![[BACK]](/icons/back.gif){kind=icon}
Return to if_cue.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb|
Return to if_cue.c CVS log | Up to [local] / sys / dev / usb |
1.1 nbrk 1: /* $OpenBSD: if_cue.c,v 1.45 2007/06/14 10:11:15 mbalmer Exp $ */
2: /* $NetBSD: if_cue.c,v 1.40 2002/07/11 21:14:26 augustss Exp $ */
3: /*
4: * Copyright (c) 1997, 1998, 1999, 2000
5: * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: * 3. All advertising materials mentioning features or use of this software
16: * must display the following acknowledgement:
17: * This product includes software developed by Bill Paul.
18: * 4. Neither the name of the author nor the names of any co-contributors
19: * may be used to endorse or promote products derived from this software
20: * without specific prior written permission.
21: *
22: * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
23: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25: * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
26: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32: * THE POSSIBILITY OF SUCH DAMAGE.
33: *
34: * $FreeBSD: src/sys/dev/usb/if_cue.c,v 1.4 2000/01/16 22:45:06 wpaul Exp $
35: */
36:
37: /*
38: * CATC USB-EL1210A USB to ethernet driver. Used in the CATC Netmate
39: * adapters and others.
40: *
41: * Written by Bill Paul <wpaul@ee.columbia.edu>
42: * Electrical Engineering Department
43: * Columbia University, New York City
44: */
45:
46: /*
47: * The CATC USB-EL1210A provides USB ethernet support at 10Mbps. The
48: * RX filter uses a 512-bit multicast hash table, single perfect entry
49: * for the station address, and promiscuous mode. Unlike the ADMtek
50: * and KLSI chips, the CATC ASIC supports read and write combining
51: * mode where multiple packets can be transferred using a single bulk
52: * transaction, which helps performance a great deal.
53: */
54:
55: /*
56: * Ported to NetBSD and somewhat rewritten by Lennart Augustsson.
57: */
58:
59: #include "bpfilter.h"
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/sockio.h>
64: #include <sys/mbuf.h>
65: #include <sys/malloc.h>
66: #include <sys/kernel.h>
67: #include <sys/socket.h>
68: #include <sys/timeout.h>
69: #include <sys/device.h>
70:
71: #include <net/if.h>
72: #include <net/if_dl.h>
73:
74: #if NBPFILTER > 0
75: #include <net/bpf.h>
76: #endif
77:
78: #ifdef INET
79: #include <netinet/in.h>
80: #include <netinet/in_systm.h>
81: #include <netinet/in_var.h>
82: #include <netinet/ip.h>
83: #include <netinet/if_ether.h>
84: #endif
85:
86: #include <dev/usb/usb.h>
87: #include <dev/usb/usbdi.h>
88: #include <dev/usb/usbdi_util.h>
89: #include <dev/usb/usbdevs.h>
90:
91: #include <dev/usb/if_cuereg.h>
92:
93: #ifdef CUE_DEBUG
94: #define DPRINTF(x) do { if (cuedebug) printf x; } while (0)
95: #define DPRINTFN(n,x) do { if (cuedebug >= (n)) printf x; } while (0)
96: int cuedebug = 0;
97: #else
98: #define DPRINTF(x)
99: #define DPRINTFN(n,x)
100: #endif
101:
102: /*
103: * Various supported device vendors/products.
104: */
105: struct usb_devno cue_devs[] = {
106: { USB_VENDOR_CATC, USB_PRODUCT_CATC_NETMATE },
107: { USB_VENDOR_CATC, USB_PRODUCT_CATC_NETMATE2 },
108: { USB_VENDOR_SMARTBRIDGES, USB_PRODUCT_SMARTBRIDGES_SMARTLINK },
109: /* Belkin F5U111 adapter covered by NETMATE entry */
110: };
111: #define cue_lookup(v, p) (usb_lookup(cue_devs, v, p))
112:
113: int cue_match(struct device *, void *, void *);
114: void cue_attach(struct device *, struct device *, void *);
115: int cue_detach(struct device *, int);
116: int cue_activate(struct device *, enum devact);
117:
118: struct cfdriver cue_cd = {
119: NULL, "cue", DV_IFNET
120: };
121:
122: const struct cfattach cue_ca = {
123: sizeof(struct cue_softc),
124: cue_match,
125: cue_attach,
126: cue_detach,
127: cue_activate,
128: };
129:
130: int cue_open_pipes(struct cue_softc *);
131: int cue_tx_list_init(struct cue_softc *);
132: int cue_rx_list_init(struct cue_softc *);
133: int cue_newbuf(struct cue_softc *, struct cue_chain *, struct mbuf *);
134: int cue_send(struct cue_softc *, struct mbuf *, int);
135: void cue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
136: void cue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
137: void cue_tick(void *);
138: void cue_tick_task(void *);
139: void cue_start(struct ifnet *);
140: int cue_ioctl(struct ifnet *, u_long, caddr_t);
141: void cue_init(void *);
142: void cue_stop(struct cue_softc *);
143: void cue_watchdog(struct ifnet *);
144:
145: void cue_setmulti(struct cue_softc *);
146: void cue_reset(struct cue_softc *);
147:
148: int cue_csr_read_1(struct cue_softc *, int);
149: int cue_csr_write_1(struct cue_softc *, int, int);
150: int cue_csr_read_2(struct cue_softc *, int);
151: #if 0
152: int cue_csr_write_2(struct cue_softc *, int, int);
153: #endif
154: int cue_mem(struct cue_softc *, int, int, void *, int);
155: int cue_getmac(struct cue_softc *, void *);
156:
157: #define CUE_SETBIT(sc, reg, x) \
158: cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) | (x))
159:
160: #define CUE_CLRBIT(sc, reg, x) \
161: cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) & ~(x))
162:
163: int
164: cue_csr_read_1(struct cue_softc *sc, int reg)
165: {
166: usb_device_request_t req;
167: usbd_status err;
168: u_int8_t val = 0;
169:
170: if (sc->cue_dying)
171: return (0);
172:
173: req.bmRequestType = UT_READ_VENDOR_DEVICE;
174: req.bRequest = CUE_CMD_READREG;
175: USETW(req.wValue, 0);
176: USETW(req.wIndex, reg);
177: USETW(req.wLength, 1);
178:
179: err = usbd_do_request(sc->cue_udev, &req, &val);
180:
181: if (err) {
182: DPRINTF(("%s: cue_csr_read_1: reg=0x%x err=%s\n",
183: sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
184: return (0);
185: }
186:
187: DPRINTFN(10,("%s: cue_csr_read_1 reg=0x%x val=0x%x\n",
188: sc->cue_dev.dv_xname, reg, val));
189:
190: return (val);
191: }
192:
193: int
194: cue_csr_read_2(struct cue_softc *sc, int reg)
195: {
196: usb_device_request_t req;
197: usbd_status err;
198: uWord val;
199:
200: if (sc->cue_dying)
201: return (0);
202:
203: req.bmRequestType = UT_READ_VENDOR_DEVICE;
204: req.bRequest = CUE_CMD_READREG;
205: USETW(req.wValue, 0);
206: USETW(req.wIndex, reg);
207: USETW(req.wLength, 2);
208:
209: err = usbd_do_request(sc->cue_udev, &req, &val);
210:
211: DPRINTFN(10,("%s: cue_csr_read_2 reg=0x%x val=0x%x\n",
212: sc->cue_dev.dv_xname, reg, UGETW(val)));
213:
214: if (err) {
215: DPRINTF(("%s: cue_csr_read_2: reg=0x%x err=%s\n",
216: sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
217: return (0);
218: }
219:
220: return (UGETW(val));
221: }
222:
223: int
224: cue_csr_write_1(struct cue_softc *sc, int reg, int val)
225: {
226: usb_device_request_t req;
227: usbd_status err;
228:
229: if (sc->cue_dying)
230: return (0);
231:
232: DPRINTFN(10,("%s: cue_csr_write_1 reg=0x%x val=0x%x\n",
233: sc->cue_dev.dv_xname, reg, val));
234:
235: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
236: req.bRequest = CUE_CMD_WRITEREG;
237: USETW(req.wValue, val);
238: USETW(req.wIndex, reg);
239: USETW(req.wLength, 0);
240:
241: err = usbd_do_request(sc->cue_udev, &req, NULL);
242:
243: if (err) {
244: DPRINTF(("%s: cue_csr_write_1: reg=0x%x err=%s\n",
245: sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
246: return (-1);
247: }
248:
249: DPRINTFN(20,("%s: cue_csr_write_1, after reg=0x%x val=0x%x\n",
250: sc->cue_dev.dv_xname, reg, cue_csr_read_1(sc, reg)));
251:
252: return (0);
253: }
254:
255: #if 0
256: int
257: cue_csr_write_2(struct cue_softc *sc, int reg, int aval)
258: {
259: usb_device_request_t req;
260: usbd_status err;
261: uWord val;
262: int s;
263:
264: if (sc->cue_dying)
265: return (0);
266:
267: DPRINTFN(10,("%s: cue_csr_write_2 reg=0x%x val=0x%x\n",
268: sc->cue_dev.dv_xname, reg, aval));
269:
270: USETW(val, aval);
271: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
272: req.bRequest = CUE_CMD_WRITEREG;
273: USETW(req.wValue, val);
274: USETW(req.wIndex, reg);
275: USETW(req.wLength, 0);
276:
277: err = usbd_do_request(sc->cue_udev, &req, NULL);
278:
279: if (err) {
280: DPRINTF(("%s: cue_csr_write_2: reg=0x%x err=%s\n",
281: sc->cue_dev.dv_xname, reg, usbd_errstr(err)));
282: return (-1);
283: }
284:
285: return (0);
286: }
287: #endif
288:
289: int
290: cue_mem(struct cue_softc *sc, int cmd, int addr, void *buf, int len)
291: {
292: usb_device_request_t req;
293: usbd_status err;
294:
295: DPRINTFN(10,("%s: cue_mem cmd=0x%x addr=0x%x len=%d\n",
296: sc->cue_dev.dv_xname, cmd, addr, len));
297:
298: if (cmd == CUE_CMD_READSRAM)
299: req.bmRequestType = UT_READ_VENDOR_DEVICE;
300: else
301: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
302: req.bRequest = cmd;
303: USETW(req.wValue, 0);
304: USETW(req.wIndex, addr);
305: USETW(req.wLength, len);
306:
307: err = usbd_do_request(sc->cue_udev, &req, buf);
308:
309: if (err) {
310: DPRINTF(("%s: cue_csr_mem: addr=0x%x err=%s\n",
311: sc->cue_dev.dv_xname, addr, usbd_errstr(err)));
312: return (-1);
313: }
314:
315: return (0);
316: }
317:
318: int
319: cue_getmac(struct cue_softc *sc, void *buf)
320: {
321: usb_device_request_t req;
322: usbd_status err;
323:
324: DPRINTFN(10,("%s: cue_getmac\n", sc->cue_dev.dv_xname));
325:
326: req.bmRequestType = UT_READ_VENDOR_DEVICE;
327: req.bRequest = CUE_CMD_GET_MACADDR;
328: USETW(req.wValue, 0);
329: USETW(req.wIndex, 0);
330: USETW(req.wLength, ETHER_ADDR_LEN);
331:
332: err = usbd_do_request(sc->cue_udev, &req, buf);
333:
334: if (err) {
335: printf("%s: read MAC address failed\n",
336: sc->cue_dev.dv_xname);
337: return (-1);
338: }
339:
340: return (0);
341: }
342:
343: #define CUE_BITS 9
344:
345: void
346: cue_setmulti(struct cue_softc *sc)
347: {
348: struct ifnet *ifp;
349: struct ether_multi *enm;
350: struct ether_multistep step;
351: u_int32_t h, i;
352:
353: ifp = GET_IFP(sc);
354:
355: DPRINTFN(2,("%s: cue_setmulti if_flags=0x%x\n",
356: sc->cue_dev.dv_xname, ifp->if_flags));
357:
358: if (ifp->if_flags & IFF_PROMISC) {
359: allmulti:
360: ifp->if_flags |= IFF_ALLMULTI;
361: for (i = 0; i < CUE_MCAST_TABLE_LEN; i++)
362: sc->cue_mctab[i] = 0xFF;
363: cue_mem(sc, CUE_CMD_WRITESRAM, CUE_MCAST_TABLE_ADDR,
364: &sc->cue_mctab, CUE_MCAST_TABLE_LEN);
365: return;
366: }
367:
368: /* first, zot all the existing hash bits */
369: for (i = 0; i < CUE_MCAST_TABLE_LEN; i++)
370: sc->cue_mctab[i] = 0;
371:
372: /* now program new ones */
373: ETHER_FIRST_MULTI(step, &sc->arpcom, enm);
374: while (enm != NULL) {
375: if (memcmp(enm->enm_addrlo,
376: enm->enm_addrhi, ETHER_ADDR_LEN) != 0)
377: goto allmulti;
378:
379: h = ether_crc32_le(enm->enm_addrlo, ETHER_ADDR_LEN) &
380: ((1 << CUE_BITS) - 1);
381: sc->cue_mctab[h >> 3] |= 1 << (h & 0x7);
382: ETHER_NEXT_MULTI(step, enm);
383: }
384:
385: ifp->if_flags &= ~IFF_ALLMULTI;
386:
387: /*
388: * Also include the broadcast address in the filter
389: * so we can receive broadcast frames.
390: */
391: if (ifp->if_flags & IFF_BROADCAST) {
392: h = ether_crc32_le(etherbroadcastaddr, ETHER_ADDR_LEN) &
393: ((1 << CUE_BITS) - 1);
394: sc->cue_mctab[h >> 3] |= 1 << (h & 0x7);
395: }
396:
397: cue_mem(sc, CUE_CMD_WRITESRAM, CUE_MCAST_TABLE_ADDR,
398: &sc->cue_mctab, CUE_MCAST_TABLE_LEN);
399: }
400:
401: void
402: cue_reset(struct cue_softc *sc)
403: {
404: usb_device_request_t req;
405: usbd_status err;
406:
407: DPRINTFN(2,("%s: cue_reset\n", sc->cue_dev.dv_xname));
408:
409: if (sc->cue_dying)
410: return;
411:
412: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
413: req.bRequest = CUE_CMD_RESET;
414: USETW(req.wValue, 0);
415: USETW(req.wIndex, 0);
416: USETW(req.wLength, 0);
417:
418: err = usbd_do_request(sc->cue_udev, &req, NULL);
419:
420: if (err)
421: printf("%s: reset failed\n", sc->cue_dev.dv_xname);
422:
423: /* Wait a little while for the chip to get its brains in order. */
424: usbd_delay_ms(sc->cue_udev, 1);
425: }
426:
427: /*
428: * Probe for a CATC chip.
429: */
430: int
431: cue_match(struct device *parent, void *match, void *aux)
432: {
433: struct usb_attach_arg *uaa = aux;
434:
435: if (uaa->iface != NULL)
436: return (UMATCH_NONE);
437:
438: return (cue_lookup(uaa->vendor, uaa->product) != NULL ?
439: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
440: }
441:
442: /*
443: * Attach the interface. Allocate softc structures, do ifmedia
444: * setup and ethernet/BPF attach.
445: */
446: void
447: cue_attach(struct device *parent, struct device *self, void *aux)
448: {
449: struct cue_softc *sc = (struct cue_softc *)self;
450: struct usb_attach_arg *uaa = aux;
451: char *devinfop;
452: int s;
453: u_char eaddr[ETHER_ADDR_LEN];
454: usbd_device_handle dev = uaa->device;
455: usbd_interface_handle iface;
456: usbd_status err;
457: struct ifnet *ifp;
458: usb_interface_descriptor_t *id;
459: usb_endpoint_descriptor_t *ed;
460: int i;
461:
462: DPRINTFN(5,(" : cue_attach: sc=%p, dev=%p", sc, dev));
463:
464: devinfop = usbd_devinfo_alloc(dev, 0);
465: printf("\n%s: %s\n", sc->cue_dev.dv_xname, devinfop);
466: usbd_devinfo_free(devinfop);
467:
468: err = usbd_set_config_no(dev, CUE_CONFIG_NO, 1);
469: if (err) {
470: printf("%s: setting config no failed\n",
471: sc->cue_dev.dv_xname);
472: return;
473: }
474:
475: sc->cue_udev = dev;
476: sc->cue_product = uaa->product;
477: sc->cue_vendor = uaa->vendor;
478:
479: usb_init_task(&sc->cue_tick_task, cue_tick_task, sc);
480: usb_init_task(&sc->cue_stop_task, (void (*)(void *))cue_stop, sc);
481:
482: err = usbd_device2interface_handle(dev, CUE_IFACE_IDX, &iface);
483: if (err) {
484: printf("%s: getting interface handle failed\n",
485: sc->cue_dev.dv_xname);
486: return;
487: }
488:
489: sc->cue_iface = iface;
490: id = usbd_get_interface_descriptor(iface);
491:
492: /* Find endpoints. */
493: for (i = 0; i < id->bNumEndpoints; i++) {
494: ed = usbd_interface2endpoint_descriptor(iface, i);
495: if (ed == NULL) {
496: printf("%s: couldn't get ep %d\n",
497: sc->cue_dev.dv_xname, i);
498: return;
499: }
500: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
501: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
502: sc->cue_ed[CUE_ENDPT_RX] = ed->bEndpointAddress;
503: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
504: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
505: sc->cue_ed[CUE_ENDPT_TX] = ed->bEndpointAddress;
506: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
507: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
508: sc->cue_ed[CUE_ENDPT_INTR] = ed->bEndpointAddress;
509: }
510: }
511:
512: #if 0
513: /* Reset the adapter. */
514: cue_reset(sc);
515: #endif
516: /*
517: * Get station address.
518: */
519: cue_getmac(sc, &eaddr);
520:
521: s = splnet();
522:
523: /*
524: * A CATC chip was detected. Inform the world.
525: */
526: printf("%s: address %s\n", sc->cue_dev.dv_xname,
527: ether_sprintf(eaddr));
528:
529: bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
530:
531: /* Initialize interface info.*/
532: ifp = GET_IFP(sc);
533: ifp->if_softc = sc;
534: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
535: ifp->if_ioctl = cue_ioctl;
536: ifp->if_start = cue_start;
537: ifp->if_watchdog = cue_watchdog;
538: strlcpy(ifp->if_xname, sc->cue_dev.dv_xname, IFNAMSIZ);
539:
540: IFQ_SET_READY(&ifp->if_snd);
541:
542: /* Attach the interface. */
543: if_attach(ifp);
544: ether_ifattach(ifp);
545:
546: timeout_set(&sc->cue_stat_ch, NULL, NULL);
547:
548: sc->cue_attached = 1;
549: splx(s);
550:
551: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->cue_udev,
552: &sc->cue_dev);
553: }
554:
555: int
556: cue_detach(struct device *self, int flags)
557: {
558: struct cue_softc *sc = (struct cue_softc *)self;
559: struct ifnet *ifp = GET_IFP(sc);
560: int s;
561:
562: DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
563:
564: timeout_del(&sc->cue_stat_ch);
565: /*
566: * Remove any pending task. It cannot be executing because it run
567: * in the same thread as detach.
568: */
569: usb_rem_task(sc->cue_udev, &sc->cue_tick_task);
570: usb_rem_task(sc->cue_udev, &sc->cue_stop_task);
571:
572: if (!sc->cue_attached) {
573: /* Detached before attached finished, so just bail out. */
574: return (0);
575: }
576:
577: s = splusb();
578:
579: if (ifp->if_flags & IFF_RUNNING)
580: cue_stop(sc);
581:
582: ether_ifdetach(ifp);
583:
584: if_detach(ifp);
585:
586: #ifdef DIAGNOSTIC
587: if (sc->cue_ep[CUE_ENDPT_TX] != NULL ||
588: sc->cue_ep[CUE_ENDPT_RX] != NULL ||
589: sc->cue_ep[CUE_ENDPT_INTR] != NULL)
590: printf("%s: detach has active endpoints\n",
591: sc->cue_dev.dv_xname);
592: #endif
593:
594: sc->cue_attached = 0;
595: splx(s);
596:
597: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->cue_udev,
598: &sc->cue_dev);
599:
600: return (0);
601: }
602:
603: int
604: cue_activate(struct device *self, enum devact act)
605: {
606: struct cue_softc *sc = (struct cue_softc *)self;
607:
608: DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
609:
610: switch (act) {
611: case DVACT_ACTIVATE:
612: break;
613:
614: case DVACT_DEACTIVATE:
615: sc->cue_dying = 1;
616: break;
617: }
618: return (0);
619: }
620:
621: /*
622: * Initialize an RX descriptor and attach an MBUF cluster.
623: */
624: int
625: cue_newbuf(struct cue_softc *sc, struct cue_chain *c, struct mbuf *m)
626: {
627: struct mbuf *m_new = NULL;
628:
629: if (m == NULL) {
630: MGETHDR(m_new, M_DONTWAIT, MT_DATA);
631: if (m_new == NULL) {
632: printf("%s: no memory for rx list "
633: "-- packet dropped!\n", sc->cue_dev.dv_xname);
634: return (ENOBUFS);
635: }
636:
637: MCLGET(m_new, M_DONTWAIT);
638: if (!(m_new->m_flags & M_EXT)) {
639: printf("%s: no memory for rx list "
640: "-- packet dropped!\n", sc->cue_dev.dv_xname);
641: m_freem(m_new);
642: return (ENOBUFS);
643: }
644: m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
645: } else {
646: m_new = m;
647: m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
648: m_new->m_data = m_new->m_ext.ext_buf;
649: }
650:
651: m_adj(m_new, ETHER_ALIGN);
652: c->cue_mbuf = m_new;
653:
654: return (0);
655: }
656:
657: int
658: cue_rx_list_init(struct cue_softc *sc)
659: {
660: struct cue_cdata *cd;
661: struct cue_chain *c;
662: int i;
663:
664: cd = &sc->cue_cdata;
665: for (i = 0; i < CUE_RX_LIST_CNT; i++) {
666: c = &cd->cue_rx_chain[i];
667: c->cue_sc = sc;
668: c->cue_idx = i;
669: if (cue_newbuf(sc, c, NULL) == ENOBUFS)
670: return (ENOBUFS);
671: if (c->cue_xfer == NULL) {
672: c->cue_xfer = usbd_alloc_xfer(sc->cue_udev);
673: if (c->cue_xfer == NULL)
674: return (ENOBUFS);
675: c->cue_buf = usbd_alloc_buffer(c->cue_xfer, CUE_BUFSZ);
676: if (c->cue_buf == NULL) {
677: usbd_free_xfer(c->cue_xfer);
678: return (ENOBUFS);
679: }
680: }
681: }
682:
683: return (0);
684: }
685:
686: int
687: cue_tx_list_init(struct cue_softc *sc)
688: {
689: struct cue_cdata *cd;
690: struct cue_chain *c;
691: int i;
692:
693: cd = &sc->cue_cdata;
694: for (i = 0; i < CUE_TX_LIST_CNT; i++) {
695: c = &cd->cue_tx_chain[i];
696: c->cue_sc = sc;
697: c->cue_idx = i;
698: c->cue_mbuf = NULL;
699: if (c->cue_xfer == NULL) {
700: c->cue_xfer = usbd_alloc_xfer(sc->cue_udev);
701: if (c->cue_xfer == NULL)
702: return (ENOBUFS);
703: c->cue_buf = usbd_alloc_buffer(c->cue_xfer, CUE_BUFSZ);
704: if (c->cue_buf == NULL) {
705: usbd_free_xfer(c->cue_xfer);
706: return (ENOBUFS);
707: }
708: }
709: }
710:
711: return (0);
712: }
713:
714: /*
715: * A frame has been uploaded: pass the resulting mbuf chain up to
716: * the higher level protocols.
717: */
718: void
719: cue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
720: {
721: struct cue_chain *c = priv;
722: struct cue_softc *sc = c->cue_sc;
723: struct ifnet *ifp = GET_IFP(sc);
724: struct mbuf *m;
725: int total_len = 0;
726: u_int16_t len;
727: int s;
728:
729: DPRINTFN(10,("%s: %s: enter status=%d\n", sc->cue_dev.dv_xname,
730: __func__, status));
731:
732: if (sc->cue_dying)
733: return;
734:
735: if (!(ifp->if_flags & IFF_RUNNING))
736: return;
737:
738: if (status != USBD_NORMAL_COMPLETION) {
739: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
740: return;
741: sc->cue_rx_errs++;
742: if (usbd_ratecheck(&sc->cue_rx_notice)) {
743: printf("%s: %u usb errors on rx: %s\n",
744: sc->cue_dev.dv_xname, sc->cue_rx_errs,
745: usbd_errstr(status));
746: sc->cue_rx_errs = 0;
747: }
748: if (status == USBD_STALLED)
749: usbd_clear_endpoint_stall_async(sc->cue_ep[CUE_ENDPT_RX]);
750: goto done;
751: }
752:
753: usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
754:
755: memcpy(mtod(c->cue_mbuf, char *), c->cue_buf, total_len);
756:
757: m = c->cue_mbuf;
758: len = UGETW(mtod(m, u_int8_t *));
759:
760: /* No errors; receive the packet. */
761: total_len = len;
762:
763: if (len < sizeof(struct ether_header)) {
764: ifp->if_ierrors++;
765: goto done;
766: }
767:
768: ifp->if_ipackets++;
769: m_adj(m, sizeof(u_int16_t));
770: m->m_pkthdr.len = m->m_len = total_len;
771:
772: m->m_pkthdr.rcvif = ifp;
773:
774: s = splnet();
775:
776: /* XXX ugly */
777: if (cue_newbuf(sc, c, NULL) == ENOBUFS) {
778: ifp->if_ierrors++;
779: goto done1;
780: }
781:
782: #if NBPFILTER > 0
783: /*
784: * Handle BPF listeners. Let the BPF user see the packet, but
785: * don't pass it up to the ether_input() layer unless it's
786: * a broadcast packet, multicast packet, matches our ethernet
787: * address or the interface is in promiscuous mode.
788: */
789: if (ifp->if_bpf)
790: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
791: #endif
792:
793: DPRINTFN(10,("%s: %s: deliver %d\n", sc->cue_dev.dv_xname,
794: __func__, m->m_len));
795: ether_input_mbuf(ifp, m);
796: done1:
797: splx(s);
798:
799: done:
800: /* Setup new transfer. */
801: usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
802: c, c->cue_buf, CUE_BUFSZ, USBD_SHORT_XFER_OK | USBD_NO_COPY,
803: USBD_NO_TIMEOUT, cue_rxeof);
804: usbd_transfer(c->cue_xfer);
805:
806: DPRINTFN(10,("%s: %s: start rx\n", sc->cue_dev.dv_xname,
807: __func__));
808: }
809:
810: /*
811: * A frame was downloaded to the chip. It's safe for us to clean up
812: * the list buffers.
813: */
814: void
815: cue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
816: {
817: struct cue_chain *c = priv;
818: struct cue_softc *sc = c->cue_sc;
819: struct ifnet *ifp = GET_IFP(sc);
820: int s;
821:
822: if (sc->cue_dying)
823: return;
824:
825: s = splnet();
826:
827: DPRINTFN(10,("%s: %s: enter status=%d\n", sc->cue_dev.dv_xname,
828: __func__, status));
829:
830: ifp->if_timer = 0;
831: ifp->if_flags &= ~IFF_OACTIVE;
832:
833: if (status != USBD_NORMAL_COMPLETION) {
834: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
835: splx(s);
836: return;
837: }
838: ifp->if_oerrors++;
839: printf("%s: usb error on tx: %s\n", sc->cue_dev.dv_xname,
840: usbd_errstr(status));
841: if (status == USBD_STALLED)
842: usbd_clear_endpoint_stall_async(sc->cue_ep[CUE_ENDPT_TX]);
843: splx(s);
844: return;
845: }
846:
847: ifp->if_opackets++;
848:
849: m_freem(c->cue_mbuf);
850: c->cue_mbuf = NULL;
851:
852: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
853: cue_start(ifp);
854:
855: splx(s);
856: }
857:
858: void
859: cue_tick(void *xsc)
860: {
861: struct cue_softc *sc = xsc;
862:
863: if (sc == NULL)
864: return;
865:
866: if (sc->cue_dying)
867: return;
868:
869: DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
870:
871: /* Perform statistics update in process context. */
872: usb_add_task(sc->cue_udev, &sc->cue_tick_task);
873: }
874:
875: void
876: cue_tick_task(void *xsc)
877: {
878: struct cue_softc *sc = xsc;
879: struct ifnet *ifp;
880:
881: if (sc->cue_dying)
882: return;
883:
884: DPRINTFN(2,("%s: %s: enter\n", sc->cue_dev.dv_xname, __func__));
885:
886: ifp = GET_IFP(sc);
887:
888: ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_SINGLECOLL);
889: ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_MULTICOLL);
890: ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_EXCESSCOLL);
891:
892: if (cue_csr_read_2(sc, CUE_RX_FRAMEERR))
893: ifp->if_ierrors++;
894: }
895:
896: int
897: cue_send(struct cue_softc *sc, struct mbuf *m, int idx)
898: {
899: int total_len;
900: struct cue_chain *c;
901: usbd_status err;
902:
903: c = &sc->cue_cdata.cue_tx_chain[idx];
904:
905: /*
906: * Copy the mbuf data into a contiguous buffer, leaving two
907: * bytes at the beginning to hold the frame length.
908: */
909: m_copydata(m, 0, m->m_pkthdr.len, c->cue_buf + 2);
910: c->cue_mbuf = m;
911:
912: total_len = m->m_pkthdr.len + 2;
913:
914: DPRINTFN(10,("%s: %s: total_len=%d\n",
915: sc->cue_dev.dv_xname, __func__, total_len));
916:
917: /* The first two bytes are the frame length */
918: c->cue_buf[0] = (u_int8_t)m->m_pkthdr.len;
919: c->cue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8);
920:
921: /* XXX 10000 */
922: usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_TX],
923: c, c->cue_buf, total_len, USBD_NO_COPY, 10000, cue_txeof);
924:
925: /* Transmit */
926: err = usbd_transfer(c->cue_xfer);
927: if (err != USBD_IN_PROGRESS) {
928: printf("%s: cue_send error=%s\n", sc->cue_dev.dv_xname,
929: usbd_errstr(err));
930: /* Stop the interface from process context. */
931: usb_add_task(sc->cue_udev, &sc->cue_stop_task);
932: return (EIO);
933: }
934:
935: sc->cue_cdata.cue_tx_cnt++;
936:
937: return (0);
938: }
939:
940: void
941: cue_start(struct ifnet *ifp)
942: {
943: struct cue_softc *sc = ifp->if_softc;
944: struct mbuf *m_head = NULL;
945:
946: if (sc->cue_dying)
947: return;
948:
949: DPRINTFN(10,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
950:
951: if (ifp->if_flags & IFF_OACTIVE)
952: return;
953:
954: IFQ_POLL(&ifp->if_snd, m_head);
955: if (m_head == NULL)
956: return;
957:
958: if (cue_send(sc, m_head, 0)) {
959: ifp->if_flags |= IFF_OACTIVE;
960: return;
961: }
962:
963: IFQ_DEQUEUE(&ifp->if_snd, m_head);
964:
965: #if NBPFILTER > 0
966: /*
967: * If there's a BPF listener, bounce a copy of this frame
968: * to him.
969: */
970: if (ifp->if_bpf)
971: bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
972: #endif
973:
974: ifp->if_flags |= IFF_OACTIVE;
975:
976: /*
977: * Set a timeout in case the chip goes out to lunch.
978: */
979: ifp->if_timer = 5;
980: }
981:
982: void
983: cue_init(void *xsc)
984: {
985: struct cue_softc *sc = xsc;
986: struct ifnet *ifp = GET_IFP(sc);
987: int i, s, ctl;
988: u_char *eaddr;
989:
990: if (sc->cue_dying)
991: return;
992:
993: DPRINTFN(10,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
994:
995: if (ifp->if_flags & IFF_RUNNING)
996: return;
997:
998: s = splnet();
999:
1000: /*
1001: * Cancel pending I/O and free all RX/TX buffers.
1002: */
1003: #if 1
1004: cue_reset(sc);
1005: #endif
1006:
1007: /* Set advanced operation modes. */
1008: cue_csr_write_1(sc, CUE_ADVANCED_OPMODES,
1009: CUE_AOP_EMBED_RXLEN | 0x03); /* 1 wait state */
1010:
1011: eaddr = sc->arpcom.ac_enaddr;
1012: /* Set MAC address */
1013: for (i = 0; i < ETHER_ADDR_LEN; i++)
1014: cue_csr_write_1(sc, CUE_PAR0 - i, eaddr[i]);
1015:
1016: /* Enable RX logic. */
1017: ctl = CUE_ETHCTL_RX_ON | CUE_ETHCTL_MCAST_ON;
1018: if (ifp->if_flags & IFF_PROMISC)
1019: ctl |= CUE_ETHCTL_PROMISC;
1020: cue_csr_write_1(sc, CUE_ETHCTL, ctl);
1021:
1022: /* Init TX ring. */
1023: if (cue_tx_list_init(sc) == ENOBUFS) {
1024: printf("%s: tx list init failed\n", sc->cue_dev.dv_xname);
1025: splx(s);
1026: return;
1027: }
1028:
1029: /* Init RX ring. */
1030: if (cue_rx_list_init(sc) == ENOBUFS) {
1031: printf("%s: rx list init failed\n", sc->cue_dev.dv_xname);
1032: splx(s);
1033: return;
1034: }
1035:
1036: /* Load the multicast filter. */
1037: cue_setmulti(sc);
1038:
1039: /*
1040: * Set the number of RX and TX buffers that we want
1041: * to reserve inside the ASIC.
1042: */
1043: cue_csr_write_1(sc, CUE_RX_BUFPKTS, CUE_RX_FRAMES);
1044: cue_csr_write_1(sc, CUE_TX_BUFPKTS, CUE_TX_FRAMES);
1045:
1046: /* Set advanced operation modes. */
1047: cue_csr_write_1(sc, CUE_ADVANCED_OPMODES,
1048: CUE_AOP_EMBED_RXLEN | 0x01); /* 1 wait state */
1049:
1050: /* Program the LED operation. */
1051: cue_csr_write_1(sc, CUE_LEDCTL, CUE_LEDCTL_FOLLOW_LINK);
1052:
1053: if (sc->cue_ep[CUE_ENDPT_RX] == NULL) {
1054: if (cue_open_pipes(sc)) {
1055: splx(s);
1056: return;
1057: }
1058: }
1059:
1060: ifp->if_flags |= IFF_RUNNING;
1061: ifp->if_flags &= ~IFF_OACTIVE;
1062:
1063: splx(s);
1064:
1065: timeout_del(&sc->cue_stat_ch);
1066: timeout_set(&sc->cue_stat_ch, cue_tick, sc);
1067: timeout_add(&sc->cue_stat_ch, hz);
1068: }
1069:
1070: int
1071: cue_open_pipes(struct cue_softc *sc)
1072: {
1073: struct cue_chain *c;
1074: usbd_status err;
1075: int i;
1076:
1077: /* Open RX and TX pipes. */
1078: err = usbd_open_pipe(sc->cue_iface, sc->cue_ed[CUE_ENDPT_RX],
1079: USBD_EXCLUSIVE_USE, &sc->cue_ep[CUE_ENDPT_RX]);
1080: if (err) {
1081: printf("%s: open rx pipe failed: %s\n",
1082: sc->cue_dev.dv_xname, usbd_errstr(err));
1083: return (EIO);
1084: }
1085: err = usbd_open_pipe(sc->cue_iface, sc->cue_ed[CUE_ENDPT_TX],
1086: USBD_EXCLUSIVE_USE, &sc->cue_ep[CUE_ENDPT_TX]);
1087: if (err) {
1088: printf("%s: open tx pipe failed: %s\n",
1089: sc->cue_dev.dv_xname, usbd_errstr(err));
1090: return (EIO);
1091: }
1092:
1093: /* Start up the receive pipe. */
1094: for (i = 0; i < CUE_RX_LIST_CNT; i++) {
1095: c = &sc->cue_cdata.cue_rx_chain[i];
1096: usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
1097: c, c->cue_buf, CUE_BUFSZ,
1098: USBD_SHORT_XFER_OK | USBD_NO_COPY, USBD_NO_TIMEOUT,
1099: cue_rxeof);
1100: usbd_transfer(c->cue_xfer);
1101: }
1102:
1103: return (0);
1104: }
1105:
1106: int
1107: cue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
1108: {
1109: struct cue_softc *sc = ifp->if_softc;
1110: struct ifaddr *ifa = (struct ifaddr *)data;
1111: struct ifreq *ifr = (struct ifreq *)data;
1112: int s, error = 0;
1113:
1114: if (sc->cue_dying)
1115: return (EIO);
1116:
1117: s = splnet();
1118:
1119: switch(command) {
1120: case SIOCSIFADDR:
1121: ifp->if_flags |= IFF_UP;
1122: cue_init(sc);
1123:
1124: switch (ifa->ifa_addr->sa_family) {
1125: #ifdef INET
1126: case AF_INET:
1127: arp_ifinit(&sc->arpcom, ifa);
1128: break;
1129: #endif /* INET */
1130: }
1131: break;
1132:
1133: case SIOCSIFMTU:
1134: if (ifr->ifr_mtu > ETHERMTU)
1135: error = EINVAL;
1136: else
1137: ifp->if_mtu = ifr->ifr_mtu;
1138: break;
1139:
1140: case SIOCSIFFLAGS:
1141: if (ifp->if_flags & IFF_UP) {
1142: if (ifp->if_flags & IFF_RUNNING &&
1143: ifp->if_flags & IFF_PROMISC &&
1144: !(sc->cue_if_flags & IFF_PROMISC)) {
1145: CUE_SETBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
1146: cue_setmulti(sc);
1147: } else if (ifp->if_flags & IFF_RUNNING &&
1148: !(ifp->if_flags & IFF_PROMISC) &&
1149: sc->cue_if_flags & IFF_PROMISC) {
1150: CUE_CLRBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
1151: cue_setmulti(sc);
1152: } else if (!(ifp->if_flags & IFF_RUNNING))
1153: cue_init(sc);
1154: } else {
1155: if (ifp->if_flags & IFF_RUNNING)
1156: cue_stop(sc);
1157: }
1158: sc->cue_if_flags = ifp->if_flags;
1159: error = 0;
1160: break;
1161: case SIOCADDMULTI:
1162: case SIOCDELMULTI:
1163: error = (command == SIOCADDMULTI) ?
1164: ether_addmulti(ifr, &sc->arpcom) :
1165: ether_delmulti(ifr, &sc->arpcom);
1166:
1167: if (error == ENETRESET) {
1168: /*
1169: * Multicast list has changed; set the hardware
1170: * filter accordingly.
1171: */
1172: if (ifp->if_flags & IFF_RUNNING)
1173: cue_setmulti(sc);
1174: error = 0;
1175: }
1176: break;
1177: default:
1178: error = EINVAL;
1179: break;
1180: }
1181:
1182: splx(s);
1183:
1184: return (error);
1185: }
1186:
1187: void
1188: cue_watchdog(struct ifnet *ifp)
1189: {
1190: struct cue_softc *sc = ifp->if_softc;
1191: struct cue_chain *c;
1192: usbd_status stat;
1193: int s;
1194:
1195: DPRINTFN(5,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
1196:
1197: if (sc->cue_dying)
1198: return;
1199:
1200: ifp->if_oerrors++;
1201: printf("%s: watchdog timeout\n", sc->cue_dev.dv_xname);
1202:
1203: s = splusb();
1204: c = &sc->cue_cdata.cue_tx_chain[0];
1205: usbd_get_xfer_status(c->cue_xfer, NULL, NULL, NULL, &stat);
1206: cue_txeof(c->cue_xfer, c, stat);
1207:
1208: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1209: cue_start(ifp);
1210: splx(s);
1211: }
1212:
1213: /*
1214: * Stop the adapter and free any mbufs allocated to the
1215: * RX and TX lists.
1216: */
1217: void
1218: cue_stop(struct cue_softc *sc)
1219: {
1220: usbd_status err;
1221: struct ifnet *ifp;
1222: int i;
1223:
1224: DPRINTFN(10,("%s: %s: enter\n", sc->cue_dev.dv_xname,__func__));
1225:
1226: ifp = GET_IFP(sc);
1227: ifp->if_timer = 0;
1228: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1229:
1230: cue_csr_write_1(sc, CUE_ETHCTL, 0);
1231: cue_reset(sc);
1232: timeout_del(&sc->cue_stat_ch);
1233:
1234: /* Stop transfers. */
1235: if (sc->cue_ep[CUE_ENDPT_RX] != NULL) {
1236: err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_RX]);
1237: if (err) {
1238: printf("%s: abort rx pipe failed: %s\n",
1239: sc->cue_dev.dv_xname, usbd_errstr(err));
1240: }
1241: err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_RX]);
1242: if (err) {
1243: printf("%s: close rx pipe failed: %s\n",
1244: sc->cue_dev.dv_xname, usbd_errstr(err));
1245: }
1246: sc->cue_ep[CUE_ENDPT_RX] = NULL;
1247: }
1248:
1249: if (sc->cue_ep[CUE_ENDPT_TX] != NULL) {
1250: err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_TX]);
1251: if (err) {
1252: printf("%s: abort tx pipe failed: %s\n",
1253: sc->cue_dev.dv_xname, usbd_errstr(err));
1254: }
1255: err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_TX]);
1256: if (err) {
1257: printf("%s: close tx pipe failed: %s\n",
1258: sc->cue_dev.dv_xname, usbd_errstr(err));
1259: }
1260: sc->cue_ep[CUE_ENDPT_TX] = NULL;
1261: }
1262:
1263: if (sc->cue_ep[CUE_ENDPT_INTR] != NULL) {
1264: err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
1265: if (err) {
1266: printf("%s: abort intr pipe failed: %s\n",
1267: sc->cue_dev.dv_xname, usbd_errstr(err));
1268: }
1269: err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
1270: if (err) {
1271: printf("%s: close intr pipe failed: %s\n",
1272: sc->cue_dev.dv_xname, usbd_errstr(err));
1273: }
1274: sc->cue_ep[CUE_ENDPT_INTR] = NULL;
1275: }
1276:
1277: /* Free RX resources. */
1278: for (i = 0; i < CUE_RX_LIST_CNT; i++) {
1279: if (sc->cue_cdata.cue_rx_chain[i].cue_mbuf != NULL) {
1280: m_freem(sc->cue_cdata.cue_rx_chain[i].cue_mbuf);
1281: sc->cue_cdata.cue_rx_chain[i].cue_mbuf = NULL;
1282: }
1283: if (sc->cue_cdata.cue_rx_chain[i].cue_xfer != NULL) {
1284: usbd_free_xfer(sc->cue_cdata.cue_rx_chain[i].cue_xfer);
1285: sc->cue_cdata.cue_rx_chain[i].cue_xfer = NULL;
1286: }
1287: }
1288:
1289: /* Free TX resources. */
1290: for (i = 0; i < CUE_TX_LIST_CNT; i++) {
1291: if (sc->cue_cdata.cue_tx_chain[i].cue_mbuf != NULL) {
1292: m_freem(sc->cue_cdata.cue_tx_chain[i].cue_mbuf);
1293: sc->cue_cdata.cue_tx_chain[i].cue_mbuf = NULL;
1294: }
1295: if (sc->cue_cdata.cue_tx_chain[i].cue_xfer != NULL) {
1296: usbd_free_xfer(sc->cue_cdata.cue_tx_chain[i].cue_xfer);
1297: sc->cue_cdata.cue_tx_chain[i].cue_xfer = NULL;
1298: }
1299: }
1300: }