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