Add a driver for the Megahertz Ethernet/Modem combo cards, e.g. XJEM3336.
This supplies an attachment of the `sm' and `com' drivers. Thanks to Chuck Cranor for sifting through the Linux smc91c92_cs.c driver to find the magic sequence that brings the Ethernet portion of the card on-line!
This commit is contained in:
parent
9103e43937
commit
b5a2d37e04
|
@ -1,4 +1,4 @@
|
|||
# $NetBSD: files.pcmcia,v 1.16 1999/09/21 03:39:37 enami Exp $
|
||||
# $NetBSD: files.pcmcia,v 1.17 1999/09/28 17:58:55 thorpej Exp $
|
||||
#
|
||||
# Config.new file and device description for machine-independent PCMCIA code.
|
||||
# Included by ports that need it.
|
||||
|
@ -69,3 +69,11 @@ file dev/pcmcia/if_cnw.c cnw
|
|||
device wi: arp, ether, ifnet
|
||||
attach wi at pcmcia
|
||||
file dev/pcmcia/if_wi.c wi
|
||||
|
||||
# Megaherz combo cards
|
||||
device mhzc { }
|
||||
attach mhzc at pcmcia
|
||||
attach com at mhzc with com_mhzc
|
||||
attach sm at mhzc with sm_mhzc
|
||||
file dev/pcmcia/mhzc.c mhzc | com_mhzc | sm_mhzc
|
||||
needs-flag
|
||||
|
|
|
@ -0,0 +1,848 @@
|
|||
/* $NetBSD: mhzc.c,v 1.1 1999/09/28 17:58:55 thorpej Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1999 The NetBSD Foundation, Inc.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to The NetBSD Foundation
|
||||
* by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
|
||||
* NASA Ames Research Center.
|
||||
*
|
||||
* 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 the NetBSD
|
||||
* Foundation, Inc. and its contributors.
|
||||
* 4. Neither the name of The NetBSD Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 THE FOUNDATION OR CONTRIBUTORS
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Device driver for the Megaherz X-JACK Ethernet/Modem combo cards.
|
||||
*
|
||||
* Many thanks to Chuck Cranor for having the patience to sift through
|
||||
* the Linux smc91c92_cs.c driver to find the magic details to get this
|
||||
* working!
|
||||
*/
|
||||
|
||||
#include "opt_inet.h"
|
||||
#include "opt_ns.h"
|
||||
#include "bpfilter.h"
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/mbuf.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/errno.h>
|
||||
#include <sys/syslog.h>
|
||||
#include <sys/select.h>
|
||||
#include <sys/tty.h>
|
||||
#include <sys/device.h>
|
||||
|
||||
#include <net/if.h>
|
||||
#include <net/if_dl.h>
|
||||
#include <net/if_ether.h>
|
||||
#include <net/if_media.h>
|
||||
|
||||
#ifdef INET
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/in_systm.h>
|
||||
#include <netinet/in_var.h>
|
||||
#include <netinet/ip.h>
|
||||
#include <netinet/if_inarp.h>
|
||||
#endif
|
||||
|
||||
#ifdef NS
|
||||
#include <netns/ns.h>
|
||||
#include <netns/ns_if.h>
|
||||
#endif
|
||||
|
||||
#if NBPFILTER > 0
|
||||
#include <net/bpf.h>
|
||||
#include <net/bpfdesc.h>
|
||||
#endif
|
||||
|
||||
#include <machine/intr.h>
|
||||
#include <machine/bus.h>
|
||||
|
||||
#include <dev/ic/comreg.h>
|
||||
#include <dev/ic/comvar.h>
|
||||
|
||||
#include <dev/ic/smc91cxxreg.h>
|
||||
#include <dev/ic/smc91cxxvar.h>
|
||||
|
||||
#include <dev/pcmcia/pcmciareg.h>
|
||||
#include <dev/pcmcia/pcmciavar.h>
|
||||
#include <dev/pcmcia/pcmciadevs.h>
|
||||
|
||||
#include "mhzc.h"
|
||||
|
||||
struct mhzc_softc {
|
||||
struct device sc_dev; /* generic device glue */
|
||||
|
||||
struct pcmcia_function *sc_pf; /* our PCMCIA function */
|
||||
void *sc_ih; /* interrupt handle */
|
||||
|
||||
const struct mhzc_product *sc_product;
|
||||
|
||||
/*
|
||||
* Data for the Modem portion.
|
||||
*/
|
||||
struct device *sc_modem;
|
||||
struct pcmcia_io_handle sc_modem_pcioh;
|
||||
int sc_modem_io_window;
|
||||
|
||||
/*
|
||||
* Data for the Ethernet portion.
|
||||
*/
|
||||
struct device *sc_ethernet;
|
||||
struct pcmcia_io_handle sc_ethernet_pcioh;
|
||||
int sc_ethernet_io_window;
|
||||
|
||||
int sc_flags;
|
||||
};
|
||||
|
||||
/* sc_flags */
|
||||
#define MHZC_MODEM_MAPPED 0x01
|
||||
#define MHZC_ETHERNET_MAPPED 0x02
|
||||
#define MHZC_MODEM_ENABLED 0x04
|
||||
#define MHZC_ETHERNET_ENABLED 0x08
|
||||
|
||||
int mhzc_match __P((struct device *, struct cfdata *, void *));
|
||||
void mhzc_attach __P((struct device *, struct device *, void *));
|
||||
int mhzc_detach __P((struct device *, int));
|
||||
int mhzc_activate __P((struct device *, enum devact));
|
||||
|
||||
struct cfattach mhzc_ca = {
|
||||
sizeof(struct mhzc_softc), mhzc_match, mhzc_attach,
|
||||
mhzc_detach, mhzc_activate
|
||||
};
|
||||
|
||||
int mhzc_em3336_enaddr __P((struct mhzc_softc *, u_int8_t *));
|
||||
int mhzc_em3336_enable __P((struct mhzc_softc *));
|
||||
|
||||
struct mhzc_product {
|
||||
u_int32_t mp_vendor; /* PCMCIA vendor ID */
|
||||
u_int32_t mp_product; /* PCMCIA product ID */
|
||||
int mp_expfunc; /* expected function number */
|
||||
const char *mp_name; /* device name */
|
||||
|
||||
/* Get the Ethernet address for this card. */
|
||||
int (*mp_enaddr) __P((struct mhzc_softc *, u_int8_t *));
|
||||
|
||||
/* Perform any special `enable' magic. */
|
||||
int (*mp_enable) __P((struct mhzc_softc *));
|
||||
} mhzc_products[] = {
|
||||
{ PCMCIA_VENDOR_MEGAHERTZ, PCMCIA_PRODUCT_MEGAHERTZ_XJEM3336,
|
||||
0, PCMCIA_STR_MEGAHERTZ_XJEM3336,
|
||||
mhzc_em3336_enaddr, mhzc_em3336_enable },
|
||||
|
||||
/*
|
||||
* Eventually we could add support for other Ethernet/Modem
|
||||
* combo cards, even if they're aren't Megahertz, because
|
||||
* most of them work more or less the same way.
|
||||
*/
|
||||
|
||||
{ 0, 0,
|
||||
0, NULL,
|
||||
NULL, NULL },
|
||||
};
|
||||
|
||||
int mhzc_print __P((void *, const char *));
|
||||
|
||||
int mhzc_check_cfe __P((struct mhzc_softc *, struct pcmcia_config_entry *));
|
||||
int mhzc_alloc_ethernet __P((struct mhzc_softc *));
|
||||
|
||||
int mhzc_enable __P((struct mhzc_softc *, int));
|
||||
void mhzc_disable __P((struct mhzc_softc *, int));
|
||||
|
||||
int mhzc_intr __P((void *));
|
||||
|
||||
const struct mhzc_product *mhzc_lookup __P((const struct pcmcia_attach_args *));
|
||||
|
||||
const struct mhzc_product *
|
||||
mhzc_lookup(pa)
|
||||
const struct pcmcia_attach_args *pa;
|
||||
{
|
||||
const struct mhzc_product *mp;
|
||||
|
||||
for (mp = mhzc_products; mp->mp_name != NULL; mp++) {
|
||||
if (pa->manufacturer == mp->mp_vendor &&
|
||||
pa->product == mp->mp_product &&
|
||||
pa->pf->number == mp->mp_expfunc)
|
||||
return (mp);
|
||||
}
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_match(parent, match, aux)
|
||||
struct device *parent;
|
||||
struct cfdata *match;
|
||||
void *aux;
|
||||
{
|
||||
struct pcmcia_attach_args *pa = aux;
|
||||
|
||||
if (mhzc_lookup(pa) != NULL)
|
||||
return (10); /* beat `com' */
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
void
|
||||
mhzc_attach(parent, self, aux)
|
||||
struct device *parent, *self;
|
||||
void *aux;
|
||||
{
|
||||
struct mhzc_softc *sc = (void *)self;
|
||||
struct pcmcia_attach_args *pa = aux;
|
||||
struct pcmcia_config_entry *cfe;
|
||||
|
||||
sc->sc_pf = pa->pf;
|
||||
|
||||
sc->sc_product = mhzc_lookup(pa);
|
||||
if (sc->sc_product == NULL) {
|
||||
printf("\n");
|
||||
panic("mhzc_attach: impossible");
|
||||
}
|
||||
|
||||
printf(": %s\n", sc->sc_product->mp_name);
|
||||
|
||||
/*
|
||||
* The address decoders on these cards are wacky. The configuration
|
||||
* entries are set up to look like serial ports, and have no
|
||||
* information about the Ethernet portion. In order to talk to
|
||||
* the Modem portion, the I/O address must have bit 0x80 set.
|
||||
* In order to talk to the Ethernet portion, the I/O address must
|
||||
* have the 0x80 bit clear.
|
||||
*
|
||||
* The standard configuration entries conveniently have 0x80 set
|
||||
* in them, and have a length of 8 (a 16550's size, convenient!),
|
||||
* so we use those to set up the Modem portion.
|
||||
*
|
||||
* Once we have the Modem's address established, we search for
|
||||
* an address suitable for the Ethernet portion. We do this by
|
||||
* rounding up to the next 16-byte aligned address where 0x80
|
||||
* isn't set (the SMC Ethernet chip has a 16-byte address size)
|
||||
* and attemping to allocate a 16-byte region until we succeed.
|
||||
*
|
||||
* Sure would have been nice if Megahertz had made the card a
|
||||
* proper multi-function device.
|
||||
*/
|
||||
for (cfe = SIMPLEQ_FIRST(&pa->pf->cfe_head); cfe != NULL;
|
||||
cfe = SIMPLEQ_NEXT(cfe, cfe_list)) {
|
||||
if (mhzc_check_cfe(sc, cfe)) {
|
||||
/* Found one! */
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (cfe == NULL) {
|
||||
printf("%s: unable to find suitable config table entry\n",
|
||||
sc->sc_dev.dv_xname);
|
||||
return;
|
||||
}
|
||||
|
||||
if (mhzc_alloc_ethernet(sc) == 0) {
|
||||
printf("%s: unable to allocate space for Ethernet portion\n",
|
||||
sc->sc_dev.dv_xname);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Enable the card. */
|
||||
pcmcia_function_init(pa->pf, cfe);
|
||||
if (pcmcia_function_enable(pa->pf)) {
|
||||
printf(": function enable failed\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (sc->sc_product->mp_enable != NULL)
|
||||
(*sc->sc_product->mp_enable)(sc);
|
||||
|
||||
sc->sc_modem = config_found(&sc->sc_dev, "com", mhzc_print);
|
||||
sc->sc_ethernet = config_found(&sc->sc_dev, "sm", mhzc_print);
|
||||
|
||||
pcmcia_function_disable(pa->pf);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_check_cfe(sc, cfe)
|
||||
struct mhzc_softc *sc;
|
||||
struct pcmcia_config_entry *cfe;
|
||||
{
|
||||
|
||||
if (cfe->num_memspace != 0)
|
||||
return (0);
|
||||
|
||||
if (cfe->num_iospace != 1)
|
||||
return (0);
|
||||
|
||||
if (pcmcia_io_alloc(sc->sc_pf,
|
||||
cfe->iospace[0].start,
|
||||
cfe->iospace[0].length,
|
||||
cfe->iospace[0].length,
|
||||
&sc->sc_modem_pcioh) == 0) {
|
||||
/* Found one for the modem! */
|
||||
return (1);
|
||||
}
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_alloc_ethernet(sc)
|
||||
struct mhzc_softc *sc;
|
||||
{
|
||||
bus_addr_t addr, maxaddr;
|
||||
|
||||
maxaddr = sc->sc_pf->sc->iobase + sc->sc_pf->sc->iosize;
|
||||
|
||||
/*
|
||||
* Start with the first address past the Modem.
|
||||
*/
|
||||
addr = sc->sc_modem_pcioh.addr + sc->sc_modem_pcioh.size;
|
||||
|
||||
/*
|
||||
* Now round it up so that it starts on a 16-byte boundary.
|
||||
*/
|
||||
addr = roundup(addr, 0x10);
|
||||
|
||||
for (; (addr + 0x10) < maxaddr; addr += 0x10) {
|
||||
if (addr & 0x80)
|
||||
continue;
|
||||
if (pcmcia_io_alloc(sc->sc_pf, addr, 0x10, 0x10,
|
||||
&sc->sc_ethernet_pcioh) == 0) {
|
||||
/* Found one for the ethernet! */
|
||||
return (1);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Weren't able to allocate space for the Ethernet, so we
|
||||
* free the Modem's I/O space.
|
||||
*/
|
||||
pcmcia_io_free(sc->sc_pf, &sc->sc_modem_pcioh);
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_print(aux, pnp)
|
||||
void *aux;
|
||||
const char *pnp;
|
||||
{
|
||||
const char *name = aux;
|
||||
|
||||
if (pnp)
|
||||
printf("%s at %s", name, pnp);
|
||||
|
||||
return (UNCONF);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_detach(self, flags)
|
||||
struct device *self;
|
||||
int flags;
|
||||
{
|
||||
struct mhzc_softc *sc = (void *)self;
|
||||
int rv;
|
||||
|
||||
if (sc->sc_ethernet != NULL) {
|
||||
rv = config_detach(sc->sc_ethernet, flags);
|
||||
if (rv != 0)
|
||||
return (rv);
|
||||
}
|
||||
|
||||
if (sc->sc_modem != NULL) {
|
||||
rv = config_detach(sc->sc_modem, flags);
|
||||
if (rv != 0)
|
||||
return (rv);
|
||||
}
|
||||
|
||||
/* Unmap our i/o windows. */
|
||||
if (sc->sc_flags & MHZC_MODEM_MAPPED)
|
||||
pcmcia_io_unmap(sc->sc_pf, sc->sc_modem_io_window);
|
||||
if (sc->sc_flags & MHZC_ETHERNET_MAPPED)
|
||||
pcmcia_io_unmap(sc->sc_pf, sc->sc_ethernet_io_window);
|
||||
|
||||
/* Free our i/o spaces. */
|
||||
pcmcia_io_free(sc->sc_pf, &sc->sc_modem_pcioh);
|
||||
pcmcia_io_free(sc->sc_pf, &sc->sc_ethernet_pcioh);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_activate(self, act)
|
||||
struct device *self;
|
||||
enum devact act;
|
||||
{
|
||||
struct mhzc_softc *sc = (void *)self;
|
||||
int s, rv = 0;
|
||||
|
||||
s = splhigh();
|
||||
switch (act) {
|
||||
case DVACT_ACTIVATE:
|
||||
rv = EOPNOTSUPP;
|
||||
break;
|
||||
|
||||
case DVACT_DEACTIVATE:
|
||||
if (sc->sc_ethernet != NULL) {
|
||||
rv = config_deactivate(sc->sc_ethernet);
|
||||
if (rv != 0)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (sc->sc_modem != NULL) {
|
||||
rv = config_deactivate(sc->sc_modem);
|
||||
if (rv != 0)
|
||||
goto out;
|
||||
}
|
||||
break;
|
||||
}
|
||||
out:
|
||||
splx(s);
|
||||
return (rv);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_intr(arg)
|
||||
void *arg;
|
||||
{
|
||||
struct mhzc_softc *sc = arg;
|
||||
int rval = 0;
|
||||
|
||||
#if NCOM_MHZC > 0
|
||||
if (sc->sc_modem != NULL &&
|
||||
(sc->sc_flags & MHZC_MODEM_ENABLED) != 0)
|
||||
rval |= comintr(sc->sc_modem);
|
||||
#endif
|
||||
|
||||
#if NSM_MHZC > 0
|
||||
if (sc->sc_ethernet != NULL &&
|
||||
(sc->sc_flags & MHZC_ETHERNET_ENABLED) != 0)
|
||||
rval |= smc91cxx_intr(sc->sc_ethernet);
|
||||
#endif
|
||||
|
||||
return (rval);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_enable(sc, flag)
|
||||
struct mhzc_softc *sc;
|
||||
int flag;
|
||||
{
|
||||
|
||||
if (sc->sc_flags & flag) {
|
||||
printf("%s: %s already enabled\n", sc->sc_dev.dv_xname,
|
||||
(flag & MHZC_MODEM_ENABLED) ? "modem" : "ethernet");
|
||||
panic("mhzc_enable");
|
||||
}
|
||||
|
||||
if ((sc->sc_flags & (MHZC_MODEM_ENABLED|MHZC_ETHERNET_ENABLED)) != 0) {
|
||||
sc->sc_flags |= flag;
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Perform any special enable magic necessary.
|
||||
*/
|
||||
if (sc->sc_product->mp_enable != NULL &&
|
||||
(*sc->sc_product->mp_enable)(sc) != 0)
|
||||
return (1);
|
||||
|
||||
/*
|
||||
* Establish our interrupt handler.
|
||||
*
|
||||
* XXX Note, we establish this at IPL_NET. This is suboptimal
|
||||
* XXX the Modem portion, but is necessary to make the Ethernet
|
||||
* XXX portion have the correct interrupt level semantics.
|
||||
*
|
||||
* XXX Eventually we should use the `enabled' bits in the
|
||||
* XXX flags word to determine which level we should be at.
|
||||
*/
|
||||
sc->sc_ih = pcmcia_intr_establish(sc->sc_pf, IPL_NET,
|
||||
mhzc_intr, sc);
|
||||
if (sc->sc_ih == NULL) {
|
||||
printf("%s: unable to establish interrupt\n",
|
||||
sc->sc_dev.dv_xname);
|
||||
return (1);
|
||||
}
|
||||
|
||||
if (pcmcia_function_enable(sc->sc_pf)) {
|
||||
pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
|
||||
return (1);
|
||||
}
|
||||
|
||||
sc->sc_flags |= flag;
|
||||
return (0);
|
||||
}
|
||||
|
||||
void
|
||||
mhzc_disable(sc, flag)
|
||||
struct mhzc_softc *sc;
|
||||
int flag;
|
||||
{
|
||||
|
||||
if ((sc->sc_flags & flag) == 0) {
|
||||
printf("%s: %s already disabled\n", sc->sc_dev.dv_xname,
|
||||
(flag & MHZC_MODEM_ENABLED) ? "modem" : "ethernet");
|
||||
panic("mhzc_disable");
|
||||
}
|
||||
|
||||
sc->sc_flags &= ~flag;
|
||||
if ((sc->sc_flags & (MHZC_MODEM_ENABLED|MHZC_ETHERNET_ENABLED)) != 0)
|
||||
return;
|
||||
|
||||
pcmcia_intr_disestablish(sc->sc_pf, sc->sc_ih);
|
||||
pcmcia_function_disable(sc->sc_pf);
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
* Megahertz EM3336 (and compatibles) support
|
||||
*****************************************************************************/
|
||||
|
||||
int mhzc_em3336_lannid_ciscallback __P((struct pcmcia_tuple *, void *));
|
||||
int mhzc_em3336_ascii_enaddr __P((const char *cisstr, u_int8_t *));
|
||||
|
||||
int
|
||||
mhzc_em3336_enaddr(sc, myla)
|
||||
struct mhzc_softc *sc;
|
||||
u_int8_t *myla;
|
||||
{
|
||||
|
||||
/* Get the station address from CIS tuple 0x81. */
|
||||
if (pcmcia_scan_cis(sc->sc_dev.dv_parent,
|
||||
mhzc_em3336_lannid_ciscallback, myla) != 1) {
|
||||
printf("%s: unable to get Ethernet address from CIS\n",
|
||||
sc->sc_dev.dv_xname);
|
||||
return (0);
|
||||
}
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_em3336_enable(sc)
|
||||
struct mhzc_softc *sc;
|
||||
{
|
||||
struct pcmcia_mem_handle memh;
|
||||
bus_addr_t memoff;
|
||||
int memwin, reg;
|
||||
|
||||
/*
|
||||
* Bring the chip to live by touching its registers in the correct
|
||||
* way (as per my reference... the Linux smc91c92_cs.c driver by
|
||||
* David A. Hinds).
|
||||
*/
|
||||
|
||||
/* Map the ISRPOWEREG. */
|
||||
if (pcmcia_mem_alloc(sc->sc_pf, 0x1000, &memh) != 0) {
|
||||
printf("%s: unable to allocate memory space\n",
|
||||
sc->sc_dev.dv_xname);
|
||||
return (1);
|
||||
}
|
||||
|
||||
if (pcmcia_mem_map(sc->sc_pf, PCMCIA_MEM_ATTR, 0, 0x1000,
|
||||
&memh, &memoff, &memwin)) {
|
||||
printf("%s: unable to map memory space\n",
|
||||
sc->sc_dev.dv_xname);
|
||||
pcmcia_mem_free(sc->sc_pf, &memh);
|
||||
return (1);
|
||||
}
|
||||
|
||||
/*
|
||||
* The magic sequence:
|
||||
*
|
||||
* - read/write the CCR option register.
|
||||
* - read the ISRPOWEREG 2 times.
|
||||
* - read/write the CCR option register again.
|
||||
*/
|
||||
|
||||
reg = pcmcia_ccr_read(sc->sc_pf, PCMCIA_CCR_OPTION);
|
||||
pcmcia_ccr_write(sc->sc_pf, PCMCIA_CCR_OPTION, reg);
|
||||
|
||||
reg = bus_space_read_1(memh.memt, memh.memh, 0x380);
|
||||
delay(5);
|
||||
reg = bus_space_read_1(memh.memt, memh.memh, 0x380);
|
||||
|
||||
delay(200000);
|
||||
|
||||
reg = pcmcia_ccr_read(sc->sc_pf, PCMCIA_CCR_OPTION);
|
||||
delay(5);
|
||||
pcmcia_ccr_write(sc->sc_pf, PCMCIA_CCR_OPTION, reg);
|
||||
|
||||
pcmcia_mem_unmap(sc->sc_pf, memwin);
|
||||
pcmcia_mem_free(sc->sc_pf, &memh);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
int
|
||||
mhzc_em3336_lannid_ciscallback(tuple, arg)
|
||||
struct pcmcia_tuple *tuple;
|
||||
void *arg;
|
||||
{
|
||||
u_int8_t *myla = arg, addr_str[ETHER_ADDR_LEN * 2];
|
||||
int i;
|
||||
|
||||
if (tuple->code == 0x81) {
|
||||
/*
|
||||
* We have a string-encoded address. Length includes
|
||||
* terminating 0xff.
|
||||
*/
|
||||
if (tuple->length != (ETHER_ADDR_LEN * 2) + 1)
|
||||
return (0);
|
||||
|
||||
for (i = 0; i < tuple->length - 1; i++)
|
||||
addr_str[i] = pcmcia_tuple_read_1(tuple, i);
|
||||
|
||||
/*
|
||||
* Decode the string into `myla'.
|
||||
*/
|
||||
return (mhzc_em3336_ascii_enaddr(addr_str, myla));
|
||||
}
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* XXX This should be shared w/ if_sm_pcmcia.c */
|
||||
int
|
||||
mhzc_em3336_ascii_enaddr(cisstr, myla)
|
||||
const char *cisstr;
|
||||
u_int8_t *myla;
|
||||
{
|
||||
u_int8_t digit;
|
||||
int i;
|
||||
|
||||
memset(myla, 0, ETHER_ADDR_LEN);
|
||||
|
||||
for (i = 0, digit = 0; i < (ETHER_ADDR_LEN * 2); i++) {
|
||||
if (cisstr[i] >= '0' && cisstr[i] <= '9')
|
||||
digit |= cisstr[i] - '0';
|
||||
else if (cisstr[i] >= 'a' && cisstr[i] <= 'f')
|
||||
digit |= (cisstr[i] - 'a') + 10;
|
||||
else if (cisstr[i] >= 'A' && cisstr[i] <= 'F')
|
||||
digit |= (cisstr[i] - 'A') + 10;
|
||||
else {
|
||||
/* Bogus digit!! */
|
||||
return (0);
|
||||
}
|
||||
|
||||
/* Compensate for ordering of digits. */
|
||||
if (i & 1) {
|
||||
myla[i >> 1] = digit;
|
||||
digit = 0;
|
||||
} else
|
||||
digit <<= 4;
|
||||
}
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
||||
/****** Here begins the com attachment code. ******/
|
||||
|
||||
#if NCOM_MHZC > 0
|
||||
int com_mhzc_match __P((struct device *, struct cfdata *, void *));
|
||||
void com_mhzc_attach __P((struct device *, struct device *, void *));
|
||||
|
||||
/* No mhzc-specific goo in the softc; it's all in the parent. */
|
||||
struct cfattach com_mhzc_ca = {
|
||||
sizeof(struct com_softc), com_mhzc_match, com_mhzc_attach,
|
||||
com_detach, com_activate
|
||||
};
|
||||
|
||||
int com_mhzc_enable __P((struct com_softc *));
|
||||
void com_mhzc_disable __P((struct com_softc *));
|
||||
|
||||
int
|
||||
com_mhzc_match(parent, match, aux)
|
||||
struct device *parent;
|
||||
struct cfdata *match;
|
||||
void *aux;
|
||||
{
|
||||
extern struct cfdriver com_cd;
|
||||
const char *name = aux;
|
||||
|
||||
/* Device is always present. */
|
||||
if (strcmp(name, com_cd.cd_name) == 0)
|
||||
return (1);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
void
|
||||
com_mhzc_attach(parent, self, aux)
|
||||
struct device *parent, *self;
|
||||
void *aux;
|
||||
{
|
||||
struct com_softc *sc = (void *)self;
|
||||
struct mhzc_softc *msc = (void *)parent;
|
||||
|
||||
printf(":");
|
||||
if (pcmcia_io_map(msc->sc_pf, PCMCIA_WIDTH_IO8, 0,
|
||||
msc->sc_modem_pcioh.size, &msc->sc_modem_pcioh,
|
||||
&msc->sc_modem_io_window)) {
|
||||
printf("unable to map I/O space\n");
|
||||
return;
|
||||
}
|
||||
|
||||
msc->sc_flags |= MHZC_MODEM_MAPPED;
|
||||
|
||||
sc->sc_iot = msc->sc_modem_pcioh.iot;
|
||||
sc->sc_ioh = msc->sc_modem_pcioh.ioh;
|
||||
|
||||
sc->enabled = 1;
|
||||
|
||||
sc->sc_iobase = -1;
|
||||
sc->sc_frequency = COM_FREQ;
|
||||
|
||||
sc->enable = com_mhzc_enable;
|
||||
sc->disable = com_mhzc_disable;
|
||||
|
||||
com_attach_subr(sc);
|
||||
|
||||
sc->enabled = 0;
|
||||
}
|
||||
|
||||
int
|
||||
com_mhzc_enable(sc)
|
||||
struct com_softc *sc;
|
||||
{
|
||||
|
||||
return (mhzc_enable((struct mhzc_softc *)sc->sc_dev.dv_parent,
|
||||
MHZC_MODEM_ENABLED));
|
||||
}
|
||||
|
||||
void
|
||||
com_mhzc_disable(sc)
|
||||
struct com_softc *sc;
|
||||
{
|
||||
|
||||
mhzc_disable((struct mhzc_softc *)sc->sc_dev.dv_parent,
|
||||
MHZC_MODEM_ENABLED);
|
||||
}
|
||||
|
||||
#endif /* NCOM_MHZC > 0 */
|
||||
|
||||
/****** Here begins the sm attachment code. ******/
|
||||
|
||||
#if NSM_MHZC > 0
|
||||
int sm_mhzc_match __P((struct device *, struct cfdata *, void *));
|
||||
void sm_mhzc_attach __P((struct device *, struct device *, void *));
|
||||
int sm_mhzc_detach __P((struct device *, int));
|
||||
|
||||
/* No mhzc-specific goo in the softc; it's all in the parent. */
|
||||
struct cfattach sm_mhzc_ca = {
|
||||
sizeof(struct smc91cxx_softc), sm_mhzc_match, sm_mhzc_attach,
|
||||
sm_mhzc_detach, smc91cxx_activate
|
||||
};
|
||||
|
||||
int sm_mhzc_enable __P((struct smc91cxx_softc *));
|
||||
void sm_mhzc_disable __P((struct smc91cxx_softc *));
|
||||
|
||||
int
|
||||
sm_mhzc_match(parent, match, aux)
|
||||
struct device *parent;
|
||||
struct cfdata *match;
|
||||
void *aux;
|
||||
{
|
||||
extern struct cfdriver sm_cd;
|
||||
const char *name = aux;
|
||||
|
||||
/* Device is always present. */
|
||||
if (strcmp(name, sm_cd.cd_name) == 0)
|
||||
return (1);
|
||||
|
||||
return (0);
|
||||
}
|
||||
|
||||
void
|
||||
sm_mhzc_attach(parent, self, aux)
|
||||
struct device *parent, *self;
|
||||
void *aux;
|
||||
{
|
||||
struct smc91cxx_softc *sc = (void *)self;
|
||||
struct mhzc_softc *msc = (void *)parent;
|
||||
u_int8_t myla[ETHER_ADDR_LEN];
|
||||
|
||||
printf(":");
|
||||
if (pcmcia_io_map(msc->sc_pf, PCMCIA_WIDTH_IO16, 0,
|
||||
msc->sc_ethernet_pcioh.size, &msc->sc_ethernet_pcioh,
|
||||
&msc->sc_ethernet_io_window)) {
|
||||
printf("unable to map I/O space\n");
|
||||
return;
|
||||
}
|
||||
printf("\n");
|
||||
|
||||
msc->sc_flags |= MHZC_ETHERNET_MAPPED;
|
||||
|
||||
sc->sc_bst = msc->sc_ethernet_pcioh.iot;
|
||||
sc->sc_bsh = msc->sc_ethernet_pcioh.ioh;
|
||||
|
||||
sc->sc_enable = sm_mhzc_enable;
|
||||
sc->sc_disable = sm_mhzc_disable;
|
||||
|
||||
if ((*msc->sc_product->mp_enaddr)(msc, myla) != 1)
|
||||
return;
|
||||
|
||||
/* Perform generic initialization. */
|
||||
smc91cxx_attach(sc, myla);
|
||||
}
|
||||
|
||||
int
|
||||
sm_mhzc_detach(self, flags)
|
||||
struct device *self;
|
||||
int flags;
|
||||
{
|
||||
#ifdef notyet
|
||||
struct smc91cxx_softc *sc = (void *)self;
|
||||
|
||||
/*
|
||||
* Our softc is about to go away, so drop our reference
|
||||
* to the ifnet.
|
||||
*/
|
||||
if_delref(sc->sc_ec.ec_if);
|
||||
return (0);
|
||||
#else
|
||||
return (EBUSY);
|
||||
#endif
|
||||
}
|
||||
|
||||
int
|
||||
sm_mhzc_enable(sc)
|
||||
struct smc91cxx_softc *sc;
|
||||
{
|
||||
|
||||
return (mhzc_enable((struct mhzc_softc *)sc->sc_dev.dv_parent,
|
||||
MHZC_ETHERNET_ENABLED));
|
||||
}
|
||||
|
||||
void
|
||||
sm_mhzc_disable(sc)
|
||||
struct smc91cxx_softc *sc;
|
||||
{
|
||||
|
||||
mhzc_disable((struct mhzc_softc *)sc->sc_dev.dv_parent,
|
||||
MHZC_ETHERNET_ENABLED);
|
||||
}
|
||||
|
||||
#endif /* NSM_MHZC > 0 */
|
Loading…
Reference in New Issue