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