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 DBG_COUNTER(padapter->tx_logs.os_tx_err_up);
394 #ifdef DBG_TX_DROP_FRAME
395 RTW_INFO("DBG_TX_DROP_FRAME %s if_up fail\n", __FUNCTION__);
396 #endif
397 goto drop_packet;
398 }
399
400 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 35))
401 os_qid = skb_get_queue_mapping(pkt);
402 #endif
403
404 #ifdef CONFIG_TCP_CSUM_OFFLOAD_TX
405 if (skb_shinfo(skb)->gso_size) {
406 /* split a big(65k) skb into several small(1.5k) skbs */
407 features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
408 segs = skb_gso_segment(skb, features);
409 if (IS_ERR(segs) || !segs)
410 goto drop_packet;
411
412 do {
413 nskb = segs;
414 segs = segs->next;
415 nskb->next = NULL;
416 rtw_mstat_update( MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, nskb->truesize);
417 res = rtw_xmit(padapter, &nskb, os_qid);
418 if (res < 0) {
419 #ifdef DBG_TX_DROP_FRAME
420 RTW_INFO("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__);
421 #endif
422 pxmitpriv->tx_drop++;
423 rtw_os_pkt_complete(padapter, nskb);
424 }
425 } while (segs);
426 rtw_os_pkt_complete(padapter, skb);
427 goto exit;
428 }
429 #endif
430
431 res = rtw_xmit(padapter, &pkt, os_qid);
432 if (res < 0) {
433 #ifdef DBG_TX_DROP_FRAME
434 RTW_INFO("DBG_TX_DROP_FRAME %s rtw_xmit fail\n", __FUNCTION__);
435 #endif
436 goto drop_packet;
437 }
438
439 goto exit;
440
441 drop_packet:
442 pxmitpriv->tx_drop++;
443 rtw_os_pkt_complete(padapter, pkt);
444
445 exit:
446
447
448 return 0;
449 }
450
451 #ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
check_alibaba_meshpkt(struct sk_buff * skb)452 int check_alibaba_meshpkt(struct sk_buff *skb)
453 {
454 u16 protocol;
455
456 if (skb)
457 return (htons(skb->protocol) == ETH_P_ALL);
458
459 return _FALSE;
460 }
461
rtw_alibaba_mesh_xmit_entry(_pkt * pkt,struct net_device * ndev)462 s32 rtw_alibaba_mesh_xmit_entry(_pkt *pkt, struct net_device *ndev)
463 {
464 u16 frame_ctl;
465
466 _adapter *padapter = (_adapter *)rtw_netdev_priv(ndev);
467 struct pkt_file pktfile;
468 struct rtw_ieee80211_hdr *pwlanhdr;
469 struct pkt_attrib *pattrib;
470 struct xmit_frame *pmgntframe;
471 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
472 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
473 unsigned char *pframe;
474 struct sk_buff *skb = (struct sk_buff *)pkt;
475 int len = skb->len;
476
477 rtw_mstat_update(MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, skb->truesize);
478
479 pmgntframe = alloc_mgtxmitframe(pxmitpriv);
480 if (pmgntframe == NULL) {
481 goto fail;
482 return -1;
483 }
484
485 pattrib = &pmgntframe->attrib;
486 update_mgntframe_attrib(padapter, pattrib);
487 _rtw_memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
488 pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
489 pwlanhdr = (struct rtw_ieee80211_hdr *)pframe;
490
491 _rtw_open_pktfile(pkt, &pktfile);
492 _rtw_pktfile_read(&pktfile, pframe, len);
493
494 pattrib->type = pframe[0] & 0x0C;
495 pattrib->subtype = pframe[0] & 0xF0;
496 pattrib->raid = rtw_get_mgntframe_raid(padapter, WIRELESS_11G);
497 pattrib->rate = MGN_24M;
498 pattrib->pktlen = len;
499 SetSeqNum(pwlanhdr, pmlmeext->mgnt_seq);
500 pmlmeext->mgnt_seq++;
501
502 RTW_DBG_DUMP("rtw_alibaba_mesh_xmit_entry payload:", skb->data, len);
503
504 pattrib->last_txcmdsz = pattrib->pktlen;
505 dump_mgntframe(padapter, pmgntframe);
506
507 fail:
508 rtw_skb_free(skb);
509 return 0;
510 }
511 #endif
512
513 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32))
rtw_xmit_entry(_pkt * pkt,_nic_hdl pnetdev)514 netdev_tx_t rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev)
515 #else
516 int rtw_xmit_entry(_pkt *pkt, _nic_hdl pnetdev)
517 #endif
518 {
519 _adapter *padapter = (_adapter *)rtw_netdev_priv(pnetdev);
520 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
521 int ret = 0;
522
523 if (pkt) {
524 #ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
525 if (check_alibaba_meshpkt(pkt)) {
526 ret = rtw_alibaba_mesh_xmit_entry(pkt, pnetdev);
527 goto out;
528 }
529 #endif
530 if (check_fwstate(pmlmepriv, WIFI_MONITOR_STATE) == _TRUE) {
531 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 24))
532 rtw_monitor_xmit_entry((struct sk_buff *)pkt, pnetdev);
533 #endif
534 }
535 else {
536 rtw_mstat_update(MSTAT_TYPE_SKB, MSTAT_ALLOC_SUCCESS, pkt->truesize);
537 ret = _rtw_xmit_entry(pkt, pnetdev);
538 }
539
540 }
541
542 #ifdef CONFIG_CUSTOMER_ALIBABA_GENERAL
543 out:
544 #endif
545 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 32))
546 return (ret == 0) ? NETDEV_TX_OK : NETDEV_TX_BUSY;
547 #else
548 return ret;
549 #endif
550 }
551