2000-01-05 04:27:24 +00:00
|
|
|
/*
|
2000-01-05 23:38:07 +00:00
|
|
|
* Copyright (c) 1997, 1998, 1999, 2000
|
2000-01-05 04:27:24 +00:00
|
|
|
* Bill Paul <wpaul@ee.columbia.edu>. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by Bill Paul.
|
|
|
|
* 4. Neither the name of the author nor the names of any co-contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
|
|
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* $FreeBSD$
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2000-01-05 17:13:50 +00:00
|
|
|
* Kawasaki LSI KL5KUSB101B USB to ethernet adapter driver.
|
|
|
|
*
|
2000-01-05 04:27:24 +00:00
|
|
|
* Written by Bill Paul <wpaul@ee.columbia.edu>
|
|
|
|
* Electrical Engineering Department
|
|
|
|
* Columbia University, New York City
|
|
|
|
*/
|
|
|
|
|
2000-01-05 17:13:50 +00:00
|
|
|
/*
|
|
|
|
* The KLSI USB to ethernet adapter chip contains an USB serial interface,
|
|
|
|
* ethernet MAC and embedded microcontroller (called the QT Engine).
|
|
|
|
* The chip must have firmware loaded into it before it will operate.
|
|
|
|
* Packets are passed between the chip and host via bulk transfers.
|
|
|
|
* There is an interrupt endpoint mentioned in the software spec, however
|
|
|
|
* it's currently unused. This device is 10Mbps half-duplex only, hence
|
|
|
|
* there is no media selection logic. The MAC supports a 128 entry
|
|
|
|
* multicast filter, though the exact size of the filter can depend
|
|
|
|
* on the firmware. Curiously, while the software spec describes various
|
|
|
|
* ethernet statistics counters, my sample adapter and firmware combination
|
|
|
|
* claims not to support any statistics counters at all.
|
|
|
|
*
|
|
|
|
* Note that once we load the firmware in the device, we have to be
|
|
|
|
* careful not to load it again: if you restart your computer but
|
|
|
|
* leave the adapter attached to the USB controller, it may remain
|
|
|
|
* powered on and retain its firmware. In this case, we don't need
|
|
|
|
* to load the firmware a second time.
|
2000-01-05 23:38:07 +00:00
|
|
|
*
|
|
|
|
* Special thanks to Rob Furr for providing an ADS Technologies
|
|
|
|
* adapter for development and testing. No monkeys were harmed during
|
|
|
|
* the development of this driver.
|
2000-01-05 17:13:50 +00:00
|
|
|
*/
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/sockio.h>
|
|
|
|
#include <sys/mbuf.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_arp.h>
|
|
|
|
#include <net/ethernet.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_media.h>
|
|
|
|
|
|
|
|
#include <net/bpf.h>
|
|
|
|
|
|
|
|
#include <machine/clock.h> /* for DELAY */
|
|
|
|
#include <sys/bus.h>
|
|
|
|
|
|
|
|
#include <dev/usb/usb.h>
|
|
|
|
#include <dev/usb/usbdi.h>
|
|
|
|
#include <dev/usb/usbdi_util.h>
|
|
|
|
#include <dev/usb/usbdivar.h>
|
|
|
|
#include <dev/usb/usbdevs.h>
|
Attempt to fix a problem with receiving packets on USB ethernet interfaces.
Packets are received inside USB bulk transfer callbacks, which run at
splusb() (actually splbio()). The packet input queues are meant to be
manipulated at splimp(). However the locking apparently breaks down under
certain circumstances and the input queues can get trampled.
There's a similar problem with if_ppp, which is driven by hardware/tty
interrupts from the serial driver, but which must also manipulate the
packet input queues at splimp(). The fix there is to use a netisr, and
that's the fix I used here. (I can hear you groaning back there. Hush up.)
The usb_ethersubr module maintains a single queue of its own. When a
packet is received in the USB callback routine, it's placed on this
queue with usb_ether_input(). This routine also schedules a soft net
interrupt with schednetisr(). The ISR routine then runs later, at
splnet, outside of the USB callback/interrupt context, and passes the
packet to ether_input(), hopefully in a safe manner.
The reason this is implemented as a separate module is that there are
a limited number of NETISRs that we can use, and snarfing one up for
each driver that needs it is wasteful (there will be three once I get
the CATC driver done). It also reduces code duplication to a certain
small extent. Unfortunately, it also needs to be linked in with the
usb.ko module in order for the USB ethernet drivers to share it.
Also removed some uneeded includes from if_aue.c and if_kue.c
Fix suggested by: peter
Not rejected as a hairbrained idea by: n_hibma
2000-01-10 23:12:54 +00:00
|
|
|
#include <dev/usb/usb_ethersubr.h>
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
#include <dev/usb/if_kuereg.h>
|
|
|
|
#include <dev/usb/kue_fw.h>
|
|
|
|
|
|
|
|
#ifndef lint
|
|
|
|
static const char rcsid[] =
|
|
|
|
"$FreeBSD$";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2000-01-16 22:45:07 +00:00
|
|
|
* Various supported device vendors/products.
|
2000-01-05 04:27:24 +00:00
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static struct kue_type kue_devs[] = {
|
2000-01-16 22:45:07 +00:00
|
|
|
{ USB_VENDOR_AOX, USB_PRODUCT_AOX_USB101 },
|
2000-03-18 01:36:37 +00:00
|
|
|
{ USB_VENDOR_KLSI, USB_PRODUCT_AOX_USB101 },
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
{ USB_VENDOR_ADS, USB_PRODUCT_ADS_UBS10BT },
|
2000-01-16 22:45:07 +00:00
|
|
|
{ USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC10T },
|
|
|
|
{ USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_EA101 },
|
|
|
|
{ USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET },
|
|
|
|
{ USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET2 },
|
|
|
|
{ USB_VENDOR_ENTREGA, USB_PRODUCT_ENTREGA_E45 },
|
|
|
|
{ USB_VENDOR_3COM, USB_PRODUCT_3COM_3C19250 },
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
{ USB_VENDOR_COREGA, USB_PRODUCT_COREGA_ETHER_USB_T },
|
2000-01-16 22:45:07 +00:00
|
|
|
{ USB_VENDOR_DLINK, USB_PRODUCT_DLINK_DSB650C },
|
|
|
|
{ USB_VENDOR_SMC, USB_PRODUCT_SMC_2102USB },
|
2000-03-21 15:20:41 +00:00
|
|
|
{ USB_VENDOR_LINKSYS, USB_PRODUCT_LINKSYS_USB10T },
|
2000-03-29 19:44:48 +00:00
|
|
|
{ USB_VENDOR_KLSI, USB_PRODUCT_KLSI_DUH3E10BT },
|
|
|
|
{ USB_VENDOR_PERACOM, USB_PRODUCT_PERACOM_ENET3 },
|
2000-01-16 22:45:07 +00:00
|
|
|
{ 0, 0 }
|
2000-01-05 04:27:24 +00:00
|
|
|
};
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static struct usb_qdat kue_qdat;
|
2000-01-13 20:13:58 +00:00
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_match __P((device_t));
|
|
|
|
Static int kue_attach __P((device_t));
|
|
|
|
Static int kue_detach __P((device_t));
|
|
|
|
Static void kue_shutdown __P((device_t));
|
|
|
|
Static int kue_tx_list_init __P((struct kue_softc *));
|
|
|
|
Static int kue_rx_list_init __P((struct kue_softc *));
|
|
|
|
Static int kue_newbuf __P((struct kue_softc *, struct kue_chain *,
|
2000-01-05 04:27:24 +00:00
|
|
|
struct mbuf *));
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_encap __P((struct kue_softc *, struct mbuf *, int));
|
|
|
|
Static void kue_rxeof __P((usbd_xfer_handle,
|
2000-01-05 04:27:24 +00:00
|
|
|
usbd_private_handle, usbd_status));
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_txeof __P((usbd_xfer_handle,
|
2000-01-05 04:27:24 +00:00
|
|
|
usbd_private_handle, usbd_status));
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_start __P((struct ifnet *));
|
|
|
|
Static void kue_rxstart __P((struct ifnet *));
|
|
|
|
Static int kue_ioctl __P((struct ifnet *, u_long, caddr_t));
|
|
|
|
Static void kue_init __P((void *));
|
|
|
|
Static void kue_stop __P((struct kue_softc *));
|
|
|
|
Static void kue_watchdog __P((struct ifnet *));
|
2000-01-05 04:27:24 +00:00
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_setmulti __P((struct kue_softc *));
|
|
|
|
Static void kue_reset __P((struct kue_softc *));
|
2000-01-05 04:27:24 +00:00
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static usbd_status kue_do_request
|
2000-01-05 04:27:24 +00:00
|
|
|
__P((usbd_device_handle,
|
|
|
|
usb_device_request_t *, void *));
|
2000-04-03 20:58:30 +00:00
|
|
|
Static usbd_status kue_ctl __P((struct kue_softc *, int, u_int8_t,
|
2000-01-05 04:27:24 +00:00
|
|
|
u_int16_t, char *, int));
|
2000-04-03 20:58:30 +00:00
|
|
|
Static usbd_status kue_setword __P((struct kue_softc *, u_int8_t, u_int16_t));
|
|
|
|
Static int kue_load_fw __P((struct kue_softc *));
|
2000-01-05 04:27:24 +00:00
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static device_method_t kue_methods[] = {
|
2000-01-05 04:27:24 +00:00
|
|
|
/* Device interface */
|
|
|
|
DEVMETHOD(device_probe, kue_match),
|
|
|
|
DEVMETHOD(device_attach, kue_attach),
|
|
|
|
DEVMETHOD(device_detach, kue_detach),
|
|
|
|
DEVMETHOD(device_shutdown, kue_shutdown),
|
|
|
|
|
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static driver_t kue_driver = {
|
2000-01-05 04:27:24 +00:00
|
|
|
"kue",
|
|
|
|
kue_methods,
|
|
|
|
sizeof(struct kue_softc)
|
|
|
|
};
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static devclass_t kue_devclass;
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
DRIVER_MODULE(if_kue, uhub, kue_driver, kue_devclass, usbd_driver_load, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have a custom do_request function which is almost like the
|
|
|
|
* regular do_request function, except it has a much longer timeout.
|
|
|
|
* Why? Because we need to make requests over the control endpoint
|
|
|
|
* to download the firmware to the device, which can take longer
|
|
|
|
* than the default timeout.
|
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static usbd_status kue_do_request(dev, req, data)
|
2000-01-05 04:27:24 +00:00
|
|
|
usbd_device_handle dev;
|
|
|
|
usb_device_request_t *req;
|
|
|
|
void *data;
|
|
|
|
{
|
|
|
|
usbd_xfer_handle xfer;
|
|
|
|
usbd_status err;
|
|
|
|
|
|
|
|
xfer = usbd_alloc_xfer(dev);
|
|
|
|
usbd_setup_default_xfer(xfer, dev, 0, 500000, req,
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
data, UGETW(req->wLength), USBD_SHORT_XFER_OK|USBD_NO_TSLEEP, 0);
|
2000-01-05 04:27:24 +00:00
|
|
|
err = usbd_sync_transfer(xfer);
|
|
|
|
usbd_free_xfer(xfer);
|
|
|
|
return(err);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static usbd_status kue_setword(sc, breq, word)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
u_int8_t breq;
|
|
|
|
u_int16_t word;
|
|
|
|
{
|
|
|
|
usbd_device_handle dev;
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
int s;
|
|
|
|
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
if (sc->kue_gone)
|
|
|
|
return(USBD_NORMAL_COMPLETION);
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
dev = sc->kue_udev;
|
|
|
|
|
|
|
|
s = splusb();
|
|
|
|
|
|
|
|
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
|
|
|
|
|
|
|
req.bRequest = breq;
|
|
|
|
USETW(req.wValue, word);
|
|
|
|
USETW(req.wIndex, 0);
|
|
|
|
USETW(req.wLength, 0);
|
|
|
|
|
|
|
|
err = kue_do_request(dev, &req, NULL);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
return(err);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static usbd_status kue_ctl(sc, rw, breq, val, data, len)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
int rw;
|
|
|
|
u_int8_t breq;
|
|
|
|
u_int16_t val;
|
|
|
|
char *data;
|
|
|
|
int len;
|
|
|
|
{
|
|
|
|
usbd_device_handle dev;
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
dev = sc->kue_udev;
|
|
|
|
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
if (sc->kue_gone)
|
|
|
|
return(USBD_NORMAL_COMPLETION);
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
s = splusb();
|
|
|
|
|
|
|
|
if (rw == KUE_CTL_WRITE)
|
|
|
|
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
|
|
|
else
|
|
|
|
req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
|
|
|
|
|
|
|
req.bRequest = breq;
|
|
|
|
USETW(req.wValue, val);
|
|
|
|
USETW(req.wIndex, 0);
|
|
|
|
USETW(req.wLength, len);
|
|
|
|
|
|
|
|
err = kue_do_request(dev, &req, data);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
return(err);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_load_fw(sc)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
{
|
|
|
|
usbd_status err;
|
2000-01-17 23:14:40 +00:00
|
|
|
usb_device_descriptor_t *dd;
|
|
|
|
int hwrev;
|
|
|
|
|
|
|
|
dd = &sc->kue_udev->ddesc;
|
|
|
|
hwrev = UGETW(dd->bcdDevice);
|
|
|
|
|
2000-01-05 17:13:50 +00:00
|
|
|
/*
|
|
|
|
* First, check if we even need to load the firmware.
|
|
|
|
* If the device was still attached when the system was
|
|
|
|
* rebooted, it may already have firmware loaded in it.
|
|
|
|
* If this is the case, we don't need to do it again.
|
|
|
|
* And in fact, if we try to load it again, we'll hang,
|
|
|
|
* so we have to avoid this condition if we don't want
|
|
|
|
* to look stupid.
|
|
|
|
*
|
2000-01-17 23:14:40 +00:00
|
|
|
* We can test this quickly by checking the bcdRevision
|
|
|
|
* code. The NIC will return a different revision code if
|
|
|
|
* it's probed while the firmware is still loaded and
|
|
|
|
* running.
|
2000-01-05 17:13:50 +00:00
|
|
|
*/
|
2000-01-17 23:14:40 +00:00
|
|
|
if (hwrev == 0x0202)
|
|
|
|
return(0);
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
/* Load code segment */
|
|
|
|
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
|
|
|
|
0, kue_code_seg, sizeof(kue_code_seg));
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: failed to load code segment: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
return(ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Load fixup segment */
|
|
|
|
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
|
|
|
|
0, kue_fix_seg, sizeof(kue_fix_seg));
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: failed to load fixup segment: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
return(ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send trigger command. */
|
|
|
|
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
|
|
|
|
0, kue_trig_seg, sizeof(kue_trig_seg));
|
|
|
|
if (err) {
|
2000-01-05 17:13:50 +00:00
|
|
|
printf("kue%d: failed to load trigger segment: %s\n",
|
2000-01-05 04:27:24 +00:00
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
return(ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_setmulti(sc)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct ifmultiaddr *ifma;
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
|
|
|
|
sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI;
|
|
|
|
sc->kue_rxfilt &= ~KUE_RXFILT_MULTICAST;
|
|
|
|
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI;
|
|
|
|
|
|
|
|
for (ifma = ifp->if_multiaddrs.lh_first; ifma != NULL;
|
|
|
|
ifma = ifma->ifma_link.le_next) {
|
|
|
|
if (ifma->ifma_addr->sa_family != AF_LINK)
|
|
|
|
continue;
|
|
|
|
/*
|
|
|
|
* If there are too many addresses for the
|
|
|
|
* internal filter, switch over to allmulti mode.
|
|
|
|
*/
|
2000-01-11 18:09:19 +00:00
|
|
|
if (i == KUE_MCFILTCNT(sc))
|
2000-01-05 04:27:24 +00:00
|
|
|
break;
|
|
|
|
bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
|
|
|
|
KUE_MCFILT(sc, i), ETHER_ADDR_LEN);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
2000-01-11 18:09:19 +00:00
|
|
|
if (i == KUE_MCFILTCNT(sc))
|
|
|
|
sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI;
|
|
|
|
else {
|
2000-01-05 04:27:24 +00:00
|
|
|
sc->kue_rxfilt |= KUE_RXFILT_MULTICAST;
|
|
|
|
kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS,
|
|
|
|
i, sc->kue_mcfilters, i * ETHER_ADDR_LEN);
|
2000-01-11 18:09:19 +00:00
|
|
|
}
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Issue a SET_CONFIGURATION command to reset the MAC. This should be
|
|
|
|
* done after the firmware is loaded into the adapter in order to
|
|
|
|
* bring it into proper operation.
|
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_reset(sc)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
{
|
2000-01-16 22:45:07 +00:00
|
|
|
if (usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 0)) {
|
|
|
|
printf("kue%d: getting interface handle failed\n",
|
|
|
|
sc->kue_unit);
|
|
|
|
}
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
/* Wait a little while for the chip to get its brains in order. */
|
|
|
|
DELAY(1000);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe for a KLSI chip.
|
|
|
|
*/
|
|
|
|
USB_MATCH(kue)
|
|
|
|
{
|
|
|
|
USB_MATCH_START(kue, uaa);
|
|
|
|
struct kue_type *t;
|
|
|
|
|
|
|
|
if (!uaa->iface)
|
|
|
|
return(UMATCH_NONE);
|
|
|
|
|
|
|
|
t = kue_devs;
|
2000-01-16 22:45:07 +00:00
|
|
|
while(t->kue_vid) {
|
2000-01-05 04:27:24 +00:00
|
|
|
if (uaa->vendor == t->kue_vid &&
|
|
|
|
uaa->product == t->kue_did) {
|
|
|
|
return(UMATCH_VENDOR_PRODUCT);
|
|
|
|
}
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(UMATCH_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach the interface. Allocate softc structures, do
|
|
|
|
* setup and ethernet/BPF attach.
|
|
|
|
*/
|
|
|
|
USB_ATTACH(kue)
|
|
|
|
{
|
|
|
|
USB_ATTACH_START(kue, sc, uaa);
|
|
|
|
char devinfo[1024];
|
|
|
|
int s;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
usbd_status err;
|
|
|
|
usb_interface_descriptor_t *id;
|
|
|
|
usb_endpoint_descriptor_t *ed;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
|
|
|
|
bzero(sc, sizeof(struct kue_softc));
|
|
|
|
sc->kue_iface = uaa->iface;
|
|
|
|
sc->kue_udev = uaa->device;
|
|
|
|
sc->kue_unit = device_get_unit(self);
|
|
|
|
|
|
|
|
id = usbd_get_interface_descriptor(uaa->iface);
|
|
|
|
|
|
|
|
usbd_devinfo(uaa->device, 0, devinfo);
|
|
|
|
device_set_desc_copy(self, devinfo);
|
|
|
|
printf("%s: %s\n", USBDEVNAME(self), devinfo);
|
|
|
|
|
|
|
|
/* Find endpoints. */
|
|
|
|
for (i = 0; i < id->bNumEndpoints; i++) {
|
|
|
|
ed = usbd_interface2endpoint_descriptor(uaa->iface, i);
|
|
|
|
if (!ed) {
|
|
|
|
printf("kue%d: couldn't get ep %d\n",
|
|
|
|
sc->kue_unit, i);
|
|
|
|
splx(s);
|
|
|
|
USB_ATTACH_ERROR_RETURN;
|
|
|
|
}
|
|
|
|
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
|
|
|
|
(ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
|
|
|
|
sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
|
|
|
|
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
|
|
|
|
(ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
|
|
|
|
sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
|
|
|
|
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
|
|
|
|
(ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
|
|
|
|
sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Load the firmware into the NIC. */
|
|
|
|
if (kue_load_fw(sc)) {
|
|
|
|
splx(s);
|
|
|
|
USB_ATTACH_ERROR_RETURN;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reset the adapter. */
|
|
|
|
kue_reset(sc);
|
|
|
|
|
|
|
|
/* Read ethernet descriptor */
|
|
|
|
err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
|
|
|
|
0, (char *)&sc->kue_desc, sizeof(sc->kue_desc));
|
|
|
|
|
|
|
|
sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
|
|
|
|
M_USBDEV, M_NOWAIT);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A KLSI chip was detected. Inform the world.
|
|
|
|
*/
|
|
|
|
printf("kue%d: Ethernet address: %6D\n", sc->kue_unit,
|
|
|
|
sc->kue_desc.kue_macaddr, ":");
|
|
|
|
|
|
|
|
bcopy(sc->kue_desc.kue_macaddr,
|
|
|
|
(char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
|
|
|
|
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
ifp->if_softc = sc;
|
|
|
|
ifp->if_unit = sc->kue_unit;
|
|
|
|
ifp->if_name = "kue";
|
|
|
|
ifp->if_mtu = ETHERMTU;
|
|
|
|
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
|
|
|
|
ifp->if_ioctl = kue_ioctl;
|
|
|
|
ifp->if_output = ether_output;
|
|
|
|
ifp->if_start = kue_start;
|
|
|
|
ifp->if_watchdog = kue_watchdog;
|
|
|
|
ifp->if_init = kue_init;
|
|
|
|
ifp->if_baudrate = 10000000;
|
|
|
|
ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
|
|
|
|
|
2000-01-13 20:13:58 +00:00
|
|
|
kue_qdat.ifp = ifp;
|
|
|
|
kue_qdat.if_rxstart = kue_rxstart;
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
/*
|
2000-07-13 22:54:34 +00:00
|
|
|
* Call MI attach routine.
|
2000-01-05 04:27:24 +00:00
|
|
|
*/
|
2000-07-13 22:54:34 +00:00
|
|
|
ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
|
Attempt to fix a problem with receiving packets on USB ethernet interfaces.
Packets are received inside USB bulk transfer callbacks, which run at
splusb() (actually splbio()). The packet input queues are meant to be
manipulated at splimp(). However the locking apparently breaks down under
certain circumstances and the input queues can get trampled.
There's a similar problem with if_ppp, which is driven by hardware/tty
interrupts from the serial driver, but which must also manipulate the
packet input queues at splimp(). The fix there is to use a netisr, and
that's the fix I used here. (I can hear you groaning back there. Hush up.)
The usb_ethersubr module maintains a single queue of its own. When a
packet is received in the USB callback routine, it's placed on this
queue with usb_ether_input(). This routine also schedules a soft net
interrupt with schednetisr(). The ISR routine then runs later, at
splnet, outside of the USB callback/interrupt context, and passes the
packet to ether_input(), hopefully in a safe manner.
The reason this is implemented as a separate module is that there are
a limited number of NETISRs that we can use, and snarfing one up for
each driver that needs it is wasteful (there will be three once I get
the CATC driver done). It also reduces code duplication to a certain
small extent. Unfortunately, it also needs to be linked in with the
usb.ko module in order for the USB ethernet drivers to share it.
Also removed some uneeded includes from if_aue.c and if_kue.c
Fix suggested by: peter
Not rejected as a hairbrained idea by: n_hibma
2000-01-10 23:12:54 +00:00
|
|
|
usb_register_netisr();
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
sc->kue_gone = 0;
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
splx(s);
|
|
|
|
USB_ATTACH_SUCCESS_RETURN;
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_detach(dev)
|
2000-01-05 04:27:24 +00:00
|
|
|
device_t dev;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splusb();
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
More USB ethernet tweaks:
- Sync ohci, uhci and usbdi modules with NetBSD in order to obtain the
following improvements:
o New USBD_NO_TSLEEP flag can be used in place of UQ_NO_TSLEEP
quirk. This allows drivers to specify busy waiting only for
certain transfers (namely control transfers for reading/writing
registers and stuff).
o New USBD_FORCE_SHORT_XFER flag can be used to deal with
devices like the ADMtek Pegasus that sense the end of bulk OUT
transfers in a special way (if a transfer is exactly a multiple
of 64 bytes in size, you need to send an extra empty packet
to terminate the transfer).
o usbd_open_pipe_intr() now accepts an interval argument which
can be used to change the rate at which the interrupt callback
routine is invoked. Specifying USBD_DEFAULT_INTERVAL uses the
value specified in the device's config data, but drivers can
override it if needed.
- Change if_aue to use USBD_FORCE_SHORT_XFER for packet transmissions.
- Change if_aue, if_kue and if_cue to use USBD_NO_TSLEEP for all
control transfers. We no longer force the non-tsleep hack for
bulk transfers since these are done asynchronously anyway.
- Removed quirk entry fiddling from if_aue and if_kue since we don't
need it anymore now that we have the USBD_NO_TSLEEP flag.
- Tweak ulpt, uhid, ums and ukbd drivers to use the new arg to
usbd_open_pipe_intr().
- Add a flag to the softc struct in the ethernet drivers to indicate
when a device has been detached, and use this flag to perform
tests to prevent the drivers from trying to do control transfers
if this is the case. This is necessary because calling if_detach()
with INET6 enabled will eventually result in a call to the driver's
ioctl() routine to delete the multicast groups on the interface,
which will result in attempts to perform control transfers. (It's
possible this also happens even without INET6 support enabled.) This
is pointless since we know that if the detach method has been called,
the hardware has been unplugged.
- Changed watchdog timeout routines to just call the driver init routines
to initialize the device states without trying to close and re-open the
pipes. This is partly because we don't want to frob things at interrupt
context, but also because this doesn't seem to work right and I don't
want to panic the system just because a USB device may have stopped
responding.
- Fix aue_rxeof() to be a little smarter about detecting when a double
transfer is needed. Unfortunately, the design of the chip makes it hard
to get this exactly right. Hopefully, this will go away once either
Nick or Lennart finds the bug in the uhci driver that makes this ugly
hack necessary.
- Also sync usbdevs with NetBSD.
2000-01-20 07:38:33 +00:00
|
|
|
sc->kue_gone = 1;
|
|
|
|
|
2000-07-13 22:54:34 +00:00
|
|
|
if (ifp != NULL)
|
|
|
|
ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
if (sc->kue_ep[KUE_ENDPT_TX] != NULL)
|
|
|
|
usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]);
|
|
|
|
if (sc->kue_ep[KUE_ENDPT_RX] != NULL)
|
|
|
|
usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_RX]);
|
|
|
|
if (sc->kue_ep[KUE_ENDPT_INTR] != NULL)
|
|
|
|
usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
|
|
|
|
|
|
|
|
if (sc->kue_mcfilters != NULL)
|
|
|
|
free(sc->kue_mcfilters, M_USBDEV);
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize an RX descriptor and attach an MBUF cluster.
|
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_newbuf(sc, c, m)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
struct kue_chain *c;
|
|
|
|
struct mbuf *m;
|
|
|
|
{
|
|
|
|
struct mbuf *m_new = NULL;
|
|
|
|
|
|
|
|
if (m == NULL) {
|
|
|
|
MGETHDR(m_new, M_DONTWAIT, MT_DATA);
|
|
|
|
if (m_new == NULL) {
|
|
|
|
printf("kue%d: no memory for rx list "
|
|
|
|
"-- packet dropped!\n", sc->kue_unit);
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
|
|
|
|
MCLGET(m_new, M_DONTWAIT);
|
|
|
|
if (!(m_new->m_flags & M_EXT)) {
|
|
|
|
printf("kue%d: no memory for rx list "
|
|
|
|
"-- packet dropped!\n", sc->kue_unit);
|
|
|
|
m_freem(m_new);
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
|
|
|
|
} else {
|
|
|
|
m_new = m;
|
|
|
|
m_new->m_len = m_new->m_pkthdr.len = MCLBYTES;
|
|
|
|
m_new->m_data = m_new->m_ext.ext_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
c->kue_mbuf = m_new;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_rx_list_init(sc)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
{
|
|
|
|
struct kue_cdata *cd;
|
|
|
|
struct kue_chain *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cd = &sc->kue_cdata;
|
|
|
|
for (i = 0; i < KUE_RX_LIST_CNT; i++) {
|
|
|
|
c = &cd->kue_rx_chain[i];
|
|
|
|
c->kue_sc = sc;
|
|
|
|
c->kue_idx = i;
|
|
|
|
if (kue_newbuf(sc, c, NULL) == ENOBUFS)
|
|
|
|
return(ENOBUFS);
|
|
|
|
if (c->kue_xfer == NULL) {
|
|
|
|
c->kue_xfer = usbd_alloc_xfer(sc->kue_udev);
|
|
|
|
if (c->kue_xfer == NULL)
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_tx_list_init(sc)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
{
|
|
|
|
struct kue_cdata *cd;
|
|
|
|
struct kue_chain *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cd = &sc->kue_cdata;
|
|
|
|
for (i = 0; i < KUE_TX_LIST_CNT; i++) {
|
|
|
|
c = &cd->kue_tx_chain[i];
|
|
|
|
c->kue_sc = sc;
|
|
|
|
c->kue_idx = i;
|
|
|
|
c->kue_mbuf = NULL;
|
|
|
|
if (c->kue_xfer == NULL) {
|
|
|
|
c->kue_xfer = usbd_alloc_xfer(sc->kue_udev);
|
|
|
|
if (c->kue_xfer == NULL)
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
c->kue_buf = malloc(KUE_BUFSZ, M_USBDEV, M_NOWAIT);
|
|
|
|
if (c->kue_buf == NULL)
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_rxstart(ifp)
|
2000-01-13 20:13:58 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
|
|
|
struct kue_chain *c;
|
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
|
|
|
c = &sc->kue_cdata.kue_rx_chain[sc->kue_cdata.kue_rx_prod];
|
|
|
|
|
|
|
|
if (kue_newbuf(sc, c, NULL) == ENOBUFS) {
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup new transfer. */
|
|
|
|
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
|
|
|
|
c, mtod(c->kue_mbuf, char *), KUE_BUFSZ, USBD_SHORT_XFER_OK,
|
|
|
|
USBD_NO_TIMEOUT, kue_rxeof);
|
|
|
|
usbd_transfer(c->kue_xfer);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
/*
|
|
|
|
* A frame has been uploaded: pass the resulting mbuf chain up to
|
|
|
|
* the higher level protocols.
|
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_rxeof(xfer, priv, status)
|
2000-01-05 04:27:24 +00:00
|
|
|
usbd_xfer_handle xfer;
|
|
|
|
usbd_private_handle priv;
|
|
|
|
usbd_status status;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
|
|
|
struct kue_chain *c;
|
|
|
|
struct mbuf *m;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int total_len = 0;
|
|
|
|
u_int16_t len;
|
|
|
|
|
|
|
|
c = priv;
|
|
|
|
sc = c->kue_sc;
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
Attempt to fix a problem with receiving packets on USB ethernet interfaces.
Packets are received inside USB bulk transfer callbacks, which run at
splusb() (actually splbio()). The packet input queues are meant to be
manipulated at splimp(). However the locking apparently breaks down under
certain circumstances and the input queues can get trampled.
There's a similar problem with if_ppp, which is driven by hardware/tty
interrupts from the serial driver, but which must also manipulate the
packet input queues at splimp(). The fix there is to use a netisr, and
that's the fix I used here. (I can hear you groaning back there. Hush up.)
The usb_ethersubr module maintains a single queue of its own. When a
packet is received in the USB callback routine, it's placed on this
queue with usb_ether_input(). This routine also schedules a soft net
interrupt with schednetisr(). The ISR routine then runs later, at
splnet, outside of the USB callback/interrupt context, and passes the
packet to ether_input(), hopefully in a safe manner.
The reason this is implemented as a separate module is that there are
a limited number of NETISRs that we can use, and snarfing one up for
each driver that needs it is wasteful (there will be three once I get
the CATC driver done). It also reduces code duplication to a certain
small extent. Unfortunately, it also needs to be linked in with the
usb.ko module in order for the USB ethernet drivers to share it.
Also removed some uneeded includes from if_aue.c and if_kue.c
Fix suggested by: peter
Not rejected as a hairbrained idea by: n_hibma
2000-01-10 23:12:54 +00:00
|
|
|
if (!(ifp->if_flags & IFF_RUNNING))
|
2000-01-05 04:27:24 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (status != USBD_NORMAL_COMPLETION) {
|
Attempt to fix a problem with receiving packets on USB ethernet interfaces.
Packets are received inside USB bulk transfer callbacks, which run at
splusb() (actually splbio()). The packet input queues are meant to be
manipulated at splimp(). However the locking apparently breaks down under
certain circumstances and the input queues can get trampled.
There's a similar problem with if_ppp, which is driven by hardware/tty
interrupts from the serial driver, but which must also manipulate the
packet input queues at splimp(). The fix there is to use a netisr, and
that's the fix I used here. (I can hear you groaning back there. Hush up.)
The usb_ethersubr module maintains a single queue of its own. When a
packet is received in the USB callback routine, it's placed on this
queue with usb_ether_input(). This routine also schedules a soft net
interrupt with schednetisr(). The ISR routine then runs later, at
splnet, outside of the USB callback/interrupt context, and passes the
packet to ether_input(), hopefully in a safe manner.
The reason this is implemented as a separate module is that there are
a limited number of NETISRs that we can use, and snarfing one up for
each driver that needs it is wasteful (there will be three once I get
the CATC driver done). It also reduces code duplication to a certain
small extent. Unfortunately, it also needs to be linked in with the
usb.ko module in order for the USB ethernet drivers to share it.
Also removed some uneeded includes from if_aue.c and if_kue.c
Fix suggested by: peter
Not rejected as a hairbrained idea by: n_hibma
2000-01-10 23:12:54 +00:00
|
|
|
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
|
2000-01-05 04:27:24 +00:00
|
|
|
return;
|
|
|
|
printf("kue%d: usb error on rx: %s\n", sc->kue_unit,
|
|
|
|
usbd_errstr(status));
|
|
|
|
if (status == USBD_STALLED)
|
|
|
|
usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_RX]);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
|
|
|
|
m = c->kue_mbuf;
|
2000-01-14 00:49:28 +00:00
|
|
|
if (total_len <= 1)
|
|
|
|
goto done;
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
len = *mtod(m, u_int16_t *);
|
|
|
|
m_adj(m, sizeof(u_int16_t));
|
|
|
|
|
|
|
|
/* No errors; receive the packet. */
|
|
|
|
total_len = len;
|
|
|
|
|
2000-01-14 00:49:28 +00:00
|
|
|
if (len < sizeof(struct ether_header)) {
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
ifp->if_ipackets++;
|
2000-01-13 20:13:58 +00:00
|
|
|
m->m_pkthdr.rcvif = (struct ifnet *)&kue_qdat;
|
2000-01-05 04:27:24 +00:00
|
|
|
m->m_pkthdr.len = m->m_len = total_len;
|
|
|
|
|
Attempt to fix a problem with receiving packets on USB ethernet interfaces.
Packets are received inside USB bulk transfer callbacks, which run at
splusb() (actually splbio()). The packet input queues are meant to be
manipulated at splimp(). However the locking apparently breaks down under
certain circumstances and the input queues can get trampled.
There's a similar problem with if_ppp, which is driven by hardware/tty
interrupts from the serial driver, but which must also manipulate the
packet input queues at splimp(). The fix there is to use a netisr, and
that's the fix I used here. (I can hear you groaning back there. Hush up.)
The usb_ethersubr module maintains a single queue of its own. When a
packet is received in the USB callback routine, it's placed on this
queue with usb_ether_input(). This routine also schedules a soft net
interrupt with schednetisr(). The ISR routine then runs later, at
splnet, outside of the USB callback/interrupt context, and passes the
packet to ether_input(), hopefully in a safe manner.
The reason this is implemented as a separate module is that there are
a limited number of NETISRs that we can use, and snarfing one up for
each driver that needs it is wasteful (there will be three once I get
the CATC driver done). It also reduces code duplication to a certain
small extent. Unfortunately, it also needs to be linked in with the
usb.ko module in order for the USB ethernet drivers to share it.
Also removed some uneeded includes from if_aue.c and if_kue.c
Fix suggested by: peter
Not rejected as a hairbrained idea by: n_hibma
2000-01-10 23:12:54 +00:00
|
|
|
/* Put the packet on the special USB input queue. */
|
|
|
|
usb_ether_input(m);
|
2000-01-05 04:27:24 +00:00
|
|
|
|
2000-01-14 00:49:28 +00:00
|
|
|
return;
|
2000-01-05 04:27:24 +00:00
|
|
|
done:
|
|
|
|
|
2000-01-14 00:49:28 +00:00
|
|
|
/* Setup new transfer. */
|
|
|
|
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
|
|
|
|
c, mtod(c->kue_mbuf, char *), KUE_BUFSZ, USBD_SHORT_XFER_OK,
|
|
|
|
USBD_NO_TIMEOUT, kue_rxeof);
|
|
|
|
usbd_transfer(c->kue_xfer);
|
|
|
|
|
2000-01-05 04:27:24 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A frame was downloaded to the chip. It's safe for us to clean up
|
|
|
|
* the list buffers.
|
|
|
|
*/
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_txeof(xfer, priv, status)
|
2000-01-05 04:27:24 +00:00
|
|
|
usbd_xfer_handle xfer;
|
|
|
|
usbd_private_handle priv;
|
|
|
|
usbd_status status;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
|
|
|
struct kue_chain *c;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
usbd_status err;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
|
|
|
|
c = priv;
|
|
|
|
sc = c->kue_sc;
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
ifp->if_timer = 0;
|
|
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
|
|
|
|
|
|
if (status != USBD_NORMAL_COMPLETION) {
|
|
|
|
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
printf("kue%d: usb error on tx: %s\n", sc->kue_unit,
|
|
|
|
usbd_errstr(status));
|
|
|
|
if (status == USBD_STALLED)
|
|
|
|
usbd_clear_endpoint_stall(sc->kue_ep[KUE_ENDPT_TX]);
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
usbd_get_xfer_status(c->kue_xfer, NULL, NULL, NULL, &err);
|
|
|
|
|
2000-06-01 23:16:42 +00:00
|
|
|
if (c->kue_mbuf != NULL) {
|
|
|
|
c->kue_mbuf->m_pkthdr.rcvif = ifp;
|
|
|
|
usb_tx_done(c->kue_mbuf);
|
|
|
|
c->kue_mbuf = NULL;
|
|
|
|
}
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
ifp->if_oerrors++;
|
|
|
|
else
|
|
|
|
ifp->if_opackets++;
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_encap(sc, m, idx)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
struct mbuf *m;
|
|
|
|
int idx;
|
|
|
|
{
|
|
|
|
int total_len;
|
|
|
|
struct kue_chain *c;
|
|
|
|
usbd_status err;
|
|
|
|
|
|
|
|
c = &sc->kue_cdata.kue_tx_chain[idx];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy the mbuf data into a contiguous buffer, leaving two
|
|
|
|
* bytes at the beginning to hold the frame length.
|
|
|
|
*/
|
|
|
|
m_copydata(m, 0, m->m_pkthdr.len, c->kue_buf + 2);
|
|
|
|
c->kue_mbuf = m;
|
|
|
|
|
|
|
|
total_len = m->m_pkthdr.len + 2;
|
|
|
|
total_len += 64 - (total_len % 64);
|
|
|
|
|
2000-01-06 07:39:07 +00:00
|
|
|
/* Frame length is specified in the first 2 bytes of the buffer. */
|
2000-01-05 04:27:24 +00:00
|
|
|
c->kue_buf[0] = (u_int8_t)m->m_pkthdr.len;
|
|
|
|
c->kue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8);
|
|
|
|
|
|
|
|
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_TX],
|
|
|
|
c, c->kue_buf, total_len, 0, 10000, kue_txeof);
|
|
|
|
|
|
|
|
/* Transmit */
|
|
|
|
err = usbd_transfer(c->kue_xfer);
|
|
|
|
if (err != USBD_IN_PROGRESS) {
|
|
|
|
kue_stop(sc);
|
|
|
|
return(EIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->kue_cdata.kue_tx_cnt++;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_start(ifp)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
|
|
|
struct mbuf *m_head = NULL;
|
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_OACTIVE)
|
|
|
|
return;
|
|
|
|
|
|
|
|
IF_DEQUEUE(&ifp->if_snd, m_head);
|
|
|
|
if (m_head == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (kue_encap(sc, m_head, 0)) {
|
|
|
|
IF_PREPEND(&ifp->if_snd, m_head);
|
|
|
|
ifp->if_flags |= IFF_OACTIVE;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's a BPF listener, bounce a copy of this frame
|
|
|
|
* to him.
|
|
|
|
*/
|
|
|
|
if (ifp->if_bpf)
|
|
|
|
bpf_mtap(ifp, m_head);
|
|
|
|
|
|
|
|
ifp->if_flags |= IFF_OACTIVE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set a timeout in case the chip goes out to lunch.
|
|
|
|
*/
|
|
|
|
ifp->if_timer = 5;
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_init(xsc)
|
2000-01-05 04:27:24 +00:00
|
|
|
void *xsc;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc = xsc;
|
|
|
|
struct ifnet *ifp = &sc->arpcom.ac_if;
|
|
|
|
struct kue_chain *c;
|
|
|
|
usbd_status err;
|
|
|
|
int i, s;
|
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_RUNNING)
|
|
|
|
return;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
|
|
|
|
/* Set MAC address */
|
|
|
|
kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC,
|
|
|
|
0, sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
|
|
|
|
|
|
|
|
sc->kue_rxfilt = KUE_RXFILT_UNICAST|KUE_RXFILT_BROADCAST;
|
|
|
|
|
|
|
|
/* If we want promiscuous mode, set the allframes bit. */
|
|
|
|
if (ifp->if_flags & IFF_PROMISC)
|
|
|
|
sc->kue_rxfilt |= KUE_RXFILT_PROMISC;
|
|
|
|
|
|
|
|
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
|
|
|
|
|
|
|
|
/* I'm not sure how to tune these. */
|
2000-01-08 00:40:44 +00:00
|
|
|
#ifdef notdef
|
|
|
|
/*
|
|
|
|
* Leave this one alone for now; setting it
|
|
|
|
* wrong causes lockups on some machines/controllers.
|
|
|
|
*/
|
2000-01-05 04:27:24 +00:00
|
|
|
kue_setword(sc, KUE_CMD_SET_SOFS, 1);
|
2000-01-08 00:40:44 +00:00
|
|
|
#endif
|
2000-01-05 04:27:24 +00:00
|
|
|
kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);
|
|
|
|
|
|
|
|
/* Init TX ring. */
|
|
|
|
if (kue_tx_list_init(sc) == ENOBUFS) {
|
|
|
|
printf("kue%d: tx list init failed\n", sc->kue_unit);
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Init RX ring. */
|
|
|
|
if (kue_rx_list_init(sc) == ENOBUFS) {
|
|
|
|
printf("kue%d: rx list init failed\n", sc->kue_unit);
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Load the multicast filter. */
|
|
|
|
kue_setmulti(sc);
|
|
|
|
|
|
|
|
/* Open RX and TX pipes. */
|
|
|
|
err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_RX],
|
|
|
|
USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_RX]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: open rx pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = usbd_open_pipe(sc->kue_iface, sc->kue_ed[KUE_ENDPT_TX],
|
|
|
|
USBD_EXCLUSIVE_USE, &sc->kue_ep[KUE_ENDPT_TX]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: open tx pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Start up the receive pipe. */
|
|
|
|
for (i = 0; i < KUE_RX_LIST_CNT; i++) {
|
|
|
|
c = &sc->kue_cdata.kue_rx_chain[i];
|
|
|
|
usbd_setup_xfer(c->kue_xfer, sc->kue_ep[KUE_ENDPT_RX],
|
|
|
|
c, mtod(c->kue_mbuf, char *), KUE_BUFSZ,
|
|
|
|
USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, kue_rxeof);
|
|
|
|
usbd_transfer(c->kue_xfer);
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_flags |= IFF_RUNNING;
|
|
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
|
|
|
|
|
|
(void)splx(s);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static int kue_ioctl(ifp, command, data)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
u_long command;
|
|
|
|
caddr_t data;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc = ifp->if_softc;
|
|
|
|
int s, error = 0;
|
|
|
|
|
|
|
|
s = splimp();
|
|
|
|
|
|
|
|
switch(command) {
|
|
|
|
case SIOCSIFADDR:
|
|
|
|
case SIOCGIFADDR:
|
|
|
|
case SIOCSIFMTU:
|
|
|
|
error = ether_ioctl(ifp, command, data);
|
|
|
|
break;
|
|
|
|
case SIOCSIFFLAGS:
|
|
|
|
if (ifp->if_flags & IFF_UP) {
|
|
|
|
if (ifp->if_flags & IFF_RUNNING &&
|
|
|
|
ifp->if_flags & IFF_PROMISC &&
|
|
|
|
!(sc->kue_if_flags & IFF_PROMISC)) {
|
|
|
|
sc->kue_rxfilt |= KUE_RXFILT_PROMISC;
|
|
|
|
kue_setword(sc, KUE_CMD_SET_PKT_FILTER,
|
|
|
|
sc->kue_rxfilt);
|
|
|
|
} else if (ifp->if_flags & IFF_RUNNING &&
|
|
|
|
!(ifp->if_flags & IFF_PROMISC) &&
|
|
|
|
sc->kue_if_flags & IFF_PROMISC) {
|
|
|
|
sc->kue_rxfilt &= ~KUE_RXFILT_PROMISC;
|
|
|
|
kue_setword(sc, KUE_CMD_SET_PKT_FILTER,
|
|
|
|
sc->kue_rxfilt);
|
|
|
|
} else if (!(ifp->if_flags & IFF_RUNNING))
|
|
|
|
kue_init(sc);
|
|
|
|
} else {
|
|
|
|
if (ifp->if_flags & IFF_RUNNING)
|
|
|
|
kue_stop(sc);
|
|
|
|
}
|
|
|
|
sc->kue_if_flags = ifp->if_flags;
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
|
|
case SIOCDELMULTI:
|
|
|
|
kue_setmulti(sc);
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
(void)splx(s);
|
|
|
|
|
|
|
|
return(error);
|
|
|
|
}
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_watchdog(ifp)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct ifnet *ifp;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
2000-06-01 23:16:42 +00:00
|
|
|
struct kue_chain *c;
|
|
|
|
usbd_status stat;
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
|
|
|
|
|
|
|
ifp->if_oerrors++;
|
|
|
|
printf("kue%d: watchdog timeout\n", sc->kue_unit);
|
|
|
|
|
2000-06-01 23:16:42 +00:00
|
|
|
c = &sc->kue_cdata.kue_tx_chain[0];
|
|
|
|
usbd_get_xfer_status(c->kue_xfer, NULL, NULL, NULL, &stat);
|
|
|
|
kue_txeof(c->kue_xfer, c, stat);
|
2000-01-05 04:27:24 +00:00
|
|
|
|
|
|
|
if (ifp->if_snd.ifq_head != NULL)
|
|
|
|
kue_start(ifp);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop the adapter and free any mbufs allocated to the
|
|
|
|
* RX and TX lists.
|
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_stop(sc)
|
2000-01-05 04:27:24 +00:00
|
|
|
struct kue_softc *sc;
|
|
|
|
{
|
|
|
|
usbd_status err;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
ifp->if_timer = 0;
|
|
|
|
|
|
|
|
/* Stop transfers. */
|
|
|
|
if (sc->kue_ep[KUE_ENDPT_RX] != NULL) {
|
|
|
|
err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_RX]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: abort rx pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_RX]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: close rx pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
sc->kue_ep[KUE_ENDPT_RX] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sc->kue_ep[KUE_ENDPT_TX] != NULL) {
|
|
|
|
err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_TX]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: abort tx pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_TX]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: close tx pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
sc->kue_ep[KUE_ENDPT_TX] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sc->kue_ep[KUE_ENDPT_INTR] != NULL) {
|
|
|
|
err = usbd_abort_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: abort intr pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
err = usbd_close_pipe(sc->kue_ep[KUE_ENDPT_INTR]);
|
|
|
|
if (err) {
|
|
|
|
printf("kue%d: close intr pipe failed: %s\n",
|
|
|
|
sc->kue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
sc->kue_ep[KUE_ENDPT_INTR] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free RX resources. */
|
|
|
|
for (i = 0; i < KUE_RX_LIST_CNT; i++) {
|
|
|
|
if (sc->kue_cdata.kue_rx_chain[i].kue_buf != NULL) {
|
|
|
|
free(sc->kue_cdata.kue_rx_chain[i].kue_buf, M_USBDEV);
|
|
|
|
sc->kue_cdata.kue_rx_chain[i].kue_buf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->kue_cdata.kue_rx_chain[i].kue_mbuf != NULL) {
|
|
|
|
m_freem(sc->kue_cdata.kue_rx_chain[i].kue_mbuf);
|
|
|
|
sc->kue_cdata.kue_rx_chain[i].kue_mbuf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->kue_cdata.kue_rx_chain[i].kue_xfer != NULL) {
|
|
|
|
usbd_free_xfer(sc->kue_cdata.kue_rx_chain[i].kue_xfer);
|
|
|
|
sc->kue_cdata.kue_rx_chain[i].kue_xfer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free TX resources. */
|
|
|
|
for (i = 0; i < KUE_TX_LIST_CNT; i++) {
|
|
|
|
if (sc->kue_cdata.kue_tx_chain[i].kue_buf != NULL) {
|
|
|
|
free(sc->kue_cdata.kue_tx_chain[i].kue_buf, M_USBDEV);
|
|
|
|
sc->kue_cdata.kue_tx_chain[i].kue_buf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->kue_cdata.kue_tx_chain[i].kue_mbuf != NULL) {
|
|
|
|
m_freem(sc->kue_cdata.kue_tx_chain[i].kue_mbuf);
|
|
|
|
sc->kue_cdata.kue_tx_chain[i].kue_mbuf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->kue_cdata.kue_tx_chain[i].kue_xfer != NULL) {
|
|
|
|
usbd_free_xfer(sc->kue_cdata.kue_tx_chain[i].kue_xfer);
|
|
|
|
sc->kue_cdata.kue_tx_chain[i].kue_xfer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop all chip I/O so that the kernel's probe routines don't
|
|
|
|
* get confused by errant DMAs when rebooting.
|
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static void kue_shutdown(dev)
|
2000-01-05 04:27:24 +00:00
|
|
|
device_t dev;
|
|
|
|
{
|
|
|
|
struct kue_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
|
|
|
kue_stop(sc);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|