drivers/staging/ath6kl/os/linux/ar6000_drv.c

   1 //------------------------------------------------------------------------------
   2 // Copyright (c) 2004-2010 Atheros Communications Inc.
   3 // All rights reserved.
   4 //
   5 //
   6 //
   7 // Permission to use, copy, modify, and/or distribute this software for any
   8 // purpose with or without fee is hereby granted, provided that the above
   9 // copyright notice and this permission notice appear in all copies.
  10 //
  11 // THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  12 // WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  13 // MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  14 // ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  15 // WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  16 // ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  17 // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18 //
  19 //
  20 //
  21 // Author(s): ="Atheros"
  22 //------------------------------------------------------------------------------
  23
  24 /*
  25  * This driver is a pseudo ethernet driver to access the Atheros AR6000
  26  * WLAN Device
  27  */
  28
  29 #include "ar6000_drv.h"
  30 #ifdef ATH6K_CONFIG_CFG80211
  31 #include "cfg80211.h"
  32 #endif /* ATH6K_CONFIG_CFG80211 */
  33 #include "htc.h"
  34 #include "wmi_filter_linux.h"
  35 #include "epping_test.h"
  36 #include "wlan_config.h"
  37 #include "ar3kconfig.h"
  38 #include "ar6k_pal.h"
  39 #include "AR6002/addrs.h"
  40
  41
  42 /* LINUX_HACK_FUDGE_FACTOR -- this is used to provide a workaround for linux behavior.  When
  43  *  the meta data was added to the header it was found that linux did not correctly provide
  44  *  enough headroom.  However when more headroom was requested beyond what was truly needed
  45  *  Linux gave the requested headroom. Therefore to get the necessary headroom from Linux
  46  *  the driver requests more than is needed by the amount = LINUX_HACK_FUDGE_FACTOR */
  47 #define LINUX_HACK_FUDGE_FACTOR 16
  48 #define BDATA_BDADDR_OFFSET     28
  49
  50 A_UINT8 bcast_mac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  51 A_UINT8 null_mac[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
  52
  53 #ifdef DEBUG
  54
  55 #define  ATH_DEBUG_DBG_LOG       ATH_DEBUG_MAKE_MODULE_MASK(0)
  56 #define  ATH_DEBUG_WLAN_CONNECT  ATH_DEBUG_MAKE_MODULE_MASK(1)
  57 #define  ATH_DEBUG_WLAN_SCAN     ATH_DEBUG_MAKE_MODULE_MASK(2)
  58 #define  ATH_DEBUG_WLAN_TX       ATH_DEBUG_MAKE_MODULE_MASK(3)
  59 #define  ATH_DEBUG_WLAN_RX       ATH_DEBUG_MAKE_MODULE_MASK(4)
  60 #define  ATH_DEBUG_HTC_RAW       ATH_DEBUG_MAKE_MODULE_MASK(5)
  61 #define  ATH_DEBUG_HCI_BRIDGE    ATH_DEBUG_MAKE_MODULE_MASK(6)
  62
  63 static ATH_DEBUG_MASK_DESCRIPTION driver_debug_desc[] = {
  64     { ATH_DEBUG_DBG_LOG      , "Target Debug Logs"},
  65     { ATH_DEBUG_WLAN_CONNECT , "WLAN connect"},
  66     { ATH_DEBUG_WLAN_SCAN    , "WLAN scan"},
  67     { ATH_DEBUG_WLAN_TX      , "WLAN Tx"},
  68     { ATH_DEBUG_WLAN_RX      , "WLAN Rx"},
  69     { ATH_DEBUG_HTC_RAW      , "HTC Raw IF tracing"},
  70     { ATH_DEBUG_HCI_BRIDGE   , "HCI Bridge Setup"},
  71     { ATH_DEBUG_HCI_RECV     , "HCI Recv tracing"},
  72     { ATH_DEBUG_HCI_DUMP     , "HCI Packet dumps"},
  73 };
  74
  75 ATH_DEBUG_INSTANTIATE_MODULE_VAR(driver,
  76                                  "driver",
  77                                  "Linux Driver Interface",
  78                                  ATH_DEBUG_MASK_DEFAULTS | ATH_DEBUG_WLAN_SCAN |
  79                                  ATH_DEBUG_HCI_BRIDGE,
  80                                  ATH_DEBUG_DESCRIPTION_COUNT(driver_debug_desc),
  81                                  driver_debug_desc);
  82
  83 #endif
  84
  85
  86 #define IS_MAC_NULL(mac) (mac[0]==0 && mac[1]==0 && mac[2]==0 && mac[3]==0 && mac[4]==0 && mac[5]==0)
  87 #define IS_MAC_BCAST(mac) (*mac==0xff)
  88
  89 #define DESCRIPTION "Driver to access the Atheros AR600x Device, version " __stringify(__VER_MAJOR_) "." __stringify(__VER_MINOR_) "." __stringify(__VER_PATCH_) "." __stringify(__BUILD_NUMBER_)
  90
  91 MODULE_AUTHOR("Atheros Communications, Inc.");
  92 MODULE_DESCRIPTION(DESCRIPTION);
  93 MODULE_LICENSE("Dual BSD/GPL");
  94
  95 #ifndef REORG_APTC_HEURISTICS
  96 #undef ADAPTIVE_POWER_THROUGHPUT_CONTROL
  97 #endif /* REORG_APTC_HEURISTICS */
  98
  99 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
 100 #define APTC_TRAFFIC_SAMPLING_INTERVAL     100  /* msec */
 101 #define APTC_UPPER_THROUGHPUT_THRESHOLD    3000 /* Kbps */
 102 #define APTC_LOWER_THROUGHPUT_THRESHOLD    2000 /* Kbps */
 103
 104 typedef struct aptc_traffic_record {
 105     A_BOOL timerScheduled;
 106     struct timeval samplingTS;
 107     unsigned long bytesReceived;
 108     unsigned long bytesTransmitted;
 109 } APTC_TRAFFIC_RECORD;
 110
 111 A_TIMER aptcTimer;
 112 APTC_TRAFFIC_RECORD aptcTR;
 113 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
 114
 115 #ifdef EXPORT_HCI_BRIDGE_INTERFACE
 116 // callbacks registered by HCI transport driver
 117 HCI_TRANSPORT_CALLBACKS ar6kHciTransCallbacks = { NULL };
 118 #endif
 119
 120 unsigned int processDot11Hdr = 0;
 121 int bmienable = BMIENABLE_DEFAULT;
 122
 123 char ifname[IFNAMSIZ] = {0,};
 124
 125 int wlaninitmode = WLAN_INIT_MODE_DEFAULT;
 126 unsigned int bypasswmi = 0;
 127 unsigned int debuglevel = 0;
 128 int tspecCompliance = ATHEROS_COMPLIANCE;
 129 unsigned int busspeedlow = 0;
 130 unsigned int onebitmode = 0;
 131 unsigned int skipflash = 0;
 132 unsigned int wmitimeout = 2;
 133 unsigned int wlanNodeCaching = 1;
 134 unsigned int enableuartprint = ENABLEUARTPRINT_DEFAULT;
 135 unsigned int logWmiRawMsgs = 0;
 136 unsigned int enabletimerwar = 0;
 137 unsigned int fwmode = 1;
 138 unsigned int mbox_yield_limit = 99;
 139 unsigned int enablerssicompensation = 0;
 140 int reduce_credit_dribble = 1 + HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_ONE_HALF;
 141 int allow_trace_signal = 0;
 142 #ifdef CONFIG_HOST_TCMD_SUPPORT
 143 unsigned int testmode =0;
 144 #endif
 145
 146 unsigned int irqprocmode = HIF_DEVICE_IRQ_SYNC_ONLY;//HIF_DEVICE_IRQ_ASYNC_SYNC;
 147 unsigned int panic_on_assert = 1;
 148 unsigned int nohifscattersupport = NOHIFSCATTERSUPPORT_DEFAULT;
 149
 150 unsigned int setuphci = SETUPHCI_DEFAULT;
 151 unsigned int setuphcipal = SETUPHCIPAL_DEFAULT;
 152 unsigned int loghci = 0;
 153 unsigned int setupbtdev = SETUPBTDEV_DEFAULT;
 154 #ifndef EXPORT_HCI_BRIDGE_INTERFACE
 155 unsigned int ar3khcibaud = AR3KHCIBAUD_DEFAULT;
 156 unsigned int hciuartscale = HCIUARTSCALE_DEFAULT;
 157 unsigned int hciuartstep = HCIUARTSTEP_DEFAULT;
 158 #endif
 159 #ifdef CONFIG_CHECKSUM_OFFLOAD
 160 unsigned int csumOffload=0;
 161 unsigned int csumOffloadTest=0;
 162 #endif
 163 unsigned int eppingtest=0;
 164
 165 module_param_string(ifname, ifname, sizeof(ifname), 0644);
 166 module_param(wlaninitmode, int, 0644);
 167 module_param(bmienable, int, 0644);
 168 module_param(bypasswmi, uint, 0644);
 169 module_param(debuglevel, uint, 0644);
 170 module_param(tspecCompliance, int, 0644);
 171 module_param(onebitmode, uint, 0644);
 172 module_param(busspeedlow, uint, 0644);
 173 module_param(skipflash, uint, 0644);
 174 module_param(wmitimeout, uint, 0644);
 175 module_param(wlanNodeCaching, uint, 0644);
 176 module_param(logWmiRawMsgs, uint, 0644);
 177 module_param(enableuartprint, uint, 0644);
 178 module_param(enabletimerwar, uint, 0644);
 179 module_param(fwmode, uint, 0644);
 180 module_param(mbox_yield_limit, uint, 0644);
 181 module_param(reduce_credit_dribble, int, 0644);
 182 module_param(allow_trace_signal, int, 0644);
 183 module_param(enablerssicompensation, uint, 0644);
 184 module_param(processDot11Hdr, uint, 0644);
 185 #ifdef CONFIG_CHECKSUM_OFFLOAD
 186 module_param(csumOffload, uint, 0644);
 187 #endif
 188 #ifdef CONFIG_HOST_TCMD_SUPPORT
 189 module_param(testmode, uint, 0644);
 190 #endif
 191 module_param(irqprocmode, uint, 0644);
 192 module_param(nohifscattersupport, uint, 0644);
 193 module_param(panic_on_assert, uint, 0644);
 194 module_param(setuphci, uint, 0644);
 195 module_param(setuphcipal, uint, 0644);
 196 module_param(loghci, uint, 0644);
 197 module_param(setupbtdev, uint, 0644);
 198 #ifndef EXPORT_HCI_BRIDGE_INTERFACE
 199 module_param(ar3khcibaud, uint, 0644);
 200 module_param(hciuartscale, uint, 0644);
 201 module_param(hciuartstep, uint, 0644);
 202 #endif
 203 module_param(eppingtest, uint, 0644);
 204
 205 /* in 2.6.10 and later this is now a pointer to a uint */
 206 unsigned int _mboxnum = HTC_MAILBOX_NUM_MAX;
 207 #define mboxnum &_mboxnum
 208
 209 #ifdef DEBUG
 210 A_UINT32 g_dbg_flags = DBG_DEFAULTS;
 211 unsigned int debugflags = 0;
 212 int debugdriver = 0;
 213 unsigned int debughtc = 0;
 214 unsigned int debugbmi = 0;
 215 unsigned int debughif = 0;
 216 unsigned int txcreditsavailable[HTC_MAILBOX_NUM_MAX] = {0};
 217 unsigned int txcreditsconsumed[HTC_MAILBOX_NUM_MAX] = {0};
 218 unsigned int txcreditintrenable[HTC_MAILBOX_NUM_MAX] = {0};
 219 unsigned int txcreditintrenableaggregate[HTC_MAILBOX_NUM_MAX] = {0};
 220 module_param(debugflags, uint, 0644);
 221 module_param(debugdriver, int, 0644);
 222 module_param(debughtc, uint, 0644);
 223 module_param(debugbmi, uint, 0644);
 224 module_param(debughif, uint, 0644);
 225 module_param_array(txcreditsavailable, uint, mboxnum, 0644);
 226 module_param_array(txcreditsconsumed, uint, mboxnum, 0644);
 227 module_param_array(txcreditintrenable, uint, mboxnum, 0644);
 228 module_param_array(txcreditintrenableaggregate, uint, mboxnum, 0644);
 229
 230 #endif /* DEBUG */
 231
 232 unsigned int resetok = 1;
 233 unsigned int tx_attempt[HTC_MAILBOX_NUM_MAX] = {0};
 234 unsigned int tx_post[HTC_MAILBOX_NUM_MAX] = {0};
 235 unsigned int tx_complete[HTC_MAILBOX_NUM_MAX] = {0};
 236 unsigned int hifBusRequestNumMax = 40;
 237 unsigned int war23838_disabled = 0;
 238 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
 239 unsigned int enableAPTCHeuristics = 1;
 240 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
 241 module_param_array(tx_attempt, uint, mboxnum, 0644);
 242 module_param_array(tx_post, uint, mboxnum, 0644);
 243 module_param_array(tx_complete, uint, mboxnum, 0644);
 244 module_param(hifBusRequestNumMax, uint, 0644);
 245 module_param(war23838_disabled, uint, 0644);
 246 module_param(resetok, uint, 0644);
 247 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
 248 module_param(enableAPTCHeuristics, uint, 0644);
 249 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
 250
 251 #ifdef BLOCK_TX_PATH_FLAG
 252 int blocktx = 0;
 253 module_param(blocktx, int, 0644);
 254 #endif /* BLOCK_TX_PATH_FLAG */
 255
 256 typedef struct user_rssi_compensation_t {
 257     A_UINT16         customerID;
 258     union {
 259     A_UINT16         a_enable;
 260     A_UINT16         bg_enable;
 261     A_UINT16         enable;
 262     };
 263     A_INT16          bg_param_a;
 264     A_INT16          bg_param_b;
 265     A_INT16          a_param_a;
 266     A_INT16          a_param_b;
 267     A_UINT32         reserved;
 268 } USER_RSSI_CPENSATION;
 269
 270 static USER_RSSI_CPENSATION rssi_compensation_param;
 271
 272 static A_INT16 rssi_compensation_table[96];
 273
 274 int reconnect_flag = 0;
 275 static ar6k_pal_config_t ar6k_pal_config_g;
 276
 277 /* Function declarations */
 278 static int ar6000_init_module(void);
 279 static void ar6000_cleanup_module(void);
 280
 281 int ar6000_init(struct net_device *dev);
 282 static int ar6000_open(struct net_device *dev);
 283 static int ar6000_close(struct net_device *dev);
 284 static void ar6000_init_control_info(AR_SOFTC_T *ar);
 285 static int ar6000_data_tx(struct sk_buff *skb, struct net_device *dev);
 286
 287 void ar6000_destroy(struct net_device *dev, unsigned int unregister);
 288 static void ar6000_detect_error(unsigned long ptr);
 289 static void     ar6000_set_multicast_list(struct net_device *dev);
 290 static struct net_device_stats *ar6000_get_stats(struct net_device *dev);
 291 static struct iw_statistics *ar6000_get_iwstats(struct net_device * dev);
 292
 293 static void disconnect_timer_handler(unsigned long ptr);
 294
 295 void read_rssi_compensation_param(AR_SOFTC_T *ar);
 296
 297     /* for android builds we call external APIs that handle firmware download and configuration */
 298 #ifdef ANDROID_ENV
 299 /* !!!! Interim android support to make it easier to patch the default driver for
 300  * android use. You must define an external source file ar6000_android.c that handles the following
 301  * APIs */
 302 extern void android_module_init(OSDRV_CALLBACKS *osdrvCallbacks);
 303 extern void android_module_exit(void);
 304 #endif
 305 /*
 306  * HTC service connection handlers
 307  */
 308 static A_STATUS ar6000_avail_ev(void *context, void *hif_handle);
 309
 310 static A_STATUS ar6000_unavail_ev(void *context, void *hif_handle);
 311
 312 A_STATUS ar6000_configure_target(AR_SOFTC_T *ar);
 313
 314 static void ar6000_target_failure(void *Instance, A_STATUS Status);
 315
 316 static void ar6000_rx(void *Context, HTC_PACKET *pPacket);
 317
 318 static void ar6000_rx_refill(void *Context,HTC_ENDPOINT_ID Endpoint);
 319
 320 static void ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPackets);
 321
 322 static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, HTC_PACKET *pPacket);
 323
 324 #ifdef ATH_AR6K_11N_SUPPORT
 325 static void ar6000_alloc_netbufs(A_NETBUF_QUEUE_T *q, A_UINT16 num);
 326 #endif
 327 static void ar6000_deliver_frames_to_nw_stack(void * dev, void *osbuf);
 328 //static void ar6000_deliver_frames_to_bt_stack(void * dev, void *osbuf);
 329
 330 static HTC_PACKET *ar6000_alloc_amsdu_rxbuf(void *Context, HTC_ENDPOINT_ID Endpoint, int Length);
 331
 332 static void ar6000_refill_amsdu_rxbufs(AR_SOFTC_T *ar, int Count);
 333
 334 static void ar6000_cleanup_amsdu_rxbufs(AR_SOFTC_T *ar);
 335
 336 static ssize_t
 337 ar6000_sysfs_bmi_read(struct file *fp, struct kobject *kobj,
 338                       struct bin_attribute *bin_attr,
 339                       char *buf, loff_t pos, size_t count);
 340
 341 static ssize_t
 342 ar6000_sysfs_bmi_write(struct file *fp, struct kobject *kobj,
 343                        struct bin_attribute *bin_attr,
 344                        char *buf, loff_t pos, size_t count);
 345
 346 static A_STATUS
 347 ar6000_sysfs_bmi_init(AR_SOFTC_T *ar);
 348
 349 /* HCI PAL callback function declarations */
 350 A_STATUS ar6k_setup_hci_pal(AR_SOFTC_T *ar);
 351 void  ar6k_cleanup_hci_pal(AR_SOFTC_T *ar);
 352
 353 static void
 354 ar6000_sysfs_bmi_deinit(AR_SOFTC_T *ar);
 355
 356 A_STATUS
 357 ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, A_UINT32 mode);
 358
 359 /*
 360  * Static variables
 361  */
 362
 363 struct net_device *ar6000_devices[MAX_AR6000];
 364 static int is_netdev_registered;
 365 extern struct iw_handler_def ath_iw_handler_def;
 366 DECLARE_WAIT_QUEUE_HEAD(arEvent);
 367 static void ar6000_cookie_init(AR_SOFTC_T *ar);
 368 static void ar6000_cookie_cleanup(AR_SOFTC_T *ar);
 369 static void ar6000_free_cookie(AR_SOFTC_T *ar, struct ar_cookie * cookie);
 370 static struct ar_cookie *ar6000_alloc_cookie(AR_SOFTC_T *ar);
 371
 372 #ifdef USER_KEYS
 373 static A_STATUS ar6000_reinstall_keys(AR_SOFTC_T *ar,A_UINT8 key_op_ctrl);
 374 #endif
 375
 376 #ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
 377 struct net_device *arApNetDev;
 378 #endif /* CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT */
 379
 380 static struct ar_cookie s_ar_cookie_mem[MAX_COOKIE_NUM];
 381
 382 #define HOST_INTEREST_ITEM_ADDRESS(ar, item) \
 383         (((ar)->arTargetType == TARGET_TYPE_AR6002) ? AR6002_HOST_INTEREST_ITEM_ADDRESS(item) : \
 384         (((ar)->arTargetType == TARGET_TYPE_AR6003) ? AR6003_HOST_INTEREST_ITEM_ADDRESS(item) : 0))
 385
 386
 387 static struct net_device_ops ar6000_netdev_ops = {
 388     .ndo_init               = NULL,
 389     .ndo_open               = ar6000_open,
 390     .ndo_stop               = ar6000_close,
 391     .ndo_get_stats          = ar6000_get_stats,
 392     .ndo_do_ioctl           = ar6000_ioctl,
 393     .ndo_start_xmit         = ar6000_data_tx,
 394     .ndo_set_multicast_list = ar6000_set_multicast_list,
 395 };
 396
 397 /* Debug log support */
 398
 399 /*
 400  * Flag to govern whether the debug logs should be parsed in the kernel
 401  * or reported to the application.
 402  */
 403 #define REPORT_DEBUG_LOGS_TO_APP
 404
 405 A_STATUS
 406 ar6000_set_host_app_area(AR_SOFTC_T *ar)
 407 {
 408     A_UINT32 address, data;
 409     struct host_app_area_s host_app_area;
 410
 411     /* Fetch the address of the host_app_area_s instance in the host interest area */
 412     address = TARG_VTOP(ar->arTargetType, HOST_INTEREST_ITEM_ADDRESS(ar, hi_app_host_interest));
 413     if (ar6000_ReadRegDiag(ar->arHifDevice, &address, &data) != A_OK) {
 414         return A_ERROR;
 415     }
 416     address = TARG_VTOP(ar->arTargetType, data);
 417     host_app_area.wmi_protocol_ver = WMI_PROTOCOL_VERSION;
 418     if (ar6000_WriteDataDiag(ar->arHifDevice, address,
 419                              (A_UCHAR *)&host_app_area,
 420                              sizeof(struct host_app_area_s)) != A_OK)
 421     {
 422         return A_ERROR;
 423     }
 424
 425     return A_OK;
 426 }
 427
 428 A_UINT32
 429 dbglog_get_debug_hdr_ptr(AR_SOFTC_T *ar)
 430 {
 431     A_UINT32 param;
 432     A_UINT32 address;
 433     A_STATUS status;
 434
 435     address = TARG_VTOP(ar->arTargetType, HOST_INTEREST_ITEM_ADDRESS(ar, hi_dbglog_hdr));
 436     if ((status = ar6000_ReadDataDiag(ar->arHifDevice, address,
 437                                       (A_UCHAR *)&param, 4)) != A_OK)
 438     {
 439         param = 0;
 440     }
 441
 442     return param;
 443 }
 444
 445 /*
 446  * The dbglog module has been initialized. Its ok to access the relevant
 447  * data stuctures over the diagnostic window.
 448  */
 449 void
 450 ar6000_dbglog_init_done(AR_SOFTC_T *ar)
 451 {
 452     ar->dbglog_init_done = TRUE;
 453 }
 454
 455 A_UINT32
 456 dbglog_get_debug_fragment(A_INT8 *datap, A_UINT32 len, A_UINT32 limit)
 457 {
 458     A_INT32 *buffer;
 459     A_UINT32 count;
 460     A_UINT32 numargs;
 461     A_UINT32 length;
 462     A_UINT32 fraglen;
 463
 464     count = fraglen = 0;
 465     buffer = (A_INT32 *)datap;
 466     length = (limit >> 2);
 467
 468     if (len <= limit) {
 469         fraglen = len;
 470     } else {
 471         while (count < length) {
 472             numargs = DBGLOG_GET_NUMARGS(buffer[count]);
 473             fraglen = (count << 2);
 474             count += numargs + 1;
 475         }
 476     }
 477
 478     return fraglen;
 479 }
 480
 481 void
 482 dbglog_parse_debug_logs(A_INT8 *datap, A_UINT32 len)
 483 {
 484     A_INT32 *buffer;
 485     A_UINT32 count;
 486     A_UINT32 timestamp;
 487     A_UINT32 debugid;
 488     A_UINT32 moduleid;
 489     A_UINT32 numargs;
 490     A_UINT32 length;
 491
 492     count = 0;
 493     buffer = (A_INT32 *)datap;
 494     length = (len >> 2);
 495     while (count < length) {
 496         debugid = DBGLOG_GET_DBGID(buffer[count]);
 497         moduleid = DBGLOG_GET_MODULEID(buffer[count]);
 498         numargs = DBGLOG_GET_NUMARGS(buffer[count]);
 499         timestamp = DBGLOG_GET_TIMESTAMP(buffer[count]);
 500         switch (numargs) {
 501             case 0:
 502             AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("%d %d (%d)\n", moduleid, debugid, timestamp));
 503             break;
 504
 505             case 1:
 506             AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("%d %d (%d): 0x%x\n", moduleid, debugid,
 507                             timestamp, buffer[count+1]));
 508             break;
 509
 510             case 2:
 511             AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("%d %d (%d): 0x%x, 0x%x\n", moduleid, debugid,
 512                             timestamp, buffer[count+1], buffer[count+2]));
 513             break;
 514
 515             default:
 516             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Invalid args: %d\n", numargs));
 517         }
 518         count += numargs + 1;
 519     }
 520 }
 521
 522 int
 523 ar6000_dbglog_get_debug_logs(AR_SOFTC_T *ar)
 524 {
 525     A_UINT32 data[8]; /* Should be able to accomodate struct dbglog_buf_s */
 526     A_UINT32 address;
 527     A_UINT32 length;
 528     A_UINT32 dropped;
 529     A_UINT32 firstbuf;
 530     A_UINT32 debug_hdr_ptr;
 531
 532     if (!ar->dbglog_init_done) return A_ERROR;
 533
 534
 535     AR6000_SPIN_LOCK(&ar->arLock, 0);
 536
 537     if (ar->dbgLogFetchInProgress) {
 538         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
 539         return A_EBUSY;
 540     }
 541
 542         /* block out others */
 543     ar->dbgLogFetchInProgress = TRUE;
 544
 545     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
 546
 547     debug_hdr_ptr = dbglog_get_debug_hdr_ptr(ar);
 548     printk("debug_hdr_ptr: 0x%x\n", debug_hdr_ptr);
 549
 550     /* Get the contents of the ring buffer */
 551     if (debug_hdr_ptr) {
 552         address = TARG_VTOP(ar->arTargetType, debug_hdr_ptr);
 553         length = 4 /* sizeof(dbuf) */ + 4 /* sizeof(dropped) */;
 554         A_MEMZERO(data, sizeof(data));
 555         ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)data, length);
 556         address = TARG_VTOP(ar->arTargetType, data[0] /* dbuf */);
 557         firstbuf = address;
 558         dropped = data[1]; /* dropped */
 559         length = 4 /* sizeof(next) */ + 4 /* sizeof(buffer) */ + 4 /* sizeof(bufsize) */ + 4 /* sizeof(length) */ + 4 /* sizeof(count) */ + 4 /* sizeof(free) */;
 560         A_MEMZERO(data, sizeof(data));
 561         ar6000_ReadDataDiag(ar->arHifDevice, address, (A_UCHAR *)&data, length);
 562
 563         do {
 564             address = TARG_VTOP(ar->arTargetType, data[1] /* buffer*/);
 565             length = data[3]; /* length */
 566             if ((length) && (length <= data[2] /* bufsize*/)) {
 567                 /* Rewind the index if it is about to overrun the buffer */
 568                 if (ar->log_cnt > (DBGLOG_HOST_LOG_BUFFER_SIZE - length)) {
 569                     ar->log_cnt = 0;
 570                 }
 571                 if(A_OK != ar6000_ReadDataDiag(ar->arHifDevice, address,
 572                                     (A_UCHAR *)&ar->log_buffer[ar->log_cnt], length))
 573                 {
 574                     break;
 575                 }
 576                 ar6000_dbglog_event(ar, dropped, (A_INT8*)&ar->log_buffer[ar->log_cnt], length);
 577                 ar->log_cnt += length;
 578             } else {
 579                 AR_DEBUG_PRINTF(ATH_DEBUG_DBG_LOG,("Length: %d (Total size: %d)\n",
 580                                 data[3], data[2]));
 581             }
 582
 583             address = TARG_VTOP(ar->arTargetType, data[0] /* next */);
 584             length = 4 /* sizeof(next) */ + 4 /* sizeof(buffer) */ + 4 /* sizeof(bufsize) */ + 4 /* sizeof(length) */ + 4 /* sizeof(count) */ + 4 /* sizeof(free) */;
 585             A_MEMZERO(data, sizeof(data));
 586             if(A_OK != ar6000_ReadDataDiag(ar->arHifDevice, address,
 587                                 (A_UCHAR *)&data, length))
 588             {
 589                 break;
 590             }
 591
 592         } while (address != firstbuf);
 593     }
 594
 595     ar->dbgLogFetchInProgress = FALSE;
 596
 597     return A_OK;
 598 }
 599
 600 void
 601 ar6000_dbglog_event(AR_SOFTC_T *ar, A_UINT32 dropped,
 602                     A_INT8 *buffer, A_UINT32 length)
 603 {
 604 #ifdef REPORT_DEBUG_LOGS_TO_APP
 605     #define MAX_WIRELESS_EVENT_SIZE 252
 606     /*
 607      * Break it up into chunks of MAX_WIRELESS_EVENT_SIZE bytes of messages.
 608      * There seems to be a limitation on the length of message that could be
 609      * transmitted to the user app via this mechanism.
 610      */
 611     A_UINT32 send, sent;
 612
 613     sent = 0;
 614     send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
 615                                      MAX_WIRELESS_EVENT_SIZE);
 616     while (send) {
 617         ar6000_send_event_to_app(ar, WMIX_DBGLOG_EVENTID, (A_UINT8*)&buffer[sent], send);
 618         sent += send;
 619         send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
 620                                          MAX_WIRELESS_EVENT_SIZE);
 621     }
 622 #else
 623     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Dropped logs: 0x%x\nDebug info length: %d\n",
 624                     dropped, length));
 625
 626     /* Interpret the debug logs */
 627     dbglog_parse_debug_logs((A_INT8*)buffer, length);
 628 #endif /* REPORT_DEBUG_LOGS_TO_APP */
 629 }
 630
 631
 632 static int __init
 633 ar6000_init_module(void)
 634 {
 635     static int probed = 0;
 636     A_STATUS status;
 637     OSDRV_CALLBACKS osdrvCallbacks;
 638
 639     a_module_debug_support_init();
 640
 641 #ifdef DEBUG
 642         /* check for debug mask overrides */
 643     if (debughtc != 0) {
 644         ATH_DEBUG_SET_DEBUG_MASK(htc,debughtc);
 645     }
 646     if (debugbmi != 0) {
 647         ATH_DEBUG_SET_DEBUG_MASK(bmi,debugbmi);
 648     }
 649     if (debughif != 0) {
 650         ATH_DEBUG_SET_DEBUG_MASK(hif,debughif);
 651     }
 652     if (debugdriver != 0) {
 653         ATH_DEBUG_SET_DEBUG_MASK(driver,debugdriver);
 654     }
 655
 656 #endif
 657
 658     A_REGISTER_MODULE_DEBUG_INFO(driver);
 659
 660     A_MEMZERO(&osdrvCallbacks,sizeof(osdrvCallbacks));
 661     osdrvCallbacks.deviceInsertedHandler = ar6000_avail_ev;
 662     osdrvCallbacks.deviceRemovedHandler = ar6000_unavail_ev;
 663 #ifdef CONFIG_PM
 664     osdrvCallbacks.deviceSuspendHandler = ar6000_suspend_ev;
 665     osdrvCallbacks.deviceResumeHandler = ar6000_resume_ev;
 666     osdrvCallbacks.devicePowerChangeHandler = ar6000_power_change_ev;
 667 #endif
 668
 669     ar6000_pm_init();
 670
 671 #ifdef ANDROID_ENV
 672     android_module_init(&osdrvCallbacks);
 673 #endif
 674
 675 #ifdef DEBUG
 676     /* Set the debug flags if specified at load time */
 677     if(debugflags != 0)
 678     {
 679         g_dbg_flags = debugflags;
 680     }
 681 #endif
 682
 683     if (probed) {
 684         return -ENODEV;
 685     }
 686     probed++;
 687
 688 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
 689     memset(&aptcTR, 0, sizeof(APTC_TRAFFIC_RECORD));
 690 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
 691
 692 #ifdef CONFIG_HOST_GPIO_SUPPORT
 693     ar6000_gpio_init();
 694 #endif /* CONFIG_HOST_GPIO_SUPPORT */
 695
 696     status = HIFInit(&osdrvCallbacks);
 697     if(status != A_OK)
 698         return -ENODEV;
 699
 700     return 0;
 701 }
 702
 703 static void __exit
 704 ar6000_cleanup_module(void)
 705 {
 706     int i = 0;
 707     struct net_device *ar6000_netdev;
 708
 709 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
 710     /* Delete the Adaptive Power Control timer */
 711     if (timer_pending(&aptcTimer)) {
 712         del_timer_sync(&aptcTimer);
 713     }
 714 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
 715
 716     for (i=0; i < MAX_AR6000; i++) {
 717         if (ar6000_devices[i] != NULL) {
 718             ar6000_netdev = ar6000_devices[i];
 719             ar6000_devices[i] = NULL;
 720             ar6000_destroy(ar6000_netdev, 1);
 721         }
 722     }
 723
 724     HIFShutDownDevice(NULL);
 725
 726     a_module_debug_support_cleanup();
 727
 728     ar6000_pm_exit();
 729
 730 #ifdef ANDROID_ENV
 731     android_module_exit();
 732 #endif
 733
 734     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_cleanup: success\n"));
 735 }
 736
 737 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
 738 void
 739 aptcTimerHandler(unsigned long arg)
 740 {
 741     A_UINT32 numbytes;
 742     A_UINT32 throughput;
 743     AR_SOFTC_T *ar;
 744     A_STATUS status;
 745
 746     ar = (AR_SOFTC_T *)arg;
 747     A_ASSERT(ar != NULL);
 748     A_ASSERT(!timer_pending(&aptcTimer));
 749
 750     AR6000_SPIN_LOCK(&ar->arLock, 0);
 751
 752     /* Get the number of bytes transferred */
 753     numbytes = aptcTR.bytesTransmitted + aptcTR.bytesReceived;
 754     aptcTR.bytesTransmitted = aptcTR.bytesReceived = 0;
 755
 756     /* Calculate and decide based on throughput thresholds */
 757     throughput = ((numbytes * 8)/APTC_TRAFFIC_SAMPLING_INTERVAL); /* Kbps */
 758     if (throughput < APTC_LOWER_THROUGHPUT_THRESHOLD) {
 759         /* Enable Sleep and delete the timer */
 760         A_ASSERT(ar->arWmiReady == TRUE);
 761         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
 762         status = wmi_powermode_cmd(ar->arWmi, REC_POWER);
 763         AR6000_SPIN_LOCK(&ar->arLock, 0);
 764         A_ASSERT(status == A_OK);
 765         aptcTR.timerScheduled = FALSE;
 766     } else {
 767         A_TIMEOUT_MS(&aptcTimer, APTC_TRAFFIC_SAMPLING_INTERVAL, 0);
 768     }
 769
 770     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
 771 }
 772 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
 773
 774 #ifdef ATH_AR6K_11N_SUPPORT
 775 static void
 776 ar6000_alloc_netbufs(A_NETBUF_QUEUE_T *q, A_UINT16 num)
 777 {
 778     void * osbuf;
 779
 780     while(num) {
 781         if((osbuf = A_NETBUF_ALLOC(AR6000_BUFFER_SIZE))) {
 782             A_NETBUF_ENQUEUE(q, osbuf);
 783         } else {
 784             break;
 785         }
 786         num--;
 787     }
 788
 789     if(num) {
 790         A_PRINTF("%s(), allocation of netbuf failed", __func__);
 791     }
 792 }
 793 #endif
 794
 795 static struct bin_attribute bmi_attr = {
 796     .attr = {.name = "bmi", .mode = 0600},
 797     .read = ar6000_sysfs_bmi_read,
 798     .write = ar6000_sysfs_bmi_write,
 799 };
 800
 801 static ssize_t
 802 ar6000_sysfs_bmi_read(struct file *fp, struct kobject *kobj,
 803                       struct bin_attribute *bin_attr,
 804                       char *buf, loff_t pos, size_t count)
 805 {
 806     int index;
 807     AR_SOFTC_T *ar;
 808     HIF_DEVICE_OS_DEVICE_INFO   *osDevInfo;
 809
 810     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Read %d bytes\n", (A_UINT32)count));
 811     for (index=0; index < MAX_AR6000; index++) {
 812         ar = (AR_SOFTC_T *)ar6k_priv(ar6000_devices[index]);
 813         osDevInfo = &ar->osDevInfo;
 814         if (kobj == (&(((struct device *)osDevInfo->pOSDevice)->kobj))) {
 815             break;
 816         }
 817     }
 818
 819     if (index == MAX_AR6000) return 0;
 820
 821     if ((BMIRawRead(ar->arHifDevice, (A_UCHAR*)buf, count, TRUE)) != A_OK) {
 822         return 0;
 823     }
 824
 825     return count;
 826 }
 827
 828 static ssize_t
 829 ar6000_sysfs_bmi_write(struct file *fp, struct kobject *kobj,
 830                        struct bin_attribute *bin_attr,
 831                        char *buf, loff_t pos, size_t count)
 832 {
 833     int index;
 834     AR_SOFTC_T *ar;
 835     HIF_DEVICE_OS_DEVICE_INFO   *osDevInfo;
 836
 837     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Write %d bytes\n", (A_UINT32)count));
 838     for (index=0; index < MAX_AR6000; index++) {
 839         ar = (AR_SOFTC_T *)ar6k_priv(ar6000_devices[index]);
 840         osDevInfo = &ar->osDevInfo;
 841         if (kobj == (&(((struct device *)osDevInfo->pOSDevice)->kobj))) {
 842             break;
 843         }
 844     }
 845
 846     if (index == MAX_AR6000) return 0;
 847
 848     if ((BMIRawWrite(ar->arHifDevice, (A_UCHAR*)buf, count)) != A_OK) {
 849         return 0;
 850     }
 851
 852     return count;
 853 }
 854
 855 static A_STATUS
 856 ar6000_sysfs_bmi_init(AR_SOFTC_T *ar)
 857 {
 858     A_STATUS status;
 859
 860     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Creating sysfs entry\n"));
 861     A_MEMZERO(&ar->osDevInfo, sizeof(HIF_DEVICE_OS_DEVICE_INFO));
 862
 863     /* Get the underlying OS device */
 864     status = HIFConfigureDevice(ar->arHifDevice,
 865                                 HIF_DEVICE_GET_OS_DEVICE,
 866                                 &ar->osDevInfo,
 867                                 sizeof(HIF_DEVICE_OS_DEVICE_INFO));
 868
 869     if (A_FAILED(status)) {
 870         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI: Failed to get OS device info from HIF\n"));
 871         return A_ERROR;
 872     }
 873
 874     /* Create a bmi entry in the sysfs filesystem */
 875     if ((sysfs_create_bin_file(&(((struct device *)ar->osDevInfo.pOSDevice)->kobj), &bmi_attr)) < 0)
 876     {
 877         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMI: Failed to create entry for bmi in sysfs filesystem\n"));
 878         return A_ERROR;
 879     }
 880
 881     return A_OK;
 882 }
 883
 884 static void
 885 ar6000_sysfs_bmi_deinit(AR_SOFTC_T *ar)
 886 {
 887     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Deleting sysfs entry\n"));
 888
 889     sysfs_remove_bin_file(&(((struct device *)ar->osDevInfo.pOSDevice)->kobj), &bmi_attr);
 890 }
 891
 892 #define bmifn(fn) do { \
 893     if ((fn) < A_OK) { \
 894         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI operation failed: %d\n", __LINE__)); \
 895         return A_ERROR; \
 896     } \
 897 } while(0)
 898
 899 #ifdef INIT_MODE_DRV_ENABLED
 900
 901 #ifdef SOFTMAC_FILE_USED
 902 #define AR6002_MAC_ADDRESS_OFFSET     0x0A
 903 #define AR6003_MAC_ADDRESS_OFFSET     0x16
 904 static
 905 void calculate_crc(A_UINT32 TargetType, A_UCHAR *eeprom_data)
 906 {
 907     A_UINT16        *ptr_crc;
 908     A_UINT16        *ptr16_eeprom;
 909     A_UINT16        checksum;
 910     A_UINT32        i;
 911     A_UINT32        eeprom_size;
 912
 913     if (TargetType == TARGET_TYPE_AR6001)
 914     {
 915         eeprom_size = 512;
 916         ptr_crc = (A_UINT16 *)eeprom_data;
 917     }
 918     else if (TargetType == TARGET_TYPE_AR6003)
 919     {
 920         eeprom_size = 1024;
 921         ptr_crc = (A_UINT16 *)((A_UCHAR *)eeprom_data + 0x04);
 922     }
 923     else
 924     {
 925         eeprom_size = 768;
 926         ptr_crc = (A_UINT16 *)((A_UCHAR *)eeprom_data + 0x04);
 927     }
 928
 929
 930     // Clear the crc
 931     *ptr_crc = 0;
 932
 933     // Recalculate new CRC
 934     checksum = 0;
 935     ptr16_eeprom = (A_UINT16 *)eeprom_data;
 936     for (i = 0;i < eeprom_size; i += 2)
 937     {
 938         checksum = checksum ^ (*ptr16_eeprom);
 939         ptr16_eeprom++;
 940     }
 941     checksum = 0xFFFF ^ checksum;
 942     *ptr_crc = checksum;
 943 }
 944
 945 static void
 946 ar6000_softmac_update(AR_SOFTC_T *ar, A_UCHAR *eeprom_data, size_t size)
 947 {
 948     const char *source = "random generated";
 949     const struct firmware *softmac_entry;
 950     A_UCHAR *ptr_mac;
 951     switch (ar->arTargetType) {
 952     case TARGET_TYPE_AR6002:
 953         ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + AR6002_MAC_ADDRESS_OFFSET);
 954         break;
 955     case TARGET_TYPE_AR6003:
 956         ptr_mac = (A_UINT8 *)((A_UCHAR *)eeprom_data + AR6003_MAC_ADDRESS_OFFSET);
 957         break;
 958     default:
 959         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Invalid Target Type\n"));
 960         return;
 961     }
 962         printk(KERN_DEBUG "MAC from EEPROM %pM\n", &ptr_mac[0]);
 963
 964     /* create a random MAC in case we cannot read file from system */
 965     ptr_mac[0] = 0;
 966     ptr_mac[1] = 0x03;
 967     ptr_mac[2] = 0x7F;
 968     ptr_mac[3] = random32() & 0xff;
 969     ptr_mac[4] = random32() & 0xff;
 970     ptr_mac[5] = random32() & 0xff;
 971     if ((A_REQUEST_FIRMWARE(&softmac_entry, "softmac", ((struct device *)ar->osDevInfo.pOSDevice))) == 0)
 972     {
 973         A_CHAR *macbuf = A_MALLOC_NOWAIT(softmac_entry->size+1);
 974         if (macbuf) {
 975             unsigned int softmac[6];
 976             memcpy(macbuf, softmac_entry->data, softmac_entry->size);
 977             macbuf[softmac_entry->size] = '\0';
 978             if (sscanf(macbuf, "%02x:%02x:%02x:%02x:%02x:%02x",
 979                         &softmac[0], &softmac[1], &softmac[2],
 980                         &softmac[3], &softmac[4], &softmac[5])==6) {
 981                 int i;
 982                 for (i=0; i<6; ++i) {
 983                     ptr_mac[i] = softmac[i] & 0xff;
 984                 }
 985                 source = "softmac file";
 986             }
 987             A_FREE(macbuf);
 988         }
 989         A_RELEASE_FIRMWARE(softmac_entry);
 990     }
 991         printk(KERN_DEBUG "MAC from %s %pM\n", source, &ptr_mac[0]);
 992    calculate_crc(ar->arTargetType, eeprom_data);
 993 }
 994 #endif /* SOFTMAC_FILE_USED */
 995
 996 static A_STATUS
 997 ar6000_transfer_bin_file(AR_SOFTC_T *ar, AR6K_BIN_FILE file, A_UINT32 address, A_BOOL compressed)
 998 {
 999     A_STATUS status;
1000     const char *filename;
1001     const struct firmware *fw_entry;
1002     A_UINT32 fw_entry_size;
1003
1004     switch (file) {
1005         case AR6K_OTP_FILE:
1006             if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1007                 filename = AR6003_REV1_OTP_FILE;
1008             } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1009                 filename = AR6003_REV2_OTP_FILE;
1010             } else {
1011                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver));
1012                 return A_ERROR;
1013             }
1014             break;
1015
1016         case AR6K_FIRMWARE_FILE:
1017             if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1018                 filename = AR6003_REV1_FIRMWARE_FILE;
1019             } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1020                 filename = AR6003_REV2_FIRMWARE_FILE;
1021             } else {
1022                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver));
1023                 return A_ERROR;
1024             }
1025
1026             if (eppingtest) {
1027                 bypasswmi = TRUE;
1028                 if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1029                     filename = AR6003_REV1_EPPING_FIRMWARE_FILE;
1030                 } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1031                     filename = AR6003_REV2_EPPING_FIRMWARE_FILE;
1032                 } else {
1033                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("eppingtest : unsupported firmware revision: %d\n",
1034                         ar->arVersion.target_ver));
1035                     return A_ERROR;
1036                 }
1037                 compressed = 0;
1038             }
1039
1040 #ifdef CONFIG_HOST_TCMD_SUPPORT
1041             if(testmode) {
1042                 if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1043                     filename = AR6003_REV1_TCMD_FIRMWARE_FILE;
1044                 } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1045                     filename = AR6003_REV2_TCMD_FIRMWARE_FILE;
1046                 } else {
1047                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver));
1048                     return A_ERROR;
1049                 }
1050                 compressed = 0;
1051             }
1052 #endif
1053 #ifdef HTC_RAW_INTERFACE
1054             if (!eppingtest && bypasswmi) {
1055                 if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1056                     filename = AR6003_REV1_ART_FIRMWARE_FILE;
1057                 } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1058                     filename = AR6003_REV2_ART_FIRMWARE_FILE;
1059                 } else {
1060                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver));
1061                     return A_ERROR;
1062                 }
1063                 compressed = 0;
1064             }
1065 #endif
1066             break;
1067
1068         case AR6K_PATCH_FILE:
1069             if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1070                 filename = AR6003_REV1_PATCH_FILE;
1071             } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1072                 filename = AR6003_REV2_PATCH_FILE;
1073             } else {
1074                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver));
1075                 return A_ERROR;
1076             }
1077             break;
1078
1079         case AR6K_BOARD_DATA_FILE:
1080             if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1081                 filename = AR6003_REV1_BOARD_DATA_FILE;
1082             } else if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1083                 filename = AR6003_REV2_BOARD_DATA_FILE;
1084             } else {
1085                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown firmware revision: %d\n", ar->arVersion.target_ver));
1086                 return A_ERROR;
1087             }
1088             break;
1089
1090         default:
1091             AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Unknown file type: %d\n", file));
1092             return A_ERROR;
1093     }
1094     if ((A_REQUEST_FIRMWARE(&fw_entry, filename, ((struct device *)ar->osDevInfo.pOSDevice))) != 0)
1095     {
1096         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Failed to get %s\n", filename));
1097         return A_ENOENT;
1098     }
1099
1100 #ifdef SOFTMAC_FILE_USED
1101     if (file==AR6K_BOARD_DATA_FILE && fw_entry->data) {
1102         ar6000_softmac_update(ar, (A_UCHAR *)fw_entry->data, fw_entry->size);
1103     }
1104 #endif
1105
1106
1107     fw_entry_size = fw_entry->size;
1108
1109     /* Load extended board data for AR6003 */
1110     if ((file==AR6K_BOARD_DATA_FILE) && (fw_entry->data)) {
1111         A_UINT32 board_ext_address;
1112         A_UINT32 board_ext_data_size;
1113         A_UINT32 board_data_size;
1114
1115         board_ext_data_size = (((ar)->arTargetType == TARGET_TYPE_AR6002) ? AR6002_BOARD_EXT_DATA_SZ : \
1116                                (((ar)->arTargetType == TARGET_TYPE_AR6003) ? AR6003_BOARD_EXT_DATA_SZ : 0));
1117
1118         board_data_size = (((ar)->arTargetType == TARGET_TYPE_AR6002) ? AR6002_BOARD_DATA_SZ : \
1119                           (((ar)->arTargetType == TARGET_TYPE_AR6003) ? AR6003_BOARD_DATA_SZ : 0));
1120
1121         /* Determine where in Target RAM to write Board Data */
1122         bmifn(BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_ext_data), (A_UCHAR *)&board_ext_address, 4));
1123         AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("Board extended Data download address: 0x%x\n", board_ext_address));
1124
1125         /* check whether the target has allocated memory for extended board data and file contains extended board data */
1126         if ((board_ext_address) && (fw_entry->size == (board_data_size + board_ext_data_size))) {
1127             A_UINT32 param;
1128
1129             status = BMIWriteMemory(ar->arHifDevice, board_ext_address, (A_UCHAR *)(((A_UINT32)fw_entry->data) + board_data_size), board_ext_data_size);
1130
1131             if (status != A_OK) {
1132                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI operation failed: %d\n", __LINE__));
1133                 A_RELEASE_FIRMWARE(fw_entry);
1134                 return A_ERROR;
1135             }
1136
1137             /* Record the fact that extended board Data IS initialized */
1138             param = 1;
1139             bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_ext_data_initialized), (A_UCHAR *)&param, 4));
1140         }
1141         fw_entry_size = board_data_size;
1142     }
1143
1144     if (compressed) {
1145         status = BMIFastDownload(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry_size);
1146     } else {
1147         status = BMIWriteMemory(ar->arHifDevice, address, (A_UCHAR *)fw_entry->data, fw_entry_size);
1148     }
1149
1150     if (status != A_OK) {
1151         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI operation failed: %d\n", __LINE__));
1152         A_RELEASE_FIRMWARE(fw_entry);
1153         return A_ERROR;
1154     }
1155     A_RELEASE_FIRMWARE(fw_entry);
1156     return A_OK;
1157 }
1158 #endif /* INIT_MODE_DRV_ENABLED */
1159
1160 A_STATUS
1161 ar6000_update_bdaddr(AR_SOFTC_T *ar)
1162 {
1163
1164         if (setupbtdev != 0) {
1165             A_UINT32 address;
1166
1167            if (BMIReadMemory(ar->arHifDevice,
1168                 HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_data), (A_UCHAR *)&address, 4) != A_OK)
1169            {
1170                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for hi_board_data failed\n"));
1171                 return A_ERROR;
1172            }
1173
1174            if (BMIReadMemory(ar->arHifDevice, address + BDATA_BDADDR_OFFSET, (A_UCHAR *)ar->bdaddr, 6) != A_OK)
1175            {
1176                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for BD address failed\n"));
1177                 return A_ERROR;
1178            }
1179            AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BDADDR 0x%x:0x%x:0x%x:0x%x:0x%x:0x%x\n", ar->bdaddr[0],
1180                                                                 ar->bdaddr[1], ar->bdaddr[2], ar->bdaddr[3],
1181                                                                 ar->bdaddr[4], ar->bdaddr[5]));
1182         }
1183
1184 return A_OK;
1185 }
1186
1187 A_STATUS
1188 ar6000_sysfs_bmi_get_config(AR_SOFTC_T *ar, A_UINT32 mode)
1189 {
1190     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("BMI: Requesting device specific configuration\n"));
1191
1192     if (mode == WLAN_INIT_MODE_UDEV) {
1193         A_CHAR version[16];
1194         const struct firmware *fw_entry;
1195
1196         /* Get config using udev through a script in user space */
1197         sprintf(version, "%2.2x", ar->arVersion.target_ver);
1198         if ((A_REQUEST_FIRMWARE(&fw_entry, version, ((struct device *)ar->osDevInfo.pOSDevice))) != 0)
1199         {
1200             AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("BMI: Failure to get configuration for target version: %s\n", version));
1201             return A_ERROR;
1202         }
1203
1204         A_RELEASE_FIRMWARE(fw_entry);
1205 #ifdef INIT_MODE_DRV_ENABLED
1206     } else {
1207         /* The config is contained within the driver itself */
1208         A_STATUS status;
1209         A_UINT32 param, options, sleep, address;
1210
1211         /* Temporarily disable system sleep */
1212         address = MBOX_BASE_ADDRESS + LOCAL_SCRATCH_ADDRESS;
1213         bmifn(BMIReadSOCRegister(ar->arHifDevice, address, &param));
1214         options = param;
1215         param |= AR6K_OPTION_SLEEP_DISABLE;
1216         bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1217
1218         address = RTC_BASE_ADDRESS + SYSTEM_SLEEP_ADDRESS;
1219         bmifn(BMIReadSOCRegister(ar->arHifDevice, address, &param));
1220         sleep = param;
1221         param |= WLAN_SYSTEM_SLEEP_DISABLE_SET(1);
1222         bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1223         AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("old options: %d, old sleep: %d\n", options, sleep));
1224
1225         if (ar->arTargetType == TARGET_TYPE_AR6003) {
1226             /* Program analog PLL register */
1227             bmifn(BMIWriteSOCRegister(ar->arHifDevice, ANALOG_INTF_BASE_ADDRESS + 0x284, 0xF9104001));
1228             /* Run at 80/88MHz by default */
1229             param = CPU_CLOCK_STANDARD_SET(1);
1230         } else {
1231             /* Run at 40/44MHz by default */
1232             param = CPU_CLOCK_STANDARD_SET(0);
1233         }
1234         address = RTC_BASE_ADDRESS + CPU_CLOCK_ADDRESS;
1235         bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1236
1237         param = 0;
1238         if (ar->arTargetType == TARGET_TYPE_AR6002) {
1239             bmifn(BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_ext_clk_detected), (A_UCHAR *)&param, 4));
1240         }
1241
1242         /* LPO_CAL.ENABLE = 1 if no external clk is detected */
1243         if (param != 1) {
1244             address = RTC_BASE_ADDRESS + LPO_CAL_ADDRESS;
1245             param = LPO_CAL_ENABLE_SET(1);
1246             bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1247         }
1248
1249         /* Venus2.0: Lower SDIO pad drive strength,
1250          * temporary WAR to avoid SDIO CRC error */
1251         if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1252             AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("AR6K: Temporary WAR to avoid SDIO CRC error\n"));
1253             param = 0x20;
1254             address = GPIO_BASE_ADDRESS + GPIO_PIN10_ADDRESS;
1255             bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1256
1257             address = GPIO_BASE_ADDRESS + GPIO_PIN11_ADDRESS;
1258             bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1259
1260             address = GPIO_BASE_ADDRESS + GPIO_PIN12_ADDRESS;
1261             bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1262
1263             address = GPIO_BASE_ADDRESS + GPIO_PIN13_ADDRESS;
1264             bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1265         }
1266
1267 #ifdef FORCE_INTERNAL_CLOCK
1268         /* Ignore external clock, if any, and force use of internal clock */
1269         if (ar->arTargetType == TARGET_TYPE_AR6003) {
1270             /* hi_ext_clk_detected = 0 */
1271             param = 0;
1272             bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_ext_clk_detected), (A_UCHAR *)&param, 4));
1273
1274             /* CLOCK_CONTROL &= ~LF_CLK32 */
1275             address = RTC_BASE_ADDRESS + CLOCK_CONTROL_ADDRESS;
1276             bmifn(BMIReadSOCRegister(ar->arHifDevice, address, &param));
1277             param &= (~CLOCK_CONTROL_LF_CLK32_SET(1));
1278             bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1279         }
1280 #endif /* FORCE_INTERNAL_CLOCK */
1281
1282         /* Transfer Board Data from Target EEPROM to Target RAM */
1283         if (ar->arTargetType == TARGET_TYPE_AR6003) {
1284             /* Determine where in Target RAM to write Board Data */
1285             bmifn(BMIReadMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_data), (A_UCHAR *)&address, 4));
1286             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("Board Data download address: 0x%x\n", address));
1287
1288             /* Write EEPROM data to Target RAM */
1289             if ((ar6000_transfer_bin_file(ar, AR6K_BOARD_DATA_FILE, address, FALSE)) != A_OK) {
1290                 return A_ERROR;
1291             }
1292
1293             /* Record the fact that Board Data IS initialized */
1294             param = 1;
1295             bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_data_initialized), (A_UCHAR *)&param, 4));
1296
1297             /* Transfer One time Programmable data */
1298             AR6K_DATA_DOWNLOAD_ADDRESS(address, ar->arVersion.target_ver);
1299             status = ar6000_transfer_bin_file(ar, AR6K_OTP_FILE, address, TRUE);
1300             if (status == A_OK) {
1301                 /* Execute the OTP code */
1302                 param = 0;
1303                 AR6K_APP_START_OVERRIDE_ADDRESS(address, ar->arVersion.target_ver);
1304                 bmifn(BMIExecute(ar->arHifDevice, address, &param));
1305             } else if (status != A_ENOENT) {
1306                 return A_ERROR;
1307             }
1308         } else {
1309             AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("Programming of board data for chip %d not supported\n", ar->arTargetType));
1310             return A_ERROR;
1311         }
1312
1313         /* Download Target firmware */
1314         AR6K_DATA_DOWNLOAD_ADDRESS(address, ar->arVersion.target_ver);
1315         if ((ar6000_transfer_bin_file(ar, AR6K_FIRMWARE_FILE, address, TRUE)) != A_OK) {
1316             return A_ERROR;
1317         }
1318
1319         /* Set starting address for firmware */
1320         AR6K_APP_START_OVERRIDE_ADDRESS(address, ar->arVersion.target_ver);
1321         bmifn(BMISetAppStart(ar->arHifDevice, address));
1322
1323         /* Apply the patches */
1324         AR6K_PATCH_DOWNLOAD_ADDRESS(address, ar->arVersion.target_ver);
1325         if ((ar6000_transfer_bin_file(ar, AR6K_PATCH_FILE, address, FALSE)) != A_OK) {
1326             return A_ERROR;
1327         }
1328
1329         param = address;
1330         bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_dset_list_head), (A_UCHAR *)&param, 4));
1331
1332         if (ar->arTargetType == TARGET_TYPE_AR6003) {
1333             if (ar->arVersion.target_ver == AR6003_REV1_VERSION) {
1334                 /* Reserve 5.5K of RAM */
1335                 param = 5632;
1336             } else { /* AR6003_REV2_VERSION */
1337                 /* Reserve 6.5K of RAM */
1338                 param = 6656;
1339             }
1340             bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_end_RAM_reserve_sz), (A_UCHAR *)&param, 4));
1341         }
1342
1343         /* Restore system sleep */
1344         address = RTC_BASE_ADDRESS + SYSTEM_SLEEP_ADDRESS;
1345         bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, sleep));
1346
1347         address = MBOX_BASE_ADDRESS + LOCAL_SCRATCH_ADDRESS;
1348         param = options | 0x20;
1349         bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1350
1351         if (ar->arTargetType == TARGET_TYPE_AR6003) {
1352             /* Configure GPIO AR6003 UART */
1353 #ifndef CONFIG_AR600x_DEBUG_UART_TX_PIN
1354 #define CONFIG_AR600x_DEBUG_UART_TX_PIN 8
1355 #endif
1356             param = CONFIG_AR600x_DEBUG_UART_TX_PIN;
1357             bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_dbg_uart_txpin), (A_UCHAR *)&param, 4));
1358
1359 #if (CONFIG_AR600x_DEBUG_UART_TX_PIN == 23)
1360             {
1361                 address = GPIO_BASE_ADDRESS + CLOCK_GPIO_ADDRESS;
1362                 bmifn(BMIReadSOCRegister(ar->arHifDevice, address, &param));
1363                 param |= CLOCK_GPIO_BT_CLK_OUT_EN_SET(1);
1364                 bmifn(BMIWriteSOCRegister(ar->arHifDevice, address, param));
1365             }
1366 #endif
1367
1368             /* Configure GPIO for BT Reset */
1369 #ifdef ATH6KL_CONFIG_GPIO_BT_RESET
1370 #define CONFIG_AR600x_BT_RESET_PIN      0x16
1371             param = CONFIG_AR600x_BT_RESET_PIN;
1372             bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_hci_uart_support_pins), (A_UCHAR *)&param, 4));
1373 #endif /* ATH6KL_CONFIG_GPIO_BT_RESET */
1374
1375             /* Configure UART flow control polarity */
1376 #ifndef CONFIG_ATH6KL_BT_UART_FC_POLARITY
1377 #define CONFIG_ATH6KL_BT_UART_FC_POLARITY 0
1378 #endif
1379
1380 #if (CONFIG_ATH6KL_BT_UART_FC_POLARITY == 1)
1381             if (ar->arVersion.target_ver == AR6003_REV2_VERSION) {
1382                 param = ((CONFIG_ATH6KL_BT_UART_FC_POLARITY << 1) & 0x2);
1383                 bmifn(BMIWriteMemory(ar->arHifDevice, HOST_INTEREST_ITEM_ADDRESS(ar, hi_hci_uart_pwr_mgmt_params), (A_UCHAR *)&param, 4));
1384             }
1385 #endif /* CONFIG_ATH6KL_BT_UART_FC_POLARITY */
1386         }
1387
1388 #ifdef HTC_RAW_INTERFACE
1389         if (!eppingtest && bypasswmi) {
1390             /* Don't run BMIDone for ART mode and force resetok=0 */
1391             resetok = 0;
1392             msleep(1000);
1393         }
1394 #endif /* HTC_RAW_INTERFACE */
1395
1396 #endif /* INIT_MODE_DRV_ENABLED */
1397     }
1398
1399     return A_OK;
1400 }
1401
1402 A_STATUS
1403 ar6000_configure_target(AR_SOFTC_T *ar)
1404 {
1405     A_UINT32 param;
1406     if (enableuartprint) {
1407         param = 1;
1408         if (BMIWriteMemory(ar->arHifDevice,
1409                            HOST_INTEREST_ITEM_ADDRESS(ar, hi_serial_enable),
1410                            (A_UCHAR *)&param,
1411                            4)!= A_OK)
1412         {
1413              AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for enableuartprint failed \n"));
1414              return A_ERROR;
1415         }
1416         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Serial console prints enabled\n"));
1417     }
1418
1419     /* Tell target which HTC version it is used*/
1420     param = HTC_PROTOCOL_VERSION;
1421     if (BMIWriteMemory(ar->arHifDevice,
1422                        HOST_INTEREST_ITEM_ADDRESS(ar, hi_app_host_interest),
1423                        (A_UCHAR *)&param,
1424                        4)!= A_OK)
1425     {
1426          AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for htc version failed \n"));
1427          return A_ERROR;
1428     }
1429
1430 #ifdef CONFIG_HOST_TCMD_SUPPORT
1431     if(testmode) {
1432         ar->arTargetMode = AR6000_TCMD_MODE;
1433     }else {
1434         ar->arTargetMode = AR6000_WLAN_MODE;
1435     }
1436 #endif
1437     if (enabletimerwar) {
1438         A_UINT32 param;
1439
1440         if (BMIReadMemory(ar->arHifDevice,
1441             HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
1442             (A_UCHAR *)&param,
1443             4)!= A_OK)
1444         {
1445             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for enabletimerwar failed \n"));
1446             return A_ERROR;
1447         }
1448
1449         param |= HI_OPTION_TIMER_WAR;
1450
1451         if (BMIWriteMemory(ar->arHifDevice,
1452             HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
1453             (A_UCHAR *)&param,
1454             4) != A_OK)
1455         {
1456             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for enabletimerwar failed \n"));
1457             return A_ERROR;
1458         }
1459         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Timer WAR enabled\n"));
1460     }
1461
1462     /* set the firmware mode to STA/IBSS/AP */
1463     {
1464         A_UINT32 param;
1465
1466         if (BMIReadMemory(ar->arHifDevice,
1467             HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
1468             (A_UCHAR *)&param,
1469             4)!= A_OK)
1470         {
1471             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for setting fwmode failed \n"));
1472             return A_ERROR;
1473         }
1474
1475         param |= (fwmode << HI_OPTION_FW_MODE_SHIFT);
1476
1477         if (BMIWriteMemory(ar->arHifDevice,
1478             HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
1479             (A_UCHAR *)&param,
1480             4) != A_OK)
1481         {
1482             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for setting fwmode failed \n"));
1483             return A_ERROR;
1484         }
1485         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Firmware mode set\n"));
1486     }
1487
1488 #ifdef ATH6KL_DISABLE_TARGET_DBGLOGS
1489     {
1490         A_UINT32 param;
1491
1492         if (BMIReadMemory(ar->arHifDevice,
1493             HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
1494             (A_UCHAR *)&param,
1495             4)!= A_OK)
1496         {
1497             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIReadMemory for disabling debug logs failed\n"));
1498             return A_ERROR;
1499         }
1500
1501         param |= HI_OPTION_DISABLE_DBGLOG;
1502
1503         if (BMIWriteMemory(ar->arHifDevice,
1504             HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
1505             (A_UCHAR *)&param,
1506             4) != A_OK)
1507         {
1508             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for HI_OPTION_DISABLE_DBGLOG\n"));
1509             return A_ERROR;
1510         }
1511         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("Firmware mode set\n"));
1512     }
1513 #endif /* ATH6KL_DISABLE_TARGET_DBGLOGS */
1514
1515     /*
1516      * Hardcode the address use for the extended board data
1517      * Ideally this should be pre-allocate by the OS at boot time
1518      * But since it is a new feature and board data is loaded
1519      * at init time, we have to workaround this from host.
1520      * It is difficult to patch the firmware boot code,
1521      * but possible in theory.
1522      */
1523     if (ar->arTargetType == TARGET_TYPE_AR6003) {
1524         param = AR6003_BOARD_EXT_DATA_ADDRESS;
1525         if (BMIWriteMemory(ar->arHifDevice,
1526             HOST_INTEREST_ITEM_ADDRESS(ar, hi_board_ext_data),
1527             (A_UCHAR *)&param,
1528             4) != A_OK)
1529         {
1530             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BMIWriteMemory for hi_board_ext_data failed \n"));
1531             return A_ERROR;
1532         }
1533     }
1534
1535
1536         /* since BMIInit is called in the driver layer, we have to set the block
1537          * size here for the target */
1538
1539     if (A_FAILED(ar6000_set_htc_params(ar->arHifDevice,
1540                                        ar->arTargetType,
1541                                        mbox_yield_limit,
1542                                        0 /* use default number of control buffers */
1543                                        ))) {
1544         return A_ERROR;
1545     }
1546
1547     if (setupbtdev != 0) {
1548         if (A_FAILED(ar6000_set_hci_bridge_flags(ar->arHifDevice,
1549                                                  ar->arTargetType,
1550                                                  setupbtdev))) {
1551             return A_ERROR;
1552         }
1553     }
1554     return A_OK;
1555 }
1556
1557 static void
1558 init_netdev(struct net_device *dev, char *name)
1559 {
1560     dev->netdev_ops = &ar6000_netdev_ops;
1561     dev->watchdog_timeo = AR6000_TX_TIMEOUT;
1562     dev->wireless_handlers = &ath_iw_handler_def;
1563
1564     ath_iw_handler_def.get_wireless_stats = ar6000_get_iwstats; /*Displayed via proc fs */
1565
1566    /*
1567     * We need the OS to provide us with more headroom in order to
1568     * perform dix to 802.3, WMI header encap, and the HTC header
1569     */
1570     if (processDot11Hdr) {
1571         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;
1572     } else {
1573         dev->hard_header_len = ETH_HLEN + sizeof(ATH_LLC_SNAP_HDR) +
1574             sizeof(WMI_DATA_HDR) + HTC_HEADER_LEN + WMI_MAX_TX_META_SZ + LINUX_HACK_FUDGE_FACTOR;
1575     }
1576
1577     if (name[0])
1578     {
1579         strcpy(dev->name, name);
1580     }
1581
1582 #ifdef SET_MODULE_OWNER
1583     SET_MODULE_OWNER(dev);
1584 #endif
1585
1586 #ifdef CONFIG_CHECKSUM_OFFLOAD
1587     if(csumOffload){
1588         dev->features |= NETIF_F_IP_CSUM; /*advertise kernel capability to do TCP/UDP CSUM offload for IPV4*/
1589     }
1590 #endif
1591
1592     return;
1593 }
1594
1595 /*
1596  * HTC Event handlers
1597  */
1598 static A_STATUS
1599 ar6000_avail_ev(void *context, void *hif_handle)
1600 {
1601     int i;
1602     struct net_device *dev;
1603     void *ar_netif;
1604     AR_SOFTC_T *ar;
1605     int device_index = 0;
1606     HTC_INIT_INFO  htcInfo;
1607 #ifdef ATH6K_CONFIG_CFG80211
1608     struct wireless_dev *wdev;
1609 #endif /* ATH6K_CONFIG_CFG80211 */
1610     A_STATUS init_status = A_OK;
1611
1612     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_available\n"));
1613
1614     for (i=0; i < MAX_AR6000; i++) {
1615         if (ar6000_devices[i] == NULL) {
1616             break;
1617         }
1618     }
1619
1620     if (i == MAX_AR6000) {
1621         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_available: max devices reached\n"));
1622         return A_ERROR;
1623     }
1624
1625     /* Save this. It gives a bit better readability especially since */
1626     /* we use another local "i" variable below.                      */
1627     device_index = i;
1628
1629 #ifdef ATH6K_CONFIG_CFG80211
1630     wdev = ar6k_cfg80211_init(NULL);
1631     if (IS_ERR(wdev)) {
1632         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s: ar6k_cfg80211_init failed\n", __func__));
1633         return A_ERROR;
1634     }
1635     ar_netif = wdev_priv(wdev);
1636 #else
1637     dev = alloc_etherdev(sizeof(AR_SOFTC_T));
1638     if (dev == NULL) {
1639         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_available: can't alloc etherdev\n"));
1640         return A_ERROR;
1641     }
1642     ether_setup(dev);
1643     ar_netif = ar6k_priv(dev);
1644 #endif /* ATH6K_CONFIG_CFG80211 */
1645
1646     if (ar_netif == NULL) {
1647         AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s: Can't allocate ar6k priv memory\n", __func__));
1648         return A_ERROR;
1649     }
1650
1651     A_MEMZERO(ar_netif, sizeof(AR_SOFTC_T));
1652     ar = (AR_SOFTC_T *)ar_netif;
1653
1654 #ifdef ATH6K_CONFIG_CFG80211
1655     ar->wdev = wdev;
1656     wdev->iftype = NL80211_IFTYPE_STATION;
1657
1658     dev = alloc_netdev_mq(0, "wlan%d", ether_setup, 1);
1659     if (!dev) {
1660         printk(KERN_CRIT "AR6K: no memory for network device instance\n");
1661         ar6k_cfg80211_deinit(ar);
1662         return A_ERROR;
1663     }
1664
1665     dev->ieee80211_ptr = wdev;
1666     SET_NETDEV_DEV(dev, wiphy_dev(wdev->wiphy));
1667     wdev->netdev = dev;
1668     ar->arNetworkType = INFRA_NETWORK;
1669 #endif /* ATH6K_CONFIG_CFG80211 */
1670
1671     init_netdev(dev, ifname);
1672
1673 #ifdef SET_NETDEV_DEV
1674     if (ar_netif) {
1675         HIF_DEVICE_OS_DEVICE_INFO osDevInfo;
1676         A_MEMZERO(&osDevInfo, sizeof(osDevInfo));
1677         if ( A_SUCCESS( HIFConfigureDevice(hif_handle, HIF_DEVICE_GET_OS_DEVICE,
1678                         &osDevInfo, sizeof(osDevInfo))) ) {
1679             SET_NETDEV_DEV(dev, osDevInfo.pOSDevice);
1680         }
1681     }
1682 #endif
1683
1684     ar->arNetDev             = dev;
1685     ar->arHifDevice          = hif_handle;
1686     ar->arWlanState          = WLAN_ENABLED;
1687     ar->arDeviceIndex        = device_index;
1688
1689     ar->arWlanPowerState     = WLAN_POWER_STATE_ON;
1690     ar->arWlanOff            = FALSE;   /* We are in ON state */
1691 #ifdef CONFIG_PM
1692     ar->arWowState           = WLAN_WOW_STATE_NONE;
1693     ar->arBTOff              = TRUE;   /* BT chip assumed to be OFF */
1694     ar->arBTSharing          = WLAN_CONFIG_BT_SHARING;
1695     ar->arWlanOffConfig      = WLAN_CONFIG_WLAN_OFF;
1696     ar->arSuspendConfig      = WLAN_CONFIG_PM_SUSPEND;
1697     ar->arWow2Config         = WLAN_CONFIG_PM_WOW2;
1698 #endif /* CONFIG_PM */
1699
1700     A_INIT_TIMER(&ar->arHBChallengeResp.timer, ar6000_detect_error, dev);
1701     ar->arHBChallengeResp.seqNum = 0;
1702     ar->arHBChallengeResp.outstanding = FALSE;
1703     ar->arHBChallengeResp.missCnt = 0;
1704     ar->arHBChallengeResp.frequency = AR6000_HB_CHALLENGE_RESP_FREQ_DEFAULT;
1705     ar->arHBChallengeResp.missThres = AR6000_HB_CHALLENGE_RESP_MISS_THRES_DEFAULT;
1706
1707     ar6000_init_control_info(ar);
1708     init_waitqueue_head(&arEvent);
1709     sema_init(&ar->arSem, 1);
1710     ar->bIsDestroyProgress = FALSE;
1711
1712     INIT_HTC_PACKET_QUEUE(&ar->amsdu_rx_buffer_queue);
1713
1714 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
1715     A_INIT_TIMER(&aptcTimer, aptcTimerHandler, ar);
1716 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
1717
1718     A_INIT_TIMER(&ar->disconnect_timer, disconnect_timer_handler, dev);
1719
1720     BMIInit();
1721
1722     if (bmienable) {
1723         ar6000_sysfs_bmi_init(ar);
1724     }
1725
1726     {
1727         struct bmi_target_info targ_info;
1728
1729         if (BMIGetTargetInfo(ar->arHifDevice, &targ_info) != A_OK) {
1730             init_status = A_ERROR;
1731             goto avail_ev_failed;
1732         }
1733
1734         ar->arVersion.target_ver = targ_info.target_ver;
1735         ar->arTargetType = targ_info.target_type;
1736
1737             /* do any target-specific preparation that can be done through BMI */
1738         if (ar6000_prepare_target(ar->arHifDevice,
1739                                   targ_info.target_type,
1740                                   targ_info.target_ver) != A_OK) {
1741             init_status = A_ERROR;
1742             goto avail_ev_failed;
1743         }
1744
1745     }
1746
1747     if (ar6000_configure_target(ar) != A_OK) {
1748             init_status = A_ERROR;
1749             goto avail_ev_failed;
1750     }
1751
1752     A_MEMZERO(&htcInfo,sizeof(htcInfo));
1753     htcInfo.pContext = ar;
1754     htcInfo.TargetFailure = ar6000_target_failure;
1755
1756     ar->arHtcTarget = HTCCreate(ar->arHifDevice,&htcInfo);
1757
1758     if (ar->arHtcTarget == NULL) {
1759         init_status = A_ERROR;
1760         goto avail_ev_failed;
1761     }
1762
1763     spin_lock_init(&ar->arLock);
1764
1765 #ifdef WAPI_ENABLE
1766     ar->arWapiEnable = 0;
1767 #endif
1768
1769
1770 #ifdef CONFIG_CHECKSUM_OFFLOAD
1771     if(csumOffload){
1772         /*if external frame work is also needed, change and use an extended rxMetaVerion*/
1773         ar->rxMetaVersion=WMI_META_VERSION_2;
1774     }
1775 #endif
1776
1777 #ifdef ATH_AR6K_11N_SUPPORT
1778     if((ar->aggr_cntxt = aggr_init(ar6000_alloc_netbufs)) == NULL) {
1779             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() Failed to initialize aggr.\n", __func__));
1780             init_status = A_ERROR;
1781             goto avail_ev_failed;
1782     }
1783
1784     aggr_register_rx_dispatcher(ar->aggr_cntxt, (void *)dev, ar6000_deliver_frames_to_nw_stack);
1785 #endif
1786
1787     HIFClaimDevice(ar->arHifDevice, ar);
1788
1789     /* We only register the device in the global list if we succeed. */
1790     /* If the device is in the global list, it will be destroyed     */
1791     /* when the module is unloaded.                                  */
1792     ar6000_devices[device_index] = dev;
1793
1794     /* Don't install the init function if BMI is requested */
1795     if (!bmienable) {
1796         ar6000_netdev_ops.ndo_init = ar6000_init;
1797     } else {
1798         AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("BMI enabled: %d\n", wlaninitmode));
1799         if ((wlaninitmode == WLAN_INIT_MODE_UDEV) ||
1800             (wlaninitmode == WLAN_INIT_MODE_DRV))
1801         {
1802             A_STATUS status = A_OK;
1803             do {
1804                 if ((status = ar6000_sysfs_bmi_get_config(ar, wlaninitmode)) != A_OK)
1805                 {
1806                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: ar6000_sysfs_bmi_get_config failed\n"));
1807                     break;
1808                 }
1809 #ifdef HTC_RAW_INTERFACE
1810                 break; /* Don't call ar6000_init for ART */
1811 #endif
1812                 rtnl_lock();
1813                 status = (ar6000_init(dev)==0) ? A_OK : A_ERROR;
1814                 rtnl_unlock();
1815                 if (status != A_OK) {
1816                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: ar6000_init\n"));
1817                 }
1818             } while (FALSE);
1819
1820             if (status != A_OK) {
1821                 init_status = status;
1822                 goto avail_ev_failed;
1823             }
1824         }
1825     }
1826
1827     /* This runs the init function if registered */
1828     if (register_netdev(dev)) {
1829         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: register_netdev failed\n"));
1830         ar6000_destroy(dev, 0);
1831         return A_ERROR;
1832     }
1833
1834         is_netdev_registered = 1;
1835
1836 #ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
1837     arApNetDev = NULL;
1838 #endif /* CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT */
1839     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("ar6000_avail: name=%s hifdevice=0x%lx, dev=0x%lx (%d), ar=0x%lx\n",
1840                     dev->name, (unsigned long)ar->arHifDevice, (unsigned long)dev, device_index,
1841                     (unsigned long)ar));
1842
1843 avail_ev_failed :
1844     if (A_FAILED(init_status)) {
1845         if (bmienable) {
1846             ar6000_sysfs_bmi_deinit(ar);
1847         }
1848     }
1849
1850     return init_status;
1851 }
1852
1853 static void ar6000_target_failure(void *Instance, A_STATUS Status)
1854 {
1855     AR_SOFTC_T *ar = (AR_SOFTC_T *)Instance;
1856     WMI_TARGET_ERROR_REPORT_EVENT errEvent;
1857     static A_BOOL sip = FALSE;
1858
1859     if (Status != A_OK) {
1860
1861         printk(KERN_ERR "ar6000_target_failure: target asserted \n");
1862
1863         if (timer_pending(&ar->arHBChallengeResp.timer)) {
1864             A_UNTIMEOUT(&ar->arHBChallengeResp.timer);
1865         }
1866
1867         /* try dumping target assertion information (if any) */
1868         ar6000_dump_target_assert_info(ar->arHifDevice,ar->arTargetType);
1869
1870         /*
1871          * Fetch the logs from the target via the diagnostic
1872          * window.
1873          */
1874         ar6000_dbglog_get_debug_logs(ar);
1875
1876         /* Report the error only once */
1877         if (!sip) {
1878             sip = TRUE;
1879             errEvent.errorVal = WMI_TARGET_COM_ERR |
1880                                 WMI_TARGET_FATAL_ERR;
1881             ar6000_send_event_to_app(ar, WMI_ERROR_REPORT_EVENTID,
1882                                      (A_UINT8 *)&errEvent,
1883                                      sizeof(WMI_TARGET_ERROR_REPORT_EVENT));
1884         }
1885     }
1886 }
1887
1888 static A_STATUS
1889 ar6000_unavail_ev(void *context, void *hif_handle)
1890 {
1891     AR_SOFTC_T *ar = (AR_SOFTC_T *)context;
1892         /* NULL out it's entry in the global list */
1893     ar6000_devices[ar->arDeviceIndex] = NULL;
1894     ar6000_destroy(ar->arNetDev, 1);
1895
1896     return A_OK;
1897 }
1898
1899 void
1900 ar6000_restart_endpoint(struct net_device *dev)
1901 {
1902     A_STATUS status = A_OK;
1903     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1904
1905     BMIInit();
1906     do {
1907         if ( (status=ar6000_configure_target(ar))!=A_OK)
1908             break;
1909         if ( (status=ar6000_sysfs_bmi_get_config(ar, wlaninitmode)) != A_OK)
1910         {
1911             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_avail: ar6000_sysfs_bmi_get_config failed\n"));
1912             break;
1913         }
1914         rtnl_lock();
1915         status = (ar6000_init(dev)==0) ? A_OK : A_ERROR;
1916         rtnl_unlock();
1917
1918         if (status!=A_OK) {
1919             break;
1920         }
1921         if (ar->arSsidLen && ar->arWlanState == WLAN_ENABLED) {
1922             ar6000_connect_to_ap(ar);
1923         }
1924     } while (0);
1925
1926     if (status==A_OK) {
1927         return;
1928     }
1929
1930     ar6000_devices[ar->arDeviceIndex] = NULL;
1931     ar6000_destroy(ar->arNetDev, 1);
1932 }
1933
1934 void
1935 ar6000_stop_endpoint(struct net_device *dev, A_BOOL keepprofile, A_BOOL getdbglogs)
1936 {
1937     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
1938
1939     /* Stop the transmit queues */
1940     netif_stop_queue(dev);
1941
1942     /* Disable the target and the interrupts associated with it */
1943     if (ar->arWmiReady == TRUE)
1944     {
1945         if (!bypasswmi)
1946         {
1947             if (ar->arConnected == TRUE || ar->arConnectPending == TRUE)
1948             {
1949                 AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): Disconnect\n", __func__));
1950                 if (!keepprofile) {
1951                     AR6000_SPIN_LOCK(&ar->arLock, 0);
1952                     ar6000_init_profile_info(ar);
1953                     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1954                 }
1955                 wmi_disconnect_cmd(ar->arWmi);
1956             }
1957
1958             A_UNTIMEOUT(&ar->disconnect_timer);
1959
1960             if (getdbglogs) {
1961                 ar6000_dbglog_get_debug_logs(ar);
1962             }
1963
1964             ar->arWmiReady  = FALSE;
1965             wmi_shutdown(ar->arWmi);
1966             ar->arWmiEnabled = FALSE;
1967             ar->arWmi = NULL;
1968             /*
1969              * After wmi_shudown all WMI events will be dropped.
1970              * We need to cleanup the buffers allocated in AP mode
1971              * and give disconnect notification to stack, which usually
1972              * happens in the disconnect_event.
1973              * Simulate the disconnect_event by calling the function directly.
1974              * Sometimes disconnect_event will be received when the debug logs
1975              * are collected.
1976              */
1977             if (ar->arConnected == TRUE || ar->arConnectPending == TRUE) {
1978                 if(ar->arNetworkType & AP_NETWORK) {
1979                     ar6000_disconnect_event(ar, DISCONNECT_CMD, bcast_mac, 0, NULL, 0);
1980                 } else {
1981                     ar6000_disconnect_event(ar, DISCONNECT_CMD, ar->arBssid, 0, NULL, 0);
1982                 }
1983                 ar->arConnected = FALSE;
1984                 ar->arConnectPending = FALSE;
1985             }
1986 #ifdef USER_KEYS
1987             ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT;
1988             ar->user_key_ctrl      = 0;
1989 #endif
1990         }
1991
1992          AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): WMI stopped\n", __func__));
1993     }
1994     else
1995     {
1996         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): WMI not ready 0x%lx 0x%lx\n",
1997             __func__, (unsigned long) ar, (unsigned long) ar->arWmi));
1998
1999         /* Shut down WMI if we have started it */
2000         if(ar->arWmiEnabled == TRUE)
2001         {
2002             AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("%s(): Shut down WMI\n", __func__));
2003             wmi_shutdown(ar->arWmi);
2004             ar->arWmiEnabled = FALSE;
2005             ar->arWmi = NULL;
2006         }
2007     }
2008
2009     if (ar->arHtcTarget != NULL) {
2010 #ifdef EXPORT_HCI_BRIDGE_INTERFACE
2011         if (NULL != ar6kHciTransCallbacks.cleanupTransport) {
2012             ar6kHciTransCallbacks.cleanupTransport(NULL);
2013         }
2014 #else
2015         // FIXME: workaround to reset BT's UART baud rate to default
2016         if (NULL != ar->exitCallback) {
2017             AR3K_CONFIG_INFO ar3kconfig;
2018             A_STATUS status;
2019
2020             A_MEMZERO(&ar3kconfig,sizeof(ar3kconfig));
2021             ar6000_set_default_ar3kconfig(ar, (void *)&ar3kconfig);
2022             status = ar->exitCallback(&ar3kconfig);
2023             if (A_OK != status) {
2024                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Failed to reset AR3K baud rate! \n"));
2025             }
2026         }
2027         // END workaround
2028         if (setuphci)
2029                 ar6000_cleanup_hci(ar);
2030 #endif
2031 #ifdef EXPORT_HCI_PAL_INTERFACE
2032         if (setuphcipal && (NULL != ar6kHciPalCallbacks_g.cleanupTransport)) {
2033            ar6kHciPalCallbacks_g.cleanupTransport(ar);
2034         }
2035 #else
2036                                 /* cleanup hci pal driver data structures */
2037         if(setuphcipal)
2038           ar6k_cleanup_hci_pal(ar);
2039 #endif
2040         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" Shutting down HTC .... \n"));
2041         /* stop HTC */
2042         HTCStop(ar->arHtcTarget);
2043     }
2044
2045     if (resetok) {
2046         /* try to reset the device if we can
2047          * The driver may have been configure NOT to reset the target during
2048          * a debug session */
2049         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" Attempting to reset target on instance destroy.... \n"));
2050         if (ar->arHifDevice != NULL) {
2051             A_BOOL coldReset = (ar->arTargetType == TARGET_TYPE_AR6003) ? TRUE: FALSE;
2052             ar6000_reset_device(ar->arHifDevice, ar->arTargetType, TRUE, coldReset);
2053         }
2054     } else {
2055         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,(" Host does not want target reset. \n"));
2056     }
2057        /* Done with cookies */
2058     ar6000_cookie_cleanup(ar);
2059 }
2060 /*
2061  * We need to differentiate between the surprise and planned removal of the
2062  * device because of the following consideration:
2063  * - In case of surprise removal, the hcd already frees up the pending
2064  *   for the device and hence there is no need to unregister the function
2065  *   driver inorder to get these requests. For planned removal, the function
2066  *   driver has to explictly unregister itself to have the hcd return all the
2067  *   pending requests before the data structures for the devices are freed up.
2068  *   Note that as per the current implementation, the function driver will
2069  *   end up releasing all the devices since there is no API to selectively
2070  *   release a particular device.
2071  * - Certain commands issued to the target can be skipped for surprise
2072  *   removal since they will anyway not go through.
2073  */
2074 void
2075 ar6000_destroy(struct net_device *dev, unsigned int unregister)
2076 {
2077     AR_SOFTC_T *ar;
2078
2079     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("+ar6000_destroy \n"));
2080
2081     if((dev == NULL) || ((ar = ar6k_priv(dev)) == NULL))
2082     {
2083         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s(): Failed to get device structure.\n", __func__));
2084         return;
2085     }
2086
2087     ar->bIsDestroyProgress = TRUE;
2088
2089     if (down_interruptible(&ar->arSem)) {
2090         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s(): down_interruptible failed \n", __func__));
2091         return;
2092     }
2093
2094     if (ar->arWlanPowerState != WLAN_POWER_STATE_CUT_PWR) {
2095         /* only stop endpoint if we are not stop it in suspend_ev */
2096         ar6000_stop_endpoint(dev, FALSE, TRUE);
2097     } else {
2098         /* clear up the platform power state before rmmod */
2099         plat_setup_power(1,0);
2100     }
2101
2102     ar->arWlanState = WLAN_DISABLED;
2103     if (ar->arHtcTarget != NULL) {
2104         /* destroy HTC */
2105         HTCDestroy(ar->arHtcTarget);
2106     }
2107     if (ar->arHifDevice != NULL) {
2108         /*release the device so we do not get called back on remove incase we
2109          * we're explicity destroyed by module unload */
2110         HIFReleaseDevice(ar->arHifDevice);
2111         HIFShutDownDevice(ar->arHifDevice);
2112     }
2113 #ifdef ATH_AR6K_11N_SUPPORT
2114     aggr_module_destroy(ar->aggr_cntxt);
2115 #endif
2116
2117        /* Done with cookies */
2118     ar6000_cookie_cleanup(ar);
2119
2120         /* cleanup any allocated AMSDU buffers */
2121     ar6000_cleanup_amsdu_rxbufs(ar);
2122
2123     if (bmienable) {
2124         ar6000_sysfs_bmi_deinit(ar);
2125     }
2126
2127     /* Cleanup BMI */
2128     BMICleanup();
2129
2130     /* Clear the tx counters */
2131     memset(tx_attempt, 0, sizeof(tx_attempt));
2132     memset(tx_post, 0, sizeof(tx_post));
2133     memset(tx_complete, 0, sizeof(tx_complete));
2134
2135 #ifdef HTC_RAW_INTERFACE
2136     if (ar->arRawHtc) {
2137         A_FREE(ar->arRawHtc);
2138         ar->arRawHtc = NULL;
2139     }
2140 #endif
2141     /* Free up the device data structure */
2142     if (unregister && is_netdev_registered) {
2143         unregister_netdev(dev);
2144         is_netdev_registered = 0;
2145     }
2146 #ifndef free_netdev
2147     kfree(dev);
2148 #else
2149     free_netdev(dev);
2150 #endif
2151
2152 #ifdef ATH6K_CONFIG_CFG80211
2153     ar6k_cfg80211_deinit(ar);
2154 #endif /* ATH6K_CONFIG_CFG80211 */
2155
2156 #ifdef CONFIG_AP_VIRTUL_ADAPTER_SUPPORT
2157     ar6000_remove_ap_interface();
2158 #endif /*CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT */
2159
2160     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("-ar6000_destroy \n"));
2161 }
2162
2163 static void disconnect_timer_handler(unsigned long ptr)
2164 {
2165     struct net_device *dev = (struct net_device *)ptr;
2166     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2167
2168     A_UNTIMEOUT(&ar->disconnect_timer);
2169
2170     ar6000_init_profile_info(ar);
2171     wmi_disconnect_cmd(ar->arWmi);
2172 }
2173
2174 static void ar6000_detect_error(unsigned long ptr)
2175 {
2176     struct net_device *dev = (struct net_device *)ptr;
2177     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2178     WMI_TARGET_ERROR_REPORT_EVENT errEvent;
2179
2180     AR6000_SPIN_LOCK(&ar->arLock, 0);
2181
2182     if (ar->arHBChallengeResp.outstanding) {
2183         ar->arHBChallengeResp.missCnt++;
2184     } else {
2185         ar->arHBChallengeResp.missCnt = 0;
2186     }
2187
2188     if (ar->arHBChallengeResp.missCnt > ar->arHBChallengeResp.missThres) {
2189         /* Send Error Detect event to the application layer and do not reschedule the error detection module timer */
2190         ar->arHBChallengeResp.missCnt = 0;
2191         ar->arHBChallengeResp.seqNum = 0;
2192         errEvent.errorVal = WMI_TARGET_COM_ERR | WMI_TARGET_FATAL_ERR;
2193         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2194         ar6000_send_event_to_app(ar, WMI_ERROR_REPORT_EVENTID,
2195                                  (A_UINT8 *)&errEvent,
2196                                  sizeof(WMI_TARGET_ERROR_REPORT_EVENT));
2197         return;
2198     }
2199
2200     /* Generate the sequence number for the next challenge */
2201     ar->arHBChallengeResp.seqNum++;
2202     ar->arHBChallengeResp.outstanding = TRUE;
2203
2204     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2205
2206     /* Send the challenge on the control channel */
2207     if (wmi_get_challenge_resp_cmd(ar->arWmi, ar->arHBChallengeResp.seqNum, DRV_HB_CHALLENGE) != A_OK) {
2208         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to send heart beat challenge\n"));
2209     }
2210
2211
2212     /* Reschedule the timer for the next challenge */
2213     A_TIMEOUT_MS(&ar->arHBChallengeResp.timer, ar->arHBChallengeResp.frequency * 1000, 0);
2214 }
2215
2216 void ar6000_init_profile_info(AR_SOFTC_T *ar)
2217 {
2218     ar->arSsidLen            = 0;
2219     A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
2220
2221     switch(fwmode) {
2222         case HI_OPTION_FW_MODE_IBSS:
2223             ar->arNetworkType = ar->arNextMode = ADHOC_NETWORK;
2224             break;
2225         case HI_OPTION_FW_MODE_BSS_STA:
2226             ar->arNetworkType = ar->arNextMode = INFRA_NETWORK;
2227             break;
2228         case HI_OPTION_FW_MODE_AP:
2229             ar->arNetworkType = ar->arNextMode = AP_NETWORK;
2230             break;
2231     }
2232
2233     ar->arDot11AuthMode      = OPEN_AUTH;
2234     ar->arAuthMode           = NONE_AUTH;
2235     ar->arPairwiseCrypto     = NONE_CRYPT;
2236     ar->arPairwiseCryptoLen  = 0;
2237     ar->arGroupCrypto        = NONE_CRYPT;
2238     ar->arGroupCryptoLen     = 0;
2239     A_MEMZERO(ar->arWepKeyList, sizeof(ar->arWepKeyList));
2240     A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid));
2241     A_MEMZERO(ar->arBssid, sizeof(ar->arBssid));
2242     ar->arBssChannel = 0;
2243     ar->arConnected = FALSE;
2244 }
2245
2246 static void
2247 ar6000_init_control_info(AR_SOFTC_T *ar)
2248 {
2249     ar->arWmiEnabled         = FALSE;
2250     ar6000_init_profile_info(ar);
2251     ar->arDefTxKeyIndex      = 0;
2252     A_MEMZERO(ar->arWepKeyList, sizeof(ar->arWepKeyList));
2253     ar->arChannelHint        = 0;
2254     ar->arListenIntervalT    = A_DEFAULT_LISTEN_INTERVAL;
2255     ar->arListenIntervalB    = 0;
2256     ar->arVersion.host_ver   = AR6K_SW_VERSION;
2257     ar->arRssi               = 0;
2258     ar->arTxPwr              = 0;
2259     ar->arTxPwrSet           = FALSE;
2260     ar->arSkipScan           = 0;
2261     ar->arBeaconInterval     = 0;
2262     ar->arBitRate            = 0;
2263     ar->arMaxRetries         = 0;
2264     ar->arWmmEnabled         = TRUE;
2265     ar->intra_bss            = 1;
2266     ar->scan_triggered       = 0;
2267     A_MEMZERO(&ar->scParams, sizeof(ar->scParams));
2268     ar->scParams.shortScanRatio = WMI_SHORTSCANRATIO_DEFAULT;
2269     ar->scParams.scanCtrlFlags = DEFAULT_SCAN_CTRL_FLAGS;
2270
2271     /* Initialize the AP mode state info */
2272     {
2273         A_UINT8 ctr;
2274         A_MEMZERO((A_UINT8 *)ar->sta_list, AP_MAX_NUM_STA * sizeof(sta_t));
2275
2276         /* init the Mutexes */
2277         A_MUTEX_INIT(&ar->mcastpsqLock);
2278
2279         /* Init the PS queues */
2280         for (ctr=0; ctr < AP_MAX_NUM_STA ; ctr++) {
2281             A_MUTEX_INIT(&ar->sta_list[ctr].psqLock);
2282             A_NETBUF_QUEUE_INIT(&ar->sta_list[ctr].psq);
2283         }
2284
2285         ar->ap_profile_flag = 0;
2286         A_NETBUF_QUEUE_INIT(&ar->mcastpsq);
2287
2288         A_MEMCPY(ar->ap_country_code, DEF_AP_COUNTRY_CODE, 3);
2289         ar->ap_wmode = DEF_AP_WMODE_G;
2290         ar->ap_dtim_period = DEF_AP_DTIM;
2291         ar->ap_beacon_interval = DEF_BEACON_INTERVAL;
2292     }
2293 }
2294
2295 static int
2296 ar6000_open(struct net_device *dev)
2297 {
2298     unsigned long  flags;
2299     AR_SOFTC_T    *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2300
2301     spin_lock_irqsave(&ar->arLock, flags);
2302
2303 #ifdef ATH6K_CONFIG_CFG80211
2304     if(ar->arWlanState == WLAN_DISABLED) {
2305         ar->arWlanState = WLAN_ENABLED;
2306     }
2307 #endif /* ATH6K_CONFIG_CFG80211 */
2308
2309     if( ar->arConnected || bypasswmi) {
2310         netif_carrier_on(dev);
2311         /* Wake up the queues */
2312         netif_wake_queue(dev);
2313     }
2314     else
2315         netif_carrier_off(dev);
2316
2317     spin_unlock_irqrestore(&ar->arLock, flags);
2318     return 0;
2319 }
2320
2321 static int
2322 ar6000_close(struct net_device *dev)
2323 {
2324 #ifdef ATH6K_CONFIG_CFG80211
2325     AR_SOFTC_T    *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2326 #endif /* ATH6K_CONFIG_CFG80211 */
2327     netif_stop_queue(dev);
2328
2329 #ifdef ATH6K_CONFIG_CFG80211
2330     AR6000_SPIN_LOCK(&ar->arLock, 0);
2331     if (ar->arConnected == TRUE || ar->arConnectPending == TRUE) {
2332         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2333         wmi_disconnect_cmd(ar->arWmi);
2334     } else {
2335         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2336     }
2337
2338     if(ar->arWmiReady == TRUE) {
2339         if (wmi_scanparams_cmd(ar->arWmi, 0xFFFF, 0,
2340                                0, 0, 0, 0, 0, 0, 0, 0) != A_OK) {
2341             return -EIO;
2342         }
2343         ar->arWlanState = WLAN_DISABLED;
2344     }
2345 #endif /* ATH6K_CONFIG_CFG80211 */
2346
2347     return 0;
2348 }
2349
2350 /* connect to a service */
2351 static A_STATUS ar6000_connectservice(AR_SOFTC_T               *ar,
2352                                       HTC_SERVICE_CONNECT_REQ  *pConnect,
2353                                       char                     *pDesc)
2354 {
2355     A_STATUS                 status;
2356     HTC_SERVICE_CONNECT_RESP response;
2357
2358     do {
2359
2360         A_MEMZERO(&response,sizeof(response));
2361
2362         status = HTCConnectService(ar->arHtcTarget,
2363                                    pConnect,
2364                                    &response);
2365
2366         if (A_FAILED(status)) {
2367             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" Failed to connect to %s service status:%d \n",
2368                               pDesc, status));
2369             break;
2370         }
2371         switch (pConnect->ServiceID) {
2372             case WMI_CONTROL_SVC :
2373                 if (ar->arWmiEnabled) {
2374                         /* set control endpoint for WMI use */
2375                     wmi_set_control_ep(ar->arWmi, response.Endpoint);
2376                 }
2377                     /* save EP for fast lookup */
2378                 ar->arControlEp = response.Endpoint;
2379                 break;
2380             case WMI_DATA_BE_SVC :
2381                 arSetAc2EndpointIDMap(ar, WMM_AC_BE, response.Endpoint);
2382                 break;
2383             case WMI_DATA_BK_SVC :
2384                 arSetAc2EndpointIDMap(ar, WMM_AC_BK, response.Endpoint);
2385                 break;
2386             case WMI_DATA_VI_SVC :
2387                 arSetAc2EndpointIDMap(ar, WMM_AC_VI, response.Endpoint);
2388                  break;
2389            case WMI_DATA_VO_SVC :
2390                 arSetAc2EndpointIDMap(ar, WMM_AC_VO, response.Endpoint);
2391                 break;
2392            default:
2393                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ServiceID not mapped %d\n", pConnect->ServiceID));
2394                 status = A_EINVAL;
2395             break;
2396         }
2397
2398     } while (FALSE);
2399
2400     return status;
2401 }
2402
2403 void ar6000_TxDataCleanup(AR_SOFTC_T *ar)
2404 {
2405         /* flush all the data (non-control) streams
2406          * we only flush packets that are tagged as data, we leave any control packets that
2407          * were in the TX queues alone */
2408     HTCFlushEndpoint(ar->arHtcTarget,
2409                      arAc2EndpointID(ar, WMM_AC_BE),
2410                      AR6K_DATA_PKT_TAG);
2411     HTCFlushEndpoint(ar->arHtcTarget,
2412                      arAc2EndpointID(ar, WMM_AC_BK),
2413                      AR6K_DATA_PKT_TAG);
2414     HTCFlushEndpoint(ar->arHtcTarget,
2415                      arAc2EndpointID(ar, WMM_AC_VI),
2416                      AR6K_DATA_PKT_TAG);
2417     HTCFlushEndpoint(ar->arHtcTarget,
2418                      arAc2EndpointID(ar, WMM_AC_VO),
2419                      AR6K_DATA_PKT_TAG);
2420 }
2421
2422 HTC_ENDPOINT_ID
2423 ar6000_ac2_endpoint_id ( void * devt, A_UINT8 ac)
2424 {
2425     AR_SOFTC_T *ar = (AR_SOFTC_T *) devt;
2426     return(arAc2EndpointID(ar, ac));
2427 }
2428
2429 A_UINT8
2430 ar6000_endpoint_id2_ac(void * devt, HTC_ENDPOINT_ID ep )
2431 {
2432     AR_SOFTC_T *ar = (AR_SOFTC_T *) devt;
2433     return(arEndpoint2Ac(ar, ep ));
2434 }
2435
2436 /* This function does one time initialization for the lifetime of the device */
2437 int ar6000_init(struct net_device *dev)
2438 {
2439     AR_SOFTC_T *ar;
2440     A_STATUS    status;
2441     A_INT32     timeleft;
2442     A_INT16     i;
2443     int         ret = 0;
2444 #if defined(INIT_MODE_DRV_ENABLED) && defined(ENABLE_COEXISTENCE)
2445     WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD sbcb_cmd;
2446     WMI_SET_BTCOEX_FE_ANT_CMD sbfa_cmd;
2447 #endif /* INIT_MODE_DRV_ENABLED && ENABLE_COEXISTENCE */
2448
2449     if((ar = ar6k_priv(dev)) == NULL)
2450     {
2451         return -EIO;
2452     }
2453
2454     if (wlaninitmode == WLAN_INIT_MODE_USR || wlaninitmode == WLAN_INIT_MODE_DRV) {
2455
2456         ar6000_update_bdaddr(ar);
2457
2458         if (enablerssicompensation) {
2459             ar6000_copy_cust_data_from_target(ar->arHifDevice, ar->arTargetType);
2460             read_rssi_compensation_param(ar);
2461             for (i=-95; i<=0; i++) {
2462                 rssi_compensation_table[0-i] = rssi_compensation_calc(ar,i);
2463             }
2464         }
2465     }
2466
2467     dev_hold(dev);
2468     rtnl_unlock();
2469
2470     /* Do we need to finish the BMI phase */
2471     if ((wlaninitmode == WLAN_INIT_MODE_USR || wlaninitmode == WLAN_INIT_MODE_DRV) &&
2472         (BMIDone(ar->arHifDevice) != A_OK))
2473     {
2474         ret = -EIO;
2475         goto ar6000_init_done;
2476     }
2477
2478     if (!bypasswmi)
2479     {
2480 #if 0 /* TBDXXX */
2481         if (ar->arVersion.host_ver != ar->arVersion.target_ver) {
2482             A_PRINTF("WARNING: Host version 0x%x does not match Target "
2483                     " version 0x%x!\n",
2484                     ar->arVersion.host_ver, ar->arVersion.target_ver);
2485         }
2486 #endif
2487
2488         /* Indicate that WMI is enabled (although not ready yet) */
2489         ar->arWmiEnabled = TRUE;
2490         if ((ar->arWmi = wmi_init((void *) ar)) == NULL)
2491         {
2492             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() Failed to initialize WMI.\n", __func__));
2493             ret = -EIO;
2494             goto ar6000_init_done;
2495         }
2496
2497         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() Got WMI @ 0x%lx.\n", __func__,
2498             (unsigned long) ar->arWmi));
2499     }
2500
2501     do {
2502         HTC_SERVICE_CONNECT_REQ connect;
2503
2504             /* the reason we have to wait for the target here is that the driver layer
2505              * has to init BMI in order to set the host block size,
2506              */
2507         status = HTCWaitTarget(ar->arHtcTarget);
2508
2509         if (A_FAILED(status)) {
2510             break;
2511         }
2512
2513         A_MEMZERO(&connect,sizeof(connect));
2514             /* meta data is unused for now */
2515         connect.pMetaData = NULL;
2516         connect.MetaDataLength = 0;
2517             /* these fields are the same for all service endpoints */
2518         connect.EpCallbacks.pContext = ar;
2519         connect.EpCallbacks.EpTxCompleteMultiple = ar6000_tx_complete;
2520         connect.EpCallbacks.EpRecv = ar6000_rx;
2521         connect.EpCallbacks.EpRecvRefill = ar6000_rx_refill;
2522         connect.EpCallbacks.EpSendFull = ar6000_tx_queue_full;
2523             /* set the max queue depth so that our ar6000_tx_queue_full handler gets called.
2524              * Linux has the peculiarity of not providing flow control between the
2525              * NIC and the network stack. There is no API to indicate that a TX packet
2526              * was sent which could provide some back pressure to the network stack.
2527              * Under linux you would have to wait till the network stack consumed all sk_buffs
2528              * before any back-flow kicked in. Which isn't very friendly.
2529              * So we have to manage this ourselves */
2530         connect.MaxSendQueueDepth = MAX_DEFAULT_SEND_QUEUE_DEPTH;
2531         connect.EpCallbacks.RecvRefillWaterMark = AR6000_MAX_RX_BUFFERS / 4; /* set to 25 % */
2532         if (0 == connect.EpCallbacks.RecvRefillWaterMark) {
2533             connect.EpCallbacks.RecvRefillWaterMark++;
2534         }
2535             /* connect to control service */
2536         connect.ServiceID = WMI_CONTROL_SVC;
2537         status = ar6000_connectservice(ar,
2538                                        &connect,
2539                                        "WMI CONTROL");
2540         if (A_FAILED(status)) {
2541             break;
2542         }
2543
2544         connect.LocalConnectionFlags |= HTC_LOCAL_CONN_FLAGS_ENABLE_SEND_BUNDLE_PADDING;
2545             /* limit the HTC message size on the send path, although we can receive A-MSDU frames of
2546              * 4K, we will only send ethernet-sized (802.3) frames on the send path. */
2547         connect.MaxSendMsgSize = WMI_MAX_TX_DATA_FRAME_LENGTH;
2548
2549             /* to reduce the amount of committed memory for larger A_MSDU frames, use the recv-alloc threshold
2550              * mechanism for larger packets */
2551         connect.EpCallbacks.RecvAllocThreshold = AR6000_BUFFER_SIZE;
2552         connect.EpCallbacks.EpRecvAllocThresh = ar6000_alloc_amsdu_rxbuf;
2553
2554             /* for the remaining data services set the connection flag to reduce dribbling,
2555              * if configured to do so */
2556         if (reduce_credit_dribble) {
2557             connect.ConnectionFlags |= HTC_CONNECT_FLAGS_REDUCE_CREDIT_DRIBBLE;
2558             /* the credit dribble trigger threshold is (reduce_credit_dribble - 1) for a value
2559              * of 0-3 */
2560             connect.ConnectionFlags &= ~HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_MASK;
2561             connect.ConnectionFlags |=
2562                         ((A_UINT16)reduce_credit_dribble - 1) & HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_MASK;
2563         }
2564             /* connect to best-effort service */
2565         connect.ServiceID = WMI_DATA_BE_SVC;
2566
2567         status = ar6000_connectservice(ar,
2568                                        &connect,
2569                                        "WMI DATA BE");
2570         if (A_FAILED(status)) {
2571             break;
2572         }
2573
2574             /* connect to back-ground
2575              * map this to WMI LOW_PRI */
2576         connect.ServiceID = WMI_DATA_BK_SVC;
2577         status = ar6000_connectservice(ar,
2578                                        &connect,
2579                                        "WMI DATA BK");
2580         if (A_FAILED(status)) {
2581             break;
2582         }
2583
2584             /* connect to Video service, map this to
2585              * to HI PRI */
2586         connect.ServiceID = WMI_DATA_VI_SVC;
2587         status = ar6000_connectservice(ar,
2588                                        &connect,
2589                                        "WMI DATA VI");
2590         if (A_FAILED(status)) {
2591             break;
2592         }
2593
2594             /* connect to VO service, this is currently not
2595              * mapped to a WMI priority stream due to historical reasons.
2596              * WMI originally defined 3 priorities over 3 mailboxes
2597              * We can change this when WMI is reworked so that priorities are not
2598              * dependent on mailboxes */
2599         connect.ServiceID = WMI_DATA_VO_SVC;
2600         status = ar6000_connectservice(ar,
2601                                        &connect,
2602                                        "WMI DATA VO");
2603         if (A_FAILED(status)) {
2604             break;
2605         }
2606
2607         A_ASSERT(arAc2EndpointID(ar,WMM_AC_BE) != 0);
2608         A_ASSERT(arAc2EndpointID(ar,WMM_AC_BK) != 0);
2609         A_ASSERT(arAc2EndpointID(ar,WMM_AC_VI) != 0);
2610         A_ASSERT(arAc2EndpointID(ar,WMM_AC_VO) != 0);
2611
2612             /* setup access class priority mappings */
2613         ar->arAcStreamPriMap[WMM_AC_BK] = 0; /* lowest  */
2614         ar->arAcStreamPriMap[WMM_AC_BE] = 1; /*         */
2615         ar->arAcStreamPriMap[WMM_AC_VI] = 2; /*         */
2616         ar->arAcStreamPriMap[WMM_AC_VO] = 3; /* highest */
2617
2618 #ifdef EXPORT_HCI_BRIDGE_INTERFACE
2619         if (setuphci && (NULL != ar6kHciTransCallbacks.setupTransport)) {
2620             HCI_TRANSPORT_MISC_HANDLES hciHandles;
2621
2622             hciHandles.netDevice = ar->arNetDev;
2623             hciHandles.hifDevice = ar->arHifDevice;
2624             hciHandles.htcHandle = ar->arHtcTarget;
2625             status = (A_STATUS)(ar6kHciTransCallbacks.setupTransport(&hciHandles));
2626         }
2627 #else
2628         if (setuphci) {
2629                 /* setup HCI */
2630             status = ar6000_setup_hci(ar);
2631         }
2632 #endif
2633 #ifdef EXPORT_HCI_PAL_INTERFACE
2634         if (setuphcipal && (NULL != ar6kHciPalCallbacks_g.setupTransport))
2635           status = ar6kHciPalCallbacks_g.setupTransport(ar);
2636 #else
2637         if(setuphcipal)
2638           status = ar6k_setup_hci_pal(ar);
2639 #endif
2640
2641     } while (FALSE);
2642
2643     if (A_FAILED(status)) {
2644         ret = -EIO;
2645         goto ar6000_init_done;
2646     }
2647
2648     /*
2649      * give our connected endpoints some buffers
2650      */
2651
2652     ar6000_rx_refill(ar, ar->arControlEp);
2653     ar6000_rx_refill(ar, arAc2EndpointID(ar,WMM_AC_BE));
2654
2655     /*
2656      * We will post the receive buffers only for SPE or endpoint ping testing so we are
2657      * making it conditional on the 'bypasswmi' flag.
2658      */
2659     if (bypasswmi) {
2660         ar6000_rx_refill(ar,arAc2EndpointID(ar,WMM_AC_BK));
2661         ar6000_rx_refill(ar,arAc2EndpointID(ar,WMM_AC_VI));
2662         ar6000_rx_refill(ar,arAc2EndpointID(ar,WMM_AC_VO));
2663     }
2664
2665     /* allocate some buffers that handle larger AMSDU frames */
2666     ar6000_refill_amsdu_rxbufs(ar,AR6000_MAX_AMSDU_RX_BUFFERS);
2667
2668         /* setup credit distribution */
2669     ar6000_setup_credit_dist(ar->arHtcTarget, &ar->arCreditStateInfo);
2670
2671     /* Since cookies are used for HTC transports, they should be */
2672     /* initialized prior to enabling HTC.                        */
2673     ar6000_cookie_init(ar);
2674
2675     /* start HTC */
2676     status = HTCStart(ar->arHtcTarget);
2677
2678     if (status != A_OK) {
2679         if (ar->arWmiEnabled == TRUE) {
2680             wmi_shutdown(ar->arWmi);
2681             ar->arWmiEnabled = FALSE;
2682             ar->arWmi = NULL;
2683         }
2684         ar6000_cookie_cleanup(ar);
2685         ret = -EIO;
2686         goto ar6000_init_done;
2687     }
2688
2689     if (!bypasswmi) {
2690         /* Wait for Wmi event to be ready */
2691         timeleft = wait_event_interruptible_timeout(arEvent,
2692             (ar->arWmiReady == TRUE), wmitimeout * HZ);
2693
2694         if (ar->arVersion.abi_ver != AR6K_ABI_VERSION) {
2695             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ABI Version mismatch: Host(0x%x), Target(0x%x)\n", AR6K_ABI_VERSION, ar->arVersion.abi_ver));
2696 #ifndef ATH6K_SKIP_ABI_VERSION_CHECK
2697             ret = -EIO;
2698             goto ar6000_init_done;
2699 #endif /* ATH6K_SKIP_ABI_VERSION_CHECK */
2700         }
2701
2702         if(!timeleft || signal_pending(current))
2703         {
2704             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI is not ready or wait was interrupted\n"));
2705             ret = -EIO;
2706             goto ar6000_init_done;
2707         }
2708
2709         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() WMI is ready\n", __func__));
2710
2711         /* Communicate the wmi protocol verision to the target */
2712         if ((ar6000_set_host_app_area(ar)) != A_OK) {
2713             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set the host app area\n"));
2714         }
2715
2716         /* configure the device for rx dot11 header rules 0,0 are the default values
2717          * therefore this command can be skipped if the inputs are 0,FALSE,FALSE.Required
2718          if checksum offload is needed. Set RxMetaVersion to 2*/
2719         if ((wmi_set_rx_frame_format_cmd(ar->arWmi,ar->rxMetaVersion, processDot11Hdr, processDot11Hdr)) != A_OK) {
2720             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set the rx frame format.\n"));
2721         }
2722
2723 #if defined(INIT_MODE_DRV_ENABLED) && defined(ENABLE_COEXISTENCE)
2724         /* Configure the type of BT collocated with WLAN */
2725         A_MEMZERO(&sbcb_cmd, sizeof(WMI_SET_BTCOEX_COLOCATED_BT_DEV_CMD));
2726 #ifdef CONFIG_AR600x_BT_QCOM
2727         sbcb_cmd.btcoexCoLocatedBTdev = 1;
2728 #elif defined(CONFIG_AR600x_BT_CSR)
2729         sbcb_cmd.btcoexCoLocatedBTdev = 2;
2730 #elif defined(CONFIG_AR600x_BT_AR3001)
2731         sbcb_cmd.btcoexCoLocatedBTdev = 3;
2732 #else
2733 #error Unsupported Bluetooth Type
2734 #endif /* Collocated Bluetooth Type */
2735
2736         if ((wmi_set_btcoex_colocated_bt_dev_cmd(ar->arWmi, &sbcb_cmd)) != A_OK)
2737         {
2738             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set collocated BT type\n"));
2739         }
2740
2741         /* Configure the type of BT collocated with WLAN */
2742         A_MEMZERO(&sbfa_cmd, sizeof(WMI_SET_BTCOEX_FE_ANT_CMD));
2743 #ifdef CONFIG_AR600x_DUAL_ANTENNA
2744         sbfa_cmd.btcoexFeAntType = 2;
2745 #elif defined(CONFIG_AR600x_SINGLE_ANTENNA)
2746         sbfa_cmd.btcoexFeAntType = 1;
2747 #else
2748 #error Unsupported Front-End Antenna Configuration
2749 #endif /* AR600x Front-End Antenna Configuration */
2750
2751         if ((wmi_set_btcoex_fe_ant_cmd(ar->arWmi, &sbfa_cmd)) != A_OK) {
2752             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Unable to set fornt end antenna configuration\n"));
2753         }
2754 #endif /* INIT_MODE_DRV_ENABLED && ENABLE_COEXISTENCE */
2755     }
2756
2757     ar->arNumDataEndPts = 1;
2758
2759     if (bypasswmi) {
2760             /* for tests like endpoint ping, the MAC address needs to be non-zero otherwise
2761              * the data path through a raw socket is disabled */
2762         dev->dev_addr[0] = 0x00;
2763         dev->dev_addr[1] = 0x01;
2764         dev->dev_addr[2] = 0x02;
2765         dev->dev_addr[3] = 0xAA;
2766         dev->dev_addr[4] = 0xBB;
2767         dev->dev_addr[5] = 0xCC;
2768     }
2769
2770 ar6000_init_done:
2771     rtnl_lock();
2772     dev_put(dev);
2773
2774     return ret;
2775 }
2776
2777
2778 void
2779 ar6000_bitrate_rx(void *devt, A_INT32 rateKbps)
2780 {
2781     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2782
2783     ar->arBitRate = rateKbps;
2784     wake_up(&arEvent);
2785 }
2786
2787 void
2788 ar6000_ratemask_rx(void *devt, A_UINT32 ratemask)
2789 {
2790     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2791
2792     ar->arRateMask = ratemask;
2793     wake_up(&arEvent);
2794 }
2795
2796 void
2797 ar6000_txPwr_rx(void *devt, A_UINT8 txPwr)
2798 {
2799     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2800
2801     ar->arTxPwr = txPwr;
2802     wake_up(&arEvent);
2803 }
2804
2805
2806 void
2807 ar6000_channelList_rx(void *devt, A_INT8 numChan, A_UINT16 *chanList)
2808 {
2809     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2810
2811     A_MEMCPY(ar->arChannelList, chanList, numChan * sizeof (A_UINT16));
2812     ar->arNumChannels = numChan;
2813
2814     wake_up(&arEvent);
2815 }
2816
2817 A_UINT8
2818 ar6000_ibss_map_epid(struct sk_buff *skb, struct net_device *dev, A_UINT32 * mapNo)
2819 {
2820     AR_SOFTC_T      *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2821     A_UINT8         *datap;
2822     ATH_MAC_HDR     *macHdr;
2823     A_UINT32         i, eptMap;
2824
2825     (*mapNo) = 0;
2826     datap = A_NETBUF_DATA(skb);
2827     macHdr = (ATH_MAC_HDR *)(datap + sizeof(WMI_DATA_HDR));
2828     if (IEEE80211_IS_MULTICAST(macHdr->dstMac)) {
2829         return ENDPOINT_2;
2830     }
2831
2832     eptMap = -1;
2833     for (i = 0; i < ar->arNodeNum; i ++) {
2834         if (IEEE80211_ADDR_EQ(macHdr->dstMac, ar->arNodeMap[i].macAddress)) {
2835             (*mapNo) = i + 1;
2836             ar->arNodeMap[i].txPending ++;
2837             return ar->arNodeMap[i].epId;
2838         }
2839
2840         if ((eptMap == -1) && !ar->arNodeMap[i].txPending) {
2841             eptMap = i;
2842         }
2843     }
2844
2845     if (eptMap == -1) {
2846         eptMap = ar->arNodeNum;
2847         ar->arNodeNum ++;
2848         A_ASSERT(ar->arNodeNum <= MAX_NODE_NUM);
2849     }
2850
2851     A_MEMCPY(ar->arNodeMap[eptMap].macAddress, macHdr->dstMac, IEEE80211_ADDR_LEN);
2852
2853     for (i = ENDPOINT_2; i <= ENDPOINT_5; i ++) {
2854         if (!ar->arTxPending[i]) {
2855             ar->arNodeMap[eptMap].epId = i;
2856             break;
2857         }
2858         // No free endpoint is available, start redistribution on the inuse endpoints.
2859         if (i == ENDPOINT_5) {
2860             ar->arNodeMap[eptMap].epId = ar->arNexEpId;
2861             ar->arNexEpId ++;
2862             if (ar->arNexEpId > ENDPOINT_5) {
2863                 ar->arNexEpId = ENDPOINT_2;
2864             }
2865         }
2866     }
2867
2868     (*mapNo) = eptMap + 1;
2869     ar->arNodeMap[eptMap].txPending ++;
2870
2871     return ar->arNodeMap[eptMap].epId;
2872 }
2873
2874 #ifdef DEBUG
2875 static void ar6000_dump_skb(struct sk_buff *skb)
2876 {
2877    u_char *ch;
2878    for (ch = A_NETBUF_DATA(skb);
2879         (unsigned long)ch < ((unsigned long)A_NETBUF_DATA(skb) +
2880         A_NETBUF_LEN(skb)); ch++)
2881     {
2882          AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("%2.2x ", *ch));
2883     }
2884     AR_DEBUG_PRINTF(ATH_DEBUG_WARN,("\n"));
2885 }
2886 #endif
2887
2888 #ifdef HTC_TEST_SEND_PKTS
2889 static void DoHTCSendPktsTest(AR_SOFTC_T *ar, int MapNo, HTC_ENDPOINT_ID eid, struct sk_buff *skb);
2890 #endif
2891
2892 static int
2893 ar6000_data_tx(struct sk_buff *skb, struct net_device *dev)
2894 {
2895 #define AC_NOT_MAPPED   99
2896     AR_SOFTC_T        *ar = (AR_SOFTC_T *)ar6k_priv(dev);
2897     A_UINT8            ac = AC_NOT_MAPPED;
2898     HTC_ENDPOINT_ID    eid = ENDPOINT_UNUSED;
2899     A_UINT32          mapNo = 0;
2900     int               len;
2901     struct ar_cookie *cookie;
2902     A_BOOL            checkAdHocPsMapping = FALSE,bMoreData = FALSE;
2903     HTC_TX_TAG        htc_tag = AR6K_DATA_PKT_TAG;
2904     A_UINT8           dot11Hdr = processDot11Hdr;
2905 #ifdef CONFIG_PM
2906     if (ar->arWowState != WLAN_WOW_STATE_NONE) {
2907         A_NETBUF_FREE(skb);
2908         return 0;
2909     }
2910 #endif /* CONFIG_PM */
2911
2912     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("ar6000_data_tx start - skb=0x%lx, data=0x%lx, len=0x%x\n",
2913                      (unsigned long)skb, (unsigned long)A_NETBUF_DATA(skb),
2914                      A_NETBUF_LEN(skb)));
2915
2916     /* If target is not associated */
2917     if( (!ar->arConnected && !bypasswmi)
2918 #ifdef CONFIG_HOST_TCMD_SUPPORT
2919      /* TCMD doesnt support any data, free the buf and return */
2920     || (ar->arTargetMode == AR6000_TCMD_MODE)
2921 #endif
2922                                             ) {
2923         A_NETBUF_FREE(skb);
2924         return 0;
2925     }
2926
2927     do {
2928
2929         if (ar->arWmiReady == FALSE && bypasswmi == 0) {
2930             break;
2931         }
2932
2933 #ifdef BLOCK_TX_PATH_FLAG
2934         if (blocktx) {
2935             break;
2936         }
2937 #endif /* BLOCK_TX_PATH_FLAG */
2938
2939         /* AP mode Power save processing */
2940         /* If the dst STA is in sleep state, queue the pkt in its PS queue */
2941
2942         if (ar->arNetworkType == AP_NETWORK) {
2943             ATH_MAC_HDR *datap = (ATH_MAC_HDR *)A_NETBUF_DATA(skb);
2944             sta_t *conn = NULL;
2945
2946             /* If the dstMac is a Multicast address & atleast one of the
2947              * associated STA is in PS mode, then queue the pkt to the
2948              * mcastq
2949              */
2950             if (IEEE80211_IS_MULTICAST(datap->dstMac)) {
2951                 A_UINT8 ctr=0;
2952                 A_BOOL qMcast=FALSE;
2953
2954
2955                 for (ctr=0; ctr<AP_MAX_NUM_STA; ctr++) {
2956                     if (STA_IS_PWR_SLEEP((&ar->sta_list[ctr]))) {
2957                         qMcast = TRUE;
2958                     }
2959                 }
2960                 if(qMcast) {
2961
2962                     /* If this transmit is not because of a Dtim Expiry q it */
2963                     if (ar->DTIMExpired == FALSE) {
2964                         A_BOOL isMcastqEmpty = FALSE;
2965
2966                         A_MUTEX_LOCK(&ar->mcastpsqLock);
2967                         isMcastqEmpty = A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq);
2968                         A_NETBUF_ENQUEUE(&ar->mcastpsq, skb);
2969                         A_MUTEX_UNLOCK(&ar->mcastpsqLock);
2970
2971                         /* If this is the first Mcast pkt getting queued
2972                          * indicate to the target to set the BitmapControl LSB
2973                          * of the TIM IE.
2974                          */
2975                         if (isMcastqEmpty) {
2976                              wmi_set_pvb_cmd(ar->arWmi, MCAST_AID, 1);
2977                         }
2978                         return 0;
2979                     } else {
2980                      /* This transmit is because of Dtim expiry. Determine if
2981                       * MoreData bit has to be set.
2982                       */
2983                          A_MUTEX_LOCK(&ar->mcastpsqLock);
2984                          if(!A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq)) {
2985                              bMoreData = TRUE;
2986                          }
2987                          A_MUTEX_UNLOCK(&ar->mcastpsqLock);
2988                     }
2989                 }
2990             } else {
2991                 conn = ieee80211_find_conn(ar, datap->dstMac);
2992                 if (conn) {
2993                     if (STA_IS_PWR_SLEEP(conn)) {
2994                         /* If this transmit is not because of a PsPoll q it*/
2995                         if (!STA_IS_PS_POLLED(conn)) {
2996                             A_BOOL isPsqEmpty = FALSE;
2997                             /* Queue the frames if the STA is sleeping */
2998                             A_MUTEX_LOCK(&conn->psqLock);
2999                             isPsqEmpty = A_NETBUF_QUEUE_EMPTY(&conn->psq);
3000                             A_NETBUF_ENQUEUE(&conn->psq, skb);
3001                             A_MUTEX_UNLOCK(&conn->psqLock);
3002
3003                             /* If this is the first pkt getting queued
3004                              * for this STA, update the PVB for this STA
3005                              */
3006                             if (isPsqEmpty) {
3007                                 wmi_set_pvb_cmd(ar->arWmi, conn->aid, 1);
3008                             }
3009
3010                             return 0;
3011                          } else {
3012                          /* This tx is because of a PsPoll. Determine if
3013                           * MoreData bit has to be set
3014                           */
3015                              A_MUTEX_LOCK(&conn->psqLock);
3016                              if (!A_NETBUF_QUEUE_EMPTY(&conn->psq)) {
3017                                  bMoreData = TRUE;
3018                              }
3019                              A_MUTEX_UNLOCK(&conn->psqLock);
3020                          }
3021                     }
3022                 } else {
3023
3024                     /* non existent STA. drop the frame */
3025                     A_NETBUF_FREE(skb);
3026                     return 0;
3027                 }
3028             }
3029         }
3030
3031         if (ar->arWmiEnabled) {
3032 #ifdef CONFIG_CHECKSUM_OFFLOAD
3033         A_UINT8 csumStart=0;
3034         A_UINT8 csumDest=0;
3035         A_UINT8 csum=skb->ip_summed;
3036         if(csumOffload && (csum==CHECKSUM_PARTIAL)){
3037             csumStart=skb->csum_start-(skb->network_header-skb->head)+sizeof(ATH_LLC_SNAP_HDR);
3038             csumDest=skb->csum_offset+csumStart;
3039         }
3040 #endif
3041             if (A_NETBUF_HEADROOM(skb) < dev->hard_header_len - LINUX_HACK_FUDGE_FACTOR) {
3042                 struct sk_buff  *newbuf;
3043
3044                 /*
3045                  * We really should have gotten enough headroom but sometimes
3046                  * we still get packets with not enough headroom.  Copy the packet.
3047                  */
3048                 len = A_NETBUF_LEN(skb);
3049                 newbuf = A_NETBUF_ALLOC(len);
3050                 if (newbuf == NULL) {
3051                     break;
3052                 }
3053                 A_NETBUF_PUT(newbuf, len);
3054                 A_MEMCPY(A_NETBUF_DATA(newbuf), A_NETBUF_DATA(skb), len);
3055                 A_NETBUF_FREE(skb);
3056                 skb = newbuf;
3057                 /* fall through and assemble header */
3058             }
3059
3060             if (dot11Hdr) {
3061                 if (wmi_dot11_hdr_add(ar->arWmi,skb,ar->arNetworkType) != A_OK) {
3062                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx-wmi_dot11_hdr_add failed\n"));
3063                     break;
3064                 }
3065             } else {
3066                 if (wmi_dix_2_dot3(ar->arWmi, skb) != A_OK) {
3067                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx - wmi_dix_2_dot3 failed\n"));
3068                     break;
3069                 }
3070             }
3071 #ifdef CONFIG_CHECKSUM_OFFLOAD
3072             if(csumOffload && (csum ==CHECKSUM_PARTIAL)){
3073                 WMI_TX_META_V2  metaV2;
3074                 metaV2.csumStart =csumStart;
3075                 metaV2.csumDest = csumDest;
3076                 metaV2.csumFlags = 0x1;/*instruct target to calculate checksum*/
3077                 if (wmi_data_hdr_add(ar->arWmi, skb, DATA_MSGTYPE, bMoreData, dot11Hdr,
3078                                         WMI_META_VERSION_2,&metaV2) != A_OK) {
3079                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx - wmi_data_hdr_add failed\n"));
3080                     break;
3081                 }
3082
3083             }
3084             else
3085 #endif
3086             {
3087                 if (wmi_data_hdr_add(ar->arWmi, skb, DATA_MSGTYPE, bMoreData, dot11Hdr,0,NULL) != A_OK) {
3088                     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_data_tx - wmi_data_hdr_add failed\n"));
3089                     break;
3090                 }
3091             }
3092
3093
3094             if ((ar->arNetworkType == ADHOC_NETWORK) &&
3095                 ar->arIbssPsEnable && ar->arConnected) {
3096                     /* flag to check adhoc mapping once we take the lock below: */
3097                 checkAdHocPsMapping = TRUE;
3098
3099             } else {
3100                     /* get the stream mapping */
3101                 ac  =  wmi_implicit_create_pstream(ar->arWmi, skb, 0, ar->arWmmEnabled);
3102             }
3103
3104         } else {
3105             EPPING_HEADER    *eppingHdr;
3106
3107             eppingHdr = A_NETBUF_DATA(skb);
3108
3109             if (IS_EPPING_PACKET(eppingHdr)) {
3110                     /* the stream ID is mapped to an access class */
3111                 ac = eppingHdr->StreamNo_h;
3112                     /* some EPPING packets cannot be dropped no matter what access class it was
3113                      * sent on.  We can change the packet tag to guarantee it will not get dropped */
3114                 if (IS_EPING_PACKET_NO_DROP(eppingHdr)) {
3115                     htc_tag = AR6K_CONTROL_PKT_TAG;
3116                 }
3117
3118                 if (ac == HCI_TRANSPORT_STREAM_NUM) {
3119                         /* pass this to HCI */
3120 #ifndef EXPORT_HCI_BRIDGE_INTERFACE
3121                     if (A_SUCCESS(hci_test_send(ar,skb))) {
3122                         return 0;
3123                     }
3124 #endif
3125                         /* set AC to discard this skb */
3126                     ac = AC_NOT_MAPPED;
3127                 } else {
3128                     /* a quirk of linux, the payload of the frame is 32-bit aligned and thus the addition
3129                      * of the HTC header will mis-align the start of the HTC frame, so we add some
3130                      * padding which will be stripped off in the target */
3131                     if (EPPING_ALIGNMENT_PAD > 0) {
3132                         A_NETBUF_PUSH(skb, EPPING_ALIGNMENT_PAD);
3133                     }
3134                 }
3135
3136             } else {
3137                     /* not a ping packet, drop it */
3138                 ac = AC_NOT_MAPPED;
3139             }
3140         }
3141
3142     } while (FALSE);
3143
3144         /* did we succeed ? */
3145     if ((ac == AC_NOT_MAPPED) && !checkAdHocPsMapping) {
3146             /* cleanup and exit */
3147         A_NETBUF_FREE(skb);
3148         AR6000_STAT_INC(ar, tx_dropped);
3149         AR6000_STAT_INC(ar, tx_aborted_errors);
3150         return 0;
3151     }
3152
3153     cookie = NULL;
3154
3155         /* take the lock to protect driver data */
3156     AR6000_SPIN_LOCK(&ar->arLock, 0);
3157
3158     do {
3159
3160         if (checkAdHocPsMapping) {
3161             eid = ar6000_ibss_map_epid(skb, dev, &mapNo);
3162         }else {
3163             eid = arAc2EndpointID (ar, ac);
3164         }
3165             /* validate that the endpoint is connected */
3166         if (eid == 0 || eid == ENDPOINT_UNUSED ) {
3167             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" eid %d is NOT mapped!\n", eid));
3168             break;
3169         }
3170             /* allocate resource for this packet */
3171         cookie = ar6000_alloc_cookie(ar);
3172
3173         if (cookie != NULL) {
3174                 /* update counts while the lock is held */
3175             ar->arTxPending[eid]++;
3176             ar->arTotalTxDataPending++;
3177         }
3178
3179     } while (FALSE);
3180
3181     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3182
3183     if (cookie != NULL) {
3184         cookie->arc_bp[0] = (unsigned long)skb;
3185         cookie->arc_bp[1] = mapNo;
3186         SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
3187                                cookie,
3188                                A_NETBUF_DATA(skb),
3189                                A_NETBUF_LEN(skb),
3190                                eid,
3191                                htc_tag);
3192
3193 #ifdef DEBUG
3194         if (debugdriver >= 3) {
3195             ar6000_dump_skb(skb);
3196         }
3197 #endif
3198 #ifdef HTC_TEST_SEND_PKTS
3199         DoHTCSendPktsTest(ar,mapNo,eid,skb);
3200 #endif
3201             /* HTC interface is asynchronous, if this fails, cleanup will happen in
3202              * the ar6000_tx_complete callback */
3203         HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt);
3204     } else {
3205             /* no packet to send, cleanup */
3206         A_NETBUF_FREE(skb);
3207         AR6000_STAT_INC(ar, tx_dropped);
3208         AR6000_STAT_INC(ar, tx_aborted_errors);
3209     }
3210
3211     return 0;
3212 }
3213
3214 int
3215 ar6000_acl_data_tx(struct sk_buff *skb, struct net_device *dev)
3216 {
3217     AR_SOFTC_T        *ar = (AR_SOFTC_T *)ar6k_priv(dev);
3218     struct ar_cookie *cookie;
3219     HTC_ENDPOINT_ID    eid = ENDPOINT_UNUSED;
3220
3221     cookie = NULL;
3222     AR6000_SPIN_LOCK(&ar->arLock, 0);
3223
3224         /* For now we send ACL on BE endpoint: We can also have a dedicated EP */
3225         eid = arAc2EndpointID (ar, 0);
3226         /* allocate resource for this packet */
3227         cookie = ar6000_alloc_cookie(ar);
3228
3229         if (cookie != NULL) {
3230             /* update counts while the lock is held */
3231             ar->arTxPending[eid]++;
3232             ar->arTotalTxDataPending++;
3233         }
3234
3235
3236     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3237
3238         if (cookie != NULL) {
3239             cookie->arc_bp[0] = (unsigned long)skb;
3240             cookie->arc_bp[1] = 0;
3241             SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
3242                             cookie,
3243                             A_NETBUF_DATA(skb),
3244                             A_NETBUF_LEN(skb),
3245                             eid,
3246                             AR6K_DATA_PKT_TAG);
3247
3248             /* HTC interface is asynchronous, if this fails, cleanup will happen in
3249              * the ar6000_tx_complete callback */
3250             HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt);
3251         } else {
3252             /* no packet to send, cleanup */
3253             A_NETBUF_FREE(skb);
3254             AR6000_STAT_INC(ar, tx_dropped);
3255             AR6000_STAT_INC(ar, tx_aborted_errors);
3256         }
3257     return 0;
3258 }
3259
3260
3261 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
3262 static void
3263 tvsub(register struct timeval *out, register struct timeval *in)
3264 {
3265     if((out->tv_usec -= in->tv_usec) < 0) {
3266         out->tv_sec--;
3267         out->tv_usec += 1000000;
3268     }
3269     out->tv_sec -= in->tv_sec;
3270 }
3271
3272 void
3273 applyAPTCHeuristics(AR_SOFTC_T *ar)
3274 {
3275     A_UINT32 duration;
3276     A_UINT32 numbytes;
3277     A_UINT32 throughput;
3278     struct timeval ts;
3279     A_STATUS status;
3280
3281     AR6000_SPIN_LOCK(&ar->arLock, 0);
3282
3283     if ((enableAPTCHeuristics) && (!aptcTR.timerScheduled)) {
3284         do_gettimeofday(&ts);
3285         tvsub(&ts, &aptcTR.samplingTS);
3286         duration = ts.tv_sec * 1000 + ts.tv_usec / 1000; /* ms */
3287         numbytes = aptcTR.bytesTransmitted + aptcTR.bytesReceived;
3288
3289         if (duration > APTC_TRAFFIC_SAMPLING_INTERVAL) {
3290             /* Initialize the time stamp and byte count */
3291             aptcTR.bytesTransmitted = aptcTR.bytesReceived = 0;
3292             do_gettimeofday(&aptcTR.samplingTS);
3293
3294             /* Calculate and decide based on throughput thresholds */
3295             throughput = ((numbytes * 8) / duration);
3296             if (throughput > APTC_UPPER_THROUGHPUT_THRESHOLD) {
3297                 /* Disable Sleep and schedule a timer */
3298                 A_ASSERT(ar->arWmiReady == TRUE);
3299                 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3300                 status = wmi_powermode_cmd(ar->arWmi, MAX_PERF_POWER);
3301                 AR6000_SPIN_LOCK(&ar->arLock, 0);
3302                 A_TIMEOUT_MS(&aptcTimer, APTC_TRAFFIC_SAMPLING_INTERVAL, 0);
3303                 aptcTR.timerScheduled = TRUE;
3304             }
3305         }
3306     }
3307
3308     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3309 }
3310 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
3311
3312 static HTC_SEND_FULL_ACTION ar6000_tx_queue_full(void *Context, HTC_PACKET *pPacket)
3313 {
3314     AR_SOFTC_T     *ar = (AR_SOFTC_T *)Context;
3315     HTC_SEND_FULL_ACTION    action = HTC_SEND_FULL_KEEP;
3316     A_BOOL                  stopNet = FALSE;
3317     HTC_ENDPOINT_ID         Endpoint = HTC_GET_ENDPOINT_FROM_PKT(pPacket);
3318
3319     do {
3320
3321         if (bypasswmi) {
3322             int accessClass;
3323
3324             if (HTC_GET_TAG_FROM_PKT(pPacket) == AR6K_CONTROL_PKT_TAG) {
3325                     /* don't drop special control packets */
3326                 break;
3327             }
3328
3329             accessClass = arEndpoint2Ac(ar,Endpoint);
3330                 /* for endpoint ping testing drop Best Effort and Background */
3331             if ((accessClass == WMM_AC_BE) || (accessClass == WMM_AC_BK)) {
3332                 action = HTC_SEND_FULL_DROP;
3333                 stopNet = FALSE;
3334             } else {
3335                     /* keep but stop the netqueues */
3336                 stopNet = TRUE;
3337             }
3338             break;
3339         }
3340
3341         if (Endpoint == ar->arControlEp) {
3342                 /* under normal WMI if this is getting full, then something is running rampant
3343                  * the host should not be exhausting the WMI queue with too many commands
3344                  * the only exception to this is during testing using endpointping */
3345             AR6000_SPIN_LOCK(&ar->arLock, 0);
3346                 /* set flag to handle subsequent messages */
3347             ar->arWMIControlEpFull = TRUE;
3348             AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3349             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI Control Endpoint is FULL!!! \n"));
3350                 /* no need to stop the network */
3351             stopNet = FALSE;
3352             break;
3353         }
3354
3355         /* if we get here, we are dealing with data endpoints getting full */
3356
3357         if (HTC_GET_TAG_FROM_PKT(pPacket) == AR6K_CONTROL_PKT_TAG) {
3358             /* don't drop control packets issued on ANY data endpoint */
3359             break;
3360         }
3361
3362         if (ar->arNetworkType == ADHOC_NETWORK) {
3363             /* in adhoc mode, we cannot differentiate traffic priorities so there is no need to
3364              * continue, however we should stop the network */
3365             stopNet = TRUE;
3366             break;
3367         }
3368         /* the last MAX_HI_COOKIE_NUM "batch" of cookies are reserved for the highest
3369          * active stream */
3370         if (ar->arAcStreamPriMap[arEndpoint2Ac(ar,Endpoint)] < ar->arHiAcStreamActivePri &&
3371             ar->arCookieCount <= MAX_HI_COOKIE_NUM) {
3372                 /* this stream's priority is less than the highest active priority, we
3373                  * give preference to the highest priority stream by directing
3374                  * HTC to drop the packet that overflowed */
3375             action = HTC_SEND_FULL_DROP;
3376                 /* since we are dropping packets, no need to stop the network */
3377             stopNet = FALSE;
3378             break;
3379         }
3380
3381     } while (FALSE);
3382
3383     if (stopNet) {
3384         AR6000_SPIN_LOCK(&ar->arLock, 0);
3385         ar->arNetQueueStopped = TRUE;
3386         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3387         /* one of the data endpoints queues is getting full..need to stop network stack
3388          * the queue will resume in ar6000_tx_complete() */
3389         netif_stop_queue(ar->arNetDev);
3390     }
3391
3392     return action;
3393 }
3394
3395
3396 static void
3397 ar6000_tx_complete(void *Context, HTC_PACKET_QUEUE *pPacketQueue)
3398 {
3399     AR_SOFTC_T     *ar = (AR_SOFTC_T *)Context;
3400     A_UINT32        mapNo = 0;
3401     A_STATUS        status;
3402     struct ar_cookie * ar_cookie;
3403     HTC_ENDPOINT_ID   eid;
3404     A_BOOL          wakeEvent = FALSE;
3405     struct sk_buff_head  skb_queue;
3406     HTC_PACKET      *pPacket;
3407     struct sk_buff  *pktSkb;
3408     A_BOOL          flushing = FALSE;
3409
3410     skb_queue_head_init(&skb_queue);
3411
3412         /* lock the driver as we update internal state */
3413     AR6000_SPIN_LOCK(&ar->arLock, 0);
3414
3415         /* reap completed packets */
3416     while (!HTC_QUEUE_EMPTY(pPacketQueue)) {
3417
3418         pPacket = HTC_PACKET_DEQUEUE(pPacketQueue);
3419
3420         ar_cookie = (struct ar_cookie *)pPacket->pPktContext;
3421         A_ASSERT(ar_cookie);
3422
3423         status = pPacket->Status;
3424         pktSkb = (struct sk_buff *)ar_cookie->arc_bp[0];
3425         eid = pPacket->Endpoint;
3426         mapNo = ar_cookie->arc_bp[1];
3427
3428         A_ASSERT(pktSkb);
3429         A_ASSERT(pPacket->pBuffer == A_NETBUF_DATA(pktSkb));
3430
3431             /* add this to the list, use faster non-lock API */
3432         __skb_queue_tail(&skb_queue,pktSkb);
3433
3434         if (A_SUCCESS(status)) {
3435             A_ASSERT(pPacket->ActualLength == A_NETBUF_LEN(pktSkb));
3436         }
3437
3438         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("ar6000_tx_complete skb=0x%lx data=0x%lx len=0x%x eid=%d ",
3439                          (unsigned long)pktSkb, (unsigned long)pPacket->pBuffer,
3440                          pPacket->ActualLength,
3441                          eid));
3442
3443         ar->arTxPending[eid]--;
3444
3445         if ((eid  != ar->arControlEp) || bypasswmi) {
3446             ar->arTotalTxDataPending--;
3447         }
3448
3449         if (eid == ar->arControlEp)
3450         {
3451             if (ar->arWMIControlEpFull) {
3452                     /* since this packet completed, the WMI EP is no longer full */
3453                 ar->arWMIControlEpFull = FALSE;
3454             }
3455
3456             if (ar->arTxPending[eid] == 0) {
3457                 wakeEvent = TRUE;
3458             }
3459         }
3460
3461         if (A_FAILED(status)) {
3462             if (status == A_ECANCELED) {
3463                     /* a packet was flushed  */
3464                 flushing = TRUE;
3465             }
3466             AR6000_STAT_INC(ar, tx_errors);
3467             if (status != A_NO_RESOURCE) {
3468                 AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s() -TX ERROR, status: 0x%x\n", __func__,
3469                             status));
3470             }
3471         } else {
3472             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("OK\n"));
3473             flushing = FALSE;
3474             AR6000_STAT_INC(ar, tx_packets);
3475             ar->arNetStats.tx_bytes += A_NETBUF_LEN(pktSkb);
3476 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
3477             aptcTR.bytesTransmitted += a_netbuf_to_len(pktSkb);
3478             applyAPTCHeuristics(ar);
3479 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
3480         }
3481
3482         // TODO this needs to be looked at
3483         if ((ar->arNetworkType == ADHOC_NETWORK) && ar->arIbssPsEnable
3484             && (eid != ar->arControlEp) && mapNo)
3485         {
3486             mapNo --;
3487             ar->arNodeMap[mapNo].txPending --;
3488
3489             if (!ar->arNodeMap[mapNo].txPending && (mapNo == (ar->arNodeNum - 1))) {
3490                 A_UINT32 i;
3491                 for (i = ar->arNodeNum; i > 0; i --) {
3492                     if (!ar->arNodeMap[i - 1].txPending) {
3493                         A_MEMZERO(&ar->arNodeMap[i - 1], sizeof(struct ar_node_mapping));
3494                         ar->arNodeNum --;
3495                     } else {
3496                         break;
3497                     }
3498                 }
3499             }
3500         }
3501
3502         ar6000_free_cookie(ar, ar_cookie);
3503
3504         if (ar->arNetQueueStopped) {
3505             ar->arNetQueueStopped = FALSE;
3506         }
3507     }
3508
3509     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3510
3511     /* lock is released, we can freely call other kernel APIs */
3512
3513         /* free all skbs in our local list */
3514     while (!skb_queue_empty(&skb_queue)) {
3515             /* use non-lock version */
3516         pktSkb = __skb_dequeue(&skb_queue);
3517         A_NETBUF_FREE(pktSkb);
3518     }
3519
3520     if ((ar->arConnected == TRUE) || (bypasswmi)) {
3521         if (!flushing) {
3522                 /* don't wake the queue if we are flushing, other wise it will just
3523                  * keep queueing packets, which will keep failing */
3524             netif_wake_queue(ar->arNetDev);
3525         }
3526     }
3527
3528     if (wakeEvent) {
3529         wake_up(&arEvent);
3530     }
3531
3532 }
3533
3534 sta_t *
3535 ieee80211_find_conn(AR_SOFTC_T *ar, A_UINT8 *node_addr)
3536 {
3537     sta_t *conn = NULL;
3538     A_UINT8 i, max_conn;
3539
3540     switch(ar->arNetworkType) {
3541         case AP_NETWORK:
3542             max_conn = AP_MAX_NUM_STA;
3543             break;
3544         default:
3545             max_conn=0;
3546             break;
3547     }
3548
3549     for (i = 0; i < max_conn; i++) {
3550         if (IEEE80211_ADDR_EQ(node_addr, ar->sta_list[i].mac)) {
3551             conn = &ar->sta_list[i];
3552             break;
3553         }
3554     }
3555
3556     return conn;
3557 }
3558
3559 sta_t *ieee80211_find_conn_for_aid(AR_SOFTC_T *ar, A_UINT8 aid)
3560 {
3561     sta_t *conn = NULL;
3562     A_UINT8 ctr;
3563
3564     for (ctr = 0; ctr < AP_MAX_NUM_STA; ctr++) {
3565         if (ar->sta_list[ctr].aid == aid) {
3566             conn = &ar->sta_list[ctr];
3567             break;
3568         }
3569     }
3570     return conn;
3571 }
3572
3573 /*
3574  * Receive event handler.  This is called by HTC when a packet is received
3575  */
3576 int pktcount;
3577 static void
3578 ar6000_rx(void *Context, HTC_PACKET *pPacket)
3579 {
3580     AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
3581     struct sk_buff *skb = (struct sk_buff *)pPacket->pPktContext;
3582     int minHdrLen;
3583     A_UINT8 containsDot11Hdr = 0;
3584     A_STATUS        status = pPacket->Status;
3585     HTC_ENDPOINT_ID   ept = pPacket->Endpoint;
3586
3587     A_ASSERT((status != A_OK) ||
3588              (pPacket->pBuffer == (A_NETBUF_DATA(skb) + HTC_HEADER_LEN)));
3589
3590     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_RX,("ar6000_rx ar=0x%lx eid=%d, skb=0x%lx, data=0x%lx, len=0x%x status:%d",
3591                     (unsigned long)ar, ept, (unsigned long)skb, (unsigned long)pPacket->pBuffer,
3592                     pPacket->ActualLength, status));
3593     if (status != A_OK) {
3594         if (status != A_ECANCELED) {
3595             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("RX ERR (%d) \n",status));
3596         }
3597     }
3598
3599         /* take lock to protect buffer counts
3600          * and adaptive power throughput state */
3601     AR6000_SPIN_LOCK(&ar->arLock, 0);
3602
3603     if (A_SUCCESS(status)) {
3604         AR6000_STAT_INC(ar, rx_packets);
3605         ar->arNetStats.rx_bytes += pPacket->ActualLength;
3606 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
3607         aptcTR.bytesReceived += a_netbuf_to_len(skb);
3608         applyAPTCHeuristics(ar);
3609 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
3610
3611         A_NETBUF_PUT(skb, pPacket->ActualLength +  HTC_HEADER_LEN);
3612         A_NETBUF_PULL(skb, HTC_HEADER_LEN);
3613
3614 #ifdef DEBUG
3615         if (debugdriver >= 2) {
3616             ar6000_dump_skb(skb);
3617         }
3618 #endif /* DEBUG */
3619     }
3620
3621     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3622
3623     skb->dev = ar->arNetDev;
3624     if (status != A_OK) {
3625         AR6000_STAT_INC(ar, rx_errors);
3626         A_NETBUF_FREE(skb);
3627     } else if (ar->arWmiEnabled == TRUE) {
3628         if (ept == ar->arControlEp) {
3629            /*
3630             * this is a wmi control msg
3631             */
3632 #ifdef CONFIG_PM
3633             ar6000_check_wow_status(ar, skb, TRUE);
3634 #endif /* CONFIG_PM */
3635             wmi_control_rx(ar->arWmi, skb);
3636         } else {
3637                 WMI_DATA_HDR *dhdr = (WMI_DATA_HDR *)A_NETBUF_DATA(skb);
3638                 A_UINT8 is_amsdu, tid, is_acl_data_frame;
3639                 is_acl_data_frame = WMI_DATA_HDR_GET_DATA_TYPE(dhdr) == WMI_DATA_HDR_DATA_TYPE_ACL;
3640 #ifdef CONFIG_PM
3641                 ar6000_check_wow_status(ar, NULL, FALSE);
3642 #endif /* CONFIG_PM */
3643                 /*
3644                  * this is a wmi data packet
3645                  */
3646                  // NWF
3647
3648                 if (processDot11Hdr) {
3649                     minHdrLen = sizeof(WMI_DATA_HDR) + sizeof(struct ieee80211_frame) + sizeof(ATH_LLC_SNAP_HDR);
3650                 } else {
3651                     minHdrLen = sizeof (WMI_DATA_HDR) + sizeof(ATH_MAC_HDR) +
3652                           sizeof(ATH_LLC_SNAP_HDR);
3653                 }
3654
3655                 /* In the case of AP mode we may receive NULL data frames
3656                  * that do not have LLC hdr. They are 16 bytes in size.
3657                  * Allow these frames in the AP mode.
3658                  * ACL data frames don't follow ethernet frame bounds for
3659                  * min length
3660                  */
3661                 if (ar->arNetworkType != AP_NETWORK &&  !is_acl_data_frame &&
3662                     ((pPacket->ActualLength < minHdrLen) ||
3663                     (pPacket->ActualLength > AR6000_MAX_RX_MESSAGE_SIZE)))
3664                 {
3665                     /*
3666                      * packet is too short or too long
3667                      */
3668                     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("TOO SHORT or TOO LONG\n"));
3669                     AR6000_STAT_INC(ar, rx_errors);
3670                     AR6000_STAT_INC(ar, rx_length_errors);
3671                     A_NETBUF_FREE(skb);
3672                 } else {
3673                     A_UINT16 seq_no;
3674                     A_UINT8 meta_type;
3675
3676 #if 0
3677                     /* Access RSSI values here */
3678                     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("RSSI %d\n",
3679                         ((WMI_DATA_HDR *) A_NETBUF_DATA(skb))->rssi));
3680 #endif
3681                     /* Get the Power save state of the STA */
3682                     if (ar->arNetworkType == AP_NETWORK) {
3683                         sta_t *conn = NULL;
3684                         A_UINT8 psState=0,prevPsState;
3685                         ATH_MAC_HDR *datap=NULL;
3686                         A_UINT16 offset;
3687
3688                         meta_type = WMI_DATA_HDR_GET_META(dhdr);
3689
3690                         psState = (((WMI_DATA_HDR *)A_NETBUF_DATA(skb))->info
3691                                      >> WMI_DATA_HDR_PS_SHIFT) & WMI_DATA_HDR_PS_MASK;
3692
3693                         offset = sizeof(WMI_DATA_HDR);
3694
3695                         switch (meta_type) {
3696                             case 0:
3697                                 break;
3698                             case WMI_META_VERSION_1:
3699                                 offset += sizeof(WMI_RX_META_V1);
3700                                 break;
3701 #ifdef CONFIG_CHECKSUM_OFFLOAD
3702                             case WMI_META_VERSION_2:
3703                                 offset += sizeof(WMI_RX_META_V2);
3704                                 break;
3705 #endif
3706                             default:
3707                                 break;
3708                         }
3709
3710                         datap = (ATH_MAC_HDR *)(A_NETBUF_DATA(skb)+offset);
3711                         conn = ieee80211_find_conn(ar, datap->srcMac);
3712
3713                         if (conn) {
3714                             /* if there is a change in PS state of the STA,
3715                              * take appropriate steps.
3716                              * 1. If Sleep-->Awake, flush the psq for the STA
3717                              *    Clear the PVB for the STA.
3718                              * 2. If Awake-->Sleep, Starting queueing frames
3719                              * the STA.
3720                              */
3721                             prevPsState = STA_IS_PWR_SLEEP(conn);
3722                             if (psState) {
3723                                 STA_SET_PWR_SLEEP(conn);
3724                             } else {
3725                                 STA_CLR_PWR_SLEEP(conn);
3726                             }
3727
3728                             if (prevPsState ^ STA_IS_PWR_SLEEP(conn)) {
3729
3730                                 if (!STA_IS_PWR_SLEEP(conn)) {
3731
3732                                     A_MUTEX_LOCK(&conn->psqLock);
3733                                     while (!A_NETBUF_QUEUE_EMPTY(&conn->psq)) {
3734                                         struct sk_buff *skb=NULL;
3735
3736                                         skb = A_NETBUF_DEQUEUE(&conn->psq);
3737                                         A_MUTEX_UNLOCK(&conn->psqLock);
3738                                         ar6000_data_tx(skb,ar->arNetDev);
3739                                         A_MUTEX_LOCK(&conn->psqLock);
3740                                     }
3741                                     A_MUTEX_UNLOCK(&conn->psqLock);
3742                                     /* Clear the PVB for this STA */
3743                                     wmi_set_pvb_cmd(ar->arWmi, conn->aid, 0);
3744                                 }
3745                             }
3746                         } else {
3747                             /* This frame is from a STA that is not associated*/
3748                             A_ASSERT(FALSE);
3749                         }
3750
3751                         /* Drop NULL data frames here */
3752                         if((pPacket->ActualLength < minHdrLen) ||
3753                                 (pPacket->ActualLength > AR6000_MAX_RX_MESSAGE_SIZE)) {
3754                             A_NETBUF_FREE(skb);
3755                             goto rx_done;
3756                         }
3757                     }
3758
3759                     is_amsdu = WMI_DATA_HDR_IS_AMSDU(dhdr);
3760                     tid = WMI_DATA_HDR_GET_UP(dhdr);
3761                     seq_no = WMI_DATA_HDR_GET_SEQNO(dhdr);
3762                     meta_type = WMI_DATA_HDR_GET_META(dhdr);
3763                     containsDot11Hdr = WMI_DATA_HDR_GET_DOT11(dhdr);
3764
3765                     wmi_data_hdr_remove(ar->arWmi, skb);
3766
3767                     switch (meta_type) {
3768                         case WMI_META_VERSION_1:
3769                             {
3770                                 WMI_RX_META_V1 *pMeta = (WMI_RX_META_V1 *)A_NETBUF_DATA(skb);
3771                                 A_PRINTF("META %d %d %d %d %x\n", pMeta->status, pMeta->rix, pMeta->rssi, pMeta->channel, pMeta->flags);
3772                                 A_NETBUF_PULL((void*)skb, sizeof(WMI_RX_META_V1));
3773                                 break;
3774                             }
3775 #ifdef CONFIG_CHECKSUM_OFFLOAD
3776                         case WMI_META_VERSION_2:
3777                             {
3778                                 WMI_RX_META_V2 *pMeta = (WMI_RX_META_V2 *)A_NETBUF_DATA(skb);
3779                                 if(pMeta->csumFlags & 0x1){
3780                                     skb->ip_summed=CHECKSUM_COMPLETE;
3781                                     skb->csum=(pMeta->csum);
3782                                 }
3783                                 A_NETBUF_PULL((void*)skb, sizeof(WMI_RX_META_V2));
3784                                 break;
3785                             }
3786 #endif
3787                         default:
3788                             break;
3789                     }
3790
3791                     A_ASSERT(status == A_OK);
3792
3793                     /* NWF: print the 802.11 hdr bytes */
3794                     if(containsDot11Hdr) {
3795                         status = wmi_dot11_hdr_remove(ar->arWmi,skb);
3796                     } else if(!is_amsdu && !is_acl_data_frame) {
3797                         status = wmi_dot3_2_dix(skb);
3798                     }
3799
3800                     if (status != A_OK) {
3801                         /* Drop frames that could not be processed (lack of memory, etc.) */
3802                         A_NETBUF_FREE(skb);
3803                         goto rx_done;
3804                     }
3805
3806                     if (is_acl_data_frame) {
3807                         A_NETBUF_PUSH(skb, sizeof(int));
3808                         *((short *)A_NETBUF_DATA(skb)) = WMI_ACL_DATA_EVENTID;
3809                         /* send the data packet to PAL driver */
3810                         if(ar6k_pal_config_g.fpar6k_pal_recv_pkt) {
3811                                 if((*ar6k_pal_config_g.fpar6k_pal_recv_pkt)(ar->hcipal_info, skb) == TRUE)
3812                                         goto rx_done;
3813                         }
3814                     }
3815
3816                     if ((ar->arNetDev->flags & IFF_UP) == IFF_UP) {
3817                         if (ar->arNetworkType == AP_NETWORK) {
3818                             struct sk_buff *skb1 = NULL;
3819                             ATH_MAC_HDR *datap;
3820
3821                             datap = (ATH_MAC_HDR *)A_NETBUF_DATA(skb);
3822                             if (IEEE80211_IS_MULTICAST(datap->dstMac)) {
3823                                 /* Bcast/Mcast frames should be sent to the OS
3824                                  * stack as well as on the air.
3825                                  */
3826                                 skb1 = skb_copy(skb,GFP_ATOMIC);
3827                             } else {
3828                                 /* Search for a connected STA with dstMac as
3829                                  * the Mac address. If found send the frame to
3830                                  * it on the air else send the frame up the
3831                                  * stack
3832                                  */
3833                                 sta_t *conn = NULL;
3834                                 conn = ieee80211_find_conn(ar, datap->dstMac);
3835
3836                                 if (conn && ar->intra_bss) {
3837                                     skb1 = skb;
3838                                     skb = NULL;
3839                                 } else if(conn && !ar->intra_bss) {
3840                                     A_NETBUF_FREE(skb);
3841                                     skb = NULL;
3842                                 }
3843                             }
3844                             if (skb1) {
3845                                 ar6000_data_tx(skb1, ar->arNetDev);
3846                             }
3847                         }
3848                     }
3849 #ifdef ATH_AR6K_11N_SUPPORT
3850                     aggr_process_recv_frm(ar->aggr_cntxt, tid, seq_no, is_amsdu, (void **)&skb);
3851 #endif
3852                     ar6000_deliver_frames_to_nw_stack((void *) ar->arNetDev, (void *)skb);
3853                 }
3854             }
3855     } else {
3856         if (EPPING_ALIGNMENT_PAD > 0) {
3857             A_NETBUF_PULL(skb, EPPING_ALIGNMENT_PAD);
3858         }
3859         ar6000_deliver_frames_to_nw_stack((void *)ar->arNetDev, (void *)skb);
3860     }
3861
3862 rx_done:
3863
3864     return;
3865 }
3866
3867 static void
3868 ar6000_deliver_frames_to_nw_stack(void *dev, void *osbuf)
3869 {
3870     struct sk_buff *skb = (struct sk_buff *)osbuf;
3871
3872     if(skb) {
3873         skb->dev = dev;
3874         if ((skb->dev->flags & IFF_UP) == IFF_UP) {
3875 #ifdef CONFIG_PM
3876             ar6000_check_wow_status((AR_SOFTC_T *)ar6k_priv(dev), skb, FALSE);
3877 #endif /* CONFIG_PM */
3878             skb->protocol = eth_type_trans(skb, skb->dev);
3879         /*
3880          * If this routine is called on a ISR (Hard IRQ) or DSR (Soft IRQ)
3881          * or tasklet use the netif_rx to deliver the packet to the stack
3882          * netif_rx will queue the packet onto the receive queue and mark
3883          * the softirq thread has a pending action to complete. Kernel will
3884          * schedule the softIrq kernel thread after processing the DSR.
3885          *
3886          * If this routine is called on a process context, use netif_rx_ni
3887          * which will schedle the softIrq kernel thread after queuing the packet.
3888          */
3889             if (in_interrupt()) {
3890                 netif_rx(skb);
3891             } else {
3892                 netif_rx_ni(skb);
3893             }
3894         } else {
3895             A_NETBUF_FREE(skb);
3896         }
3897     }
3898 }
3899
3900 #if 0
3901 static void
3902 ar6000_deliver_frames_to_bt_stack(void *dev, void *osbuf)
3903 {
3904     struct sk_buff *skb = (struct sk_buff *)osbuf;
3905
3906     if(skb) {
3907         skb->dev = dev;
3908         if ((skb->dev->flags & IFF_UP) == IFF_UP) {
3909             skb->protocol = htons(ETH_P_CONTROL);
3910             netif_rx(skb);
3911         } else {
3912             A_NETBUF_FREE(skb);
3913         }
3914     }
3915 }
3916 #endif
3917
3918 static void
3919 ar6000_rx_refill(void *Context, HTC_ENDPOINT_ID Endpoint)
3920 {
3921     AR_SOFTC_T  *ar = (AR_SOFTC_T *)Context;
3922     void        *osBuf;
3923     int         RxBuffers;
3924     int         buffersToRefill;
3925     HTC_PACKET  *pPacket;
3926     HTC_PACKET_QUEUE queue;
3927
3928     buffersToRefill = (int)AR6000_MAX_RX_BUFFERS -
3929                                     HTCGetNumRecvBuffers(ar->arHtcTarget, Endpoint);
3930
3931     if (buffersToRefill <= 0) {
3932             /* fast return, nothing to fill */
3933         return;
3934     }
3935
3936     INIT_HTC_PACKET_QUEUE(&queue);
3937
3938     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_RX,("ar6000_rx_refill: providing htc with %d buffers at eid=%d\n",
3939                     buffersToRefill, Endpoint));
3940
3941     for (RxBuffers = 0; RxBuffers < buffersToRefill; RxBuffers++) {
3942         osBuf = A_NETBUF_ALLOC(AR6000_BUFFER_SIZE);
3943         if (NULL == osBuf) {
3944             break;
3945         }
3946             /* the HTC packet wrapper is at the head of the reserved area
3947              * in the skb */
3948         pPacket = (HTC_PACKET *)(A_NETBUF_HEAD(osBuf));
3949             /* set re-fill info */
3950         SET_HTC_PACKET_INFO_RX_REFILL(pPacket,osBuf,A_NETBUF_DATA(osBuf),AR6000_BUFFER_SIZE,Endpoint);
3951             /* add to queue */
3952         HTC_PACKET_ENQUEUE(&queue,pPacket);
3953     }
3954
3955     if (!HTC_QUEUE_EMPTY(&queue)) {
3956             /* add packets */
3957         HTCAddReceivePktMultiple(ar->arHtcTarget, &queue);
3958     }
3959
3960 }
3961
3962   /* clean up our amsdu buffer list */
3963 static void ar6000_cleanup_amsdu_rxbufs(AR_SOFTC_T *ar)
3964 {
3965     HTC_PACKET  *pPacket;
3966     void        *osBuf;
3967
3968         /* empty AMSDU buffer queue and free OS bufs */
3969     while (TRUE) {
3970
3971         AR6000_SPIN_LOCK(&ar->arLock, 0);
3972         pPacket = HTC_PACKET_DEQUEUE(&ar->amsdu_rx_buffer_queue);
3973         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
3974
3975         if (NULL == pPacket) {
3976             break;
3977         }
3978
3979         osBuf = pPacket->pPktContext;
3980         if (NULL == osBuf) {
3981             A_ASSERT(FALSE);
3982             break;
3983         }
3984
3985         A_NETBUF_FREE(osBuf);
3986     }
3987
3988 }
3989
3990
3991     /* refill the amsdu buffer list */
3992 static void ar6000_refill_amsdu_rxbufs(AR_SOFTC_T *ar, int Count)
3993 {
3994     HTC_PACKET  *pPacket;
3995     void        *osBuf;
3996
3997     while (Count > 0) {
3998         osBuf = A_NETBUF_ALLOC(AR6000_AMSDU_BUFFER_SIZE);
3999         if (NULL == osBuf) {
4000             break;
4001         }
4002             /* the HTC packet wrapper is at the head of the reserved area
4003              * in the skb */
4004         pPacket = (HTC_PACKET *)(A_NETBUF_HEAD(osBuf));
4005             /* set re-fill info */
4006         SET_HTC_PACKET_INFO_RX_REFILL(pPacket,osBuf,A_NETBUF_DATA(osBuf),AR6000_AMSDU_BUFFER_SIZE,0);
4007
4008         AR6000_SPIN_LOCK(&ar->arLock, 0);
4009             /* put it in the list */
4010         HTC_PACKET_ENQUEUE(&ar->amsdu_rx_buffer_queue,pPacket);
4011         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
4012         Count--;
4013     }
4014
4015 }
4016
4017     /* callback to allocate a large receive buffer for a pending packet.  This function is called when
4018      * an HTC packet arrives whose length exceeds a threshold value
4019      *
4020      * We use a pre-allocated list of buffers of maximum AMSDU size (4K).  Under linux it is more optimal to
4021      * keep the allocation size the same to optimize cached-slab allocations.
4022      *
4023      * */
4024 static HTC_PACKET *ar6000_alloc_amsdu_rxbuf(void *Context, HTC_ENDPOINT_ID Endpoint, int Length)
4025 {
4026     HTC_PACKET  *pPacket = NULL;
4027     AR_SOFTC_T  *ar = (AR_SOFTC_T *)Context;
4028     int         refillCount = 0;
4029
4030     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_RX,("ar6000_alloc_amsdu_rxbuf: eid=%d, Length:%d\n",Endpoint,Length));
4031
4032     do {
4033
4034         if (Length <= AR6000_BUFFER_SIZE) {
4035                 /* shouldn't be getting called on normal sized packets */
4036             A_ASSERT(FALSE);
4037             break;
4038         }
4039
4040         if (Length > AR6000_AMSDU_BUFFER_SIZE) {
4041             A_ASSERT(FALSE);
4042             break;
4043         }
4044
4045         AR6000_SPIN_LOCK(&ar->arLock, 0);
4046             /* allocate a packet from the list */
4047         pPacket = HTC_PACKET_DEQUEUE(&ar->amsdu_rx_buffer_queue);
4048             /* see if we need to refill again */
4049         refillCount = AR6000_MAX_AMSDU_RX_BUFFERS - HTC_PACKET_QUEUE_DEPTH(&ar->amsdu_rx_buffer_queue);
4050         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
4051
4052         if (NULL == pPacket) {
4053             break;
4054         }
4055             /* set actual endpoint ID */
4056         pPacket->Endpoint = Endpoint;
4057
4058     } while (FALSE);
4059
4060     if (refillCount >= AR6000_AMSDU_REFILL_THRESHOLD) {
4061         ar6000_refill_amsdu_rxbufs(ar,refillCount);
4062     }
4063
4064     return pPacket;
4065 }
4066
4067 static void
4068 ar6000_set_multicast_list(struct net_device *dev)
4069 {
4070     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000: Multicast filter not supported\n"));
4071 }
4072
4073 static struct net_device_stats *
4074 ar6000_get_stats(struct net_device *dev)
4075 {
4076     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
4077     return &ar->arNetStats;
4078 }
4079
4080 static struct iw_statistics *
4081 ar6000_get_iwstats(struct net_device * dev)
4082 {
4083     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
4084     TARGET_STATS *pStats = &ar->arTargetStats;
4085     struct iw_statistics * pIwStats = &ar->arIwStats;
4086     int rtnllocked;
4087
4088     if (ar->bIsDestroyProgress || ar->arWmiReady == FALSE || ar->arWlanState == WLAN_DISABLED)
4089     {
4090         pIwStats->status = 0;
4091         pIwStats->qual.qual = 0;
4092         pIwStats->qual.level =0;
4093         pIwStats->qual.noise = 0;
4094         pIwStats->discard.code =0;
4095         pIwStats->discard.retries=0;
4096         pIwStats->miss.beacon =0;
4097         return pIwStats;
4098     }
4099
4100     /*
4101      * The in_atomic function is used to determine if the scheduling is
4102      * allowed in the current context or not. This was introduced in 2.6
4103      * From what I have read on the differences between 2.4 and 2.6, the
4104      * 2.4 kernel did not support preemption and so this check might not
4105      * be required for 2.4 kernels.
4106      */
4107     if (in_atomic())
4108     {
4109         wmi_get_stats_cmd(ar->arWmi);
4110
4111         pIwStats->status = 1 ;
4112         pIwStats->qual.qual = pStats->cs_aveBeacon_rssi - 161;
4113         pIwStats->qual.level =pStats->cs_aveBeacon_rssi; /* noise is -95 dBm */
4114         pIwStats->qual.noise = pStats->noise_floor_calibation;
4115         pIwStats->discard.code = pStats->rx_decrypt_err;
4116         pIwStats->discard.retries = pStats->tx_retry_cnt;
4117         pIwStats->miss.beacon = pStats->cs_bmiss_cnt;
4118         return pIwStats;
4119     }
4120
4121     dev_hold(dev);
4122     rtnllocked = rtnl_is_locked();
4123     if (rtnllocked) {
4124         rtnl_unlock();
4125     }
4126     pIwStats->status = 0;
4127
4128     if (down_interruptible(&ar->arSem)) {
4129         goto err_exit;
4130     }
4131
4132     do {
4133
4134         if (ar->bIsDestroyProgress || ar->arWlanState == WLAN_DISABLED) {
4135             break;
4136         }
4137
4138         ar->statsUpdatePending = TRUE;
4139
4140         if(wmi_get_stats_cmd(ar->arWmi) != A_OK) {
4141             break;
4142         }
4143
4144         wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
4145         if (signal_pending(current)) {
4146             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000 : WMI get stats timeout \n"));
4147             break;
4148         }
4149         pIwStats->status = 1 ;
4150         pIwStats->qual.qual = pStats->cs_aveBeacon_rssi - 161;
4151         pIwStats->qual.level =pStats->cs_aveBeacon_rssi;  /* noise is -95 dBm */
4152         pIwStats->qual.noise = pStats->noise_floor_calibation;
4153         pIwStats->discard.code = pStats->rx_decrypt_err;
4154         pIwStats->discard.retries = pStats->tx_retry_cnt;
4155         pIwStats->miss.beacon = pStats->cs_bmiss_cnt;
4156     } while (0);
4157     up(&ar->arSem);
4158
4159 err_exit:
4160     if (rtnllocked) {
4161         rtnl_lock();
4162     }
4163     dev_put(dev);
4164     return pIwStats;
4165 }
4166
4167 void
4168 ar6000_ready_event(void *devt, A_UINT8 *datap, A_UINT8 phyCap, A_UINT32 sw_ver, A_UINT32 abi_ver)
4169 {
4170     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
4171     struct net_device *dev = ar->arNetDev;
4172
4173     ar->arWmiReady = TRUE;
4174     wake_up(&arEvent);
4175     A_MEMCPY(dev->dev_addr, datap, AR6000_ETH_ADDR_LEN);
4176     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("mac address = %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
4177         dev->dev_addr[0], dev->dev_addr[1],
4178         dev->dev_addr[2], dev->dev_addr[3],
4179         dev->dev_addr[4], dev->dev_addr[5]));
4180
4181     ar->arPhyCapability = phyCap;
4182     ar->arVersion.wlan_ver = sw_ver;
4183     ar->arVersion.abi_ver = abi_ver;
4184
4185 #if WLAN_CONFIG_IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN
4186     wmi_pmparams_cmd(ar->arWmi, 0, 1, 0, 0, 1, IGNORE_POWER_SAVE_FAIL_EVENT_DURING_SCAN);
4187 #endif
4188 #if WLAN_CONFIG_DONOT_IGNORE_BARKER_IN_ERP
4189     wmi_set_lpreamble_cmd(ar->arWmi, 0, WMI_DONOT_IGNORE_BARKER_IN_ERP);
4190 #endif
4191     wmi_set_keepalive_cmd(ar->arWmi, WLAN_CONFIG_KEEP_ALIVE_INTERVAL);
4192 #if WLAN_CONFIG_DISABLE_11N
4193     {
4194         WMI_SET_HT_CAP_CMD htCap;
4195
4196         A_MEMZERO(&htCap, sizeof(WMI_SET_HT_CAP_CMD));
4197         htCap.band = 0;
4198         wmi_set_ht_cap_cmd(ar->arWmi, &htCap);
4199
4200         htCap.band = 1;
4201         wmi_set_ht_cap_cmd(ar->arWmi, &htCap);
4202     }
4203 #endif /* WLAN_CONFIG_DISABLE_11N */
4204
4205 #ifdef ATH6K_CONFIG_OTA_MODE
4206     wmi_powermode_cmd(ar->arWmi, MAX_PERF_POWER);
4207 #endif
4208     wmi_disctimeout_cmd(ar->arWmi, WLAN_CONFIG_DISCONNECT_TIMEOUT);
4209 }
4210
4211 void
4212 add_new_sta(AR_SOFTC_T *ar, A_UINT8 *mac, A_UINT16 aid, A_UINT8 *wpaie,
4213             A_UINT8 ielen, A_UINT8 keymgmt, A_UINT8 ucipher, A_UINT8 auth)
4214 {
4215     A_UINT8    free_slot=aid-1;
4216
4217         A_MEMCPY(ar->sta_list[free_slot].mac, mac, ATH_MAC_LEN);
4218         A_MEMCPY(ar->sta_list[free_slot].wpa_ie, wpaie, ielen);
4219         ar->sta_list[free_slot].aid = aid;
4220         ar->sta_list[free_slot].keymgmt = keymgmt;
4221         ar->sta_list[free_slot].ucipher = ucipher;
4222         ar->sta_list[free_slot].auth = auth;
4223         ar->sta_list_index = ar->sta_list_index | (1 << free_slot);
4224     ar->arAPStats.sta[free_slot].aid = aid;
4225 }
4226
4227 void
4228 ar6000_connect_event(AR_SOFTC_T *ar, A_UINT16 channel, A_UINT8 *bssid,
4229                      A_UINT16 listenInterval, A_UINT16 beaconInterval,
4230                      NETWORK_TYPE networkType, A_UINT8 beaconIeLen,
4231                      A_UINT8 assocReqLen, A_UINT8 assocRespLen,
4232                      A_UINT8 *assocInfo)
4233 {
4234     union iwreq_data wrqu;
4235     int i, beacon_ie_pos, assoc_resp_ie_pos, assoc_req_ie_pos;
4236     static const char *tag1 = "ASSOCINFO(ReqIEs=";
4237     static const char *tag2 = "ASSOCRESPIE=";
4238     static const char *beaconIetag = "BEACONIE=";
4239     char buf[WMI_CONTROL_MSG_MAX_LEN * 2 + strlen(tag1) + 1];
4240     char *pos;
4241     A_UINT8 key_op_ctrl;
4242     unsigned long flags;
4243     struct ieee80211req_key *ik;
4244     CRYPTO_TYPE keyType = NONE_CRYPT;
4245
4246     if(ar->arNetworkType & AP_NETWORK) {
4247         struct net_device *dev = ar->arNetDev;
4248         if(A_MEMCMP(dev->dev_addr, bssid, ATH_MAC_LEN)==0) {
4249             ar->arACS = channel;
4250             ik = &ar->ap_mode_bkey;
4251
4252             switch(ar->arAuthMode) {
4253             case NONE_AUTH:
4254                 if(ar->arPairwiseCrypto == WEP_CRYPT) {
4255                     ar6000_install_static_wep_keys(ar);
4256                 }
4257 #ifdef WAPI_ENABLE
4258                 else if(ar->arPairwiseCrypto == WAPI_CRYPT) {
4259                     ap_set_wapi_key(ar, ik);
4260                 }
4261 #endif
4262                 break;
4263             case WPA_PSK_AUTH:
4264             case WPA2_PSK_AUTH:
4265             case (WPA_PSK_AUTH|WPA2_PSK_AUTH):
4266                 switch (ik->ik_type) {
4267                     case IEEE80211_CIPHER_TKIP:
4268                         keyType = TKIP_CRYPT;
4269                         break;
4270                     case IEEE80211_CIPHER_AES_CCM:
4271                         keyType = AES_CRYPT;
4272                         break;
4273                     default:
4274                        goto skip_key;
4275                 }
4276                 wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, keyType, GROUP_USAGE,
4277                                 ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc,
4278                                 ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
4279                                 SYNC_BOTH_WMIFLAG);
4280
4281                 break;
4282             }
4283 skip_key:
4284             ar->arConnected  = TRUE;
4285             return;
4286         }
4287
4288         A_PRINTF("NEW STA %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x \n "
4289             " AID=%d \n", bssid[0], bssid[1], bssid[2],
4290              bssid[3], bssid[4], bssid[5], channel);
4291         switch ((listenInterval>>8)&0xFF) {
4292             case OPEN_AUTH:
4293                 A_PRINTF("AUTH: OPEN\n");
4294                 break;
4295             case SHARED_AUTH:
4296                 A_PRINTF("AUTH: SHARED\n");
4297                 break;
4298             default:
4299                 A_PRINTF("AUTH: Unknown\n");
4300                 break;
4301         };
4302         switch (listenInterval&0xFF) {
4303             case WPA_PSK_AUTH:
4304                 A_PRINTF("KeyMgmt: WPA-PSK\n");
4305                 break;
4306             case WPA2_PSK_AUTH:
4307                 A_PRINTF("KeyMgmt: WPA2-PSK\n");
4308                 break;
4309             default:
4310                 A_PRINTF("KeyMgmt: NONE\n");
4311                 break;
4312         };
4313         switch (beaconInterval) {
4314             case AES_CRYPT:
4315                 A_PRINTF("Cipher: AES\n");
4316                 break;
4317             case TKIP_CRYPT:
4318                 A_PRINTF("Cipher: TKIP\n");
4319                 break;
4320             case WEP_CRYPT:
4321                 A_PRINTF("Cipher: WEP\n");
4322                 break;
4323 #ifdef WAPI_ENABLE
4324             case WAPI_CRYPT:
4325                 A_PRINTF("Cipher: WAPI\n");
4326                 break;
4327 #endif
4328             default:
4329                 A_PRINTF("Cipher: NONE\n");
4330                 break;
4331         };
4332
4333         add_new_sta(ar, bssid, channel /*aid*/,
4334             assocInfo /* WPA IE */, assocRespLen /* IE len */,
4335             listenInterval&0xFF /* Keymgmt */, beaconInterval /* cipher */,
4336             (listenInterval>>8)&0xFF /* auth alg */);
4337
4338         /* Send event to application */
4339         A_MEMZERO(&wrqu, sizeof(wrqu));
4340         A_MEMCPY(wrqu.addr.sa_data, bssid, ATH_MAC_LEN);
4341         wireless_send_event(ar->arNetDev, IWEVREGISTERED, &wrqu, NULL);
4342         /* In case the queue is stopped when we switch modes, this will
4343          * wake it up
4344          */
4345         netif_wake_queue(ar->arNetDev);
4346         return;
4347     }
4348
4349 #ifdef ATH6K_CONFIG_CFG80211
4350     ar6k_cfg80211_connect_event(ar, channel, bssid,
4351                                 listenInterval, beaconInterval,
4352                                 networkType, beaconIeLen,
4353                                 assocReqLen, assocRespLen,
4354                                 assocInfo);
4355 #endif /* ATH6K_CONFIG_CFG80211 */
4356
4357     A_MEMCPY(ar->arBssid, bssid, sizeof(ar->arBssid));
4358     ar->arBssChannel = channel;
4359
4360     A_PRINTF("AR6000 connected event on freq %d ", channel);
4361     A_PRINTF("with bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
4362             " listenInterval=%d, beaconInterval = %d, beaconIeLen = %d assocReqLen=%d"
4363             " assocRespLen =%d\n",
4364              bssid[0], bssid[1], bssid[2],
4365              bssid[3], bssid[4], bssid[5],
4366              listenInterval, beaconInterval,
4367              beaconIeLen, assocReqLen, assocRespLen);
4368     if (networkType & ADHOC_NETWORK) {
4369         if (networkType & ADHOC_CREATOR) {
4370             A_PRINTF("Network: Adhoc (Creator)\n");
4371         } else {
4372             A_PRINTF("Network: Adhoc (Joiner)\n");
4373         }
4374     } else {
4375         A_PRINTF("Network: Infrastructure\n");
4376     }
4377
4378     if ((ar->arNetworkType == INFRA_NETWORK)) {
4379         wmi_listeninterval_cmd(ar->arWmi, ar->arListenIntervalT, ar->arListenIntervalB);
4380     }
4381
4382     if (beaconIeLen && (sizeof(buf) > (9 + beaconIeLen * 2))) {
4383         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nBeaconIEs= "));
4384
4385         beacon_ie_pos = 0;
4386         A_MEMZERO(buf, sizeof(buf));
4387         sprintf(buf, "%s", beaconIetag);
4388         pos = buf + 9;
4389         for (i = beacon_ie_pos; i < beacon_ie_pos + beaconIeLen; i++) {
4390             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i]));
4391             sprintf(pos, "%2.2x", assocInfo[i]);
4392             pos += 2;
4393         }
4394         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n"));
4395
4396         A_MEMZERO(&wrqu, sizeof(wrqu));
4397         wrqu.data.length = strlen(buf);
4398         wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
4399     }
4400
4401     if (assocRespLen && (sizeof(buf) > (12 + (assocRespLen * 2))))
4402     {
4403         assoc_resp_ie_pos = beaconIeLen + assocReqLen +
4404                             sizeof(A_UINT16)  +  /* capinfo*/
4405                             sizeof(A_UINT16)  +  /* status Code */
4406                             sizeof(A_UINT16)  ;  /* associd */
4407         A_MEMZERO(buf, sizeof(buf));
4408         sprintf(buf, "%s", tag2);
4409         pos = buf + 12;
4410         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nAssocRespIEs= "));
4411         /*
4412          * The Association Response Frame w.o. the WLAN header is delivered to
4413          * the host, so skip over to the IEs
4414          */
4415         for (i = assoc_resp_ie_pos; i < assoc_resp_ie_pos + assocRespLen - 6; i++)
4416         {
4417             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i]));
4418             sprintf(pos, "%2.2x", assocInfo[i]);
4419             pos += 2;
4420         }
4421         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n"));
4422
4423         A_MEMZERO(&wrqu, sizeof(wrqu));
4424         wrqu.data.length = strlen(buf);
4425         wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
4426     }
4427
4428     if (assocReqLen && (sizeof(buf) > (17 + (assocReqLen * 2)))) {
4429         /*
4430          * assoc Request includes capability and listen interval. Skip these.
4431          */
4432         assoc_req_ie_pos =  beaconIeLen +
4433                             sizeof(A_UINT16)  +  /* capinfo*/
4434                             sizeof(A_UINT16);    /* listen interval */
4435
4436         A_MEMZERO(buf, sizeof(buf));
4437         sprintf(buf, "%s", tag1);
4438         pos = buf + 17;
4439         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("AssocReqIEs= "));
4440         for (i = assoc_req_ie_pos; i < assoc_req_ie_pos + assocReqLen - 4; i++) {
4441             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i]));
4442             sprintf(pos, "%2.2x", assocInfo[i]);
4443             pos += 2;;
4444         }
4445         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n"));
4446
4447         A_MEMZERO(&wrqu, sizeof(wrqu));
4448         wrqu.data.length = strlen(buf);
4449         wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
4450     }
4451
4452 #ifdef USER_KEYS
4453     if (ar->user_savedkeys_stat == USER_SAVEDKEYS_STAT_RUN &&
4454         ar->user_saved_keys.keyOk == TRUE)
4455     {
4456         key_op_ctrl = KEY_OP_VALID_MASK & ~KEY_OP_INIT_TSC;
4457
4458         if (ar->user_key_ctrl & AR6000_USER_SETKEYS_RSC_UNCHANGED) {
4459             key_op_ctrl &= ~KEY_OP_INIT_RSC;
4460         } else {
4461             key_op_ctrl |= KEY_OP_INIT_RSC;
4462         }
4463         ar6000_reinstall_keys(ar, key_op_ctrl);
4464     }
4465 #endif /* USER_KEYS */
4466
4467     netif_wake_queue(ar->arNetDev);
4468
4469     /* For CFG80211 the key configuration and the default key comes in after connect so no point in plumbing invalid keys */
4470 #ifndef ATH6K_CONFIG_CFG80211
4471     if ((networkType & ADHOC_NETWORK)      &&
4472         (OPEN_AUTH == ar->arDot11AuthMode) &&
4473         (NONE_AUTH == ar->arAuthMode)      &&
4474         (WEP_CRYPT == ar->arPairwiseCrypto))
4475     {
4476         if (!ar->arConnected) {
4477             wmi_addKey_cmd(ar->arWmi,
4478                            ar->arDefTxKeyIndex,
4479                            WEP_CRYPT,
4480                            GROUP_USAGE | TX_USAGE,
4481                            ar->arWepKeyList[ar->arDefTxKeyIndex].arKeyLen,
4482                            NULL,
4483                            ar->arWepKeyList[ar->arDefTxKeyIndex].arKey, KEY_OP_INIT_VAL, NULL,
4484                            NO_SYNC_WMIFLAG);
4485         }
4486     }
4487 #endif /* ATH6K_CONFIG_CFG80211 */
4488
4489     /* Update connect & link status atomically */
4490     spin_lock_irqsave(&ar->arLock, flags);
4491     ar->arConnected  = TRUE;
4492     ar->arConnectPending = FALSE;
4493     netif_carrier_on(ar->arNetDev);
4494     spin_unlock_irqrestore(&ar->arLock, flags);
4495     /* reset the rx aggr state */
4496     aggr_reset_state(ar->aggr_cntxt);
4497     reconnect_flag = 0;
4498
4499     A_MEMZERO(&wrqu, sizeof(wrqu));
4500     A_MEMCPY(wrqu.addr.sa_data, bssid, IEEE80211_ADDR_LEN);
4501     wrqu.addr.sa_family = ARPHRD_ETHER;
4502     wireless_send_event(ar->arNetDev, SIOCGIWAP, &wrqu, NULL);
4503     if ((ar->arNetworkType == ADHOC_NETWORK) && ar->arIbssPsEnable) {
4504         A_MEMZERO(ar->arNodeMap, sizeof(ar->arNodeMap));
4505         ar->arNodeNum = 0;
4506         ar->arNexEpId = ENDPOINT_2;
4507     }
4508    if (!ar->arUserBssFilter) {
4509         wmi_bssfilter_cmd(ar->arWmi, NONE_BSS_FILTER, 0);
4510    }
4511
4512 }
4513
4514 void ar6000_set_numdataendpts(AR_SOFTC_T *ar, A_UINT32 num)
4515 {
4516     A_ASSERT(num <= (HTC_MAILBOX_NUM_MAX - 1));
4517     ar->arNumDataEndPts = num;
4518 }
4519
4520 void
4521 sta_cleanup(AR_SOFTC_T *ar, A_UINT8 i)
4522 {
4523     struct sk_buff *skb;
4524
4525     /* empty the queued pkts in the PS queue if any */
4526     A_MUTEX_LOCK(&ar->sta_list[i].psqLock);
4527     while (!A_NETBUF_QUEUE_EMPTY(&ar->sta_list[i].psq)) {
4528         skb = A_NETBUF_DEQUEUE(&ar->sta_list[i].psq);
4529         A_NETBUF_FREE(skb);
4530     }
4531     A_MUTEX_UNLOCK(&ar->sta_list[i].psqLock);
4532
4533     /* Zero out the state fields */
4534     A_MEMZERO(&ar->arAPStats.sta[ar->sta_list[i].aid-1], sizeof(WMI_PER_STA_STAT));
4535     A_MEMZERO(&ar->sta_list[i].mac, ATH_MAC_LEN);
4536     A_MEMZERO(&ar->sta_list[i].wpa_ie, IEEE80211_MAX_IE);
4537     ar->sta_list[i].aid = 0;
4538     ar->sta_list[i].flags = 0;
4539
4540     ar->sta_list_index = ar->sta_list_index & ~(1 << i);
4541
4542 }
4543
4544 A_UINT8
4545 remove_sta(AR_SOFTC_T *ar, A_UINT8 *mac, A_UINT16 reason)
4546 {
4547     A_UINT8 i, removed=0;
4548
4549     if(IS_MAC_NULL(mac)) {
4550         return removed;
4551     }
4552
4553     if(IS_MAC_BCAST(mac)) {
4554         A_PRINTF("DEL ALL STA\n");
4555         for(i=0; i < AP_MAX_NUM_STA; i++) {
4556             if(!IS_MAC_NULL(ar->sta_list[i].mac)) {
4557                 sta_cleanup(ar, i);
4558                 removed = 1;
4559             }
4560         }
4561     } else {
4562         for(i=0; i < AP_MAX_NUM_STA; i++) {
4563             if(A_MEMCMP(ar->sta_list[i].mac, mac, ATH_MAC_LEN)==0) {
4564                 A_PRINTF("DEL STA %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
4565                 " aid=%d REASON=%d\n", mac[0], mac[1], mac[2],
4566                  mac[3], mac[4], mac[5], ar->sta_list[i].aid, reason);
4567
4568                 sta_cleanup(ar, i);
4569                 removed = 1;
4570                 break;
4571             }
4572         }
4573     }
4574     return removed;
4575 }
4576
4577 void
4578 ar6000_disconnect_event(AR_SOFTC_T *ar, A_UINT8 reason, A_UINT8 *bssid,
4579                         A_UINT8 assocRespLen, A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus)
4580 {
4581     A_UINT8 i;
4582     unsigned long flags;
4583     union iwreq_data wrqu;
4584
4585     if(ar->arNetworkType & AP_NETWORK) {
4586         union iwreq_data wrqu;
4587         struct sk_buff *skb;
4588
4589         if(!remove_sta(ar, bssid, protocolReasonStatus)) {
4590             return;
4591         }
4592
4593         /* If there are no more associated STAs, empty the mcast PS q */
4594         if (ar->sta_list_index == 0) {
4595             A_MUTEX_LOCK(&ar->mcastpsqLock);
4596             while (!A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq)) {
4597                 skb = A_NETBUF_DEQUEUE(&ar->mcastpsq);
4598                 A_NETBUF_FREE(skb);
4599             }
4600             A_MUTEX_UNLOCK(&ar->mcastpsqLock);
4601
4602             /* Clear the LSB of the BitMapCtl field of the TIM IE */
4603             if (ar->arWmiReady) {
4604                 wmi_set_pvb_cmd(ar->arWmi, MCAST_AID, 0);
4605             }
4606         }
4607
4608         if(!IS_MAC_BCAST(bssid)) {
4609             /* Send event to application */
4610             A_MEMZERO(&wrqu, sizeof(wrqu));
4611             A_MEMCPY(wrqu.addr.sa_data, bssid, ATH_MAC_LEN);
4612             wireless_send_event(ar->arNetDev, IWEVEXPIRED, &wrqu, NULL);
4613         }
4614         return;
4615     }
4616
4617 #ifdef ATH6K_CONFIG_CFG80211
4618     ar6k_cfg80211_disconnect_event(ar, reason, bssid,
4619                                    assocRespLen, assocInfo,
4620                                    protocolReasonStatus);
4621 #endif /* ATH6K_CONFIG_CFG80211 */
4622
4623     /* Send disconnect event to supplicant */
4624     A_MEMZERO(&wrqu, sizeof(wrqu));
4625     wrqu.addr.sa_family = ARPHRD_ETHER;
4626     wireless_send_event(ar->arNetDev, SIOCGIWAP, &wrqu, NULL);
4627
4628     /* it is necessary to clear the host-side rx aggregation state */
4629     aggr_reset_state(ar->aggr_cntxt);
4630
4631     A_UNTIMEOUT(&ar->disconnect_timer);
4632
4633     A_PRINTF("AR6000 disconnected");
4634     if (bssid[0] || bssid[1] || bssid[2] || bssid[3] || bssid[4] || bssid[5]) {
4635         A_PRINTF(" from %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",
4636                  bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]);
4637     }
4638
4639     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nDisconnect Reason is %d", reason));
4640     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nProtocol Reason/Status Code is %d", protocolReasonStatus));
4641     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\nAssocResp Frame = %s",
4642                     assocRespLen ? " " : "NULL"));
4643     for (i = 0; i < assocRespLen; i++) {
4644         if (!(i % 0x10)) {
4645             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n"));
4646         }
4647         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("%2.2x ", assocInfo[i]));
4648     }
4649     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("\n"));
4650     /*
4651      * If the event is due to disconnect cmd from the host, only they the target
4652      * would stop trying to connect. Under any other condition, target would
4653      * keep trying to connect.
4654      *
4655      */
4656     if( reason == DISCONNECT_CMD)
4657     {
4658         ar->arConnectPending = FALSE;
4659         if ((!ar->arUserBssFilter) && (ar->arWmiReady)) {
4660             wmi_bssfilter_cmd(ar->arWmi, NONE_BSS_FILTER, 0);
4661         }
4662     } else {
4663         ar->arConnectPending = TRUE;
4664         if (((reason == ASSOC_FAILED) && (protocolReasonStatus == 0x11)) ||
4665             ((reason == ASSOC_FAILED) && (protocolReasonStatus == 0x0) && (reconnect_flag == 1))) {
4666             ar->arConnected = TRUE;
4667             return;
4668         }
4669     }
4670
4671     if ((reason == NO_NETWORK_AVAIL) && (ar->arWmiReady))
4672     {
4673         bss_t *pWmiSsidnode = NULL;
4674
4675         /* remove the current associated bssid node */
4676         wmi_free_node (ar->arWmi, bssid);
4677
4678         /*
4679          * In case any other same SSID nodes are present
4680          * remove it, since those nodes also not available now
4681          */
4682         do
4683         {
4684             /*
4685              * Find the nodes based on SSID and remove it
4686              * NOTE :: This case will not work out for Hidden-SSID
4687              */
4688             pWmiSsidnode = wmi_find_Ssidnode (ar->arWmi, ar->arSsid, ar->arSsidLen, FALSE, TRUE);
4689
4690             if (pWmiSsidnode)
4691             {
4692                 wmi_free_node (ar->arWmi, pWmiSsidnode->ni_macaddr);
4693             }
4694
4695         } while (pWmiSsidnode);
4696     }
4697
4698     /* Update connect & link status atomically */
4699     spin_lock_irqsave(&ar->arLock, flags);
4700     ar->arConnected = FALSE;
4701     netif_carrier_off(ar->arNetDev);
4702     spin_unlock_irqrestore(&ar->arLock, flags);
4703
4704     if( (reason != CSERV_DISCONNECT) || (reconnect_flag != 1) ) {
4705         reconnect_flag = 0;
4706     }
4707
4708 #ifdef USER_KEYS
4709     if (reason != CSERV_DISCONNECT)
4710     {
4711         ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT;
4712         ar->user_key_ctrl      = 0;
4713     }
4714 #endif /* USER_KEYS */
4715
4716     netif_stop_queue(ar->arNetDev);
4717     A_MEMZERO(ar->arBssid, sizeof(ar->arBssid));
4718     ar->arBssChannel = 0;
4719     ar->arBeaconInterval = 0;
4720
4721     ar6000_TxDataCleanup(ar);
4722 }
4723
4724 void
4725 ar6000_regDomain_event(AR_SOFTC_T *ar, A_UINT32 regCode)
4726 {
4727     A_PRINTF("AR6000 Reg Code = 0x%x\n", regCode);
4728     ar->arRegCode = regCode;
4729 }
4730
4731 #ifdef ATH_AR6K_11N_SUPPORT
4732 void
4733 ar6000_aggr_rcv_addba_req_evt(AR_SOFTC_T *ar, WMI_ADDBA_REQ_EVENT *evt)
4734 {
4735     if(evt->status == 0) {
4736         aggr_recv_addba_req_evt(ar->aggr_cntxt, evt->tid, evt->st_seq_no, evt->win_sz);
4737     }
4738 }
4739
4740 void
4741 ar6000_aggr_rcv_addba_resp_evt(AR_SOFTC_T *ar, WMI_ADDBA_RESP_EVENT *evt)
4742 {
4743     A_PRINTF("ADDBA RESP. tid %d status %d, sz %d\n", evt->tid, evt->status, evt->amsdu_sz);
4744     if(evt->status == 0) {
4745     }
4746 }
4747
4748 void
4749 ar6000_aggr_rcv_delba_req_evt(AR_SOFTC_T *ar, WMI_DELBA_EVENT *evt)
4750 {
4751     aggr_recv_delba_req_evt(ar->aggr_cntxt, evt->tid);
4752 }
4753 #endif
4754
4755 void register_pal_cb(ar6k_pal_config_t *palConfig_p)
4756 {
4757   ar6k_pal_config_g = *palConfig_p;
4758 }
4759
4760 void
4761 ar6000_hci_event_rcv_evt(struct ar6_softc *ar, WMI_HCI_EVENT *cmd)
4762 {
4763     void *osbuf = NULL;
4764     A_INT8 i;
4765     A_UINT8 size, *buf;
4766     A_STATUS ret = A_OK;
4767
4768     size = cmd->evt_buf_sz + 4;
4769     osbuf = A_NETBUF_ALLOC(size);
4770     if (osbuf == NULL) {
4771        ret = A_NO_MEMORY;
4772        A_PRINTF("Error in allocating netbuf \n");
4773        return;
4774     }
4775
4776     A_NETBUF_PUT(osbuf, size);
4777     buf = (A_UINT8 *)A_NETBUF_DATA(osbuf);
4778     /* First 2-bytes carry HCI event/ACL data type
4779      * the next 2 are free
4780      */
4781     *((short *)buf) = WMI_HCI_EVENT_EVENTID;
4782     buf += sizeof(int);
4783     A_MEMCPY(buf, cmd->buf, cmd->evt_buf_sz);
4784
4785     if(ar6k_pal_config_g.fpar6k_pal_recv_pkt)
4786     {
4787       /* pass the cmd packet to PAL driver */
4788       if((*ar6k_pal_config_g.fpar6k_pal_recv_pkt)(ar->hcipal_info, osbuf) == TRUE)
4789         return;
4790     }
4791     ar6000_deliver_frames_to_nw_stack(ar->arNetDev, osbuf);
4792     if(loghci) {
4793         A_PRINTF_LOG("HCI Event From PAL <-- \n");
4794         for(i = 0; i < cmd->evt_buf_sz; i++) {
4795            A_PRINTF_LOG("0x%02x ", cmd->buf[i]);
4796            if((i % 10) == 0) {
4797                A_PRINTF_LOG("\n");
4798            }
4799         }
4800         A_PRINTF_LOG("\n");
4801         A_PRINTF_LOG("==================================\n");
4802     }
4803 }
4804
4805 void
4806 ar6000_neighborReport_event(AR_SOFTC_T *ar, int numAps, WMI_NEIGHBOR_INFO *info)
4807 {
4808 #if WIRELESS_EXT >= 18
4809     struct iw_pmkid_cand *pmkcand;
4810 #else /* WIRELESS_EXT >= 18 */
4811     static const char *tag = "PRE-AUTH";
4812     char buf[128];
4813 #endif /* WIRELESS_EXT >= 18 */
4814
4815     union iwreq_data wrqu;
4816     int i;
4817
4818     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,("AR6000 Neighbor Report Event\n"));
4819     for (i=0; i < numAps; info++, i++) {
4820         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,("bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",
4821             info->bssid[0], info->bssid[1], info->bssid[2],
4822             info->bssid[3], info->bssid[4], info->bssid[5]));
4823         if (info->bssFlags & WMI_PREAUTH_CAPABLE_BSS) {
4824             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,("preauth-cap"));
4825         }
4826         if (info->bssFlags & WMI_PMKID_VALID_BSS) {
4827             AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,(" pmkid-valid\n"));
4828             continue;           /* we skip bss if the pmkid is already valid */
4829         }
4830         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,("\n"));
4831         A_MEMZERO(&wrqu, sizeof(wrqu));
4832 #if WIRELESS_EXT >= 18
4833         pmkcand = A_MALLOC_NOWAIT(sizeof(struct iw_pmkid_cand));
4834         A_MEMZERO(pmkcand, sizeof(struct iw_pmkid_cand));
4835         pmkcand->index = i;
4836         pmkcand->flags = info->bssFlags;
4837         A_MEMCPY(pmkcand->bssid.sa_data, info->bssid, ATH_MAC_LEN);
4838         wrqu.data.length = sizeof(struct iw_pmkid_cand);
4839         wireless_send_event(ar->arNetDev, IWEVPMKIDCAND, &wrqu, (char *)pmkcand);
4840         A_FREE(pmkcand);
4841 #else /* WIRELESS_EXT >= 18 */
4842         snprintf(buf, sizeof(buf), "%s%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x",
4843                  tag,
4844                  info->bssid[0], info->bssid[1], info->bssid[2],
4845                  info->bssid[3], info->bssid[4], info->bssid[5],
4846                  i, info->bssFlags);
4847         wrqu.data.length = strlen(buf);
4848         wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
4849 #endif /* WIRELESS_EXT >= 18 */
4850     }
4851 }
4852
4853 void
4854 ar6000_tkip_micerr_event(AR_SOFTC_T *ar, A_UINT8 keyid, A_BOOL ismcast)
4855 {
4856     static const char *tag = "MLME-MICHAELMICFAILURE.indication";
4857     char buf[128];
4858     union iwreq_data wrqu;
4859
4860     /*
4861      * For AP case, keyid will have aid of STA which sent pkt with
4862      * MIC error. Use this aid to get MAC & send it to hostapd.
4863      */
4864     if (ar->arNetworkType == AP_NETWORK) {
4865         sta_t *s = ieee80211_find_conn_for_aid(ar, (keyid >> 2));
4866         if(!s){
4867             A_PRINTF("AP TKIP MIC error received from Invalid aid / STA not found =%d\n", keyid);
4868             return;
4869         }
4870         A_PRINTF("AP TKIP MIC error received from aid=%d\n", keyid);
4871         snprintf(buf,sizeof(buf), "%s addr=%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x",
4872             tag, s->mac[0],s->mac[1],s->mac[2],s->mac[3],s->mac[4],s->mac[5]);
4873     } else {
4874
4875 #ifdef ATH6K_CONFIG_CFG80211
4876     ar6k_cfg80211_tkip_micerr_event(ar, keyid, ismcast);
4877 #endif /* ATH6K_CONFIG_CFG80211 */
4878
4879         A_PRINTF("AR6000 TKIP MIC error received for keyid %d %scast\n",
4880              keyid & 0x3, ismcast ? "multi": "uni");
4881         snprintf(buf, sizeof(buf), "%s(keyid=%d %sicast)", tag, keyid & 0x3,
4882              ismcast ? "mult" : "un");
4883     }
4884
4885     memset(&wrqu, 0, sizeof(wrqu));
4886     wrqu.data.length = strlen(buf);
4887     wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
4888 }
4889
4890 void
4891 ar6000_scanComplete_event(AR_SOFTC_T *ar, A_STATUS status)
4892 {
4893
4894 #ifdef ATH6K_CONFIG_CFG80211
4895     ar6k_cfg80211_scanComplete_event(ar, status);
4896 #endif /* ATH6K_CONFIG_CFG80211 */
4897
4898     if (!ar->arUserBssFilter) {
4899         wmi_bssfilter_cmd(ar->arWmi, NONE_BSS_FILTER, 0);
4900     }
4901     if (ar->scan_triggered) {
4902         if (status==A_OK) {
4903             union iwreq_data wrqu;
4904             A_MEMZERO(&wrqu, sizeof(wrqu));
4905             wireless_send_event(ar->arNetDev, SIOCGIWSCAN, &wrqu, NULL);
4906         }
4907         ar->scan_triggered = 0;
4908     }
4909
4910     AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,( "AR6000 scan complete: %d\n", status));
4911 }
4912
4913 void
4914 ar6000_targetStats_event(AR_SOFTC_T *ar,  A_UINT8 *ptr, A_UINT32 len)
4915 {
4916     A_UINT8 ac;
4917
4918     if(ar->arNetworkType == AP_NETWORK) {
4919         WMI_AP_MODE_STAT *p = (WMI_AP_MODE_STAT *)ptr;
4920         WMI_AP_MODE_STAT *ap = &ar->arAPStats;
4921
4922         if (len < sizeof(*p)) {
4923             return;
4924         }
4925
4926         for(ac=0;ac<AP_MAX_NUM_STA;ac++) {
4927             ap->sta[ac].tx_bytes   += p->sta[ac].tx_bytes;
4928             ap->sta[ac].tx_pkts    += p->sta[ac].tx_pkts;
4929             ap->sta[ac].tx_error   += p->sta[ac].tx_error;
4930             ap->sta[ac].tx_discard += p->sta[ac].tx_discard;
4931             ap->sta[ac].rx_bytes   += p->sta[ac].rx_bytes;
4932             ap->sta[ac].rx_pkts    += p->sta[ac].rx_pkts;
4933             ap->sta[ac].rx_error   += p->sta[ac].rx_error;
4934             ap->sta[ac].rx_discard += p->sta[ac].rx_discard;
4935         }
4936
4937     } else {
4938         WMI_TARGET_STATS *pTarget = (WMI_TARGET_STATS *)ptr;
4939          TARGET_STATS *pStats = &ar->arTargetStats;
4940
4941         if (len < sizeof(*pTarget)) {
4942             return;
4943         }
4944
4945         // Update the RSSI of the connected bss.
4946         if (ar->arConnected) {
4947             bss_t *pConnBss = NULL;
4948
4949             pConnBss = wmi_find_node(ar->arWmi,ar->arBssid);
4950             if (pConnBss)
4951             {
4952                 pConnBss->ni_rssi = pTarget->cservStats.cs_aveBeacon_rssi;
4953                 pConnBss->ni_snr = pTarget->cservStats.cs_aveBeacon_snr;
4954                 wmi_node_return(ar->arWmi, pConnBss);
4955             }
4956         }
4957
4958         AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 updating target stats\n"));
4959         pStats->tx_packets          += pTarget->txrxStats.tx_stats.tx_packets;
4960         pStats->tx_bytes            += pTarget->txrxStats.tx_stats.tx_bytes;
4961         pStats->tx_unicast_pkts     += pTarget->txrxStats.tx_stats.tx_unicast_pkts;
4962         pStats->tx_unicast_bytes    += pTarget->txrxStats.tx_stats.tx_unicast_bytes;
4963         pStats->tx_multicast_pkts   += pTarget->txrxStats.tx_stats.tx_multicast_pkts;
4964         pStats->tx_multicast_bytes  += pTarget->txrxStats.tx_stats.tx_multicast_bytes;
4965         pStats->tx_broadcast_pkts   += pTarget->txrxStats.tx_stats.tx_broadcast_pkts;
4966         pStats->tx_broadcast_bytes  += pTarget->txrxStats.tx_stats.tx_broadcast_bytes;
4967         pStats->tx_rts_success_cnt  += pTarget->txrxStats.tx_stats.tx_rts_success_cnt;
4968         for(ac = 0; ac < WMM_NUM_AC; ac++)
4969             pStats->tx_packet_per_ac[ac] += pTarget->txrxStats.tx_stats.tx_packet_per_ac[ac];
4970         pStats->tx_errors           += pTarget->txrxStats.tx_stats.tx_errors;
4971         pStats->tx_failed_cnt       += pTarget->txrxStats.tx_stats.tx_failed_cnt;
4972         pStats->tx_retry_cnt        += pTarget->txrxStats.tx_stats.tx_retry_cnt;
4973         pStats->tx_mult_retry_cnt   += pTarget->txrxStats.tx_stats.tx_mult_retry_cnt;
4974         pStats->tx_rts_fail_cnt     += pTarget->txrxStats.tx_stats.tx_rts_fail_cnt;
4975         pStats->tx_unicast_rate      = wmi_get_rate(pTarget->txrxStats.tx_stats.tx_unicast_rate);
4976
4977         pStats->rx_packets          += pTarget->txrxStats.rx_stats.rx_packets;
4978         pStats->rx_bytes            += pTarget->txrxStats.rx_stats.rx_bytes;
4979         pStats->rx_unicast_pkts     += pTarget->txrxStats.rx_stats.rx_unicast_pkts;
4980         pStats->rx_unicast_bytes    += pTarget->txrxStats.rx_stats.rx_unicast_bytes;
4981         pStats->rx_multicast_pkts   += pTarget->txrxStats.rx_stats.rx_multicast_pkts;
4982         pStats->rx_multicast_bytes  += pTarget->txrxStats.rx_stats.rx_multicast_bytes;
4983         pStats->rx_broadcast_pkts   += pTarget->txrxStats.rx_stats.rx_broadcast_pkts;
4984         pStats->rx_broadcast_bytes  += pTarget->txrxStats.rx_stats.rx_broadcast_bytes;
4985         pStats->rx_fragment_pkt     += pTarget->txrxStats.rx_stats.rx_fragment_pkt;
4986         pStats->rx_errors           += pTarget->txrxStats.rx_stats.rx_errors;
4987         pStats->rx_crcerr           += pTarget->txrxStats.rx_stats.rx_crcerr;
4988         pStats->rx_key_cache_miss   += pTarget->txrxStats.rx_stats.rx_key_cache_miss;
4989         pStats->rx_decrypt_err      += pTarget->txrxStats.rx_stats.rx_decrypt_err;
4990         pStats->rx_duplicate_frames += pTarget->txrxStats.rx_stats.rx_duplicate_frames;
4991         pStats->rx_unicast_rate      = wmi_get_rate(pTarget->txrxStats.rx_stats.rx_unicast_rate);
4992
4993
4994         pStats->tkip_local_mic_failure
4995                                 += pTarget->txrxStats.tkipCcmpStats.tkip_local_mic_failure;
4996         pStats->tkip_counter_measures_invoked
4997                                 += pTarget->txrxStats.tkipCcmpStats.tkip_counter_measures_invoked;
4998         pStats->tkip_replays        += pTarget->txrxStats.tkipCcmpStats.tkip_replays;
4999         pStats->tkip_format_errors  += pTarget->txrxStats.tkipCcmpStats.tkip_format_errors;
5000         pStats->ccmp_format_errors  += pTarget->txrxStats.tkipCcmpStats.ccmp_format_errors;
5001         pStats->ccmp_replays        += pTarget->txrxStats.tkipCcmpStats.ccmp_replays;
5002
5003         pStats->power_save_failure_cnt += pTarget->pmStats.power_save_failure_cnt;
5004         pStats->noise_floor_calibation = pTarget->noise_floor_calibation;
5005
5006         pStats->cs_bmiss_cnt        += pTarget->cservStats.cs_bmiss_cnt;
5007         pStats->cs_lowRssi_cnt      += pTarget->cservStats.cs_lowRssi_cnt;
5008         pStats->cs_connect_cnt      += pTarget->cservStats.cs_connect_cnt;
5009         pStats->cs_disconnect_cnt   += pTarget->cservStats.cs_disconnect_cnt;
5010         pStats->cs_aveBeacon_snr    = pTarget->cservStats.cs_aveBeacon_snr;
5011         pStats->cs_aveBeacon_rssi   = pTarget->cservStats.cs_aveBeacon_rssi;
5012
5013         if (enablerssicompensation) {
5014             pStats->cs_aveBeacon_rssi =
5015                     rssi_compensation_calc(ar, pStats->cs_aveBeacon_rssi);
5016         }
5017         pStats->cs_lastRoam_msec    = pTarget->cservStats.cs_lastRoam_msec;
5018         pStats->cs_snr              = pTarget->cservStats.cs_snr;
5019         pStats->cs_rssi             = pTarget->cservStats.cs_rssi;
5020
5021         pStats->lq_val              = pTarget->lqVal;
5022
5023         pStats->wow_num_pkts_dropped += pTarget->wowStats.wow_num_pkts_dropped;
5024         pStats->wow_num_host_pkt_wakeups += pTarget->wowStats.wow_num_host_pkt_wakeups;
5025         pStats->wow_num_host_event_wakeups += pTarget->wowStats.wow_num_host_event_wakeups;
5026         pStats->wow_num_events_discarded += pTarget->wowStats.wow_num_events_discarded;
5027         pStats->arp_received += pTarget->arpStats.arp_received;
5028         pStats->arp_matched  += pTarget->arpStats.arp_matched;
5029         pStats->arp_replied  += pTarget->arpStats.arp_replied;
5030
5031         if (ar->statsUpdatePending) {
5032             ar->statsUpdatePending = FALSE;
5033             wake_up(&arEvent);
5034         }
5035     }
5036 }
5037
5038 void
5039 ar6000_rssiThreshold_event(AR_SOFTC_T *ar,  WMI_RSSI_THRESHOLD_VAL newThreshold, A_INT16 rssi)
5040 {
5041     USER_RSSI_THOLD userRssiThold;
5042
5043     rssi = rssi + SIGNAL_QUALITY_NOISE_FLOOR;
5044
5045     if (enablerssicompensation) {
5046         rssi = rssi_compensation_calc(ar, rssi);
5047     }
5048
5049     /* Send an event to the app */
5050     userRssiThold.tag = ar->rssi_map[newThreshold].tag;
5051     userRssiThold.rssi = rssi;
5052     A_PRINTF("rssi Threshold range = %d tag = %d  rssi = %d\n", newThreshold,
5053              userRssiThold.tag, userRssiThold.rssi);
5054
5055     ar6000_send_event_to_app(ar, WMI_RSSI_THRESHOLD_EVENTID,(A_UINT8 *)&userRssiThold, sizeof(USER_RSSI_THOLD));
5056 }
5057
5058
5059 void
5060 ar6000_hbChallengeResp_event(AR_SOFTC_T *ar, A_UINT32 cookie, A_UINT32 source)
5061 {
5062     if (source == APP_HB_CHALLENGE) {
5063         /* Report it to the app in case it wants a positive acknowledgement */
5064         ar6000_send_event_to_app(ar, WMIX_HB_CHALLENGE_RESP_EVENTID,
5065                                  (A_UINT8 *)&cookie, sizeof(cookie));
5066     } else {
5067         /* This would ignore the replys that come in after their due time */
5068         if (cookie == ar->arHBChallengeResp.seqNum) {
5069             ar->arHBChallengeResp.outstanding = FALSE;
5070         }
5071     }
5072 }
5073
5074
5075 void
5076 ar6000_reportError_event(AR_SOFTC_T *ar, WMI_TARGET_ERROR_VAL errorVal)
5077 {
5078     char    *errString[] = {
5079                 [WMI_TARGET_PM_ERR_FAIL]    "WMI_TARGET_PM_ERR_FAIL",
5080                 [WMI_TARGET_KEY_NOT_FOUND]  "WMI_TARGET_KEY_NOT_FOUND",
5081                 [WMI_TARGET_DECRYPTION_ERR] "WMI_TARGET_DECRYPTION_ERR",
5082                 [WMI_TARGET_BMISS]          "WMI_TARGET_BMISS",
5083                 [WMI_PSDISABLE_NODE_JOIN]   "WMI_PSDISABLE_NODE_JOIN"
5084                 };
5085
5086     A_PRINTF("AR6000 Error on Target. Error = 0x%x\n", errorVal);
5087
5088     /* One error is reported at a time, and errorval is a bitmask */
5089     if(errorVal & (errorVal - 1))
5090        return;
5091
5092     A_PRINTF("AR6000 Error type = ");
5093     switch(errorVal)
5094     {
5095         case WMI_TARGET_PM_ERR_FAIL:
5096         case WMI_TARGET_KEY_NOT_FOUND:
5097         case WMI_TARGET_DECRYPTION_ERR:
5098         case WMI_TARGET_BMISS:
5099         case WMI_PSDISABLE_NODE_JOIN:
5100             A_PRINTF("%s\n", errString[errorVal]);
5101             break;
5102         default:
5103             A_PRINTF("INVALID\n");
5104             break;
5105     }
5106
5107 }
5108
5109
5110 void
5111 ar6000_cac_event(AR_SOFTC_T *ar, A_UINT8 ac, A_UINT8 cacIndication,
5112                  A_UINT8 statusCode, A_UINT8 *tspecSuggestion)
5113 {
5114     WMM_TSPEC_IE    *tspecIe;
5115
5116     /*
5117      * This is the TSPEC IE suggestion from AP.
5118      * Suggestion provided by AP under some error
5119      * cases, could be helpful for the host app.
5120      * Check documentation.
5121      */
5122     tspecIe = (WMM_TSPEC_IE *)tspecSuggestion;
5123
5124     /*
5125      * What do we do, if we get TSPEC rejection? One thought
5126      * that comes to mind is implictly delete the pstream...
5127      */
5128     A_PRINTF("AR6000 CAC notification. "
5129                 "AC = %d, cacIndication = 0x%x, statusCode = 0x%x\n",
5130                  ac, cacIndication, statusCode);
5131 }
5132
5133 void
5134 ar6000_channel_change_event(AR_SOFTC_T *ar, A_UINT16 oldChannel,
5135                             A_UINT16 newChannel)
5136 {
5137     A_PRINTF("Channel Change notification\nOld Channel: %d, New Channel: %d\n",
5138              oldChannel, newChannel);
5139 }
5140
5141 #define AR6000_PRINT_BSSID(_pBss)  do {     \
5142         A_PRINTF("%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",\
5143                  (_pBss)[0],(_pBss)[1],(_pBss)[2],(_pBss)[3],\
5144                  (_pBss)[4],(_pBss)[5]);  \
5145 } while(0)
5146
5147 void
5148 ar6000_roam_tbl_event(AR_SOFTC_T *ar, WMI_TARGET_ROAM_TBL *pTbl)
5149 {
5150     A_UINT8 i;
5151
5152     A_PRINTF("ROAM TABLE NO OF ENTRIES is %d ROAM MODE is %d\n",
5153               pTbl->numEntries, pTbl->roamMode);
5154     for (i= 0; i < pTbl->numEntries; i++) {
5155         A_PRINTF("[%d]bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ", i,
5156             pTbl->bssRoamInfo[i].bssid[0], pTbl->bssRoamInfo[i].bssid[1],
5157             pTbl->bssRoamInfo[i].bssid[2],
5158             pTbl->bssRoamInfo[i].bssid[3],
5159             pTbl->bssRoamInfo[i].bssid[4],
5160             pTbl->bssRoamInfo[i].bssid[5]);
5161         A_PRINTF("RSSI %d RSSIDT %d LAST RSSI %d UTIL %d ROAM_UTIL %d"
5162                  " BIAS %d\n",
5163             pTbl->bssRoamInfo[i].rssi,
5164             pTbl->bssRoamInfo[i].rssidt,
5165             pTbl->bssRoamInfo[i].last_rssi,
5166             pTbl->bssRoamInfo[i].util,
5167             pTbl->bssRoamInfo[i].roam_util,
5168             pTbl->bssRoamInfo[i].bias);
5169     }
5170 }
5171
5172 void
5173 ar6000_wow_list_event(struct ar6_softc *ar, A_UINT8 num_filters, WMI_GET_WOW_LIST_REPLY *wow_reply)
5174 {
5175     A_UINT8 i,j;
5176
5177     /*Each event now contains exactly one filter, see bug 26613*/
5178     A_PRINTF("WOW pattern %d of %d patterns\n", wow_reply->this_filter_num,                 wow_reply->num_filters);
5179     A_PRINTF("wow mode = %s host mode = %s\n",
5180             (wow_reply->wow_mode == 0? "disabled":"enabled"),
5181             (wow_reply->host_mode == 1 ? "awake":"asleep"));
5182
5183
5184     /*If there are no patterns, the reply will only contain generic
5185       WoW information. Pattern information will exist only if there are
5186       patterns present. Bug 26716*/
5187
5188    /* If this event contains pattern information, display it*/
5189     if (wow_reply->this_filter_num) {
5190         i=0;
5191         A_PRINTF("id=%d size=%d offset=%d\n",
5192                     wow_reply->wow_filters[i].wow_filter_id,
5193                     wow_reply->wow_filters[i].wow_filter_size,
5194                     wow_reply->wow_filters[i].wow_filter_offset);
5195        A_PRINTF("wow pattern = ");
5196        for (j=0; j< wow_reply->wow_filters[i].wow_filter_size; j++) {
5197              A_PRINTF("%2.2x",wow_reply->wow_filters[i].wow_filter_pattern[j]);
5198         }
5199
5200         A_PRINTF("\nwow mask = ");
5201         for (j=0; j< wow_reply->wow_filters[i].wow_filter_size; j++) {
5202             A_PRINTF("%2.2x",wow_reply->wow_filters[i].wow_filter_mask[j]);
5203         }
5204         A_PRINTF("\n");
5205     }
5206 }
5207
5208 /*
5209  * Report the Roaming related data collected on the target
5210  */
5211 void
5212 ar6000_display_roam_time(WMI_TARGET_ROAM_TIME *p)
5213 {
5214     A_PRINTF("Disconnect Data : BSSID: ");
5215     AR6000_PRINT_BSSID(p->disassoc_bssid);
5216     A_PRINTF(" RSSI %d DISASSOC Time %d NO_TXRX_TIME %d\n",
5217              p->disassoc_bss_rssi,p->disassoc_time,
5218              p->no_txrx_time);
5219     A_PRINTF("Connect Data: BSSID: ");
5220     AR6000_PRINT_BSSID(p->assoc_bssid);
5221     A_PRINTF(" RSSI %d ASSOC Time %d TXRX_TIME %d\n",
5222              p->assoc_bss_rssi,p->assoc_time,
5223              p->allow_txrx_time);
5224 }
5225
5226 void
5227 ar6000_roam_data_event(AR_SOFTC_T *ar, WMI_TARGET_ROAM_DATA *p)
5228 {
5229     switch (p->roamDataType) {
5230         case ROAM_DATA_TIME:
5231             ar6000_display_roam_time(&p->u.roamTime);
5232             break;
5233         default:
5234             break;
5235     }
5236 }
5237
5238 void
5239 ar6000_bssInfo_event_rx(AR_SOFTC_T *ar, A_UINT8 *datap, int len)
5240 {
5241     struct sk_buff *skb;
5242     WMI_BSS_INFO_HDR *bih = (WMI_BSS_INFO_HDR *)datap;
5243
5244
5245     if (!ar->arMgmtFilter) {
5246         return;
5247     }
5248     if (((ar->arMgmtFilter & IEEE80211_FILTER_TYPE_BEACON) &&
5249         (bih->frameType != BEACON_FTYPE))  ||
5250         ((ar->arMgmtFilter & IEEE80211_FILTER_TYPE_PROBE_RESP) &&
5251         (bih->frameType != PROBERESP_FTYPE)))
5252     {
5253         return;
5254     }
5255
5256     if ((skb = A_NETBUF_ALLOC_RAW(len)) != NULL) {
5257
5258         A_NETBUF_PUT(skb, len);
5259         A_MEMCPY(A_NETBUF_DATA(skb), datap, len);
5260         skb->dev = ar->arNetDev;
5261         A_MEMCPY(skb_mac_header(skb), A_NETBUF_DATA(skb), 6);
5262         skb->ip_summed = CHECKSUM_NONE;
5263         skb->pkt_type = PACKET_OTHERHOST;
5264         skb->protocol = __constant_htons(0x0019);
5265         netif_rx(skb);
5266     }
5267 }
5268
5269 A_UINT32 wmiSendCmdNum;
5270
5271 A_STATUS
5272 ar6000_control_tx(void *devt, void *osbuf, HTC_ENDPOINT_ID eid)
5273 {
5274     AR_SOFTC_T       *ar = (AR_SOFTC_T *)devt;
5275     A_STATUS         status = A_OK;
5276     struct ar_cookie *cookie = NULL;
5277     int i;
5278 #ifdef CONFIG_PM
5279     if (ar->arWowState != WLAN_WOW_STATE_NONE) {
5280         A_NETBUF_FREE(osbuf);
5281         return A_EACCES;
5282     }
5283 #endif /* CONFIG_PM */
5284         /* take lock to protect ar6000_alloc_cookie() */
5285     AR6000_SPIN_LOCK(&ar->arLock, 0);
5286
5287     do {
5288
5289         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("ar_contrstatus = ol_tx: skb=0x%lx, len=0x%x eid =%d\n",
5290                          (unsigned long)osbuf, A_NETBUF_LEN(osbuf), eid));
5291
5292         if (ar->arWMIControlEpFull && (eid == ar->arControlEp)) {
5293                 /* control endpoint is full, don't allocate resources, we
5294                  * are just going to drop this packet */
5295             cookie = NULL;
5296             AR_DEBUG_PRINTF(ATH_DEBUG_ERR,(" WMI Control EP full, dropping packet : 0x%lX, len:%d \n",
5297                     (unsigned long)osbuf, A_NETBUF_LEN(osbuf)));
5298         } else {
5299             cookie = ar6000_alloc_cookie(ar);
5300         }
5301
5302         if (cookie == NULL) {
5303             status = A_NO_MEMORY;
5304             break;
5305         }
5306
5307         if(logWmiRawMsgs) {
5308             A_PRINTF("WMI cmd send, msgNo %d :", wmiSendCmdNum);
5309             for(i = 0; i < a_netbuf_to_len(osbuf); i++)
5310                 A_PRINTF("%x ", ((A_UINT8 *)a_netbuf_to_data(osbuf))[i]);
5311             A_PRINTF("\n");
5312         }
5313
5314         wmiSendCmdNum++;
5315
5316     } while (FALSE);
5317
5318     if (cookie != NULL) {
5319             /* got a structure to send it out on */
5320         ar->arTxPending[eid]++;
5321
5322         if (eid != ar->arControlEp) {
5323             ar->arTotalTxDataPending++;
5324         }
5325     }
5326
5327     AR6000_SPIN_UNLOCK(&ar->arLock, 0);
5328
5329     if (cookie != NULL) {
5330         cookie->arc_bp[0] = (unsigned long)osbuf;
5331         cookie->arc_bp[1] = 0;
5332         SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
5333                                cookie,
5334                                A_NETBUF_DATA(osbuf),
5335                                A_NETBUF_LEN(osbuf),
5336                                eid,
5337                                AR6K_CONTROL_PKT_TAG);
5338             /* this interface is asynchronous, if there is an error, cleanup will happen in the
5339              * TX completion callback */
5340         HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt);
5341         status = A_OK;
5342     }
5343
5344     if (status != A_OK) {
5345         A_NETBUF_FREE(osbuf);
5346     }
5347     return status;
5348 }
5349
5350 /* indicate tx activity or inactivity on a WMI stream */
5351 void ar6000_indicate_tx_activity(void *devt, A_UINT8 TrafficClass, A_BOOL Active)
5352 {
5353     AR_SOFTC_T  *ar = (AR_SOFTC_T *)devt;
5354     HTC_ENDPOINT_ID eid ;
5355     int i;
5356
5357     if (ar->arWmiEnabled) {
5358         eid = arAc2EndpointID(ar, TrafficClass);
5359
5360         AR6000_SPIN_LOCK(&ar->arLock, 0);
5361
5362         ar->arAcStreamActive[TrafficClass] = Active;
5363
5364         if (Active) {
5365             /* when a stream goes active, keep track of the active stream with the highest priority */
5366
5367             if (ar->arAcStreamPriMap[TrafficClass] > ar->arHiAcStreamActivePri) {
5368                     /* set the new highest active priority */
5369                 ar->arHiAcStreamActivePri = ar->arAcStreamPriMap[TrafficClass];
5370             }
5371
5372         } else {
5373             /* when a stream goes inactive, we may have to search for the next active stream
5374              * that is the highest priority */
5375
5376             if (ar->arHiAcStreamActivePri == ar->arAcStreamPriMap[TrafficClass]) {
5377
5378                 /* the highest priority stream just went inactive */
5379
5380                     /* reset and search for the "next" highest "active" priority stream */
5381                 ar->arHiAcStreamActivePri = 0;
5382                 for (i = 0; i < WMM_NUM_AC; i++) {
5383                     if (ar->arAcStreamActive[i]) {
5384                         if (ar->arAcStreamPriMap[i] > ar->arHiAcStreamActivePri) {
5385                             /* set the new highest active priority */
5386                             ar->arHiAcStreamActivePri = ar->arAcStreamPriMap[i];
5387                         }
5388                     }
5389                 }
5390             }
5391         }
5392
5393         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
5394
5395     } else {
5396             /* for mbox ping testing, the traffic class is mapped directly as a stream ID,
5397              * see handling of AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE in ioctl.c
5398              * convert the stream ID to a endpoint */
5399         eid = arAc2EndpointID(ar, TrafficClass);
5400     }
5401
5402         /* notify HTC, this may cause credit distribution changes */
5403
5404     HTCIndicateActivityChange(ar->arHtcTarget,
5405                               eid,
5406                               Active);
5407
5408 }
5409
5410 void
5411 ar6000_btcoex_config_event(struct ar6_softc *ar,  A_UINT8 *ptr, A_UINT32 len)
5412 {
5413
5414     WMI_BTCOEX_CONFIG_EVENT *pBtcoexConfig = (WMI_BTCOEX_CONFIG_EVENT *)ptr;
5415     WMI_BTCOEX_CONFIG_EVENT *pArbtcoexConfig =&ar->arBtcoexConfig;
5416
5417     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 BTCOEX CONFIG EVENT \n"));
5418
5419     A_PRINTF("received config event\n");
5420     pArbtcoexConfig->btProfileType = pBtcoexConfig->btProfileType;
5421     pArbtcoexConfig->linkId = pBtcoexConfig->linkId;
5422
5423     switch (pBtcoexConfig->btProfileType) {
5424         case WMI_BTCOEX_BT_PROFILE_SCO:
5425             A_MEMCPY(&pArbtcoexConfig->info.scoConfigCmd, &pBtcoexConfig->info.scoConfigCmd,
5426                                         sizeof(WMI_SET_BTCOEX_SCO_CONFIG_CMD));
5427             break;
5428         case WMI_BTCOEX_BT_PROFILE_A2DP:
5429             A_MEMCPY(&pArbtcoexConfig->info.a2dpConfigCmd, &pBtcoexConfig->info.a2dpConfigCmd,
5430                                         sizeof(WMI_SET_BTCOEX_A2DP_CONFIG_CMD));
5431             break;
5432         case WMI_BTCOEX_BT_PROFILE_ACLCOEX:
5433             A_MEMCPY(&pArbtcoexConfig->info.aclcoexConfig, &pBtcoexConfig->info.aclcoexConfig,
5434                                         sizeof(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD));
5435             break;
5436         case WMI_BTCOEX_BT_PROFILE_INQUIRY_PAGE:
5437            A_MEMCPY(&pArbtcoexConfig->info.btinquiryPageConfigCmd, &pBtcoexConfig->info.btinquiryPageConfigCmd,
5438                                         sizeof(WMI_SET_BTCOEX_ACLCOEX_CONFIG_CMD));
5439             break;
5440     }
5441     if (ar->statsUpdatePending) {
5442          ar->statsUpdatePending = FALSE;
5443           wake_up(&arEvent);
5444     }
5445 }
5446
5447 void
5448 ar6000_btcoex_stats_event(struct ar6_softc *ar,  A_UINT8 *ptr, A_UINT32 len)
5449 {
5450     WMI_BTCOEX_STATS_EVENT *pBtcoexStats = (WMI_BTCOEX_STATS_EVENT *)ptr;
5451
5452     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("AR6000 BTCOEX CONFIG EVENT \n"));
5453
5454     A_MEMCPY(&ar->arBtcoexStats, pBtcoexStats, sizeof(WMI_BTCOEX_STATS_EVENT));
5455
5456     if (ar->statsUpdatePending) {
5457          ar->statsUpdatePending = FALSE;
5458         wake_up(&arEvent);
5459     }
5460
5461 }
5462 module_init(ar6000_init_module);
5463 module_exit(ar6000_cleanup_module);
5464
5465 /* Init cookie queue */
5466 static void
5467 ar6000_cookie_init(AR_SOFTC_T *ar)
5468 {
5469     A_UINT32    i;
5470
5471     ar->arCookieList = NULL;
5472     ar->arCookieCount = 0;
5473
5474     A_MEMZERO(s_ar_cookie_mem, sizeof(s_ar_cookie_mem));
5475
5476     for (i = 0; i < MAX_COOKIE_NUM; i++) {
5477         ar6000_free_cookie(ar, &s_ar_cookie_mem[i]);
5478     }
5479 }
5480
5481 /* cleanup cookie queue */
5482 static void
5483 ar6000_cookie_cleanup(AR_SOFTC_T *ar)
5484 {
5485     /* It is gone .... */
5486     ar->arCookieList = NULL;
5487     ar->arCookieCount = 0;
5488 }
5489
5490 /* Init cookie queue */
5491 static void
5492 ar6000_free_cookie(AR_SOFTC_T *ar, struct ar_cookie * cookie)
5493 {
5494     /* Insert first */
5495     A_ASSERT(ar != NULL);
5496     A_ASSERT(cookie != NULL);
5497
5498     cookie->arc_list_next = ar->arCookieList;
5499     ar->arCookieList = cookie;
5500     ar->arCookieCount++;
5501 }
5502
5503 /* cleanup cookie queue */
5504 static struct ar_cookie *
5505 ar6000_alloc_cookie(AR_SOFTC_T  *ar)
5506 {
5507     struct ar_cookie   *cookie;
5508
5509     cookie = ar->arCookieList;
5510     if(cookie != NULL)
5511     {
5512         ar->arCookieList = cookie->arc_list_next;
5513         ar->arCookieCount--;
5514     }
5515
5516     return cookie;
5517 }
5518
5519 #ifdef SEND_EVENT_TO_APP
5520 /*
5521  * This function is used to send event which come from taget to
5522  * the application. The buf which send to application is include
5523  * the event ID and event content.
5524  */
5525 #define EVENT_ID_LEN   2
5526 void ar6000_send_event_to_app(AR_SOFTC_T *ar, A_UINT16 eventId,
5527                               A_UINT8 *datap, int len)
5528 {
5529
5530 #if (WIRELESS_EXT >= 15)
5531
5532 /* note: IWEVCUSTOM only exists in wireless extensions after version 15 */
5533
5534     char *buf;
5535     A_UINT16 size;
5536     union iwreq_data wrqu;
5537
5538     size = len + EVENT_ID_LEN;
5539
5540     if (size > IW_CUSTOM_MAX) {
5541         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI event ID : 0x%4.4X, len = %d too big for IWEVCUSTOM (max=%d) \n",
5542                 eventId, size, IW_CUSTOM_MAX));
5543         return;
5544     }
5545
5546     buf = A_MALLOC_NOWAIT(size);
5547     if (NULL == buf){
5548         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: failed to allocate %d bytes\n", __func__, size));
5549         return;
5550     }
5551
5552     A_MEMZERO(buf, size);
5553     A_MEMCPY(buf, &eventId, EVENT_ID_LEN);
5554     A_MEMCPY(buf+EVENT_ID_LEN, datap, len);
5555
5556     //AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("event ID = %d,len = %d\n",*(A_UINT16*)buf, size));
5557     A_MEMZERO(&wrqu, sizeof(wrqu));
5558     wrqu.data.length = size;
5559     wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
5560     A_FREE(buf);
5561 #endif
5562
5563
5564 }
5565
5566 /*
5567  * This function is used to send events larger than 256 bytes
5568  * to the application. The buf which is sent to application
5569  * includes the event ID and event content.
5570  */
5571 void ar6000_send_generic_event_to_app(AR_SOFTC_T *ar, A_UINT16 eventId,
5572                                       A_UINT8 *datap, int len)
5573 {
5574
5575 #if (WIRELESS_EXT >= 18)
5576
5577 /* IWEVGENIE exists in wireless extensions version 18 onwards */
5578
5579     char *buf;
5580     A_UINT16 size;
5581     union iwreq_data wrqu;
5582
5583     size = len + EVENT_ID_LEN;
5584
5585     if (size > IW_GENERIC_IE_MAX) {
5586         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("WMI event ID : 0x%4.4X, len = %d too big for IWEVGENIE (max=%d) \n",
5587                         eventId, size, IW_GENERIC_IE_MAX));
5588         return;
5589     }
5590
5591     buf = A_MALLOC_NOWAIT(size);
5592     if (NULL == buf){
5593         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("%s: failed to allocate %d bytes\n", __func__, size));
5594         return;
5595     }
5596
5597     A_MEMZERO(buf, size);
5598     A_MEMCPY(buf, &eventId, EVENT_ID_LEN);
5599     A_MEMCPY(buf+EVENT_ID_LEN, datap, len);
5600
5601     A_MEMZERO(&wrqu, sizeof(wrqu));
5602     wrqu.data.length = size;
5603     wireless_send_event(ar->arNetDev, IWEVGENIE, &wrqu, buf);
5604
5605     A_FREE(buf);
5606
5607 #endif /* (WIRELESS_EXT >= 18) */
5608
5609 }
5610 #endif /* SEND_EVENT_TO_APP */
5611
5612
5613 void
5614 ar6000_tx_retry_err_event(void *devt)
5615 {
5616     AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("Tx retries reach maximum!\n"));
5617 }
5618
5619 void
5620 ar6000_snrThresholdEvent_rx(void *devt, WMI_SNR_THRESHOLD_VAL newThreshold, A_UINT8 snr)
5621 {
5622     WMI_SNR_THRESHOLD_EVENT event;
5623     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
5624
5625     event.range = newThreshold;
5626     event.snr = snr;
5627
5628     ar6000_send_event_to_app(ar, WMI_SNR_THRESHOLD_EVENTID, (A_UINT8 *)&event,
5629                              sizeof(WMI_SNR_THRESHOLD_EVENT));
5630 }
5631
5632 void
5633 ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL newThreshold, A_UINT8 lq)
5634 {
5635     AR_DEBUG_PRINTF(ATH_DEBUG_INFO,("lq threshold range %d, lq %d\n", newThreshold, lq));
5636 }
5637
5638
5639
5640 A_UINT32
5641 a_copy_to_user(void *to, const void *from, A_UINT32 n)
5642 {
5643     return(copy_to_user(to, from, n));
5644 }
5645
5646 A_UINT32
5647 a_copy_from_user(void *to, const void *from, A_UINT32 n)
5648 {
5649     return(copy_from_user(to, from, n));
5650 }
5651
5652
5653 A_STATUS
5654 ar6000_get_driver_cfg(struct net_device *dev,
5655                         A_UINT16 cfgParam,
5656                         void *result)
5657 {
5658
5659     A_STATUS    ret = 0;
5660
5661     switch(cfgParam)
5662     {
5663         case AR6000_DRIVER_CFG_GET_WLANNODECACHING:
5664            *((A_UINT32 *)result) = wlanNodeCaching;
5665            break;
5666         case AR6000_DRIVER_CFG_LOG_RAW_WMI_MSGS:
5667            *((A_UINT32 *)result) = logWmiRawMsgs;
5668             break;
5669         default:
5670            ret = EINVAL;
5671            break;
5672     }
5673
5674     return ret;
5675 }
5676
5677 void
5678 ar6000_keepalive_rx(void *devt, A_UINT8 configured)
5679 {
5680     AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
5681
5682     ar->arKeepaliveConfigured = configured;
5683     wake_up(&arEvent);
5684 }
5685
5686 void
5687 ar6000_pmkid_list_event(void *devt, A_UINT8 numPMKID, WMI_PMKID *pmkidList,
5688                         A_UINT8 *bssidList)
5689 {
5690     A_UINT8 i, j;
5691
5692     A_PRINTF("Number of Cached PMKIDs is %d\n", numPMKID);
5693
5694     for (i = 0; i < numPMKID; i++) {
5695         A_PRINTF("\nBSSID %d ", i);
5696             for (j = 0; j < ATH_MAC_LEN; j++) {
5697                 A_PRINTF("%2.2x", bssidList[j]);
5698             }
5699         bssidList += (ATH_MAC_LEN + WMI_PMKID_LEN);
5700         A_PRINTF("\nPMKID %d ", i);
5701             for (j = 0; j < WMI_PMKID_LEN; j++) {
5702                 A_PRINTF("%2.2x", pmkidList->pmkid[j]);
5703             }
5704         pmkidList = (WMI_PMKID *)((A_UINT8 *)pmkidList + ATH_MAC_LEN +
5705                                   WMI_PMKID_LEN);
5706     }
5707 }
5708
5709 void ar6000_pspoll_event(AR_SOFTC_T *ar,A_UINT8 aid)
5710 {
5711     sta_t *conn=NULL;
5712     A_BOOL isPsqEmpty = FALSE;
5713
5714     conn = ieee80211_find_conn_for_aid(ar, aid);
5715
5716     /* If the PS q for this STA is not empty, dequeue and send a pkt from
5717      * the head of the q. Also update the More data bit in the WMI_DATA_HDR
5718      * if there are more pkts for this STA in the PS q. If there are no more
5719      * pkts for this STA, update the PVB for this STA.
5720      */
5721     A_MUTEX_LOCK(&conn->psqLock);
5722     isPsqEmpty  = A_NETBUF_QUEUE_EMPTY(&conn->psq);
5723     A_MUTEX_UNLOCK(&conn->psqLock);
5724
5725     if (isPsqEmpty) {
5726         /* TODO:No buffered pkts for this STA. Send out a NULL data frame */
5727     } else {
5728         struct sk_buff *skb = NULL;
5729
5730         A_MUTEX_LOCK(&conn->psqLock);
5731         skb = A_NETBUF_DEQUEUE(&conn->psq);
5732         A_MUTEX_UNLOCK(&conn->psqLock);
5733         /* Set the STA flag to PSPolled, so that the frame will go out */
5734         STA_SET_PS_POLLED(conn);
5735         ar6000_data_tx(skb, ar->arNetDev);
5736         STA_CLR_PS_POLLED(conn);
5737
5738         /* Clear the PVB for this STA if the queue has become empty */
5739         A_MUTEX_LOCK(&conn->psqLock);
5740         isPsqEmpty  = A_NETBUF_QUEUE_EMPTY(&conn->psq);
5741         A_MUTEX_UNLOCK(&conn->psqLock);
5742
5743         if (isPsqEmpty) {
5744             wmi_set_pvb_cmd(ar->arWmi, conn->aid, 0);
5745         }
5746     }
5747 }
5748
5749 void ar6000_dtimexpiry_event(AR_SOFTC_T *ar)
5750 {
5751     A_BOOL isMcastQueued = FALSE;
5752     struct sk_buff *skb = NULL;
5753
5754     /* If there are no associated STAs, ignore the DTIM expiry event.
5755      * There can be potential race conditions where the last associated
5756      * STA may disconnect & before the host could clear the 'Indicate DTIM'
5757      * request to the firmware, the firmware would have just indicated a DTIM
5758      * expiry event. The race is between 'clear DTIM expiry cmd' going
5759      * from the host to the firmware & the DTIM expiry event happening from
5760      * the firmware to the host.
5761      */
5762     if (ar->sta_list_index == 0) {
5763         return;
5764     }
5765
5766     A_MUTEX_LOCK(&ar->mcastpsqLock);
5767     isMcastQueued = A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq);
5768     A_MUTEX_UNLOCK(&ar->mcastpsqLock);
5769
5770     A_ASSERT(isMcastQueued == FALSE);
5771
5772     /* Flush the mcast psq to the target */
5773     /* Set the STA flag to DTIMExpired, so that the frame will go out */
5774     ar->DTIMExpired = TRUE;
5775
5776     A_MUTEX_LOCK(&ar->mcastpsqLock);
5777     while (!A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq)) {
5778         skb = A_NETBUF_DEQUEUE(&ar->mcastpsq);
5779         A_MUTEX_UNLOCK(&ar->mcastpsqLock);
5780
5781         ar6000_data_tx(skb, ar->arNetDev);
5782
5783         A_MUTEX_LOCK(&ar->mcastpsqLock);
5784     }
5785     A_MUTEX_UNLOCK(&ar->mcastpsqLock);
5786
5787     /* Reset the DTIMExpired flag back to 0 */
5788     ar->DTIMExpired = FALSE;
5789
5790     /* Clear the LSB of the BitMapCtl field of the TIM IE */
5791     wmi_set_pvb_cmd(ar->arWmi, MCAST_AID, 0);
5792 }
5793
5794 void
5795 read_rssi_compensation_param(AR_SOFTC_T *ar)
5796 {
5797     A_UINT8 *cust_data_ptr;
5798
5799 //#define RSSICOMPENSATION_PRINT
5800
5801 #ifdef RSSICOMPENSATION_PRINT
5802     A_INT16 i;
5803     cust_data_ptr = ar6000_get_cust_data_buffer(ar->arTargetType);
5804     for (i=0; i<16; i++) {
5805         A_PRINTF("cust_data_%d = %x \n", i, *(A_UINT8 *)cust_data_ptr);
5806         cust_data_ptr += 1;
5807     }
5808 #endif
5809
5810     cust_data_ptr = ar6000_get_cust_data_buffer(ar->arTargetType);
5811
5812     rssi_compensation_param.customerID = *(A_UINT16 *)cust_data_ptr & 0xffff;
5813     rssi_compensation_param.enable = *(A_UINT16 *)(cust_data_ptr+2) & 0xffff;
5814     rssi_compensation_param.bg_param_a = *(A_UINT16 *)(cust_data_ptr+4) & 0xffff;
5815     rssi_compensation_param.bg_param_b = *(A_UINT16 *)(cust_data_ptr+6) & 0xffff;
5816     rssi_compensation_param.a_param_a = *(A_UINT16 *)(cust_data_ptr+8) & 0xffff;
5817     rssi_compensation_param.a_param_b = *(A_UINT16 *)(cust_data_ptr+10) &0xffff;
5818     rssi_compensation_param.reserved = *(A_UINT32 *)(cust_data_ptr+12);
5819
5820 #ifdef RSSICOMPENSATION_PRINT
5821     A_PRINTF("customerID = 0x%x \n", rssi_compensation_param.customerID);
5822     A_PRINTF("enable = 0x%x \n", rssi_compensation_param.enable);
5823     A_PRINTF("bg_param_a = 0x%x and %d \n", rssi_compensation_param.bg_param_a, rssi_compensation_param.bg_param_a);
5824     A_PRINTF("bg_param_b = 0x%x and %d \n", rssi_compensation_param.bg_param_b, rssi_compensation_param.bg_param_b);
5825     A_PRINTF("a_param_a = 0x%x and %d \n", rssi_compensation_param.a_param_a, rssi_compensation_param.a_param_a);
5826     A_PRINTF("a_param_b = 0x%x and %d \n", rssi_compensation_param.a_param_b, rssi_compensation_param.a_param_b);
5827     A_PRINTF("Last 4 bytes = 0x%x \n", rssi_compensation_param.reserved);
5828 #endif
5829
5830     if (rssi_compensation_param.enable != 0x1) {
5831         rssi_compensation_param.enable = 0;
5832     }
5833
5834    return;
5835 }
5836
5837 A_INT32
5838 rssi_compensation_calc_tcmd(A_UINT32 freq, A_INT32 rssi, A_UINT32 totalPkt)
5839 {
5840
5841     if (freq > 5000)
5842     {
5843         if (rssi_compensation_param.enable)
5844         {
5845             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11a\n"));
5846             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation  = %d, totalPkt = %d\n", rssi,totalPkt));
5847             rssi = rssi * rssi_compensation_param.a_param_a + totalPkt * rssi_compensation_param.a_param_b;
5848             rssi = (rssi-50) /100;
5849             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi));
5850         }
5851     }
5852     else
5853     {
5854         if (rssi_compensation_param.enable)
5855         {
5856             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11bg\n"));
5857             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation  = %d, totalPkt = %d\n", rssi,totalPkt));
5858             rssi = rssi * rssi_compensation_param.bg_param_a + totalPkt * rssi_compensation_param.bg_param_b;
5859             rssi = (rssi-50) /100;
5860             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi));
5861         }
5862     }
5863
5864     return rssi;
5865 }
5866
5867 A_INT16
5868 rssi_compensation_calc(AR_SOFTC_T *ar, A_INT16 rssi)
5869 {
5870     if (ar->arBssChannel > 5000)
5871     {
5872         if (rssi_compensation_param.enable)
5873         {
5874             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11a\n"));
5875             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation  = %d\n", rssi));
5876             rssi = rssi * rssi_compensation_param.a_param_a + rssi_compensation_param.a_param_b;
5877             rssi = (rssi-50) /100;
5878             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi));
5879         }
5880     }
5881     else
5882     {
5883         if (rssi_compensation_param.enable)
5884         {
5885             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11bg\n"));
5886             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before compensation  = %d\n", rssi));
5887             rssi = rssi * rssi_compensation_param.bg_param_a + rssi_compensation_param.bg_param_b;
5888             rssi = (rssi-50) /100;
5889             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after compensation = %d\n", rssi));
5890         }
5891     }
5892
5893     return rssi;
5894 }
5895
5896 A_INT16
5897 rssi_compensation_reverse_calc(AR_SOFTC_T *ar, A_INT16 rssi, A_BOOL Above)
5898 {
5899     A_INT16 i;
5900
5901     if (ar->arBssChannel > 5000)
5902     {
5903         if (rssi_compensation_param.enable)
5904         {
5905             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11a\n"));
5906             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before rev compensation  = %d\n", rssi));
5907             rssi = rssi * 100;
5908             rssi = (rssi - rssi_compensation_param.a_param_b) / rssi_compensation_param.a_param_a;
5909             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after rev compensation = %d\n", rssi));
5910         }
5911     }
5912     else
5913     {
5914         if (rssi_compensation_param.enable)
5915         {
5916             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, (">>> 11bg\n"));
5917             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi before rev compensation  = %d\n", rssi));
5918
5919             if (Above) {
5920                 for (i=95; i>=0; i--) {
5921                     if (rssi <=  rssi_compensation_table[i]) {
5922                         rssi = 0 - i;
5923                         break;
5924                     }
5925                 }
5926             } else {
5927                 for (i=0; i<=95; i++) {
5928                     if (rssi >=  rssi_compensation_table[i]) {
5929                         rssi = 0 - i;
5930                         break;
5931                     }
5932                 }
5933             }
5934             AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("rssi after rev compensation = %d\n", rssi));
5935         }
5936     }
5937
5938     return rssi;
5939 }
5940
5941 #ifdef WAPI_ENABLE
5942 void ap_wapi_rekey_event(AR_SOFTC_T *ar, A_UINT8 type, A_UINT8 *mac)
5943 {
5944     union iwreq_data wrqu;
5945     A_CHAR buf[20];
5946
5947     A_MEMZERO(buf, sizeof(buf));
5948
5949     strcpy(buf, "WAPI_REKEY");
5950     buf[10] = type;
5951     A_MEMCPY(&buf[11], mac, ATH_MAC_LEN);
5952
5953     A_MEMZERO(&wrqu, sizeof(wrqu));
5954     wrqu.data.length = 10+1+ATH_MAC_LEN;
5955     wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
5956
5957     A_PRINTF("WAPI REKEY - %d - %02x:%02x\n", type, mac[4], mac[5]);
5958 }
5959 #endif
5960
5961 #ifdef USER_KEYS
5962 static A_STATUS
5963
5964 ar6000_reinstall_keys(AR_SOFTC_T *ar, A_UINT8 key_op_ctrl)
5965 {
5966     A_STATUS status = A_OK;
5967     struct ieee80211req_key *uik = &ar->user_saved_keys.ucast_ik;
5968     struct ieee80211req_key *bik = &ar->user_saved_keys.bcast_ik;
5969     CRYPTO_TYPE  keyType = ar->user_saved_keys.keyType;
5970
5971     if (IEEE80211_CIPHER_CCKM_KRK != uik->ik_type) {
5972         if (NONE_CRYPT == keyType) {
5973             goto _reinstall_keys_out;
5974         }
5975
5976         if (uik->ik_keylen) {
5977             status = wmi_addKey_cmd(ar->arWmi, uik->ik_keyix,
5978                     ar->user_saved_keys.keyType, PAIRWISE_USAGE,
5979                     uik->ik_keylen, (A_UINT8 *)&uik->ik_keyrsc,
5980                     uik->ik_keydata, key_op_ctrl, uik->ik_macaddr, SYNC_BEFORE_WMIFLAG);
5981         }
5982
5983     } else {
5984         status = wmi_add_krk_cmd(ar->arWmi, uik->ik_keydata);
5985     }
5986
5987     if (IEEE80211_CIPHER_CCKM_KRK != bik->ik_type) {
5988         if (NONE_CRYPT == keyType) {
5989             goto _reinstall_keys_out;
5990         }
5991
5992         if (bik->ik_keylen) {
5993             status = wmi_addKey_cmd(ar->arWmi, bik->ik_keyix,
5994                     ar->user_saved_keys.keyType, GROUP_USAGE,
5995                     bik->ik_keylen, (A_UINT8 *)&bik->ik_keyrsc,
5996                     bik->ik_keydata, key_op_ctrl, bik->ik_macaddr, NO_SYNC_WMIFLAG);
5997         }
5998     } else {
5999         status = wmi_add_krk_cmd(ar->arWmi, bik->ik_keydata);
6000     }
6001
6002 _reinstall_keys_out:
6003     ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT;
6004     ar->user_key_ctrl      = 0;
6005
6006     return status;
6007 }
6008 #endif /* USER_KEYS */
6009
6010
6011 void
6012 ar6000_dset_open_req(
6013     void *context,
6014     A_UINT32 id,
6015     A_UINT32 targHandle,
6016     A_UINT32 targReplyFn,
6017     A_UINT32 targReplyArg)
6018 {
6019 }
6020
6021 void
6022 ar6000_dset_close(
6023     void *context,
6024     A_UINT32 access_cookie)
6025 {
6026     return;
6027 }
6028
6029 void
6030 ar6000_dset_data_req(
6031    void *context,
6032    A_UINT32 accessCookie,
6033    A_UINT32 offset,
6034    A_UINT32 length,
6035    A_UINT32 targBuf,
6036    A_UINT32 targReplyFn,
6037    A_UINT32 targReplyArg)
6038 {
6039 }
6040
6041 int
6042 ar6000_ap_mode_profile_commit(struct ar6_softc *ar)
6043 {
6044     WMI_CONNECT_CMD p;
6045     unsigned long  flags;
6046
6047     /* No change in AP's profile configuration */
6048     if(ar->ap_profile_flag==0) {
6049         A_PRINTF("COMMIT: No change in profile!!!\n");
6050         return -ENODATA;
6051     }
6052
6053     if(!ar->arSsidLen) {
6054         A_PRINTF("SSID not set!!!\n");
6055         return -ECHRNG;
6056     }
6057
6058     switch(ar->arAuthMode) {
6059     case NONE_AUTH:
6060         if((ar->arPairwiseCrypto != NONE_CRYPT) &&
6061 #ifdef WAPI_ENABLE
6062            (ar->arPairwiseCrypto != WAPI_CRYPT) &&
6063 #endif
6064            (ar->arPairwiseCrypto != WEP_CRYPT)) {
6065             A_PRINTF("Cipher not supported in AP mode Open auth\n");
6066             return -EOPNOTSUPP;
6067         }
6068         break;
6069     case WPA_PSK_AUTH:
6070     case WPA2_PSK_AUTH:
6071     case (WPA_PSK_AUTH|WPA2_PSK_AUTH):
6072         break;
6073     default:
6074         A_PRINTF("This key mgmt type not supported in AP mode\n");
6075         return -EOPNOTSUPP;
6076     }
6077
6078     /* Update the arNetworkType */
6079     ar->arNetworkType = ar->arNextMode;
6080
6081     A_MEMZERO(&p,sizeof(p));
6082     p.ssidLength = ar->arSsidLen;
6083     A_MEMCPY(p.ssid,ar->arSsid,p.ssidLength);
6084     p.channel = ar->arChannelHint;
6085     p.networkType = ar->arNetworkType;
6086
6087     p.dot11AuthMode = ar->arDot11AuthMode;
6088     p.authMode = ar->arAuthMode;
6089     p.pairwiseCryptoType = ar->arPairwiseCrypto;
6090     p.pairwiseCryptoLen = ar->arPairwiseCryptoLen;
6091     p.groupCryptoType = ar->arGroupCrypto;
6092     p.groupCryptoLen = ar->arGroupCryptoLen;
6093     p.ctrl_flags = ar->arConnectCtrlFlags;
6094
6095     ar->arConnected = FALSE;
6096
6097     wmi_ap_profile_commit(ar->arWmi, &p);
6098     spin_lock_irqsave(&ar->arLock, flags);
6099     ar->arConnected  = TRUE;
6100     netif_carrier_on(ar->arNetDev);
6101     spin_unlock_irqrestore(&ar->arLock, flags);
6102     ar->ap_profile_flag = 0;
6103     return 0;
6104 }
6105
6106 A_STATUS
6107 ar6000_connect_to_ap(struct ar6_softc *ar)
6108 {
6109     /* The ssid length check prevents second "essid off" from the user,
6110        to be treated as a connect cmd. The second "essid off" is ignored.
6111     */
6112     if((ar->arWmiReady == TRUE) && (ar->arSsidLen > 0) && ar->arNetworkType!=AP_NETWORK)
6113     {
6114         A_STATUS status;
6115         if((ADHOC_NETWORK != ar->arNetworkType) &&
6116            (NONE_AUTH==ar->arAuthMode)          &&
6117            (WEP_CRYPT==ar->arPairwiseCrypto)) {
6118                 ar6000_install_static_wep_keys(ar);
6119         }
6120
6121         if (!ar->arUserBssFilter) {
6122             if (wmi_bssfilter_cmd(ar->arWmi, ALL_BSS_FILTER, 0) != A_OK) {
6123                 return -EIO;
6124             }
6125         }
6126 #ifdef WAPI_ENABLE
6127         if (ar->arWapiEnable)  {
6128             ar->arPairwiseCrypto = WAPI_CRYPT;
6129             ar->arPairwiseCryptoLen = 0;
6130             ar->arGroupCrypto = WAPI_CRYPT;
6131             ar->arGroupCryptoLen = 0;
6132             ar->arAuthMode = NONE_AUTH;
6133             ar->arConnectCtrlFlags |= CONNECT_IGNORE_WPAx_GROUP_CIPHER;
6134         }
6135 #endif
6136         AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("Connect called with authmode %d dot11 auth %d"\
6137                         " PW crypto %d PW crypto Len %d GRP crypto %d"\
6138                         " GRP crypto Len %d\n",
6139                         ar->arAuthMode, ar->arDot11AuthMode,
6140                         ar->arPairwiseCrypto, ar->arPairwiseCryptoLen,
6141                         ar->arGroupCrypto, ar->arGroupCryptoLen));
6142         reconnect_flag = 0;
6143         /* Set the listen interval into 1000TUs or more. This value will be indicated to Ap in the conn.
6144            later set it back locally at the STA to 100/1000 TUs depending on the power mode */
6145         if ((ar->arNetworkType == INFRA_NETWORK)) {
6146             wmi_listeninterval_cmd(ar->arWmi, max(ar->arListenIntervalT, (A_UINT16)A_MAX_WOW_LISTEN_INTERVAL), 0);
6147         }
6148         status = wmi_connect_cmd(ar->arWmi, ar->arNetworkType,
6149                                  ar->arDot11AuthMode, ar->arAuthMode,
6150                                  ar->arPairwiseCrypto, ar->arPairwiseCryptoLen,
6151                                  ar->arGroupCrypto,ar->arGroupCryptoLen,
6152                                  ar->arSsidLen, ar->arSsid,
6153                                  ar->arReqBssid, ar->arChannelHint,
6154                                  ar->arConnectCtrlFlags);
6155         if (status != A_OK) {
6156             wmi_listeninterval_cmd(ar->arWmi, ar->arListenIntervalT, ar->arListenIntervalB);
6157             if (!ar->arUserBssFilter) {
6158                 wmi_bssfilter_cmd(ar->arWmi, NONE_BSS_FILTER, 0);
6159             }
6160             return status;
6161         }
6162
6163         if ((!(ar->arConnectCtrlFlags & CONNECT_DO_WPA_OFFLOAD)) &&
6164             ((WPA_PSK_AUTH == ar->arAuthMode) || (WPA2_PSK_AUTH == ar->arAuthMode)))
6165         {
6166             A_TIMEOUT_MS(&ar->disconnect_timer, A_DISCONNECT_TIMER_INTERVAL, 0);
6167         }
6168
6169         ar->arConnectCtrlFlags &= ~CONNECT_DO_WPA_OFFLOAD;
6170
6171         ar->arConnectPending = TRUE;
6172         return status;
6173     }
6174     return A_ERROR;
6175 }
6176
6177 A_STATUS
6178 ar6000_ap_mode_get_wpa_ie(struct ar6_softc *ar, struct ieee80211req_wpaie *wpaie)
6179 {
6180     sta_t *conn = NULL;
6181     conn = ieee80211_find_conn(ar, wpaie->wpa_macaddr);
6182
6183     A_MEMZERO(wpaie->wpa_ie, IEEE80211_MAX_IE);
6184     A_MEMZERO(wpaie->rsn_ie, IEEE80211_MAX_IE);
6185
6186     if(conn) {
6187         A_MEMCPY(wpaie->wpa_ie, conn->wpa_ie, IEEE80211_MAX_IE);
6188     }
6189
6190     return 0;
6191 }
6192
6193 A_STATUS
6194 is_iwioctl_allowed(A_UINT8 mode, A_UINT16 cmd)
6195 {
6196     if(cmd >= SIOCSIWCOMMIT && cmd <= SIOCGIWPOWER) {
6197         cmd -= SIOCSIWCOMMIT;
6198         if(sioctl_filter[cmd] == 0xFF) return A_OK;
6199         if(sioctl_filter[cmd] & mode) return A_OK;
6200     } else if(cmd >= SIOCIWFIRSTPRIV && cmd <= (SIOCIWFIRSTPRIV+30)) {
6201         cmd -= SIOCIWFIRSTPRIV;
6202         if(pioctl_filter[cmd] == 0xFF) return A_OK;
6203         if(pioctl_filter[cmd] & mode) return A_OK;
6204     } else {
6205         return A_ERROR;
6206     }
6207     return A_ENOTSUP;
6208 }
6209
6210 A_STATUS
6211 is_xioctl_allowed(A_UINT8 mode, int cmd)
6212 {
6213     if(sizeof(xioctl_filter)-1 < cmd) {
6214         A_PRINTF("Filter for this cmd=%d not defined\n",cmd);
6215         return 0;
6216     }
6217     if(xioctl_filter[cmd] == 0xFF) return A_OK;
6218     if(xioctl_filter[cmd] & mode) return A_OK;
6219     return A_ERROR;
6220 }
6221
6222 #ifdef WAPI_ENABLE
6223 int
6224 ap_set_wapi_key(struct ar6_softc *ar, void *ikey)
6225 {
6226     struct ieee80211req_key *ik = (struct ieee80211req_key *)ikey;
6227     KEY_USAGE   keyUsage = 0;
6228     A_STATUS    status;
6229
6230     if (A_MEMCMP(ik->ik_macaddr, bcast_mac, IEEE80211_ADDR_LEN) == 0) {
6231         keyUsage = GROUP_USAGE;
6232     } else {
6233         keyUsage = PAIRWISE_USAGE;
6234     }
6235     A_PRINTF("WAPI_KEY: Type:%d ix:%d mac:%02x:%02x len:%d\n",
6236         keyUsage, ik->ik_keyix, ik->ik_macaddr[4], ik->ik_macaddr[5],
6237         ik->ik_keylen);
6238
6239     status = wmi_addKey_cmd(ar->arWmi, ik->ik_keyix, WAPI_CRYPT, keyUsage,
6240                             ik->ik_keylen, (A_UINT8 *)&ik->ik_keyrsc,
6241                             ik->ik_keydata, KEY_OP_INIT_VAL, ik->ik_macaddr,
6242                             SYNC_BOTH_WMIFLAG);
6243
6244     if (A_OK != status) {
6245         return -EIO;
6246     }
6247     return 0;
6248 }
6249 #endif
6250
6251 void ar6000_peer_event(
6252     void *context,
6253     A_UINT8 eventCode,
6254     A_UINT8 *macAddr)
6255 {
6256     A_UINT8 pos;
6257
6258     for (pos=0;pos<6;pos++)
6259         printk("%02x: ",*(macAddr+pos));
6260     printk("\n");
6261 }
6262
6263 #ifdef HTC_TEST_SEND_PKTS
6264 #define HTC_TEST_DUPLICATE 8
6265 static void DoHTCSendPktsTest(AR_SOFTC_T *ar, int MapNo, HTC_ENDPOINT_ID eid, struct sk_buff *dupskb)
6266 {
6267     struct ar_cookie *cookie;
6268     struct ar_cookie *cookieArray[HTC_TEST_DUPLICATE];
6269     struct sk_buff   *new_skb;
6270     int    i;
6271     int    pkts = 0;
6272     HTC_PACKET_QUEUE pktQueue;
6273     EPPING_HEADER    *eppingHdr;
6274
6275     eppingHdr = A_NETBUF_DATA(dupskb);
6276
6277     if (eppingHdr->Cmd_h == EPPING_CMD_NO_ECHO) {
6278         /* skip test if this is already a tx perf test */
6279         return;
6280     }
6281
6282     for (i = 0; i < HTC_TEST_DUPLICATE; i++,pkts++) {
6283         AR6000_SPIN_LOCK(&ar->arLock, 0);
6284         cookie = ar6000_alloc_cookie(ar);
6285         if (cookie != NULL) {
6286             ar->arTxPending[eid]++;
6287             ar->arTotalTxDataPending++;
6288         }
6289
6290         AR6000_SPIN_UNLOCK(&ar->arLock, 0);
6291
6292         if (NULL == cookie) {
6293             break;
6294         }
6295
6296         new_skb = A_NETBUF_ALLOC(A_NETBUF_LEN(dupskb));
6297
6298         if (new_skb == NULL) {
6299             AR6000_SPIN_LOCK(&ar->arLock, 0);
6300             ar6000_free_cookie(ar,cookie);
6301             AR6000_SPIN_UNLOCK(&ar->arLock, 0);
6302             break;
6303         }
6304
6305         A_NETBUF_PUT_DATA(new_skb, A_NETBUF_DATA(dupskb), A_NETBUF_LEN(dupskb));
6306         cookie->arc_bp[0] = (unsigned long)new_skb;
6307         cookie->arc_bp[1] = MapNo;
6308         SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
6309                                cookie,
6310                                A_NETBUF_DATA(new_skb),
6311                                A_NETBUF_LEN(new_skb),
6312                                eid,
6313                                AR6K_DATA_PKT_TAG);
6314
6315         cookieArray[i] = cookie;
6316
6317         {
6318             EPPING_HEADER *pHdr = (EPPING_HEADER *)A_NETBUF_DATA(new_skb);
6319             pHdr->Cmd_h = EPPING_CMD_NO_ECHO;  /* do not echo the packet */
6320         }
6321     }
6322
6323     if (pkts == 0) {
6324         return;
6325     }
6326
6327     INIT_HTC_PACKET_QUEUE(&pktQueue);
6328
6329     for (i = 0; i < pkts; i++) {
6330         HTC_PACKET_ENQUEUE(&pktQueue,&cookieArray[i]->HtcPkt);
6331     }
6332
6333     HTCSendPktsMultiple(ar->arHtcTarget, &pktQueue);
6334
6335 }
6336 #endif
6337
6338 #ifdef CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT
6339 /*
6340  * Add support for adding and removing a virtual adapter for soft AP.
6341  * Some OS requires different adapters names for station and soft AP mode.
6342  * To support these requirement, create and destory a netdevice  instance
6343  * when the AP mode is operational. A full fledged support for virual device
6344  * is not implemented. Rather a virtual interface is created and is linked
6345  * with the existing physical device instance during the operation of the
6346  * AP mode.
6347  */
6348
6349 A_STATUS ar6000_start_ap_interface(AR_SOFTC_T *ar)
6350 {
6351     AR_VIRTUAL_INTERFACE_T *arApDev;
6352
6353     /* Change net_device to point to AP instance */
6354     arApDev = (AR_VIRTUAL_INTERFACE_T *)ar->arApDev;
6355     ar->arNetDev = arApDev->arNetDev;
6356
6357     return A_OK;
6358 }
6359
6360 A_STATUS ar6000_stop_ap_interface(AR_SOFTC_T *ar)
6361 {
6362     AR_VIRTUAL_INTERFACE_T *arApDev;
6363
6364     /* Change net_device to point to sta instance */
6365     arApDev = (AR_VIRTUAL_INTERFACE_T *)ar->arApDev;
6366     if (arApDev) {
6367         ar->arNetDev = arApDev->arStaNetDev;
6368     }
6369
6370     return A_OK;
6371 }
6372
6373
6374 A_STATUS ar6000_create_ap_interface(AR_SOFTC_T *ar, char *ap_ifname)
6375 {
6376     struct net_device *dev;
6377     AR_VIRTUAL_INTERFACE_T *arApDev;
6378
6379     dev = alloc_etherdev(sizeof(AR_VIRTUAL_INTERFACE_T));
6380     if (dev == NULL) {
6381         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_create_ap_interface: can't alloc etherdev\n"));
6382         return A_ERROR;
6383     }
6384
6385     ether_setup(dev);
6386     init_netdev(dev, ap_ifname);
6387
6388     if (register_netdev(dev)) {
6389         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_create_ap_interface: register_netdev failed\n"));
6390         return A_ERROR;
6391     }
6392
6393     arApDev = netdev_priv(dev);
6394     arApDev->arDev = ar;
6395     arApDev->arNetDev = dev;
6396     arApDev->arStaNetDev = ar->arNetDev;
6397
6398     ar->arApDev = arApDev;
6399     arApNetDev = dev;
6400
6401     /* Copy the MAC address */
6402     A_MEMCPY(dev->dev_addr, ar->arNetDev->dev_addr, AR6000_ETH_ADDR_LEN);
6403
6404     return A_OK;
6405 }
6406
6407 A_STATUS ar6000_add_ap_interface(AR_SOFTC_T *ar, char *ap_ifname)
6408 {
6409     /* Interface already added, need not proceed further */
6410     if (ar->arApDev != NULL) {
6411         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("ar6000_add_ap_interface: interface already present \n"));
6412         return A_OK;
6413     }
6414
6415     if (ar6000_create_ap_interface(ar, ap_ifname) != A_OK) {
6416         return A_ERROR;
6417     }
6418
6419     A_PRINTF("Add AP interface %s \n",ap_ifname);
6420
6421     return ar6000_start_ap_interface(ar);
6422 }
6423
6424 A_STATUS ar6000_remove_ap_interface(AR_SOFTC_T *ar)
6425 {
6426     if (arApNetDev) {
6427         ar6000_stop_ap_interface(ar);
6428
6429         unregister_netdev(arApNetDev);
6430 #ifndef free_netdev
6431         kfree(arApNetDev);
6432 #else
6433         free_netdev(apApNetDev);
6434 #endif
6435
6436         A_PRINTF("Remove AP interface\n");
6437     }
6438     ar->arApDev = NULL;
6439     arApNetDev = NULL;
6440
6441
6442     return A_OK;
6443 }
6444 #endif /* CONFIG_AP_VIRTUAL_ADAPTER_SUPPORT */
6445
6446
6447 #ifdef EXPORT_HCI_BRIDGE_INTERFACE
6448 EXPORT_SYMBOL(setupbtdev);
6449 #endif