OpenWrt XBurst

OpenWrt XBurst Git Source Tree

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

Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl

OpenWrt XBurst

OpenWrt XBurst Git Source Tree

Root/target/linux/s3c24xx/files-2.6.30/drivers/ar6000/ar6000/ar6000_drv.c

interactive