1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#define _HCI_OPS_OS_C_
30
31#include <linux/usb.h>
32
33#include "osdep_service.h"
34#include "drv_types.h"
35#include "osdep_intf.h"
36#include "usb_ops.h"
37
38#define RTL871X_VENQT_READ 0xc0
39#define RTL871X_VENQT_WRITE 0x40
40
41struct zero_bulkout_context {
42 void *pbuf;
43 void *purb;
44 void *pirp;
45 void *padapter;
46};
47
48uint r8712_usb_init_intf_priv(struct intf_priv *pintfpriv)
49{
50 pintfpriv->piorw_urb = usb_alloc_urb(0, GFP_ATOMIC);
51 if (!pintfpriv->piorw_urb)
52 return _FAIL;
53 sema_init(&(pintfpriv->io_retevt), 0);
54 return _SUCCESS;
55}
56
57void r8712_usb_unload_intf_priv(struct intf_priv *pintfpriv)
58{
59 if (pintfpriv->piorw_urb) {
60 usb_kill_urb(pintfpriv->piorw_urb);
61 usb_free_urb(pintfpriv->piorw_urb);
62 }
63}
64
65static unsigned int ffaddr2pipehdl(struct dvobj_priv *pdvobj, u32 addr)
66{
67 unsigned int pipe = 0;
68 struct usb_device *pusbd = pdvobj->pusbdev;
69
70 if (pdvobj->nr_endpoint == 11) {
71 switch (addr) {
72 case RTL8712_DMA_BKQ:
73 pipe = usb_sndbulkpipe(pusbd, 0x07);
74 break;
75 case RTL8712_DMA_BEQ:
76 pipe = usb_sndbulkpipe(pusbd, 0x06);
77 break;
78 case RTL8712_DMA_VIQ:
79 pipe = usb_sndbulkpipe(pusbd, 0x05);
80 break;
81 case RTL8712_DMA_VOQ:
82 pipe = usb_sndbulkpipe(pusbd, 0x04);
83 break;
84 case RTL8712_DMA_BCNQ:
85 pipe = usb_sndbulkpipe(pusbd, 0x0a);
86 break;
87 case RTL8712_DMA_BMCQ:
88 pipe = usb_sndbulkpipe(pusbd, 0x0b);
89 break;
90 case RTL8712_DMA_MGTQ:
91 pipe = usb_sndbulkpipe(pusbd, 0x0c);
92 break;
93 case RTL8712_DMA_RX0FF:
94 pipe = usb_rcvbulkpipe(pusbd, 0x03);
95 break;
96 case RTL8712_DMA_C2HCMD:
97 pipe = usb_rcvbulkpipe(pusbd, 0x09);
98 break;
99 case RTL8712_DMA_H2CCMD:
100 pipe = usb_sndbulkpipe(pusbd, 0x0d);
101 break;
102 }
103 } else if (pdvobj->nr_endpoint == 6) {
104 switch (addr) {
105 case RTL8712_DMA_BKQ:
106 pipe = usb_sndbulkpipe(pusbd, 0x07);
107 break;
108 case RTL8712_DMA_BEQ:
109 pipe = usb_sndbulkpipe(pusbd, 0x06);
110 break;
111 case RTL8712_DMA_VIQ:
112 pipe = usb_sndbulkpipe(pusbd, 0x05);
113 break;
114 case RTL8712_DMA_VOQ:
115 pipe = usb_sndbulkpipe(pusbd, 0x04);
116 break;
117 case RTL8712_DMA_RX0FF:
118 case RTL8712_DMA_C2HCMD:
119 pipe = usb_rcvbulkpipe(pusbd, 0x03);
120 break;
121 case RTL8712_DMA_H2CCMD:
122 case RTL8712_DMA_BCNQ:
123 case RTL8712_DMA_BMCQ:
124 case RTL8712_DMA_MGTQ:
125 pipe = usb_sndbulkpipe(pusbd, 0x0d);
126 break;
127 }
128 } else if (pdvobj->nr_endpoint == 4) {
129 switch (addr) {
130 case RTL8712_DMA_BEQ:
131 pipe = usb_sndbulkpipe(pusbd, 0x06);
132 break;
133 case RTL8712_DMA_VOQ:
134 pipe = usb_sndbulkpipe(pusbd, 0x04);
135 break;
136 case RTL8712_DMA_RX0FF:
137 case RTL8712_DMA_C2HCMD:
138 pipe = usb_rcvbulkpipe(pusbd, 0x03);
139 break;
140 case RTL8712_DMA_H2CCMD:
141 case RTL8712_DMA_BCNQ:
142 case RTL8712_DMA_BMCQ:
143 case RTL8712_DMA_MGTQ:
144 pipe = usb_sndbulkpipe(pusbd, 0x0d);
145 break;
146 }
147 } else
148 pipe = 0;
149 return pipe;
150}
151
152static void usb_write_mem_complete(struct urb *purb)
153{
154 struct io_queue *pio_q = (struct io_queue *)purb->context;
155 struct intf_hdl *pintf = &(pio_q->intf);
156 struct intf_priv *pintfpriv = pintf->pintfpriv;
157 struct _adapter *padapter = (struct _adapter *)pintf->adapter;
158
159 if (purb->status != 0) {
160 if (purb->status == (-ESHUTDOWN))
161 padapter->bDriverStopped = true;
162 else
163 padapter->bSurpriseRemoved = true;
164 }
165 up(&pintfpriv->io_retevt);
166}
167
168void r8712_usb_write_mem(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem)
169{
170 unsigned int pipe;
171 struct _adapter *padapter = (struct _adapter *)pintfhdl->adapter;
172 struct intf_priv *pintfpriv = pintfhdl->pintfpriv;
173 struct io_queue *pio_queue = (struct io_queue *)padapter->pio_queue;
174 struct dvobj_priv *pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev;
175 struct usb_device *pusbd = pdvobj->pusbdev;
176 struct urb *piorw_urb = pintfpriv->piorw_urb;
177
178 if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||
179 (padapter->pwrctrlpriv.pnp_bstop_trx))
180 return;
181
182 pipe = ffaddr2pipehdl(pdvobj, addr);
183 if (pipe == 0)
184 return;
185 usb_fill_bulk_urb(piorw_urb, pusbd, pipe,
186 wmem, cnt, usb_write_mem_complete,
187 pio_queue);
188 usb_submit_urb(piorw_urb, GFP_ATOMIC);
189 _down_sema(&pintfpriv->io_retevt);
190}
191
192static void r8712_usb_read_port_complete(struct urb *purb)
193{
194 uint isevt, *pbuf;
195 struct recv_buf *precvbuf = (struct recv_buf *)purb->context;
196 struct _adapter *padapter = (struct _adapter *)precvbuf->adapter;
197 struct recv_priv *precvpriv = &padapter->recvpriv;
198
199 if (padapter->bSurpriseRemoved || padapter->bDriverStopped)
200 return;
201 if (purb->status == 0) {
202 if ((purb->actual_length > (MAX_RECVBUF_SZ)) ||
203 (purb->actual_length < RXDESC_SIZE)) {
204 precvbuf->reuse = true;
205 r8712_read_port(padapter, precvpriv->ff_hwaddr, 0,
206 (unsigned char *)precvbuf);
207 } else {
208 precvbuf->transfer_len = purb->actual_length;
209 pbuf = (uint *)precvbuf->pbuf;
210 isevt = le32_to_cpu(*(pbuf + 1)) & 0x1ff;
211 if ((isevt & 0x1ff) == 0x1ff) {
212 r8712_rxcmd_event_hdl(padapter, pbuf);
213 precvbuf->reuse = true;
214 r8712_read_port(padapter, precvpriv->ff_hwaddr,
215 0, (unsigned char *)precvbuf);
216 } else {
217 _pkt *pskb = precvbuf->pskb;
218
219 skb_put(pskb, purb->actual_length);
220 skb_queue_tail(&precvpriv->rx_skb_queue, pskb);
221 tasklet_hi_schedule(&precvpriv->recv_tasklet);
222 precvbuf->pskb = NULL;
223 precvbuf->reuse = false;
224 r8712_read_port(padapter, precvpriv->ff_hwaddr,
225 0, (unsigned char *)precvbuf);
226 }
227 }
228 } else {
229 switch (purb->status) {
230 case -EINVAL:
231 case -EPIPE:
232 case -ENODEV:
233 case -ESHUTDOWN:
234 case -ENOENT:
235 padapter->bDriverStopped = true;
236 break;
237 case -EPROTO:
238 precvbuf->reuse = true;
239 r8712_read_port(padapter, precvpriv->ff_hwaddr, 0,
240 (unsigned char *)precvbuf);
241 break;
242 case -EINPROGRESS:
243 netdev_err(padapter->pnetdev, "ERROR: URB IS IN PROGRESS!\n");
244 break;
245 default:
246 break;
247 }
248 }
249}
250
251u32 r8712_usb_read_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *rmem)
252{
253 unsigned int pipe;
254 int err;
255 u32 tmpaddr = 0;
256 int alignment = 0;
257 u32 ret = _SUCCESS;
258 struct urb *purb = NULL;
259 struct recv_buf *precvbuf = (struct recv_buf *)rmem;
260 struct intf_priv *pintfpriv = pintfhdl->pintfpriv;
261 struct dvobj_priv *pdvobj = (struct dvobj_priv *)pintfpriv->intf_dev;
262 struct _adapter *adapter = (struct _adapter *)pdvobj->padapter;
263 struct recv_priv *precvpriv = &adapter->recvpriv;
264 struct usb_device *pusbd = pdvobj->pusbdev;
265
266 if (adapter->bDriverStopped || adapter->bSurpriseRemoved ||
267 adapter->pwrctrlpriv.pnp_bstop_trx)
268 return _FAIL;
269 if (!precvbuf->reuse == false || !precvbuf->pskb) {
270 precvbuf->pskb = skb_dequeue(&precvpriv->free_recv_skb_queue);
271 if (NULL != precvbuf->pskb)
272 precvbuf->reuse = true;
273 }
274 if (precvbuf != NULL) {
275 r8712_init_recvbuf(adapter, precvbuf);
276
277 if (!precvbuf->reuse || !precvbuf->pskb) {
278 precvbuf->pskb = netdev_alloc_skb(adapter->pnetdev,
279 MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
280 if (!precvbuf->pskb)
281 return _FAIL;
282 tmpaddr = (addr_t)precvbuf->pskb->data;
283 alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
284 skb_reserve(precvbuf->pskb,
285 (RECVBUFF_ALIGN_SZ - alignment));
286 precvbuf->phead = precvbuf->pskb->head;
287 precvbuf->pdata = precvbuf->pskb->data;
288 precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
289 precvbuf->pend = skb_end_pointer(precvbuf->pskb);
290 precvbuf->pbuf = precvbuf->pskb->data;
291 } else {
292 precvbuf->phead = precvbuf->pskb->head;
293 precvbuf->pdata = precvbuf->pskb->data;
294 precvbuf->ptail = skb_tail_pointer(precvbuf->pskb);
295 precvbuf->pend = skb_end_pointer(precvbuf->pskb);
296 precvbuf->pbuf = precvbuf->pskb->data;
297 precvbuf->reuse = false;
298 }
299 purb = precvbuf->purb;
300
301 pipe = ffaddr2pipehdl(pdvobj, addr);
302 usb_fill_bulk_urb(purb, pusbd, pipe,
303 precvbuf->pbuf, MAX_RECVBUF_SZ,
304 r8712_usb_read_port_complete,
305 precvbuf);
306 err = usb_submit_urb(purb, GFP_ATOMIC);
307 if ((err) && (err != (-EPERM)))
308 ret = _FAIL;
309 } else
310 ret = _FAIL;
311 return ret;
312}
313
314void r8712_usb_read_port_cancel(struct _adapter *padapter)
315{
316 int i;
317 struct recv_buf *precvbuf;
318
319 precvbuf = (struct recv_buf *)padapter->recvpriv.precv_buf;
320 for (i = 0; i < NR_RECVBUFF; i++) {
321 if (precvbuf->purb)
322 usb_kill_urb(precvbuf->purb);
323 precvbuf++;
324 }
325}
326
327void r8712_xmit_bh(void *priv)
328{
329 int ret = false;
330 struct _adapter *padapter = (struct _adapter *)priv;
331 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
332
333 if ((padapter->bDriverStopped == true) ||
334 (padapter->bSurpriseRemoved == true)) {
335 netdev_err(padapter->pnetdev, "xmit_bh => bDriverStopped or bSurpriseRemoved\n");
336 return;
337 }
338 ret = r8712_xmitframe_complete(padapter, pxmitpriv, NULL);
339 if (ret == false)
340 return;
341 tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
342}
343
344static void usb_write_port_complete(struct urb *purb)
345{
346 int i;
347 struct xmit_frame *pxmitframe = (struct xmit_frame *)purb->context;
348 struct xmit_buf *pxmitbuf = pxmitframe->pxmitbuf;
349 struct _adapter *padapter = pxmitframe->padapter;
350 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
351 struct pkt_attrib *pattrib = &pxmitframe->attrib;
352
353 switch (pattrib->priority) {
354 case 1:
355 case 2:
356 pxmitpriv->bkq_cnt--;
357 break;
358 case 4:
359 case 5:
360 pxmitpriv->viq_cnt--;
361 break;
362 case 6:
363 case 7:
364 pxmitpriv->voq_cnt--;
365 break;
366 case 0:
367 case 3:
368 default:
369 pxmitpriv->beq_cnt--;
370 break;
371 }
372 pxmitpriv->txirp_cnt--;
373 for (i = 0; i < 8; i++) {
374 if (purb == pxmitframe->pxmit_urb[i]) {
375 pxmitframe->bpending[i] = false;
376 break;
377 }
378 }
379 if (padapter->bSurpriseRemoved)
380 return;
381 switch (purb->status) {
382 case 0:
383 break;
384 default:
385 netdev_warn(padapter->pnetdev,
386 "r8712u: pipe error: (%d)\n", purb->status);
387 break;
388 }
389
390 r8712_free_xmitframe_ex(pxmitpriv, pxmitframe);
391 r8712_free_xmitbuf(pxmitpriv, pxmitbuf);
392 tasklet_hi_schedule(&pxmitpriv->xmit_tasklet);
393}
394
395u32 r8712_usb_write_port(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *wmem)
396{
397 unsigned long irqL;
398 int i, status;
399 unsigned int pipe;
400 u32 ret, bwritezero;
401 struct urb *purb = NULL;
402 struct _adapter *padapter = (struct _adapter *)pintfhdl->adapter;
403 struct dvobj_priv *pdvobj = (struct dvobj_priv *)&padapter->dvobjpriv;
404 struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
405 struct xmit_frame *pxmitframe = (struct xmit_frame *)wmem;
406 struct usb_device *pusbd = pdvobj->pusbdev;
407 struct pkt_attrib *pattrib = &pxmitframe->attrib;
408
409 if ((padapter->bDriverStopped) || (padapter->bSurpriseRemoved) ||
410 (padapter->pwrctrlpriv.pnp_bstop_trx))
411 return _FAIL;
412 for (i = 0; i < 8; i++) {
413 if (pxmitframe->bpending[i] == false) {
414 spin_lock_irqsave(&pxmitpriv->lock, irqL);
415 pxmitpriv->txirp_cnt++;
416 pxmitframe->bpending[i] = true;
417 switch (pattrib->priority) {
418 case 1:
419 case 2:
420 pxmitpriv->bkq_cnt++;
421 break;
422 case 4:
423 case 5:
424 pxmitpriv->viq_cnt++;
425 break;
426 case 6:
427 case 7:
428 pxmitpriv->voq_cnt++;
429 break;
430 case 0:
431 case 3:
432 default:
433 pxmitpriv->beq_cnt++;
434 break;
435 }
436 spin_unlock_irqrestore(&pxmitpriv->lock, irqL);
437 pxmitframe->sz[i] = (u16)cnt;
438 purb = pxmitframe->pxmit_urb[i];
439 break;
440 }
441 }
442 bwritezero = false;
443 if (pdvobj->ishighspeed) {
444 if (cnt > 0 && cnt % 512 == 0)
445 bwritezero = true;
446 } else {
447 if (cnt > 0 && cnt % 64 == 0)
448 bwritezero = true;
449 }
450
451 pipe = ffaddr2pipehdl(pdvobj, addr);
452 if (pxmitpriv->free_xmitbuf_cnt%NR_XMITBUFF == 0)
453 purb->transfer_flags &= (~URB_NO_INTERRUPT);
454 else
455 purb->transfer_flags |= URB_NO_INTERRUPT;
456 if (bwritezero)
457 cnt += 8;
458 usb_fill_bulk_urb(purb, pusbd, pipe,
459 pxmitframe->mem_addr,
460 cnt, usb_write_port_complete,
461 pxmitframe);
462 status = usb_submit_urb(purb, GFP_ATOMIC);
463 if (!status)
464 ret = _SUCCESS;
465 else
466 ret = _FAIL;
467 return ret;
468}
469
470void r8712_usb_write_port_cancel(struct _adapter *padapter)
471{
472 int i, j;
473 struct xmit_buf *pxmitbuf = (struct xmit_buf *)
474 padapter->xmitpriv.pxmitbuf;
475
476 for (i = 0; i < NR_XMITBUFF; i++) {
477 for (j = 0; j < 8; j++) {
478 if (pxmitbuf->pxmit_urb[j])
479 usb_kill_urb(pxmitbuf->pxmit_urb[j]);
480 }
481 pxmitbuf++;
482 }
483}
484
485int r8712_usbctrl_vendorreq(struct intf_priv *pintfpriv, u8 request, u16 value,
486 u16 index, void *pdata, u16 len, u8 requesttype)
487{
488 unsigned int pipe;
489 int status;
490 u8 reqtype;
491 struct dvobj_priv *pdvobjpriv = (struct dvobj_priv *)
492 pintfpriv->intf_dev;
493 struct usb_device *udev = pdvobjpriv->pusbdev;
494
495
496
497 u8 *palloc_buf, *pIo_buf;
498
499 palloc_buf = kmalloc((u32)len + 16, GFP_ATOMIC);
500 if (palloc_buf == NULL)
501 return -ENOMEM;
502 pIo_buf = palloc_buf + 16 - ((addr_t)(palloc_buf) & 0x0f);
503 if (requesttype == 0x01) {
504 pipe = usb_rcvctrlpipe(udev, 0);
505 reqtype = RTL871X_VENQT_READ;
506 } else {
507 pipe = usb_sndctrlpipe(udev, 0);
508 reqtype = RTL871X_VENQT_WRITE;
509 memcpy(pIo_buf, pdata, len);
510 }
511 status = usb_control_msg(udev, pipe, request, reqtype, value, index,
512 pIo_buf, len, HZ / 2);
513 if (status > 0) {
514 if (requesttype == 0x01) {
515
516
517
518 memcpy(pdata, pIo_buf, status);
519 }
520 }
521 kfree(palloc_buf);
522 return status;
523}
524