1 /* $NetBSD: if_aue.c,v 1.137 2016/07/07 06:55:42 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 1997, 1998, 1999, 2000
5 * Bill Paul <wpaul@ee.columbia.edu>. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Bill Paul.
18 * 4. Neither the name of the author nor the names of any co-contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
26 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32 * THE POSSIBILITY OF SUCH DAMAGE.
33 *
34 * $FreeBSD: src/sys/dev/usb/if_aue.c,v 1.11 2000/01/14 01:36:14 wpaul Exp $
35 */
36
37 /*
38 * ADMtek AN986 Pegasus and AN8511 Pegasus II USB to ethernet driver.
39 * Datasheet is available from http://www.admtek.com.tw.
40 *
41 * Written by Bill Paul <wpaul@ee.columbia.edu>
42 * Electrical Engineering Department
43 * Columbia University, New York City
44 */
45
46 /*
47 * The Pegasus chip uses four USB "endpoints" to provide 10/100 ethernet
48 * support: the control endpoint for reading/writing registers, burst
49 * read endpoint for packet reception, burst write for packet transmission
50 * and one for "interrupts." The chip uses the same RX filter scheme
51 * as the other ADMtek ethernet parts: one perfect filter entry for the
52 * the station address and a 64-bit multicast hash table. The chip supports
53 * both MII and HomePNA attachments.
54 *
55 * Since the maximum data transfer speed of USB is supposed to be 12Mbps,
56 * you're never really going to get 100Mbps speeds from this device. I
57 * think the idea is to allow the device to connect to 10 or 100Mbps
58 * networks, not necessarily to provide 100Mbps performance. Also, since
59 * the controller uses an external PHY chip, it's possible that board
60 * designers might simply choose a 10Mbps PHY.
61 *
62 * Registers are accessed using usbd_do_request(). Packet transfers are
63 * done using usbd_transfer() and friends.
64 */
65
66 /*
67 * Ported to NetBSD and somewhat rewritten by Lennart Augustsson.
68 */
69
70 /*
71 * TODO:
72 * better error messages from rxstat
73 * split out if_auevar.h
74 * add thread to avoid register reads from interrupt context
75 * more error checks
76 * investigate short rx problem
77 * proper cleanup on errors
78 */
79
80 #include <sys/cdefs.h>
81 __KERNEL_RCSID(0, "$NetBSD: if_aue.c,v 1.137 2016/07/07 06:55:42 msaitoh Exp $");
82
83 #ifdef _KERNEL_OPT
84 #include "opt_inet.h"
85 #endif
86
87 #include <sys/param.h>
88 #include <sys/systm.h>
89 #include <sys/sockio.h>
90 #include <sys/mutex.h>
91 #include <sys/mbuf.h>
92 #include <sys/kernel.h>
93 #include <sys/socket.h>
94 #include <sys/device.h>
95 #include <sys/rndsource.h>
96
97 #include <net/if.h>
98 #include <net/if_arp.h>
99 #include <net/if_dl.h>
100 #include <net/if_media.h>
101
102 #include <net/bpf.h>
103
104 #include <net/if_ether.h>
105 #ifdef INET
106 #include <netinet/in.h>
107 #include <netinet/if_inarp.h>
108 #endif
109
110
111
112 #include <dev/mii/mii.h>
113 #include <dev/mii/miivar.h>
114
115 #include <dev/usb/usb.h>
116 #include <dev/usb/usbdi.h>
117 #include <dev/usb/usbdi_util.h>
118 #include <dev/usb/usbdevs.h>
119
120 #include <sys/condvar.h>
121 #include <sys/kthread.h>
122
123 #include <dev/usb/if_auereg.h>
124
125 #ifdef AUE_DEBUG
126 #define DPRINTF(x) if (auedebug) printf x
127 #define DPRINTFN(n,x) if (auedebug >= (n)) printf x
128 int auedebug = 0;
129 #else
130 #define DPRINTF(x)
131 #define DPRINTFN(n,x)
132 #endif
133
134 /*
135 * Various supported device vendors/products.
136 */
137 struct aue_type {
138 struct usb_devno aue_dev;
139 uint16_t aue_flags;
140 #define LSYS 0x0001 /* use Linksys reset */
141 #define PNA 0x0002 /* has Home PNA */
142 #define PII 0x0004 /* Pegasus II chip */
143 };
144
145 Static const struct aue_type aue_devs[] = {
146 {{ USB_VENDOR_3COM, USB_PRODUCT_3COM_3C460B}, PII },
147 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX1}, PNA|PII },
148 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX2}, PII },
149 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_UFE1000}, LSYS },
150 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX4}, PNA },
151 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX5}, PNA },
152 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX6}, PII },
153 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX7}, PII },
154 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX8}, PII },
155 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX9}, PNA },
156 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_XX10}, 0 },
157 {{ USB_VENDOR_ABOCOM, USB_PRODUCT_ABOCOM_DSB650TX_PNA}, 0 },
158 {{ USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_USB320_EC}, 0 },
159 {{ USB_VENDOR_ACCTON, USB_PRODUCT_ACCTON_SS1001}, PII },
160 {{ USB_VENDOR_ADMTEK, USB_PRODUCT_ADMTEK_PEGASUS}, PNA },
161 {{ USB_VENDOR_ADMTEK, USB_PRODUCT_ADMTEK_PEGASUSII}, PII },
162 {{ USB_VENDOR_ADMTEK, USB_PRODUCT_ADMTEK_PEGASUSII_2}, PII },
163 {{ USB_VENDOR_ADMTEK, USB_PRODUCT_ADMTEK_PEGASUSII_3}, PII },
164 {{ USB_VENDOR_AEI, USB_PRODUCT_AEI_USBTOLAN}, PII },
165 {{ USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_USB2LAN}, PII },
166 {{ USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_USB100}, 0 },
167 {{ USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_USBLP100}, PNA },
168 {{ USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_USBEL100}, 0 },
169 {{ USB_VENDOR_BILLIONTON, USB_PRODUCT_BILLIONTON_USBE100}, PII },
170 {{ USB_VENDOR_COMPAQ, USB_PRODUCT_COMPAQ_HNE200}, PII },
171 {{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB_TX}, 0 },
172 {{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_FETHER_USB_TXS},PII },
173 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650TX4}, LSYS|PII },
174 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650TX1}, LSYS },
175 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650TX}, LSYS },
176 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650TX_PNA}, PNA },
177 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650TX3}, LSYS|PII },
178 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650TX2}, LSYS|PII },
179 {{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650}, 0 },
180 {{ USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_LDUSBTX0}, 0 },
181 {{ USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_LDUSBTX1}, LSYS },
182 {{ USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_LDUSBTX2}, 0 },
183 {{ USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_LDUSBTX3}, LSYS },
184 {{ USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_LDUSBLTX}, PII },
185 {{ USB_VENDOR_ELSA, USB_PRODUCT_ELSA_USB2ETHERNET}, 0 },
186 {{ USB_VENDOR_HAWKING, USB_PRODUCT_HAWKING_UF100}, PII },
187 {{ USB_VENDOR_HP, USB_PRODUCT_HP_HN210E}, PII },
188 {{ USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETTX}, 0 },
189 {{ USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBETTXS}, PII },
190 {{ USB_VENDOR_IODATA, USB_PRODUCT_IODATA_ETXUS2}, PII },
191 {{ USB_VENDOR_KINGSTON, USB_PRODUCT_KINGSTON_KNU101TX}, 0 },
192 {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10TX1}, LSYS|PII },
193 {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10T}, LSYS },
194 {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB100TX}, LSYS },
195 {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB100H1}, LSYS|PNA },
196 {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10TA}, LSYS },
197 {{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10TX2}, LSYS|PII },
198 {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUATX1}, 0 },
199 {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUATX5}, 0 },
200 {{ USB_VENDOR_MELCO, USB_PRODUCT_MELCO_LUA2TX5}, PII },
201 {{ USB_VENDOR_MICROSOFT, USB_PRODUCT_MICROSOFT_MN110}, PII },
202 {{ USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_FA101}, PII },
203 {{ USB_VENDOR_SIEMENS, USB_PRODUCT_SIEMENS_SPEEDSTREAM}, PII },
204 {{ USB_VENDOR_SMARTBRIDGES, USB_PRODUCT_SMARTBRIDGES_SMARTNIC},PII },
205 {{ USB_VENDOR_SMC, USB_PRODUCT_SMC_2202USB}, 0 },
206 {{ USB_VENDOR_SMC, USB_PRODUCT_SMC_2206USB}, PII },
207 {{ USB_VENDOR_SOHOWARE, USB_PRODUCT_SOHOWARE_NUB100}, 0 },
208 };
209 #define aue_lookup(v, p) ((const struct aue_type *)usb_lookup(aue_devs, v, p))
210
211 int aue_match(device_t, cfdata_t, void *);
212 void aue_attach(device_t, device_t, void *);
213 int aue_detach(device_t, int);
214 int aue_activate(device_t, enum devact);
215 extern struct cfdriver aue_cd;
216 CFATTACH_DECL_NEW(aue, sizeof(struct aue_softc), aue_match, aue_attach,
217 aue_detach, aue_activate);
218
219 Static void aue_multithread(void *);
220
221 Static void aue_reset_pegasus_II(struct aue_softc *);
222 Static int aue_tx_list_init(struct aue_softc *);
223 Static int aue_rx_list_init(struct aue_softc *);
224 Static int aue_newbuf(struct aue_softc *, struct aue_chain *, struct mbuf *);
225 Static int aue_send(struct aue_softc *, struct mbuf *, int);
226 Static void aue_intr(struct usbd_xfer *, void *, usbd_status);
227 Static void aue_rxeof(struct usbd_xfer *, void *, usbd_status);
228 Static void aue_txeof(struct usbd_xfer *, void *, usbd_status);
229 Static void aue_tick(void *);
230 Static void aue_tick_task(void *);
231 Static void aue_start(struct ifnet *);
232 Static int aue_ioctl(struct ifnet *, u_long, void *);
233 Static void aue_init(void *);
234 Static void aue_stop(struct aue_softc *);
235 Static void aue_watchdog(struct ifnet *);
236 Static int aue_openpipes(struct aue_softc *);
237 Static int aue_ifmedia_upd(struct ifnet *);
238
239 Static int aue_eeprom_getword(struct aue_softc *, int);
240 Static void aue_read_mac(struct aue_softc *, u_char *);
241 Static int aue_miibus_readreg(device_t, int, int);
242 Static void aue_miibus_writereg(device_t, int, int, int);
243 Static void aue_miibus_statchg(struct ifnet *);
244
245 Static void aue_lock_mii(struct aue_softc *);
246 Static void aue_unlock_mii(struct aue_softc *);
247
248 Static void aue_setmulti(struct aue_softc *);
249 Static uint32_t aue_crc(void *);
250 Static void aue_reset(struct aue_softc *);
251
252 Static int aue_csr_read_1(struct aue_softc *, int);
253 Static int aue_csr_write_1(struct aue_softc *, int, int);
254 Static int aue_csr_read_2(struct aue_softc *, int);
255 Static int aue_csr_write_2(struct aue_softc *, int, int);
256
257 #define AUE_SETBIT(sc, reg, x) \
258 aue_csr_write_1(sc, reg, aue_csr_read_1(sc, reg) | (x))
259
260 #define AUE_CLRBIT(sc, reg, x) \
261 aue_csr_write_1(sc, reg, aue_csr_read_1(sc, reg) & ~(x))
262
263 Static int
aue_csr_read_1(struct aue_softc * sc,int reg)264 aue_csr_read_1(struct aue_softc *sc, int reg)
265 {
266 usb_device_request_t req;
267 usbd_status err;
268 uByte val = 0;
269
270 if (sc->aue_dying)
271 return 0;
272
273 req.bmRequestType = UT_READ_VENDOR_DEVICE;
274 req.bRequest = AUE_UR_READREG;
275 USETW(req.wValue, 0);
276 USETW(req.wIndex, reg);
277 USETW(req.wLength, 1);
278
279 err = usbd_do_request(sc->aue_udev, &req, &val);
280
281 if (err) {
282 DPRINTF(("%s: aue_csr_read_1: reg=0x%x err=%s\n",
283 device_xname(sc->aue_dev), reg, usbd_errstr(err)));
284 return 0;
285 }
286
287 return val;
288 }
289
290 Static int
aue_csr_read_2(struct aue_softc * sc,int reg)291 aue_csr_read_2(struct aue_softc *sc, int reg)
292 {
293 usb_device_request_t req;
294 usbd_status err;
295 uWord val;
296
297 if (sc->aue_dying)
298 return 0;
299
300 req.bmRequestType = UT_READ_VENDOR_DEVICE;
301 req.bRequest = AUE_UR_READREG;
302 USETW(req.wValue, 0);
303 USETW(req.wIndex, reg);
304 USETW(req.wLength, 2);
305
306 err = usbd_do_request(sc->aue_udev, &req, &val);
307
308 if (err) {
309 DPRINTF(("%s: aue_csr_read_2: reg=0x%x err=%s\n",
310 device_xname(sc->aue_dev), reg, usbd_errstr(err)));
311 return 0;
312 }
313
314 return UGETW(val);
315 }
316
317 Static int
aue_csr_write_1(struct aue_softc * sc,int reg,int aval)318 aue_csr_write_1(struct aue_softc *sc, int reg, int aval)
319 {
320 usb_device_request_t req;
321 usbd_status err;
322 uByte val;
323
324 if (sc->aue_dying)
325 return 0;
326
327 val = aval;
328 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
329 req.bRequest = AUE_UR_WRITEREG;
330 USETW(req.wValue, val);
331 USETW(req.wIndex, reg);
332 USETW(req.wLength, 1);
333
334 err = usbd_do_request(sc->aue_udev, &req, &val);
335
336 if (err) {
337 DPRINTF(("%s: aue_csr_write_1: reg=0x%x err=%s\n",
338 device_xname(sc->aue_dev), reg, usbd_errstr(err)));
339 return -1;
340 }
341
342 return 0;
343 }
344
345 Static int
aue_csr_write_2(struct aue_softc * sc,int reg,int aval)346 aue_csr_write_2(struct aue_softc *sc, int reg, int aval)
347 {
348 usb_device_request_t req;
349 usbd_status err;
350 uWord val;
351
352 if (sc->aue_dying)
353 return 0;
354
355 USETW(val, aval);
356 req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
357 req.bRequest = AUE_UR_WRITEREG;
358 USETW(req.wValue, aval);
359 USETW(req.wIndex, reg);
360 USETW(req.wLength, 2);
361
362 err = usbd_do_request(sc->aue_udev, &req, &val);
363
364 if (err) {
365 DPRINTF(("%s: aue_csr_write_2: reg=0x%x err=%s\n",
366 device_xname(sc->aue_dev), reg, usbd_errstr(err)));
367 return -1;
368 }
369
370 return 0;
371 }
372
373 /*
374 * Read a word of data stored in the EEPROM at address 'addr.'
375 */
376 Static int
aue_eeprom_getword(struct aue_softc * sc,int addr)377 aue_eeprom_getword(struct aue_softc *sc, int addr)
378 {
379 int i;
380
381 aue_csr_write_1(sc, AUE_EE_REG, addr);
382 aue_csr_write_1(sc, AUE_EE_CTL, AUE_EECTL_READ);
383
384 for (i = 0; i < AUE_TIMEOUT; i++) {
385 if (aue_csr_read_1(sc, AUE_EE_CTL) & AUE_EECTL_DONE)
386 break;
387 }
388
389 if (i == AUE_TIMEOUT) {
390 printf("%s: EEPROM read timed out\n",
391 device_xname(sc->aue_dev));
392 }
393
394 return aue_csr_read_2(sc, AUE_EE_DATA);
395 }
396
397 /*
398 * Read the MAC from the EEPROM. It's at offset 0.
399 */
400 Static void
aue_read_mac(struct aue_softc * sc,u_char * dest)401 aue_read_mac(struct aue_softc *sc, u_char *dest)
402 {
403 int i;
404 int off = 0;
405 int word;
406
407 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
408
409 for (i = 0; i < 3; i++) {
410 word = aue_eeprom_getword(sc, off + i);
411 dest[2 * i] = (u_char)word;
412 dest[2 * i + 1] = (u_char)(word >> 8);
413 }
414 }
415
416 /* Get exclusive access to the MII registers */
417 Static void
aue_lock_mii(struct aue_softc * sc)418 aue_lock_mii(struct aue_softc *sc)
419 {
420 sc->aue_refcnt++;
421 mutex_enter(&sc->aue_mii_lock);
422 }
423
424 Static void
aue_unlock_mii(struct aue_softc * sc)425 aue_unlock_mii(struct aue_softc *sc)
426 {
427 mutex_exit(&sc->aue_mii_lock);
428 if (--sc->aue_refcnt < 0)
429 usb_detach_wakeupold(sc->aue_dev);
430 }
431
432 Static int
aue_miibus_readreg(device_t dev,int phy,int reg)433 aue_miibus_readreg(device_t dev, int phy, int reg)
434 {
435 struct aue_softc *sc = device_private(dev);
436 int i;
437 uint16_t val;
438
439 if (sc->aue_dying) {
440 #ifdef DIAGNOSTIC
441 printf("%s: dying\n", device_xname(sc->aue_dev));
442 #endif
443 return 0;
444 }
445
446 #if 0
447 /*
448 * The Am79C901 HomePNA PHY actually contains
449 * two transceivers: a 1Mbps HomePNA PHY and a
450 * 10Mbps full/half duplex ethernet PHY with
451 * NWAY autoneg. However in the ADMtek adapter,
452 * only the 1Mbps PHY is actually connected to
453 * anything, so we ignore the 10Mbps one. It
454 * happens to be configured for MII address 3,
455 * so we filter that out.
456 */
457 if (sc->aue_vendor == USB_VENDOR_ADMTEK &&
458 sc->aue_product == USB_PRODUCT_ADMTEK_PEGASUS) {
459 if (phy == 3)
460 return 0;
461 }
462 #endif
463
464 aue_lock_mii(sc);
465 aue_csr_write_1(sc, AUE_PHY_ADDR, phy);
466 aue_csr_write_1(sc, AUE_PHY_CTL, reg | AUE_PHYCTL_READ);
467
468 for (i = 0; i < AUE_TIMEOUT; i++) {
469 if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
470 break;
471 }
472
473 if (i == AUE_TIMEOUT) {
474 printf("%s: MII read timed out\n", device_xname(sc->aue_dev));
475 }
476
477 val = aue_csr_read_2(sc, AUE_PHY_DATA);
478
479 DPRINTFN(11,("%s: %s: phy=%d reg=%d => 0x%04x\n",
480 device_xname(sc->aue_dev), __func__, phy, reg, val));
481
482 aue_unlock_mii(sc);
483 return val;
484 }
485
486 Static void
aue_miibus_writereg(device_t dev,int phy,int reg,int data)487 aue_miibus_writereg(device_t dev, int phy, int reg, int data)
488 {
489 struct aue_softc *sc = device_private(dev);
490 int i;
491
492 #if 0
493 if (sc->aue_vendor == USB_VENDOR_ADMTEK &&
494 sc->aue_product == USB_PRODUCT_ADMTEK_PEGASUS) {
495 if (phy == 3)
496 return;
497 }
498 #endif
499
500 DPRINTFN(11,("%s: %s: phy=%d reg=%d data=0x%04x\n",
501 device_xname(sc->aue_dev), __func__, phy, reg, data));
502
503 aue_lock_mii(sc);
504 aue_csr_write_2(sc, AUE_PHY_DATA, data);
505 aue_csr_write_1(sc, AUE_PHY_ADDR, phy);
506 aue_csr_write_1(sc, AUE_PHY_CTL, reg | AUE_PHYCTL_WRITE);
507
508 for (i = 0; i < AUE_TIMEOUT; i++) {
509 if (aue_csr_read_1(sc, AUE_PHY_CTL) & AUE_PHYCTL_DONE)
510 break;
511 }
512
513 if (i == AUE_TIMEOUT) {
514 printf("%s: MII read timed out\n", device_xname(sc->aue_dev));
515 }
516 aue_unlock_mii(sc);
517 }
518
519 Static void
aue_miibus_statchg(struct ifnet * ifp)520 aue_miibus_statchg(struct ifnet *ifp)
521 {
522 struct aue_softc *sc = ifp->if_softc;
523 struct mii_data *mii = GET_MII(sc);
524
525 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
526
527 aue_lock_mii(sc);
528 AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_RX_ENB | AUE_CTL0_TX_ENB);
529
530 if (IFM_SUBTYPE(mii->mii_media_active) == IFM_100_TX) {
531 AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_SPEEDSEL);
532 } else {
533 AUE_CLRBIT(sc, AUE_CTL1, AUE_CTL1_SPEEDSEL);
534 }
535
536 if ((mii->mii_media_active & IFM_GMASK) == IFM_FDX)
537 AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_DUPLEX);
538 else
539 AUE_CLRBIT(sc, AUE_CTL1, AUE_CTL1_DUPLEX);
540
541 AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_RX_ENB | AUE_CTL0_TX_ENB);
542 aue_unlock_mii(sc);
543
544 /*
545 * Set the LED modes on the LinkSys adapter.
546 * This turns on the 'dual link LED' bin in the auxmode
547 * register of the Broadcom PHY.
548 */
549 if (!sc->aue_dying && (sc->aue_flags & LSYS)) {
550 uint16_t auxmode;
551 auxmode = aue_miibus_readreg(sc->aue_dev, 0, 0x1b);
552 aue_miibus_writereg(sc->aue_dev, 0, 0x1b, auxmode | 0x04);
553 }
554 DPRINTFN(5,("%s: %s: exit\n", device_xname(sc->aue_dev), __func__));
555 }
556
557 #define AUE_POLY 0xEDB88320
558 #define AUE_BITS 6
559
560 Static uint32_t
aue_crc(void * addrv)561 aue_crc(void *addrv)
562 {
563 uint32_t idx, bit, data, crc;
564 char *addr = addrv;
565
566 /* Compute CRC for the address value. */
567 crc = 0xFFFFFFFF; /* initial value */
568
569 for (idx = 0; idx < 6; idx++) {
570 for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
571 crc = (crc >> 1) ^ (((crc ^ data) & 1) ? AUE_POLY : 0);
572 }
573
574 return crc & ((1 << AUE_BITS) - 1);
575 }
576
577 Static void
aue_setmulti(struct aue_softc * sc)578 aue_setmulti(struct aue_softc *sc)
579 {
580 struct ifnet *ifp;
581 struct ether_multi *enm;
582 struct ether_multistep step;
583 uint32_t h = 0, i;
584
585 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
586
587 ifp = GET_IFP(sc);
588
589 if (ifp->if_flags & IFF_PROMISC) {
590 allmulti:
591 ifp->if_flags |= IFF_ALLMULTI;
592 AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
593 return;
594 }
595
596 AUE_CLRBIT(sc, AUE_CTL0, AUE_CTL0_ALLMULTI);
597
598 /* first, zot all the existing hash bits */
599 for (i = 0; i < 8; i++)
600 aue_csr_write_1(sc, AUE_MAR0 + i, 0);
601
602 /* now program new ones */
603 ETHER_FIRST_MULTI(step, &sc->aue_ec, enm);
604 while (enm != NULL) {
605 if (memcmp(enm->enm_addrlo,
606 enm->enm_addrhi, ETHER_ADDR_LEN) != 0)
607 goto allmulti;
608
609 h = aue_crc(enm->enm_addrlo);
610 AUE_SETBIT(sc, AUE_MAR + (h >> 3), 1 << (h & 0x7));
611 ETHER_NEXT_MULTI(step, enm);
612 }
613
614 ifp->if_flags &= ~IFF_ALLMULTI;
615 }
616
617 Static void
aue_reset_pegasus_II(struct aue_softc * sc)618 aue_reset_pegasus_II(struct aue_softc *sc)
619 {
620 /* Magic constants taken from Linux driver. */
621 aue_csr_write_1(sc, AUE_REG_1D, 0);
622 aue_csr_write_1(sc, AUE_REG_7B, 2);
623 #if 0
624 if ((sc->aue_flags & HAS_HOME_PNA) && mii_mode)
625 aue_csr_write_1(sc, AUE_REG_81, 6);
626 else
627 #endif
628 aue_csr_write_1(sc, AUE_REG_81, 2);
629 }
630
631 Static void
aue_reset(struct aue_softc * sc)632 aue_reset(struct aue_softc *sc)
633 {
634 int i;
635
636 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
637
638 AUE_SETBIT(sc, AUE_CTL1, AUE_CTL1_RESETMAC);
639
640 for (i = 0; i < AUE_TIMEOUT; i++) {
641 if (!(aue_csr_read_1(sc, AUE_CTL1) & AUE_CTL1_RESETMAC))
642 break;
643 }
644
645 if (i == AUE_TIMEOUT)
646 printf("%s: reset failed\n", device_xname(sc->aue_dev));
647
648 #if 0
649 /* XXX what is mii_mode supposed to be */
650 if (sc->aue_mii_mode && (sc->aue_flags & PNA))
651 aue_csr_write_1(sc, AUE_GPIO1, 0x34);
652 else
653 aue_csr_write_1(sc, AUE_GPIO1, 0x26);
654 #endif
655
656 /*
657 * The PHY(s) attached to the Pegasus chip may be held
658 * in reset until we flip on the GPIO outputs. Make sure
659 * to set the GPIO pins high so that the PHY(s) will
660 * be enabled.
661 *
662 * Note: We force all of the GPIO pins low first, *then*
663 * enable the ones we want.
664 */
665 if (sc->aue_flags & LSYS) {
666 /* Grrr. LinkSys has to be different from everyone else. */
667 aue_csr_write_1(sc, AUE_GPIO0,
668 AUE_GPIO_SEL0 | AUE_GPIO_SEL1);
669 } else {
670 aue_csr_write_1(sc, AUE_GPIO0,
671 AUE_GPIO_OUT0 | AUE_GPIO_SEL0);
672 }
673 aue_csr_write_1(sc, AUE_GPIO0,
674 AUE_GPIO_OUT0 | AUE_GPIO_SEL0 | AUE_GPIO_SEL1);
675
676 if (sc->aue_flags & PII)
677 aue_reset_pegasus_II(sc);
678
679 /* Wait a little while for the chip to get its brains in order. */
680 delay(10000); /* XXX */
681 }
682
683 /*
684 * Probe for a Pegasus chip.
685 */
686 int
aue_match(device_t parent,cfdata_t match,void * aux)687 aue_match(device_t parent, cfdata_t match, void *aux)
688 {
689 struct usb_attach_arg *uaa = aux;
690
691 /*
692 * Some manufacturers use the same vendor and product id for
693 * different devices. We need to sanity check the DeviceClass
694 * in this case
695 * Currently known guilty products:
696 * 0x050d/0x0121 Belkin Bluetooth and USB2LAN
697 *
698 * If this turns out to be more common, we could use a quirk
699 * table.
700 */
701 if (uaa->uaa_vendor == USB_VENDOR_BELKIN &&
702 uaa->uaa_product == USB_PRODUCT_BELKIN_USB2LAN) {
703 usb_device_descriptor_t *dd;
704
705 dd = usbd_get_device_descriptor(uaa->uaa_device);
706 if (dd != NULL &&
707 dd->bDeviceClass != UDCLASS_IN_INTERFACE)
708 return UMATCH_NONE;
709 }
710
711 return aue_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
712 UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
713 }
714
715 /*
716 * Attach the interface. Allocate softc structures, do ifmedia
717 * setup and ethernet/BPF attach.
718 */
719 void
aue_attach(device_t parent,device_t self,void * aux)720 aue_attach(device_t parent, device_t self, void *aux)
721 {
722 struct aue_softc *sc = device_private(self);
723 struct usb_attach_arg *uaa = aux;
724 char *devinfop;
725 int s;
726 u_char eaddr[ETHER_ADDR_LEN];
727 struct ifnet *ifp;
728 struct mii_data *mii;
729 struct usbd_device *dev = uaa->uaa_device;
730 struct usbd_interface *iface;
731 usbd_status err;
732 usb_interface_descriptor_t *id;
733 usb_endpoint_descriptor_t *ed;
734 int i;
735
736 DPRINTFN(5,(" : aue_attach: sc=%p", sc));
737
738 sc->aue_dev = self;
739
740 aprint_naive("\n");
741 aprint_normal("\n");
742
743 devinfop = usbd_devinfo_alloc(uaa->uaa_device, 0);
744 aprint_normal_dev(self, "%s\n", devinfop);
745 usbd_devinfo_free(devinfop);
746
747 err = usbd_set_config_no(dev, AUE_CONFIG_NO, 1);
748 if (err) {
749 aprint_error_dev(self, "failed to set configuration"
750 ", err=%s\n", usbd_errstr(err));
751 return;
752 }
753
754 usb_init_task(&sc->aue_tick_task, aue_tick_task, sc, 0);
755 usb_init_task(&sc->aue_stop_task, (void (*)(void *))aue_stop, sc, 0);
756 mutex_init(&sc->aue_mii_lock, MUTEX_DEFAULT, IPL_NONE);
757
758 err = usbd_device2interface_handle(dev, AUE_IFACE_IDX, &iface);
759 if (err) {
760 aprint_error_dev(self, "getting interface handle failed\n");
761 return;
762 }
763 sc->aue_closing = 0;
764
765 mutex_init(&sc->aue_mcmtx, MUTEX_DRIVER, IPL_NET);
766 cv_init(&sc->aue_domc, "auemc");
767 cv_init(&sc->aue_closemc, "auemccl");
768
769 err = kthread_create(PRI_NONE, 0, NULL,
770 aue_multithread, sc, &sc->aue_thread,
771 "%s-mc", device_xname(sc->aue_dev));
772
773 if (err) {
774 aprint_error_dev(self,
775 "creating multicast configuration thread\n");
776 return;
777 }
778 sc->aue_flags = aue_lookup(uaa->uaa_vendor,
779 uaa->uaa_product)->aue_flags;
780
781 sc->aue_udev = dev;
782 sc->aue_iface = iface;
783 sc->aue_product = uaa->uaa_product;
784 sc->aue_vendor = uaa->uaa_vendor;
785
786 id = usbd_get_interface_descriptor(iface);
787
788 /* Find endpoints. */
789 for (i = 0; i < id->bNumEndpoints; i++) {
790 ed = usbd_interface2endpoint_descriptor(iface, i);
791 if (ed == NULL) {
792 aprint_error_dev(self,
793 "couldn't get endpoint descriptor %d\n", i);
794 return;
795 }
796 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
797 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
798 sc->aue_ed[AUE_ENDPT_RX] = ed->bEndpointAddress;
799 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
800 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
801 sc->aue_ed[AUE_ENDPT_TX] = ed->bEndpointAddress;
802 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
803 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
804 sc->aue_ed[AUE_ENDPT_INTR] = ed->bEndpointAddress;
805 }
806 }
807
808 if (sc->aue_ed[AUE_ENDPT_RX] == 0 || sc->aue_ed[AUE_ENDPT_TX] == 0 ||
809 sc->aue_ed[AUE_ENDPT_INTR] == 0) {
810 aprint_error_dev(self, "missing endpoint\n");
811 return;
812 }
813
814
815 s = splnet();
816
817 /* Reset the adapter. */
818 aue_reset(sc);
819
820 /*
821 * Get station address from the EEPROM.
822 */
823 aue_read_mac(sc, eaddr);
824
825 /*
826 * A Pegasus chip was detected. Inform the world.
827 */
828 ifp = GET_IFP(sc);
829 aprint_normal_dev(self, "Ethernet address %s\n", ether_sprintf(eaddr));
830
831 /* Initialize interface info.*/
832 ifp->if_softc = sc;
833 ifp->if_mtu = ETHERMTU;
834 ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
835 ifp->if_ioctl = aue_ioctl;
836 ifp->if_start = aue_start;
837 ifp->if_watchdog = aue_watchdog;
838 strncpy(ifp->if_xname, device_xname(sc->aue_dev), IFNAMSIZ);
839
840 IFQ_SET_READY(&ifp->if_snd);
841
842 /* Initialize MII/media info. */
843 mii = &sc->aue_mii;
844 mii->mii_ifp = ifp;
845 mii->mii_readreg = aue_miibus_readreg;
846 mii->mii_writereg = aue_miibus_writereg;
847 mii->mii_statchg = aue_miibus_statchg;
848 mii->mii_flags = MIIF_AUTOTSLEEP;
849 sc->aue_ec.ec_mii = mii;
850 ifmedia_init(&mii->mii_media, 0, aue_ifmedia_upd, ether_mediastatus);
851 mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
852 if (LIST_FIRST(&mii->mii_phys) == NULL) {
853 ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
854 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
855 } else
856 ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
857
858 /* Attach the interface. */
859 if_attach(ifp);
860 ether_ifattach(ifp, eaddr);
861 rnd_attach_source(&sc->rnd_source, device_xname(sc->aue_dev),
862 RND_TYPE_NET, RND_FLAG_DEFAULT);
863
864 callout_init(&(sc->aue_stat_ch), 0);
865
866 sc->aue_attached = 1;
867 splx(s);
868
869 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->aue_udev, sc->aue_dev);
870
871 return;
872 }
873
874 int
aue_detach(device_t self,int flags)875 aue_detach(device_t self, int flags)
876 {
877 struct aue_softc *sc = device_private(self);
878 struct ifnet *ifp = GET_IFP(sc);
879 int s;
880
881 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
882
883 if (!sc->aue_attached) {
884 /* Detached before attached finished, so just bail out. */
885 return 0;
886 }
887
888 callout_stop(&sc->aue_stat_ch);
889 /*
890 * Remove any pending tasks. They cannot be executing because they run
891 * in the same thread as detach.
892 */
893 usb_rem_task(sc->aue_udev, &sc->aue_tick_task);
894 usb_rem_task(sc->aue_udev, &sc->aue_stop_task);
895
896 sc->aue_closing = 1;
897 cv_signal(&sc->aue_domc);
898
899 mutex_enter(&sc->aue_mcmtx);
900 cv_wait(&sc->aue_closemc,&sc->aue_mcmtx);
901 mutex_exit(&sc->aue_mcmtx);
902
903 mutex_destroy(&sc->aue_mcmtx);
904 cv_destroy(&sc->aue_domc);
905 cv_destroy(&sc->aue_closemc);
906
907 s = splusb();
908
909 if (ifp->if_flags & IFF_RUNNING)
910 aue_stop(sc);
911
912 rnd_detach_source(&sc->rnd_source);
913 mii_detach(&sc->aue_mii, MII_PHY_ANY, MII_OFFSET_ANY);
914 ifmedia_delete_instance(&sc->aue_mii.mii_media, IFM_INST_ANY);
915 ether_ifdetach(ifp);
916
917 if_detach(ifp);
918
919 #ifdef DIAGNOSTIC
920 if (sc->aue_ep[AUE_ENDPT_TX] != NULL ||
921 sc->aue_ep[AUE_ENDPT_RX] != NULL ||
922 sc->aue_ep[AUE_ENDPT_INTR] != NULL)
923 aprint_error_dev(self, "detach has active endpoints\n");
924 #endif
925
926 sc->aue_attached = 0;
927
928 if (--sc->aue_refcnt >= 0) {
929 /* Wait for processes to go away. */
930 usb_detach_waitold(sc->aue_dev);
931 }
932 splx(s);
933
934 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->aue_udev, sc->aue_dev);
935
936 mutex_destroy(&sc->aue_mii_lock);
937 #if 0
938 mutex_destroy(&sc->wkmtx);
939 #endif
940 return 0;
941 }
942
943 int
aue_activate(device_t self,enum devact act)944 aue_activate(device_t self, enum devact act)
945 {
946 struct aue_softc *sc = device_private(self);
947
948 DPRINTFN(2,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
949
950 switch (act) {
951 case DVACT_DEACTIVATE:
952 if_deactivate(&sc->aue_ec.ec_if);
953 sc->aue_dying = 1;
954 return 0;
955 default:
956 return EOPNOTSUPP;
957 }
958 }
959
960 /*
961 * Initialize an RX descriptor and attach an MBUF cluster.
962 */
963 Static int
aue_newbuf(struct aue_softc * sc,struct aue_chain * c,struct mbuf * m)964 aue_newbuf(struct aue_softc *sc, struct aue_chain *c, struct mbuf *m)
965 {
966 struct mbuf *m_new = NULL;
967
968 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->aue_dev),__func__));
969
970 if (m == NULL) {
971 MGETHDR(m_new, M_DONTWAIT, MT_DATA);
972 if (m_new == NULL) {
973 aprint_error_dev(sc->aue_dev, "no memory for rx list "
974 "-- packet dropped!\n");
975 return ENOBUFS;
976 }
977
978 MCLGET(m_new, M_DONTWAIT);
979 if (!(m_new->m_flags & M_EXT)) {
980 aprint_error_dev(sc->aue_dev, "no memory for rx "
981 "list -- packet dropped!\n");
982 m_freem(m_new);
983 return ENOBUFS;
984 }
985 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
986 } else {
987 m_new = m;
988 m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
989 m_new->m_data = m_new->m_ext.ext_buf;
990 }
991
992 m_adj(m_new, ETHER_ALIGN);
993 c->aue_mbuf = m_new;
994
995 return 0;
996 }
997
998 Static int
aue_rx_list_init(struct aue_softc * sc)999 aue_rx_list_init(struct aue_softc *sc)
1000 {
1001 struct aue_cdata *cd;
1002 struct aue_chain *c;
1003 int i;
1004
1005 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
1006
1007 cd = &sc->aue_cdata;
1008 for (i = 0; i < AUE_RX_LIST_CNT; i++) {
1009 c = &cd->aue_rx_chain[i];
1010 c->aue_sc = sc;
1011 c->aue_idx = i;
1012 if (aue_newbuf(sc, c, NULL) == ENOBUFS)
1013 return ENOBUFS;
1014 if (c->aue_xfer == NULL) {
1015 int err = usbd_create_xfer(sc->aue_ep[AUE_ENDPT_RX],
1016 AUE_BUFSZ, USBD_SHORT_XFER_OK, 0, &c->aue_xfer);
1017 if (err) {
1018 return err;
1019 }
1020 c->aue_buf = usbd_get_buffer(c->aue_xfer);
1021 }
1022 }
1023
1024 return 0;
1025 }
1026
1027 Static int
aue_tx_list_init(struct aue_softc * sc)1028 aue_tx_list_init(struct aue_softc *sc)
1029 {
1030 struct aue_cdata *cd;
1031 struct aue_chain *c;
1032 int i;
1033
1034 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
1035
1036 cd = &sc->aue_cdata;
1037 for (i = 0; i < AUE_TX_LIST_CNT; i++) {
1038 c = &cd->aue_tx_chain[i];
1039 c->aue_sc = sc;
1040 c->aue_idx = i;
1041 c->aue_mbuf = NULL;
1042 if (c->aue_xfer == NULL) {
1043 int err = usbd_create_xfer(sc->aue_ep[AUE_ENDPT_TX],
1044 AUE_BUFSZ, USBD_FORCE_SHORT_XFER, 0, &c->aue_xfer);
1045 if (err) {
1046 return err;
1047 }
1048 c->aue_buf = usbd_get_buffer(c->aue_xfer);
1049 }
1050 }
1051
1052 return 0;
1053 }
1054
1055 Static void
aue_intr(struct usbd_xfer * xfer,void * priv,usbd_status status)1056 aue_intr(struct usbd_xfer *xfer, void *priv,
1057 usbd_status status)
1058 {
1059 struct aue_softc *sc = priv;
1060 struct ifnet *ifp = GET_IFP(sc);
1061 struct aue_intrpkt *p = &sc->aue_cdata.aue_ibuf;
1062
1063 DPRINTFN(15,("%s: %s: enter\n", device_xname(sc->aue_dev),__func__));
1064
1065 if (sc->aue_dying)
1066 return;
1067
1068 if (!(ifp->if_flags & IFF_RUNNING))
1069 return;
1070
1071 if (status != USBD_NORMAL_COMPLETION) {
1072 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1073 return;
1074 }
1075 sc->aue_intr_errs++;
1076 if (usbd_ratecheck(&sc->aue_rx_notice)) {
1077 aprint_debug_dev(sc->aue_dev,
1078 "%u usb errors on intr: %s\n", sc->aue_intr_errs,
1079 usbd_errstr(status));
1080 sc->aue_intr_errs = 0;
1081 }
1082 if (status == USBD_STALLED)
1083 usbd_clear_endpoint_stall_async(sc->aue_ep[AUE_ENDPT_RX]);
1084 return;
1085 }
1086
1087 if (p->aue_txstat0)
1088 ifp->if_oerrors++;
1089
1090 if (p->aue_txstat0 & (AUE_TXSTAT0_LATECOLL | AUE_TXSTAT0_EXCESSCOLL))
1091 ifp->if_collisions++;
1092 }
1093
1094 /*
1095 * A frame has been uploaded: pass the resulting mbuf chain up to
1096 * the higher level protocols.
1097 */
1098 Static void
aue_rxeof(struct usbd_xfer * xfer,void * priv,usbd_status status)1099 aue_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status)
1100 {
1101 struct aue_chain *c = priv;
1102 struct aue_softc *sc = c->aue_sc;
1103 struct ifnet *ifp = GET_IFP(sc);
1104 struct mbuf *m;
1105 uint32_t total_len;
1106 struct aue_rxpkt r;
1107 int s;
1108
1109 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->aue_dev),__func__));
1110
1111 if (sc->aue_dying)
1112 return;
1113
1114 if (!(ifp->if_flags & IFF_RUNNING))
1115 return;
1116
1117 if (status != USBD_NORMAL_COMPLETION) {
1118 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
1119 return;
1120 sc->aue_rx_errs++;
1121 if (usbd_ratecheck(&sc->aue_rx_notice)) {
1122 aprint_error_dev(sc->aue_dev,
1123 "%u usb errors on rx: %s\n", sc->aue_rx_errs,
1124 usbd_errstr(status));
1125 sc->aue_rx_errs = 0;
1126 }
1127 if (status == USBD_STALLED)
1128 usbd_clear_endpoint_stall_async(sc->aue_ep[AUE_ENDPT_RX]);
1129 goto done;
1130 }
1131
1132 usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
1133
1134 memcpy(mtod(c->aue_mbuf, char *), c->aue_buf, total_len);
1135
1136 if (total_len <= 4 + ETHER_CRC_LEN) {
1137 ifp->if_ierrors++;
1138 goto done;
1139 }
1140
1141 memcpy(&r, c->aue_buf + total_len - 4, sizeof(r));
1142
1143 /* Turn off all the non-error bits in the rx status word. */
1144 r.aue_rxstat &= AUE_RXSTAT_MASK;
1145 if (r.aue_rxstat) {
1146 ifp->if_ierrors++;
1147 goto done;
1148 }
1149
1150 /* No errors; receive the packet. */
1151 m = c->aue_mbuf;
1152 total_len -= ETHER_CRC_LEN + 4;
1153 m->m_pkthdr.len = m->m_len = total_len;
1154 ifp->if_ipackets++;
1155
1156 m_set_rcvif(m, ifp);
1157
1158 s = splnet();
1159
1160 /* XXX ugly */
1161 if (aue_newbuf(sc, c, NULL) == ENOBUFS) {
1162 ifp->if_ierrors++;
1163 goto done1;
1164 }
1165
1166 /*
1167 * Handle BPF listeners. Let the BPF user see the packet, but
1168 * don't pass it up to the ether_input() layer unless it's
1169 * a broadcast packet, multicast packet, matches our ethernet
1170 * address or the interface is in promiscuous mode.
1171 */
1172 bpf_mtap(ifp, m);
1173
1174 DPRINTFN(10,("%s: %s: deliver %d\n", device_xname(sc->aue_dev),
1175 __func__, m->m_len));
1176 if_percpuq_enqueue(ifp->if_percpuq, m);
1177 done1:
1178 splx(s);
1179
1180 done:
1181
1182 /* Setup new transfer. */
1183 usbd_setup_xfer(xfer, c, c->aue_buf, AUE_BUFSZ,
1184 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, aue_rxeof);
1185 usbd_transfer(xfer);
1186
1187 DPRINTFN(10,("%s: %s: start rx\n", device_xname(sc->aue_dev),
1188 __func__));
1189 }
1190
1191 /*
1192 * A frame was downloaded to the chip. It's safe for us to clean up
1193 * the list buffers.
1194 */
1195
1196 Static void
aue_txeof(struct usbd_xfer * xfer,void * priv,usbd_status status)1197 aue_txeof(struct usbd_xfer *xfer, void *priv,
1198 usbd_status status)
1199 {
1200 struct aue_chain *c = priv;
1201 struct aue_softc *sc = c->aue_sc;
1202 struct ifnet *ifp = GET_IFP(sc);
1203 int s;
1204
1205 if (sc->aue_dying)
1206 return;
1207
1208 s = splnet();
1209
1210 DPRINTFN(10,("%s: %s: enter status=%d\n", device_xname(sc->aue_dev),
1211 __func__, status));
1212
1213 ifp->if_timer = 0;
1214 ifp->if_flags &= ~IFF_OACTIVE;
1215
1216 if (status != USBD_NORMAL_COMPLETION) {
1217 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
1218 splx(s);
1219 return;
1220 }
1221 ifp->if_oerrors++;
1222 aprint_error_dev(sc->aue_dev, "usb error on tx: %s\n",
1223 usbd_errstr(status));
1224 if (status == USBD_STALLED)
1225 usbd_clear_endpoint_stall_async(sc->aue_ep[AUE_ENDPT_TX]);
1226 splx(s);
1227 return;
1228 }
1229
1230 ifp->if_opackets++;
1231
1232 m_freem(c->aue_mbuf);
1233 c->aue_mbuf = NULL;
1234
1235 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1236 aue_start(ifp);
1237
1238 splx(s);
1239 }
1240
1241 Static void
aue_tick(void * xsc)1242 aue_tick(void *xsc)
1243 {
1244 struct aue_softc *sc = xsc;
1245
1246 DPRINTFN(15,("%s: %s: enter\n", device_xname(sc->aue_dev),__func__));
1247
1248 if (sc == NULL)
1249 return;
1250
1251 if (sc->aue_dying)
1252 return;
1253
1254 /* Perform periodic stuff in process context. */
1255 usb_add_task(sc->aue_udev, &sc->aue_tick_task, USB_TASKQ_DRIVER);
1256 }
1257
1258 Static void
aue_tick_task(void * xsc)1259 aue_tick_task(void *xsc)
1260 {
1261 struct aue_softc *sc = xsc;
1262 struct ifnet *ifp;
1263 struct mii_data *mii;
1264 int s;
1265
1266 DPRINTFN(15,("%s: %s: enter\n", device_xname(sc->aue_dev),__func__));
1267
1268 if (sc->aue_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->aue_link) {
1280 mii_pollstat(mii); /* XXX FreeBSD has removed this call */
1281 if (mii->mii_media_status & IFM_ACTIVE &&
1282 IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) {
1283 DPRINTFN(2,("%s: %s: got link\n",
1284 device_xname(sc->aue_dev), __func__));
1285 sc->aue_link++;
1286 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1287 aue_start(ifp);
1288 }
1289 }
1290
1291 callout_reset(&(sc->aue_stat_ch), (hz), (aue_tick), (sc));
1292
1293 splx(s);
1294 }
1295
1296 Static int
aue_send(struct aue_softc * sc,struct mbuf * m,int idx)1297 aue_send(struct aue_softc *sc, struct mbuf *m, int idx)
1298 {
1299 int total_len;
1300 struct aue_chain *c;
1301 usbd_status err;
1302
1303 DPRINTFN(10,("%s: %s: enter\n", device_xname(sc->aue_dev),__func__));
1304
1305 c = &sc->aue_cdata.aue_tx_chain[idx];
1306
1307 /*
1308 * Copy the mbuf data into a contiguous buffer, leaving two
1309 * bytes at the beginning to hold the frame length.
1310 */
1311 m_copydata(m, 0, m->m_pkthdr.len, c->aue_buf + 2);
1312 c->aue_mbuf = m;
1313
1314 /*
1315 * The ADMtek documentation says that the packet length is
1316 * supposed to be specified in the first two bytes of the
1317 * transfer, however it actually seems to ignore this info
1318 * and base the frame size on the bulk transfer length.
1319 */
1320 c->aue_buf[0] = (uint8_t)m->m_pkthdr.len;
1321 c->aue_buf[1] = (uint8_t)(m->m_pkthdr.len >> 8);
1322 total_len = m->m_pkthdr.len + 2;
1323
1324 usbd_setup_xfer(c->aue_xfer, c, c->aue_buf, total_len,
1325 USBD_FORCE_SHORT_XFER, AUE_TX_TIMEOUT, aue_txeof);
1326
1327 /* Transmit */
1328 err = usbd_transfer(c->aue_xfer);
1329 if (err != USBD_IN_PROGRESS) {
1330 aprint_error_dev(sc->aue_dev, "aue_send error=%s\n",
1331 usbd_errstr(err));
1332 /* Stop the interface from process context. */
1333 usb_add_task(sc->aue_udev, &sc->aue_stop_task,
1334 USB_TASKQ_DRIVER);
1335 return EIO;
1336 }
1337 DPRINTFN(5,("%s: %s: send %d bytes\n", device_xname(sc->aue_dev),
1338 __func__, total_len));
1339
1340 sc->aue_cdata.aue_tx_cnt++;
1341
1342 return 0;
1343 }
1344
1345 Static void
aue_start(struct ifnet * ifp)1346 aue_start(struct ifnet *ifp)
1347 {
1348 struct aue_softc *sc = ifp->if_softc;
1349 struct mbuf *m_head = NULL;
1350
1351 DPRINTFN(5,("%s: %s: enter, link=%d\n", device_xname(sc->aue_dev),
1352 __func__, sc->aue_link));
1353
1354 if (sc->aue_dying)
1355 return;
1356
1357 if (!sc->aue_link)
1358 return;
1359
1360 if (ifp->if_flags & IFF_OACTIVE)
1361 return;
1362
1363 IFQ_POLL(&ifp->if_snd, m_head);
1364 if (m_head == NULL)
1365 return;
1366
1367 if (aue_send(sc, m_head, 0)) {
1368 ifp->if_flags |= IFF_OACTIVE;
1369 return;
1370 }
1371
1372 IFQ_DEQUEUE(&ifp->if_snd, m_head);
1373
1374 /*
1375 * If there's a BPF listener, bounce a copy of this frame
1376 * to him.
1377 */
1378 bpf_mtap(ifp, m_head);
1379
1380 ifp->if_flags |= IFF_OACTIVE;
1381
1382 /*
1383 * Set a timeout in case the chip goes out to lunch.
1384 */
1385 ifp->if_timer = 5;
1386 }
1387
1388 Static void
aue_init(void * xsc)1389 aue_init(void *xsc)
1390 {
1391 struct aue_softc *sc = xsc;
1392 struct ifnet *ifp = GET_IFP(sc);
1393 struct mii_data *mii = GET_MII(sc);
1394 int i, s;
1395 const u_char *eaddr;
1396
1397 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
1398
1399 if (sc->aue_dying)
1400 return;
1401
1402 if (ifp->if_flags & IFF_RUNNING)
1403 return;
1404
1405 s = splnet();
1406
1407 /*
1408 * Cancel pending I/O and free all RX/TX buffers.
1409 */
1410 aue_reset(sc);
1411
1412 eaddr = CLLADDR(ifp->if_sadl);
1413 for (i = 0; i < ETHER_ADDR_LEN; i++)
1414 aue_csr_write_1(sc, AUE_PAR0 + i, eaddr[i]);
1415
1416 /* If we want promiscuous mode, set the allframes bit. */
1417 if (ifp->if_flags & IFF_PROMISC)
1418 AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1419 else
1420 AUE_CLRBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1421
1422 if (sc->aue_ep[AUE_ENDPT_RX] == NULL) {
1423 if (aue_openpipes(sc)) {
1424 splx(s);
1425 return;
1426 }
1427 }
1428 /* Init TX ring. */
1429 if (aue_tx_list_init(sc)) {
1430 aprint_error_dev(sc->aue_dev, "tx list init failed\n");
1431 splx(s);
1432 return;
1433 }
1434
1435 /* Init RX ring. */
1436 if (aue_rx_list_init(sc)) {
1437 aprint_error_dev(sc->aue_dev, "rx list init failed\n");
1438 splx(s);
1439 return;
1440 }
1441
1442 /* Start up the receive pipe. */
1443 for (i = 0; i < AUE_RX_LIST_CNT; i++) {
1444 struct aue_chain *c = &sc->aue_cdata.aue_rx_chain[i];
1445
1446 usbd_setup_xfer(c->aue_xfer, c, c->aue_buf, AUE_BUFSZ,
1447 USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, aue_rxeof);
1448 (void)usbd_transfer(c->aue_xfer); /* XXX */
1449 DPRINTFN(5,("%s: %s: start read\n", device_xname(sc->aue_dev),
1450 __func__));
1451
1452 }
1453
1454 /* Load the multicast filter. */
1455 aue_setmulti(sc);
1456
1457 /* Enable RX and TX */
1458 aue_csr_write_1(sc, AUE_CTL0, AUE_CTL0_RXSTAT_APPEND | AUE_CTL0_RX_ENB);
1459 AUE_SETBIT(sc, AUE_CTL0, AUE_CTL0_TX_ENB);
1460 AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_EP3_CLR);
1461
1462 mii_mediachg(mii);
1463
1464 ifp->if_flags |= IFF_RUNNING;
1465 ifp->if_flags &= ~IFF_OACTIVE;
1466
1467 splx(s);
1468
1469 callout_reset(&(sc->aue_stat_ch), (hz), (aue_tick), (sc));
1470 }
1471
1472 Static int
aue_openpipes(struct aue_softc * sc)1473 aue_openpipes(struct aue_softc *sc)
1474 {
1475 usbd_status err;
1476
1477 /* Open RX and TX pipes. */
1478 err = usbd_open_pipe(sc->aue_iface, sc->aue_ed[AUE_ENDPT_RX],
1479 USBD_EXCLUSIVE_USE, &sc->aue_ep[AUE_ENDPT_RX]);
1480 if (err) {
1481 aprint_error_dev(sc->aue_dev, "open rx pipe failed: %s\n",
1482 usbd_errstr(err));
1483 return EIO;
1484 }
1485 err = usbd_open_pipe(sc->aue_iface, sc->aue_ed[AUE_ENDPT_TX],
1486 USBD_EXCLUSIVE_USE, &sc->aue_ep[AUE_ENDPT_TX]);
1487 if (err) {
1488 aprint_error_dev(sc->aue_dev, "open tx pipe failed: %s\n",
1489 usbd_errstr(err));
1490 return EIO;
1491 }
1492 err = usbd_open_pipe_intr(sc->aue_iface, sc->aue_ed[AUE_ENDPT_INTR],
1493 USBD_EXCLUSIVE_USE, &sc->aue_ep[AUE_ENDPT_INTR], sc,
1494 &sc->aue_cdata.aue_ibuf, AUE_INTR_PKTLEN, aue_intr,
1495 AUE_INTR_INTERVAL);
1496 if (err) {
1497 aprint_error_dev(sc->aue_dev, "open intr pipe failed: %s\n",
1498 usbd_errstr(err));
1499 return EIO;
1500 }
1501
1502 return 0;
1503 }
1504
1505 /*
1506 * Set media options.
1507 */
1508 Static int
aue_ifmedia_upd(struct ifnet * ifp)1509 aue_ifmedia_upd(struct ifnet *ifp)
1510 {
1511 struct aue_softc *sc = ifp->if_softc;
1512 struct mii_data *mii = GET_MII(sc);
1513 int rc;
1514
1515 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
1516
1517 if (sc->aue_dying)
1518 return 0;
1519
1520 sc->aue_link = 0;
1521
1522 if ((rc = mii_mediachg(mii)) == ENXIO)
1523 return 0;
1524 return rc;
1525 }
1526
1527 Static int
aue_ioctl(struct ifnet * ifp,u_long command,void * data)1528 aue_ioctl(struct ifnet *ifp, u_long command, void *data)
1529 {
1530 struct aue_softc *sc = ifp->if_softc;
1531 struct ifaddr *ifa = (struct ifaddr *)data;
1532 struct ifreq *ifr = (struct ifreq *)data;
1533 int s, error = 0;
1534
1535 if (sc->aue_dying)
1536 return EIO;
1537
1538 s = splnet();
1539
1540 switch(command) {
1541 case SIOCINITIFADDR:
1542 ifp->if_flags |= IFF_UP;
1543 aue_init(sc);
1544
1545 switch (ifa->ifa_addr->sa_family) {
1546 #ifdef INET
1547 case AF_INET:
1548 arp_ifinit(ifp, ifa);
1549 break;
1550 #endif /* INET */
1551 }
1552 break;
1553
1554 case SIOCSIFMTU:
1555 if (ifr->ifr_mtu < ETHERMIN || ifr->ifr_mtu > ETHERMTU)
1556 error = EINVAL;
1557 else if ((error = ifioctl_common(ifp, command, data)) == ENETRESET)
1558 error = 0;
1559 break;
1560
1561 case SIOCSIFFLAGS:
1562 if ((error = ifioctl_common(ifp, command, data)) != 0)
1563 break;
1564 if (ifp->if_flags & IFF_UP) {
1565 if (ifp->if_flags & IFF_RUNNING &&
1566 ifp->if_flags & IFF_PROMISC &&
1567 !(sc->aue_if_flags & IFF_PROMISC)) {
1568 AUE_SETBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1569 } else if (ifp->if_flags & IFF_RUNNING &&
1570 !(ifp->if_flags & IFF_PROMISC) &&
1571 sc->aue_if_flags & IFF_PROMISC) {
1572 AUE_CLRBIT(sc, AUE_CTL2, AUE_CTL2_RX_PROMISC);
1573 } else if (!(ifp->if_flags & IFF_RUNNING))
1574 aue_init(sc);
1575 } else {
1576 if (ifp->if_flags & IFF_RUNNING)
1577 aue_stop(sc);
1578 }
1579 sc->aue_if_flags = ifp->if_flags;
1580 error = 0;
1581 break;
1582 case SIOCADDMULTI:
1583 case SIOCDELMULTI:
1584 case SIOCGIFMEDIA:
1585 case SIOCSIFMEDIA:
1586 if ((error = ether_ioctl(ifp, command, data)) == ENETRESET) {
1587 if (ifp->if_flags & IFF_RUNNING) {
1588 cv_signal(&sc->aue_domc);
1589 }
1590 error = 0;
1591 }
1592 break;
1593 default:
1594 error = ether_ioctl(ifp, command, data);
1595 break;
1596 }
1597
1598 splx(s);
1599
1600 return error;
1601 }
1602
1603 Static void
aue_watchdog(struct ifnet * ifp)1604 aue_watchdog(struct ifnet *ifp)
1605 {
1606 struct aue_softc *sc = ifp->if_softc;
1607 struct aue_chain *c;
1608 usbd_status stat;
1609 int s;
1610
1611 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
1612
1613 ifp->if_oerrors++;
1614 aprint_error_dev(sc->aue_dev, "watchdog timeout\n");
1615
1616 s = splusb();
1617 c = &sc->aue_cdata.aue_tx_chain[0];
1618 usbd_get_xfer_status(c->aue_xfer, NULL, NULL, NULL, &stat);
1619 aue_txeof(c->aue_xfer, c, stat);
1620
1621 if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)
1622 aue_start(ifp);
1623 splx(s);
1624 }
1625
1626 /*
1627 * Stop the adapter and free any mbufs allocated to the
1628 * RX and TX lists.
1629 */
1630 Static void
aue_stop(struct aue_softc * sc)1631 aue_stop(struct aue_softc *sc)
1632 {
1633 usbd_status err;
1634 struct ifnet *ifp;
1635 int i;
1636
1637 DPRINTFN(5,("%s: %s: enter\n", device_xname(sc->aue_dev), __func__));
1638
1639 ifp = GET_IFP(sc);
1640 ifp->if_timer = 0;
1641
1642 aue_csr_write_1(sc, AUE_CTL0, 0);
1643 aue_csr_write_1(sc, AUE_CTL1, 0);
1644 aue_reset(sc);
1645 callout_stop(&sc->aue_stat_ch);
1646
1647 /* Stop transfers. */
1648 if (sc->aue_ep[AUE_ENDPT_RX] != NULL) {
1649 err = usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_RX]);
1650 if (err) {
1651 printf("%s: abort rx pipe failed: %s\n",
1652 device_xname(sc->aue_dev), usbd_errstr(err));
1653 }
1654 err = usbd_close_pipe(sc->aue_ep[AUE_ENDPT_RX]);
1655 if (err) {
1656 printf("%s: close rx pipe failed: %s\n",
1657 device_xname(sc->aue_dev), usbd_errstr(err));
1658 }
1659 sc->aue_ep[AUE_ENDPT_RX] = NULL;
1660 }
1661
1662 if (sc->aue_ep[AUE_ENDPT_TX] != NULL) {
1663 err = usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_TX]);
1664 if (err) {
1665 printf("%s: abort tx pipe failed: %s\n",
1666 device_xname(sc->aue_dev), usbd_errstr(err));
1667 }
1668 }
1669
1670 if (sc->aue_ep[AUE_ENDPT_INTR] != NULL) {
1671 err = usbd_abort_pipe(sc->aue_ep[AUE_ENDPT_INTR]);
1672 if (err) {
1673 printf("%s: abort intr pipe failed: %s\n",
1674 device_xname(sc->aue_dev), usbd_errstr(err));
1675 }
1676 }
1677
1678 /* Free RX resources. */
1679 for (i = 0; i < AUE_RX_LIST_CNT; i++) {
1680 if (sc->aue_cdata.aue_rx_chain[i].aue_mbuf != NULL) {
1681 m_freem(sc->aue_cdata.aue_rx_chain[i].aue_mbuf);
1682 sc->aue_cdata.aue_rx_chain[i].aue_mbuf = NULL;
1683 }
1684 if (sc->aue_cdata.aue_rx_chain[i].aue_xfer != NULL) {
1685 usbd_destroy_xfer(sc->aue_cdata.aue_rx_chain[i].aue_xfer);
1686 sc->aue_cdata.aue_rx_chain[i].aue_xfer = NULL;
1687 }
1688 }
1689
1690 /* Free TX resources. */
1691 for (i = 0; i < AUE_TX_LIST_CNT; i++) {
1692 if (sc->aue_cdata.aue_tx_chain[i].aue_mbuf != NULL) {
1693 m_freem(sc->aue_cdata.aue_tx_chain[i].aue_mbuf);
1694 sc->aue_cdata.aue_tx_chain[i].aue_mbuf = NULL;
1695 }
1696 if (sc->aue_cdata.aue_tx_chain[i].aue_xfer != NULL) {
1697 usbd_destroy_xfer(sc->aue_cdata.aue_tx_chain[i].aue_xfer);
1698 sc->aue_cdata.aue_tx_chain[i].aue_xfer = NULL;
1699 }
1700 }
1701
1702 /* Close pipes */
1703 if (sc->aue_ep[AUE_ENDPT_TX] != NULL) {
1704 err = usbd_close_pipe(sc->aue_ep[AUE_ENDPT_TX]);
1705 if (err) {
1706 printf("%s: close tx pipe failed: %s\n",
1707 device_xname(sc->aue_dev), usbd_errstr(err));
1708 }
1709 sc->aue_ep[AUE_ENDPT_TX] = NULL;
1710 }
1711
1712 if (sc->aue_ep[AUE_ENDPT_INTR] != NULL) {
1713 err = usbd_close_pipe(sc->aue_ep[AUE_ENDPT_INTR]);
1714 if (err) {
1715 printf("%s: close intr pipe failed: %s\n",
1716 device_xname(sc->aue_dev), usbd_errstr(err));
1717 }
1718 sc->aue_ep[AUE_ENDPT_INTR] = NULL;
1719 }
1720
1721 sc->aue_link = 0;
1722
1723 ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
1724 }
1725
1726 Static void
aue_multithread(void * arg)1727 aue_multithread(void *arg)
1728 {
1729 struct aue_softc *sc;
1730 int s;
1731
1732 sc = (struct aue_softc *)arg;
1733
1734 while (1) {
1735 mutex_enter(&sc->aue_mcmtx);
1736 cv_wait(&sc->aue_domc,&sc->aue_mcmtx);
1737 mutex_exit(&sc->aue_mcmtx);
1738
1739 if (sc->aue_closing)
1740 break;
1741
1742 s = splnet();
1743 aue_init(sc);
1744 /* XXX called by aue_init, but rc ifconfig hangs without it: */
1745 aue_setmulti(sc);
1746 splx(s);
1747 }
1748
1749 cv_signal(&sc->aue_closemc);
1750
1751 kthread_exit(0);
1752 }
1753