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