Annotation of sys/dev/usb/if_axe.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: if_axe.c,v 1.78 2007/06/14 10:11:15 mbalmer Exp $ */
2:
3: /*
4: * Copyright (c) 2005, 2006, 2007 Jonathan Gray <jsg@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: /*
20: * Copyright (c) 1997, 1998, 1999, 2000-2003
21: * Bill Paul <wpaul@windriver.com>. All rights reserved.
22: *
23: * Redistribution and use in source and binary forms, with or without
24: * modification, are permitted provided that the following conditions
25: * are met:
26: * 1. Redistributions of source code must retain the above copyright
27: * notice, this list of conditions and the following disclaimer.
28: * 2. Redistributions in binary form must reproduce the above copyright
29: * notice, this list of conditions and the following disclaimer in the
30: * documentation and/or other materials provided with the distribution.
31: * 3. All advertising materials mentioning features or use of this software
32: * must display the following acknowledgement:
33: * This product includes software developed by Bill Paul.
34: * 4. Neither the name of the author nor the names of any co-contributors
35: * may be used to endorse or promote products derived from this software
36: * without specific prior written permission.
37: *
38: * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
39: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
41: * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
42: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
43: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
44: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
45: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
46: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
47: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
48: * THE POSSIBILITY OF SUCH DAMAGE.
49: */
50:
51: #include <sys/cdefs.h>
52:
53: /*
54: * ASIX Electronics AX88172 USB 2.0 ethernet driver. Used in the
55: * LinkSys USB200M and various other adapters.
56: *
57: * Manuals available from:
58: * http://www.asix.com.tw/datasheet/mac/Ax88172.PDF
59: * Note: you need the manual for the AX88170 chip (USB 1.x ethernet
60: * controller) to find the definitions for the RX control register.
61: * http://www.asix.com.tw/datasheet/mac/Ax88170.PDF
62: *
63: * Written by Bill Paul <wpaul@windriver.com>
64: * Senior Engineer
65: * Wind River Systems
66: */
67:
68: /*
69: * The AX88172 provides USB ethernet supports at 10 and 100Mbps.
70: * It uses an external PHY (reference designs use a RealTek chip),
71: * and has a 64-bit multicast hash filter. There is some information
72: * missing from the manual which one needs to know in order to make
73: * the chip function:
74: *
75: * - You must set bit 7 in the RX control register, otherwise the
76: * chip won't receive any packets.
77: * - You must initialize all 3 IPG registers, or you won't be able
78: * to send any packets.
79: *
80: * Note that this device appears to only support loading the station
81: * address via autload from the EEPROM (i.e. there's no way to manaully
82: * set it).
83: *
84: * (Adam Weinberger wanted me to name this driver if_gir.c.)
85: */
86:
87: /*
88: * Ported to OpenBSD 3/28/2004 by Greg Taleck <taleck@oz.net>
89: * with bits and pieces from the aue and url drivers.
90: */
91:
92: #include "bpfilter.h"
93:
94: #include <sys/param.h>
95: #include <sys/systm.h>
96: #include <sys/sockio.h>
97: #include <sys/rwlock.h>
98: #include <sys/mbuf.h>
99: #include <sys/kernel.h>
100: #include <sys/proc.h>
101: #include <sys/socket.h>
102:
103: #include <sys/device.h>
104:
105: #include <machine/bus.h>
106:
107: #include <net/if.h>
108: #include <net/if_dl.h>
109: #include <net/if_media.h>
110:
111: #if NBPFILTER > 0
112: #include <net/bpf.h>
113: #endif
114:
115: #ifdef INET
116: #include <netinet/in.h>
117: #include <netinet/in_systm.h>
118: #include <netinet/in_var.h>
119: #include <netinet/ip.h>
120: #include <netinet/if_ether.h>
121: #endif
122:
123: #include <dev/mii/mii.h>
124: #include <dev/mii/miivar.h>
125:
126: #include <dev/usb/usb.h>
127: #include <dev/usb/usbdi.h>
128: #include <dev/usb/usbdi_util.h>
129: #include <dev/usb/usbdivar.h>
130: #include <dev/usb/usbdevs.h>
131:
132: #include <dev/usb/if_axereg.h>
133:
134: #ifdef AXE_DEBUG
135: #define DPRINTF(x) do { if (axedebug) printf x; } while (0)
136: #define DPRINTFN(n,x) do { if (axedebug >= (n)) printf x; } while (0)
137: int axedebug = 0;
138: #else
139: #define DPRINTF(x)
140: #define DPRINTFN(n,x)
141: #endif
142:
143: /*
144: * Various supported device vendors/products.
145: */
146: const struct axe_type axe_devs[] = {
147: { { USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_UF200}, 0 },
148: { { USB_VENDOR_ACERCM, USB_PRODUCT_ACERCM_EP1427X2}, 0 },
149: { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88172}, 0 },
150: { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88772}, AX772 },
151: { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88178}, AX178 },
152: { { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC210T}, 0 },
153: { { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5D5055 }, AX178 },
154: { { USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_SNAPPORT}, 0 },
155: { { USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_USB2AR}, 0},
156: { { USB_VENDOR_CISCOLINKSYS, USB_PRODUCT_CISCOLINKSYS_USB200MV2}, AX772 },
157: { { USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB2_TX }, 0},
158: { { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUBE100}, 0 },
159: { { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUBE100B1 }, AX772 },
160: { { USB_VENDOR_GOODWAY, USB_PRODUCT_GOODWAY_GWUSB2E}, 0 },
161: { { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_ETGUS2 }, AX178 },
162: { { USB_VENDOR_JVC, USB_PRODUCT_JVC_MP_PRX1}, 0 },
163: { { USB_VENDOR_LINKSYS2, USB_PRODUCT_LINKSYS2_USB200M}, 0 },
164: { { USB_VENDOR_LINKSYS4, USB_PRODUCT_LINKSYS4_USB1000 }, AX178 },
165: { { USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUAU2KTX}, 0 },
166: { { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_FA120}, 0 },
167: { { USB_VENDOR_OQO, USB_PRODUCT_OQO_ETHER01PLUS }, AX772 },
168: { { USB_VENDOR_PLANEX3, USB_PRODUCT_PLANEX3_GU1000T }, AX178 },
169: { { USB_VENDOR_SYSTEMTALKS, USB_PRODUCT_SYSTEMTALKS_SGCX2UL}, 0 },
170: { { USB_VENDOR_SITECOM, USB_PRODUCT_SITECOM_LN029}, 0 },
171: { { USB_VENDOR_SITECOMEU, USB_PRODUCT_SITECOMEU_LN028 }, AX178 }
172: };
173:
174: #define axe_lookup(v, p) ((struct axe_type *)usb_lookup(axe_devs, v, p))
175:
176: int axe_match(struct device *, void *, void *);
177: void axe_attach(struct device *, struct device *, void *);
178: int axe_detach(struct device *, int);
179: int axe_activate(struct device *, enum devact);
180:
181: struct cfdriver axe_cd = {
182: NULL, "axe", DV_IFNET
183: };
184:
185: const struct cfattach axe_ca = {
186: sizeof(struct axe_softc),
187: axe_match,
188: axe_attach,
189: axe_detach,
190: axe_activate,
191: };
192:
193: int axe_tx_list_init(struct axe_softc *);
194: int axe_rx_list_init(struct axe_softc *);
195: struct mbuf *axe_newbuf(void);
196: int axe_encap(struct axe_softc *, struct mbuf *, int);
197: void axe_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
198: void axe_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
199: void axe_tick(void *);
200: void axe_tick_task(void *);
201: void axe_start(struct ifnet *);
202: int axe_ioctl(struct ifnet *, u_long, caddr_t);
203: void axe_init(void *);
204: void axe_stop(struct axe_softc *);
205: void axe_watchdog(struct ifnet *);
206: int axe_miibus_readreg(struct device *, int, int);
207: void axe_miibus_writereg(struct device *, int, int, int);
208: void axe_miibus_statchg(struct device *);
209: int axe_cmd(struct axe_softc *, int, int, int, void *);
210: int axe_ifmedia_upd(struct ifnet *);
211: void axe_ifmedia_sts(struct ifnet *, struct ifmediareq *);
212: void axe_reset(struct axe_softc *sc);
213:
214: void axe_setmulti(struct axe_softc *);
215: void axe_lock_mii(struct axe_softc *sc);
216: void axe_unlock_mii(struct axe_softc *sc);
217:
218: void axe_ax88178_init(struct axe_softc *);
219: void axe_ax88772_init(struct axe_softc *);
220:
221: /* Get exclusive access to the MII registers */
222: void
223: axe_lock_mii(struct axe_softc *sc)
224: {
225: sc->axe_refcnt++;
226: rw_enter_write(&sc->axe_mii_lock);
227: }
228:
229: void
230: axe_unlock_mii(struct axe_softc *sc)
231: {
232: rw_exit_write(&sc->axe_mii_lock);
233: if (--sc->axe_refcnt < 0)
234: usb_detach_wakeup(&sc->axe_dev);
235: }
236:
237: int
238: axe_cmd(struct axe_softc *sc, int cmd, int index, int val, void *buf)
239: {
240: usb_device_request_t req;
241: usbd_status err;
242:
243: if (sc->axe_dying)
244: return(0);
245:
246: if (AXE_CMD_DIR(cmd))
247: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
248: else
249: req.bmRequestType = UT_READ_VENDOR_DEVICE;
250: req.bRequest = AXE_CMD_CMD(cmd);
251: USETW(req.wValue, val);
252: USETW(req.wIndex, index);
253: USETW(req.wLength, AXE_CMD_LEN(cmd));
254:
255: err = usbd_do_request(sc->axe_udev, &req, buf);
256:
257: if (err)
258: return(-1);
259:
260: return(0);
261: }
262:
263: int
264: axe_miibus_readreg(struct device *dev, int phy, int reg)
265: {
266: struct axe_softc *sc = (void *)dev;
267: usbd_status err;
268: uWord val;
269:
270: if (sc->axe_dying) {
271: DPRINTF(("axe: dying\n"));
272: return(0);
273: }
274:
275: #ifdef notdef
276: /*
277: * The chip tells us the MII address of any supported
278: * PHYs attached to the chip, so only read from those.
279: */
280:
281: DPRINTF(("axe_miibus_readreg: phy 0x%x reg 0x%x\n", phy, reg));
282:
283: if (sc->axe_phyaddrs[0] != AXE_NOPHY && phy != sc->axe_phyaddrs[0])
284: return (0);
285:
286: if (sc->axe_phyaddrs[1] != AXE_NOPHY && phy != sc->axe_phyaddrs[1])
287: return (0);
288: #endif
289: if (sc->axe_phyaddrs[0] != 0xFF && sc->axe_phyaddrs[0] != phy)
290: return (0);
291:
292: USETW(val, 0);
293:
294: axe_lock_mii(sc);
295: axe_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL);
296: err = axe_cmd(sc, AXE_CMD_MII_READ_REG, reg, phy, val);
297: axe_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL);
298: axe_unlock_mii(sc);
299:
300: if (err) {
301: printf("axe%d: read PHY failed\n", sc->axe_unit);
302: return(-1);
303: }
304:
305: if (UGETW(val))
306: sc->axe_phyaddrs[0] = phy;
307:
308: return (UGETW(val));
309: }
310:
311: void
312: axe_miibus_writereg(struct device *dev, int phy, int reg, int val)
313: {
314: struct axe_softc *sc = (void *)dev;
315: usbd_status err;
316: uWord uval;
317:
318: if (sc->axe_dying)
319: return;
320:
321: USETW(uval, val);
322:
323: axe_lock_mii(sc);
324: axe_cmd(sc, AXE_CMD_MII_OPMODE_SW, 0, 0, NULL);
325: err = axe_cmd(sc, AXE_CMD_MII_WRITE_REG, reg, phy, uval);
326: axe_cmd(sc, AXE_CMD_MII_OPMODE_HW, 0, 0, NULL);
327: axe_unlock_mii(sc);
328:
329: if (err) {
330: printf("axe%d: write PHY failed\n", sc->axe_unit);
331: return;
332: }
333: }
334:
335: void
336: axe_miibus_statchg(struct device *dev)
337: {
338: struct axe_softc *sc = (void *)dev;
339: struct mii_data *mii = GET_MII(sc);
340: int val, err;
341:
342: if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
343: val = AXE_MEDIA_FULL_DUPLEX;
344: else
345: val = 0;
346:
347: if (sc->axe_flags & AX178 || sc->axe_flags & AX772) {
348: val |= (AXE_178_MEDIA_RX_EN | AXE_178_MEDIA_MAGIC);
349:
350: switch (IFM_SUBTYPE(mii->mii_media_active)) {
351: case IFM_1000_T:
352: val |= AXE_178_MEDIA_GMII | AXE_178_MEDIA_ENCK;
353: break;
354: case IFM_100_TX:
355: val |= AXE_178_MEDIA_100TX;
356: break;
357: case IFM_10_T:
358: /* doesn't need to be handled */
359: break;
360: }
361: }
362:
363: DPRINTF(("axe_miibus_statchg: val=0x%x\n", val));
364: err = axe_cmd(sc, AXE_CMD_WRITE_MEDIA, 0, val, NULL);
365: if (err) {
366: printf("%s: media change failed\n", sc->axe_dev.dv_xname);
367: return;
368: }
369: }
370:
371: /*
372: * Set media options.
373: */
374: int
375: axe_ifmedia_upd(struct ifnet *ifp)
376: {
377: struct axe_softc *sc = ifp->if_softc;
378: struct mii_data *mii = GET_MII(sc);
379:
380: sc->axe_link = 0;
381: if (mii->mii_instance) {
382: struct mii_softc *miisc;
383: LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
384: mii_phy_reset(miisc);
385: }
386: mii_mediachg(mii);
387:
388: return (0);
389: }
390:
391: /*
392: * Report current media status.
393: */
394: void
395: axe_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
396: {
397: struct axe_softc *sc = ifp->if_softc;
398: struct mii_data *mii = GET_MII(sc);
399:
400: mii_pollstat(mii);
401: ifmr->ifm_active = mii->mii_media_active;
402: ifmr->ifm_status = mii->mii_media_status;
403: }
404:
405: void
406: axe_setmulti(struct axe_softc *sc)
407: {
408: struct ifnet *ifp;
409: struct ether_multi *enm;
410: struct ether_multistep step;
411: u_int32_t h = 0;
412: uWord urxmode;
413: u_int16_t rxmode;
414: u_int8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
415:
416: if (sc->axe_dying)
417: return;
418:
419: ifp = GET_IFP(sc);
420:
421: axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, urxmode);
422: rxmode = UGETW(urxmode);
423:
424: if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
425: allmulti:
426: rxmode |= AXE_RXCMD_ALLMULTI;
427: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
428: return;
429: } else
430: rxmode &= ~AXE_RXCMD_ALLMULTI;
431:
432: /* now program new ones */
433: ETHER_FIRST_MULTI(step, &sc->arpcom, enm);
434: while (enm != NULL) {
435: if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
436: ETHER_ADDR_LEN) != 0)
437: goto allmulti;
438:
439: h = ether_crc32_be(enm->enm_addrlo, ETHER_ADDR_LEN) >> 26;
440: hashtbl[h / 8] |= 1 << (h % 8);
441: ETHER_NEXT_MULTI(step, enm);
442: }
443:
444: ifp->if_flags &= ~IFF_ALLMULTI;
445: axe_cmd(sc, AXE_CMD_WRITE_MCAST, 0, 0, (void *)&hashtbl);
446: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
447: return;
448: }
449:
450: void
451: axe_reset(struct axe_softc *sc)
452: {
453: if (sc->axe_dying)
454: return;
455: /* XXX What to reset? */
456:
457: /* Wait a little while for the chip to get its brains in order. */
458: DELAY(1000);
459: return;
460: }
461:
462: void
463: axe_ax88178_init(struct axe_softc *sc)
464: {
465: int gpio0 = 0, phymode = 0;
466: u_int16_t eeprom;
467:
468: axe_cmd(sc, AXE_CMD_SROM_WR_ENABLE, 0, 0, NULL);
469: /* XXX magic */
470: axe_cmd(sc, AXE_CMD_SROM_READ, 0, 0x0017, &eeprom);
471: axe_cmd(sc, AXE_CMD_SROM_WR_DISABLE, 0, 0, NULL);
472:
473: eeprom = letoh16(eeprom);
474:
475: DPRINTF((" EEPROM is 0x%x\n", eeprom));
476:
477: /* if EEPROM is invalid we have to use to GPIO0 */
478: if (eeprom == 0xffff) {
479: phymode = 0;
480: gpio0 = 1;
481: } else {
482: phymode = eeprom & 7;
483: gpio0 = (eeprom & 0x80) ? 0 : 1;
484: }
485:
486: DPRINTF(("use gpio0: %d, phymode %d\n", gpio0, phymode));
487:
488: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x008c, NULL);
489: usbd_delay_ms(sc->axe_udev, 40);
490: if ((eeprom >> 8) != 1) {
491: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL);
492: usbd_delay_ms(sc->axe_udev, 30);
493:
494: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x001c, NULL);
495: usbd_delay_ms(sc->axe_udev, 300);
496:
497: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x003c, NULL);
498: usbd_delay_ms(sc->axe_udev, 30);
499: } else {
500: DPRINTF(("axe gpio phymode == 1 path\n"));
501: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x0004, NULL);
502: usbd_delay_ms(sc->axe_udev, 30);
503: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x000c, NULL);
504: usbd_delay_ms(sc->axe_udev, 30);
505: }
506:
507: /* soft reset */
508: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL);
509: usbd_delay_ms(sc->axe_udev, 150);
510: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
511: AXE_SW_RESET_PRL | AXE_178_RESET_MAGIC, NULL);
512: usbd_delay_ms(sc->axe_udev, 150);
513: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
514: }
515:
516: void
517: axe_ax88772_init(struct axe_softc *sc)
518: {
519: axe_cmd(sc, AXE_CMD_WRITE_GPIO, 0, 0x00b0, NULL);
520: usbd_delay_ms(sc->axe_udev, 40);
521:
522: if (sc->axe_phyaddrs[1] == AXE_INTPHY) {
523: /* ask for the embedded PHY */
524: axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x01, NULL);
525: usbd_delay_ms(sc->axe_udev, 10);
526:
527: /* power down and reset state, pin reset state */
528: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_CLEAR, NULL);
529: usbd_delay_ms(sc->axe_udev, 60);
530:
531: /* power down/reset state, pin operating state */
532: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
533: AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL);
534: usbd_delay_ms(sc->axe_udev, 150);
535:
536: /* power up, reset */
537: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0, AXE_SW_RESET_PRL, NULL);
538:
539: /* power up, operating */
540: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
541: AXE_SW_RESET_IPRL | AXE_SW_RESET_PRL, NULL);
542: } else {
543: /* ask for external PHY */
544: axe_cmd(sc, AXE_CMD_SW_PHY_SELECT, 0, 0x00, NULL);
545: usbd_delay_ms(sc->axe_udev, 10);
546:
547: /* power down internal PHY */
548: axe_cmd(sc, AXE_CMD_SW_RESET_REG, 0,
549: AXE_SW_RESET_IPPD | AXE_SW_RESET_PRL, NULL);
550: }
551:
552: usbd_delay_ms(sc->axe_udev, 150);
553: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, 0, NULL);
554: }
555:
556: /*
557: * Probe for a AX88172 chip.
558: */
559: int
560: axe_match(struct device *parent, void *match, void *aux)
561: {
562: struct usb_attach_arg *uaa = aux;
563:
564: if (!uaa->iface)
565: return(UMATCH_NONE);
566:
567: return (axe_lookup(uaa->vendor, uaa->product) != NULL ?
568: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
569: }
570:
571: /*
572: * Attach the interface. Allocate softc structures, do ifmedia
573: * setup and ethernet/BPF attach.
574: */
575: void
576: axe_attach(struct device *parent, struct device *self, void *aux)
577: {
578: struct axe_softc *sc = (struct axe_softc *)self;
579: struct usb_attach_arg *uaa = aux;
580: usbd_device_handle dev = uaa->device;
581: usbd_status err;
582: usb_interface_descriptor_t *id;
583: usb_endpoint_descriptor_t *ed;
584: struct mii_data *mii;
585: u_char eaddr[ETHER_ADDR_LEN];
586: char *devinfop;
587: char *devname = sc->axe_dev.dv_xname;
588: struct ifnet *ifp;
589: int i, s;
590:
591: devinfop = usbd_devinfo_alloc(dev, 0);
592: printf("\n");
593:
594: sc->axe_unit = self->dv_unit; /*device_get_unit(self);*/
595:
596: err = usbd_set_config_no(dev, AXE_CONFIG_NO, 1);
597: if (err) {
598: printf("axe%d: getting interface handle failed\n",
599: sc->axe_unit);
600: usbd_devinfo_free(devinfop);
601: return;
602: }
603:
604: sc->axe_flags = axe_lookup(uaa->vendor, uaa->product)->axe_flags;
605:
606: usb_init_task(&sc->axe_tick_task, axe_tick_task, sc);
607: rw_init(&sc->axe_mii_lock, "axemii");
608: usb_init_task(&sc->axe_stop_task, (void (*)(void *))axe_stop, sc);
609:
610: err = usbd_device2interface_handle(dev, AXE_IFACE_IDX, &sc->axe_iface);
611: if (err) {
612: printf("axe%d: getting interface handle failed\n",
613: sc->axe_unit);
614: usbd_devinfo_free(devinfop);
615: return;
616: }
617:
618: sc->axe_udev = dev;
619: sc->axe_product = uaa->product;
620: sc->axe_vendor = uaa->vendor;
621:
622: id = usbd_get_interface_descriptor(sc->axe_iface);
623:
624: printf("%s: %s", sc->axe_dev.dv_xname, devinfop);
625: usbd_devinfo_free(devinfop);
626:
627: /* decide on what our bufsize will be */
628: if (sc->axe_flags & AX178 || sc->axe_flags & AX772)
629: sc->axe_bufsz = (sc->axe_udev->speed == USB_SPEED_HIGH) ?
630: AXE_178_MAX_BUFSZ : AXE_178_MIN_BUFSZ;
631: else
632: sc->axe_bufsz = AXE_172_BUFSZ;
633:
634: /* Find endpoints. */
635: for (i = 0; i < id->bNumEndpoints; i++) {
636: ed = usbd_interface2endpoint_descriptor(sc->axe_iface, i);
637: if (!ed) {
638: printf(" couldn't get ep %d\n", i);
639: return;
640: }
641: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
642: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
643: sc->axe_ed[AXE_ENDPT_RX] = ed->bEndpointAddress;
644: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
645: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
646: sc->axe_ed[AXE_ENDPT_TX] = ed->bEndpointAddress;
647: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
648: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
649: sc->axe_ed[AXE_ENDPT_INTR] = ed->bEndpointAddress;
650: }
651: }
652:
653: s = splnet();
654:
655: /* We need the PHYID for init dance in some cases */
656: axe_cmd(sc, AXE_CMD_READ_PHYID, 0, 0, (void *)&sc->axe_phyaddrs);
657:
658: DPRINTF((" phyaddrs[0]: %x phyaddrs[1]: %x\n",
659: sc->axe_phyaddrs[0], sc->axe_phyaddrs[1]));
660:
661: if (sc->axe_flags & AX178) {
662: axe_ax88178_init(sc);
663: printf(", AX88178");
664: } else if (sc->axe_flags & AX772) {
665: axe_ax88772_init(sc);
666: printf(", AX88772");
667: } else
668: printf(", AX88172");
669:
670: /*
671: * Get station address.
672: */
673: if (sc->axe_flags & AX178 || sc->axe_flags & AX772)
674: axe_cmd(sc, AXE_178_CMD_READ_NODEID, 0, 0, &eaddr);
675: else
676: axe_cmd(sc, AXE_172_CMD_READ_NODEID, 0, 0, &eaddr);
677:
678: /*
679: * Load IPG values
680: */
681: axe_cmd(sc, AXE_CMD_READ_IPG012, 0, 0, (void *)&sc->axe_ipgs);
682:
683: /*
684: * Work around broken adapters that appear to lie about
685: * their PHY addresses.
686: */
687: sc->axe_phyaddrs[0] = sc->axe_phyaddrs[1] = 0xFF;
688:
689: /*
690: * An ASIX chip was detected. Inform the world.
691: */
692: printf(", address %s\n", ether_sprintf(eaddr));
693:
694: bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
695:
696: /* Initialize interface info.*/
697: ifp = &sc->arpcom.ac_if;
698: ifp->if_softc = sc;
699: strlcpy(ifp->if_xname, devname, IFNAMSIZ);
700: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
701: ifp->if_ioctl = axe_ioctl;
702: ifp->if_start = axe_start;
703:
704: ifp->if_watchdog = axe_watchdog;
705:
706: /* ifp->if_baudrate = 10000000; */
707: /* ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;*/
708:
709: IFQ_SET_READY(&ifp->if_snd);
710:
711: /* Initialize MII/media info. */
712: mii = &sc->axe_mii;
713: mii->mii_ifp = ifp;
714: mii->mii_readreg = axe_miibus_readreg;
715: mii->mii_writereg = axe_miibus_writereg;
716: mii->mii_statchg = axe_miibus_statchg;
717: mii->mii_flags = MIIF_AUTOTSLEEP;
718:
719: ifmedia_init(&mii->mii_media, 0, axe_ifmedia_upd, axe_ifmedia_sts);
720: mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
721:
722: if (LIST_FIRST(&mii->mii_phys) == NULL) {
723: ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
724: ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
725: } else
726: ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
727:
728: /* Attach the interface. */
729: if_attach(ifp);
730: ether_ifattach(ifp);
731:
732: timeout_set(&sc->axe_stat_ch, NULL, NULL);
733:
734: sc->axe_attached = 1;
735: splx(s);
736:
737: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->axe_udev,
738: &sc->axe_dev);
739: }
740:
741: int
742: axe_detach(struct device *self, int flags)
743: {
744: struct axe_softc *sc = (struct axe_softc *)self;
745: int s;
746: struct ifnet *ifp = GET_IFP(sc);
747:
748: DPRINTFN(2,("%s: %s: enter\n", sc->axe_dev.dv_xname, __func__));
749:
750: /* Detached before attached finished, so just bail out. */
751: if (!sc->axe_attached)
752: return (0);
753:
754: timeout_del(&sc->axe_stat_ch);
755:
756: sc->axe_dying = 1;
757:
758: ether_ifdetach(ifp);
759:
760: if (sc->axe_ep[AXE_ENDPT_TX] != NULL)
761: usbd_abort_pipe(sc->axe_ep[AXE_ENDPT_TX]);
762: if (sc->axe_ep[AXE_ENDPT_RX] != NULL)
763: usbd_abort_pipe(sc->axe_ep[AXE_ENDPT_RX]);
764: if (sc->axe_ep[AXE_ENDPT_INTR] != NULL)
765: usbd_abort_pipe(sc->axe_ep[AXE_ENDPT_INTR]);
766:
767: /*
768: * Remove any pending tasks. They cannot be executing because they run
769: * in the same thread as detach.
770: */
771: usb_rem_task(sc->axe_udev, &sc->axe_tick_task);
772: usb_rem_task(sc->axe_udev, &sc->axe_stop_task);
773:
774: s = splusb();
775:
776: if (--sc->axe_refcnt >= 0) {
777: /* Wait for processes to go away */
778: usb_detach_wait(&sc->axe_dev);
779: }
780:
781: if (ifp->if_flags & IFF_RUNNING)
782: axe_stop(sc);
783:
784: mii_detach(&sc->axe_mii, MII_PHY_ANY, MII_OFFSET_ANY);
785: ifmedia_delete_instance(&sc->axe_mii.mii_media, IFM_INST_ANY);
786: ether_ifdetach(ifp);
787: if_detach(ifp);
788:
789: #ifdef DIAGNOSTIC
790: if (sc->axe_ep[AXE_ENDPT_TX] != NULL ||
791: sc->axe_ep[AXE_ENDPT_RX] != NULL ||
792: sc->axe_ep[AXE_ENDPT_INTR] != NULL)
793: printf("%s: detach has active endpoints\n",
794: sc->axe_dev.dv_xname);
795: #endif
796:
797: sc->axe_attached = 0;
798:
799: if (--sc->axe_refcnt >= 0) {
800: /* Wait for processes to go away. */
801: usb_detach_wait(&sc->axe_dev);
802: }
803: splx(s);
804:
805: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->axe_udev,
806: &sc->axe_dev);
807:
808: return (0);
809: }
810:
811: int
812: axe_activate(struct device *self, enum devact act)
813: {
814: struct axe_softc *sc = (struct axe_softc *)self;
815:
816: DPRINTFN(2,("%s: %s: enter\n", sc->axe_dev.dv_xname, __func__));
817:
818: switch (act) {
819: case DVACT_ACTIVATE:
820: break;
821:
822: case DVACT_DEACTIVATE:
823: sc->axe_dying = 1;
824: break;
825: }
826: return (0);
827: }
828:
829: struct mbuf *
830: axe_newbuf(void)
831: {
832: struct mbuf *m;
833:
834: MGETHDR(m, M_DONTWAIT, MT_DATA);
835: if (m == NULL)
836: return (NULL);
837:
838: MCLGET(m, M_DONTWAIT);
839: if (!(m->m_flags & M_EXT)) {
840: m_freem(m);
841: return (NULL);
842: }
843:
844: m->m_len = m->m_pkthdr.len = MCLBYTES;
845: m_adj(m, ETHER_ALIGN);
846:
847: return (m);
848: }
849:
850: int
851: axe_rx_list_init(struct axe_softc *sc)
852: {
853: struct axe_cdata *cd;
854: struct axe_chain *c;
855: int i;
856:
857: DPRINTF(("%s: %s: enter\n", sc->axe_dev.dv_xname, __func__));
858:
859: cd = &sc->axe_cdata;
860: for (i = 0; i < AXE_RX_LIST_CNT; i++) {
861: c = &cd->axe_rx_chain[i];
862: c->axe_sc = sc;
863: c->axe_idx = i;
864: c->axe_mbuf = NULL;
865: if (c->axe_xfer == NULL) {
866: c->axe_xfer = usbd_alloc_xfer(sc->axe_udev);
867: if (c->axe_xfer == NULL)
868: return (ENOBUFS);
869: c->axe_buf = usbd_alloc_buffer(c->axe_xfer,
870: sc->axe_bufsz);
871: if (c->axe_buf == NULL) {
872: usbd_free_xfer(c->axe_xfer);
873: return (ENOBUFS);
874: }
875: }
876: }
877:
878: return (0);
879: }
880:
881: int
882: axe_tx_list_init(struct axe_softc *sc)
883: {
884: struct axe_cdata *cd;
885: struct axe_chain *c;
886: int i;
887:
888: DPRINTF(("%s: %s: enter\n", sc->axe_dev.dv_xname, __func__));
889:
890: cd = &sc->axe_cdata;
891: for (i = 0; i < AXE_TX_LIST_CNT; i++) {
892: c = &cd->axe_tx_chain[i];
893: c->axe_sc = sc;
894: c->axe_idx = i;
895: c->axe_mbuf = NULL;
896: if (c->axe_xfer == NULL) {
897: c->axe_xfer = usbd_alloc_xfer(sc->axe_udev);
898: if (c->axe_xfer == NULL)
899: return (ENOBUFS);
900: c->axe_buf = usbd_alloc_buffer(c->axe_xfer,
901: sc->axe_bufsz);
902: if (c->axe_buf == NULL) {
903: usbd_free_xfer(c->axe_xfer);
904: return (ENOBUFS);
905: }
906: }
907: }
908:
909: return (0);
910: }
911:
912: /*
913: * A frame has been uploaded: pass the resulting mbuf chain up to
914: * the higher level protocols.
915: */
916: void
917: axe_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
918: {
919: struct axe_chain *c = (struct axe_chain *)priv;
920: struct axe_softc *sc = c->axe_sc;
921: struct ifnet *ifp = GET_IFP(sc);
922: u_char *buf = c->axe_buf;
923: u_int32_t total_len;
924: u_int16_t pktlen = 0;
925: struct mbuf *m;
926: struct axe_sframe_hdr hdr;
927: int s;
928:
929: DPRINTFN(10,("%s: %s: enter\n", sc->axe_dev.dv_xname,__func__));
930:
931: if (sc->axe_dying)
932: return;
933:
934: if (!(ifp->if_flags & IFF_RUNNING))
935: return;
936:
937: if (status != USBD_NORMAL_COMPLETION) {
938: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
939: return;
940: if (usbd_ratecheck(&sc->axe_rx_notice)) {
941: printf("%s: usb errors on rx: %s\n",
942: sc->axe_dev.dv_xname, usbd_errstr(status));
943: }
944: if (status == USBD_STALLED)
945: usbd_clear_endpoint_stall_async(sc->axe_ep[AXE_ENDPT_RX]);
946: goto done;
947: }
948:
949: usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
950:
951: do {
952: if (sc->axe_flags & AX178 || sc->axe_flags & AX772) {
953: if (total_len < sizeof(hdr)) {
954: ifp->if_ierrors++;
955: goto done;
956: }
957:
958: buf += pktlen;
959:
960: memcpy(&hdr, buf, sizeof(hdr));
961: total_len -= sizeof(hdr);
962:
963: if ((hdr.len ^ hdr.ilen) != 0xffff) {
964: ifp->if_ierrors++;
965: goto done;
966: }
967: pktlen = letoh16(hdr.len);
968: if (pktlen > total_len) {
969: ifp->if_ierrors++;
970: goto done;
971: }
972:
973: buf += sizeof(hdr);
974:
975: if ((pktlen % 2) != 0)
976: pktlen++;
977:
978: if ((total_len - pktlen) < 0)
979: total_len = 0;
980: else
981: total_len -= pktlen;
982: } else {
983: pktlen = total_len; /* crc on the end? */
984: total_len = 0;
985: }
986:
987: m = axe_newbuf();
988: if (m == NULL) {
989: ifp->if_ierrors++;
990: goto done;
991: }
992:
993: ifp->if_ipackets++;
994: m->m_pkthdr.rcvif = ifp;
995: m->m_pkthdr.len = m->m_len = pktlen;
996:
997: memcpy(mtod(m, char *), buf, pktlen);
998:
999: /* push the packet up */
1000: s = splnet();
1001: #if NBPFILTER > 0
1002: if (ifp->if_bpf)
1003: bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);
1004: #endif
1005:
1006: ether_input_mbuf(ifp, m);
1007:
1008: splx(s);
1009:
1010: } while (total_len > 0);
1011:
1012: done:
1013: memset(c->axe_buf, 0, sc->axe_bufsz);
1014:
1015: /* Setup new transfer. */
1016: usbd_setup_xfer(xfer, sc->axe_ep[AXE_ENDPT_RX],
1017: c, c->axe_buf, sc->axe_bufsz,
1018: USBD_SHORT_XFER_OK | USBD_NO_COPY,
1019: USBD_NO_TIMEOUT, axe_rxeof);
1020: usbd_transfer(xfer);
1021:
1022: DPRINTFN(10,("%s: %s: start rx\n", sc->axe_dev.dv_xname, __func__));
1023:
1024: return;
1025: }
1026:
1027: /*
1028: * A frame was downloaded to the chip. It's safe for us to clean up
1029: * the list buffers.
1030: */
1031:
1032: void
1033: axe_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
1034: {
1035: struct axe_softc *sc;
1036: struct axe_chain *c;
1037: struct ifnet *ifp;
1038: int s;
1039:
1040: c = priv;
1041: sc = c->axe_sc;
1042: ifp = &sc->arpcom.ac_if;
1043:
1044: if (sc->axe_dying)
1045: return;
1046:
1047: s = splnet();
1048:
1049: if (status != USBD_NORMAL_COMPLETION) {
1050: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1051: splx(s);
1052: return;
1053: }
1054: ifp->if_oerrors++;
1055: printf("axe%d: usb error on tx: %s\n", sc->axe_unit,
1056: usbd_errstr(status));
1057: if (status == USBD_STALLED)
1058: usbd_clear_endpoint_stall_async(sc->axe_ep[AXE_ENDPT_TX]);
1059: splx(s);
1060: return;
1061: }
1062:
1063: ifp->if_timer = 0;
1064: ifp->if_flags &= ~IFF_OACTIVE;
1065:
1066: m_freem(c->axe_mbuf);
1067: c->axe_mbuf = NULL;
1068:
1069: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1070: axe_start(ifp);
1071:
1072: ifp->if_opackets++;
1073: splx(s);
1074: return;
1075: }
1076:
1077: void
1078: axe_tick(void *xsc)
1079: {
1080: struct axe_softc *sc = xsc;
1081:
1082: if (sc == NULL)
1083: return;
1084:
1085: DPRINTFN(0xff, ("%s: %s: enter\n", sc->axe_dev.dv_xname,
1086: __func__));
1087:
1088: if (sc->axe_dying)
1089: return;
1090:
1091: /* Perform periodic stuff in process context */
1092: usb_add_task(sc->axe_udev, &sc->axe_tick_task);
1093:
1094: }
1095:
1096: void
1097: axe_tick_task(void *xsc)
1098: {
1099: int s;
1100: struct axe_softc *sc;
1101: struct ifnet *ifp;
1102: struct mii_data *mii;
1103:
1104: sc = xsc;
1105:
1106: if (sc == NULL)
1107: return;
1108:
1109: if (sc->axe_dying)
1110: return;
1111:
1112: ifp = GET_IFP(sc);
1113: mii = GET_MII(sc);
1114: if (mii == NULL)
1115: return;
1116:
1117: s = splnet();
1118:
1119: mii_tick(mii);
1120: if (!sc->axe_link && mii->mii_media_status & IFM_ACTIVE &&
1121: IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
1122: DPRINTF(("%s: %s: got link\n",
1123: sc->axe_dev.dv_xname, __func__));
1124: sc->axe_link++;
1125: if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1126: axe_start(ifp);
1127: }
1128:
1129: timeout_del(&sc->axe_stat_ch);
1130: timeout_set(&sc->axe_stat_ch, axe_tick, sc);
1131: timeout_add(&sc->axe_stat_ch, hz);
1132:
1133: splx(s);
1134: }
1135:
1136: int
1137: axe_encap(struct axe_softc *sc, struct mbuf *m, int idx)
1138: {
1139: struct axe_chain *c;
1140: usbd_status err;
1141: struct axe_sframe_hdr hdr;
1142: int length, boundary;
1143:
1144: c = &sc->axe_cdata.axe_tx_chain[idx];
1145:
1146: if (sc->axe_flags & AX178 || sc->axe_flags & AX772) {
1147: boundary = (sc->axe_udev->speed == USB_SPEED_HIGH) ? 512 : 64;
1148:
1149: hdr.len = htole16(m->m_pkthdr.len);
1150: hdr.ilen = ~hdr.len;
1151:
1152: memcpy(c->axe_buf, &hdr, sizeof(hdr));
1153: length = sizeof(hdr);
1154:
1155: m_copydata(m, 0, m->m_pkthdr.len, c->axe_buf + length);
1156: length += m->m_pkthdr.len;
1157:
1158: if ((length % boundary) == 0) {
1159: hdr.len = 0x0000;
1160: hdr.ilen = 0xffff;
1161: memcpy(c->axe_buf + length, &hdr, sizeof(hdr));
1162: length += sizeof(hdr);
1163: }
1164:
1165: } else {
1166: m_copydata(m, 0, m->m_pkthdr.len, c->axe_buf);
1167: length = m->m_pkthdr.len;
1168: }
1169:
1170: c->axe_mbuf = m;
1171:
1172: usbd_setup_xfer(c->axe_xfer, sc->axe_ep[AXE_ENDPT_TX],
1173: c, c->axe_buf, length, USBD_FORCE_SHORT_XFER | USBD_NO_COPY,
1174: 10000, axe_txeof);
1175:
1176: /* Transmit */
1177: err = usbd_transfer(c->axe_xfer);
1178: if (err != USBD_IN_PROGRESS) {
1179: axe_stop(sc);
1180: return(EIO);
1181: }
1182:
1183: sc->axe_cdata.axe_tx_cnt++;
1184:
1185: return(0);
1186: }
1187:
1188: void
1189: axe_start(struct ifnet *ifp)
1190: {
1191: struct axe_softc *sc;
1192: struct mbuf *m_head = NULL;
1193:
1194: sc = ifp->if_softc;
1195:
1196: if (!sc->axe_link)
1197: return;
1198:
1199: if (ifp->if_flags & IFF_OACTIVE)
1200: return;
1201:
1202: IFQ_POLL(&ifp->if_snd, m_head);
1203: if (m_head == NULL)
1204: return;
1205:
1206: if (axe_encap(sc, m_head, 0)) {
1207: ifp->if_flags |= IFF_OACTIVE;
1208: return;
1209: }
1210: IFQ_DEQUEUE(&ifp->if_snd, m_head);
1211:
1212: /*
1213: * If there's a BPF listener, bounce a copy of this frame
1214: * to him.
1215: */
1216: #if NBPFILTER > 0
1217: if (ifp->if_bpf)
1218: bpf_mtap(ifp->if_bpf, m_head, BPF_DIRECTION_OUT);
1219: #endif
1220:
1221: ifp->if_flags |= IFF_OACTIVE;
1222:
1223: /*
1224: * Set a timeout in case the chip goes out to lunch.
1225: */
1226: ifp->if_timer = 5;
1227:
1228: return;
1229: }
1230:
1231: void
1232: axe_init(void *xsc)
1233: {
1234: struct axe_softc *sc = xsc;
1235: struct ifnet *ifp = &sc->arpcom.ac_if;
1236: struct axe_chain *c;
1237: usbd_status err;
1238: int rxmode;
1239: int i, s;
1240:
1241: s = splnet();
1242:
1243: /*
1244: * Cancel pending I/O and free all RX/TX buffers.
1245: */
1246: axe_reset(sc);
1247:
1248: /* Enable RX logic. */
1249:
1250: /* Init RX ring. */
1251: if (axe_rx_list_init(sc) == ENOBUFS) {
1252: printf("axe%d: rx list init failed\n", sc->axe_unit);
1253: splx(s);
1254: return;
1255: }
1256:
1257: /* Init TX ring. */
1258: if (axe_tx_list_init(sc) == ENOBUFS) {
1259: printf("axe%d: tx list init failed\n", sc->axe_unit);
1260: splx(s);
1261: return;
1262: }
1263:
1264: /* Set transmitter IPG values */
1265: if (sc->axe_flags & AX178 || sc->axe_flags & AX772)
1266: axe_cmd(sc, AXE_178_CMD_WRITE_IPG012, sc->axe_ipgs[2],
1267: (sc->axe_ipgs[1] << 8) | (sc->axe_ipgs[0]), NULL);
1268: else {
1269: axe_cmd(sc, AXE_172_CMD_WRITE_IPG0, 0, sc->axe_ipgs[0], NULL);
1270: axe_cmd(sc, AXE_172_CMD_WRITE_IPG1, 0, sc->axe_ipgs[1], NULL);
1271: axe_cmd(sc, AXE_172_CMD_WRITE_IPG2, 0, sc->axe_ipgs[2], NULL);
1272: }
1273:
1274: /* Enable receiver, set RX mode */
1275: rxmode = AXE_RXCMD_MULTICAST|AXE_RXCMD_ENABLE;
1276: if (sc->axe_flags & AX178 || sc->axe_flags & AX772) {
1277: if (sc->axe_udev->speed == USB_SPEED_HIGH) {
1278: /* largest possible USB buffer size for AX88178 */
1279: rxmode |= AXE_178_RXCMD_MFB;
1280: }
1281: } else
1282: rxmode |= AXE_172_RXCMD_UNICAST;
1283:
1284: /* If we want promiscuous mode, set the allframes bit. */
1285: if (ifp->if_flags & IFF_PROMISC)
1286: rxmode |= AXE_RXCMD_PROMISC;
1287:
1288: if (ifp->if_flags & IFF_BROADCAST)
1289: rxmode |= AXE_RXCMD_BROADCAST;
1290:
1291: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0, rxmode, NULL);
1292:
1293: /* Load the multicast filter. */
1294: axe_setmulti(sc);
1295:
1296: /* Open RX and TX pipes. */
1297: err = usbd_open_pipe(sc->axe_iface, sc->axe_ed[AXE_ENDPT_RX],
1298: USBD_EXCLUSIVE_USE, &sc->axe_ep[AXE_ENDPT_RX]);
1299: if (err) {
1300: printf("axe%d: open rx pipe failed: %s\n",
1301: sc->axe_unit, usbd_errstr(err));
1302: splx(s);
1303: return;
1304: }
1305:
1306: err = usbd_open_pipe(sc->axe_iface, sc->axe_ed[AXE_ENDPT_TX],
1307: USBD_EXCLUSIVE_USE, &sc->axe_ep[AXE_ENDPT_TX]);
1308: if (err) {
1309: printf("axe%d: open tx pipe failed: %s\n",
1310: sc->axe_unit, usbd_errstr(err));
1311: splx(s);
1312: return;
1313: }
1314:
1315: /* Start up the receive pipe. */
1316: for (i = 0; i < AXE_RX_LIST_CNT; i++) {
1317: c = &sc->axe_cdata.axe_rx_chain[i];
1318: usbd_setup_xfer(c->axe_xfer, sc->axe_ep[AXE_ENDPT_RX],
1319: c, c->axe_buf, sc->axe_bufsz,
1320: USBD_SHORT_XFER_OK | USBD_NO_COPY,
1321: USBD_NO_TIMEOUT, axe_rxeof);
1322: usbd_transfer(c->axe_xfer);
1323: }
1324:
1325: ifp->if_flags |= IFF_RUNNING;
1326: ifp->if_flags &= ~IFF_OACTIVE;
1327:
1328: splx(s);
1329:
1330: timeout_del(&sc->axe_stat_ch);
1331: timeout_set(&sc->axe_stat_ch, axe_tick, sc);
1332: timeout_add(&sc->axe_stat_ch, hz);
1333: return;
1334: }
1335:
1336: int
1337: axe_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
1338: {
1339: struct axe_softc *sc = ifp->if_softc;
1340: struct ifreq *ifr = (struct ifreq *)data;
1341: struct ifaddr *ifa = (struct ifaddr *)data;
1342: struct mii_data *mii;
1343: uWord rxmode;
1344: int error = 0;
1345:
1346: switch(cmd) {
1347: case SIOCSIFADDR:
1348: ifp->if_flags |= IFF_UP;
1349: if (!(ifp->if_flags & IFF_RUNNING))
1350: axe_init(sc);
1351: #ifdef INET
1352: if (ifa->ifa_addr->sa_family == AF_INET)
1353: arp_ifinit(&sc->arpcom, ifa);
1354: #endif
1355: break;
1356:
1357: case SIOCSIFMTU:
1358: if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ifp->if_hardmtu)
1359: error = EINVAL;
1360: else if (ifp->if_mtu != ifr->ifr_mtu)
1361: ifp->if_mtu = ifr->ifr_mtu;
1362: break;
1363:
1364: case SIOCSIFFLAGS:
1365: if (ifp->if_flags & IFF_UP) {
1366: if (ifp->if_flags & IFF_RUNNING &&
1367: ifp->if_flags & IFF_PROMISC &&
1368: !(sc->axe_if_flags & IFF_PROMISC)) {
1369:
1370: axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, rxmode);
1371: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0,
1372: UGETW(rxmode) | AXE_RXCMD_PROMISC, NULL);
1373:
1374: axe_setmulti(sc);
1375: } else if (ifp->if_flags & IFF_RUNNING &&
1376: !(ifp->if_flags & IFF_PROMISC) &&
1377: sc->axe_if_flags & IFF_PROMISC) {
1378: axe_cmd(sc, AXE_CMD_RXCTL_READ, 0, 0, rxmode);
1379: axe_cmd(sc, AXE_CMD_RXCTL_WRITE, 0,
1380: UGETW(rxmode) & ~AXE_RXCMD_PROMISC, NULL);
1381: axe_setmulti(sc);
1382: } else if (!(ifp->if_flags & IFF_RUNNING))
1383: axe_init(sc);
1384: } else {
1385: if (ifp->if_flags & IFF_RUNNING)
1386: axe_stop(sc);
1387: }
1388: sc->axe_if_flags = ifp->if_flags;
1389: break;
1390: case SIOCADDMULTI:
1391: case SIOCDELMULTI:
1392: error = (cmd == SIOCADDMULTI) ?
1393: ether_addmulti(ifr, &sc->arpcom) :
1394: ether_delmulti(ifr, &sc->arpcom);
1395:
1396: if (error == ENETRESET) {
1397: /*
1398: * Multicast list has changed; set the hardware
1399: * filter accordingly.
1400: */
1401: if (ifp->if_flags & IFF_RUNNING)
1402: axe_setmulti(sc);
1403: error = 0;
1404: }
1405: break;
1406: case SIOCGIFMEDIA:
1407: case SIOCSIFMEDIA:
1408: mii = GET_MII(sc);
1409: error = ifmedia_ioctl(ifp, ifr, &mii->mii_media, cmd);
1410: break;
1411:
1412: default:
1413: error = EINVAL;
1414: break;
1415: }
1416:
1417: return(error);
1418: }
1419:
1420: void
1421: axe_watchdog(struct ifnet *ifp)
1422: {
1423: struct axe_softc *sc;
1424: struct axe_chain *c;
1425: usbd_status stat;
1426: int s;
1427:
1428: sc = ifp->if_softc;
1429:
1430: ifp->if_oerrors++;
1431: printf("axe%d: watchdog timeout\n", sc->axe_unit);
1432:
1433: s = splusb();
1434: c = &sc->axe_cdata.axe_tx_chain[0];
1435: usbd_get_xfer_status(c->axe_xfer, NULL, NULL, NULL, &stat);
1436: axe_txeof(c->axe_xfer, c, stat);
1437:
1438: if (!IFQ_IS_EMPTY(&ifp->if_snd))
1439: axe_start(ifp);
1440: splx(s);
1441: }
1442:
1443: /*
1444: * Stop the adapter and free any mbufs allocated to the
1445: * RX and TX lists.
1446: */
1447: void
1448: axe_stop(struct axe_softc *sc)
1449: {
1450: usbd_status err;
1451: struct ifnet *ifp;
1452: int i;
1453:
1454: axe_reset(sc);
1455:
1456: ifp = &sc->arpcom.ac_if;
1457: ifp->if_timer = 0;
1458: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1459:
1460: timeout_del(&sc->axe_stat_ch);
1461:
1462: /* Stop transfers. */
1463: if (sc->axe_ep[AXE_ENDPT_RX] != NULL) {
1464: err = usbd_abort_pipe(sc->axe_ep[AXE_ENDPT_RX]);
1465: if (err) {
1466: printf("axe%d: abort rx pipe failed: %s\n",
1467: sc->axe_unit, usbd_errstr(err));
1468: }
1469: err = usbd_close_pipe(sc->axe_ep[AXE_ENDPT_RX]);
1470: if (err) {
1471: printf("axe%d: close rx pipe failed: %s\n",
1472: sc->axe_unit, usbd_errstr(err));
1473: }
1474: sc->axe_ep[AXE_ENDPT_RX] = NULL;
1475: }
1476:
1477: if (sc->axe_ep[AXE_ENDPT_TX] != NULL) {
1478: err = usbd_abort_pipe(sc->axe_ep[AXE_ENDPT_TX]);
1479: if (err) {
1480: printf("axe%d: abort tx pipe failed: %s\n",
1481: sc->axe_unit, usbd_errstr(err));
1482: }
1483: err = usbd_close_pipe(sc->axe_ep[AXE_ENDPT_TX]);
1484: if (err) {
1485: printf("axe%d: close tx pipe failed: %s\n",
1486: sc->axe_unit, usbd_errstr(err));
1487: }
1488: sc->axe_ep[AXE_ENDPT_TX] = NULL;
1489: }
1490:
1491: if (sc->axe_ep[AXE_ENDPT_INTR] != NULL) {
1492: err = usbd_abort_pipe(sc->axe_ep[AXE_ENDPT_INTR]);
1493: if (err) {
1494: printf("axe%d: abort intr pipe failed: %s\n",
1495: sc->axe_unit, usbd_errstr(err));
1496: }
1497: err = usbd_close_pipe(sc->axe_ep[AXE_ENDPT_INTR]);
1498: if (err) {
1499: printf("axe%d: close intr pipe failed: %s\n",
1500: sc->axe_unit, usbd_errstr(err));
1501: }
1502: sc->axe_ep[AXE_ENDPT_INTR] = NULL;
1503: }
1504:
1505: /* Free RX resources. */
1506: for (i = 0; i < AXE_RX_LIST_CNT; i++) {
1507: if (sc->axe_cdata.axe_rx_chain[i].axe_mbuf != NULL) {
1508: m_freem(sc->axe_cdata.axe_rx_chain[i].axe_mbuf);
1509: sc->axe_cdata.axe_rx_chain[i].axe_mbuf = NULL;
1510: }
1511: if (sc->axe_cdata.axe_rx_chain[i].axe_xfer != NULL) {
1512: usbd_free_xfer(sc->axe_cdata.axe_rx_chain[i].axe_xfer);
1513: sc->axe_cdata.axe_rx_chain[i].axe_xfer = NULL;
1514: }
1515: }
1516:
1517: /* Free TX resources. */
1518: for (i = 0; i < AXE_TX_LIST_CNT; i++) {
1519: if (sc->axe_cdata.axe_tx_chain[i].axe_mbuf != NULL) {
1520: m_freem(sc->axe_cdata.axe_tx_chain[i].axe_mbuf);
1521: sc->axe_cdata.axe_tx_chain[i].axe_mbuf = NULL;
1522: }
1523: if (sc->axe_cdata.axe_tx_chain[i].axe_xfer != NULL) {
1524: usbd_free_xfer(sc->axe_cdata.axe_tx_chain[i].axe_xfer);
1525: sc->axe_cdata.axe_tx_chain[i].axe_xfer = NULL;
1526: }
1527: }
1528:
1529: sc->axe_link = 0;
1530: }
1531:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_axe.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb