Annotation of src/sys/dev/usb/if_axen.c, Revision 1.9.2.1
1.9.2.1 ! pgoyette 1: /* $NetBSD: if_axen.c,v 1.11 2016/12/15 09:28:06 ozaki-r Exp $ */
1.1 nonaka 2: /* $OpenBSD: if_axen.c,v 1.3 2013/10/21 10:10:22 yuo Exp $ */
3:
4: /*
5: * Copyright (c) 2013 Yojiro UO <yuo@openbsd.org>
6: *
7: * Permission to use, copy, modify, and distribute this software for any
8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
10: *
11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18: */
19:
20: /*
21: * ASIX Electronics AX88178a USB 2.0 ethernet and AX88179 USB 3.0 Ethernet
1.8 skrll 22: * driver.
1.1 nonaka 23: */
24:
25: #include <sys/cdefs.h>
1.9.2.1 ! pgoyette 26: __KERNEL_RCSID(0, "$NetBSD: if_axen.c,v 1.11 2016/12/15 09:28:06 ozaki-r Exp $");
1.1 nonaka 27:
28: #ifdef _KERNEL_OPT
29: #include "opt_inet.h"
1.9.2.1 ! pgoyette 30: #include "opt_usb.h"
1.1 nonaka 31: #endif
32:
33: #include <sys/param.h>
34: #include <sys/bus.h>
35: #include <sys/device.h>
36: #include <sys/kernel.h>
37: #include <sys/mbuf.h>
38: #include <sys/module.h>
39: #include <sys/rwlock.h>
40: #include <sys/socket.h>
41: #include <sys/sockio.h>
42: #include <sys/systm.h>
43:
1.6 riastrad 44: #include <sys/rndsource.h>
1.1 nonaka 45:
46: #include <net/if.h>
47: #include <net/if_dl.h>
48: #include <net/if_ether.h>
49: #include <net/if_media.h>
50:
51: #include <net/bpf.h>
52:
53: #include <dev/mii/mii.h>
54: #include <dev/mii/miivar.h>
55:
56: #include <dev/usb/usb.h>
57: #include <dev/usb/usbdi.h>
58: #include <dev/usb/usbdi_util.h>
59: #include <dev/usb/usbdivar.h>
60: #include <dev/usb/usbdevs.h>
61:
62: #include <dev/usb/if_axenreg.h>
63:
64: #ifdef AXEN_DEBUG
65: #define DPRINTF(x) do { if (axendebug) printf x; } while (/*CONSTCOND*/0)
66: #define DPRINTFN(n,x) do { if (axendebug >= (n)) printf x; } while (/*CONSTCOND*/0)
67: int axendebug = 0;
68: #else
69: #define DPRINTF(x)
70: #define DPRINTFN(n,x)
71: #endif
72:
73: #define AXEN_TOE /* enable checksum offload function */
74:
75: /*
76: * Various supported device vendors/products.
77: */
78: static const struct axen_type axen_devs[] = {
79: #if 0 /* not tested */
80: { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88178A}, AX178A },
81: #endif
82: { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88179}, AX179 }
83: };
84:
85: #define axen_lookup(v, p) ((const struct axen_type *)usb_lookup(axen_devs, v, p))
86:
87: static int axen_match(device_t, cfdata_t, void *);
88: static void axen_attach(device_t, device_t, void *);
89: static int axen_detach(device_t, int);
90: static int axen_activate(device_t, devact_t);
91:
92: CFATTACH_DECL_NEW(axen, sizeof(struct axen_softc),
93: axen_match, axen_attach, axen_detach, axen_activate);
94:
95: static int axen_tx_list_init(struct axen_softc *);
96: static int axen_rx_list_init(struct axen_softc *);
97: static struct mbuf *axen_newbuf(void);
98: static int axen_encap(struct axen_softc *, struct mbuf *, int);
1.8 skrll 99: static void axen_rxeof(struct usbd_xfer *, void *, usbd_status);
100: static void axen_txeof(struct usbd_xfer *, void *, usbd_status);
1.1 nonaka 101: static void axen_tick(void *);
102: static void axen_tick_task(void *);
103: static void axen_start(struct ifnet *);
104: static int axen_ioctl(struct ifnet *, u_long, void *);
105: static int axen_init(struct ifnet *);
106: static void axen_stop(struct ifnet *, int);
107: static void axen_watchdog(struct ifnet *);
108: static int axen_miibus_readreg(device_t, int, int);
109: static void axen_miibus_writereg(device_t, int, int, int);
110: static void axen_miibus_statchg(struct ifnet *);
111: static int axen_cmd(struct axen_softc *, int, int, int, void *);
112: static int axen_ifmedia_upd(struct ifnet *);
113: static void axen_ifmedia_sts(struct ifnet *, struct ifmediareq *);
1.8 skrll 114: static void axen_reset(struct axen_softc *);
1.1 nonaka 115: #if 0
116: static int axen_ax88179_eeprom(struct axen_softc *, void *);
117: #endif
118:
119: static void axen_iff(struct axen_softc *);
1.8 skrll 120: static void axen_lock_mii(struct axen_softc *);
121: static void axen_unlock_mii(struct axen_softc *);
1.1 nonaka 122:
123: static void axen_ax88179_init(struct axen_softc *);
124:
125: /* Get exclusive access to the MII registers */
126: static void
127: axen_lock_mii(struct axen_softc *sc)
128: {
129:
130: sc->axen_refcnt++;
131: rw_enter(&sc->axen_mii_lock, RW_WRITER);
132: }
133:
134: static void
135: axen_unlock_mii(struct axen_softc *sc)
136: {
137:
138: rw_exit(&sc->axen_mii_lock);
139: if (--sc->axen_refcnt < 0)
140: usb_detach_wakeupold(sc->axen_dev);
141: }
142:
143: static int
144: axen_cmd(struct axen_softc *sc, int cmd, int index, int val, void *buf)
145: {
146: usb_device_request_t req;
147: usbd_status err;
148:
149: KASSERT(rw_lock_held(&sc->axen_mii_lock));
150:
151: if (sc->axen_dying)
152: return 0;
153:
154: if (AXEN_CMD_DIR(cmd))
155: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
156: else
157: req.bmRequestType = UT_READ_VENDOR_DEVICE;
158: req.bRequest = AXEN_CMD_CMD(cmd);
159: USETW(req.wValue, val);
160: USETW(req.wIndex, index);
161: USETW(req.wLength, AXEN_CMD_LEN(cmd));
162:
163: err = usbd_do_request(sc->axen_udev, &req, buf);
164: DPRINTFN(5, ("axen_cmd: cmd 0x%04x val 0x%04x len %d\n",
165: cmd, val, AXEN_CMD_LEN(cmd)));
166:
167: if (err) {
168: DPRINTF(("axen_cmd err: cmd: %d, error: %d\n", cmd, err));
169: return -1;
170: }
171:
172: return 0;
173: }
174:
175: static int
176: axen_miibus_readreg(device_t dev, int phy, int reg)
177: {
178: struct axen_softc *sc = device_private(dev);
179: usbd_status err;
180: uint16_t val;
181: int ival;
182:
183: if (sc->axen_dying) {
184: DPRINTF(("axen: dying\n"));
185: return 0;
186: }
187:
188: if (sc->axen_phyno != phy)
189: return 0;
190:
191: axen_lock_mii(sc);
192: err = axen_cmd(sc, AXEN_CMD_MII_READ_REG, reg, phy, &val);
193: axen_unlock_mii(sc);
194:
195: if (err) {
196: aprint_error_dev(sc->axen_dev, "read PHY failed\n");
197: return -1;
198: }
199:
200: ival = le16toh(val);
201: DPRINTFN(2,("axen_miibus_readreg: phy 0x%x reg 0x%x val 0x%x\n",
202: phy, reg, ival));
203:
204: if (reg == MII_BMSR) {
205: ival &= ~BMSR_EXTCAP;
206: }
207:
208: return ival;
209: }
210:
211: static void
212: axen_miibus_writereg(device_t dev, int phy, int reg, int val)
213: {
214: struct axen_softc *sc = device_private(dev);
215: usbd_status err;
216: uint16_t uval;
217:
218: if (sc->axen_dying)
219: return;
220:
221: if (sc->axen_phyno != phy)
222: return;
223:
224: uval = htole16(val);
225: axen_lock_mii(sc);
226: err = axen_cmd(sc, AXEN_CMD_MII_WRITE_REG, reg, phy, &uval);
227: axen_unlock_mii(sc);
228: DPRINTFN(2, ("axen_miibus_writereg: phy 0x%x reg 0x%x val 0x%0x\n",
229: phy, reg, val));
230:
231: if (err) {
232: aprint_error_dev(sc->axen_dev, "write PHY failed\n");
233: return;
234: }
235: }
236:
237: static void
238: axen_miibus_statchg(struct ifnet *ifp)
239: {
240: struct axen_softc *sc = ifp->if_softc;
241: struct mii_data *mii = GET_MII(sc);
242: int err;
243: uint16_t val;
244: uint16_t wval;
245:
246: sc->axen_link = 0;
247: if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
248: (IFM_ACTIVE | IFM_AVALID)) {
249: switch (IFM_SUBTYPE(mii->mii_media_active)) {
250: case IFM_10_T:
251: case IFM_100_TX:
252: sc->axen_link++;
253: break;
254: case IFM_1000_T:
255: sc->axen_link++;
256: break;
257: default:
258: break;
259: }
260: }
261:
262: /* Lost link, do nothing. */
263: if (sc->axen_link == 0)
264: return;
265:
266: val = 0;
267: if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
268: val |= AXEN_MEDIUM_FDX;
269:
270: val |= (AXEN_MEDIUM_RECV_EN | AXEN_MEDIUM_ALWAYS_ONE);
271: val |= (AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN);
272:
273: switch (IFM_SUBTYPE(mii->mii_media_active)) {
274: case IFM_1000_T:
275: val |= AXEN_MEDIUM_GIGA | AXEN_MEDIUM_EN_125MHZ;
276: break;
277: case IFM_100_TX:
278: val |= AXEN_MEDIUM_PS;
279: break;
280: case IFM_10_T:
281: /* doesn't need to be handled */
282: break;
283: }
284:
285: DPRINTF(("axen_miibus_statchg: val=0x%x\n", val));
286: wval = htole16(val);
287: axen_lock_mii(sc);
288: err = axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval);
289: axen_unlock_mii(sc);
290: if (err) {
291: aprint_error_dev(sc->axen_dev, "media change failed\n");
292: return;
293: }
294: }
295:
296: /*
297: * Set media options.
298: */
299: static int
300: axen_ifmedia_upd(struct ifnet *ifp)
301: {
302: struct axen_softc *sc = ifp->if_softc;
303: struct mii_data *mii = GET_MII(sc);
304: int rc;
305:
306: sc->axen_link = 0;
307:
308: if (mii->mii_instance) {
309: struct mii_softc *miisc;
310:
311: LIST_FOREACH(miisc, &mii->mii_phys, mii_list)
312: mii_phy_reset(miisc);
313: }
314:
315: if ((rc = mii_mediachg(mii)) == ENXIO)
316: return 0;
317: return rc;
318: }
319:
320: /*
321: * Report current media status.
322: */
323: static void
324: axen_ifmedia_sts(struct ifnet *ifp, struct ifmediareq *ifmr)
325: {
326: struct axen_softc *sc = ifp->if_softc;
327: struct mii_data *mii = GET_MII(sc);
328:
329: mii_pollstat(mii);
330: ifmr->ifm_active = mii->mii_media_active;
331: ifmr->ifm_status = mii->mii_media_status;
332: }
333:
334: static void
335: axen_iff(struct axen_softc *sc)
336: {
337: struct ifnet *ifp = GET_IFP(sc);
338: struct ethercom *ec = &sc->axen_ec;
339: struct ether_multi *enm;
340: struct ether_multistep step;
341: uint32_t h = 0;
342: uint16_t rxmode;
343: uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
344: uint16_t wval;
345:
346: if (sc->axen_dying)
347: return;
348:
349: rxmode = 0;
350:
351: /* Enable receiver, set RX mode */
352: axen_lock_mii(sc);
353: axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
354: rxmode = le16toh(wval);
355: rxmode &= ~(AXEN_RXCTL_ACPT_ALL_MCAST | AXEN_RXCTL_ACPT_PHY_MCAST |
356: AXEN_RXCTL_PROMISC);
357: ifp->if_flags &= ~IFF_ALLMULTI;
358:
359: /*
360: * Always accept broadcast frames.
361: * Always accept frames destined to our station address.
362: */
363: rxmode |= AXEN_RXCTL_ACPT_BCAST;
364:
365: if (ifp->if_flags & IFF_PROMISC || ec->ec_multicnt > 0 /* XXX */) {
366: ifp->if_flags |= IFF_ALLMULTI;
367: rxmode |= AXEN_RXCTL_ACPT_ALL_MCAST | AXEN_RXCTL_ACPT_PHY_MCAST;
368: if (ifp->if_flags & IFF_PROMISC)
369: rxmode |= AXEN_RXCTL_PROMISC;
370: } else {
371: rxmode |= AXEN_RXCTL_ACPT_ALL_MCAST | AXEN_RXCTL_ACPT_PHY_MCAST;
372:
373: /* now program new ones */
374: ETHER_FIRST_MULTI(step, ec, enm);
375: while (enm != NULL) {
376: h = ether_crc32_be(enm->enm_addrlo,
377: ETHER_ADDR_LEN) >> 26;
378: hashtbl[h / 8] |= 1 << (h % 8);
379: ETHER_NEXT_MULTI(step, enm);
380: }
381: }
382:
383: axen_cmd(sc, AXEN_CMD_MAC_WRITE_FILTER, 8, AXEN_FILTER_MULTI, hashtbl);
384: wval = htole16(rxmode);
385: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
386: axen_unlock_mii(sc);
387: }
388:
389: static void
390: axen_reset(struct axen_softc *sc)
391: {
392:
393: if (sc->axen_dying)
394: return;
395: /* XXX What to reset? */
396:
397: /* Wait a little while for the chip to get its brains in order. */
398: DELAY(1000);
399: }
400:
401: #if 0 /* not used */
402: #define AXEN_GPIO_WRITE(x,y) do { \
403: axen_cmd(sc, AXEN_CMD_WRITE_GPIO, 0, (x), NULL); \
404: usbd_delay_ms(sc->axen_udev, (y)); \
405: } while (/*CONSTCOND*/0)
406:
407: static int
408: axen_ax88179_eeprom(struct axen_softc *sc, void *addr)
409: {
410: int i, retry;
411: uint8_t eeprom[20];
412: uint16_t csum;
413: uint16_t buf;
414:
415: for (i = 0; i < 6; i++) {
416: /* set eeprom address */
417: buf = htole16(i);
418: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_ADDR, &buf);
419:
420: /* set eeprom command */
421: buf = htole16(AXEN_EEPROM_READ);
422: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_CMD, &buf);
423:
424: /* check the value is ready */
425: retry = 3;
426: do {
427: buf = htole16(AXEN_EEPROM_READ);
428: usbd_delay_ms(sc->axen_udev, 10);
429: axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MAC_EEPROM_CMD,
430: &buf);
431: retry--;
432: if (retry < 0)
433: return EINVAL;
434: } while ((le16toh(buf) & 0xff) & AXEN_EEPROM_BUSY);
435:
436: /* read data */
1.8 skrll 437: axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_EEPROM_READ,
1.1 nonaka 438: &eeprom[i * 2]);
439:
440: /* sanity check */
441: if ((i == 0) && (eeprom[0] == 0xff))
442: return EINVAL;
443: }
444:
445: /* check checksum */
446: csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9];
447: csum = (csum >> 8) + (csum & 0xff) + eeprom[10];
448: if (csum != 0xff) {
449: printf("eeprom checksum mismatchi(0x%02x)\n", csum);
450: return EINVAL;
451: }
452:
453: memcpy(addr, eeprom, ETHER_ADDR_LEN);
454: return 0;
455: }
456: #endif
457:
458: static void
459: axen_ax88179_init(struct axen_softc *sc)
460: {
461: struct axen_qctrl qctrl;
462: uint16_t ctl, temp;
463: uint16_t wval;
464: uint8_t val;
465:
466: axen_lock_mii(sc);
467:
468: /* XXX: ? */
469: axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_UNK_05, &val);
470: DPRINTFN(5, ("AXEN_CMD_MAC_READ(0x05): 0x%02x\n", val));
471:
472: /* check AX88179 version, UA1 / UA2 */
473: axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_GENERAL_STATUS, &val);
474: /* UA1 */
475: if (!(val & AXEN_GENERAL_STATUS_MASK)) {
476: sc->axen_rev = AXEN_REV_UA1;
477: DPRINTF(("AX88179 ver. UA1\n"));
478: } else {
479: sc->axen_rev = AXEN_REV_UA2;
480: DPRINTF(("AX88179 ver. UA2\n"));
481: }
482:
483: /* power up ethernet PHY */
484: wval = htole16(0);
485: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
486:
487: wval = htole16(AXEN_PHYPWR_RSTCTL_IPRL);
488: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
489: usbd_delay_ms(sc->axen_udev, 200);
490:
491: /* set clock mode */
492: val = AXEN_PHYCLK_ACS | AXEN_PHYCLK_BCS;
493: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
494: usbd_delay_ms(sc->axen_udev, 100);
495:
496: /* set monitor mode (disable) */
497: val = AXEN_MONITOR_NONE;
498: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val);
499:
500: /* enable auto detach */
501: axen_cmd(sc, AXEN_CMD_EEPROM_READ, 2, AXEN_EEPROM_STAT, &wval);
502: temp = le16toh(wval);
503: DPRINTFN(2,("EEPROM0x43 = 0x%04x\n", temp));
504: if (!(temp == 0xffff) && !(temp & 0x0100)) {
505: /* Enable auto detach bit */
506: val = 0;
507: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
508: val = AXEN_PHYCLK_ULR;
509: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
510: usbd_delay_ms(sc->axen_udev, 100);
511:
512: axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_PHYPWR_RSTCTL, &wval);
513: ctl = le16toh(wval);
514: ctl |= AXEN_PHYPWR_RSTCTL_AUTODETACH;
515: wval = htole16(ctl);
516: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
517: usbd_delay_ms(sc->axen_udev, 200);
518: aprint_error_dev(sc->axen_dev, "enable auto detach (0x%04x)\n",
519: ctl);
520: }
521:
522: /* bulkin queue setting */
523: axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_USB_UPLINK, &val);
524: switch (val) {
525: case AXEN_USB_FS:
526: DPRINTF(("uplink: USB1.1\n"));
527: qctrl.ctrl = 0x07;
528: qctrl.timer_low = 0xcc;
529: qctrl.timer_high = 0x4c;
530: qctrl.bufsize = AXEN_BUFSZ_LS - 1;
531: qctrl.ifg = 0x08;
532: break;
533: case AXEN_USB_HS:
534: DPRINTF(("uplink: USB2.0\n"));
535: qctrl.ctrl = 0x07;
536: qctrl.timer_low = 0x02;
537: qctrl.timer_high = 0xa0;
538: qctrl.bufsize = AXEN_BUFSZ_HS - 1;
539: qctrl.ifg = 0xff;
540: break;
541: case AXEN_USB_SS:
542: DPRINTF(("uplink: USB3.0\n"));
543: qctrl.ctrl = 0x07;
544: qctrl.timer_low = 0x4f;
545: qctrl.timer_high = 0x00;
546: qctrl.bufsize = AXEN_BUFSZ_SS - 1;
547: qctrl.ifg = 0xff;
548: break;
549: default:
550: aprint_error_dev(sc->axen_dev, "unknown uplink bus:0x%02x\n",
551: val);
552: axen_unlock_mii(sc);
553: return;
554: }
555: axen_cmd(sc, AXEN_CMD_MAC_SET_RXSR, 5, AXEN_RX_BULKIN_QCTRL, &qctrl);
556:
557: /*
558: * set buffer high/low watermark to pause/resume.
559: * write 2byte will set high/log simultaneous with AXEN_PAUSE_HIGH.
560: * XXX: what is the best value? OSX driver uses 0x3c-0x4c as LOW-HIGH
561: * watermark parameters.
562: */
563: val = 0x34;
564: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_LOW_WATERMARK, &val);
565: val = 0x52;
566: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_HIGH_WATERMARK, &val);
567:
568: /* Set RX/TX configuration. */
569: /* Offloadng enable */
570: #ifdef AXEN_TOE
571: val = AXEN_RXCOE_IPv4 | AXEN_RXCOE_TCPv4 | AXEN_RXCOE_UDPv4 |
572: AXEN_RXCOE_TCPv6 | AXEN_RXCOE_UDPv6;
573: #else
574: val = AXEN_RXCOE_OFF;
575: #endif
576: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_RX_COE, &val);
577:
578: #ifdef AXEN_TOE
579: val = AXEN_TXCOE_IPv4 | AXEN_TXCOE_TCPv4 | AXEN_TXCOE_UDPv4 |
580: AXEN_TXCOE_TCPv6 | AXEN_TXCOE_UDPv6;
581: #else
582: val = AXEN_TXCOE_OFF;
583: #endif
584: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_TX_COE, &val);
585:
586: /* Set RX control register */
587: ctl = AXEN_RXCTL_IPE | AXEN_RXCTL_DROPCRCERR | AXEN_RXCTL_AUTOB;
588: ctl |= AXEN_RXCTL_ACPT_PHY_MCAST | AXEN_RXCTL_ACPT_ALL_MCAST;
589: ctl |= AXEN_RXCTL_START;
590: wval = htole16(ctl);
591: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
592:
593: /* set monitor mode (enable) */
594: val = AXEN_MONITOR_PMETYPE | AXEN_MONITOR_PMEPOL | AXEN_MONITOR_RWMP;
595: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val);
596: axen_cmd(sc, AXEN_CMD_MAC_READ, 1, AXEN_MONITOR_MODE, &val);
597: DPRINTF(("axen: Monitor mode = 0x%02x\n", val));
598:
599: /* set medium type */
600: ctl = AXEN_MEDIUM_GIGA | AXEN_MEDIUM_FDX | AXEN_MEDIUM_ALWAYS_ONE |
601: AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN;
602: ctl |= AXEN_MEDIUM_RECV_EN;
603: wval = htole16(ctl);
604: DPRINTF(("axen: set to medium mode: 0x%04x\n", ctl));
605: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval);
606: usbd_delay_ms(sc->axen_udev, 100);
607:
608: axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MEDIUM_STATUS, &wval);
609: DPRINTF(("axen: current medium mode: 0x%04x\n", le16toh(wval)));
610:
611: axen_unlock_mii(sc);
612:
613: #if 0 /* XXX: TBD.... */
614: #define GMII_LED_ACTIVE 0x1a
615: #define GMII_PHY_PAGE_SEL 0x1e
616: #define GMII_PHY_PAGE_SEL 0x1f
617: #define GMII_PAGE_EXT 0x0007
618: axen_miibus_writereg(&sc->axen_dev, sc->axen_phyno, GMII_PHY_PAGE_SEL,
619: GMII_PAGE_EXT);
620: axen_miibus_writereg(&sc->axen_dev, sc->axen_phyno, GMII_PHY_PAGE,
621: 0x002c);
622: #endif
623:
624: #if 1 /* XXX: phy hack ? */
625: axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x1F, 0x0005);
626: axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x0C, 0x0000);
627: val = axen_miibus_readreg(sc->axen_dev, sc->axen_phyno, 0x0001);
628: axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x01,
629: val | 0x0080);
630: axen_miibus_writereg(sc->axen_dev, sc->axen_phyno, 0x1F, 0x0000);
631: #endif
632: }
633:
634: static int
635: axen_match(device_t parent, cfdata_t match, void *aux)
636: {
637: struct usb_attach_arg *uaa = aux;
638:
1.8 skrll 639: return axen_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
1.1 nonaka 640: UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
641: }
642:
643: static void
644: axen_attach(device_t parent, device_t self, void *aux)
645: {
646: struct axen_softc *sc = device_private(self);
647: struct usb_attach_arg *uaa = aux;
1.8 skrll 648: struct usbd_device *dev = uaa->uaa_device;
1.1 nonaka 649: usbd_status err;
650: usb_interface_descriptor_t *id;
651: usb_endpoint_descriptor_t *ed;
652: struct mii_data *mii;
653: uint8_t eaddr[ETHER_ADDR_LEN];
654: char *devinfop;
655: const char *devname = device_xname(self);
656: struct ifnet *ifp;
657: int i, s;
658:
659: aprint_naive("\n");
660: aprint_normal("\n");
661:
662: sc->axen_dev = self;
663: sc->axen_udev = dev;
664:
665: devinfop = usbd_devinfo_alloc(dev, 0);
666: aprint_normal_dev(self, "%s\n", devinfop);
667: usbd_devinfo_free(devinfop);
668:
669: err = usbd_set_config_no(dev, AXEN_CONFIG_NO, 1);
670: if (err) {
671: aprint_error_dev(self, "failed to set configuration"
672: ", err=%s\n", usbd_errstr(err));
673: return;
674: }
675:
1.8 skrll 676: sc->axen_flags = axen_lookup(uaa->uaa_vendor, uaa->uaa_product)->axen_flags;
1.1 nonaka 677:
678: rw_init(&sc->axen_mii_lock);
679: usb_init_task(&sc->axen_tick_task, axen_tick_task, sc, 0);
680:
681: err = usbd_device2interface_handle(dev, AXEN_IFACE_IDX,&sc->axen_iface);
682: if (err) {
683: aprint_error_dev(self, "getting interface handle failed\n");
684: return;
685: }
686:
1.8 skrll 687: sc->axen_product = uaa->uaa_product;
688: sc->axen_vendor = uaa->uaa_vendor;
1.1 nonaka 689:
690: id = usbd_get_interface_descriptor(sc->axen_iface);
691:
692: /* decide on what our bufsize will be */
1.8 skrll 693: switch (sc->axen_udev->ud_speed) {
1.4 nonaka 694: case USB_SPEED_SUPER:
695: sc->axen_bufsz = AXEN_BUFSZ_SS * 1024;
696: break;
697: case USB_SPEED_HIGH:
698: sc->axen_bufsz = AXEN_BUFSZ_HS * 1024;
699: break;
700: default:
701: sc->axen_bufsz = AXEN_BUFSZ_LS * 1024;
702: break;
703: }
1.1 nonaka 704:
705: /* Find endpoints. */
706: for (i = 0; i < id->bNumEndpoints; i++) {
707: ed = usbd_interface2endpoint_descriptor(sc->axen_iface, i);
708: if (!ed) {
709: aprint_error_dev(self, "couldn't get ep %d\n", i);
710: return;
711: }
712: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
713: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
714: sc->axen_ed[AXEN_ENDPT_RX] = ed->bEndpointAddress;
715: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
716: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
717: sc->axen_ed[AXEN_ENDPT_TX] = ed->bEndpointAddress;
718: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
719: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
720: sc->axen_ed[AXEN_ENDPT_INTR] = ed->bEndpointAddress;
721: }
722: }
723:
724: s = splnet();
725:
726: sc->axen_phyno = AXEN_PHY_ID;
727: DPRINTF(("%s: phyno %d\n", device_xname(self), sc->axen_phyno));
728:
729: /*
730: * Get station address.
731: */
732: #if 0 /* read from eeprom */
733: if (axen_ax88179_eeprom(sc, &eaddr)) {
734: printf("EEPROM checksum error\n");
735: return;
736: }
737: #else /* use MAC command */
738: axen_lock_mii(sc);
739: axen_cmd(sc, AXEN_CMD_MAC_READ_ETHER, 6, AXEN_CMD_MAC_NODE_ID, &eaddr);
740: axen_unlock_mii(sc);
741: #endif
742: axen_ax88179_init(sc);
743:
744: /*
745: * An ASIX chip was detected. Inform the world.
746: */
747: if (sc->axen_flags & AX178A)
748: aprint_normal_dev(self, "AX88178a\n");
749: else if (sc->axen_flags & AX179)
750: aprint_normal_dev(self, "AX88179\n");
751: aprint_normal_dev(self, "Ethernet address %s\n", ether_sprintf(eaddr));
752:
753: /* Initialize interface info.*/
754:
755: ifp = &sc->sc_if;
756: ifp->if_softc = sc;
757: strlcpy(ifp->if_xname, devname, IFNAMSIZ);
758: ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
759: ifp->if_ioctl = axen_ioctl;
760: ifp->if_start = axen_start;
761: ifp->if_init = axen_init;
762: ifp->if_stop = axen_stop;
763: ifp->if_watchdog = axen_watchdog;
764:
765: IFQ_SET_READY(&ifp->if_snd);
766:
767: sc->axen_ec.ec_capabilities = ETHERCAP_VLAN_MTU;
768: #ifdef AXEN_TOE
769: ifp->if_capabilities |= IFCAP_CSUM_IPv4_Rx | IFCAP_CSUM_IPv4_Tx |
770: IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv4_Tx |
771: IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv4_Tx |
772: IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_TCPv6_Tx |
773: IFCAP_CSUM_UDPv6_Rx | IFCAP_CSUM_UDPv6_Tx;
774: #endif
775:
776: /* Initialize MII/media info. */
777: mii = &sc->axen_mii;
778: mii->mii_ifp = ifp;
779: mii->mii_readreg = axen_miibus_readreg;
780: mii->mii_writereg = axen_miibus_writereg;
781: mii->mii_statchg = axen_miibus_statchg;
782: mii->mii_flags = MIIF_AUTOTSLEEP;
783:
784: sc->axen_ec.ec_mii = mii;
785: ifmedia_init(&mii->mii_media, 0, axen_ifmedia_upd, axen_ifmedia_sts);
786: mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
787:
788: if (LIST_FIRST(&mii->mii_phys) == NULL) {
789: ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
790: ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
791: } else
792: ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
793:
794: /* Attach the interface. */
795: if_attach(ifp);
796: ether_ifattach(ifp, eaddr);
797: rnd_attach_source(&sc->rnd_source, device_xname(sc->axen_dev),
1.3 tls 798: RND_TYPE_NET, RND_FLAG_DEFAULT);
1.1 nonaka 799:
800: callout_init(&sc->axen_stat_ch, 0);
801: callout_setfunc(&sc->axen_stat_ch, axen_tick, sc);
802:
803: sc->axen_attached = true;
804: splx(s);
805:
806: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->axen_udev,sc->axen_dev);
1.5 nonaka 807:
808: if (!pmf_device_register(self, NULL, NULL))
809: aprint_error_dev(self, "couldn't establish power handler\n");
1.1 nonaka 810: }
811:
812: static int
813: axen_detach(device_t self, int flags)
814: {
815: struct axen_softc *sc = device_private(self);
816: struct ifnet *ifp = GET_IFP(sc);
817: int s;
818:
819: DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
820:
821: /* Detached before attached finished, so just bail out. */
822: if (!sc->axen_attached)
823: return 0;
824:
1.5 nonaka 825: pmf_device_deregister(self);
826:
1.1 nonaka 827: sc->axen_dying = true;
828:
829: /*
830: * Remove any pending tasks. They cannot be executing because they run
831: * in the same thread as detach.
832: */
833: usb_rem_task(sc->axen_udev, &sc->axen_tick_task);
834:
835: s = splusb();
836:
837: if (ifp->if_flags & IFF_RUNNING)
838: axen_stop(ifp, 1);
839:
840: callout_destroy(&sc->axen_stat_ch);
841: rnd_detach_source(&sc->rnd_source);
842: mii_detach(&sc->axen_mii, MII_PHY_ANY, MII_OFFSET_ANY);
843: ifmedia_delete_instance(&sc->axen_mii.mii_media, IFM_INST_ANY);
844: ether_ifdetach(ifp);
845: if_detach(ifp);
846:
847: #ifdef DIAGNOSTIC
848: if (sc->axen_ep[AXEN_ENDPT_TX] != NULL ||
849: sc->axen_ep[AXEN_ENDPT_RX] != NULL ||
850: sc->axen_ep[AXEN_ENDPT_INTR] != NULL)
851: aprint_debug_dev(self, "detach has active endpoints\n");
852: #endif
853:
854: sc->axen_attached = false;
855:
856: if (--sc->axen_refcnt >= 0) {
857: /* Wait for processes to go away. */
858: usb_detach_waitold(sc->axen_dev);
859: }
860: splx(s);
861:
862: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->axen_udev,sc->axen_dev);
863:
864: rw_destroy(&sc->axen_mii_lock);
865:
866: return 0;
867: }
868:
869: static int
870: axen_activate(device_t self, devact_t act)
871: {
872: struct axen_softc *sc = device_private(self);
873: struct ifnet *ifp = GET_IFP(sc);
874:
875: DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
876:
877: switch (act) {
878: case DVACT_DEACTIVATE:
879: if_deactivate(ifp);
880: sc->axen_dying = true;
881: return 0;
882: default:
883: return EOPNOTSUPP;
884: }
885: }
886:
887: static struct mbuf *
888: axen_newbuf(void)
889: {
890: struct mbuf *m;
891:
892: MGETHDR(m, M_DONTWAIT, MT_DATA);
893: if (m == NULL)
894: return NULL;
895:
896: MCLGET(m, M_DONTWAIT);
897: if (!(m->m_flags & M_EXT)) {
898: m_freem(m);
899: return NULL;
900: }
901:
902: m->m_len = m->m_pkthdr.len = MCLBYTES;
903: m_adj(m, ETHER_ALIGN);
904:
905: return m;
906: }
907:
908: static int
909: axen_rx_list_init(struct axen_softc *sc)
910: {
911: struct axen_cdata *cd;
912: struct axen_chain *c;
913: int i;
914:
915: DPRINTF(("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
916:
917: cd = &sc->axen_cdata;
918: for (i = 0; i < AXEN_RX_LIST_CNT; i++) {
919: c = &cd->axen_rx_chain[i];
920: c->axen_sc = sc;
921: c->axen_idx = i;
922: if (c->axen_xfer == NULL) {
1.8 skrll 923: int err = usbd_create_xfer(sc->axen_ep[AXEN_ENDPT_RX],
924: sc->axen_bufsz, USBD_SHORT_XFER_OK, 0,
925: &c->axen_xfer);
926: if (err)
927: return err;
928: c->axen_buf = usbd_get_buffer(c->axen_xfer);
1.1 nonaka 929: }
930: }
931:
932: return 0;
933: }
934:
935: static int
936: axen_tx_list_init(struct axen_softc *sc)
937: {
938: struct axen_cdata *cd;
939: struct axen_chain *c;
940: int i;
941:
942: DPRINTF(("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
943:
944: cd = &sc->axen_cdata;
945: for (i = 0; i < AXEN_TX_LIST_CNT; i++) {
946: c = &cd->axen_tx_chain[i];
947: c->axen_sc = sc;
948: c->axen_idx = i;
949: if (c->axen_xfer == NULL) {
1.8 skrll 950: int err = usbd_create_xfer(sc->axen_ep[AXEN_ENDPT_TX],
951: sc->axen_bufsz, USBD_FORCE_SHORT_XFER, 0,
952: &c->axen_xfer);
953: if (err)
954: return err;
955: c->axen_buf = usbd_get_buffer(c->axen_xfer);
1.1 nonaka 956: }
957: }
958:
959: return 0;
960: }
961:
962: /*
963: * A frame has been uploaded: pass the resulting mbuf chain up to
964: * the higher level protocols.
965: */
966: static void
1.8 skrll 967: axen_rxeof(struct usbd_xfer *xfer, void * priv, usbd_status status)
1.1 nonaka 968: {
969: struct axen_chain *c = (struct axen_chain *)priv;
970: struct axen_softc *sc = c->axen_sc;
971: struct ifnet *ifp = GET_IFP(sc);
972: uint8_t *buf = c->axen_buf;
973: struct mbuf *m;
974: uint32_t total_len;
975: uint32_t rx_hdr, pkt_hdr;
976: uint32_t *hdr_p;
977: uint16_t hdr_offset, pkt_count;
978: size_t pkt_len;
979: size_t temp;
980: int s;
981:
982: DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->axen_dev), __func__));
983:
984: if (sc->axen_dying)
985: return;
986:
987: if (!(ifp->if_flags & IFF_RUNNING))
988: return;
989:
990: if (status != USBD_NORMAL_COMPLETION) {
991: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
992: return;
993: if (usbd_ratecheck(&sc->axen_rx_notice)) {
994: aprint_error_dev(sc->axen_dev, "usb errors on rx: %s\n",
995: usbd_errstr(status));
996: }
997: if (status == USBD_STALLED)
998: usbd_clear_endpoint_stall_async(sc->axen_ep[AXEN_ENDPT_RX]);
999: goto done;
1000: }
1001:
1002: usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
1003:
1004: if (total_len < sizeof(pkt_hdr)) {
1005: ifp->if_ierrors++;
1006: goto done;
1007: }
1008:
1.8 skrll 1009: /*
1.1 nonaka 1010: * buffer map
1011: * [packet #0]...[packet #n][pkt hdr#0]..[pkt hdr#n][recv_hdr]
1012: * each packet has 0xeeee as psuedo header..
1013: */
1014: hdr_p = (uint32_t *)(buf + total_len - sizeof(uint32_t));
1015: rx_hdr = le32toh(*hdr_p);
1016: hdr_offset = (uint16_t)(rx_hdr >> 16);
1017: pkt_count = (uint16_t)(rx_hdr & 0xffff);
1018:
1019: if (total_len > sc->axen_bufsz) {
1020: aprint_error_dev(sc->axen_dev, "rxeof: too large transfer\n");
1021: goto done;
1022: }
1.8 skrll 1023:
1.1 nonaka 1024: /* sanity check */
1.2 joerg 1025: if (hdr_offset > total_len) {
1.1 nonaka 1026: ifp->if_ierrors++;
1027: usbd_delay_ms(sc->axen_udev, 100);
1028: goto done;
1029: }
1030:
1031: /* point first packet header */
1032: hdr_p = (uint32_t *)(buf + hdr_offset);
1033:
1034: /*
1035: * ax88179 will pack multiple ip packet to a USB transaction.
1036: * process all of packets in the buffer
1037: */
1038:
1039: #if 1 /* XXX: paranoiac check. need to remove later */
1.8 skrll 1040: #define AXEN_MAX_PACKED_PACKET 200
1.1 nonaka 1041: if (pkt_count > AXEN_MAX_PACKED_PACKET) {
1.8 skrll 1042: DPRINTF(("%s: Too many packets (%d) in a transaction, discard.\n",
1.1 nonaka 1043: device_xname(sc->axen_dev), pkt_count));
1044: goto done;
1045: }
1046: #endif
1047:
1048: do {
1049: if ((buf[0] != 0xee) || (buf[1] != 0xee)){
1050: aprint_error_dev(sc->axen_dev,
1051: "invalid buffer(pkt#%d), continue\n", pkt_count);
1052: ifp->if_ierrors += pkt_count;
1053: goto done;
1054: }
1055:
1056: pkt_hdr = le32toh(*hdr_p);
1057: pkt_len = (pkt_hdr >> 16) & 0x1fff;
1058: DPRINTFN(10,
1.8 skrll 1059: ("%s: rxeof: packet#%d, pkt_hdr 0x%08x, pkt_len %zu\n",
1.1 nonaka 1060: device_xname(sc->axen_dev), pkt_count, pkt_hdr, pkt_len));
1061:
1062: if ((pkt_hdr & AXEN_RXHDR_CRC_ERR) ||
1063: (pkt_hdr & AXEN_RXHDR_DROP_ERR)) {
1064: ifp->if_ierrors++;
1065: /* move to next pkt header */
1066: DPRINTF(("%s: crc err (pkt#%d)\n",
1067: device_xname(sc->axen_dev), pkt_count));
1068: goto nextpkt;
1069: }
1070:
1071: /* process each packet */
1072: /* allocate mbuf */
1073: m = axen_newbuf();
1074: if (m == NULL) {
1075: ifp->if_ierrors++;
1076: goto nextpkt;
1077: }
1078:
1079: /* skip pseudo header (2byte) */
1.9 ozaki-r 1080: m_set_rcvif(m, ifp);
1.4 nonaka 1081: m->m_pkthdr.len = m->m_len = pkt_len - 6;
1.1 nonaka 1082:
1083: #ifdef AXEN_TOE
1084: /* cheksum err */
1.8 skrll 1085: if ((pkt_hdr & AXEN_RXHDR_L3CSUM_ERR) ||
1.1 nonaka 1086: (pkt_hdr & AXEN_RXHDR_L4CSUM_ERR)) {
1087: aprint_error_dev(sc->axen_dev,
1088: "checksum err (pkt#%d)\n", pkt_count);
1089: goto nextpkt;
1090: } else {
1091: m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
1092: }
1093:
1.8 skrll 1094: int l4_type = (pkt_hdr & AXEN_RXHDR_L4_TYPE_MASK) >>
1.1 nonaka 1095: AXEN_RXHDR_L4_TYPE_OFFSET;
1096:
1097: if ((l4_type == AXEN_RXHDR_L4_TYPE_TCP) ||
1098: (l4_type == AXEN_RXHDR_L4_TYPE_UDP)) {
1099: m->m_pkthdr.csum_flags |= M_CSUM_TCPv4 |
1100: M_CSUM_UDPv4; /* XXX v6? */
1101: }
1102: #endif
1103:
1.4 nonaka 1104: memcpy(mtod(m, char *), buf + 2, pkt_len - 6);
1.1 nonaka 1105:
1106: /* push the packet up */
1107: s = splnet();
1.7 ozaki-r 1108: if_percpuq_enqueue((ifp)->if_percpuq, (m));
1.1 nonaka 1109: splx(s);
1110:
1111: nextpkt:
1112: /*
1.8 skrll 1113: * prepare next packet
1.1 nonaka 1114: * as each packet will be aligned 8byte boundary,
1115: * need to fix up the start point of the buffer.
1116: */
1117: temp = ((pkt_len + 7) & 0xfff8);
1118: buf = buf + temp;
1119: hdr_p++;
1120: pkt_count--;
1121: } while( pkt_count > 0);
1122:
1123: done:
1124: /* clear buffer for next transaction */
1125: memset(c->axen_buf, 0, sc->axen_bufsz);
1126:
1127: /* Setup new transfer. */
1.8 skrll 1128: usbd_setup_xfer(xfer, c, c->axen_buf, sc->axen_bufsz,
1129: USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, axen_rxeof);
1.1 nonaka 1130: usbd_transfer(xfer);
1131:
1132: DPRINTFN(10,("%s: %s: start rx\n",device_xname(sc->axen_dev),__func__));
1133: }
1134:
1135: /*
1136: * A frame was downloaded to the chip. It's safe for us to clean up
1137: * the list buffers.
1138: */
1139: static void
1.8 skrll 1140: axen_txeof(struct usbd_xfer *xfer, void * priv, usbd_status status)
1.1 nonaka 1141: {
1142: struct axen_chain *c = (struct axen_chain *)priv;
1143: struct axen_softc *sc = c->axen_sc;
1144: struct ifnet *ifp = GET_IFP(sc);
1145: int s;
1146:
1147: if (sc->axen_dying)
1148: return;
1149:
1150: s = splnet();
1151:
1152: if (status != USBD_NORMAL_COMPLETION) {
1153: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1154: splx(s);
1155: return;
1156: }
1157: ifp->if_oerrors++;
1158: aprint_error_dev(sc->axen_dev, "usb error on tx: %s\n",
1159: usbd_errstr(status));
1160: if (status == USBD_STALLED)
1161: usbd_clear_endpoint_stall_async(sc->axen_ep[AXEN_ENDPT_TX]);
1162: splx(s);
1163: return;
1164: }
1165:
1166: ifp->if_timer = 0;
1167: ifp->if_flags &= ~IFF_OACTIVE;
1168:
1169: if (!IFQ_IS_EMPTY(&ifp->if_snd))
1170: axen_start(ifp);
1171:
1172: ifp->if_opackets++;
1173: splx(s);
1174: }
1175:
1176: static void
1177: axen_tick(void *xsc)
1178: {
1179: struct axen_softc *sc = xsc;
1180:
1181: if (sc == NULL)
1182: return;
1183:
1184: DPRINTFN(0xff,("%s: %s: enter\n", device_xname(sc->axen_dev),__func__));
1185:
1186: if (sc->axen_dying)
1187: return;
1188:
1189: /* Perform periodic stuff in process context */
1190: usb_add_task(sc->axen_udev, &sc->axen_tick_task, USB_TASKQ_DRIVER);
1191: }
1192:
1193: static void
1194: axen_tick_task(void *xsc)
1195: {
1196: int s;
1197: struct axen_softc *sc;
1198: struct ifnet *ifp;
1199: struct mii_data *mii;
1200:
1201: sc = xsc;
1202:
1203: if (sc == NULL)
1204: return;
1205:
1206: if (sc->axen_dying)
1207: return;
1208:
1209: ifp = GET_IFP(sc);
1210: mii = GET_MII(sc);
1211: if (mii == NULL)
1212: return;
1213:
1214: s = splnet();
1215:
1216: mii_tick(mii);
1217: if (sc->axen_link == 0 &&
1218: (mii->mii_media_status & IFM_ACTIVE) != 0 &&
1219: IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
1220: DPRINTF(("%s: %s: got link\n", device_xname(sc->axen_dev),
1221: __func__));
1222: sc->axen_link++;
1223: if (!IFQ_IS_EMPTY(&ifp->if_snd))
1224: axen_start(ifp);
1225: }
1226:
1227: callout_schedule(&sc->axen_stat_ch, hz);
1228:
1229: splx(s);
1230: }
1231:
1232: static int
1233: axen_encap(struct axen_softc *sc, struct mbuf *m, int idx)
1234: {
1235: struct ifnet *ifp = GET_IFP(sc);
1236: struct axen_chain *c;
1237: usbd_status err;
1238: struct axen_sframe_hdr hdr;
1239: int length, boundary;
1240:
1241: c = &sc->axen_cdata.axen_tx_chain[idx];
1242:
1.8 skrll 1243: boundary = (sc->axen_udev->ud_speed == USB_SPEED_HIGH) ? 512 : 64;
1.1 nonaka 1244:
1245: hdr.plen = htole32(m->m_pkthdr.len);
1246: hdr.gso = 0; /* disable segmentation offloading */
1247:
1248: memcpy(c->axen_buf, &hdr, sizeof(hdr));
1249: length = sizeof(hdr);
1250:
1251: m_copydata(m, 0, m->m_pkthdr.len, c->axen_buf + length);
1252: length += m->m_pkthdr.len;
1253:
1254: if ((length % boundary) == 0) {
1255: hdr.plen = 0x0;
1256: hdr.gso |= 0x80008000; /* enable padding */
1257: memcpy(c->axen_buf + length, &hdr, sizeof(hdr));
1258: length += sizeof(hdr);
1259: }
1260:
1.8 skrll 1261: usbd_setup_xfer(c->axen_xfer, c, c->axen_buf, length,
1262: USBD_FORCE_SHORT_XFER, 10000, axen_txeof);
1.1 nonaka 1263:
1264: /* Transmit */
1265: err = usbd_transfer(c->axen_xfer);
1266: if (err != USBD_IN_PROGRESS) {
1267: axen_stop(ifp, 0);
1268: return EIO;
1269: }
1270:
1271: sc->axen_cdata.axen_tx_cnt++;
1272:
1273: return 0;
1274: }
1275:
1276: static void
1277: axen_start(struct ifnet *ifp)
1278: {
1279: struct axen_softc *sc;
1280: struct mbuf *m;
1281:
1282: sc = ifp->if_softc;
1283:
1284: if (sc->axen_link == 0)
1285: return;
1286:
1287: if ((ifp->if_flags & (IFF_OACTIVE|IFF_RUNNING)) != IFF_RUNNING)
1288: return;
1289:
1290: IFQ_POLL(&ifp->if_snd, m);
1291: if (m == NULL)
1292: return;
1293:
1294: if (axen_encap(sc, m, 0)) {
1295: ifp->if_flags |= IFF_OACTIVE;
1296: return;
1297: }
1298: IFQ_DEQUEUE(&ifp->if_snd, m);
1299:
1300: /*
1301: * If there's a BPF listener, bounce a copy of this frame
1302: * to him.
1303: */
1304: bpf_mtap(ifp, m);
1305: m_freem(m);
1306:
1307: ifp->if_flags |= IFF_OACTIVE;
1308:
1309: /*
1310: * Set a timeout in case the chip goes out to lunch.
1311: */
1312: ifp->if_timer = 5;
1313: }
1314:
1315: static int
1316: axen_init(struct ifnet *ifp)
1317: {
1318: struct axen_softc *sc = ifp->if_softc;
1319: struct axen_chain *c;
1320: usbd_status err;
1321: int i, s;
1322: uint16_t rxmode;
1323: uint16_t wval;
1324: uint8_t bval;
1325:
1326: s = splnet();
1327:
1328: if (ifp->if_flags & IFF_RUNNING)
1329: axen_stop(ifp, 0);
1330:
1331: /*
1332: * Cancel pending I/O and free all RX/TX buffers.
1333: */
1334: axen_reset(sc);
1335:
1336: /* XXX: ? */
1337: axen_lock_mii(sc);
1338: bval = 0x01;
1339: axen_cmd(sc, AXEN_CMD_MAC_WRITE, 1, AXEN_UNK_28, &bval);
1340: axen_unlock_mii(sc);
1341:
1342: /* Program promiscuous mode and multicast filters. */
1343: axen_iff(sc);
1344:
1345: /* Enable receiver, set RX mode */
1346: axen_lock_mii(sc);
1347: axen_cmd(sc, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
1348: rxmode = le16toh(wval);
1349: rxmode |= AXEN_RXCTL_START;
1350: wval = htole16(rxmode);
1351: axen_cmd(sc, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
1352: axen_unlock_mii(sc);
1353:
1354: /* Open RX and TX pipes. */
1355: err = usbd_open_pipe(sc->axen_iface, sc->axen_ed[AXEN_ENDPT_RX],
1356: USBD_EXCLUSIVE_USE, &sc->axen_ep[AXEN_ENDPT_RX]);
1357: if (err) {
1358: aprint_error_dev(sc->axen_dev, "open rx pipe failed: %s\n",
1359: usbd_errstr(err));
1360: splx(s);
1361: return EIO;
1362: }
1363:
1364: err = usbd_open_pipe(sc->axen_iface, sc->axen_ed[AXEN_ENDPT_TX],
1365: USBD_EXCLUSIVE_USE, &sc->axen_ep[AXEN_ENDPT_TX]);
1366: if (err) {
1367: aprint_error_dev(sc->axen_dev, "open tx pipe failed: %s\n",
1368: usbd_errstr(err));
1369: splx(s);
1370: return EIO;
1371: }
1372:
1.8 skrll 1373: /* Init RX ring. */
1374: if (axen_rx_list_init(sc)) {
1375: aprint_error_dev(sc->axen_dev, "rx list init failed\n");
1376: splx(s);
1377: return ENOBUFS;
1378: }
1379:
1380: /* Init TX ring. */
1381: if (axen_tx_list_init(sc)) {
1382: aprint_error_dev(sc->axen_dev, "tx list init failed\n");
1383: splx(s);
1384: return ENOBUFS;
1385: }
1386:
1.1 nonaka 1387: /* Start up the receive pipe. */
1388: for (i = 0; i < AXEN_RX_LIST_CNT; i++) {
1389: c = &sc->axen_cdata.axen_rx_chain[i];
1.8 skrll 1390:
1391: usbd_setup_xfer(c->axen_xfer, c, c->axen_buf, sc->axen_bufsz,
1392: USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, axen_rxeof);
1.1 nonaka 1393: usbd_transfer(c->axen_xfer);
1394: }
1395:
1396: ifp->if_flags |= IFF_RUNNING;
1397: ifp->if_flags &= ~IFF_OACTIVE;
1398:
1399: splx(s);
1400:
1401: callout_schedule(&sc->axen_stat_ch, hz);
1402: return 0;
1403: }
1404:
1405: static int
1406: axen_ioctl(struct ifnet *ifp, u_long cmd, void *data)
1407: {
1408: struct axen_softc *sc = ifp->if_softc;
1409: int s;
1410: int error = 0;
1411:
1412: s = splnet();
1413:
1414: switch (cmd) {
1415: case SIOCSIFFLAGS:
1416: if ((error = ifioctl_common(ifp, cmd, data)) != 0)
1417: break;
1418:
1419: switch (ifp->if_flags & (IFF_UP | IFF_RUNNING)) {
1420: case IFF_RUNNING:
1421: axen_stop(ifp, 1);
1422: break;
1423: case IFF_UP:
1424: axen_init(ifp);
1425: break;
1426: case IFF_UP | IFF_RUNNING:
1427: if ((ifp->if_flags ^ sc->axen_if_flags) == IFF_PROMISC)
1428: axen_iff(sc);
1429: else
1430: axen_init(ifp);
1431: break;
1432: }
1433: sc->axen_if_flags = ifp->if_flags;
1434: break;
1435:
1436: default:
1437: if ((error = ether_ioctl(ifp, cmd, data)) != ENETRESET)
1438: break;
1439:
1440: error = 0;
1441:
1442: if (cmd == SIOCADDMULTI || cmd == SIOCDELMULTI)
1443: axen_iff(sc);
1444: break;
1445: }
1446: splx(s);
1447:
1448: return error;
1449: }
1450:
1451: static void
1452: axen_watchdog(struct ifnet *ifp)
1453: {
1454: struct axen_softc *sc;
1455: struct axen_chain *c;
1456: usbd_status stat;
1457: int s;
1458:
1459: sc = ifp->if_softc;
1460:
1461: ifp->if_oerrors++;
1462: aprint_error_dev(sc->axen_dev, "watchdog timeout\n");
1463:
1464: s = splusb();
1465: c = &sc->axen_cdata.axen_tx_chain[0];
1466: usbd_get_xfer_status(c->axen_xfer, NULL, NULL, NULL, &stat);
1467: axen_txeof(c->axen_xfer, c, stat);
1468:
1469: if (!IFQ_IS_EMPTY(&ifp->if_snd))
1470: axen_start(ifp);
1471: splx(s);
1472: }
1473:
1474: /*
1475: * Stop the adapter and free any mbufs allocated to the
1476: * RX and TX lists.
1477: */
1478: static void
1479: axen_stop(struct ifnet *ifp, int disable)
1480: {
1481: struct axen_softc *sc = ifp->if_softc;
1482: usbd_status err;
1483: int i;
1484:
1485: axen_reset(sc);
1486:
1487: ifp->if_timer = 0;
1488: ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1489:
1490: callout_stop(&sc->axen_stat_ch);
1491:
1492: /* Stop transfers. */
1493: if (sc->axen_ep[AXEN_ENDPT_RX] != NULL) {
1494: err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_RX]);
1495: if (err) {
1496: aprint_error_dev(sc->axen_dev,
1497: "abort rx pipe failed: %s\n", usbd_errstr(err));
1498:
1499: }
1500: }
1501:
1502: if (sc->axen_ep[AXEN_ENDPT_TX] != NULL) {
1503: err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_TX]);
1504: if (err) {
1505: aprint_error_dev(sc->axen_dev,
1506: "abort tx pipe failed: %s\n", usbd_errstr(err));
1507: }
1508: }
1509:
1510: if (sc->axen_ep[AXEN_ENDPT_INTR] != NULL) {
1511: err = usbd_abort_pipe(sc->axen_ep[AXEN_ENDPT_INTR]);
1512: if (err) {
1513: aprint_error_dev(sc->axen_dev,
1514: "abort intr pipe failed: %s\n", usbd_errstr(err));
1515: }
1516: }
1517:
1518: /* Free RX resources. */
1519: for (i = 0; i < AXEN_RX_LIST_CNT; i++) {
1520: if (sc->axen_cdata.axen_rx_chain[i].axen_xfer != NULL) {
1.8 skrll 1521: usbd_destroy_xfer(sc->axen_cdata.axen_rx_chain[i].axen_xfer);
1.1 nonaka 1522: sc->axen_cdata.axen_rx_chain[i].axen_xfer = NULL;
1523: }
1524: }
1525:
1526: /* Free TX resources. */
1527: for (i = 0; i < AXEN_TX_LIST_CNT; i++) {
1528: if (sc->axen_cdata.axen_tx_chain[i].axen_xfer != NULL) {
1.8 skrll 1529: usbd_destroy_xfer(sc->axen_cdata.axen_tx_chain[i].axen_xfer);
1.1 nonaka 1530: sc->axen_cdata.axen_tx_chain[i].axen_xfer = NULL;
1531: }
1532: }
1533:
1.8 skrll 1534: /* Close pipes. */
1535: if (sc->axen_ep[AXEN_ENDPT_RX] != NULL) {
1536: err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_RX]);
1537: if (err) {
1538: aprint_error_dev(sc->axen_dev,
1539: "close rx pipe failed: %s\n", usbd_errstr(err));
1540: }
1541: sc->axen_ep[AXEN_ENDPT_RX] = NULL;
1542: }
1543:
1544: if (sc->axen_ep[AXEN_ENDPT_TX] != NULL) {
1545: err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_TX]);
1546: if (err) {
1547: aprint_error_dev(sc->axen_dev,
1548: "close tx pipe failed: %s\n", usbd_errstr(err));
1549: }
1550: sc->axen_ep[AXEN_ENDPT_TX] = NULL;
1551: }
1552:
1553: if (sc->axen_ep[AXEN_ENDPT_INTR] != NULL) {
1554: err = usbd_close_pipe(sc->axen_ep[AXEN_ENDPT_INTR]);
1555: if (err) {
1556: aprint_error_dev(sc->axen_dev,
1557: "close intr pipe failed: %s\n", usbd_errstr(err));
1558: }
1559: sc->axen_ep[AXEN_ENDPT_INTR] = NULL;
1560: }
1561:
1.1 nonaka 1562: sc->axen_link = 0;
1563: }
1564:
1565: MODULE(MODULE_CLASS_DRIVER, if_axen, "bpf");
1566:
1567: #ifdef _MODULE
1568: #include "ioconf.c"
1569: #endif
1570:
1571: static int
1572: if_axen_modcmd(modcmd_t cmd, void *aux)
1573: {
1574: int error = 0;
1575:
1576: switch (cmd) {
1577: case MODULE_CMD_INIT:
1578: #ifdef _MODULE
1579: error = config_init_component(cfdriver_ioconf_axen,
1580: cfattach_ioconf_axen, cfdata_ioconf_axen);
1581: #endif
1582: return error;
1583: case MODULE_CMD_FINI:
1584: #ifdef _MODULE
1585: error = config_fini_component(cfdriver_ioconf_axen,
1586: cfattach_ioconf_axen, cfdata_ioconf_axen);
1587: #endif
1588: return error;
1589: default:
1590: return ENOTTY;
1591: }
1592: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to if_axen.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / dev / usb