1 /******************************************************************************
2 *
3 * Copyright(c) 2007 - 2017 Realtek Corporation.
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 *****************************************************************************/
15 #define _XMIT_OSDEP_C_
16
17 #include <drv_types.h>
18
19 #define DBG_DUMP_OS_QUEUE_CTL 0
20
rtw_remainder_len(struct pkt_file * pfile)21 uint rtw_remainder_len(struct pkt_file *pfile)
22 {
23 return pfile->buf_len - ((SIZE_PTR)(pfile->cur_addr) - (SIZE_PTR)(pfile->buf_start));
24 }
25
_rtw_open_pktfile(_pkt * pktptr,struct pkt_file * pfile)26 void _rtw_open_pktfile(_pkt *pktptr, struct pkt_file *pfile)
27 {
28
29 pfile->pkt = pktptr;
30 pfile->cur_addr = pfile->buf_start = pktptr->data;
31 pfile->pkt_len = pfile->buf_len = pktptr->len;
32
33 pfile->cur_buffer = pfile->buf_start ;
34
35 }
36
_rtw_pktfile_read(struct pkt_file * pfile,u8 * rmem,uint rlen)37 uint _rtw_pktfile_read(struct pkt_file *pfile, u8 *rmem, uint rlen)
38 {
39 uint len = 0;
40
41
42 len = rtw_remainder_len(pfile);
43 len = (rlen > len) ? len : rlen;
44
45 if (rmem)
46 skb_copy_bits(pfile->pkt, pfile->buf_len - pfile->pkt_len, rmem, len);
47
48 pfile->cur_addr += len;
49 pfile->pkt_len -= len;
50
51
52 return len;
53 }
54
rtw_endofpktfile(struct pkt_file * pfile)55 sint rtw_endofpktfile(struct pkt_file *pfile)
56 {
57
58 if (pfile->pkt_len == 0) {
59 return _TRUE;
60 }
61
62
63 return _FALSE;
64 }
65
rtw_set_tx_chksum_offload(_pkt * pkt,struct pkt_attrib * pattrib)66 void rtw_set_tx_chksum_offload(_pkt *pkt, struct pkt_attrib *pattrib)
67 {
68 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
69 struct sk_buff *skb = (struct sk_buff *)pkt;
70 struct iphdr *iph = NULL;
71 struct ipv6hdr *i6ph = NULL;
72 struct udphdr *uh = NULL;
73 struct tcphdr *th = NULL;
74 u8 protocol = 0xFF;
75
76 if (skb->protocol == htons(ETH_P_IP)) {
77 iph = (struct iphdr *)skb_network_header(skb);
78 protocol = iph->protocol;
79 } else if (skb->protocol == htons(ETH_P_IPV6)) {
80 i6ph = (struct ipv6hdr *)skb_network_header(skb);
81 protocol = i6ph->nexthdr;
82 } else
83 {}
84
85 /* HW unable to compute CSUM if header & payload was be encrypted by SW(cause TXDMA error) */
86 if (pattrib->bswenc == _TRUE) {
87 if (skb->ip_summed == CHECKSUM_PARTIAL)
88 skb_checksum_help(skb);
89 return;
90 }
91
92 /* For HW rule, clear ipv4_csum & UDP/TCP_csum if it is UDP/TCP packet */
93 switch (protocol) {
94 case IPPROTO_UDP:
95 uh = (struct udphdr *)skb_transport_header(skb);
96 uh->check = 0;
97 if (iph)
98 iph->check = 0;
99 pattrib->hw_csum = _TRUE;
100 break;
101 case IPPROTO_TCP:
102 th = (struct tcphdr *)skb_transport_header(skb);
103 th->check = 0;
104 if (iph)
105 iph->check = 0;
106 pattrib->hw_csum = _TRUE;
107 break;
108 default:
109 break;
110 }
111 #endif
112
113 }
114
rtw_os_xmit_resource_alloc(_adapter * padapter,struct xmit_buf * pxmitbuf,u32 alloc_sz,u8 flag)115 int rtw_os_xmit_resource_alloc(_adapter *padapter, struct xmit_buf *pxmitbuf, u32 alloc_sz, u8 flag)
116 {
117 if (alloc_sz > 0) {
118 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
119 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
120 struct usb_device *pusbd = pdvobjpriv->pusbdev;
121
122 pxmitbuf->pallocated_buf = rtw_usb_buffer_alloc(pusbd, (size_t)alloc_sz, &pxmitbuf->dma_transfer_addr);
123 pxmitbuf->pbuf = pxmitbuf->pallocated_buf;
124 if (pxmitbuf->pallocated_buf == NULL)
125 return _FAIL;
126 #else /* CONFIG_USE_USB_BUFFER_ALLOC_TX */
127
128 pxmitbuf->pallocated_buf = rtw_zmalloc(alloc_sz);
129 if (pxmitbuf->pallocated_buf == NULL)
130 return _FAIL;
131
132 pxmitbuf->pbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitbuf->pallocated_buf), XMITBUF_ALIGN_SZ);
133
134 #endif /* CONFIG_USE_USB_BUFFER_ALLOC_TX */
135 }
136
137 if (flag) {
138 #ifdef CONFIG_USB_HCI
139 int i;
140 for (i = 0; i < 8; i++) {
141 pxmitbuf->pxmit_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
142 if (pxmitbuf->pxmit_urb[i] == NULL) {
143 RTW_INFO("pxmitbuf->pxmit_urb[i]==NULL");
144 return _FAIL;
145 }
146 }
147 #endif
148 }
149
150 return _SUCCESS;
151 }
152
rtw_os_xmit_resource_free(_adapter * padapter,struct xmit_buf * pxmitbuf,u32 free_sz,u8 flag)153 void rtw_os_xmit_resource_free(_adapter *padapter, struct xmit_buf *pxmitbuf, u32 free_sz, u8 flag)
154 {
155 if (flag) {
156 #ifdef CONFIG_USB_HCI
157 int i;
158
159 for (i = 0; i < 8; i++) {
160 if (pxmitbuf->pxmit_urb[i]) {
161 /* usb_kill_urb(pxmitbuf->pxmit_urb[i]); */
162 usb_free_urb(pxmitbuf->pxmit_urb[i]);
163 }
164 }
165 #endif
166 }
167
168 if (free_sz > 0) {
169 #ifdef CONFIG_USE_USB_BUFFER_ALLOC_TX
170 struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
171 struct usb_device *pusbd = pdvobjpriv->pusbdev;
172
173 rtw_usb_buffer_free(pusbd, (size_t)free_sz, pxmitbuf->pallocated_buf, pxmitbuf->dma_transfer_addr);
174 pxmitbuf->pallocated_buf = NULL;
175 pxmitbuf->dma_transfer_addr = 0;
176 #else /* CONFIG_USE_USB_BUFFER_ALLOC_TX */
177 if (pxmitbuf->pallocated_buf)
178 rtw_mfree(pxmitbuf->pallocated_buf, free_sz);
179 #endif /* CONFIG_USE_USB_BUFFER_ALLOC_TX */
180 }
181 }
182
dump_os_queue(void * sel,_adapter * padapter)183 void dump_os_queue(void *sel, _adapter *padapter)
184 {
185 struct net_device *ndev = padapter->pnetdev;
186
187 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
188 int i;
189
190 for (i = 0; i < 4; i++) {
191 RTW_PRINT_SEL(sel, "os_queue[%d]:%s\n"
192 , i, __netif_subqueue_stopped(ndev, i) ? "stopped" : "waked");
193 }
194 #else
195 RTW_PRINT_SEL(sel, "os_queue:%s\n"
196 , netif_queue_stopped(ndev) ? "stopped" : "waked");
197 #endif
198 }
199
200 #define WMM_XMIT_THRESHOLD (NR_XMITFRAME*2/5)
201
rtw_os_need_wake_queue(_adapter * padapter,u16 os_qid)202 static inline bool rtw_os_need_wake_queue(_adapter *padapter, u16 os_qid)
203 {
204 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
205 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
206
207 if (padapter->registrypriv.wifi_spec) {
208 if (pxmitpriv->hwxmits[os_qid].accnt < WMM_XMIT_THRESHOLD)
209 return _TRUE;
210 #ifdef DBG_CONFIG_ERROR_DETECT
211 #ifdef DBG_CONFIG_ERROR_RESET
212 } else if (rtw_hal_sreset_inprogress(padapter) == _TRUE) {
213 return _FALSE;
214 #endif/* #ifdef DBG_CONFIG_ERROR_RESET */
215 #endif/* #ifdef DBG_CONFIG_ERROR_DETECT */
216 } else {
217 #ifdef CONFIG_MCC_MODE
218 if (MCC_EN(padapter)) {
219 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)
220 && MCC_STOP(padapter))
221 return _FALSE;
222 }
223 #endif /* CONFIG_MCC_MODE */
224 return _TRUE;
225 }
226 return _FALSE;
227 #else
228 #ifdef CONFIG_MCC_MODE
229 if (MCC_EN(padapter)) {
230 if (rtw_hal_check_mcc_status(padapter, MCC_STATUS_DOING_MCC)
231 && MCC_STOP(padapter))
232 return _FALSE;
233 }
234 #endif /* CONFIG_MCC_MODE */
235 return _TRUE;
236 #endif
237 }
238
rtw_os_need_stop_queue(_adapter * padapter,u16 os_qid)239 static inline bool rtw_os_need_stop_queue(_adapter *padapter, u16 os_qid)
240 {
241 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
242 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
243 if (padapter->registrypriv.wifi_spec) {
244 /* No free space for Tx, tx_worker is too slow */
245 if (pxmitpriv->hwxmits[os_qid].accnt > WMM_XMIT_THRESHOLD)
246 return _TRUE;
247 } else {
248 if (pxmitpriv->free_xmitframe_cnt <= 4)
249 return _TRUE;
250 }
251 #else
252 if (pxmitpriv->free_xmitframe_cnt <= 4)
253 return _TRUE;
254 #endif
255 return _FALSE;
256 }
257
rtw_os_pkt_complete(_adapter * padapter,_pkt * pkt)258 void rtw_os_pkt_complete(_adapter *padapter, _pkt *pkt)
259 {
260 rtw_skb_free(pkt);
261 }
262
rtw_os_xmit_complete(_adapter * padapter,struct xmit_frame * pxframe)263 void rtw_os_xmit_complete(_adapter *padapter, struct xmit_frame *pxframe)
264 {
265 if (pxframe->pkt)
266 rtw_os_pkt_complete(padapter, pxframe->pkt);
267
268 pxframe->pkt = NULL;
269 }
270
rtw_os_xmit_schedule(_adapter * padapter)271 void rtw_os_xmit_schedule(_adapter *padapter)
272 {
273 #if defined(CONFIG_SDIO_HCI) || defined(CONFIG_GSPI_HCI)
274 _adapter *pri_adapter;
275
276 if (!padapter)
277 return;
278 pri_adapter = GET_PRIMARY_ADAPTER(padapter);
279
280 if (_rtw_queue_empty(&padapter->xmitpriv.pending_xmitbuf_queue) == _FALSE)
281 _rtw_up_sema(&pri_adapter->xmitpriv.xmit_sema);
282
283
284 #else
285 _irqL irqL;
286 struct xmit_priv *pxmitpriv;
287
288 if (!padapter)
289 return;
290
291 pxmitpriv = &padapter->xmitpriv;
292
293 _enter_critical_bh(&pxmitpriv->lock, &irqL);
294
295 if (rtw_txframes_pending(padapter))
296 tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
297
298 _exit_critical_bh(&pxmitpriv->lock, &irqL);
299
300 #if defined(CONFIG_PCI_HCI) && defined(CONFIG_XMIT_THREAD_MODE)
301 if (_rtw_queue_empty(&padapter->xmitpriv.pending_xmitbuf_queue) == _FALSE)
302 _rtw_up_sema(&padapter->xmitpriv.xmit_sema);
303 #endif
304
305
306 #endif
307 }
308
rtw_os_check_wakup_queue(_adapter * adapter,u16 os_qid)309 void rtw_os_check_wakup_queue(_adapter *adapter, u16 os_qid)
310 {
311 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
312 if (rtw_os_need_wake_queue(adapter, os_qid)) {
313 if (DBG_DUMP_OS_QUEUE_CTL)
314 RTW_INFO(FUNC_ADPT_FMT": netif_wake_subqueue[%d]\n", FUNC_ADPT_ARG(adapter), os_qid);
315 netif_wake_subqueue(adapter->pnetdev, os_qid);
316 }
317 #else
318 if (rtw_os_need_wake_queue(adapter, 0)) {
319 if (DBG_DUMP_OS_QUEUE_CTL)
320 RTW_INFO(FUNC_ADPT_FMT": netif_wake_queue\n", FUNC_ADPT_ARG(adapter));
321 netif_wake_queue(adapter->pnetdev);
322 }
323 #endif
324 }
325
rtw_os_check_stop_queue(_adapter * adapter,u16 os_qid)326 bool rtw_os_check_stop_queue(_adapter *adapter, u16 os_qid)
327 {
328 bool busy = _FALSE;
329
330 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
331 if (rtw_os_need_stop_queue(adapter, os_qid)) {
332 if (DBG_DUMP_OS_QUEUE_CTL)
333 RTW_INFO(FUNC_ADPT_FMT": netif_stop_subqueue[%d]\n", FUNC_ADPT_ARG(adapter), os_qid);
334 netif_stop_subqueue(adapter->pnetdev, os_qid);
335 busy = _TRUE;
336 }
337 #else
338 if (rtw_os_need_stop_queue(adapter, 0)) {
339 if (DBG_DUMP_OS_QUEUE_CTL)
340 RTW_INFO(FUNC_ADPT_FMT": netif_stop_queue\n", FUNC_ADPT_ARG(adapter));
341 rtw_netif_stop_queue(adapter->pnetdev);
342 busy = _TRUE;
343 }
344 #endif
345 return busy;
346 }
347
rtw_os_wake_queue_at_free_stainfo(_adapter * padapter,int * qcnt_freed)348 void rtw_os_wake_queue_at_free_stainfo(_adapter *padapter, int *qcnt_freed)
349 {
350 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
351 int i;
352
353 for (i = 0; i < 4; i++) {
354 if (qcnt_freed[i] == 0)
355 continue;
356
357 if (rtw_os_need_wake_queue(padapter, i)) {
358 if (DBG_DUMP_OS_QUEUE_CTL)
359 RTW_INFO(FUNC_ADPT_FMT": netif_wake_subqueue[%d]\n", FUNC_ADPT_ARG(padapter), i);
360 netif_wake_subqueue(padapter->pnetdev, i);
361 }
362 }
363 #else
364 if (qcnt_freed[0] || qcnt_freed[1] || qcnt_freed[2] || qcnt_freed[3]) {
365 if (rtw_os_need_wake_queue(padapter, 0)) {
366 if (DBG_DUMP_OS_QUEUE_CTL)
367 RTW_INFO(FUNC_ADPT_FMT": netif_wake_queue\n", FUNC_ADPT_ARG(padapter));
368 netif_wake_queue(padapter->pnetdev);
369 }
370 }
371 #endif
372 }
373
_rtw_xmit_entry(_pkt * pkt,_nic_hdl pnetdev)374 int _rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev)
375 {
376 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
377 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
378 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
379 struct sk_buff *skb = pkt;
380 struct sk_buff *segs, *nskb;
381 netdev_features_t features = padapter->pnetdev->features;
382 #endif
383 u16 os_qid = 0;
384 s32 res = 0;
385
386 if (padapter->registrypriv.mp_mode) {
387 RTW_INFO("MP_TX_DROP_OS_FRAME\n");
388 goto drop_packet;
389 }
390 DBG_COUNTER(padapter->tx_logs.os_tx);
391
392 if ((rtw_if_up(padapter) == _FALSE)
393 #ifdef CONFIG_LAYER2_ROAMING
394 &&(!padapter->mlmepriv.roam_network)
395 #endif
396 ){
397 DBG_COUNTER(padapter->tx_logs.os_tx_err_up);
398 #ifdef DBG_TX_DROP_FRAME
399 RTW_INFO("DBG_TX_DROP_FRAME %s if_up fail\n", __FUNCTION__);
400 #endif
401 goto drop_packet;
402 }
403
404 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
405 os_qid = skb_get_queue_mapping(pkt);
406 #endif
407
408 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
409 if (skb_shinfo(skb)->gso_size) {
410 /* split a big(65k) skb into several small(1.5k) skbs */
411 features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
412 segs = skb_gso_segment(skb, features);
413 if (IS_ERR(segs) || !segs)
414 goto drop_packet;
415
416 do {
417 nskb = segs;
418 segs = segs->next;
419 nskb->next = NULL;
420 rtw_mstat_update( MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, nskb->truesize);
421 res = rtw_xmit(padapter, &nskb, os_qid);
422 if (res < 0) {
423 #ifdef DBG_TX_DROP_FRAME
424 RTW_INFO("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__);
425 #endif
426 pxmitpriv->tx_drop++;
427 rtw_os_pkt_complete(padapter, nskb);
428 }
429 } while (segs);
430 rtw_os_pkt_complete(padapter, skb);
431 goto exit;
432 }
433 #endif
434
435 res = rtw_xmit(padapter, &pkt, os_qid);
436 if (res < 0) {
437 #ifdef DBG_TX_DROP_FRAME
438 RTW_INFO("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__);
439 #endif
440 goto drop_packet;
441 }
442
443 goto exit;
444
445 drop_packet:
446 pxmitpriv->tx_drop++;
447 rtw_os_pkt_complete(padapter, pkt);
448
449 exit:
450
451
452 return 0;
453 }
454
455 #ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
check_alibaba_meshpkt(struct sk_buff * skb)456 int check_alibaba_meshpkt(struct sk_buff *skb)
457 {
458 u16 protocol;
459
460 if (skb)
461 return (htons(skb->protocol) == ETH_P_ALL);
462
463 return _FALSE;
464 }
465
rtw_alibaba_mesh_xmit_entry(_pkt * pkt,struct net_device * ndev)466 s32 rtw_alibaba_mesh_xmit_entry(_pkt *pkt, struct net_device *ndev)
467 {
468 u16 frame_ctl;
469
470 _adapter *padapter = (_adapter *)rtw_netdev_priv(ndev);
471 struct pkt_file pktfile;
472 struct rtw_ieee80211_hdr *pwlanhdr;
473 struct pkt_attrib *pattrib;
474 struct xmit_frame *pmgntframe;
475 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
476 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
477 unsigned char *pframe;
478 struct sk_buff *skb = (struct sk_buff *)pkt;
479 int len = skb->len;
480
481 rtw_mstat_update(MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, skb->truesize);
482
483 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
484 if (pmgntframe == NULL) {
485 goto fail;
486 return -1;
487 }
488
489 pattrib = &pmgntframe->attrib;
490 update_mgntframe_attrib(padapter, pattrib);
491 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
492 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
493 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
494
495 _rtw_open_pktfile(pkt, &pktfile);
496 _rtw_pktfile_read(&pktfile, pframe, len);
497
498 pattrib->type = pframe[0] & 0x0C;
499 pattrib->subtype = pframe[0] & 0xF0;
500 pattrib->raid = rtw_get_mgntframe_raid(padapter, WIRELESS_11G);
501 pattrib->rate = MGN_24M;
502 pattrib->pktlen = len;
503 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
504 pmlmeext->mgnt_seq++;
505
506 RTW_DBG_DUMP("rtw_alibaba_mesh_xmit_entry payload:", skb->data, len);
507
508 pattrib->last_txcmdsz = pattrib->pktlen;
509 dump_mgntframe(padapter, pmgntframe);
510
511 fail:
512 rtw_skb_free(skb);
513 return 0;
514 }
515 #endif
516
517 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32))
rtw_xmit_entry(_pkt * pkt,_nic_hdl pnetdev)518 netdev_tx_t rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev)
519 #else
520 int rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev)
521 #endif
522 {
523 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
524 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
525 int ret = 0;
526
527 if (pkt) {
528 #ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
529 if (check_alibaba_meshpkt(pkt)) {
530 ret = rtw_alibaba_mesh_xmit_entry(pkt, pnetdev);
531 goto out;
532 }
533 #endif
534 if (check_fwstate(pmlmepriv, WIFI_MONITOR_STATE) == _TRUE) {
535 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
536 rtw_monitor_xmit_entry((struct sk_buff *)pkt, pnetdev);
537 #endif
538 }
539 else {
540 rtw_mstat_update(MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, pkt->truesize);
541 ret = _rtw_xmit_entry(pkt, pnetdev);
542 }
543
544 }
545
546 #ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
547 out:
548 #endif
549 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32))
550 return (ret == 0) ? NETDEV_TX_OK : NETDEV_TX_BUSY;
551 #else
552 return ret;
553 #endif
554 }
555