/*
* Called from boot code to establish ppp interfaces.
*/
static void
pppattach(void *dummy)
{
struct ppp_softc *sc;
int i = 0;
for (sc = ppp_softc; i < NPPP; sc++) {
if_initname(&(sc->sc_if), "ppp", i++);
sc->sc_if.if_softc = sc;
sc->sc_if.if_mtu = PPP_MTU;
sc->sc_if.if_flags = IFF_POINTOPOINT | IFF_MULTICAST;
sc->sc_if.if_type = IFT_PPP;
sc->sc_if.if_hdrlen = PPP_HDRLEN;
sc->sc_if.if_ioctl = pppsioctl;
sc->sc_if.if_output = pppoutput;
sc->sc_if.if_start = ppp_ifstart;
ifq_set_maxlen(&sc->sc_if.if_snd, IFQ_MAXLEN);
ifq_set_ready(&sc->sc_if.if_snd);
sc->sc_inq.ifq_maxlen = IFQ_MAXLEN;
sc->sc_fastq.ifq_maxlen = IFQ_MAXLEN;
sc->sc_rawq.ifq_maxlen = IFQ_MAXLEN;
callout_init(&sc->sc_timeout);
if_attach(&sc->sc_if, NULL);
bpfattach(&sc->sc_if, DLT_PPP, PPP_HDRLEN);
}
netisr_register(NETISR_PPP, pppintr, NULL);
/*
* XXX layering violation - if_ppp can work over any lower level
* transport that cares to attach to it.
*/
pppasyncattach(dummy);
}
/* ARGSUSED */
static void
loopattach(void *dummy)
{
struct ifnet *ifp;
int i;
for (i = 0, ifp = loif; i < NLOOP; i++, ifp++) {
if_initname(ifp, "lo", i);
ifp->if_mtu = LOMTU;
ifp->if_flags = IFF_LOOPBACK | IFF_MULTICAST;
ifp->if_capabilities = IFCAP_HWCSUM;
ifp->if_hwassist = LO_CSUM_FEATURES;
ifp->if_capenable = ifp->if_capabilities;
ifp->if_ioctl = loioctl;
ifp->if_output = looutput;
ifp->if_type = IFT_LOOP;
ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
ifq_set_ready(&ifp->if_snd);
#ifdef ALTQ
ifp->if_start = lo_altqstart;
#endif
if_attach(ifp, NULL);
bpfattach(ifp, DLT_NULL, sizeof(u_int));
}
}
static int
ipfw_log_clone_create(struct if_clone *ifc, int unit, caddr_t param __unused)
{
struct ifnet *ifp;
if (unit < 0 || unit >= LOG_IF_MAX) {
return EINVAL;
}
if (log_if_table[unit] != NULL) {
return EINVAL;
}
ifp = if_alloc(IFT_PFLOG);
if_initname(ifp, ipfw_log_ifname, unit);
ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
ifq_set_ready(&ifp->if_snd);
ifp->if_mtu = 65536;
ifp->if_flags = IFF_UP | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_init = (void *)log_dummy;
ifp->if_ioctl = log_dummy;
ifp->if_start = ipfw_log_start;
ifp->if_output = ipfw_log_output;
ifp->if_addrlen = 6;
ifp->if_hdrlen = 14;
ifp->if_broadcastaddr = ipfwbroadcastaddr;
ifp->if_baudrate = IF_Mbps(10);
LOGIF_WLOCK();
log_if_table[unit] = ifp;
log_if_count++;
if_attach(ifp, NULL);
bpfattach(ifp, DLT_EN10MB, ETHER_HDR_LEN);
LOGIF_WUNLOCK();
return (0);
}
/* Attach the interface to the kernel data structures. By the time
* this is called, we know that the card exists at the given I/O address.
* We still assume that the IRQ given is correct.
*/
static int
el_attach(struct isa_device *idev)
{
struct el_softc *sc;
struct ifnet *ifp;
dprintf(("Attaching el%d...\n",idev->id_unit));
/* Get things pointing to the right places. */
idev->id_intr = (inthand2_t *)elintr;
sc = &el_softc[idev->id_unit];
ifp = &sc->arpcom.ac_if;
/* Now reset the board */
dprintf(("Resetting board...\n"));
el_hardreset(sc);
/* Initialize ifnet structure */
ifp->if_softc = sc;
if_initname(ifp, "el", idev->id_unit);
ifp->if_mtu = ETHERMTU;
ifp->if_start = el_start;
ifp->if_ioctl = el_ioctl;
ifp->if_watchdog = el_watchdog;
ifp->if_init = el_init;
ifp->if_flags = (IFF_BROADCAST | IFF_SIMPLEX);
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
/* Now we can attach the interface */
dprintf(("Attaching interface...\n"));
ether_ifattach(ifp, sc->arpcom.ac_enaddr, &el_serializer);
dprintf(("el_attach() finished.\n"));
return(1);
}
static int
sbsh_attach(device_t dev)
{
struct sbsh_softc *sc;
struct ifnet *ifp;
int unit, error = 0, rid;
sc = device_get_softc(dev);
unit = device_get_unit(dev);
rid = PCIR_MAPS + 4;
sc->mem_res = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid,
0, ~0, 4096, RF_ACTIVE);
if (sc->mem_res == NULL) {
kprintf ("sbsh%d: couldn't map memory\n", unit);
error = ENXIO;
goto fail;
}
rid = 0;
sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
RF_SHAREABLE | RF_ACTIVE);
if (sc->irq_res == NULL) {
kprintf("sbsh%d: couldn't map interrupt\n", unit);
error = ENXIO;
goto fail;
}
sc->mem_base = rman_get_virtual(sc->mem_res);
init_card(sc);
/* generate ethernet MAC address */
*(u_int32_t *)sc->arpcom.ac_enaddr = htonl(0x00ff0192);
read_random_unlimited(sc->arpcom.ac_enaddr + 4, 2);
ifp = &sc->arpcom.ac_if;
ifp->if_softc = sc;
if_initname(ifp, "sbsh", unit);
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = sbsh_ioctl;
ifp->if_start = sbsh_start;
ifp->if_watchdog = sbsh_watchdog;
ifp->if_init = sbsh_init;
ifp->if_baudrate = 4600000;
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
ether_ifattach(ifp, sc->arpcom.ac_enaddr, NULL);
ifq_set_cpuid(&ifp->if_snd, rman_get_cpuid(sc->irq_res));
error = bus_setup_intr(dev, sc->irq_res, INTR_MPSAFE,
sbsh_intr, sc, &sc->intr_hand,
ifp->if_serializer);
if (error) {
ether_ifdetach(ifp);
kprintf("sbsh%d: couldn't set up irq\n", unit);
goto fail;
}
return(0);
fail:
sbsh_detach(dev);
return (error);
}
/*
* Attach the interface.
*/
static int
lgue_attach(device_t dev)
{
struct lgue_softc *sc;
struct usb_attach_arg *uaa;
struct ifnet *ifp;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
u_char eaddr[ETHER_ADDR_LEN];
usbd_status err;
sc = device_get_softc(dev);
uaa = device_get_ivars(dev);
sc->lgue_ctl_iface = uaa->iface;
sc->lgue_udev = uaa->device;
/* It has only config but in case... */
if (usbd_set_config_no(sc->lgue_udev, LGUE_CONFIG_NO, 0)) {
device_printf(dev, "setting config no %d failed\n",
LGUE_CONFIG_NO);
return(ENXIO);
}
/* Get control and data intefaces */
id = usbd_get_interface_descriptor(uaa->iface);
sc->lgue_ctl_iface_no = id->bInterfaceNumber;
sc->lgue_data_iface_no = lgue_get_data_iface_no(sc->lgue_udev, id);
if (sc->lgue_data_iface_no == -1) {
device_printf(dev, "no data interface number\n");
goto bad;
}
/* Claim data interface */
for (i = 0; i < uaa->nifaces; ++i) {
if (uaa->ifaces[i] != NULL) {
id = usbd_get_interface_descriptor(uaa->ifaces[i]);
if (id != NULL &&
id->bInterfaceNumber == sc->lgue_data_iface_no) {
err = usbd_set_interface(uaa->ifaces[i],
LGUE_ALTERNATE_SETTING);
if ( err != USBD_NORMAL_COMPLETION) {
device_printf(dev,
"no alternate data interface. err:%s\n",
usbd_errstr(err));
goto bad;
}
sc->lgue_data_iface = uaa->ifaces[i];
uaa->ifaces[i] = NULL;
}
}
}
if (sc->lgue_data_iface == NULL) {
device_printf(dev, "no data interface\n");
goto bad;
}
/* Find data interface endpoints */
id = usbd_get_interface_descriptor(sc->lgue_data_iface);
sc->lgue_ed[LGUE_ENDPT_RX] = sc->lgue_ed[LGUE_ENDPT_TX] = -1;
for (i = 0; i < id->bNumEndpoints; ++i) {
ed = usbd_interface2endpoint_descriptor(sc->lgue_data_iface, i);
if (!ed) {
device_printf(dev,
"couldn't get endpoint descriptor %d\n", i);
goto bad;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->lgue_ed[LGUE_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->lgue_ed[LGUE_ENDPT_TX] = ed->bEndpointAddress;
}
}
if (sc->lgue_ed[LGUE_ENDPT_RX] == -1) {
device_printf(dev, "couldn't find data bilk in\n");
goto bad;
}
if (sc->lgue_ed[LGUE_ENDPT_TX] == -1) {
device_printf(dev, "couldn't find data bilk out\n");
goto bad;
}
/* Find control interface endpoint */
id = usbd_get_interface_descriptor(sc->lgue_ctl_iface);
sc->lgue_ed[LGUE_ENDPT_INTR] = -1;
for (i = 0; i < id->bNumEndpoints; ++i) {
ed = usbd_interface2endpoint_descriptor(sc->lgue_ctl_iface, i);
if (!ed) {
device_printf(dev,
"couldn't get endpoint descriptor %d\n", i);
goto bad;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->lgue_ed[LGUE_ENDPT_INTR] = ed->bEndpointAddress;
}
}
if (sc->lgue_ed[LGUE_ENDPT_INTR] == -1) {
device_printf(dev, "couldn't find interrupt bilk in\n");
goto bad;
}
/* Create interface */
ifp = &sc->lgue_arpcom.ac_if;
ifp->if_softc = sc;
if_initname(ifp, device_get_name(dev), device_get_unit(dev));
lgue_getmac(sc, eaddr);
ifp->if_mtu = lgue_getmtu(sc);
ifp->if_data.ifi_mtu = ifp->if_mtu;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_baudrate = 10000000;
ifp->if_ioctl = lgue_ioctl;
ifp->if_start = lgue_start;
ifp->if_watchdog = lgue_watchdog;
ifp->if_init = lgue_init;
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
/* Call attach routine */
ether_ifattach(ifp, eaddr, NULL);
usb_register_netisr();
sc->lgue_dying = 0;
return(0);
bad:
return(ENXIO);
}
/* Attach the interface. Allocate softc structures */
static int
sln_attach(device_t dev)
{
struct sln_softc *sc = device_get_softc(dev);
struct ifnet *ifp = &sc->arpcom.ac_if;
unsigned char eaddr[ETHER_ADDR_LEN];
int rid;
int error = 0;
if_initname(ifp, device_get_name(dev), device_get_unit(dev));
/* TODO: power state change */
pci_enable_busmaster(dev);
rid = SL_RID;
sc->sln_res = bus_alloc_resource_any(dev, SL_RES, &rid, RF_ACTIVE);
if (sc->sln_res == NULL) {
device_printf(dev, "couldn't map ports/memory\n");
error = ENXIO;
goto fail;
}
sc->sln_bustag = rman_get_bustag(sc->sln_res);
sc->sln_bushandle = rman_get_bushandle(sc->sln_res);
/* alloc pci irq */
rid = 0;
sc->sln_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
RF_SHAREABLE | RF_ACTIVE);
if (sc->sln_irq == NULL) {
device_printf(dev, "couldn't map interrupt\n");
bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
error = ENXIO;
goto fail;
}
/* Get MAC address */
((uint32_t *)(&eaddr))[0] = be32toh(SLN_READ_4(sc, SL_MAC_ADDR0));
((uint16_t *)(&eaddr))[2] = be16toh(SLN_READ_4(sc, SL_MAC_ADDR1));
/* alloc rx buffer space */
sc->sln_bufdata.sln_rx_buf = contigmalloc(SL_RX_BUFLEN,
M_DEVBUF, M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);
if (sc->sln_bufdata.sln_rx_buf == NULL) {
device_printf(dev, "no memory for rx buffers!\n");
bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sln_irq);
bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
error = ENXIO;
goto fail;
}
callout_init(&sc->sln_state);
ifp->if_softc = sc;
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_init = sln_init;
ifp->if_start = sln_tx;
ifp->if_ioctl = sln_ioctl;
ifp->if_watchdog = sln_watchdog;
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
/* initial media */
ifmedia_init(&sc->ifmedia, 0, sln_media_upd, sln_media_stat);
/* supported media types */
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_AUTO, 0, NULL);
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_10_T, 0, NULL);
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_10_T | IFM_HDX, 0, NULL);
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_10_T | IFM_FDX, 0, NULL);
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_100_TX, 0, NULL);
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_100_TX | IFM_HDX, 0, NULL);
ifmedia_add(&sc->ifmedia, IFM_ETHER | IFM_100_TX | IFM_FDX, 0, NULL);
/* Choose a default media. */
ifmedia_set(&sc->ifmedia, IFM_ETHER | IFM_AUTO);
ether_ifattach(ifp, eaddr, NULL);
error = bus_setup_intr(dev, sc->sln_irq, INTR_MPSAFE, sln_interrupt, sc,
&sc->sln_intrhand, ifp->if_serializer);
if (error) {
bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sln_irq);
bus_release_resource(dev, SL_RES, SL_RID, sc->sln_res);
ether_ifdetach(ifp);
device_printf(dev, "couldn't set up irq\n");
goto fail;
}
ifp->if_cpuid = rman_get_cpuid(sc->sln_irq);
KKASSERT(ifp->if_cpuid >= 0 && ifp->if_cpuid < ncpus);
return 0;
fail:
return error;
}
/*
* Prepare a vap for use. Drivers use this call to
* setup net80211 state in new vap's prior attaching
* them with ieee80211_vap_attach (below).
*/
int
ieee80211_vap_setup(struct ieee80211com *ic, struct ieee80211vap *vap,
const char name[IFNAMSIZ], int unit, int opmode, int flags,
const uint8_t bssid[IEEE80211_ADDR_LEN],
const uint8_t macaddr[IEEE80211_ADDR_LEN])
{
struct ifnet *ifp;
ifp = if_alloc(IFT_ETHER);
if (ifp == NULL) {
if_printf(ic->ic_ifp, "%s: unable to allocate ifnet\n",
__func__);
return ENOMEM;
}
if_initname(ifp, name, unit);
ifp->if_softc = vap; /* back pointer */
ifp->if_flags = IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST;
ifp->if_start = ieee80211_start;
ifp->if_ioctl = ieee80211_ioctl;
ifp->if_init = ieee80211_init;
/* NB: input+output filled in by ether_ifattach */
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
vap->iv_ifp = ifp;
vap->iv_ic = ic;
vap->iv_flags = ic->ic_flags; /* propagate common flags */
vap->iv_flags_ext = ic->ic_flags_ext;
vap->iv_flags_ven = ic->ic_flags_ven;
vap->iv_caps = ic->ic_caps &~ IEEE80211_C_OPMODE;
vap->iv_htcaps = ic->ic_htcaps;
vap->iv_opmode = opmode;
vap->iv_caps |= ieee80211_opcap[opmode];
switch (opmode) {
case IEEE80211_M_WDS:
/*
* WDS links must specify the bssid of the far end.
* For legacy operation this is a static relationship.
* For non-legacy operation the station must associate
* and be authorized to pass traffic. Plumbing the
* vap to the proper node happens when the vap
* transitions to RUN state.
*/
IEEE80211_ADDR_COPY(vap->iv_des_bssid, bssid);
vap->iv_flags |= IEEE80211_F_DESBSSID;
if (flags & IEEE80211_CLONE_WDSLEGACY)
vap->iv_flags_ext |= IEEE80211_FEXT_WDSLEGACY;
break;
#ifdef IEEE80211_SUPPORT_TDMA
case IEEE80211_M_AHDEMO:
if (flags & IEEE80211_CLONE_TDMA) {
/* NB: checked before clone operation allowed */
KASSERT(ic->ic_caps & IEEE80211_C_TDMA,
("not TDMA capable, ic_caps 0x%x", ic->ic_caps));
/*
* Propagate TDMA capability to mark vap; this
* cannot be removed and is used to distinguish
* regular ahdemo operation from ahdemo+tdma.
*/
vap->iv_caps |= IEEE80211_C_TDMA;
}
break;
#endif
}
/* auto-enable s/w beacon miss support */
if (flags & IEEE80211_CLONE_NOBEACONS)
vap->iv_flags_ext |= IEEE80211_FEXT_SWBMISS;
/* auto-generated or user supplied MAC address */
if (flags & (IEEE80211_CLONE_BSSID|IEEE80211_CLONE_MACADDR))
vap->iv_flags_ext |= IEEE80211_FEXT_UNIQMAC;
/*
* Enable various functionality by default if we're
* capable; the driver can override us if it knows better.
*/
if (vap->iv_caps & IEEE80211_C_WME)
vap->iv_flags |= IEEE80211_F_WME;
if (vap->iv_caps & IEEE80211_C_BURST)
vap->iv_flags |= IEEE80211_F_BURST;
#if 0
/*
* NB: bg scanning only makes sense for station mode right now
*
* XXX: bgscan is not necessarily stable, so do not enable it by
* default. It messes up atheros drivers for sure.
* (tested w/ AR9280).
*/
if (vap->iv_opmode == IEEE80211_M_STA &&
(vap->iv_caps & IEEE80211_C_BGSCAN))
vap->iv_flags |= IEEE80211_F_BGSCAN;
#endif
vap->iv_flags |= IEEE80211_F_DOTH; /* XXX no cap, just ena */
/* NB: DFS support only makes sense for ap mode right now */
if (vap->iv_opmode == IEEE80211_M_HOSTAP &&
(vap->iv_caps & IEEE80211_C_DFS))
vap->iv_flags_ext |= IEEE80211_FEXT_DFS;
vap->iv_des_chan = IEEE80211_CHAN_ANYC; /* any channel is ok */
vap->iv_bmissthreshold = IEEE80211_HWBMISS_DEFAULT;
vap->iv_dtim_period = IEEE80211_DTIM_DEFAULT;
/*
* Install a default reset method for the ioctl support;
* the driver can override this.
*/
vap->iv_reset = default_reset;
IEEE80211_ADDR_COPY(vap->iv_myaddr, macaddr);
ieee80211_sysctl_vattach(vap);
ieee80211_crypto_vattach(vap);
ieee80211_node_vattach(vap);
ieee80211_power_vattach(vap);
ieee80211_proto_vattach(vap);
#ifdef IEEE80211_SUPPORT_SUPERG
ieee80211_superg_vattach(vap);
#endif
ieee80211_ht_vattach(vap);
ieee80211_scan_vattach(vap);
ieee80211_regdomain_vattach(vap);
ieee80211_radiotap_vattach(vap);
ieee80211_ratectl_set(vap, IEEE80211_RATECTL_AMRR);
return 0;
}
static int
txp_attach(device_t dev)
{
struct txp_softc *sc;
struct ifnet *ifp;
uint16_t p1;
uint32_t p2;
uint8_t enaddr[ETHER_ADDR_LEN];
int error = 0, rid;
sc = device_get_softc(dev);
callout_init(&sc->txp_stat_timer);
ifp = &sc->sc_arpcom.ac_if;
if_initname(ifp, device_get_name(dev), device_get_unit(dev));
pci_enable_busmaster(dev);
rid = TXP_RID;
sc->sc_res = bus_alloc_resource_any(dev, TXP_RES, &rid, RF_ACTIVE);
if (sc->sc_res == NULL) {
device_printf(dev, "couldn't map ports/memory\n");
return(ENXIO);
}
sc->sc_bt = rman_get_bustag(sc->sc_res);
sc->sc_bh = rman_get_bushandle(sc->sc_res);
/* Allocate interrupt */
rid = 0;
sc->sc_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
RF_SHAREABLE | RF_ACTIVE);
if (sc->sc_irq == NULL) {
device_printf(dev, "couldn't map interrupt\n");
error = ENXIO;
goto fail;
}
if (txp_chip_init(sc)) {
error = ENXIO;
goto fail;
}
sc->sc_fwbuf = contigmalloc(32768, M_DEVBUF,
M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);
error = txp_download_fw(sc);
contigfree(sc->sc_fwbuf, 32768, M_DEVBUF);
sc->sc_fwbuf = NULL;
if (error)
goto fail;
sc->sc_ldata = contigmalloc(sizeof(struct txp_ldata), M_DEVBUF,
M_WAITOK | M_ZERO, 0, 0xffffffff, PAGE_SIZE, 0);
if (txp_alloc_rings(sc)) {
error = ENXIO;
goto fail;
}
if (txp_command(sc, TXP_CMD_MAX_PKT_SIZE_WRITE, TXP_MAX_PKTLEN, 0, 0,
NULL, NULL, NULL, 1)) {
error = ENXIO;
goto fail;
}
if (txp_command(sc, TXP_CMD_STATION_ADDRESS_READ, 0, 0, 0,
&p1, &p2, NULL, 1)) {
error = ENXIO;
goto fail;
}
txp_set_filter(sc);
enaddr[0] = ((uint8_t *)&p1)[1];
enaddr[1] = ((uint8_t *)&p1)[0];
enaddr[2] = ((uint8_t *)&p2)[3];
enaddr[3] = ((uint8_t *)&p2)[2];
enaddr[4] = ((uint8_t *)&p2)[1];
enaddr[5] = ((uint8_t *)&p2)[0];
ifmedia_init(&sc->sc_ifmedia, 0, txp_ifmedia_upd, txp_ifmedia_sts);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_10_T|IFM_HDX, 0, NULL);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_10_T|IFM_FDX, 0, NULL);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_100_TX, 0, NULL);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_100_TX|IFM_HDX, 0, NULL);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_100_TX|IFM_FDX, 0, NULL);
ifmedia_add(&sc->sc_ifmedia, IFM_ETHER|IFM_AUTO, 0, NULL);
sc->sc_xcvr = TXP_XCVR_AUTO;
txp_command(sc, TXP_CMD_XCVR_SELECT, TXP_XCVR_AUTO, 0, 0,
NULL, NULL, NULL, 0);
ifmedia_set(&sc->sc_ifmedia, IFM_ETHER|IFM_AUTO);
ifp->if_softc = sc;
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = txp_ioctl;
ifp->if_start = txp_start;
ifp->if_watchdog = txp_watchdog;
ifp->if_init = txp_init;
ifp->if_baudrate = 100000000;
ifq_set_maxlen(&ifp->if_snd, TX_ENTRIES);
ifq_set_ready(&ifp->if_snd);
ifp->if_hwassist = 0;
txp_capabilities(sc);
ether_ifattach(ifp, enaddr, NULL);
error = bus_setup_intr(dev, sc->sc_irq, INTR_MPSAFE,
txp_intr, sc, &sc->sc_intrhand,
ifp->if_serializer);
if (error) {
device_printf(dev, "couldn't set up irq\n");
ether_ifdetach(ifp);
goto fail;
}
ifp->if_cpuid = ithread_cpuid(rman_get_start(sc->sc_irq));
KKASSERT(ifp->if_cpuid >= 0 && ifp->if_cpuid < ncpus);
return(0);
fail:
txp_release_resources(dev);
return(error);
}
static void
ue_attach_post_task(struct usb_proc_msg *_task)
{
struct usb_ether_cfg_task *task =
(struct usb_ether_cfg_task *)_task;
struct usb_ether *ue = task->ue;
struct ifnet *ifp = uether_getifp(ue);
int error;
char num[14]; /* sufficient for 32 bits */
/* first call driver's post attach routine */
ue->ue_methods->ue_attach_post(ue);
UE_UNLOCK(ue);
KKASSERT(!lockowned(ue->ue_lock));
ue->ue_unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(ue), 0);
usb_callout_init_mtx(&ue->ue_watchdog, ue->ue_lock, 0);
sysctl_ctx_init(&ue->ue_sysctl_ctx);
KKASSERT(!lockowned(ue->ue_lock));
error = 0;
ifp->if_softc = ue;
if_initname(ifp, "ue", ue->ue_unit);
if (ue->ue_methods->ue_attach_post_sub != NULL) {
error = ue->ue_methods->ue_attach_post_sub(ue);
KKASSERT(!lockowned(ue->ue_lock));
} else {
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
if (ue->ue_methods->ue_ioctl != NULL)
ifp->if_ioctl = ue->ue_methods->ue_ioctl;
else
ifp->if_ioctl = uether_ioctl;
ifp->if_start = ue_start;
ifp->if_init = ue_init;
ifq_set_maxlen(&ifp->if_snd, ifqmaxlen);
ifq_set_ready(&ifp->if_snd);
if (ue->ue_methods->ue_mii_upd != NULL &&
ue->ue_methods->ue_mii_sts != NULL) {
error = mii_phy_probe(ue->ue_dev, &ue->ue_miibus,
ue_ifmedia_upd, ue->ue_methods->ue_mii_sts);
}
}
if (error) {
device_printf(ue->ue_dev, "attaching PHYs failed\n");
goto fail;
}
if_printf(ifp, "<USB Ethernet> on %s\n", device_get_nameunit(ue->ue_dev));
ether_ifattach(ifp, ue->ue_eaddr, NULL);
/* Tell upper layer we support VLAN oversized frames. */
if (ifp->if_capabilities & IFCAP_VLAN_MTU)
ifp->if_hdrlen = sizeof(struct ether_vlan_header);
ksnprintf(num, sizeof(num), "%u", ue->ue_unit);
ue->ue_sysctl_oid = SYSCTL_ADD_NODE(&ue->ue_sysctl_ctx,
&SYSCTL_NODE_CHILDREN(_net, ue),
OID_AUTO, num, CTLFLAG_RD, NULL, "");
SYSCTL_ADD_PROC(&ue->ue_sysctl_ctx,
SYSCTL_CHILDREN(ue->ue_sysctl_oid), OID_AUTO,
"%parent", CTLTYPE_STRING | CTLFLAG_RD, ue, 0,
ue_sysctl_parent, "A", "parent device");
KKASSERT(!lockowned(ue->ue_lock));
UE_LOCK(ue);
return;
fail:
devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(ue), ue->ue_unit);
UE_LOCK(ue);
return;
}
int
sn_attach(device_t dev)
{
struct sn_softc *sc = device_get_softc(dev);
struct ifnet *ifp = &sc->arpcom.ac_if;
u_short i;
u_char *p;
int rev;
u_short address;
int j;
int error;
sn_activate(dev);
snstop(sc);
sc->dev = dev;
sc->pages_wanted = -1;
device_printf(dev, " ");
SMC_SELECT_BANK(3);
rev = inw(BASE + REVISION_REG_W);
if (chip_ids[(rev >> 4) & 0xF])
kprintf("%s ", chip_ids[(rev >> 4) & 0xF]);
SMC_SELECT_BANK(1);
i = inw(BASE + CONFIG_REG_W);
kprintf("%s\n", i & CR_AUI_SELECT ? "AUI" : "UTP");
if (sc->pccard_enaddr)
for (j = 0; j < 3; j++) {
u_short w;
w = (u_short)sc->arpcom.ac_enaddr[j * 2] |
(((u_short)sc->arpcom.ac_enaddr[j * 2 + 1]) << 8);
outw(BASE + IAR_ADDR0_REG_W + j * 2, w);
}
/*
* Read the station address from the chip. The MAC address is bank 1,
* regs 4 - 9
*/
SMC_SELECT_BANK(1);
p = (u_char *) & sc->arpcom.ac_enaddr;
for (i = 0; i < 6; i += 2) {
address = inw(BASE + IAR_ADDR0_REG_W + i);
p[i + 1] = address >> 8;
p[i] = address & 0xFF;
}
ifp->if_softc = sc;
if_initname(ifp, "sn", device_get_unit(dev));
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_start = snstart;
ifp->if_ioctl = snioctl;
ifp->if_watchdog = snwatchdog;
ifp->if_init = sninit;
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
ifp->if_timer = 0;
ether_ifattach(ifp, sc->arpcom.ac_enaddr, NULL);
ifq_set_cpuid(&ifp->if_snd, rman_get_cpuid(sc->irq_res));
error = bus_setup_intr(dev, sc->irq_res, INTR_MPSAFE,
sn_intr, sc, &sc->intrhand,
ifp->if_serializer);
if (error) {
ether_ifdetach(ifp);
sn_deactivate(dev);
return error;
}
return 0;
}
int
ep_attach(struct ep_softc *sc)
{
struct ifnet * ifp = NULL;
struct ifmedia * ifm = NULL;
u_short * p;
uint8_t ether_addr[ETHER_ADDR_LEN];
int i;
sc->gone = 0;
ep_get_macaddr(sc, ether_addr);
/*
* Setup the station address
*/
p = (u_short*)ether_addr;
GO_WINDOW(2);
for (i = 0; i < 3; i++) {
outw(BASE + EP_W2_ADDR_0 + (i * 2), ntohs(p[i]));
}
ifp = &sc->arpcom.ac_if;
ifp->if_softc = sc;
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_start = ep_if_start;
ifp->if_ioctl = ep_if_ioctl;
ifp->if_watchdog = ep_if_watchdog;
ifp->if_init = ep_if_init;
ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
ifq_set_ready(&ifp->if_snd);
if (!sc->epb.mii_trans) {
ifmedia_init(&sc->ifmedia, 0, ep_ifmedia_upd, ep_ifmedia_sts);
if (sc->ep_connectors & AUI)
ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_5, 0, NULL);
if (sc->ep_connectors & UTP)
ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_T, 0, NULL);
if (sc->ep_connectors & BNC)
ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_10_2, 0, NULL);
if (!sc->ep_connectors)
ifmedia_add(&sc->ifmedia, IFM_ETHER|IFM_NONE, 0, NULL);
ifmedia_set(&sc->ifmedia, IFM_ETHER|ep_media2if_media[sc->ep_connector]);
ifm = &sc->ifmedia;
ifm->ifm_media = ifm->ifm_cur->ifm_media;
ep_ifmedia_upd(ifp);
}
ether_ifattach(ifp, ether_addr, NULL);
#ifdef EP_LOCAL_STATS
sc->rx_no_first = sc->rx_no_mbuf = sc->rx_bpf_disc =
sc->rx_overrunf = sc->rx_overrunl = sc->tx_underrun = 0;
#endif
EP_FSET(sc, F_RX_FIRST);
sc->top = sc->mcur = 0;
return 0;
}