1/* $NetBSD: if_upl.c,v 1.56 2016/07/07 06:55:42 msaitoh Exp $ */
2/*
3 * Copyright (c) 2000 The NetBSD Foundation, Inc.
4 * All rights reserved.
5 *
6 * This code is derived from software contributed to The NetBSD Foundation
7 * by Lennart Augustsson (lennart@augustsson.net) at
8 * Carlstedt Research & Technology.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*
33 * Prolific PL2301/PL2302 driver
34 */
35
36#include <sys/cdefs.h>
37__KERNEL_RCSID(0, "$NetBSD: if_upl.c,v 1.56 2016/07/07 06:55:42 msaitoh Exp $");
38
39#ifdef _KERNEL_OPT
40#include "opt_inet.h"
41#endif
42
43#include <sys/param.h>
44#include <sys/systm.h>
45#include <sys/callout.h>
46#include <sys/sockio.h>
47#include <sys/mbuf.h>
48#include <sys/kernel.h>
49#include <sys/socket.h>
50
51#include <sys/device.h>
52#include <sys/rndsource.h>
53
54#include <net/if.h>
55#include <net/if_types.h>
56#include <net/if_dl.h>
57#include <net/netisr.h>
58
59#include <net/bpf.h>
60
61#ifdef INET
62#include <netinet/in.h>
63#include <netinet/in_var.h>
64#include <netinet/if_inarp.h>
65#endif
66
67
68#include <dev/usb/usb.h>
69#include <dev/usb/usbdi.h>
70#include <dev/usb/usbdi_util.h>
71#include <dev/usb/usbdevs.h>
72
73/*
74 * 7 6 5 4 3 2 1 0
75 * tx rx 1 0
76 * 1110 0000 rxdata
77 * 1010 0000 idle
78 * 0010 0000 tx over
79 * 0110 tx over + rxd
80 */
81
82#define UPL_RXDATA 0x40
83#define UPL_TXOK 0x80
84
85#define UPL_INTR_PKTLEN 1
86
87#define UPL_CONFIG_NO 1
88#define UPL_IFACE_IDX 0
89
90/***/
91
92#define UPL_INTR_INTERVAL 20
93
94#define UPL_BUFSZ 1024
95
96#define UPL_RX_FRAMES 1
97#define UPL_TX_FRAMES 1
98
99#define UPL_RX_LIST_CNT 1
100#define UPL_TX_LIST_CNT 1
101
102#define UPL_ENDPT_RX 0x0
103#define UPL_ENDPT_TX 0x1
104#define UPL_ENDPT_INTR 0x2
105#define UPL_ENDPT_MAX 0x3
106
107struct upl_type {
108 uint16_t upl_vid;
109 uint16_t upl_did;
110};
111
112struct upl_softc;
113
114struct upl_chain {
115 struct upl_softc *upl_sc;
116 struct usbd_xfer *upl_xfer;
117 char *upl_buf;
118 struct mbuf *upl_mbuf;
119 int upl_idx;
120};
121
122struct upl_cdata {
123 struct upl_chain upl_tx_chain[UPL_TX_LIST_CNT];
124 struct upl_chain upl_rx_chain[UPL_RX_LIST_CNT];
125 int upl_tx_prod;
126 int upl_tx_cons;
127 int upl_tx_cnt;
128 int upl_rx_prod;
129};
130
131struct upl_softc {
132 device_t sc_dev;
133
134 struct ifnet sc_if;
135 krndsource_t sc_rnd_source;
136
137 struct callout sc_stat_ch;
138
139 struct usbd_device * sc_udev;
140 struct usbd_interface * sc_iface;
141 uint16_t sc_vendor;
142 uint16_t sc_product;
143 int sc_ed[UPL_ENDPT_MAX];
144 struct usbd_pipe * sc_ep[UPL_ENDPT_MAX];
145 struct upl_cdata sc_cdata;
146
147 uByte sc_ibuf;
148
149 char sc_dying;
150 char sc_attached;
151 u_int sc_rx_errs;
152 struct timeval sc_rx_notice;
153 u_int sc_intr_errs;
154};
155
156#ifdef UPL_DEBUG
157#define DPRINTF(x) if (upldebug) printf x
158#define DPRINTFN(n,x) if (upldebug >= (n)) printf x
159int upldebug = 0;
160#else
161#define DPRINTF(x)
162#define DPRINTFN(n,x)
163#endif
164
165/*
166 * Various supported device vendors/products.
167 */
168Static struct upl_type sc_devs[] = {
169 { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2301 },
170 { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2302 },
171 { 0, 0 }
172};
173
174int upl_match(device_t, cfdata_t, void *);
175void upl_attach(device_t, device_t, void *);
176int upl_detach(device_t, int);
177int upl_activate(device_t, enum devact);
178extern struct cfdriver upl_cd;
179CFATTACH_DECL_NEW(upl, sizeof(struct upl_softc), upl_match, upl_attach,
180 upl_detach, upl_activate);
181
182Static int upl_openpipes(struct upl_softc *);
183Static int upl_tx_list_init(struct upl_softc *);
184Static int upl_rx_list_init(struct upl_softc *);
185Static int upl_newbuf(struct upl_softc *, struct upl_chain *, struct mbuf *);
186Static int upl_send(struct upl_softc *, struct mbuf *, int);
187Static void upl_intr(struct usbd_xfer *, void *, usbd_status);
188Static void upl_rxeof(struct usbd_xfer *, void *, usbd_status);
189Static void upl_txeof(struct usbd_xfer *, void *, usbd_status);
190Static void upl_start(struct ifnet *);
191Static int upl_ioctl(struct ifnet *, u_long, void *);
192Static void upl_init(void *);
193Static void upl_stop(struct upl_softc *);
194Static void upl_watchdog(struct ifnet *);
195
196Static int upl_output(struct ifnet *, struct mbuf *, const struct sockaddr *,
197 const struct rtentry *);
198Static void upl_input(struct ifnet *, struct mbuf *);
199
200/*
201 * Probe for a Prolific chip.
202 */
203int
204upl_match(device_t parent, cfdata_t match, void *aux)
205{
206 struct usb_attach_arg *uaa = aux;
207 struct upl_type *t;
208
209 for (t = sc_devs; t->upl_vid != 0; t++)
210 if (uaa->uaa_vendor == t->upl_vid && uaa->uaa_product == t->upl_did)
211 return UMATCH_VENDOR_PRODUCT;
212
213 return UMATCH_NONE;
214}
215
216void
217upl_attach(device_t parent, device_t self, void *aux)
218{
219 struct upl_softc *sc = device_private(self);
220 struct usb_attach_arg *uaa = aux;
221 char *devinfop;
222 int s;
223 struct usbd_device * dev = uaa->uaa_device;
224 struct usbd_interface * iface;
225 usbd_status err;
226 struct ifnet *ifp;
227 usb_interface_descriptor_t *id;
228 usb_endpoint_descriptor_t *ed;
229 int i;
230
231 DPRINTFN(5,(" : upl_attach: sc=%p, dev=%p", sc, dev));
232
233 sc->sc_dev = self;
234
235 aprint_naive("\n");
236 aprint_normal("\n");
237
238 devinfop = usbd_devinfo_alloc(dev, 0);
239 aprint_normal_dev(self, "%s\n", devinfop);
240 usbd_devinfo_free(devinfop);
241
242 err = usbd_set_config_no(dev, UPL_CONFIG_NO, 1);
243 if (err) {
244 aprint_error_dev(self, "failed to set configuration"
245 ", err=%s\n", usbd_errstr(err));
246 return;
247 }
248
249 sc->sc_udev = dev;
250 sc->sc_product = uaa->uaa_product;
251 sc->sc_vendor = uaa->uaa_vendor;
252
253 err = usbd_device2interface_handle(dev, UPL_IFACE_IDX, &iface);
254 if (err) {
255 aprint_error_dev(self, "getting interface handle failed\n");
256 return;
257 }
258
259 sc->sc_iface = iface;
260 id = usbd_get_interface_descriptor(iface);
261
262 /* Find endpoints. */
263 for (i = 0; i < id->bNumEndpoints; i++) {
264 ed = usbd_interface2endpoint_descriptor(iface, i);
265 if (ed == NULL) {
266 aprint_error_dev(self, "couldn't get ep %d\n", i);
267 return;
268 }
269 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
270 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
271 sc->sc_ed[UPL_ENDPT_RX] = ed->bEndpointAddress;
272 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
273 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
274 sc->sc_ed[UPL_ENDPT_TX] = ed->bEndpointAddress;
275 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
276 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
277 sc->sc_ed[UPL_ENDPT_INTR] = ed->bEndpointAddress;
278 }
279 }
280
281 if (sc->sc_ed[UPL_ENDPT_RX] == 0 || sc->sc_ed[UPL_ENDPT_TX] == 0 ||
282 sc->sc_ed[UPL_ENDPT_INTR] == 0) {
283 aprint_error_dev(self, "missing endpoint\n");
284 return;
285 }
286
287 s = splnet();
288
289 /* Initialize interface info.*/
290 ifp = &sc->sc_if;
291 ifp->if_softc = sc;
292 ifp->if_mtu = UPL_BUFSZ;
293 ifp->if_flags = IFF_POINTOPOINT | IFF_NOARP | IFF_SIMPLEX;
294 ifp->if_ioctl = upl_ioctl;
295 ifp->if_start = upl_start;
296 ifp->if_watchdog = upl_watchdog;
297 strncpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
298
299 ifp->if_type = IFT_OTHER;
300 ifp->if_addrlen = 0;
301 ifp->if_hdrlen = 0;
302 ifp->if_output = upl_output;
303 ifp->_if_input = upl_input;
304 ifp->if_baudrate = 12000000;
305 ifp->if_dlt = DLT_RAW;
306 IFQ_SET_READY(&ifp->if_snd);
307
308 /* Attach the interface. */
309 if_initialize(ifp);
310 if_register(ifp);
311 if_alloc_sadl(ifp);
312
313 bpf_attach(ifp, DLT_RAW, 0);
314 rnd_attach_source(&sc->sc_rnd_source, device_xname(sc->sc_dev),
315 RND_TYPE_NET, RND_FLAG_DEFAULT);
316
317 sc->sc_attached = 1;
318 splx(s);
319
320 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
321
322 return;
323}
324
325int
326upl_detach(device_t self, int flags)
327{
328 struct upl_softc *sc = device_private(self);
329 struct ifnet *ifp = &sc->sc_if;
330 int s;
331
332 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
333
334 s = splusb();
335
336 if (!sc->sc_attached) {
337 /* Detached before attached finished, so just bail out. */
338 splx(s);
339 return 0;
340 }
341
342 if (ifp->if_flags & IFF_RUNNING)
343 upl_stop(sc);
344
345 rnd_detach_source(&sc->sc_rnd_source);
346 bpf_detach(ifp);
347
348 if_detach(ifp);
349
350#ifdef DIAGNOSTIC
351 if (sc->sc_ep[UPL_ENDPT_TX] != NULL ||
352 sc->sc_ep[UPL_ENDPT_RX] != NULL ||
353 sc->sc_ep[UPL_ENDPT_INTR] != NULL)
354 aprint_debug_dev(self, "detach has active endpoints\n");
355#endif
356
357 sc->sc_attached = 0;
358 splx(s);
359
360 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
361
362 return 0;
363}
364
365int
366upl_activate(device_t self, enum devact act)
367{
368 struct upl_softc *sc = device_private(self);
369
370 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
371
372 switch (act) {
373 case DVACT_DEACTIVATE:
374 /* Deactivate the interface. */
375 if_deactivate(&sc->sc_if);
376 sc->sc_dying = 1;
377 return 0;
378 default:
379 return EOPNOTSUPP;
380 }
381}
382
383/*
384 * Initialize an RX descriptor and attach an MBUF cluster.
385 */
386Static int
387upl_newbuf(struct upl_softc *sc, struct upl_chain *c, struct mbuf *m)
388{
389 struct mbuf *m_new = NULL;
390
391 DPRINTFN(8,("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
392
393 if (m == NULL) {
394 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
395 if (m_new == NULL) {
396 printf("%s: no memory for rx list "
397 "-- packet dropped!\n", device_xname(sc->sc_dev));
398 return ENOBUFS;
399 }
400
401 MCLGET(m_new, M_DONTWAIT);
402 if (!(m_new->m_flags & M_EXT)) {
403 printf("%s: no memory for rx list "
404 "-- packet dropped!\n", device_xname(sc->sc_dev));
405 m_freem(m_new);
406 return ENOBUFS;
407 }
408 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
409 } else {
410 m_new = m;
411 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
412 m_new->m_data = m_new->m_ext.ext_buf;
413 }
414
415 c->upl_mbuf = m_new;
416
417 return 0;
418}
419
420Static int
421upl_rx_list_init(struct upl_softc *sc)
422{
423 struct upl_cdata *cd;
424 struct upl_chain *c;
425 int i;
426
427 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
428
429 cd = &sc->sc_cdata;
430 for (i = 0; i < UPL_RX_LIST_CNT; i++) {
431 c = &cd->upl_rx_chain[i];
432 c->upl_sc = sc;
433 c->upl_idx = i;
434 if (upl_newbuf(sc, c, NULL) == ENOBUFS)
435 return ENOBUFS;
436 if (c->upl_xfer == NULL) {
437 int error = usbd_create_xfer(sc->sc_ep[UPL_ENDPT_RX],
438 UPL_BUFSZ, USBD_SHORT_XFER_OK, 0, &c->upl_xfer);
439 if (error)
440 return error;
441 c->upl_buf = usbd_get_buffer(c->upl_xfer);
442 }
443 }
444
445 return 0;
446}
447
448Static int
449upl_tx_list_init(struct upl_softc *sc)
450{
451 struct upl_cdata *cd;
452 struct upl_chain *c;
453 int i;
454
455 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
456
457 cd = &sc->sc_cdata;
458 for (i = 0; i < UPL_TX_LIST_CNT; i++) {
459 c = &cd->upl_tx_chain[i];
460 c->upl_sc = sc;
461 c->upl_idx = i;
462 c->upl_mbuf = NULL;
463 if (c->upl_xfer == NULL) {
464 int error = usbd_create_xfer(sc->sc_ep[UPL_ENDPT_TX],
465 UPL_BUFSZ, 0, 0, &c->upl_xfer);
466 if (error)
467 return error;
468 c->upl_buf = usbd_get_buffer(c->upl_xfer);
469 }
470 }
471
472 return 0;
473}
474
475/*
476 * A frame has been uploaded: pass the resulting mbuf chain up to
477 * the higher level protocols.
478 */
479Static void
480upl_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
481{
482 struct upl_chain *c = priv;
483 struct upl_softc *sc = c->upl_sc;
484 struct ifnet *ifp = &sc->sc_if;
485 struct mbuf *m;
486 int total_len = 0;
487 int s;
488
489 if (sc->sc_dying)
490 return;
491
492 if (!(ifp->if_flags & IFF_RUNNING))
493 return;
494
495 if (status != USBD_NORMAL_COMPLETION) {
496 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
497 return;
498 sc->sc_rx_errs++;
499 if (usbd_ratecheck(&sc->sc_rx_notice)) {
500 printf("%s: %u usb errors on rx: %s\n",
501 device_xname(sc->sc_dev), sc->sc_rx_errs,
502 usbd_errstr(status));
503 sc->sc_rx_errs = 0;
504 }
505 if (status == USBD_STALLED)
506 usbd_clear_endpoint_stall_async(sc->sc_ep[UPL_ENDPT_RX]);
507 goto done;
508 }
509
510 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
511
512 DPRINTFN(9,("%s: %s: enter status=%d length=%d\n",
513 device_xname(sc->sc_dev), __func__, status, total_len));
514
515 m = c->upl_mbuf;
516 memcpy(mtod(c->upl_mbuf, char *), c->upl_buf, total_len);
517
518 ifp->if_ipackets++;
519 m->m_pkthdr.len = m->m_len = total_len;
520
521 m_set_rcvif(m, ifp);
522
523 s = splnet();
524
525 /* XXX ugly */
526 if (upl_newbuf(sc, c, NULL) == ENOBUFS) {
527 ifp->if_ierrors++;
528 goto done1;
529 }
530
531 /*
532 * Handle BPF listeners. Let the BPF user see the packet, but
533 * don't pass it up to the ether_input() layer unless it's
534 * a broadcast packet, multicast packet, matches our ethernet
535 * address or the interface is in promiscuous mode.
536 */
537 bpf_mtap(ifp, m);
538
539 DPRINTFN(10,("%s: %s: deliver %d\n", device_xname(sc->sc_dev),
540 __func__, m->m_len));
541
542 if_input((ifp), (m));
543
544 done1:
545 splx(s);
546
547 done:
548#if 1
549 /* Setup new transfer. */
550 usbd_setup_xfer(c->upl_xfer, c, c->upl_buf, UPL_BUFSZ,
551 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, upl_rxeof);
552 usbd_transfer(c->upl_xfer);
553
554 DPRINTFN(10,("%s: %s: start rx\n", device_xname(sc->sc_dev),
555 __func__));
556#endif
557}
558
559/*
560 * A frame was downloaded to the chip. It's safe for us to clean up
561 * the list buffers.
562 */
563Static void
564upl_txeof(struct usbd_xfer *xfer, void *priv,
565 usbd_status status)
566{
567 struct upl_chain *c = priv;
568 struct upl_softc *sc = c->upl_sc;
569 struct ifnet *ifp = &sc->sc_if;
570 int s;
571
572 if (sc->sc_dying)
573 return;
574
575 s = splnet();
576
577 DPRINTFN(10,("%s: %s: enter status=%d\n", device_xname(sc->sc_dev),
578 __func__, status));
579
580 ifp->if_timer = 0;
581 ifp->if_flags &= ~IFF_OACTIVE;
582
583 if (status != USBD_NORMAL_COMPLETION) {
584 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
585 splx(s);
586 return;
587 }
588 ifp->if_oerrors++;
589 printf("%s: usb error on tx: %s\n", device_xname(sc->sc_dev),
590 usbd_errstr(status));
591 if (status == USBD_STALLED)
592 usbd_clear_endpoint_stall_async(sc->sc_ep[UPL_ENDPT_TX]);
593 splx(s);
594 return;
595 }
596
597 ifp->if_opackets++;
598
599 m_freem(c->upl_mbuf);
600 c->upl_mbuf = NULL;
601
602 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
603 upl_start(ifp);
604
605 splx(s);
606}
607
608Static int
609upl_send(struct upl_softc *sc, struct mbuf *m, int idx)
610{
611 int total_len;
612 struct upl_chain *c;
613 usbd_status err;
614
615 c = &sc->sc_cdata.upl_tx_chain[idx];
616
617 /*
618 * Copy the mbuf data into a contiguous buffer, leaving two
619 * bytes at the beginning to hold the frame length.
620 */
621 m_copydata(m, 0, m->m_pkthdr.len, c->upl_buf);
622 c->upl_mbuf = m;
623
624 total_len = m->m_pkthdr.len;
625
626 DPRINTFN(10,("%s: %s: total_len=%d\n",
627 device_xname(sc->sc_dev), __func__, total_len));
628
629 usbd_setup_xfer(c->upl_xfer, c, c->upl_buf, total_len, 0,
630 USBD_DEFAULT_TIMEOUT, upl_txeof);
631
632 /* Transmit */
633 err = usbd_transfer(c->upl_xfer);
634 if (err != USBD_IN_PROGRESS) {
635 printf("%s: upl_send error=%s\n", device_xname(sc->sc_dev),
636 usbd_errstr(err));
637 upl_stop(sc);
638 return EIO;
639 }
640
641 sc->sc_cdata.upl_tx_cnt++;
642
643 return 0;
644}
645
646Static void
647upl_start(struct ifnet *ifp)
648{
649 struct upl_softc *sc = ifp->if_softc;
650 struct mbuf *m_head = NULL;
651
652 if (sc->sc_dying)
653 return;
654
655 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
656
657 if (ifp->if_flags & IFF_OACTIVE)
658 return;
659
660 IFQ_POLL(&ifp->if_snd, m_head);
661 if (m_head == NULL)
662 return;
663
664 if (upl_send(sc, m_head, 0)) {
665 ifp->if_flags |= IFF_OACTIVE;
666 return;
667 }
668
669 IFQ_DEQUEUE(&ifp->if_snd, m_head);
670
671 /*
672 * If there's a BPF listener, bounce a copy of this frame
673 * to him.
674 */
675 bpf_mtap(ifp, m_head);
676
677 ifp->if_flags |= IFF_OACTIVE;
678
679 /*
680 * Set a timeout in case the chip goes out to lunch.
681 */
682 ifp->if_timer = 5;
683}
684
685Static void
686upl_init(void *xsc)
687{
688 struct upl_softc *sc = xsc;
689 struct ifnet *ifp = &sc->sc_if;
690 int s;
691
692 if (sc->sc_dying)
693 return;
694
695 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
696
697 if (ifp->if_flags & IFF_RUNNING)
698 return;
699
700 s = splnet();
701
702 if (sc->sc_ep[UPL_ENDPT_RX] == NULL) {
703 if (upl_openpipes(sc)) {
704 splx(s);
705 return;
706 }
707 }
708 /* Init TX ring. */
709 if (upl_tx_list_init(sc)) {
710 printf("%s: tx list init failed\n", device_xname(sc->sc_dev));
711 splx(s);
712 return;
713 }
714
715 /* Init RX ring. */
716 if (upl_rx_list_init(sc)) {
717 printf("%s: rx list init failed\n", device_xname(sc->sc_dev));
718 splx(s);
719 return;
720 }
721
722 /* Start up the receive pipe. */
723 for (int i = 0; i < UPL_RX_LIST_CNT; i++) {
724 struct upl_chain *c = &sc->sc_cdata.upl_rx_chain[i];
725 usbd_setup_xfer(c->upl_xfer, c, c->upl_buf, UPL_BUFSZ,
726 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT,
727 upl_rxeof);
728 usbd_transfer(c->upl_xfer);
729 }
730
731 ifp->if_flags |= IFF_RUNNING;
732 ifp->if_flags &= ~IFF_OACTIVE;
733
734 splx(s);
735}
736
737Static int
738upl_openpipes(struct upl_softc *sc)
739{
740 usbd_status err;
741
742 /* Open RX and TX pipes. */
743 err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[UPL_ENDPT_RX],
744 USBD_EXCLUSIVE_USE, &sc->sc_ep[UPL_ENDPT_RX]);
745 if (err) {
746 printf("%s: open rx pipe failed: %s\n",
747 device_xname(sc->sc_dev), usbd_errstr(err));
748 return EIO;
749 }
750 err = usbd_open_pipe(sc->sc_iface, sc->sc_ed[UPL_ENDPT_TX],
751 USBD_EXCLUSIVE_USE, &sc->sc_ep[UPL_ENDPT_TX]);
752 if (err) {
753 printf("%s: open tx pipe failed: %s\n",
754 device_xname(sc->sc_dev), usbd_errstr(err));
755 return EIO;
756 }
757 err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_ed[UPL_ENDPT_INTR],
758 USBD_EXCLUSIVE_USE, &sc->sc_ep[UPL_ENDPT_INTR], sc,
759 &sc->sc_ibuf, UPL_INTR_PKTLEN, upl_intr,
760 UPL_INTR_INTERVAL);
761 if (err) {
762 printf("%s: open intr pipe failed: %s\n",
763 device_xname(sc->sc_dev), usbd_errstr(err));
764 return EIO;
765 }
766
767 return 0;
768}
769
770Static void
771upl_intr(struct usbd_xfer *xfer, void *priv,
772 usbd_status status)
773{
774 struct upl_softc *sc = priv;
775 struct ifnet *ifp = &sc->sc_if;
776 uByte stat;
777
778 DPRINTFN(15,("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
779
780 if (sc->sc_dying)
781 return;
782
783 if (!(ifp->if_flags & IFF_RUNNING))
784 return;
785
786 if (status != USBD_NORMAL_COMPLETION) {
787 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
788 return;
789 }
790 sc->sc_intr_errs++;
791 if (usbd_ratecheck(&sc->sc_rx_notice)) {
792 printf("%s: %u usb errors on intr: %s\n",
793 device_xname(sc->sc_dev), sc->sc_rx_errs,
794 usbd_errstr(status));
795 sc->sc_intr_errs = 0;
796 }
797 if (status == USBD_STALLED)
798 usbd_clear_endpoint_stall_async(sc->sc_ep[UPL_ENDPT_RX]);
799 return;
800 }
801
802 stat = sc->sc_ibuf;
803
804 if (stat == 0)
805 return;
806
807 DPRINTFN(10,("%s: %s: stat=0x%02x\n", device_xname(sc->sc_dev),
808 __func__, stat));
809
810}
811
812Static int
813upl_ioctl(struct ifnet *ifp, u_long command, void *data)
814{
815 struct upl_softc *sc = ifp->if_softc;
816 struct ifaddr *ifa = (struct ifaddr *)data;
817 struct ifreq *ifr = (struct ifreq *)data;
818 int s, error = 0;
819
820 if (sc->sc_dying)
821 return EIO;
822
823 DPRINTFN(5,("%s: %s: cmd=0x%08lx\n",
824 device_xname(sc->sc_dev), __func__, command));
825
826 s = splnet();
827
828 switch(command) {
829 case SIOCINITIFADDR:
830 ifp->if_flags |= IFF_UP;
831 upl_init(sc);
832
833 switch (ifa->ifa_addr->sa_family) {
834#ifdef INET
835 case AF_INET:
836 break;
837#endif /* INET */
838 }
839 break;
840
841 case SIOCSIFMTU:
842 if (ifr->ifr_mtu > UPL_BUFSZ)
843 error = EINVAL;
844 else if ((error = ifioctl_common(ifp, command, data)) == ENETRESET)
845 error = 0;
846 break;
847
848 case SIOCSIFFLAGS:
849 if ((error = ifioctl_common(ifp, command, data)) != 0)
850 break;
851 /* XXX re-use ether_ioctl() */
852 switch (ifp->if_flags & (IFF_UP|IFF_RUNNING)) {
853 case IFF_UP:
854 upl_init(sc);
855 break;
856 case IFF_RUNNING:
857 upl_stop(sc);
858 break;
859 default:
860 break;
861 }
862 break;
863 default:
864 error = ifioctl_common(ifp, command, data);
865 break;
866 }
867
868 splx(s);
869
870 return error;
871}
872
873Static void
874upl_watchdog(struct ifnet *ifp)
875{
876 struct upl_softc *sc = ifp->if_softc;
877
878 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
879
880 if (sc->sc_dying)
881 return;
882
883 ifp->if_oerrors++;
884 printf("%s: watchdog timeout\n", device_xname(sc->sc_dev));
885
886 upl_stop(sc);
887 upl_init(sc);
888
889 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
890 upl_start(ifp);
891}
892
893/*
894 * Stop the adapter and free any mbufs allocated to the
895 * RX and TX lists.
896 */
897Static void
898upl_stop(struct upl_softc *sc)
899{
900 usbd_status err;
901 struct ifnet *ifp;
902 int i;
903
904 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->sc_dev),__func__));
905
906 ifp = &sc->sc_if;
907 ifp->if_timer = 0;
908
909 /* Stop transfers. */
910 if (sc->sc_ep[UPL_ENDPT_RX] != NULL) {
911 err = usbd_abort_pipe(sc->sc_ep[UPL_ENDPT_RX]);
912 if (err) {
913 printf("%s: abort rx pipe failed: %s\n",
914 device_xname(sc->sc_dev), usbd_errstr(err));
915 }
916 }
917
918 if (sc->sc_ep[UPL_ENDPT_TX] != NULL) {
919 err = usbd_abort_pipe(sc->sc_ep[UPL_ENDPT_TX]);
920 if (err) {
921 printf("%s: abort tx pipe failed: %s\n",
922 device_xname(sc->sc_dev), usbd_errstr(err));
923 }
924 }
925
926 if (sc->sc_ep[UPL_ENDPT_INTR] != NULL) {
927 err = usbd_abort_pipe(sc->sc_ep[UPL_ENDPT_INTR]);
928 if (err) {
929 printf("%s: abort intr pipe failed: %s\n",
930 device_xname(sc->sc_dev), usbd_errstr(err));
931 }
932 }
933
934 /* Free RX resources. */
935 for (i = 0; i < UPL_RX_LIST_CNT; i++) {
936 if (sc->sc_cdata.upl_rx_chain[i].upl_mbuf != NULL) {
937 m_freem(sc->sc_cdata.upl_rx_chain[i].upl_mbuf);
938 sc->sc_cdata.upl_rx_chain[i].upl_mbuf = NULL;
939 }
940 }
941
942 /* Free TX resources. */
943 for (i = 0; i < UPL_TX_LIST_CNT; i++) {
944 if (sc->sc_cdata.upl_tx_chain[i].upl_mbuf != NULL) {
945 m_freem(sc->sc_cdata.upl_tx_chain[i].upl_mbuf);
946 sc->sc_cdata.upl_tx_chain[i].upl_mbuf = NULL;
947 }
948 if (sc->sc_cdata.upl_tx_chain[i].upl_xfer != NULL) {
949 usbd_destroy_xfer(sc->sc_cdata.upl_tx_chain[i].upl_xfer);
950 sc->sc_cdata.upl_tx_chain[i].upl_xfer = NULL;
951 }
952 }
953
954 /* Close pipes */
955 if (sc->sc_ep[UPL_ENDPT_RX] != NULL) {
956 err = usbd_close_pipe(sc->sc_ep[UPL_ENDPT_RX]);
957 if (err) {
958 printf("%s: close rx pipe failed: %s\n",
959 device_xname(sc->sc_dev), usbd_errstr(err));
960 }
961 sc->sc_ep[UPL_ENDPT_RX] = NULL;
962 }
963
964 if (sc->sc_ep[UPL_ENDPT_TX] != NULL) {
965 err = usbd_close_pipe(sc->sc_ep[UPL_ENDPT_TX]);
966 if (err) {
967 printf("%s: close tx pipe failed: %s\n",
968 device_xname(sc->sc_dev), usbd_errstr(err));
969 }
970 sc->sc_ep[UPL_ENDPT_TX] = NULL;
971 }
972
973 if (sc->sc_ep[UPL_ENDPT_INTR] != NULL) {
974 err = usbd_close_pipe(sc->sc_ep[UPL_ENDPT_INTR]);
975 if (err) {
976 printf("%s: close intr pipe failed: %s\n",
977 device_xname(sc->sc_dev), usbd_errstr(err));
978 }
979 sc->sc_ep[UPL_ENDPT_INTR] = NULL;
980 }
981
982 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
983}
984
985Static int
986upl_output(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
987 const struct rtentry *rt0)
988{
989 int error;
990
991 DPRINTFN(10,("%s: %s: enter\n",
992 device_xname(((struct upl_softc *)ifp->if_softc)->sc_dev),
993 __func__));
994
995 /*
996 * if the queueing discipline needs packet classification,
997 * do it now.
998 */
999 IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
1000
1001 /*
1002 * Queue message on interface, and start output if interface
1003 * not yet active.
1004 */
1005 error = if_transmit_lock(ifp, m);
1006
1007 return error;
1008}
1009
1010Static void
1011upl_input(struct ifnet *ifp, struct mbuf *m)
1012{
1013#ifdef INET
1014 size_t pktlen = m->m_len;
1015 int s;
1016
1017 s = splnet();
1018 if (__predict_false(!pktq_enqueue(ip_pktq, m, 0))) {
1019 ifp->if_iqdrops++;
1020 m_freem(m);
1021 } else {
1022 ifp->if_ipackets++;
1023 ifp->if_ibytes += pktlen;
1024 }
1025 splx(s);
1026#endif
1027}
1028