projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Staging: add Realtek 8192 PCI wireless driver
[deliverable/linux.git] / drivers / staging / rtl8192e / r819xE_firmware.c
1 /**************************************************************************************************
2 * Procedure: Init boot code/firmware code/data session
3 *
4 * Description: This routine will intialize firmware. If any error occurs during the initialization
5 * process, the routine shall terminate immediately and return fail.
6 * NIC driver should call NdisOpenFile only from MiniportInitialize.
7 *
8 * Arguments: The pointer of the adapter
9
10 * Returns:
11 * NDIS_STATUS_FAILURE - the following initialization process should be terminated
12 * NDIS_STATUS_SUCCESS - if firmware initialization process success
13 **************************************************************************************************/
14 //#include "ieee80211.h"
15 #include "r8192E.h"
16 #include "r8192E_hw.h"
17 #ifdef RTL8190P
18 #include "r819xP_firmware_img.h"
19 #else
20 #include "r819xE_firmware_img.h"
21 #endif
22 #include "r819xE_firmware.h"
23 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
24 #include <linux/firmware.h>
25 #endif
26
27 extern void firmware_init_param(struct net_device *dev)
28 {
29 struct r8192_priv *priv = ieee80211_priv(dev);
30 rt_firmware *pfirmware = priv->pFirmware;
31
32 pfirmware->cmdpacket_frag_thresold = GET_COMMAND_PACKET_FRAG_THRESHOLD(MAX_TRANSMIT_BUFFER_SIZE);
33 }
34
35 /*
36 * segment the img and use the ptr and length to remember info on each segment
37 *
38 */
39 bool fw_download_code(struct net_device *dev, u8 *code_virtual_address, u32 buffer_len)
40 {
41 struct r8192_priv *priv = ieee80211_priv(dev);
42 bool rt_status = true;
43 u16 frag_threshold;
44 u16 frag_length, frag_offset = 0;
45 //u16 total_size;
46 int i;
47
48 rt_firmware *pfirmware = priv->pFirmware;
49 struct sk_buff *skb;
50 unsigned char *seg_ptr;
51 cb_desc *tcb_desc;
52 u8 bLastIniPkt;
53
54 firmware_init_param(dev);
55 //Fragmentation might be required
56 frag_threshold = pfirmware->cmdpacket_frag_thresold;
57 do {
58 if((buffer_len - frag_offset) > frag_threshold) {
59 frag_length = frag_threshold ;
60 bLastIniPkt = 0;
61
62 } else {
63 frag_length = buffer_len - frag_offset;
64 bLastIniPkt = 1;
65
66 }
67
68 /* Allocate skb buffer to contain firmware info and tx descriptor info
69 * add 4 to avoid packet appending overflow.
70 * */
71 //skb = dev_alloc_skb(USB_HWDESC_HEADER_LEN + frag_length + 4);
72 skb = dev_alloc_skb(frag_length + 4);
73 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
74 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
75 tcb_desc->queue_index = TXCMD_QUEUE;
76 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
77 tcb_desc->bLastIniPkt = bLastIniPkt;
78
79 //skb_reserve(skb, USB_HWDESC_HEADER_LEN);
80 seg_ptr = skb->data;
81 /*
82 * Transform from little endian to big endian
83 * and pending zero
84 */
85 for(i=0 ; i < frag_length; i+=4) {
86 *seg_ptr++ = ((i+0)<frag_length)?code_virtual_address[i+3]:0;
87 *seg_ptr++ = ((i+1)<frag_length)?code_virtual_address[i+2]:0;
88 *seg_ptr++ = ((i+2)<frag_length)?code_virtual_address[i+1]:0;
89 *seg_ptr++ = ((i+3)<frag_length)?code_virtual_address[i+0]:0;
90 }
91 tcb_desc->txbuf_size= (u16)i;
92 skb_put(skb, i);
93 priv->ieee80211->softmac_hard_start_xmit(skb,dev);
94
95 code_virtual_address += frag_length;
96 frag_offset += frag_length;
97
98 }while(frag_offset < buffer_len);
99
100 return rt_status;
101
102 #if 0
103 cmdsend_downloadcode_fail:
104 rt_status = false;
105 RT_TRACE(COMP_ERR, "CmdSendDownloadCode fail !!\n");
106 return rt_status;
107 #endif
108 }
109
110 bool
111 fwSendNullPacket(
112 struct net_device *dev,
113 u32 Length
114 )
115 {
116 bool rtStatus = true;
117 struct r8192_priv *priv = ieee80211_priv(dev);
118 struct sk_buff *skb;
119 cb_desc *tcb_desc;
120 unsigned char *ptr_buf;
121 bool bLastInitPacket = false;
122
123 //PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
124
125 //Get TCB and local buffer from common pool. (It is shared by CmdQ, MgntQ, and USB coalesce DataQ)
126 skb = dev_alloc_skb(Length+ 4);
127 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
128 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
129 tcb_desc->queue_index = TXCMD_QUEUE;
130 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
131 tcb_desc->bLastIniPkt = bLastInitPacket;
132 ptr_buf = skb_put(skb, Length);
133 memset(ptr_buf,0,Length);
134 tcb_desc->txbuf_size= (u16)Length;
135
136 if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
137 (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
138 (priv->ieee80211->queue_stop) ) {
139 RT_TRACE(COMP_FIRMWARE,"===================NULL packet==================================> tx full!\n");
140 skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
141 } else {
142 priv->ieee80211->softmac_hard_start_xmit(skb,dev);
143 }
144
145 //PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
146 return rtStatus;
147 }
148
149 //-----------------------------------------------------------------------------
150 // Procedure: Check whether main code is download OK. If OK, turn on CPU
151 //
152 // Description: CPU register locates in different page against general register.
153 // Switch to CPU register in the begin and switch back before return
154 //
155 //
156 // Arguments: The pointer of the adapter
157 //
158 // Returns:
159 // NDIS_STATUS_FAILURE - the following initialization process should be terminated
160 // NDIS_STATUS_SUCCESS - if firmware initialization process success
161 //-----------------------------------------------------------------------------
162 bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev)
163 {
164 bool rt_status = true;
165 int check_putcodeOK_time = 200000, check_bootOk_time = 200000;
166 u32 CPU_status = 0;
167
168 /* Check whether put code OK */
169 do {
170 CPU_status = read_nic_dword(dev, CPU_GEN);
171
172 if(CPU_status&CPU_GEN_PUT_CODE_OK)
173 break;
174
175 }while(check_putcodeOK_time--);
176
177 if(!(CPU_status&CPU_GEN_PUT_CODE_OK)) {
178 RT_TRACE(COMP_ERR, "Download Firmware: Put code fail!\n");
179 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
180 } else {
181 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n");
182 }
183
184 /* Turn On CPU */
185 CPU_status = read_nic_dword(dev, CPU_GEN);
186 write_nic_byte(dev, CPU_GEN, (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff));
187 mdelay(1);
188
189 /* Check whether CPU boot OK */
190 do {
191 CPU_status = read_nic_dword(dev, CPU_GEN);
192
193 if(CPU_status&CPU_GEN_BOOT_RDY)
194 break;
195 }while(check_bootOk_time--);
196
197 if(!(CPU_status&CPU_GEN_BOOT_RDY)) {
198 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
199 } else {
200 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Boot ready!\n");
201 }
202
203 return rt_status;
204
205 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
206 RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
207 rt_status = FALSE;
208 return rt_status;
209 }
210
211 bool CPUcheck_firmware_ready(struct net_device *dev)
212 {
213
214 bool rt_status = true;
215 int check_time = 200000;
216 u32 CPU_status = 0;
217
218 /* Check Firmware Ready */
219 do {
220 CPU_status = read_nic_dword(dev, CPU_GEN);
221
222 if(CPU_status&CPU_GEN_FIRM_RDY)
223 break;
224
225 }while(check_time--);
226
227 if(!(CPU_status&CPU_GEN_FIRM_RDY))
228 goto CPUCheckFirmwareReady_Fail;
229 else
230 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Firmware ready!\n");
231
232 return rt_status;
233
234 CPUCheckFirmwareReady_Fail:
235 RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
236 rt_status = false;
237 return rt_status;
238
239 }
240
241 bool init_firmware(struct net_device *dev)
242 {
243 struct r8192_priv *priv = ieee80211_priv(dev);
244 bool rt_status = TRUE;
245
246 #ifdef RTL8190P
247 u8 *firmware_img_buf[3] = { &rtl8190_fwboot_array[0],
248 &rtl8190_fwmain_array[0],
249 &rtl8190_fwdata_array[0]};
250
251 u32 firmware_img_len[3] = { sizeof(rtl8190_fwboot_array),
252 sizeof(rtl8190_fwmain_array),
253 sizeof(rtl8190_fwdata_array)};
254 #else
255 u8 *firmware_img_buf[3] = { &rtl8192e_fwboot_array[0],
256 &rtl8192e_fwmain_array[0],
257 &rtl8192e_fwdata_array[0]};
258
259 u32 firmware_img_len[3] = { sizeof(rtl8192e_fwboot_array),
260 sizeof(rtl8192e_fwmain_array),
261 sizeof(rtl8192e_fwdata_array)};
262 #endif
263 u32 file_length = 0;
264 u8 *mapped_file = NULL;
265 u32 init_step = 0;
266 opt_rst_type_e rst_opt = OPT_SYSTEM_RESET;
267 firmware_init_step_e starting_state = FW_INIT_STEP0_BOOT;
268
269 rt_firmware *pfirmware = priv->pFirmware;
270 const struct firmware *fw_entry;
271 #ifdef RTL8190P
272 const char *fw_name[3] = { "RTL8190P/boot.img",
273 "RTL8190P/main.img",
274 "RTL8190P/data.img"};
275 #endif
276 #ifdef RTL8192E
277 const char *fw_name[3] = { "RTL8192E/boot.img",
278 "RTL8192E/main.img",
279 "RTL8192E/data.img"};
280 #endif
281 int rc;
282
283 RT_TRACE(COMP_FIRMWARE, " PlatformInitFirmware()==>\n");
284
285 if (pfirmware->firmware_status == FW_STATUS_0_INIT ) {
286 /* it is called by reset */
287 rst_opt = OPT_SYSTEM_RESET;
288 starting_state = FW_INIT_STEP0_BOOT;
289 // TODO: system reset
290
291 }else if(pfirmware->firmware_status == FW_STATUS_5_READY) {
292 /* it is called by Initialize */
293 rst_opt = OPT_FIRMWARE_RESET;
294 starting_state = FW_INIT_STEP2_DATA;
295 }else {
296 RT_TRACE(COMP_FIRMWARE, "PlatformInitFirmware: undefined firmware state\n");
297 }
298
299 /*
300 * Download boot, main, and data image for System reset.
301 * Download data image for firmware reseta
302 */
303 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
304 priv->firmware_source = FW_SOURCE_HEADER_FILE;
305 #else
306 priv->firmware_source = FW_SOURCE_IMG_FILE;
307 #endif
308 for(init_step = starting_state; init_step <= FW_INIT_STEP2_DATA; init_step++) {
309 /*
310 * Open Image file, and map file to contineous memory if open file success.
311 * or read image file from array. Default load from IMG file
312 */
313 if(rst_opt == OPT_SYSTEM_RESET) {
314 switch(priv->firmware_source) {
315 case FW_SOURCE_IMG_FILE:
316 {
317 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
318 if(pfirmware->firmware_buf_size[init_step] == 0) {
319 rc = request_firmware(&fw_entry, fw_name[init_step],&priv->pdev->dev);
320 if(rc < 0 ) {
321 RT_TRACE(COMP_FIRMWARE, "request firmware fail!\n");
322 goto download_firmware_fail;
323 }
324
325 if(fw_entry->size > sizeof(pfirmware->firmware_buf[init_step])) {
326 RT_TRACE(COMP_FIRMWARE, "img file size exceed the container buffer fail!\n");
327 goto download_firmware_fail;
328 }
329
330 if(init_step != FW_INIT_STEP1_MAIN) {
331 memcpy(pfirmware->firmware_buf[init_step],fw_entry->data,fw_entry->size);
332 pfirmware->firmware_buf_size[init_step] = fw_entry->size;
333
334 } else {
335 #ifdef RTL8190P
336 memcpy(pfirmware->firmware_buf[init_step],fw_entry->data,fw_entry->size);
337 pfirmware->firmware_buf_size[init_step] = fw_entry->size;
338
339 #else
340 memset(pfirmware->firmware_buf[init_step],0,128);
341 memcpy(&pfirmware->firmware_buf[init_step][128],fw_entry->data,fw_entry->size);
342 //mapped_file = pfirmware->firmware_buf[init_step];
343 pfirmware->firmware_buf_size[init_step] = fw_entry->size+128;
344 //file_length = fw_entry->size + 128;
345 #endif
346 }
347 //pfirmware->firmware_buf_size = file_length;
348
349 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
350 if(rst_opt == OPT_SYSTEM_RESET) {
351 release_firmware(fw_entry);
352 }
353 #endif
354 }
355 mapped_file = pfirmware->firmware_buf[init_step];
356 file_length = pfirmware->firmware_buf_size[init_step];
357 #endif
358 break;
359 }
360 case FW_SOURCE_HEADER_FILE:
361 mapped_file = firmware_img_buf[init_step];
362 file_length = firmware_img_len[init_step];
363 if(init_step == FW_INIT_STEP2_DATA) {
364 memcpy(pfirmware->firmware_buf[init_step], mapped_file, file_length);
365 pfirmware->firmware_buf_size[init_step] = file_length;
366 }
367 break;
368
369 default:
370 break;
371 }
372
373
374 }else if(rst_opt == OPT_FIRMWARE_RESET ) {
375 /* we only need to download data.img here */
376 mapped_file = pfirmware->firmware_buf[init_step];
377 file_length = pfirmware->firmware_buf_size[init_step];
378 }
379
380 /* Download image file */
381 /* The firmware download process is just as following,
382 * 1. that is each packet will be segmented and inserted to the wait queue.
383 * 2. each packet segment will be put in the skb_buff packet.
384 * 3. each skb_buff packet data content will already include the firmware info
385 * and Tx descriptor info
386 * */
387 rt_status = fw_download_code(dev,mapped_file,file_length);
388 if(rt_status != TRUE) {
389 goto download_firmware_fail;
390 }
391
392 switch(init_step) {
393 case FW_INIT_STEP0_BOOT:
394 /* Download boot
395 * initialize command descriptor.
396 * will set polling bit when firmware code is also configured
397 */
398 pfirmware->firmware_status = FW_STATUS_1_MOVE_BOOT_CODE;
399 #ifdef RTL8190P
400 // To initialize IMEM, CPU move code from 0x80000080, hence, we send 0x80 byte packet
401 rt_status = fwSendNullPacket(dev, RTL8190_CPU_START_OFFSET);
402 if(rt_status != true)
403 {
404 RT_TRACE(COMP_INIT, "fwSendNullPacket() fail ! \n");
405 goto download_firmware_fail;
406 }
407 #endif
408 //mdelay(1000);
409 /*
410 * To initialize IMEM, CPU move code from 0x80000080,
411 * hence, we send 0x80 byte packet
412 */
413 break;
414
415 case FW_INIT_STEP1_MAIN:
416 /* Download firmware code. Wait until Boot Ready and Turn on CPU */
417 pfirmware->firmware_status = FW_STATUS_2_MOVE_MAIN_CODE;
418
419 /* Check Put Code OK and Turn On CPU */
420 rt_status = CPUcheck_maincodeok_turnonCPU(dev);
421 if(rt_status != TRUE) {
422 RT_TRACE(COMP_FIRMWARE, "CPUcheck_maincodeok_turnonCPU fail!\n");
423 goto download_firmware_fail;
424 }
425
426 pfirmware->firmware_status = FW_STATUS_3_TURNON_CPU;
427 break;
428
429 case FW_INIT_STEP2_DATA:
430 /* download initial data code */
431 pfirmware->firmware_status = FW_STATUS_4_MOVE_DATA_CODE;
432 mdelay(1);
433
434 rt_status = CPUcheck_firmware_ready(dev);
435 if(rt_status != TRUE) {
436 RT_TRACE(COMP_FIRMWARE, "CPUcheck_firmware_ready fail(%d)!\n",rt_status);
437 goto download_firmware_fail;
438 }
439
440 /* wait until data code is initialized ready.*/
441 pfirmware->firmware_status = FW_STATUS_5_READY;
442 break;
443 }
444 }
445
446 RT_TRACE(COMP_FIRMWARE, "Firmware Download Success\n");
447 //assert(pfirmware->firmware_status == FW_STATUS_5_READY, ("Firmware Download Fail\n"));
448
449 return rt_status;
450
451 download_firmware_fail:
452 RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
453 rt_status = FALSE;
454 return rt_status;
455
456 }
457
458 #if 0
459 /*
460 * Procedure: (1) Transform firmware code from little endian to big endian if required.
461 * (2) Number of bytes in Firmware downloading should be multiple
462 * of 4 bytes. If length is not multiple of 4 bytes, appending of zeros is required
463 *
464 */
465 void CmdAppendZeroAndEndianTransform(
466 u1Byte *pDst,
467 u1Byte *pSrc,
468 u2Byte *pLength)
469 {
470
471 u2Byte ulAppendBytes = 0, i;
472 u2Byte ulLength = *pLength;
473
474 //test only
475 //memset(pDst, 0xcc, 12);
476
477
478 /* Transform from little endian to big endian */
479 //#if DEV_BUS_TYPE==PCI_INTERFACE
480 #if 0
481 for( i=0 ; i<(*pLength) ; i+=4)
482 {
483 if((i+3) < (*pLength)) pDst[i+0] = pSrc[i+3];
484 if((i+2) < (*pLength)) pDst[i+1] = pSrc[i+2];
485 if((i+1) < (*pLength)) pDst[i+2] = pSrc[i+1];
486 if((i+0) < (*pLength)) pDst[i+3] = pSrc[i+0];
487 }
488 #else
489 pDst += USB_HWDESC_HEADER_LEN;
490 ulLength -= USB_HWDESC_HEADER_LEN;
491
492 for( i=0 ; i<ulLength ; i+=4) {
493 if((i+3) < ulLength) pDst[i+0] = pSrc[i+3];
494 if((i+2) < ulLength) pDst[i+1] = pSrc[i+2];
495 if((i+1) < ulLength) pDst[i+2] = pSrc[i+1];
496 if((i+0) < ulLength) pDst[i+3] = pSrc[i+0];
497
498 }
499 #endif
500
501 //1(2) Append Zero
502 if( ((*pLength) % 4) >0)
503 {
504 ulAppendBytes = 4-((*pLength) % 4);
505
506 for(i=0 ; i<ulAppendBytes; i++)
507 pDst[ 4*((*pLength)/4) + i ] = 0x0;
508
509 *pLength += ulAppendBytes;
510 }
511 }
512 #endif
513
514 #if 0
515 RT_STATUS
516 CmdSendPacket(
517 PADAPTER Adapter,
518 PRT_TCB pTcb,
519 PRT_TX_LOCAL_BUFFER pBuf,
520 u4Byte BufferLen,
521 u4Byte PacketType,
522 BOOLEAN bLastInitPacket
523 )
524 {
525 s2Byte i;
526 u1Byte QueueID;
527 u2Byte firstDesc,curDesc = 0;
528 u2Byte FragIndex=0, FragBufferIndex=0;
529
530 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
531
532 CmdInitTCB(Adapter, pTcb, pBuf, BufferLen);
533
534
535 if(CmdCheckFragment(Adapter, pTcb, pBuf))
536 CmdFragmentTCB(Adapter, pTcb);
537 else
538 pTcb->FragLength[0] = (u2Byte)pTcb->BufferList[0].Length;
539
540 QueueID=pTcb->SpecifiedQueueID;
541 #if DEV_BUS_TYPE!=USB_INTERFACE
542 firstDesc=curDesc=Adapter->NextTxDescToFill[QueueID];
543 #endif
544
545 #if DEV_BUS_TYPE!=USB_INTERFACE
546 if(VacancyTxDescNum(Adapter, QueueID) > pTcb->BufferCount)
547 #else
548 if(PlatformIsTxQueueAvailable(Adapter, QueueID, pTcb->BufferCount) &&
549 RTIsListEmpty(&Adapter->TcbWaitQueue[QueueID]))
550 #endif
551 {
552 pTcb->nDescUsed=0;
553
554 for(i=0 ; i<pTcb->BufferCount ; i++)
555 {
556 Adapter->HalFunc.TxFillCmdDescHandler(
557 Adapter,
558 pTcb,
559 QueueID, //QueueIndex
560 curDesc, //index
561 FragBufferIndex==0, //bFirstSeg
562 FragBufferIndex==(pTcb->FragBufCount[FragIndex]-1), //bLastSeg
563 pTcb->BufferList[i].VirtualAddress, //VirtualAddress
564 pTcb->BufferList[i].PhysicalAddressLow, //PhyAddressLow
565 pTcb->BufferList[i].Length, //BufferLen
566 i!=0, //bSetOwnBit
567 (i==(pTcb->BufferCount-1)) && bLastInitPacket, //bLastInitPacket
568 PacketType, //DescPacketType
569 pTcb->FragLength[FragIndex] //PktLen
570 );
571
572 if(FragBufferIndex==(pTcb->FragBufCount[FragIndex]-1))
573 { // Last segment of the fragment.
574 pTcb->nFragSent++;
575 }
576
577 FragBufferIndex++;
578 if(FragBufferIndex==pTcb->FragBufCount[FragIndex])
579 {
580 FragIndex++;
581 FragBufferIndex=0;
582 }
583
584 #if DEV_BUS_TYPE!=USB_INTERFACE
585 curDesc=(curDesc+1)%Adapter->NumTxDesc[QueueID];
586 #endif
587 pTcb->nDescUsed++;
588 }
589
590 #if DEV_BUS_TYPE!=USB_INTERFACE
591 RTInsertTailList(&Adapter->TcbBusyQueue[QueueID], &pTcb->List);
592 IncrementTxDescToFill(Adapter, QueueID, pTcb->nDescUsed);
593 Adapter->HalFunc.SetTxDescOWNHandler(Adapter, QueueID, firstDesc);
594 // TODO: should call poll use QueueID
595 Adapter->HalFunc.TxPollingHandler(Adapter, TXCMD_QUEUE);
596 #endif
597 }
598 else
599 #if DEV_BUS_TYPE!=USB_INTERFACE
600 goto CmdSendPacket_Fail;
601 #else
602 {
603 pTcb->bLastInitPacket = bLastInitPacket;
604 RTInsertTailList(&Adapter->TcbWaitQueue[pTcb->SpecifiedQueueID], &pTcb->List);
605 }
606 #endif
607
608 return rtStatus;
609
610 #if DEV_BUS_TYPE!=USB_INTERFACE
611 CmdSendPacket_Fail:
612 rtStatus = RT_STATUS_FAILURE;
613 return rtStatus;
614 #endif
615
616 }
617 #endif
618
619
620
621
622 #if 0
623 RT_STATUS
624 FWSendNullPacket(
625 IN PADAPTER Adapter,
626 IN u4Byte Length
627 )
628 {
629 RT_STATUS rtStatus = RT_STATUS_SUCCESS;
630
631
632 PRT_TCB pTcb;
633 PRT_TX_LOCAL_BUFFER pBuf;
634 BOOLEAN bLastInitPacket = FALSE;
635
636 PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
637
638 #if DEV_BUS_TYPE==USB_INTERFACE
639 Length += USB_HWDESC_HEADER_LEN;
640 #endif
641
642 //Get TCB and local buffer from common pool. (It is shared by CmdQ, MgntQ, and USB coalesce DataQ)
643 if(MgntGetBuffer(Adapter, &pTcb, &pBuf))
644 {
645 PlatformZeroMemory(pBuf->Buffer.VirtualAddress, Length);
646 rtStatus = CmdSendPacket(Adapter, pTcb, pBuf, Length, DESC_PACKET_TYPE_INIT, bLastInitPacket); //0 : always set LastInitPacket to zero
647 //#if HAL_CODE_BASE != RTL8190HW
648 // // TODO: for test only
649 // ReturnTCB(Adapter, pTcb, RT_STATUS_SUCCESS);
650 //#endif
651 if(rtStatus == RT_STATUS_FAILURE)
652 goto CmdSendNullPacket_Fail;
653 }else
654 goto CmdSendNullPacket_Fail;
655
656 PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
657 return rtStatus;
658
659
660 CmdSendNullPacket_Fail:
661 PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
662 rtStatus = RT_STATUS_FAILURE;
663 RT_ASSERT(rtStatus == RT_STATUS_SUCCESS, ("CmdSendDownloadCode fail !!\n"));
664 return rtStatus;
665 }
666 #endif
667
668
Linux kernel - Deliverables
This page took 0.04536 seconds and 5 git commands to generate.