| /****************************************************************************** |
| * rtl8712_xmit.c |
| * |
| * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. |
| * Linux device driver for RTL8192SU |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms of version 2 of the GNU General Public License as |
| * published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| * You should have received a copy of the GNU General Public License along with |
| * this program; if not, write to the Free Software Foundation, Inc., |
| * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA |
| * |
| * Modifications for inclusion into the Linux staging tree are |
| * Copyright(c) 2010 Larry Finger. All rights reserved. |
| * |
| * Contact information: |
| * WLAN FAE <wlanfae@realtek.com> |
| * Larry Finger <Larry.Finger@lwfinger.net> |
| * |
| ******************************************************************************/ |
| |
| #define _RTL8712_XMIT_C_ |
| |
| #include "osdep_service.h" |
| #include "drv_types.h" |
| #include "rtl871x_byteorder.h" |
| #include "wifi.h" |
| #include "osdep_intf.h" |
| #include "usb_ops.h" |
| |
| static void dump_xframe(struct _adapter *padapter, |
| struct xmit_frame *pxmitframe); |
| |
| sint _r8712_init_hw_txqueue(struct hw_txqueue *phw_txqueue, u8 ac_tag) |
| { |
| phw_txqueue->ac_tag = ac_tag; |
| switch (ac_tag) { |
| case BE_QUEUE_INX: |
| phw_txqueue->ff_hwaddr = RTL8712_DMA_BEQ; |
| break; |
| case BK_QUEUE_INX: |
| phw_txqueue->ff_hwaddr = RTL8712_DMA_BKQ; |
| break; |
| case VI_QUEUE_INX: |
| phw_txqueue->ff_hwaddr = RTL8712_DMA_VIQ; |
| break; |
| case VO_QUEUE_INX: |
| phw_txqueue->ff_hwaddr = RTL8712_DMA_VOQ; |
| break; |
| case BMC_QUEUE_INX: |
| phw_txqueue->ff_hwaddr = RTL8712_DMA_BEQ; |
| break; |
| } |
| return _SUCCESS; |
| } |
| |
| int r8712_txframes_sta_ac_pending(struct _adapter *padapter, |
| struct pkt_attrib *pattrib) |
| { |
| struct sta_info *psta; |
| struct tx_servq *ptxservq; |
| int priority = pattrib->priority; |
| |
| psta = pattrib->psta; |
| switch (priority) { |
| case 1: |
| case 2: |
| ptxservq = &(psta->sta_xmitpriv.bk_q); |
| break; |
| case 4: |
| case 5: |
| ptxservq = &(psta->sta_xmitpriv.vi_q); |
| break; |
| case 6: |
| case 7: |
| ptxservq = &(psta->sta_xmitpriv.vo_q); |
| break; |
| case 0: |
| case 3: |
| default: |
| ptxservq = &(psta->sta_xmitpriv.be_q); |
| break; |
| } |
| return ptxservq->qcnt; |
| } |
| |
| static u32 get_ff_hwaddr(struct xmit_frame *pxmitframe) |
| { |
| u32 addr = 0; |
| struct pkt_attrib *pattrib = &pxmitframe->attrib; |
| struct _adapter *padapter = pxmitframe->padapter; |
| struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; |
| |
| if (pxmitframe->frame_tag == TXAGG_FRAMETAG) |
| addr = RTL8712_DMA_H2CCMD; |
| else if (pxmitframe->frame_tag == MGNT_FRAMETAG) |
| addr = RTL8712_DMA_MGTQ; |
| else if (pdvobj->nr_endpoint == 6) { |
| switch (pattrib->priority) { |
| case 0: |
| case 3: |
| addr = RTL8712_DMA_BEQ; |
| break; |
| case 1: |
| case 2: |
| addr = RTL8712_DMA_BKQ; |
| break; |
| case 4: |
| case 5: |
| addr = RTL8712_DMA_VIQ; |
| break; |
| case 6: |
| case 7: |
| addr = RTL8712_DMA_VOQ; |
| break; |
| case 0x10: |
| case 0x11: |
| case 0x12: |
| case 0x13: |
| addr = RTL8712_DMA_H2CCMD; |
| break; |
| default: |
| addr = RTL8712_DMA_BEQ; |
| break; |
| } |
| } else if (pdvobj->nr_endpoint == 4) { |
| switch (pattrib->qsel) { |
| case 0: |
| case 3: |
| case 1: |
| case 2: |
| addr = RTL8712_DMA_BEQ;/*RTL8712_EP_LO;*/ |
| break; |
| case 4: |
| case 5: |
| case 6: |
| case 7: |
| addr = RTL8712_DMA_VOQ;/*RTL8712_EP_HI;*/ |
| break; |
| case 0x10: |
| case 0x11: |
| case 0x12: |
| case 0x13: |
| addr = RTL8712_DMA_H2CCMD;; |
| break; |
| default: |
| addr = RTL8712_DMA_BEQ;/*RTL8712_EP_LO;*/ |
| break; |
| } |
| } |
| return addr; |
| } |
| |
| static struct xmit_frame *dequeue_one_xmitframe(struct xmit_priv *pxmitpriv, |
| struct hw_xmit *phwxmit, |
| struct tx_servq *ptxservq, |
| struct __queue *pframe_queue) |
| { |
| struct list_head *xmitframe_plist, *xmitframe_phead; |
| struct xmit_frame *pxmitframe = NULL; |
| |
| xmitframe_phead = get_list_head(pframe_queue); |
| xmitframe_plist = get_next(xmitframe_phead); |
| if ((end_of_queue_search(xmitframe_phead, xmitframe_plist)) == false) { |
| pxmitframe = LIST_CONTAINOR(xmitframe_plist, |
| struct xmit_frame, list); |
| list_delete(&pxmitframe->list); |
| ptxservq->qcnt--; |
| phwxmit->txcmdcnt++; |
| } |
| return pxmitframe; |
| } |
| |
| static struct xmit_frame *dequeue_xframe_ex(struct xmit_priv *pxmitpriv, |
| struct hw_xmit *phwxmit_i, sint entry) |
| { |
| unsigned long irqL0; |
| struct list_head *sta_plist, *sta_phead; |
| struct hw_xmit *phwxmit; |
| struct tx_servq *ptxservq = NULL; |
| struct __queue *pframe_queue = NULL; |
| struct xmit_frame *pxmitframe = NULL; |
| int i, inx[4]; |
| int j, tmp, acirp_cnt[4]; |
| |
| /*entry indx: 0->vo, 1->vi, 2->be, 3->bk.*/ |
| inx[0] = 0; acirp_cnt[0] = pxmitpriv->voq_cnt; |
| inx[1] = 1; acirp_cnt[1] = pxmitpriv->viq_cnt; |
| inx[2] = 2; acirp_cnt[2] = pxmitpriv->beq_cnt; |
| inx[3] = 3; acirp_cnt[3] = pxmitpriv->bkq_cnt; |
| for (i = 0; i < 4; i++) { |
| for (j = i + 1; j < 4; j++) { |
| if (acirp_cnt[j] < acirp_cnt[i]) { |
| tmp = acirp_cnt[i]; |
| acirp_cnt[i] = acirp_cnt[j]; |
| acirp_cnt[j] = tmp; |
| tmp = inx[i]; |
| inx[i] = inx[j]; |
| inx[j] = tmp; |
| } |
| } |
| } |
| spin_lock_irqsave(&pxmitpriv->lock, irqL0); |
| for (i = 0; i < entry; i++) { |
| phwxmit = phwxmit_i + inx[i]; |
| sta_phead = get_list_head(phwxmit->sta_queue); |
| sta_plist = get_next(sta_phead); |
| while ((end_of_queue_search(sta_phead, sta_plist)) == false) { |
| ptxservq = LIST_CONTAINOR(sta_plist, struct tx_servq, |
| tx_pending); |
| pframe_queue = &ptxservq->sta_pending; |
| pxmitframe = dequeue_one_xmitframe(pxmitpriv, phwxmit, |
| ptxservq, pframe_queue); |
| if (pxmitframe) { |
| phwxmit->accnt--; |
| goto exit_dequeue_xframe_ex; |
| } |
| sta_plist = get_next(sta_plist); |
| /*Remove sta node when there are no pending packets.*/ |
| if (_queue_empty(pframe_queue)) { |
| /*must be done after get_next and before break*/ |
| list_delete(&ptxservq->tx_pending); |
| } |
| } |
| } |
| exit_dequeue_xframe_ex: |
| spin_unlock_irqrestore(&pxmitpriv->lock, irqL0); |
| return pxmitframe; |
| } |
| |
| void r8712_do_queue_select(struct _adapter *padapter, |
| struct pkt_attrib *pattrib) |
| { |
| u8 qsel = 0; |
| struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; |
| |
| if (pdvobj->nr_endpoint == 6) |
| qsel = pattrib->priority; |
| else if (pdvobj->nr_endpoint == 4) |
| qsel = pattrib->priority; |
| pattrib->qsel = qsel; |
| } |
| |
| static void update_txdesc(struct xmit_frame *pxmitframe, uint *pmem, int sz) |
| { |
| uint qsel; |
| struct _adapter *padapter = pxmitframe->padapter; |
| struct mlme_priv *pmlmepriv = &padapter->mlmepriv; |
| struct qos_priv *pqospriv = &pmlmepriv->qospriv; |
| struct security_priv *psecuritypriv = &padapter->securitypriv; |
| struct pkt_attrib *pattrib = &pxmitframe->attrib; |
| struct tx_desc *ptxdesc = (struct tx_desc *)pmem; |
| struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv; |
| u8 blnSetTxDescOffset; |
| sint bmcst = IS_MCAST(pattrib->ra); |
| struct ht_priv *phtpriv = &pmlmepriv->htpriv; |
| struct tx_desc txdesc_mp; |
| |
| memcpy(&txdesc_mp, ptxdesc, sizeof(struct tx_desc)); |
| memset(ptxdesc, 0, sizeof(struct tx_desc)); |
| /* offset 0 */ |
| ptxdesc->txdw0 |= cpu_to_le32(sz&0x0000ffff); |
| if (pdvobj->ishighspeed) { |
| if (((sz + TXDESC_SIZE) % 512) == 0) |
| blnSetTxDescOffset = 1; |
| else |
| blnSetTxDescOffset = 0; |
| } else { |
| if (((sz + TXDESC_SIZE) % 64) == 0) |
| blnSetTxDescOffset = 1; |
| else |
| blnSetTxDescOffset = 0; |
| } |
| if (blnSetTxDescOffset) { |
| /* 32 bytes for TX Desc + 8 bytes pending */ |
| ptxdesc->txdw0 |= cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ + 8) << |
| OFFSET_SHT) & 0x00ff0000); |
| } else { |
| /* default = 32 bytes for TX Desc */ |
| ptxdesc->txdw0 |= cpu_to_le32(((TXDESC_SIZE+OFFSET_SZ) << |
| OFFSET_SHT) & 0x00ff0000); |
| } |
| ptxdesc->txdw0 |= cpu_to_le32(OWN | FSG | LSG); |
| if (pxmitframe->frame_tag == DATA_FRAMETAG) { |
| /* offset 4 */ |
| ptxdesc->txdw1 |= cpu_to_le32((pattrib->mac_id)&0x1f); |
| qsel = (uint)(pattrib->qsel & 0x0000001f); |
| ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00); |
| if (!pqospriv->qos_option) |
| ptxdesc->txdw1 |= cpu_to_le32(BIT(16));/*Non-QoS*/ |
| if ((pattrib->encrypt > 0) && !pattrib->bswenc) { |
| switch (pattrib->encrypt) { /*SEC_TYPE*/ |
| case _WEP40_: |
| case _WEP104_: |
| ptxdesc->txdw1 |= cpu_to_le32((0x01 << 22) & |
| 0x00c00000); |
| /*KEY_ID when WEP is used;*/ |
| ptxdesc->txdw1 |= cpu_to_le32((psecuritypriv-> |
| PrivacyKeyIndex << 17) & |
| 0x00060000); |
| break; |
| case _TKIP_: |
| case _TKIP_WTMIC_: |
| ptxdesc->txdw1 |= cpu_to_le32((0x02 << 22) & |
| 0x00c00000); |
| break; |
| case _AES_: |
| ptxdesc->txdw1 |= cpu_to_le32((0x03 << 22) & |
| 0x00c00000); |
| break; |
| case _NO_PRIVACY_: |
| default: |
| break; |
| } |
| } |
| /*offset 8*/ |
| if (bmcst) |
| ptxdesc->txdw2 |= cpu_to_le32(BMC); |
| |
| /*offset 12*/ |
| /* f/w will increase the seqnum by itself, driver pass the |
| * correct priority to fw |
| * fw will check the correct priority for increasing the |
| * seqnum per tid. about usb using 4-endpoint, qsel points out |
| * the correct mapping between AC&Endpoint, |
| * the purpose is that correct mapping lets the MAC release |
| * the AC Queue list correctly. */ |
| ptxdesc->txdw3 = cpu_to_le32((pattrib->priority << SEQ_SHT) & |
| 0x0fff0000); |
| if ((pattrib->ether_type != 0x888e) && |
| (pattrib->ether_type != 0x0806) && |
| (pattrib->dhcp_pkt != 1)) { |
| /*Not EAP & ARP type data packet*/ |
| if (phtpriv->ht_option == 1) { /*B/G/N Mode*/ |
| if (phtpriv->ampdu_enable != true) |
| ptxdesc->txdw2 |= cpu_to_le32(BK); |
| } |
| } else { |
| /* EAP data packet and ARP packet. |
| * Use the 1M data rate to send the EAP/ARP packet. |
| * This will maybe make the handshake smooth. |
| */ |
| /*driver uses data rate*/ |
| ptxdesc->txdw4 = cpu_to_le32(0x80000000); |
| ptxdesc->txdw5 = cpu_to_le32(0x001f8000);/*1M*/ |
| } |
| if (pattrib->pctrl == 1) { /* mp tx packets */ |
| struct tx_desc *ptxdesc_mp; |
| ptxdesc_mp = &txdesc_mp; |
| /* offset 8 */ |
| ptxdesc->txdw2 = cpu_to_le32(ptxdesc_mp->txdw2); |
| if (bmcst) |
| ptxdesc->txdw2 |= cpu_to_le32(BMC); |
| ptxdesc->txdw2 |= cpu_to_le32(BK); |
| /* offset 16 */ |
| ptxdesc->txdw4 = cpu_to_le32(ptxdesc_mp->txdw4); |
| /* offset 20 */ |
| ptxdesc->txdw5 = cpu_to_le32(ptxdesc_mp->txdw5); |
| pattrib->pctrl = 0;/* reset to zero; */ |
| } |
| } else if (pxmitframe->frame_tag == MGNT_FRAMETAG) { |
| /* offset 4 */ |
| ptxdesc->txdw1 |= (0x05) & 0x1f;/*CAM_ID(MAC_ID), default=5;*/ |
| qsel = (uint)(pattrib->qsel & 0x0000001f); |
| ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00); |
| ptxdesc->txdw1 |= cpu_to_le32(BIT(16));/* Non-QoS */ |
| /* offset 8 */ |
| if (bmcst) |
| ptxdesc->txdw2 |= cpu_to_le32(BMC); |
| /* offset 12 */ |
| /* f/w will increase the seqnum by itself, driver pass the |
| * correct priority to fw |
| * fw will check the correct priority for increasing the seqnum |
| * per tid. about usb using 4-endpoint, qsel points out the |
| * correct mapping between AC&Endpoint, |
| * the purpose is that correct mapping let the MAC releases |
| * the AC Queue list correctly. */ |
| ptxdesc->txdw3 = cpu_to_le32((pattrib->priority << SEQ_SHT) & |
| 0x0fff0000); |
| /* offset 16 */ |
| ptxdesc->txdw4 = cpu_to_le32(0x80002040);/*gtest*/ |
| /* offset 20 */ |
| ptxdesc->txdw5 = cpu_to_le32(0x001f8000);/* gtest 1M */ |
| } else if (pxmitframe->frame_tag == TXAGG_FRAMETAG) { |
| /* offset 4 */ |
| qsel = 0x13; |
| ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00); |
| } else { |
| /* offset 4 */ |
| qsel = (uint)(pattrib->priority&0x0000001f); |
| ptxdesc->txdw1 |= cpu_to_le32((qsel << QSEL_SHT) & 0x00001f00); |
| /*offset 8*/ |
| /*offset 12*/ |
| ptxdesc->txdw3 = cpu_to_le32((pattrib->seqnum << SEQ_SHT) & |
| 0x0fff0000); |
| /*offset 16*/ |
| ptxdesc->txdw4 = cpu_to_le32(0x80002040);/*gtest*/ |
| /*offset 20*/ |
| ptxdesc->txdw5 = cpu_to_le32(0x001f9600);/*gtest*/ |
| } |
| } |
| |
| int r8712_xmitframe_complete(struct _adapter *padapter, |
| struct xmit_priv *pxmitpriv, |
| struct xmit_buf *pxmitbuf) |
| { |
| struct hw_xmit *phwxmits; |
| sint hwentry; |
| struct xmit_frame *pxmitframe = NULL; |
| int res = _SUCCESS, xcnt = 0; |
| |
| phwxmits = pxmitpriv->hwxmits; |
| hwentry = pxmitpriv->hwxmit_entry; |
| if (pxmitbuf == NULL) { |
| pxmitbuf = r8712_alloc_xmitbuf(pxmitpriv); |
| if (!pxmitbuf) |
| return false; |
| } |
| do { |
| pxmitframe = dequeue_xframe_ex(pxmitpriv, phwxmits, hwentry); |
| if (pxmitframe) { |
| pxmitframe->pxmitbuf = pxmitbuf; |
| pxmitframe->pxmit_urb[0] = pxmitbuf->pxmit_urb[0]; |
| pxmitframe->buf_addr = pxmitbuf->pbuf; |
| if (pxmitframe->frame_tag == DATA_FRAMETAG) { |
| if (pxmitframe->attrib.priority <= 15) |
| res = r8712_xmitframe_coalesce(padapter, |
| pxmitframe->pkt, pxmitframe); |
| /* always return ndis_packet after |
| * r8712_xmitframe_coalesce */ |
| r8712_xmit_complete(padapter, pxmitframe); |
| } |
| if (res == _SUCCESS) |
| dump_xframe(padapter, pxmitframe); |
| else |
| r8712_free_xmitframe_ex(pxmitpriv, pxmitframe); |
| xcnt++; |
| } else { |
| r8712_free_xmitbuf(pxmitpriv, pxmitbuf); |
| return false; |
| } |
| break; |
| } while (0); |
| return true; |
| } |
| |
| static void dump_xframe(struct _adapter *padapter, |
| struct xmit_frame *pxmitframe) |
| { |
| int t, sz, w_sz; |
| u8 *mem_addr; |
| u32 ff_hwaddr; |
| struct pkt_attrib *pattrib = &pxmitframe->attrib; |
| struct xmit_priv *pxmitpriv = &padapter->xmitpriv; |
| struct security_priv *psecuritypriv = &padapter->securitypriv; |
| |
| if (pxmitframe->attrib.ether_type != 0x0806) { |
| if (pxmitframe->attrib.ether_type != 0x888e) |
| r8712_issue_addbareq_cmd(padapter, pattrib->priority); |
| } |
| mem_addr = pxmitframe->buf_addr; |
| for (t = 0; t < pattrib->nr_frags; t++) { |
| if (t != (pattrib->nr_frags - 1)) { |
| sz = pxmitpriv->frag_len; |
| sz = sz - 4 - (psecuritypriv->sw_encrypt ? 0 : |
| pattrib->icv_len); |
| pxmitframe->last[t] = 0; |
| } else { |
| sz = pattrib->last_txcmdsz; |
| pxmitframe->last[t] = 1; |
| } |
| update_txdesc(pxmitframe, (uint *)mem_addr, sz); |
| w_sz = sz + TXDESC_SIZE; |
| pxmitframe->mem_addr = mem_addr; |
| pxmitframe->bpending[t] = false; |
| ff_hwaddr = get_ff_hwaddr(pxmitframe); |
| r8712_write_port(padapter, ff_hwaddr, w_sz, |
| (unsigned char *)pxmitframe); |
| mem_addr += w_sz; |
| mem_addr = (u8 *)RND4(((addr_t)(mem_addr))); |
| } |
| } |
| |
| int r8712_xmit_direct(struct _adapter *padapter, struct xmit_frame *pxmitframe) |
| { |
| int res = _SUCCESS; |
| |
| res = r8712_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe); |
| pxmitframe->pkt = NULL; |
| if (res == _SUCCESS) |
| dump_xframe(padapter, pxmitframe); |
| return res; |
| } |
| |
| int r8712_xmit_enqueue(struct _adapter *padapter, struct xmit_frame *pxmitframe) |
| { |
| if (r8712_xmit_classifier(padapter, pxmitframe) == _FAIL) { |
| pxmitframe->pkt = NULL; |
| return _FAIL; |
| } |
| return _SUCCESS; |
| } |