if_axen.c revision 1.61 1 /* $NetBSD: if_axen.c,v 1.61 2019/08/11 02:37:03 mrg 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.61 2019/08/11 02:37:03 mrg Exp $");
27
28 #ifdef _KERNEL_OPT
29 #include "opt_usb.h"
30 #endif
31
32 #include <sys/param.h>
33 #include <sys/module.h>
34
35 #include <netinet/in.h> /* XXX for netinet/ip.h */
36 #include <netinet/ip.h> /* XXX for IP_MAXPACKET */
37
38 #include <dev/usb/usbnet.h>
39
40 #include <dev/usb/if_axenreg.h>
41
42 #ifdef AXEN_DEBUG
43 #define DPRINTF(x) do { if (axendebug) printf x; } while (/*CONSTCOND*/0)
44 #define DPRINTFN(n, x) do { if (axendebug >= (n)) printf x; } while (/*CONSTCOND*/0)
45 int axendebug = 0;
46 #else
47 #define DPRINTF(x)
48 #define DPRINTFN(n, x)
49 #endif
50
51 struct axen_type {
52 struct usb_devno axen_devno;
53 uint16_t axen_flags;
54 #define AX178A 0x0001 /* AX88178a */
55 #define AX179 0x0002 /* AX88179 */
56 };
57
58 /*
59 * Various supported device vendors/products.
60 */
61 static const struct axen_type axen_devs[] = {
62 #if 0 /* not tested */
63 { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88178A}, AX178A },
64 #endif
65 { { USB_VENDOR_ASIX, USB_PRODUCT_ASIX_AX88179}, AX179 },
66 { { USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DUB1312}, AX179 }
67 };
68
69 #define axen_lookup(v, p) ((const struct axen_type *)usb_lookup(axen_devs, v, p))
70
71 static int axen_match(device_t, cfdata_t, void *);
72 static void axen_attach(device_t, device_t, void *);
73
74 CFATTACH_DECL_NEW(axen, sizeof(struct usbnet),
75 axen_match, axen_attach, usbnet_detach, usbnet_activate);
76
77 static int axen_cmd(struct usbnet *, int, int, int, void *);
78 static void axen_reset(struct usbnet *);
79 static int axen_get_eaddr(struct usbnet *, void *);
80 static void axen_ax88179_init(struct usbnet *);
81
82 static void axen_stop_cb(struct ifnet *, int);
83 static int axen_ioctl_cb(struct ifnet *, u_long, void *);
84 static usbd_status axen_mii_read_reg(struct usbnet *, int, int, uint16_t *);
85 static usbd_status axen_mii_write_reg(struct usbnet *, int, int, uint16_t);
86 static void axen_mii_statchg(struct ifnet *);
87 static void axen_rxeof_loop(struct usbnet *, struct usbd_xfer *,
88 struct usbnet_chain *, uint32_t);
89 static unsigned axen_tx_prepare(struct usbnet *, struct mbuf *,
90 struct usbnet_chain *);
91 static int axen_init(struct ifnet *);
92
93 static struct usbnet_ops axen_ops = {
94 .uno_stop = axen_stop_cb,
95 .uno_ioctl = axen_ioctl_cb,
96 .uno_read_reg = axen_mii_read_reg,
97 .uno_write_reg = axen_mii_write_reg,
98 .uno_statchg = axen_mii_statchg,
99 .uno_tx_prepare = axen_tx_prepare,
100 .uno_rx_loop = axen_rxeof_loop,
101 .uno_init = axen_init,
102 };
103
104 static int
105 axen_cmd(struct usbnet *un, int cmd, int index, int val, void *buf)
106 {
107 usb_device_request_t req;
108 usbd_status err;
109
110 usbnet_isowned_mii(un);
111
112 if (usbnet_isdying(un))
113 return 0;
114
115 if (AXEN_CMD_DIR(cmd))
116 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
117 else
118 req.bmRequestType = UT_READ_VENDOR_DEVICE;
119 req.bRequest = AXEN_CMD_CMD(cmd);
120 USETW(req.wValue, val);
121 USETW(req.wIndex, index);
122 USETW(req.wLength, AXEN_CMD_LEN(cmd));
123
124 err = usbd_do_request(un->un_udev, &req, buf);
125 DPRINTFN(5, ("axen_cmd: cmd 0x%04x val 0x%04x len %d\n",
126 cmd, val, AXEN_CMD_LEN(cmd)));
127
128 if (err) {
129 DPRINTF(("%s: cmd: %d, error: %d\n", __func__, cmd, err));
130 return -1;
131 }
132
133 return 0;
134 }
135
136 static usbd_status
137 axen_mii_read_reg(struct usbnet *un, int phy, int reg, uint16_t *val)
138 {
139 uint16_t data;
140 usbd_status err = axen_cmd(un, AXEN_CMD_MII_READ_REG, reg, phy, &data);
141
142 if (!err) {
143 *val = le16toh(data);
144
145 if (reg == MII_BMSR)
146 *val &= ~BMSR_EXTCAP;
147 }
148
149 return err;
150 }
151
152 static usbd_status
153 axen_mii_write_reg(struct usbnet *un, int phy, int reg, uint16_t val)
154 {
155 uint16_t uval = htole16(val);
156
157 return axen_cmd(un, AXEN_CMD_MII_WRITE_REG, reg, phy, &uval);
158 }
159
160 static void
161 axen_mii_statchg(struct ifnet *ifp)
162 {
163 struct usbnet * const un = ifp->if_softc;
164 struct mii_data * const mii = usbnet_mii(un);
165 int err;
166 uint16_t val;
167 uint16_t wval;
168
169 if (usbnet_isdying(un))
170 return;
171
172 usbnet_set_link(un, false);
173 if ((mii->mii_media_status & (IFM_ACTIVE | IFM_AVALID)) ==
174 (IFM_ACTIVE | IFM_AVALID)) {
175 switch (IFM_SUBTYPE(mii->mii_media_active)) {
176 case IFM_10_T:
177 case IFM_100_TX:
178 usbnet_set_link(un, true);
179 break;
180 case IFM_1000_T:
181 usbnet_set_link(un, true);
182 break;
183 default:
184 break;
185 }
186 }
187
188 /* Lost link, do nothing. */
189 if (!usbnet_havelink(un))
190 return;
191
192 val = 0;
193 if ((mii->mii_media_active & IFM_FDX) != 0)
194 val |= AXEN_MEDIUM_FDX;
195
196 val |= AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN |
197 AXEN_MEDIUM_RECV_EN;
198 switch (IFM_SUBTYPE(mii->mii_media_active)) {
199 case IFM_1000_T:
200 val |= AXEN_MEDIUM_GIGA | AXEN_MEDIUM_EN_125MHZ;
201 break;
202 case IFM_100_TX:
203 val |= AXEN_MEDIUM_PS;
204 break;
205 case IFM_10_T:
206 /* doesn't need to be handled */
207 break;
208 }
209
210 DPRINTF(("%s: val=0x%x\n", __func__, val));
211 wval = htole16(val);
212 usbnet_lock_mii(un);
213 err = axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval);
214 usbnet_unlock_mii(un);
215 if (err)
216 aprint_error_dev(un->un_dev, "media change failed\n");
217 }
218
219 static void
220 axen_setiff_locked(struct usbnet *un)
221 {
222 struct ifnet * const ifp = usbnet_ifp(un);
223 struct ethercom *ec = usbnet_ec(un);
224 struct ether_multi *enm;
225 struct ether_multistep step;
226 uint32_t h = 0;
227 uint16_t rxmode;
228 uint8_t hashtbl[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
229 uint16_t wval;
230
231 if (usbnet_isdying(un))
232 return;
233
234 usbnet_isowned_mii(un);
235
236 rxmode = 0;
237
238 /* Enable receiver, set RX mode */
239 axen_cmd(un, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
240 rxmode = le16toh(wval);
241 rxmode &= ~(AXEN_RXCTL_ACPT_ALL_MCAST | AXEN_RXCTL_PROMISC |
242 AXEN_RXCTL_ACPT_MCAST);
243
244 if (ifp->if_flags & IFF_PROMISC) {
245 DPRINTF(("%s: promisc\n", device_xname(un->un_dev)));
246 rxmode |= AXEN_RXCTL_PROMISC;
247 allmulti:
248 ETHER_LOCK(ec);
249 ec->ec_flags |= ETHER_F_ALLMULTI;
250 ETHER_UNLOCK(ec);
251 rxmode |= AXEN_RXCTL_ACPT_ALL_MCAST
252 /* | AXEN_RXCTL_ACPT_PHY_MCAST */;
253 } else {
254 /* now program new ones */
255 DPRINTF(("%s: initializing hash table\n",
256 device_xname(un->un_dev)));
257 ETHER_LOCK(ec);
258 ec->ec_flags &= ~ETHER_F_ALLMULTI;
259
260 ETHER_FIRST_MULTI(step, ec, enm);
261 while (enm != NULL) {
262 if (memcmp(enm->enm_addrlo, enm->enm_addrhi,
263 ETHER_ADDR_LEN)) {
264 DPRINTF(("%s: allmulti\n",
265 device_xname(un->un_dev)));
266 memset(hashtbl, 0, sizeof(hashtbl));
267 ETHER_UNLOCK(ec);
268 goto allmulti;
269 }
270 h = ether_crc32_be(enm->enm_addrlo,
271 ETHER_ADDR_LEN) >> 26;
272 hashtbl[h / 8] |= 1 << (h % 8);
273 DPRINTF(("%s: %s added\n",
274 device_xname(un->un_dev),
275 ether_sprintf(enm->enm_addrlo)));
276 ETHER_NEXT_MULTI(step, enm);
277 }
278 ETHER_UNLOCK(ec);
279 rxmode |= AXEN_RXCTL_ACPT_MCAST;
280 }
281
282 axen_cmd(un, AXEN_CMD_MAC_WRITE_FILTER, 8, AXEN_FILTER_MULTI, hashtbl);
283 wval = htole16(rxmode);
284 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
285 }
286
287 static void
288 axen_setiff(struct usbnet *un)
289 {
290 usbnet_lock_mii(un);
291 axen_setiff_locked(un);
292 usbnet_unlock_mii(un);
293 }
294
295 static void
296 axen_reset(struct usbnet *un)
297 {
298 usbnet_isowned(un);
299 if (usbnet_isdying(un))
300 return;
301 /* XXX What to reset? */
302
303 /* Wait a little while for the chip to get its brains in order. */
304 DELAY(1000);
305 }
306
307 static int
308 axen_get_eaddr(struct usbnet *un, void *addr)
309 {
310 #if 1
311 return axen_cmd(un, AXEN_CMD_MAC_READ_ETHER, 6, AXEN_CMD_MAC_NODE_ID,
312 addr);
313 #else
314 int i, retry;
315 uint8_t eeprom[20];
316 uint16_t csum;
317 uint16_t buf;
318
319 for (i = 0; i < 6; i++) {
320 /* set eeprom address */
321 buf = htole16(i);
322 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_ADDR, &buf);
323
324 /* set eeprom command */
325 buf = htole16(AXEN_EEPROM_READ);
326 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_MAC_EEPROM_CMD, &buf);
327
328 /* check the value is ready */
329 retry = 3;
330 do {
331 buf = htole16(AXEN_EEPROM_READ);
332 usbd_delay_ms(un->un_udev, 10);
333 axen_cmd(un, AXEN_CMD_MAC_READ, 1, AXEN_MAC_EEPROM_CMD,
334 &buf);
335 retry--;
336 if (retry < 0)
337 return EINVAL;
338 } while ((le16toh(buf) & 0xff) & AXEN_EEPROM_BUSY);
339
340 /* read data */
341 axen_cmd(un, AXEN_CMD_MAC_READ2, 2, AXEN_EEPROM_READ,
342 &eeprom[i * 2]);
343
344 /* sanity check */
345 if ((i == 0) && (eeprom[0] == 0xff))
346 return EINVAL;
347 }
348
349 /* check checksum */
350 csum = eeprom[6] + eeprom[7] + eeprom[8] + eeprom[9];
351 csum = (csum >> 8) + (csum & 0xff) + eeprom[10];
352 if (csum != 0xff) {
353 printf("eeprom checksum mismatch(0x%02x)\n", csum);
354 return EINVAL;
355 }
356
357 memcpy(addr, eeprom, ETHER_ADDR_LEN);
358 return 0;
359 #endif
360 }
361
362 static void
363 axen_ax88179_init(struct usbnet *un)
364 {
365 struct axen_qctrl qctrl;
366 uint16_t ctl, temp;
367 uint16_t wval;
368 uint8_t val;
369
370 usbnet_lock_mii(un);
371
372 /* XXX: ? */
373 axen_cmd(un, AXEN_CMD_MAC_READ, 1, AXEN_UNK_05, &val);
374 DPRINTFN(5, ("AXEN_CMD_MAC_READ(0x05): 0x%02x\n", val));
375
376 /* check AX88179 version, UA1 / UA2 */
377 axen_cmd(un, AXEN_CMD_MAC_READ, 1, AXEN_GENERAL_STATUS, &val);
378 /* UA1 */
379 if (!(val & AXEN_GENERAL_STATUS_MASK)) {
380 DPRINTF(("AX88179 ver. UA1\n"));
381 } else {
382 DPRINTF(("AX88179 ver. UA2\n"));
383 }
384
385 /* power up ethernet PHY */
386 wval = htole16(0);
387 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
388
389 wval = htole16(AXEN_PHYPWR_RSTCTL_IPRL);
390 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
391 usbd_delay_ms(un->un_udev, 200);
392
393 /* set clock mode */
394 val = AXEN_PHYCLK_ACS | AXEN_PHYCLK_BCS;
395 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
396 usbd_delay_ms(un->un_udev, 100);
397
398 /* set monitor mode (disable) */
399 val = AXEN_MONITOR_NONE;
400 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val);
401
402 /* enable auto detach */
403 axen_cmd(un, AXEN_CMD_EEPROM_READ, 2, AXEN_EEPROM_STAT, &wval);
404 temp = le16toh(wval);
405 DPRINTFN(2,("EEPROM0x43 = 0x%04x\n", temp));
406 if (!(temp == 0xffff) && !(temp & 0x0100)) {
407 /* Enable auto detach bit */
408 val = 0;
409 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
410 val = AXEN_PHYCLK_ULR;
411 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_PHYCLK, &val);
412 usbd_delay_ms(un->un_udev, 100);
413
414 axen_cmd(un, AXEN_CMD_MAC_READ2, 2, AXEN_PHYPWR_RSTCTL, &wval);
415 ctl = le16toh(wval);
416 ctl |= AXEN_PHYPWR_RSTCTL_AUTODETACH;
417 wval = htole16(ctl);
418 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_PHYPWR_RSTCTL, &wval);
419 usbd_delay_ms(un->un_udev, 200);
420 aprint_error_dev(un->un_dev, "enable auto detach (0x%04x)\n",
421 ctl);
422 }
423
424 /* bulkin queue setting */
425 axen_cmd(un, AXEN_CMD_MAC_READ, 1, AXEN_USB_UPLINK, &val);
426 switch (val) {
427 case AXEN_USB_FS:
428 DPRINTF(("uplink: USB1.1\n"));
429 qctrl.ctrl = 0x07;
430 qctrl.timer_low = 0xcc;
431 qctrl.timer_high = 0x4c;
432 qctrl.bufsize = AXEN_BUFSZ_LS - 1;
433 qctrl.ifg = 0x08;
434 break;
435 case AXEN_USB_HS:
436 DPRINTF(("uplink: USB2.0\n"));
437 qctrl.ctrl = 0x07;
438 qctrl.timer_low = 0x02;
439 qctrl.timer_high = 0xa0;
440 qctrl.bufsize = AXEN_BUFSZ_HS - 1;
441 qctrl.ifg = 0xff;
442 break;
443 case AXEN_USB_SS:
444 DPRINTF(("uplink: USB3.0\n"));
445 qctrl.ctrl = 0x07;
446 qctrl.timer_low = 0x4f;
447 qctrl.timer_high = 0x00;
448 qctrl.bufsize = AXEN_BUFSZ_SS - 1;
449 qctrl.ifg = 0xff;
450 break;
451 default:
452 aprint_error_dev(un->un_dev, "unknown uplink bus:0x%02x\n",
453 val);
454 usbnet_unlock_mii(un);
455 return;
456 }
457 axen_cmd(un, AXEN_CMD_MAC_SET_RXSR, 5, AXEN_RX_BULKIN_QCTRL, &qctrl);
458
459 /*
460 * set buffer high/low watermark to pause/resume.
461 * write 2byte will set high/log simultaneous with AXEN_PAUSE_HIGH.
462 * XXX: what is the best value? OSX driver uses 0x3c-0x4c as LOW-HIGH
463 * watermark parameters.
464 */
465 val = 0x34;
466 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_LOW_WATERMARK, &val);
467 val = 0x52;
468 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_PAUSE_HIGH_WATERMARK, &val);
469
470 /* Set RX/TX configuration. */
471 /* Set RX control register */
472 ctl = AXEN_RXCTL_IPE | AXEN_RXCTL_DROPCRCERR | AXEN_RXCTL_AUTOB;
473 wval = htole16(ctl);
474 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
475
476 /* set monitor mode (enable) */
477 val = AXEN_MONITOR_PMETYPE | AXEN_MONITOR_PMEPOL | AXEN_MONITOR_RWMP;
478 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_MONITOR_MODE, &val);
479 axen_cmd(un, AXEN_CMD_MAC_READ, 1, AXEN_MONITOR_MODE, &val);
480 DPRINTF(("axen: Monitor mode = 0x%02x\n", val));
481
482 /* set medium type */
483 ctl = AXEN_MEDIUM_GIGA | AXEN_MEDIUM_FDX | AXEN_MEDIUM_EN_125MHZ |
484 AXEN_MEDIUM_RXFLOW_CTRL_EN | AXEN_MEDIUM_TXFLOW_CTRL_EN |
485 AXEN_MEDIUM_RECV_EN;
486 wval = htole16(ctl);
487 DPRINTF(("axen: set to medium mode: 0x%04x\n", ctl));
488 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_MEDIUM_STATUS, &wval);
489 usbd_delay_ms(un->un_udev, 100);
490
491 axen_cmd(un, AXEN_CMD_MAC_READ2, 2, AXEN_MEDIUM_STATUS, &wval);
492 DPRINTF(("axen: current medium mode: 0x%04x\n", le16toh(wval)));
493
494 usbnet_unlock_mii(un);
495
496 #if 0 /* XXX: TBD.... */
497 #define GMII_LED_ACTIVE 0x1a
498 #define GMII_PHY_PAGE_SEL 0x1e
499 #define GMII_PHY_PAGE_SEL 0x1f
500 #define GMII_PAGE_EXT 0x0007
501 usbnet_mii_writereg(un->un_dev, un->un_phyno, GMII_PHY_PAGE_SEL,
502 GMII_PAGE_EXT);
503 usbnet_mii_writereg(un->un_dev, un->un_phyno, GMII_PHY_PAGE,
504 0x002c);
505 #endif
506
507 #if 1 /* XXX: phy hack ? */
508 usbnet_mii_writereg(un->un_dev, un->un_phyno, 0x1F, 0x0005);
509 usbnet_mii_writereg(un->un_dev, un->un_phyno, 0x0C, 0x0000);
510 usbnet_mii_readreg(un->un_dev, un->un_phyno, 0x0001, &wval);
511 usbnet_mii_writereg(un->un_dev, un->un_phyno, 0x01, wval | 0x0080);
512 usbnet_mii_writereg(un->un_dev, un->un_phyno, 0x1F, 0x0000);
513 #endif
514 }
515
516 static void
517 axen_setoe_locked(struct usbnet *un)
518 {
519 struct ifnet * const ifp = usbnet_ifp(un);
520 uint64_t enabled = ifp->if_capenable;
521 uint8_t val;
522
523 usbnet_isowned_mii(un);
524
525 val = AXEN_RXCOE_OFF;
526 if (enabled & IFCAP_CSUM_IPv4_Rx)
527 val |= AXEN_RXCOE_IPv4;
528 if (enabled & IFCAP_CSUM_TCPv4_Rx)
529 val |= AXEN_RXCOE_TCPv4;
530 if (enabled & IFCAP_CSUM_UDPv4_Rx)
531 val |= AXEN_RXCOE_UDPv4;
532 if (enabled & IFCAP_CSUM_TCPv6_Rx)
533 val |= AXEN_RXCOE_TCPv6;
534 if (enabled & IFCAP_CSUM_UDPv6_Rx)
535 val |= AXEN_RXCOE_UDPv6;
536 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_RX_COE, &val);
537
538 val = AXEN_TXCOE_OFF;
539 if (enabled & IFCAP_CSUM_IPv4_Tx)
540 val |= AXEN_TXCOE_IPv4;
541 if (enabled & IFCAP_CSUM_TCPv4_Tx)
542 val |= AXEN_TXCOE_TCPv4;
543 if (enabled & IFCAP_CSUM_UDPv4_Tx)
544 val |= AXEN_TXCOE_UDPv4;
545 if (enabled & IFCAP_CSUM_TCPv6_Tx)
546 val |= AXEN_TXCOE_TCPv6;
547 if (enabled & IFCAP_CSUM_UDPv6_Tx)
548 val |= AXEN_TXCOE_UDPv6;
549 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_TX_COE, &val);
550 }
551
552 static void
553 axen_setoe(struct usbnet *un)
554 {
555
556 usbnet_lock_mii(un);
557 axen_setoe_locked(un);
558 usbnet_unlock_mii(un);
559 }
560
561 static int
562 axen_ioctl_cb(struct ifnet *ifp, u_long cmd, void *data)
563 {
564 struct usbnet * const un = ifp->if_softc;
565
566 switch (cmd) {
567 case SIOCSIFFLAGS:
568 case SIOCSETHERCAP:
569 case SIOCADDMULTI:
570 case SIOCDELMULTI:
571 axen_setiff(un);
572 break;
573 case SIOCSIFCAP:
574 axen_setoe(un);
575 break;
576 default:
577 break;
578 }
579
580 return 0;
581 }
582
583 static int
584 axen_match(device_t parent, cfdata_t match, void *aux)
585 {
586 struct usb_attach_arg *uaa = aux;
587
588 return axen_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
589 UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
590 }
591
592 static void
593 axen_attach(device_t parent, device_t self, void *aux)
594 {
595 struct usbnet * const un = device_private(self);
596 struct usb_attach_arg *uaa = aux;
597 struct usbd_device *dev = uaa->uaa_device;
598 usbd_status err;
599 usb_interface_descriptor_t *id;
600 usb_endpoint_descriptor_t *ed;
601 char *devinfop;
602 uint16_t axen_flags;
603 int i;
604
605 aprint_naive("\n");
606 aprint_normal("\n");
607 devinfop = usbd_devinfo_alloc(dev, 0);
608 aprint_normal_dev(self, "%s\n", devinfop);
609 usbd_devinfo_free(devinfop);
610
611 un->un_dev = self;
612 un->un_udev = dev;
613 un->un_sc = un;
614 un->un_ops = &axen_ops;
615 un->un_rx_xfer_flags = USBD_SHORT_XFER_OK;
616 un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER;
617 un->un_rx_list_cnt = AXEN_RX_LIST_CNT;
618 un->un_tx_list_cnt = AXEN_TX_LIST_CNT;
619
620 err = usbd_set_config_no(dev, AXEN_CONFIG_NO, 1);
621 if (err) {
622 aprint_error_dev(self, "failed to set configuration"
623 ", err=%s\n", usbd_errstr(err));
624 return;
625 }
626
627 axen_flags = axen_lookup(uaa->uaa_vendor, uaa->uaa_product)->axen_flags;
628
629 err = usbd_device2interface_handle(dev, AXEN_IFACE_IDX, &un->un_iface);
630 if (err) {
631 aprint_error_dev(self, "getting interface handle failed\n");
632 return;
633 }
634
635 /* decide on what our bufsize will be */
636 switch (dev->ud_speed) {
637 case USB_SPEED_SUPER:
638 un->un_rx_bufsz = AXEN_BUFSZ_SS * 1024;
639 break;
640 case USB_SPEED_HIGH:
641 un->un_rx_bufsz = AXEN_BUFSZ_HS * 1024;
642 break;
643 default:
644 un->un_rx_bufsz = AXEN_BUFSZ_LS * 1024;
645 break;
646 }
647 un->un_tx_bufsz = IP_MAXPACKET + ETHER_HDR_LEN + ETHER_CRC_LEN +
648 ETHER_VLAN_ENCAP_LEN + sizeof(struct axen_sframe_hdr);
649
650 /* Find endpoints. */
651 id = usbd_get_interface_descriptor(un->un_iface);
652 for (i = 0; i < id->bNumEndpoints; i++) {
653 ed = usbd_interface2endpoint_descriptor(un->un_iface, i);
654 if (!ed) {
655 aprint_error_dev(self, "couldn't get ep %d\n", i);
656 return;
657 }
658 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
659 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
660 un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress;
661 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
662 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
663 un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress;
664 #if 0 /* not used yet */
665 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
666 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
667 un->un_ed[USBNET_ENDPT_INTR] = ed->bEndpointAddress;
668 #endif
669 }
670 }
671
672 /* Set these up now for axen_cmd(). */
673 usbnet_attach(un, "axendet");
674
675 un->un_phyno = AXEN_PHY_ID;
676 DPRINTF(("%s: phyno %d\n", device_xname(self), un->un_phyno));
677
678 /* Get station address. */
679 usbnet_lock_mii(un);
680 if (axen_get_eaddr(un, &un->un_eaddr)) {
681 usbnet_unlock_mii(un);
682 printf("EEPROM checksum error\n");
683 return;
684 }
685 usbnet_unlock_mii(un);
686
687 axen_ax88179_init(un);
688
689 /* An ASIX chip was detected. Inform the world. */
690 if (axen_flags & AX178A)
691 aprint_normal_dev(self, "AX88178a\n");
692 else if (axen_flags & AX179)
693 aprint_normal_dev(self, "AX88179\n");
694 else
695 aprint_normal_dev(self, "(unknown)\n");
696
697 struct ethercom *ec = usbnet_ec(un);
698 ec->ec_capabilities = ETHERCAP_VLAN_MTU;
699
700 /* Adapter does not support TSOv6 (They call it LSOv2). */
701 struct ifnet *ifp = usbnet_ifp(un);
702 ifp->if_capabilities |= IFCAP_TSOv4 |
703 IFCAP_CSUM_IPv4_Rx | IFCAP_CSUM_IPv4_Tx |
704 IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv4_Tx |
705 IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv4_Tx |
706 IFCAP_CSUM_TCPv6_Rx | IFCAP_CSUM_TCPv6_Tx |
707 IFCAP_CSUM_UDPv6_Rx | IFCAP_CSUM_UDPv6_Tx;
708
709 usbnet_attach_ifp(un, true, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST,
710 0, 0);
711 }
712
713 static int
714 axen_csum_flags_rx(struct ifnet *ifp, uint32_t pkt_hdr)
715 {
716 int enabled_flags = ifp->if_csum_flags_rx;
717 int csum_flags = 0;
718 int l3_type, l4_type;
719
720 if (enabled_flags == 0)
721 return 0;
722
723 l3_type = (pkt_hdr & AXEN_RXHDR_L3_TYPE_MASK) >>
724 AXEN_RXHDR_L3_TYPE_OFFSET;
725
726 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4)
727 csum_flags |= M_CSUM_IPv4;
728
729 l4_type = (pkt_hdr & AXEN_RXHDR_L4_TYPE_MASK) >>
730 AXEN_RXHDR_L4_TYPE_OFFSET;
731
732 switch (l4_type) {
733 case AXEN_RXHDR_L4_TYPE_TCP:
734 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4)
735 csum_flags |= M_CSUM_TCPv4;
736 else
737 csum_flags |= M_CSUM_TCPv6;
738 break;
739 case AXEN_RXHDR_L4_TYPE_UDP:
740 if (l3_type == AXEN_RXHDR_L3_TYPE_IPV4)
741 csum_flags |= M_CSUM_UDPv4;
742 else
743 csum_flags |= M_CSUM_UDPv6;
744 break;
745 default:
746 break;
747 }
748
749 csum_flags &= enabled_flags;
750 if ((csum_flags & M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L3CSUM_ERR))
751 csum_flags |= M_CSUM_IPv4_BAD;
752 if ((csum_flags & ~M_CSUM_IPv4) && (pkt_hdr & AXEN_RXHDR_L4CSUM_ERR))
753 csum_flags |= M_CSUM_TCP_UDP_BAD;
754
755 return csum_flags;
756 }
757
758 static void
759 axen_rxeof_loop(struct usbnet *un, struct usbd_xfer *xfer,
760 struct usbnet_chain *c, uint32_t total_len)
761 {
762 struct ifnet *ifp = usbnet_ifp(un);
763 uint8_t *buf = c->unc_buf;
764 uint32_t rx_hdr, pkt_hdr;
765 uint32_t *hdr_p;
766 uint16_t hdr_offset, pkt_count;
767 size_t pkt_len;
768 size_t temp;
769
770 usbnet_isowned_rx(un);
771
772 if (total_len < sizeof(pkt_hdr)) {
773 aprint_error_dev(un->un_dev, "rxeof: too short transfer\n");
774 ifp->if_ierrors++;
775 return;
776 }
777
778 /*
779 * buffer map
780 * [packet #0]...[packet #n][pkt hdr#0]..[pkt hdr#n][recv_hdr]
781 * each packet has 0xeeee as psuedo header..
782 */
783 hdr_p = (uint32_t *)(buf + total_len - sizeof(uint32_t));
784 rx_hdr = le32toh(*hdr_p);
785 hdr_offset = (uint16_t)(rx_hdr >> 16);
786 pkt_count = (uint16_t)(rx_hdr & 0xffff);
787
788 /* sanity check */
789 if (hdr_offset > total_len) {
790 aprint_error_dev(un->un_dev,
791 "rxeof: invalid hdr offset (%u > %u)\n",
792 hdr_offset, total_len);
793 ifp->if_ierrors++;
794 usbd_delay_ms(un->un_udev, 100);
795 return;
796 }
797
798 /* point first packet header */
799 hdr_p = (uint32_t *)(buf + hdr_offset);
800
801 /*
802 * ax88179 will pack multiple ip packet to a USB transaction.
803 * process all of packets in the buffer
804 */
805
806 #if 1 /* XXX: paranoiac check. need to remove later */
807 #define AXEN_MAX_PACKED_PACKET 200
808 if (pkt_count > AXEN_MAX_PACKED_PACKET) {
809 DPRINTF(("%s: Too many packets (%d) in a transaction, discard.\n",
810 device_xname(un->un_dev), pkt_count));
811 return;
812 }
813 #endif
814
815 if (pkt_count)
816 rnd_add_uint32(usbnet_rndsrc(un), pkt_count);
817
818 do {
819 if ((buf[0] != 0xee) || (buf[1] != 0xee)) {
820 aprint_error_dev(un->un_dev,
821 "invalid buffer(pkt#%d), continue\n", pkt_count);
822 ifp->if_ierrors += pkt_count;
823 return;
824 }
825
826 pkt_hdr = le32toh(*hdr_p);
827 pkt_len = (pkt_hdr >> 16) & 0x1fff;
828 DPRINTFN(10,
829 ("%s: rxeof: packet#%d, pkt_hdr 0x%08x, pkt_len %zu\n",
830 device_xname(un->un_dev), pkt_count, pkt_hdr, pkt_len));
831
832 if (pkt_hdr & (AXEN_RXHDR_CRC_ERR | AXEN_RXHDR_DROP_ERR)) {
833 ifp->if_ierrors++;
834 /* move to next pkt header */
835 DPRINTF(("%s: %s err (pkt#%d)\n",
836 device_xname(un->un_dev),
837 (pkt_hdr & AXEN_RXHDR_CRC_ERR) ? "crc" : "drop",
838 pkt_count));
839 goto nextpkt;
840 }
841
842 usbnet_enqueue(un, buf + 2, pkt_len - 6,
843 axen_csum_flags_rx(ifp, pkt_hdr), 0, 0);
844
845 nextpkt:
846 /*
847 * prepare next packet
848 * as each packet will be aligned 8byte boundary,
849 * need to fix up the start point of the buffer.
850 */
851 temp = ((pkt_len + 7) & 0xfff8);
852 buf = buf + temp;
853 hdr_p++;
854 pkt_count--;
855 } while (pkt_count > 0);
856 }
857
858 static unsigned
859 axen_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c)
860 {
861 struct axen_sframe_hdr hdr;
862 u_int length, boundary;
863
864 usbnet_isowned_tx(un);
865
866 if (m->m_pkthdr.len > un->un_tx_bufsz - sizeof(hdr))
867 return 0;
868 length = m->m_pkthdr.len + sizeof(hdr);
869
870 /* XXX Is this needed? wMaxPacketSize? */
871 switch (un->un_udev->ud_speed) {
872 case USB_SPEED_SUPER:
873 boundary = 4096;
874 break;
875 case USB_SPEED_HIGH:
876 boundary = 512;
877 break;
878 default:
879 boundary = 64;
880 break;
881 }
882
883 hdr.plen = htole32(m->m_pkthdr.len);
884
885 hdr.gso = (m->m_pkthdr.csum_flags & M_CSUM_TSOv4) ?
886 m->m_pkthdr.segsz : 0;
887 if ((length % boundary) == 0) {
888 DPRINTF(("%s: boundary hit\n", device_xname(un->un_dev)));
889 hdr.gso |= 0x80008000; /* XXX enable padding */
890 }
891 hdr.gso = htole32(hdr.gso);
892
893 memcpy(c->unc_buf, &hdr, sizeof(hdr));
894 m_copydata(m, 0, m->m_pkthdr.len, c->unc_buf + sizeof(hdr));
895
896 return length;
897 }
898
899 static int
900 axen_init_locked(struct ifnet *ifp)
901 {
902 struct usbnet * const un = ifp->if_softc;
903 uint16_t rxmode;
904 uint16_t wval;
905 uint8_t bval;
906
907 usbnet_isowned(un);
908
909 if (usbnet_isdying(un))
910 return EIO;
911
912 /* Cancel pending I/O */
913 usbnet_stop(un, ifp, 1);
914
915 /* Reset the ethernet interface. */
916 axen_reset(un);
917
918 usbnet_lock_mii_un_locked(un);
919
920 /* XXX: ? */
921 bval = 0x01;
922 axen_cmd(un, AXEN_CMD_MAC_WRITE, 1, AXEN_UNK_28, &bval);
923
924 /* Configure offloading engine. */
925 axen_setoe_locked(un);
926
927 /* Program promiscuous mode and multicast filters. */
928 axen_setiff_locked(un);
929
930 /* Enable receiver, set RX mode */
931 axen_cmd(un, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
932 rxmode = le16toh(wval);
933 rxmode |= AXEN_RXCTL_START;
934 wval = htole16(rxmode);
935 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
936
937 usbnet_unlock_mii_un_locked(un);
938
939 return usbnet_init_rx_tx(un);
940 }
941
942 static int
943 axen_init(struct ifnet *ifp)
944 {
945 struct usbnet * const un = ifp->if_softc;
946
947 usbnet_lock(un);
948 int ret = axen_init_locked(ifp);
949 usbnet_unlock(un);
950
951 return ret;
952 }
953
954 static void
955 axen_stop_cb(struct ifnet *ifp, int disable)
956 {
957 struct usbnet * const un = ifp->if_softc;
958 uint16_t rxmode, wval;
959
960 axen_reset(un);
961
962 /* Disable receiver, set RX mode */
963 usbnet_lock_mii_un_locked(un);
964 axen_cmd(un, AXEN_CMD_MAC_READ2, 2, AXEN_MAC_RXCTL, &wval);
965 rxmode = le16toh(wval);
966 rxmode &= ~AXEN_RXCTL_START;
967 wval = htole16(rxmode);
968 axen_cmd(un, AXEN_CMD_MAC_WRITE2, 2, AXEN_MAC_RXCTL, &wval);
969 usbnet_unlock_mii_un_locked(un);
970 }
971
972 MODULE(MODULE_CLASS_DRIVER, if_axen, "usbnet");
973
974 #ifdef _MODULE
975 #include "ioconf.c"
976 #endif
977
978 static int
979 if_axen_modcmd(modcmd_t cmd, void *aux)
980 {
981 int error = 0;
982
983 switch (cmd) {
984 case MODULE_CMD_INIT:
985 #ifdef _MODULE
986 error = config_init_component(cfdriver_ioconf_axen,
987 cfattach_ioconf_axen, cfdata_ioconf_axen);
988 #endif
989 return error;
990 case MODULE_CMD_FINI:
991 #ifdef _MODULE
992 error = config_fini_component(cfdriver_ioconf_axen,
993 cfattach_ioconf_axen, cfdata_ioconf_axen);
994 #endif
995 return error;
996 default:
997 return ENOTTY;
998 }
999 }
1000