//------------------------------------------------------------------------------ // ISC License (ISC) // // Copyright (c) 2004-2013, The Linux Foundation // All rights reserved. // Software was previously licensed under ISC license by Qualcomm Atheros, Inc. // // // // Permission to use, copy, modify, and/or distribute this software for any // purpose with or without fee is hereby granted, provided that the above // copyright notice and this permission notice appear in all copies. // // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // // // // Author(s): ="Atheros" //------------------------------------------------------------------------------ /* * This driver is a pseudo ethernet driver to access the Atheros AR6000 * WLAN Device */ #include #include "ar6000_drv.h" #include "htc.h" #include "wmi_filter_linux.h" #include "epping_test.h" #include "wlan_config.h" #include "ar3kconfig.h" #include "ar6k_pal.h" #include "AR6002/addrs.h" #include "target_reg_table.h" #include "a_drv_api.h" /* LINUX_HACK_FUDGE_FACTOR -- this is used to provide a workaround for linux behavior. When * the meta data was added to the header it was found that linux did not correctly provide * enough headroom. However when more headroom was requested beyond what was truly needed * Linux gave the requested headroom. Therefore to get the necessary headroom from Linux * the driver requests more than is needed by the amount = LINUX_HACK_FUDGE_FACTOR */ #define LINUX_HACK_FUDGE_FACTOR 16 #define BDATA_BDADDR_OFFSET 28 A_UINT8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; A_UINT8 null_mac[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; #ifdef DEBUG #define ATH_DEBUG_DBG_LOG ATH_DEBUG_MAKE_MODULE_MASK(0) #define ATH_DEBUG_WLAN_CONNECT ATH_DEBUG_MAKE_MODULE_MASK(1) #define ATH_DEBUG_WLAN_SCAN ATH_DEBUG_MAKE_MODULE_MASK(2) #define ATH_DEBUG_WLAN_TX ATH_DEBUG_MAKE_MODULE_MASK(3) #define ATH_DEBUG_WLAN_RX ATH_DEBUG_MAKE_MODULE_MASK(4) #define ATH_DEBUG_HTC_RAW ATH_DEBUG_MAKE_MODULE_MASK(5) #define ATH_DEBUG_HCI_BRIDGE ATH_DEBUG_MAKE_MODULE_MASK(6) static ATH_DEBUG_MASK_DESCRIPTION driver_debug_desc[] = { { ATH_DEBUG_DBG_LOG , "Target Debug Logs"}, { ATH_DEBUG_WLAN_CONNECT , "WLAN connect"}, { ATH_DEBUG_WLAN_SCAN , "WLAN scan"}, { ATH_DEBUG_WLAN_TX , "WLAN Tx"}, { ATH_DEBUG_WLAN_RX , "WLAN Rx"}, { ATH_DEBUG_HTC_RAW , "HTC Raw IF tracing"}, { ATH_DEBUG_HCI_BRIDGE , "HCI Bridge Setup"}, { ATH_DEBUG_HCI_RECV , "HCI Recv tracing"}, { ATH_DEBUG_HCI_DUMP , "HCI Packet dumps"}, }; ATH_DEBUG_INSTANTIATE_MODULE_VAR(driver, "driver", "Linux Driver Interface", ATH_DEBUG_MASK_DEFAULTS | ATH_DEBUG_WLAN_SCAN | ATH_DEBUG_HCI_BRIDGE, ATH_DEBUG_DESCRIPTION_COUNT(driver_debug_desc), driver_debug_desc); #endif #define IS_MAC_NULL(mac) (mac[0]==0 && mac[1]==0 && mac[2]==0 && mac[3]==0 && mac[4]==0 && mac[5]==0) #define IS_MAC_BCAST(mac) (*mac==0xff) #define DESCRIPTION "Driver to access the AR600x Device, version " __stringify(__VER_MAJOR_) "." __stringify(__VER_MINOR_) "." __stringify(__VER_PATCH_) "." __stringify(__BUILD_NUMBER_) MODULE_AUTHOR("Qualcomm Atheros"); MODULE_DESCRIPTION(DESCRIPTION); MODULE_LICENSE("Dual BSD/GPL"); #ifndef REORG_APTC_HEURISTICS #undef ADAPTIVE_POWER_THROUGHPUT_CONTROL #endif /* REORG_APTC_HEURISTICS */ #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL A_TIMER aptcTimer[NUM_DEV]; #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ #ifdef EXPORT_HCI_BRIDGE_INTERFACE // callbacks registered by HCI transport driver HCI_TRANSPORT_CALLBACKS ar6kHciTransCallbacks = { NULL }; #endif unsigned int processDot11Hdr = 0; char targetconf[10]={0,}; int bmienable = BMIENABLE_DEFAULT; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) char ifname[IFNAMSIZ] = {0,}; char devmode[32] ={0,}; char submode[32] ={0,}; #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */ int regcode = 0; int wlaninitmode = WLAN_INIT_MODE_DEFAULT; unsigned int bypasswmi = 0; unsigned int debuglevel = 0; int tspecCompliance = ATHEROS_COMPLIANCE; unsigned int busspeedlow = 0; unsigned int onebitmode = 0; unsigned int skipflash = 0; unsigned int wmitimeout = 2; unsigned int wlanNodeCaching = 1; unsigned int enableuartprint = ENABLEUARTPRINT_DEFAULT; unsigned int logWmiRawMsgs = 0; unsigned int enabletimerwar = 0; unsigned int fwmode = 1; unsigned int fwsubmode = 0; unsigned int mbox_yield_limit = 99; unsigned int enablerssicompensation = 0; int reduce_credit_dribble = 1 + HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_ONE_HALF; int allow_trace_signal = 0; #ifdef CONFIG_HOST_TCMD_SUPPORT unsigned int testmode =0; #endif unsigned int firmware_bridge = 0; unsigned int irqprocmode = HIF_DEVICE_IRQ_SYNC_ONLY;//HIF_DEVICE_IRQ_ASYNC_SYNC; unsigned int panic_on_assert = 1; unsigned int nohifscattersupport = NOHIFSCATTERSUPPORT_DEFAULT; unsigned int setuphci = SETUPHCI_DEFAULT; unsigned int setuphcipal = SETUPHCIPAL_DEFAULT; unsigned int loghci = 0; unsigned int setupbtdev = SETUPBTDEV_DEFAULT; #ifndef EXPORT_HCI_BRIDGE_INTERFACE unsigned int ar3khcibaud = AR3KHCIBAUD_DEFAULT; unsigned int hciuartscale = HCIUARTSCALE_DEFAULT; unsigned int hciuartstep = HCIUARTSTEP_DEFAULT; #endif #ifdef CONFIG_CHECKSUM_OFFLOAD unsigned int csumOffload=0; unsigned int csumOffloadTest=0; #endif unsigned int eppingtest=0; unsigned int regscanmode=0; unsigned int num_device=1; unsigned char ar6k_init=FALSE; unsigned int rtc_reset_only_on_exit=0; unsigned int mac_addr_method=0; A_BOOL avail_ev_called=FALSE; #if defined(CONFIG_MMC_MSM) && defined(CONFIG_ARCH_MSM7X27) && defined(CONFIG_MSM_SOC_REV_A) unsigned int refClock = 19200000; #elif defined(CONFIG_MMC_MSM) && defined(CONFIG_ARCH_MSM9615) && defined(ATH_AR6K_EXT_PMIC_CLK) unsigned int refClock = 19200000; #else unsigned int refClock = 26000000; #endif unsigned int max_psq_depth = MAX_DEFAULT_PS_QUEUE_DEPTH; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_param_string(ifname, ifname, sizeof(ifname), 0644); module_param(regcode, int, 0644); module_param(wlaninitmode, int, 0644); module_param(bmienable, int, 0644); module_param(bypasswmi, uint, 0644); module_param(debuglevel, uint, 0644); module_param(tspecCompliance, int, 0644); module_param(onebitmode, uint, 0644); module_param(busspeedlow, uint, 0644); module_param(skipflash, uint, 0644); module_param(wmitimeout, uint, 0644); module_param(wlanNodeCaching, uint, 0644); module_param(logWmiRawMsgs, uint, 0644); module_param(enableuartprint, uint, 0644); module_param(enabletimerwar, uint, 0644); module_param(mbox_yield_limit, uint, 0644); module_param(reduce_credit_dribble, int, 0644); module_param(allow_trace_signal, int, 0644); module_param(enablerssicompensation, uint, 0644); module_param(processDot11Hdr, uint, 0644); #ifdef CONFIG_CHECKSUM_OFFLOAD module_param(csumOffload, uint, 0644); #endif #ifdef CONFIG_HOST_TCMD_SUPPORT module_param(testmode, uint, 0644); #endif module_param(firmware_bridge, uint, 0644); module_param(irqprocmode, uint, 0644); module_param(nohifscattersupport, uint, 0644); module_param(panic_on_assert, uint, 0644); module_param(setuphci, uint, 0644); module_param(setuphcipal, uint, 0644); module_param(loghci, uint, 0644); module_param(setupbtdev, uint, 0644); #ifndef EXPORT_HCI_BRIDGE_INTERFACE module_param(ar3khcibaud, uint, 0644); module_param(hciuartscale, uint, 0644); module_param(hciuartstep, uint, 0644); #endif module_param(eppingtest, uint, 0644); module_param(regscanmode, uint, 0644); module_param_string(devmode, devmode, sizeof(devmode), 0644); module_param_string(submode, submode, sizeof(submode), 0644); module_param_string(targetconf, targetconf, sizeof(targetconf), 0644); module_param(rtc_reset_only_on_exit, uint, 0644); module_param(mac_addr_method, uint, 0644); module_param(refClock, uint, 0644); module_param(max_psq_depth, uint, 0644); #else #define __user /* for linux 2.4 and lower */ MODULE_PARM(bmienable,"i"); MODULE_PARM(wlaninitmode,"i"); MODULE_PARM(bypasswmi,"i"); MODULE_PARM(debuglevel, "i"); MODULE_PARM(onebitmode,"i"); MODULE_PARM(busspeedlow, "i"); MODULE_PARM(skipflash, "i"); MODULE_PARM(wmitimeout, "i"); MODULE_PARM(wlanNodeCaching, "i"); MODULE_PARM(enableuartprint,"i"); MODULE_PARM(logWmiRawMsgs, "i"); MODULE_PARM(enabletimerwar,"i"); MODULE_PARM(mbox_yield_limit,"i"); MODULE_PARM(reduce_credit_dribble,"i"); MODULE_PARM(allow_trace_signal,"i"); MODULE_PARM(enablerssicompensation,"i"); MODULE_PARM(processDot11Hdr,"i"); #ifdef CONFIG_CHECKSUM_OFFLOAD MODULE_PARM(csumOffload,"i"); #endif #ifdef CONFIG_HOST_TCMD_SUPPORT MODULE_PARM(testmode, "i"); #endif MODULE_PARM(irqprocmode, "i"); MODULE_PARM(nohifscattersupport, "i"); MODULE_PARM(panic_on_assert, "i"); MODULE_PARM(setuphci, "i"); MODULE_PARM(setuphcipal, "i"); MODULE_PARM(loghci, "i"); MODULE_PARM(regscanmode, "i"); MODULE_PARM(rtc_reset_only_on_exit, "i"); MODULE_PARM(mac_addr_method, "i"); MODULE_PARM(refClock, "i"); MODULE_PARM(max_psq_depth, "i"); #endif #if WLAN_CONFIG_FIRST_SCAN_2G_ONLY unsigned int first_scan_2g_only = WLAN_CONFIG_FIRST_SCAN_2G_ONLY; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_param(first_scan_2g_only, uint, 0644); #else MODULE_PARM(first_scan_2g_only, "i"); #endif #endif #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10) /* in 2.6.10 and later this is now a pointer to a uint */ unsigned int _mboxnum = HTC_MAILBOX_NUM_MAX; #define mboxnum &_mboxnum #else unsigned int mboxnum = HTC_MAILBOX_NUM_MAX; #endif #ifdef DEBUG A_UINT32 g_dbg_flags = DBG_DEFAULTS; unsigned int debugflags = 0; int debugdriver = 0; unsigned int debughtc = 0; unsigned int debugbmi = 0; unsigned int debughif = 0; unsigned int txcreditsavailable[HTC_MAILBOX_NUM_MAX] = {0}; unsigned int txcreditsconsumed[HTC_MAILBOX_NUM_MAX] = {0}; unsigned int txcreditintrenable[HTC_MAILBOX_NUM_MAX] = {0}; unsigned int txcreditintrenableaggregate[HTC_MAILBOX_NUM_MAX] = {0}; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_param(debugflags, uint, 0644); module_param(debugdriver, int, 0644); module_param(debughtc, uint, 0644); module_param(debugbmi, uint, 0644); module_param(debughif, uint, 0644); module_param_array(txcreditsavailable, uint, mboxnum, 0644); module_param_array(txcreditsconsumed, uint, mboxnum, 0644); module_param_array(txcreditintrenable, uint, mboxnum, 0644); module_param_array(txcreditintrenableaggregate, uint, mboxnum, 0644); #else /* linux 2.4 and lower */ MODULE_PARM(debugflags,"i"); MODULE_PARM(debugdriver, "i"); MODULE_PARM(debughtc, "i"); MODULE_PARM(debugbmi, "i"); MODULE_PARM(debughif, "i"); MODULE_PARM(txcreditsavailable, "0-3i"); MODULE_PARM(txcreditsconsumed, "0-3i"); MODULE_PARM(txcreditintrenable, "0-3i"); MODULE_PARM(txcreditintrenableaggregate, "0-3i"); #endif #endif /* DEBUG */ unsigned int resetok = 1; unsigned int tx_attempt[HTC_MAILBOX_NUM_MAX] = {0}; unsigned int tx_post[HTC_MAILBOX_NUM_MAX] = {0}; unsigned int tx_complete[HTC_MAILBOX_NUM_MAX] = {0}; unsigned int hifBusRequestNumMax = 40; unsigned int war23838_disabled = 0; #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL unsigned int enableAPTCHeuristics = 1; #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ unsigned int psm_info = 99; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_param_array(tx_attempt, uint, mboxnum, 0644); module_param_array(tx_post, uint, mboxnum, 0644); module_param_array(tx_complete, uint, mboxnum, 0644); module_param(hifBusRequestNumMax, uint, 0644); module_param(war23838_disabled, uint, 0644); module_param(resetok, uint, 0644); #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL module_param(enableAPTCHeuristics, uint, 0644); #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ module_param(psm_info, uint, 0444); #else MODULE_PARM(tx_attempt, "0-3i"); MODULE_PARM(tx_post, "0-3i"); MODULE_PARM(tx_complete, "0-3i"); MODULE_PARM(hifBusRequestNumMax, "i"); MODULE_PARM(war23838_disabled, "i"); MODULE_PARM(resetok, "i"); #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL MODULE_PARM(enableAPTCHeuristics, "i"); #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ MODULE_PARM(psm_info, "i"); #endif #ifdef BLOCK_TX_PATH_FLAG int blocktx = 0; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) module_param(blocktx, int, 0644); #else MODULE_PARM(blocktx, "i"); #endif #endif /* BLOCK_TX_PATH_FLAG */ static A_INT16 rssi_compensation_table[NUM_DEV][96]; int reconnect_flag = 0; static ar6k_pal_config_t ar6k_pal_config_g; // Load unload synchronization DECLARE_WAIT_QUEUE_HEAD(load_complete); DECLARE_WAIT_QUEUE_HEAD(scan_complete); // Indicates if the module load completed static int mod_loaded = FALSE; /* Function declarations */ static int ar6000_init_module(void); static void ar6000_cleanup_module(void); struct completion avail_ev_completion; int ar6000_init(struct net_device *dev); static int ar6000_open(struct net_device *dev); static int ar6000_close(struct net_device *dev); static int ar6000_init_control_info(AR_SOFTC_DEV_T *arPriv); static int ar6000_data_tx(struct sk_buff *skb, struct net_device *dev); void ar6000_destroy(struct net_device *dev, unsigned int unregister); void ar6000_cleanup(AR_SOFTC_T *ar); static void ar6000_detect_error(unsigned long ptr); static void ar6000_set_multicast_list(struct net_device *dev); static struct net_device_stats *ar6000_get_stats(struct net_device *dev); static struct iw_statistics *ar6000_get_iwstats(struct net_device * dev); static void disconnect_timer_handler(unsigned long ptr); void read_rssi_compensation_param(AR_SOFTC_T *ar); void target_register_tbl_attach(A_UINT32 target_type); static void ar6000_uapsd_trigger_frame_rx(AR_SOFTC_DEV_T *arPriv, conn_t *conn); static void delba_timer_callback(unsigned long ptr); static int ar6000_check_hold_conn_status(AR_SOFTC_DEV_T *arPriv, A_UINT8 conn_status); extern int android_readwrite_file(const A_CHAR *filename, A_CHAR *rbuf, const A_CHAR *wbuf, size_t length); /* for android builds we call external APIs that handle firmware download and configuration */ /* * HTC service connection handlers */ static A_STATUS ar6000_avail_ev(void *context, void *hif_handle); static A_STATUS ar6000_unavail_ev(void *context, void *hif_handle); A_STATUS ar6000_configure_target(AR_SOFTC_T *ar); static void ar6000_target_failure(void *Instance, A_STATUS Status); static void ar6000_rx(void *Context, HTC_PACKET *pPacket); static void ar6000_rx_refill(void *Context,HTC_ENDPOINT_ID Endpoint); static void ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPackets); static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, HTC_PACKET *pPacket); #ifdef ATH_AR6K_11N_SUPPORT static void ar6000_alloc_netbufs(A_NETBUF_QUEUE_T *q, A_UINT16 num); #endif static void ar6000_deliver_frames_to_nw_stack(void * dev, void *osbuf); //static void ar6000_deliver_frames_to_bt_stack(void * dev, void *osbuf); static HTC_PACKET *ar6000_alloc_amsdu_rxbuf(void *Context, HTC_ENDPOINT_ID Endpoint, int Length); static void ar6000_refill_amsdu_rxbufs(AR_SOFTC_T *ar, int Count); static void ar6000_cleanup_amsdu_rxbufs(AR_SOFTC_T *ar); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) static ssize_t ar6000_sysfs_bmi_read(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count); static ssize_t ar6000_sysfs_bmi_write(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count); #else static ssize_t ar6000_sysfs_bmi_read(struct file *fp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count); static ssize_t ar6000_sysfs_bmi_write(struct file *fp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count); #endif static A_STATUS ar6000_sysfs_bmi_init(AR_SOFTC_T *ar); /* HCI PAL callback function declarations */ A_STATUS ar6k_setup_hci_pal(AR_SOFTC_DEV_T *ar); void ar6k_cleanup_hci_pal(AR_SOFTC_DEV_T *ar); static void ar6000_sysfs_bmi_deinit(AR_SOFTC_T *ar); A_STATUS ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, A_UINT32 mode); /* * Static variables */ struct net_device *ar6000_devices[NUM_DEV]; extern struct iw_handler_def ath_iw_handler_def; static void ar6000_cookie_init(AR_SOFTC_T *ar); static void ar6000_cookie_cleanup(AR_SOFTC_T *ar); static void ar6000_free_cookie(AR_SOFTC_T *ar, struct ar_cookie * cookie); static struct ar_cookie *ar6000_alloc_cookie(AR_SOFTC_T *ar); #ifdef USER_KEYS static A_STATUS ar6000_reinstall_keys(AR_SOFTC_DEV_T *arPriv,A_UINT8 key_op_ctrl); #endif static struct ar_cookie s_ar_cookie_mem[MAX_COOKIE_NUM]; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29) static struct net_device_ops ar6000_netdev_ops = { .ndo_init = NULL, .ndo_open = ar6000_open, .ndo_stop = ar6000_close, .ndo_get_stats = ar6000_get_stats, .ndo_do_ioctl = ar6000_ioctl, .ndo_start_xmit = ar6000_data_tx, #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0) .ndo_set_rx_mode = ar6000_set_multicast_list, #else .ndo_set_multicast_list = ar6000_set_multicast_list, #endif .ndo_change_mtu = eth_change_mtu, }; #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,29) */ /* Debug log support */ /* * Flag to govern whether the debug logs should be parsed in the kernel * or reported to the application. */ #define REPORT_DEBUG_LOGS_TO_APP A_STATUS ar6000_set_host_app_area(AR_SOFTC_T *ar) { A_UINT32 address, data; struct host_app_area_s host_app_area; /* Fetch the address of the host_app_area_s instance in the host interest area */ address = TARG_VTOP(ar->arTargetType, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_app_host_interest)); if (ar6000_ReadRegDiag(ar->arHifDevice, &address, &data) != A_OK) { return A_ERROR; } address = TARG_VTOP(ar->arTargetType, data); host_app_area.wmi_protocol_ver = WMI_PROTOCOL_VERSION; if (ar6000_WriteDataDiag(ar->arHifDevice, address, (A_UCHAR *)&host_app_area, sizeof(struct host_app_area_s)) != A_OK) { return A_ERROR; } return A_OK; } A_UINT32 dbglog_get_debug_hdr_ptr(AR_SOFTC_T *ar) { A_UINT32 param; A_UINT32 address; A_STATUS status; address = TARG_VTOP(ar->arTargetType, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_dbglog_hdr)); if ((status = ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)¶m, 4)) != A_OK) { param = 0; } return param; } /* * The dbglog module has been initialized. Its ok to access the relevant * data stuctures over the diagnostic window. */ void ar6000_dbglog_init_done(AR_SOFTC_DEV_T *arPriv) { AR_SOFTC_T *ar = arPriv->arSoftc; ar->dbglog_init_done = TRUE; } A_UINT32 dbglog_get_debug_fragment(A_INT8 *datap, A_UINT32 len, A_UINT32 limit) { A_INT32 *buffer; A_UINT32 count; A_UINT32 numargs; A_UINT32 length; A_UINT32 fraglen; count = fraglen = 0; buffer = (A_INT32 *)datap; length = (limit >> 2); if (len <= limit) { fraglen = len; } else { while (count < length) { numargs = DBGLOG_GET_NUMARGS(buffer[count]); fraglen = (count << 2); count += numargs + 1; } } return fraglen; } void dbglog_parse_debug_logs(A_INT8 *datap, A_UINT32 len) { A_INT32 *buffer; A_UINT32 count; A_UINT32 timestamp; A_UINT32 debugid; A_UINT32 moduleid; A_UINT32 numargs; A_UINT32 length; count = 0; buffer = (A_INT32 *)datap; length = (len >> 2); while (count < length) { debugid = DBGLOG_GET_DBGID(buffer[count]); moduleid = DBGLOG_GET_MODULEID(buffer[count]); numargs = DBGLOG_GET_NUMARGS(buffer[count]); timestamp = DBGLOG_GET_TIMESTAMP(buffer[count]); switch (numargs) { case 0: AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("%d %d (%d)\n", moduleid, debugid, timestamp)); break; case 1: AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("%d %d (%d): 0x%x\n", moduleid, debugid, timestamp, buffer[count+1])); break; case 2: AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("%d %d (%d): 0x%x, 0x%x\n", moduleid, debugid, timestamp, buffer[count+1], buffer[count+2])); break; default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Invalid args: %d\n", numargs)); } count += numargs + 1; } } int ar6000_dbglog_get_debug_logs(AR_SOFTC_T *ar) { struct dbglog_hdr_s debug_hdr; struct dbglog_buf_s debug_buf; A_UINT32 address; A_UINT32 length; A_UINT32 dropped; A_UINT32 firstbuf; A_UINT32 debug_hdr_ptr; if (!ar->dbglog_init_done) return A_ERROR; AR6000_SPIN_LOCK(&ar->arLock, 0); if (ar->dbgLogFetchInProgress) { AR6000_SPIN_UNLOCK(&ar->arLock, 0); return A_EBUSY; } /* block out others */ ar->dbgLogFetchInProgress = TRUE; AR6000_SPIN_UNLOCK(&ar->arLock, 0); debug_hdr_ptr = dbglog_get_debug_hdr_ptr(ar); printk("debug_hdr_ptr: 0x%x\n", debug_hdr_ptr); /* Get the contents of the ring buffer */ if (debug_hdr_ptr) { address = TARG_VTOP(ar->arTargetType, debug_hdr_ptr); length = sizeof(struct dbglog_hdr_s); ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)&debug_hdr, length); address = TARG_VTOP(ar->arTargetType, (A_UINT32)debug_hdr.dbuf); firstbuf = address; dropped = debug_hdr.dropped; length = sizeof(struct dbglog_buf_s); ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)&debug_buf, length); do { address = TARG_VTOP(ar->arTargetType, (A_UINT32)debug_buf.buffer); length = debug_buf.length; if ((length) && (debug_buf.length <= debug_buf.bufsize)) { /* Rewind the index if it is about to overrun the buffer */ if (ar->log_cnt > (DBGLOG_HOST_LOG_BUFFER_SIZE - length)) { ar->log_cnt = 0; } if(A_OK != ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)&ar->log_buffer[ar->log_cnt], length)) { break; } ar6000_dbglog_event(ar->arDev[0], dropped, (A_INT8*)&ar->log_buffer[ar->log_cnt], length); ar->log_cnt += length; } else { AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("Length: %d (Total size: %d)\n", debug_buf.length, debug_buf.bufsize)); } address = TARG_VTOP(ar->arTargetType, (A_UINT32)debug_buf.next); length = sizeof(struct dbglog_buf_s); if(A_OK != ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)&debug_buf, length)) { break; } } while (address != firstbuf); } ar->dbgLogFetchInProgress = FALSE; return A_OK; } void ar6000_dbglog_event(AR_SOFTC_DEV_T *arPriv, A_UINT32 dropped, A_INT8 *buffer, A_UINT32 length) { #ifdef REPORT_DEBUG_LOGS_TO_APP #define MAX_WIRELESS_EVENT_SIZE 252 /* * Break it up into chunks of MAX_WIRELESS_EVENT_SIZE bytes of messages. * There seems to be a limitation on the length of message that could be * transmitted to the user app via this mechanism. */ A_UINT32 send, sent; sent = 0; send = dbglog_get_debug_fragment(&buffer[sent], length - sent, MAX_WIRELESS_EVENT_SIZE); while (send) { ar6000_send_event_to_app(arPriv, WMIX_DBGLOG_EVENTID, (A_UINT8*)&buffer[sent], send); sent += send; send = dbglog_get_debug_fragment(&buffer[sent], length - sent, MAX_WIRELESS_EVENT_SIZE); } #else AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Dropped logs: 0x%x\nDebug info length: %d\n", dropped, length)); /* Interpret the debug logs */ dbglog_parse_debug_logs((A_INT8*)buffer, length); #endif /* REPORT_DEBUG_LOGS_TO_APP */ } void ar6000_parse_dev_mode(A_CHAR *mode) { A_UINT8 i, match = FALSE, mode_len; A_UINT8 num_submode; char *valid_modes[] = { "sta", "ap", "ibss", "bt30amp", "sta,ap", "ap,sta", "ap,ap", "sta,sta", "sta,bt30amp", "sta,ap,ap" }; A_CHAR *dev_mode; A_CHAR *str; A_UINT32 host_int = 0; dev_mode = mode; str = mode; num_device = 0; fwmode = 0; mode_len = strlen(dev_mode); for (i=0; i <= 9; i++) { if ((mode_len == strlen(valid_modes[i])) && (strcmp(dev_mode,valid_modes[i]))==0) { match = TRUE; break; } } if(!match) { num_device = fwmode = 1; AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ERROR: Wrong mode. using default (single device STA mode).\n")); return; } do { str++; if(*str == ',' || *str == '\0') { num_device++; if(strncmp(dev_mode,"ap",2) == 0) { host_int = HI_OPTION_FW_MODE_AP; } else if(strncmp(dev_mode,"sta",3) == 0) { host_int = HI_OPTION_FW_MODE_BSS_STA; } else if(strncmp(dev_mode,"ibss",4) == 0 ) { host_int = HI_OPTION_FW_MODE_IBSS; } else if(strncmp(dev_mode,"bt30amp",7) == 0) { host_int = HI_OPTION_FW_MODE_BT30AMP; } fwmode |= (host_int << ((num_device -1) * HI_OPTION_FW_MODE_BITS)); dev_mode = ++str; } }while(*dev_mode != '\0'); /* Validate submode if present */ if (!submode[0]) { /* default "none" submode for all devices */ fwsubmode = 0; return; } dev_mode = submode; str = submode; num_submode = 0; fwsubmode = 0; match = FALSE; return; } static int __init ar6000_init_module(void) { static int probed = 0; A_STATUS status; OSDRV_CALLBACKS osdrvCallbacks; a_module_debug_support_init(); #ifdef DEBUG /* check for debug mask overrides */ if (debughtc != 0) { ATH_DEBUG_SET_DEBUG_MASK(htc,debughtc); } if (debugbmi != 0) { ATH_DEBUG_SET_DEBUG_MASK(bmi,debugbmi); } if (debughif != 0) { ATH_DEBUG_SET_DEBUG_MASK(hif,debughif); } if (debugdriver != 0) { ATH_DEBUG_SET_DEBUG_MASK(driver,debugdriver); } #endif A_REGISTER_MODULE_DEBUG_INFO(driver); ar6k_init = FALSE; A_MEMZERO(&osdrvCallbacks,sizeof(osdrvCallbacks)); osdrvCallbacks.deviceInsertedHandler = ar6000_avail_ev; osdrvCallbacks.deviceRemovedHandler = ar6000_unavail_ev; #ifdef CONFIG_PM osdrvCallbacks.deviceSuspendHandler = ar6000_suspend_ev; osdrvCallbacks.deviceResumeHandler = ar6000_resume_ev; osdrvCallbacks.devicePowerChangeHandler = ar6000_power_change_ev; #endif init_completion(&avail_ev_completion); ar6000_pm_init(); if(devmode[0]) ar6000_parse_dev_mode(devmode); #ifdef DEBUG /* Set the debug flags if specified at load time */ if(debugflags != 0) { g_dbg_flags = debugflags; } #endif if (probed) { return -ENODEV; } probed++; #ifdef CONFIG_HOST_GPIO_SUPPORT ar6000_gpio_init(); #endif /* CONFIG_HOST_GPIO_SUPPORT */ status = HIFInit(&osdrvCallbacks); if(status != A_OK) return -ENODEV; return 0; } #define AR6K_AVAIL_EV_COMPLETION_TIMEOUT (60 * HZ) static void __exit ar6000_cleanup_module(void) { int i = 0; struct net_device *ar6000_netdev; AR_SOFTC_T *ar; AR_SOFTC_DEV_T *arPriv = NULL; unsigned long tmo = AR6K_AVAIL_EV_COMPLETION_TIMEOUT; if (!wait_event_interruptible_timeout(load_complete, mod_loaded != FALSE, 5 * HZ)) { printk(KERN_ERR "Load did not complete. Unload did not proceed\n"); return; } A_PRINTF("\nAR6K: %s()\n", __func__); tmo = wait_for_completion_timeout(&avail_ev_completion, tmo); if (tmo == 0) { A_PRINTF("AR6K: wait for avail_ev_completion %d sec timeout\n", AR6K_AVAIL_EV_COMPLETION_TIMEOUT / HZ); } if (ar6000_devices[0] != NULL) { arPriv = (AR_SOFTC_DEV_T *) ar6k_priv(ar6000_devices[0]); ar = arPriv->arSoftc; ar6000_cleanup(ar); } for (i=0; i < num_device; i++) { #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL /* Delete the Adaptive Power Control timer */ if (timer_pending(&aptcTimer[i])) { del_timer_sync(&aptcTimer[i]); } #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ if (ar6000_devices[i] != NULL) { arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[i]); if (arPriv) { A_UNTIMEOUT(&arPriv->arSta.disconnect_timer); } ar6000_netdev = ar6000_devices[i]; ar6000_devices[i] = NULL; ar6000_destroy(ar6000_netdev, 1); } } HIFShutDownDevice(NULL); a_module_debug_support_cleanup(); ar6000_pm_exit(); a_meminfo_report(TRUE); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_cleanup: success\n")); } #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL void aptcTimerHandler(unsigned long arg) { A_UINT32 numbytes; A_UINT32 throughput; AR_SOFTC_T *ar; A_STATUS status; APTC_TRAFFIC_RECORD *aptcTR; A_UNIT8 i; ar = (AR_SOFTC_T *)arg; A_ASSERT(ar != NULL); for(i = 0; i < num_device; i++) { aptcTR = ar->arDev[i].aptcTR; A_ASSERT(!timer_pending(&aptcTimer[i])); AR6000_SPIN_LOCK(&ar->arLock, 0); /* Get the number of bytes transferred */ numbytes = aptcTR->bytesTransmitted + aptcTR->bytesReceived; aptcTR->bytesTransmitted = aptcTR->bytesReceived = 0; /* Calculate and decide based on throughput thresholds */ throughput = ((numbytes * 8)/APTC_TRAFFIC_SAMPLING_INTERVAL); /* Kbps */ if (throughput < APTC_LOWER_THROUGHPUT_THRESHOLD) { /* Enable Sleep and delete the timer */ A_ASSERT(ar->arWmiReady == TRUE); AR6000_SPIN_UNLOCK(&ar->arLock, 0); status = wmi_powermode_cmd(ar->arWmi, REC_POWER); AR6000_SPIN_LOCK(&ar->arLock, 0); A_ASSERT(status == A_OK); aptcTR->timerScheduled = FALSE; } else { A_TIMEOUT_MS(&aptcTimer[i], APTC_TRAFFIC_SAMPLING_INTERVAL, 0); } AR6000_SPIN_UNLOCK(&ar->arLock, 0); } } #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ #ifdef ATH_AR6K_11N_SUPPORT static void ar6000_alloc_netbufs(A_NETBUF_QUEUE_T *q, A_UINT16 num) { void * osbuf; while(num) { if((osbuf = A_NETBUF_ALLOC(AR6000_BUFFER_SIZE))) { A_NETBUF_ENQUEUE(q, osbuf); } else { break; } num--; } if(num) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s(), allocation of netbuf failed", __func__)); } } #endif static struct bin_attribute bmi_attr = { .attr = {.name = "bmi", .mode = 0600}, .read = ar6000_sysfs_bmi_read, .write = ar6000_sysfs_bmi_write, }; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) static ssize_t ar6000_sysfs_bmi_read(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count) #else static ssize_t ar6000_sysfs_bmi_read(struct file *fp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count) #endif { int index; AR_SOFTC_DEV_T *arPriv; AR_SOFTC_T *ar = NULL; HIF_DEVICE_OS_DEVICE_INFO *osDevInfo; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Read %d bytes\n", count)); for (index=0; index < num_device; index++) { arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[index]); ar = arPriv->arSoftc; osDevInfo = &ar->osDevInfo; if (kobj == (&(((struct device *)osDevInfo->pOSDevice)->kobj))) { break; } } if (ar == NULL) return 0; if (index == num_device) return 0; if ((BMIRawRead(ar->arHifDevice, (A_UCHAR*)buf, count, TRUE)) != A_OK) { return 0; } return count; } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35) static ssize_t ar6000_sysfs_bmi_write(struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count) #else static ssize_t ar6000_sysfs_bmi_write(struct file *fp, struct kobject *kobj, struct bin_attribute *bin_attr, char *buf, loff_t pos, size_t count) #endif { int index; AR_SOFTC_DEV_T *arPriv; AR_SOFTC_T *ar = NULL; HIF_DEVICE_OS_DEVICE_INFO *osDevInfo; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Write %d bytes\n", count)); for (index=0; index < num_device; index++) { arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[index]); ar = arPriv->arSoftc; osDevInfo = &ar->osDevInfo; if (kobj == (&(((struct device *)osDevInfo->pOSDevice)->kobj))) { break; } } if (ar == NULL) return 0; if (index == num_device) return 0; if ((BMIRawWrite(ar->arHifDevice, (A_UCHAR*)buf, count)) != A_OK) { return 0; } return count; } static A_STATUS ar6000_sysfs_bmi_init(AR_SOFTC_T *ar) { A_STATUS status; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Creating sysfs entry\n")); A_MEMZERO(&ar->osDevInfo, sizeof(HIF_DEVICE_OS_DEVICE_INFO)); /* Get the underlying OS device */ status = HIFConfigureDevice(ar->arHifDevice, HIF_DEVICE_GET_OS_DEVICE, &ar->osDevInfo, sizeof(HIF_DEVICE_OS_DEVICE_INFO)); if (A_FAILED(status)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI: Failed to get OS device info from HIF\n")); return A_ERROR; } /* Create a bmi entry in the sysfs filesystem */ if ((sysfs_create_bin_file(&(((struct device *)ar->osDevInfo.pOSDevice)->kobj), &bmi_attr)) < 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMI: Failed to create entry for bmi in sysfs filesystem\n")); return A_ERROR; } return A_OK; } static void ar6000_sysfs_bmi_deinit(AR_SOFTC_T *ar) { if (ar->osDevInfo.pOSDevice) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Deleting sysfs entry\n")); sysfs_remove_bin_file(&(((struct device *)ar->osDevInfo.pOSDevice)->kobj), &bmi_attr); ar->osDevInfo.pOSDevice = NULL; } } #define bmifn(fn) do { \ if ((fn) < A_OK) { \ A_PRINTF("BMI operation failed: %d\n", __LINE__); \ return A_ERROR; \ } \ } while(0) #ifdef INIT_MODE_DRV_ENABLED #define MCKINLEY_MAC_ADDRESS_OFFSET 0x16 static void calculate_crc(A_UINT32 TargetType, A_UCHAR *eeprom_data, size_t eeprom_size) { A_UINT16 *ptr_crc; A_UINT16 *ptr16_eeprom; A_UINT16 checksum; A_UINT32 i; if (TargetType == TARGET_TYPE_AR6001) { ptr_crc = (A_UINT16 *)eeprom_data; } else if (TargetType == TARGET_TYPE_AR6003) { ptr_crc = (A_UINT16 *)((A_UCHAR *)eeprom_data + 0x04); } else if (TargetType == TARGET_TYPE_MCKINLEY) { eeprom_size = 1024; ptr_crc = (A_UINT16 *)((A_UCHAR *)eeprom_data + 0x04); } else { ptr_crc = (A_UINT16 *)((A_UCHAR *)eeprom_data + 0x04); } // Clear the crc *ptr_crc = 0; // Recalculate new CRC checksum = 0; ptr16_eeprom = (A_UINT16 *)eeprom_data; for (i = 0;i < eeprom_size; i += 2) { checksum = checksum ^ (*ptr16_eeprom); ptr16_eeprom++; } checksum = 0xFFFF ^ checksum; *ptr_crc = checksum; } #ifdef SOFTMAC_FILE_USED #define AR6002_MAC_ADDRESS_OFFSET 0x0A #define AR6003_MAC_ADDRESS_OFFSET 0x16 static void ar6000_softmac_update(AR_SOFTC_T *ar, A_UCHAR *eeprom_data, size_t eeprom_size) { /* We need to store the MAC, which comes either from the softmac file or is * randomly generated, because we do not want to load a new MAC address * if the chip goes into suspend and then is resumed later on. We ONLY * want to load a new MAC if the driver is unloaded and then reloaded */ static A_UCHAR random_mac[6]; const char *source = "random generated"; const struct firmware *softmac_entry; A_UCHAR *ptr_mac; switch (ar->arTargetType) { case TARGET_TYPE_AR6002: ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + AR6002_MAC_ADDRESS_OFFSET); break; case TARGET_TYPE_AR6003: ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + AR6003_MAC_ADDRESS_OFFSET); break; case TARGET_TYPE_MCKINLEY: ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + MCKINLEY_MAC_ADDRESS_OFFSET); break; default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Invalid Target Type \n")); return; } AR_DEBUG_PRINTF(ATH_DEBUG_WARN, ("MAC from EEPROM %02X:%02X:%02X:%02X:%02X:%02X\n", ptr_mac[0], ptr_mac[1], ptr_mac[2], ptr_mac[3], ptr_mac[4], ptr_mac[5])); if (memcmp(random_mac, "\0\0\0\0\0\0", 6)!=0) { memcpy(ptr_mac, random_mac, 6); } else { /* create a random MAC in case we cannot read file from system */ ptr_mac[0] = random_mac[0] = 2; /* locally administered */ ptr_mac[1] = random_mac[1] = 0x03; ptr_mac[2] = random_mac[2] = 0x7F; ptr_mac[3] = random_mac[3] = random32() & 0xff; ptr_mac[4] = random_mac[4] = random32() & 0xff; ptr_mac[5] = random_mac[5] = random32() & 0xff; } #if defined(CONFIG_ARCH_MSM9615) if ((A_REQUEST_FIRMWARE(&softmac_entry, "ath6k/AR6003/hw2.1.1/softmac", ((struct device *)ar->osDevInfo.pOSDevice))) == 0) #else if ((A_REQUEST_FIRMWARE(&softmac_entry, "softmac", ((struct device *)ar->osDevInfo.pOSDevice))) == 0) #endif { A_CHAR *macbuf = A_MALLOC_NOWAIT(softmac_entry->size+1); if (macbuf) { unsigned int softmac[6]; memcpy(macbuf, softmac_entry->data, softmac_entry->size); macbuf[softmac_entry->size] = '\0'; if (sscanf(macbuf, "%02x:%02x:%02x:%02x:%02x:%02x", &softmac[0], &softmac[1], &softmac[2], &softmac[3], &softmac[4], &softmac[5])==6) { int i; for (i=0; i<6; ++i) { ptr_mac[i] = softmac[i] & 0xff; } source = "softmac file"; A_MEMZERO(random_mac, sizeof(random_mac)); } A_FREE(macbuf); } A_RELEASE_FIRMWARE(softmac_entry); } if (memcmp(random_mac, "\0\0\0\0\0\0", 6)!=0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Warning! Random MAC address is just for testing purpose\n")); } AR_DEBUG_PRINTF(ATH_DEBUG_WARN, ("MAC from %s %02X:%02X:%02X:%02X:%02X:%02X\n", source, ptr_mac[0], ptr_mac[1], ptr_mac[2], ptr_mac[3], ptr_mac[4], ptr_mac[5])); calculate_crc(ar->arTargetType, eeprom_data, eeprom_size); } #endif /* SOFTMAC_FILE_USED */ static void ar6000_reg_update(AR_SOFTC_T *ar, A_UCHAR *eeprom_data, size_t eeprom_size, int regCode) { A_UCHAR *ptr_reg; switch (ar->arTargetType) { case TARGET_TYPE_AR6002: ptr_reg = (A_UINT8 *)((A_UCHAR *)eeprom_data + 8); break; case TARGET_TYPE_AR6003: ptr_reg = (A_UINT8 *)((A_UCHAR *)eeprom_data + 12); break; default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Invalid Target Type \n")); return; } ptr_reg[0] = (A_UCHAR)(regCode&0xFF); ptr_reg[1] = (A_UCHAR)((regCode>>8)&0xFF); calculate_crc(ar->arTargetType, eeprom_data, eeprom_size); } static A_STATUS ar6000_transfer_bin_file(AR_SOFTC_T *ar, AR6K_BIN_FILE file, A_UINT32 address, A_BOOL compressed) { A_STATUS status; const char *filename; const struct firmware *fw_entry; A_UINT32 fw_entry_size; A_UCHAR *tempEeprom; A_UINT32 board_data_size; switch (file) { case AR6K_OTP_FILE: if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_OTP_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_OTP_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } break; case AR6K_FIRMWARE_FILE: if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_FIRMWARE_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { if(ar->arVersion.targetconf_ver == AR6003_SUBVER_ROUTER) filename = AR6003_REV3_ROUTER_FIRMWARE_FILE; else if (ar->arVersion.targetconf_ver == AR6003_SUBVER_MOBILE) filename = AR6003_REV3_MOBILE_FIRMWARE_FILE; else if (ar->arVersion.targetconf_ver == AR6003_SUBVER_TABLET) filename = AR6003_REV3_TABLET_FIRMWARE_FILE; else filename = AR6003_REV3_DEFAULT_FIRMWARE_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s firmware will be loaded\n", filename)); if (eppingtest) { bypasswmi = TRUE; if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_EPPING_FIRMWARE_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_EPPING_FIRMWARE_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("eppingtest : unsupported firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } compressed = 0; } #ifdef CONFIG_HOST_TCMD_SUPPORT if(testmode == 1) { if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_TCMD_FIRMWARE_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_TCMD_FIRMWARE_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } compressed = 0; } #endif #ifdef HTC_RAW_INTERFACE if (!eppingtest && bypasswmi) { if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_ART_FIRMWARE_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_ART_FIRMWARE_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } compressed = 0; } #endif break; case AR6K_PATCH_FILE: if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_PATCH_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_PATCH_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } break; case AR6K_BOARD_DATA_FILE: if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_BOARD_DATA_FILE; } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_BOARD_DATA_FILE; } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver)); return A_ERROR; } break; default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown file type: %d\n", file)); return A_ERROR; } if ((A_REQUEST_FIRMWARE(&fw_entry, filename, ((struct device *)ar->osDevInfo.pOSDevice))) != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get %s\n", filename)); return A_ENOENT; } if (fw_entry == NULL) return A_ERROR; fw_entry_size = fw_entry->size; tempEeprom = NULL; /* Load extended board data for AR6003 */ if ((file==AR6K_BOARD_DATA_FILE) && (fw_entry->data)) { A_UINT32 board_ext_address; A_INT32 board_ext_data_size; tempEeprom = A_MALLOC_NOWAIT(fw_entry->size); if (!tempEeprom) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Memory allocation failed\n")); A_RELEASE_FIRMWARE(fw_entry); return A_ERROR; } board_data_size = (((ar)->arTargetType == TARGET_TYPE_AR6002) ? AR6002_BOARD_DATA_SZ : \ (((ar)->arTargetType == TARGET_TYPE_AR6003) ? AR6003_BOARD_DATA_SZ : 0)); board_ext_data_size = 0; if (ar->arTargetType == TARGET_TYPE_AR6002) { board_ext_data_size = AR6002_BOARD_EXT_DATA_SZ; } else if (ar->arTargetType == TARGET_TYPE_AR6003) { if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { board_ext_data_size = AR6003_VER2_BOARD_EXT_DATA_SZ; } else { board_ext_data_size = AR6003_BOARD_EXT_DATA_SZ; } } /* AR6003 2.1.1 support 1792 bytes and 2048 bytes board file */ if ((board_ext_data_size) && (fw_entry->size < (board_data_size + board_ext_data_size))) { board_ext_data_size = fw_entry->size - board_data_size; if (board_ext_data_size < 0) { board_ext_data_size = 0; } } A_MEMCPY(tempEeprom, (A_UCHAR *)fw_entry->data, fw_entry->size); #ifdef SOFTMAC_FILE_USED ar6000_softmac_update(ar, tempEeprom, board_data_size); #endif if (regcode!=0) { ar6000_reg_update(ar, tempEeprom, board_data_size, regcode); } /* Determine where in Target RAM to write Board Data */ bmifn(BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_ext_data), (A_UCHAR *)&board_ext_address, 4)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("Board extended Data download address: 0x%x\n", board_ext_address)); /* check whether the target has allocated memory for extended board data and file contains extended board data */ if ((board_ext_address) && (fw_entry->size == (board_data_size + board_ext_data_size))) { A_UINT32 param; status = BMIWriteMemory(ar->arHifDevice, board_ext_address, (A_UCHAR *)(((A_UINT32)tempEeprom) + board_data_size), board_ext_data_size); if (status != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI operation failed: %d\n", __LINE__)); A_RELEASE_FIRMWARE(fw_entry); return A_ERROR; } /* Record the fact that extended board Data IS initialized */ param = (board_ext_data_size << 16) | 1; bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_ext_data_config), (A_UCHAR *)¶m, 4)); } fw_entry_size = board_data_size; } if (compressed) { status = BMIFastDownload(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry_size); } else { if (file==AR6K_BOARD_DATA_FILE && fw_entry->data) { status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)tempEeprom, fw_entry_size); } else if(fw_entry->data) { status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry_size); } else { A_RELEASE_FIRMWARE(fw_entry); return A_ERROR; } } if (tempEeprom) { A_FREE(tempEeprom); } if (status != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI operation failed: %d\n", __LINE__)); A_RELEASE_FIRMWARE(fw_entry); return A_ERROR; } A_RELEASE_FIRMWARE(fw_entry); return A_OK; } #endif /* INIT_MODE_DRV_ENABLED */ A_STATUS ar6000_update_bdaddr(AR_SOFTC_T *ar) { if (setupbtdev != 0) { A_UINT32 address; if (BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_data), (A_UCHAR *)&address, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for hi_board_data failed\n")); return A_ERROR; } if (BMIReadMemory(ar->arHifDevice, address + BDATA_BDADDR_OFFSET, (A_UCHAR *)ar->bdaddr, 6) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for BD address failed\n")); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BDADDR 0x%x:0x%x:0x%x:0x%x:0x%x:0x%x\n", ar->bdaddr[0], ar->bdaddr[1], ar->bdaddr[2], ar->bdaddr[3], ar->bdaddr[4], ar->bdaddr[5])); } return A_OK; } A_STATUS ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, A_UINT32 mode) { #if defined(INIT_MODE_DRV_ENABLED) && defined(CONFIG_HOST_TCMD_SUPPORT) const char *filename; const struct firmware *fw_entry; #endif AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Requesting device specific configuration\n")); if (mode == WLAN_INIT_MODE_UDEV) { A_CHAR version[16]; const struct firmware *fw_entry; /* Get config using udev through a script in user space */ if (snprintf(version, sizeof(version), "%2.2x", ar->arVersion.target_ver) >= sizeof(version)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("snprintf: Target version-%2.2x\n", ar->arVersion.target_ver)); return A_ERROR; } if ((A_REQUEST_FIRMWARE(&fw_entry, version, ((struct device *)ar->osDevInfo.pOSDevice))) != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI: Failure to get configuration for target version: %s\n", version)); return A_ERROR; } A_RELEASE_FIRMWARE(fw_entry); #ifdef INIT_MODE_DRV_ENABLED } else { /* The config is contained within the driver itself */ A_STATUS status; A_UINT32 param, options, sleep, address; /* Temporarily disable system sleep */ address = MBOX_BASE_ADDRESS + LOCAL_SCRATCH_OFFSET; bmifn(BMIReadSOCRegister(ar->arHifDevice, address, ¶m)); options = param; param |= AR6K_OPTION_SLEEP_DISABLE; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); address = RTC_WMAC_BASE_ADDRESS + WLAN_SYSTEM_SLEEP_OFFSET; bmifn(BMIReadSOCRegister(ar->arHifDevice, address, ¶m)); sleep = param; param |= WLAN_SYSTEM_SLEEP_DISABLE_SET(1); bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("old options: %d, old sleep: %d\n", options, sleep)); if (ar->arTargetType == TARGET_TYPE_MCKINLEY) { /* Run at 40/44MHz by default */ param = CPU_CLOCK_STANDARD_SET(0); } else if (ar->arTargetType == TARGET_TYPE_AR6003) { /* Program analog PLL register */ bmifn(BMIWriteSOCRegister(ar->arHifDevice, ANALOG_INTF_BASE_ADDRESS + 0x284, 0xF9104001)); /* Run at 80/88MHz by default */ param = CPU_CLOCK_STANDARD_SET(1); } else { /* Run at 40/44MHz by default */ param = CPU_CLOCK_STANDARD_SET(0); } address = RTC_SOC_BASE_ADDRESS + CPU_CLOCK_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); param = 0; if (ar->arTargetType == TARGET_TYPE_AR6002) { bmifn(BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_ext_clk_detected), (A_UCHAR *)¶m, 4)); } /* LPO_CAL.ENABLE = 1 if no external clk is detected */ if (param != 1) { address = RTC_SOC_BASE_ADDRESS + LPO_CAL_OFFSET; param = LPO_CAL_ENABLE_SET(1); bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); } /* Venus2.0: Lower SDIO pad drive strength */ if ((ar->arVersion.target_ver == AR6003_REV2_VERSION) || (ar->arVersion.target_ver == AR6003_REV3_VERSION)) { param = 0x28; address = GPIO_BASE_ADDRESS + GPIO_PIN9_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); param = 0x20; address = GPIO_BASE_ADDRESS + GPIO_PIN10_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); address = GPIO_BASE_ADDRESS + GPIO_PIN11_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); address = GPIO_BASE_ADDRESS + GPIO_PIN12_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); address = GPIO_BASE_ADDRESS + GPIO_PIN13_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); } /* Change the clock with module parameter refclock Mhz */ bmifn(BMIWriteSOCRegister(ar->arHifDevice, 0x540678, refClock)); #ifdef FORCE_INTERNAL_CLOCK /* Ignore external clock, if any, and force use of internal clock */ if (ar->arTargetType == TARGET_TYPE_AR6003 || ar->arTargetType == TARGET_TYPE_MCKINLEY) { /* hi_ext_clk_detected = 0 */ param = 0; bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_ext_clk_detected), (A_UCHAR *)¶m, 4)); /* CLOCK_CONTROL &= ~LF_CLK32 */ address = RTC_BASE_ADDRESS + CLOCK_CONTROL_ADDRESS; bmifn(BMIReadSOCRegister(ar->arHifDevice, address, ¶m)); param &= (~CLOCK_CONTROL_LF_CLK32_SET(1)); bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); } #endif /* FORCE_INTERNAL_CLOCK */ /* Transfer Board Data from Target EEPROM to Target RAM */ if (ar->arTargetType == TARGET_TYPE_AR6003 || ar->arTargetType == TARGET_TYPE_MCKINLEY) { /* Determine where in Target RAM to write Board Data */ bmifn(BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_data), (A_UCHAR *)&address, 4)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("Board Data download address: 0x%x\n", address)); /* Write EEPROM data to Target RAM */ if ((status=ar6000_transfer_bin_file(ar, AR6K_BOARD_DATA_FILE, address, FALSE)) != A_OK) { return A_ERROR; } /* Record the fact that Board Data IS initialized */ param = 1; bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_data_initialized), (A_UCHAR *)¶m, 4)); /* Transfer One time Programmable data */ AR6K_APP_LOAD_ADDRESS(address, ar->arVersion.target_ver); if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { address = BMI_SEGMENTED_WRITE_ADDR; } status = ar6000_transfer_bin_file(ar, AR6K_OTP_FILE, address, TRUE); if (status == A_OK) { /* Execute the OTP code */ #ifdef SOFTMAC_FILE_USED param = 1; #else param = 0; #endif if (regcode != 0) param |= 0x2; AR6K_APP_START_OVERRIDE_ADDRESS(address, ar->arVersion.target_ver); bmifn(BMIExecute(ar->arHifDevice, address, ¶m)); } else if (status != A_ENOENT) { return A_ERROR; } } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Programming of board data for chip %d not supported\n", ar->arTargetType)); return A_ERROR; } /* Download Target firmware */ AR6K_APP_LOAD_ADDRESS(address, ar->arVersion.target_ver); if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { address = BMI_SEGMENTED_WRITE_ADDR; } if ((ar6000_transfer_bin_file(ar, AR6K_FIRMWARE_FILE, address, TRUE)) != A_OK) { return A_ERROR; } if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { /* Set starting address for firmware */ AR6K_APP_START_OVERRIDE_ADDRESS(address, ar->arVersion.target_ver); bmifn(BMISetAppStart(ar->arHifDevice, address)); } /* Apply the patches */ if (ar->arTargetType == TARGET_TYPE_AR6003) { AR6K_DATASET_PATCH_ADDRESS(address, ar->arVersion.target_ver); if ((ar6000_transfer_bin_file(ar, AR6K_PATCH_FILE, address, FALSE)) != A_OK) { return A_ERROR; } param = address; bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_dset_list_head), (A_UCHAR *)¶m, 4)); } /* Restore system sleep */ address = RTC_WMAC_BASE_ADDRESS + WLAN_SYSTEM_SLEEP_OFFSET; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, sleep)); address = MBOX_BASE_ADDRESS + LOCAL_SCRATCH_OFFSET; param = options | 0x20; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); if (ar->arTargetType == TARGET_TYPE_AR6003 || ar->arTargetType == TARGET_TYPE_MCKINLEY) { /* Configure GPIO AR6003 UART */ #ifndef CONFIG_AR600x_DEBUG_UART_TX_PIN #define CONFIG_AR600x_DEBUG_UART_TX_PIN 8 #endif param = CONFIG_AR600x_DEBUG_UART_TX_PIN; bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_dbg_uart_txpin), (A_UCHAR *)¶m, 4)); #if (CONFIG_AR600x_DEBUG_UART_TX_PIN == 23) if (ATH_REGISTER_SUPPORTED_BY_TARGET(CLOCK_GPIO_OFFSET)) { address = GPIO_BASE_ADDRESS + CLOCK_GPIO_OFFSET; bmifn(BMIReadSOCRegister(ar->arHifDevice, address, ¶m)); param |= CLOCK_GPIO_BT_CLK_OUT_EN_SET(1); bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); } else { /* AR6004 has no need for a CLOCK_GPIO register */ } #endif /* Configure GPIO for BT Reset */ #ifdef ATH6KL_CONFIG_GPIO_BT_RESET #define CONFIG_AR600x_BT_RESET_PIN 0x16 param = CONFIG_AR600x_BT_RESET_PIN; bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_hci_uart_support_pins), (A_UCHAR *)¶m, 4)); #endif /* ATH6KL_CONFIG_GPIO_BT_RESET */ /* Configure UART flow control polarity */ #ifndef CONFIG_ATH6KL_BT_UART_FC_POLARITY #define CONFIG_ATH6KL_BT_UART_FC_POLARITY 0 #endif #if (CONFIG_ATH6KL_BT_UART_FC_POLARITY == 1) if ((ar->arVersion.target_ver == AR6003_REV2_VERSION) || (ar->arVersion.target_ver == AR6003_REV3_VERSION)) { param = ((CONFIG_ATH6KL_BT_UART_FC_POLARITY << 1) & 0x2); bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_hci_uart_pwr_mgmt_params), (A_UCHAR *)¶m, 4)); } #endif /* CONFIG_ATH6KL_BT_UART_FC_POLARITY */ } #ifdef HTC_RAW_INTERFACE if (!eppingtest && bypasswmi) { /* Don't run BMIDone for ART mode and force resetok=0 */ resetok = 0; msleep(1000); param = 1; status = BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_data_initialized), (A_UCHAR *)¶m, 4); } #endif /* HTC_RAW_INTERFACE */ #ifdef CONFIG_HOST_TCMD_SUPPORT if (testmode == 2) { if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { filename = AR6003_REV2_UTF_FIRMWARE_FILE; if ((A_REQUEST_FIRMWARE(&fw_entry, filename, ((struct device *)ar->osDevInfo.pOSDevice))) != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get %s\n", filename)); return A_ENOENT; } if (fw_entry == NULL) return A_ERROR; /* Download Target firmware */ AR6K_APP_LOAD_ADDRESS(address, ar->arVersion.target_ver); status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry->size); address = HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_end_RAM_reserve_sz); param = 11008; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); address = 0x57D884; filename = AR6003_REV2_TESTSCRIPT_FILE; if ((A_REQUEST_FIRMWARE(&fw_entry, filename, ((struct device *)ar->osDevInfo.pOSDevice))) != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get %s\n", filename)); return A_ENOENT; } if (fw_entry == NULL) return A_ERROR; status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry->size); param = 0x57D884; address = HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_ota_testscript); bmifn(BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)¶m, 4)); address = HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_test_apps_related); bmifn(BMIReadSOCRegister(ar->arHifDevice, address, ¶m)); param |= 1; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); A_RELEASE_FIRMWARE(fw_entry); } else if (ar->arVersion.target_ver == AR6003_REV3_VERSION) { filename = AR6003_REV3_UTF_FIRMWARE_FILE; if ((A_REQUEST_FIRMWARE(&fw_entry, filename, ((struct device *)ar->osDevInfo.pOSDevice))) != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get %s\n", filename)); return A_ENOENT; } /* Download Target firmware */ address = BMI_SEGMENTED_WRITE_ADDR; if (fw_entry == NULL) return A_ERROR; status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry->size); address = HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_end_RAM_reserve_sz); param = 4096; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); address = 0x57EF74; filename = AR6003_REV3_TESTSCRIPT_FILE; if ((A_REQUEST_FIRMWARE(&fw_entry, filename, ((struct device *)ar->osDevInfo.pOSDevice))) != 0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get %s\n", filename)); return A_ENOENT; } if (fw_entry == NULL) return A_ERROR; status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry->size); param = 0x57EF74; address = HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_ota_testscript); bmifn(BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)¶m, 4)); address = HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_test_apps_related); bmifn(BMIReadSOCRegister(ar->arHifDevice, address, ¶m)); param |= 1; bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param)); A_RELEASE_FIRMWARE(fw_entry); } } #endif #endif /* INIT_MODE_DRV_ENABLED */ } return A_OK; } A_STATUS ar6000_configure_target(AR_SOFTC_T *ar) { A_UINT32 param; if (enableuartprint) { param = 1; if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_serial_enable), (A_UCHAR *)¶m, 4)!= A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for enableuartprint failed \n")); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Serial console prints enabled\n")); } /* Tell target which HTC version it is used*/ param = HTC_PROTOCOL_VERSION; if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_app_host_interest), (A_UCHAR *)¶m, 4)!= A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for htc version failed \n")); return A_ERROR; } if (enabletimerwar) { A_UINT32 param; if (BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4)!= A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for enabletimerwar failed \n")); return A_ERROR; } param |= HI_OPTION_TIMER_WAR; if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for enabletimerwar failed \n")); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Timer WAR enabled\n")); } /* set the firmware mode to STA/IBSS/AP */ { A_UINT32 param; if (BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4)!= A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for setting fwmode failed \n")); return A_ERROR; } param |= (num_device << HI_OPTION_NUM_DEV_SHIFT); param |= (fwmode << HI_OPTION_FW_MODE_SHIFT); param |= (mac_addr_method << HI_OPTION_MAC_ADDR_METHOD_SHIFT); param |= (firmware_bridge << HI_OPTION_FW_BRIDGE_SHIFT); param |= (fwsubmode << HI_OPTION_FW_SUBMODE_SHIFT); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("NUM_DEV=%d FWMODE=0x%x FWSUBMODE=0x%x FWBR_BUF %d\n", num_device, fwmode, fwsubmode, firmware_bridge)); if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for setting fwmode failed \n")); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Firmware mode set\n")); } #ifdef ATH6KL_DISABLE_TARGET_DBGLOGS { A_UINT32 param; if (BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4)!= A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for disabling debug logs failed\n")); return A_ERROR; } param |= HI_OPTION_DISABLE_DBGLOG; if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for HI_OPTION_DISABLE_DBGLOG\n")); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Firmware mode set\n")); } #endif /* ATH6KL_DISABLE_TARGET_DBGLOGS */ if (regscanmode) { A_UINT32 param; if (BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4)!= A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for setting regscanmode failed\n")); return A_ERROR; } if (regscanmode == 1) { param |= HI_OPTION_SKIP_REG_SCAN; } else if (regscanmode == 2) { param |= HI_OPTION_INIT_REG_SCAN; } if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_option_flag), (A_UCHAR *)¶m, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for setting regscanmode failed\n")); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Regulatory scan mode set\n")); } /* * Hardcode the address use for the extended board data * Ideally this should be pre-allocate by the OS at boot time * But since it is a new feature and board data is loaded * at init time, we have to workaround this from host. * It is difficult to patch the firmware boot code, * but possible in theory. */ if (ar->arTargetType == TARGET_TYPE_AR6003) { A_UINT32 ramReservedSz; if (ar->arVersion.target_ver == AR6003_REV2_VERSION) { param = AR6003_REV2_BOARD_EXT_DATA_ADDRESS; ramReservedSz = AR6003_REV2_RAM_RESERVE_SIZE; } else { param = AR6003_REV3_BOARD_EXT_DATA_ADDRESS; if (testmode) { ramReservedSz = AR6003_REV3_RAM_RESERVE_SIZE_TCMD; } else { ramReservedSz = AR6003_REV3_RAM_RESERVE_SIZE; } } if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_board_ext_data), (A_UCHAR *)¶m, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for hi_board_ext_data failed \n")); return A_ERROR; } if (BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar->arTargetType, hi_end_RAM_reserve_sz), (A_UCHAR *)&ramReservedSz, 4) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for hi_end_RAM_reserve_sz failed \n")); return A_ERROR; } } /* since BMIInit is called in the driver layer, we have to set the block * size here for the target */ if (A_FAILED(ar6000_set_htc_params(ar->arHifDevice, ar->arTargetType, mbox_yield_limit, 0 /* use default number of control buffers */ ))) { return A_ERROR; } if (setupbtdev != 0) { if (A_FAILED(ar6000_set_hci_bridge_flags(ar->arHifDevice, ar->arTargetType, setupbtdev))) { return A_ERROR; } } return A_OK; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) static void ar6000_ethtool_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) { A_STATUS status; HIF_DEVICE_OS_DEVICE_INFO osDevInfo; AR_SOFTC_T *ar; AR_SOFTC_DEV_T *arPriv; struct ar6000_version *revinfo; if((dev == NULL) || ((arPriv = ar6k_priv(dev)) == NULL)) { return; } ar = arPriv->arSoftc; revinfo = &ar->arVersion; strcpy(info->driver, "AR6000"); snprintf(info->version, sizeof(info->version), "%u.%u.%u.%u", ((revinfo->host_ver)&0xf0000000)>>28, ((revinfo->host_ver)&0x0f000000)>>24, ((revinfo->host_ver)&0x00ff0000)>>16, ((revinfo->host_ver)&0x0000ffff)); snprintf(info->fw_version, sizeof(info->fw_version), "%u.%u.%u.%u", ((revinfo->wlan_ver)&0xf0000000)>>28, ((revinfo->wlan_ver)&0x0f000000)>>24, ((revinfo->wlan_ver)&0x00ff0000)>>16, ((revinfo->wlan_ver)&0x0000ffff)); status = HIFConfigureDevice(ar->arHifDevice, HIF_DEVICE_GET_OS_DEVICE, &osDevInfo, sizeof(HIF_DEVICE_OS_DEVICE_INFO)); if (A_SUCCESS(status) && osDevInfo.pOSDevice) { struct device *dev = (struct device*)osDevInfo.pOSDevice; if (dev->bus && dev->bus->name) { #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 27) const char *dinfo = dev_name(dev); #else const char *dinfo = kobject_name(&dev->kobj); #endif snprintf(info->bus_info, sizeof(info->bus_info), dinfo); } } } static u32 ar6000_ethtool_get_link(struct net_device *dev) { AR_SOFTC_DEV_T *arPriv; return ((arPriv = ar6k_priv(dev))!=NULL) ? arPriv->arConnected : 0; } #ifdef CONFIG_CHECKSUM_OFFLOAD static u32 ar6000_ethtool_get_rx_csum(struct net_device *dev) { AR_SOFTC_DEV_T *arPriv; if((dev == NULL) || ((arPriv = ar6k_priv(dev)) == NULL)) { return 0; } return (arPriv->arSoftc->rxMetaVersion==WMI_META_VERSION_2); } static int ar6000_ethtool_set_rx_csum(struct net_device *dev, u32 enable) { AR_SOFTC_T *ar; AR_SOFTC_DEV_T *arPriv; A_UINT8 metaVersion; if((dev == NULL) || ((arPriv = ar6k_priv(dev)) == NULL)) { return -EIO; } ar = arPriv->arSoftc; if (ar->arWmiReady == FALSE || ar->arWlanState == WLAN_DISABLED) { return -EIO; } metaVersion = (enable) ? WMI_META_VERSION_2 : 0; if ((wmi_set_rx_frame_format_cmd(arPriv->arWmi, metaVersion, processDot11Hdr, processDot11Hdr)) != A_OK) { return -EFAULT; } ar->rxMetaVersion = metaVersion; return 0; } static u32 ar6000_ethtool_get_tx_csum(struct net_device *dev) { return csumOffload; } static int ar6000_ethtool_set_tx_csum(struct net_device *dev, u32 enable) { csumOffload = enable; if(enable){ dev->features |= NETIF_F_IP_CSUM; } else { dev->features &= ~NETIF_F_IP_CSUM; } return 0; } #endif /* CONFIG_CHECKSUM_OFFLOAD */ static const struct ethtool_ops ar6000_ethtool_ops = { .get_drvinfo = ar6000_ethtool_get_drvinfo, .get_link = ar6000_ethtool_get_link, #ifdef CONFIG_CHECKSUM_OFFLOAD .get_rx_csum = ar6000_ethtool_get_rx_csum, .set_rx_csum = ar6000_ethtool_set_rx_csum, .get_tx_csum = ar6000_ethtool_get_tx_csum, .set_tx_csum = ar6000_ethtool_set_tx_csum, #endif /* CONFIG_CHECKSUM_OFFLOAD */ }; #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) */ /* * HTC Event handlers */ static A_STATUS ar6000_avail_ev(void *context, void *hif_handle) { int i; struct net_device *dev; void *ar_netif; AR_SOFTC_T *ar=NULL; AR_SOFTC_DEV_T *arPriv; int device_index = 0; HTC_INIT_INFO htcInfo; A_STATUS init_status = A_OK; unsigned char devnum = 0; unsigned char cnt = 0; /* * If ar6000_avail_ev is called more than once, this means that * multiple AR600x devices have been inserted into the system. * We do not support more than one AR600x device at this time. */ if (avail_ev_called) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("ERROR: More than one AR600x device not supported by driver\n")); complete(&avail_ev_completion); return A_ERROR; } avail_ev_called = TRUE; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_available\n")); ar = A_MALLOC(sizeof(AR_SOFTC_T)); if (ar == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("AR_SOFTC: can not allocate\n")); complete(&avail_ev_completion); return A_ERROR; } A_MEMZERO(ar, sizeof(AR_SOFTC_T)); #ifdef ATH_AR6K_11N_SUPPORT if(aggr_init(ar6000_alloc_netbufs, ar6000_deliver_frames_to_nw_stack) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() Failed to initialize aggr.\n", __func__)); init_status = A_ERROR; goto avail_ev_failed; } #endif A_MEMZERO((A_UINT8 *)ar->connTbl, NUM_CONN * sizeof(conn_t)); /* Init the PS queues */ for (i=0; i < NUM_CONN ; i++) { #ifdef ATH_AR6K_11N_SUPPORT if ((ar->connTbl[i].conn_aggr = aggr_init_conn()) == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s() Failed to initialize aggr.\n", __func__)); A_FREE(ar); complete(&avail_ev_completion); return A_ERROR; } #endif A_MUTEX_INIT(&ar->connTbl[i].psqLock); A_NETBUF_QUEUE_INIT(&ar->connTbl[i].psq); A_NETBUF_QUEUE_INIT(&ar->connTbl[i].apsdq); } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) if(ifname[0]) { for(i = 0; i < strlen(ifname); i++) { if(ifname[i] >= '0' && ifname[i] <= '9' ) { devnum = (devnum * 10) + (ifname[i] - '0'); } else { cnt++; } } ifname[cnt]='\0'; } #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */ ar->arConfNumDev = num_device; for (i=0; i < num_device; i++) { if (ar6000_devices[i] != NULL) { break; } /* Save this. It gives a bit better readability especially since */ /* we use another local "i" variable below. */ device_index = i; dev = alloc_etherdev(sizeof(AR_SOFTC_DEV_T)); if (dev == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_available: can't alloc etherdev\n")); A_FREE(ar); complete(&avail_ev_completion); return A_ERROR; } ether_setup(dev); ar_netif = ar6k_priv(dev); if (ar_netif == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s: Can't allocate ar6k priv memory\n", __func__)); A_FREE(ar); complete(&avail_ev_completion); return A_ERROR; } A_MEMZERO(ar_netif, sizeof(AR_SOFTC_DEV_T)); arPriv = (AR_SOFTC_DEV_T *)ar_netif; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) if (ifname[0]) { snprintf(dev->name, sizeof(dev->name), "%s%d", ifname, (devnum + device_index)); } #endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) */ #ifdef SET_MODULE_OWNER SET_MODULE_OWNER(dev); #endif #ifdef SET_NETDEV_DEV #if 0 if (ar_netif) { HIF_DEVICE_OS_DEVICE_INFO osDevInfo; A_MEMZERO(&osDevInfo, sizeof(osDevInfo)); if ( A_SUCCESS( HIFConfigureDevice(hif_handle, HIF_DEVICE_GET_OS_DEVICE, &osDevInfo, sizeof(osDevInfo))) ) { SET_NETDEV_DEV(dev, osDevInfo.pOSDevice); } } #endif #endif arPriv->arNetDev = dev; ar6000_devices[device_index] = dev; arPriv->arSoftc = ar; ar->arDev[device_index] = arPriv; ar->arWlanState = WLAN_ENABLED; arPriv->arDeviceIndex = device_index; ar->arWlanPowerState = WLAN_POWER_STATE_ON; if(ar6000_init_control_info(arPriv) != A_OK) { init_status = A_ERROR; goto avail_ev_failed; } init_waitqueue_head(&arPriv->arEvent); #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL A_INIT_TIMER(&aptcTimer[i], aptcTimerHandler, ar); #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ spin_lock_init(&arPriv->arPrivLock); #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) dev->open = &ar6000_open; dev->stop = &ar6000_close; dev->hard_start_xmit = &ar6000_data_tx; dev->get_stats = &ar6000_get_stats; /* dev->tx_timeout = ar6000_tx_timeout; */ dev->do_ioctl = &ar6000_ioctl; dev->set_multicast_list = &ar6000_set_multicast_list; #else dev->netdev_ops = &ar6000_netdev_ops; #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) */ #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24) dev->ethtool_ops = &ar6000_ethtool_ops; #endif dev->watchdog_timeo = AR6000_TX_TIMEOUT; dev->wireless_handlers = &ath_iw_handler_def; #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) dev->get_wireless_stats = ar6000_get_iwstats; /*Displayed via proc fs */ #else ath_iw_handler_def.get_wireless_stats = ar6000_get_iwstats; /*Displayed via proc fs */ #endif #ifdef CONFIG_CHECKSUM_OFFLOAD if(csumOffload){ dev->features |= NETIF_F_IP_CSUM;/*advertise kernel capability to do TCP/UDP CSUM offload for IPV4*/ } #endif if (processDot11Hdr) { dev->hard_header_len = sizeof(struct ieee80211_qosframe) + sizeof(ATH_LLC_SNAP_HDR) + sizeof(WMI_DATA_HDR) + HTC_HEADER_LEN + WMI_MAX_TX_META_SZ + LINUX_HACK_FUDGE_FACTOR; } else { /* * We need the OS to provide us with more headroom in order to * perform dix to 802.3, WMI header encap, and the HTC header */ dev->hard_header_len = ETH_HLEN + sizeof(ATH_LLC_SNAP_HDR) + sizeof(WMI_DATA_HDR) + HTC_HEADER_LEN + WMI_MAX_TX_META_SZ + LINUX_HACK_FUDGE_FACTOR; } if (!bypasswmi && !eppingtest) { /* Indicate that WMI is enabled (although not ready yet) */ arPriv->arWmiEnabled = TRUE; if ((arPriv->arWmi = wmi_init((void *) arPriv,arPriv->arDeviceIndex)) == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() Failed to initialize WMI.\n", __func__)); init_status = A_ERROR; goto avail_ev_failed; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s() Got WMI @ 0x%08x.\n", __func__, (unsigned int) arPriv->arWmi)); } } #ifdef CONFIG_HOST_TCMD_SUPPORT if(testmode) { ar->arTargetMode = AR6000_TCMD_MODE; }else { ar->arTargetMode = AR6000_WLAN_MODE; } #endif ar->arWlanOff = FALSE; /* We are in ON state */ #ifdef CONFIG_PM ar->arWowState = WLAN_WOW_STATE_NONE; ar->arBTOff = TRUE; /* BT chip assumed to be OFF */ ar->arBTSharing = WLAN_CONFIG_BT_SHARING; ar->arWlanOffConfig = WLAN_CONFIG_WLAN_OFF; ar->arSuspendConfig = WLAN_CONFIG_PM_SUSPEND; ar->arWow2Config = WLAN_CONFIG_PM_WOW2; #endif /* CONFIG_PM */ A_INIT_TIMER(&ar->arHBChallengeResp.timer, ar6000_detect_error, ar); ar->arHBChallengeResp.seqNum = 0; ar->arHBChallengeResp.outstanding = FALSE; ar->arHBChallengeResp.missCnt = 0; ar->arHBChallengeResp.frequency = AR6000_HB_CHALLENGE_RESP_FREQ_DEFAULT; ar->arHBChallengeResp.missThres = AR6000_HB_CHALLENGE_RESP_MISS_THRES_DEFAULT; ar->arHifDevice = hif_handle; sema_init(&ar->arSem, 1); ar->bIsDestroyProgress = FALSE; ar->delbaState = REASON_DELBA_INIT; ar->IsdelbaTimerInitialized = FALSE; A_INIT_TIMER (&ar->delbaTimer, delba_timer_callback, ar); ar->isHostAsleep = 0; INIT_HTC_PACKET_QUEUE(&ar->amsdu_rx_buffer_queue); /* * If requested, perform some magic which requires no cooperation from * the Target. It causes the Target to ignore flash and execute to the * OS from ROM. * * This is intended to support recovery from a corrupted flash on Targets * that support flash. */ if (skipflash) { //ar6000_reset_device_skipflash(ar->arHifDevice); } BMIInit(); if (bmienable) { ar6000_sysfs_bmi_init(ar); } { struct bmi_target_info targ_info; A_MEMZERO(&targ_info, sizeof(targ_info)); if (BMIGetTargetInfo(ar->arHifDevice, &targ_info) != A_OK) { init_status = A_ERROR; goto avail_ev_failed; } ar->arVersion.target_ver = targ_info.target_ver; ar->arTargetType = targ_info.target_type; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s() TARGET TYPE: %d\n", __func__,ar->arTargetType)); target_register_tbl_attach(ar->arTargetType); /* do any target-specific preparation that can be done through BMI */ if (ar6000_prepare_target(ar->arHifDevice, targ_info.target_type, targ_info.target_ver) != A_OK) { init_status = A_ERROR; goto avail_ev_failed; } } if (ar6000_configure_target(ar) != A_OK) { init_status = A_ERROR; goto avail_ev_failed; } A_MEMZERO(&htcInfo,sizeof(htcInfo)); htcInfo.pContext = ar; htcInfo.TargetFailure = ar6000_target_failure; ar->arHtcTarget = HTCCreate(ar->arHifDevice,&htcInfo); if (ar->arHtcTarget == NULL) { init_status = A_ERROR; goto avail_ev_failed; } spin_lock_init(&ar->arLock); #ifdef CONFIG_CHECKSUM_OFFLOAD if(csumOffload){ ar->rxMetaVersion=WMI_META_VERSION_2;/*if external frame work is also needed, change and use an extended rxMetaVerion*/ } #endif HIFClaimDevice(ar->arHifDevice, ar); if (bmienable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("BMI enabled: %d\n", wlaninitmode)); if ((wlaninitmode == WLAN_INIT_MODE_UDEV) || (wlaninitmode == WLAN_INIT_MODE_DRV)) { A_STATUS status = A_OK; do { if ((status = ar6000_sysfs_bmi_get_config(ar, wlaninitmode)) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: ar6000_sysfs_bmi_get_config failed\n")); break; } dev = ar6000_devices[0]; #ifdef HTC_RAW_INTERFACE if (!eppingtest && bypasswmi) { break; /* Don't call ar6000_init for ART */ } #endif status = (ar6000_init(dev)==0) ? A_OK : A_ERROR; if (status != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: ar6000_init\n")); } } while (FALSE); if (status != A_OK) { init_status = status; goto avail_ev_failed; } } } for (i=0; i < num_device; i++) { dev = ar6000_devices[i]; arPriv = ar6k_priv(dev); ar = arPriv->arSoftc; #ifdef CONFIG_PM init_waitqueue_head(&arPriv->sleep_mode_cmd_completed_event); #endif /* Don't install the init function if BMI is requested */ if (!bmienable) { #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) dev->init = ar6000_init; #else ar6000_netdev_ops.ndo_init = ar6000_init; #endif /* LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29) */ } /* This runs the init function if registered */ if (register_netdev(dev)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("ar6000_avail: register_netdev failed\n")); ar6000_cleanup(ar); ar6000_devices[i] = NULL; ar6000_destroy(dev, 0); complete(&avail_ev_completion); return A_ERROR; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_avail: name=%s hifdevice=0x%lx, dev=0x%lx (%d), ar=0x%lx\n", dev->name, (unsigned long)ar->arHifDevice, (unsigned long)dev, device_index, (unsigned long)ar)); } avail_ev_failed : if (A_FAILED(init_status)) { if (bmienable) { ar6000_sysfs_bmi_deinit(ar); } for (i=0; i < num_device; i++) { dev = ar6000_devices[i]; arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); if(arPriv->arWmiEnabled == TRUE) { wmi_shutdown(arPriv->arWmi); arPriv->arWmiEnabled = FALSE; } ar6000_devices[i] = NULL; } A_FREE(ar); } complete(&avail_ev_completion); mod_loaded = TRUE; wake_up_interruptible(&load_complete); printk("Completed loading the module %s\n", __func__); return init_status; } static void ar6000_target_failure(void *Instance, A_STATUS Status) { AR_SOFTC_T *ar = (AR_SOFTC_T *)Instance; WMI_TARGET_ERROR_REPORT_EVENT errEvent; static A_BOOL sip = FALSE; A_UINT8 i; if (Status != A_OK) { printk(KERN_ERR "ar6000_target_failure: target asserted \n"); if (timer_pending(&ar->arHBChallengeResp.timer)) { A_UNTIMEOUT(&ar->arHBChallengeResp.timer); } /* try dumping target assertion information (if any) */ ar6000_dump_target_assert_info(ar->arHifDevice,ar->arTargetType); /* * Fetch the logs from the target via the diagnostic * window. */ ar6000_dbglog_get_debug_logs(ar); /* Report the error only once */ if (!sip) { sip = TRUE; errEvent.errorVal = WMI_TARGET_COM_ERR | WMI_TARGET_FATAL_ERR; for(i = 0; i < num_device; i++) { ar6000_send_event_to_app(ar->arDev[i], WMI_ERROR_REPORT_EVENTID, (A_UINT8 *)&errEvent, sizeof(WMI_TARGET_ERROR_REPORT_EVENT)); } } } } static A_STATUS ar6000_unavail_ev(void *context, void *hif_handle) { unsigned int old_reset_ok = resetok; A_UINT8 i; struct net_device *ar6000_netdev; AR_SOFTC_T *ar = (AR_SOFTC_T*)context; resetok = 0; /* card is remove, don't reset */ ar6000_cleanup(ar); resetok = old_reset_ok; /* NULL out it's entry in the global list */ for(i = 0; i < num_device; i++) { ar6000_netdev = ar6000_devices[i]; ar6000_devices[i] = NULL; ar6000_destroy(ar6000_netdev, 1); } return A_OK; } /* * EV93295 Kernel panic "cannot create duplicate filename 'bmi'" */ A_BOOL restart_endpoint_called = FALSE; void ar6000_restart_endpoint(AR_SOFTC_T *ar) { A_STATUS status = A_OK; AR_SOFTC_DEV_T *arPriv; struct net_device *dev; A_UINT8 i = 0; if(restart_endpoint_called) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR6K: %s() already called.\n", __func__)); dump_stack(); return; } restart_endpoint_called = TRUE; /* * Call wmi_init for each device. This must be done BEFORE ar6000_init() is * called, or we will get a null pointer exception in the wmi code. We must * also set the arWmiEnabled flag for each device. */ for(i = 0; i < num_device; i++) { arPriv = ar->arDev[i]; arPriv->arWmiEnabled = TRUE; if ((arPriv->arWmi = wmi_init((void *) arPriv,arPriv->arDeviceIndex)) == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() Failed to initialize WMI.\n", __func__)); status = A_ERROR; goto exit; } } BMIInit(); if (bmienable) { ar6000_sysfs_bmi_init(ar); } do { if ( (status=ar6000_configure_target(ar))!=A_OK) break; if ( (status=ar6000_sysfs_bmi_get_config(ar, wlaninitmode)) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: ar6000_sysfs_bmi_get_config failed\n")); break; } } while(0); dev = ar6000_devices[0]; status = (ar6000_init(dev)==0) ? A_OK : A_ERROR; if (status != A_OK) { goto exit; } for(i = 0; i < num_device; i++) { arPriv = ar->arDev[i]; if (arPriv->arDoConnectOnResume && arPriv->arSsidLen && ar->arWlanState == WLAN_ENABLED) { ar6000_connect_to_ap(arPriv); } } if (status == A_OK) { restart_endpoint_called = FALSE; return; } exit: for(i = 0; i < num_device; i++) { arPriv = ar->arDev[i]; ar6000_devices[i] = NULL; ar6000_destroy(arPriv->arNetDev, 1); } restart_endpoint_called = FALSE; } void ar6000_stop_endpoint(AR_SOFTC_T *ar, A_BOOL keepprofile, A_BOOL getdbglogs) { AR_SOFTC_DEV_T *arPriv ; A_UINT8 i; A_UINT8 ctr; AR_SOFTC_STA_T *arSta; for(i = 0; i < num_device; i++) { arPriv = ar->arDev[i]; arSta = &arPriv->arSta; /* Stop the transmit queues */ netif_stop_queue(arPriv->arNetDev); /* Disable the target and the interrupts associated with it */ if (ar->arWmiReady == TRUE) { if (!bypasswmi) { A_BOOL disconnectIssued; arPriv->arDoConnectOnResume = arPriv->arConnected; A_UNTIMEOUT(&arPriv->arSta.disconnect_timer); A_UNTIMEOUT(&ar->ap_reconnect_timer); // AP + BTCOEX State variables resetted here. ar->IsdelbaTimerInitialized = FALSE; A_UNTIMEOUT(&ar->delbaTimer); ar->delbaState = REASON_DELBA_INIT; #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL /* Delete the Adaptive Power Control timer */ if (timer_pending(&aptcTimer[i])) { del_timer_sync(&aptcTimer[i]); } #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ #ifdef ATH_AR6K_11N_SUPPORT for (ctr=0; ctr < NUM_CONN ; ctr++) { aggr_module_destroy_timers(ar->connTbl[ctr].conn_aggr); } #endif if (!wait_event_interruptible_timeout(scan_complete, !arSta->scan_triggered, 2 * HZ)) { printk(KERN_ERR "scan complete not received\n"); } disconnectIssued = (arPriv->arConnected) || (arPriv->arSta.arConnectPending); ar6000_disconnect(arPriv); if (!keepprofile) { ar6000_init_profile_info(arPriv); } if (getdbglogs) { ar6000_dbglog_get_debug_logs(ar); } ar->arWmiReady = FALSE; arPriv->arWmiEnabled = FALSE; wmi_shutdown(arPriv->arWmi); arPriv->arWmi = NULL; /* * After wmi_shudown all WMI events will be dropped. * We need to cleanup the buffers allocated in AP mode * and give disconnect notification to stack, which usually * happens in the disconnect_event. * Simulate the disconnect_event by calling the function directly. * Sometimes disconnect_event will be received when the debug logs * are collected. */ if (disconnectIssued) { if(arPriv->arNetworkType & AP_NETWORK) { ar6000_disconnect_event(arPriv, DISCONNECT_CMD, bcast_mac, 0, NULL, 0); } else { ar6000_disconnect_event(arPriv, DISCONNECT_CMD, arPriv->arBssid, 0, NULL, 0); } } #ifdef USER_KEYS arPriv->arSta.user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT; arPriv->arSta.user_key_ctrl = 0; #endif } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): WMI stopped\n", __func__)); } else { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): WMI not ready 0x%lx 0x%lx\n", __func__, (unsigned long) ar, (unsigned long) arPriv->arWmi)); /* Shut down WMI if we have started it */ if(arPriv->arWmiEnabled == TRUE) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): Shut down WMI\n", __func__)); arPriv->arWmiEnabled = FALSE; wmi_shutdown(arPriv->arWmi); arPriv->arWmi = NULL; } } /* cleanup hci pal driver data structures */ if (setuphcipal && (arPriv->isBt30amp == TRUE)) { ar6k_cleanup_hci_pal(arPriv); } } if (ar->arHtcTarget != NULL) { #ifdef EXPORT_HCI_BRIDGE_INTERFACE if (NULL != ar6kHciTransCallbacks.cleanupTransport) { ar6kHciTransCallbacks.cleanupTransport(NULL); } #else // FIXME: workaround to reset BT's UART baud rate to default if (NULL != ar->exitCallback) { AR3K_CONFIG_INFO ar3kconfig; A_STATUS status; A_MEMZERO(&ar3kconfig,sizeof(ar3kconfig)); ar6000_set_default_ar3kconfig(ar, (void *)&ar3kconfig); status = ar->exitCallback(&ar3kconfig); if (A_OK != status) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Failed to reset AR3K baud rate! \n")); } } // END workaround if (setuphci) ar6000_cleanup_hci(ar); #endif AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" Shutting down HTC .... \n")); /* stop HTC */ HTCStop(ar->arHtcTarget); ar6k_init = FALSE; } if (resetok) { /* try to reset the device if we can * The driver may have been configure NOT to reset the target during * a debug session */ AR_DEBUG_PRINTF(ATH_DEBUG_ANY,(" Attempting to reset target on instance destroy.... \n")); if (ar->arHifDevice != NULL) { #if defined(CONFIG_MMC_MSM) || defined(CONFIG_MMC_SDHCI_S3C) A_BOOL coldReset = ((ar->arTargetType == TARGET_TYPE_AR6003)|| (ar->arTargetType == TARGET_TYPE_MCKINLEY)) ? TRUE: FALSE; #else A_BOOL coldReset = (ar->arTargetType == TARGET_TYPE_MCKINLEY) ? TRUE: FALSE; #endif ar6000_reset_device(ar->arHifDevice, ar->arTargetType, TRUE, coldReset); } } else { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" Host does not want target reset. \n")); } /* Done with cookies */ ar6000_cookie_cleanup(ar); /* cleanup any allocated AMSDU buffers */ ar6000_cleanup_amsdu_rxbufs(ar); if (bmienable) { ar6000_sysfs_bmi_deinit(ar); } } void ar6000_cleanup(AR_SOFTC_T *ar) { A_UINT8 ctr; ar->bIsDestroyProgress = TRUE; if (down_interruptible(&ar->arSem)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s(): down_interruptible failed \n", __func__)); return; } if (ar->arWlanPowerState != WLAN_POWER_STATE_CUT_PWR) { /* only stop endpoint if we are not stop it in suspend_ev */ ar6000_stop_endpoint(ar, FALSE, TRUE); } else { /* clear up the platform power state before rmmod */ plat_setup_power(ar, 1, 0); ar->arPlatPowerOff = FALSE; } #ifdef ATH_AR6K_11N_SUPPORT for (ctr=0; ctr < NUM_CONN ; ctr++) { aggr_module_destroy_conn(ar->connTbl[ctr].conn_aggr); } aggr_module_destroy(); #endif ar->arWlanState = WLAN_DISABLED; up(&ar->arSem); if (ar->arHtcTarget != NULL) { /* destroy HTC */ HTCDestroy(ar->arHtcTarget); } if (ar->arHifDevice != NULL) { /*release the device so we do not get called back on remove incase we * we're explicity destroyed by module unload */ HIFReleaseDevice(ar->arHifDevice); HIFShutDownDevice(ar->arHifDevice); } /* Done with cookies */ ar6000_cookie_cleanup(ar); /* cleanup any allocated AMSDU buffers */ ar6000_cleanup_amsdu_rxbufs(ar); if (bmienable) { ar6000_sysfs_bmi_deinit(ar); } /* Cleanup BMI */ BMICleanup(); /* Clear the tx counters */ memset(tx_attempt, 0, sizeof(tx_attempt)); memset(tx_post, 0, sizeof(tx_post)); memset(tx_complete, 0, sizeof(tx_complete)); #ifdef HTC_RAW_INTERFACE if (ar->arRawHtc) { A_FREE(ar->arRawHtc); ar->arRawHtc = NULL; } #endif A_UNTIMEOUT(&ar->ap_reconnect_timer); A_UNTIMEOUT(&ar->arHBChallengeResp.timer); // AP + BTCOEX State variables resetted here. ar->IsdelbaTimerInitialized = FALSE; A_UNTIMEOUT(&ar->delbaTimer); ar->delbaState = REASON_DELBA_INIT; A_FREE(ar); } /* * We need to differentiate between the surprise and planned removal of the * device because of the following consideration: * - In case of surprise removal, the hcd already frees up the pending * for the device and hence there is no need to unregister the function * driver inorder to get these requests. For planned removal, the function * driver has to explictly unregister itself to have the hcd return all the * pending requests before the data structures for the devices are freed up. * Note that as per the current implementation, the function driver will * end up releasing all the devices since there is no API to selectively * release a particular device. * - Certain commands issued to the target can be skipped for surprise * removal since they will anyway not go through. */ void ar6000_destroy(struct net_device *dev, unsigned int unregister) { AR_SOFTC_DEV_T *arPriv; AR_SOFTC_AP_T *arAp; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("+ar6000_destroy \n")); if((dev == NULL) || ((arPriv = ar6k_priv(dev)) == NULL)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s(): Failed to get device structure.\n", __func__)); return; } aggr_module_destroy_conn(arPriv->conn_aggr); if(arPriv->arNetworkType == AP_NETWORK) { arAp = &arPriv->arAp; } ar6k_init = FALSE; /* Free up the device data structure */ if (unregister) { unregister_netdev(dev); } #ifndef HAVE_FREE_NETDEV kfree(dev); #else free_netdev(dev); #endif AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("-ar6000_destroy \n")); } static void delba_timer_callback(unsigned long ptr) { AR_SOFTC_T *ar= (AR_SOFTC_T *)ptr; do { if (NULL != ar) { if (!ar->IsdelbaTimerInitialized) { break; } ar->IsdelbaTimerInitialized = FALSE; A_UNTIMEOUT (&ar->delbaTimer); ar6000_send_delba (ar, REASON_DELBA_TIMEOUT); ar->delbaState = REASON_DELBA_INIT; } }while (FALSE); } static void ap_reconnect_timer_handler(unsigned long ptr) { AR_SOFTC_T *ar= (AR_SOFTC_T *)ptr; AR_SOFTC_DEV_T *arTempPriv = NULL; A_UINT8 i=0; A_UNTIMEOUT(&ar->ap_reconnect_timer); if(ar->arHoldConnection){ for(i=0;iarConfNumDev;i++){ arTempPriv = ar->arDev[i]; if((AP_NETWORK == arTempPriv->arNetworkType) && (ar->arHoldConnection & (1<arDeviceIndex))){ ar->arHoldConnection &= ~(1<arDeviceIndex); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ap_reconnect_timer_handler: starting AP %d", arTempPriv->arDeviceIndex)); ar6000_ap_mode_profile_commit(arTempPriv); break; } } } else { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_reconnect_timer_handler : no" " device pending for connect\n")); } } static void disconnect_timer_handler(unsigned long ptr) { struct net_device *dev = (struct net_device *)ptr; AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); A_UNTIMEOUT(&arPriv->arSta.disconnect_timer); ar6000_init_profile_info(arPriv); ar6000_disconnect(arPriv); } static void ar6000_detect_error(unsigned long ptr) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ptr; A_UINT8 i; WMI_TARGET_ERROR_REPORT_EVENT errEvent; AR6000_SPIN_LOCK(&ar->arLock, 0); if (ar->arHBChallengeResp.outstanding) { ar->arHBChallengeResp.missCnt++; } else { ar->arHBChallengeResp.missCnt = 0; } if (ar->arHBChallengeResp.missCnt > ar->arHBChallengeResp.missThres) { /* Send Error Detect event to the application layer and do not reschedule the error detection module timer */ ar->arHBChallengeResp.missCnt = 0; ar->arHBChallengeResp.seqNum = 0; errEvent.errorVal = WMI_TARGET_COM_ERR | WMI_TARGET_FATAL_ERR; AR6000_SPIN_UNLOCK(&ar->arLock, 0); for(i = 0; i < num_device; i++) { ar6000_send_event_to_app(ar->arDev[i], WMI_ERROR_REPORT_EVENTID, (A_UINT8 *)&errEvent, sizeof(WMI_TARGET_ERROR_REPORT_EVENT)); } return; } /* Generate the sequence number for the next challenge */ ar->arHBChallengeResp.seqNum++; ar->arHBChallengeResp.outstanding = TRUE; AR6000_SPIN_UNLOCK(&ar->arLock, 0); /* Send the challenge on the control channel */ if (wmi_get_challenge_resp_cmd(ar->arDev[0]->arWmi, ar->arHBChallengeResp.seqNum, DRV_HB_CHALLENGE) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to send heart beat challenge\n")); } /* Reschedule the timer for the next challenge */ A_TIMEOUT_MS(&ar->arHBChallengeResp.timer, ar->arHBChallengeResp.frequency * 1000, 0); } void ar6000_init_profile_info(AR_SOFTC_DEV_T *arPriv) { A_UINT8 mode = 0; mode = ((fwmode >> (arPriv->arDeviceIndex * HI_OPTION_FW_MODE_BITS)) & (HI_OPTION_FW_MODE_MASK )); switch(mode) { case HI_OPTION_FW_MODE_IBSS: arPriv->arNetworkType = arPriv->arNextMode = ADHOC_NETWORK; break; case HI_OPTION_FW_MODE_BSS_STA: arPriv->arNetworkType = arPriv->arNextMode = INFRA_NETWORK; break; case HI_OPTION_FW_MODE_AP: arPriv->arNetworkType = arPriv->arNextMode = AP_NETWORK; break; case HI_OPTION_FW_MODE_BT30AMP: arPriv->arNetworkType = arPriv->arNextMode = INFRA_NETWORK; arPriv->isBt30amp = TRUE; break; } ar6000_init_mode_info(arPriv); } static int ar6000_init_control_info(AR_SOFTC_DEV_T *arPriv) { AR_SOFTC_T *ar = arPriv->arSoftc; arPriv->arWmiEnabled = FALSE; ar->arVersion.host_ver = AR6K_SW_VERSION; if(!(strcmp(targetconf,"mobile"))) ar->arVersion.targetconf_ver = AR6003_SUBVER_MOBILE; else if(!(strcmp(targetconf,"tablet"))) ar->arVersion.targetconf_ver = AR6003_SUBVER_TABLET; else if(!(strcmp(targetconf,"router"))) ar->arVersion.targetconf_ver = AR6003_SUBVER_ROUTER; else ar->arVersion.targetconf_ver = AR6003_SUBVER_DEFAULT; ar6000_init_profile_info(arPriv); if((arPriv->conn_aggr = aggr_init_conn()) == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s() Failed to initialize aggr.\n", __func__)); return A_ERROR; } return A_OK; } static int ar6000_open(struct net_device *dev) { unsigned long flags; AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); spin_lock_irqsave(&arPriv->arPrivLock, flags); if( arPriv->arConnected || bypasswmi) { netif_carrier_on(dev); /* Wake up the queues */ netif_wake_queue(dev); } else netif_carrier_off(dev); spin_unlock_irqrestore(&arPriv->arPrivLock, flags); return 0; } static int ar6000_close(struct net_device *dev) { netif_stop_queue(dev); return 0; } /* connect to a service */ static A_STATUS ar6000_connectservice(AR_SOFTC_DEV_T *arPriv, HTC_SERVICE_CONNECT_REQ *pConnect, char *pDesc) { A_STATUS status; HTC_SERVICE_CONNECT_RESP response; AR_SOFTC_T *ar = arPriv->arSoftc; do { A_MEMZERO(&response,sizeof(response)); status = HTCConnectService(ar->arHtcTarget, pConnect, &response); if (A_FAILED(status)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" Failed to connect to %s service status:%d \n", pDesc, status)); break; } switch (pConnect->ServiceID) { case WMI_CONTROL_SVC : if(!bypasswmi) { /* set control endpoint for WMI use */ wmi_set_control_ep(arPriv->arWmi, response.Endpoint); /* save EP for fast lookup */ ar->arControlEp = response.Endpoint; } break; case WMI_DATA_BE_SVC : arSetAc2EndpointIDMap(ar, WMM_AC_BE, response.Endpoint); break; case WMI_DATA_BK_SVC : arSetAc2EndpointIDMap(ar, WMM_AC_BK, response.Endpoint); break; case WMI_DATA_VI_SVC : arSetAc2EndpointIDMap(ar, WMM_AC_VI, response.Endpoint); break; case WMI_DATA_VO_SVC : arSetAc2EndpointIDMap(ar, WMM_AC_VO, response.Endpoint); break; default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ServiceID not mapped %d\n", pConnect->ServiceID)); status = A_EINVAL; break; } } while (FALSE); return status; } void ar6000_TxDataCleanup(AR_SOFTC_T *ar) { /* flush all the data (non-control) streams * we only flush packets that are tagged as data, we leave any control packets that * were in the TX queues alone */ HTCFlushEndpoint(ar->arHtcTarget, arAc2EndpointID(ar, WMM_AC_BE), AR6K_DATA_PKT_TAG); HTCFlushEndpoint(ar->arHtcTarget, arAc2EndpointID(ar, WMM_AC_BK), AR6K_DATA_PKT_TAG); HTCFlushEndpoint(ar->arHtcTarget, arAc2EndpointID(ar, WMM_AC_VI), AR6K_DATA_PKT_TAG); HTCFlushEndpoint(ar->arHtcTarget, arAc2EndpointID(ar, WMM_AC_VO), AR6K_DATA_PKT_TAG); } HTC_ENDPOINT_ID ar6000_ac2_endpoint_id ( void * devt, A_UINT8 ac) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *) devt; AR_SOFTC_T *ar = arPriv->arSoftc; return(arAc2EndpointID(ar, ac)); } A_UINT8 ar6000_endpoint_id2_ac(void * devt, HTC_ENDPOINT_ID ep ) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *) devt; AR_SOFTC_T *ar = arPriv->arSoftc; return(arEndpoint2Ac(ar, ep )); } /* This function does one time initialization for the lifetime of the device */ int ar6000_init(struct net_device *dev) { AR_SOFTC_DEV_T *arPriv; AR_SOFTC_T *ar; int ret = 0; int i = 0; int j = 0; A_STATUS status; A_INT32 timeleft; #if defined(INIT_MODE_DRV_ENABLED) && defined(ENABLE_COEXISTENCE) WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD sbcb_cmd; WMI_SET_BTCOEX_FE_ANT_CMD sbfa_cmd; #endif /* INIT_MODE_DRV_ENABLED && ENABLE_COEXISTENCE */ dev_hold(dev); if(ar6k_init) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR6000 Initialised\n")); goto ar6000_init_done; } ar6k_init = TRUE; if((arPriv = ar6k_priv(dev)) == NULL) { ret = -EIO; goto ar6000_init_done; } ar = arPriv->arSoftc; if (wlaninitmode == WLAN_INIT_MODE_USR || wlaninitmode == WLAN_INIT_MODE_DRV) { ar6000_update_bdaddr(ar); } if (enablerssicompensation) { ar6000_copy_cust_data_from_target(ar->arHifDevice, ar->arTargetType); read_rssi_compensation_param(ar); for(j=0; jarDev[j],i); } } } /* Do we need to finish the BMI phase */ if ((wlaninitmode==WLAN_INIT_MODE_USR || wlaninitmode==WLAN_INIT_MODE_DRV) && (BMIDone(ar->arHifDevice) != A_OK)) { ret = -EIO; goto ar6000_init_done; } do { HTC_SERVICE_CONNECT_REQ connect; /* the reason we have to wait for the target here is that the driver layer * has to init BMI in order to set the host block size, */ status = HTCWaitTarget(ar->arHtcTarget); if (A_FAILED(status)) { break; } A_MEMZERO(&connect,sizeof(connect)); /* meta data is unused for now */ connect.pMetaData = NULL; connect.MetaDataLength = 0; /* these fields are the same for all service endpoints */ connect.EpCallbacks.pContext = ar; connect.EpCallbacks.EpTxCompleteMultiple = ar6000_tx_complete; connect.EpCallbacks.EpRecv = ar6000_rx; connect.EpCallbacks.EpRecvRefill = ar6000_rx_refill; connect.EpCallbacks.EpSendFull = ar6000_tx_queue_full; /* set the max queue depth so that our ar6000_tx_queue_full handler gets called. * Linux has the peculiarity of not providing flow control between the * NIC and the network stack. There is no API to indicate that a TX packet * was sent which could provide some back pressure to the network stack. * Under linux you would have to wait till the network stack consumed all sk_buffs * before any back-flow kicked in. Which isn't very friendly. * So we have to manage this ourselves */ connect.MaxSendQueueDepth = MAX_DEFAULT_SEND_QUEUE_DEPTH; connect.EpCallbacks.RecvRefillWaterMark = AR6000_MAX_RX_BUFFERS / 4; /* set to 25 % */ if (0 == connect.EpCallbacks.RecvRefillWaterMark) { connect.EpCallbacks.RecvRefillWaterMark++; } /* connect to control service */ connect.ServiceID = WMI_CONTROL_SVC; status = ar6000_connectservice(arPriv, &connect, "WMI CONTROL"); if (A_FAILED(status)) { break; } connect.LocalConnectionFlags |= HTC_LOCAL_CONN_FLAGS_ENABLE_SEND_BUNDLE_PADDING; /* limit the HTC message size on the send path, although we can receive A-MSDU frames of * 4K, we will only send ethernet-sized (802.3) frames on the send path. */ connect.MaxSendMsgSize = WMI_MAX_TX_DATA_FRAME_LENGTH; /* to reduce the amount of committed memory for larger A_MSDU frames, use the recv-alloc threshold * mechanism for larger packets */ connect.EpCallbacks.RecvAllocThreshold = AR6000_BUFFER_SIZE; connect.EpCallbacks.EpRecvAllocThresh = ar6000_alloc_amsdu_rxbuf; /* for the remaining data services set the connection flag to reduce dribbling, * if configured to do so */ if (reduce_credit_dribble) { connect.ConnectionFlags |= HTC_CONNECT_FLAGS_REDUCE_CREDIT_DRIBBLE; /* the credit dribble trigger threshold is (reduce_credit_dribble - 1) for a value * of 0-3 */ connect.ConnectionFlags &= ~HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_MASK; connect.ConnectionFlags |= ((A_UINT16)reduce_credit_dribble - 1) & HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_MASK; } /* connect to best-effort service */ connect.ServiceID = WMI_DATA_BE_SVC; status = ar6000_connectservice(arPriv, &connect, "WMI DATA BE"); if (A_FAILED(status)) { break; } /* connect to back-ground * map this to WMI LOW_PRI */ connect.ServiceID = WMI_DATA_BK_SVC; status = ar6000_connectservice(arPriv, &connect, "WMI DATA BK"); if (A_FAILED(status)) { break; } /* connect to Video service, map this to * to HI PRI */ connect.ServiceID = WMI_DATA_VI_SVC; status = ar6000_connectservice(arPriv, &connect, "WMI DATA VI"); if (A_FAILED(status)) { break; } /* connect to VO service, this is currently not * mapped to a WMI priority stream due to historical reasons. * WMI originally defined 3 priorities over 3 mailboxes * We can change this when WMI is reworked so that priorities are not * dependent on mailboxes */ connect.ServiceID = WMI_DATA_VO_SVC; status = ar6000_connectservice(arPriv, &connect, "WMI DATA VO"); if (A_FAILED(status)) { break; } A_ASSERT(arAc2EndpointID(ar,WMM_AC_BE) != 0); A_ASSERT(arAc2EndpointID(ar,WMM_AC_BK) != 0); A_ASSERT(arAc2EndpointID(ar,WMM_AC_VI) != 0); A_ASSERT(arAc2EndpointID(ar,WMM_AC_VO) != 0); /* setup access class priority mappings */ ar->arAcStreamPriMap[WMM_AC_BK] = 0; /* lowest */ ar->arAcStreamPriMap[WMM_AC_BE] = 1; /* */ ar->arAcStreamPriMap[WMM_AC_VI] = 2; /* */ ar->arAcStreamPriMap[WMM_AC_VO] = 3; /* highest */ #ifdef EXPORT_HCI_BRIDGE_INTERFACE if (setuphci && (NULL != ar6kHciTransCallbacks.setupTransport)) { HCI_TRANSPORT_MISC_HANDLES hciHandles; hciHandles.netDevice = ar->arNetDev; hciHandles.hifDevice = ar->arHifDevice; hciHandles.htcHandle = ar->arHtcTarget; status = (A_STATUS)(ar6kHciTransCallbacks.setupTransport(&hciHandles)); } #else if (setuphci) { /* setup HCI */ status = ar6000_setup_hci(ar); } #endif } while (FALSE); if (A_FAILED(status)) { ret = -EIO; goto ar6000_init_done; } /* * give our connected endpoints some buffers */ ar6000_rx_refill(ar, ar->arControlEp); ar6000_rx_refill(ar, arAc2EndpointID(ar,WMM_AC_BE)); /* * We will post the receive buffers only for SPE or endpoint ping testing so we are * making it conditional on the 'bypasswmi' flag. */ if (bypasswmi) { ar6000_rx_refill(ar,arAc2EndpointID(ar,WMM_AC_BK)); ar6000_rx_refill(ar,arAc2EndpointID(ar,WMM_AC_VI)); ar6000_rx_refill(ar,arAc2EndpointID(ar,WMM_AC_VO)); } /* allocate some buffers that handle larger AMSDU frames */ ar6000_refill_amsdu_rxbufs(ar,AR6000_MAX_AMSDU_RX_BUFFERS); /* setup credit distribution */ ar6000_setup_credit_dist(ar->arHtcTarget, &ar->arCreditStateInfo); /* Since cookies are used for HTC transports, they should be */ /* initialized prior to enabling HTC. */ ar6000_cookie_init(ar); /* Initialize the control cookie counter to 0 */ ar->arControlCookieCount = 0; /* start HTC */ status = HTCStart(ar->arHtcTarget); if (status != A_OK) { for(i = 0; i < num_device; i++) { if (ar->arDev[i]->arWmiEnabled == TRUE) { wmi_shutdown(ar->arDev[i]->arWmi); ar->arDev[i]->arWmiEnabled = FALSE; ar->arDev[i]->arWmi = NULL; } } ar6000_cookie_cleanup(ar); ret = -EIO; goto ar6000_init_done; } if (!bypasswmi) { /* Wait for Wmi event to be ready */ timeleft = wait_event_interruptible_timeout(ar->arDev[0]->arEvent, (ar->arWmiReady == TRUE), wmitimeout * HZ); if (ar->arVersion.abi_ver != AR6K_ABI_VERSION) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ABI Version mismatch: Host(0x%x), Target(0x%x)\n", AR6K_ABI_VERSION, ar->arVersion.abi_ver)); #ifndef ATH6KL_SKIP_ABI_VERSION_CHECK ret = -EIO; goto ar6000_init_done; #endif /* ATH6KL_SKIP_ABI_VERSION_CHECK */ } if(!timeleft || signal_pending(current)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI is not ready or wait was interrupted\n")); ret = -EIO; goto ar6000_init_done; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s() WMI is ready\n", __func__)); /* init PAL driver after WMI is ready */ if(setuphcipal) { A_BOOL bt30ampDevFound = FALSE; for (i=0; i < num_device; i++) { if ( ar->arDev[i]->isBt30amp == TRUE ) { status = ar6k_setup_hci_pal(ar->arDev[i]); bt30ampDevFound = TRUE; } } } /* Communicate the wmi protocol verision to the target */ if ((ar6000_set_host_app_area(ar)) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set the host app area\n")); } /* configure the device for rx dot11 header rules 0,0 are the default values * therefore this command can be skipped if the inputs are 0,FALSE,FALSE.Required if checksum offload is needed. Set RxMetaVersion to 2*/ if ((wmi_set_rx_frame_format_cmd(arPriv->arWmi,ar->rxMetaVersion, processDot11Hdr, processDot11Hdr)) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set the rx frame format.\n")); } #if defined(INIT_MODE_DRV_ENABLED) && defined(ENABLE_COEXISTENCE) /* Configure the type of BT collocated with WLAN */ A_MEMZERO(&sbcb_cmd, sizeof(WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD)); #ifdef CONFIG_AR600x_BT_QCOM sbcb_cmd.btcoexCoLocatedBTdev = 1; #elif defined(CONFIG_AR600x_BT_CSR) sbcb_cmd.btcoexCoLocatedBTdev = 2; #elif defined(CONFIG_AR600x_BT_AR3001) sbcb_cmd.btcoexCoLocatedBTdev = 3; #else #error Unsupported Bluetooth Type #endif /* Collocated Bluetooth Type */ if ((wmi_set_btcoex_colocated_bt_dev_cmd(arPriv->arWmi, &sbcb_cmd)) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set collocated BT type\n")); } /* Configure the type of BT collocated with WLAN */ A_MEMZERO(&sbfa_cmd, sizeof(WMI_SET_BTCOEX_FE_ANT_CMD)); #ifdef CONFIG_AR600x_DUAL_ANTENNA sbfa_cmd.btcoexFeAntType = 2; #elif defined(CONFIG_AR600x_SINGLE_ANTENNA) sbfa_cmd.btcoexFeAntType = 1; #else #error Unsupported Front-End Antenna Configuration #endif /* AR600x Front-End Antenna Configuration */ if ((wmi_set_btcoex_fe_ant_cmd(arPriv->arWmi, &sbfa_cmd)) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set fornt end antenna configuration\n")); } #endif /* INIT_MODE_DRV_ENABLED && ENABLE_COEXISTENCE */ } ar->arNumDataEndPts = 1; if (bypasswmi) { /* for tests like endpoint ping, the MAC address needs to be non-zero otherwise * the data path through a raw socket is disabled */ dev->dev_addr[0] = 0x00; dev->dev_addr[1] = 0x01; dev->dev_addr[2] = 0x02; dev->dev_addr[3] = 0xAA; dev->dev_addr[4] = 0xBB; dev->dev_addr[5] = 0xCC; } ar6000_init_done: dev_put(dev); return ret; } void ar6000_bitrate_rx(void *devt, A_INT32 rateKbps) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; arPriv->arBitRate = rateKbps; wake_up(&arPriv->arEvent); } void ar6000_ratemask_rx(void *devt, A_UINT32 *ratemask) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; arPriv->arRateMask[0] = ratemask[0]; arPriv->arRateMask[1] = ratemask[1]; wake_up(&arPriv->arEvent); } void ar6000_txPwr_rx(void *devt, A_UINT8 txPwr) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; arPriv->arTxPwr = txPwr; wake_up(&arPriv->arEvent); } void ar6000_channelList_rx(void *devt, A_INT8 numChan, A_UINT16 *chanList) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; A_MEMCPY(arPriv->arSta.arChannelList, chanList, numChan * sizeof (A_UINT16)); arPriv->arSta.arNumChannels = numChan; wake_up(&arPriv->arEvent); } A_UINT8 ar6000_ibss_map_epid(struct sk_buff *skb, struct net_device *dev, A_UINT32 * mapNo) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); AR_SOFTC_STA_T *arSta = &arPriv->arSta; AR_SOFTC_T *ar = arPriv->arSoftc; A_UINT8 *datap; ATH_MAC_HDR *macHdr; A_UINT32 i, eptMap; (*mapNo) = 0; datap = A_NETBUF_DATA(skb); macHdr = (ATH_MAC_HDR *)(datap + sizeof(WMI_DATA_HDR)); if (IEEE80211_IS_MULTICAST(macHdr->dstMac)) { return ENDPOINT_2; } eptMap = -1; for (i = 0; i < arSta->arNodeNum; i ++) { if (IEEE80211_ADDR_EQ(macHdr->dstMac, arSta->arNodeMap[i].macAddress)) { (*mapNo) = i + 1; arSta->arNodeMap[i].txPending ++; return arSta->arNodeMap[i].epId; } if ((eptMap == -1) && !arSta->arNodeMap[i].txPending) { eptMap = i; } } if (eptMap == -1) { eptMap = arSta->arNodeNum; arSta->arNodeNum ++; A_ASSERT(arSta->arNodeNum <= MAX_NODE_NUM); } A_MEMCPY(arSta->arNodeMap[eptMap].macAddress, macHdr->dstMac, IEEE80211_ADDR_LEN); for (i = ENDPOINT_2; i <= ENDPOINT_5; i ++) { if (!ar->arTxPending[i]) { arSta->arNodeMap[eptMap].epId = i; break; } // No free endpoint is available, start redistribution on the inuse endpoints. if (i == ENDPOINT_5) { arSta->arNodeMap[eptMap].epId = arSta->arNexEpId; arSta->arNexEpId ++; if (arSta->arNexEpId > ENDPOINT_5) { arSta->arNexEpId = ENDPOINT_2; } } } (*mapNo) = eptMap + 1; arSta->arNodeMap[eptMap].txPending ++; return arSta->arNodeMap[eptMap].epId; } #ifdef DEBUG static void ar6000_dump_skb(struct sk_buff *skb) { u_char *ch; for (ch = A_NETBUF_DATA(skb); (A_UINT32)ch < ((A_UINT32)A_NETBUF_DATA(skb) + A_NETBUF_LEN(skb)); ch++) { AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("%2.2x ", *ch)); } AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("\n")); } #endif #ifdef HTC_TEST_SEND_PKTS static void DoHTCSendPktsTest(AR_SOFTC_T *ar, int MapNo, HTC_ENDPOINT_ID eid, struct sk_buff *skb); #endif static int ar6000_data_tx(struct sk_buff *skb, struct net_device *dev) { #define AC_NOT_MAPPED 99 AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); AR_SOFTC_T *ar = arPriv->arSoftc; AR_SOFTC_STA_T *arSta = &arPriv->arSta; AR_SOFTC_AP_T *arAp = &arPriv->arAp; A_UINT8 ac = AC_NOT_MAPPED; HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED; A_UINT32 mapNo = 0; int len; struct ar_cookie *cookie; A_BOOL checkAdHocPsMapping = FALSE; HTC_TX_TAG htc_tag = AR6K_DATA_PKT_TAG; A_UINT8 dot11Hdr = processDot11Hdr; conn_t *conn = NULL; A_UINT32 wmiDataFlags = 0; #ifdef AR6K_ALLOC_DEBUG A_NETBUF_CHECK(skb); #endif #ifdef CONFIG_PM if ((ar->arWowState != WLAN_WOW_STATE_NONE) || (ar->arWlanState == WLAN_DISABLED)) { A_NETBUF_FREE(skb); return 0; } #endif /* CONFIG_PM */ #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13) skb->list = NULL; #endif AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("ar6000_data_tx start - skb=0x%x, data=0x%x, len=0x%x\n", (A_UINT32)skb, (A_UINT32)A_NETBUF_DATA(skb), A_NETBUF_LEN(skb))); /* Kernel panic occurs in bridge driver (brX) when the wlan interface(wlanX) and usb interface(rndisX) are bridged. This is due to multicast/broadcast skb are forwarded to both the interfaces (wlan0,rndis0) from bridge module and later skb->data got modified by the AR driver. Since the USB driver is using the same skb->data portion for its transmission eventually creating the issue. Use skb_unshare for creating seperate skb for the wlanX. */ skb = skb_unshare(skb, GFP_ATOMIC); if (skb == NULL){ AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx skb cannot be shared \n")); return 0; } /* If target is not associated */ if( (!arPriv->arConnected && !bypasswmi) #ifdef CONFIG_HOST_TCMD_SUPPORT /* TCMD doesnt support any data, free the buf and return */ || (ar->arTargetMode == AR6000_TCMD_MODE) #endif ) { A_NETBUF_FREE(skb); return 0; } do { if (ar->arWmiReady == FALSE && bypasswmi == 0) { break; } #ifdef BLOCK_TX_PATH_FLAG if (blocktx) { break; } #endif /* BLOCK_TX_PATH_FLAG */ /* AP mode Power save processing */ /* If the dst STA is in sleep state, queue the pkt in its PS queue */ if (arPriv->arNetworkType == AP_NETWORK) { ATH_MAC_HDR *datap = (ATH_MAC_HDR *)A_NETBUF_DATA(skb); struct sk_buff *skb_to_drop = NULL; /* If the dstMac is a Multicast address & atleast one of the * associated STA is in PS mode, then queue the pkt to the * mcastq */ if (IEEE80211_IS_MULTICAST(datap->dstMac)) { A_UINT8 ctr=0; A_BOOL qMcast=FALSE; for (ctr=0; ctrconnTbl[ctr].arPriv == arPriv) { if (STA_IS_PWR_SLEEP((&ar->connTbl[ctr]))) { qMcast = TRUE; } } } if(qMcast) { /* If this transmit is not because of a Dtim Expiry q it */ if (arAp->DTIMExpired == FALSE) { A_BOOL isMcastqEmpty = FALSE; A_MUTEX_LOCK(&arAp->mcastpsqLock); /* Check for queue depth, if overflowing then dequeue a * packet so that there is room for new one */ if (max_psq_depth != 0 && A_NETBUF_QUEUE_SIZE(&arAp->mcastpsq) >= max_psq_depth) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("TX Mcast PS queue is full, Depth:%d, Max:%d \n", A_NETBUF_QUEUE_SIZE(&arAp->mcastpsq), max_psq_depth)); skb_to_drop = A_NETBUF_DEQUEUE(&arAp->mcastpsq); } isMcastqEmpty = A_NETBUF_QUEUE_EMPTY(&arAp->mcastpsq); A_NETBUF_ENQUEUE(&arAp->mcastpsq, skb); A_MUTEX_UNLOCK(&arAp->mcastpsqLock); /* Free the SKB outside the lock */ if (skb_to_drop != NULL) { A_NETBUF_FREE(skb_to_drop); AR6000_STAT_INC(arPriv, tx_dropped); AR6000_STAT_INC(arPriv, tx_aborted_errors); } /* If this is the first Mcast pkt getting queued * indicate to the target to set the BitmapControl LSB * of the TIM IE. */ if (isMcastqEmpty) { wmi_set_pvb_cmd(arPriv->arWmi, MCAST_AID, 1); } return 0; } else { /* This transmit is because of Dtim expiry. Determine if * MoreData bit has to be set. */ A_MUTEX_LOCK(&arAp->mcastpsqLock); if(!A_NETBUF_QUEUE_EMPTY(&arAp->mcastpsq)) { wmiDataFlags |= WMI_DATA_HDR_FLAGS_MORE; } A_MUTEX_UNLOCK(&arAp->mcastpsqLock); } } } else { conn = ieee80211_find_conn(arPriv, datap->dstMac); if (conn) { if (STA_IS_PWR_SLEEP(conn)) { /* If this transmit is not because of a PsPoll q it*/ if (!(STA_IS_PS_POLLED(conn) || STA_IS_APSD_TRIGGER(conn))) { A_BOOL trigger = FALSE; A_UINT32 cur_psq_len = 0; if (conn->apsd_info) { A_UINT8 up = 0; A_UINT8 trafficClass; if (arPriv->arWmmEnabled) { A_UINT16 ipType = IP_ETHERTYPE; A_UINT16 etherType; A_UINT8 *ipHdr; etherType = datap->typeOrLen; if (IS_ETHERTYPE(A_BE2CPU16(etherType))) { /* packet is in DIX format */ ipHdr = (A_UINT8 *)(datap + 1); } else { /* packet is in 802.3 format */ ATH_LLC_SNAP_HDR *llcHdr; llcHdr = (ATH_LLC_SNAP_HDR *)(datap + 1); etherType = llcHdr->etherType; ipHdr = (A_UINT8 *)(llcHdr + 1); } if (etherType == A_CPU2BE16(ipType)) { up = wmi_determine_userPriority (ipHdr, 0); } } trafficClass = convert_userPriority_to_trafficClass(up); if (conn->apsd_info & (1 << trafficClass)) { trigger = TRUE; } } if (trigger) { A_BOOL isApsdqEmpty; /* Queue the frames if the STA is sleeping */ A_MUTEX_LOCK(&conn->psqLock); /* If max_psq_depth is 0 then no limit to queue size */ if (max_psq_depth != 0) { /* APSD queue depth + PS queue depth should * not be more than MAX PS queue depth */ cur_psq_len = A_NETBUF_QUEUE_SIZE(&conn->apsdq) + A_NETBUF_QUEUE_SIZE(&conn->psq); /* Check for queue depth, if overflowing then * dequeue a packet so that there is room for * new one */ if (cur_psq_len >= max_psq_depth) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("TX STA PS(APSD) queue is full, Depth:%d, Max:%d \n", cur_psq_len, max_psq_depth)); skb_to_drop = A_NETBUF_DEQUEUE(&conn->apsdq); } } isApsdqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->apsdq); A_NETBUF_ENQUEUE(&conn->apsdq, skb); A_MUTEX_UNLOCK(&conn->psqLock); /* Free the SKB outside the lock */ if (skb_to_drop != NULL) { A_NETBUF_FREE(skb_to_drop); AR6000_STAT_INC(arPriv, tx_dropped); AR6000_STAT_INC(arPriv, tx_aborted_errors); } /* If this is the first pkt getting queued * for this STA, update the PVB for this STA */ if (isApsdqEmpty) { wmi_set_apsd_buffered_traffic_cmd(arPriv->arWmi, conn->aid, 1, 0); } } else { A_BOOL isPsqEmpty = FALSE; /* Queue the frames if the STA is sleeping */ A_MUTEX_LOCK(&conn->psqLock); /* If max_psq_depth is 0 then no limit to queue size */ if (max_psq_depth != 0) { /* APSD queue depth + PS queue depth should * not be more than MAX PS queue depth */ cur_psq_len = A_NETBUF_QUEUE_SIZE(&conn->apsdq) + A_NETBUF_QUEUE_SIZE(&conn->psq); /* Check for queue depth, if overflowing then * dequeue a packet so that there is room for * new one */ if (cur_psq_len >= max_psq_depth) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("TX STA PS queue is full, Depth:%d, Max:%d \n", cur_psq_len, max_psq_depth)); skb_to_drop = A_NETBUF_DEQUEUE(&conn->psq); } } /* Free the SKB outside the lock */ if (skb_to_drop != NULL) { A_NETBUF_FREE(skb_to_drop); AR6000_STAT_INC(arPriv, tx_dropped); AR6000_STAT_INC(arPriv, tx_aborted_errors); } isPsqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->psq); A_NETBUF_ENQUEUE(&conn->psq, skb); A_MUTEX_UNLOCK(&conn->psqLock); /* If this is the first pkt getting queued * for this STA, update the PVB for this STA */ if (isPsqEmpty) { wmi_set_pvb_cmd(arPriv->arWmi, conn->aid, 1); } } return 0; } else { /* * This tx is because of a PsPoll or trigger. Determine if * MoreData bit has to be set */ A_MUTEX_LOCK(&conn->psqLock); if (STA_IS_PS_POLLED(conn)) { if (!A_NETBUF_QUEUE_EMPTY(&conn->psq)) { wmiDataFlags |= WMI_DATA_HDR_FLAGS_MORE; } } else { /* * This tx is because of a uAPSD trigger, determine * more and EOSP bit. Set EOSP is queue is empty * or sufficient frames is delivered for this trigger */ if (!A_NETBUF_QUEUE_EMPTY(&conn->apsdq)) { wmiDataFlags |= WMI_DATA_HDR_FLAGS_MORE; } if (STA_IS_APSD_EOSP(conn)) { wmiDataFlags |= WMI_DATA_HDR_FLAGS_EOSP; } } A_MUTEX_UNLOCK(&conn->psqLock); } } } else { /* non existent STA. drop the frame */ A_NETBUF_FREE(skb); return 0; } } } if (arPriv->arWmiEnabled) { #ifdef CONFIG_CHECKSUM_OFFLOAD A_UINT8 csumStart=0; A_UINT8 csumDest=0; A_UINT8 csum=skb->ip_summed; if(csumOffload && (csum==CHECKSUM_PARTIAL)){ csumStart=skb->csum_start-(skb->network_header-skb->head)+sizeof(ATH_LLC_SNAP_HDR); csumDest=skb->csum_offset+csumStart; } #endif if (A_NETBUF_HEADROOM(skb) < dev->hard_header_len - LINUX_HACK_FUDGE_FACTOR) { struct sk_buff *newbuf; /* * We really should have gotten enough headroom but sometimes * we still get packets with not enough headroom. Copy the packet. */ len = A_NETBUF_LEN(skb); newbuf = A_NETBUF_ALLOC(len); if (newbuf == NULL) { break; } A_NETBUF_PUT(newbuf, len); A_MEMCPY(A_NETBUF_DATA(newbuf), A_NETBUF_DATA(skb), len); A_NETBUF_FREE(skb); skb = newbuf; /* fall through and assemble header */ } if (dot11Hdr) { if (wmi_dot11_hdr_add(arPriv->arWmi,skb,arPriv->arNetworkType) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx-wmi_dot11_hdr_add failed\n")); break; } } else { if (wmi_dix_2_dot3(arPriv->arWmi, skb) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx - wmi_dix_2_dot3 failed\n")); break; } } #ifdef CONFIG_CHECKSUM_OFFLOAD if(csumOffload && (csum ==CHECKSUM_PARTIAL)){ WMI_TX_META_V2 metaV2; metaV2.csumStart =csumStart; metaV2.csumDest = csumDest; metaV2.csumFlags = 0x1;/*instruct target to calculate checksum*/ if (wmi_data_hdr_add(arPriv->arWmi, skb, DATA_MSGTYPE, wmiDataFlags, dot11Hdr, WMI_META_VERSION_2,&metaV2) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx - wmi_data_hdr_add failed\n")); break; } } else #endif { if (wmi_data_hdr_add(arPriv->arWmi, skb, DATA_MSGTYPE, wmiDataFlags, dot11Hdr,0,NULL) != A_OK) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx - wmi_data_hdr_add failed\n")); break; } } if ((arPriv->arNetworkType == ADHOC_NETWORK) && arSta->arIbssPsEnable && arPriv->arConnected) { /* flag to check adhoc mapping once we take the lock below: */ checkAdHocPsMapping = TRUE; } else { A_UINT32 layer2Priority = 0; /* 256->263 are magic values in Linux for passing directly * 802.1d priority from VLAN tags, etc */ if (skb->priority >= 256 && skb->priority <= 263) { layer2Priority = skb->priority - 256; } /* get the stream mapping */ ac = wmi_implicit_create_pstream(arPriv->arWmi, skb, layer2Priority, arPriv->arWmmEnabled); } } else { EPPING_HEADER *eppingHdr; eppingHdr = A_NETBUF_DATA(skb); if (IS_EPPING_PACKET(eppingHdr)) { /* the stream ID is mapped to an access class */ ac = eppingHdr->StreamNo_h; /* some EPPING packets cannot be dropped no matter what access class it was * sent on. We can change the packet tag to guarantee it will not get dropped */ if (IS_EPING_PACKET_NO_DROP(eppingHdr)) { htc_tag = AR6K_CONTROL_PKT_TAG; } if (ac == HCI_TRANSPORT_STREAM_NUM) { /* pass this to HCI */ #ifndef EXPORT_HCI_BRIDGE_INTERFACE if (A_SUCCESS(hci_test_send(ar,skb))) { return 0; } #endif /* set AC to discard this skb */ ac = AC_NOT_MAPPED; } else { /* a quirk of linux, the payload of the frame is 32-bit aligned and thus the addition * of the HTC header will mis-align the start of the HTC frame, so we add some * padding which will be stripped off in the target */ if (EPPING_ALIGNMENT_PAD > 0) { A_NETBUF_PUSH(skb, EPPING_ALIGNMENT_PAD); } } } else { /* not a ping packet, drop it */ ac = AC_NOT_MAPPED; } } } while (FALSE); /* did we succeed ? */ if ((ac == AC_NOT_MAPPED) && !checkAdHocPsMapping) { /* cleanup and exit */ A_NETBUF_FREE(skb); AR6000_STAT_INC(arPriv, tx_dropped); AR6000_STAT_INC(arPriv, tx_aborted_errors); return 0; } cookie = NULL; /* take the lock to protect driver data */ AR6000_SPIN_LOCK(&ar->arLock, 0); do { if (checkAdHocPsMapping) { eid = ar6000_ibss_map_epid(skb, dev, &mapNo); }else { if (ac >= WMM_NUM_AC) break; eid = arAc2EndpointID (ar, ac); if (eid < 0 || eid >= ENDPOINT_MAX) break; } /* validate that the endpoint is connected */ if (eid == 0 || eid == ENDPOINT_UNUSED ) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" eid %d is NOT mapped!\n", eid)); break; } /* allocate resource for this packet */ cookie = ar6000_alloc_cookie(ar); if (cookie != NULL) { /* update counts while the lock is held */ ar->arTxPending[eid]++; ar->arTotalTxDataPending++; if (htc_tag == AR6K_CONTROL_PKT_TAG) { /* This cookie allocated for a control packet, update count */ ar->arControlCookieCount++; } } } while (FALSE); AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (cookie != NULL) { cookie->arc_bp[0] = (A_UINT32)skb; cookie->arc_bp[1] = mapNo; SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt, cookie, A_NETBUF_DATA(skb), A_NETBUF_LEN(skb), eid, htc_tag); #ifdef DEBUG if (debugdriver >= 3) { ar6000_dump_skb(skb); } #endif #ifdef HTC_TEST_SEND_PKTS DoHTCSendPktsTest(ar,mapNo,eid,skb); #endif /* HTC interface is asynchronous, if this fails, cleanup will happen in * the ar6000_tx_complete callback */ HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt); } else { /* no packet to send, cleanup */ A_NETBUF_FREE(skb); AR6000_STAT_INC(arPriv, tx_dropped); AR6000_STAT_INC(arPriv, tx_aborted_errors); } return 0; } int ar6000_acl_data_tx(struct sk_buff *skb, AR_SOFTC_DEV_T *arPriv) { struct ar_cookie *cookie; AR_SOFTC_T *ar = arPriv->arSoftc; HTC_ENDPOINT_ID eid = ENDPOINT_UNUSED; cookie = NULL; AR6000_SPIN_LOCK(&ar->arLock, 0); /* For now we send ACL on BE endpoint: We can also have a dedicated EP */ eid = arAc2EndpointID (ar, 0); if (eid < 0) { AR6000_SPIN_UNLOCK(&ar->arLock, 0); A_NETBUF_FREE(skb); return -1; } /* allocate resource for this packet */ cookie = ar6000_alloc_cookie(ar); if (cookie != NULL) { /* update counts while the lock is held */ ar->arTxPending[eid]++; ar->arTotalTxDataPending++; } AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (cookie != NULL) { cookie->arc_bp[0] = (A_UINT32)skb; cookie->arc_bp[1] = 0; SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt, cookie, A_NETBUF_DATA(skb), A_NETBUF_LEN(skb), eid, AR6K_DATA_PKT_TAG); /* HTC interface is asynchronous, if this fails, cleanup will happen in * the ar6000_tx_complete callback */ HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt); } else { /* no packet to send, cleanup */ A_NETBUF_FREE(skb); AR6000_STAT_INC(arPriv, tx_dropped); AR6000_STAT_INC(arPriv, tx_aborted_errors); } return 0; } #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL static void tvsub(register struct timeval *out, register struct timeval *in) { if((out->tv_usec -= in->tv_usec) < 0) { out->tv_sec--; out->tv_usec += 1000000; } out->tv_sec -= in->tv_sec; } void applyAPTCHeuristics(AR_SOFTC_DEV_T *arPriv) { A_UINT32 duration; A_UINT32 numbytes; A_UINT32 throughput; struct timeval ts; A_STATUS status; APTC_TRAFFIC_RECORD *aptcTR; AR_SOFTC_T *ar = arPriv->arSoftc; aptcTR = arPriv->aptcTR; AR6000_SPIN_LOCK(&arPriv->arPrivLock, 0); if ((enableAPTCHeuristics) && (!aptcTR->timerScheduled)) { do_gettimeofday(&ts); tvsub(&ts, &aptcTR->samplingTS); duration = ts.tv_sec * 1000 + ts.tv_usec / 1000; /* ms */ numbytes = aptcTR->bytesTransmitted + aptcTR->bytesReceived; if (duration > APTC_TRAFFIC_SAMPLING_INTERVAL) { /* Initialize the time stamp and byte count */ aptcTR->bytesTransmitted = aptcTR->bytesReceived = 0; do_gettimeofday(&aptcTR->samplingTS); /* Calculate and decide based on throughput thresholds */ throughput = ((numbytes * 8) / duration); if (throughput > APTC_UPPER_THROUGHPUT_THRESHOLD) { /* Disable Sleep and schedule a timer */ A_ASSERT(ar->arWmiReady == TRUE); AR6000_SPIN_UNLOCK(&arPriv->ariPrivLock, 0); status = wmi_powermode_cmd(arPriv->arWmi, MAX_PERF_POWER); AR6000_SPIN_LOCK(&arPriv->arPrivLock, 0); A_TIMEOUT_MS(&aptcTimer[arPriv->arDeviceIndex], APTC_TRAFFIC_SAMPLING_INTERVAL, 0); aptcTR->timerScheduled = TRUE; } } } AR6000_SPIN_UNLOCK(&arPriv->arLock, 0); } #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, HTC_PACKET *pPacket) { AR_SOFTC_T *ar = (AR_SOFTC_T *)Context; HTC_SEND_FULL_ACTION action = HTC_SEND_FULL_KEEP; A_BOOL stopNet = FALSE; HTC_ENDPOINT_ID Endpoint = HTC_GET_ENDPOINT_FROM_PKT(pPacket); A_UINT8 i; AR_SOFTC_DEV_T *arPriv; A_UINT32 controlCookieThreshold, highPriorityCookieThreshold; do { if (bypasswmi) { int accessClass; if (HTC_GET_TAG_FROM_PKT(pPacket) == AR6K_CONTROL_PKT_TAG) { /* don't drop special control packets */ break; } accessClass = arEndpoint2Ac(ar,Endpoint); /* for endpoint ping testing drop Best Effort and Background */ if ((accessClass == WMM_AC_BE) || (accessClass == WMM_AC_BK)) { action = HTC_SEND_FULL_DROP; stopNet = FALSE; } else { /* keep but stop the netqueues */ stopNet = TRUE; } break; } if (Endpoint == ar->arControlEp) { /* under normal WMI if this is getting full, then something is running rampant * the host should not be exhausting the WMI queue with too many commands * the only exception to this is during testing using endpointping */ AR6000_SPIN_LOCK(&ar->arLock, 0); /* set flag to handle subsequent messages */ ar->arWMIControlEpFull = TRUE; AR6000_SPIN_UNLOCK(&ar->arLock, 0); AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI Control Endpoint is FULL!!! \n")); /* no need to stop the network */ stopNet = FALSE; break; } /* if we get here, we are dealing with data endpoints getting full */ AR6000_SPIN_LOCK(&ar->arLock, 0); controlCookieThreshold = MAX_CONTROL_COOKIE_NUM - ar->arControlCookieCount; highPriorityCookieThreshold = controlCookieThreshold + MAX_HIGH_PRIORITY_COOKIE_NUM; if (ar->arCookieCount <= controlCookieThreshold) { /* the last few cookies are reserved exclusively for sending * control messages on the 4 data endpoints and the control endpoint. Each of * the 4 data endpoints could need up to 2 sync messages (if we are using * SYNC_BOTH_WMIFLAG) so we need to reserve 11 cookies (2*WMM_NUM_AC=2*4=8) * for the data endpoints and 3 for the control endpoint (one WMI_ADD_CIPHER_CMDID * command and two WMI_SYNCHRONIZE_CMDID commands). This is why we MUST reserve * some cookies for control messages; SYNC messages are important and dropping * these would effectively make the WiFi connection useless because the AP would be * using a different encryption key. So, we reserve 11 cookies for sending SYNC * messages, plus one additional (just in case someone happens to issue a wmi command * during the rekey process) */ AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (HTC_GET_TAG_FROM_PKT(pPacket) == AR6K_CONTROL_PKT_TAG) { /* don't drop control packets issued on ANY data endpoint */ break; } else { /* If cookie count is below controlCookieThreshold and this is NOT a control * message, stop it from being sent. */ action = HTC_SEND_FULL_DROP; stopNet = FALSE; break; } } /* the last highPriorityCookieThreshold "batch" of cookies (except for the last * controlCookieThreshold cookies which are captured by the statement above) * are reserved for the highest priority active stream */ if (ar->arAcStreamPriMap[arEndpoint2Ac(ar,Endpoint)] < ar->arHiAcStreamActivePri && ar->arCookieCount <= highPriorityCookieThreshold) { AR6000_SPIN_UNLOCK(&ar->arLock, 0); /* this stream's priority is less than the highest active priority, we * give preference to the highest priority stream by directing * HTC to drop the packet that overflowed */ action = HTC_SEND_FULL_DROP; /* since we are dropping packets, no need to stop the network */ stopNet = FALSE; break; } AR6000_SPIN_UNLOCK(&ar->arLock, 0); } while (FALSE); if (stopNet) { for(i = 0; i < num_device; i++) { arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[i]); AR6000_SPIN_LOCK(&arPriv->arPrivLock, 0); arPriv->arNetQueueStopped = TRUE; AR6000_SPIN_UNLOCK(&arPriv->arPrivLock, 0); /* one of the data endpoints queues is getting full..need to stop network stack * the queue will resume in ar6000_tx_complete() */ netif_stop_queue(ar6000_devices[i]); } } else { /* in adhoc mode, we cannot differentiate traffic priorities so there is no need to * continue, however we should stop the network */ for(i = 0; i < num_device; i++) { arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[i]); if(arPriv->arNetworkType == ADHOC_NETWORK) { AR6000_SPIN_LOCK(&arPriv->arPrivLock, 0); arPriv->arNetQueueStopped = TRUE; AR6000_SPIN_UNLOCK(&arPriv->arPrivLock, 0); /* one of the data endpoints queues is getting full..need to stop network stack * the queue will resume in ar6000_tx_complete() */ netif_stop_queue(ar6000_devices[i]); } } } return action; } static void ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPacketQueue) { AR_SOFTC_T *ar = (AR_SOFTC_T *)Context; A_UINT32 mapNo = 0; A_STATUS status; struct ar_cookie * ar_cookie; HTC_ENDPOINT_ID eid; A_BOOL wakeEvent = FALSE; struct sk_buff_head skb_queue; HTC_PACKET *pPacket; struct sk_buff *pktSkb; A_BOOL flushing[NUM_DEV]; A_INT8 devid = -1; AR_SOFTC_DEV_T *arPriv = NULL; AR_SOFTC_STA_T *arSta; A_UINT8 i; skb_queue_head_init(&skb_queue); /* lock the driver as we update internal state */ AR6000_SPIN_LOCK(&ar->arLock, 0); /* reap completed packets */ while (!HTC_QUEUE_EMPTY(pPacketQueue)) { if ((pPacket = HTC_PACKET_DEQUEUE(pPacketQueue)) == NULL) return; ar_cookie = (struct ar_cookie *)pPacket->pPktContext; A_ASSERT(ar_cookie); status = pPacket->Status; pktSkb = (struct sk_buff *)ar_cookie->arc_bp[0]; eid = pPacket->Endpoint; if (eid < 0) return; mapNo = ar_cookie->arc_bp[1]; if(pktSkb == NULL || pPacket->pBuffer != A_NETBUF_DATA(pktSkb)) { AR6000_SPIN_UNLOCK(&ar->arLock, 0); return; } A_ASSERT(pktSkb); A_ASSERT(pPacket->pBuffer == A_NETBUF_DATA(pktSkb)); /* add this to the list, use faster non-lock API */ __skb_queue_tail(&skb_queue,pktSkb); if (A_SUCCESS(status)) { A_ASSERT(pPacket->ActualLength == A_NETBUF_LEN(pktSkb)); } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("ar6000_tx_complete skb=0x%x data=0x%x len=0x%x eid=%d ", (A_UINT32)pktSkb, (A_UINT32)pPacket->pBuffer, pPacket->ActualLength, eid)); ar->arTxPending[eid]--; if(!bypasswmi) { if (eid != ar->arControlEp) { WMI_DATA_HDR *dhdr = (WMI_DATA_HDR *)A_NETBUF_DATA(pktSkb); ar->arTotalTxDataPending--; devid = WMI_DATA_HDR_GET_DEVID(dhdr); if (devid < 0 || devid >= NUM_DEV) return; arPriv = ar->arDev[devid]; } if (eid == ar->arControlEp) { WMI_CMD_HDR *cmhdr = (WMI_CMD_HDR*)A_NETBUF_DATA(pktSkb); if (ar->arWMIControlEpFull) { /* since this packet completed, the WMI EP is no longer full */ ar->arWMIControlEpFull = FALSE; } if (ar->arTxPending[eid] == 0) { wakeEvent = TRUE; } devid = WMI_CMD_HDR_GET_DEVID(cmhdr); if (devid < 0 || devid >= NUM_DEV) return; arPriv = ar->arDev[devid]; } } else { devid = 0; arPriv = ar->arDev[devid]; } if (A_FAILED(status)) { if (status == A_ECANCELED || status == A_ECOMM ) { /* a packet was flushed */ flushing[devid] = TRUE; } AR6000_STAT_INC(arPriv, tx_errors); if (status != A_NO_RESOURCE && status != A_ECOMM ) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() -TX ERROR, status: 0x%x\n", __func__, status)); } } else { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("OK\n")); flushing[devid] = FALSE; AR6000_STAT_INC(arPriv, tx_packets); arPriv->arNetStats.tx_bytes += A_NETBUF_LEN(pktSkb); #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL arPriv->aptcTR.bytesTransmitted += a_netbuf_to_len(pktSkb); applyAPTCHeuristics(arPriv); #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ } // TODO this needs to be looked at if (arPriv->arNetworkType == ADHOC_NETWORK) { arSta = &arPriv->arSta; if((arSta->arIbssPsEnable && (eid != ar->arControlEp) && mapNo)) { mapNo --; arSta->arNodeMap[mapNo].txPending --; if (!arSta->arNodeMap[mapNo].txPending && (mapNo == (arSta->arNodeNum - 1))) { A_UINT32 i; for (i = arSta->arNodeNum; i > 0; i --) { if (!arSta->arNodeMap[i - 1].txPending) { A_MEMZERO(&arSta->arNodeMap[i - 1], sizeof(struct ar_node_mapping)); arSta->arNodeNum --; } else { break; } } } } } ar6000_free_cookie(ar, ar_cookie); if (HTC_GET_TAG_FROM_PKT(pPacket) == AR6K_CONTROL_PKT_TAG) { /* If we just freed a control packet, update the count */ ar->arControlCookieCount--; } if (arPriv->arNetQueueStopped) { arPriv->arNetQueueStopped = FALSE; } } AR6000_SPIN_UNLOCK(&ar->arLock, 0); /* lock is released, we can freely call other kernel APIs */ /* free all skbs in our local list */ while (!skb_queue_empty(&skb_queue)) { /* use non-lock version */ pktSkb = __skb_dequeue(&skb_queue); A_NETBUF_FREE(pktSkb); } for(i = 0; i < num_device; i++) { arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(ar6000_devices[i]); if (((arPriv->arNetworkType == INFRA_NETWORK ) && (arPriv->arConnected == TRUE)) || (bypasswmi)) { if (!flushing[i]) { /* don't wake the queue if we are flushing, other wise it will just * keep queueing packets, which will keep failing */ netif_wake_queue(arPriv->arNetDev); } } if (wakeEvent) { wake_up(&arPriv->arEvent); } } } conn_t * ieee80211_find_conn(AR_SOFTC_DEV_T *arPriv, A_UINT8 *node_addr) { conn_t *conn = NULL; A_UINT8 i; AR_SOFTC_T *ar = arPriv->arSoftc; if (IS_MAC_NULL(node_addr)) { return NULL; } for (i = 0; i < NUM_CONN; i++) { if (IEEE80211_ADDR_EQ(node_addr, ar->connTbl[i].mac)) { conn = &ar->connTbl[i]; break; } } return conn; } conn_t *ieee80211_find_conn_for_aid(AR_SOFTC_DEV_T *arPriv, A_UINT8 aid) { conn_t *conn = NULL; AR_SOFTC_T *ar = arPriv->arSoftc; if (arPriv->arNetworkType != AP_NETWORK) { conn = NULL; } else if( (aid > 0) && (aid < NUM_CONN) ) { if (ar->connTbl[aid-1].aid == aid) { conn = &ar->connTbl[aid-1]; } } return conn; } void *get_aggr_ctx(AR_SOFTC_DEV_T *arPriv, conn_t *conn) { if (arPriv->arNetworkType != AP_NETWORK) { return (arPriv->conn_aggr); } else { return (conn->conn_aggr); } } /* * Receive event handler. This is called by HTC when a packet is received */ int pktcount; static void ar6000_rx(void *Context, HTC_PACKET *pPacket) { AR_SOFTC_T *ar = NULL; struct sk_buff *skb = NULL; int minHdrLen; A_UINT8 containsDot11Hdr = 0; A_STATUS status; HTC_ENDPOINT_ID ept; conn_t *conn = NULL; AR_SOFTC_DEV_T *arPriv = NULL; A_UINT8 devid ; ATH_MAC_HDR *multicastcheck_datap = NULL; if(Context == NULL || pPacket == NULL) { AR_DEBUG_PRINTF(ATH_DEBUG_ANY, ("AR6K: Context is null or pPacket is null\n")); goto rx_done; } ar = (AR_SOFTC_T *)Context; skb = (struct sk_buff *)pPacket->pPktContext; status = pPacket->Status; ept = pPacket->Endpoint; A_ASSERT((status != A_OK) || (pPacket->pBuffer == (A_NETBUF_DATA(skb) + HTC_HEADER_LEN))); AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_RX,("ar6000_rx ar=0x%x eid=%d, skb=0x%x, data=0x%x, len=0x%x status:%d", (A_UINT32)ar, ept, (A_UINT32)skb, (A_UINT32)pPacket->pBuffer, pPacket->ActualLength, status)); if (status != A_OK) { if (status != A_ECANCELED) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("RX ERR (%d) \n",status)); } A_NETBUF_FREE(skb); goto rx_done; } /* take lock to protect buffer counts * and adaptive power throughput state */ AR6000_SPIN_LOCK(&ar->arLock, 0); A_NETBUF_PUT(skb, pPacket->ActualLength + HTC_HEADER_LEN); A_NETBUF_PULL(skb, HTC_HEADER_LEN); if(!bypasswmi) { if(ept == ar->arControlEp) { WMI_CMD_HDR *cmhdr = (WMI_CMD_HDR*)A_NETBUF_DATA(skb); devid = WMI_CMD_HDR_GET_DEVID(cmhdr); if (devid < 0 || devid >= NUM_DEV) { A_NETBUF_FREE(skb); goto rx_done; } arPriv = ar->arDev[devid]; } else { WMI_DATA_HDR *dhdr = (WMI_DATA_HDR *)A_NETBUF_DATA(skb); devid = WMI_DATA_HDR_GET_DEVID(dhdr); if (devid < 0 || devid >= NUM_DEV) { A_NETBUF_FREE(skb); goto rx_done; } arPriv = ar->arDev[devid]; } } else { devid = 0; arPriv = ar->arDev[devid]; } if (A_SUCCESS(status)) { AR6000_STAT_INC(arPriv, rx_packets); arPriv->arNetStats.rx_bytes += pPacket->ActualLength; #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL arPriv->aptcTR.bytesReceived += pPacket->ActualLength; applyAPTCHeuristics(arPriv); #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */ #ifdef DEBUG if (debugdriver >= 2) { ar6000_dump_skb(skb); } #endif /* DEBUG */ } AR6000_SPIN_UNLOCK(&ar->arLock, 0); skb->dev = arPriv->arNetDev; if (status != A_OK) { AR6000_STAT_INC(arPriv, rx_errors); A_NETBUF_FREE(skb); } else if (arPriv->arWmiEnabled == TRUE) { if (ept == ar->arControlEp) { /* * this is a wmi control msg */ #ifdef CONFIG_PM ar6000_check_wow_status(ar, skb, TRUE); #endif /* CONFIG_PM */ wmi_control_rx(arPriv->arWmi, skb); } else { WMI_DATA_HDR *dhdr = (WMI_DATA_HDR *)A_NETBUF_DATA(skb); A_UINT8 is_amsdu, tid, is_acl_data_frame; is_acl_data_frame = WMI_DATA_HDR_GET_DATA_TYPE(dhdr) == WMI_DATA_HDR_DATA_TYPE_ACL; #ifdef CONFIG_PM ar6000_check_wow_status(ar, NULL, FALSE); #endif /* CONFIG_PM */ /* * this is a wmi data packet */ // NWF if (processDot11Hdr) { minHdrLen = sizeof(WMI_DATA_HDR) + sizeof(struct ieee80211_frame) + sizeof(ATH_LLC_SNAP_HDR); } else { minHdrLen = sizeof (WMI_DATA_HDR) + sizeof(ATH_MAC_HDR) + sizeof(ATH_LLC_SNAP_HDR); } /* In the case of AP mode we may receive NULL data frames * that do not have LLC hdr. They are 16 bytes in size. * Allow these frames in the AP mode. * ACL data frames don't follow ethernet frame bounds for * min length */ if (arPriv->arNetworkType != AP_NETWORK && !is_acl_data_frame && ((pPacket->ActualLength < minHdrLen) || (pPacket->ActualLength > AR6000_MAX_RX_MESSAGE_SIZE))) { /* * packet is too short or too long */ AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("TOO SHORT or TOO LONG\n")); AR6000_STAT_INC(arPriv, rx_errors); AR6000_STAT_INC(arPriv, rx_length_errors); A_NETBUF_FREE(skb); } else { A_UINT16 seq_no; A_UINT8 meta_type; #if 0 /* Access RSSI values here */ AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("RSSI %d\n", ((WMI_DATA_HDR *) A_NETBUF_DATA(skb))->rssi)); #endif /* Get the Power save state of the STA */ if (arPriv->arNetworkType == AP_NETWORK) { A_UINT8 psState=0,prevPsState; ATH_MAC_HDR *datap=NULL; A_UINT16 offset; A_UINT8 triggerState; meta_type = WMI_DATA_HDR_GET_META(dhdr); psState = (((WMI_DATA_HDR *)A_NETBUF_DATA(skb))->info >> WMI_DATA_HDR_PS_SHIFT) & WMI_DATA_HDR_PS_MASK; triggerState = WMI_DATA_HDR_IS_TRIGGER(dhdr); offset = sizeof(WMI_DATA_HDR); switch (meta_type) { case 0: break; case WMI_META_VERSION_1: offset += sizeof(WMI_RX_META_V1); break; #ifdef CONFIG_CHECKSUM_OFFLOAD case WMI_META_VERSION_2: offset += sizeof(WMI_RX_META_V2); break; #endif default: break; } #ifdef DIX_RX_OFFLOAD #define SKIP_LLC_LEN 8 /*DIX to ETHERNET hdr conversion is offloaded to firmware */ /*Empty LLC header is moved to get ethernet header*/ A_UINT32 datalen = (A_UINT32)A_NETBUF_LEN(skb)-offset; is_amsdu = WMI_DATA_HDR_IS_AMSDU(dhdr); containsDot11Hdr = WMI_DATA_HDR_GET_DOT11(dhdr); if(!containsDot11Hdr && !is_amsdu && !is_acl_data_frame && datalen >= (sizeof(ATH_MAC_HDR) + sizeof(ATH_LLC_SNAP_HDR))) { datap = (ATH_MAC_HDR *)((A_INT8*)A_NETBUF_DATA(skb)+offset+SKIP_LLC_LEN); } else { datap = (ATH_MAC_HDR *)((A_INT8*)A_NETBUF_DATA(skb)+offset); } #else datap = (ATH_MAC_HDR *)(A_NETBUF_DATA(skb)+offset); #endif conn = ieee80211_find_conn(arPriv, datap->srcMac); if (conn) { /* if there is a change in PS state of the STA, * take appropriate steps. * 1. If Sleep-->Awake, flush the psq for the STA * Clear the PVB for the STA. * 2. If Awake-->Sleep, Starting queueing frames * the STA. */ prevPsState = STA_IS_PWR_SLEEP(conn); if (psState) { STA_SET_PWR_SLEEP(conn); } else { STA_CLR_PWR_SLEEP(conn); } if (STA_IS_PWR_SLEEP(conn)) { /* Accept trigger only when the station is in sleep */ if (triggerState) { ar6000_uapsd_trigger_frame_rx(arPriv, conn); } } if (prevPsState ^ STA_IS_PWR_SLEEP(conn)) { A_BOOL isApsdqEmptyAtStart; if (!STA_IS_PWR_SLEEP(conn)) { A_MUTEX_LOCK(&conn->psqLock); while (!A_NETBUF_QUEUE_EMPTY(&conn->psq)) { struct sk_buff *skb=NULL; skb = A_NETBUF_DEQUEUE(&conn->psq); A_MUTEX_UNLOCK(&conn->psqLock); ar6000_data_tx(skb,arPriv->arNetDev); A_MUTEX_LOCK(&conn->psqLock); } isApsdqEmptyAtStart = A_NETBUF_QUEUE_EMPTY(&conn->apsdq); while (!A_NETBUF_QUEUE_EMPTY(&conn->apsdq)) { struct sk_buff *skb=NULL; skb = A_NETBUF_DEQUEUE(&conn->apsdq); A_MUTEX_UNLOCK(&conn->psqLock); ar6000_data_tx(skb,arPriv->arNetDev); A_MUTEX_LOCK(&conn->psqLock); } A_MUTEX_UNLOCK(&conn->psqLock); /* Clear the APSD buffered bitmap for this STA */ if (!isApsdqEmptyAtStart) { wmi_set_apsd_buffered_traffic_cmd(arPriv->arWmi, conn->aid, 0, 0); } /* Clear the PVB for this STA */ wmi_set_pvb_cmd(arPriv->arWmi, conn->aid, 0); } } } else { /* This frame is from a STA that is not associated*/ A_NETBUF_FREE(skb); goto rx_done; } /* Drop NULL data frames here */ if((pPacket->ActualLength < minHdrLen) || (pPacket->ActualLength > AR6000_MAX_RX_MESSAGE_SIZE)) { A_NETBUF_FREE(skb); goto rx_done; } } is_amsdu = WMI_DATA_HDR_IS_AMSDU(dhdr); tid = WMI_DATA_HDR_GET_UP(dhdr); seq_no = WMI_DATA_HDR_GET_SEQNO(dhdr); meta_type = WMI_DATA_HDR_GET_META(dhdr); containsDot11Hdr = WMI_DATA_HDR_GET_DOT11(dhdr); wmi_data_hdr_remove(arPriv->arWmi, skb); switch (meta_type) { case WMI_META_VERSION_1: { WMI_RX_META_V1 *pMeta = (WMI_RX_META_V1 *)A_NETBUF_DATA(skb); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("META %d %d %d %d %x\n", pMeta->status, pMeta->rix, pMeta->rssi, pMeta->channel, pMeta->flags)); A_NETBUF_PULL((void*)skb, sizeof(WMI_RX_META_V1)); break; } #ifdef CONFIG_CHECKSUM_OFFLOAD case WMI_META_VERSION_2: { WMI_RX_META_V2 *pMeta = (WMI_RX_META_V2 *)A_NETBUF_DATA(skb); if(pMeta->csumFlags & 0x1){ skb->ip_summed=CHECKSUM_COMPLETE; skb->csum=(pMeta->csum); } A_NETBUF_PULL((void*)skb, sizeof(WMI_RX_META_V2)); break; } #endif default: break; } A_ASSERT(status == A_OK); /* NWF: print the 802.11 hdr bytes */ if(containsDot11Hdr) { status = wmi_dot11_hdr_remove(arPriv->arWmi,skb); } else if(!is_amsdu && !is_acl_data_frame) { #ifdef DIX_RX_OFFLOAD /*Skip the conversion its offloaded to firmware*/ if(A_NETBUF_PULL(skb, sizeof(ATH_LLC_SNAP_HDR)) != A_OK) { status = A_NO_MEMORY; } else { status = A_OK; } #else status = wmi_dot3_2_dix(skb); #endif } if (status != A_OK) { /* Drop frames that could not be processed (lack of memory, etc.) */ A_NETBUF_FREE(skb); goto rx_done; } if (is_acl_data_frame) { A_NETBUF_PUSH(skb, sizeof(int)); *((short *)A_NETBUF_DATA(skb)) = WMI_ACL_DATA_EVENTID; /* send the data packet to PAL driver */ if(ar6k_pal_config_g.fpar6k_pal_recv_pkt) { if((*ar6k_pal_config_g.fpar6k_pal_recv_pkt)(arPriv->hcipal_info, skb) == TRUE) goto rx_done; } } #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0) /* * extra push and memcpy, for eth_type_trans() of 2.4 kernel * will pull out hard_header_len bytes of the skb. */ A_NETBUF_PUSH(skb, sizeof(WMI_DATA_HDR) + sizeof(ATH_LLC_SNAP_HDR) + HTC_HEADER_LEN); A_MEMCPY(A_NETBUF_DATA(skb), A_NETBUF_DATA(skb) + sizeof(WMI_DATA_HDR) + sizeof(ATH_LLC_SNAP_HDR) + HTC_HEADER_LEN, sizeof(ATH_MAC_HDR)); #endif #ifdef ATH_AR6K_11N_SUPPORT multicastcheck_datap = (ATH_MAC_HDR *)A_NETBUF_DATA(skb); /* * Do not pass multicast/bcast data packets to aggregation module * incase of STA mode */ if (!(((IEEE80211_IS_MULTICAST(multicastcheck_datap->dstMac))) && (arPriv->arNetworkType == INFRA_NETWORK))){ aggr_process_recv_frm(get_aggr_ctx(arPriv, conn), tid, seq_no, is_amsdu, (void **)&skb); } #endif ar6000_deliver_frames_to_nw_stack((void *) arPriv->arNetDev, (void *)skb); } } } else { if (EPPING_ALIGNMENT_PAD > 0) { A_NETBUF_PULL(skb, EPPING_ALIGNMENT_PAD); } ar6000_deliver_frames_to_nw_stack((void *)arPriv->arNetDev, (void *)skb); } rx_done: return; } static void ar6000_deliver_frames_to_nw_stack(void *dev, void *osbuf) { struct sk_buff *skb = (struct sk_buff *)osbuf; AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); AR_SOFTC_T *ar = arPriv->arSoftc; if(skb) { skb->dev = dev; if ((skb->dev->flags & IFF_UP) == IFF_UP) { if (arPriv->arNetworkType == AP_NETWORK) { struct sk_buff *skb1 = NULL; ATH_MAC_HDR *datap; struct net_device *net_dev = arPriv->arNetDev; #ifdef CONFIG_PM ar6000_check_wow_status(ar, skb, FALSE); #endif /* CONFIG_PM */ datap = (ATH_MAC_HDR *)A_NETBUF_DATA(skb); if (IEEE80211_IS_MULTICAST(datap->dstMac)) { /* Bcast/Mcast frames should be sent to the OS * stack as well as on the air. */ skb1 = skb_copy(skb,GFP_ATOMIC); } else { /* Search for a connected STA with dstMac as * the Mac address. If found send the frame to * it on the air else send the frame up the stack */ AR_SOFTC_DEV_T *to_arPriv = NULL; A_UINT8 is_forward = 0; conn_t *to_conn = NULL; to_conn = ieee80211_find_conn(arPriv, datap->dstMac); if (to_conn) { to_arPriv = (AR_SOFTC_DEV_T *)to_conn->arPriv; /* Forward data within BSS */ if(arPriv == to_arPriv) { is_forward = arPriv->arAp.intra_bss; } else { /* Forward data within mBSS */ is_forward = ar->inter_bss; net_dev = to_arPriv->arNetDev; } if(is_forward && net_dev) { skb1 = skb; skb = NULL; } else { A_NETBUF_FREE(skb); skb = NULL; return; } } } if (skb1) { ar6000_data_tx(skb1, net_dev); if (!skb) return; } } #ifdef CONFIG_PM ar6000_check_wow_status(ar, skb, FALSE); #endif /* CONFIG_PM */ skb->protocol = eth_type_trans(skb, skb->dev); /* * If this routine is called on a ISR (Hard IRQ) or DSR (Soft IRQ) * or tasklet use the netif_rx to deliver the packet to the stack * netif_rx will queue the packet onto the receive queue and mark * the softirq thread has a pending action to complete. Kernel will * schedule the softIrq kernel thread after processing the DSR. * * If this routine is called on a process context, use netif_rx_ni * which will schedle the softIrq kernel thread after queuing the packet. */ if (in_interrupt()) { A_NETIF_RX(skb); } else { A_NETIF_RX_NI(skb); } } else { A_NETBUF_FREE(skb); } } } #if 0 static void ar6000_deliver_frames_to_bt_stack(void *dev, void *osbuf) { struct sk_buff *skb = (struct sk_buff *)osbuf; if(skb) { skb->dev = dev; if ((skb->dev->flags & IFF_UP) == IFF_UP) { skb->protocol = htons(ETH_P_CONTROL); netif_rx(skb); } else { A_NETBUF_FREE(skb); } } } #endif static void ar6000_rx_refill(void *Context, HTC_ENDPOINT_ID Endpoint) { AR_SOFTC_T *ar = (AR_SOFTC_T *)Context; void *osBuf; int RxBuffers; int buffersToRefill; HTC_PACKET *pPacket; HTC_PACKET_QUEUE queue; if (Endpoint < 0 || Endpoint >= ENDPOINT_MAX) return; buffersToRefill = (int)AR6000_MAX_RX_BUFFERS - HTCGetNumRecvBuffers(ar->arHtcTarget, Endpoint); if (buffersToRefill <= 0) { /* fast return, nothing to fill */ return; } INIT_HTC_PACKET_QUEUE(&queue); AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_RX,("ar6000_rx_refill: providing htc with %d buffers at eid=%d\n", buffersToRefill, Endpoint)); for (RxBuffers = 0; RxBuffers < buffersToRefill; RxBuffers++) { osBuf = A_NETBUF_ALLOC(AR6000_BUFFER_SIZE); if (NULL == osBuf) { break; } /* the HTC packet wrapper is at the head of the reserved area * in the skb */ pPacket = (HTC_PACKET *)(A_NETBUF_HEAD(osBuf)); /* set re-fill info */ SET_HTC_PACKET_INFO_RX_REFILL(pPacket,osBuf,A_NETBUF_DATA(osBuf),AR6000_BUFFER_SIZE,Endpoint); /* add to queue */ HTC_PACKET_ENQUEUE(&queue,pPacket); } if (!HTC_QUEUE_EMPTY(&queue)) { /* add packets */ HTCAddReceivePktMultiple(ar->arHtcTarget, &queue); } } /* clean up our amsdu buffer list */ static void ar6000_cleanup_amsdu_rxbufs(AR_SOFTC_T *ar) { HTC_PACKET *pPacket; void *osBuf; /* empty AMSDU buffer queue and free OS bufs */ while (TRUE) { AR6000_SPIN_LOCK(&ar->arLock, 0); pPacket = HTC_PACKET_DEQUEUE(&ar->amsdu_rx_buffer_queue); AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (NULL == pPacket) { break; } osBuf = pPacket->pPktContext; if (NULL == osBuf) { A_ASSERT(FALSE); break; } A_NETBUF_FREE(osBuf); } } /* refill the amsdu buffer list */ static void ar6000_refill_amsdu_rxbufs(AR_SOFTC_T *ar, int Count) { HTC_PACKET *pPacket; void *osBuf; while (Count > 0) { osBuf = A_NETBUF_ALLOC(AR6000_AMSDU_BUFFER_SIZE); if (NULL == osBuf) { break; } /* the HTC packet wrapper is at the head of the reserved area * in the skb */ pPacket = (HTC_PACKET *)(A_NETBUF_HEAD(osBuf)); /* set re-fill info */ SET_HTC_PACKET_INFO_RX_REFILL(pPacket,osBuf,A_NETBUF_DATA(osBuf),AR6000_AMSDU_BUFFER_SIZE,0); AR6000_SPIN_LOCK(&ar->arLock, 0); /* put it in the list */ HTC_PACKET_ENQUEUE(&ar->amsdu_rx_buffer_queue,pPacket); AR6000_SPIN_UNLOCK(&ar->arLock, 0); Count--; } } /* callback to allocate a large receive buffer for a pending packet. This function is called when * an HTC packet arrives whose length exceeds a threshold value * * We use a pre-allocated list of buffers of maximum AMSDU size (4K). Under linux it is more optimal to * keep the allocation size the same to optimize cached-slab allocations. * * */ static HTC_PACKET *ar6000_alloc_amsdu_rxbuf(void *Context, HTC_ENDPOINT_ID Endpoint, int Length) { HTC_PACKET *pPacket = NULL; AR_SOFTC_T *ar = (AR_SOFTC_T *)Context; int refillCount = 0; AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_RX,("ar6000_alloc_amsdu_rxbuf: eid=%d, Length:%d\n",Endpoint,Length)); do { if (Length <= AR6000_BUFFER_SIZE) { /* shouldn't be getting called on normal sized packets */ A_ASSERT(FALSE); break; } if (Length > AR6000_AMSDU_BUFFER_SIZE) { A_ASSERT(FALSE); break; } AR6000_SPIN_LOCK(&ar->arLock, 0); /* allocate a packet from the list */ pPacket = HTC_PACKET_DEQUEUE(&ar->amsdu_rx_buffer_queue); /* see if we need to refill again */ refillCount = AR6000_MAX_AMSDU_RX_BUFFERS - HTC_PACKET_QUEUE_DEPTH(&ar->amsdu_rx_buffer_queue); AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (NULL == pPacket) { break; } /* set actual endpoint ID */ pPacket->Endpoint = Endpoint; } while (FALSE); if (refillCount >= AR6000_AMSDU_REFILL_THRESHOLD) { ar6000_refill_amsdu_rxbufs(ar,refillCount); } return pPacket; } static void ar6000_set_multicast_list(struct net_device *dev) { #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35) int mc_count = dev->mc_count; struct dev_mc_list *mc; int j; #else int mc_count = netdev_mc_count(dev); struct netdev_hw_addr *ha; #endif AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); AR_SOFTC_T *ar = arPriv->arSoftc; int i; A_BOOL enableAll, disableAll; enum { IGNORE = 0, MATCH = 1, ADD = 2, DELETE = 3 } action[MAC_MAX_FILTERS_PER_LIST]; A_BOOL mcValid; A_UINT8 *mac; A_UINT8 *filter; A_BOOL filterValid; if (ar->arWmiReady == FALSE || ar->arWlanState == WLAN_DISABLED) return; enableAll = FALSE; disableAll = FALSE; /* * Enable receive all multicast, if * 1. promiscous mode, * 2. Allow all multicast * 3. H/W supported filters is less than application requested filter */ if ((dev->flags & IFF_PROMISC) || (dev->flags & IFF_ALLMULTI) || (mc_count > MAC_MAX_FILTERS_PER_LIST)) { enableAll = TRUE; } else { /* Disable all multicast if interface has multicast disable or list is empty */ if ((!(dev->flags & IFF_MULTICAST)) || (!mc_count)) { disableAll = TRUE; } } /* * Firmware behaviour * enableAll - set filter to enable and delete valid filters * disableAll - set filter to disable and delete valid filers * filter - set valid filters */ /* * Pass 1: Mark all the valid filters to delete */ for (i=0; imcast_filters[i]; filterValid = (filter[1] || filter[2]); if (filterValid) { action[i] = DELETE; } else { action[i] = IGNORE; } } if ((!enableAll) && (!disableAll)) { /* * Pass 2: Mark all filters which match the previous ones */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34) for (j = 0, mc = dev->mc_list; mc && (j < dev->mc_count); j++, mc = mc->next) { mac = mc->dmi_addr; #else netdev_for_each_mc_addr(ha, dev) { mac = ha->addr; #endif mcValid = (mac[2] || mac[3] || mac[4] || mac[5]); if (mcValid) { for (i=0; imcast_filters[i]; if ((A_MEMCMP(filter, &mac[0], AR_MCAST_FILTER_MAC_ADDR_SIZE)) == 0) { action[i] = MATCH; break; } } } } /* * Delete old entries and free-up space for new additions */ for (i = 0; i < MAC_MAX_FILTERS_PER_LIST; i++) { filter = arPriv->mcast_filters[i]; if (action[i] == DELETE) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Delete Filter %d = %02x:%02x:%02x:%02x:%02x:%02x\n", i, filter[0], filter[1], filter[2], filter[3], filter[4], filter[5])); wmi_del_mcast_filter_cmd(arPriv->arWmi, filter); A_MEMZERO(filter, AR_MCAST_FILTER_MAC_ADDR_SIZE); /* Make this available for further additions */ action[i] = IGNORE; } } /* * Pass 3: Add new filters to empty slots */ #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34) for (j = 0, mc = dev->mc_list; mc && (j < dev->mc_count); j++, mc = mc->next) { #else netdev_for_each_mc_addr(ha, dev) { #endif A_BOOL match; A_INT32 free; #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 34) mac = mc->dmi_addr; #else mac = ha->addr; #endif mcValid = (mac[2] || mac[3] || mac[4] || mac[5]); if (mcValid) { match = FALSE; free = -1; for (i=0; imcast_filters[i]; if ((A_MEMCMP(filter, &mac[0], AR_MCAST_FILTER_MAC_ADDR_SIZE)) == 0) { match = TRUE; break; } else if (action[i] != MATCH && action[i] != ADD) { if (free == -1) { free = i; // Mark the first free index } } } if ((!match) && (free != -1)) { filter = arPriv->mcast_filters[free]; A_MEMCPY(filter, &mac[0], AR_MCAST_FILTER_MAC_ADDR_SIZE); action[free] = ADD; } } } } for (i=0; imcast_filters[i]; if (action[i] == DELETE) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Delete Filter %d = %02x:%02x:%02x:%02x:%02x:%02x\n", i, filter[0], filter[1], filter[2], filter[3], filter[4], filter[5])); wmi_del_mcast_filter_cmd(arPriv->arWmi, filter); A_MEMZERO(filter, AR_MCAST_FILTER_MAC_ADDR_SIZE); } else if (action[i] == ADD) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Add Filter %d = %02x:%02x:%02x:%02x:%02x:%02x\n", i, filter[0], filter[1], filter[2], filter[3],filter[4],filter[5])); wmi_set_mcast_filter_cmd(arPriv->arWmi, filter); } else if (action[i] == MATCH) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Keep Filter %d = %02x:%02x:%02x:%02x:%02x:%02x\n", i, filter[0], filter[1], filter[2], filter[3],filter[4],filter[5])); } } if (enableAll) { /* target allow all multicast packets if fitler enable and fitler list is zero */ wmi_mcast_filter_cmd(arPriv->arWmi, TRUE); } else if (disableAll) { /* target drop multicast packets if fitler disable and fitler list is zero */ wmi_mcast_filter_cmd(arPriv->arWmi, FALSE); } } static struct net_device_stats * ar6000_get_stats(struct net_device *dev) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); return &arPriv->arNetStats; } static struct iw_statistics * ar6000_get_iwstats(struct net_device * dev) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)ar6k_priv(dev); AR_SOFTC_T *ar = arPriv->arSoftc; TARGET_STATS *pStats = &arPriv->arTargetStats; struct iw_statistics * pIwStats = &arPriv->arIwStats; #ifdef CONFIG_HOST_TCMD_SUPPORT if (ar->bIsDestroyProgress || ar->arWmiReady == FALSE || ar->arWlanState == WLAN_DISABLED || testmode) #else if (ar->bIsDestroyProgress || ar->arWmiReady == FALSE || ar->arWlanState == WLAN_DISABLED) #endif { pIwStats->status = 0; pIwStats->qual.qual = 0; pIwStats->qual.level =0; pIwStats->qual.noise = 0; pIwStats->discard.code =0; pIwStats->discard.retries=0; pIwStats->miss.beacon =0; return pIwStats; } #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) /* * The in_atomic function is used to determine if the scheduling is * allowed in the current context or not. This was introduced in 2.6 * From what I have read on the differences between 2.4 and 2.6, the * 2.4 kernel did not support preemption and so this check might not * be required for 2.4 kernels. */ if (in_atomic()) { if (wmi_get_stats_cmd(arPriv->arWmi) == A_OK) { } pIwStats->status = 1 ; pIwStats->qual.qual = pStats->cs_aveBeacon_rssi - 161; pIwStats->qual.level =pStats->cs_aveBeacon_rssi; /* noise is -95 dBm */ pIwStats->qual.noise = pStats->noise_floor_calibation; pIwStats->discard.code = pStats->rx_decrypt_err; pIwStats->discard.retries = pStats->tx_retry_cnt; pIwStats->miss.beacon = pStats->cs_bmiss_cnt; return pIwStats; } #endif /* LINUX_VERSION_CODE */ dev_hold(dev); pIwStats->status = 0; if (down_interruptible(&ar->arSem)) { goto err_exit; } do { if (ar->bIsDestroyProgress || ar->arWlanState == WLAN_DISABLED) { break; } arPriv->statsUpdatePending = TRUE; if(wmi_get_stats_cmd(arPriv->arWmi) != A_OK) { break; } wait_event_interruptible_timeout(arPriv->arEvent, arPriv->statsUpdatePending == FALSE, wmitimeout * HZ); if (signal_pending(current)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000 : WMI get stats timeout \n")); break; } pIwStats->status = 1 ; pIwStats->qual.qual = pStats->cs_aveBeacon_rssi - 161; pIwStats->qual.level =pStats->cs_aveBeacon_rssi; /* noise is -95 dBm */ pIwStats->qual.noise = pStats->noise_floor_calibation; pIwStats->discard.code = pStats->rx_decrypt_err; pIwStats->discard.retries = pStats->tx_retry_cnt; pIwStats->miss.beacon = pStats->cs_bmiss_cnt; } while (0); up(&ar->arSem); err_exit: dev_put(dev); return pIwStats; } void ar6000_ready_event(void *devt, A_UINT8 *datap, A_UINT8 phyCap, A_UINT32 sw_ver, A_UINT32 abi_ver) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; struct net_device *dev; AR_SOFTC_T *ar = arPriv->arSoftc; A_UINT8 i, j, k; AR_SOFTC_STA_T *arSta; ar->arWmiReady = TRUE; ar->arVersion.wlan_ver = sw_ver; ar->arVersion.abi_ver = abi_ver; wake_up(&arPriv->arEvent); for(i = 0; i < num_device ; i++) { dev = ar6000_devices[i]; arPriv = ar->arDev[i]; arPriv->arPhyCapability = phyCap; if (arPriv->arPhyCapability == WMI_11NAG_CAPABILITY){ arPriv->phymode = DEF_AP_WMODE_AG; } else { arPriv->phymode = DEF_AP_WMODE_G; } A_MEMCPY(dev->dev_addr, datap, AR6000_ETH_ADDR_LEN); if (i > 0) { if(mac_addr_method) { k = dev->dev_addr[5]; dev->dev_addr[5] += i; for(j=5; j>3; j--) { if(dev->dev_addr[j] > k) { break; } k = dev->dev_addr[j-1]; dev->dev_addr[j-1]++; } } else { dev->dev_addr[0] = (((dev->dev_addr[0]) ^ (1 << i))) | 0x02; } } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("DEV%d mac address = %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n", i, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5])); #ifdef AR6K_ENABLE_HCI_PAL ar6k_hci_pal_info_t *pHciPalInfo = (ar6k_hci_pal_info_t *)ar->hcipal_info; pHciPalInfo->hdev->bdaddr.b[0]=dev->dev_addr[5]; pHciPalInfo->hdev->bdaddr.b[1]=dev->dev_addr[4]; pHciPalInfo->hdev->bdaddr.b[2]=dev->dev_addr[3]; pHciPalInfo->hdev->bdaddr.b[3]=dev->dev_addr[2]; pHciPalInfo->hdev->bdaddr.b[4]=dev->dev_addr[1]; pHciPalInfo->hdev->bdaddr.b[5]=dev->dev_addr[0]; #endif #if (WLAN_CONFIG_PSPOLL_NUM) || (WLAN_CONFIG_DTIM_POLICY) || \ (WLAN_CONFIG_IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN) AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("AR6K: %s: PSPOLL_NUM = %d, DTIM_POLICY = %d, PS_FAIL_EVENT_POLICY = %d\n", __FUNCTION__, WLAN_CONFIG_PSPOLL_NUM, WLAN_CONFIG_DTIM_POLICY, WLAN_CONFIG_IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN)); wmi_pmparams_cmd(arPriv->arWmi, 0, /* idlePeriod */ WLAN_CONFIG_PSPOLL_NUM, /* psPollNum */ WLAN_CONFIG_DTIM_POLICY, /* dtimPolicy */ 0, /* tx_wakeup_policy */ 1, /* num_tx_to_wakeup */ WLAN_CONFIG_IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN /* ps_fail_event_policy */ ); #endif #if WLAN_CONFIG_DONOT_IGNORE_BARKER_IN_ERP wmi_set_lpreamble_cmd(arPriv->arWmi, 0, WMI_DONOT_IGNORE_BARKER_IN_ERP); #endif wmi_set_keepalive_cmd(arPriv->arWmi, WLAN_CONFIG_KEEP_ALIVE_INTERVAL); #ifdef BMISS_ENHANCEMENT /* This code has been added to enable the new algorithm to prevent BMISS * Enabling this right now only for single dev opertaing mode */ if (num_device == 1) { wmi_sta_bmiss_enhance_cmd(arPriv->arWmi, 1); } #endif /* BG scan should be enabled for p2p operation */ A_PRINTF("AR6K: targetconf_ver : %d\n", ar->arVersion.targetconf_ver); if (ar->arVersion.targetconf_ver == AR6003_SUBVER_DEFAULT) { WMI_SET_ROAM_CTRL_CMD roamCtrl; if (arPriv->arNetworkType != AP_NETWORK) { arSta = &arPriv->arSta; /* if psm_info is 0, disable background scan for OTA */ if (!psm_info) { arSta->scParams.bg_period = 65535; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6K: bg scan interval = %d, active dwell time = %d passive dwell time = %d\n", arSta->scParams.bg_period, arSta->scParams.maxact_chdwell_time, arSta->scParams.pas_chdwell_time)); wmi_scanparams_cmd(arPriv->arWmi, arSta->scParams.fg_start_period, arSta->scParams.fg_end_period, arSta->scParams.bg_period, arSta->scParams.minact_chdwell_time, arSta->scParams.maxact_chdwell_time, arSta->scParams.pas_chdwell_time, arSta->scParams.shortScanRatio, arSta->scParams.scanCtrlFlags, arSta->scParams.max_dfsch_act_time, arSta->scParams.maxact_scan_per_ssid); } A_MEMZERO(&roamCtrl, sizeof(roamCtrl)); roamCtrl.roamCtrlType = WMI_SET_LOWRSSI_SCAN_PARAMS; roamCtrl.info.lrScanParams.lowrssi_scan_period = 65535; //low rssi scanning disabled wmi_set_roam_ctrl_cmd(arPriv->arWmi, &roamCtrl, sizeof(roamCtrl)); } #if WLAN_CONFIG_DISABLE_11N { WMI_SET_HT_CAP_CMD htCap; A_MEMZERO(&htCap, sizeof(WMI_SET_HT_CAP_CMD)); htCap.band = 0; wmi_set_ht_cap_cmd(arPriv->arWmi, &htCap); htCap.band = 1; wmi_set_ht_cap_cmd(arPriv->arWmi, &htCap); } #endif /* WLAN_CONFIG_DISABLE_11N */ #ifdef ATH6K_CONFIG_OTA_MODE wmi_powermode_cmd(arPriv->arWmi, MAX_PERF_POWER); #else AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6K: %s: psm.info is %d (0: MAX_PERF_POWER, 1:REC_POWER)\n", __FUNCTION__, psm_info)); wmi_powermode_cmd_w_psminfo(arPriv->arWmi, psm_info, 0); #endif wmi_disctimeout_cmd(arPriv->arWmi, WLAN_CONFIG_DISCONNECT_TIMEOUT); } } A_STATUS ar6000_ap_mode_probe_rx(AR_SOFTC_DEV_T *arPriv, A_UINT8 *datap, int len) { struct sk_buff *skb; WMI_BSS_INFO_HDR *bih = (WMI_BSS_INFO_HDR *)datap; A_UINT8 *buf = NULL; if((arPriv->arNetworkType != AP_NETWORK) || (arPriv->arNetworkSubType != SUBTYPE_NONE)) { return A_ERROR; } buf = datap + sizeof(WMI_BSS_INFO_HDR); len -= sizeof(WMI_BSS_INFO_HDR); len += 6; /* For adding MAC addr */ if ((skb = A_NETBUF_ALLOC_RAW(len)) != NULL) { A_NETBUF_PUT(skb, len); A_MEMCPY(A_NETBUF_DATA(skb), bih->bssid, 6); A_MEMCPY(A_NETBUF_DATA(skb)+6, buf, len-6); skb->dev = arPriv->arNetDev; skb_reset_mac_header(skb); skb->ip_summed = CHECKSUM_NONE; skb->pkt_type = PACKET_OTHERHOST; skb->protocol = __constant_htons(0x0019); A_NETIF_RX(skb); } return A_OK; } void add_new_sta(AR_SOFTC_DEV_T *arPriv, A_UINT8 *mac, A_UINT16 aid, A_UINT8 *wpaie, A_UINT8 ielen, A_UINT8 keymgmt, A_UINT8 ucipher, A_UINT8 auth, A_UINT8 wmode, A_UINT8 apsd_info, A_UINT8 HT_present) { AR_SOFTC_T *ar = arPriv->arSoftc; AR_SOFTC_AP_T *arAp = &arPriv->arAp; A_UINT8 free_slot=aid-1; A_MEMCPY(ar->connTbl[free_slot].mac, mac, ATH_MAC_LEN); A_MEMCPY(ar->connTbl[free_slot].wpa_ie, wpaie, ielen); ar->connTbl[free_slot].arPriv = arPriv; ar->connTbl[free_slot].aid = aid; ar->connTbl[free_slot].keymgmt = keymgmt; ar->connTbl[free_slot].ucipher = ucipher; ar->connTbl[free_slot].auth = auth; ar->connTbl[free_slot].wmode = wmode; ar->connTbl[free_slot].apsd_info= apsd_info; ar->connTbl[free_slot].HT_present = HT_present; ar->connTbl[free_slot].flags = 0; ar->arAPStats[free_slot].aid = aid; arAp->sta_list_index = arAp->sta_list_index | (1 << free_slot); aggr_reset_state(ar->connTbl[free_slot].conn_aggr, (void *) arPriv->arNetDev); } void ar6000_connect_event(AR_SOFTC_DEV_T *arPriv, WMI_CONNECT_EVENT *pEvt) { union iwreq_data wrqu; int i, beacon_ie_pos, assoc_resp_ie_pos, assoc_req_ie_pos; static const char *tag1 = "ASSOCINFO(ReqIEs="; static const char *tag2 = "ASSOCRESPIE="; static const char *beaconIetag = "BEACONIE="; char buf[WMI_CONTROL_MSG_MAX_LEN * 2 + strlen(tag1) + 1]; char *pos; A_UINT8 key_op_ctrl; unsigned long flags; struct ieee80211req_key *ik; CRYPTO_TYPE keyType = NONE_CRYPT; AR_SOFTC_STA_T *arSta; struct ieee80211_frame *wh; A_UINT8 *frm, *efrm, *ssid, *rates, *xrates, *wpaie, wpaLen=0; A_UINT16 subtype; A_UINT8 beaconIeLen; A_UINT8 assocReqLen; A_UINT8 assocRespLen; A_UINT8 *assocInfo; A_UINT8 *bssid; A_INT8 rate_idx; A_UINT8 HT_present = 0; beaconIeLen = pEvt->beaconIeLen; assocReqLen = pEvt->assocReqLen; assocRespLen = pEvt->assocRespLen; assocInfo = pEvt->assocInfo; /* BSSID and MAC_ADDR is in the same location for all modes */ bssid = pEvt->u.infra_ibss_bss.bssid; if(arPriv->arNetworkType & AP_NETWORK) { struct net_device *dev = arPriv->arNetDev; AR_SOFTC_AP_T *arAp = &arPriv->arAp; A_UINT8 aid, wmode, keymgmt, auth_alg; if(A_MEMCMP(dev->dev_addr, bssid, ATH_MAC_LEN)==0) { ik = &arAp->ap_mode_bkey; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AP%d: [UP] SSID %s MAC %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n", arPriv->arDeviceIndex, arPriv->arSsid, bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5])); arPriv->arChannelHint = pEvt->u.ap_bss.channel; arPriv->arBssChannel = arPriv->arChannelHint; arPriv->arConnected = TRUE; A_MEMCPY(arPriv->arAp.ap_country_code, pEvt->u.ap_sta.unused, sizeof(arPriv->arAp.ap_country_code)); /* Concurrency: Process the pending connect of the other virtual device(s) */ ar6000_check_hold_conn_status(arPriv, TRUE); #ifdef WAPI_ENABLE if( (arPriv->arAuthMode == WMI_NONE_AUTH) && (arPriv->arPairwiseCrypto == WAPI_CRYPT) ) { ap_set_wapi_key(arPriv, ik); } #endif if(arPriv->arAuthMode & (WMI_WPA_PSK_AUTH|WMI_WPA2_PSK_AUTH|WMI_WPA_AUTH|WMI_WPA2_AUTH)) { switch (ik->ik_type) { case IEEE80211_CIPHER_TKIP: keyType = TKIP_CRYPT; break; case IEEE80211_CIPHER_AES_CCM: keyType = AES_CRYPT; break; default: goto skip_key; } wmi_addKey_cmd(arPriv->arWmi, ik->ik_keyix, keyType, GROUP_USAGE, ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc, ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr, SYNC_BOTH_WMIFLAG); } skip_key: wmi_bssfilter_cmd(arPriv->arWmi, NONE_BSS_FILTER, 0); arPriv->arConnected = TRUE; return; } wh = (struct ieee80211_frame *) (assocInfo + beaconIeLen); subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK; frm = (A_UINT8 *)&wh[1]; efrm = assocInfo + beaconIeLen + assocReqLen; /* capability information */ frm += 2; /* listen int */ frm += 2; /* Reassoc will have current AP addr field */ if(subtype == IEEE80211_FC0_SUBTYPE_REASSOC_REQ) { frm += 6; } ssid = rates = xrates = wpaie = NULL; while (frm < efrm) { switch (*frm) { /* currently unused */ /* case IEEE80211_ELEMID_SSID: ssid = frm; break; case IEEE80211_ELEMID_RATES: rates = frm; break; case IEEE80211_ELEMID_XRATES: xrates = frm; break; */ case IEEE80211_ELEMID_VENDOR: if( (frm[1] > 3) && (frm[2] == 0x00) && (frm[3] == 0x50) && (frm[4] == 0xF2) && ((frm[5] == 0x01) || (frm[5] == 0x04)) ) { wpaie = frm; wpaLen = wpaie[1]+2; } break; case IEEE80211_ELEMID_RSN: wpaie = frm; wpaLen = wpaie[1]+2; break; #ifdef WAPI_ENABLE case IEEE80211_ELEMID_WAPI: wpaie = frm; wpaLen = wpaie[1]+2; break; #endif case IEEE80211_ELEMID_HTCAP_ANA: HT_present = 1; break; } frm += frm[1] + 2; } aid = pEvt->u.ap_sta.aid; wmode = pEvt->u.ap_sta.phymode; keymgmt = pEvt->u.ap_sta.keymgmt; auth_alg = pEvt->u.ap_sta.auth; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("NEW STA %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x \n " " AID=%d AUTH=%d WMODE=%d KEYMGMT=%d CIPHER=%d APSD=%x\n", pEvt->u.ap_sta.mac_addr[0], pEvt->u.ap_sta.mac_addr[1], pEvt->u.ap_sta.mac_addr[2], pEvt->u.ap_sta.mac_addr[3], pEvt->u.ap_sta.mac_addr[4], pEvt->u.ap_sta.mac_addr[5], aid, auth_alg, wmode, keymgmt, pEvt->u.ap_sta.cipher, pEvt->u.ap_sta.apsd_info)); add_new_sta(arPriv, pEvt->u.ap_sta.mac_addr, aid, wpaie, wpaLen, keymgmt, pEvt->u.ap_sta.cipher, auth_alg, wmode, pEvt->u.ap_sta.apsd_info,HT_present); /* Send event to application */ A_MEMZERO(&wrqu, sizeof(wrqu)); A_MEMCPY(wrqu.addr.sa_data, pEvt->u.ap_sta.mac_addr, ATH_MAC_LEN); wireless_send_event(arPriv->arNetDev, IWEVREGISTERED, &wrqu, NULL); /* In case the queue is stopped when we switch modes, this will * wake it up */ netif_wake_queue(arPriv->arNetDev); return; } arPriv->arChannelHint = pEvt->u.infra_ibss_bss.channel; arPriv->arBssChannel = arPriv->arChannelHint; arPriv->arConnected = TRUE; arSta = &arPriv->arSta; arSta->arConnectPending = FALSE; /* Concurrency: Process the pending connect of the other virtual device(s) */ ar6000_check_hold_conn_status(arPriv, TRUE); A_MEMCPY(arPriv->arBssid, bssid, sizeof(arPriv->arBssid)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 connected event on freq %d ", pEvt->u.infra_ibss_bss.channel)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("with bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x " " listenInterval=%d, beaconInterval = %d, beaconIeLen = %d assocReqLen=%d" " assocRespLen =%d\n", bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5], pEvt->u.infra_ibss_bss.listenInterval, pEvt->u.infra_ibss_bss.beaconInterval, beaconIeLen, assocReqLen, assocRespLen)); if (pEvt->u.infra_ibss_bss.networkType & ADHOC_NETWORK) { /* Disable BG Scan for ADHOC NETWORK */ wmi_scanparams_cmd(arPriv->arWmi, 0, 0, 0xFFFF, 0, 0, 0, WMI_SHORTSCANRATIO_DEFAULT,DEFAULT_SCAN_CTRL_FLAGS, 0, 0); if (pEvt->u.infra_ibss_bss.networkType & ADHOC_CREATOR) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Network: Adhoc (Creator)\n")); } else { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Network: Adhoc (Joiner)\n")); } } else { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Network: Infrastructure\n")); } if ((arPriv->arNetworkType == INFRA_NETWORK)) { if (arSta->arConnectPending) { wmi_listeninterval_cmd(arPriv->arWmi, arSta->arListenIntervalT, arSta->arListenIntervalB); } if (arPriv->arBitRate != -1) { if ((wmi_validate_bitrate(arPriv->arWmi, arPriv->arBitRate, &rate_idx)) != A_OK){ printk("User set rate cannot be used\n"); arPriv->arBitRate = -1; } } } if (beaconIeLen && (sizeof(buf) > (9 + beaconIeLen * 2))) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nBeaconIEs= ")); beacon_ie_pos = 0; A_MEMZERO(buf, sizeof(buf)); sprintf(buf, "%s", beaconIetag); pos = buf + 9; for (i = beacon_ie_pos; i < beacon_ie_pos + beaconIeLen; i++) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i])); sprintf(pos, "%2.2x", assocInfo[i]); pos += 2; } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n")); A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.data.length = strlen(buf); if (wrqu.data.length <= IW_CUSTOM_MAX) { wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Fail to send BeaconIEs to upper layer\n")); } } if (assocRespLen && (sizeof(buf) > (12 + (assocRespLen * 2)))) { assoc_resp_ie_pos = beaconIeLen + assocReqLen + sizeof(A_UINT16) + /* capinfo*/ sizeof(A_UINT16) + /* status Code */ sizeof(A_UINT16) ; /* associd */ A_MEMZERO(buf, sizeof(buf)); sprintf(buf, "%s", tag2); pos = buf + 12; AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nAssocRespIEs= ")); /* * The Association Response Frame w.o. the WLAN header is delivered to * the host, so skip over to the IEs */ for (i = assoc_resp_ie_pos; i < assoc_resp_ie_pos + assocRespLen - 6; i++) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i])); sprintf(pos, "%2.2x", assocInfo[i]); pos += 2; } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n")); A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.data.length = strlen(buf); if (wrqu.data.length <= IW_CUSTOM_MAX) { wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); } else { #if (WIRELESS_EXT >= 18) wrqu.data.length = (assocRespLen - 6); wireless_send_event(arPriv->arNetDev, IWEVASSOCRESPIE, &wrqu, &assocInfo[assoc_resp_ie_pos]); #else AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Fail to send Association Response to upper layer\n")); #endif } } if (assocReqLen && (sizeof(buf) > (17 + (assocReqLen * 2)))) { /* * assoc Request includes capability and listen interval. Skip these. */ assoc_req_ie_pos = beaconIeLen + sizeof(A_UINT16) + /* capinfo*/ sizeof(A_UINT16); /* listen interval */ A_MEMZERO(buf, sizeof(buf)); sprintf(buf, "%s", tag1); pos = buf + 17; AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("AssocReqIEs= ")); for (i = assoc_req_ie_pos; i < assoc_req_ie_pos + assocReqLen - 4; i++) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i])); sprintf(pos, "%2.2x", assocInfo[i]); pos += 2;; } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n")); A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.data.length = strlen(buf); if (wrqu.data.length <= IW_CUSTOM_MAX) { wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); } else { #if (WIRELESS_EXT >= 18) wrqu.data.length = (assocReqLen - 4); wireless_send_event(arPriv->arNetDev, IWEVASSOCREQIE, &wrqu, &assocInfo[assoc_req_ie_pos]); #else AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Fail to send Association Request to upper layer\n")); #endif } } #ifdef USER_KEYS if (arSta->user_savedkeys_stat == USER_SAVEDKEYS_STAT_RUN && arSta->user_saved_keys.keyOk == TRUE) { key_op_ctrl = KEY_OP_VALID_MASK & ~KEY_OP_INIT_TSC; if (arSta->user_key_ctrl & AR6000_USER_SETKEYS_RSC_UNCHANGED) { key_op_ctrl &= ~KEY_OP_INIT_RSC; } else { key_op_ctrl |= KEY_OP_INIT_RSC; } ar6000_reinstall_keys(arPriv, key_op_ctrl); } #endif /* USER_KEYS */ netif_wake_queue(arPriv->arNetDev); /* For CFG80211 the key configuration and the default key comes in after connect so no point in plumbing invalid keys */ if ((pEvt->u.infra_ibss_bss.networkType & ADHOC_NETWORK) && (OPEN_AUTH == arPriv->arDot11AuthMode) && (WMI_NONE_AUTH == arPriv->arAuthMode) && (WEP_CRYPT == arPriv->arPairwiseCrypto)) { if (!arPriv->arConnected) { wmi_addKey_cmd(arPriv->arWmi, arPriv->arDefTxKeyIndex, WEP_CRYPT, GROUP_USAGE | TX_USAGE, arPriv->arWepKeyList[arPriv->arDefTxKeyIndex].arKeyLen, NULL, arPriv->arWepKeyList[arPriv->arDefTxKeyIndex].arKey, KEY_OP_INIT_VAL, NULL, NO_SYNC_WMIFLAG); } } /* Update connect & link status atomically */ spin_lock_irqsave(&arPriv->arPrivLock, flags); netif_carrier_on(arPriv->arNetDev); spin_unlock_irqrestore(&arPriv->arPrivLock, flags); /* reset the rx aggr state */ aggr_reset_state(arPriv->conn_aggr, (void *) arPriv->arNetDev); reconnect_flag = 0; A_MEMZERO(&wrqu, sizeof(wrqu)); A_MEMCPY(wrqu.addr.sa_data, bssid, IEEE80211_ADDR_LEN); wrqu.addr.sa_family = ARPHRD_ETHER; wireless_send_event(arPriv->arNetDev, SIOCGIWAP, &wrqu, NULL); if ((arPriv->arNetworkType == ADHOC_NETWORK) && arSta->arIbssPsEnable) { A_MEMZERO(arSta->arNodeMap, sizeof(arSta->arNodeMap)); arSta->arNodeNum = 0; arSta->arNexEpId = ENDPOINT_2; } if (!arSta->arUserBssFilter) { wmi_bssfilter_cmd(arPriv->arWmi, NONE_BSS_FILTER, 0); } } void ar6000_set_numdataendpts(AR_SOFTC_DEV_T *arPriv, A_UINT32 num) { AR_SOFTC_T *ar = arPriv->arSoftc; A_ASSERT(num <= (HTC_MAILBOX_NUM_MAX - 1)); ar->arNumDataEndPts = num; } void sta_cleanup(AR_SOFTC_DEV_T *arPriv, A_UINT8 i) { struct sk_buff *skb; AR_SOFTC_T *ar = arPriv->arSoftc; AR_SOFTC_AP_T *arAp = &arPriv->arAp; /* empty the queued pkts in the PS queue if any */ A_MUTEX_LOCK(&ar->connTbl[i].psqLock); while (!A_NETBUF_QUEUE_EMPTY(&ar->connTbl[i].psq)) { skb = A_NETBUF_DEQUEUE(&ar->connTbl[i].psq); A_NETBUF_FREE(skb); } while (!A_NETBUF_QUEUE_EMPTY(&ar->connTbl[i].apsdq)) { skb = A_NETBUF_DEQUEUE(&ar->connTbl[i].apsdq); A_NETBUF_FREE(skb); } A_MUTEX_UNLOCK(&ar->connTbl[i].psqLock); /* Zero out the state fields */ A_MEMZERO(&ar->arAPStats[i], sizeof(WMI_PER_STA_STAT)); A_MEMZERO(&ar->connTbl[i].mac, ATH_MAC_LEN); A_MEMZERO(&ar->connTbl[i].wpa_ie, IEEE80211_MAX_IE); ar->connTbl[i].aid = 0; ar->connTbl[i].flags = 0; ar->connTbl[i].arPriv = NULL; ar->connTbl[i].HT_present = 0; arAp->sta_list_index =arAp->sta_list_index & ~(1 << i); aggr_reset_state(ar->connTbl[i].conn_aggr, NULL); } void ar6000_ap_cleanup(AR_SOFTC_DEV_T *arPriv) { A_UINT8 ctr; struct sk_buff *skb; AR_SOFTC_T *ar = arPriv->arSoftc; AR_SOFTC_AP_T *arAp = &arPriv->arAp; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("DEL ALL STA\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AP%d: [DOWN] SSID %s\n", arPriv->arDeviceIndex, arPriv->arSsid)); // AP + BTCOEX State variables resetted here. ar->IsdelbaTimerInitialized = FALSE; A_UNTIMEOUT(&ar->delbaTimer); ar->delbaState = REASON_DELBA_INIT; for (ctr=0; ctr < NUM_CONN; ctr++) { if(ar->connTbl[ctr].arPriv == arPriv) { remove_sta(arPriv, ar->connTbl[ctr].mac, 0); } } A_MUTEX_LOCK(&arAp->mcastpsqLock); while (!A_NETBUF_QUEUE_EMPTY(&arAp->mcastpsq)) { skb = A_NETBUF_DEQUEUE(&arAp->mcastpsq); A_NETBUF_FREE(skb); } A_MUTEX_UNLOCK(&arAp->mcastpsqLock); arPriv->arConnected = FALSE; arPriv->arTxPwr = 0; arPriv->arTxPwrSet = FALSE; } A_UINT8 remove_sta(AR_SOFTC_DEV_T *arPriv, A_UINT8 *mac, A_UINT16 reason) { A_UINT8 i, removed=0; AR_SOFTC_T *ar = arPriv->arSoftc; union iwreq_data wrqu; struct sk_buff *skb; if(IS_MAC_NULL(mac)) { return removed; } if(reason == AP_DISCONNECT_MAX_STA) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("MAX STA %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5])); return removed; } else if(reason == AP_DISCONNECT_ACL) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ACL STA %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5])); return removed; } for(i=0; i < NUM_CONN; i++) { if(A_MEMCMP(ar->connTbl[i].mac, mac, ATH_MAC_LEN)==0) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("DEL STA %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x " " aid=%d REASON=%d\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], ar->connTbl[i].aid, reason)); sta_cleanup(arPriv, i); removed = 1; /* Send event to application */ A_MEMZERO(&wrqu, sizeof(wrqu)); A_MEMCPY(wrqu.addr.sa_data, mac, ATH_MAC_LEN); wireless_send_event(arPriv->arNetDev, IWEVEXPIRED, &wrqu, NULL); break; } } /* If there are no more associated STAs, empty the mcast PS q */ if (arPriv->arAp.sta_list_index == 0) { A_MUTEX_LOCK(&arPriv->arAp.mcastpsqLock); while (!A_NETBUF_QUEUE_EMPTY(&arPriv->arAp.mcastpsq)) { skb = A_NETBUF_DEQUEUE(&arPriv->arAp.mcastpsq); A_NETBUF_FREE(skb); } A_MUTEX_UNLOCK(&arPriv->arAp.mcastpsqLock); /* Clear the LSB of the BitMapCtl field of the TIM IE */ if (ar->arWmiReady) { wmi_set_pvb_cmd(arPriv->arWmi, MCAST_AID, 0); } } return removed; } void ar6000_disconnect_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 reason, A_UINT8 *bssid, A_UINT8 assocRespLen, A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus) { A_UINT8 i; unsigned long flags; union iwreq_data wrqu; AR_SOFTC_T *ar = arPriv->arSoftc; A_BOOL bt30Devfound = FALSE; if(arPriv->arNetworkType & AP_NETWORK) { if(IS_MAC_BCAST(bssid)) { A_UINT32 tmp_regCode; tmp_regCode = arPriv->arRegCode; if(protocolReasonStatus != AP_DISCONNECT_STA_ROAM) { arPriv->arBssChannel = 0; arPriv->arChannelHint = 0; } else { arPriv->is_sta_roaming = TRUE; } ar6000_ap_cleanup(arPriv); arPriv->arRegCode = tmp_regCode; /* Concurrency: Process the pending connect of the other virtual device(s) */ ar6000_check_hold_conn_status(arPriv, FALSE); if ((protocolReasonStatus == AP_DISCONNECT_STA_ROAM) || (protocolReasonStatus == AP_DISCONNECT_DFS_CHANNEL)) { ar->arHoldConnection |= (1<arDeviceIndex); arPriv->ap_profile_flag = TRUE; } } else { remove_sta(arPriv, bssid, protocolReasonStatus); } return; } /*Skip DISCONNECT event for host intaitated Diconnect cmd*/ if((!arPriv->arSta.arHostDisconnect) || (protocolReasonStatus != 0) ) { /* Send disconnect event to supplicant */ A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.addr.sa_family = ARPHRD_ETHER; wireless_send_event(arPriv->arNetDev, SIOCGIWAP, &wrqu, NULL); } /* it is necessary to clear the host-side rx aggregation state */ aggr_reset_state(arPriv->conn_aggr, NULL); A_UNTIMEOUT(&arPriv->arSta.disconnect_timer); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 disconnected")); if (bssid[0] || bssid[1] || bssid[2] || bssid[3] || bssid[4] || bssid[5]) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" from %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ", bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5])); } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Disconnect Reason is %d, Status Code is %d", reason, protocolReasonStatus)); AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nDisconnect Reason is %d", reason)); AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nProtocol Reason/Status Code is %d", protocolReasonStatus)); AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nAssocResp Frame = %s", assocRespLen ? " " : "NULL")); for (i = 0; i < assocRespLen; i++) { if (!(i % 0x10)) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n")); } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i])); } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n")); /* * If the event is due to disconnect cmd from the host, only they the target * would stop trying to connect. Under any other condition, target would * keep trying to connect. * */ if( reason == DISCONNECT_CMD) { if ((!arPriv->arSta.arUserBssFilter) && (ar->arWmiReady) && (ar->arWlanState != WLAN_DISABLED)) { wmi_bssfilter_cmd(arPriv->arWmi, NONE_BSS_FILTER, 0); } } else { arPriv->arSta.arConnectPending = TRUE; if (((reason == ASSOC_FAILED) && (protocolReasonStatus == 0x11)) || ((reason == ASSOC_FAILED) && (protocolReasonStatus == 0x0) && (reconnect_flag == 1))) { arPriv->arConnected = TRUE; return; } } /* In the case of p2p-client, if we get a NO_NETWORK_AVAIL or LOST_LINK reason from the * firmware, issue a wmi_disconnect_cmd to the firmware to reset the firmware back to p2p-dev * state. */ if (((reason == NO_NETWORK_AVAIL) || (reason == LOST_LINK)) && (ar->arWmiReady)) { bss_t *pWmiSsidnode = NULL; wmi_scan_report_lock(arPriv->arWmi); /* remove the current associated bssid node */ wmi_free_node (arPriv->arWmi, bssid); /* * In case any other same SSID nodes are present * remove it, since those nodes also not available now */ do { /* * Find the nodes based on SSID and remove it * NOTE :: This case will not work out for Hidden-SSID */ pWmiSsidnode = wmi_find_Ssidnode (arPriv->arWmi, arPriv->arSsid, arPriv->arSsidLen, FALSE, TRUE); if (pWmiSsidnode) { wmi_free_node (arPriv->arWmi, pWmiSsidnode->ni_macaddr); } }while (pWmiSsidnode); wmi_scan_report_unlock(arPriv->arWmi); ar6000_init_profile_info(arPriv); wmi_disconnect_cmd(arPriv->arWmi); } /* Update connect & link status atomically */ spin_lock_irqsave(&arPriv->arPrivLock, flags); netif_carrier_off(arPriv->arNetDev); spin_unlock_irqrestore(&arPriv->arPrivLock, flags); if( (reason != CSERV_DISCONNECT) || (reconnect_flag != 1) ) { reconnect_flag = 0; } #ifdef USER_KEYS if (reason != CSERV_DISCONNECT) { arPriv->arSta.user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT; arPriv->arSta.user_key_ctrl = 0; } #endif /* USER_KEYS */ netif_stop_queue(arPriv->arNetDev); A_MEMZERO(arPriv->arBssid, sizeof(arPriv->arBssid)); arPriv->arBssChannel = 0; arPriv->arSta.arBeaconInterval = 0; arPriv->arConnected = FALSE; arPriv->arChannelHint = 0; arPriv->arTxPwr = 0; arPriv->arTxPwrSet = FALSE; /* Concurrency: Process the pending connect of the other virtual device(s) */ ar6000_check_hold_conn_status(arPriv, FALSE); for (i=0; i < num_device; i++) { AR_SOFTC_DEV_T *temparPriv; temparPriv = ar->arDev[i]; if (temparPriv->isBt30amp == TRUE) { bt30Devfound = TRUE; } } if (bt30Devfound == FALSE) { ar6000_TxDataCleanup(ar); } if (arPriv->arNetworkType == ADHOC_NETWORK){ /* Reset Scan params to default */ wmi_scanparams_cmd(arPriv->arWmi, 0, 0, 60, 0, 0, 0, WMI_SHORTSCANRATIO_DEFAULT,DEFAULT_SCAN_CTRL_FLAGS, 0, 0); } } void ar6000_regDomain_event(AR_SOFTC_DEV_T *arPriv, A_UINT32 regCode) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 Reg Code = 0x%x\n", regCode)); arPriv->arRegCode = regCode; } #ifdef ATH_AR6K_11N_SUPPORT #define BA_EVT_GET_CONNID(a) ((a)>>4) #define BA_EVT_GET_TID(b) ((b)&0xF) void ar6000_aggr_rcv_addba_req_evt(AR_SOFTC_DEV_T *arPriv, WMI_ADDBA_REQ_EVENT *evt) { A_UINT8 connid = BA_EVT_GET_CONNID(evt->tid); A_UINT8 tid = BA_EVT_GET_TID(evt->tid); conn_t *conn = ieee80211_find_conn_for_aid(arPriv, connid); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ADDBA REQ: tid=%d, connid=%d, status=%d, win_sz=%d\n", tid, connid, evt->status, evt->win_sz)); if(((arPriv->arNetworkType == INFRA_NETWORK) || (conn != NULL)) && evt->status == 0) { aggr_recv_addba_req_evt(get_aggr_ctx(arPriv, conn), tid, evt->st_seq_no, evt->win_sz); } } void ar6000_aggr_rcv_addba_resp_evt(AR_SOFTC_DEV_T *arPriv, WMI_ADDBA_RESP_EVENT *evt) { A_UINT8 connid = BA_EVT_GET_CONNID(evt->tid); A_UINT8 tid = BA_EVT_GET_TID(evt->tid); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ADDBA RSP: tid=%d, connid=%d, status=%d, sz=%d\n", tid, connid, evt->status, evt->amsdu_sz)); if(evt->status == 0) { } } void ar6000_aggr_rcv_delba_req_evt(AR_SOFTC_DEV_T *arPriv, WMI_DELBA_EVENT *evt) { A_UINT8 connid = BA_EVT_GET_CONNID(evt->tid); A_UINT8 tid = BA_EVT_GET_TID(evt->tid); conn_t *conn = ieee80211_find_conn_for_aid(arPriv, connid); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("DELBA REQ: tid=%d, connid=%d\n", tid, connid)); if(((arPriv->arNetworkType == INFRA_NETWORK) || (conn != NULL)) && (!evt->is_peer_initiator)) { aggr_recv_delba_req_evt(get_aggr_ctx(arPriv, conn), tid); } } #endif void register_pal_cb(ar6k_pal_config_t *palConfig_p) { ar6k_pal_config_g = *palConfig_p; } void ar6000_hci_event_rcv_evt(AR_SOFTC_DEV_T *arPriv, WMI_HCI_EVENT *cmd) { void *osbuf = NULL; A_INT8 i; A_UINT8 size, *buf; A_STATUS ret = A_OK; size = cmd->evt_buf_sz + 4; osbuf = A_NETBUF_ALLOC(size); if (osbuf == NULL) { ret = A_NO_MEMORY; AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Error in allocating netbuf \n")); return; } A_NETBUF_PUT(osbuf, size); buf = (A_UINT8 *)A_NETBUF_DATA(osbuf); /* First 2-bytes carry HCI event/ACL data type * the next 2 are free */ *((short *)buf) = WMI_HCI_EVENT_EVENTID; buf += sizeof(int); A_MEMCPY(buf, cmd->buf, cmd->evt_buf_sz); if(ar6k_pal_config_g.fpar6k_pal_recv_pkt) { /* pass the cmd packet to PAL driver */ if((*ar6k_pal_config_g.fpar6k_pal_recv_pkt)(arPriv->hcipal_info, osbuf) == TRUE) return; } ar6000_deliver_frames_to_nw_stack(arPriv->arNetDev, osbuf); if(loghci) { A_PRINTF_LOG("HCI Event From PAL <-- \n"); for(i = 0; i < cmd->evt_buf_sz; i++) { A_PRINTF_LOG("0x%02x ", cmd->buf[i]); if((i % 10) == 0) { A_PRINTF_LOG("\n"); } } A_PRINTF_LOG("\n"); A_PRINTF_LOG("==================================\n"); } } void ar6000_neighborReport_event(AR_SOFTC_DEV_T *arPriv, int numAps, WMI_NEIGHBOR_INFO *info) { #if WIRELESS_EXT >= 18 struct iw_pmkid_cand *pmkcand; #else /* WIRELESS_EXT >= 18 */ static const char *tag = "PRE-AUTH"; char buf[128]; #endif /* WIRELESS_EXT >= 18 */ union iwreq_data wrqu; int i; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 Neighbor Report Event\n")); for (i=0; i < numAps; info++, i++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ", info->bssid[0], info->bssid[1], info->bssid[2], info->bssid[3], info->bssid[4], info->bssid[5])); if (info->bssFlags & WMI_PREAUTH_CAPABLE_BSS) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("preauth-cap")); } if (info->bssFlags & WMI_PMKID_VALID_BSS) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" pmkid-valid\n")); continue; /* we skip bss if the pmkid is already valid */ } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("\n")); A_MEMZERO(&wrqu, sizeof(wrqu)); #if WIRELESS_EXT >= 18 pmkcand = A_MALLOC_NOWAIT(sizeof(struct iw_pmkid_cand)); if (pmkcand == NULL) return; A_MEMZERO(pmkcand, sizeof(struct iw_pmkid_cand)); pmkcand->index = i; pmkcand->flags = info->bssFlags; A_MEMCPY(pmkcand->bssid.sa_data, info->bssid, ATH_MAC_LEN); wrqu.data.length = sizeof(struct iw_pmkid_cand); wireless_send_event(arPriv->arNetDev, IWEVPMKIDCAND, &wrqu, (char *)pmkcand); A_FREE(pmkcand); #else /* WIRELESS_EXT >= 18 */ snprintf(buf, sizeof(buf), "%s%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x", tag, info->bssid[0], info->bssid[1], info->bssid[2], info->bssid[3], info->bssid[4], info->bssid[5], i, info->bssFlags); wrqu.data.length = strlen(buf); wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); #endif /* WIRELESS_EXT >= 18 */ } } void ar6000_indicate_proberesp(AR_SOFTC_DEV_T *arPriv , A_UINT8* pData , A_UINT16 len ,A_UINT8* bssid) { } void ar6000_indicate_beacon(AR_SOFTC_DEV_T *arPriv, A_UINT8* pData , A_UINT16 len ,A_UINT8* bssid) { } void ar6000_assoc_req_report_event (void *context, A_UINT8 status, A_UINT8 rspType, A_UINT8* pData, int len) { } void ar6000_tkip_micerr_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 keyid, A_BOOL ismcast) { static const char *tag = "MLME-MICHAELMICFAILURE.indication"; char buf[128]; union iwreq_data wrqu; /* * For AP case, keyid will have aid of STA which sent pkt with * MIC error. Use this aid to get MAC & send it to hostapd. */ if (arPriv->arNetworkType == AP_NETWORK) { conn_t *s = ieee80211_find_conn_for_aid(arPriv, (keyid >> 2)); if(!s){ AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AP TKIP MIC error received from Invalid aid / STA not found =%d\n", keyid)); return; } AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AP TKIP MIC error received from aid=%d\n", keyid)); snprintf(buf,sizeof(buf), "%s addr=%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x", tag, s->mac[0],s->mac[1],s->mac[2],s->mac[3],s->mac[4],s->mac[5]); } else { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR6000 TKIP MIC error received for keyid %d %scast\n", keyid & 0x3, ismcast ? "multi": "uni")); snprintf(buf, sizeof(buf), "%s(keyid=%d %sicast)", tag, keyid & 0x3, ismcast ? "mult" : "un"); } memset(&wrqu, 0, sizeof(wrqu)); wrqu.data.length = strlen(buf); wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); } void ar6000_scanComplete_event(AR_SOFTC_DEV_T *arPriv, A_STATUS status) { if ((arPriv->arSoftc->arWmiReady) && (arPriv->arWmiEnabled) && (arPriv->arSoftc->arWlanState==WLAN_ENABLED)) { if (!arPriv->arSta.arUserBssFilter) { wmi_bssfilter_cmd(arPriv->arWmi, NONE_BSS_FILTER, 0); } } if (arPriv->arSta.scan_triggered) { union iwreq_data wrqu; A_MEMZERO(&wrqu, sizeof(wrqu)); wireless_send_event(arPriv->arNetDev, SIOCGIWSCAN, &wrqu, NULL); arPriv->arSta.scan_triggered = 0; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,( "AR6000 scan complete: %d\n", status)); wake_up_interruptible(&scan_complete); } void ar6000_targetStats_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 *ptr, A_UINT32 len) { A_UINT8 ac, i; if(arPriv->arNetworkType == AP_NETWORK) { WMI_AP_MODE_STAT *p = (WMI_AP_MODE_STAT *)ptr; WMI_PER_STA_STAT *ap = arPriv->arSoftc->arAPStats; if (len < sizeof(*p)) { return; } for(ac=0;acsta[ac].aid == 0) { continue; } i = p->sta[ac].aid-1; ap[i].tx_bytes += p->sta[ac].tx_bytes; ap[i].tx_pkts += p->sta[ac].tx_pkts; ap[i].tx_error += p->sta[ac].tx_error; ap[i].tx_discard += p->sta[ac].tx_discard; ap[i].rx_bytes += p->sta[ac].rx_bytes; ap[i].rx_pkts += p->sta[ac].rx_pkts; ap[i].rx_error += p->sta[ac].rx_error; ap[i].rx_discard += p->sta[ac].rx_discard; } } else { WMI_TARGET_STATS *pTarget = (WMI_TARGET_STATS *)ptr; TARGET_STATS *pStats = &arPriv->arTargetStats; if (len < sizeof(*pTarget)) { return; } // Update the RSSI of the connected bss. if (arPriv->arConnected) { bss_t *pConnBss = NULL; wmi_scan_report_lock(arPriv->arWmi); pConnBss = wmi_find_node(arPriv->arWmi,arPriv->arBssid); if (pConnBss) { pConnBss->ni_rssi = pTarget->cservStats.cs_aveBeacon_rssi; pConnBss->ni_snr = pTarget->cservStats.cs_aveBeacon_snr; wmi_node_return(arPriv->arWmi, pConnBss); } wmi_scan_report_unlock(arPriv->arWmi); } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 updating target stats\n")); pStats->tx_packets += pTarget->txrxStats.tx_stats.tx_packets; pStats->tx_bytes += pTarget->txrxStats.tx_stats.tx_bytes; pStats->tx_unicast_pkts += pTarget->txrxStats.tx_stats.tx_unicast_pkts; pStats->tx_unicast_bytes += pTarget->txrxStats.tx_stats.tx_unicast_bytes; pStats->tx_multicast_pkts += pTarget->txrxStats.tx_stats.tx_multicast_pkts; pStats->tx_multicast_bytes += pTarget->txrxStats.tx_stats.tx_multicast_bytes; pStats->tx_broadcast_pkts += pTarget->txrxStats.tx_stats.tx_broadcast_pkts; pStats->tx_broadcast_bytes += pTarget->txrxStats.tx_stats.tx_broadcast_bytes; pStats->tx_rts_success_cnt += pTarget->txrxStats.tx_stats.tx_rts_success_cnt; for(ac = 0; ac < WMM_NUM_AC; ac++) pStats->tx_packet_per_ac[ac] += pTarget->txrxStats.tx_stats.tx_packet_per_ac[ac]; pStats->tx_errors += pTarget->txrxStats.tx_stats.tx_errors; pStats->tx_failed_cnt += pTarget->txrxStats.tx_stats.tx_failed_cnt; pStats->tx_retry_cnt += pTarget->txrxStats.tx_stats.tx_retry_cnt; pStats->tx_mult_retry_cnt += pTarget->txrxStats.tx_stats.tx_mult_retry_cnt; pStats->tx_rts_fail_cnt += pTarget->txrxStats.tx_stats.tx_rts_fail_cnt; pStats->tx_unicast_rate = wmi_get_rate(pTarget->txrxStats.tx_stats.tx_unicast_rate); pStats->rx_packets += pTarget->txrxStats.rx_stats.rx_packets; pStats->rx_bytes += pTarget->txrxStats.rx_stats.rx_bytes; pStats->rx_unicast_pkts += pTarget->txrxStats.rx_stats.rx_unicast_pkts; pStats->rx_unicast_bytes += pTarget->txrxStats.rx_stats.rx_unicast_bytes; pStats->rx_multicast_pkts += pTarget->txrxStats.rx_stats.rx_multicast_pkts; pStats->rx_multicast_bytes += pTarget->txrxStats.rx_stats.rx_multicast_bytes; pStats->rx_broadcast_pkts += pTarget->txrxStats.rx_stats.rx_broadcast_pkts; pStats->rx_broadcast_bytes += pTarget->txrxStats.rx_stats.rx_broadcast_bytes; pStats->rx_fragment_pkt += pTarget->txrxStats.rx_stats.rx_fragment_pkt; pStats->rx_errors += pTarget->txrxStats.rx_stats.rx_errors; pStats->rx_crcerr += pTarget->txrxStats.rx_stats.rx_crcerr; pStats->rx_key_cache_miss += pTarget->txrxStats.rx_stats.rx_key_cache_miss; pStats->rx_decrypt_err += pTarget->txrxStats.rx_stats.rx_decrypt_err; pStats->rx_duplicate_frames += pTarget->txrxStats.rx_stats.rx_duplicate_frames; pStats->rx_unicast_rate = wmi_get_rate(pTarget->txrxStats.rx_stats.rx_unicast_rate); pStats->tkip_local_mic_failure += pTarget->txrxStats.tkipCcmpStats.tkip_local_mic_failure; pStats->tkip_counter_measures_invoked += pTarget->txrxStats.tkipCcmpStats.tkip_counter_measures_invoked; pStats->tkip_replays += pTarget->txrxStats.tkipCcmpStats.tkip_replays; pStats->tkip_format_errors += pTarget->txrxStats.tkipCcmpStats.tkip_format_errors; pStats->ccmp_format_errors += pTarget->txrxStats.tkipCcmpStats.ccmp_format_errors; pStats->ccmp_replays += pTarget->txrxStats.tkipCcmpStats.ccmp_replays; pStats->power_save_failure_cnt += pTarget->pmStats.power_save_failure_cnt; pStats->noise_floor_calibation = pTarget->noise_floor_calibation; pStats->cs_bmiss_cnt += pTarget->cservStats.cs_bmiss_cnt; pStats->cs_lowRssi_cnt += pTarget->cservStats.cs_lowRssi_cnt; pStats->cs_connect_cnt += pTarget->cservStats.cs_connect_cnt; pStats->cs_disconnect_cnt += pTarget->cservStats.cs_disconnect_cnt; pStats->cs_aveBeacon_snr = pTarget->cservStats.cs_aveBeacon_snr; pStats->cs_aveBeacon_rssi = pTarget->cservStats.cs_aveBeacon_rssi; if (enablerssicompensation) { pStats->cs_aveBeacon_rssi = rssi_compensation_calc(arPriv, pStats->cs_aveBeacon_rssi); } pStats->cs_lastRoam_msec = pTarget->cservStats.cs_lastRoam_msec; pStats->cs_snr = pTarget->cservStats.cs_snr; pStats->cs_rssi = pTarget->cservStats.cs_rssi; pStats->lq_val = pTarget->lqVal; pStats->wow_num_pkts_dropped += pTarget->wowStats.wow_num_pkts_dropped; pStats->wow_num_host_pkt_wakeups += pTarget->wowStats.wow_num_host_pkt_wakeups; pStats->wow_num_host_event_wakeups += pTarget->wowStats.wow_num_host_event_wakeups; pStats->wow_num_events_discarded += pTarget->wowStats.wow_num_events_discarded; pStats->arp_received += pTarget->arpStats.arp_received; pStats->arp_matched += pTarget->arpStats.arp_matched; pStats->arp_replied += pTarget->arpStats.arp_replied; if (arPriv->statsUpdatePending) { arPriv->statsUpdatePending = FALSE; wake_up(&arPriv->arEvent); } } } void ar6000_rssiThreshold_event(AR_SOFTC_DEV_T *arPriv, WMI_RSSI_THRESHOLD_VAL newThreshold, A_INT16 rssi) { USER_RSSI_THOLD userRssiThold; rssi = rssi + SIGNAL_QUALITY_NOISE_FLOOR; if (enablerssicompensation) { rssi = rssi_compensation_calc(arPriv, rssi); } /* Send an event to the app */ userRssiThold.tag = arPriv->arSta.rssi_map[newThreshold].tag; userRssiThold.rssi = rssi; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("rssi Threshold range = %d tag = %d rssi = %d\n", newThreshold, userRssiThold.tag, userRssiThold.rssi)); ar6000_send_event_to_app(arPriv, WMI_RSSI_THRESHOLD_EVENTID,(A_UINT8 *)&userRssiThold, sizeof(USER_RSSI_THOLD)); } void ar6000_hbChallengeResp_event(AR_SOFTC_DEV_T *arPriv, A_UINT32 cookie, A_UINT32 source) { AR_SOFTC_T *ar = arPriv->arSoftc; if (source == APP_HB_CHALLENGE) { /* Report it to the app in case it wants a positive acknowledgement */ ar6000_send_event_to_app(arPriv, WMIX_HB_CHALLENGE_RESP_EVENTID, (A_UINT8 *)&cookie, sizeof(cookie)); } else { /* This would ignore the replys that come in after their due time */ if (cookie == ar->arHBChallengeResp.seqNum) { ar->arHBChallengeResp.outstanding = FALSE; } } } void ar6000_reportError_event(AR_SOFTC_DEV_T *arPriv, WMI_TARGET_ERROR_VAL errorVal) { char *errString[] = { [WMI_TARGET_PM_ERR_FAIL] "WMI_TARGET_PM_ERR_FAIL", [WMI_TARGET_KEY_NOT_FOUND] "WMI_TARGET_KEY_NOT_FOUND", [WMI_TARGET_DECRYPTION_ERR] "WMI_TARGET_DECRYPTION_ERR", [WMI_TARGET_BMISS] "WMI_TARGET_BMISS", [WMI_PSDISABLE_NODE_JOIN] "WMI_PSDISABLE_NODE_JOIN" }; AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR6000 Error on Target. Error = 0x%x\n", errorVal)); /* One error is reported at a time, and errorval is a bitmask */ if(errorVal & (errorVal - 1)) return; AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("AR6000 Error type = ")); switch(errorVal) { case WMI_TARGET_PM_ERR_FAIL: case WMI_TARGET_KEY_NOT_FOUND: case WMI_TARGET_DECRYPTION_ERR: case WMI_TARGET_BMISS: case WMI_PSDISABLE_NODE_JOIN: AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s\n", errString[errorVal])); break; default: AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("INVALID\n")); break; } } void ar6000_cac_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 ac, A_UINT8 cacIndication, A_UINT8 statusCode, A_UINT8 *tspecSuggestion) { WMM_TSPEC_IE *tspecIe; /* * This is the TSPEC IE suggestion from AP. * Suggestion provided by AP under some error * cases, could be helpful for the host app. * Check documentation. */ tspecIe = (WMM_TSPEC_IE *)tspecSuggestion; /* * What do we do, if we get TSPEC rejection? One thought * that comes to mind is implictly delete the pstream... */ AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 CAC notification. " "AC = %d, cacIndication = 0x%x, statusCode = 0x%x\n", ac, cacIndication, statusCode)); } void ar6000_channel_change_event(AR_SOFTC_DEV_T *arPriv, A_UINT16 oldChannel, A_UINT16 newChannel) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Channel Change notification\nOld Channel: %d, New Channel: %d\n", oldChannel, newChannel)); } #define AR6000_PRINT_BSSID(_pBss) do { \ A_PRINTF("%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",\ (_pBss)[0],(_pBss)[1],(_pBss)[2],(_pBss)[3],\ (_pBss)[4],(_pBss)[5]); \ } while(0) void ar6000_roam_tbl_event(AR_SOFTC_DEV_T *arPriv, WMI_TARGET_ROAM_TBL *pTbl) { A_UINT8 i; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ROAM TABLE NO OF ENTRIES is %d ROAM MODE is %d\n", pTbl->numEntries, pTbl->roamMode)); for (i= 0; i < pTbl->numEntries; i++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("[%d]bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ", i, pTbl->bssRoamInfo[i].bssid[0], pTbl->bssRoamInfo[i].bssid[1], pTbl->bssRoamInfo[i].bssid[2], pTbl->bssRoamInfo[i].bssid[3], pTbl->bssRoamInfo[i].bssid[4], pTbl->bssRoamInfo[i].bssid[5])); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("RSSI %d RSSIDT %d LAST RSSI %d UTIL %d ROAM_UTIL %d" " BIAS %d\n", pTbl->bssRoamInfo[i].rssi, pTbl->bssRoamInfo[i].rssidt, pTbl->bssRoamInfo[i].last_rssi, pTbl->bssRoamInfo[i].util, pTbl->bssRoamInfo[i].roam_util, pTbl->bssRoamInfo[i].bias)); } } void ar6000_wow_list_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 num_filters, WMI_GET_WOW_LIST_REPLY *wow_reply) { A_UINT8 i,j; /*Each event now contains exactly one filter, see bug 26613*/ AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("WOW pattern %d of %d patterns\n", wow_reply->this_filter_num, wow_reply->num_filters)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("wow mode = %s host mode = %s\n", (wow_reply->wow_mode == 0? "disabled":"enabled"), (wow_reply->host_mode == 1 ? "awake":"asleep"))); /*If there are no patterns, the reply will only contain generic WoW information. Pattern information will exist only if there are patterns present. Bug 26716*/ /* If this event contains pattern information, display it*/ if (wow_reply->this_filter_num) { i=0; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("id=%d size=%d offset=%d\n", wow_reply->wow_filters[i].wow_filter_id, wow_reply->wow_filters[i].wow_filter_size, wow_reply->wow_filters[i].wow_filter_offset)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("wow pattern = ")); for (j=0; j< wow_reply->wow_filters[i].wow_filter_size; j++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%2.2x",wow_reply->wow_filters[i].wow_filter_pattern[j])); } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("\nwow mask = ")); for (j=0; j< wow_reply->wow_filters[i].wow_filter_size; j++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%2.2x",wow_reply->wow_filters[i].wow_filter_mask[j])); } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("\n")); } } /* * Report the Roaming related data collected on the target */ void ar6000_display_roam_time(WMI_TARGET_ROAM_TIME *p) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Disconnect Data : BSSID: ")); AR6000_PRINT_BSSID(p->disassoc_bssid); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" RSSI %d DISASSOC Time %d NO_TXRX_TIME %d\n", p->disassoc_bss_rssi,p->disassoc_time, p->no_txrx_time)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Connect Data: BSSID: ")); AR6000_PRINT_BSSID(p->assoc_bssid); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" RSSI %d ASSOC Time %d TXRX_TIME %d\n", p->assoc_bss_rssi,p->assoc_time, p->allow_txrx_time)); } void ar6000_roam_data_event(AR_SOFTC_DEV_T *arPriv, WMI_TARGET_ROAM_DATA *p) { switch (p->roamDataType) { case ROAM_DATA_TIME: ar6000_display_roam_time(&p->u.roamTime); break; default: break; } } void ar6000_bssInfo_event_rx(AR_SOFTC_DEV_T *arPriv, A_UINT8 *datap, int len) { struct sk_buff *skb; WMI_BSS_INFO_HDR *bih = (WMI_BSS_INFO_HDR *)datap; if (!arPriv->arSta.arMgmtFilter) { return; } if (((arPriv->arSta.arMgmtFilter & IEEE80211_FILTER_TYPE_BEACON) && (bih->frameType != BEACON_FTYPE)) || ((arPriv->arSta.arMgmtFilter & IEEE80211_FILTER_TYPE_PROBE_RESP) && (bih->frameType != PROBERESP_FTYPE))) { return; } if ((skb = A_NETBUF_ALLOC_RAW(len)) != NULL) { A_NETBUF_PUT(skb, len); A_MEMCPY(A_NETBUF_DATA(skb), datap, len); skb->dev = arPriv->arNetDev; #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) A_MEMCPY(skb_mac_header(skb), A_NETBUF_DATA(skb), 6); #else skb->mac.raw = A_NETBUF_DATA(skb); #endif skb->ip_summed = CHECKSUM_NONE; skb->pkt_type = PACKET_OTHERHOST; skb->protocol = __constant_htons(0x0019); A_NETIF_RX(skb); } } A_UINT32 wmiSendCmdNum; A_STATUS ar6000_control_tx(void *devt, void *osbuf, HTC_ENDPOINT_ID eid) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; AR_SOFTC_T *ar = arPriv->arSoftc; A_STATUS status = A_OK; struct ar_cookie *cookie = NULL; int i; #ifdef CONFIG_PM if (ar->arWowState == WLAN_WOW_STATE_SUSPENDED) { return A_EACCES; } #endif /* CONFIG_PM */ /* take lock to protect ar6000_alloc_cookie() */ AR6000_SPIN_LOCK(&ar->arLock, 0); do { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("ar_contrstatus = ol_tx: skb=0x%x, len=0x%x eid =%d\n", (A_UINT32)osbuf, A_NETBUF_LEN(osbuf), eid)); if (ar->arWMIControlEpFull && (eid == ar->arControlEp)) { /* control endpoint is full, don't allocate resources, we * are just going to drop this packet */ cookie = NULL; AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" WMI Control EP full, dropping packet : 0x%X, len:%d \n", (A_UINT32)osbuf, A_NETBUF_LEN(osbuf))); } else { cookie = ar6000_alloc_cookie(ar); } if (cookie == NULL) { status = A_NO_MEMORY; break; } if(logWmiRawMsgs) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("WMI cmd send, msgNo %d :", wmiSendCmdNum)); for(i = 0; i < a_netbuf_to_len(osbuf); i++) AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%x ", ((A_UINT8 *)a_netbuf_to_data(osbuf))[i])); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("\n")); } wmiSendCmdNum++; } while (FALSE); if (cookie != NULL) { /* got a structure to send it out on */ ar->arTxPending[eid]++; if (eid != ar->arControlEp) { ar->arTotalTxDataPending++; } /* Increment number of cookies allocated for control packets */ ar->arControlCookieCount++; } AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (cookie != NULL) { cookie->arc_bp[0] = (A_UINT32)osbuf; cookie->arc_bp[1] = 0; SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt, cookie, A_NETBUF_DATA(osbuf), A_NETBUF_LEN(osbuf), eid, AR6K_CONTROL_PKT_TAG); /* this interface is asynchronous, if there is an error, cleanup will happen in the * TX completion callback */ HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt); status = A_OK; } return status; } /* indicate tx activity or inactivity on a WMI stream */ void ar6000_indicate_tx_activity(void *devt, A_UINT8 TrafficClass, A_BOOL Active) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; AR_SOFTC_T *ar = arPriv->arSoftc; HTC_ENDPOINT_ID eid ; int i; if (ar->arWmiReady) { eid = arAc2EndpointID(ar, TrafficClass); AR6000_SPIN_LOCK(&ar->arLock, 0); ar->arAcStreamActive[TrafficClass] = Active; if (Active) { /* when a stream goes active, keep track of the active stream with the highest priority */ if (ar->arAcStreamPriMap[TrafficClass] > ar->arHiAcStreamActivePri) { /* set the new highest active priority */ ar->arHiAcStreamActivePri = ar->arAcStreamPriMap[TrafficClass]; } } else { /* when a stream goes inactive, we may have to search for the next active stream * that is the highest priority */ if (ar->arHiAcStreamActivePri == ar->arAcStreamPriMap[TrafficClass]) { /* the highest priority stream just went inactive */ /* reset and search for the "next" highest "active" priority stream */ ar->arHiAcStreamActivePri = 0; for (i = 0; i < WMM_NUM_AC; i++) { if (ar->arAcStreamActive[i]) { if (ar->arAcStreamPriMap[i] > ar->arHiAcStreamActivePri) { /* set the new highest active priority */ ar->arHiAcStreamActivePri = ar->arAcStreamPriMap[i]; } } } } } AR6000_SPIN_UNLOCK(&ar->arLock, 0); } else { /* for mbox ping testing, the traffic class is mapped directly as a stream ID, * see handling of AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE in ioctl.c * convert the stream ID to a endpoint */ eid = arAc2EndpointID(ar, TrafficClass); } /* notify HTC, this may cause credit distribution changes */ if (eid < 0 || eid >= ENDPOINT_MAX) return; HTCIndicateActivityChange(ar->arHtcTarget, eid, Active); } void ar6000_btcoex_config_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 *ptr, A_UINT32 len) { WMI_BTCOEX_CONFIG_EVENT *pBtcoexConfig = (WMI_BTCOEX_CONFIG_EVENT *)ptr; WMI_BTCOEX_CONFIG_EVENT *pArbtcoexConfig =&arPriv->arBtcoexConfig; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 BTCOEX CONFIG EVENT \n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("received config event\n")); pArbtcoexConfig->btProfileType = pBtcoexConfig->btProfileType; pArbtcoexConfig->linkId = pBtcoexConfig->linkId; switch (pBtcoexConfig->btProfileType) { case WMI_BTCOEX_BT_PROFILE_SCO: A_MEMCPY(&pArbtcoexConfig->info.scoConfigCmd, &pBtcoexConfig->info.scoConfigCmd, sizeof(WMI_SET_BTCOEX_SCO_CONFIG_CMD)); break; case WMI_BTCOEX_BT_PROFILE_A2DP: A_MEMCPY(&pArbtcoexConfig->info.a2dpConfigCmd, &pBtcoexConfig->info.a2dpConfigCmd, sizeof(WMI_SET_BTCOEX_A2DP_CONFIG_CMD)); break; case WMI_BTCOEX_BT_PROFILE_ACLCOEX: A_MEMCPY(&pArbtcoexConfig->info.aclcoexConfig, &pBtcoexConfig->info.aclcoexConfig, sizeof(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD)); break; case WMI_BTCOEX_BT_PROFILE_INQUIRY_PAGE: A_MEMCPY(&pArbtcoexConfig->info.btinquiryPageConfigCmd, &pBtcoexConfig->info.btinquiryPageConfigCmd, sizeof(WMI_SET_BTCOEX_BTINQUIRY_PAGE_CONFIG_CMD)); break; } if (arPriv->statsUpdatePending) { arPriv->statsUpdatePending = FALSE; wake_up(&arPriv->arEvent); } } void ar6000_btcoex_stats_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 *ptr, A_UINT32 len) { WMI_BTCOEX_STATS_EVENT *pBtcoexStats = (WMI_BTCOEX_STATS_EVENT *)ptr; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 BTCOEX CONFIG EVENT \n")); A_MEMCPY(&arPriv->arBtcoexStats, pBtcoexStats, sizeof(WMI_BTCOEX_STATS_EVENT)); if (arPriv->statsUpdatePending) { arPriv->statsUpdatePending = FALSE; wake_up(&arPriv->arEvent); } } void ar6000_wacinfo_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 *ptr, A_UINT32 len) { } module_init(ar6000_init_module); module_exit(ar6000_cleanup_module); /* Init cookie queue */ static void ar6000_cookie_init(AR_SOFTC_T *ar) { A_UINT32 i; ar->arCookieList = NULL; ar->arCookieCount = 0; A_MEMZERO(s_ar_cookie_mem, sizeof(s_ar_cookie_mem)); for (i = 0; i < MAX_COOKIE_NUM; i++) { ar6000_free_cookie(ar, &s_ar_cookie_mem[i]); } } /* cleanup cookie queue */ static void ar6000_cookie_cleanup(AR_SOFTC_T *ar) { /* It is gone .... */ ar->arCookieList = NULL; ar->arCookieCount = 0; ar->arControlCookieCount = 0; } /* Init cookie queue */ static void ar6000_free_cookie(AR_SOFTC_T *ar, struct ar_cookie * cookie) { /* Insert first */ A_ASSERT(ar != NULL); if (ar == NULL) return; A_ASSERT(cookie != NULL); if (cookie == NULL) return; cookie->arc_list_next = ar->arCookieList; ar->arCookieList = cookie; ar->arCookieCount++; } /* cleanup cookie queue */ static struct ar_cookie * ar6000_alloc_cookie(AR_SOFTC_T *ar) { struct ar_cookie *cookie; if (ar == NULL) return NULL; cookie = ar->arCookieList; if(cookie != NULL) { ar->arCookieList = cookie->arc_list_next; ar->arCookieCount--; } return cookie; } #ifdef SEND_EVENT_TO_APP /* * This function is used to send event which come from taget to * the application. The buf which send to application is include * the event ID and event content. */ #define EVENT_ID_LEN 2 void ar6000_send_event_to_app(AR_SOFTC_DEV_T *arPriv, A_UINT16 eventId, A_UINT8 *datap, int len) { #if (WIRELESS_EXT >= 15) /* note: IWEVCUSTOM only exists in wireless extensions after version 15 */ char *buf; A_UINT16 size; union iwreq_data wrqu; size = len + EVENT_ID_LEN; if (size > IW_CUSTOM_MAX) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI event ID : 0x%4.4X, len = %d too big for IWEVCUSTOM (max=%d) \n", eventId, size, IW_CUSTOM_MAX)); return; } /*Dont send DISCONNECT event to APP for host drv intiated Disconnect cmd*/ if((eventId == WMI_DISCONNECT_EVENTID) && arPriv->arSta.arHostDisconnect ) { arPriv->arSta.arHostDisconnect = 0; } buf = A_MALLOC_NOWAIT(size); if (NULL == buf){ AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: failed to allocate %d bytes\n", __func__, size)); return; } A_MEMZERO(buf, size); A_MEMCPY(buf, &eventId, EVENT_ID_LEN); A_MEMCPY(buf+EVENT_ID_LEN, datap, len); //AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("event ID = %d,len = %d\n",*(A_UINT16*)buf, size)); A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.data.length = size; wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); A_FREE(buf); #endif } /* * This function is used to send events larger than 256 bytes * to the application. The buf which is sent to application * includes the event ID and event content. */ void ar6000_send_generic_event_to_app(AR_SOFTC_DEV_T *arPriv, A_UINT16 eventId, A_UINT8 *datap, int len) { #if (WIRELESS_EXT >= 18) /* IWEVGENIE exists in wireless extensions version 18 onwards */ char *buf; A_UINT16 size; union iwreq_data wrqu; size = len + EVENT_ID_LEN; if (size > IW_GENERIC_IE_MAX) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI event ID : 0x%4.4X, len = %d too big for IWEVGENIE (max=%d) \n", eventId, size, IW_GENERIC_IE_MAX)); return; } buf = A_MALLOC_NOWAIT(size); if (NULL == buf){ AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: failed to allocate %d bytes\n", __func__, size)); return; } A_MEMZERO(buf, size); A_MEMCPY(buf, &eventId, EVENT_ID_LEN); A_MEMCPY(buf+EVENT_ID_LEN, datap, len); A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.data.length = size; wireless_send_event(arPriv->arNetDev, IWEVGENIE, &wrqu, buf); A_FREE(buf); #endif /* (WIRELESS_EXT >= 18) */ } #endif /* SEND_EVENT_TO_APP */ void ar6000_tx_retry_err_event(void *devt) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Tx retries reach maximum!\n")); } void ar6000_snrThresholdEvent_rx(void *devt, WMI_SNR_THRESHOLD_VAL newThreshold, A_UINT8 snr) { WMI_SNR_THRESHOLD_EVENT event; AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; event.range = newThreshold; event.snr = snr; ar6000_send_event_to_app(arPriv, WMI_SNR_THRESHOLD_EVENTID, (A_UINT8 *)&event, sizeof(WMI_SNR_THRESHOLD_EVENT)); } void ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL newThreshold, A_UINT8 lq) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("lq threshold range %d, lq %d\n", newThreshold, lq)); } A_UINT32 a_copy_to_user(void *to, const void *from, A_UINT32 n) { return(copy_to_user(to, from, n)); } A_UINT32 a_copy_from_user(void *to, const void *from, A_UINT32 n) { return(copy_from_user(to, from, n)); } A_STATUS ar6000_get_driver_cfg(struct net_device *dev, A_UINT16 cfgParam, void *result) { A_STATUS ret = A_OK; switch(cfgParam) { case AR6000_DRIVER_CFG_GET_WLANNODECACHING: *((A_UINT32 *)result) = wlanNodeCaching; break; case AR6000_DRIVER_CFG_LOG_RAW_WMI_MSGS: *((A_UINT32 *)result) = logWmiRawMsgs; break; default: ret = A_EINVAL; break; } return ret; } void ar6000_keepalive_rx(void *devt, A_UINT8 configured) { AR_SOFTC_DEV_T *arPriv = (AR_SOFTC_DEV_T *)devt; arPriv->arSta.arKeepaliveConfigured = configured; wake_up(&arPriv->arEvent); } void ar6000_pmkid_list_event(void *devt, A_UINT8 numPMKID, WMI_PMKID *pmkidList, A_UINT8 *bssidList) { A_UINT8 i, j; AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Number of Cached PMKIDs is %d\n", numPMKID)); for (i = 0; i < numPMKID; i++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("\nBSSID %d ", i)); for (j = 0; j < ATH_MAC_LEN; j++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%2.2x", bssidList[j])); } bssidList += (ATH_MAC_LEN + WMI_PMKID_LEN); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("\nPMKID %d ", i)); for (j = 0; j < WMI_PMKID_LEN; j++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%2.2x", pmkidList->pmkid[j])); } pmkidList = (WMI_PMKID *)((A_UINT8 *)pmkidList + ATH_MAC_LEN + WMI_PMKID_LEN); } } void ar6000_pspoll_event(AR_SOFTC_DEV_T *arPriv,A_UINT8 aid) { conn_t *conn=NULL; A_BOOL isPsqEmpty = FALSE; conn = ieee80211_find_conn_for_aid(arPriv, aid); if(!conn) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("PS-POLL from invalid STA\n")); return; } /* If the PS q for this STA is not empty, dequeue and send a pkt from * the head of the q. Also update the More data bit in the WMI_DATA_HDR * if there are more pkts for this STA in the PS q. If there are no more * pkts for this STA, update the PVB for this STA. */ A_MUTEX_LOCK(&conn->psqLock); isPsqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->psq); A_MUTEX_UNLOCK(&conn->psqLock); if (isPsqEmpty) { /* TODO:No buffered pkts for this STA. Send out a NULL data frame */ } else { struct sk_buff *skb = NULL; A_MUTEX_LOCK(&conn->psqLock); skb = A_NETBUF_DEQUEUE(&conn->psq); A_MUTEX_UNLOCK(&conn->psqLock); /* Set the STA flag to PSPolled, so that the frame will go out */ STA_SET_PS_POLLED(conn); ar6000_data_tx(skb, arPriv->arNetDev); STA_CLR_PS_POLLED(conn); A_MUTEX_LOCK(&conn->psqLock); isPsqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->psq); A_MUTEX_UNLOCK(&conn->psqLock); } /* Clear the PVB for this STA if the queue has become empty */ if (isPsqEmpty) { wmi_set_pvb_cmd(arPriv->arWmi, conn->aid, 0); } } void ar6000_dtimexpiry_event(AR_SOFTC_DEV_T *arPriv) { A_BOOL isMcastQueued = FALSE; struct sk_buff *skb = NULL; AR_SOFTC_AP_T *arAp = &arPriv->arAp; /* If there are no associated STAs, ignore the DTIM expiry event. * There can be potential race conditions where the last associated * STA may disconnect & before the host could clear the 'Indicate DTIM' * request to the firmware, the firmware would have just indicated a DTIM * expiry event. The race is between 'clear DTIM expiry cmd' going * from the host to the firmware & the DTIM expiry event happening from * the firmware to the host. */ if (arAp->sta_list_index == 0) { return; } A_MUTEX_LOCK(&arAp->mcastpsqLock); isMcastQueued = A_NETBUF_QUEUE_EMPTY(&arAp->mcastpsq); A_MUTEX_UNLOCK(&arAp->mcastpsqLock); if(isMcastQueued == TRUE) { return; } /* Flush the mcast psq to the target */ /* Set the STA flag to DTIMExpired, so that the frame will go out */ arAp->DTIMExpired = TRUE; A_MUTEX_LOCK(&arAp->mcastpsqLock); while (!A_NETBUF_QUEUE_EMPTY(&arAp->mcastpsq)) { skb = A_NETBUF_DEQUEUE(&arAp->mcastpsq); A_MUTEX_UNLOCK(&arAp->mcastpsqLock); ar6000_data_tx(skb, arPriv->arNetDev); A_MUTEX_LOCK(&arAp->mcastpsqLock); } A_MUTEX_UNLOCK(&arAp->mcastpsqLock); /* Reset the DTIMExpired flag back to 0 */ arAp->DTIMExpired = FALSE; /* Clear the LSB of the BitMapCtl field of the TIM IE */ wmi_set_pvb_cmd(arPriv->arWmi, MCAST_AID, 0); } static void ar6000_uapsd_trigger_frame_rx(AR_SOFTC_DEV_T *arPriv, conn_t *conn) { A_BOOL isApsdqEmpty; A_BOOL isApsdqEmptyAtStart; A_UINT32 numFramesToDeliver; /* If the APSD q for this STA is not empty, dequeue and send a pkt from * the head of the q. Also update the More data bit in the WMI_DATA_HDR * if there are more pkts for this STA in the APSD q. If there are no more * pkts for this STA, update the APSD bitmap for this STA. */ numFramesToDeliver = (conn->apsd_info >> 4) & 0xF; /* Number of frames to send in a service period is indicated by the station * in the QOS_INFO of the association request * If it is zero, send all frames */ if (!numFramesToDeliver) { numFramesToDeliver = 0xFFFF; } A_MUTEX_LOCK(&conn->psqLock); isApsdqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->apsdq); A_MUTEX_UNLOCK(&conn->psqLock); isApsdqEmptyAtStart = isApsdqEmpty; while ((!isApsdqEmpty) && (numFramesToDeliver)) { struct sk_buff *skb = NULL; A_MUTEX_LOCK(&conn->psqLock); skb = A_NETBUF_DEQUEUE(&conn->apsdq); isApsdqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->apsdq); A_MUTEX_UNLOCK(&conn->psqLock); /* Set the STA flag to Trigger delivery, so that the frame will go out */ STA_SET_APSD_TRIGGER(conn); numFramesToDeliver--; /* Last frame in the service period, set EOSP or queue empty */ if ((isApsdqEmpty) || (!numFramesToDeliver)) { STA_SET_APSD_EOSP(conn); } ar6000_data_tx(skb, arPriv->arNetDev); STA_CLR_APSD_TRIGGER(conn); STA_CLR_APSD_EOSP(conn); } if (isApsdqEmpty) { if (isApsdqEmptyAtStart) { wmi_set_apsd_buffered_traffic_cmd(arPriv->arWmi, conn->aid, 0, WMI_AP_APSD_NO_DELIVERY_FRAMES_FOR_THIS_TRIGGER); } else { wmi_set_apsd_buffered_traffic_cmd(arPriv->arWmi, conn->aid, 0, 0); } } return; } void read_rssi_compensation_param(AR_SOFTC_T *ar) { A_UINT8 *cust_data_ptr; USER_RSSI_CPENSATION *rssi_compensation_param; //#define RSSICOMPENSATION_PRINT #ifdef RSSICOMPENSATION_PRINT A_INT16 i; cust_data_ptr = ar6000_get_cust_data_buffer(ar->arTargetType); if (cust_data_ptr == NULL) return; for (i=0; i<16; i++) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("cust_data_%d = %x \n", i, *(A_UINT8 *)cust_data_ptr)); cust_data_ptr += 1; } #endif rssi_compensation_param = &ar->rssi_compensation_param; cust_data_ptr = ar6000_get_cust_data_buffer(ar->arTargetType); if (cust_data_ptr == NULL) return; rssi_compensation_param->customerID = *(A_UINT16 *)cust_data_ptr & 0xffff; rssi_compensation_param->enable = *(A_UINT16 *)(cust_data_ptr+2) & 0xffff; rssi_compensation_param->bg_param_a = *(A_UINT16 *)(cust_data_ptr+4) & 0xffff; rssi_compensation_param->bg_param_b = *(A_UINT16 *)(cust_data_ptr+6) & 0xffff; rssi_compensation_param->a_param_a = *(A_UINT16 *)(cust_data_ptr+8) & 0xffff; rssi_compensation_param->a_param_b = *(A_UINT16 *)(cust_data_ptr+10) &0xffff; rssi_compensation_param->reserved = *(A_UINT32 *)(cust_data_ptr+12); #ifdef RSSICOMPENSATION_PRINT AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("customerID = 0x%x \n", rssi_compensation_param->customerID)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("enable = 0x%x \n", rssi_compensation_param->enable)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("bg_param_a = 0x%x and %d \n", rssi_compensation_param->bg_param_a, rssi_compensation_param->bg_param_a)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("bg_param_b = 0x%x and %d \n", rssi_compensation_param->bg_param_b, rssi_compensation_param->bg_param_b)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("a_param_a = 0x%x and %d \n", rssi_compensation_param->a_param_a, rssi_compensation_param->a_param_a)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("a_param_b = 0x%x and %d \n", rssi_compensation_param->a_param_b, rssi_compensation_param->a_param_b)); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Last 4 bytes = 0x%x \n", rssi_compensation_param->reserved)); #endif if (rssi_compensation_param->enable != 0x1) { rssi_compensation_param->enable = 0; } return; } A_INT32 rssi_compensation_calc_tcmd(AR_SOFTC_T *ar, A_UINT32 freq, A_INT32 rssi, A_UINT32 totalPkt) { USER_RSSI_CPENSATION *rssi_compensation_param; rssi_compensation_param = &ar->rssi_compensation_param; if (freq > 5000) { if (rssi_compensation_param->enable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11a\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation = %d, totalPkt = %d\n", rssi,totalPkt)); rssi = rssi * rssi_compensation_param->a_param_a + totalPkt * rssi_compensation_param->a_param_b; rssi = (rssi-50) /100; AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi)); } } else { if (rssi_compensation_param->enable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11bg\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation = %d, totalPkt = %d\n", rssi,totalPkt)); rssi = rssi * rssi_compensation_param->bg_param_a + totalPkt * rssi_compensation_param->bg_param_b; rssi = (rssi-50) /100; AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi)); } } return rssi; } A_INT16 rssi_compensation_calc(AR_SOFTC_DEV_T *arPriv, A_INT16 rssi) { USER_RSSI_CPENSATION *rssi_compensation_param; AR_SOFTC_T *ar = arPriv->arSoftc; rssi_compensation_param = &ar->rssi_compensation_param; if (arPriv->arBssChannel > 5000) { if (rssi_compensation_param->enable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11a\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation = %d\n", rssi)); rssi = rssi * rssi_compensation_param->a_param_a + rssi_compensation_param->a_param_b; rssi = (rssi-50) /100; AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi)); } } else { if (rssi_compensation_param->enable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11bg\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation = %d\n", rssi)); rssi = rssi * rssi_compensation_param->bg_param_a + rssi_compensation_param->bg_param_b; rssi = (rssi-50) /100; AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi)); } } return rssi; } A_INT16 rssi_compensation_reverse_calc(AR_SOFTC_DEV_T *arPriv, A_INT16 rssi, A_BOOL Above) { A_INT16 i; USER_RSSI_CPENSATION *rssi_compensation_param; AR_SOFTC_T *ar = arPriv->arSoftc; rssi_compensation_param = &ar->rssi_compensation_param; if (arPriv->arBssChannel > 5000) { if (rssi_compensation_param->enable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11a\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before rev compensation = %d\n", rssi)); rssi = rssi * 100; rssi = (rssi - rssi_compensation_param->a_param_b) / rssi_compensation_param->a_param_a; AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after rev compensation = %d\n", rssi)); } } else { if (rssi_compensation_param->enable) { AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11bg\n")); AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before rev compensation = %d\n", rssi)); if (Above) { for (i=95; i>=0; i--) { if (rssi <= rssi_compensation_table[arPriv->arDeviceIndex][i]) { rssi = 0 - i; break; } } } else { for (i=0; i<=95; i++) { if (rssi >= rssi_compensation_table[arPriv->arDeviceIndex][i]) { rssi = 0 - i; break; } } } AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after rev compensation = %d\n", rssi)); } } return rssi; } #ifdef WAPI_ENABLE void ap_wapi_rekey_event(AR_SOFTC_DEV_T *arPriv, A_UINT8 type, A_UINT8 *mac) { union iwreq_data wrqu; A_CHAR buf[20]; A_MEMZERO(buf, sizeof(buf)); strcpy(buf, "WAPI_REKEY"); buf[10] = type; A_MEMCPY(&buf[11], mac, ATH_MAC_LEN); A_MEMZERO(&wrqu, sizeof(wrqu)); wrqu.data.length = 10+1+ATH_MAC_LEN; wireless_send_event(arPriv->arNetDev, IWEVCUSTOM, &wrqu, buf); AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("WAPI REKEY - %d - %02x:%02x\n", type, mac[4], mac[5])); } #endif #ifdef USER_KEYS static A_STATUS ar6000_reinstall_keys(AR_SOFTC_DEV_T *arPriv, A_UINT8 key_op_ctrl) { A_STATUS status = A_OK; struct ieee80211req_key *uik = &arPriv->arSta.user_saved_keys.ucast_ik; struct ieee80211req_key *bik = &arPriv->arSta.user_saved_keys.bcast_ik; CRYPTO_TYPE keyType = arPriv->arSta.user_saved_keys.keyType; if (IEEE80211_CIPHER_CCKM_KRK != uik->ik_type) { if (NONE_CRYPT == keyType) { goto _reinstall_keys_out; } if (uik->ik_keylen) { status = wmi_addKey_cmd(arPriv->arWmi, uik->ik_keyix, keyType, PAIRWISE_USAGE, uik->ik_keylen, (A_UINT8 *)&uik->ik_keyrsc, uik->ik_keydata, key_op_ctrl, uik->ik_macaddr, SYNC_BEFORE_WMIFLAG); } } else { status = wmi_add_krk_cmd(arPriv->arWmi, uik->ik_keydata); } if (IEEE80211_CIPHER_CCKM_KRK != bik->ik_type) { if (NONE_CRYPT == keyType) { goto _reinstall_keys_out; } if (bik->ik_keylen) { status = wmi_addKey_cmd(arPriv->arWmi, bik->ik_keyix, keyType, GROUP_USAGE, bik->ik_keylen, (A_UINT8 *)&bik->ik_keyrsc, bik->ik_keydata, key_op_ctrl, bik->ik_macaddr, NO_SYNC_WMIFLAG); } } else { status = wmi_add_krk_cmd(arPriv->arWmi, bik->ik_keydata); } _reinstall_keys_out: arPriv->arSta.user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT; arPriv->arSta.user_key_ctrl = 0; return status; } #endif /* USER_KEYS */ void ar6000_dset_open_req( void *context, A_UINT32 id, A_UINT32 targHandle, A_UINT32 targReplyFn, A_UINT32 targReplyArg) { } void ar6000_dset_close( void *context, A_UINT32 access_cookie) { return; } void ar6000_dset_data_req( void *context, A_UINT32 accessCookie, A_UINT32 offset, A_UINT32 length, A_UINT32 targBuf, A_UINT32 targReplyFn, A_UINT32 targReplyArg) { } void ar6000_init_mode_info(AR_SOFTC_DEV_T *arPriv) { AR_SOFTC_T *ar = arPriv->arSoftc; arPriv->arDot11AuthMode = OPEN_AUTH; arPriv->arAuthMode = WMI_NONE_AUTH; arPriv->arPairwiseCrypto = NONE_CRYPT; arPriv->arPairwiseCryptoLen = 0; arPriv->arGroupCrypto = NONE_CRYPT; arPriv->arGroupCryptoLen = 0; arPriv->arChannelHint = 0; arPriv->arDefTxKeyIndex = 0; A_MEMZERO(arPriv->arBssid, sizeof(arPriv->arBssid)); A_MEMZERO(arPriv->arSsid, sizeof(arPriv->arSsid)); A_MEMZERO(arPriv->arWepKeyList, sizeof(arPriv->arWepKeyList)); arPriv->arSsidLen = 0; arPriv->arTxPwr = 0; arPriv->arTxPwrSet = FALSE; arPriv->arBitRate = -1; arPriv->arMaxRetries = 0; arPriv->arWmmEnabled = TRUE; arPriv->ap_profile_flag = 0; arPriv->num_sta = 0xFF; ar->gNumSta = AP_MAX_NUM_STA; if(arPriv->arNextMode == AP_NETWORK) { AR_SOFTC_AP_T *arAp; if(arPriv->arNetworkType != AP_NETWORK) { A_MEMZERO(&arPriv->arSta,sizeof(AR_SOFTC_STA_T)); } arAp = &arPriv->arAp; arAp->intra_bss = 1; ar->inter_bss = 1; /* init the Mutexes */ A_NETBUF_QUEUE_INIT(&arAp->mcastpsq); A_MUTEX_INIT(&arAp->mcastpsqLock); A_MEMCPY(arAp->ap_country_code, DEF_AP_COUNTRY_CODE, 3); if (arPriv->arPhyCapability == WMI_11NAG_CAPABILITY){ arPriv->phymode = DEF_AP_WMODE_AG; } else { arPriv->phymode = DEF_AP_WMODE_G; } arAp->ap_dtim_period = DEF_AP_DTIM; arAp->ap_beacon_interval = DEF_BEACON_INTERVAL; A_INIT_TIMER(&ar->ap_reconnect_timer,ap_reconnect_timer_handler, ar); } else { /*Station Mode intialisation*/ AR_SOFTC_STA_T *arSta; if(arPriv->arNetworkType == AP_NETWORK) { A_MEMZERO(&arPriv->arAp,sizeof(AR_SOFTC_AP_T)); } arSta = &arPriv->arSta; arSta->arListenIntervalT = A_DEFAULT_LISTEN_INTERVAL; arSta->arListenIntervalB = 0; arSta->arBmissTimeT = A_DEFAULT_BMISS_TIME; arSta->arBmissTimeB = 0; arSta->arRssi = 0; arSta->arSkipScan = 0; arSta->arBeaconInterval = 0; arSta->scan_triggered = 0; arSta->arConnectPending = FALSE; A_MEMZERO(&arSta->scParams, sizeof(arSta->scParams)); arSta->scParams.shortScanRatio = WMI_SHORTSCANRATIO_DEFAULT; arSta->scParams.scanCtrlFlags = DEFAULT_SCAN_CTRL_FLAGS; A_MEMZERO(arSta->arReqBssid, sizeof(arSta->arReqBssid)); if (!arSta->disconnect_timer_inited) { A_INIT_TIMER(&arSta->disconnect_timer, disconnect_timer_handler, arPriv->arNetDev); arSta->disconnect_timer_inited = 1; } else { A_UNTIMEOUT(&arSta->disconnect_timer); } } } int ar6000_ap_set_num_sta(AR_SOFTC_T *ar, AR_SOFTC_DEV_T *arPriv, A_UINT8 num_sta) { int ret = A_OK; A_UINT8 i, total_num_sta; AR_SOFTC_DEV_T *tpriv = NULL; if(num_sta & 0x80) { total_num_sta = (num_sta & (~0x80)); for(i=0; inum_sta = 0xFF; } } else { total_num_sta = num_sta; arPriv->num_sta = num_sta; ar->gNumSta = 0xFF; for(i=0; inum_sta !=0xFF) && (tpriv->arNetworkType == AP_NETWORK)) { total_num_sta += tpriv->num_sta; } } } if(total_num_sta > AP_MAX_NUM_STA) { ret = -EINVAL; } else { if(num_sta & 0x80) { ar->gNumSta = (num_sta & (~0x80)); } else { arPriv->num_sta = num_sta; } wmi_ap_set_num_sta(arPriv->arWmi, num_sta); } return ret; } A_BOOL is_on_valid_chan_for_acspolicy(AR_SOFTC_DEV_T *arPriv, A_UINT8 arAcsPolicy) { if(arPriv->arBssChannel) { switch(arAcsPolicy) { case AP_ACS_DISABLE_CH11: if(arPriv->arBssChannel != 2412 && arPriv->arBssChannel != 2437) { return FALSE; } break; case AP_ACS_DISABLE_CH1: if(arPriv->arBssChannel != 2437 && arPriv->arBssChannel != 2462) { return FALSE; } break; case AP_ACS_DISABLE_CH1_6: if(arPriv->arBssChannel != 2462) { return FALSE; } break; } } return TRUE; } int ar6000_ap_handle_lte_freq(AR_SOFTC_T *ar, AR_SOFTC_DEV_T *arPriv, A_UINT16 lteFreq) { A_UINT8 i = 0, prev_acs = 0; AR_SOFTC_DEV_T *arTempPriv = NULL; for(i = 0;i < ar->arConfNumDev;i++) { arTempPriv = ar->arDev[i]; if ((arTempPriv->arNetworkType == INFRA_NETWORK)) { A_PRINTF("WLAN: Ignore LTE freq in STA mode\n"); return 0; } } ar->lteFreq = lteFreq; prev_acs = ar->arAcsPolicy; /* * Current algorithm to convert LTE freq to WLAN freq * * if 2496 <= f <= 2690 * bad_channel_set_to_be_avoided = [10, 11, 12, 13, 14]; * elseif 2300 <= f < 2350 * bad_channel_set_to_be_avoided = [1, 2, 3, 4]; * elseif 2350 <= f < 2370 * bad_channel_set_to_be_avoided = [1,2,3,4,5,6]; * elseif 2370 <= f <=2400 * bad_channel_set_to_be_avoided = [1,2,3,4,5,6,7,8,9]; * else * bad_channel_set_to_be_avoided = []; end */ /* Decide ACS policy based on LTE freq */ if(ar->lteFreq >= 2496 && ar->lteFreq <= 2690) { ar->arAcsPolicy = AP_ACS_DISABLE_CH11; } else if(ar->lteFreq >= 2300 && ar->lteFreq < 2350) { ar->arAcsPolicy = AP_ACS_DISABLE_CH1; } else if(ar->lteFreq >= 2350 && ar->lteFreq < 2370) { ar->arAcsPolicy = AP_ACS_DISABLE_CH1_6; } else if(ar->lteFreq >= 2370 && ar->lteFreq <= 2400) { ar->arAcsPolicy = AP_ACS_DISABLE_CH1_6; } else { ar->lteFreq = 0; ar->arAcsPolicy = 0; } if (ar->arAcsPolicy && (ar->arAcsPolicy != prev_acs)) { /* Stop all running APs and switch them to ACS */ A_PRINTF("WLAN: LTE_FREQ: %d, Acs Policy = %d, Prev acs = %d\n", lteFreq, ar->arAcsPolicy, prev_acs); for(i=0;iarConfNumDev;i++) { arTempPriv = ar->arDev[i]; if(arTempPriv->arConnected && !is_on_valid_chan_for_acspolicy(arTempPriv, ar->arAcsPolicy)) { A_PRINTF("LTE Channel avoidance, changing channel\n"); ar6000_disconnect(arTempPriv); arTempPriv->arConnected = FALSE; arTempPriv->arChannelHint = 0; arTempPriv->ap_profile_flag = 1; arTempPriv->arBssChannel = 0; ar->arHoldConnection |= (1<arDeviceIndex); } } } return 0; } /* * Check hold status of other concurrent devices during * connect or disconnect of every virtual device */ static int ar6000_check_hold_conn_status(AR_SOFTC_DEV_T *arPriv, A_UINT8 conn_status) { AR_SOFTC_DEV_T *arTempPriv = NULL; AR_SOFTC_T *ar = arPriv->arSoftc; A_STATUS status = A_OK; /* Concurrency: Process the pending connect of the other virtual device(s) */ if (ar->arHoldConnection) { A_UINT8 connect_flag = 0, cnt = 0; for(cnt=0;cntarConfNumDev;cnt++) { arTempPriv = ar->arDev[cnt]; //if(arTempPriv == arPriv) continue; if(ar->arHoldConnection & (1<arDeviceIndex)) { A_STATUS status = A_OK; /* validate channel-hint vs home-channel */ status = ar6000_check_connect_request(ar->arDev[cnt], FALSE); if(A_OK == status) { connect_flag = TRUE; break; } else if(A_ERROR == status) { ar->arHoldConnection &= ~(1<arDev[cnt]->arDeviceIndex); } } if(conn_status) arTempPriv->arChannelHint = 0; } if(connect_flag) { /* Profile commit happens at time-out */ A_TIMEOUT_MS(&ar->ap_reconnect_timer, 1*1000, 0); } status = A_OK; } else { status = A_ERROR; } return status; } /* * (1) Check the status of other devices' connection * (2) If there is atleast one device up already, validate the channelHint * (3) If check_pending_status is set, check whether the current device conn * needs to be kept on hold. Otherwise, do only channel validation * return : A_ERROR - one of the above failed * A_OK - success * A_PENDING - if called during connect, the connect is kep on hold * (assumed as success) */ A_STATUS ar6000_check_connect_request(AR_SOFTC_DEV_T *arPriv, A_UINT8 check_pending_status) { A_UINT8 i; A_STATUS ret_val = A_OK; AR_SOFTC_DEV_T *temp_priv = NULL; AR_SOFTC_STA_T *arSta = NULL; AR_SOFTC_T *ar = arPriv->arSoftc; for(i=0; iarSta; if(arPriv == temp_priv) continue; if(arPriv->arNetworkType == AP_NETWORK && temp_priv->arConnected) { if(temp_priv->arNetworkType == AP_NETWORK) { if(((temp_priv->phymode == WMI_11A_MODE) && (arPriv->phymode != WMI_11A_MODE) && (arPriv->phymode != WMI_11AG_MODE)) || ((temp_priv->phymode != WMI_11A_MODE) && (arPriv->phymode == WMI_11A_MODE ))) { A_PRINTF("ar6000_check_connect_request: One or more concurrent devices" " conneted in different phy mode\n"); ret_val = A_ERROR; break; } } } if( check_pending_status ) { if( arPriv->arNextMode == AP_NETWORK ) { /* If connecting device is AP and pending device is STA or AP, make the connecting device's state as HOLD */ if( ((temp_priv->arNextMode == AP_NETWORK) && (temp_priv->arConnected) && (!temp_priv->arBssChannel)) || ((temp_priv->arNextMode == INFRA_NETWORK) && (arSta->arConnectPending == TRUE))) { ar->arHoldConnection |= (1<arDeviceIndex); A_PRINTF("ar6000_check_connect_request: dev %d on hold\n", arPriv->arDeviceIndex); /* break & return sucess. Process it later */ ret_val = A_PENDING; break; } } else if( arPriv->arNextMode == INFRA_NETWORK ) { /* If the connecting device is STA and pending device is AP, disconnect the pending device and put it in HOLD. Process it's connect during STA connect */ if((temp_priv->arNextMode == AP_NETWORK) && (temp_priv->arConnected) && (!temp_priv->arBssChannel)) { A_PRINTF("ar6000_check_connect_request : disconnecting AP dev %d",temp_priv->arDeviceIndex); ar6000_disconnect(temp_priv); temp_priv->ap_profile_flag = 1; if(!(ar->arHoldConnection & (1<arDeviceIndex))) { ar->arHoldConnection |= (1<arDeviceIndex); } continue; } else if((temp_priv->arNextMode == INFRA_NETWORK) && (arSta->arConnectPending == TRUE)) { /* STA-STA conc - not handled */ } } } /* validate 'channel-hint v home-channel' */ if((temp_priv->arConnected) && (arPriv->arNextMode == AP_NETWORK)) { A_UINT8 prev_phy_mode = arPriv->phymode; if(arPriv->is_sta_roaming) { arPriv->arChannelHint = 0; arPriv->is_sta_roaming = FALSE; } if (!(((arPriv->arChannelHint >= 5180) && (temp_priv->arBssChannel >= 5180)) || ((arPriv->arChannelHint < 5180) && (temp_priv->arBssChannel < 5180))) || (arPriv->arChannelHint == 0)) { if(prev_phy_mode && (temp_priv->arNetworkType == AP_NETWORK) && (arPriv->arNetworkType == AP_NETWORK)) { arPriv->phymode = prev_phy_mode; } else if (arPriv->arPhyCapability == WMI_11NAG_CAPABILITY){ arPriv->phymode = DEF_AP_WMODE_AG; } else { arPriv->phymode = DEF_AP_WMODE_G; } } /* Copy station's regDomain to softAP interface */ if (temp_priv->arRegCode != arPriv->arRegCode) { A_MEMCPY(arPriv->arAp.ap_country_code, (A_UINT8 *)&temp_priv->arRegCode, 2); arPriv->arAp.ap_country_code[2]=COUNTRY_CODE_PRESENT; wmi_set_country(arPriv->arWmi, arPriv->arAp.ap_country_code); } /* User has set the channel for this interface */ if(arPriv->arChannelHint) { if(temp_priv->arBssChannel != arPriv->arChannelHint) { A_PRINTF("ar6000_check_connect_request: Error: Channel should be %d" "MHz. but it is %d\n", temp_priv->arBssChannel, arPriv->arChannelHint); arPriv->arChannelHint = 0; /* channel mismatch is an error - say so */ ret_val = A_ERROR; arPriv->phymode = prev_phy_mode; break; } } else { /* ACS is enabled for this interface */ if(temp_priv->arBssChannel) { arPriv->arChannelHint = temp_priv->arBssChannel; A_PRINTF("ar6000_check_connect_request:Selected Channel %d of dev %d\n", temp_priv->arBssChannel, temp_priv->arDeviceIndex); /* go ahead with the connect on the other device's channel*/ ret_val = A_OK; break; } } } } return ret_val; } int ar6000_ap_mode_profile_commit(AR_SOFTC_DEV_T *arPriv) { AR_SOFTC_T *ar = arPriv->arSoftc; WMI_CONNECT_CMD p; unsigned long flags; if (ar->isHostAsleep != 0) { A_PRINTF("Cannot commit while host is in sleep mode!!!\n"); return -EOPNOTSUPP; } /* No change in AP's profile configuration */ if(arPriv->ap_profile_flag==0) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("COMMIT: No change in profile!!!\n")); return -ENODATA; } if(!arPriv->arSsidLen) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("SSID not set!!!\n")); return -ECHRNG; } if(arPriv->arAuthMode == WMI_NONE_AUTH) { if((arPriv->arPairwiseCrypto != NONE_CRYPT) && #ifdef WAPI_ENABLE (arPriv->arPairwiseCrypto != WAPI_CRYPT) && #endif (arPriv->arPairwiseCrypto != WEP_CRYPT)) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Cipher not supported in AP mode Open auth\n")); return -EOPNOTSUPP; } } else if(!(arPriv->arAuthMode & (WMI_WPA_PSK_AUTH|WMI_WPA2_PSK_AUTH|WMI_WPA_AUTH|WMI_WPA2_AUTH))) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Key mgmt type not supported in AP mode\n")); return -EOPNOTSUPP; } if ((arPriv->arAuthMode == WMI_NONE_AUTH) && (arPriv->arPairwiseCrypto == WEP_CRYPT)) { ar6000_install_static_wep_keys(arPriv); } /* Update the arNetworkType */ arPriv->arNetworkType = arPriv->arNextMode; arPriv->arBssChannel = 0; A_MEMZERO(&p,sizeof(p)); p.ssidLength = arPriv->arSsidLen; A_MEMCPY(p.ssid,arPriv->arSsid,p.ssidLength); /* * p.channel == 0 [Do ACS and choose 1, 6, or 11] * p.channel == 1 [Do ACS and choose 1, or 6] * p.channel == xxxx [No ACS, use xxxx freq] */ if (((arPriv->phymode != WMI_11AG_MODE && arPriv->phymode != WMI_11A_MODE) && (IS_5G_CHANNEL(arPriv->arChannelHint))) || ((arPriv->phymode == WMI_11A_MODE) && !(IS_5G_CHANNEL(arPriv->arChannelHint)) && arPriv->arChannelHint)) { A_PRINTF("ar6000_ap_mode_profile_commit: Channel hint not matching with phymode\n"); arPriv->arChannelHint = 0; return -EINVAL; } if ((arPriv->arChannelHint == 0) && (ar->arAcsPolicy)) { p.channel = ar->arAcsPolicy; } else { p.channel = arPriv->arChannelHint; if ((arPriv->arChannelHint >= 5180) && (arPriv->arChannelHint <= 5825)) { if (!(wmi_set_channelParams_cmd(arPriv->arWmi, 0, WMI_11A_MODE, 0, NULL))) { arPriv->phymode = WMI_11A_MODE; } } else if ((arPriv->phymode == WMI_11AG_MODE)) { if (!(wmi_set_channelParams_cmd(arPriv->arWmi, 0, WMI_11G_MODE, 0, NULL))) { arPriv->phymode = WMI_11G_MODE; } } } p.networkType = arPriv->arNetworkType; p.dot11AuthMode = arPriv->arDot11AuthMode; p.authMode = arPriv->arAuthMode; p.pairwiseCryptoType = arPriv->arPairwiseCrypto; p.pairwiseCryptoLen = arPriv->arPairwiseCryptoLen; p.groupCryptoType = arPriv->arGroupCrypto; p.groupCryptoLen = arPriv->arGroupCryptoLen; p.ctrl_flags = arPriv->arSta.arConnectCtrlFlags; #if WLAN_CONFIG_NO_DISASSOC_UPON_DEAUTH p.ctrl_flags |= AP_NO_DISASSOC_UPON_DEAUTH; #endif wmi_ap_profile_commit(arPriv->arWmi, &p); spin_lock_irqsave(&arPriv->arPrivLock, flags); arPriv->arConnected = TRUE; netif_carrier_on(arPriv->arNetDev); spin_unlock_irqrestore(&arPriv->arPrivLock, flags); arPriv->ap_profile_flag = 0; return 0; } A_STATUS ar6000_connect_to_ap(AR_SOFTC_DEV_T *arPriv) { AR_SOFTC_T *ar = arPriv->arSoftc; AR_SOFTC_STA_T *arSta = &arPriv->arSta; /* The ssid length check prevents second "essid off" from the user, to be treated as a connect cmd. The second "essid off" is ignored. */ if((ar->arWmiReady == TRUE) && (arPriv->arSsidLen > 0) && arPriv->arNetworkType!=AP_NETWORK) { A_STATUS status; if((ADHOC_NETWORK != arPriv->arNetworkType) && (WMI_NONE_AUTH==arPriv->arAuthMode) && (WEP_CRYPT==arPriv->arPairwiseCrypto)) { ar6000_install_static_wep_keys(arPriv); } if (!arSta->arUserBssFilter) { if (wmi_bssfilter_cmd(arPriv->arWmi, ALL_BSS_FILTER, 0) != A_OK) { return -EIO; } } /* Check for APs pending to be connected */ if( A_ERROR == ar6000_check_connect_request(arPriv, TRUE)) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("ar6000_connect_to_ap:unknown error, hold %x",ar->arHoldConnection)); } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("Connect called with authmode %d dot11 auth %d"\ " PW crypto %d PW crypto Len %d GRP crypto %d"\ " GRP crypto Len %d\n", arPriv->arAuthMode, arPriv->arDot11AuthMode, arPriv->arPairwiseCrypto, arPriv->arPairwiseCryptoLen, arPriv->arGroupCrypto, arPriv->arGroupCryptoLen)); reconnect_flag = 0; /* Set the listen interval into 1000TUs or more. This value will be indicated to Ap in the conn. later set it back locally at the STA to 100/1000 TUs depending on the power mode */ if ((arPriv->arNetworkType == INFRA_NETWORK)) { wmi_listeninterval_cmd(arPriv->arWmi, max(arSta->arListenIntervalT, (A_UINT16)A_MAX_WOW_LISTEN_INTERVAL), 0); } status = wmi_connect_cmd(arPriv->arWmi, arPriv->arNetworkType, arPriv->arDot11AuthMode, arPriv->arAuthMode, arPriv->arPairwiseCrypto, arPriv->arPairwiseCryptoLen, arPriv->arGroupCrypto,arPriv->arGroupCryptoLen, arPriv->arSsidLen, arPriv->arSsid, arSta->arReqBssid, arPriv->arChannelHint, arSta->arConnectCtrlFlags); if (status != A_OK) { wmi_listeninterval_cmd(arPriv->arWmi, arSta->arListenIntervalT, arSta->arListenIntervalB); if (!arSta->arUserBssFilter) { wmi_bssfilter_cmd(arPriv->arWmi, NONE_BSS_FILTER, 0); } return status; } if ((!(arSta->arConnectCtrlFlags & CONNECT_DO_WPA_OFFLOAD)) && ((WMI_WPA_PSK_AUTH == arPriv->arAuthMode) || (WMI_WPA2_PSK_AUTH == arPriv->arAuthMode))) { A_TIMEOUT_MS(&arSta->disconnect_timer, A_DISCONNECT_TIMER_INTERVAL, 0); } arSta->arConnectCtrlFlags &= ~CONNECT_DO_WPA_OFFLOAD; arSta->arConnectPending = TRUE; return status; } return A_ERROR; } A_STATUS ar6000_disconnect(AR_SOFTC_DEV_T *arPriv) { AR_SOFTC_T *ar = arPriv->arSoftc; if ((arPriv->arConnected == TRUE) || (arPriv->arSta.arConnectPending == TRUE)) { wmi_disconnect_cmd(arPriv->arWmi); /* * Disconnect cmd is issued, clear connectPending. * arConnected will be cleard in disconnect_event notification. */ arPriv->arSta.arConnectPending = FALSE; } ar->arHoldConnection &= ~(1 << arPriv->arDeviceIndex); return A_OK; } A_STATUS ar6000_ap_mode_get_wpa_ie(AR_SOFTC_DEV_T *arPriv, struct ieee80211req_wpaie *wpaie) { conn_t *conn = NULL; conn = ieee80211_find_conn(arPriv, wpaie->wpa_macaddr); A_MEMZERO(wpaie->wpa_ie, IEEE80211_MAX_IE); A_MEMZERO(wpaie->rsn_ie, IEEE80211_MAX_IE); if(conn) { A_MEMCPY(wpaie->wpa_ie, conn->wpa_ie, IEEE80211_MAX_IE); } return 0; } A_STATUS is_iwioctl_allowed(A_UINT8 mode, A_UINT16 cmd) { if(cmd >= SIOCSIWCOMMIT && cmd <= SIOCGIWPOWER) { cmd -= SIOCSIWCOMMIT; if(sioctl_filter[cmd] == 0xFF) return A_OK; if(sioctl_filter[cmd] & mode) return A_OK; } else if(cmd >= SIOCIWFIRSTPRIV && cmd <= (SIOCIWFIRSTPRIV+30)) { cmd -= SIOCIWFIRSTPRIV; if(pioctl_filter[cmd] == 0xFF) return A_OK; if(pioctl_filter[cmd] & mode) return A_OK; } else { return A_ERROR; } return A_ENOTSUP; } A_STATUS is_xioctl_allowed(A_UINT8 mode, A_UINT8 submode, int cmd) { A_UINT8 mode_bits, submode_bits; A_BOOL is_valid_mode=FALSE, is_valid_submode=FALSE; if(sizeof(xioctl_filter)-1 < cmd) { AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Filter for this cmd=%d not defined\n",cmd)); return A_OK; } /* Valid for all modes/submodes */ if(xioctl_filter[cmd] == 0xFF) return A_OK; /* Check if this cmd is valid for the set mode of this device. */ #define XIOCTL_FILTER_MODE_MASK 0x1F #define XIOCTL_FILTER_MODE_BIT_OFFSET 0x0 mode_bits = xioctl_filter[cmd] & XIOCTL_FILTER_MODE_MASK; if (mode_bits & (mode << XIOCTL_FILTER_MODE_BIT_OFFSET)) { /* Valid cmd for this mode */ is_valid_mode = TRUE; } /* Check if this cmd is valid for the set submode of this device. */ #define XIOCTL_FILTER_SUBMODE_MASK 0xE0 #define XIOCTL_FILTER_SUBMODE_BIT_OFFSET 0x0 submode_bits = (xioctl_filter[cmd] & XIOCTL_FILTER_SUBMODE_MASK)>>XIOCTL_FILTER_SUBMODE_BIT_OFFSET; if (submode == SUBTYPE_P2PDEV || submode == SUBTYPE_P2PCLIENT || submode == SUBTYPE_P2PGO) { /* P2P Submode */ if (submode_bits & XIOCTL_FILTER_P2P_SUBMODE) { is_valid_submode = TRUE; } } else { /* Non P2P Sub mode */ if ((submode_bits & XIOCTL_FILTER_NONP2P_SUBMODE)) { is_valid_submode = TRUE; } } if (is_valid_mode && is_valid_submode) { return A_OK; } return A_ERROR; } #ifdef WAPI_ENABLE int ap_set_wapi_key(AR_SOFTC_DEV_T *arPriv, void *ikey) { struct ieee80211req_key *ik = (struct ieee80211req_key *)ikey; KEY_USAGE keyUsage = 0; A_STATUS status; if (A_MEMCMP(ik->ik_macaddr, bcast_mac, IEEE80211_ADDR_LEN) == 0) { keyUsage = GROUP_USAGE; } else { keyUsage = PAIRWISE_USAGE; } AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("WAPI_KEY: Type:%d ix:%d mac:%02x:%02x len:%d\n", keyUsage, ik->ik_keyix, ik->ik_macaddr[4], ik->ik_macaddr[5], ik->ik_keylen)); status = wmi_addKey_cmd(arPriv->arWmi, ik->ik_keyix, WAPI_CRYPT, keyUsage, ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc, ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr, SYNC_BOTH_WMIFLAG); if (A_OK != status) { return -EIO; } return 0; } #endif void ar6000_peer_event( void *context, A_UINT8 eventCode, A_UINT8 *macAddr) { A_UINT8 pos; for (pos=0;pos<6;pos++) printk("%02x: ",*(macAddr+pos)); printk("\n"); } void ar6000_get_device_addr(AR_SOFTC_DEV_T *arPriv, A_UINT8 *addr) { A_MEMCPY(addr, arPriv->arNetDev->dev_addr, IEEE80211_ADDR_LEN); return; } #ifdef HTC_TEST_SEND_PKTS #define HTC_TEST_DUPLICATE 8 static void DoHTCSendPktsTest(AR_SOFTC_T *ar, int MapNo, HTC_ENDPOINT_ID eid, struct sk_buff *dupskb) { struct ar_cookie *cookie; struct ar_cookie *cookieArray[HTC_TEST_DUPLICATE]; struct sk_buff *new_skb; int i; int pkts = 0; HTC_PACKET_QUEUE pktQueue; EPPING_HEADER *eppingHdr; eppingHdr = A_NETBUF_DATA(dupskb); if (eppingHdr->Cmd_h == EPPING_CMD_NO_ECHO) { /* skip test if this is already a tx perf test */ return; } for (i = 0; i < HTC_TEST_DUPLICATE; i++,pkts++) { AR6000_SPIN_LOCK(&ar->arLock, 0); cookie = ar6000_alloc_cookie(ar); if (cookie != NULL) { ar->arTxPending[eid]++; ar->arTotalTxDataPending++; } AR6000_SPIN_UNLOCK(&ar->arLock, 0); if (NULL == cookie) { break; } new_skb = A_NETBUF_ALLOC(A_NETBUF_LEN(dupskb)); if (new_skb == NULL) { AR6000_SPIN_LOCK(&ar->arLock, 0); ar6000_free_cookie(ar,cookie); AR6000_SPIN_UNLOCK(&ar->arLock, 0); break; } A_NETBUF_PUT_DATA(new_skb, A_NETBUF_DATA(dupskb), A_NETBUF_LEN(dupskb)); cookie->arc_bp[0] = (A_UINT32)new_skb; cookie->arc_bp[1] = MapNo; SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt, cookie, A_NETBUF_DATA(new_skb), A_NETBUF_LEN(new_skb), eid, AR6K_DATA_PKT_TAG); cookieArray[i] = cookie; { EPPING_HEADER *pHdr = (EPPING_HEADER *)A_NETBUF_DATA(new_skb); pHdr->Cmd_h = EPPING_CMD_NO_ECHO; /* do not echo the packet */ } } if (pkts == 0) { return; } INIT_HTC_PACKET_QUEUE(&pktQueue); for (i = 0; i < pkts; i++) { HTC_PACKET_ENQUEUE(&pktQueue,&cookieArray[i]->HtcPkt); } HTCSendPktsMultiple(ar->arHtcTarget, &pktQueue); } #endif #ifdef EXPORT_HCI_BRIDGE_INTERFACE EXPORT_SYMBOL(setupbtdev); #endif NETWORK_TYPE ar6000_get_network_type(AR_SOFTC_DEV_T *arPriv) { return (arPriv->arNetworkType); }