projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[s3c24xx] bump to 2.6.30-rc6
[openwrt/svn-archive/archive.git] / target / linux / s3c24xx / files-2.6.30 / drivers / ar6000 / ar6000 / ar6000_drv.c
1 /*
2 *
3 * Copyright (c) 2004-2007 Atheros Communications Inc.
4 * All rights reserved.
5 *
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation;
10 *
11 * Software distributed under the License is distributed on an "AS
12 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
13 * implied. See the License for the specific language governing
14 * rights and limitations under the License.
15 *
16 *
17 *
18 */
19
20 /*
21 * This driver is a pseudo ethernet driver to access the Atheros AR6000
22 * WLAN Device
23 */
24 static const char athId[] __attribute__ ((unused)) = "$Id: //depot/sw/releases/olca2.0-GPL/host/os/linux/ar6000_drv.c#2 $";
25
26 #include "ar6000_drv.h"
27 #include "htc.h"
28
29 MODULE_LICENSE("GPL and additional rights");
30
31 #ifndef REORG_APTC_HEURISTICS
32 #undef ADAPTIVE_POWER_THROUGHPUT_CONTROL
33 #endif /* REORG_APTC_HEURISTICS */
34
35 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
36 #define APTC_TRAFFIC_SAMPLING_INTERVAL 100 /* msec */
37 #define APTC_UPPER_THROUGHPUT_THRESHOLD 3000 /* Kbps */
38 #define APTC_LOWER_THROUGHPUT_THRESHOLD 2000 /* Kbps */
39
40 typedef struct aptc_traffic_record {
41 A_BOOL timerScheduled;
42 struct timeval samplingTS;
43 unsigned long bytesReceived;
44 unsigned long bytesTransmitted;
45 } APTC_TRAFFIC_RECORD;
46
47 A_TIMER aptcTimer;
48 APTC_TRAFFIC_RECORD aptcTR;
49 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
50
51 int bmienable = 0;
52 unsigned int bypasswmi = 0;
53 unsigned int debuglevel = 0;
54 int tspecCompliance = 1;
55 unsigned int busspeedlow = 0;
56 unsigned int onebitmode = 0;
57 unsigned int skipflash = 0;
58 unsigned int wmitimeout = 2;
59 unsigned int wlanNodeCaching = 1;
60 unsigned int enableuartprint = 0;
61 unsigned int logWmiRawMsgs = 0;
62 unsigned int enabletimerwar = 0;
63 unsigned int mbox_yield_limit = 99;
64 int reduce_credit_dribble = 1 + HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_ONE_HALF;
65 int allow_trace_signal = 0;
66 #ifdef CONFIG_HOST_TCMD_SUPPORT
67 unsigned int testmode =0;
68 #endif
69
70 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
71 module_param(bmienable, int, 0644);
72 module_param(bypasswmi, int, 0644);
73 module_param(debuglevel, int, 0644);
74 module_param(tspecCompliance, int, 0644);
75 module_param(onebitmode, int, 0644);
76 module_param(busspeedlow, int, 0644);
77 module_param(skipflash, int, 0644);
78 module_param(wmitimeout, int, 0644);
79 module_param(wlanNodeCaching, int, 0644);
80 module_param(logWmiRawMsgs, int, 0644);
81 module_param(enableuartprint, int, 0644);
82 module_param(enabletimerwar, int, 0644);
83 module_param(mbox_yield_limit, int, 0644);
84 module_param(reduce_credit_dribble, int, 0644);
85 module_param(allow_trace_signal, int, 0644);
86 #ifdef CONFIG_HOST_TCMD_SUPPORT
87 module_param(testmode, int, 0644);
88 #endif
89 #else
90
91 #define __user
92 /* for linux 2.4 and lower */
93 MODULE_PARM(bmienable,"i");
94 MODULE_PARM(bypasswmi,"i");
95 MODULE_PARM(debuglevel, "i");
96 MODULE_PARM(onebitmode,"i");
97 MODULE_PARM(busspeedlow, "i");
98 MODULE_PARM(skipflash, "i");
99 MODULE_PARM(wmitimeout, "i");
100 MODULE_PARM(wlanNodeCaching, "i");
101 MODULE_PARM(enableuartprint,"i");
102 MODULE_PARM(logWmiRawMsgs, "i");
103 MODULE_PARM(enabletimerwar,"i");
104 MODULE_PARM(mbox_yield_limit,"i");
105 MODULE_PARM(reduce_credit_dribble,"i");
106 MODULE_PARM(allow_trace_signal,"i");
107 #ifdef CONFIG_HOST_TCMD_SUPPORT
108 MODULE_PARM(testmode, "i");
109 #endif
110 #endif
111
112 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
113 /* in 2.6.10 and later this is now a pointer to a uint */
114 unsigned int _mboxnum = HTC_MAILBOX_NUM_MAX;
115 #define mboxnum &_mboxnum
116 #else
117 unsigned int mboxnum = HTC_MAILBOX_NUM_MAX;
118 #endif
119
120 #ifdef CONFIG_AR6000_WLAN_RESET
121 unsigned int resetok = 1;
122 #else
123 unsigned int resetok = 0;
124 #endif
125
126 #ifdef DEBUG
127 A_UINT32 g_dbg_flags = DBG_DEFAULTS;
128 unsigned int debugflags = 0;
129 int debugdriver = 1;
130 unsigned int debughtc = 128;
131 unsigned int debugbmi = 1;
132 unsigned int debughif = 2;
133 unsigned int txcreditsavailable[HTC_MAILBOX_NUM_MAX] = {0};
134 unsigned int txcreditsconsumed[HTC_MAILBOX_NUM_MAX] = {0};
135 unsigned int txcreditintrenable[HTC_MAILBOX_NUM_MAX] = {0};
136 unsigned int txcreditintrenableaggregate[HTC_MAILBOX_NUM_MAX] = {0};
137
138 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
139 module_param(debugflags, int, 0644);
140 module_param(debugdriver, int, 0644);
141 module_param(debughtc, int, 0644);
142 module_param(debugbmi, int, 0644);
143 module_param(debughif, int, 0644);
144 module_param(resetok, int, 0644);
145 module_param_array(txcreditsavailable, int, mboxnum, 0644);
146 module_param_array(txcreditsconsumed, int, mboxnum, 0644);
147 module_param_array(txcreditintrenable, int, mboxnum, 0644);
148 module_param_array(txcreditintrenableaggregate, int, mboxnum, 0644);
149 #else
150 /* linux 2.4 and lower */
151 MODULE_PARM(debugflags,"i");
152 MODULE_PARM(debugdriver, "i");
153 MODULE_PARM(debughtc, "i");
154 MODULE_PARM(debugbmi, "i");
155 MODULE_PARM(debughif, "i");
156 MODULE_PARM(resetok, "i");
157 MODULE_PARM(txcreditsavailable, "0-3i");
158 MODULE_PARM(txcreditsconsumed, "0-3i");
159 MODULE_PARM(txcreditintrenable, "0-3i");
160 MODULE_PARM(txcreditintrenableaggregate, "0-3i");
161 #endif
162
163 #endif /* DEBUG */
164
165 unsigned int tx_attempt[HTC_MAILBOX_NUM_MAX] = {0};
166 unsigned int tx_post[HTC_MAILBOX_NUM_MAX] = {0};
167 unsigned int tx_complete[HTC_MAILBOX_NUM_MAX] = {0};
168 unsigned int hifBusRequestNumMax = 40;
169 unsigned int war23838_disabled = 0;
170 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
171 unsigned int enableAPTCHeuristics = 1;
172 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
173 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
174 module_param_array(tx_attempt, int, mboxnum, 0644);
175 module_param_array(tx_post, int, mboxnum, 0644);
176 module_param_array(tx_complete, int, mboxnum, 0644);
177 module_param(hifBusRequestNumMax, int, 0644);
178 module_param(war23838_disabled, int, 0644);
179 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
180 module_param(enableAPTCHeuristics, int, 0644);
181 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
182 #else
183 MODULE_PARM(tx_attempt, "0-3i");
184 MODULE_PARM(tx_post, "0-3i");
185 MODULE_PARM(tx_complete, "0-3i");
186 MODULE_PARM(hifBusRequestNumMax, "i");
187 MODULE_PARM(war23838_disabled, "i");
188 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
189 MODULE_PARM(enableAPTCHeuristics, "i");
190 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
191 #endif
192
193 #ifdef BLOCK_TX_PATH_FLAG
194 int blocktx = 0;
195 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
196 module_param(blocktx, int, 0644);
197 #else
198 MODULE_PARM(blocktx, "i");
199 #endif
200 #endif /* BLOCK_TX_PATH_FLAG */
201
202 // TODO move to arsoft_c
203 USER_RSSI_THOLD rssi_map[12];
204
205 int reconnect_flag = 0;
206
207 DECLARE_WAIT_QUEUE_HEAD(ar6000_scan_queue);
208
209 /* Function declarations */
210 static int ar6000_init_module(void);
211 static void ar6000_cleanup_module(void);
212
213 int ar6000_init(struct net_device *dev);
214 static int ar6000_open(struct net_device *dev);
215 static int ar6000_close(struct net_device *dev);
216 static void ar6000_init_control_info(AR_SOFTC_T *ar);
217 static int ar6000_data_tx(struct sk_buff *skb, struct net_device *dev);
218
219 static void ar6000_destroy(struct net_device *dev, unsigned int unregister);
220 static void ar6000_detect_error(unsigned long ptr);
221 static struct net_device_stats *ar6000_get_stats(struct net_device *dev);
222 static struct iw_statistics *ar6000_get_iwstats(struct net_device * dev);
223
224 /*
225 * HTC service connection handlers
226 */
227 static void ar6000_avail_ev(HTC_HANDLE HTCHandle);
228
229 static void ar6000_unavail_ev(void *Instance);
230
231 static void ar6000_target_failure(void *Instance, A_STATUS Status);
232
233 static void ar6000_rx(void *Context, HTC_PACKET *pPacket);
234
235 static void ar6000_rx_refill(void *Context,HTC_ENDPOINT_ID Endpoint);
236
237 static void ar6000_tx_complete(void *Context, HTC_PACKET *pPacket);
238
239 static void ar6000_tx_queue_full(void *Context, HTC_ENDPOINT_ID Endpoint);
240
241 static void ar6000_tx_queue_avail(void *Context, HTC_ENDPOINT_ID Endpoint);
242
243 /*
244 * Static variables
245 */
246
247 static struct net_device *ar6000_devices[MAX_AR6000];
248 extern struct iw_handler_def ath_iw_handler_def;
249 DECLARE_WAIT_QUEUE_HEAD(arEvent);
250 static void ar6000_cookie_init(AR_SOFTC_T *ar);
251 static void ar6000_cookie_cleanup(AR_SOFTC_T *ar);
252 static void ar6000_free_cookie(AR_SOFTC_T *ar, struct ar_cookie * cookie);
253 static struct ar_cookie *ar6000_alloc_cookie(AR_SOFTC_T *ar);
254 static void ar6000_TxDataCleanup(AR_SOFTC_T *ar);
255
256 #ifdef USER_KEYS
257 static A_STATUS ar6000_reinstall_keys(AR_SOFTC_T *ar,A_UINT8 key_op_ctrl);
258 #endif
259
260
261 static struct ar_cookie s_ar_cookie_mem[MAX_COOKIE_NUM];
262
263 #define HOST_INTEREST_ITEM_ADDRESS(ar, item) \
264 ((ar->arTargetType == TARGET_TYPE_AR6001) ? \
265 AR6001_HOST_INTEREST_ITEM_ADDRESS(item) : \
266 AR6002_HOST_INTEREST_ITEM_ADDRESS(item))
267
268
269 /* Debug log support */
270
271 /*
272 * Flag to govern whether the debug logs should be parsed in the kernel
273 * or reported to the application.
274 */
275 #ifdef DEBUG
276 #define REPORT_DEBUG_LOGS_TO_APP
277 #endif
278
279 A_STATUS
280 ar6000_set_host_app_area(AR_SOFTC_T *ar)
281 {
282 A_UINT32 address, data;
283 struct host_app_area_s host_app_area;
284
285 /* Fetch the address of the host_app_area_s instance in the host interest area */
286 address = HOST_INTEREST_ITEM_ADDRESS(ar, hi_app_host_interest);
287 if (ar6000_ReadRegDiag(ar->arHifDevice, &address, &data) != A_OK) {
288 return A_ERROR;
289 }
290 address = data;
291 host_app_area.wmi_protocol_ver = WMI_PROTOCOL_VERSION;
292 if (ar6000_WriteDataDiag(ar->arHifDevice, address,
293 (A_UCHAR *)&host_app_area,
294 sizeof(struct host_app_area_s)) != A_OK)
295 {
296 return A_ERROR;
297 }
298
299 return A_OK;
300 }
301
302 A_UINT32
303 dbglog_get_debug_hdr_ptr(AR_SOFTC_T *ar)
304 {
305 A_UINT32 param;
306 A_UINT32 address;
307 A_STATUS status;
308
309 address = HOST_INTEREST_ITEM_ADDRESS(ar, hi_dbglog_hdr);
310 if ((status = ar6000_ReadDataDiag(ar->arHifDevice, address,
311 (A_UCHAR *)&param, 4)) != A_OK)
312 {
313 param = 0;
314 }
315
316 return param;
317 }
318
319 /*
320 * The dbglog module has been initialized. Its ok to access the relevant
321 * data stuctures over the diagnostic window.
322 */
323 void
324 ar6000_dbglog_init_done(AR_SOFTC_T *ar)
325 {
326 ar->dbglog_init_done = TRUE;
327 }
328
329 A_UINT32
330 dbglog_get_debug_fragment(A_INT8 *datap, A_UINT32 len, A_UINT32 limit)
331 {
332 A_INT32 *buffer;
333 A_UINT32 count;
334 A_UINT32 numargs;
335 A_UINT32 length;
336 A_UINT32 fraglen;
337
338 count = fraglen = 0;
339 buffer = (A_INT32 *)datap;
340 length = (limit >> 2);
341
342 if (len <= limit) {
343 fraglen = len;
344 } else {
345 while (count < length) {
346 numargs = DBGLOG_GET_NUMARGS(buffer[count]);
347 fraglen = (count << 2);
348 count += numargs + 1;
349 }
350 }
351
352 return fraglen;
353 }
354
355 void
356 dbglog_parse_debug_logs(A_INT8 *datap, A_UINT32 len)
357 {
358 A_INT32 *buffer;
359 A_UINT32 count;
360 A_UINT32 timestamp;
361 A_UINT32 debugid;
362 A_UINT32 moduleid;
363 A_UINT32 numargs;
364 A_UINT32 length;
365
366 count = 0;
367 buffer = (A_INT32 *)datap;
368 length = (len >> 2);
369 while (count < length) {
370 debugid = DBGLOG_GET_DBGID(buffer[count]);
371 moduleid = DBGLOG_GET_MODULEID(buffer[count]);
372 numargs = DBGLOG_GET_NUMARGS(buffer[count]);
373 timestamp = DBGLOG_GET_TIMESTAMP(buffer[count]);
374 switch (numargs) {
375 case 0:
376 AR_DEBUG_PRINTF("%d %d (%d)\n", moduleid, debugid, timestamp);
377 break;
378
379 case 1:
380 AR_DEBUG_PRINTF("%d %d (%d): 0x%x\n", moduleid, debugid,
381 timestamp, buffer[count+1]);
382 break;
383
384 case 2:
385 AR_DEBUG_PRINTF("%d %d (%d): 0x%x, 0x%x\n", moduleid, debugid,
386 timestamp, buffer[count+1], buffer[count+2]);
387 break;
388
389 default:
390 AR_DEBUG_PRINTF("Invalid args: %d\n", numargs);
391 }
392 count += numargs + 1;
393 }
394 }
395
396 int
397 ar6000_dbglog_get_debug_logs(AR_SOFTC_T *ar)
398 {
399 struct dbglog_hdr_s debug_hdr;
400 struct dbglog_buf_s debug_buf;
401 A_UINT32 address;
402 A_UINT32 length;
403 A_UINT32 dropped;
404 A_UINT32 firstbuf;
405 A_UINT32 debug_hdr_ptr;
406
407 if (!ar->dbglog_init_done) return A_ERROR;
408
409 #ifndef CONFIG_AR6000_WLAN_DEBUG
410 return 0;
411 #endif
412
413 AR6000_SPIN_LOCK(&ar->arLock, 0);
414
415 if (ar->dbgLogFetchInProgress) {
416 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
417 return A_EBUSY;
418 }
419
420 /* block out others */
421 ar->dbgLogFetchInProgress = TRUE;
422
423 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
424
425 debug_hdr_ptr = dbglog_get_debug_hdr_ptr(ar);
426 printk("debug_hdr_ptr: 0x%x\n", debug_hdr_ptr);
427
428 /* Get the contents of the ring buffer */
429 if (debug_hdr_ptr) {
430 address = debug_hdr_ptr;
431 length = sizeof(struct dbglog_hdr_s);
432 ar6000_ReadDataDiag(ar->arHifDevice, address,
433 (A_UCHAR *)&debug_hdr, length);
434 address = (A_UINT32)debug_hdr.dbuf;
435 firstbuf = address;
436 dropped = debug_hdr.dropped;
437 length = sizeof(struct dbglog_buf_s);
438 ar6000_ReadDataDiag(ar->arHifDevice, address,
439 (A_UCHAR *)&debug_buf, length);
440
441 do {
442 address = (A_UINT32)debug_buf.buffer;
443 length = debug_buf.length;
444 if ((length) && (debug_buf.length <= debug_buf.bufsize)) {
445 /* Rewind the index if it is about to overrun the buffer */
446 if (ar->log_cnt > (DBGLOG_HOST_LOG_BUFFER_SIZE - length)) {
447 ar->log_cnt = 0;
448 }
449 if(A_OK != ar6000_ReadDataDiag(ar->arHifDevice, address,
450 (A_UCHAR *)&ar->log_buffer[ar->log_cnt], length))
451 {
452 break;
453 }
454 ar6000_dbglog_event(ar, dropped, &ar->log_buffer[ar->log_cnt], length);
455 ar->log_cnt += length;
456 } else {
457 AR_DEBUG_PRINTF("Length: %d (Total size: %d)\n",
458 debug_buf.length, debug_buf.bufsize);
459 }
460
461 address = (A_UINT32)debug_buf.next;
462 length = sizeof(struct dbglog_buf_s);
463 if(A_OK != ar6000_ReadDataDiag(ar->arHifDevice, address,
464 (A_UCHAR *)&debug_buf, length))
465 {
466 break;
467 }
468
469 } while (address != firstbuf);
470 }
471
472 ar->dbgLogFetchInProgress = FALSE;
473
474 return A_OK;
475 }
476
477 void
478 ar6000_dbglog_event(AR_SOFTC_T *ar, A_UINT32 dropped,
479 A_INT8 *buffer, A_UINT32 length)
480 {
481 #ifdef REPORT_DEBUG_LOGS_TO_APP
482 #define MAX_WIRELESS_EVENT_SIZE 252
483 /*
484 * Break it up into chunks of MAX_WIRELESS_EVENT_SIZE bytes of messages.
485 * There seems to be a limitation on the length of message that could be
486 * transmitted to the user app via this mechanism.
487 */
488 A_UINT32 send, sent;
489
490 sent = 0;
491 send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
492 MAX_WIRELESS_EVENT_SIZE);
493 while (send) {
494 ar6000_send_event_to_app(ar, WMIX_DBGLOG_EVENTID, &buffer[sent], send);
495 sent += send;
496 send = dbglog_get_debug_fragment(&buffer[sent], length - sent,
497 MAX_WIRELESS_EVENT_SIZE);
498 }
499 #else
500 AR_DEBUG_PRINTF("Dropped logs: 0x%x\nDebug info length: %d\n",
501 dropped, length);
502
503 /* Interpret the debug logs */
504 dbglog_parse_debug_logs(buffer, length);
505 #endif /* REPORT_DEBUG_LOGS_TO_APP */
506 }
507
508
509
510 static int __init
511 ar6000_init_module(void)
512 {
513 static int probed = 0;
514 A_STATUS status;
515 HTC_INIT_INFO initInfo;
516
517 A_MEMZERO(&initInfo,sizeof(initInfo));
518 initInfo.AddInstance = ar6000_avail_ev;
519 initInfo.DeleteInstance = ar6000_unavail_ev;
520 initInfo.TargetFailure = ar6000_target_failure;
521
522
523 #ifdef DEBUG
524 /* Set the debug flags if specified at load time */
525 if(debugflags != 0)
526 {
527 g_dbg_flags = debugflags;
528 }
529 #endif
530
531 if (probed) {
532 return -ENODEV;
533 }
534 probed++;
535
536 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
537 memset(&aptcTR, 0, sizeof(APTC_TRAFFIC_RECORD));
538 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
539
540 #ifdef CONFIG_HOST_GPIO_SUPPORT
541 ar6000_gpio_init();
542 #endif /* CONFIG_HOST_GPIO_SUPPORT */
543
544 status = HTCInit(&initInfo);
545 if(status != A_OK)
546 return -ENODEV;
547
548 return 0;
549 }
550
551 static void __exit
552 ar6000_cleanup_module(void)
553 {
554 int i = 0;
555 struct net_device *ar6000_netdev;
556
557 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
558 /* Delete the Adaptive Power Control timer */
559 if (timer_pending(&aptcTimer)) {
560 del_timer_sync(&aptcTimer);
561 }
562 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
563
564 for (i=0; i < MAX_AR6000; i++) {
565 if (ar6000_devices[i] != NULL) {
566 ar6000_netdev = ar6000_devices[i];
567 ar6000_devices[i] = NULL;
568 ar6000_destroy(ar6000_netdev, 1);
569 }
570 }
571
572 /* shutting down HTC will cause the HIF layer to detach from the
573 * underlying bus driver which will cause the subsequent deletion of
574 * all HIF and HTC instances */
575 HTCShutDown();
576
577 AR_DEBUG_PRINTF("ar6000_cleanup: success\n");
578 }
579
580 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
581 void
582 aptcTimerHandler(unsigned long arg)
583 {
584 A_UINT32 numbytes;
585 A_UINT32 throughput;
586 AR_SOFTC_T *ar;
587 A_STATUS status;
588
589 ar = (AR_SOFTC_T *)arg;
590 A_ASSERT(ar != NULL);
591 A_ASSERT(!timer_pending(&aptcTimer));
592
593 AR6000_SPIN_LOCK(&ar->arLock, 0);
594
595 /* Get the number of bytes transferred */
596 numbytes = aptcTR.bytesTransmitted + aptcTR.bytesReceived;
597 aptcTR.bytesTransmitted = aptcTR.bytesReceived = 0;
598
599 /* Calculate and decide based on throughput thresholds */
600 throughput = ((numbytes * 8)/APTC_TRAFFIC_SAMPLING_INTERVAL); /* Kbps */
601 if (throughput < APTC_LOWER_THROUGHPUT_THRESHOLD) {
602 /* Enable Sleep and delete the timer */
603 A_ASSERT(ar->arWmiReady == TRUE);
604 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
605 status = wmi_powermode_cmd(ar->arWmi, REC_POWER);
606 AR6000_SPIN_LOCK(&ar->arLock, 0);
607 A_ASSERT(status == A_OK);
608 aptcTR.timerScheduled = FALSE;
609 } else {
610 A_TIMEOUT_MS(&aptcTimer, APTC_TRAFFIC_SAMPLING_INTERVAL, 0);
611 }
612
613 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
614 }
615 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
616
617
618
619 /* set HTC block size, assume BMI is already initialized */
620 A_STATUS ar6000_SetHTCBlockSize(AR_SOFTC_T *ar)
621 {
622 A_STATUS status;
623 A_UINT32 blocksizes[HTC_MAILBOX_NUM_MAX];
624
625 do {
626 /* get the block sizes */
627 status = HIFConfigureDevice(ar->arHifDevice, HIF_DEVICE_GET_MBOX_BLOCK_SIZE,
628 blocksizes, sizeof(blocksizes));
629
630 if (A_FAILED(status)) {
631 AR_DEBUG_PRINTF("Failed to get block size info from HIF layer...\n");
632 break;
633 }
634 /* note: we actually get the block size for mailbox 1, for SDIO the block
635 * size on mailbox 0 is artificially set to 1 */
636 /* must be a power of 2 */
637 A_ASSERT((blocksizes[1] & (blocksizes[1] - 1)) == 0);
638
639 /* set the host interest area for the block size */
640 status = BMIWriteMemory(ar->arHifDevice,
641 HOST_INTEREST_ITEM_ADDRESS(ar, hi_mbox_io_block_sz),
642 (A_UCHAR *)&blocksizes[1],
643 4);
644
645 if (A_FAILED(status)) {
646 AR_DEBUG_PRINTF("BMIWriteMemory for IO block size failed \n");
647 break;
648 }
649
650 AR_DEBUG_PRINTF("Block Size Set: %d (target address:0x%X)\n",
651 blocksizes[1], HOST_INTEREST_ITEM_ADDRESS(ar, hi_mbox_io_block_sz));
652
653 /* set the host interest area for the mbox ISR yield limit */
654 status = BMIWriteMemory(ar->arHifDevice,
655 HOST_INTEREST_ITEM_ADDRESS(ar, hi_mbox_isr_yield_limit),
656 (A_UCHAR *)&mbox_yield_limit,
657 4);
658
659 if (A_FAILED(status)) {
660 AR_DEBUG_PRINTF("BMIWriteMemory for yield limit failed \n");
661 break;
662 }
663
664 } while (FALSE);
665
666 return status;
667 }
668
669 static void free_raw_buffers(AR_SOFTC_T *ar)
670 {
671 int i, j;
672
673 for (i = 0; i != HTC_RAW_STREAM_NUM_MAX; i++) {
674 for (j = 0; j != RAW_HTC_READ_BUFFERS_NUM; j++)
675 kfree(ar->raw_htc_read_buffer[i][j]);
676 for (j = 0; j != RAW_HTC_WRITE_BUFFERS_NUM; j++)
677 kfree(ar->raw_htc_write_buffer[i][j]);
678 }
679 }
680
681 static int alloc_raw_buffers(AR_SOFTC_T *ar)
682 {
683 int i, j;
684 raw_htc_buffer *b;
685
686 for (i = 0; i != HTC_RAW_STREAM_NUM_MAX; i++) {
687 for (j = 0; j != RAW_HTC_READ_BUFFERS_NUM; j++) {
688 b = kzalloc(sizeof(*b), GFP_KERNEL);
689 if (!b)
690 return -ENOMEM;
691 ar->raw_htc_read_buffer[i][j] = b;
692 }
693 for (j = 0; j != RAW_HTC_WRITE_BUFFERS_NUM; j++) {
694 b = kzalloc(sizeof(*b), GFP_KERNEL);
695 if (!b)
696 return -ENOMEM;
697 ar->raw_htc_write_buffer[i][j] = b;
698 }
699 }
700 return 0;
701 }
702
703 /*
704 * HTC Event handlers
705 */
706 static void
707 ar6000_avail_ev(HTC_HANDLE HTCHandle)
708 {
709 int i;
710 struct net_device *dev;
711 AR_SOFTC_T *ar;
712 int device_index = 0;
713
714 AR_DEBUG_PRINTF("ar6000_available\n");
715
716 for (i=0; i < MAX_AR6000; i++) {
717 if (ar6000_devices[i] == NULL) {
718 break;
719 }
720 }
721
722 if (i == MAX_AR6000) {
723 AR_DEBUG_PRINTF("ar6000_available: max devices reached\n");
724 return;
725 }
726
727 /* Save this. It gives a bit better readability especially since */
728 /* we use another local "i" variable below. */
729 device_index = i;
730
731 A_ASSERT(HTCHandle != NULL);
732
733 dev = alloc_etherdev(sizeof(AR_SOFTC_T));
734 if (dev == NULL) {
735 AR_DEBUG_PRINTF("ar6000_available: can't alloc etherdev\n");
736 return;
737 }
738
739 ether_setup(dev);
740
741 if (netdev_priv(dev) == NULL) {
742 printk(KERN_CRIT "ar6000_available: Could not allocate memory\n");
743 return;
744 }
745
746 A_MEMZERO(netdev_priv(dev), sizeof(AR_SOFTC_T));
747
748 ar = (AR_SOFTC_T *)netdev_priv(dev);
749 ar->arNetDev = dev;
750 ar->arHtcTarget = HTCHandle;
751 ar->arHifDevice = HTCGetHifDevice(HTCHandle);
752 ar->arWlanState = WLAN_ENABLED;
753 ar->arRadioSwitch = WLAN_ENABLED;
754 ar->arDeviceIndex = device_index;
755
756 A_INIT_TIMER(&ar->arHBChallengeResp.timer, ar6000_detect_error, dev);
757 ar->arHBChallengeResp.seqNum = 0;
758 ar->arHBChallengeResp.outstanding = FALSE;
759 ar->arHBChallengeResp.missCnt = 0;
760 ar->arHBChallengeResp.frequency = AR6000_HB_CHALLENGE_RESP_FREQ_DEFAULT;
761 ar->arHBChallengeResp.missThres = AR6000_HB_CHALLENGE_RESP_MISS_THRES_DEFAULT;
762
763 ar6000_init_control_info(ar);
764 init_waitqueue_head(&arEvent);
765 sema_init(&ar->arSem, 1);
766
767 if (alloc_raw_buffers(ar)) {
768 free_raw_buffers(ar);
769 /*
770 * @@@ Clean up our own mess, but for anything else, cheerfully mimick
771 * the beautiful error non-handling of the rest of this function.
772 */
773 return;
774 }
775
776 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
777 A_INIT_TIMER(&aptcTimer, aptcTimerHandler, ar);
778 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
779
780 /*
781 * If requested, perform some magic which requires no cooperation from
782 * the Target. It causes the Target to ignore flash and execute to the
783 * OS from ROM.
784 *
785 * This is intended to support recovery from a corrupted flash on Targets
786 * that support flash.
787 */
788 if (skipflash)
789 {
790 ar6000_reset_device_skipflash(ar->arHifDevice);
791 }
792
793 BMIInit();
794 {
795 struct bmi_target_info targ_info;
796
797 if (BMIGetTargetInfo(ar->arHifDevice, &targ_info) != A_OK) {
798 return;
799 }
800
801 ar->arVersion.target_ver = targ_info.target_ver;
802 ar->arTargetType = targ_info.target_type;
803 }
804
805 if (enableuartprint) {
806 A_UINT32 param;
807 param = 1;
808 if (BMIWriteMemory(ar->arHifDevice,
809 HOST_INTEREST_ITEM_ADDRESS(ar, hi_serial_enable),
810 (A_UCHAR *)&param,
811 4)!= A_OK)
812 {
813 AR_DEBUG_PRINTF("BMIWriteMemory for enableuartprint failed \n");
814 return ;
815 }
816 AR_DEBUG_PRINTF("Serial console prints enabled\n");
817 }
818 #ifdef CONFIG_HOST_TCMD_SUPPORT
819 if(testmode) {
820 ar->arTargetMode = AR6000_TCMD_MODE;
821 }else {
822 ar->arTargetMode = AR6000_WLAN_MODE;
823 }
824 #endif
825 if (enabletimerwar) {
826 A_UINT32 param;
827
828 if (BMIReadMemory(ar->arHifDevice,
829 HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
830 (A_UCHAR *)&param,
831 4)!= A_OK)
832 {
833 AR_DEBUG_PRINTF("BMIReadMemory for enabletimerwar failed \n");
834 return;
835 }
836
837 param |= HI_OPTION_TIMER_WAR;
838
839 if (BMIWriteMemory(ar->arHifDevice,
840 HOST_INTEREST_ITEM_ADDRESS(ar, hi_option_flag),
841 (A_UCHAR *)&param,
842 4) != A_OK)
843 {
844 AR_DEBUG_PRINTF("BMIWriteMemory for enabletimerwar failed \n");
845 return;
846 }
847 AR_DEBUG_PRINTF("Timer WAR enabled\n");
848 }
849
850
851 /* since BMIInit is called in the driver layer, we have to set the block
852 * size here for the target */
853
854 if (A_FAILED(ar6000_SetHTCBlockSize(ar))) {
855 return;
856 }
857
858 spin_lock_init(&ar->arLock);
859
860 /* Don't install the init function if BMI is requested */
861 if(!bmienable)
862 {
863 dev->init = ar6000_init;
864 } else {
865 AR_DEBUG_PRINTF(" BMI enabled \n");
866 }
867
868 dev->open = &ar6000_open;
869 dev->stop = &ar6000_close;
870 dev->hard_start_xmit = &ar6000_data_tx;
871 dev->get_stats = &ar6000_get_stats;
872
873 /* dev->tx_timeout = ar6000_tx_timeout; */
874 dev->do_ioctl = &ar6000_ioctl;
875 dev->watchdog_timeo = AR6000_TX_TIMEOUT;
876 ar6000_ioctl_iwsetup(&ath_iw_handler_def);
877 dev->wireless_handlers = &ath_iw_handler_def;
878 ath_iw_handler_def.get_wireless_stats = ar6000_get_iwstats; /*Displayed via proc fs */
879
880 /*
881 * We need the OS to provide us with more headroom in order to
882 * perform dix to 802.3, WMI header encap, and the HTC header
883 */
884 dev->hard_header_len = ETH_HLEN + sizeof(ATH_LLC_SNAP_HDR) +
885 sizeof(WMI_DATA_HDR) + HTC_HEADER_LEN;
886
887 /* This runs the init function */
888 SET_NETDEV_DEV(dev, HIFGetOSDevice(ar->arHifDevice));
889 if (register_netdev(dev)) {
890 AR_DEBUG_PRINTF("ar6000_avail: register_netdev failed\n");
891 ar6000_destroy(dev, 0);
892 return;
893 }
894
895 HTCSetInstance(ar->arHtcTarget, ar);
896
897 /* We only register the device in the global list if we succeed. */
898 /* If the device is in the global list, it will be destroyed */
899 /* when the module is unloaded. */
900 ar6000_devices[device_index] = dev;
901
902 AR_DEBUG_PRINTF("ar6000_avail: name=%s htcTarget=0x%x, dev=0x%x (%d), ar=0x%x\n",
903 dev->name, (A_UINT32)HTCHandle, (A_UINT32)dev, device_index,
904 (A_UINT32)ar);
905 }
906
907 static void ar6000_target_failure(void *Instance, A_STATUS Status)
908 {
909 AR_SOFTC_T *ar = (AR_SOFTC_T *)Instance;
910 WMI_TARGET_ERROR_REPORT_EVENT errEvent;
911 static A_BOOL sip = FALSE;
912
913 if (Status != A_OK) {
914 if (timer_pending(&ar->arHBChallengeResp.timer)) {
915 A_UNTIMEOUT(&ar->arHBChallengeResp.timer);
916 }
917
918 /* try dumping target assertion information (if any) */
919 ar6000_dump_target_assert_info(ar->arHifDevice,ar->arTargetType);
920
921 /*
922 * Fetch the logs from the target via the diagnostic
923 * window.
924 */
925 ar6000_dbglog_get_debug_logs(ar);
926
927 /* Report the error only once */
928 if (!sip) {
929 sip = TRUE;
930 errEvent.errorVal = WMI_TARGET_COM_ERR |
931 WMI_TARGET_FATAL_ERR;
932 #ifdef SEND_EVENT_TO_APP
933 ar6000_send_event_to_app(ar, WMI_ERROR_REPORT_EVENTID,
934 (A_UINT8 *)&errEvent,
935 sizeof(WMI_TARGET_ERROR_REPORT_EVENT));
936 #endif
937 }
938 }
939 }
940
941 static void
942 ar6000_unavail_ev(void *Instance)
943 {
944 AR_SOFTC_T *ar = (AR_SOFTC_T *)Instance;
945 /* NULL out it's entry in the global list */
946 ar6000_devices[ar->arDeviceIndex] = NULL;
947 ar6000_destroy(ar->arNetDev, 1);
948 }
949
950 /*
951 * We need to differentiate between the surprise and planned removal of the
952 * device because of the following consideration:
953 * - In case of surprise removal, the hcd already frees up the pending
954 * for the device and hence there is no need to unregister the function
955 * driver inorder to get these requests. For planned removal, the function
956 * driver has to explictly unregister itself to have the hcd return all the
957 * pending requests before the data structures for the devices are freed up.
958 * Note that as per the current implementation, the function driver will
959 * end up releasing all the devices since there is no API to selectively
960 * release a particular device.
961 * - Certain commands issued to the target can be skipped for surprise
962 * removal since they will anyway not go through.
963 */
964 static void
965 ar6000_destroy(struct net_device *dev, unsigned int unregister)
966 {
967 AR_SOFTC_T *ar;
968
969 AR_DEBUG_PRINTF("+ar6000_destroy \n");
970
971 if((dev == NULL) || ((ar = netdev_priv(dev)) == NULL))
972 {
973 AR_DEBUG_PRINTF("%s(): Failed to get device structure.\n", __func__);
974 return;
975 }
976
977 /* Clear the tx counters */
978 memset(tx_attempt, 0, sizeof(tx_attempt));
979 memset(tx_post, 0, sizeof(tx_post));
980 memset(tx_complete, 0, sizeof(tx_complete));
981
982 /* Free up the device data structure */
983 if (unregister) {
984 unregister_netdev(dev);
985 } else {
986 ar6000_close(dev);
987 }
988
989 free_raw_buffers(ar);
990
991 #ifndef free_netdev
992 kfree(dev);
993 #else
994 free_netdev(dev);
995 #endif
996
997 AR_DEBUG_PRINTF("-ar6000_destroy \n");
998 }
999
1000 static void ar6000_detect_error(unsigned long ptr)
1001 {
1002 struct net_device *dev = (struct net_device *)ptr;
1003 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
1004 WMI_TARGET_ERROR_REPORT_EVENT errEvent;
1005
1006 AR6000_SPIN_LOCK(&ar->arLock, 0);
1007
1008 if (ar->arHBChallengeResp.outstanding) {
1009 ar->arHBChallengeResp.missCnt++;
1010 } else {
1011 ar->arHBChallengeResp.missCnt = 0;
1012 }
1013
1014 if (ar->arHBChallengeResp.missCnt > ar->arHBChallengeResp.missThres) {
1015 /* Send Error Detect event to the application layer and do not reschedule the error detection module timer */
1016 ar->arHBChallengeResp.missCnt = 0;
1017 ar->arHBChallengeResp.seqNum = 0;
1018 errEvent.errorVal = WMI_TARGET_COM_ERR | WMI_TARGET_FATAL_ERR;
1019 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1020 #ifdef SEND_EVENT_TO_APP
1021 ar6000_send_event_to_app(ar, WMI_ERROR_REPORT_EVENTID,
1022 (A_UINT8 *)&errEvent,
1023 sizeof(WMI_TARGET_ERROR_REPORT_EVENT));
1024 #endif
1025 return;
1026 }
1027
1028 /* Generate the sequence number for the next challenge */
1029 ar->arHBChallengeResp.seqNum++;
1030 ar->arHBChallengeResp.outstanding = TRUE;
1031
1032 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1033
1034 /* Send the challenge on the control channel */
1035 if (wmi_get_challenge_resp_cmd(ar->arWmi, ar->arHBChallengeResp.seqNum, DRV_HB_CHALLENGE) != A_OK) {
1036 AR_DEBUG_PRINTF("Unable to send heart beat challenge\n");
1037 }
1038
1039
1040 /* Reschedule the timer for the next challenge */
1041 A_TIMEOUT_MS(&ar->arHBChallengeResp.timer, ar->arHBChallengeResp.frequency * 1000, 0);
1042 }
1043
1044 void ar6000_init_profile_info(AR_SOFTC_T *ar)
1045 {
1046 ar->arSsidLen = 0;
1047 A_MEMZERO(ar->arSsid, sizeof(ar->arSsid));
1048 ar->arNetworkType = INFRA_NETWORK;
1049 ar->arDot11AuthMode = OPEN_AUTH;
1050 ar->arAuthMode = NONE_AUTH;
1051 ar->arPairwiseCrypto = NONE_CRYPT;
1052 ar->arPairwiseCryptoLen = 0;
1053 ar->arGroupCrypto = NONE_CRYPT;
1054 ar->arGroupCryptoLen = 0;
1055 A_MEMZERO(ar->arWepKeyList, sizeof(ar->arWepKeyList));
1056 A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid));
1057 A_MEMZERO(ar->arBssid, sizeof(ar->arBssid));
1058 ar->arBssChannel = 0;
1059 }
1060
1061 static void
1062 ar6000_init_control_info(AR_SOFTC_T *ar)
1063 {
1064 ar->arWmiEnabled = FALSE;
1065 ar6000_init_profile_info(ar);
1066 ar->arDefTxKeyIndex = 0;
1067 A_MEMZERO(ar->arWepKeyList, sizeof(ar->arWepKeyList));
1068 ar->arChannelHint = 0;
1069 ar->arListenInterval = MAX_LISTEN_INTERVAL;
1070 ar->arVersion.host_ver = AR6K_SW_VERSION;
1071 ar->arRssi = 0;
1072 ar->arTxPwr = 0;
1073 ar->arTxPwrSet = FALSE;
1074 ar->arSkipScan = 0;
1075 ar->arBeaconInterval = 0;
1076 ar->arBitRate = 0;
1077 ar->arMaxRetries = 0;
1078 ar->arWmmEnabled = TRUE;
1079 }
1080
1081 static int
1082 ar6000_open(struct net_device *dev)
1083 {
1084 /* Wake up the queues */
1085 netif_start_queue(dev);
1086
1087 return 0;
1088 }
1089
1090 static int
1091 ar6000_close(struct net_device *dev)
1092 {
1093 AR_SOFTC_T *ar = netdev_priv(dev);
1094
1095 /* Stop the transmit queues */
1096 netif_stop_queue(dev);
1097
1098 /* Disable the target and the interrupts associated with it */
1099 if (ar->arWmiReady == TRUE)
1100 {
1101 if (!bypasswmi)
1102 {
1103 if (ar->arConnected == TRUE || ar->arConnectPending == TRUE)
1104 {
1105 AR_DEBUG_PRINTF("%s(): Disconnect\n", __func__);
1106 AR6000_SPIN_LOCK(&ar->arLock, 0);
1107 ar6000_init_profile_info(ar);
1108 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1109 wmi_disconnect_cmd(ar->arWmi);
1110 }
1111
1112 ar6000_dbglog_get_debug_logs(ar);
1113 ar->arWmiReady = FALSE;
1114 ar->arConnected = FALSE;
1115 ar->arConnectPending = FALSE;
1116 wmi_shutdown(ar->arWmi);
1117 ar->arWmiEnabled = FALSE;
1118 ar->arWmi = NULL;
1119 ar->arWlanState = WLAN_ENABLED;
1120 #ifdef USER_KEYS
1121 ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT;
1122 ar->user_key_ctrl = 0;
1123 #endif
1124 }
1125
1126 AR_DEBUG_PRINTF("%s(): WMI stopped\n", __func__);
1127 }
1128 else
1129 {
1130 AR_DEBUG_PRINTF("%s(): WMI not ready 0x%08x 0x%08x\n",
1131 __func__, (unsigned int) ar, (unsigned int) ar->arWmi);
1132
1133 /* Shut down WMI if we have started it */
1134 if(ar->arWmiEnabled == TRUE)
1135 {
1136 AR_DEBUG_PRINTF("%s(): Shut down WMI\n", __func__);
1137 wmi_shutdown(ar->arWmi);
1138 ar->arWmiEnabled = FALSE;
1139 ar->arWmi = NULL;
1140 }
1141 }
1142
1143 /* stop HTC */
1144 HTCStop(ar->arHtcTarget);
1145
1146 /* set the instance to NULL so we do not get called back on remove incase we
1147 * we're explicity destroyed by module unload */
1148 HTCSetInstance(ar->arHtcTarget, NULL);
1149
1150 if (resetok) {
1151 /* try to reset the device if we can
1152 * The driver may have been configure NOT to reset the target during
1153 * a debug session */
1154 AR_DEBUG_PRINTF(" Attempting to reset target on instance destroy.... \n");
1155 ar6000_reset_device(ar->arHifDevice, ar->arTargetType);
1156 } else {
1157 AR_DEBUG_PRINTF(" Host does not want target reset. \n");
1158 }
1159
1160 /* Done with cookies */
1161 ar6000_cookie_cleanup(ar);
1162
1163 /* Cleanup BMI */
1164 BMIInit();
1165
1166 return 0;
1167 }
1168
1169 /* connect to a service */
1170 static A_STATUS ar6000_connectservice(AR_SOFTC_T *ar,
1171 HTC_SERVICE_CONNECT_REQ *pConnect,
1172 WMI_PRI_STREAM_ID WmiStreamID,
1173 char *pDesc)
1174 {
1175 A_STATUS status;
1176 HTC_SERVICE_CONNECT_RESP response;
1177
1178 do {
1179
1180 A_MEMZERO(&response,sizeof(response));
1181
1182 status = HTCConnectService(ar->arHtcTarget,
1183 pConnect,
1184 &response);
1185
1186 if (A_FAILED(status)) {
1187 AR_DEBUG_PRINTF(" Failed to connect to %s service status:%d \n", pDesc, status);
1188 break;
1189 }
1190
1191 if (WmiStreamID == WMI_NOT_MAPPED) {
1192 /* done */
1193 break;
1194 }
1195
1196 /* set endpoint mapping for the WMI stream in the driver layer */
1197 arSetWMIStream2EndpointIDMap(ar,WmiStreamID,response.Endpoint);
1198
1199 } while (FALSE);
1200
1201 return status;
1202 }
1203
1204 static void ar6000_TxDataCleanup(AR_SOFTC_T *ar)
1205 {
1206 /* flush all the data (non-control) streams
1207 * we only flush packets that are tagged as data, we leave any control packets that
1208 * were in the TX queues alone */
1209 HTCFlushEndpoint(ar->arHtcTarget,
1210 arWMIStream2EndpointID(ar,WMI_BEST_EFFORT_PRI),
1211 AR6K_DATA_PKT_TAG);
1212 HTCFlushEndpoint(ar->arHtcTarget,
1213 arWMIStream2EndpointID(ar,WMI_LOW_PRI),
1214 AR6K_DATA_PKT_TAG);
1215 HTCFlushEndpoint(ar->arHtcTarget,
1216 arWMIStream2EndpointID(ar,WMI_HIGH_PRI),
1217 AR6K_DATA_PKT_TAG);
1218 HTCFlushEndpoint(ar->arHtcTarget,
1219 arWMIStream2EndpointID(ar,WMI_HIGHEST_PRI),
1220 AR6K_DATA_PKT_TAG);
1221 }
1222
1223 /* This function does one time initialization for the lifetime of the device */
1224 int ar6000_init(struct net_device *dev)
1225 {
1226 AR_SOFTC_T *ar;
1227 A_STATUS status;
1228 A_INT32 timeleft;
1229
1230 if((ar = netdev_priv(dev)) == NULL)
1231 {
1232 return(-EIO);
1233 }
1234
1235 /* Do we need to finish the BMI phase */
1236 if(BMIDone(ar->arHifDevice) != A_OK)
1237 {
1238 return -EIO;
1239 }
1240
1241 if (!bypasswmi)
1242 {
1243 #if 0 /* TBDXXX */
1244 if (ar->arVersion.host_ver != ar->arVersion.target_ver) {
1245 A_PRINTF("WARNING: Host version 0x%x does not match Target "
1246 " version 0x%x!\n",
1247 ar->arVersion.host_ver, ar->arVersion.target_ver);
1248 }
1249 #endif
1250
1251 /* Indicate that WMI is enabled (although not ready yet) */
1252 ar->arWmiEnabled = TRUE;
1253 if ((ar->arWmi = wmi_init((void *) ar)) == NULL)
1254 {
1255 AR_DEBUG_PRINTF("%s() Failed to initialize WMI.\n", __func__);
1256 return(-EIO);
1257 }
1258
1259 AR_DEBUG_PRINTF("%s() Got WMI @ 0x%08x.\n", __func__,
1260 (unsigned int) ar->arWmi);
1261 }
1262
1263 do {
1264 HTC_SERVICE_CONNECT_REQ connect;
1265
1266 /* the reason we have to wait for the target here is that the driver layer
1267 * has to init BMI in order to set the host block size,
1268 */
1269 status = HTCWaitTarget(ar->arHtcTarget);
1270
1271 if (A_FAILED(status)) {
1272 break;
1273 }
1274
1275 A_MEMZERO(&connect,sizeof(connect));
1276 /* meta data is unused for now */
1277 connect.pMetaData = NULL;
1278 connect.MetaDataLength = 0;
1279 /* these fields are the same for all service endpoints */
1280 connect.EpCallbacks.pContext = ar;
1281 connect.EpCallbacks.EpTxComplete = ar6000_tx_complete;
1282 connect.EpCallbacks.EpRecv = ar6000_rx;
1283 connect.EpCallbacks.EpRecvRefill = ar6000_rx_refill;
1284 connect.EpCallbacks.EpSendFull = ar6000_tx_queue_full;
1285 connect.EpCallbacks.EpSendAvail = ar6000_tx_queue_avail;
1286 /* set the max queue depth so that our ar6000_tx_queue_full handler gets called.
1287 * Linux has the peculiarity of not providing flow control between the
1288 * NIC and the network stack. There is no API to indicate that a TX packet
1289 * was sent which could provide some back pressure to the network stack.
1290 * Under linux you would have to wait till the network stack consumed all sk_buffs
1291 * before any back-flow kicked in. Which isn't very friendly.
1292 * So we have to manage this ourselves */
1293 connect.MaxSendQueueDepth = 32;
1294
1295 /* connect to control service */
1296 connect.ServiceID = WMI_CONTROL_SVC;
1297 status = ar6000_connectservice(ar,
1298 &connect,
1299 WMI_CONTROL_PRI,
1300 "WMI CONTROL");
1301 if (A_FAILED(status)) {
1302 break;
1303 }
1304
1305 /* for the remaining data services set the connection flag to reduce dribbling,
1306 * if configured to do so */
1307 if (reduce_credit_dribble) {
1308 connect.ConnectionFlags |= HTC_CONNECT_FLAGS_REDUCE_CREDIT_DRIBBLE;
1309 /* the credit dribble trigger threshold is (reduce_credit_dribble - 1) for a value
1310 * of 0-3 */
1311 connect.ConnectionFlags &= ~HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_MASK;
1312 connect.ConnectionFlags |=
1313 ((A_UINT16)reduce_credit_dribble - 1) & HTC_CONNECT_FLAGS_THRESHOLD_LEVEL_MASK;
1314 }
1315 /* connect to best-effort service */
1316 connect.ServiceID = WMI_DATA_BE_SVC;
1317
1318 status = ar6000_connectservice(ar,
1319 &connect,
1320 WMI_BEST_EFFORT_PRI,
1321 "WMI DATA BE");
1322 if (A_FAILED(status)) {
1323 break;
1324 }
1325
1326 /* connect to back-ground
1327 * map this to WMI LOW_PRI */
1328 connect.ServiceID = WMI_DATA_BK_SVC;
1329 status = ar6000_connectservice(ar,
1330 &connect,
1331 WMI_LOW_PRI,
1332 "WMI DATA BK");
1333 if (A_FAILED(status)) {
1334 break;
1335 }
1336
1337 /* connect to Video service, map this to
1338 * to HI PRI */
1339 connect.ServiceID = WMI_DATA_VI_SVC;
1340 status = ar6000_connectservice(ar,
1341 &connect,
1342 WMI_HIGH_PRI,
1343 "WMI DATA VI");
1344 if (A_FAILED(status)) {
1345 break;
1346 }
1347
1348 /* connect to VO service, this is currently not
1349 * mapped to a WMI priority stream due to historical reasons.
1350 * WMI originally defined 3 priorities over 3 mailboxes
1351 * We can change this when WMI is reworked so that priorities are not
1352 * dependent on mailboxes */
1353 connect.ServiceID = WMI_DATA_VO_SVC;
1354 status = ar6000_connectservice(ar,
1355 &connect,
1356 WMI_HIGHEST_PRI,
1357 "WMI DATA VO");
1358 if (A_FAILED(status)) {
1359 break;
1360 }
1361
1362 A_ASSERT(arWMIStream2EndpointID(ar,WMI_CONTROL_PRI) != 0);
1363 A_ASSERT(arWMIStream2EndpointID(ar,WMI_BEST_EFFORT_PRI) != 0);
1364 A_ASSERT(arWMIStream2EndpointID(ar,WMI_LOW_PRI) != 0);
1365 A_ASSERT(arWMIStream2EndpointID(ar,WMI_HIGH_PRI) != 0);
1366 A_ASSERT(arWMIStream2EndpointID(ar,WMI_HIGHEST_PRI) != 0);
1367 } while (FALSE);
1368
1369 if (A_FAILED(status)) {
1370 return (-EIO);
1371 }
1372
1373 /*
1374 * give our connected endpoints some buffers
1375 */
1376 ar6000_rx_refill(ar, arWMIStream2EndpointID(ar,WMI_CONTROL_PRI));
1377
1378 ar6000_rx_refill(ar, arWMIStream2EndpointID(ar,WMI_BEST_EFFORT_PRI));
1379
1380 /*
1381 * We will post the receive buffers only for SPE testing and so we are
1382 * making it conditional on the 'bypasswmi' flag.
1383 */
1384 if (bypasswmi) {
1385 ar6000_rx_refill(ar,arWMIStream2EndpointID(ar,WMI_LOW_PRI));
1386 ar6000_rx_refill(ar,arWMIStream2EndpointID(ar,WMI_HIGH_PRI));
1387 }
1388
1389 /* setup credit distribution */
1390 ar6000_setup_credit_dist(ar->arHtcTarget, &ar->arCreditStateInfo);
1391
1392 /* Since cookies are used for HTC transports, they should be */
1393 /* initialized prior to enabling HTC. */
1394 ar6000_cookie_init(ar);
1395
1396 /* start HTC */
1397 status = HTCStart(ar->arHtcTarget);
1398
1399 if (status != A_OK) {
1400 if (ar->arWmiEnabled == TRUE) {
1401 wmi_shutdown(ar->arWmi);
1402 ar->arWmiEnabled = FALSE;
1403 ar->arWmi = NULL;
1404 }
1405 ar6000_cookie_cleanup(ar);
1406 return -EIO;
1407 }
1408
1409 if (!bypasswmi) {
1410 /* Wait for Wmi event to be ready */
1411 timeleft = wait_event_interruptible_timeout(arEvent,
1412 (ar->arWmiReady == TRUE), wmitimeout * HZ);
1413
1414 if(!timeleft || signal_pending(current))
1415 {
1416 AR_DEBUG_PRINTF("WMI is not ready or wait was interrupted\n");
1417 #if defined(DWSIM) /* TBDXXX */
1418 AR_DEBUG_PRINTF(".....but proceed anyway.\n");
1419 #else
1420 return -EIO;
1421 #endif
1422 }
1423
1424 AR_DEBUG_PRINTF("%s() WMI is ready\n", __func__);
1425
1426 /* Communicate the wmi protocol verision to the target */
1427 if ((ar6000_set_host_app_area(ar)) != A_OK) {
1428 AR_DEBUG_PRINTF("Unable to set the host app area\n");
1429 }
1430 }
1431
1432 ar->arNumDataEndPts = 1;
1433
1434 return(0);
1435 }
1436
1437
1438 void
1439 ar6000_bitrate_rx(void *devt, A_INT32 rateKbps)
1440 {
1441 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
1442
1443 ar->arBitRate = rateKbps;
1444 wake_up(&arEvent);
1445 }
1446
1447 void
1448 ar6000_ratemask_rx(void *devt, A_UINT16 ratemask)
1449 {
1450 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
1451
1452 ar->arRateMask = ratemask;
1453 wake_up(&arEvent);
1454 }
1455
1456 void
1457 ar6000_txPwr_rx(void *devt, A_UINT8 txPwr)
1458 {
1459 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
1460
1461 ar->arTxPwr = txPwr;
1462 wake_up(&arEvent);
1463 }
1464
1465
1466 void
1467 ar6000_channelList_rx(void *devt, A_INT8 numChan, A_UINT16 *chanList)
1468 {
1469 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
1470
1471 A_MEMCPY(ar->arChannelList, chanList, numChan * sizeof (A_UINT16));
1472 ar->arNumChannels = numChan;
1473
1474 wake_up(&arEvent);
1475 }
1476
1477 A_UINT8
1478 ar6000_ibss_map_epid(struct sk_buff *skb, struct net_device *dev, A_UINT32 * mapNo)
1479 {
1480 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
1481 A_UINT8 *datap;
1482 ATH_MAC_HDR *macHdr;
1483 A_UINT32 i, eptMap;
1484
1485 (*mapNo) = 0;
1486 datap = A_NETBUF_DATA(skb);
1487 macHdr = (ATH_MAC_HDR *)(datap + sizeof(WMI_DATA_HDR));
1488 if (IEEE80211_IS_MULTICAST(macHdr->dstMac)) {
1489 return ENDPOINT_2;
1490 }
1491
1492 eptMap = -1;
1493 for (i = 0; i < ar->arNodeNum; i ++) {
1494 if (IEEE80211_ADDR_EQ(macHdr->dstMac, ar->arNodeMap[i].macAddress)) {
1495 (*mapNo) = i + 1;
1496 ar->arNodeMap[i].txPending ++;
1497 return ar->arNodeMap[i].epId;
1498 }
1499
1500 if ((eptMap == -1) && !ar->arNodeMap[i].txPending) {
1501 eptMap = i;
1502 }
1503 }
1504
1505 if (eptMap == -1) {
1506 eptMap = ar->arNodeNum;
1507 ar->arNodeNum ++;
1508 A_ASSERT(ar->arNodeNum <= MAX_NODE_NUM);
1509 }
1510
1511 A_MEMCPY(ar->arNodeMap[eptMap].macAddress, macHdr->dstMac, IEEE80211_ADDR_LEN);
1512
1513 for (i = ENDPOINT_2; i <= ENDPOINT_5; i ++) {
1514 if (!ar->arTxPending[i]) {
1515 ar->arNodeMap[eptMap].epId = i;
1516 break;
1517 }
1518 // No free endpoint is available, start redistribution on the inuse endpoints.
1519 if (i == ENDPOINT_5) {
1520 ar->arNodeMap[eptMap].epId = ar->arNexEpId;
1521 ar->arNexEpId ++;
1522 if (ar->arNexEpId > ENDPOINT_5) {
1523 ar->arNexEpId = ENDPOINT_2;
1524 }
1525 }
1526 }
1527
1528 (*mapNo) = eptMap + 1;
1529 ar->arNodeMap[eptMap].txPending ++;
1530
1531 return ar->arNodeMap[eptMap].epId;
1532 }
1533
1534 #ifdef DEBUG
1535 static void ar6000_dump_skb(struct sk_buff *skb)
1536 {
1537 u_char *ch;
1538 for (ch = A_NETBUF_DATA(skb);
1539 (A_UINT32)ch < ((A_UINT32)A_NETBUF_DATA(skb) +
1540 A_NETBUF_LEN(skb)); ch++)
1541 {
1542 AR_DEBUG_PRINTF("%2.2x ", *ch);
1543 }
1544 AR_DEBUG_PRINTF("\n");
1545 }
1546 #endif
1547
1548 static int
1549 ar6000_data_tx(struct sk_buff *skb, struct net_device *dev)
1550 {
1551 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
1552 WMI_PRI_STREAM_ID streamID = WMI_NOT_MAPPED;
1553 A_UINT32 mapNo = 0;
1554 int len;
1555 struct ar_cookie *cookie;
1556 A_BOOL checkAdHocPsMapping = FALSE;
1557
1558 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
1559 skb->list = NULL;
1560 #endif
1561
1562 AR_DEBUG2_PRINTF("ar6000_data_tx start - skb=0x%x, data=0x%x, len=0x%x\n",
1563 (A_UINT32)skb, (A_UINT32)A_NETBUF_DATA(skb),
1564 A_NETBUF_LEN(skb));
1565 #ifdef CONFIG_HOST_TCMD_SUPPORT
1566 /* TCMD doesnt support any data, free the buf and return */
1567 if(ar->arTargetMode == AR6000_TCMD_MODE) {
1568 A_NETBUF_FREE(skb);
1569 return 0;
1570 }
1571 #endif
1572 do {
1573
1574 if (ar->arWmiReady == FALSE && bypasswmi == 0) {
1575 break;
1576 }
1577
1578 #ifdef BLOCK_TX_PATH_FLAG
1579 if (blocktx) {
1580 break;
1581 }
1582 #endif /* BLOCK_TX_PATH_FLAG */
1583
1584 if (ar->arWmiEnabled) {
1585 if (A_NETBUF_HEADROOM(skb) < dev->hard_header_len) {
1586 struct sk_buff *newbuf;
1587 /*
1588 * We really should have gotten enough headroom but sometimes
1589 * we still get packets with not enough headroom. Copy the packet.
1590 */
1591 len = A_NETBUF_LEN(skb);
1592 newbuf = A_NETBUF_ALLOC(len);
1593 if (newbuf == NULL) {
1594 break;
1595 }
1596 A_NETBUF_PUT(newbuf, len);
1597 A_MEMCPY(A_NETBUF_DATA(newbuf), A_NETBUF_DATA(skb), len);
1598 A_NETBUF_FREE(skb);
1599 skb = newbuf;
1600 /* fall through and assemble header */
1601 }
1602
1603 if (wmi_dix_2_dot3(ar->arWmi, skb) != A_OK) {
1604 AR_DEBUG_PRINTF("ar6000_data_tx - wmi_dix_2_dot3 failed\n");
1605 break;
1606 }
1607
1608 if (wmi_data_hdr_add(ar->arWmi, skb, DATA_MSGTYPE) != A_OK) {
1609 AR_DEBUG_PRINTF("ar6000_data_tx - wmi_data_hdr_add failed\n");
1610 break;
1611 }
1612
1613 if ((ar->arNetworkType == ADHOC_NETWORK) &&
1614 ar->arIbssPsEnable && ar->arConnected) {
1615 /* flag to check adhoc mapping once we take the lock below: */
1616 checkAdHocPsMapping = TRUE;
1617
1618 } else {
1619 /* get the stream mapping */
1620 if (ar->arWmmEnabled) {
1621 streamID = wmi_get_stream_id(ar->arWmi,
1622 wmi_implicit_create_pstream(ar->arWmi, skb, UPLINK_TRAFFIC, UNDEFINED_PRI));
1623 } else {
1624 streamID = WMI_BEST_EFFORT_PRI;
1625 }
1626 }
1627
1628 } else {
1629 struct iphdr *ipHdr;
1630 /*
1631 * the endpoint is directly based on the TOS field in the IP
1632 * header **** only for testing ******
1633 */
1634 ipHdr = A_NETBUF_DATA(skb) + sizeof(ATH_MAC_HDR);
1635 /* here we map the TOS field to an endpoint number, this is for
1636 * the endpointping test application */
1637 streamID = IP_TOS_TO_WMI_PRI(ipHdr->tos);
1638 }
1639
1640 } while (FALSE);
1641
1642 /* did we succeed ? */
1643 if ((streamID == WMI_NOT_MAPPED) && !checkAdHocPsMapping) {
1644 /* cleanup and exit */
1645 A_NETBUF_FREE(skb);
1646 AR6000_STAT_INC(ar, tx_dropped);
1647 AR6000_STAT_INC(ar, tx_aborted_errors);
1648 return 0;
1649 }
1650
1651 cookie = NULL;
1652
1653 /* take the lock to protect driver data */
1654 AR6000_SPIN_LOCK(&ar->arLock, 0);
1655
1656 do {
1657
1658 if (checkAdHocPsMapping) {
1659 streamID = ar6000_ibss_map_epid(skb, dev, &mapNo);
1660 }
1661
1662 A_ASSERT(streamID != WMI_NOT_MAPPED);
1663
1664 /* validate that the endpoint is connected */
1665 if (arWMIStream2EndpointID(ar,streamID) == 0) {
1666 AR_DEBUG_PRINTF("Stream %d is NOT mapped!\n",streamID);
1667 break;
1668 }
1669 /* allocate resource for this packet */
1670 cookie = ar6000_alloc_cookie(ar);
1671
1672 if (cookie != NULL) {
1673 /* update counts while the lock is held */
1674 ar->arTxPending[streamID]++;
1675 ar->arTotalTxDataPending++;
1676 }
1677
1678 } while (FALSE);
1679
1680 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1681
1682 if (cookie != NULL) {
1683 cookie->arc_bp[0] = (A_UINT32)skb;
1684 cookie->arc_bp[1] = mapNo;
1685 SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
1686 cookie,
1687 A_NETBUF_DATA(skb),
1688 A_NETBUF_LEN(skb),
1689 arWMIStream2EndpointID(ar,streamID),
1690 AR6K_DATA_PKT_TAG);
1691
1692 #ifdef DEBUG
1693 if (debugdriver >= 3) {
1694 ar6000_dump_skb(skb);
1695 }
1696 #endif
1697 /* HTC interface is asynchronous, if this fails, cleanup will happen in
1698 * the ar6000_tx_complete callback */
1699 HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt);
1700 } else {
1701 /* no packet to send, cleanup */
1702 A_NETBUF_FREE(skb);
1703 AR6000_STAT_INC(ar, tx_dropped);
1704 AR6000_STAT_INC(ar, tx_aborted_errors);
1705 }
1706
1707 return 0;
1708 }
1709
1710 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
1711 static void
1712 tvsub(register struct timeval *out, register struct timeval *in)
1713 {
1714 if((out->tv_usec -= in->tv_usec) < 0) {
1715 out->tv_sec--;
1716 out->tv_usec += 1000000;
1717 }
1718 out->tv_sec -= in->tv_sec;
1719 }
1720
1721 void
1722 applyAPTCHeuristics(AR_SOFTC_T *ar)
1723 {
1724 A_UINT32 duration;
1725 A_UINT32 numbytes;
1726 A_UINT32 throughput;
1727 struct timeval ts;
1728 A_STATUS status;
1729
1730 AR6000_SPIN_LOCK(&ar->arLock, 0);
1731
1732 if ((enableAPTCHeuristics) && (!aptcTR.timerScheduled)) {
1733 do_gettimeofday(&ts);
1734 tvsub(&ts, &aptcTR.samplingTS);
1735 duration = ts.tv_sec * 1000 + ts.tv_usec / 1000; /* ms */
1736 numbytes = aptcTR.bytesTransmitted + aptcTR.bytesReceived;
1737
1738 if (duration > APTC_TRAFFIC_SAMPLING_INTERVAL) {
1739 /* Initialize the time stamp and byte count */
1740 aptcTR.bytesTransmitted = aptcTR.bytesReceived = 0;
1741 do_gettimeofday(&aptcTR.samplingTS);
1742
1743 /* Calculate and decide based on throughput thresholds */
1744 throughput = ((numbytes * 8) / duration);
1745 if (throughput > APTC_UPPER_THROUGHPUT_THRESHOLD) {
1746 /* Disable Sleep and schedule a timer */
1747 A_ASSERT(ar->arWmiReady == TRUE);
1748 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1749 status = wmi_powermode_cmd(ar->arWmi, MAX_PERF_POWER);
1750 AR6000_SPIN_LOCK(&ar->arLock, 0);
1751 A_TIMEOUT_MS(&aptcTimer, APTC_TRAFFIC_SAMPLING_INTERVAL, 0);
1752 aptcTR.timerScheduled = TRUE;
1753 }
1754 }
1755 }
1756
1757 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1758 }
1759 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
1760
1761 static void
1762 ar6000_tx_queue_full(void *Context, HTC_ENDPOINT_ID Endpoint)
1763 {
1764 AR_SOFTC_T *ar = (AR_SOFTC_T *) Context;
1765
1766 if (Endpoint == arWMIStream2EndpointID(ar,WMI_CONTROL_PRI)) {
1767 if (!bypasswmi) {
1768 /* under normal WMI if this is getting full, then something is running rampant
1769 * the host should not be exhausting the WMI queue with too many commands
1770 * the only exception to this is during testing using endpointping */
1771
1772 AR6000_SPIN_LOCK(&ar->arLock, 0);
1773 /* set flag to handle subsequent messages */
1774 ar->arWMIControlEpFull = TRUE;
1775 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1776 AR_DEBUG_PRINTF("WMI Control Endpoint is FULL!!! \n");
1777 }
1778 } else {
1779 /* one of the data endpoints queues is getting full..need to stop network stack
1780 * the queue will resume after credits received */
1781 netif_stop_queue(ar->arNetDev);
1782 }
1783 }
1784
1785 static void
1786 ar6000_tx_queue_avail(void *Context, HTC_ENDPOINT_ID Endpoint)
1787 {
1788 AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
1789
1790 if (Endpoint == arWMIStream2EndpointID(ar,WMI_CONTROL_PRI)) {
1791 /* FIXME: what do for it? */
1792 } else {
1793 /* Wake up interface, rescheduling prevented. */
1794 if (ar->arConnected == TRUE || bypasswmi)
1795 netif_wake_queue(ar->arNetDev);
1796 }
1797 }
1798
1799 static void
1800 ar6000_tx_complete(void *Context, HTC_PACKET *pPacket)
1801 {
1802 AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
1803 void *cookie = (void *)pPacket->pPktContext;
1804 struct sk_buff *skb = NULL;
1805 A_UINT32 mapNo = 0;
1806 A_STATUS status;
1807 struct ar_cookie * ar_cookie;
1808 WMI_PRI_STREAM_ID streamID;
1809 A_BOOL wakeEvent = FALSE;
1810
1811 status = pPacket->Status;
1812 ar_cookie = (struct ar_cookie *)cookie;
1813 skb = (struct sk_buff *)ar_cookie->arc_bp[0];
1814 streamID = arEndpoint2WMIStreamID(ar,pPacket->Endpoint);
1815 mapNo = ar_cookie->arc_bp[1];
1816
1817 A_ASSERT(skb);
1818 A_ASSERT(pPacket->pBuffer == A_NETBUF_DATA(skb));
1819
1820 if (A_SUCCESS(status)) {
1821 A_ASSERT(pPacket->ActualLength == A_NETBUF_LEN(skb));
1822 }
1823
1824 AR_DEBUG2_PRINTF("ar6000_tx_complete skb=0x%x data=0x%x len=0x%x sid=%d ",
1825 (A_UINT32)skb, (A_UINT32)pPacket->pBuffer,
1826 pPacket->ActualLength,
1827 streamID);
1828
1829 /* lock the driver as we update internal state */
1830 AR6000_SPIN_LOCK(&ar->arLock, 0);
1831
1832 ar->arTxPending[streamID]--;
1833
1834 if ((streamID != WMI_CONTROL_PRI) || bypasswmi) {
1835 ar->arTotalTxDataPending--;
1836 }
1837
1838 if (streamID == WMI_CONTROL_PRI)
1839 {
1840 if (ar->arWMIControlEpFull) {
1841 /* since this packet completed, the WMI EP is no longer full */
1842 ar->arWMIControlEpFull = FALSE;
1843 }
1844
1845 if (ar->arTxPending[streamID] == 0) {
1846 wakeEvent = TRUE;
1847 }
1848 }
1849
1850 if (A_FAILED(status)) {
1851 AR_DEBUG_PRINTF("%s() -TX ERROR, status: 0x%x\n", __func__,
1852 status);
1853 AR6000_STAT_INC(ar, tx_errors);
1854 } else {
1855 AR_DEBUG2_PRINTF("OK\n");
1856 AR6000_STAT_INC(ar, tx_packets);
1857 ar->arNetStats.tx_bytes += A_NETBUF_LEN(skb);
1858 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
1859 aptcTR.bytesTransmitted += a_netbuf_to_len(skb);
1860 applyAPTCHeuristics(ar);
1861 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
1862 }
1863
1864 // TODO this needs to be looked at
1865 if ((ar->arNetworkType == ADHOC_NETWORK) && ar->arIbssPsEnable
1866 && (streamID != WMI_CONTROL_PRI) && mapNo)
1867 {
1868 mapNo --;
1869 ar->arNodeMap[mapNo].txPending --;
1870
1871 if (!ar->arNodeMap[mapNo].txPending && (mapNo == (ar->arNodeNum - 1))) {
1872 A_UINT32 i;
1873 for (i = ar->arNodeNum; i > 0; i --) {
1874 if (!ar->arNodeMap[i - 1].txPending) {
1875 A_MEMZERO(&ar->arNodeMap[i - 1], sizeof(struct ar_node_mapping));
1876 ar->arNodeNum --;
1877 } else {
1878 break;
1879 }
1880 }
1881 }
1882 }
1883
1884 /* Freeing a cookie should not be contingent on either of */
1885 /* these flags, just if we have a cookie or not. */
1886 /* Can we even get here without a cookie? Fix later. */
1887 if (ar->arWmiReady == TRUE || (bypasswmi))
1888 {
1889 ar6000_free_cookie(ar, cookie);
1890 }
1891
1892 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1893
1894 /* lock is released, we can freely call other kernel APIs */
1895
1896 /* this indirectly frees the HTC_PACKET */
1897 A_NETBUF_FREE(skb);
1898
1899 if (wakeEvent) {
1900 wake_up(&arEvent);
1901 }
1902 }
1903
1904 /*
1905 * Receive event handler. This is called by HTC when a packet is received
1906 */
1907 int pktcount;
1908 static void
1909 ar6000_rx(void *Context, HTC_PACKET *pPacket)
1910 {
1911 AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
1912 struct sk_buff *skb = (struct sk_buff *)pPacket->pPktContext;
1913 int minHdrLen;
1914 A_STATUS status = pPacket->Status;
1915 WMI_PRI_STREAM_ID streamID = arEndpoint2WMIStreamID(ar,pPacket->Endpoint);
1916 HTC_ENDPOINT_ID ept = pPacket->Endpoint;
1917
1918 A_ASSERT((status != A_OK) || (pPacket->pBuffer == (A_NETBUF_DATA(skb) + HTC_HEADER_LEN)));
1919
1920 AR_DEBUG2_PRINTF("ar6000_rx ar=0x%x sid=%d, skb=0x%x, data=0x%x, len=0x%x ",
1921 (A_UINT32)ar, streamID, (A_UINT32)skb, (A_UINT32)pPacket->pBuffer,
1922 pPacket->ActualLength);
1923 if (status != A_OK) {
1924 AR_DEBUG2_PRINTF("ERR\n");
1925 } else {
1926 AR_DEBUG2_PRINTF("OK\n");
1927 }
1928
1929 /* take lock to protect buffer counts
1930 * and adaptive power throughput state */
1931 AR6000_SPIN_LOCK(&ar->arLock, 0);
1932
1933 ar->arRxBuffers[streamID]--;
1934
1935 if (A_SUCCESS(status)) {
1936 AR6000_STAT_INC(ar, rx_packets);
1937 ar->arNetStats.rx_bytes += pPacket->ActualLength;
1938 #ifdef ADAPTIVE_POWER_THROUGHPUT_CONTROL
1939 aptcTR.bytesReceived += a_netbuf_to_len(skb);
1940 applyAPTCHeuristics(ar);
1941 #endif /* ADAPTIVE_POWER_THROUGHPUT_CONTROL */
1942
1943 A_NETBUF_PUT(skb, pPacket->ActualLength + HTC_HEADER_LEN);
1944 A_NETBUF_PULL(skb, HTC_HEADER_LEN);
1945
1946 #ifdef DEBUG
1947 if (debugdriver >= 2) {
1948 ar6000_dump_skb(skb);
1949 }
1950 #endif /* DEBUG */
1951 }
1952
1953 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
1954
1955 if (status != A_OK) {
1956 AR6000_STAT_INC(ar, rx_errors);
1957 A_NETBUF_FREE(skb);
1958 } else if (ar->arWmiEnabled == TRUE) {
1959 if (streamID == WMI_CONTROL_PRI) {
1960 /*
1961 * this is a wmi control msg
1962 */
1963 wmi_control_rx(ar->arWmi, skb);
1964 } else {
1965 WMI_DATA_HDR *dhdr = (WMI_DATA_HDR *)A_NETBUF_DATA(skb);
1966 if (WMI_DATA_HDR_IS_MSG_TYPE(dhdr, CNTL_MSGTYPE)) {
1967 /*
1968 * this is a wmi control msg
1969 */
1970 /* strip off WMI hdr */
1971 wmi_data_hdr_remove(ar->arWmi, skb);
1972 wmi_control_rx(ar->arWmi, skb);
1973 } else {
1974 /*
1975 * this is a wmi data packet
1976 */
1977 minHdrLen = sizeof (WMI_DATA_HDR) + sizeof(ATH_MAC_HDR) +
1978 sizeof(ATH_LLC_SNAP_HDR);
1979
1980 if ((pPacket->ActualLength < minHdrLen) ||
1981 (pPacket->ActualLength > AR6000_BUFFER_SIZE))
1982 {
1983 /*
1984 * packet is too short or too long
1985 */
1986 AR_DEBUG_PRINTF("TOO SHORT or TOO LONG\n");
1987 AR6000_STAT_INC(ar, rx_errors);
1988 AR6000_STAT_INC(ar, rx_length_errors);
1989 A_NETBUF_FREE(skb);
1990 } else {
1991 if (ar->arWmmEnabled) {
1992 wmi_implicit_create_pstream(ar->arWmi, skb,
1993 DNLINK_TRAFFIC, UNDEFINED_PRI);
1994 }
1995 #if 0
1996 /* Access RSSI values here */
1997 AR_DEBUG_PRINTF("RSSI %d\n",
1998 ((WMI_DATA_HDR *) A_NETBUF_DATA(skb))->rssi);
1999 #endif
2000 wmi_data_hdr_remove(ar->arWmi, skb);
2001 wmi_dot3_2_dix(ar->arWmi, skb);
2002
2003 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2004 /*
2005 * extra push and memcpy, for eth_type_trans() of 2.4 kernel
2006 * will pull out hard_header_len bytes of the skb.
2007 */
2008 A_NETBUF_PUSH(skb, sizeof(WMI_DATA_HDR) + sizeof(ATH_LLC_SNAP_HDR) + HTC_HEADER_LEN);
2009 A_MEMCPY(A_NETBUF_DATA(skb), A_NETBUF_DATA(skb) + sizeof(WMI_DATA_HDR) +
2010 sizeof(ATH_LLC_SNAP_HDR) + HTC_HEADER_LEN, sizeof(ATH_MAC_HDR));
2011 #endif
2012 if ((ar->arNetDev->flags & IFF_UP) == IFF_UP)
2013 {
2014 skb->dev = ar->arNetDev;
2015 skb->protocol = eth_type_trans(skb, ar->arNetDev);
2016 netif_rx(skb);
2017 }
2018 else
2019 {
2020 A_NETBUF_FREE(skb);
2021 }
2022 }
2023 }
2024 }
2025 } else {
2026 if ((ar->arNetDev->flags & IFF_UP) == IFF_UP)
2027 {
2028 skb->dev = ar->arNetDev;
2029 skb->protocol = eth_type_trans(skb, ar->arNetDev);
2030 netif_rx(skb);
2031 }
2032 else
2033 {
2034 A_NETBUF_FREE(skb);
2035 }
2036 }
2037
2038 if (status != A_ECANCELED) {
2039 /*
2040 * HTC provides A_ECANCELED status when it doesn't want to be refilled
2041 * (probably due to a shutdown)
2042 */
2043 ar6000_rx_refill(Context, ept);
2044 }
2045
2046
2047 }
2048
2049 static void
2050 ar6000_rx_refill(void *Context, HTC_ENDPOINT_ID Endpoint)
2051 {
2052 AR_SOFTC_T *ar = (AR_SOFTC_T *)Context;
2053 void *osBuf;
2054 int RxBuffers;
2055 int buffersToRefill;
2056 HTC_PACKET *pPacket;
2057 WMI_PRI_STREAM_ID streamId = arEndpoint2WMIStreamID(ar,Endpoint);
2058
2059 buffersToRefill = (int)AR6000_MAX_RX_BUFFERS -
2060 (int)ar->arRxBuffers[streamId];
2061
2062 if (buffersToRefill <= 0) {
2063 /* fast return, nothing to fill */
2064 return;
2065 }
2066
2067 AR_DEBUG2_PRINTF("ar6000_rx_refill: providing htc with %d buffers at eid=%d\n",
2068 buffersToRefill, Endpoint);
2069
2070 for (RxBuffers = 0; RxBuffers < buffersToRefill; RxBuffers++) {
2071 osBuf = A_NETBUF_ALLOC(AR6000_BUFFER_SIZE);
2072 if (NULL == osBuf) {
2073 break;
2074 }
2075 /* the HTC packet wrapper is at the head of the reserved area
2076 * in the skb */
2077 pPacket = (HTC_PACKET *)(A_NETBUF_HEAD(osBuf));
2078 /* set re-fill info */
2079 SET_HTC_PACKET_INFO_RX_REFILL(pPacket,osBuf,A_NETBUF_DATA(osBuf),AR6000_BUFFER_SIZE,Endpoint);
2080 /* add this packet */
2081 HTCAddReceivePkt(ar->arHtcTarget, pPacket);
2082 }
2083
2084 /* update count */
2085 AR6000_SPIN_LOCK(&ar->arLock, 0);
2086 ar->arRxBuffers[streamId] += RxBuffers;
2087 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2088 }
2089
2090 static struct net_device_stats *
2091 ar6000_get_stats(struct net_device *dev)
2092 {
2093 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
2094 return &ar->arNetStats;
2095 }
2096
2097 static struct iw_statistics *
2098 ar6000_get_iwstats(struct net_device * dev)
2099 {
2100 AR_SOFTC_T *ar = (AR_SOFTC_T *)netdev_priv(dev);
2101 TARGET_STATS *pStats = &ar->arTargetStats;
2102 struct iw_statistics * pIwStats = &ar->arIwStats;
2103
2104 if ((ar->arWmiReady == FALSE)
2105 /*
2106 * The in_atomic function is used to determine if the scheduling is
2107 * allowed in the current context or not. This was introduced in 2.6
2108 * From what I have read on the differences between 2.4 and 2.6, the
2109 * 2.4 kernel did not support preemption and so this check might not
2110 * be required for 2.4 kernels.
2111 */
2112 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2113 || (in_atomic())
2114 #endif
2115 )
2116 {
2117 pIwStats->status = 0;
2118 pIwStats->qual.qual = 0;
2119 pIwStats->qual.level =0;
2120 pIwStats->qual.noise = 0;
2121 pIwStats->discard.code =0;
2122 pIwStats->discard.retries=0;
2123 pIwStats->miss.beacon =0;
2124 return pIwStats;
2125 }
2126 if (down_interruptible(&ar->arSem)) {
2127 pIwStats->status = 0;
2128 return pIwStats;
2129 }
2130
2131
2132 ar->statsUpdatePending = TRUE;
2133
2134 if(wmi_get_stats_cmd(ar->arWmi) != A_OK) {
2135 up(&ar->arSem);
2136 pIwStats->status = 0;
2137 return pIwStats;
2138 }
2139
2140 wait_event_interruptible_timeout(arEvent, ar->statsUpdatePending == FALSE, wmitimeout * HZ);
2141
2142 if (signal_pending(current)) {
2143 AR_DEBUG_PRINTF("ar6000 : WMI get stats timeout \n");
2144 up(&ar->arSem);
2145 pIwStats->status = 0;
2146 return pIwStats;
2147 }
2148 pIwStats->status = 1 ;
2149 pIwStats->qual.qual = pStats->cs_aveBeacon_rssi;
2150 pIwStats->qual.level =pStats->cs_aveBeacon_rssi + 161; /* noise is -95 dBm */
2151 pIwStats->qual.noise = pStats->noise_floor_calibation;
2152 pIwStats->discard.code = pStats->rx_decrypt_err;
2153 pIwStats->discard.retries = pStats->tx_retry_cnt;
2154 pIwStats->miss.beacon = pStats->cs_bmiss_cnt;
2155 up(&ar->arSem);
2156 return pIwStats;
2157 }
2158
2159 void
2160 ar6000_ready_event(void *devt, A_UINT8 *datap, A_UINT8 phyCap)
2161 {
2162 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2163 struct net_device *dev = ar->arNetDev;
2164
2165 ar->arWmiReady = TRUE;
2166 wake_up(&arEvent);
2167 A_MEMCPY(dev->dev_addr, datap, AR6000_ETH_ADDR_LEN);
2168 AR_DEBUG_PRINTF("mac address = %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x\n",
2169 dev->dev_addr[0], dev->dev_addr[1],
2170 dev->dev_addr[2], dev->dev_addr[3],
2171 dev->dev_addr[4], dev->dev_addr[5]);
2172
2173 ar->arPhyCapability = phyCap;
2174 }
2175
2176 A_UINT8
2177 ar6000_iptos_to_userPriority(A_UINT8 *pkt)
2178 {
2179 struct iphdr *ipHdr = (struct iphdr *)pkt;
2180 A_UINT8 userPriority;
2181
2182 /*
2183 * IP Tos format :
2184 * (Refer Pg 57 WMM-test-plan-v1.2)
2185 * IP-TOS - 8bits
2186 * : DSCP(6-bits) ECN(2-bits)
2187 * : DSCP - P2 P1 P0 X X X
2188 * where (P2 P1 P0) form 802.1D
2189 */
2190 userPriority = ipHdr->tos >> 5;
2191 return (userPriority & 0x7);
2192 }
2193
2194 void
2195 ar6000_connect_event(AR_SOFTC_T *ar, A_UINT16 channel, A_UINT8 *bssid,
2196 A_UINT16 listenInterval, A_UINT16 beaconInterval,
2197 NETWORK_TYPE networkType, A_UINT8 beaconIeLen,
2198 A_UINT8 assocReqLen, A_UINT8 assocRespLen,
2199 A_UINT8 *assocInfo)
2200 {
2201 union iwreq_data wrqu;
2202 int i, beacon_ie_pos, assoc_resp_ie_pos, assoc_req_ie_pos;
2203 static const char *tag1 = "ASSOCINFO(ReqIEs=";
2204 static const char *tag2 = "ASSOCRESPIE=";
2205 static const char *beaconIetag = "BEACONIE=";
2206 char buf[WMI_CONTROL_MSG_MAX_LEN * 2 + sizeof(tag1)];
2207 char *pos;
2208 A_UINT8 key_op_ctrl;
2209
2210 A_MEMCPY(ar->arBssid, bssid, sizeof(ar->arBssid));
2211 ar->arBssChannel = channel;
2212
2213 A_PRINTF("AR6000 connected event on freq %d ", channel);
2214 A_PRINTF("with bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
2215 " listenInterval=%d, beaconInterval = %d, beaconIeLen = %d assocReqLen=%d"
2216 " assocRespLen =%d\n",
2217 bssid[0], bssid[1], bssid[2],
2218 bssid[3], bssid[4], bssid[5],
2219 listenInterval, beaconInterval,
2220 beaconIeLen, assocReqLen, assocRespLen);
2221 if (networkType & ADHOC_NETWORK) {
2222 if (networkType & ADHOC_CREATOR) {
2223 A_PRINTF("Network: Adhoc (Creator)\n");
2224 } else {
2225 A_PRINTF("Network: Adhoc (Joiner)\n");
2226 }
2227 } else {
2228 A_PRINTF("Network: Infrastructure\n");
2229 }
2230
2231 if (beaconIeLen && (sizeof(buf) > (9 + beaconIeLen * 2))) {
2232 AR_DEBUG_PRINTF("\nBeaconIEs= ");
2233
2234 beacon_ie_pos = 0;
2235 A_MEMZERO(buf, sizeof(buf));
2236 sprintf(buf, "%s", beaconIetag);
2237 pos = buf + 9;
2238 for (i = beacon_ie_pos; i < beacon_ie_pos + beaconIeLen; i++) {
2239 AR_DEBUG_PRINTF("%2.2x ", assocInfo[i]);
2240 sprintf(pos, "%2.2x", assocInfo[i]);
2241 pos += 2;
2242 }
2243 AR_DEBUG_PRINTF("\n");
2244
2245 A_MEMZERO(&wrqu, sizeof(wrqu));
2246 wrqu.data.length = strlen(buf);
2247 wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
2248 }
2249
2250 if (assocRespLen && (sizeof(buf) > (12 + (assocRespLen * 2))))
2251 {
2252 assoc_resp_ie_pos = beaconIeLen + assocReqLen +
2253 sizeof(A_UINT16) + /* capinfo*/
2254 sizeof(A_UINT16) + /* status Code */
2255 sizeof(A_UINT16) ; /* associd */
2256 A_MEMZERO(buf, sizeof(buf));
2257 sprintf(buf, "%s", tag2);
2258 pos = buf + 12;
2259 AR_DEBUG_PRINTF("\nAssocRespIEs= ");
2260 /*
2261 * The Association Response Frame w.o. the WLAN header is delivered to
2262 * the host, so skip over to the IEs
2263 */
2264 for (i = assoc_resp_ie_pos; i < assoc_resp_ie_pos + assocRespLen - 6; i++)
2265 {
2266 AR_DEBUG_PRINTF("%2.2x ", assocInfo[i]);
2267 sprintf(pos, "%2.2x", assocInfo[i]);
2268 pos += 2;
2269 }
2270 AR_DEBUG_PRINTF("\n");
2271
2272 A_MEMZERO(&wrqu, sizeof(wrqu));
2273 wrqu.data.length = strlen(buf);
2274 wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
2275 }
2276
2277 if (assocReqLen && (sizeof(buf) > (17 + (assocReqLen * 2)))) {
2278 /*
2279 * assoc Request includes capability and listen interval. Skip these.
2280 */
2281 assoc_req_ie_pos = beaconIeLen +
2282 sizeof(A_UINT16) + /* capinfo*/
2283 sizeof(A_UINT16); /* listen interval */
2284
2285 A_MEMZERO(buf, sizeof(buf));
2286 sprintf(buf, "%s", tag1);
2287 pos = buf + 17;
2288 AR_DEBUG_PRINTF("AssocReqIEs= ");
2289 for (i = assoc_req_ie_pos; i < assoc_req_ie_pos + assocReqLen - 4; i++) {
2290 AR_DEBUG_PRINTF("%2.2x ", assocInfo[i]);
2291 sprintf(pos, "%2.2x", assocInfo[i]);
2292 pos += 2;;
2293 }
2294 AR_DEBUG_PRINTF("\n");
2295
2296 A_MEMZERO(&wrqu, sizeof(wrqu));
2297 wrqu.data.length = strlen(buf);
2298 wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
2299 }
2300
2301 #ifdef USER_KEYS
2302 if (ar->user_savedkeys_stat == USER_SAVEDKEYS_STAT_RUN &&
2303 ar->user_saved_keys.keyOk == TRUE)
2304 {
2305
2306 key_op_ctrl = KEY_OP_VALID_MASK & ~KEY_OP_INIT_TSC;
2307 if (ar->user_key_ctrl & AR6000_USER_SETKEYS_RSC_UNCHANGED) {
2308 key_op_ctrl &= ~KEY_OP_INIT_RSC;
2309 } else {
2310 key_op_ctrl |= KEY_OP_INIT_RSC;
2311 }
2312 ar6000_reinstall_keys(ar, key_op_ctrl);
2313 }
2314 #endif /* USER_KEYS */
2315
2316 /* flush data queues */
2317 ar6000_TxDataCleanup(ar);
2318
2319 netif_start_queue(ar->arNetDev);
2320
2321 if ((OPEN_AUTH == ar->arDot11AuthMode) &&
2322 (NONE_AUTH == ar->arAuthMode) &&
2323 (WEP_CRYPT == ar->arPairwiseCrypto))
2324 {
2325 if (!ar->arConnected) {
2326 ar6000_install_static_wep_keys(ar);
2327 }
2328 }
2329
2330 ar->arConnected = TRUE;
2331 ar->arConnectPending = FALSE;
2332
2333 reconnect_flag = 0;
2334
2335 A_MEMZERO(&wrqu, sizeof(wrqu));
2336 A_MEMCPY(wrqu.addr.sa_data, bssid, IEEE80211_ADDR_LEN);
2337 wrqu.addr.sa_family = ARPHRD_ETHER;
2338 wireless_send_event(ar->arNetDev, SIOCGIWAP, &wrqu, NULL);
2339 if ((ar->arNetworkType == ADHOC_NETWORK) && ar->arIbssPsEnable) {
2340 A_MEMZERO(ar->arNodeMap, sizeof(ar->arNodeMap));
2341 ar->arNodeNum = 0;
2342 ar->arNexEpId = ENDPOINT_2;
2343 }
2344
2345 }
2346
2347 void ar6000_set_numdataendpts(AR_SOFTC_T *ar, A_UINT32 num)
2348 {
2349 A_ASSERT(num <= (HTC_MAILBOX_NUM_MAX - 1));
2350 ar->arNumDataEndPts = num;
2351 }
2352
2353 void
2354 ar6000_disconnect_event(AR_SOFTC_T *ar, A_UINT8 reason, A_UINT8 *bssid,
2355 A_UINT8 assocRespLen, A_UINT8 *assocInfo, A_UINT16 protocolReasonStatus)
2356 {
2357 A_UINT8 i;
2358
2359 A_PRINTF("AR6000 disconnected");
2360 if (bssid[0] || bssid[1] || bssid[2] || bssid[3] || bssid[4] || bssid[5]) {
2361 A_PRINTF(" from %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",
2362 bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]);
2363 }
2364 A_PRINTF("\n");
2365
2366 AR_DEBUG_PRINTF("\nDisconnect Reason is %d", reason);
2367 AR_DEBUG_PRINTF("\nProtocol Reason/Status Code is %d", protocolReasonStatus);
2368 AR_DEBUG_PRINTF("\nAssocResp Frame = %s",
2369 assocRespLen ? " " : "NULL");
2370 for (i = 0; i < assocRespLen; i++) {
2371 if (!(i % 0x10)) {
2372 AR_DEBUG_PRINTF("\n");
2373 }
2374 AR_DEBUG_PRINTF("%2.2x ", assocInfo[i]);
2375 }
2376 AR_DEBUG_PRINTF("\n");
2377 /*
2378 * If the event is due to disconnect cmd from the host, only they the target
2379 * would stop trying to connect. Under any other condition, target would
2380 * keep trying to connect.
2381 *
2382 */
2383 if( reason == DISCONNECT_CMD)
2384 {
2385 ar->arConnectPending = FALSE;
2386 } else {
2387 ar->arConnectPending = TRUE;
2388 if (((reason == ASSOC_FAILED) && (protocolReasonStatus == 0x11)) ||
2389 ((reason == ASSOC_FAILED) && (protocolReasonStatus == 0x0) && (reconnect_flag == 1))) {
2390 ar->arConnected = TRUE;
2391 return;
2392 }
2393 }
2394 ar->arConnected = FALSE;
2395
2396 if( (reason != CSERV_DISCONNECT) || (reconnect_flag != 1) ) {
2397 reconnect_flag = 0;
2398 }
2399
2400 #ifdef USER_KEYS
2401 if (reason != CSERV_DISCONNECT)
2402 {
2403 ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT;
2404 ar->user_key_ctrl = 0;
2405 }
2406 #endif /* USER_KEYS */
2407
2408 netif_stop_queue(ar->arNetDev);
2409 A_MEMZERO(ar->arBssid, sizeof(ar->arBssid));
2410 ar->arBssChannel = 0;
2411 ar->arBeaconInterval = 0;
2412
2413 ar6000_TxDataCleanup(ar);
2414 }
2415
2416 void
2417 ar6000_regDomain_event(AR_SOFTC_T *ar, A_UINT32 regCode)
2418 {
2419 A_PRINTF("AR6000 Reg Code = 0x%x\n", regCode);
2420 ar->arRegCode = regCode;
2421 }
2422
2423 void
2424 ar6000_neighborReport_event(AR_SOFTC_T *ar, int numAps, WMI_NEIGHBOR_INFO *info)
2425 {
2426 static const char *tag = "PRE-AUTH";
2427 char buf[128];
2428 union iwreq_data wrqu;
2429 int i;
2430
2431 AR_DEBUG_PRINTF("AR6000 Neighbor Report Event\n");
2432 for (i=0; i < numAps; info++, i++) {
2433 AR_DEBUG_PRINTF("bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",
2434 info->bssid[0], info->bssid[1], info->bssid[2],
2435 info->bssid[3], info->bssid[4], info->bssid[5]);
2436 if (info->bssFlags & WMI_PREAUTH_CAPABLE_BSS) {
2437 AR_DEBUG_PRINTF("preauth-cap");
2438 }
2439 if (info->bssFlags & WMI_PMKID_VALID_BSS) {
2440 AR_DEBUG_PRINTF(" pmkid-valid\n");
2441 continue; /* we skip bss if the pmkid is already valid */
2442 }
2443 AR_DEBUG_PRINTF("\n");
2444 snprintf(buf, sizeof(buf), "%s%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x",
2445 tag,
2446 info->bssid[0], info->bssid[1], info->bssid[2],
2447 info->bssid[3], info->bssid[4], info->bssid[5],
2448 i, info->bssFlags);
2449 A_MEMZERO(&wrqu, sizeof(wrqu));
2450 wrqu.data.length = strlen(buf);
2451 wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
2452 }
2453 }
2454
2455 void
2456 ar6000_tkip_micerr_event(AR_SOFTC_T *ar, A_UINT8 keyid, A_BOOL ismcast)
2457 {
2458 static const char *tag = "MLME-MICHAELMICFAILURE.indication";
2459 char buf[128];
2460 union iwreq_data wrqu;
2461
2462 A_PRINTF("AR6000 TKIP MIC error received for keyid %d %scast\n",
2463 keyid, ismcast ? "multi": "uni");
2464 snprintf(buf, sizeof(buf), "%s(keyid=%d %scat)", tag, keyid,
2465 ismcast ? "multi" : "uni");
2466 memset(&wrqu, 0, sizeof(wrqu));
2467 wrqu.data.length = strlen(buf);
2468 wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
2469 }
2470
2471 void
2472 ar6000_scanComplete_event(AR_SOFTC_T *ar, A_STATUS status)
2473 {
2474 AR_DEBUG_PRINTF("AR6000 scan complete: %d\n", status);
2475
2476 ar->scan_complete = 1;
2477 wake_up_interruptible(&ar6000_scan_queue);
2478 }
2479
2480 void
2481 ar6000_targetStats_event(AR_SOFTC_T *ar, WMI_TARGET_STATS *pTarget)
2482 {
2483 TARGET_STATS *pStats = &ar->arTargetStats;
2484 A_UINT8 ac;
2485
2486 /*A_PRINTF("AR6000 updating target stats\n");*/
2487 pStats->tx_packets += pTarget->txrxStats.tx_stats.tx_packets;
2488 pStats->tx_bytes += pTarget->txrxStats.tx_stats.tx_bytes;
2489 pStats->tx_unicast_pkts += pTarget->txrxStats.tx_stats.tx_unicast_pkts;
2490 pStats->tx_unicast_bytes += pTarget->txrxStats.tx_stats.tx_unicast_bytes;
2491 pStats->tx_multicast_pkts += pTarget->txrxStats.tx_stats.tx_multicast_pkts;
2492 pStats->tx_multicast_bytes += pTarget->txrxStats.tx_stats.tx_multicast_bytes;
2493 pStats->tx_broadcast_pkts += pTarget->txrxStats.tx_stats.tx_broadcast_pkts;
2494 pStats->tx_broadcast_bytes += pTarget->txrxStats.tx_stats.tx_broadcast_bytes;
2495 pStats->tx_rts_success_cnt += pTarget->txrxStats.tx_stats.tx_rts_success_cnt;
2496 for(ac = 0; ac < WMM_NUM_AC; ac++)
2497 pStats->tx_packet_per_ac[ac] += pTarget->txrxStats.tx_stats.tx_packet_per_ac[ac];
2498 pStats->tx_errors += pTarget->txrxStats.tx_stats.tx_errors;
2499 pStats->tx_failed_cnt += pTarget->txrxStats.tx_stats.tx_failed_cnt;
2500 pStats->tx_retry_cnt += pTarget->txrxStats.tx_stats.tx_retry_cnt;
2501 pStats->tx_rts_fail_cnt += pTarget->txrxStats.tx_stats.tx_rts_fail_cnt;
2502 pStats->tx_unicast_rate = wmi_get_rate(pTarget->txrxStats.tx_stats.tx_unicast_rate);
2503
2504 pStats->rx_packets += pTarget->txrxStats.rx_stats.rx_packets;
2505 pStats->rx_bytes += pTarget->txrxStats.rx_stats.rx_bytes;
2506 pStats->rx_unicast_pkts += pTarget->txrxStats.rx_stats.rx_unicast_pkts;
2507 pStats->rx_unicast_bytes += pTarget->txrxStats.rx_stats.rx_unicast_bytes;
2508 pStats->rx_multicast_pkts += pTarget->txrxStats.rx_stats.rx_multicast_pkts;
2509 pStats->rx_multicast_bytes += pTarget->txrxStats.rx_stats.rx_multicast_bytes;
2510 pStats->rx_broadcast_pkts += pTarget->txrxStats.rx_stats.rx_broadcast_pkts;
2511 pStats->rx_broadcast_bytes += pTarget->txrxStats.rx_stats.rx_broadcast_bytes;
2512 pStats->rx_fragment_pkt += pTarget->txrxStats.rx_stats.rx_fragment_pkt;
2513 pStats->rx_errors += pTarget->txrxStats.rx_stats.rx_errors;
2514 pStats->rx_crcerr += pTarget->txrxStats.rx_stats.rx_crcerr;
2515 pStats->rx_key_cache_miss += pTarget->txrxStats.rx_stats.rx_key_cache_miss;
2516 pStats->rx_decrypt_err += pTarget->txrxStats.rx_stats.rx_decrypt_err;
2517 pStats->rx_duplicate_frames += pTarget->txrxStats.rx_stats.rx_duplicate_frames;
2518 pStats->rx_unicast_rate = wmi_get_rate(pTarget->txrxStats.rx_stats.rx_unicast_rate);
2519
2520
2521 pStats->tkip_local_mic_failure
2522 += pTarget->txrxStats.tkipCcmpStats.tkip_local_mic_failure;
2523 pStats->tkip_counter_measures_invoked
2524 += pTarget->txrxStats.tkipCcmpStats.tkip_counter_measures_invoked;
2525 pStats->tkip_replays += pTarget->txrxStats.tkipCcmpStats.tkip_replays;
2526 pStats->tkip_format_errors += pTarget->txrxStats.tkipCcmpStats.tkip_format_errors;
2527 pStats->ccmp_format_errors += pTarget->txrxStats.tkipCcmpStats.ccmp_format_errors;
2528 pStats->ccmp_replays += pTarget->txrxStats.tkipCcmpStats.ccmp_replays;
2529
2530
2531 pStats->power_save_failure_cnt += pTarget->pmStats.power_save_failure_cnt;
2532 pStats->noise_floor_calibation = pTarget->noise_floor_calibation;
2533
2534 pStats->cs_bmiss_cnt += pTarget->cservStats.cs_bmiss_cnt;
2535 pStats->cs_lowRssi_cnt += pTarget->cservStats.cs_lowRssi_cnt;
2536 pStats->cs_connect_cnt += pTarget->cservStats.cs_connect_cnt;
2537 pStats->cs_disconnect_cnt += pTarget->cservStats.cs_disconnect_cnt;
2538 pStats->cs_aveBeacon_snr = pTarget->cservStats.cs_aveBeacon_snr;
2539 pStats->cs_aveBeacon_rssi = pTarget->cservStats.cs_aveBeacon_rssi;
2540 pStats->cs_lastRoam_msec = pTarget->cservStats.cs_lastRoam_msec;
2541 pStats->cs_snr = pTarget->cservStats.cs_snr;
2542 pStats->cs_rssi = pTarget->cservStats.cs_rssi;
2543
2544 pStats->lq_val = pTarget->lqVal;
2545
2546 pStats->wow_num_pkts_dropped += pTarget->wowStats.wow_num_pkts_dropped;
2547 pStats->wow_num_host_pkt_wakeups += pTarget->wowStats.wow_num_host_pkt_wakeups;
2548 pStats->wow_num_host_event_wakeups += pTarget->wowStats.wow_num_host_event_wakeups;
2549 pStats->wow_num_events_discarded += pTarget->wowStats.wow_num_events_discarded;
2550
2551 ar->statsUpdatePending = FALSE;
2552 wake_up(&arEvent);
2553 }
2554
2555 void
2556 ar6000_rssiThreshold_event(AR_SOFTC_T *ar, WMI_RSSI_THRESHOLD_VAL newThreshold, A_INT16 rssi)
2557 {
2558 USER_RSSI_THOLD userRssiThold;
2559
2560 userRssiThold.tag = rssi_map[newThreshold].tag;
2561 userRssiThold.rssi = rssi;
2562 AR_DEBUG2_PRINTF("rssi Threshold range = %d tag = %d rssi = %d\n", newThreshold, userRssiThold.tag, rssi);
2563 #ifdef SEND_EVENT_TO_APP
2564 ar6000_send_event_to_app(ar, WMI_RSSI_THRESHOLD_EVENTID,(A_UINT8 *)&userRssiThold, sizeof(USER_RSSI_THOLD));
2565 #endif
2566 }
2567
2568
2569 void
2570 ar6000_hbChallengeResp_event(AR_SOFTC_T *ar, A_UINT32 cookie, A_UINT32 source)
2571 {
2572 if (source == APP_HB_CHALLENGE) {
2573 /* Report it to the app in case it wants a positive acknowledgement */
2574 #ifdef SEND_EVENT_TO_APP
2575 ar6000_send_event_to_app(ar, WMIX_HB_CHALLENGE_RESP_EVENTID,
2576 (A_UINT8 *)&cookie, sizeof(cookie));
2577 #endif
2578 } else {
2579 /* This would ignore the replys that come in after their due time */
2580 if (cookie == ar->arHBChallengeResp.seqNum) {
2581 ar->arHBChallengeResp.outstanding = FALSE;
2582 }
2583 }
2584 }
2585
2586
2587 void
2588 ar6000_reportError_event(AR_SOFTC_T *ar, WMI_TARGET_ERROR_VAL errorVal)
2589 {
2590 char *errString[] = {
2591 [WMI_TARGET_PM_ERR_FAIL] "WMI_TARGET_PM_ERR_FAIL",
2592 [WMI_TARGET_KEY_NOT_FOUND] "WMI_TARGET_KEY_NOT_FOUND",
2593 [WMI_TARGET_DECRYPTION_ERR] "WMI_TARGET_DECRYPTION_ERR",
2594 [WMI_TARGET_BMISS] "WMI_TARGET_BMISS",
2595 [WMI_PSDISABLE_NODE_JOIN] "WMI_PSDISABLE_NODE_JOIN"
2596 };
2597
2598 A_PRINTF("AR6000 Error on Target. Error = 0x%x\n", errorVal);
2599
2600 /* One error is reported at a time, and errorval is a bitmask */
2601 if(errorVal & (errorVal - 1))
2602 return;
2603
2604 A_PRINTF("AR6000 Error type = ");
2605 switch(errorVal)
2606 {
2607 case WMI_TARGET_PM_ERR_FAIL:
2608 case WMI_TARGET_KEY_NOT_FOUND:
2609 case WMI_TARGET_DECRYPTION_ERR:
2610 case WMI_TARGET_BMISS:
2611 case WMI_PSDISABLE_NODE_JOIN:
2612 A_PRINTF("%s\n", errString[errorVal]);
2613 break;
2614 default:
2615 A_PRINTF("INVALID\n");
2616 break;
2617 }
2618
2619 }
2620
2621
2622 void
2623 ar6000_cac_event(AR_SOFTC_T *ar, A_UINT8 ac, A_UINT8 cacIndication,
2624 A_UINT8 statusCode, A_UINT8 *tspecSuggestion)
2625 {
2626 WMM_TSPEC_IE *tspecIe;
2627
2628 /*
2629 * This is the TSPEC IE suggestion from AP.
2630 * Suggestion provided by AP under some error
2631 * cases, could be helpful for the host app.
2632 * Check documentation.
2633 */
2634 tspecIe = (WMM_TSPEC_IE *)tspecSuggestion;
2635
2636 /*
2637 * What do we do, if we get TSPEC rejection? One thought
2638 * that comes to mind is implictly delete the pstream...
2639 */
2640 A_PRINTF("AR6000 CAC notification. "
2641 "AC = %d, cacIndication = 0x%x, statusCode = 0x%x\n",
2642 ac, cacIndication, statusCode);
2643 }
2644
2645 #define AR6000_PRINT_BSSID(_pBss) do { \
2646 A_PRINTF("%2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ",\
2647 (_pBss)[0],(_pBss)[1],(_pBss)[2],(_pBss)[3],\
2648 (_pBss)[4],(_pBss)[5]); \
2649 } while(0)
2650
2651 void
2652 ar6000_roam_tbl_event(AR_SOFTC_T *ar, WMI_TARGET_ROAM_TBL *pTbl)
2653 {
2654 A_UINT8 i;
2655
2656 A_PRINTF("ROAM TABLE NO OF ENTRIES is %d ROAM MODE is %d\n",
2657 pTbl->numEntries, pTbl->roamMode);
2658 for (i= 0; i < pTbl->numEntries; i++) {
2659 A_PRINTF("[%d]bssid %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x ", i,
2660 pTbl->bssRoamInfo[i].bssid[0], pTbl->bssRoamInfo[i].bssid[1],
2661 pTbl->bssRoamInfo[i].bssid[2],
2662 pTbl->bssRoamInfo[i].bssid[3],
2663 pTbl->bssRoamInfo[i].bssid[4],
2664 pTbl->bssRoamInfo[i].bssid[5]);
2665 A_PRINTF("RSSI %d RSSIDT %d LAST RSSI %d UTIL %d ROAM_UTIL %d"
2666 " BIAS %d\n",
2667 pTbl->bssRoamInfo[i].rssi,
2668 pTbl->bssRoamInfo[i].rssidt,
2669 pTbl->bssRoamInfo[i].last_rssi,
2670 pTbl->bssRoamInfo[i].util,
2671 pTbl->bssRoamInfo[i].roam_util,
2672 pTbl->bssRoamInfo[i].bias);
2673 }
2674 }
2675
2676 void
2677 ar6000_wow_list_event(struct ar6_softc *ar, A_UINT8 num_filters, WMI_GET_WOW_LIST_REPLY *wow_reply)
2678 {
2679 A_UINT8 i,j;
2680
2681 /*Each event now contains exactly one filter, see bug 26613*/
2682 A_PRINTF("WOW pattern %d of %d patterns\n", wow_reply->this_filter_num, wow_reply->num_filters);
2683 A_PRINTF("wow mode = %s host mode = %s\n",
2684 (wow_reply->wow_mode == 0? "disabled":"enabled"),
2685 (wow_reply->host_mode == 1 ? "awake":"asleep"));
2686
2687
2688 /*If there are no patterns, the reply will only contain generic
2689 WoW information. Pattern information will exist only if there are
2690 patterns present. Bug 26716*/
2691
2692 /* If this event contains pattern information, display it*/
2693 if (wow_reply->this_filter_num) {
2694 i=0;
2695 A_PRINTF("id=%d size=%d offset=%d\n",
2696 wow_reply->wow_filters[i].wow_filter_id,
2697 wow_reply->wow_filters[i].wow_filter_size,
2698 wow_reply->wow_filters[i].wow_filter_offset);
2699 A_PRINTF("wow pattern = ");
2700 for (j=0; j< wow_reply->wow_filters[i].wow_filter_size; j++) {
2701 A_PRINTF("%2.2x",wow_reply->wow_filters[i].wow_filter_pattern[j]);
2702 }
2703
2704 A_PRINTF("\nwow mask = ");
2705 for (j=0; j< wow_reply->wow_filters[i].wow_filter_size; j++) {
2706 A_PRINTF("%2.2x",wow_reply->wow_filters[i].wow_filter_mask[j]);
2707 }
2708 A_PRINTF("\n");
2709 }
2710 }
2711
2712 /*
2713 * Report the Roaming related data collected on the target
2714 */
2715 void
2716 ar6000_display_roam_time(WMI_TARGET_ROAM_TIME *p)
2717 {
2718 A_PRINTF("Disconnect Data : BSSID: ");
2719 AR6000_PRINT_BSSID(p->disassoc_bssid);
2720 A_PRINTF(" RSSI %d DISASSOC Time %d NO_TXRX_TIME %d\n",
2721 p->disassoc_bss_rssi,p->disassoc_time,
2722 p->no_txrx_time);
2723 A_PRINTF("Connect Data: BSSID: ");
2724 AR6000_PRINT_BSSID(p->assoc_bssid);
2725 A_PRINTF(" RSSI %d ASSOC Time %d TXRX_TIME %d\n",
2726 p->assoc_bss_rssi,p->assoc_time,
2727 p->allow_txrx_time);
2728 A_PRINTF("Last Data Tx Time (b4 Disassoc) %d "\
2729 "First Data Tx Time (after Assoc) %d\n",
2730 p->last_data_txrx_time, p->first_data_txrx_time);
2731 }
2732
2733 void
2734 ar6000_roam_data_event(AR_SOFTC_T *ar, WMI_TARGET_ROAM_DATA *p)
2735 {
2736 switch (p->roamDataType) {
2737 case ROAM_DATA_TIME:
2738 ar6000_display_roam_time(&p->u.roamTime);
2739 break;
2740 default:
2741 break;
2742 }
2743 }
2744
2745 void
2746 ar6000_bssInfo_event_rx(AR_SOFTC_T *ar, A_UINT8 *datap, int len)
2747 {
2748 struct sk_buff *skb;
2749 WMI_BSS_INFO_HDR *bih = (WMI_BSS_INFO_HDR *)datap;
2750
2751
2752 if (!ar->arMgmtFilter) {
2753 return;
2754 }
2755 if (((ar->arMgmtFilter & IEEE80211_FILTER_TYPE_BEACON) &&
2756 (bih->frameType != BEACON_FTYPE)) ||
2757 ((ar->arMgmtFilter & IEEE80211_FILTER_TYPE_PROBE_RESP) &&
2758 (bih->frameType != PROBERESP_FTYPE)))
2759 {
2760 return;
2761 }
2762
2763 if ((skb = A_NETBUF_ALLOC_RAW(len)) != NULL) {
2764
2765 A_NETBUF_PUT(skb, len);
2766 A_MEMCPY(A_NETBUF_DATA(skb), datap, len);
2767 skb->dev = ar->arNetDev;
2768 printk("MAC RAW...\n");
2769 // skb->mac.raw = A_NETBUF_DATA(skb);
2770 skb->ip_summed = CHECKSUM_NONE;
2771 skb->pkt_type = PACKET_OTHERHOST;
2772 skb->protocol = __constant_htons(0x0019);
2773 netif_rx(skb);
2774 }
2775 }
2776
2777 A_UINT32 wmiSendCmdNum;
2778
2779 A_STATUS
2780 ar6000_control_tx(void *devt, void *osbuf, WMI_PRI_STREAM_ID streamID)
2781 {
2782 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2783 A_STATUS status = A_OK;
2784 struct ar_cookie *cookie = NULL;
2785 int i;
2786
2787 /* take lock to protect ar6000_alloc_cookie() */
2788 AR6000_SPIN_LOCK(&ar->arLock, 0);
2789
2790 do {
2791
2792 AR_DEBUG2_PRINTF("ar_contrstatus = ol_tx: skb=0x%x, len=0x%x, sid=%d\n",
2793 (A_UINT32)osbuf, A_NETBUF_LEN(osbuf), streamID);
2794
2795 if ((streamID == WMI_CONTROL_PRI) && (ar->arWMIControlEpFull)) {
2796 /* control endpoint is full, don't allocate resources, we
2797 * are just going to drop this packet */
2798 cookie = NULL;
2799 AR_DEBUG_PRINTF(" WMI Control EP full, dropping packet : 0x%X, len:%d \n",
2800 (A_UINT32)osbuf, A_NETBUF_LEN(osbuf));
2801 } else {
2802 cookie = ar6000_alloc_cookie(ar);
2803 }
2804
2805 if (cookie == NULL) {
2806 status = A_NO_MEMORY;
2807 break;
2808 }
2809
2810 if(logWmiRawMsgs) {
2811 A_PRINTF("WMI cmd send, msgNo %d :", wmiSendCmdNum);
2812 for(i = 0; i < a_netbuf_to_len(osbuf); i++)
2813 A_PRINTF("%x ", ((A_UINT8 *)a_netbuf_to_data(osbuf))[i]);
2814 A_PRINTF("\n");
2815 }
2816
2817 wmiSendCmdNum++;
2818
2819 } while (FALSE);
2820
2821 if (cookie != NULL) {
2822 /* got a structure to send it out on */
2823 ar->arTxPending[streamID]++;
2824
2825 if (streamID != WMI_CONTROL_PRI) {
2826 ar->arTotalTxDataPending++;
2827 }
2828 }
2829
2830 AR6000_SPIN_UNLOCK(&ar->arLock, 0);
2831
2832 if (cookie != NULL) {
2833 cookie->arc_bp[0] = (A_UINT32)osbuf;
2834 cookie->arc_bp[1] = 0;
2835 SET_HTC_PACKET_INFO_TX(&cookie->HtcPkt,
2836 cookie,
2837 A_NETBUF_DATA(osbuf),
2838 A_NETBUF_LEN(osbuf),
2839 arWMIStream2EndpointID(ar,streamID),
2840 AR6K_CONTROL_PKT_TAG);
2841 /* this interface is asynchronous, if there is an error, cleanup will happen in the
2842 * TX completion callback */
2843 HTCSendPkt(ar->arHtcTarget, &cookie->HtcPkt);
2844 status = A_OK;
2845 }
2846
2847 return status;
2848 }
2849
2850 /* indicate tx activity or inactivity on a WMI stream */
2851 void ar6000_indicate_tx_activity(void *devt, A_UINT8 TrafficClass, A_BOOL Active)
2852 {
2853 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
2854 WMI_PRI_STREAM_ID streamid;
2855
2856 if (ar->arWmiEnabled) {
2857 streamid = wmi_get_stream_id(ar->arWmi, TrafficClass);
2858 } else {
2859 /* for mbox ping testing, the traffic class is mapped directly as a stream ID,
2860 * see handling of AR6000_XIOCTL_TRAFFIC_ACTIVITY_CHANGE in ioctl.c */
2861 streamid = (WMI_PRI_STREAM_ID)TrafficClass;
2862 }
2863
2864 /* notify HTC, this may cause credit distribution changes */
2865
2866 HTCIndicateActivityChange(ar->arHtcTarget,
2867 arWMIStream2EndpointID(ar,streamid),
2868 Active);
2869
2870 }
2871
2872 module_init(ar6000_init_module);
2873 module_exit(ar6000_cleanup_module);
2874
2875 /* Init cookie queue */
2876 static void
2877 ar6000_cookie_init(AR_SOFTC_T *ar)
2878 {
2879 A_UINT32 i;
2880
2881 ar->arCookieList = NULL;
2882 A_MEMZERO(s_ar_cookie_mem, sizeof(s_ar_cookie_mem));
2883
2884 for (i = 0; i < MAX_COOKIE_NUM; i++) {
2885 ar6000_free_cookie(ar, &s_ar_cookie_mem[i]);
2886 }
2887 }
2888
2889 /* cleanup cookie queue */
2890 static void
2891 ar6000_cookie_cleanup(AR_SOFTC_T *ar)
2892 {
2893 /* It is gone .... */
2894 ar->arCookieList = NULL;
2895 }
2896
2897 /* Init cookie queue */
2898 static void
2899 ar6000_free_cookie(AR_SOFTC_T *ar, struct ar_cookie * cookie)
2900 {
2901 /* Insert first */
2902 A_ASSERT(ar != NULL);
2903 A_ASSERT(cookie != NULL);
2904 cookie->arc_list_next = ar->arCookieList;
2905 ar->arCookieList = cookie;
2906 }
2907
2908 /* cleanup cookie queue */
2909 static struct ar_cookie *
2910 ar6000_alloc_cookie(AR_SOFTC_T *ar)
2911 {
2912 struct ar_cookie *cookie;
2913
2914 cookie = ar->arCookieList;
2915 if(cookie != NULL)
2916 {
2917 ar->arCookieList = cookie->arc_list_next;
2918 }
2919
2920 return cookie;
2921 }
2922
2923 #ifdef SEND_EVENT_TO_APP
2924 /*
2925 * This function is used to send event which come from taget to
2926 * the application. The buf which send to application is include
2927 * the event ID and event content.
2928 */
2929 #define EVENT_ID_LEN 2
2930 void ar6000_send_event_to_app(AR_SOFTC_T *ar, A_UINT16 eventId,
2931 A_UINT8 *datap, int len)
2932 {
2933
2934 #if (WIRELESS_EXT >= 15)
2935
2936 /* note: IWEVCUSTOM only exists in wireless extensions after version 15 */
2937
2938 char *buf;
2939 A_UINT16 size;
2940 union iwreq_data wrqu;
2941
2942 size = len + EVENT_ID_LEN;
2943
2944 if (size > IW_CUSTOM_MAX) {
2945 AR_DEBUG_PRINTF("WMI event ID : 0x%4.4X, len = %d too big for IWEVCUSTOM (max=%d) \n",
2946 eventId, size, IW_CUSTOM_MAX);
2947 return;
2948 }
2949
2950 buf = A_MALLOC_NOWAIT(size);
2951 A_MEMZERO(buf, size);
2952 A_MEMCPY(buf, &eventId, EVENT_ID_LEN);
2953 A_MEMCPY(buf+EVENT_ID_LEN, datap, len);
2954
2955 //AR_DEBUG_PRINTF("event ID = %d,len = %d\n",*(A_UINT16*)buf, size);
2956 A_MEMZERO(&wrqu, sizeof(wrqu));
2957 wrqu.data.length = size;
2958 wireless_send_event(ar->arNetDev, IWEVCUSTOM, &wrqu, buf);
2959
2960 A_FREE(buf);
2961 #endif
2962
2963
2964 }
2965 #endif
2966
2967
2968 void
2969 ar6000_tx_retry_err_event(void *devt)
2970 {
2971 AR_DEBUG2_PRINTF("Tx retries reach maximum!\n");
2972 }
2973
2974 void
2975 ar6000_snrThresholdEvent_rx(void *devt, WMI_SNR_THRESHOLD_VAL newThreshold, A_UINT8 snr)
2976 {
2977 AR_DEBUG2_PRINTF("snr threshold range %d, snr %d\n", newThreshold, snr);
2978 }
2979
2980 void
2981 ar6000_lqThresholdEvent_rx(void *devt, WMI_LQ_THRESHOLD_VAL newThreshold, A_UINT8 lq)
2982 {
2983 AR_DEBUG2_PRINTF("lq threshold range %d, lq %d\n", newThreshold, lq);
2984 }
2985
2986
2987
2988 A_UINT32
2989 a_copy_to_user(void *to, const void *from, A_UINT32 n)
2990 {
2991 return(copy_to_user(to, from, n));
2992 }
2993
2994 A_UINT32
2995 a_copy_from_user(void *to, const void *from, A_UINT32 n)
2996 {
2997 return(copy_from_user(to, from, n));
2998 }
2999
3000
3001 A_STATUS
3002 ar6000_get_driver_cfg(struct net_device *dev,
3003 A_UINT16 cfgParam,
3004 void *result)
3005 {
3006
3007 A_STATUS ret = 0;
3008
3009 switch(cfgParam)
3010 {
3011 case AR6000_DRIVER_CFG_GET_WLANNODECACHING:
3012 *((A_UINT32 *)result) = wlanNodeCaching;
3013 break;
3014 case AR6000_DRIVER_CFG_LOG_RAW_WMI_MSGS:
3015 *((A_UINT32 *)result) = logWmiRawMsgs;
3016 break;
3017 default:
3018 ret = EINVAL;
3019 break;
3020 }
3021
3022 return ret;
3023 }
3024
3025 void
3026 ar6000_keepalive_rx(void *devt, A_UINT8 configured)
3027 {
3028 AR_SOFTC_T *ar = (AR_SOFTC_T *)devt;
3029
3030 ar->arKeepaliveConfigured = configured;
3031 wake_up(&arEvent);
3032 }
3033
3034 void
3035 ar6000_pmkid_list_event(void *devt, A_UINT8 numPMKID, WMI_PMKID *pmkidList)
3036 {
3037 A_UINT8 i, j;
3038
3039 A_PRINTF("Number of Cached PMKIDs is %d\n", numPMKID);
3040
3041 for (i = 0; i < numPMKID; i++) {
3042 A_PRINTF("\nPMKID %d ", i);
3043 for (j = 0; j < WMI_PMKID_LEN; j++) {
3044 A_PRINTF("%2.2x", pmkidList->pmkid[j]);
3045 }
3046 pmkidList++;
3047 }
3048 }
3049
3050 #ifdef USER_KEYS
3051 static A_STATUS
3052
3053 ar6000_reinstall_keys(AR_SOFTC_T *ar, A_UINT8 key_op_ctrl)
3054 {
3055 A_STATUS status = A_OK;
3056 struct ieee80211req_key *uik = &ar->user_saved_keys.ucast_ik;
3057 struct ieee80211req_key *bik = &ar->user_saved_keys.bcast_ik;
3058 CRYPTO_TYPE keyType = ar->user_saved_keys.keyType;
3059
3060 if (IEEE80211_CIPHER_CCKM_KRK != uik->ik_type) {
3061 if (NONE_CRYPT == keyType) {
3062 goto _reinstall_keys_out;
3063 }
3064
3065 if (uik->ik_keylen) {
3066 status = wmi_addKey_cmd(ar->arWmi, uik->ik_keyix,
3067 ar->user_saved_keys.keyType, PAIRWISE_USAGE,
3068 uik->ik_keylen, (A_UINT8 *)&uik->ik_keyrsc,
3069 uik->ik_keydata, key_op_ctrl, SYNC_BEFORE_WMIFLAG);
3070 }
3071
3072 } else {
3073 status = wmi_add_krk_cmd(ar->arWmi, uik->ik_keydata);
3074 }
3075
3076 if (IEEE80211_CIPHER_CCKM_KRK != bik->ik_type) {
3077 if (NONE_CRYPT == keyType) {
3078 goto _reinstall_keys_out;
3079 }
3080
3081 if (bik->ik_keylen) {
3082 status = wmi_addKey_cmd(ar->arWmi, bik->ik_keyix,
3083 ar->user_saved_keys.keyType, GROUP_USAGE,
3084 bik->ik_keylen, (A_UINT8 *)&bik->ik_keyrsc,
3085 bik->ik_keydata, key_op_ctrl, NO_SYNC_WMIFLAG);
3086 }
3087 } else {
3088 status = wmi_add_krk_cmd(ar->arWmi, bik->ik_keydata);
3089 }
3090
3091 _reinstall_keys_out:
3092 ar->user_savedkeys_stat = USER_SAVEDKEYS_STAT_INIT;
3093 ar->user_key_ctrl = 0;
3094
3095 return status;
3096 }
3097 #endif /* USER_KEYS */
3098
3099
3100 void
3101 ar6000_dset_open_req(
3102 void *context,
3103 A_UINT32 id,
3104 A_UINT32 targHandle,
3105 A_UINT32 targReplyFn,
3106 A_UINT32 targReplyArg)
3107 {
3108 }
3109
3110 void
3111 ar6000_dset_close(
3112 void *context,
3113 A_UINT32 access_cookie)
3114 {
3115 return;
3116 }
3117
3118 void
3119 ar6000_dset_data_req(
3120 void *context,
3121 A_UINT32 accessCookie,
3122 A_UINT32 offset,
3123 A_UINT32 length,
3124 A_UINT32 targBuf,
3125 A_UINT32 targReplyFn,
3126 A_UINT32 targReplyArg)
3127 {
3128 }
OpenWrt SVN history