1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include "r8192U.h"
25#include "r819xU_cmdpkt.h"
26
27
28#define CMPK_DEBOUNCE_CNT 1
29
30#define CMPK_PRINT(Address)\
31{\
32 unsigned char i;\
33 u32 temp[10];\
34 \
35 memcpy(temp, Address, 40);\
36 for (i = 0; i <40; i+=4)\
37 printk("\r\n %08x", temp[i]);\
38}\
39
40
41rt_status
42SendTxCommandPacket(
43 struct net_device *dev,
44 void* pData,
45 u32 DataLen
46 )
47{
48 rt_status rtStatus = RT_STATUS_SUCCESS;
49 struct r8192_priv *priv = ieee80211_priv(dev);
50 struct sk_buff *skb;
51 cb_desc *tcb_desc;
52 unsigned char *ptr_buf;
53
54
55
56
57
58 skb = dev_alloc_skb(USB_HWDESC_HEADER_LEN + DataLen + 4);
59 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
60 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
61 tcb_desc->queue_index = TXCMD_QUEUE;
62 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_NORMAL;
63 tcb_desc->bLastIniPkt = 0;
64 skb_reserve(skb, USB_HWDESC_HEADER_LEN);
65 ptr_buf = skb_put(skb, DataLen);
66 memcpy(ptr_buf,pData,DataLen);
67 tcb_desc->txbuf_size= (u16)DataLen;
68
69 if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
70 (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
71 (priv->ieee80211->queue_stop) ) {
72 RT_TRACE(COMP_FIRMWARE,"===================NULL packet==================================> tx full!\n");
73 skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
74 } else {
75 priv->ieee80211->softmac_hard_start_xmit(skb,dev);
76 }
77
78
79 return rtStatus;
80}
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102 extern rt_status cmpk_message_handle_tx(
103 struct net_device *dev,
104 u8* codevirtualaddress,
105 u32 packettype,
106 u32 buffer_len)
107{
108
109 bool rt_status = true;
110#ifdef RTL8192U
111 return rt_status;
112#else
113 struct r8192_priv *priv = ieee80211_priv(dev);
114 u16 frag_threshold;
115 u16 frag_length, frag_offset = 0;
116
117
118
119 rt_firmware *pfirmware = priv->pFirmware;
120 struct sk_buff *skb;
121 unsigned char *seg_ptr;
122 cb_desc *tcb_desc;
123 u8 bLastIniPkt;
124
125 firmware_init_param(dev);
126
127 frag_threshold = pfirmware->cmdpacket_frag_thresold;
128 do {
129 if((buffer_len - frag_offset) > frag_threshold) {
130 frag_length = frag_threshold ;
131 bLastIniPkt = 0;
132
133 } else {
134 frag_length = buffer_len - frag_offset;
135 bLastIniPkt = 1;
136
137 }
138
139
140
141
142 #ifdef RTL8192U
143 skb = dev_alloc_skb(USB_HWDESC_HEADER_LEN + frag_length + 4);
144 #else
145 skb = dev_alloc_skb(frag_length + 4);
146 #endif
147 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
148 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
149 tcb_desc->queue_index = TXCMD_QUEUE;
150 tcb_desc->bCmdOrInit = packettype;
151 tcb_desc->bLastIniPkt = bLastIniPkt;
152
153 #ifdef RTL8192U
154 skb_reserve(skb, USB_HWDESC_HEADER_LEN);
155 #endif
156
157 seg_ptr = skb_put(skb, buffer_len);
158
159
160
161
162 memcpy(seg_ptr,codevirtualaddress,buffer_len);
163 tcb_desc->txbuf_size= (u16)buffer_len;
164
165
166 if(!priv->ieee80211->check_nic_enough_desc(dev,tcb_desc->queue_index)||
167 (!skb_queue_empty(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index]))||\
168 (priv->ieee80211->queue_stop) ) {
169 RT_TRACE(COMP_FIRMWARE,"=====================================================> tx full!\n");
170 skb_queue_tail(&priv->ieee80211->skb_waitQ[tcb_desc->queue_index], skb);
171 } else {
172 priv->ieee80211->softmac_hard_start_xmit(skb,dev);
173 }
174
175 codevirtualaddress += frag_length;
176 frag_offset += frag_length;
177
178 }while(frag_offset < buffer_len);
179
180 return rt_status;
181
182
183#endif
184}
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203static void
204cmpk_count_txstatistic(
205 struct net_device *dev,
206 cmpk_txfb_t *pstx_fb)
207{
208 struct r8192_priv *priv = ieee80211_priv(dev);
209#ifdef ENABLE_PS
210 RT_RF_POWER_STATE rtState;
211
212 pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState));
213
214
215
216
217 if (rtState == eRfOff)
218 {
219 return;
220 }
221#endif
222
223#ifdef TODO
224 if(pAdapter->bInHctTest)
225 return;
226#endif
227
228
229
230 if (pstx_fb->tok)
231 {
232 priv->stats.txfeedbackok++;
233 priv->stats.txoktotal++;
234 priv->stats.txokbytestotal += pstx_fb->pkt_length;
235 priv->stats.txokinperiod++;
236
237
238 if (pstx_fb->pkt_type == PACKET_MULTICAST)
239 {
240 priv->stats.txmulticast++;
241 priv->stats.txbytesmulticast += pstx_fb->pkt_length;
242 }
243 else if (pstx_fb->pkt_type == PACKET_BROADCAST)
244 {
245 priv->stats.txbroadcast++;
246 priv->stats.txbytesbroadcast += pstx_fb->pkt_length;
247 }
248 else
249 {
250 priv->stats.txunicast++;
251 priv->stats.txbytesunicast += pstx_fb->pkt_length;
252 }
253 }
254 else
255 {
256 priv->stats.txfeedbackfail++;
257 priv->stats.txerrtotal++;
258 priv->stats.txerrbytestotal += pstx_fb->pkt_length;
259
260
261 if (pstx_fb->pkt_type == PACKET_MULTICAST)
262 {
263 priv->stats.txerrmulticast++;
264 }
265 else if (pstx_fb->pkt_type == PACKET_BROADCAST)
266 {
267 priv->stats.txerrbroadcast++;
268 }
269 else
270 {
271 priv->stats.txerrunicast++;
272 }
273 }
274
275 priv->stats.txretrycount += pstx_fb->retry_cnt;
276 priv->stats.txfeedbackretry += pstx_fb->retry_cnt;
277
278}
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303static void
304cmpk_handle_tx_feedback(
305 struct net_device *dev,
306 u8 * pmsg)
307{
308 struct r8192_priv *priv = ieee80211_priv(dev);
309 cmpk_txfb_t rx_tx_fb;
310
311 priv->stats.txfeedback++;
312
313
314
315
316
317
318
319
320
321
322 memcpy((u8*)&rx_tx_fb, pmsg, sizeof(cmpk_txfb_t));
323
324 cmpk_count_txstatistic(dev, &rx_tx_fb);
325
326
327
328
329
330
331}
332
333void
334cmdpkt_beacontimerinterrupt_819xusb(
335 struct net_device *dev
336)
337{
338 struct r8192_priv *priv = ieee80211_priv(dev);
339 u16 tx_rate;
340 {
341
342
343
344 if(priv->ieee80211->current_network.mode == IEEE_A ||
345 priv->ieee80211->current_network.mode == IEEE_N_5G ||
346 (priv->ieee80211->current_network.mode == IEEE_N_24G && (!priv->ieee80211->pHTInfo->bCurSuppCCK)))
347 {
348 tx_rate = 60;
349 DMESG("send beacon frame tx rate is 6Mbpm\n");
350 }
351 else
352 {
353 tx_rate =10;
354 DMESG("send beacon frame tx rate is 1Mbpm\n");
355 }
356
357 rtl819xusb_beacon_tx(dev,tx_rate);
358
359 }
360
361}
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386static void
387cmpk_handle_interrupt_status(
388 struct net_device *dev,
389 u8* pmsg)
390{
391 cmpk_intr_sta_t rx_intr_status;
392 struct r8192_priv *priv = ieee80211_priv(dev);
393
394 DMESG("---> cmpk_Handle_Interrupt_Status()\n");
395
396
397
398
399
400
401
402
403
404
405 rx_intr_status.length = pmsg[1];
406 if (rx_intr_status.length != (sizeof(cmpk_intr_sta_t) - 2))
407 {
408 DMESG("cmpk_Handle_Interrupt_Status: wrong length!\n");
409 return;
410 }
411
412
413
414 if( priv->ieee80211->iw_mode == IW_MODE_ADHOC)
415 {
416
417 rx_intr_status.interrupt_status = *((u32 *)(pmsg + 4));
418
419
420 DMESG("interrupt status = 0x%x\n", rx_intr_status.interrupt_status);
421
422 if (rx_intr_status.interrupt_status & ISR_TxBcnOk)
423 {
424 priv->ieee80211->bibsscoordinator = true;
425 priv->stats.txbeaconokint++;
426 }
427 else if (rx_intr_status.interrupt_status & ISR_TxBcnErr)
428 {
429 priv->ieee80211->bibsscoordinator = false;
430 priv->stats.txbeaconerr++;
431 }
432
433 if (rx_intr_status.interrupt_status & ISR_BcnTimerIntr)
434 {
435 cmdpkt_beacontimerinterrupt_819xusb(dev);
436 }
437
438 }
439
440
441
442
443 DMESG("<---- cmpk_handle_interrupt_status()\n");
444
445}
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467static void
468cmpk_handle_query_config_rx(
469 struct net_device *dev,
470 u8* pmsg)
471{
472 cmpk_query_cfg_t rx_query_cfg;
473
474
475
476
477
478
479
480
481
482
483 rx_query_cfg.cfg_action = (pmsg[4] & 0x80000000)>>31;
484 rx_query_cfg.cfg_type = (pmsg[4] & 0x60) >> 5;
485 rx_query_cfg.cfg_size = (pmsg[4] & 0x18) >> 3;
486 rx_query_cfg.cfg_page = (pmsg[6] & 0x0F) >> 0;
487 rx_query_cfg.cfg_offset = pmsg[7];
488 rx_query_cfg.value = (pmsg[8] << 24) | (pmsg[9] << 16) |
489 (pmsg[10] << 8) | (pmsg[11] << 0);
490 rx_query_cfg.mask = (pmsg[12] << 24) | (pmsg[13] << 16) |
491 (pmsg[14] << 8) | (pmsg[15] << 0);
492
493}
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513static void cmpk_count_tx_status( struct net_device *dev,
514 cmpk_tx_status_t *pstx_status)
515{
516 struct r8192_priv *priv = ieee80211_priv(dev);
517
518#ifdef ENABLE_PS
519
520 RT_RF_POWER_STATE rtstate;
521
522 pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState));
523
524
525
526
527 if (rtState == eRfOff)
528 {
529 return;
530 }
531#endif
532
533 priv->stats.txfeedbackok += pstx_status->txok;
534 priv->stats.txoktotal += pstx_status->txok;
535
536 priv->stats.txfeedbackfail += pstx_status->txfail;
537 priv->stats.txerrtotal += pstx_status->txfail;
538
539 priv->stats.txretrycount += pstx_status->txretry;
540 priv->stats.txfeedbackretry += pstx_status->txretry;
541
542
543
544
545
546 priv->stats.txmulticast += pstx_status->txmcok;
547 priv->stats.txbroadcast += pstx_status->txbcok;
548 priv->stats.txunicast += pstx_status->txucok;
549
550 priv->stats.txerrmulticast += pstx_status->txmcfail;
551 priv->stats.txerrbroadcast += pstx_status->txbcfail;
552 priv->stats.txerrunicast += pstx_status->txucfail;
553
554 priv->stats.txbytesmulticast += pstx_status->txmclength;
555 priv->stats.txbytesbroadcast += pstx_status->txbclength;
556 priv->stats.txbytesunicast += pstx_status->txuclength;
557
558 priv->stats.last_packet_rate = pstx_status->rate;
559}
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580static void
581cmpk_handle_tx_status(
582 struct net_device *dev,
583 u8* pmsg)
584{
585 cmpk_tx_status_t rx_tx_sts;
586
587 memcpy((void*)&rx_tx_sts, (void*)pmsg, sizeof(cmpk_tx_status_t));
588
589 cmpk_count_tx_status(dev, &rx_tx_sts);
590
591}
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610static void
611cmpk_handle_tx_rate_history(
612 struct net_device *dev,
613 u8* pmsg)
614{
615 cmpk_tx_rahis_t *ptxrate;
616
617 u8 i, j;
618 u16 length = sizeof(cmpk_tx_rahis_t);
619 u32 *ptemp;
620 struct r8192_priv *priv = ieee80211_priv(dev);
621
622
623#ifdef ENABLE_PS
624 pAdapter->HalFunc.GetHwRegHandler(pAdapter, HW_VAR_RF_STATE, (pu1Byte)(&rtState));
625
626
627
628
629 if (rtState == eRfOff)
630 {
631 return;
632 }
633#endif
634
635 ptemp = (u32 *)pmsg;
636
637
638
639
640
641 for (i = 0; i < (length/4); i++)
642 {
643 u16 temp1, temp2;
644
645 temp1 = ptemp[i]&0x0000FFFF;
646 temp2 = ptemp[i]>>16;
647 ptemp[i] = (temp1<<16)|temp2;
648 }
649
650 ptxrate = (cmpk_tx_rahis_t *)pmsg;
651
652 if (ptxrate == NULL )
653 {
654 return;
655 }
656
657 for (i = 0; i < 16; i++)
658 {
659
660 if (i < 4)
661 priv->stats.txrate.cck[i] += ptxrate->cck[i];
662
663
664 if (i< 8)
665 priv->stats.txrate.ofdm[i] += ptxrate->ofdm[i];
666
667 for (j = 0; j < 4; j++)
668 priv->stats.txrate.ht_mcs[j][i] += ptxrate->ht_mcs[j][i];
669 }
670
671}
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694extern u32
695cmpk_message_handle_rx(
696 struct net_device *dev,
697 struct ieee80211_rx_stats *pstats)
698{
699
700 struct r8192_priv *priv = ieee80211_priv(dev);
701 int total_length;
702 u8 cmd_length, exe_cnt = 0;
703 u8 element_id;
704 u8 *pcmd_buff;
705
706
707
708 if ((pstats== NULL))
709 {
710
711
712
713 return 0;
714 }
715
716
717 total_length = pstats->Length;
718
719
720 pcmd_buff = pstats->virtual_address;
721
722
723 element_id = pcmd_buff[0];
724
725
726
727
728
729
730
731 while (total_length > 0 || exe_cnt++ >100)
732 {
733
734 element_id = pcmd_buff[0];
735
736 switch(element_id)
737 {
738 case RX_TX_FEEDBACK:
739 cmpk_handle_tx_feedback (dev, pcmd_buff);
740 cmd_length = CMPK_RX_TX_FB_SIZE;
741 break;
742
743 case RX_INTERRUPT_STATUS:
744 cmpk_handle_interrupt_status(dev, pcmd_buff);
745 cmd_length = sizeof(cmpk_intr_sta_t);
746 break;
747
748 case BOTH_QUERY_CONFIG:
749 cmpk_handle_query_config_rx(dev, pcmd_buff);
750 cmd_length = CMPK_BOTH_QUERY_CONFIG_SIZE;
751 break;
752
753 case RX_TX_STATUS:
754 cmpk_handle_tx_status(dev, pcmd_buff);
755 cmd_length = CMPK_RX_TX_STS_SIZE;
756 break;
757
758 case RX_TX_PER_PKT_FEEDBACK:
759
760
761
762 cmd_length = CMPK_RX_TX_FB_SIZE;
763 break;
764
765 case RX_TX_RATE_HISTORY:
766
767 cmpk_handle_tx_rate_history(dev, pcmd_buff);
768 cmd_length = CMPK_TX_RAHIS_SIZE;
769 break;
770
771 default:
772
773 RT_TRACE(COMP_ERR, "---->cmpk_message_handle_rx():unknow CMD Element\n");
774 return 1;
775 }
776
777
778
779
780
781
782
783 priv->stats.rxcmdpkt[element_id]++;
784
785 total_length -= cmd_length;
786 pcmd_buff += cmd_length;
787 }
788 return 1;
789
790}
791