Static void
kue_setmulti(struct kue_softc *sc)
{
struct ifnet *ifp = GET_IFP(sc);
struct ether_multi *enm;
struct ether_multistep step;
int i;
DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __func__));
if (ifp->if_flags & IFF_PROMISC) {
allmulti:
ifp->if_flags |= IFF_ALLMULTI;
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;
i = 0;
#if defined (__NetBSD__)
ETHER_FIRST_MULTI(step, &sc->kue_ec, enm);
#else
ETHER_FIRST_MULTI(step, &sc->arpcom, enm);
#endif
while (enm != NULL) {
if (i == KUE_MCFILTCNT(sc) ||
memcmp(enm->enm_addrlo, enm->enm_addrhi,
ETHER_ADDR_LEN) != 0)
goto allmulti;
memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN);
ETHER_NEXT_MULTI(step, enm);
i++;
}
ifp->if_flags &= ~IFF_ALLMULTI;
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);
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
}
void
kue_setmulti(struct kue_softc *sc)
{
struct arpcom *ac = &sc->arpcom;
struct ifnet *ifp = GET_IFP(sc);
struct ether_multi *enm;
struct ether_multistep step;
int i;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
if (ifp->if_flags & IFF_PROMISC || ac->ac_multirangecnt > 0) {
allmulti:
ifp->if_flags |= IFF_ALLMULTI;
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;
i = 0;
ETHER_FIRST_MULTI(step, ac, enm);
while (enm != NULL) {
if (i == KUE_MCFILTCNT(sc))
goto allmulti;
memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN);
ETHER_NEXT_MULTI(step, enm);
i++;
}
ifp->if_flags &= ~IFF_ALLMULTI;
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);
kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt);
}
void
kue_init(void *xsc)
{
struct kue_softc *sc = xsc;
struct ifnet *ifp = GET_IFP(sc);
int s;
u_char *eaddr;
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname,__func__));
if (ifp->if_flags & IFF_RUNNING)
return;
s = splnet();
eaddr = sc->arpcom.ac_enaddr;
/* Set MAC address */
kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MAC, 0, eaddr, 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. */
#if 0
/*
* Leave this one alone for now; setting it
* wrong causes lockups on some machines/controllers.
*/
kue_setword(sc, KUE_CMD_SET_SOFS, 1);
#endif
kue_setword(sc, KUE_CMD_SET_URB_SIZE, 64);
/* Init TX ring. */
if (kue_tx_list_init(sc) == ENOBUFS) {
printf("%s: tx list init failed\n", sc->kue_dev.dv_xname);
splx(s);
return;
}
/* Init RX ring. */
if (kue_rx_list_init(sc) == ENOBUFS) {
printf("%s: rx list init failed\n", sc->kue_dev.dv_xname);
splx(s);
return;
}
/* Load the multicast filter. */
kue_setmulti(sc);
if (sc->kue_ep[KUE_ENDPT_RX] == NULL) {
if (kue_open_pipes(sc)) {
splx(s);
return;
}
}
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
splx(s);
}
void
kue_attachhook(void *xsc)
{
struct kue_softc *sc = xsc;
int s;
struct ifnet *ifp;
usbd_device_handle dev = sc->kue_udev;
usbd_interface_handle iface;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
/* Load the firmware into the NIC. */
if (kue_load_fw(sc)) {
printf("%s: loading firmware failed\n",
sc->kue_dev.dv_xname);
return;
}
err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface);
if (err) {
printf("%s: getting interface handle failed\n",
sc->kue_dev.dv_xname);
return;
}
sc->kue_iface = iface;
id = usbd_get_interface_descriptor(iface);
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->kue_dev.dv_xname, i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
}
}
if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) {
printf("%s: missing endpoint\n", sc->kue_dev.dv_xname);
return;
}
/* Read ethernet descriptor */
err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
0, &sc->kue_desc, sizeof(sc->kue_desc));
if (err) {
printf("%s: could not read Ethernet descriptor\n",
sc->kue_dev.dv_xname);
return;
}
sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
M_USBDEV, M_NOWAIT);
if (sc->kue_mcfilters == NULL) {
printf("%s: no memory for multicast filter buffer\n",
sc->kue_dev.dv_xname);
return;
}
s = splnet();
/*
* A KLSI chip was detected. Inform the world.
*/
printf("%s: address %s\n", sc->kue_dev.dv_xname,
ether_sprintf(sc->kue_desc.kue_macaddr));
bcopy(sc->kue_desc.kue_macaddr,
(char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
/* Initialize interface info.*/
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = kue_ioctl;
ifp->if_start = kue_start;
ifp->if_watchdog = kue_watchdog;
strlcpy(ifp->if_xname, sc->kue_dev.dv_xname, IFNAMSIZ);
IFQ_SET_READY(&ifp->if_snd);
/* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp);
sc->kue_attached = 1;
splx(s);
}
int
kue_load_fw(struct kue_softc *sc)
{
usb_device_descriptor_t dd;
usbd_status err;
struct kue_firmware *fw;
u_char *buf;
size_t buflen;
DPRINTFN(1,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
/*
* 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.
*
* 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.
*/
if (usbd_get_device_desc(sc->kue_udev, &dd))
return (EIO);
if (UGETW(dd.bcdDevice) >= KUE_WARM_REV) {
printf("%s: warm boot, no firmware download\n",
sc->kue_dev.dv_xname);
return (0);
}
err = loadfirmware("kue", &buf, &buflen);
if (err) {
printf("%s: failed loadfirmware of file %s: errno %d\n",
sc->kue_dev.dv_xname, "kue", err);
return (err);
}
fw = (struct kue_firmware *)buf;
printf("%s: cold boot, downloading firmware\n",
sc->kue_dev.dv_xname);
/* Load code segment */
DPRINTFN(1,("%s: kue_load_fw: download code_seg\n",
sc->kue_dev.dv_xname));
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
0, (void *)&fw->data[0], ntohl(fw->codeseglen));
if (err) {
printf("%s: failed to load code segment: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
free(buf, M_DEVBUF);
return (EIO);
}
/* Load fixup segment */
DPRINTFN(1,("%s: kue_load_fw: download fix_seg\n",
sc->kue_dev.dv_xname));
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
0, (void *)&fw->data[ntohl(fw->codeseglen)], ntohl(fw->fixseglen));
if (err) {
printf("%s: failed to load fixup segment: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
free(buf, M_DEVBUF);
return (EIO);
}
/* Send trigger command. */
DPRINTFN(1,("%s: kue_load_fw: download trig_seg\n",
sc->kue_dev.dv_xname));
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
0, (void *)&fw->data[ntohl(fw->codeseglen) + ntohl(fw->fixseglen)],
ntohl(fw->trigseglen));
if (err) {
printf("%s: failed to load trigger segment: %s\n",
sc->kue_dev.dv_xname, usbd_errstr(err));
free(buf, M_DEVBUF);
return (EIO);
}
free(buf, M_DEVBUF);
usbd_delay_ms(sc->kue_udev, 10);
/*
* Reload device descriptor.
* Why? The chip without the firmware loaded returns
* one revision code. The chip with the firmware
* loaded and running returns a *different* revision
* code. This confuses the quirk mechanism, which is
* dependent on the revision data.
*/
(void)usbd_reload_device_desc(sc->kue_udev);
DPRINTFN(1,("%s: %s: done\n", sc->kue_dev.dv_xname, __func__));
/* Reset the adapter. */
kue_reset(sc);
return (0);
}
Static int
kue_load_fw(struct kue_softc *sc)
{
usb_device_descriptor_t dd;
usbd_status err;
DPRINTFN(1,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __func__));
/*
* 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.
*
* 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.
*/
if (usbd_get_device_desc(sc->kue_udev, &dd))
return (EIO);
if (UGETW(dd.bcdDevice) == KUE_WARM_REV) {
printf("%s: warm boot, no firmware download\n",
USBDEVNAME(sc->kue_dev));
return (0);
}
printf("%s: cold boot, downloading firmware\n",
USBDEVNAME(sc->kue_dev));
/* Load code segment */
DPRINTFN(1,("%s: kue_load_fw: download code_seg\n",
USBDEVNAME(sc->kue_dev)));
/*XXXUNCONST*/
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
0, __UNCONST(kue_code_seg), sizeof(kue_code_seg));
if (err) {
printf("%s: failed to load code segment: %s\n",
USBDEVNAME(sc->kue_dev), usbd_errstr(err));
return (EIO);
}
/* Load fixup segment */
DPRINTFN(1,("%s: kue_load_fw: download fix_seg\n",
USBDEVNAME(sc->kue_dev)));
/*XXXUNCONST*/
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
0, __UNCONST(kue_fix_seg), sizeof(kue_fix_seg));
if (err) {
printf("%s: failed to load fixup segment: %s\n",
USBDEVNAME(sc->kue_dev), usbd_errstr(err));
return (EIO);
}
/* Send trigger command. */
DPRINTFN(1,("%s: kue_load_fw: download trig_seg\n",
USBDEVNAME(sc->kue_dev)));
/*XXXUNCONST*/
err = kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SEND_SCAN,
0, __UNCONST(kue_trig_seg), sizeof(kue_trig_seg));
if (err) {
printf("%s: failed to load trigger segment: %s\n",
USBDEVNAME(sc->kue_dev), usbd_errstr(err));
return (EIO);
}
usbd_delay_ms(sc->kue_udev, 10);
/*
* Reload device descriptor.
* Why? The chip without the firmware loaded returns
* one revision code. The chip with the firmware
* loaded and running returns a *different* revision
* code. This confuses the quirk mechanism, which is
* dependent on the revision data.
*/
(void)usbd_reload_device_desc(sc->kue_udev);
DPRINTFN(1,("%s: %s: done\n", USBDEVNAME(sc->kue_dev), __func__));
/* Reset the adapter. */
kue_reset(sc);
return (0);
}
/*
* Attach the interface. Allocate softc structures, do
* setup and ethernet/BPF attach.
*/
void
kue_attach(device_t parent, device_t self, void *aux)
{
struct kue_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
char *devinfop;
int s;
struct ifnet *ifp;
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
DPRINTFN(5,(" : kue_attach: sc=%p, dev=%p", sc, dev));
sc->kue_dev = self;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, KUE_CONFIG_NO, 1);
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
return;
}
sc->kue_udev = dev;
sc->kue_product = uaa->product;
sc->kue_vendor = uaa->vendor;
/* Load the firmware into the NIC. */
if (kue_load_fw(sc)) {
aprint_error_dev(self, "loading firmware failed\n");
return;
}
err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface);
if (err) {
aprint_error_dev(self, "getting interface handle failed\n");
return;
}
sc->kue_iface = iface;
id = usbd_get_interface_descriptor(iface);
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
aprint_error_dev(self, "couldn't get ep %d\n", i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
}
}
if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) {
aprint_error_dev(self, "missing endpoint\n");
return;
}
/* Read ethernet descriptor */
err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
0, &sc->kue_desc, sizeof(sc->kue_desc));
if (err) {
aprint_error_dev(self, "could not read Ethernet descriptor\n");
return;
}
sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
M_USBDEV, M_NOWAIT);
if (sc->kue_mcfilters == NULL) {
aprint_error_dev(self,
"no memory for multicast filter buffer\n");
return;
}
s = splnet();
/*
* A KLSI chip was detected. Inform the world.
*/
aprint_normal_dev(self, "Ethernet address %s\n",
ether_sprintf(sc->kue_desc.kue_macaddr));
/* Initialize interface info.*/
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = kue_ioctl;
ifp->if_start = kue_start;
ifp->if_watchdog = kue_watchdog;
strncpy(ifp->if_xname, device_xname(sc->kue_dev), IFNAMSIZ);
IFQ_SET_READY(&ifp->if_snd);
/* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp, sc->kue_desc.kue_macaddr);
rnd_attach_source(&sc->rnd_source, device_xname(sc->kue_dev),
RND_TYPE_NET, RND_FLAG_DEFAULT);
sc->kue_attached = true;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->kue_udev,
sc->kue_dev);
return;
}
