hal/rtl8723au_recv.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _RTL8192CU_RECV_C_
  21 #include <drv_conf.h>
  22 #include <osdep_service.h>
  23 #include <drv_types.h>
  24 #include <recv_osdep.h>
  25 #include <mlme_osdep.h>
  26 #include <ip.h>
  27 #include <if_ether.h>
  28 #include <ethernet.h>
  29
  30 #include <usb_ops.h>
  31
  32
  33 #include <wifi.h>
  34 #include <circ_buf.h>
  35
  36 //#include <rtl8192c_hal.h>
  37 #include <rtl8723a_hal.h>
  38
  39 void rtl8192cu_init_recvbuf(_adapter *padapter, struct recv_buf *precvbuf)
  40 {
  41
  42         precvbuf->transfer_len = 0;
  43
  44         precvbuf->len = 0;
  45
  46         precvbuf->ref_cnt = 0;
  47
  48         if(precvbuf->pbuf)
  49         {
  50                 precvbuf->pdata = precvbuf->phead = precvbuf->ptail = precvbuf->pbuf;
  51                 precvbuf->pend = precvbuf->pdata + MAX_RECVBUF_SZ;
  52         }
  53
  54 }
  55
  56 int     rtl8192cu_init_recv_priv(_adapter *padapter)
  57 {
  58         struct recv_priv        *precvpriv = &padapter->recvpriv;
  59         int     i, res = _SUCCESS;
  60         struct recv_buf *precvbuf;
  61
  62 #ifdef CONFIG_RECV_THREAD_MODE
  63         sema_init(&precvpriv->recv_sema, 0);//will be removed
  64         sema_init(&precvpriv->terminate_recvthread_sema, 0);//will be removed
  65 #endif
  66
  67         tasklet_init(&precvpriv->recv_tasklet,
  68              (void(*)(unsigned long))rtl8192cu_recv_tasklet,
  69              (unsigned long)padapter);
  70
  71 #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
  72         precvpriv->int_in_urb = usb_alloc_urb(0, GFP_KERNEL);
  73         if(precvpriv->int_in_urb == NULL){
  74                 DBG_8723A("alloc_urb for interrupt in endpoint fail !!!!\n");
  75         }
  76         precvpriv->int_in_buf = kzalloc(USB_INTR_CONTENT_LENGTH, GFP_KERNEL);
  77         if(precvpriv->int_in_buf == NULL){
  78                 DBG_8723A("alloc_mem for interrupt in endpoint fail !!!!\n");
  79         }
  80 #endif
  81
  82         //init recv_buf
  83         _rtw_init_queue(&precvpriv->free_recv_buf_queue);
  84
  85 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_RX
  86         _rtw_init_queue(&precvpriv->recv_buf_pending_queue);
  87 #endif  // CONFIG_USE_USB_BUFFER_ALLOC_RX
  88
  89         precvpriv->pallocated_recv_buf = kzalloc(NR_RECVBUFF *sizeof(struct recv_buf) + 4, GFP_KERNEL);
  90         if(precvpriv->pallocated_recv_buf==NULL){
  91                 res= _FAIL;
  92                 RT_TRACE(_module_rtl871x_recv_c_,_drv_err_,("alloc recv_buf fail!\n"));
  93                 goto exit;
  94         }
  95
  96         precvpriv->precv_buf = PTR_ALIGN(precvpriv->pallocated_recv_buf, 4);
  97
  98         precvbuf = (struct recv_buf*)precvpriv->precv_buf;
  99
 100         for(i=0; i < NR_RECVBUFF ; i++)
 101         {
 102                 _rtw_init_listhead(&precvbuf->list);
 103
 104                 spin_lock_init(&precvbuf->recvbuf_lock);
 105
 106                 precvbuf->alloc_sz = MAX_RECVBUF_SZ;
 107
 108                 res = rtw_os_recvbuf_resource_alloc(padapter, precvbuf);
 109                 if(res==_FAIL)
 110                         break;
 111
 112                 precvbuf->ref_cnt = 0;
 113                 precvbuf->adapter =padapter;
 114
 115
 116                 //rtw_list_insert_tail(&precvbuf->list, &(precvpriv->free_recv_buf_queue.queue));
 117
 118                 precvbuf++;
 119
 120         }
 121
 122         precvpriv->free_recv_buf_queue_cnt = NR_RECVBUFF;
 123
 124         skb_queue_head_init(&precvpriv->rx_skb_queue);
 125
 126 #ifdef CONFIG_PREALLOC_RECV_SKB
 127         {
 128                 int i;
 129                 unsigned long tmpaddr = 0;
 130                 unsigned long alignment = 0;
 131                 struct sk_buff *pskb = NULL;
 132
 133                 skb_queue_head_init(&precvpriv->free_recv_skb_queue);
 134
 135                 for(i=0; i<NR_PREALLOC_RECV_SKB; i++)
 136                 {
 137
 138         #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)) // http://www.mail-archive.com/netdev@vger.kernel.org/msg17214.html
 139                         pskb = __dev_alloc_skb(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ, GFP_KERNEL);
 140         #else
 141                         pskb = __netdev_alloc_skb(padapter->pnetdev, MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ, GFP_KERNEL);
 142         #endif
 143
 144                         if(pskb)
 145                         {
 146                                 pskb->dev = padapter->pnetdev;
 147
 148                                 tmpaddr = (unsigned long)pskb->data;
 149                                 alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
 150                                 skb_reserve(pskb, (RECVBUFF_ALIGN_SZ - alignment));
 151
 152                                 skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
 153                         }
 154
 155                         pskb=NULL;
 156
 157                 }
 158         }
 159 #endif
 160
 161 exit:
 162
 163         return res;
 164
 165 }
 166
 167 void rtl8192cu_free_recv_priv (_adapter *padapter)
 168 {
 169         int     i;
 170         struct recv_buf *precvbuf;
 171         struct recv_priv        *precvpriv = &padapter->recvpriv;
 172
 173         precvbuf = (struct recv_buf *)precvpriv->precv_buf;
 174
 175         for(i=0; i < NR_RECVBUFF ; i++)
 176         {
 177                 rtw_os_recvbuf_resource_free(padapter, precvbuf);
 178                 precvbuf++;
 179         }
 180
 181         if(precvpriv->pallocated_recv_buf)
 182                 kfree(precvpriv->pallocated_recv_buf);
 183
 184 #ifdef CONFIG_USB_INTERRUPT_IN_PIPE
 185         if(precvpriv->int_in_urb)
 186         {
 187                 usb_free_urb(precvpriv->int_in_urb);
 188         }
 189         if(precvpriv->int_in_buf)
 190                 kfree(precvpriv->int_in_buf);
 191 #endif
 192
 193         if (skb_queue_len(&precvpriv->rx_skb_queue)) {
 194                 DBG_8723A(KERN_WARNING "rx_skb_queue not empty\n");
 195         }
 196
 197         skb_queue_purge(&precvpriv->rx_skb_queue);
 198
 199 #ifdef CONFIG_PREALLOC_RECV_SKB
 200
 201         if (skb_queue_len(&precvpriv->free_recv_skb_queue)) {
 202                 DBG_8723A(KERN_WARNING "free_recv_skb_queue not empty, %d\n", skb_queue_len(&precvpriv->free_recv_skb_queue));
 203         }
 204
 205         skb_queue_purge(&precvpriv->free_recv_skb_queue);
 206
 207 #endif
 208 }
 209
 210
 211 void update_recvframe_attrib(
 212         union recv_frame *precvframe,
 213         struct recv_stat *prxstat)
 214 {
 215         struct rx_pkt_attrib    *pattrib;
 216         struct recv_stat        report;
 217         PRXREPORT               prxreport;
 218
 219
 220         report.rxdw0 = le32_to_cpu(prxstat->rxdw0);
 221         report.rxdw1 = le32_to_cpu(prxstat->rxdw1);
 222         report.rxdw2 = le32_to_cpu(prxstat->rxdw2);
 223         report.rxdw3 = le32_to_cpu(prxstat->rxdw3);
 224         report.rxdw4 = le32_to_cpu(prxstat->rxdw4);
 225         report.rxdw5 = le32_to_cpu(prxstat->rxdw5);
 226
 227         prxreport = (PRXREPORT)&report;
 228
 229         pattrib = &precvframe->u.hdr.attrib;
 230         memset(pattrib, 0, sizeof(struct rx_pkt_attrib));
 231
 232         // update rx report to recv_frame attribute
 233         pattrib->pkt_len = (u16)prxreport->pktlen;
 234         pattrib->drvinfo_sz = (u8)(prxreport->drvinfosize << 3);
 235         pattrib->physt = (u8)prxreport->physt;
 236
 237         pattrib->crc_err = (u8)prxreport->crc32;
 238         pattrib->icv_err = (u8)prxreport->icverr;
 239
 240         pattrib->bdecrypted = (u8)(prxreport->swdec ? 0 : 1);
 241         pattrib->encrypt = (u8)prxreport->security;
 242
 243         pattrib->qos = (u8)prxreport->qos;
 244         pattrib->priority = (u8)prxreport->tid;
 245
 246         pattrib->amsdu = (u8)prxreport->amsdu;
 247
 248         pattrib->seq_num = (u16)prxreport->seq;
 249         pattrib->frag_num = (u8)prxreport->frag;
 250         pattrib->mfrag = (u8)prxreport->mf;
 251         pattrib->mdata = (u8)prxreport->md;
 252
 253         pattrib->mcs_rate = (u8)prxreport->rxmcs;
 254         pattrib->rxht = (u8)prxreport->rxht;
 255 }
 256
 257
 258
 259 /*
 260  * Notice:
 261  *      Before calling this function,
 262  *      precvframe->u.hdr.rx_data should be ready!
 263  */
 264 void update_recvframe_phyinfo(
 265         union recv_frame        *precvframe,
 266         struct phy_stat *pphy_status)
 267 {
 268         PADAPTER                        padapter = precvframe->u.hdr.adapter;
 269         struct rx_pkt_attrib    *pattrib = &precvframe->u.hdr.attrib;
 270         HAL_DATA_TYPE           *pHalData= GET_HAL_DATA(padapter);
 271         PODM_PHY_INFO_T         pPHYInfo  = (PODM_PHY_INFO_T)(&pattrib->phy_info);
 272         u8                                      *wlanhdr;
 273         ODM_PACKET_INFO_T       pkt_info;
 274         u8 *sa;
 275         //_irqL         irqL;
 276         struct sta_priv *pstapriv;
 277         struct sta_info *psta;
 278
 279         pkt_info.bPacketMatchBSSID =_FALSE;
 280         pkt_info.bPacketToSelf = _FALSE;
 281         pkt_info.bPacketBeacon = _FALSE;
 282
 283         wlanhdr = get_recvframe_data(precvframe);
 284
 285         pkt_info.bPacketMatchBSSID = ((!IsFrameTypeCtrl(wlanhdr)) &&
 286                 !pattrib->icv_err && !pattrib->crc_err &&
 287                 !memcmp(get_hdr_bssid(wlanhdr), get_bssid(&padapter->mlmepriv), ETH_ALEN));
 288
 289         pkt_info.bPacketToSelf = pkt_info.bPacketMatchBSSID && (!memcmp(get_da(wlanhdr), myid(&padapter->eeprompriv), ETH_ALEN));
 290
 291         pkt_info.bPacketBeacon = pkt_info.bPacketMatchBSSID && (GetFrameSubType(wlanhdr) == WIFI_BEACON);
 292
 293         pkt_info.StationID = 0xFF;
 294         if(pkt_info.bPacketBeacon){
 295                 if(check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == _TRUE){
 296                         sa = padapter->mlmepriv.cur_network.network.MacAddress;
 297                         #if 0
 298                         {
 299                                 printk("==> rx beacon from AP[%02x:%02x:%02x:%02x:%02x:%02x]\n",
 300                                         sa[0],sa[1],sa[2],sa[3],sa[4],sa[5]);
 301                         }
 302                         #endif
 303                 }
 304                 //to do Ad-hoc
 305         }
 306         else{
 307                 sa = get_sa(wlanhdr);
 308         }
 309
 310         pstapriv = &padapter->stapriv;
 311         psta = rtw_get_stainfo(pstapriv, sa);
 312         if (psta)
 313         {
 314              pkt_info.StationID = psta->mac_id;
 315                 //printk("%s ==> StationID(%d)\n",__FUNCTION__,pkt_info.StationID);
 316         }
 317         pkt_info.Rate = pattrib->mcs_rate;
 318
 319         #ifdef CONFIG_CONCURRENT_MODE
 320         //get Primary adapter's odmpriv
 321         if(padapter->adapter_type > PRIMARY_ADAPTER){
 322                 pHalData = GET_HAL_DATA(padapter->pbuddy_adapter);
 323         }
 324         #endif
 325
 326         //rtl8192c_query_rx_phy_status(precvframe, pphy_status);
 327         //spin_lock_bh(&pHalData->odm_stainfo_lock);
 328          ODM_PhyStatusQuery(&pHalData->odmpriv,pPHYInfo,(u8 *)pphy_status,&(pkt_info));
 329         //spin_unlock_bh(&pHalData->odm_stainfo_lock);
 330         precvframe->u.hdr.psta = NULL;
 331         if (pkt_info.bPacketMatchBSSID &&
 332                 (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == _TRUE))
 333         {
 334                 if (psta)
 335                 {
 336                         precvframe->u.hdr.psta = psta;
 337                         rtl8192c_process_phy_info(padapter, precvframe);
 338                 }
 339         }
 340         else if (pkt_info.bPacketToSelf || pkt_info.bPacketBeacon)
 341         {
 342                 if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == _TRUE)
 343                 {
 344                         if (psta)
 345                         {
 346                                 precvframe->u.hdr.psta = psta;
 347                         }
 348                 }
 349
 350                 rtl8192c_process_phy_info(padapter, precvframe);
 351         }
 352 }