1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
6 ******************************************************************************/
7 #define _USB_OPS_LINUX_C_
10 #include <recv_osdep.h>
11 #include <rtw_sreset.h>
13 #define RTW_USB_CONTROL_MSG_TIMEOUT 500 /* ms */
15 #define MAX_USBCTRL_VENDORREQ_TIMES 10
17 #define ALIGNMENT_UNIT 16
18 #define MAX_VENDOR_REQ_CMD_SIZE 254
19 #define MAX_USB_IO_CTL_SIZE (MAX_VENDOR_REQ_CMD_SIZE + ALIGNMENT_UNIT)
21 #define REALTEK_USB_VENQT_READ (USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
22 #define REALTEK_USB_VENQT_WRITE (USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE)
24 #define REALTEK_USB_VENQT_CMD_REQ 0x05
25 #define REALTEK_USB_VENQT_CMD_IDX 0x00
27 static void interrupt_handler_8188eu(struct adapter *adapt, u16 pkt_len, u8 *pbuf)
29 struct hal_data_8188e *haldata = adapt->HalData;
31 if (pkt_len != INTERRUPT_MSG_FORMAT_LEN)
35 memcpy(&haldata->IntArray[0], &pbuf[USB_INTR_CONTENT_HISR_OFFSET], 4);
36 memcpy(&haldata->IntArray[1], &pbuf[USB_INTR_CONTENT_HISRE_OFFSET], 4);
40 memcpy(&haldata->C2hArray[0],
41 &pbuf[USB_INTR_CONTENT_C2H_OFFSET], 16);
44 static int recvbuf2recvframe(struct adapter *adapt, struct sk_buff *pskb)
49 u32 pkt_offset, skb_len, alloc_sz;
51 struct recv_stat *prxstat;
52 struct phy_stat *pphy_status = NULL;
53 struct sk_buff *pkt_copy = NULL;
54 struct recv_frame *precvframe = NULL;
55 struct rx_pkt_attrib *pattrib = NULL;
56 struct hal_data_8188e *haldata = adapt->HalData;
57 struct recv_priv *precvpriv = &adapt->recvpriv;
58 struct __queue *pfree_recv_queue = &precvpriv->free_recv_queue;
60 transfer_len = (s32)pskb->len;
63 prxstat = (struct recv_stat *)pbuf;
64 pkt_cnt = (le32_to_cpu(prxstat->rxdw2) >> 16) & 0xff;
67 prxstat = (struct recv_stat *)pbuf;
69 precvframe = rtw_alloc_recvframe(pfree_recv_queue);
71 goto _exit_recvbuf2recvframe;
73 INIT_LIST_HEAD(&precvframe->list);
75 update_recvframe_attrib_88e(precvframe, prxstat);
77 pattrib = &precvframe->attrib;
79 if ((pattrib->crc_err) || (pattrib->icv_err)) {
80 rtw_free_recvframe(precvframe, pfree_recv_queue);
81 goto _exit_recvbuf2recvframe;
84 if ((pattrib->physt) && (pattrib->pkt_rpt_type == NORMAL_RX))
85 pphy_status = (struct phy_stat *)(pbuf + RXDESC_OFFSET);
87 pkt_offset = RXDESC_SIZE + pattrib->drvinfo_sz + pattrib->shift_sz + pattrib->pkt_len;
89 if ((pattrib->pkt_len <= 0) || (pkt_offset > transfer_len)) {
90 rtw_free_recvframe(precvframe, pfree_recv_queue);
91 goto _exit_recvbuf2recvframe;
94 /* Modified by Albert 20101213 */
95 /* For 8 bytes IP header alignment. */
96 if (pattrib->qos) /* Qos data, wireless lan header length is 26 */
101 skb_len = pattrib->pkt_len;
103 /* for first fragment packet, driver need allocate 1536+drvinfo_sz+RXDESC_SIZE to defrag packet. */
104 /* modify alloc_sz for recvive crc error packet by thomas 2011-06-02 */
105 if ((pattrib->mfrag == 1) && (pattrib->frag_num == 0)) {
109 alloc_sz = skb_len + 14;
112 /* 6 is for IP header 8 bytes alignment in QoS packet case. */
113 /* 8 is for skb->data 4 bytes alignment. */
117 pkt_copy = netdev_alloc_skb(adapt->pnetdev, alloc_sz);
119 pkt_copy->dev = adapt->pnetdev;
120 precvframe->pkt = pkt_copy;
121 skb_reserve(pkt_copy, 8 - ((size_t)(pkt_copy->data) & 7));/* force pkt_copy->data at 8-byte alignment address */
122 skb_reserve(pkt_copy, shift_sz);/* force ip_hdr at 8-byte alignment address according to shift_sz. */
123 skb_put_data(pkt_copy, (pbuf + pattrib->drvinfo_sz + RXDESC_SIZE), skb_len);
125 rtw_free_recvframe(precvframe, pfree_recv_queue);
126 goto _exit_recvbuf2recvframe;
129 switch (haldata->UsbRxAggMode) {
132 pkt_offset = (u16)round_up(pkt_offset, 128);
135 pkt_offset = (u16)round_up(pkt_offset, 4);
137 case USB_RX_AGG_DISABLE:
141 if (pattrib->pkt_rpt_type == NORMAL_RX) { /* Normal rx packet */
143 update_recvframe_phyinfo_88e(precvframe, pphy_status);
144 rtw_recv_entry(precvframe);
145 } else if (pattrib->pkt_rpt_type == TX_REPORT1) {
146 /* CCX-TXRPT ack for xmit mgmt frames. */
147 handle_txrpt_ccx_88e(adapt, precvframe->pkt->data);
148 rtw_free_recvframe(precvframe, pfree_recv_queue);
149 } else if (pattrib->pkt_rpt_type == TX_REPORT2) {
150 ODM_RA_TxRPT2Handle_8188E(&haldata->odmpriv,
151 precvframe->pkt->data,
153 pattrib->MacIDValidEntry[0],
154 pattrib->MacIDValidEntry[1]);
155 rtw_free_recvframe(precvframe, pfree_recv_queue);
156 } else if (pattrib->pkt_rpt_type == HIS_REPORT) {
157 interrupt_handler_8188eu(adapt, pattrib->pkt_len, precvframe->pkt->data);
158 rtw_free_recvframe(precvframe, pfree_recv_queue);
161 transfer_len -= pkt_offset;
166 if (transfer_len > 0 && pkt_cnt == 0)
167 pkt_cnt = (le32_to_cpu(prxstat->rxdw2) >> 16) & 0xff;
169 } while ((transfer_len > 0) && (pkt_cnt > 0));
171 _exit_recvbuf2recvframe:
176 static unsigned int ffaddr2pipehdl(struct dvobj_priv *pdvobj, u32 addr)
178 unsigned int pipe = 0, ep_num = 0;
179 struct usb_device *pusbd = pdvobj->pusbdev;
181 if (addr == RECV_BULK_IN_ADDR) {
182 pipe = usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[0]);
183 } else if (addr == RECV_INT_IN_ADDR) {
184 pipe = usb_rcvbulkpipe(pusbd, pdvobj->RtInPipe[1]);
185 } else if (addr < HW_QUEUE_ENTRY) {
186 ep_num = pdvobj->Queue2Pipe[addr];
187 pipe = usb_sndbulkpipe(pusbd, ep_num);
194 usbctrl_vendorreq(struct adapter *adapt, u16 value, void *pdata, u16 len, u8 reqtype)
196 struct dvobj_priv *dvobjpriv = adapter_to_dvobj(adapt);
197 struct usb_device *udev = dvobjpriv->pusbdev;
201 int vendorreq_times = 0;
203 if ((adapt->bSurpriseRemoved) || (adapt->pwrctrlpriv.pnp_bstop_trx)) {
208 if (len > MAX_VENDOR_REQ_CMD_SIZE) {
213 if (mutex_lock_interruptible(&dvobjpriv->usb_vendor_req_mutex)) {
214 status = -ERESTARTSYS;
218 /* Acquire IO memory for vendorreq */
219 pIo_buf = kmalloc(MAX_USB_IO_CTL_SIZE, GFP_ATOMIC);
226 if (reqtype == REALTEK_USB_VENQT_READ) {
227 pipe = usb_rcvctrlpipe(udev, 0);
228 } else if (reqtype == REALTEK_USB_VENQT_WRITE) {
229 pipe = usb_sndctrlpipe(udev, 0);
235 while (++vendorreq_times <= MAX_USBCTRL_VENDORREQ_TIMES) {
236 if (reqtype == REALTEK_USB_VENQT_READ)
237 memset(pIo_buf, 0, len);
239 memcpy(pIo_buf, pdata, len);
241 status = usb_control_msg(udev, pipe, REALTEK_USB_VENQT_CMD_REQ,
242 reqtype, value, REALTEK_USB_VENQT_CMD_IDX,
243 pIo_buf, len, RTW_USB_CONTROL_MSG_TIMEOUT);
245 if (status == len) { /* Success this control transfer. */
246 if (reqtype == REALTEK_USB_VENQT_READ)
247 memcpy(pdata, pIo_buf, len);
248 } else { /* error cases */
250 if (status == -ESHUTDOWN || status == -ENODEV)
251 adapt->bSurpriseRemoved = true;
253 adapt->HalData->srestpriv.wifi_error_status = USB_VEN_REQ_CMD_FAIL;
254 } else { /* status != len && status >= 0 */
256 if (reqtype == REALTEK_USB_VENQT_READ) {
257 /* For Control read transfer, we have to copy the read data from pIo_buf to pdata. */
258 memcpy(pdata, pIo_buf, len);
264 /* firmware download is checksummed, don't retry */
265 if ((value >= FW_8188E_START_ADDRESS && value <= FW_8188E_END_ADDRESS) || status == len)
272 mutex_unlock(&dvobjpriv->usb_vendor_req_mutex);
277 u8 usb_read8(struct adapter *adapter, u32 addr)
279 u16 wvalue = (u16)(addr & 0xffff);
282 usbctrl_vendorreq(adapter, wvalue, &data, 1, REALTEK_USB_VENQT_READ);
287 u16 usb_read16(struct adapter *adapter, u32 addr)
289 u16 wvalue = (u16)(addr & 0xffff);
292 usbctrl_vendorreq(adapter, wvalue, &data, 2, REALTEK_USB_VENQT_READ);
294 return (u16)(le32_to_cpu(data) & 0xffff);
297 u32 usb_read32(struct adapter *adapter, u32 addr)
299 u16 wvalue = (u16)(addr & 0xffff);
302 usbctrl_vendorreq(adapter, wvalue, &data, 4, REALTEK_USB_VENQT_READ);
304 return le32_to_cpu(data);
307 static void usb_read_port_complete(struct urb *purb)
309 struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
310 struct adapter *adapt = (struct adapter *)precvbuf->adapter;
311 struct recv_priv *precvpriv = &adapt->recvpriv;
313 if (adapt->bSurpriseRemoved || adapt->bDriverStopped || adapt->bReadPortCancel) {
314 precvbuf->reuse = true;
318 if (purb->status == 0) { /* SUCCESS */
319 if ((purb->actual_length > MAX_RECVBUF_SZ) || (purb->actual_length < RXDESC_SIZE)) {
320 precvbuf->reuse = true;
321 usb_read_port(adapt, RECV_BULK_IN_ADDR, precvbuf);
323 skb_put(precvbuf->pskb, purb->actual_length);
324 skb_queue_tail(&precvpriv->rx_skb_queue, precvbuf->pskb);
326 if (skb_queue_len(&precvpriv->rx_skb_queue) <= 1)
327 tasklet_schedule(&precvpriv->recv_tasklet);
329 precvbuf->pskb = NULL;
330 precvbuf->reuse = false;
331 usb_read_port(adapt, RECV_BULK_IN_ADDR, precvbuf);
334 skb_put(precvbuf->pskb, purb->actual_length);
335 precvbuf->pskb = NULL;
337 switch (purb->status) {
342 adapt->bSurpriseRemoved = true;
345 adapt->bDriverStopped = true;
349 adapt->HalData->srestpriv.wifi_error_status = USB_READ_PORT_FAIL;
350 precvbuf->reuse = true;
351 usb_read_port(adapt, RECV_BULK_IN_ADDR, precvbuf);
361 u32 usb_read_port(struct adapter *adapter, u32 addr, struct recv_buf *precvbuf)
363 struct urb *purb = NULL;
364 struct dvobj_priv *pdvobj = adapter_to_dvobj(adapter);
365 struct recv_priv *precvpriv = &adapter->recvpriv;
366 struct usb_device *pusbd = pdvobj->pusbdev;
371 if (adapter->bDriverStopped || adapter->bSurpriseRemoved ||
372 adapter->pwrctrlpriv.pnp_bstop_trx) {
379 if (!precvbuf->reuse || !precvbuf->pskb) {
380 precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue);
382 precvbuf->reuse = true;
385 /* re-assign for linux based on skb */
386 if (!precvbuf->reuse || !precvbuf->pskb) {
387 precvbuf->pskb = netdev_alloc_skb(adapter->pnetdev, MAX_RECVBUF_SZ);
390 } else { /* reuse skb */
391 precvbuf->reuse = false;
394 purb = precvbuf->purb;
396 /* translate DMA FIFO addr to pipehandle */
397 pipe = ffaddr2pipehdl(pdvobj, addr);
399 usb_fill_bulk_urb(purb, pusbd, pipe,
400 precvbuf->pskb->data,
402 usb_read_port_complete,
403 precvbuf);/* context is precvbuf */
405 err = usb_submit_urb(purb, GFP_ATOMIC);
406 if ((err) && (err != (-EPERM)))
412 void rtw_hal_inirp_deinit(struct adapter *padapter)
415 struct recv_buf *precvbuf;
417 precvbuf = padapter->recvpriv.precv_buf;
419 padapter->bReadPortCancel = true;
421 for (i = 0; i < NR_RECVBUFF; i++) {
422 precvbuf->reuse = true;
424 usb_kill_urb(precvbuf->purb);
429 int usb_write8(struct adapter *adapter, u32 addr, u8 val)
431 u16 wvalue = (u16)(addr & 0xffff);
434 return usbctrl_vendorreq(adapter, wvalue, &data, 1, REALTEK_USB_VENQT_WRITE);
437 int usb_write16(struct adapter *adapter, u32 addr, u16 val)
439 u16 wvalue = (u16)(addr & 0xffff);
440 __le32 data = cpu_to_le32(val & 0xffff);
442 return usbctrl_vendorreq(adapter, wvalue, &data, 2, REALTEK_USB_VENQT_WRITE);
445 int usb_write32(struct adapter *adapter, u32 addr, u32 val)
447 u16 wvalue = (u16)(addr & 0xffff);
448 __le32 data = cpu_to_le32(val);
450 return usbctrl_vendorreq(adapter, wvalue, &data, 4, REALTEK_USB_VENQT_WRITE);
453 static void usb_write_port_complete(struct urb *purb)
455 struct xmit_buf *pxmitbuf = (struct xmit_buf *)purb->context;
456 struct adapter *padapter = pxmitbuf->padapter;
457 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
459 switch (pxmitbuf->flags) {
461 pxmitpriv->voq_cnt--;
464 pxmitpriv->viq_cnt--;
467 pxmitpriv->beq_cnt--;
470 pxmitpriv->bkq_cnt--;
473 #ifdef CONFIG_88EU_AP_MODE
474 rtw_chk_hi_queue_cmd(padapter);
481 if (padapter->bSurpriseRemoved || padapter->bDriverStopped || padapter->bWritePortCancel)
482 goto check_completion;
485 if ((purb->status == -EPIPE) || (purb->status == -EPROTO)) {
486 sreset_set_wifi_error_status(padapter, USB_WRITE_PORT_FAIL);
487 } else if (purb->status == -EINPROGRESS) {
488 goto check_completion;
489 } else if (purb->status == -ENOENT) {
490 goto check_completion;
491 } else if (purb->status == -ECONNRESET) {
492 goto check_completion;
493 } else if (purb->status == -ESHUTDOWN) {
494 padapter->bDriverStopped = true;
495 goto check_completion;
497 padapter->bSurpriseRemoved = true;
498 goto check_completion;
503 rtw_sctx_done_err(&pxmitbuf->sctx,
504 purb->status ? RTW_SCTX_DONE_WRITE_PORT_ERR :
505 RTW_SCTX_DONE_SUCCESS);
507 rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
509 tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
512 u32 usb_write_port(struct adapter *padapter, u32 addr, u32 cnt, struct xmit_buf *xmitbuf)
518 struct urb *purb = NULL;
519 struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
520 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
521 struct xmit_frame *pxmitframe = (struct xmit_frame *)xmitbuf->priv_data;
522 struct usb_device *pusbd = pdvobj->pusbdev;
524 if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||
525 (padapter->pwrctrlpriv.pnp_bstop_trx)) {
526 rtw_sctx_done_err(&xmitbuf->sctx, RTW_SCTX_DONE_TX_DENY);
530 spin_lock_irqsave(&pxmitpriv->lock, irqL);
534 pxmitpriv->voq_cnt++;
535 xmitbuf->flags = VO_QUEUE_INX;
538 pxmitpriv->viq_cnt++;
539 xmitbuf->flags = VI_QUEUE_INX;
542 pxmitpriv->beq_cnt++;
543 xmitbuf->flags = BE_QUEUE_INX;
546 pxmitpriv->bkq_cnt++;
547 xmitbuf->flags = BK_QUEUE_INX;
550 xmitbuf->flags = HIGH_QUEUE_INX;
553 xmitbuf->flags = MGT_QUEUE_INX;
557 spin_unlock_irqrestore(&pxmitpriv->lock, irqL);
559 purb = xmitbuf->pxmit_urb[0];
561 /* translate DMA FIFO addr to pipehandle */
562 pipe = ffaddr2pipehdl(pdvobj, addr);
564 usb_fill_bulk_urb(purb, pusbd, pipe,
565 pxmitframe->buf_addr, /* xmitbuf->pbuf */
567 usb_write_port_complete,
568 xmitbuf);/* context is xmitbuf */
570 status = usb_submit_urb(purb, GFP_ATOMIC);
572 rtw_sctx_done_err(&xmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR);
573 if (status == -ENODEV)
574 padapter->bDriverStopped = true;
583 rtw_free_xmitbuf(pxmitpriv, xmitbuf);
587 void usb_write_port_cancel(struct adapter *padapter)
590 struct xmit_buf *pxmitbuf = (struct xmit_buf *)padapter->xmitpriv.pxmitbuf;
592 padapter->bWritePortCancel = true;
594 for (i = 0; i < NR_XMITBUFF; i++) {
595 for (j = 0; j < 8; j++) {
596 if (pxmitbuf->pxmit_urb[j])
597 usb_kill_urb(pxmitbuf->pxmit_urb[j]);
602 pxmitbuf = (struct xmit_buf *)padapter->xmitpriv.pxmit_extbuf;
603 for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
604 for (j = 0; j < 8; j++) {
605 if (pxmitbuf->pxmit_urb[j])
606 usb_kill_urb(pxmitbuf->pxmit_urb[j]);
612 void rtl8188eu_recv_tasklet(struct tasklet_struct *t)
614 struct sk_buff *pskb;
615 struct adapter *adapt = from_tasklet(adapt, t, recvpriv.recv_tasklet);
616 struct recv_priv *precvpriv = &adapt->recvpriv;
618 while (NULL != (pskb = skb_dequeue(&precvpriv->rx_skb_queue))) {
619 if ((adapt->bDriverStopped) || (adapt->bSurpriseRemoved)) {
620 dev_kfree_skb_any(pskb);
623 recvbuf2recvframe(adapt, pskb);
624 skb_reset_tail_pointer(pskb);
626 skb_queue_tail(&precvpriv->free_recv_skb_queue, pskb);
630 void rtl8188eu_xmit_tasklet(struct tasklet_struct *t)
632 struct adapter *adapt = from_tasklet(adapt, t, xmitpriv.xmit_tasklet);
633 struct xmit_priv *pxmitpriv = &adapt->xmitpriv;
635 if (check_fwstate(&adapt->mlmepriv, _FW_UNDER_SURVEY))
639 if ((adapt->bDriverStopped) || (adapt->bSurpriseRemoved) || (adapt->bWritePortCancel))
642 if (!rtl8188eu_xmitframe_complete(adapt, pxmitpriv))