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