?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / staging / rtl8712 / rtl8712_xmit.c
blob693331955d67ef4e58b0e2e61b8c12e79b4e6d6a
1 /******************************************************************************
2 * rtl8712_xmit.c
3 *
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
22 *
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
26 *
27 ******************************************************************************/
28
29 #define _RTL8712_XMIT_C_
30
31 #include "osdep_service.h"
32 #include "drv_types.h"
33 #include "rtl871x_byteorder.h"
34 #include "wifi.h"
35 #include "osdep_intf.h"
36 #include "usb_ops.h"
37
38 static void dump_xframe(struct _adapter *padapter,
39 struct xmit_frame *pxmitframe);
40 static void update_txdesc(struct xmit_frame *pxmitframe, uint *pmem, int sz);
41
42 sint _r8712_init_hw_txqueue(struct hw_txqueue *phw_txqueue, u8 ac_tag)
43 {
44 phw_txqueue->ac_tag = ac_tag;
45 switch (ac_tag) {
46 case BE_QUEUE_INX:
47 phw_txqueue->ff_hwaddr = RTL8712_DMA_BEQ;
48 break;
49 case BK_QUEUE_INX:
50 phw_txqueue->ff_hwaddr = RTL8712_DMA_BKQ;
51 break;
52 case VI_QUEUE_INX:
53 phw_txqueue->ff_hwaddr = RTL8712_DMA_VIQ;
54 break;
55 case VO_QUEUE_INX:
56 phw_txqueue->ff_hwaddr = RTL8712_DMA_VOQ;
57 break;
58 case BMC_QUEUE_INX:
59 phw_txqueue->ff_hwaddr = RTL8712_DMA_BEQ;
60 break;
61 }
62 return _SUCCESS;
63 }
64
65 int r8712_txframes_sta_ac_pending(struct _adapter *padapter,
66 struct pkt_attrib *pattrib)
67 {
68 struct sta_info *psta;
69 struct tx_servq *ptxservq;
70 int priority = pattrib->priority;
71
72 psta = pattrib->psta;
73 switch (priority) {
74 case 1:
75 case 2:
76 ptxservq = &(psta->sta_xmitpriv.bk_q);
77 break;
78 case 4:
79 case 5:
80 ptxservq = &(psta->sta_xmitpriv.vi_q);
81 break;
82 case 6:
83 case 7:
84 ptxservq = &(psta->sta_xmitpriv.vo_q);
85 break;
86 case 0:
87 case 3:
88 default:
89 ptxservq = &(psta->sta_xmitpriv.be_q);
90 break;
91 }
92 return ptxservq->qcnt;
93 }
94
95 static u32 get_ff_hwaddr(struct xmit_frame *pxmitframe)
96 {
97 u32 addr = 0;
98 struct pkt_attrib *pattrib = &pxmitframe->attrib;
99 struct _adapter *padapter = pxmitframe->padapter;
100 struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv;
101
102 if (pxmitframe->frame_tag == TXAGG_FRAMETAG)
103 addr = RTL8712_DMA_H2CCMD;
104 else if (pxmitframe->frame_tag == MGNT_FRAMETAG)
105 addr = RTL8712_DMA_MGTQ;
106 else if (pdvobj->nr_endpoint == 6) {
107 switch (pattrib->priority) {
108 case 0:
109 case 3:
110 addr = RTL8712_DMA_BEQ;
111 break;
112 case 1:
113 case 2:
114 addr = RTL8712_DMA_BKQ;
115 break;
116 case 4:
117 case 5:
118 addr = RTL8712_DMA_VIQ;
119 break;
120 case 6:
121 case 7:
122 addr = RTL8712_DMA_VOQ;
123 break;
124 case 0x10:
125 case 0x11:
126 case 0x12:
127 case 0x13:
128 addr = RTL8712_DMA_H2CCMD;
129 break;
130 default:
131 addr = RTL8712_DMA_BEQ;
132 break;
133 }
134 } else if (pdvobj->nr_endpoint == 4) {
135 switch (pattrib->qsel) {
136 case 0:
137 case 3:
138 case 1:
139 case 2:
140 addr = RTL8712_DMA_BEQ;/*RTL8712_EP_LO;*/
141 break;
142 case 4:
143 case 5:
144 case 6:
145 case 7:
146 addr = RTL8712_DMA_VOQ;/*RTL8712_EP_HI;*/
147 break;
148 case 0x10:
149 case 0x11:
150 case 0x12:
151 case 0x13:
152 addr = RTL8712_DMA_H2CCMD;
153 break;
154 default:
155 addr = RTL8712_DMA_BEQ;/*RTL8712_EP_LO;*/
156 break;
157 }
158 }
159 return addr;
160 }
161
162 static struct xmit_frame *dequeue_one_xmitframe(struct xmit_priv *pxmitpriv,
163 struct hw_xmit *phwxmit,
164 struct tx_servq *ptxservq,
165 struct __queue *pframe_queue)
166 {
167 struct list_head *xmitframe_plist, *xmitframe_phead;
168 struct xmit_frame *pxmitframe = NULL;
169
170 xmitframe_phead = get_list_head(pframe_queue);
171 xmitframe_plist = get_next(xmitframe_phead);
172 if ((end_of_queue_search(xmitframe_phead, xmitframe_plist)) == false) {
173 pxmitframe = LIST_CONTAINOR(xmitframe_plist,
174 struct xmit_frame, list);
175 list_delete(&pxmitframe->list);
176 ptxservq->qcnt--;
177 phwxmit->txcmdcnt++;
178 }
179 return pxmitframe;
180 }
181
182 static struct xmit_frame *dequeue_xframe_ex(struct xmit_priv *pxmitpriv,
183 struct hw_xmit *phwxmit_i, sint entry)
184 {
185 unsigned long irqL0;
186 struct list_head *sta_plist, *sta_phead;
187 struct hw_xmit *phwxmit;
188 struct tx_servq *ptxservq = NULL;
189 struct __queue *pframe_queue = NULL;
190 struct xmit_frame *pxmitframe = NULL;
191 int i, inx[4];
192 int j, tmp, acirp_cnt[4];
193
194 /*entry indx: 0->vo, 1->vi, 2->be, 3->bk.*/
195 inx[0] = 0; acirp_cnt[0] = pxmitpriv->voq_cnt;
196 inx[1] = 1; acirp_cnt[1] = pxmitpriv->viq_cnt;
197 inx[2] = 2; acirp_cnt[2] = pxmitpriv->beq_cnt;
198 inx[3] = 3; acirp_cnt[3] = pxmitpriv->bkq_cnt;
199 for (i = 0; i < 4; i++) {
200 for (j = i + 1; j < 4; j++) {
201 if (acirp_cnt[j] < acirp_cnt[i]) {
202 tmp = acirp_cnt[i];
203 acirp_cnt[i] = acirp_cnt[j];
204 acirp_cnt[j] = tmp;
205 tmp = inx[i];
206 inx[i] = inx[j];
207 inx[j] = tmp;
208 }
209 }
210 }
211 spin_lock_irqsave(&pxmitpriv->lock, irqL0);
212 for (i = 0; i < entry; i++) {
213 phwxmit = phwxmit_i + inx[i];
214 sta_phead = get_list_head(phwxmit->sta_queue);
215 sta_plist = get_next(sta_phead);
216 while ((end_of_queue_search(sta_phead, sta_plist)) == false) {
217 ptxservq = LIST_CONTAINOR(sta_plist, struct tx_servq,
218 tx_pending);
219 pframe_queue = &ptxservq->sta_pending;
220 pxmitframe = dequeue_one_xmitframe(pxmitpriv, phwxmit,
221 ptxservq, pframe_queue);
222 if (pxmitframe) {
223 phwxmit->accnt--;
224 goto exit_dequeue_xframe_ex;
225 }
226 sta_plist = get_next(sta_plist);
227 /*Remove sta node when there are no pending packets.*/
228 if (_queue_empty(pframe_queue)) {
229 /*must be done after get_next and before break*/
230 list_delete(&ptxservq->tx_pending);
231 }
232 }
233 }
234 exit_dequeue_xframe_ex:
235 spin_unlock_irqrestore(&pxmitpriv->lock, irqL0);
236 return pxmitframe;
237 }
238
239 void r8712_do_queue_select(struct _adapter *padapter,
240 struct pkt_attrib *pattrib)
241 {
242 unsigned int qsel = 0;
243 struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv;
244
245 if (pdvobj->nr_endpoint == 6)
246 qsel = (unsigned int) pattrib->priority;
247 else if (pdvobj->nr_endpoint == 4) {
248 qsel = (unsigned int) pattrib->priority;
249 if (qsel == 0 || qsel == 3)
250 qsel = 3;
251 else if (qsel == 1 || qsel == 2)
252 qsel = 1;
253 else if (qsel == 4 || qsel == 5)
254 qsel = 5;
255 else if (qsel == 6 || qsel == 7)
256 qsel = 7;
257 else
258 qsel = 3;
259 }
260 pattrib->qsel = qsel;
261 }
262
263 #ifdef CONFIG_R8712_TX_AGGR
264 u8 r8712_construct_txaggr_cmd_desc(struct xmit_buf *pxmitbuf)
265 {
266 struct tx_desc *ptx_desc = (struct tx_desc *)pxmitbuf->pbuf;
267
268 /* Fill up TxCmd Descriptor according as USB FW Tx Aaggregation info.*/
269 /* dw0 */
270 ptx_desc->txdw0 = cpu_to_le32(CMD_HDR_SZ&0xffff);
271 ptx_desc->txdw0 |=
272 cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ)<<OFFSET_SHT)&0x00ff0000);
273 ptx_desc->txdw0 |= cpu_to_le32(OWN | FSG | LSG);
274
275 /* dw1 */
276 ptx_desc->txdw1 |= cpu_to_le32((0x13<<QSEL_SHT)&0x00001f00);
277
278 return _SUCCESS;
279 }
280
281 u8 r8712_construct_txaggr_cmd_hdr(struct xmit_buf *pxmitbuf)
282 {
283 struct xmit_frame *pxmitframe = (struct xmit_frame *)
284 pxmitbuf->priv_data;
285 struct _adapter *padapter = pxmitframe->padapter;
286 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
287 struct cmd_hdr *pcmd_hdr = (struct cmd_hdr *)
288 (pxmitbuf->pbuf + TXDESC_SIZE);
289
290 /* Fill up Cmd Header for USB FW Tx Aggregation.*/
291 /* dw0 */
292 pcmd_hdr->cmd_dw0 = cpu_to_le32((GEN_CMD_CODE(_AMSDU_TO_AMPDU) << 16) |
293 (pcmdpriv->cmd_seq << 24));
294 pcmdpriv->cmd_seq++;
295
296 return _SUCCESS;
297 }
298
299 u8 r8712_append_mpdu_unit(struct xmit_buf *pxmitbuf,
300 struct xmit_frame *pxmitframe)
301 {
302 struct _adapter *padapter = pxmitframe->padapter;
303 struct tx_desc *ptx_desc = (struct tx_desc *)pxmitbuf->pbuf;
304 int last_txcmdsz = 0;
305 int padding_sz = 0;
306
307 /* 802.3->802.11 convertor */
308 r8712_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe);
309 /* free skb struct */
310 r8712_xmit_complete(padapter, pxmitframe);
311 if (pxmitframe->attrib.ether_type != 0x0806) {
312 if ((pxmitframe->attrib.ether_type != 0x888e) &&
313 (pxmitframe->attrib.dhcp_pkt != 1)) {
314 r8712_issue_addbareq_cmd(padapter,
315 pxmitframe->attrib.priority);
316 }
317 }
318 pxmitframe->last[0] = 1;
319 update_txdesc(pxmitframe, (uint *)(pxmitframe->buf_addr),
320 pxmitframe->attrib.last_txcmdsz);
321 /*padding zero */
322 last_txcmdsz = pxmitframe->attrib.last_txcmdsz;
323 padding_sz = (8 - (last_txcmdsz % 8));
324 if ((last_txcmdsz % 8) != 0) {
325 int i;
326 for (i = 0; i < padding_sz; i++)
327 *(pxmitframe->buf_addr+TXDESC_SIZE+last_txcmdsz+i) = 0;
328 }
329 /* Add the new mpdu's length */
330 ptx_desc->txdw0 = cpu_to_le32((ptx_desc->txdw0&0xffff0000) |
331 ((ptx_desc->txdw0&0x0000ffff)+
332 ((TXDESC_SIZE+last_txcmdsz+padding_sz)&0x0000ffff)));
333
334 return _SUCCESS;
335 }
336
337
338 u8 r8712_xmitframe_aggr_1st(struct xmit_buf *pxmitbuf,
339 struct xmit_frame *pxmitframe)
340 {
341 /* linux complete context doesnt need to protect */
342 pxmitframe->pxmitbuf = pxmitbuf;
343 pxmitbuf->priv_data = pxmitframe;
344 pxmitframe->pxmit_urb[0] = pxmitbuf->pxmit_urb[0];
345 /* buffer addr assoc */
346 pxmitframe->buf_addr = pxmitbuf->pbuf+TXDESC_SIZE+CMD_HDR_SZ;
347 /*RTL8712_DMA_H2CCMD */
348 r8712_construct_txaggr_cmd_desc(pxmitbuf);
349 r8712_construct_txaggr_cmd_hdr(pxmitbuf);
350 if (r8712_append_mpdu_unit(pxmitbuf, pxmitframe) == _SUCCESS)
351 pxmitbuf->aggr_nr = 1;
352
353 return _SUCCESS;
354 }
355
356 u16 r8712_xmitframe_aggr_next(struct xmit_buf *pxmitbuf,
357 struct xmit_frame *pxmitframe)
358 {
359 pxmitframe->pxmitbuf = pxmitbuf;
360 pxmitbuf->priv_data = pxmitframe;
361 pxmitframe->pxmit_urb[0] = pxmitbuf->pxmit_urb[0];
362 /* buffer addr assoc */
363 pxmitframe->buf_addr = pxmitbuf->pbuf + TXDESC_SIZE +
364 (((struct tx_desc *)pxmitbuf->pbuf)->txdw0 & 0x0000ffff);
365 if (r8712_append_mpdu_unit(pxmitbuf, pxmitframe) == _SUCCESS) {
366 r8712_free_xmitframe_ex(&pxmitframe->padapter->xmitpriv,
367 pxmitframe);
368 pxmitbuf->aggr_nr++;
369 }
370
371 return TXDESC_SIZE +
372 (((struct tx_desc *)pxmitbuf->pbuf)->txdw0 & 0x0000ffff);
373 }
374
375 u8 r8712_dump_aggr_xframe(struct xmit_buf *pxmitbuf,
376 struct xmit_frame *pxmitframe)
377 {
378 struct _adapter *padapter = pxmitframe->padapter;
379 struct dvobj_priv *pdvobj = (struct dvobj_priv *) &padapter->dvobjpriv;
380 struct tx_desc * ptxdesc = (struct tx_desc *)pxmitbuf->pbuf;
381 struct cmd_hdr *pcmd_hdr = (struct cmd_hdr *)
382 (pxmitbuf->pbuf + TXDESC_SIZE);
383 u16 total_length = (u16) (ptxdesc->txdw0 & 0xffff);
384
385 /* use 1st xmitframe as media */
386 xmitframe_xmitbuf_attach(pxmitframe, pxmitbuf);
387 pcmd_hdr->cmd_dw0 = cpu_to_le32(((total_length-CMD_HDR_SZ)&0x0000ffff)|
388 (pcmd_hdr->cmd_dw0&0xffff0000));
389
390 /* urb length in cmd_dw1 */
391 pcmd_hdr->cmd_dw1 = cpu_to_le32((pxmitbuf->aggr_nr & 0xff)|
392 ((total_length+TXDESC_SIZE) << 16));
393 pxmitframe->last[0] = 1;
394 pxmitframe->bpending[0] = false;
395 pxmitframe->mem_addr = pxmitbuf->pbuf;
396
397 if ((pdvobj->ishighspeed && ((total_length+TXDESC_SIZE)%0x200) == 0) ||
398 ((!pdvobj->ishighspeed &&
399 ((total_length+TXDESC_SIZE)%0x40) == 0))) {
400 ptxdesc->txdw0 |= cpu_to_le32
401 (((TXDESC_SIZE+OFFSET_SZ+8)<<OFFSET_SHT)&0x00ff0000);
402 /*32 bytes for TX Desc + 8 bytes pending*/
403 } else {
404 ptxdesc->txdw0 |= cpu_to_le32
405 (((TXDESC_SIZE+OFFSET_SZ)<<OFFSET_SHT)&0x00ff0000);
406 /*default = 32 bytes for TX Desc*/
407 }
408 r8712_write_port(pxmitframe->padapter, RTL8712_DMA_H2CCMD,
409 total_length+TXDESC_SIZE, (u8 *)pxmitframe);
410
411 return _SUCCESS;
412 }
413
414 #endif
415
416 static void update_txdesc(struct xmit_frame *pxmitframe, uint *pmem, int sz)
417 {
418 uint qsel;
419 struct _adapter *padapter = pxmitframe->padapter;
420 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
421 struct qos_priv *pqospriv = &pmlmepriv->qospriv;
422 struct security_priv *psecuritypriv = &padapter->securitypriv;
423 struct pkt_attrib *pattrib = &pxmitframe->attrib;
424 struct tx_desc *ptxdesc = (struct tx_desc *)pmem;
425 struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv;
426 #ifdef CONFIG_R8712_TX_AGGR
427 struct cmd_priv *pcmdpriv = (struct cmd_priv *)&padapter->cmdpriv;
428 #endif
429 u8 blnSetTxDescOffset;
430 sint bmcst = IS_MCAST(pattrib->ra);
431 struct ht_priv *phtpriv = &pmlmepriv->htpriv;
432 struct tx_desc txdesc_mp;
433
434 memcpy(&txdesc_mp, ptxdesc, sizeof(struct tx_desc));
435 memset(ptxdesc, 0, sizeof(struct tx_desc));
436 /* offset 0 */
437 ptxdesc->txdw0 |= cpu_to_le32(sz&0x0000ffff);
438 if (pdvobj->ishighspeed) {
439 if (((sz + TXDESC_SIZE) % 512) == 0)
440 blnSetTxDescOffset = 1;
441 else
442 blnSetTxDescOffset = 0;
443 } else {
444 if (((sz + TXDESC_SIZE) % 64) == 0)
445 blnSetTxDescOffset = 1;
446 else
447 blnSetTxDescOffset = 0;
448 }
449 if (blnSetTxDescOffset) {
450 /* 32 bytes for TX Desc + 8 bytes pending */
451 ptxdesc->txdw0 |= cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ + 8) <<
452 OFFSET_SHT) & 0x00ff0000);
453 } else {
454 /* default = 32 bytes for TX Desc */
455 ptxdesc->txdw0 |= cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ) <<
456 OFFSET_SHT) & 0x00ff0000);
457 }
458 ptxdesc->txdw0 |= cpu_to_le32(OWN | FSG | LSG);
459 if (pxmitframe->frame_tag == DATA_FRAMETAG) {
460 /* offset 4 */
461 ptxdesc->txdw1 |= cpu_to_le32((pattrib->mac_id)&0x1f);
462
463 #ifdef CONFIG_R8712_TX_AGGR
464 /* dirty workaround, need to check if it is aggr cmd. */
465 if ((u8 *)pmem != (u8 *)pxmitframe->pxmitbuf->pbuf) {
466 ptxdesc->txdw0 |= cpu_to_le32
467 ((0x3 << TYPE_SHT)&TYPE_MSK);
468 qsel = (uint)(pattrib->qsel & 0x0000001f);
469 if (qsel == 2)
470 qsel = 0;
471 ptxdesc->txdw1 |= cpu_to_le32
472 ((qsel << QSEL_SHT) & 0x00001f00);
473 ptxdesc->txdw2 = cpu_to_le32
474 ((qsel << RTS_RC_SHT)&0x001f0000);
475 ptxdesc->txdw6 |= cpu_to_le32
476 ((0x5 << RSVD6_SHT)&RSVD6_MSK);
477 } else {
478 ptxdesc->txdw0 |= cpu_to_le32
479 ((0x3 << TYPE_SHT)&TYPE_MSK);
480 ptxdesc->txdw1 |= cpu_to_le32
481 ((0x13 << QSEL_SHT) & 0x00001f00);
482 qsel = (uint)(pattrib->qsel & 0x0000001f);
483 if (qsel == 2)
484 qsel = 0;
485 ptxdesc->txdw2 = cpu_to_le32
486 ((qsel << RTS_RC_SHT)&0x0001f000);
487 ptxdesc->txdw7 |= cpu_to_le32
488 (pcmdpriv->cmd_seq << 24);
489 pcmdpriv->cmd_seq++;
490 }
491 pattrib->qsel = 0x13;
492 #else
493 qsel = (uint)(pattrib->qsel & 0x0000001f);
494 ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00);
495 #endif
496 if (!pqospriv->qos_option)
497 ptxdesc->txdw1 |= cpu_to_le32(BIT(16));/*Non-QoS*/
498 if ((pattrib->encrypt > 0) && !pattrib->bswenc) {
499 switch (pattrib->encrypt) { /*SEC_TYPE*/
500 case _WEP40_:
501 case _WEP104_:
502 ptxdesc->txdw1 |= cpu_to_le32((0x01 << 22) &
503 0x00c00000);
504 /*KEY_ID when WEP is used;*/
505 ptxdesc->txdw1 |= cpu_to_le32((psecuritypriv->
506 PrivacyKeyIndex << 17) &
507 0x00060000);
508 break;
509 case _TKIP_:
510 case _TKIP_WTMIC_:
511 ptxdesc->txdw1 |= cpu_to_le32((0x02 << 22) &
512 0x00c00000);
513 break;
514 case _AES_:
515 ptxdesc->txdw1 |= cpu_to_le32((0x03 << 22) &
516 0x00c00000);
517 break;
518 case _NO_PRIVACY_:
519 default:
520 break;
521 }
522 }
523 /*offset 8*/
524 if (bmcst)
525 ptxdesc->txdw2 |= cpu_to_le32(BMC);
526
527 /*offset 12*/
528 /* f/w will increase the seqnum by itself, driver pass the
529 * correct priority to fw
530 * fw will check the correct priority for increasing the
531 * seqnum per tid. about usb using 4-endpoint, qsel points out
532 * the correct mapping between AC&Endpoint,
533 * the purpose is that correct mapping lets the MAC release
534 * the AC Queue list correctly. */
535 ptxdesc->txdw3 = cpu_to_le32((pattrib->priority << SEQ_SHT) &
536 0x0fff0000);
537 if ((pattrib->ether_type != 0x888e) &&
538 (pattrib->ether_type != 0x0806) &&
539 (pattrib->dhcp_pkt != 1)) {
540 /*Not EAP & ARP type data packet*/
541 if (phtpriv->ht_option == 1) { /*B/G/N Mode*/
542 if (phtpriv->ampdu_enable != true)
543 ptxdesc->txdw2 |= cpu_to_le32(BK);
544 }
545 } else {
546 /* EAP data packet and ARP packet.
547 * Use the 1M data rate to send the EAP/ARP packet.
548 * This will maybe make the handshake smooth.
549 */
550 /*driver uses data rate*/
551 ptxdesc->txdw4 = cpu_to_le32(0x80000000);
552 ptxdesc->txdw5 = cpu_to_le32(0x001f8000);/*1M*/
553 }
554 if (pattrib->pctrl == 1) { /* mp tx packets */
555 struct tx_desc *ptxdesc_mp;
556 ptxdesc_mp = &txdesc_mp;
557 /* offset 8 */
558 ptxdesc->txdw2 = cpu_to_le32(ptxdesc_mp->txdw2);
559 if (bmcst)
560 ptxdesc->txdw2 |= cpu_to_le32(BMC);
561 ptxdesc->txdw2 |= cpu_to_le32(BK);
562 /* offset 16 */
563 ptxdesc->txdw4 = cpu_to_le32(ptxdesc_mp->txdw4);
564 /* offset 20 */
565 ptxdesc->txdw5 = cpu_to_le32(ptxdesc_mp->txdw5);
566 pattrib->pctrl = 0;/* reset to zero; */
567 }
568 } else if (pxmitframe->frame_tag == MGNT_FRAMETAG) {
569 /* offset 4 */
570 ptxdesc->txdw1 |= (0x05) & 0x1f;/*CAM_ID(MAC_ID), default=5;*/
571 qsel = (uint)(pattrib->qsel & 0x0000001f);
572 ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00);
573 ptxdesc->txdw1 |= cpu_to_le32(BIT(16));/* Non-QoS */
574 /* offset 8 */
575 if (bmcst)
576 ptxdesc->txdw2 |= cpu_to_le32(BMC);
577 /* offset 12 */
578 /* f/w will increase the seqnum by itself, driver pass the
579 * correct priority to fw
580 * fw will check the correct priority for increasing the seqnum
581 * per tid. about usb using 4-endpoint, qsel points out the
582 * correct mapping between AC&Endpoint,
583 * the purpose is that correct mapping let the MAC releases
584 * the AC Queue list correctly. */
585 ptxdesc->txdw3 = cpu_to_le32((pattrib->priority << SEQ_SHT) &
586 0x0fff0000);
587 /* offset 16 */
588 ptxdesc->txdw4 = cpu_to_le32(0x80002040);/*gtest*/
589 /* offset 20 */
590 ptxdesc->txdw5 = cpu_to_le32(0x001f8000);/* gtest 1M */
591 } else if (pxmitframe->frame_tag == TXAGG_FRAMETAG) {
592 /* offset 4 */
593 qsel = 0x13;
594 ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00);
595 } else {
596 /* offset 4 */
597 qsel = (uint)(pattrib->priority&0x0000001f);
598 ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00);
599 /*offset 8*/
600 /*offset 12*/
601 ptxdesc->txdw3 = cpu_to_le32((pattrib->seqnum << SEQ_SHT) &
602 0x0fff0000);
603 /*offset 16*/
604 ptxdesc->txdw4 = cpu_to_le32(0x80002040);/*gtest*/
605 /*offset 20*/
606 ptxdesc->txdw5 = cpu_to_le32(0x001f9600);/*gtest*/
607 }
608 }
609
610 int r8712_xmitframe_complete(struct _adapter *padapter,
611 struct xmit_priv *pxmitpriv,
612 struct xmit_buf *pxmitbuf)
613 {
614 struct hw_xmit *phwxmits;
615 sint hwentry;
616 struct xmit_frame *pxmitframe = NULL;
617 #ifdef CONFIG_R8712_TX_AGGR
618 struct xmit_frame *p2ndxmitframe = NULL;
619 #else
620 int res = _SUCCESS, xcnt = 0;
621 #endif
622
623 phwxmits = pxmitpriv->hwxmits;
624 hwentry = pxmitpriv->hwxmit_entry;
625 if (pxmitbuf == NULL) {
626 pxmitbuf = r8712_alloc_xmitbuf(pxmitpriv);
627 if (!pxmitbuf)
628 return false;
629 #ifdef CONFIG_R8712_TX_AGGR
630 pxmitbuf->aggr_nr = 0;
631 #endif
632 }
633 /* 1st frame dequeued */
634 pxmitframe = dequeue_xframe_ex(pxmitpriv, phwxmits, hwentry);
635 /* need to remember the 1st frame */
636 if (pxmitframe != NULL) {
637
638 #ifdef CONFIG_R8712_TX_AGGR
639 /* 1. dequeue 2nd frame
640 * 2. aggr if 2nd xframe is dequeued, else dump directly
641 */
642 if (AGGR_NR_HIGH_BOUND > 1)
643 p2ndxmitframe = dequeue_xframe_ex(pxmitpriv, phwxmits,
644 hwentry);
645 if (pxmitframe->frame_tag != DATA_FRAMETAG) {
646 r8712_free_xmitbuf(pxmitpriv, pxmitbuf);
647 return false;
648 }
649 if (p2ndxmitframe != NULL)
650 if (p2ndxmitframe->frame_tag != DATA_FRAMETAG) {
651 r8712_free_xmitbuf(pxmitpriv, pxmitbuf);
652 return false;
653 }
654 r8712_xmitframe_aggr_1st(pxmitbuf, pxmitframe);
655 if (p2ndxmitframe != NULL) {
656 u16 total_length;
657 total_length = r8712_xmitframe_aggr_next(
658 pxmitbuf, p2ndxmitframe);
659 do {
660 p2ndxmitframe = dequeue_xframe_ex(
661 pxmitpriv, phwxmits, hwentry);
662 if (p2ndxmitframe != NULL)
663 total_length =
664 r8712_xmitframe_aggr_next(
665 pxmitbuf,
666 p2ndxmitframe);
667 else
668 break;
669 } while (total_length <= 0x1800 &&
670 pxmitbuf->aggr_nr <= AGGR_NR_HIGH_BOUND);
671 }
672 if (pxmitbuf->aggr_nr > 0)
673 r8712_dump_aggr_xframe(pxmitbuf, pxmitframe);
674
675 #else
676
677 xmitframe_xmitbuf_attach(pxmitframe, pxmitbuf);
678 if (pxmitframe->frame_tag == DATA_FRAMETAG) {
679 if (pxmitframe->attrib.priority <= 15)
680 res = r8712_xmitframe_coalesce(padapter,
681 pxmitframe->pkt, pxmitframe);
682 /* always return ndis_packet after
683 * r8712_xmitframe_coalesce */
684 r8712_xmit_complete(padapter, pxmitframe);
685 }
686 if (res == _SUCCESS)
687 dump_xframe(padapter, pxmitframe);
688 else
689 r8712_free_xmitframe_ex(pxmitpriv, pxmitframe);
690 xcnt++;
691 #endif
692
693 } else { /* pxmitframe == NULL && p2ndxmitframe == NULL */
694 r8712_free_xmitbuf(pxmitpriv, pxmitbuf);
695 return false;
696 }
697 return true;
698 }
699
700 static void dump_xframe(struct _adapter *padapter,
701 struct xmit_frame *pxmitframe)
702 {
703 int t, sz, w_sz;
704 u8 *mem_addr;
705 u32 ff_hwaddr;
706 struct pkt_attrib *pattrib = &pxmitframe->attrib;
707 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
708 struct security_priv *psecuritypriv = &padapter->securitypriv;
709
710 if (pxmitframe->attrib.ether_type != 0x0806) {
711 if (pxmitframe->attrib.ether_type != 0x888e)
712 r8712_issue_addbareq_cmd(padapter, pattrib->priority);
713 }
714 mem_addr = pxmitframe->buf_addr;
715 for (t = 0; t < pattrib->nr_frags; t++) {
716 if (t != (pattrib->nr_frags - 1)) {
717 sz = pxmitpriv->frag_len;
718 sz = sz - 4 - (psecuritypriv->sw_encrypt ? 0 :
719 pattrib->icv_len);
720 pxmitframe->last[t] = 0;
721 } else {
722 sz = pattrib->last_txcmdsz;
723 pxmitframe->last[t] = 1;
724 }
725 update_txdesc(pxmitframe, (uint *)mem_addr, sz);
726 w_sz = sz + TXDESC_SIZE;
727 pxmitframe->mem_addr = mem_addr;
728 pxmitframe->bpending[t] = false;
729 ff_hwaddr = get_ff_hwaddr(pxmitframe);
730 #ifdef CONFIG_R8712_TX_AGGR
731 r8712_write_port(padapter, RTL8712_DMA_H2CCMD, w_sz,
732 (unsigned char *)pxmitframe);
733 #else
734 r8712_write_port(padapter, ff_hwaddr, w_sz,
735 (unsigned char *)pxmitframe);
736 #endif
737 mem_addr += w_sz;
738 mem_addr = (u8 *)RND4(((addr_t)(mem_addr)));
739 }
740 }
741
742 int r8712_xmit_direct(struct _adapter *padapter, struct xmit_frame *pxmitframe)
743 {
744 int res = _SUCCESS;
745
746 res = r8712_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe);
747 pxmitframe->pkt = NULL;
748 if (res == _SUCCESS)
749 dump_xframe(padapter, pxmitframe);
750 return res;
751 }
752
753 int r8712_xmit_enqueue(struct _adapter *padapter, struct xmit_frame *pxmitframe)
754 {
755 if (r8712_xmit_classifier(padapter, pxmitframe) == _FAIL) {
756 pxmitframe->pkt = NULL;
757 return _FAIL;
758 }
759 return _SUCCESS;
760 }
Linux Btrfs Development