2000-01-14 03:14:49 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1997, 1998, 1999, 2000
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2003-08-24 17:55:58 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
2000-01-14 03:14:49 +00:00
|
|
|
/*
|
2000-01-17 18:49:20 +00:00
|
|
|
* CATC USB-EL1210A USB to ethernet driver. Used in the CATC Netmate
|
2000-01-14 03:14:49 +00:00
|
|
|
* adapters and others.
|
|
|
|
*
|
|
|
|
* Written by Bill Paul <wpaul@ee.columbia.edu>
|
|
|
|
* Electrical Engineering Department
|
|
|
|
* Columbia University, New York City
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2000-01-17 18:49:20 +00:00
|
|
|
* The CATC USB-EL1210A provides USB ethernet support at 10Mbps. The
|
2000-01-14 03:14:49 +00:00
|
|
|
* RX filter uses a 512-bit multicast hash table, single perfect entry
|
|
|
|
* for the station address, and promiscuous mode. Unlike the ADMtek
|
|
|
|
* and KLSI chips, the CATC ASIC supports read and write combining
|
|
|
|
* mode where multiple packets can be transfered using a single bulk
|
|
|
|
* transaction, which helps performance a great deal.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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/bpf.h>
|
|
|
|
|
|
|
|
#include <sys/bus.h>
|
2003-07-16 02:20:14 +00:00
|
|
|
#include <machine/bus.h>
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version < 500000
|
|
|
|
#include <machine/clock.h>
|
|
|
|
#endif
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
#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>
|
|
|
|
#include <dev/usb/usb_ethersubr.h>
|
|
|
|
|
|
|
|
#include <dev/usb/if_cuereg.h>
|
|
|
|
|
|
|
|
/*
|
2000-01-16 22:45:07 +00:00
|
|
|
* Various supported device vendors/products.
|
2000-01-14 03:14:49 +00:00
|
|
|
*/
|
2000-04-03 20:58:30 +00:00
|
|
|
Static struct cue_type cue_devs[] = {
|
2000-01-16 22:45:07 +00:00
|
|
|
{ USB_VENDOR_CATC, USB_PRODUCT_CATC_NETMATE },
|
|
|
|
{ USB_VENDOR_CATC, USB_PRODUCT_CATC_NETMATE2 },
|
2000-04-14 14:46:22 +00:00
|
|
|
{ USB_VENDOR_SMARTBRIDGES, USB_PRODUCT_SMARTBRIDGES_SMARTLINK },
|
2000-01-16 22:45:07 +00:00
|
|
|
{ 0, 0 }
|
2000-01-14 03:14:49 +00:00
|
|
|
};
|
|
|
|
|
2002-04-06 19:55:52 +00:00
|
|
|
Static int cue_match(device_ptr_t);
|
|
|
|
Static int cue_attach(device_ptr_t);
|
|
|
|
Static int cue_detach(device_ptr_t);
|
2002-04-02 11:54:28 +00:00
|
|
|
|
|
|
|
Static int cue_tx_list_init(struct cue_softc *);
|
|
|
|
Static int cue_rx_list_init(struct cue_softc *);
|
|
|
|
Static int cue_newbuf(struct cue_softc *, struct cue_chain *, struct mbuf *);
|
|
|
|
Static int cue_encap(struct cue_softc *, struct mbuf *, int);
|
|
|
|
Static void cue_rxeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
|
|
|
|
Static void cue_txeof(usbd_xfer_handle, usbd_private_handle, usbd_status);
|
|
|
|
Static void cue_tick(void *);
|
|
|
|
Static void cue_rxstart(struct ifnet *);
|
|
|
|
Static void cue_start(struct ifnet *);
|
|
|
|
Static int cue_ioctl(struct ifnet *, u_long, caddr_t);
|
|
|
|
Static void cue_init(void *);
|
|
|
|
Static void cue_stop(struct cue_softc *);
|
|
|
|
Static void cue_watchdog(struct ifnet *);
|
2002-04-06 19:55:52 +00:00
|
|
|
Static void cue_shutdown(device_ptr_t);
|
2002-04-02 11:54:28 +00:00
|
|
|
|
|
|
|
Static void cue_setmulti(struct cue_softc *);
|
2003-11-14 06:02:51 +00:00
|
|
|
Static uint32_t cue_mchash(const uint8_t *);
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void cue_reset(struct cue_softc *);
|
|
|
|
|
2002-04-06 20:24:25 +00:00
|
|
|
Static int cue_csr_read_1(struct cue_softc *, int);
|
|
|
|
Static int cue_csr_write_1(struct cue_softc *, int, int);
|
|
|
|
Static int cue_csr_read_2(struct cue_softc *, int);
|
2000-01-14 03:14:49 +00:00
|
|
|
#ifdef notdef
|
2002-04-06 20:24:25 +00:00
|
|
|
Static int cue_csr_write_2(struct cue_softc *, int, int);
|
2000-01-14 03:14:49 +00:00
|
|
|
#endif
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int cue_mem(struct cue_softc *, int, int, void *, int);
|
|
|
|
Static int cue_getmac(struct cue_softc *, void *);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static device_method_t cue_methods[] = {
|
2000-01-14 03:14:49 +00:00
|
|
|
/* Device interface */
|
|
|
|
DEVMETHOD(device_probe, cue_match),
|
|
|
|
DEVMETHOD(device_attach, cue_attach),
|
|
|
|
DEVMETHOD(device_detach, cue_detach),
|
|
|
|
DEVMETHOD(device_shutdown, cue_shutdown),
|
|
|
|
|
|
|
|
{ 0, 0 }
|
|
|
|
};
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static driver_t cue_driver = {
|
2000-01-14 03:14:49 +00:00
|
|
|
"cue",
|
|
|
|
cue_methods,
|
|
|
|
sizeof(struct cue_softc)
|
|
|
|
};
|
|
|
|
|
2000-04-03 20:58:30 +00:00
|
|
|
Static devclass_t cue_devclass;
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2003-04-15 06:37:30 +00:00
|
|
|
DRIVER_MODULE(cue, uhub, cue_driver, cue_devclass, usbd_driver_load, 0);
|
|
|
|
MODULE_DEPEND(cue, usb, 1, 1, 1);
|
|
|
|
MODULE_DEPEND(cue, ether, 1, 1, 1);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
#define CUE_SETBIT(sc, reg, x) \
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) | (x))
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
#define CUE_CLRBIT(sc, reg, x) \
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, reg, cue_csr_read_1(sc, reg) & ~(x))
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_read_1(struct cue_softc *sc, int reg)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
u_int8_t val = 0;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return(0);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
|
|
|
req.bRequest = CUE_CMD_READREG;
|
|
|
|
USETW(req.wValue, 0);
|
|
|
|
USETW(req.wIndex, reg);
|
|
|
|
USETW(req.wLength, 1);
|
|
|
|
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, &val);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return(0);
|
|
|
|
|
|
|
|
return(val);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_read_2(struct cue_softc *sc, int reg)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
u_int16_t val = 0;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return(0);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
|
|
|
req.bRequest = CUE_CMD_READREG;
|
|
|
|
USETW(req.wValue, 0);
|
|
|
|
USETW(req.wIndex, reg);
|
|
|
|
USETW(req.wLength, 2);
|
|
|
|
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, &val);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return(0);
|
|
|
|
|
|
|
|
return(val);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(struct cue_softc *sc, int reg, int val)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return(0);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
|
|
|
req.bRequest = CUE_CMD_WRITEREG;
|
|
|
|
USETW(req.wValue, val);
|
|
|
|
USETW(req.wIndex, reg);
|
|
|
|
USETW(req.wLength, 0);
|
|
|
|
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, NULL);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return(-1);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef notdef
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_2(struct cue_softc *sc, int reg, int val)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return(0);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
|
|
|
req.bRequest = CUE_CMD_WRITEREG;
|
|
|
|
USETW(req.wValue, val);
|
|
|
|
USETW(req.wIndex, reg);
|
|
|
|
USETW(req.wLength, 0);
|
|
|
|
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, NULL);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return(-1);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_mem(struct cue_softc *sc, int cmd, int addr, void *buf, int len)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return(0);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (cmd == CUE_CMD_READSRAM)
|
|
|
|
req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
|
|
|
else
|
|
|
|
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
|
|
|
req.bRequest = cmd;
|
|
|
|
USETW(req.wValue, 0);
|
|
|
|
USETW(req.wIndex, addr);
|
|
|
|
USETW(req.wLength, len);
|
|
|
|
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, buf);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return(-1);
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_getmac(struct cue_softc *sc, void *buf)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return(0);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
req.bmRequestType = UT_READ_VENDOR_DEVICE;
|
|
|
|
req.bRequest = CUE_CMD_GET_MACADDR;
|
|
|
|
USETW(req.wValue, 0);
|
|
|
|
USETW(req.wIndex, 0);
|
|
|
|
USETW(req.wLength, ETHER_ADDR_LEN);
|
|
|
|
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, buf);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: read MAC address failed\n", sc->cue_unit);
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define CUE_POLY 0xEDB88320
|
|
|
|
#define CUE_BITS 9
|
|
|
|
|
2003-11-14 06:02:51 +00:00
|
|
|
Static uint32_t
|
|
|
|
cue_mchash(const uint8_t *addr)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
2003-12-08 07:54:15 +00:00
|
|
|
uint32_t crc;
|
|
|
|
int idx, bit;
|
|
|
|
uint8_t data;
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/* Compute CRC for the address value. */
|
|
|
|
crc = 0xFFFFFFFF; /* initial value */
|
|
|
|
|
|
|
|
for (idx = 0; idx < 6; idx++) {
|
|
|
|
for (data = *addr++, bit = 0; bit < 8; bit++, data >>= 1)
|
|
|
|
crc = (crc >> 1) ^ (((crc ^ data) & 1) ? CUE_POLY : 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (crc & ((1 << CUE_BITS) - 1));
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_setmulti(struct cue_softc *sc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct ifmultiaddr *ifma;
|
|
|
|
u_int32_t h = 0, i;
|
|
|
|
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_ALLMULTI || ifp->if_flags & IFF_PROMISC) {
|
|
|
|
for (i = 0; i < CUE_MCAST_TABLE_LEN; i++)
|
|
|
|
sc->cue_mctab[i] = 0xFF;
|
2003-05-31 19:02:20 +00:00
|
|
|
cue_mem(sc, CUE_CMD_WRITESRAM, CUE_MCAST_TABLE_ADDR,
|
|
|
|
&sc->cue_mctab, CUE_MCAST_TABLE_LEN);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* first, zot all the existing hash bits */
|
|
|
|
for (i = 0; i < CUE_MCAST_TABLE_LEN; i++)
|
|
|
|
sc->cue_mctab[i] = 0;
|
|
|
|
|
|
|
|
/* now program new ones */
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
|
|
|
TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
|
|
|
|
#else
|
|
|
|
LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link)
|
|
|
|
#endif
|
|
|
|
{
|
2000-01-14 03:14:49 +00:00
|
|
|
if (ifma->ifma_addr->sa_family != AF_LINK)
|
|
|
|
continue;
|
2003-11-13 20:55:53 +00:00
|
|
|
h = cue_mchash(LLADDR((struct sockaddr_dl *)ifma->ifma_addr));
|
2003-07-04 01:50:39 +00:00
|
|
|
sc->cue_mctab[h >> 3] |= 1 << (h & 0x7);
|
2000-01-14 03:14:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Also include the broadcast address in the filter
|
|
|
|
* so we can receive broadcast frames.
|
|
|
|
*/
|
2000-01-14 17:03:00 +00:00
|
|
|
if (ifp->if_flags & IFF_BROADCAST) {
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
2003-11-13 20:55:53 +00:00
|
|
|
h = cue_mchash(ifp->if_broadcastaddr);
|
2003-10-04 21:41:01 +00:00
|
|
|
#else
|
2003-11-13 20:55:53 +00:00
|
|
|
h = cue_mchash(etherbroadcastaddr);
|
2003-10-04 21:41:01 +00:00
|
|
|
#endif
|
2003-07-04 01:50:39 +00:00
|
|
|
sc->cue_mctab[h >> 3] |= 1 << (h & 0x7);
|
2000-01-14 17:03:00 +00:00
|
|
|
}
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
cue_mem(sc, CUE_CMD_WRITESRAM, CUE_MCAST_TABLE_ADDR,
|
|
|
|
&sc->cue_mctab, CUE_MCAST_TABLE_LEN);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_reset(struct cue_softc *sc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usb_device_request_t req;
|
|
|
|
usbd_status err;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
if (sc->cue_dying)
|
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
|
|
|
return;
|
|
|
|
|
2000-01-14 03:14:49 +00:00
|
|
|
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
|
|
|
|
req.bRequest = CUE_CMD_RESET;
|
|
|
|
USETW(req.wValue, 0);
|
|
|
|
USETW(req.wIndex, 0);
|
|
|
|
USETW(req.wLength, 0);
|
2002-04-07 12:19:50 +00:00
|
|
|
err = usbd_do_request(sc->cue_udev, &req, NULL);
|
2000-01-14 03:14:49 +00:00
|
|
|
if (err)
|
|
|
|
printf("cue%d: reset failed\n", sc->cue_unit);
|
|
|
|
|
|
|
|
/* Wait a little while for the chip to get its brains in order. */
|
|
|
|
DELAY(1000);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Probe for a Pegasus chip.
|
|
|
|
*/
|
|
|
|
USB_MATCH(cue)
|
|
|
|
{
|
|
|
|
USB_MATCH_START(cue, uaa);
|
|
|
|
struct cue_type *t;
|
|
|
|
|
|
|
|
if (!uaa->iface)
|
|
|
|
return(UMATCH_NONE);
|
|
|
|
|
|
|
|
t = cue_devs;
|
2000-01-16 22:45:07 +00:00
|
|
|
while(t->cue_vid) {
|
2000-01-14 03:14:49 +00:00
|
|
|
if (uaa->vendor == t->cue_vid &&
|
|
|
|
uaa->product == t->cue_did) {
|
|
|
|
return(UMATCH_VENDOR_PRODUCT);
|
|
|
|
}
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(UMATCH_NONE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Attach the interface. Allocate softc structures, do ifmedia
|
|
|
|
* setup and ethernet/BPF attach.
|
|
|
|
*/
|
|
|
|
USB_ATTACH(cue)
|
|
|
|
{
|
|
|
|
USB_ATTACH_START(cue, sc, uaa);
|
|
|
|
char devinfo[1024];
|
|
|
|
u_char eaddr[ETHER_ADDR_LEN];
|
|
|
|
struct ifnet *ifp;
|
|
|
|
usb_interface_descriptor_t *id;
|
|
|
|
usb_endpoint_descriptor_t *ed;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
bzero(sc, sizeof(struct cue_softc));
|
|
|
|
sc->cue_iface = uaa->iface;
|
|
|
|
sc->cue_udev = uaa->device;
|
|
|
|
sc->cue_unit = device_get_unit(self);
|
|
|
|
|
2000-01-16 22:45:07 +00:00
|
|
|
if (usbd_set_config_no(sc->cue_udev, CUE_CONFIG_NO, 0)) {
|
|
|
|
printf("cue%d: getting interface handle failed\n",
|
|
|
|
sc->cue_unit);
|
|
|
|
USB_ATTACH_ERROR_RETURN;
|
|
|
|
}
|
|
|
|
|
2000-01-14 03:14:49 +00:00
|
|
|
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("cue%d: couldn't get ep %d\n",
|
|
|
|
sc->cue_unit, i);
|
|
|
|
USB_ATTACH_ERROR_RETURN;
|
|
|
|
}
|
|
|
|
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
|
2002-04-06 21:28:57 +00:00
|
|
|
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
|
2000-01-14 03:14:49 +00:00
|
|
|
sc->cue_ed[CUE_ENDPT_RX] = ed->bEndpointAddress;
|
|
|
|
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
|
2002-04-06 21:28:57 +00:00
|
|
|
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
|
2000-01-14 03:14:49 +00:00
|
|
|
sc->cue_ed[CUE_ENDPT_TX] = ed->bEndpointAddress;
|
|
|
|
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
|
2002-04-06 21:28:57 +00:00
|
|
|
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
|
2000-01-14 03:14:49 +00:00
|
|
|
sc->cue_ed[CUE_ENDPT_INTR] = ed->bEndpointAddress;
|
|
|
|
}
|
|
|
|
}
|
2000-01-14 07:08:33 +00:00
|
|
|
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
2002-04-04 21:03:38 +00:00
|
|
|
mtx_init(&sc->cue_mtx, device_get_nameunit(self), MTX_NETWORK_LOCK,
|
|
|
|
MTX_DEF | MTX_RECURSE);
|
2003-10-04 21:41:01 +00:00
|
|
|
#endif
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
|
|
|
|
2000-01-14 07:08:33 +00:00
|
|
|
#ifdef notdef
|
2000-01-14 03:14:49 +00:00
|
|
|
/* Reset the adapter. */
|
|
|
|
cue_reset(sc);
|
|
|
|
#endif
|
|
|
|
/*
|
|
|
|
* Get station address.
|
|
|
|
*/
|
|
|
|
cue_getmac(sc, &eaddr);
|
|
|
|
|
|
|
|
bcopy(eaddr, (char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
|
|
|
|
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
ifp->if_softc = sc;
|
2003-10-31 18:32:15 +00:00
|
|
|
if_initname(ifp, "cue", sc->cue_unit);
|
2000-01-14 03:14:49 +00:00
|
|
|
ifp->if_mtu = ETHERMTU;
|
|
|
|
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
|
|
|
|
ifp->if_ioctl = cue_ioctl;
|
|
|
|
ifp->if_output = ether_output;
|
|
|
|
ifp->if_start = cue_start;
|
|
|
|
ifp->if_watchdog = cue_watchdog;
|
|
|
|
ifp->if_init = cue_init;
|
|
|
|
ifp->if_baudrate = 10000000;
|
|
|
|
ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
|
|
|
|
|
2004-05-23 12:35:25 +00:00
|
|
|
sc->cue_qdat.ifp = ifp;
|
|
|
|
sc->cue_qdat.if_rxstart = cue_rxstart;
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/*
|
2000-07-13 22:54:34 +00:00
|
|
|
* Call MI attach routine.
|
2000-01-14 03:14:49 +00:00
|
|
|
*/
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
2002-11-14 23:54:55 +00:00
|
|
|
ether_ifattach(ifp, eaddr);
|
2003-10-04 21:41:01 +00:00
|
|
|
#else
|
|
|
|
ether_ifattach(ifp, ETHER_BPF_SUPPORTED);
|
|
|
|
#endif
|
2000-01-14 03:14:49 +00:00
|
|
|
callout_handle_init(&sc->cue_stat_ch);
|
|
|
|
usb_register_netisr();
|
2002-04-06 20:17:13 +00:00
|
|
|
sc->cue_dying = 0;
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
USB_ATTACH_SUCCESS_RETURN;
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
2002-04-06 19:55:52 +00:00
|
|
|
cue_detach(device_ptr_t dev)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
2002-04-06 20:17:13 +00:00
|
|
|
sc->cue_dying = 1;
|
2000-01-14 03:14:49 +00:00
|
|
|
untimeout(cue_tick, sc, sc->cue_stat_ch);
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
2002-11-14 23:54:55 +00:00
|
|
|
ether_ifdetach(ifp);
|
2003-10-04 21:41:01 +00:00
|
|
|
#else
|
|
|
|
ether_ifdetach(ifp, ETHER_BPF_SUPPORTED);
|
|
|
|
#endif
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (sc->cue_ep[CUE_ENDPT_TX] != NULL)
|
|
|
|
usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_TX]);
|
|
|
|
if (sc->cue_ep[CUE_ENDPT_RX] != NULL)
|
|
|
|
usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_RX]);
|
|
|
|
if (sc->cue_ep[CUE_ENDPT_INTR] != NULL)
|
|
|
|
usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2003-10-04 21:41:01 +00:00
|
|
|
#if __FreeBSD_version >= 500000
|
2000-10-24 22:38:54 +00:00
|
|
|
mtx_destroy(&sc->cue_mtx);
|
2003-10-04 21:41:01 +00:00
|
|
|
#endif
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize an RX descriptor and attach an MBUF cluster.
|
|
|
|
*/
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_newbuf(struct cue_softc *sc, struct cue_chain *c, struct mbuf *m)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct mbuf *m_new = NULL;
|
|
|
|
|
|
|
|
if (m == NULL) {
|
2003-02-19 05:47:46 +00:00
|
|
|
MGETHDR(m_new, M_DONTWAIT, MT_DATA);
|
2000-01-14 03:14:49 +00:00
|
|
|
if (m_new == NULL) {
|
|
|
|
printf("cue%d: no memory for rx list "
|
|
|
|
"-- packet dropped!\n", sc->cue_unit);
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
MCLGET(m_new, M_DONTWAIT);
|
2000-01-14 03:14:49 +00:00
|
|
|
if (!(m_new->m_flags & M_EXT)) {
|
|
|
|
printf("cue%d: no memory for rx list "
|
|
|
|
"-- packet dropped!\n", sc->cue_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;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_adj(m_new, ETHER_ALIGN);
|
|
|
|
c->cue_mbuf = m_new;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_rx_list_init(struct cue_softc *sc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_cdata *cd;
|
|
|
|
struct cue_chain *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cd = &sc->cue_cdata;
|
|
|
|
for (i = 0; i < CUE_RX_LIST_CNT; i++) {
|
|
|
|
c = &cd->cue_rx_chain[i];
|
|
|
|
c->cue_sc = sc;
|
|
|
|
c->cue_idx = i;
|
|
|
|
if (cue_newbuf(sc, c, NULL) == ENOBUFS)
|
|
|
|
return(ENOBUFS);
|
|
|
|
if (c->cue_xfer == NULL) {
|
|
|
|
c->cue_xfer = usbd_alloc_xfer(sc->cue_udev);
|
|
|
|
if (c->cue_xfer == NULL)
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_tx_list_init(struct cue_softc *sc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_cdata *cd;
|
|
|
|
struct cue_chain *c;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
cd = &sc->cue_cdata;
|
|
|
|
for (i = 0; i < CUE_TX_LIST_CNT; i++) {
|
|
|
|
c = &cd->cue_tx_chain[i];
|
|
|
|
c->cue_sc = sc;
|
|
|
|
c->cue_idx = i;
|
|
|
|
c->cue_mbuf = NULL;
|
|
|
|
if (c->cue_xfer == NULL) {
|
|
|
|
c->cue_xfer = usbd_alloc_xfer(sc->cue_udev);
|
|
|
|
if (c->cue_xfer == NULL)
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
c->cue_buf = malloc(CUE_BUFSZ, M_USBDEV, M_NOWAIT);
|
|
|
|
if (c->cue_buf == NULL)
|
|
|
|
return(ENOBUFS);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_rxstart(struct ifnet *ifp)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
struct cue_chain *c;
|
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
c = &sc->cue_cdata.cue_rx_chain[sc->cue_cdata.cue_rx_prod];
|
|
|
|
|
|
|
|
if (cue_newbuf(sc, c, NULL) == ENOBUFS) {
|
|
|
|
ifp->if_ierrors++;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup new transfer. */
|
|
|
|
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
|
2000-01-28 02:15:31 +00:00
|
|
|
c, mtod(c->cue_mbuf, char *), CUE_BUFSZ, USBD_SHORT_XFER_OK,
|
2000-01-14 03:14:49 +00:00
|
|
|
USBD_NO_TIMEOUT, cue_rxeof);
|
|
|
|
usbd_transfer(c->cue_xfer);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A frame has been uploaded: pass the resulting mbuf chain up to
|
|
|
|
* the higher level protocols.
|
|
|
|
*/
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_rxeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
struct cue_chain *c;
|
|
|
|
struct mbuf *m;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int total_len = 0;
|
|
|
|
u_int16_t len;
|
|
|
|
|
|
|
|
c = priv;
|
|
|
|
sc = c->cue_sc;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
if (!(ifp->if_flags & IFF_RUNNING)) {
|
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
2000-10-24 22:38:54 +00:00
|
|
|
}
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (status != USBD_NORMAL_COMPLETION) {
|
2000-10-24 22:38:54 +00:00
|
|
|
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
|
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
2000-10-24 22:38:54 +00:00
|
|
|
}
|
2002-04-07 12:04:02 +00:00
|
|
|
if (usbd_ratecheck(&sc->cue_rx_notice))
|
|
|
|
printf("cue%d: usb error on rx: %s\n", sc->cue_unit,
|
|
|
|
usbd_errstr(status));
|
2000-01-14 03:14:49 +00:00
|
|
|
if (status == USBD_STALLED)
|
|
|
|
usbd_clear_endpoint_stall(sc->cue_ep[CUE_ENDPT_RX]);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);
|
|
|
|
|
|
|
|
m = c->cue_mbuf;
|
|
|
|
len = *mtod(m, u_int16_t *);
|
|
|
|
|
|
|
|
/* No errors; receive the packet. */
|
|
|
|
total_len = len;
|
|
|
|
|
|
|
|
if (len < sizeof(struct ether_header)) {
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_ipackets++;
|
|
|
|
m_adj(m, sizeof(u_int16_t));
|
2004-05-23 12:35:25 +00:00
|
|
|
m->m_pkthdr.rcvif = (struct ifnet *)&sc->cue_qdat;
|
2000-01-14 03:14:49 +00:00
|
|
|
m->m_pkthdr.len = m->m_len = total_len;
|
|
|
|
|
|
|
|
/* Put the packet on the special USB input queue. */
|
|
|
|
usb_ether_input(m);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
done:
|
|
|
|
/* Setup new transfer. */
|
|
|
|
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
|
2000-01-28 02:15:31 +00:00
|
|
|
c, mtod(c->cue_mbuf, char *), CUE_BUFSZ, USBD_SHORT_XFER_OK,
|
2000-01-14 03:14:49 +00:00
|
|
|
USBD_NO_TIMEOUT, cue_rxeof);
|
|
|
|
usbd_transfer(c->cue_xfer);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A frame was downloaded to the chip. It's safe for us to clean up
|
|
|
|
* the list buffers.
|
|
|
|
*/
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
struct cue_chain *c;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
usbd_status err;
|
|
|
|
|
|
|
|
c = priv;
|
|
|
|
sc = c->cue_sc;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
|
|
|
if (status != USBD_NORMAL_COMPLETION) {
|
|
|
|
if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
printf("cue%d: usb error on tx: %s\n", sc->cue_unit,
|
|
|
|
usbd_errstr(status));
|
|
|
|
if (status == USBD_STALLED)
|
|
|
|
usbd_clear_endpoint_stall(sc->cue_ep[CUE_ENDPT_TX]);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_timer = 0;
|
|
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
|
|
usbd_get_xfer_status(c->cue_xfer, NULL, NULL, NULL, &err);
|
|
|
|
|
2000-06-01 23:16:42 +00:00
|
|
|
if (c->cue_mbuf != NULL) {
|
|
|
|
c->cue_mbuf->m_pkthdr.rcvif = ifp;
|
|
|
|
usb_tx_done(c->cue_mbuf);
|
|
|
|
c->cue_mbuf = NULL;
|
|
|
|
}
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
ifp->if_oerrors++;
|
|
|
|
else
|
|
|
|
ifp->if_opackets++;
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_tick(void *xsc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
|
|
|
|
sc = xsc;
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
if (sc == NULL)
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
2000-10-24 22:38:54 +00:00
|
|
|
|
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
|
2002-04-06 20:24:25 +00:00
|
|
|
ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_SINGLECOLL);
|
|
|
|
ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_MULTICOLL);
|
|
|
|
ifp->if_collisions += cue_csr_read_2(sc, CUE_TX_EXCESSCOLL);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2002-04-06 20:24:25 +00:00
|
|
|
if (cue_csr_read_2(sc, CUE_RX_FRAMEERR))
|
2000-01-14 03:14:49 +00:00
|
|
|
ifp->if_ierrors++;
|
|
|
|
|
|
|
|
sc->cue_stat_ch = timeout(cue_tick, sc, hz);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_encap(struct cue_softc *sc, struct mbuf *m, int idx)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
int total_len;
|
|
|
|
struct cue_chain *c;
|
|
|
|
usbd_status err;
|
|
|
|
|
|
|
|
c = &sc->cue_cdata.cue_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->cue_buf + 2);
|
|
|
|
c->cue_mbuf = m;
|
|
|
|
|
|
|
|
total_len = m->m_pkthdr.len + 2;
|
2000-01-14 07:08:33 +00:00
|
|
|
|
2000-01-14 03:14:49 +00:00
|
|
|
/* The first two bytes are the frame length */
|
|
|
|
c->cue_buf[0] = (u_int8_t)m->m_pkthdr.len;
|
|
|
|
c->cue_buf[1] = (u_int8_t)(m->m_pkthdr.len >> 8);
|
|
|
|
|
|
|
|
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_TX],
|
|
|
|
c, c->cue_buf, total_len, 0, 10000, cue_txeof);
|
|
|
|
|
|
|
|
/* Transmit */
|
|
|
|
err = usbd_transfer(c->cue_xfer);
|
|
|
|
if (err != USBD_IN_PROGRESS) {
|
|
|
|
cue_stop(sc);
|
|
|
|
return(EIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
sc->cue_cdata.cue_tx_cnt++;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_start(struct ifnet *ifp)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
struct mbuf *m_head = NULL;
|
|
|
|
|
|
|
|
sc = ifp->if_softc;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
if (ifp->if_flags & IFF_OACTIVE) {
|
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
2000-10-24 22:38:54 +00:00
|
|
|
}
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
IF_DEQUEUE(&ifp->if_snd, m_head);
|
2000-10-24 22:38:54 +00:00
|
|
|
if (m_head == NULL) {
|
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
2000-10-24 22:38:54 +00:00
|
|
|
}
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (cue_encap(sc, m_head, 0)) {
|
|
|
|
IF_PREPEND(&ifp->if_snd, m_head);
|
|
|
|
ifp->if_flags |= IFF_OACTIVE;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there's a BPF listener, bounce a copy of this frame
|
|
|
|
* to him.
|
|
|
|
*/
|
2002-11-14 23:54:55 +00:00
|
|
|
BPF_MTAP(ifp, m_head);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
ifp->if_flags |= IFF_OACTIVE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set a timeout in case the chip goes out to lunch.
|
|
|
|
*/
|
|
|
|
ifp->if_timer = 5;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_init(void *xsc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc = xsc;
|
|
|
|
struct ifnet *ifp = &sc->arpcom.ac_if;
|
|
|
|
struct cue_chain *c;
|
|
|
|
usbd_status err;
|
2000-10-24 22:38:54 +00:00
|
|
|
int i;
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (ifp->if_flags & IFF_RUNNING)
|
|
|
|
return;
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Cancel pending I/O and free all RX/TX buffers.
|
|
|
|
*/
|
|
|
|
#ifdef foo
|
|
|
|
cue_reset(sc);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Set MAC address */
|
|
|
|
for (i = 0; i < ETHER_ADDR_LEN; i++)
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, CUE_PAR0 - i, sc->arpcom.ac_enaddr[i]);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/* Enable RX logic. */
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, CUE_ETHCTL, CUE_ETHCTL_RX_ON|CUE_ETHCTL_MCAST_ON);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/* If we want promiscuous mode, set the allframes bit. */
|
|
|
|
if (ifp->if_flags & IFF_PROMISC) {
|
|
|
|
CUE_SETBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
|
|
|
|
} else {
|
|
|
|
CUE_CLRBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Init TX ring. */
|
|
|
|
if (cue_tx_list_init(sc) == ENOBUFS) {
|
|
|
|
printf("cue%d: tx list init failed\n", sc->cue_unit);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Init RX ring. */
|
|
|
|
if (cue_rx_list_init(sc) == ENOBUFS) {
|
|
|
|
printf("cue%d: rx list init failed\n", sc->cue_unit);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Load the multicast filter. */
|
|
|
|
cue_setmulti(sc);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the number of RX and TX buffers that we want
|
|
|
|
* to reserve inside the ASIC.
|
|
|
|
*/
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, CUE_RX_BUFPKTS, CUE_RX_FRAMES);
|
|
|
|
cue_csr_write_1(sc, CUE_TX_BUFPKTS, CUE_TX_FRAMES);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/* Set advanced operation modes. */
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, CUE_ADVANCED_OPMODES,
|
2000-01-14 03:14:49 +00:00
|
|
|
CUE_AOP_EMBED_RXLEN|0x01); /* 1 wait state */
|
|
|
|
|
|
|
|
/* Program the LED operation. */
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, CUE_LEDCTL, CUE_LEDCTL_FOLLOW_LINK);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
/* Open RX and TX pipes. */
|
|
|
|
err = usbd_open_pipe(sc->cue_iface, sc->cue_ed[CUE_ENDPT_RX],
|
|
|
|
USBD_EXCLUSIVE_USE, &sc->cue_ep[CUE_ENDPT_RX]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: open rx pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
err = usbd_open_pipe(sc->cue_iface, sc->cue_ed[CUE_ENDPT_TX],
|
|
|
|
USBD_EXCLUSIVE_USE, &sc->cue_ep[CUE_ENDPT_TX]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: open tx pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Start up the receive pipe. */
|
|
|
|
for (i = 0; i < CUE_RX_LIST_CNT; i++) {
|
|
|
|
c = &sc->cue_cdata.cue_rx_chain[i];
|
|
|
|
usbd_setup_xfer(c->cue_xfer, sc->cue_ep[CUE_ENDPT_RX],
|
2000-01-28 02:15:31 +00:00
|
|
|
c, mtod(c->cue_mbuf, char *), CUE_BUFSZ,
|
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
|
|
|
USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, cue_rxeof);
|
2000-01-14 03:14:49 +00:00
|
|
|
usbd_transfer(c->cue_xfer);
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_flags |= IFF_RUNNING;
|
|
|
|
ifp->if_flags &= ~IFF_OACTIVE;
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
sc->cue_stat_ch = timeout(cue_tick, sc, hz);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static int
|
|
|
|
cue_ioctl(struct ifnet *ifp, u_long command, caddr_t data)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc = ifp->if_softc;
|
2000-10-24 22:38:54 +00:00
|
|
|
int error = 0;
|
2000-01-14 03:14:49 +00:00
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
switch(command) {
|
|
|
|
case SIOCSIFFLAGS:
|
|
|
|
if (ifp->if_flags & IFF_UP) {
|
|
|
|
if (ifp->if_flags & IFF_RUNNING &&
|
|
|
|
ifp->if_flags & IFF_PROMISC &&
|
|
|
|
!(sc->cue_if_flags & IFF_PROMISC)) {
|
|
|
|
CUE_SETBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
|
|
|
|
cue_setmulti(sc);
|
|
|
|
} else if (ifp->if_flags & IFF_RUNNING &&
|
|
|
|
!(ifp->if_flags & IFF_PROMISC) &&
|
|
|
|
sc->cue_if_flags & IFF_PROMISC) {
|
|
|
|
CUE_CLRBIT(sc, CUE_ETHCTL, CUE_ETHCTL_PROMISC);
|
|
|
|
cue_setmulti(sc);
|
|
|
|
} else if (!(ifp->if_flags & IFF_RUNNING))
|
|
|
|
cue_init(sc);
|
|
|
|
} else {
|
|
|
|
if (ifp->if_flags & IFF_RUNNING)
|
|
|
|
cue_stop(sc);
|
|
|
|
}
|
|
|
|
sc->cue_if_flags = ifp->if_flags;
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
case SIOCADDMULTI:
|
|
|
|
case SIOCDELMULTI:
|
|
|
|
cue_setmulti(sc);
|
|
|
|
error = 0;
|
|
|
|
break;
|
|
|
|
default:
|
2002-11-14 23:54:55 +00:00
|
|
|
error = ether_ioctl(ifp, command, data);
|
2000-01-14 03:14:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return(error);
|
|
|
|
}
|
|
|
|
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_watchdog(struct ifnet *ifp)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
2000-06-01 23:16:42 +00:00
|
|
|
struct cue_chain *c;
|
|
|
|
usbd_status stat;
|
2000-10-24 22:38:54 +00:00
|
|
|
|
2000-01-14 03:14:49 +00:00
|
|
|
sc = ifp->if_softc;
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
ifp->if_oerrors++;
|
|
|
|
printf("cue%d: watchdog timeout\n", sc->cue_unit);
|
|
|
|
|
2000-06-01 23:16:42 +00:00
|
|
|
c = &sc->cue_cdata.cue_tx_chain[0];
|
|
|
|
usbd_get_xfer_status(c->cue_xfer, NULL, NULL, NULL, &stat);
|
|
|
|
cue_txeof(c->cue_xfer, c, stat);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
if (ifp->if_snd.ifq_head != NULL)
|
|
|
|
cue_start(ifp);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop the adapter and free any mbufs allocated to the
|
|
|
|
* RX and TX lists.
|
|
|
|
*/
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
|
|
|
cue_stop(struct cue_softc *sc)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
usbd_status err;
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int i;
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
|
|
|
|
2000-01-14 03:14:49 +00:00
|
|
|
ifp = &sc->arpcom.ac_if;
|
|
|
|
ifp->if_timer = 0;
|
|
|
|
|
2002-04-06 20:24:25 +00:00
|
|
|
cue_csr_write_1(sc, CUE_ETHCTL, 0);
|
2000-01-14 03:14:49 +00:00
|
|
|
cue_reset(sc);
|
|
|
|
untimeout(cue_tick, sc, sc->cue_stat_ch);
|
|
|
|
|
|
|
|
/* Stop transfers. */
|
|
|
|
if (sc->cue_ep[CUE_ENDPT_RX] != NULL) {
|
|
|
|
err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_RX]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: abort rx pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_RX]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: close rx pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
sc->cue_ep[CUE_ENDPT_RX] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sc->cue_ep[CUE_ENDPT_TX] != NULL) {
|
|
|
|
err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_TX]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: abort tx pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_TX]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: close tx pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
sc->cue_ep[CUE_ENDPT_TX] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sc->cue_ep[CUE_ENDPT_INTR] != NULL) {
|
|
|
|
err = usbd_abort_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: abort intr pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
err = usbd_close_pipe(sc->cue_ep[CUE_ENDPT_INTR]);
|
|
|
|
if (err) {
|
|
|
|
printf("cue%d: close intr pipe failed: %s\n",
|
|
|
|
sc->cue_unit, usbd_errstr(err));
|
|
|
|
}
|
|
|
|
sc->cue_ep[CUE_ENDPT_INTR] = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free RX resources. */
|
|
|
|
for (i = 0; i < CUE_RX_LIST_CNT; i++) {
|
|
|
|
if (sc->cue_cdata.cue_rx_chain[i].cue_buf != NULL) {
|
|
|
|
free(sc->cue_cdata.cue_rx_chain[i].cue_buf, M_USBDEV);
|
|
|
|
sc->cue_cdata.cue_rx_chain[i].cue_buf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->cue_cdata.cue_rx_chain[i].cue_mbuf != NULL) {
|
|
|
|
m_freem(sc->cue_cdata.cue_rx_chain[i].cue_mbuf);
|
|
|
|
sc->cue_cdata.cue_rx_chain[i].cue_mbuf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->cue_cdata.cue_rx_chain[i].cue_xfer != NULL) {
|
|
|
|
usbd_free_xfer(sc->cue_cdata.cue_rx_chain[i].cue_xfer);
|
|
|
|
sc->cue_cdata.cue_rx_chain[i].cue_xfer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free TX resources. */
|
|
|
|
for (i = 0; i < CUE_TX_LIST_CNT; i++) {
|
|
|
|
if (sc->cue_cdata.cue_tx_chain[i].cue_buf != NULL) {
|
|
|
|
free(sc->cue_cdata.cue_tx_chain[i].cue_buf, M_USBDEV);
|
|
|
|
sc->cue_cdata.cue_tx_chain[i].cue_buf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->cue_cdata.cue_tx_chain[i].cue_mbuf != NULL) {
|
|
|
|
m_freem(sc->cue_cdata.cue_tx_chain[i].cue_mbuf);
|
|
|
|
sc->cue_cdata.cue_tx_chain[i].cue_mbuf = NULL;
|
|
|
|
}
|
|
|
|
if (sc->cue_cdata.cue_tx_chain[i].cue_xfer != NULL) {
|
|
|
|
usbd_free_xfer(sc->cue_cdata.cue_tx_chain[i].cue_xfer);
|
|
|
|
sc->cue_cdata.cue_tx_chain[i].cue_xfer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stop all chip I/O so that the kernel's probe routines don't
|
|
|
|
* get confused by errant DMAs when rebooting.
|
|
|
|
*/
|
2002-04-02 11:54:28 +00:00
|
|
|
Static void
|
2002-04-06 19:55:52 +00:00
|
|
|
cue_shutdown(device_ptr_t dev)
|
2000-01-14 03:14:49 +00:00
|
|
|
{
|
|
|
|
struct cue_softc *sc;
|
|
|
|
|
|
|
|
sc = device_get_softc(dev);
|
|
|
|
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_LOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
cue_reset(sc);
|
|
|
|
cue_stop(sc);
|
2000-10-24 22:38:54 +00:00
|
|
|
CUE_UNLOCK(sc);
|
2000-01-14 03:14:49 +00:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|