?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / usb / net / Zydas / zd1211.c
blob47dec8363fa3f4c8ebaaf9a36b31b51b047d0963
1 /* src/zd1211.c
2 *
3 *
4 *
5 * Copyright (C) 2004 ZyDAS Inc. All Rights Reserved.
6 * --------------------------------------------------------------------
7 *
8 *
9 *
10 * The contents of this file are subject to the Mozilla Public
11 * License Version 1.1 (the "License"); you may not use this file
12 * except in compliance with the License. You may obtain a copy of
13 * the License at http://www.mozilla.org/MPL/
14 *
15 * Software distributed under the License is distributed on an "AS
16 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
17 * implied. See the License for the specific language governing
18 * rights and limitations under the License.
19 *
20 * Alternatively, the contents of this file may be used under the
21 * terms of the GNU Public License version 2 (the "GPL"), in which
22 * case the provisions of the GPL are applicable instead of the
23 * above. If you wish to allow the use of your version of this file
24 * only under the terms of the GPL and not to allow others to use
25 * your version of this file under the MPL, indicate your decision
26 * by deleting the provisions above and replace them with the notice
27 * and other provisions required by the GPL. If you do not delete
28 * the provisions above, a recipient may use your version of this
29 * file under either the MPL or the GPL.
30 *
31 * -------------------------------------------------------------------- */
32
33 #include <linux/config.h>
34 #include <net/checksum.h>
35 #include <linux/tcp.h>
36 #include <linux/udp.h>
37 #include <linux/hardirq.h>
38
39 #include "zddebug.h"
40 #include "zdhw.h"
41 #include "zd1211.h"
42 #include "zdcompat.h"
43 #include "zdglobal.h"
44 #include "zdmisc.h"
45
46 u8 WS11UPh[]
47 #if fMERGE_RX_FRAME
48 #if ZDCONF_LP_SUPPORT == 1
49 #include "WS11UPhR_Turbo.h"
50 #elif ZDCONF_LP_SUPPORT == 0
51 #include "WS11UPhR.h"
52 #else
53 #error "ZDCONF_LP_SUPPORT isn't defined"
54 #endif
55 u8 WS11UPhm[]
56 #include "WS11UPhm.h"
57 #else
58 #include "WS11UPhm.h"
59 #endif
60
61 u8 WS11Ur[]
62 #include "WS11Ur.h"
63
64 u8 WS11Ub[]
65 #include "WS11Ub.h"
66
67
68 u8 WS11Ur2[(0xEE00 - 0xEC00) * 2] = { 0x0F, 0x9F, 0x00, 0xEE }; // JMP 0xEE00
69
70
71 extern zd_80211Obj_t dot11Obj;
72 extern struct net_device *g_dev;
73
74 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) /* tune me! */
75 # define SUBMIT_URB(u,f) usb_submit_urb(u,f)
76 # define USB_ALLOC_URB(u,f) usb_alloc_urb(u,f)
77 #else
78 # define SUBMIT_URB(u,f) usb_submit_urb(u)
79 # define USB_ALLOC_URB(u,f) usb_alloc_urb(u)
80 #endif
81
82 #if defined CONFIG_ARCH_W341 || defined CONFIG_ARCH_W321 || defined CONFIG_ARCH_W311
83 #define WLAN_LED 4
84 #define MCPU_GPIO_INPUT 0
85 #define MCPU_GPIO_OUTPUT 1
86 #define MCPU_GPIO_HIGH 1
87 #define MCPU_GPIO_LOW 0
88 /*
89 #elif defined CONFIG_ARCH_W311
90 #define WLAN_LED_REG CPE_WLAN_LED_REG_VA_BASE
91 #define WLAN_LED 0
92 #define STR1_LED 1
93 #define STR2_LED 2
94 #define STR3_LED 3
95 #define STR4_LED 4
96 #define STR5_LED 5
97 #define PIO(x) (1<<x)
98 */
99 #endif
100
101
102
103 inline void zd1211_DumpErrorCode(struct zd1205_private *macp, int err)
104 {
105 switch (err){
106 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
107 case USB_ST_CRC:
108 ZD1211DEBUG(0, "USB_ST_CRC\n");
109 break;
110
111 //case USB_ST_BITSTUFF:
112 //ZD1211DEBUG(0, "USB_ST_BITSTUFF\n");
113 //break;
114
115 //case USB_ST_NORESPONSE:
116 //ZD1211DEBUG(0, "USB_ST_NORESPONSE\n");
117 //break;
118
119 case USB_ST_DATAOVERRUN:
120 ZD1211DEBUG(0, "USB_ST_DATAOVERRUN\n");
121 break;
122
123 case USB_ST_DATAUNDERRUN:
124 ZD1211DEBUG(0, "USB_ST_DATAUNDERRUN\n");
125 break;
126
127 case USB_ST_BUFFEROVERRUN:
128 ZD1211DEBUG(0, "USB_ST_BUFFEROVERRUN\n");
129 break;
130
131 case USB_ST_BUFFERUNDERRUN:
132 ZD1211DEBUG(0, "USB_ST_BUFFERUNDERRUN\n");
133 break;
134
135 case USB_ST_INTERNALERROR:
136 ZD1211DEBUG(0, "USB_ST_INTERNALERROR\n");
137 break;
138
139 //case USB_ST_SHORT_PACKET:
140 //ZD1211DEBUG(0, "USB_ST_SHORT_PACKET\n");
141 //break;
142
143 case USB_ST_PARTIAL_ERROR:
144 ZD1211DEBUG(0, "USB_ST_PARTIAL_ERROR\n");
145 break;
146
147 case USB_ST_URB_KILLED:
148 ZD1211DEBUG(0, "USB_ST_URB_KILLED\n");
149 break;
150
151 case USB_ST_URB_PENDING:
152 ZD1211DEBUG(0, "USB_ST_URB_PENDING\n");
153 break;
154
155 case USB_ST_REMOVED:
156 ZD1211DEBUG(0, "USB_ST_REMOVED\n");
157 break;
158
159 case USB_ST_TIMEOUT:
160 ZD1211DEBUG(0, "USB_ST_TIMEOUT\n");
161 break;
162
163 case USB_ST_NOTSUPPORTED:
164 ZD1211DEBUG(0, "USB_ST_NOTSUPPORTED\n");
165 break;
166
167
168
169
170
171 case USB_ST_BANDWIDTH_ERROR:
172 ZD1211DEBUG(0, "USB_ST_BANDWIDTH_ERROR\n");
173 break;
174
175 case USB_ST_URB_INVALID_ERROR:
176 ZD1211DEBUG(0, "USB_ST_URB_INVALID_ERROR\n");
177 break;
178
179 case USB_ST_URB_REQUEST_ERROR:
180 ZD1211DEBUG(0, "USB_ST_URB_REQUEST_ERROR\n");
181 break;
182
183 case USB_ST_STALL:
184 ZD1211DEBUG(0, "USB_ST_STALL\n");
185 break;
186
187 case -ENOMEM:
188 ZD1211DEBUG(0, "ENOMEM\n");
189 break;
190 #endif
191
192 default:
193 ZD1211DEBUG(0, "USB ST Code = %d\n",err);
194
195 break;
196 }
197 macp->dbg_flag=0;
198
199 }
200
201
202 void zd1211_DumpReadMultipleReg(struct zd1205_private *macp, u16 adr0)
203 {
204 u16 ReadAddr[cMAX_MULTI_READ_REG_NUM];
205 u16 ReadData[cMAX_MULTI_READ_REG_NUM];
206 u16 ReadIndex = 0;
207
208 FPRINT_V("adr0", adr0);
209
210 for (ReadIndex = 0; ReadIndex < cMAX_MULTI_READ_REG_NUM;)
211
212
213
214 mFILL_READ_REGISTER(adr0++);
215
216 zd1211_USB_PACKAGE_READ_REGISTER(ReadAddr, ReadData, ReadIndex, false);
217
218 for (ReadIndex = 0; ReadIndex < 8; ReadIndex ++)
219 printk("%04X, ", ReadData[ReadIndex]);
220
221 printk("\n");
222 printk(" ");
223
224 for (; ReadIndex < cMAX_MULTI_READ_REG_NUM; ReadIndex ++)
225 printk("%04X, ", ReadData[ReadIndex]);
226 printk("\n");
227 }
228
229
230
231 // len0: in word, adr: word offset
232 void zd1211_WriteEEPROM(struct zd1205_private *macp, u16 rom_adr, u16 ram_adr, u16 len0)
233 {
234 u32 tmpvalue;
235 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
236 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
237 u16 WriteIndex = 0;
238
239 tmpvalue = zd1211_readl(ZD1211_CLOCK_CTRL, false);
240 mFILL_WRITE_REGISTER(ZD1211_CLOCK_CTRL, mSET_BIT((u16) tmpvalue, bZD1211_CLOCK_EEPROM));
241 mFILL_WRITE_REGISTER(UMAC_EPROM_ROM_ADDR, rom_adr);
242 mFILL_WRITE_REGISTER(UMAC_EPROM_RAM_ADDR, ram_adr);
243 mFILL_WRITE_REGISTER(UMAC_EPROM_DMA_LEN_DIR, bmEPROM_XFER_DIR | len0);
244 mFILL_WRITE_REGISTER(ZD1211_CLOCK_CTRL, mCLR_BIT((u16) tmpvalue, bZD1211_CLOCK_EEPROM));
245 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
246 }
247
248
249 #if fMERGE_RX_FRAME
250 int zd1211_ChangeToFlashAble(struct zd1205_private *macp)
251 {
252 u32 tmpvalue;
253
254 if (!macp->bFlashable){
255 int LoadRet;
256
257 zd_writel(0x01, FW_SOFT_RESET);
258
259 macp->bDisableTx = 1;
260 //USB_StopTxEP(macp);
261
262 macp->bAllowAccessRegister = 0;
263
264 LoadRet = zd1211_LoadUSBSpecCode(macp, WS11UPhm, sizeof(WS11UPhm),
265 cFIRMWARE_START_ADDR, true);
266 if (LoadRet){
267 FPRINT("Load WS11UPhm fail");
268 return 1;
269 }
270
271 ZD1211DEBUG(0, "Load WS11UPhm Done\n");
272
273 //macp->bAllowAccessRegister = 1;
274 macp->bFlashable = 1;
275
276 #if fWRITE_WORD_REG || fREAD_MUL_REG
277 // Must get this information before any register write
278 tmpvalue = zd1211_readl(cADDR_ENTRY_TABLE, FALSE);
279 macp->AddrEntryTable = (u16) tmpvalue;
280 #endif
281
282 }
283
284 return 0;
285 }
286 #endif
287
288 /*
289 int zd1211_UpdateBootCode(struct zd1205_private *macp, u16 *pCheckSum, u16 *pEEPROMData,
290 u32 EEPROMLen)
291 {
292 u32 i;
293 //int ret;
294 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
295 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
296 u16 WriteIndex = 0;
297 u16 ROMBufAdr = cBOOTCODE_START_ADDR;
298
299 ZD1211DEBUG(0, "UpdateBootCode\n");
300
301 for (i=0; i<EEPROMLen; i+=(2*WRITE_WORD_TO_EEPROM_PER_TIME)){
302 for (WriteIndex=0; WriteIndex<WRITE_WORD_TO_EEPROM_PER_TIME/2; ){
303 if (ROMBufAdr >= cINT_VECT_ADDR){
304 FPRINT("Exceed max address");
305 break;
306 }
307 mFILL_WRITE_REGISTER(ROMBufAdr ++,
308 pEEPROMData[WriteIndex * 2] | (pEEPROMData[WriteIndex * 2 + 1] << 8));
309 }
310
311 if (WriteIndex)
312 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
313
314 if (ROMBufAdr >= cINT_VECT_ADDR){
315 FPRINT("Exceed max address1");
316 return 0;
317 }
318
319 pEEPROMData += WRITE_WORD_TO_EEPROM_PER_TIME;
320 }
321
322 if (EEPROMLen % (2*WRITE_WORD_TO_EEPROM_PER_TIME)){
323 for (WriteIndex = 0; WriteIndex < (EEPROMLen % (2 * WRITE_WORD_TO_EEPROM_PER_TIME)) / 2;){
324 if (ROMBufAdr >= cINT_VECT_ADDR){
325 FPRINT("Exceed max address2");
326 break;
327 }
328
329 mFILL_WRITE_REGISTER(ROMBufAdr ++,
330 pEEPROMData[WriteIndex * 2] | (pEEPROMData[WriteIndex * 2 + 1] << 8));
331 }
332
333 if (WriteIndex)
334 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
335 }
336
337 return 0;
338 }
339 */
340
341
342
343 /*
344 int zd1211_USB_Write_EEPROM(struct zd1205_private *macp, u16 *pEEPROMData, u32 EEPROMLen) //in bytes
345 {
346 u16 CheckSum = 0;
347 int ret;
348
349 ZD1211DEBUG(0, "USB_Write_EEPROM\n");
350
351 macp->bDisableTx = 1;
352
353 //USB_StopTxEP(macp);
354
355 ret = zd1211_UpdateBootCode(macp, &CheckSum, pEEPROMData, EEPROMLen);
356 if (ret != 0)
357 return ret;
358
359 zd1211_WriteEEPROM(macp, 0, cBOOTCODE_START_ADDR, cEEPROM_SIZE - cLOAD_VECT_LEN);
360 //macp->bDisableTx = 0;
361
362 return 0;
363
364 }
365 */
366
367
368
369 int zd1211_USB_WRITE_EEPROM_DATA(struct zd1205_private *macp, PUSB_EEPROM_DATA pData, int DataLen)
370 {
371 int ret;
372 u8 *pBuffer;
373 //int memflags = GFP_KERNEL;
374
375 ZD1211DEBUG(0, "USB_WRITE_EEPROM_DATA\n");
376
377 if (!macp->bUSBDeveiceAttached){
378 return 1;
379 }
380
381 down(&macp->reg_sem);
382
383 pBuffer = kmalloc(DataLen, GFP_KERNEL);
384
385 if (!pBuffer) {
386 up(&macp->reg_sem);
387 return -ENOMEM;
388 }
389 else
390 memcpy(pBuffer, (u8 *)pData, DataLen);
391
392 if (macp->ep4isIntOut)
393 usb_fill_int_urb(macp->reg_urb, macp->usb,
394 usb_sndintpipe(macp->usb, EP_REG_OUT),
395 pBuffer, DataLen,
396 zd1211_reg_cb, macp, 1);
397 else
398 usb_fill_bulk_urb(macp->reg_urb, macp->usb,
399 usb_sndbulkpipe(macp->usb, EP_REG_OUT),
400 pBuffer, DataLen,
401 zd1211_reg_cb, macp);
402 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
403 macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
404 #endif
405
406 if ((ret = SUBMIT_URB(macp->reg_urb, GFP_ATOMIC))){
407 printk(KERN_ERR "zd1211: failed reg_urb\n");
408 zd1211_DumpErrorCode(macp, ret);
409 goto out;
410 }
411
412 wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
413 clear_bit(ZD1211_CMD_FINISH, &macp->flags);
414
415 out:
416 kfree(pBuffer);
417 up(&macp->reg_sem);
418 return ret;
419 }
420
421 #if fPROG_FLASH_BY_FW
422 int zd1211_USB_ProgramFlash(struct zd1205_private *macp, u16 *Value, u16 RegCount)
423 {
424 u8 *pRegBuffer = NULL;
425
426 int ret;
427 u16 size = sizeof(USB_WRITE_REG);
428
429 u16 bufSize;
430 int ii;
431
432 ZD1211DEBUG(0, "USB_ProgramFlash\n");
433
434 if ((RegCount == 0) || (!macp->bUSBDeveiceAttached))
435 return 0;
436
437 down(&macp->reg_sem);
438 pRegBuffer = kmalloc(size, GFP_KERNEL);
439
440 if (!pRegBuffer) {
441 up(&macp->reg_sem);
442 return -ENOMEM;
443 }
444 else
445 memset(pRegBuffer, 0x0, size);
446
447 ((PUSB_WRITE_REG)pRegBuffer)->RequestID = zd_cpu_to_le16(REGID_PROG_FLSH);
448 ((PUSB_SET_RF) pRegBuffer)->Value = Value[0];
449 ((PUSB_SET_RF) pRegBuffer)->Index = Value[1];
450
451 for (ii = 2; ii < RegCount; ii ++)
452 ((PUSB_SET_RF)pRegBuffer)->Data[ii - 2] = Value[ii];
453
454 bufSize = sizeof(u16) * (1+RegCount);
455
456 if (macp->ep4isIntOut)
457 usb_fill_int_urb(macp->reg_urb, macp->usb,
458 usb_sndintpipe(macp->usb, EP_REG_OUT),
459 pRegBuffer, bufSize,
460 zd1211_reg_cb, macp, 1);
461 else
462 usb_fill_bulk_urb(macp->reg_urb, macp->usb,
463 usb_sndbulkpipe(macp->usb, EP_REG_OUT),
464 pRegBuffer, bufSize,
465 zd1211_reg_cb, macp);
466 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
467 macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
468 #endif
469
470 if ((ret = SUBMIT_URB(macp->reg_urb, GFP_KERNEL))){
471 printk(KERN_ERR "zd1211: failed reg_urb\n");
472 zd1211_DumpErrorCode(macp, ret);
473 goto out;
474 }
475
476 wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
477 clear_bit(ZD1211_CMD_FINISH, &macp->flags);
478
479 out:
480 kfree(pRegBuffer);
481 up(&macp->reg_sem);
482 return ret;
483 }
484 #endif
485
486
487 // return 0: success
488 int zd1211_USB_PACKAGE_READ_REGISTER(u16 *Address, u16 *pValue, u16 RegCount, u8 bAddUSBCSRAddress)
489 {
490 struct zd1205_private *macp = g_dev->priv;
491 u8 *pRegBuffer = NULL;
492 int ret = 0;
493 u16 size = sizeof(USB_READ_REG_REQ);
494 u16 bufSize;
495 int ii;
496 //int memflags = GFP_KERNEL;
497
498 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
499 if (in_interrupt()){
500 #else
501
502 if (in_atomic()){
503 #endif
504 printk(KERN_ERR "********zd1211_USB_PACKAGE_READ_REGISTER in_interrupt*********\n");
505 return 0;
506 }
507 down(&macp->reg_sem);
508
509 if ((RegCount == 0) || (!macp->bUSBDeveiceAttached) || (!test_bit(ZD1211_RUNNING, &macp->flags))){
510 up(&macp->reg_sem);
511 return 0;
512 }
513
514 pRegBuffer = kmalloc(size, GFP_KERNEL);
515
516 if (!pRegBuffer) {
517 up(&macp->reg_sem);
518 return -ENOMEM;
519 }else
520 memset(pRegBuffer, 0x0, size);
521
522 ((PUSB_READ_REG_REQ)pRegBuffer)->RequestID = zd_cpu_to_le16(REGID_READ);
523
524 for (ii = 0; ii < RegCount; ii ++){
525 if ((Address[ii] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
526 Address[ii] = Address[ii] - USB_BASE_ADDR_HOST + macp->AddrEntryTable;
527 else if ((Address[ii] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_EEPROM)
528 Address[ii] = ((Address[ii] - USB_BASE_ADDR_EEPROM) / 2) + cFIRMWARE_EEPROM_OFFSET;
529 //0x9900 //0xF817
530 ((PUSB_READ_REG_REQ) pRegBuffer)->Address[ii] = zd_cpu_to_le16(Address[ii]);
531 }
532
533 bufSize = sizeof(u16) * (1+RegCount);
534
535 if (macp->ep4isIntOut)
536 usb_fill_int_urb(macp->reg_urb, macp->usb,
537 usb_sndintpipe(macp->usb, EP_REG_OUT),
538 pRegBuffer, bufSize,
539 zd1211_reg_cb, macp, 1);
540 else
541 usb_fill_bulk_urb(macp->reg_urb, macp->usb,
542 usb_sndbulkpipe(macp->usb, EP_REG_OUT),
543 pRegBuffer, bufSize,
544 zd1211_reg_cb, macp);
545 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
546 macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
547 #endif
548
549 if ((ret = SUBMIT_URB(macp->reg_urb, GFP_ATOMIC))){
550 printk(KERN_ERR "zd1211: failed reg_urb\n");
551 zd1211_DumpErrorCode(macp, ret);
552 up(&macp->reg_sem);
553 kfree(pRegBuffer);
554 return ret;
555 }
556
557 //wait command complete
558 macp->regWaitRCompCnt++;
559 //printk(KERN_ERR "before wait 4\n");
560 wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
561 //printk(KERN_ERR "after wait 4\n");
562 macp->regRWCompCnt++;
563
564 clear_bit(ZD1211_CMD_FINISH, &macp->flags);
565 kfree(pRegBuffer);
566
567 if (ret != 0)
568 goto out;
569
570 //wait response complete
571 macp->regWaitRspCnt++;
572
573 #if 0//(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
574 if (wait_event_interruptible_timeout(macp->iorwRsp_wait, test_bit(ZD1211_REQ_COMP, &macp->flags), HZ/2)){ //use it, we may can't wake up
575
576 //interrupt by a signal
577 memset(macp->IntEPBuffer, 0, MAX_EPINT_BUFFER);
578 macp->regUnCompCnt++;
579 ret = -ERESTARTSYS;
580 goto out;
581 }
582 else
583 macp->regRspCompCnt++;
584 #else
585 //#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
586 //interruptible_sleep_on_timeout(&macp->iorwRsp_wait, 1); //magic delay
587 //20060809 MZCai. the interruptible... has race condition issue.
588 //We don't use it anymore in 2.6.x.
589 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
590 wait_event_interruptible_timeout(macp->iorwRsp_wait, 0, 1);
591 #else
592 interruptible_sleep_on_timeout(&macp->iorwRsp_wait, 1); //magic delay
593 #endif
594
595
596 //interruptible_sleep_on_timeout(&macp->iorwRsp_wait, HZ/40); //magic delay
597 if (!test_bit(ZD1211_REQ_COMP, &macp->flags)){
598 //check if Rsp has completed, race condition may happen,
599 macp->regRdSleepCnt++;
600 //we waste time_out time
601 //printk(KERN_ERR "before wait 2\n");
602 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
603 wait_event_interruptible_timeout(macp->iorwRsp_wait, 0, HZ/10);
604 #else
605 interruptible_sleep_on_timeout(&macp->iorwRsp_wait, HZ/10); //magic delay
606 #endif
607 //wake up, check if timeout or ompleted
608
609 }
610 if (test_bit(ZD1211_REQ_COMP, &macp->flags))
611 macp->regRspCompCnt++;
612 else{
613 memset(macp->IntEPBuffer, 0x0, MAX_EPINT_BUFFER);
614 macp->regUnCompCnt++;
615 ret = -1;
616 goto out;
617 }
618 #endif
619
620 // Get data
621 if ((macp->ReadRegCount == 0) || (macp->ReadRegCount > MAX_EPINT_BUFFER)){
622 ret = 1;
623 }
624 else {
625 for (ii = 0; ii < (macp->ReadRegCount-2) / 4; ii++){
626 pValue[ii] = zd_get_LE_U16(macp->IntEPBuffer2+(1+ii*2+1)*2);
627 }
628 ret = 0;
629 }
630
631 out:
632 clear_bit(ZD1211_REQ_COMP, &macp->flags);
633 up(&macp->reg_sem);
634 return ret;
635 }
636
637 u32 zd1211_readl(u32 Address, u8 bAddUSBCSRAddress)
638 {
639 struct zd1205_private *macp = g_dev->priv;
640
641 u16 ReadAddr[2];
642 u16 ReadData[2];
643 int bRet = 1;
644 u32 value;
645 int count = 0;
646
647 if (bAddUSBCSRAddress && Address < 0x8000){
648 Address += macp->USBCSRAddress;
649
650 if ((Address & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
651 ReadAddr[1] = (u16) Address + 1;
652 else
653 ReadAddr[1] = (u16) Address + 2;
654 }
655 else
656 ReadAddr[1] = (u16) Address + 1;
657
658 ReadAddr[0] = (u16) Address; // Read Low Word first
659
660 while (bRet != 0){
661 bRet = zd1211_USB_PACKAGE_READ_REGISTER(ReadAddr, ReadData, 2, false);
662 count++;
663
664 if (count > 5){
665 printk(KERN_ERR "1211_readl failed for 5 attempts...Very Serious");
666 break;
667 }
668 }
669
670 value = (((u32) ReadData[1]) << 16) + ReadData[0];
671 return value;
672 }
673
674 //return 0: success
675 int zd1211_USB_PACKAGE_WRITE_REGISTER(u16 *Address, u16 *Value, u16 RegCount, u8 bAddUSBCSRAddress)
676 {
677 struct zd1205_private *macp = g_dev->priv;
678 u8 *pRegBuffer = NULL;
679 int ret;
680 u16 size = sizeof(USB_WRITE_REG);
681 u16 bufSize;
682 int i;
683
684 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
685 if (in_interrupt()){
686 #else
687 if (in_atomic()){
688 #endif
689 FPRINT("********zd1211_USB_PACKAGE_WRITE_REGISTER in_interrupt*********");
690 return 0;
691 }
692
693 down(&macp->reg_sem);
694
695 if ((RegCount == 0) || (!macp->bUSBDeveiceAttached) || !test_bit(ZD1211_RUNNING, &macp->flags)) {
696 up(&macp->reg_sem);
697 return 0;
698 }
699
700 pRegBuffer = kmalloc(size, GFP_KERNEL);
701 if (!pRegBuffer) {
702 up(&macp->reg_sem);
703 return -ENOMEM;
704 }
705 else
706 memset(pRegBuffer, 0x0, size);
707
708 ((PUSB_WRITE_REG)pRegBuffer)->RequestID = zd_cpu_to_le16(REGID_WRITE);
709
710 if (RegCount > cMIN_MULTI_WRITE_REG_NUM){
711 for (i=cMIN_MULTI_WRITE_REG_NUM; i<RegCount; i++){
712 if (bAddUSBCSRAddress)
713 Address[i] += macp->USBCSRAddress;
714
715 if ((Address[i] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
716 Address[i] = Address[i] - USB_BASE_ADDR_HOST + macp->AddrEntryTable;
717 else if ((Address[i] & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_EEPROM)
718 Address[i] = ((Address[i] - USB_BASE_ADDR_EEPROM) / 2) + cFIRMWARE_EEPROM_OFFSET;
719
720 ((PUSB_WRITE_REG)pRegBuffer)->WritePackage[i].Address = zd_cpu_to_le16(Address[i]);
721 ((PUSB_WRITE_REG)pRegBuffer)->WritePackage[i].WriteData_low = zd_cpu_to_le16(Value[i]);
722 }
723 }
724
725 bufSize = sizeof(u16) * (1+RegCount*2);
726
727 if (macp->ep4isIntOut)
728 usb_fill_int_urb(macp->reg_urb, macp->usb,
729 usb_sndintpipe(macp->usb, EP_REG_OUT),
730 pRegBuffer, bufSize,
731 zd1211_reg_cb, macp, 1);
732 else
733 usb_fill_bulk_urb(macp->reg_urb, macp->usb,
734 usb_sndbulkpipe(macp->usb, EP_REG_OUT),
735 pRegBuffer, bufSize,
736 zd1211_reg_cb, macp);
737 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
738 macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
739 #endif
740
741 if ((ret = SUBMIT_URB(macp->reg_urb, GFP_ATOMIC))){
742 printk(KERN_ERR "zd1211: failed reg_urb\n");
743 zd1211_DumpErrorCode(macp, ret);
744 goto out;
745 }
746
747 macp->regWaitWCompCnt++;
748 wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
749
750 macp->regRWCompCnt++;
751 clear_bit(ZD1211_CMD_FINISH, &macp->flags);
752
753 out:
754 kfree(pRegBuffer);
755 up(&macp->reg_sem);
756 return ret;
757 }
758
759 int zd1211_WriteMultiRegister(u16 *Address, u16 *Value, u16 RegCount, u8 bAddUSBCSRAddress)
760 {
761 int ret = 1;
762 int count = 0;
763
764 while (ret != 0){
765 ret = zd1211_USB_PACKAGE_WRITE_REGISTER(Address, Value, RegCount, bAddUSBCSRAddress);
766
767 count++;
768 if (count > 5){
769 FPRINT("zd1211_WriteMultiRegister failed");
770 break;
771 }
772 }
773
774 return ret;
775 }
776
777
778 //return 0: success
779 int zd1211_writel(u32 Address, u32 Value, u8 bAddUSBCSRAddress)
780 {
781 struct zd1205_private *macp = g_dev->priv;
782 #ifdef fQuickPhySet
783
784 u8 bIsPhyReg = 0;
785 #endif
786
787
788 u16 WriteAddr[6];
789 u16 WriteData[6];
790 int ret = 1;
791 int count = 0;
792
793 #ifdef fQuickPhySet
794
795 if (bAddUSBCSRAddress && (Address <= ZD1205_PHY_END))
796
797 bIsPhyReg = 1;
798 #endif
799
800
801 #ifdef fQuickPhySet
802 if (bIsPhyReg){
803 u32 tmpvalue;
804
805 tmpvalue = zd_readl(CtlReg1);
806 tmpvalue &= ~0x80;
807 {
808 if (((macp->USBCSRAddress+CtlReg1) & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
809 WriteAddr[0] = (u16) (macp->USBCSRAddress+CtlReg1) + 1;
810 else
811
812 // must write High word first
813 WriteAddr[0] = (u16) (macp->USBCSRAddress+CtlReg1) + 2;
814 }
815 WriteData[0] = (u16) (tmpvalue >> 16);
816
817 WriteAddr[1] = (u16) (macp->USBCSRAddress+CtlReg1);
818
819 WriteData[1] = (u16) (tmpvalue & 0xFFFF);
820
821 if (bAddUSBCSRAddress ){
822 Address += (u16) (macp->USBCSRAddress);
823 if ((Address & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
824 WriteAddr[2] = (u16) Address + 1;
825 else
826 // must write High word first
827 WriteAddr[2] = (u16) Address + 2;
828 }
829 else
830 WriteAddr[2] = (u16) Address + 1;
831
832 WriteData[2] = (u16) (Value >> 16);
833 WriteAddr[3] = (u16) Address;
834
835 WriteData[3] = (u16) (Value & 0xFFFF);
836
837
838 tmpvalue |= 0x80;
839 {
840
841 if (((macp->USBCSRAddress+CtlReg1) & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
842
843 WriteAddr[4] = (u16) (macp->USBCSRAddress+CtlReg1) + 1;
844 else
845 // must write High word first
846 WriteAddr[4] = (u16) (macp->USBCSRAddress+CtlReg1) + 2;
847 }
848 WriteData[4] = (u16) (tmpvalue >> 16);
849 WriteAddr[5] = (u16) (macp->USBCSRAddress+CtlReg1);
850 WriteData[5] = (u16) (tmpvalue & 0xFFFF);
851
852 return zd1211_USB_PACKAGE_WRITE_REGISTER(WriteAddr, WriteData, 6, false);
853 }
854 else
855 {
856 #endif
857 if (bAddUSBCSRAddress && Address < 0x8000){
858 Address += macp->USBCSRAddress;
859 if ((Address & BASE_ADDR_MASK_HOST) == USB_BASE_ADDR_HOST)
860 WriteAddr[0] = (u16) Address + 1;
861 else
862 // must write High word first
863 WriteAddr[0] = (u16) Address + 2;
864 }
865 else
866 WriteAddr[0] = (u16) Address + 1;
867
868 WriteAddr[1] = (u16) Address;
869 WriteData[0] = (u16) (Value >> 16);
870 WriteData[1] = (u16) (Value & 0xFFFF);
871
872
873 while (ret != 0){
874 ret = zd1211_USB_PACKAGE_WRITE_REGISTER(WriteAddr, WriteData, 2, false);
875 count++;
876 if (count > 5){
877
878 printk(KERN_ERR "zd1211_writel failed for 5 attempts\n");
879 break;
880 }
881 }
882
883 #ifdef fQuickPhySet
884 }
885 #endif
886
887 return ret;
888 }
889
890
891
892 void zd1211_StrongSignalDect(struct zd1205_private *macp)
893 {
894 u32 tmpvalue;
895
896 if ( (macp->PHYTestTimerCount >= macp->PHYTestTimer)&&
897 (macp->PHYTestTimer) && (macp->PHYLowPower & BIT_0) &&
898 (!dot11Obj.bContinueTx) &&
899
900 (macp->bAssoc)){
901 macp->PHYTestTimerCount = 0;
902 if (macp->RF_Mode == RFMD_RF){
903 if ( (macp->PHYTestRssi >= macp->PHYTestRssiBound) &&
904
905 ((!dot11Obj.CR122Flag) || (dot11Obj.CR122Flag == 2))){
906 LockPhyReg(&dot11Obj);
907 zd_writel(0xff, ZD1205_CR122);
908
909 if ( (macp->PHYLowPower & BIT_1)&&
910 ((!dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ){
911
912
913 macp->bTraceSetPoint = 0;
914
915 tmpvalue = dot11Obj.IntValue[dot11Obj.Channel-1] - cPWR_STRONG_SIG_DROP;
916
917 zd_writel(tmpvalue, ZD1205_CR31);
918
919 dot11Obj.CR31Flag = 1;
920 }
921
922
923 UnLockPhyReg(&dot11Obj);
924
925 dot11Obj.CR122Flag = 1;
926
927 }
928 else if ( (macp->PHYTestRssi < macp->PHYTestRssiBound) &&
929 ((dot11Obj.CR122Flag) || (dot11Obj.CR122Flag == 2)) ){
930 LockPhyReg(&dot11Obj);
931 zd_writel(0x00, ZD1205_CR122);
932 UnLockPhyReg(&dot11Obj);
933
934 if ( (macp->PHYLowPower & BIT_1) &&
935
936 ((dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ){
937 macp->bTraceSetPoint = 1;
938
939 HW_UpdateIntegrationValue(&dot11Obj, dot11Obj.Channel, macp->cardSetting.MacMode);
940
941 dot11Obj.CR31Flag = 0;
942
943 }
944
945
946 dot11Obj.CR122Flag = 0;
947 }
948
949 }
950 else if((macp->RF_Mode == AL2230_RF) || (macp->RF_Mode == AL2230S_RF)){
951 if ( (macp->PHYTestRssi >= macp->PHYTestRssiBound)&&
952 ((!dot11Obj.CR203Flag) || (dot11Obj.CR203Flag == 2)) ){
953
954 LockPhyReg(&dot11Obj);
955
956 zd_writel(0x0a, ZD1205_CR203);
957 if ( (macp->PHYLowPower & BIT_1)&&
958 ((!dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ){
959
960
961
962 macp->bTraceSetPoint = 0;
963
964 tmpvalue = dot11Obj.IntValue[dot11Obj.Channel-1] - cPWR_STRONG_SIG_DROP;
965 zd_writel(tmpvalue, ZD1205_CR31);
966 dot11Obj.CR31Flag = 1;
967 }
968
969 UnLockPhyReg(&dot11Obj);
970 dot11Obj.CR203Flag = 1;
971 }
972 else if ( (macp->PHYTestRssi < macp->PHYTestRssiBound)&&
973 ((dot11Obj.CR203Flag) || (dot11Obj.CR203Flag == 2)) ){
974 LockPhyReg(&dot11Obj);
975 zd_writel(0x06, ZD1205_CR203);
976 UnLockPhyReg(&dot11Obj);
977
978
979
980
981 if ( (macp->PHYLowPower & BIT_1)&&
982 ((dot11Obj.CR31Flag) || (dot11Obj.CR31Flag == 2)) ){
983
984 macp->bTraceSetPoint = 1;
985
986
987 HW_UpdateIntegrationValue(&dot11Obj, dot11Obj.Channel, macp->cardSetting.MacMode);
988 dot11Obj.CR31Flag = 0;
989 }
990
991
992 dot11Obj.CR203Flag = 0;
993 }
994 }
995 }
996 else {
997 macp->PHYTestTimerCount++;
998
999 }
1000 }
1001
1002
1003 //================================================================
1004 // Housekeeping Every 0.5 s
1005 //================================================================
1006
1007
1008 void zd1211_TxCalibration(struct zd1205_private *macp)
1009 {
1010 static u32 loop = 0;
1011
1012 static u16 TrackingLoop = 0;
1013 static u32 accumulate = 0;
1014 u8 setpoint;
1015 u16 channel;
1016 u32 average = 0;
1017 u32 tmpvalue;
1018 static u16 TrackingCnt = 0;
1019 static u32 accumulate_OFDM = 0;
1020 static u16 TrackingCnt_OFDM = 0;
1021 u8 PreTxOFDMType = cTX_CCK;
1022
1023 loop++;
1024
1025
1026 #if fTX_PWR_CTRL
1027 if ((loop % 64) == 0){
1028 if (macp->bTraceSetPoint){
1029
1030
1031 LockPhyReg(&dot11Obj);
1032 if (TrackingLoop == TRACKING_NUM) {
1033 TrackingLoop = 0;
1034
1035
1036 if (TrackingCnt && PURE_A_MODE != macp->cardSetting.MacMode ){
1037 average = (u32) (accumulate / TrackingCnt);
1038 channel = dot11Obj.Channel;
1039 setpoint = macp->EepSetPoint[channel-1];
1040 if (macp->EnableTxPwrCtrl) {
1041 if (average < (u32) (setpoint - cPWR_CTRL_GUARD))
1042 zd1205_IncreaseTxPower(macp, cTX_CCK);
1043 else if (average > setpoint)
1044
1045 zd1205_DecreaseTxPower(macp, cTX_CCK);
1046 }
1047 accumulate = 0;
1048 TrackingCnt = 0;
1049 }
1050
1051 if (TrackingCnt_OFDM){
1052 average = (u32) (accumulate_OFDM / TrackingCnt_OFDM);
1053 channel = dot11Obj.Channel;
1054 if(PURE_A_MODE != macp->cardSetting.MacMode) {
1055 setpoint = macp->SetPointOFDM[macp->TxOFDMType - cTX_OFDM][channel - 1];
1056 }
1057 else if (PURE_A_MODE == macp->cardSetting.MacMode) {
1058 u8 UselessInt;//Only for store return Integration value that we don't need
1059 int ret;
1060 ret = a_OSC_get_cal_int(
1061 channel,
1062 macp->cardSetting.LastSentTxRate ,
1063 &UselessInt, &setpoint);
1064 if(0 != ret) printk("a_OSC_get_cal_int can't found the channel\n");
1065 }
1066 //printk("Enter TrackingCnt_OFDM(CH:%d)(SET:%d)(avg:%d)\n",channel,setpoint,average);
1067 if (macp->EnableTxPwrCtrl){
1068 if (average < (u32) (setpoint - cPWR_CTRL_GUARD))
1069 zd1205_IncreaseTxPower(macp, cTX_OFDM);
1070 else if (average > setpoint)
1071 zd1205_DecreaseTxPower(macp, cTX_OFDM);
1072 }
1073 accumulate_OFDM = 0;
1074 TrackingCnt_OFDM = 0;
1075 }
1076 }
1077 else {
1078
1079 TrackingLoop ++;
1080 tmpvalue = zd_readl(rLED_CTRL);
1081 if (tmpvalue & BIT_0){ // Continuous Tx
1082 if (tmpvalue & BIT_2){ // Tx OFDM
1083
1084 macp->TxPwrOFDM ++;
1085 macp->TxOFDMCnt = cTX_SENT_LEN + 1;
1086 tmpvalue = zd_readl(ZD1205_CR132);
1087 tmpvalue &= 0xFF;
1088 macp->TxOFDMType = cTX_OFDM;
1089 if (tmpvalue == 0xC)
1090 macp->TxOFDMType = cTX_54M;
1091
1092 else if (tmpvalue == 0x8)
1093
1094
1095
1096 macp->TxOFDMType = cTX_48M;
1097 }
1098 else
1099 macp->TxPwrCCK ++; // Tx CCK
1100 }
1101
1102 if (macp->TxPwrCCK){ // New sent after last read
1103 tmpvalue = zd_readl(ZD1205_CR58);
1104 tmpvalue &= 0xFF;
1105 accumulate += tmpvalue;
1106 TrackingCnt ++;
1107
1108 macp->TxPwrCCK = 0;
1109
1110 }
1111
1112
1113 if (macp->TxPwrOFDM){
1114 if (macp->TxOFDMCnt > cTX_SENT_LEN){ // make sure Tx by HMAC (for UMAC)
1115 tmpvalue = zd_readl(ZD1205_CR57);
1116 tmpvalue &= 0xFF;
1117 accumulate_OFDM += tmpvalue;
1118 TrackingCnt_OFDM ++;
1119 PreTxOFDMType = macp->TxOFDMType;
1120 }
1121 else {
1122 if (PreTxOFDMType != macp->TxOFDMType) {
1123
1124 accumulate_OFDM = 0;
1125 TrackingCnt_OFDM = 0;
1126 }
1127
1128 }
1129 macp->TxPwrOFDM = 0;
1130 }
1131 }
1132 UnLockPhyReg(&dot11Obj);
1133 }
1134 }
1135
1136
1137 #endif
1138
1139 }
1140
1141
1142 //================================================================
1143 // Housekeeping Every 1s
1144
1145
1146 //================================================================
1147 void zd1211_CheckWithIPC(struct zd1205_private *macp)
1148 {
1149 static u32 loop = 0;
1150 u8 BssType = macp->cardSetting.BssType;
1151
1152 loop++;
1153
1154 if ((loop % 10) == 0){
1155 // bypass the weak signal in BSS and AP mode
1156 if ( (macp->bAssoc) &&
1157 (macp->PHYTestRssi <= 0x18) &&
1158 ((BssType == INDEPENDENT_BSS) ||
1159 (BssType == PSEUDO_IBSS)) ){
1160 if (!macp->CR138Flag){
1161
1162 LockPhyReg(&dot11Obj);
1163 zd_writel(0xa8, ZD1205_CR138);
1164
1165
1166 UnLockPhyReg(&dot11Obj);
1167 macp->CR138Flag = 1;
1168 }
1169 }
1170
1171 else if (macp->CR138Flag){
1172 LockPhyReg(&dot11Obj);
1173 zd_writel(0x28, ZD1205_CR138);
1174 UnLockPhyReg(&dot11Obj);
1175 macp->CR138Flag = 0;
1176 }
1177
1178 #if 0
1179 // solve the throughput problem when communicate with the IPC card
1180 if ( ((macp->rxDataPerSec + macp->txDataPerSec) > 50000) &&
1181
1182 (macp->RF_Mode == RFMD_RF) &&
1183 (BssType != PSEUDO_IBSS) &&
1184 (macp->IPCFlag != 4) ){
1185
1186
1187 if ( (macp->rxDataPerSec > 3*macp->txDataPerSec) &&
1188 (macp->PHYTestRssi <= 0x24) ){
1189 if ((!macp->IPCFlag) || (macp->IPCFlag!=1)){
1190 LockPhyReg(&dot11Obj);
1191 zd_writel(0x0a, ZD1205_CR87);
1192 zd_writel(0x04, ZD1205_CR89);
1193 UnLockPhyReg(&dot11Obj);
1194 macp->AdapterMaxRate = 8; // MAX = 24M
1195 macp->IPCFlag = 1;
1196 }
1197 }
1198 else if ( 3*macp->rxDataPerSec < macp->txDataPerSec ){
1199 if ((!macp->IPCFlag) || (macp->IPCFlag != 3)){
1200 LockPhyReg(&dot11Obj);
1201 zd_writel(0x2A, ZD1205_CR87);
1202 zd_writel(0x24, ZD1205_CR89);
1203 UnLockPhyReg(&dot11Obj);
1204 macp->AdapterMaxRate = 0x0B; // MAX = 54M
1205
1206 macp->IPCFlag = 3;
1207 }
1208 }
1209 else
1210 {
1211 if ((!macp->IPCFlag) || (macp->IPCFlag != 2)){
1212 LockPhyReg(&dot11Obj);
1213 zd_writel(0x10, ZD1205_CR87);
1214 zd_writel(0x0C, ZD1205_CR89);
1215 UnLockPhyReg(&dot11Obj);
1216 macp->AdapterMaxRate = 9; // MAX = 36M
1217 macp->IPCFlag = 2;
1218
1219 }
1220 }
1221
1222 }
1223 else if ((macp->RF_Mode == RFMD_RF) &&
1224
1225 (BssType == PSEUDO_IBSS) &&
1226 (macp->IPCFlag != 4)){
1227 if ((!macp->IPCFlag) || (macp->IPCFlag != 3)){
1228 LockPhyReg(&dot11Obj);
1229 zd_writel(0x2A, ZD1205_CR87);
1230 zd_writel(0x24, ZD1205_CR89);
1231 UnLockPhyReg(&dot11Obj);
1232 macp->AdapterMaxRate = 0x0B; // MAX = 54M
1233 macp->IPCFlag = 3;
1234 }
1235 }
1236
1237
1238 else if ((macp->RF_Mode == RFMD_RF) &&
1239 (macp->IPCFlag != 4) ){
1240 if ( (!macp->IPCFlag) || (macp->IPCFlag != 2)){
1241 LockPhyReg(&dot11Obj);
1242 zd_writel(0x10, ZD1205_CR87);
1243 zd_writel(0x0C, ZD1205_CR89);
1244
1245 UnLockPhyReg(&dot11Obj);
1246 macp->AdapterMaxRate = 9; // MAX = 36M
1247 macp->IPCFlag = 2;
1248 }
1249 }
1250
1251 macp->rxDataPerSec = 0;
1252 macp->txDataPerSec = 0;
1253 #endif
1254
1255 if (macp->LinkLEDn == LED2)
1256 iLED_OFF(macp, LED1);
1257
1258 if (!macp->bAssoc){
1259 macp->LinkTimer ++;
1260
1261 if ((macp->LinkTimer == 1) && (macp->LinkLED_OnDur != 0)){
1262 iLED_ON(macp, macp->LinkLEDn);
1263
1264 }
1265
1266 if (macp->LinkTimer == (macp->LinkLED_OnDur + 1)){
1267 iLED_OFF(macp, macp->LinkLEDn);
1268 }
1269
1270
1271 if (macp->LinkTimer >= (macp->LinkLED_OnDur + macp->LinkLED_OffDur))
1272 macp->LinkTimer = 0;
1273 }
1274
1275 #if 0
1276 if (dot11Obj.PhyTest & BIT_8){
1277
1278 u32 tmpvalue;
1279 LockPhyReg(&dot11Obj);
1280 tmpvalue = zd_readl(ZD1205_CR122);
1281 if ((tmpvalue & 0xFF) != 0xFF)
1282 zd_writel(0xFF, ZD1205_CR122);
1283
1284 else
1285 zd_writel(0x00, ZD1205_CR122);
1286 UnLockPhyReg(&dot11Obj);
1287 }
1288 #endif
1289 }// end of (loop % 10)
1290 }
1291
1292
1293 // Switch to another antenna
1294 void zd1211_SwitchAntenna(struct zd1205_private *macp)
1295 {
1296 u32 tmpvalue;
1297
1298 LockPhyReg(&dot11Obj);
1299
1300 tmpvalue = zd_readl(ZD1205_CR10);
1301 tmpvalue ^= BIT_1;
1302 zd_writel(tmpvalue, ZD1205_CR10);
1303
1304 tmpvalue = zd_readl(ZD1205_CR9);
1305 tmpvalue ^= BIT_2;
1306 zd_writel(tmpvalue, ZD1205_CR9);
1307
1308 UnLockPhyReg(&dot11Obj);
1309 }
1310
1311 //-----------------------------------------------------------------------------
1312 #if fPROG_FLASH
1313 // 1:Intel Flash; 0: MXIC, Winbond, AMD, Atmel...
1314 #define cFLASH_MXIC 0
1315 #define cFLASH_INTEL 1
1316
1317 u16 zd1211_SetHighAddr(struct zd1205_private *macp, u16 high_addr)
1318 {
1319 u16 tmp_cr203;
1320 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
1321 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
1322 u16 WriteIndex = 0;
1323
1324 tmp_cr203 = ((high_addr << 1) & ~mMASK(2)) + (high_addr & mBIT(0));
1325
1326 if (macp->FlashType == cFLASH_INTEL){
1327 mFILL_WRITE_REGISTER(rLED_CTRL, 0);
1328 if (mTEST_BIT(high_addr, 7))
1329 mFILL_WRITE_REGISTER(rLED_CTRL, LED2);
1330 }
1331
1332
1333 mFILL_WRITE_REGISTER(ZD1205_CR203, tmp_cr203);
1334 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, true);
1335 return tmp_cr203;
1336 }
1337
1338
1339 /* abs_addr: in word */
1340 u16 zd1211_SetAbsAddr(struct zd1205_private *macp, u32 abs_addr, u16 *get_cr203)
1341
1342 {
1343 static u16 pre_high_addr = 0, pre_cr203 = 0;
1344
1345 u16 high_addr;
1346
1347 high_addr = (u16) (abs_addr >> 14);
1348 if (pre_high_addr != high_addr){
1349 pre_cr203 = zd1211_SetHighAddr(macp, high_addr);
1350 pre_high_addr = high_addr;
1351 }
1352
1353
1354 if (get_cr203 != NULL)
1355 *get_cr203 = pre_cr203;
1356
1357 return ((u16) (abs_addr & mMASK(14)));
1358 }
1359
1360 void zd1211_FlashCmdWrite(struct zd1205_private *macp, u8 Cmd)
1361 {
1362 u32 tmpvalue;
1363 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
1364 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
1365 u16 WriteIndex = 0;
1366
1367 tmpvalue = zd1211_readl(ZD1205_CR203, true);
1368 if (macp->FlashType == cFLASH_MXIC){
1369 mFLASH_WRITE_EVEN_ADDR(0xAAA, 0xAA, tmpvalue);
1370 mFLASH_WRITE_ODD_ADDR(0x555, 0x55, tmpvalue);
1371 mFLASH_WRITE_EVEN_ADDR(0xAAA, Cmd, tmpvalue);
1372 }
1373 else
1374
1375 mFLASH_WRITE_EVEN_ADDR(0, Cmd, tmpvalue);
1376 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1377 }
1378
1379 void zd1211_FlashResetCmd(struct zd1205_private *macp)
1380 {
1381 if (macp->FlashType == cFLASH_MXIC)
1382 zd1211_writel(0, 0xF0, false);
1383 else
1384 zd1211_FlashCmdWrite(macp, 0xFF);
1385 }
1386
1387
1388
1389 void zd1211_InitHighAddr(struct zd1205_private *macp)
1390 {
1391 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
1392
1393 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
1394 u16 WriteIndex = 0;
1395
1396 mFILL_WRITE_REGISTER(UMAC_WAIT_STATE, 0x022); // 25ns * 2
1397 mFILL_WRITE_REGISTER(ZD1205_CR11 + (u16) (macp->USBCSRAddress), 0x15);
1398 // Use AntSel to control VPEN for Intel Flash
1399 mFILL_WRITE_REGISTER(ZD1205_CR10 + (u16) (macp->USBCSRAddress), 0x82);
1400
1401 mFILL_WRITE_REGISTER(ZD1205_CR9 + (u16) (macp->USBCSRAddress), 0x24);
1402 mFILL_WRITE_REGISTER(ZD1205_CR204 + (u16) (macp->USBCSRAddress), 0x7C);
1403 mFILL_WRITE_REGISTER(ZD1205_CR203 + (u16) (macp->USBCSRAddress), 0);
1404 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1405 if (macp->FlashType == 0xFF){
1406 u32 tmpvalue;
1407
1408
1409 macp->FlashType = cFLASH_INTEL;
1410 zd1211_FlashCmdWrite(macp, 0x90); // Read Chip ID
1411
1412 tmpvalue = zd1211_readl(0, false);
1413 if ((tmpvalue & 0xFFFF) != 0x8989) // Intel Manufacture Code
1414 macp->FlashType = cFLASH_MXIC;
1415 }
1416 zd1211_SetAbsAddr(macp, 0, NULL);
1417 zd1211_FlashResetCmd(macp);
1418
1419
1420 }
1421
1422
1423 /* Top: 8k byte / sector ==> 0 - 0x1000 (word address) */
1424 /* ==> sec0 address = 0; sec1 address = 0x1000 ... */
1425 void zd1211_FlashSecErase(struct zd1205_private *macp, u16 Sec0)
1426 {
1427 u32 tmpvalue;
1428 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
1429 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
1430 u16 WriteIndex = 0;
1431
1432 LockPhyReg(&dot11Obj);
1433 tmpvalue = zd1211_readl(ZD1205_CR203, true);
1434 if (macp->FlashType == cFLASH_MXIC){
1435 zd1211_FlashCmdWrite(macp, 0x80);
1436 mFLASH_WRITE_EVEN_ADDR(0xAAA, 0xAA, tmpvalue);
1437 mFLASH_WRITE_ODD_ADDR(0x555, 0x55, tmpvalue);
1438 mFLASH_WRITE_EVEN_ADDR(Sec0 << 1, 0x30, tmpvalue);
1439 }
1440 else
1441 {
1442 mFLASH_SET_EVEN_ADDR(tmpvalue);
1443 mFILL_WRITE_REGISTER(Sec0, 0x20);
1444
1445 mFILL_WRITE_REGISTER(Sec0, 0xD0);
1446 }
1447
1448 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1449 UnLockPhyReg(&dot11Obj);
1450 }
1451
1452
1453
1454
1455
1456 void zd1211_EraseFlash(struct zd1205_private *macp)
1457 {
1458 u32 ii;
1459 u32 tmpvalue;
1460 u16 low_addr, jj;
1461
1462 macp->bDisableTx = 1;
1463 //USB_StopTxEP(Adapter);
1464 LockPhyReg(&dot11Obj);
1465 macp->bAllowAccessRegister = 0;
1466
1467
1468 zd1211_InitHighAddr(macp);
1469
1470 if (macp->FlashType == cFLASH_MXIC)
1471
1472 {
1473 zd1211_FlashCmdWrite(macp, 0x80);
1474 zd1211_FlashCmdWrite(macp, 0x10);
1475 }
1476 else {
1477 for (ii = 0; ii < 0x400000L; ii += 0x10000L){
1478 low_addr = zd1211_SetAbsAddr(macp, ii, NULL);
1479 zd1211_FlashSecErase(macp, low_addr);
1480 for (jj = 0; jj < 100; jj ++){
1481 tmpvalue = zd1211_readl(0, false);
1482 if (tmpvalue & 0x8000)
1483 break;
1484
1485 mdelay(10); // Sleep 10ms
1486 }
1487 }
1488
1489 }
1490
1491
1492 //macp->bAllowAccessRegister = 1;
1493
1494
1495
1496 UnLockPhyReg(&dot11Obj);
1497
1498 //macp->bDisableTx = 0;
1499 }
1500
1501
1502 #if !fPROG_FLASH_BY_FW
1503 void FlashProgram(struct zd1205_private *macp, u16 addr0, u8 *pbuf, u16 tmpvalue)
1504 {
1505 u16 WriteAddr[cMAX_MULTI_WRITE_REG_NUM];
1506 u16 WriteData[cMAX_MULTI_WRITE_REG_NUM];
1507 u16 WriteIndex = 0;
1508 u16 jj;
1509
1510 if (macp->FlashType == cFLASH_MXIC){
1511 for (jj = 0; jj < 16; jj ++){
1512 WriteIndex = 0;
1513 mFLASH_SET_EVEN_ADDR(tmpvalue);
1514 zd1211_FlashCmdWrite(macp, 0xA0);
1515 mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2]);
1516 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false;
1517 }
1518
1519 for (jj = 0; jj < 16; jj ++){
1520 WriteIndex = 0;
1521 mFLASH_SET_ODD_ADDR(tmpvalue);
1522 zd1211_FlashCmdWrite(macp, 0xA0);
1523 mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2 + 1]);
1524
1525 if (jj == 15){
1526 // Read Word Addr
1527
1528 mFLASH_SET_EVEN_ADDR(tmpvalue);
1529 }
1530
1531 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1532 }
1533 }
1534 else
1535 {
1536 mFLASH_SET_EVEN_ADDR(tmpvalue);
1537 mFILL_WRITE_REGISTER(addr0, 0xE8);
1538 mFILL_WRITE_REGISTER(addr0, 0x0F);
1539 for (jj = 0; jj < 8; jj ++)
1540 mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2]);
1541 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1542
1543
1544 WriteIndex = 0;
1545 for (jj = 8; jj < 16; jj ++)
1546
1547 mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2]);
1548
1549 mFILL_WRITE_REGISTER(0, 0xD0);
1550 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1551
1552 WriteIndex = 0;
1553 mFLASH_SET_ODD_ADDR(tmpvalue);
1554 mFILL_WRITE_REGISTER(addr0, 0xE8);
1555 mFILL_WRITE_REGISTER(addr0, 0x0F);
1556 for (jj = 0; jj < 8; jj ++)
1557 mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2 + 1]);
1558 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1559
1560 WriteIndex = 0;
1561 for (jj = 8; jj < 16; jj ++)
1562 mFILL_WRITE_REGISTER(addr0 + jj, pbuf[jj * 2 + 1]);
1563 mFILL_WRITE_REGISTER(0, 0xD0);
1564 zd1211_WriteMultiRegister(WriteAddr, WriteData, WriteIndex, false);
1565 }
1566
1567 }
1568 #endif
1569
1570
1571
1572 int zd1211_ProgFlash(struct zd1205_private *macp, u32 StartAddr,
1573 u32 BufLenInBytes, u8 *pDownloadBuffer)
1574 {
1575 int i;
1576 u32 ii;
1577 u16 low_addr, jj;
1578 int chk_flg = 1;
1579 u16 tmpvalue;
1580 #if fPROG_FLASH_BY_FW
1581 u16 WriteData[cMAX_MULTI_RF_REG_NUM];
1582 u16 WriteIndex = 0;
1583 #endif
1584
1585 #if fVERIFY_FLASH
1586 u16 ReadAddr[cMAX_MULTI_READ_REG_NUM];
1587 u16 ReadData[cMAX_MULTI_READ_REG_NUM];
1588 u16 ReadIndex = 0;
1589 u16 chk_cnt = 0;
1590 #endif
1591
1592 macp->bDisableTx = 1;
1593 //USB_StopTxEP(Adapter);
1594
1595 LockPhyReg(&dot11Obj);
1596 macp->bAllowAccessRegister = 0;
1597
1598 zd1211_InitHighAddr(macp);
1599 StartAddr /= 2; // Convert Byte Addr to Word Addr
1600
1601 for (ii = 0; ii < BufLenInBytes / 2; ii += 16){
1602 if (macp->FlashType == cFLASH_MXIC){
1603 if ((ii + StartAddr) >= 0x200000) // 2M Word = 4M Byte
1604 break;
1605 }
1606 else {
1607 if ((ii + StartAddr) >= 0x400000) // 4M Word = 8M Byte
1608 break;
1609 }
1610
1611 low_addr = zd1211_SetAbsAddr(macp, ii + StartAddr, &tmpvalue);
1612
1613 #if fPROG_FLASH_BY_FW
1614 WriteIndex = 0;
1615 tmpvalue &= 0x00FF;
1616 tmpvalue |= ((macp->FlashType) << 8);
1617 mFILL_RF_REGISTER(mCLR_BIT((tmpvalue), bmFLASH_A0));
1618 mFILL_RF_REGISTER(low_addr);
1619
1620 for (jj = 0; jj < 16; jj ++)
1621 mFILL_RF_REGISTER((u16) pDownloadBuffer[(ii + jj) * 2]);
1622
1623 zd1211_USB_ProgramFlash(macp, WriteData, WriteIndex);
1624 WriteIndex = 0;
1625 mFILL_RF_REGISTER(mSET_BIT((tmpvalue), bmFLASH_A0));
1626 mFILL_RF_REGISTER(low_addr);
1627
1628 for (jj = 0; jj < 16; jj ++)
1629 mFILL_RF_REGISTER((u16) pDownloadBuffer[(ii + jj) * 2 + 1]);
1630
1631 for (i=0; i<5; i++){
1632 if (zd1211_USB_ProgramFlash(macp, WriteData, WriteIndex))
1633 break;
1634 }
1635 #else
1636 zd1211_FlashProgram(macp, low_addr, pDownloadBuffer + 2 * ii, tmpvalue);
1637 #endif
1638 }
1639
1640 //macp->bAllowAccessRegister = 1;
1641 UnLockPhyReg(&dot11Obj);
1642 //macp->bDisableTx = 0;
1643
1644 return chk_flg;
1645 }
1646
1647 #endif
1648
1649 int zd1211_USB_SET_RF_REG(u16 *InputValue, int bIs3683A)
1650 {
1651 struct zd1205_private *macp = g_dev->priv;
1652
1653 u8 *pRegBuffer = NULL;
1654 int ret;
1655 u16 size = sizeof(USB_SET_RF);
1656 u16 bufSize;
1657 u32 S_bit_cnt = dot11Obj.S_bit_cnt;
1658 u16 i;
1659
1660 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1661 if (in_interrupt()){
1662 #else
1663 if (in_atomic()){
1664 #endif
1665 FPRINT("********zd1211_USB_SET_RF_REG in_interrupt*********");
1666 return 0;
1667 }
1668
1669 down(&macp->reg_sem);
1670
1671 if (!(macp->bUSBDeveiceAttached)){
1672 up(&macp->reg_sem);
1673 return 0;
1674 }
1675
1676 pRegBuffer = kmalloc(size, GFP_KERNEL);
1677
1678 if (!pRegBuffer) {
1679 up(&macp->reg_sem);
1680 return -ENOMEM;
1681 }
1682 else
1683 memset(pRegBuffer, 0x0, size);
1684
1685 ((PUSB_SET_RF)pRegBuffer)->RequestID = zd_cpu_to_le16(REGID_RFOFDMSET);
1686
1687 if (bIs3683A)
1688 ((PUSB_SET_RF)pRegBuffer)->Value = zd_cpu_to_le16(1);
1689 else
1690 ((PUSB_SET_RF)pRegBuffer)->Value = zd_cpu_to_le16(2);
1691
1692 ((PUSB_SET_RF)pRegBuffer)->Index = zd_cpu_to_le16((u16)S_bit_cnt);
1693
1694 for (i = 0; i < S_bit_cnt; i ++)
1695 ((PUSB_SET_RF)pRegBuffer)->Data[i] = zd_cpu_to_le16(InputValue[i]);
1696
1697 bufSize = sizeof(u16) * (3+S_bit_cnt);
1698
1699 if (macp->ep4isIntOut)
1700 usb_fill_int_urb(macp->reg_urb, macp->usb,
1701 usb_sndintpipe(macp->usb, EP_REG_OUT),
1702 pRegBuffer, bufSize,
1703 zd1211_reg_cb, macp, 1);
1704 else
1705 usb_fill_bulk_urb(macp->reg_urb, macp->usb,
1706 usb_sndbulkpipe(macp->usb, EP_REG_OUT),
1707 pRegBuffer, bufSize,
1708 zd1211_reg_cb, macp);
1709 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
1710 macp->reg_urb->transfer_flags |= URB_ASYNC_UNLINK;
1711 #endif
1712
1713 if ((ret = SUBMIT_URB(macp->reg_urb, GFP_ATOMIC))){
1714 printk(KERN_ERR "zd1211: failed rf reg_urb\n");
1715 zd1211_DumpErrorCode(macp, ret);
1716 goto out;
1717 }
1718
1719 macp->regWaitWCompCnt++;
1720 wait_event(macp->regSet_wait, test_bit(ZD1211_CMD_FINISH, &macp->flags));
1721 macp->regRWCompCnt++;
1722 clear_bit(ZD1211_CMD_FINISH, &macp->flags);
1723
1724 out:
1725 kfree(pRegBuffer);
1726 up(&macp->reg_sem);
1727 return ret;
1728 }
1729
1730 #define bmZD_IF_LE 1
1731 #define bmZD_RF_CLK 2
1732 #define bmZD_RF_DATA 3
1733 void
1734 HW_Set_IF_Synthesizer(zd_80211Obj_t *pObj, U32 InputValue)
1735 {
1736 u32 S_bit_cnt;
1737 u32 tmpvalue;
1738 u16 WriteData[cMAX_MULTI_RF_REG_NUM];
1739 u16 WriteIndex = 0;
1740
1741 S_bit_cnt = pObj->S_bit_cnt;
1742 InputValue = InputValue << (31 - S_bit_cnt);
1743
1744 //to avoid un-necessary register read/write
1745 LockPhyReg(pObj);
1746 tmpvalue = zd_readl(ZD_CR203);
1747 tmpvalue = mCLR_BIT(tmpvalue, bmZD_IF_LE);
1748
1749 // Configure RF by Software
1750 tmpvalue = mCLR_BIT(tmpvalue, bmZD_RF_CLK);
1751
1752 while (S_bit_cnt){
1753 InputValue = InputValue << 1;
1754
1755 if (InputValue & 0x80000000){
1756 tmpvalue = mSET_BIT(tmpvalue, bmZD_RF_DATA);
1757 mFILL_RF_REGISTER((u16) tmpvalue);
1758 }
1759 else {
1760 tmpvalue = mCLR_BIT(tmpvalue, bmZD_RF_DATA);
1761 mFILL_RF_REGISTER((u16) tmpvalue);
1762 }
1763
1764 if (WriteIndex >= cMAX_MULTI_RF_REG_NUM){
1765 FPRINT_V("S_bit_cnt over range! ", (u32)pObj->S_bit_cnt);
1766 break;
1767 }
1768
1769 S_bit_cnt --;
1770 }
1771
1772 zd1211_USB_SET_RF_REG(WriteData, 0);
1773 UnLockPhyReg(pObj);
1774 }
1775
1776 static void zd1211_tx_timeout(struct net_device *dev)
1777 {
1778 struct zd1205_private *macp = dev->priv;
1779
1780 if (!macp)
1781 return;
1782
1783 printk("%s: Tx timed out.\n", dev->name);
1784 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8))
1785 defer_kevent(macp, KEVENT_USB_KILL_TX_URB);
1786 #else
1787 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
1788 macp->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
1789 #endif
1790 usb_unlink_urb(macp->tx_urb);
1791
1792 #endif
1793 /*
1794 zd1205_Ctrl_Set_t *pCtrlSet;
1795
1796 zd1205_SwTcb_t *sw_tcb;
1797 zd1205_TBD_t *Tbd;
1798 int i;
1799 if(macp->activeTxQ->count)
1800 {
1801 sw_tcb = macp->activeTxQ->first;
1802 pCtrlSet = sw_tcb->pHwCtrlPtr;
1803 Tbd = sw_tcb->pFirstTbd;
1804 Tbd++;
1805 printk("##### Control Setting #####\n");
1806 for(i=0;i<24;i++)
1807 printk("%02x ", *((U8 *)pCtrlSet+i));
1808 printk("\n");
1809 printk("##### MAC Header #####\n");
1810 for(i=0;i<24;i++)
1811 printk("%02x ", *(U8 *)(Tbd->TbdBufferAddrLowPart+i));
1812 printk("\n");
1813
1814 }
1815 */
1816 }
1817
1818 int zd1211_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
1819 {
1820 struct zd1205_private *macp = dev->priv;
1821
1822 memcpy(&macp->ifreq, ifr, sizeof(struct ifreq));
1823 macp->ifcmd = cmd;
1824 defer_kevent(macp, KEVENT_STD_IOCTL);
1825 return 0;
1826 }
1827
1828 #define ZD1211_TX_TIMEOUT (HZ*10)
1829 #define ZD1211_MTU 1500
1830 extern struct iw_handler_def p80211wext_handler_def;
1831
1832 u8 zd1211_InitSetup(struct net_device *dev, struct zd1205_private *macp)
1833 {
1834 int res;
1835
1836 //return true; //for debug
1837 ZENTER(1);
1838
1839 init_MUTEX(&macp->ps_sem);
1840 init_MUTEX(&macp->reg_sem);
1841 init_MUTEX(&macp->bcn_sem);
1842 init_MUTEX(&macp->config_sem);
1843 init_MUTEX(&macp->ioctl_sem);
1844
1845 spin_lock_init(&(macp->intr_lock));
1846 spin_lock_init(&(macp->q_lock));
1847 spin_lock_init(&(macp->cs_lock));
1848
1849 INIT_WORK(&macp->kevent, kevent, macp);
1850 INIT_WORK(&macp->scan_tout_event, kevent, macp);
1851
1852 macp->numTcb = NUM_TCB;
1853 macp->numTbd = NUM_TBD;
1854 macp->numRfd = NUM_RFD;
1855 macp->numTbdPerTcb = NUM_TBD_PER_TCB;
1856 macp->rxOffset = ZD_RX_OFFSET;
1857 macp->rfd_size = 24; // form CbStatus to NextCbPhyAddrHighPart
1858
1859 init_timer(&macp->watchdog_timer);
1860 macp->watchdog_timer.data = (unsigned long) dev;
1861
1862 macp->watchdog_timer.function = (void *) &zd1205_watchdog_cb;
1863
1864 init_timer(&macp->tm_hking_id);
1865 macp->tm_hking_id.data = (unsigned long) dev;
1866 macp->tm_hking_id.function = (void *) &HKeepingCB;
1867
1868 init_timer(&macp->tm_mgt_id);
1869 macp->tm_mgt_id.data = (unsigned long) dev;
1870 macp->tm_mgt_id.function = (void *) &zd1205_mgt_mon_cb;
1871
1872 #if ZDCONF_LP_SUPPORT == 1
1873 init_timer(&macp->tm_lp_poll_id);
1874 macp->tm_lp_poll_id.data = (unsigned long) dev;
1875 macp->tm_lp_poll_id.function = (void *)&zd1205_lp_poll_cb;
1876 #endif
1877
1878
1879 dot11Obj.reg = (void *)0x9000;
1880 macp->regp = (void *)0x9000;
1881 macp->USBCSRAddress = 0x9000;
1882
1883 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1884 macp->in_interval = 10;
1885 #else
1886 macp->in_interval = 10;
1887 #endif
1888
1889 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1890 usb_fill_int_urb(macp->intr_urb, macp->usb,
1891 usb_rcvintpipe(macp->usb, EP_INT_IN),
1892 macp->IntEPBuffer, MAX_EPINT_BUFFER,
1893 zd1211_intr_cb, macp, macp->in_interval);
1894 #else //fake it
1895 usb_fill_bulk_urb(macp->intr_urb, macp->usb,
1896 usb_rcvbulkpipe(macp->usb, EP_INT_IN),
1897 macp->IntEPBuffer, MAX_EPINT_BUFFER,
1898 zd1211_intr_cb, macp);
1899 #endif
1900
1901 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
1902 macp->intr_urb->transfer_flags |= URB_ASYNC_UNLINK;
1903 #endif
1904 #if 0
1905 macp->intr_urb->transfer_dma = macp->IntBufferHandle;
1906 macp->intr_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1907 #endif
1908 if ((res = SUBMIT_URB(macp->intr_urb, GFP_KERNEL))){
1909 printk(KERN_ERR "zd1211: failed intr_urb\n");
1910 zd1211_DumpErrorCode(macp, res);
1911 return false;
1912 }
1913 zd1205_init(macp);
1914
1915 dev->open = zd1205_open;
1916 dev->stop = zd1205_close;
1917 dev->watchdog_timeo = ZD1211_TX_TIMEOUT;
1918 dev->do_ioctl = zd1205_ioctl;
1919
1920 #if WIRELESS_EXT > 12
1921 dev->wireless_handlers = (struct iw_handler_def *)&p80211wext_handler_def;
1922 #endif
1923
1924 dev->hard_start_xmit = zd1205_xmit_frame;
1925 dev->set_multicast_list = zd1205_set_multi;
1926 dev->get_stats = zd1205_get_stats;
1927 #if ZDCONF_WE_STAT_SUPPORT == 1
1928 dev->get_wireless_stats = zd1205_iw_getstats;
1929 #elif !defined(ZDCONF_WE_STAT_SUPPORT)
1930 #error "Undefine ZDCONF_WE_STAT_SUPPORT"
1931 #endif
1932 dev->mtu = ZD1211_MTU;
1933 dev->set_mac_address = zd1205_set_mac;
1934 dev->tx_timeout = &zd1211_tx_timeout;
1935
1936 //dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;
1937 dev->flags |= IFF_MULTICAST;
1938
1939 //memcpy(macp->ifname, dev->name, IFNAMSIZ);
1940 //macp->ifname[IFNAMSIZ-1] = 0;
1941 //
1942 //prince add for led
1943 #if 0 // mask by Victor Yu. 04-04-2007
1944 #if defined CONFIG_ARCH_W341 || defined CONFIG_ARCH_W321
1945 mcpu_gpio_inout(1<<WLAN_LED,MCPU_GPIO_OUTPUT);
1946 mcpu_gpio_set(1<<WLAN_LED,MCPU_GPIO_LOW);
1947 #elif defined CONFIG_ARCH_W311
1948 *(volatile unsigned char *)WLAN_LED_REG = ( (*(volatile unsigned char *)WLAN_LED_REG) | (~PIO(WLAN_LED)) );
1949 #endif
1950 #endif
1951 ZEXIT(1);
1952 return true;
1953 }
1954
1955 int zd1211_alloc_all_urbs(struct zd1205_private *macp)
1956 {
1957 struct usb_interface *interface = macp->interface;
1958 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1959 struct usb_interface_descriptor *iface_desc = &interface->altsetting[0];
1960 #else
1961
1962 struct usb_host_interface *iface_desc = &interface->altsetting[0];
1963 #endif
1964
1965 struct usb_endpoint_descriptor *endpoint;
1966 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
1967 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
1968 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
1969
1970 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
1971
1972 u8 num_bulk_in = 0;
1973 u8 num_bulk_out = 0;
1974
1975 u8 num_interrupt_in = 0;
1976 u8 num_interrupt_out = 0;
1977
1978 int i;
1979
1980
1981 /* descriptor matches, let's find the endpoints needed */
1982 /* check out the endpoints */
1983 //ZD1211DEBUG(2, "bNumEndpoints = %d\n", iface_desc->bNumEndpoints);
1984 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
1985 for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
1986
1987 endpoint = &iface_desc->endpoint[i];
1988 #else
1989 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1990 endpoint = &iface_desc->endpoint[i].desc;
1991 #endif
1992
1993 if ((endpoint->bEndpointAddress & 0x80) &&
1994
1995
1996 ((endpoint->bmAttributes & 3) == 0x02)) {
1997
1998 /* we found a bulk in endpoint */
1999 bulk_in_endpoint[num_bulk_in] = endpoint;
2000 ++num_bulk_in;
2001
2002
2003 macp->wMaxPacketSize = zd_le16_to_cpu(endpoint->wMaxPacketSize);
2004 if(macp->wMaxPacketSize != 64 && macp->wMaxPacketSize!= 512)
2005 {
2006 printk("Something wrong. Mostly, it's a endian issue\n");
2007 }
2008 ZD1211DEBUG(0, "bulk in: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));
2009 }
2010
2011
2012
2013 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
2014 ((endpoint->bmAttributes & 3) == 0x02)) {
2015 /* we found a bulk out endpoint */
2016 bulk_out_endpoint[num_bulk_out] = endpoint;
2017 ++num_bulk_out;
2018 ZD1211DEBUG(0, "bulk out: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));
2019
2020 }
2021
2022 if ((endpoint->bEndpointAddress & 0x80) &&
2023
2024
2025 ((endpoint->bmAttributes & 3) == 0x03)) {
2026 /* we found a interrupt in endpoint */
2027 interrupt_in_endpoint[num_interrupt_in] = endpoint;
2028 ++num_interrupt_in;
2029 macp->in_interval = endpoint->bInterval;
2030 ZD1211DEBUG(0, "interrupt in: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));
2031
2032 ZD1211DEBUG(0, "interrupt in: int_interval = %d\n", endpoint->bInterval);
2033
2034 }
2035
2036 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
2037 ((endpoint->bmAttributes & 3) == 0x03)) {
2038 /* we found a interrupt out endpoint */
2039 interrupt_out_endpoint[num_interrupt_out] = endpoint;
2040 ++num_interrupt_out;
2041 macp->ep4isIntOut = 0;//1;
2042
2043 ZD1211DEBUG(0, "interrupt out: wMaxPacketSize = %x\n", zd_le16_to_cpu(endpoint->wMaxPacketSize));
2044 macp->out_interval = endpoint->bInterval;
2045 }
2046 }
2047
2048
2049 macp->num_bulk_in = num_bulk_in;
2050 macp->num_bulk_out = num_bulk_out;
2051 macp->num_interrupt_in = num_interrupt_in;
2052
2053 macp->num_interrupt_out = num_interrupt_out;
2054
2055
2056 macp->rx_urb = USB_ALLOC_URB(0, GFP_KERNEL);
2057 if (!macp->rx_urb)
2058 return 0;
2059
2060 macp->tx_urb = USB_ALLOC_URB(0, GFP_KERNEL);
2061 if (!macp->tx_urb) {
2062 usb_free_urb(macp->rx_urb);
2063 return 0;
2064 }
2065
2066
2067 macp->intr_urb = USB_ALLOC_URB(0, GFP_KERNEL);
2068 if (!macp->intr_urb) {
2069
2070 usb_free_urb(macp->rx_urb);
2071 usb_free_urb(macp->tx_urb);
2072 return 0;
2073 }
2074
2075 macp->ctrl_urb = USB_ALLOC_URB(0, GFP_KERNEL);
2076 if (!macp->ctrl_urb) {
2077 usb_free_urb(macp->rx_urb);
2078 usb_free_urb(macp->tx_urb);
2079 usb_free_urb(macp->intr_urb);
2080 return 0;
2081
2082
2083 }
2084
2085
2086 macp->reg_urb = USB_ALLOC_URB(0, GFP_KERNEL);
2087 if (!macp->reg_urb) {
2088 usb_free_urb(macp->rx_urb);
2089 usb_free_urb(macp->tx_urb);
2090 usb_free_urb(macp->intr_urb);
2091 usb_free_urb(macp->ctrl_urb);
2092 return 0;
2093 }
2094
2095 #if 0//(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
2096 #if 1
2097 macp->IntEPBuffer = kmalloc(MAX_EPINT_BUFFER, GFP_KERNEL);
2098
2099 #else //always failed? why???
2100 macp->IntEPBuffer = usb_buffer_alloc(macp->device,
2101 MAX_EPINT_BUFFER,
2102 GFP_KERNEL,
2103 &macp->IntBufferHandle);
2104 #endif
2105 if (!macp->IntEPBuffer){
2106 FPRINT("usb_buffer_alloc failed");
2107 usb_free_urb(macp->rx_urb);
2108 usb_free_urb(macp->tx_urb);
2109 usb_free_urb(macp->intr_urb);
2110 usb_free_urb(macp->ctrl_urb);
2111
2112 usb_free_urb(macp->reg_urb);
2113 return 0;
2114 }
2115 #endif
2116
2117 return 1;
2118 }
2119
2120
2121
2122
2123 void zd1211_free_all_urbs(struct zd1205_private *macp)
2124
2125 {
2126
2127
2128 if (macp->rx_urb)
2129 usb_free_urb(macp->rx_urb);
2130 if (macp->tx_urb)
2131
2132 usb_free_urb(macp->tx_urb);
2133 if (macp->intr_urb)
2134
2135 usb_free_urb(macp->intr_urb);
2136 if (macp->ctrl_urb)
2137 usb_free_urb(macp->ctrl_urb);
2138 if (macp->reg_urb)
2139 usb_free_urb(macp->reg_urb);
2140
2141 #if 0//(LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
2142 if (macp->IntEPBuffer)
2143 #if 1
2144 kfree(macp->IntEPBuffer);
2145 #else
2146 usb_buffer_free(macp->device,
2147 MAX_EPINT_BUFFER,
2148 (void *)macp->IntEPBuffer,
2149
2150 macp->IntBufferHandle);
2151 #endif
2152 #endif
2153 }
2154
2155
2156 void zd1211_unlink_all_urbs(struct zd1205_private *macp)
2157 {
2158 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8))
2159 usb_kill_urb(macp->rx_urb);
2160 usb_kill_urb(macp->tx_urb);
2161 usb_kill_urb(macp->ctrl_urb);
2162 usb_kill_urb(macp->reg_urb);
2163
2164 if (test_bit(ZD1211_UNPLUG, &macp->flags))
2165 usb_kill_urb(macp->intr_urb);
2166
2167 #else
2168 usb_unlink_urb(macp->rx_urb);
2169 usb_unlink_urb(macp->tx_urb);
2170 usb_unlink_urb(macp->ctrl_urb);
2171 usb_unlink_urb(macp->reg_urb);
2172
2173 if (test_bit(ZD1211_UNPLUG, &macp->flags))
2174 usb_unlink_urb(macp->intr_urb);
2175 #endif
2176
2177
2178 }
2179 int debug_flag=0;
2180 #define MAX_RX_MERGE_PACKET_NUM 3
2181 void zd1211_rx_isr(unsigned long parm)
2182 {
2183 struct zd1205_private *macp = (struct zd1205_private *)parm;
2184 struct urb *urb = macp->read_urb;
2185 struct rx_list_elem *rx_struct;
2186 #if fMERGE_RX_FRAME
2187 struct rx_list_elem *rx_struct_array[MAX_RX_MERGE_PACKET_NUM];
2188 int total_rx_struct = 1, rx_array_cnt = 0;
2189 int i;
2190 u32 tmpLen = 0;
2191 u16 last_pkt_len;
2192 #endif
2193 u32 TotalLength = urb->actual_length;
2194 u8 *pRxBuffer;
2195 struct sk_buff *skb;
2196 zd1205_RFD_t *rfd = NULL;
2197 int flag;
2198
2199 /*if(in_irq())*/spin_lock(&macp->intr_lock);
2200 //else spin_lock_irqsave(&macp->intr_lock,flag);
2201 //
2202
2203 ZD1211DEBUG(4, "actual_length = %x\n", urb->actual_length);
2204 rx_struct = list_entry(macp->active_rx_list.next,
2205 struct rx_list_elem, list_elem);
2206
2207 skb = rx_struct->skb;
2208 rfd = RFD_POINTER(skb, macp);
2209 pRxBuffer = &rfd->RxBuffer[macp->rxOffset];
2210
2211 #if 0
2212 //for debug only
2213 zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
2214 //zd1211_submit_rx_urb(macp);
2215 //return;
2216 #endif
2217
2218 #if fMERGE_RX_FRAME
2219 if (rx_struct->UnFinishFrmLen){
2220 TotalLength += rx_struct->UnFinishFrmLen;
2221 rx_struct->UnFinishFrmLen = 0;
2222 macp->CompLenInfoCnt++;
2223 //ZD1211DEBUG(0, "Got Rx Frames Length Info!!\n");
2224 }
2225
2226 last_pkt_len = TotalLength & (macp->wMaxPacketSize - 1);
2227
2228 if (last_pkt_len <= (macp->wMaxPacketSize - 4)){
2229 if (zd_get_LE_U16(pRxBuffer + (TotalLength/sizeof(u16)-1)*2 ) == 0x697E) {
2230 //if (((u16 *) pRxBuffer)[TotalLength / sizeof(u16) - 1] == 0x697E){
2231 total_rx_struct = 3;
2232 //ZD1211DEBUG(0, "Got merged Rx Frames!!\n");
2233 //zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
2234 macp->Continue2Rx++;
2235 }
2236 else
2237 macp->NoMergedRxCnt++;
2238
2239 //ZD1211DEBUG(3, "last_pkt_len = %x\n", last_pkt_len);
2240 //zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
2241
2242 for (i=0; i<total_rx_struct; i++){
2243 int CurFrmLen;
2244
2245 if (total_rx_struct> 1){
2246 CurFrmLen=zd_get_LE_U16(pRxBuffer+(TotalLength/sizeof(u16)+i-4)*2);
2247 //ZD1211DEBUG(2, "CurFrmLen = %x\n", CurFrmLen);
2248 }
2249 else
2250 CurFrmLen = TotalLength;
2251
2252 if (CurFrmLen == 0){
2253 break;
2254 }
2255
2256 if (list_empty(&(macp->active_rx_list)))break;
2257
2258 rx_struct_array[i] = list_entry(macp->active_rx_list.next,struct rx_list_elem, list_elem);
2259 list_del(&(rx_struct_array[i]->list_elem));
2260 /*
2261 if (list_empty(&(macp->active_rx_list))){
2262 zd1205_add_skb_to_end(macp, rx_struct_array[i]);
2263 break;
2264 }
2265 */
2266 /*
2267 if(total_rx_struct>1){
2268 zd1205_add_skb_to_end(macp, rx_struct_array[i]);
2269 if (list_empty(&(macp->active_rx_list)))
2270 break;
2271 else
2272 continue;
2273 }
2274 */
2275 rx_array_cnt++;
2276
2277 ZD1211DEBUG(2, "CurFrmLen = %x\n", CurFrmLen);
2278
2279 skb = rx_struct_array[i]->skb;
2280 rfd = RFD_POINTER(skb, macp);
2281
2282 rfd->CbStatus = RFD_STATUS_COMPLETE;
2283 rfd->ActualCount = CurFrmLen;
2284
2285 if (i > 0){
2286 memcpy(&rfd->RxBuffer[macp->rxOffset],
2287 pRxBuffer + tmpLen,
2288 rfd->ActualCount);
2289 }
2290
2291 tmpLen += (rfd->ActualCount & ~0x03);
2292
2293 if (rfd->ActualCount & 0x03)
2294 tmpLen += 4;
2295 rfd->ActualCount += macp->rxOffset;
2296 }
2297 }
2298 else {
2299 // last_pkt_len = 509, 510, 511
2300 // wait next Rx
2301 //ZD1211DEBUG(0, "Wait Rx Frames Length Info!!\n");
2302 //ZD1211DEBUG(2, "last_pkt_len = %x\n", last_pkt_len);
2303 macp->WaitLenInfoCnt++;
2304 rx_struct->UnFinishFrmLen = ((TotalLength / macp->wMaxPacketSize) + 1)
2305 * (macp->wMaxPacketSize);
2306 //zd1205_dump_data("pRxBuffer", (u8 *)pRxBuffer, TotalLength);
2307 }
2308
2309 if(zd1211_submit_rx_urb(macp))
2310 {
2311 //printk("No available buffer. Reallocate\n");
2312
2313 zd1211_alloc_rx((unsigned long)macp);
2314 if(zd1211_submit_rx_urb(macp)){
2315 //printk("zd1211_submit_rx_urb fail. Abort\n");
2316 }
2317
2318 }
2319
2320 if (!rx_struct->UnFinishFrmLen){
2321 macp->total_rx_cnt = rx_array_cnt;
2322 macp->rx_struct_array = rx_struct_array;
2323 zd1205_rx_isr(macp);
2324 }
2325
2326 #else
2327 rfd->CbStatus = RFD_STATUS_COMPLETE;
2328 rfd->ActualCount = TotalLength + macp->rxOffset;
2329 zd1205_rx_isr(macp);
2330 #endif
2331
2332 if (dot11Obj.QueueFlag & MGT_QUEUE_SET)
2333 defer_kevent(macp, KEVENT_PROCESS_SIGNAL);
2334
2335 /*if(in_irq())*/spin_unlock(&macp->intr_lock);
2336 //else spin_unlock_irqrestore(&macp->intr_lock,flag);
2337 }
2338
2339
2340 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
2341 void zd1211_rx_comp_cb(struct urb *urb)
2342 #else
2343 void zd1211_rx_comp_cb(struct urb *urb, struct pt_regs *regs)
2344 #endif
2345 {
2346 struct zd1205_private *macp = urb->context;
2347
2348
2349 macp->lastRxComp = jiffies;
2350 if ((!macp) || !test_bit(ZD1211_RUNNING, &macp->flags))
2351 {
2352 return;
2353 }
2354
2355
2356 if (!netif_device_present(macp->device))
2357 {
2358 printk("Error2 in %s\n", __FUNCTION__);
2359 return;
2360 }
2361
2362 if (urb->status != 0){
2363 /*printk("Error Occur in %s\n", __FUNCTION__);
2364 zd1211_DumpErrorCode(macp, urb->status);*/ //Johnson Liu remove 2009-03-02
2365 if ((urb->status != -ENOENT) &&
2366
2367 (urb->status != -ECONNRESET) &&
2368
2369 (urb->status != -ESHUTDOWN)) {
2370 //printk("nonzero read bulk status received: %d\n", urb->status);
2371 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
2372 if (urb->status == USB_ST_INTERNALERROR)
2373 {
2374 printk("Error3 in %s\n", __FUNCTION__);
2375 return;
2376 }
2377
2378 #else
2379
2380 if (urb->status == -EPIPE){
2381 printk("nonzero read bulk status received: -EPIPE\n");
2382 return;
2383 }
2384
2385 if (urb->status == -EPROTO){
2386 printk("nonzero read bulk status received: -EPROTO\n");
2387 return;
2388 }
2389
2390
2391
2392 #endif
2393
2394
2395 if(zd1211_submit_rx_urb(macp))
2396 {
2397 printk("No available buffer. Reallocate\n");
2398 zd1211_alloc_rx((unsigned long)macp);
2399 if(zd1211_submit_rx_urb(macp))
2400 printk("zd1211_submit_rx_urb fail. Abort\n");
2401 }
2402 return;
2403 }
2404 return;
2405
2406 }
2407
2408
2409 if (urb->actual_length == 0){
2410 FPRINT("Got Length = 0");
2411
2412 if(zd1211_submit_rx_urb(macp))
2413 {
2414 printk("No available buffer. Reallocate\n");
2415 zd1211_alloc_rx((unsigned long)macp);
2416 if(zd1211_submit_rx_urb(macp))
2417 printk("zd1211_submit_rx_urb fail. Abort\n");
2418 }
2419 return;
2420 }
2421
2422
2423 macp->read_urb = urb;
2424 zd1211_rx_isr((unsigned long) macp);
2425
2426 }
2427
2428
2429
2430
2431
2432 //callback function for interrupt or response
2433 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
2434 void zd1211_intr_cb(struct urb *urb)
2435 #else
2436 void zd1211_intr_cb(struct urb *urb, struct pt_regs *regs)
2437 #endif
2438 {
2439 struct zd1205_private *macp = urb->context;
2440 u16 intNum;
2441 int status;
2442 u32 actual_length = urb->actual_length;
2443
2444 if (!macp)
2445 return;
2446
2447 spin_lock(&macp->intr_lock);
2448
2449 if (urb->status != 0){
2450 zd1211_DumpErrorCode(macp, urb->status);
2451
2452 if (urb->status == -ENODEV){ //device was removed
2453 FPRINT("Device was removed!!!");
2454 macp->bUSBDeveiceAttached = 0;
2455
2456 wake_up(&macp->regSet_wait);
2457 wake_up_interruptible(&macp->iorwRsp_wait);
2458
2459 spin_unlock(&macp->intr_lock);
2460
2461 return;
2462 }
2463
2464 switch (urb->status){
2465 case -ECONNRESET:
2466 case -ENOENT:
2467 case -ESHUTDOWN:
2468 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
2469 case -EPROTO:
2470 #endif
2471 macp->bUSBDeveiceAttached = 0;
2472 FPRINT("Device was down!!!");
2473 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
2474 spin_unlock(&macp->intr_lock);
2475 return;
2476 #endif
2477
2478 break;
2479
2480 default:
2481 //printk("nonzero intr status received: %d\n", urb->status);
2482 break;
2483 }
2484
2485 }
2486 else {
2487 if (macp->IntEPBuffer[0] != 0x01)
2488 FPRINT("Got unknown packet");
2489
2490 switch (macp->IntEPBuffer[1]){
2491 case EPINT_IORDRsp:
2492
2493 // this is USB_READ_REGISTER response
2494 macp->ReadRegCount = (u16)actual_length;
2495
2496 //intNum = *(u16 *)(macp->IntEPBuffer+2);
2497 intNum = zd_get_LE_U16(macp->IntEPBuffer+2);
2498
2499 if (intNum == (InterruptCtrl | macp->USBCSRAddress)){
2500 // Handle non-RxTx interrupt
2501 if (macp->bHandleNonRxTxRunning){
2502 printk("Impossible, interrupt happen!!!!! %x\n", intNum);
2503 break;
2504 }
2505
2506 // disable non-RxTx interrupt
2507 // No needed to diable interrupt, firmware will do it.
2508 macp->bHandleNonRxTxRunning = 1;
2509 memcpy(macp->IntEPBuffer3, macp->IntEPBuffer, MAX_EPINT_BUFFER);
2510 //printk("Get NON TX RX INT\n");
2511 defer_kevent(macp, KEVENT_NON_TX_RX_INT);
2512
2513 }
2514 else{
2515 // handle read register
2516 memcpy(macp->IntEPBuffer2, macp->IntEPBuffer, MAX_EPINT_BUFFER);
2517 set_bit(ZD1211_REQ_COMP, &macp->flags);
2518 wake_up_interruptible(&macp->iorwRsp_wait);
2519 }
2520 break;
2521
2522 case EPINT_RetryFial_Event:
2523 {
2524 u8 *pMacAddr = macp->IntEPBuffer + 4;
2525 //u8 NewRate = (u8)(*(u16 *)(macp->IntEPBuffer + 2));
2526 //u8 NewRate = macp->IntEPBuffer[2];
2527 u16 aid;
2528
2529 #if fTX_PWR_CTRL
2530 if (macp->TxOFDMType >= cTX_48M)
2531 macp->TxOFDMCnt = 0;
2532 #endif
2533
2534 if ( macp->IntEPBuffer[10] & BIT_0 )
2535
2536 macp->bIBSS_Wakeup_Dest = 1;
2537
2538
2539 //ZD1211DEBUG(2, "Retry Failed!!!\n");
2540 //ZD1211DEBUG(2, "NewRate = %x\n", NewRate);
2541 aid = zd_AidLookUp(pMacAddr);
2542 zd_EventNotify(EVENT_TX_COMPLETE, ZD_RETRY_FAILED, 0xff, (U32)aid);
2543 //macp->retryFailCnt += *(u16 *)(macp->IntEPBuffer + 10);
2544 macp->retryFailCnt += zd_get_LE_U16(macp->IntEPBuffer + 10);
2545 break;
2546
2547 }
2548
2549
2550 default:
2551 FPRINT("Got Unknown interrupt!!!");
2552 break;
2553 }
2554
2555 }
2556
2557 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
2558 #if 1
2559 //memset(macp->IntEPBuffer, 0x0, MAX_EPINT_BUFFER);
2560
2561 //use bulk instead of interrupt in
2562 usb_fill_bulk_urb(macp->intr_urb, macp->usb,
2563 usb_rcvbulkpipe(macp->usb, EP_INT_IN),
2564 macp->IntEPBuffer, MAX_EPINT_BUFFER,
2565 zd1211_intr_cb, macp);
2566 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
2567 macp->intr_urb->transfer_flags |= URB_ASYNC_UNLINK;
2568 #endif
2569 status = SUBMIT_URB(macp->intr_urb, GFP_ATOMIC);
2570 #else
2571 status = SUBMIT_URB(urb, GFP_ATOMIC);
2572 #endif
2573
2574 if (status)
2575 FPRINT("Can't resubmit interrupt urb!!!");
2576 #endif
2577
2578 spin_unlock(&macp->intr_lock);
2579
2580 return;
2581 }
2582
2583
2584 //callback function for register get/set
2585 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
2586 void zd1211_reg_cb(struct urb *urb)
2587 #else
2588 void zd1211_reg_cb(struct urb *urb, struct pt_regs *regs)
2589 #endif
2590 {
2591 struct zd1205_private *macp = urb->context;
2592 set_bit(ZD1211_CMD_FINISH, &macp->flags);
2593 wake_up(&macp->regSet_wait);
2594 }
2595
2596 void zd1211_handle_non_tx_rx(struct zd1205_private *macp)
2597 {
2598 u32 intr_status;
2599 // in current design, no need to use spinlock
2600
2601 //intr_status = *(u16 *)(macp->IntEPBuffer3+4);
2602 intr_status = zd_get_LE_U16(macp->IntEPBuffer3+4);
2603 //ZD1211DEBUG(2, "intr_status = %x\n", intr_status);
2604
2605 if (!intr_status)
2606 {
2607 printk("In %s,, intr_status is NULL\n", __FUNCTION__);
2608 goto done;
2609 return;
2610 }
2611
2612 if (intr_status & WAKE_UP){
2613 //printk("WAKE_UP\n");
2614 //printk(KERN_ERR "befor1 : %lu\n", jiffies);
2615 down(&macp->ps_sem);
2616 //printk(KERN_ERR "before2: %lu\n", jiffies);
2617 if (dot11Obj.bDeviceInSleep){
2618 zd1205_process_wakeup(macp);
2619 }
2620
2621 //printk(KERN_ERR "after2: %lu\n", jiffies);
2622 up(&macp->ps_sem);
2623 //printk(KERN_ERR "after1: %lu\n", jiffies);
2624
2625 }
2626
2627 if (intr_status & CFG_NEXT_BCN){
2628 //ZD1211DEBUG(2, "CFG_NEXT_BCN\n");
2629 if (macp->config_next_bcn_en){
2630 if (macp->cardSetting.BssType == AP_BSS)
2631 goto done;
2632
2633 macp->bcnCnt++;
2634 down(&macp->bcn_sem);
2635 zd_EventNotify(EVENT_TBCN, 0, 0, 0);
2636 up(&macp->bcn_sem);
2637
2638 if (macp->cardSetting.BssType == INDEPENDENT_BSS){
2639 macp->bFrmRxed1 = 0;
2640 }
2641 #if 0
2642 else if (macp->cardSetting.BssType == AP_BSS){
2643 if (macp->dtimCount == 0)
2644 macp->dtimCount = macp->cardSetting.DtimPeriod;
2645 macp->dtimCount--;
2646 }
2647 #endif
2648 }
2649 }
2650
2651 if (intr_status & DTIM_NOTIFY){
2652 printk("DTIM_NOTIFY\n");
2653 if (macp->dtim_notify_en){
2654 macp->dtimCnt++;
2655 zd_EventNotify(EVENT_DTIM_NOTIFY, 0, 0, 0);
2656 }
2657 }
2658
2659 done:
2660 macp->bHandleNonRxTxRunning = 0;
2661
2662 // enable non-RxTx interrupt
2663 zd1205_enable_int();
2664 return;
2665 }
2666
2667 int zd1211_submit_rx_urb(struct zd1205_private *macp)
2668 {
2669 struct rx_list_elem *rx_struct = NULL;
2670 u8 *rx_buff = NULL;
2671 u32 bufLen = MAX_WLAN_SIZE - macp->rxOffset;
2672 int res;
2673 //int memflags = GFP_KERNEL;
2674
2675
2676
2677 rx_struct = zd1205_start_ru(macp);
2678
2679 if (!rx_struct)
2680 return 1;
2681
2682 #if fMERGE_RX_FRAME
2683 if (rx_struct->UnFinishFrmLen){
2684 rx_buff = (u8 *)(rx_struct->dma_addr)+ macp->rxOffset + (rx_struct->UnFinishFrmLen);
2685 bufLen -= (rx_struct->UnFinishFrmLen);
2686 }
2687 else
2688 rx_buff = (u8 *)(rx_struct->dma_addr) + macp->rxOffset;
2689
2690
2691 #else
2692
2693 rx_buff = (u8 *)(rx_struct->dma_addr) + macp->rxOffset;
2694 #endif
2695
2696
2697 usb_fill_bulk_urb(macp->rx_urb, macp->usb,
2698 usb_rcvbulkpipe(macp->usb, EP_DATA_IN),
2699 rx_buff, bufLen,
2700
2701 zd1211_rx_comp_cb, macp);
2702
2703 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
2704 macp->rx_urb->transfer_flags |= URB_ASYNC_UNLINK;
2705 #endif
2706 if ((res = SUBMIT_URB(macp->rx_urb, GFP_ATOMIC))){
2707 printk(KERN_ERR "zd1211: failed rx_urb\n");
2708 zd1211_DumpErrorCode(macp, res);
2709 }
2710
2711
2712
2713 return 0;
2714 }
2715
2716
2717
2718 void zd1211_tx_isr(unsigned long parm)
2719 {
2720 struct zd1205_private *macp = (struct zd1205_private *)parm;
2721 zd1205_SwTcb_t *sw_tcb;
2722
2723
2724 ZENTER(3);
2725
2726 spin_lock(&macp->intr_lock);
2727
2728 sw_tcb = macp->activeTxQ->first;
2729 if (sw_tcb)
2730 sw_tcb->pTcb->CbStatus = CB_STATUS_COMPLETE;
2731 zd1205_tx_isr(macp);
2732
2733 #if 0
2734 if (dot11Obj.QueueFlag & TX_QUEUE_SET){
2735 macp->txQueSetCnt++;
2736
2737 tasklet_schedule(&macp->zd1205_tx_tasklet);
2738 }
2739 #endif
2740
2741 spin_unlock(&macp->intr_lock);
2742
2743 ZEXIT(3);
2744
2745 }
2746
2747
2748
2749 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
2750 void zd1211_tx_comp_cb(struct urb *urb)
2751 #else
2752 void zd1211_tx_comp_cb(struct urb *urb, struct pt_regs *regs)
2753
2754 #endif
2755 {
2756 struct zd1205_private *macp = urb->context;
2757
2758
2759 if ((!macp) || !test_bit(ZD1211_RUNNING, &macp->flags))
2760 {
2761 printk(KERN_ERR "macp is NULL or macp.flags.ZD1211_RUNNING\n");
2762 return;
2763 }
2764
2765 if (!netif_device_present(macp->device))
2766 {
2767 printk(KERN_ERR "netif_device_present return NULL\n");
2768 return;
2769 }
2770
2771 if (urb->status)
2772 {
2773 printk(KERN_ERR "Tx status: %d", urb->status);
2774 zd1211_DumpErrorCode(macp, urb->status);
2775 }
2776
2777 macp->usbTxCompCnt++;
2778 //Clear here results in race condition on SMP. We move it to zd1205_tx_isr
2779 //clear_bit(ZD1211_TX_BUSY, &macp->flags);
2780
2781 macp->TxStartTime = 0;
2782
2783 macp->write_urb = urb;
2784
2785 zd1211_tx_isr((unsigned long) macp);
2786
2787 return;
2788 }
2789
2790
2791
2792
2793
2794
2795 // return send_length
2796 int zd1211_submit_tx_urb(struct zd1205_private *macp,BOOLEAN LastFrag)
2797 {
2798 u8 *dst = macp->tx_buff;
2799
2800
2801 u32 TotalLength = 0;
2802
2803 zd1205_Ctrl_Set_t *pCtrlSet;
2804 zd1205_TBD_t *Tbd;
2805 zd1205_SwTcb_t *sw_tcb;
2806 int res;
2807 U32 TxCbTbdNumber;
2808 static U32 lastSetBusy = 0;
2809 //int memflags = GFP_KERNEL;
2810
2811
2812
2813 if (!macp->activeTxQ->count)
2814 {
2815 if(macp->bPSMSupported)
2816 if(test_bit(ZD1211_TX_BUSY, &macp->flags) == 0)
2817 if(dot11Obj.bDeviceInSleep == 0 && mPwrState == 1)
2818 if(macp->bAssoc && atomic_read(&macp->DoNotSleep) == 0)
2819 if(!dot11Obj.bMoreData)
2820 {
2821 //printk("Schedule to Sleep \n");
2822 dot11Obj.bDeviceInSleep = 1;
2823 defer_kevent(macp, KEVENT_FALL_IN_SLEEP);
2824 }
2825 return 0;
2826
2827 }
2828 if(dot11Obj.bDeviceInSleep)
2829 {
2830 return 0;
2831 }
2832
2833 if (test_and_set_bit(ZD1211_TX_BUSY, &macp->flags))
2834 {
2835 if(jiffies - lastSetBusy> 5*HZ)
2836 {
2837 printk("ZD1211_TX_BUSY is locked over 5 seconds\n");
2838 }
2839 return 0;
2840 }
2841 lastSetBusy = jiffies;
2842
2843 ZENTER(3);
2844
2845 sw_tcb = macp->activeTxQ->first;
2846 //Not include CtrlSet & MacHdr
2847 TxCbTbdNumber = sw_tcb->pTcb->TxCbTbdNumber - 2;
2848 pCtrlSet = sw_tcb->pHwCtrlPtr;
2849 Tbd = sw_tcb->pFirstTbd;
2850
2851 // We skip TCB address, Address 1, NextLength = 16 bytes, add 2 bytes for total length
2852 //pCtrlSet->CtrlSetting[23]=0;
2853 //pCtrlSet->CtrlSetting[24]=0;
2854
2855 memcpy(dst, (u8 *)(pCtrlSet), 3);
2856 dst += 3;
2857
2858 TotalLength += 3;
2859
2860 memcpy(dst, (u8 *)(pCtrlSet)+(3+8), // 8 mean skip TCB address
2861
2862 1); // misc
2863
2864 dst += 1;
2865
2866
2867 TotalLength += 1;
2868
2869
2870 dst += 2; // reserver 2 bytes for total length
2871
2872 TotalLength += 2;
2873
2874
2875
2876 memcpy(dst, (u8 *)(pCtrlSet)+(3+8+1+6+2), // 6:skip address 1, 2:skip next length
2877 5);
2878
2879 dst += 5;
2880
2881 TotalLength += 5;
2882
2883 ZD1211DEBUG(2, "Tx Ctrl Length = %x\n", TotalLength);
2884
2885 Tbd++;
2886
2887 //Mac Header
2888 if(*((u8 *)Tbd->TbdBufferAddrLowPart) != PS_POLL)
2889 {
2890 *(U8 *)(Tbd->TbdBufferAddrLowPart+2) = 0;
2891 *(U8 *)(Tbd->TbdBufferAddrLowPart+3) = 0;
2892 }
2893 else
2894 {
2895 if(macp->bPSMSupported != 1)
2896 printk("What~~~~PS_POLL & mPwrState ==0\n");
2897
2898
2899 }
2900
2901 /*
2902 if(macp->bPSMSupported != 1)
2903 {
2904 *(U8 *)(Tbd->TbdBufferAddrLowPart+2) = 0;
2905 *(U8 *)(Tbd->TbdBufferAddrLowPart+3) = 0;
2906 }
2907 else
2908 {
2909 if( ((*((U8 *)pCtrlSet + 11)) & (BIT_2|BIT_3)) != (BIT_2 | BIT_3))
2910 {
2911 *(U8 *)(Tbd->TbdBufferAddrLowPart+2) = 0;
2912 *(U8 *)(Tbd->TbdBufferAddrLowPart+3) = 0;
2913 }
2914 else
2915 printk("PS_POLL Found\n");
2916 }
2917 */
2918 /*
2919 if(*(u8 *)(Tbd->TbdBufferAddrLowPart+2)!=0) {
2920 //if(macp->bPSMSupported != 1)
2921 if(!( (*((U8 *)pCtrlSet + 11)) & BIT_2))
2922 {
2923 *(U8 *)(Tbd->TbdBufferAddrLowPart+2) = 0;
2924 *(U8 *)(Tbd->TbdBufferAddrLowPart+3) = 0;
2925 // *(u16 *)(Tbd->TbdBufferAddrLowPart+2)=0;
2926 }
2927 //printk("Non-Zero Duration,%d\n",*(u16 *)(Tbd->TbdBufferAddrLowPart+2));
2928 //printk("\n OK\n");
2929 }
2930 else if(*(u8 *)(Tbd->TbdBufferAddrLowPart+3)!=0) {
2931 //if(macp->bPSMSupported != 1)
2932 if(!( (*((U8 *)pCtrlSet + 11)) & BIT_2))
2933 {
2934 *(U8 *)(Tbd->TbdBufferAddrLowPart+2) = 0;
2935 *(U8 *)(Tbd->TbdBufferAddrLowPart+3) = 0;
2936 // *(u16 *)(Tbd->TbdBufferAddrLowPart+2)=0;
2937 }
2938 //printk("Non-Zero Duration,%d\n",*(u16 *)(Tbd->TbdBufferAddrLowPart+2));
2939 //printk("\n OK\n");
2940 }
2941 */
2942
2943
2944 memcpy(dst, (u8 *)Tbd->TbdBufferAddrLowPart, Tbd->TbdCount);
2945
2946 ZD1211DEBUG(2, "MAC Header Length = %x\n", Tbd->TbdCount);
2947 dst += Tbd->TbdCount;
2948
2949 TotalLength += Tbd->TbdCount;
2950
2951 Tbd++;
2952
2953 //MAC Body
2954 while(TxCbTbdNumber)
2955 {
2956 TxCbTbdNumber --;
2957 memcpy(dst, (u8 *)Tbd->TbdBufferAddrLowPart, Tbd->TbdCount);
2958
2959 ZD1211DEBUG(2, "Tx DATA Length = %x\n", Tbd->TbdCount);
2960 dst += Tbd->TbdCount;
2961
2962
2963 TotalLength += Tbd->TbdCount;
2964 Tbd++;
2965
2966 ZD1211DEBUG(2, "TotalLength = %x\n", TotalLength);
2967
2968 if(LastFrag == TRUE) {
2969 if(TxCbTbdNumber > 0)
2970 printk("TxCbTbdNumber > 0, This is invalid. It is greater than 0 only in LP_Mode. And LP_Mode doesn't allow fragment\n");
2971 memcpy(dst-sw_tcb->MIC_Len,sw_tcb->CalMIC+sw_tcb->MIC_Start,sw_tcb->MIC_Len);
2972 }
2973 }
2974
2975
2976
2977 // write down total length
2978 #ifdef ZD1211
2979 //*((u16 *)(macp->tx_buff+4)) = (u16)TotalLength + 14;
2980 // For endian-free U16 write
2981 *(macp->tx_buff+4) = (U8)((U16)TotalLength+14) ;
2982 *(macp->tx_buff+5) = (U8)(((U16)TotalLength+14) >> 8);
2983 #elif defined(ZD1211B)
2984 //*((u16 *)(macp->tx_buff+4)) = sw_tcb->LengthDiff;
2985 *(macp->tx_buff+4) = (U8)(sw_tcb->LengthDiff);
2986 *(macp->tx_buff+5) = (U8)(sw_tcb->LengthDiff >> 8);
2987 #endif
2988
2989 /*
2990 if(TotalLength > 400)
2991 {
2992 int i;
2993 for(i=0;i<24;i++)
2994 printk("%02x ", *(macp->tx_buff+i));
2995 printk("Total : %d", TotalLength);
2996 printk("\n");
2997 }
2998 */
2999
3000
3001 ZD1211DEBUG(2, "macp->tx_buff+4 = %x\n", *((u16 *)(macp->tx_buff+4)));
3002
3003
3004 usb_fill_bulk_urb(macp->tx_urb, macp->usb,
3005 usb_sndbulkpipe(macp->usb, EP_DATA_OUT),
3006 macp->tx_buff, TotalLength,
3007 zd1211_tx_comp_cb, macp);
3008
3009
3010
3011 macp->tx_urb->transfer_buffer_length = TotalLength;
3012 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,14))
3013 macp->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
3014 #endif
3015 res = SUBMIT_URB(macp->tx_urb, GFP_ATOMIC);
3016 if (res){
3017
3018 printk("error in tx submit urb: %d", res);
3019 printk("Clear Tx Busy\n");
3020 clear_bit(ZD1211_TX_BUSY, &macp->flags);
3021 zd1211_DumpErrorCode(macp, res);
3022 goto err;
3023 }
3024
3025 macp->usbTxCnt++;
3026
3027 //set_bit(ZD1211_TX_BUSY, &macp->flags);
3028
3029
3030
3031
3032 ZEXIT(3);
3033
3034 return TotalLength;
3035
3036
3037
3038 err:
3039 return 0;
3040 }
3041
3042
3043
3044 void zd1211_disable_net_traffic(struct zd1205_private *macp)
3045 {
3046
3047 // When suspend, call this
3048 if ( (macp->RF_Mode == AL2230_RF) || (macp->RF_Mode == AL2230S_RF) )
3049 HW_Set_IF_Synthesizer(&dot11Obj, 0x71687);
3050
3051 LockPhyReg(&dot11Obj);
3052 zd_writel(0xFF, ZD_CR252);
3053 zd_writel(0xc, ZD_CR253);
3054
3055
3056
3057 zd_writel(0x3, ZD_CR255);
3058 UnLockPhyReg(&dot11Obj);
3059
3060
3061 zd_writel(0x0, BCNInterval);
3062 // Turn off LEDs
3063
3064 zd_writel(0x0, rLED_CTRL);
3065
3066 // turn of MAC
3067 zd_writel(0x3, PS_Ctrl);
3068
3069
3070
3071
3072 dot11Obj.PhyTest = 0;
3073 macp->LinkTimer = 0;
3074
3075
3076 }
3077
3078
3079 #if 0
3080 int zd1211_DownLoadUSBCode(struct zd1205_private *macp, u8* filename, void *ptr, u16 uCodeOfst)
3081 {
3082 int ifp;
3083 long bcount;
3084 mm_segment_t fs;
3085
3086 struct stat file_info;
3087
3088 size_t* file_length;
3089
3090 u8 *buffer;
3091
3092 //FPRINT("DownLoadUSBCode");
3093
3094 // Open the code file
3095
3096 // for file opening temporarily tell the kernel I am not a user for
3097 // memory management segment access
3098
3099 fs = get_fs();
3100 set_fs(KERNEL_DS);
3101
3102
3103 // open the file with the firmware for uploading
3104
3105 if (ifp = open(filename, O_RDONLY, 0 ), ifp < 0){
3106 // error opening the file
3107 FPRINT("ERROR: File opening did not success");
3108 set_fs(fs);
3109 return -1;
3110 }
3111
3112
3113
3114
3115 /* Get information about the file. */
3116 fstat (ifp, &file_info);
3117 file_length = file_info.st_size;
3118
3119
3120 buffer = kmalloc(file_length, GFP_ATOMIC);
3121
3122 /* Read the file into the buffer. */
3123 bcount = read(ifp, buffer, file_length);
3124
3125 if (bcount != file_length)
3126 FPRINT("read failed");
3127
3128
3129
3130 // close the file
3131
3132
3133
3134 close(ifp);
3135
3136 // switch back the segment setting
3137
3138 set_fs(fs);
3139
3140
3141
3142 ret = zd1211_LoadUSBSpecCode(macp, buffer, file_length, uCodeOfst, true);
3143
3144
3145
3146 kfree(buffer);
3147
3148
3149
3150
3151 return ret;
3152
3153
3154 }
3155 #endif
3156 void ZD1211_WriteMultiRegister(u16 *Address, u16 *Value, u16 RegCount, BOOLEAN AddUSBCSRAddress)
3157 {
3158 int count = 0;
3159 u8 ret = 0xff;
3160
3161 while (ret != 0) {
3162 ret = zd1211_USB_PACKAGE_WRITE_REGISTER(Address, Value, RegCount, AddUSBCSRAddress);
3163 count++;
3164
3165 if (count > 5){
3166 printk("ZD1211_WriteMultiRegister failed!!\n");
3167 break;
3168 }
3169 }
3170 }
3171 void ZD1211_WRITE_MULTI_REG(u16 *pAddress, u16 *pValue, u16 *pRegCount)
3172 {
3173 u16 TotalRegCount = *pRegCount;
3174 u16* pWriteAddr = pAddress;
3175 u16* pWriteData = pValue;
3176
3177 if(TotalRegCount > 256)
3178 printk("Reg Count > 256 !!!!!!!!!!!\n");
3179 while (TotalRegCount > cMAX_MULTI_WRITE_REG_NUM)
3180 {
3181 ZD1211_WriteMultiRegister(pWriteAddr, pWriteData, cMAX_MULTI_WRITE_REG_NUM, true);
3182
3183 TotalRegCount -= cMAX_MULTI_WRITE_REG_NUM;
3184 pWriteAddr += cMAX_MULTI_WRITE_REG_NUM;
3185 pWriteData += cMAX_MULTI_WRITE_REG_NUM;
3186 }
3187
3188 if (TotalRegCount)
3189 ZD1211_WriteMultiRegister(pWriteAddr, pWriteData, TotalRegCount, true);
3190
3191 *pRegCount = 0;
3192
3193
3194 }
3195 int zd1211_GetUSBSpecData(struct zd1205_private *macp, u8 *pBuffer,
3196 u32 uImgLength, u16 uCodeOfst)
3197
3198 {
3199 u32 uCurLength;
3200 int result = 0;
3201 u8 *image, *ptr;
3202 u32 uploadLength = uImgLength;
3203
3204
3205 image = kmalloc(uImgLength, GFP_KERNEL);
3206 ptr = image;
3207
3208 while (uImgLength > 0){
3209 uCurLength = uImgLength;
3210 if (uCurLength > 60)
3211 uCurLength = 60;
3212
3213 // Get data from device
3214 result = usb_control_msg(macp->usb, usb_rcvctrlpipe(macp->usb, 0),
3215 FIRMWARE_READ_DATA, USB_DIR_IN | 0x40, uCodeOfst, 0,
3216 image, uCurLength, 1000 * HZ);
3217
3218 //ZD1211DEBUG(3, "result = %d\n", result);
3219 if (result < 0) {
3220 printk(KERN_ERR "zd1211: usb_rcvctrlpipe 1 fail: %02X\n", result);
3221 goto exit;
3222 }
3223 else if(uCurLength != result)
3224 {
3225 printk("control msg sends less. If you see this twice, you get troubles\n");
3226 }
3227
3228
3229
3230
3231 uImgLength -= uCurLength;
3232 image += uCurLength;
3233
3234 uCodeOfst += (u16) (uCurLength / 2); // in Word (16 bit)
3235 result = 0;
3236
3237 }
3238
3239 image -= uploadLength; //move to buffer head
3240 memcpy(pBuffer, image, uploadLength);
3241
3242 exit:
3243 //kfree(image);
3244 kfree(ptr);
3245
3246 return result ;
3247 }
3248
3249 //return 0: success, others: fail
3250 int zd1211_LoadUSBSpecCode(struct zd1205_private *macp, u8 *pBuffer, u32 uImgLength, u16 uCodeOfst, u8 bReboot)
3251 {
3252 u8 ret;
3253 int result = 0;
3254 u8 *image, *ptr;
3255
3256 ZD1211DEBUG(0, "uImgLength = %x\n", uImgLength);
3257 image = kmalloc(uImgLength, GFP_KERNEL);
3258 ptr = image;
3259 memcpy(image, pBuffer, uImgLength);
3260
3261
3262 while (uImgLength > 0) {
3263 int translen = (uImgLength > 4096) ? 4096 : uImgLength;
3264
3265 ZD1211DEBUG(0, "translen = %x\n", translen);
3266 ZD1211DEBUG(0, "uCodeOfst = %x\n", uCodeOfst);
3267 result = usb_control_msg(macp->usb, usb_sndctrlpipe(macp->usb, 0),
3268 FIRMWARE_DOWNLOAD, USB_DIR_OUT | 0x40, uCodeOfst, 0,
3269 image, translen, HZ);
3270
3271 ZD1211DEBUG(0, "result = %x\n", result);
3272 if(result != translen) {
3273 printk("##### Warning! ####\n");
3274 printk("usb_control_msg doesn't send all data out\n");
3275 printk("You need to decrease the message amount in each send\n");
3276 }
3277
3278 if (result < 0) {
3279 printk(KERN_ERR "zd1211: usb_control_msg 1 fail: %02X\n", result);
3280 goto exit;
3281 }
3282
3283 uImgLength -= translen;
3284 image += translen;
3285 uCodeOfst += (u16) (translen / 2); // in Word (16 bit)
3286 result = 0;
3287 }
3288
3289 if (bReboot){
3290 printk("Finish download Firmware. Ready to reboot \n");
3291 result = usb_control_msg(macp->usb, usb_rcvctrlpipe(macp->usb, 0),
3292 FIRMWARE_CONFIRM, USB_DIR_IN | 0x40, 0, 0,
3293 &ret, sizeof(ret), 1000 * HZ);
3294 if (result < 0) {
3295
3296 printk(KERN_ERR "zd1211: usb_control_msg 2 fail: %02X\n", result);
3297
3298
3299
3300 goto exit;
3301
3302
3303 }
3304
3305 //ZD1211DEBUG(2, "result = %x\n", result);
3306
3307 ZD1211DEBUG(0, "FIRMWARE_CONFIRM = %x\n", ret);
3308
3309
3310
3311 if (ret & 0x80) {
3312 FPRINT("USB Download Boot code error");
3313
3314 goto exit;
3315 }
3316 else {
3317 ZD1211DEBUG(0, "USB Download Boot code success\n");
3318 }
3319
3320 result = 0;
3321
3322 }
3323
3324 exit:
3325 //kfree(image);
3326 kfree(ptr);
3327 return result;
3328
3329 }
3330
3331 int zd1211_Download_IncludeFile(struct zd1205_private *macp)
3332 {
3333 int ret;
3334 u16 EEPVer;
3335
3336 //return 0; //for debug
3337
3338 EEPVer = WS11Ub[cEPDATA_OFFSET * 2] + (WS11Ub[cEPDATA_OFFSET * 2 + 1] << 8);
3339 printk(KERN_NOTICE "EEPORM Ver = %x\n", EEPVer);
3340
3341
3342 if (macp->release != EEPVer){
3343 ZD1211DEBUG(0, "macp->release != EEPVer\n");
3344 if (macp->release <= 0x4312)
3345 ret = zd1211_LoadUSBSpecCode(macp, WS11Ur2, sizeof(WS11Ur2),
3346 cFIRMWARE_OLD_ADDR, false);
3347
3348 ret = zd1211_LoadUSBSpecCode(macp, WS11Ur, sizeof(WS11Ur),
3349 cFIRMWARE_START_ADDR, true);
3350 if (ret != 0){
3351 FPRINT("Load WS11Ur fail");
3352 return ret;
3353 }
3354
3355 ret = zd1211_LoadUSBSpecCode(macp, WS11Ub + (cEPDATA_OFFSET * 2) + (E2P_END - E2P_SUBID),
3356 sizeof(WS11Ub) - (cEPDATA_OFFSET * 2) - (E2P_END - E2P_SUBID),
3357 cFIRMWARE_EEPROM_OFFSET + (E2P_END - E2P_SUBID) / 2,
3358 true);
3359
3360 if (ret != 0){
3361 FPRINT("Load WS11Ub fail");
3362 return ret;
3363 }
3364
3365
3366 if (macp->release == 0x0101)
3367 ret = zd1211_GetUSBSpecData(macp, WS11Ub + (cEPDATA_OFFSET * 2),
3368 (E2P_END - E2P_SUBID),
3369 cBOOTCODE_START_ADDR);
3370 else
3371 ret = zd1211_GetUSBSpecData(macp, WS11Ub + (cEPDATA_OFFSET * 2),
3372 (E2P_END - E2P_SUBID),
3373 cFIRMWARE_EEPROM_OFFSET);
3374
3375
3376 if (ret != 0){
3377 FPRINT("Read EEPROM Data fail");
3378 return ret;
3379
3380 }
3381
3382 WS11Ub[(cEPDATA_OFFSET * 2) + (E2P_DEVICE_VER - E2P_SUBID)] = EEPVer & 0xFF;
3383 WS11Ub[(cEPDATA_OFFSET * 2) + (E2P_DEVICE_VER - E2P_SUBID) + 1] = EEPVer >> 8;
3384
3385 ret = zd1211_LoadUSBSpecCode(macp, WS11Ub,
3386 (E2P_END - E2P_SUBID) + (cEPDATA_OFFSET * 2),
3387 cBOOTCODE_START_ADDR,
3388 false);
3389
3390
3391 if (ret != 0){
3392 FPRINT("Write EEPROM Data fail");
3393 return ret;
3394 }
3395
3396 }
3397
3398 //for single RX
3399 ret = zd1211_LoadUSBSpecCode(macp, WS11UPh, sizeof(WS11UPh), cFIRMWARE_START_ADDR, true);
3400
3401 if (ret != 0){
3402
3403 FPRINT("Load WS11UPh fail\n");
3404 return ret;
3405 }
3406
3407 return 0;
3408 }
3409
3410 // tasklet (work deferred from completions, in_irq) or timer
3411 void defer_kevent(struct zd1205_private *macp, int flag)
3412 {
3413
3414 ZENTER(4);
3415
3416 if (!macp->bUSBDeveiceAttached)
3417 {
3418 return;
3419 }
3420 // if (macp->kevent_flags != 0)
3421 // printk("macp->kevent_flags=%08x\n",macp->kevent_flags);
3422 set_bit(flag, &macp->kevent_flags);
3423 /*
3424 if (flag == KEVENT_SCAN_TIMEOUT)
3425 {
3426 if(!schedule_work(&macp->scan_tout_event))
3427 {
3428 ZD1211DEBUG(4, "schedule_task failed, flag = %x\n", flag);
3429 if(!schedule_work(&macp->scan_tout_event)) {
3430 dot11Obj.bChScanning = FALSE;
3431 }
3432 printk(" Schedule task fail \n");
3433 }
3434 ZEXIT(4);
3435 return;
3436 }
3437 */
3438
3439
3440
3441 if (!schedule_work(&macp->kevent)){
3442 ZD1211DEBUG(4,"schedule_task failed, flag = %x\n", flag);
3443 }
3444
3445 ZEXIT(4);
3446
3447 }
3448 unsigned int smp_kevent_Lock = 0;
3449 void kevent(void *data)
3450 {
3451 struct zd1205_private *macp = (struct zd1205_private *) data;
3452
3453 if (!macp->bUSBDeveiceAttached)
3454 {
3455 return;
3456 }
3457
3458
3459 if(test_and_set_bit(0, (void *)&smp_kevent_Lock))
3460 {
3461 schedule_work(&macp->kevent);
3462 return;
3463 }
3464
3465 down(&macp->ioctl_sem);
3466
3467 /*prince add for dis_update_setting
3468 if (test_bit( KEVENT_DIS_UPDATE_SETTING, &macp->kevent_flags)){
3469 if ( zd1205_dis_update_setting(macp) == 1 )
3470 {
3471 clear_bit( KEVENT_DIS_UPDATE_SETTING, &macp->kevent_flags);
3472 }
3473 }
3474
3475 //prince add for moxa_repeat
3476 if (test_bit( KEVENT_MOXA_REPEAT, &macp->kevent_flags)){
3477 if ( zd1205_moxa_repeat(macp) == 1 )
3478 {
3479 clear_bit( KEVENT_MOXA_REPEAT, &macp->kevent_flags);
3480 }
3481 }
3482 */
3483
3484
3485
3486 //non tx rx interrupt
3487 if (test_bit(KEVENT_FALL_IN_SLEEP, &macp->kevent_flags)){
3488 //printk("Handling FALL IN SLEEP Kevent\n");
3489 zd1205_sleep_reset(macp);
3490 clear_bit(KEVENT_FALL_IN_SLEEP,&macp->kevent_flags);
3491 up(&macp->ioctl_sem);
3492 clear_bit(0, (void *)&smp_kevent_Lock);
3493 schedule_work(&macp->kevent);
3494 return;
3495 }
3496 if (test_bit(KEVENT_NON_TX_RX_INT, &macp->kevent_flags)){
3497 //printk("Get Non Tx Rx\n");
3498 zd1211_handle_non_tx_rx(macp);
3499 clear_bit(KEVENT_NON_TX_RX_INT, &macp->kevent_flags);
3500 }
3501
3502 if(dot11Obj.bDeviceInSleep)
3503 {
3504 up(&macp->ioctl_sem);
3505 clear_bit(0, (void *)&smp_kevent_Lock);
3506 schedule_work(&macp->kevent);
3507 return;
3508 }
3509 dot11Obj.AcquireDoNotSleep();
3510
3511
3512 if (test_bit(KEVENT_USB_KILL_TX_URB, &macp->kevent_flags)) {
3513 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,8))
3514 #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,14))
3515 macp->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
3516 #endif
3517 printk("We are going to usb_kill_urb @ kevent\n");
3518 usb_kill_urb(macp->tx_urb);
3519 #else
3520 printk("Why do you call this ?\n");
3521 #endif
3522 clear_bit(KEVENT_USB_KILL_TX_URB, &macp->kevent_flags);
3523 }
3524 /*
3525 if (test_bit(KEVENT_NON_TX_RX_INT, &macp->kevent_flags)){
3526 zd1211_handle_non_tx_rx(macp);
3527 clear_bit(KEVENT_NON_TX_RX_INT, &macp->kevent_flags);
3528 }
3529 */
3530
3531 //scan timeout
3532 if (test_bit(KEVENT_SCAN_TIMEOUT, &macp->kevent_flags)){
3533 //FPRINT("scan");
3534 zd_EventNotify(EVENT_SCAN_TIMEOUT, 0, 0, 0);
3535 clear_bit(KEVENT_SCAN_TIMEOUT, &macp->kevent_flags);
3536 }
3537
3538 //mgt_mon timeout
3539 if (test_bit(KEVENT_MGT_MON_TIMEOUT, &macp->kevent_flags)){
3540 //FPRINT("connect_mon");
3541 zd1205_connect_mon(macp);
3542 clear_bit(KEVENT_MGT_MON_TIMEOUT, &macp->kevent_flags);
3543 }
3544
3545 //house keeping timeout
3546 if (test_bit(KEVENT_HOUSE_KEEPING, &macp->kevent_flags)){
3547 zd1205_house_keeping(macp);
3548 clear_bit(KEVENT_HOUSE_KEEPING, &macp->kevent_flags);
3549 }
3550
3551 //watchdog timeout
3552 if (test_bit(KEVENT_WATCH_DOG, &macp->kevent_flags)){
3553 zd1205_watchdog(macp);
3554 clear_bit(KEVENT_WATCH_DOG, &macp->kevent_flags);
3555 }
3556
3557 //auth timeout
3558 if (test_bit(KEVENT_AUTH_TIMEOUT, &macp->kevent_flags)){
3559 zd_EventNotify(EVENT_AUTH_TIMEOUT, 0, 0, 0);
3560 clear_bit(KEVENT_AUTH_TIMEOUT, &macp->kevent_flags);
3561 }
3562
3563 //associate timeout
3564 if (test_bit(KEVENT_ASOC_TIMEOUT, &macp->kevent_flags)){
3565 zd_EventNotify(EVENT_ASOC_TIMEOUT, 0, 0, 0);
3566 clear_bit(KEVENT_ASOC_TIMEOUT, &macp->kevent_flags);
3567 }
3568
3569 //challenge timeout
3570 if (test_bit(KEVENT_TCHAL_TIMEOUT, &macp->kevent_flags)){
3571 zd_EventNotify(EVENT_TCHAL_TIMEOUT, 0, 0, 0);
3572 clear_bit(KEVENT_TCHAL_TIMEOUT, &macp->kevent_flags);
3573 }
3574
3575 //zd_ioctl
3576 if (test_bit(KEVENT_ZD_IOCTL, &macp->kevent_flags)){
3577 //FPRINT("ioctl");
3578 zd1205_zd_dbg_ioctl(macp, &macp->zdreq);
3579 clear_bit(KEVENT_ZD_IOCTL, &macp->kevent_flags);
3580 }
3581
3582 //wpa ioctl handling
3583 if (test_bit(KEVENT_ZD_WPA_IOCTL, &macp->kevent_flags)){
3584 zd1205_wpa_ioctl(macp, &macp->zd_wpa_req);
3585 clear_bit(KEVENT_ZD_WPA_IOCTL, &macp->kevent_flags);
3586 }
3587
3588 //use protection
3589 if (test_bit(KEVENT_EN_PROTECTION, &macp->kevent_flags)){
3590 zd_EventNotify(EVENT_ENABLE_PROTECTION, 1, 0, 0);
3591 clear_bit(KEVENT_EN_PROTECTION, &macp->kevent_flags);
3592 }
3593
3594 //disable protection
3595 if (test_bit(KEVENT_DIS_PROTECTION, &macp->kevent_flags)){
3596 zd_EventNotify(EVENT_ENABLE_PROTECTION, 0, 0, 0);
3597 clear_bit(KEVENT_DIS_PROTECTION, &macp->kevent_flags);
3598 }
3599
3600 //update card setting
3601 if (test_bit(KEVENT_UPDATE_SETTING, &macp->kevent_flags)){
3602 zd_UpdateCardSetting(&macp->cardSetting);
3603 clear_bit(KEVENT_UPDATE_SETTING, &macp->kevent_flags);
3604 }
3605
3606 //set multicast
3607 if (test_bit(KEVENT_SET_MULTICAST, &macp->kevent_flags)){
3608 zd1211_set_multicast(macp);
3609 clear_bit(KEVENT_SET_MULTICAST, &macp->kevent_flags);
3610 }
3611
3612 //process signal
3613 if (test_bit(KEVENT_PROCESS_SIGNAL, &macp->kevent_flags)){
3614 zd_SigProcess();
3615 clear_bit(KEVENT_PROCESS_SIGNAL, &macp->kevent_flags);
3616 }
3617
3618 //enable barker preamble
3619 if (test_bit(KEVENT_EN_BARKER, &macp->kevent_flags)){
3620 zd_EventNotify(EVENT_ENABLE_BARKER, 1, 0, 0);
3621 clear_bit(KEVENT_EN_BARKER, &macp->kevent_flags);
3622 }
3623
3624 //disable barker preamble
3625 if (test_bit(KEVENT_DIS_BARKER, &macp->kevent_flags)){
3626 zd_EventNotify(EVENT_ENABLE_BARKER, 0, 0, 0);
3627 clear_bit(KEVENT_DIS_BARKER, &macp->kevent_flags);
3628 }
3629
3630 //enable short slot
3631 if (test_bit(KEVENT_EN_SHORT_SLOT, &macp->kevent_flags)){
3632 zd_EventNotify(EVENT_SHORT_SLOT, 1, 0, 0);
3633 clear_bit(KEVENT_EN_SHORT_SLOT, &macp->kevent_flags);
3634 }
3635
3636 //disable short slot
3637 if (test_bit(KEVENT_DIS_SHORT_SLOT, &macp->kevent_flags)){
3638 zd_EventNotify(EVENT_SHORT_SLOT, 0, 0, 0);
3639 clear_bit(KEVENT_DIS_SHORT_SLOT, &macp->kevent_flags);
3640 }
3641
3642 //disable short slot
3643 if (test_bit(KEVENT_DIS_CONNECT, &macp->kevent_flags)){
3644 if (!zd1205_dis_connect(macp)){
3645 zd_CmdProcess(CMD_DIS_CONNECT, 0, 0);
3646 macp->NoBcnDetectedCnt = 0;
3647 }
3648 clear_bit(KEVENT_DIS_CONNECT, &macp->kevent_flags);
3649 }
3650
3651 //std_ioctl
3652 if (test_bit(KEVENT_STD_IOCTL, &macp->kevent_flags)){
3653 //FPRINT("ioctl");
3654 zd1205_ioctl(macp->device, &macp->ifreq, macp->ifcmd);
3655 clear_bit(KEVENT_STD_IOCTL, &macp->kevent_flags);
3656 }
3657
3658 if (test_bit(KEVENT_REGISTER_NET, &macp->kevent_flags)){
3659 register_netdev(macp->device);
3660 clear_bit(KEVENT_REGISTER_NET, &macp->kevent_flags);
3661 }
3662
3663 //prince add for dis_update_setting
3664 if (test_bit( KEVENT_DIS_UPDATE_SETTING, &macp->kevent_flags)){
3665 if ( zd1205_dis_update_setting(macp) == 1 )
3666 {
3667 clear_bit( KEVENT_DIS_UPDATE_SETTING, &macp->kevent_flags);
3668 }
3669 }
3670
3671 //prince add for moxa_repeat
3672 if (test_bit( KEVENT_MOXA_REPEAT, &macp->kevent_flags)){
3673 if ( zd1205_moxa_repeat(macp) == 1 )
3674 {
3675 clear_bit( KEVENT_MOXA_REPEAT, &macp->kevent_flags);
3676 }
3677 }
3678
3679 clear_bit(0, (void *)&smp_kevent_Lock);
3680 up(&macp->ioctl_sem);
3681 dot11Obj.ReleaseDoNotSleep();
3682 }
3683 int test_flag;
3684 void zd1211_alloc_rx(unsigned long parm)
3685 {
3686 struct zd1205_private *macp = (struct zd1205_private *) parm;
3687 unsigned long flags;
3688
3689 if(!in_irq())spin_lock_irqsave(&macp->rx_pool_lock, flags);
3690 zd1205_alloc_skbs(macp);
3691 if(!in_irq())spin_unlock_irqrestore(&macp->rx_pool_lock, flags);
3692 }
3693
MOXA 2.6.9 from sdlinux-moxaart.tgz