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