/********************************************************************* * * Filename: netwave_cs.c * Version: 0.4.1 * Description: Netwave AirSurfer Wireless LAN PC Card driver * Status: Experimental. * Authors: John Markus Bjørndalen * Dag Brattli * David Hinds * Created at: A long time ago! * Modified at: Mon Nov 10 11:54:37 1997 * Modified by: Dag Brattli * * Copyright (c) 1997 University of Tromsø, Norway * * Revision History: * * 08-Nov-97 15:14:47 John Markus Bjørndalen * - Fixed some bugs in netwave_rx and cleaned it up a bit. * (One of the bugs would have destroyed packets when receiving * multiple packets per interrupt). * - Cleaned up parts of newave_hw_xmit. * - A few general cleanups. * 24-Oct-97 13:17:36 Dag Brattli * - Fixed netwave_rx receive function (got updated docs) * Others: * - Changed name from xircnw to netwave, take a look at * http://www.netwave-wireless.com * - Some reorganizing of the code * - Removed possible race condition between interrupt handler and transmit * function * - Started to add wireless extensions, but still needs some coding * - Added watchdog for better handling of transmission timeouts * (hopefully this works better) ********************************************************************/ /* To have statistics (just packets sent) define this */ #undef NETWAVE_STATS #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef HAS_WIRELESS_EXTENSIONS #include #endif #include #include #include #include #include #include #include #define NETWAVE_REGOFF 0x8000 /* The Netwave IO registers, offsets to iobase */ #define NETWAVE_REG_COR 0x0 #define NETWAVE_REG_CCSR 0x2 #define NETWAVE_REG_ASR 0x4 #define NETWAVE_REG_IMR 0xa #define NETWAVE_REG_PMR 0xc #define NETWAVE_REG_IOLOW 0x6 #define NETWAVE_REG_IOHI 0x7 #define NETWAVE_REG_IOCONTROL 0x8 #define NETWAVE_REG_DATA 0xf /* The Netwave Extended IO registers, offsets to RamBase */ #define NETWAVE_EREG_ASCC 0x114 #define NETWAVE_EREG_RSER 0x120 #define NETWAVE_EREG_RSERW 0x124 #define NETWAVE_EREG_TSER 0x130 #define NETWAVE_EREG_TSERW 0x134 #define NETWAVE_EREG_CB 0x100 #define NETWAVE_EREG_SPCQ 0x154 #define NETWAVE_EREG_SPU 0x155 #define NETWAVE_EREG_LIF 0x14e #define NETWAVE_EREG_ISPLQ 0x156 #define NETWAVE_EREG_HHC 0x158 #define NETWAVE_EREG_NI 0x16e #define NETWAVE_EREG_MHS 0x16b #define NETWAVE_EREG_TDP 0x140 #define NETWAVE_EREG_RDP 0x150 #define NETWAVE_EREG_PA 0x160 #define NETWAVE_EREG_EC 0x180 #define NETWAVE_EREG_CRBP 0x17a #define NETWAVE_EREG_ARW 0x166 /* * Commands used in the extended command buffer * NETWAVE_EREG_CB (0x100-0x10F) */ #define NETWAVE_CMD_NOP 0x00 #define NETWAVE_CMD_SRC 0x01 #define NETWAVE_CMD_STC 0x02 #define NETWAVE_CMD_AMA 0x03 #define NETWAVE_CMD_DMA 0x04 #define NETWAVE_CMD_SAMA 0x05 #define NETWAVE_CMD_ER 0x06 #define NETWAVE_CMD_DR 0x07 #define NETWAVE_CMD_TL 0x08 #define NETWAVE_CMD_SRP 0x09 #define NETWAVE_CMD_SSK 0x0a #define NETWAVE_CMD_SMD 0x0b #define NETWAVE_CMD_SAPD 0x0c #define NETWAVE_CMD_SSS 0x11 /* End of Command marker */ #define NETWAVE_CMD_EOC 0x00 /* ASR register bits */ #define NETWAVE_ASR_RXRDY 0x80 #define NETWAVE_ASR_TXBA 0x01 #define TX_TIMEOUT 20 #define WATCHDOG_JIFFIES 32 static const unsigned int imrConfRFU1 = 0x10; /* RFU interrupt mask, keep high */ static const unsigned int imrConfIENA = 0x02; /* Interrupt enable */ static const unsigned int corConfIENA = 0x01; /* Interrupt enable */ static const unsigned int corConfLVLREQ = 0x40; /* Keep high */ static const unsigned int rxConfRxEna = 0x80; /* Receive Enable */ static const unsigned int rxConfMAC = 0x20; /* MAC host receive mode*/ static const unsigned int rxConfPro = 0x10; /* Promiscuous */ static const unsigned int rxConfAMP = 0x08; /* Accept Multicast Packets */ static const unsigned int rxConfBcast = 0x04; /* Accept Broadcast Packets */ static const unsigned int txConfTxEna = 0x80; /* Transmit Enable */ static const unsigned int txConfMAC = 0x20; /* Host sends MAC mode */ static const unsigned int txConfEUD = 0x10; /* Enable Uni-Data packets */ static const unsigned int txConfKey = 0x02; /* Scramble data packets */ static const unsigned int txConfLoop = 0x01; /* Loopback mode */ /*static int netwave_debug = 0;*/ /* All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If you do not define PCMCIA_DEBUG at all, all the debug code will be left out. If you compile with PCMCIA_DEBUG=0, the debug code will be present but disabled -- but it can then be enabled for specific modules at load time with a 'pc_debug=#' option to insmod. */ #ifdef PCMCIA_DEBUG static int pc_debug = PCMCIA_DEBUG; MODULE_PARM(pc_debug, "i"); #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args) static char *version = "netwave_cs.c 0.3.0 Thu Jul 17 14:36:02 1997 (John Markus Bjørndalen)\n"; #else #define DEBUG(n, args...) #endif static dev_info_t dev_info = "netwave_cs"; /*====================================================================*/ /* Parameters that can be set with 'insmod' */ /* Choose the domain, default is 0x100 */ static u_int domain = 0x100; /* Scramble key, range from 0x0 to 0xffff. * 0x0 is no scrambling. */ static u_int scramble_key = 0x0; /* Shared memory speed, in ns. The documentation states that * the card should not be read faster than every 400ns. * This timing should be provided by the HBA. If it becomes a * problem, try setting mem_speed to 400. */ static int mem_speed = 0; /* Bit map of interrupts to choose from */ /* This means pick from 15, 14, 12, 11, 10, 9, 7, 5, 4, and 3 */ static u_int irq_mask = 0xdeb8; static int irq_list[4] = { -1 }; MODULE_PARM(domain, "i"); MODULE_PARM(scramble_key, "i"); MODULE_PARM(mem_speed, "i"); MODULE_PARM(irq_mask, "i"); MODULE_PARM(irq_list, "1-4i"); /*====================================================================*/ /* PCMCIA (Card Services) related functions */ static void netwave_release(u_long arg); /* Card removal */ static int netwave_event(event_t event, int priority, event_callback_args_t *args); static void netwave_pcmcia_config(dev_link_t *arg); /* Runs after card insertion */ static dev_link_t *netwave_attach(void); /* Create instance */ static void netwave_detach(dev_link_t *); /* Destroy instance */ static void netwave_flush_stale_links(void); /* Destroy all staled instances */ /* Hardware configuration */ static void netwave_doreset(unsigned long iobase, u_char* ramBase); static void netwave_reset(struct device *dev); /* Misc device stuff */ static int netwave_open(struct device *dev); /* Open the device */ static int netwave_close(struct device *dev); /* Close the device */ static int netwave_config(struct device *dev, struct ifmap *map); /* Packet transmission and Packet reception */ static int netwave_start_xmit( struct sk_buff *skb, struct device *dev); static int netwave_rx( struct device *dev); /* Interrupt routines */ static void netwave_interrupt IRQ(int irq, void *dev_id, struct pt_regs *regs); static void netwave_watchdog(u_long); /* Transmission watchdog */ /* Statistics */ static void update_stats(struct device *dev); static struct enet_statistics *netwave_get_stats(struct device *dev); /* Wireless extensions */ #ifdef WIRELESS_EXT static struct iw_statistics* netwave_get_wireless_stats(struct device *dev); #endif static int netwave_ioctl(struct device *, struct ifreq *, int); static void set_multicast_list(struct device *dev); /* A linked list of "instances" of the skeleton device. Each actual PCMCIA card corresponds to one device instance, and is described by one dev_link_t structure (defined in ds.h). You may not want to use a linked list for this -- for example, the memory card driver uses an array of dev_link_t pointers, where minor device numbers are used to derive the corresponding array index. */ static dev_link_t *dev_list = NULL; /* A dev_link_t structure has fields for most things that are needed to keep track of a socket, but there will usually be some device specific information that also needs to be kept track of. The 'priv' pointer in a dev_link_t structure can be used to point to a device-specific private data structure, like this. A driver needs to provide a dev_node_t structure for each device on a card. In some cases, there is only one device per card (for example, ethernet cards, modems). In other cases, there may be many actual or logical devices (SCSI adapters, memory cards with multiple partitions). The dev_node_t structures need to be kept in a linked list starting at the 'dev' field of a dev_link_t structure. We allocate them in the card's private data structure, because they generally can't be allocated dynamically. */ #define SIOCGIPSNAP SIOCDEVPRIVATE /* Site Survey Snapshot */ /*#define SIOCGIPQTHR SIOCDEVPRIVATE + 1*/ #define MAX_ESA 10 typedef struct net_addr { u_char addr48[6]; } net_addr; struct site_survey { u_short length; u_char struct_revision; u_char roaming_state; u_char sp_existsFlag; u_char sp_link_quality; u_char sp_max_link_quality; u_char linkQualityGoodFairBoundary; u_char linkQualityFairPoorBoundary; u_char sp_utilization; u_char sp_goodness; u_char sp_hotheadcount; u_char roaming_condition; net_addr sp; u_char numAPs; net_addr nearByAccessPoints[MAX_ESA]; }; typedef struct netwave_private { dev_node_t node; u_char *ramBase; int timeoutCounter; int lastExec; struct timer_list watchdog; /* To avoid blocking state */ struct site_survey nss; struct enet_statistics stats; #ifdef WIRELESS_EXT struct iw_statistics iw_stats; /* Wireless stats */ #endif } netwave_private; #ifdef NETWAVE_STATS static struct enet_statistics *netwave_get_stats(struct device *dev); #endif /* * The Netwave card is little-endian, so won't work for big endian * systems. */ static inline unsigned short get_uint16(u_char* staddr) { return readw(staddr); /* Return only 16 bits */ } static inline short get_int16(u_char* staddr) { return readw(staddr); } /**************************************************************************/ static void cs_error(client_handle_t handle, int func, int ret) { error_info_t err = { func, ret }; CardServices(ReportError, handle, &err); } /* * Wait until the WOC (Write Operation Complete) bit in the * ASR (Adapter Status Register) is asserted. * This should have aborted if it takes too long time. */ static inline void wait_WOC(unsigned int iobase) { /* Spin lock */ while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ; } #ifdef WIRELESS_EXT static void netwave_snapshot(netwave_private *priv, u_char *ramBase, unsigned short iobase) { u_short resultBuffer; /* if time since last snapshot is > 1 sec. (100 jiffies?) then take * new snapshot, else return cached data. This is the recommended rate. */ if ( jiffies - priv->lastExec > 100) { /* Take site survey snapshot */ /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies - priv->lastExec); */ wait_WOC(iobase); writeb(NETWAVE_CMD_SSS, ramBase + NETWAVE_EREG_CB + 0); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); wait_WOC(iobase); /* Get result and copy to cach */ resultBuffer = readw(ramBase + NETWAVE_EREG_CRBP); copy_from_pc( &priv->nss, ramBase+resultBuffer, sizeof(struct site_survey)); } } #endif #ifdef WIRELESS_EXT /* * Function netwave_get_wireless_stats (dev) * * Wireless extensions statistics * */ static struct iw_statistics *netwave_get_wireless_stats(struct device *dev) { unsigned long flags; unsigned short iobase = dev->base_addr; netwave_private *priv = (netwave_private *) dev->priv; u_char *ramBase = priv->ramBase; struct iw_statistics* wstats; wstats = &priv->iw_stats; save_flags(flags); cli(); netwave_snapshot( priv, ramBase, iobase); wstats->status = priv->nss.roaming_state; wstats->qual.qual = readb( ramBase + NETWAVE_EREG_SPCQ); wstats->qual.level = readb( ramBase + NETWAVE_EREG_ISPLQ); wstats->qual.noise = readb( ramBase + NETWAVE_EREG_SPU) & 0x3f; wstats->discard.nwid = 0L; wstats->discard.code = 0L; wstats->discard.misc = 0L; restore_flags(flags); return &priv->iw_stats; } #endif /* * Function netwave_init (dev) * * We never need to do anything when a device is "initialized" * by the net software, because we only register already-found cards. */ int netwave_init(struct device *dev) { /* We do all the initialization of this in netwave_attach instead */ return 0; } /* * Function netwave_attach (void) * * Creates an "instance" of the driver, allocating local data * structures for one device. The device is registered with Card * Services. * * The dev_link structure is initialized, but we don't actually * configure the card at this point -- we wait until we receive a * card insertion event. */ static dev_link_t *netwave_attach(void) { client_reg_t client_reg; dev_link_t *link; struct device *dev; netwave_private *priv; int i, ret; DEBUG(0, "netwave_attach()\n"); /* Perform some cleanup */ netwave_flush_stale_links(); /* Initialize the dev_link_t structure */ link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); memset(link, 0, sizeof(struct dev_link_t)); link->release.function = &netwave_release; link->release.data = (u_long)link; /* The io structure describes IO port mapping */ link->io.NumPorts1 = 16; link->io.Attributes1 = IO_DATA_PATH_WIDTH_16; /* link->io.NumPorts2 = 16; link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */ link->io.IOAddrLines = 5; /* Interrupt setup */ link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT; link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID; if (irq_list[0] == -1) link->irq.IRQInfo2 = irq_mask; else for (i = 0; i < 4; i++) link->irq.IRQInfo2 |= 1 << irq_list[i]; link->irq.Handler = &netwave_interrupt; /* General socket configuration */ link->conf.Attributes = CONF_ENABLE_IRQ; link->conf.Vcc = 50; link->conf.IntType = INT_MEMORY_AND_IO; link->conf.ConfigIndex = 1; link->conf.Present = PRESENT_OPTION; /* Allocate space for private device-specific data */ dev = kmalloc(sizeof(struct device), GFP_KERNEL); memset(dev, 0, sizeof(struct device)); dev->priv = kmalloc(sizeof(netwave_private), GFP_KERNEL); memset(dev->priv, 0, sizeof(netwave_private)); /* Set the watchdog timer */ priv = (netwave_private *) dev->priv; priv->watchdog.function = &netwave_watchdog; priv->watchdog.data = (unsigned long) dev; /* Netwave specific entries in the device structure */ dev->hard_start_xmit = &netwave_start_xmit; dev->set_config = &netwave_config; dev->get_stats = &netwave_get_stats; dev->set_multicast_list = &set_multicast_list; /* wireless extensions */ #ifdef WIRELESS_EXT dev->get_wireless_stats = &netwave_get_wireless_stats; #endif dev->do_ioctl = &netwave_ioctl; ether_setup(dev); dev->name = ((struct netwave_private *)dev->priv)->node.dev_name; dev->init = &netwave_init; dev->open = &netwave_open; dev->stop = &netwave_close; dev->tbusy = 1; link->priv = link->irq.Instance = dev; /* Register with Card Services */ link->next = dev_list; dev_list = link; client_reg.dev_info = &dev_info; client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE; client_reg.EventMask = CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME; client_reg.event_handler = &netwave_event; client_reg.Version = 0x0210; client_reg.event_callback_args.client_data = link; ret = CardServices(RegisterClient, &link->handle, &client_reg); if (ret != 0) { cs_error(link->handle, RegisterClient, ret); netwave_detach(link); return NULL; } return link; } /* netwave_attach */ /* * Function netwave_detach (link) * * This deletes a driver "instance". The device is de-registered * with Card Services. If it has been released, all local data * structures are freed. Otherwise, the structures will be freed * when the device is released. */ static void netwave_detach(dev_link_t *link) { dev_link_t **linkp; long flags; DEBUG(0, "netwave_detach(0x%p)\n", link); save_flags(flags); if (link->state & DEV_RELEASE_PENDING) { del_timer(&link->release); link->state &= ~DEV_RELEASE_PENDING; } cli(); restore_flags(flags); /* If the device is currently configured and active, we won't actually delete it yet. Instead, it is marked so that when the release() function is called, that will trigger a proper detach(). */ if (link->state & DEV_CONFIG) { netwave_release((u_long) link); if (link->state & DEV_STALE_CONFIG) { DEBUG(1, "netwave_cs: detach postponed, '%s' still " "locked\n", link->dev->dev_name); link->state |= DEV_STALE_LINK; return; } } /* Break the link with Card Services */ if (link->handle) CardServices(DeregisterClient, link->handle); /* Locate device structure */ for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) if (*linkp == link) break; if (*linkp == NULL) { DEBUG(1, "netwave_cs: detach fail, '%s' not in list\n", link->dev->dev_name); return; } /* Unlink device structure, free pieces */ *linkp = link->next; if (link->priv) { struct device *dev = link->priv; if (link->dev != NULL) unregister_netdev(dev); link->dev = NULL; if (dev->priv) kfree_s(dev->priv, sizeof(netwave_private)); kfree_s(link->priv, sizeof(struct device)); } kfree_s(link, sizeof(struct dev_link_t)); } /* netwave_detach */ /* * Function netwave_flush_stale_links (void) * * This deletes all driver "instances" that need to be deleted. * Sometimes, netwave_detach can't be performed following a call from * cardmgr (device still open) and the device is put in a STALE_LINK * state. * This function is in charge of making the cleanup... */ static void netwave_flush_stale_links(void) { dev_link_t * link; /* Current node in linked list */ dev_link_t * next; /* Next node in linked list */ DEBUG(1, "netwave_flush_stale_links(0x%p)\n", dev_list); /* Go through the list */ for (link = dev_list; link; link = next) { next = link->next; /* Check if in need of being removed */ if(link->state & DEV_STALE_LINK) netwave_detach(link); } } /* netwave_flush_stale_links */ /* * Function netwave_ioctl (dev, rq, cmd) * * Perform ioctl : config & info stuff * This is the stuff that are treated the wireless extensions (iwconfig) * */ static int netwave_ioctl(struct device *dev, /* ioctl device */ struct ifreq *rq, /* Data passed */ int cmd) /* Ioctl number */ { unsigned long flags; int ret = 0; #ifdef WIRELESS_EXT unsigned short iobase = dev->base_addr; netwave_private *priv = (netwave_private *) dev->priv; u_char *ramBase = priv->ramBase; struct iwreq *wrq = (struct iwreq *) rq; #endif DEBUG( 0, "%s: ->netwave_ioctl(cmd=0x%X)\n", dev->name, cmd); /* Disable interrupts & save flags */ save_flags(flags); cli(); /* Look what is the request */ switch(cmd) { /* --------------- WIRELESS EXTENSIONS --------------- */ #ifdef WIRELESS_EXT case SIOCGIWNAME: /* Get name */ strcpy(wrq->u.name, "Netwave"); break; case SIOCSIWNWID: /* Set domain */ if(wrq->u.nwid.on) { domain = wrq->u.nwid.nwid; printk( KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff); wait_WOC(iobase); writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0); writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1); writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3); } break; case SIOCGIWNWID: /* Read domain*/ wrq->u.nwid.nwid = domain; wrq->u.nwid.on = 1; break; case SIOCGIWENCODE: /* Get scramble key */ wrq->u.encoding.code = scramble_key; wrq->u.encoding.method = 1; break; case SIOCSIWENCODE: /* Set scramble key */ scramble_key = wrq->u.encoding.code; wait_WOC(iobase); writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0); writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1); writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3); break; case SIOCGIWRANGE: /* Basic checking... */ if(wrq->u.data.pointer != (caddr_t) 0) { struct iw_range range; /* Verify the user buffer */ ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, sizeof(struct iw_range)); if(ret) break; /* Set the length (useless : its constant...) */ wrq->u.data.length = sizeof(struct iw_range); /* Set information in the range struct */ range.throughput = 1.6 * 1024 * 1024; /* don't argue on this ! */ range.min_nwid = 0x0000; range.max_nwid = 0x01FF; range.num_channels = range.num_frequency = 0; range.sensitivity = 0x3F; range.max_qual.qual = 255; range.max_qual.level = 255; range.max_qual.noise = 0; /* Copy structure to the user buffer */ copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)); } break; case SIOCGIWPRIV: /* Basic checking... */ if(wrq->u.data.pointer != (caddr_t) 0) { struct iw_priv_args priv[] = { /* cmd, set_args, get_args, name */ { SIOCGIPSNAP, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 0, sizeof(struct site_survey), "getsitesurvey" }, }; /* Verify the user buffer */ ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, sizeof(priv)); if(ret) break; /* Set the number of ioctl available */ wrq->u.data.length = 1; /* Copy structure to the user buffer */ copy_to_user(wrq->u.data.pointer, (u_char *) priv, sizeof(priv)); } break; case SIOCGIPSNAP: if(wrq->u.data.pointer != (caddr_t) 0) { /* Take snapshot of environment */ netwave_snapshot( priv, ramBase, iobase); /* Verify the user buffer */ ret = verify_area(VERIFY_WRITE, wrq->u.data.pointer, sizeof(struct site_survey)); if(ret) { printk(KERN_DEBUG "Bad buffer!\n"); break; } wrq->u.data.length = priv->nss.length; /* Copy structure to the user buffer */ copy_to_user(wrq->u.data.pointer, (u_char *) &priv->nss, sizeof( struct site_survey)); priv->lastExec = jiffies; } break; #endif default: ret = -EOPNOTSUPP; } /* ReEnable interrupts & restore flags */ restore_flags(flags); return ret; } /* * Function netwave_pcmcia_config (link) * * netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION * event is received, to configure the PCMCIA socket, and to make the * device available to the system. * */ #define CS_CHECK(fn, args...) \ while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed static void netwave_pcmcia_config(dev_link_t *link) { client_handle_t handle; tuple_t tuple; cisparse_t parse; struct device *dev; int i, j, last_ret, last_fn; u_char buf[64]; win_req_t req; memreq_t mem; u_char *ramBase = NULL; /* modwin_t mod; short iobase, *phys_addr; */ handle = link->handle; dev = link->priv; DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link); /* This reads the card's CONFIG tuple to find its configuration registers. */ tuple.Attributes = 0; tuple.TupleData = (cisdata_t *) buf; tuple.TupleDataMax = 64; tuple.TupleOffset = 0; tuple.DesiredTuple = CISTPL_CONFIG; CS_CHECK(GetFirstTuple, handle, &tuple); CS_CHECK(GetTupleData, handle, &tuple); CS_CHECK(ParseTuple, handle, &tuple, &parse); link->conf.ConfigBase = parse.config.base; link->conf.Present = parse.config.rmask[0]; /* Configure card */ link->state |= DEV_CONFIG; /* * Try allocating IO ports. This tries a few fixed addresses. * If you want, you can also read the card's config table to * pick addresses -- see the serial driver for an example. */ for (j = 0x0; j < 0x400; j += 0x20) { link->io.BasePort1 = j ^ 0x300; i = CardServices(RequestIO, link->handle, &link->io); if (i == CS_SUCCESS) break; } if (i != CS_SUCCESS) { cs_error(link->handle, RequestIO, i); goto failed; } /* * Now allocate an interrupt line. Note that this does not * actually assign a handler to the interrupt. */ CS_CHECK(RequestIRQ, handle, &link->irq); /* * This actually configures the PCMCIA socket -- setting up * the I/O windows and the interrupt mapping. */ CS_CHECK(RequestConfiguration, handle, &link->conf); /* * Allocate a 32K memory window. Note that the dev_link_t * structure provides space for one window handle -- if your * device needs several windows, you'll need to keep track of * the handles in your private data structure, link->priv. */ DEBUG(1, "Setting mem speed of %d\n", mem_speed); req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE; req.Base = 0; req.Size = 0x8000; req.AccessSpeed = mem_speed; link->win = (window_handle_t)link->handle; CS_CHECK(RequestWindow, &link->win, &req); mem.CardOffset = 0x20000; mem.Page = 0; CS_CHECK(MapMemPage, link->win, &mem); /* Store base address of the common window frame */ ramBase = ioremap(req.Base, 0x8000); ((netwave_private*)dev->priv)->ramBase = ramBase; dev->irq = link->irq.AssignedIRQ; dev->base_addr = link->io.BasePort1; dev->tbusy = 0; if (register_netdev(dev) != 0) { printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n"); goto failed; } link->state &= ~DEV_CONFIG_PENDING; link->dev = &((netwave_private *)dev->priv)->node; /* Reset card before reading physical address */ netwave_doreset(dev->base_addr, ramBase); /* Read the ethernet address and fill in the Netwave registers. */ for (i = 0; i < 6; i++) dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i); printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id " "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq, (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI), (int) readb(ramBase+NETWAVE_EREG_NI+1)); for (i = 0; i < 6; i++) printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n")); /* get revision words */ printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n", get_uint16(ramBase + NETWAVE_EREG_ARW), get_uint16(ramBase + NETWAVE_EREG_ARW+2)); return; cs_failed: cs_error(link->handle, last_fn, last_ret); failed: netwave_release((u_long)link); return; } /* netwave_pcmcia_config */ /* * Function netwave_release (arg) * * After a card is removed, netwave_release() will unregister the net * device, and release the PCMCIA configuration. If the device is * still open, this will be postponed until it is closed. */ static void netwave_release(u_long arg) { dev_link_t *link = (dev_link_t *)arg; struct device *dev = link->priv; DEBUG(0, "netwave_release(0x%p)\n", link); /* If the device is currently in use, we won't release until it is actually closed. */ if (link->open) { printk(KERN_DEBUG "netwave_cs: release postponed, '%s' still open\n", link->dev->dev_name); link->state |= DEV_STALE_CONFIG; return; } /* Don't bother checking to see if these succeed or not */ if (link->win) { iounmap(((netwave_private *)dev->priv)->ramBase); CardServices(ReleaseWindow, link->win); } CardServices(ReleaseConfiguration, link->handle); CardServices(ReleaseIO, link->handle, &link->io); CardServices(ReleaseIRQ, link->handle, &link->irq); link->state &= ~(DEV_CONFIG | DEV_RELEASE_PENDING | DEV_STALE_CONFIG); } /* netwave_release */ /* * Function netwave_event (event, priority, args) * * The card status event handler. Mostly, this schedules other * stuff to run after an event is received. A CARD_REMOVAL event * also sets some flags to discourage the net drivers from trying * to talk to the card any more. * * When a CARD_REMOVAL event is received, we immediately set a flag * to block future accesses to this device. All the functions that * actually access the device should check this flag to make sure * the card is still present. * */ static int netwave_event(event_t event, int priority, event_callback_args_t *args) { dev_link_t *link = args->client_data; struct device *dev = link->priv; DEBUG(1, "netwave_event(0x%06x)\n", event); switch (event) { case CS_EVENT_REGISTRATION_COMPLETE: DEBUG(0, "netwave_cs: registration complete\n"); break; case CS_EVENT_CARD_REMOVAL: link->state &= ~DEV_PRESENT; if (link->state & DEV_CONFIG) { dev->tbusy = 1; dev->start = 0; /* ((netwave_private *)link->priv)->block = 1; */ link->release.expires = RUN_AT(5); add_timer(&link->release); } break; case CS_EVENT_CARD_INSERTION: link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; netwave_pcmcia_config( link); break; case CS_EVENT_PM_SUSPEND: link->state |= DEV_SUSPEND; /* Fall through... */ case CS_EVENT_RESET_PHYSICAL: if (link->state & DEV_CONFIG) { if (link->open) { dev->tbusy = 1; dev->start = 0; } CardServices(ReleaseConfiguration, link->handle); } break; case CS_EVENT_PM_RESUME: link->state &= ~DEV_SUSPEND; /* Fall through... */ case CS_EVENT_CARD_RESET: if (link->state & DEV_CONFIG) { CardServices(RequestConfiguration, link->handle, &link->conf); if (link->open) { netwave_reset(dev); dev->tbusy = 0; dev->start = 1; } } break; } return 0; } /* netwave_event */ /* * Function netwave_doreset (ioBase, ramBase) * * Proper hardware reset of the card. */ static void netwave_doreset(unsigned long ioBase, u_char* ramBase) { /* Reset card */ wait_WOC(ioBase); outb(0x80, ioBase + NETWAVE_REG_PMR); writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */ outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */ } /* * Function netwave_reset (dev) * * Reset and restore all of the netwave registers */ static void netwave_reset(struct device *dev) { /* u_char state; */ netwave_private *priv = (netwave_private*) dev->priv; u_char *ramBase = priv->ramBase; unsigned long iobase = dev->base_addr; DEBUG(0, "netwave_reset: Done with hardware reset\n"); priv->timeoutCounter = 0; /* If watchdog was activated, kill it ! */ del_timer(&priv->watchdog); /* Reset card */ netwave_doreset(iobase, ramBase); printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n"); /* Write a NOP to check the card */ wait_WOC(iobase); writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); /* Set receive conf */ wait_WOC(iobase); writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0); writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2); /* Set transmit conf */ wait_WOC(iobase); writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0); writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2); /* Now set the MU Domain */ printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff); wait_WOC(iobase); writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0); writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1); writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3); /* Set scramble key */ printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key); wait_WOC(iobase); writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0); writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1); writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3); /* Enable interrupts, bit 4 high to keep unused * source from interrupting us, bit 2 high to * set interrupt enable, 567 to enable TxDN, * RxErr and RxRdy */ wait_WOC(iobase); outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR); /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36 * waitWOC * skriv 80 til d000:3688 * sjekk om det ble 80 */ /* Enable Receiver */ wait_WOC(iobase); writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); /* Set the IENA bit in COR */ wait_WOC(iobase); outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR); } /* * Function netwave_config (dev, map) * * Configure device, this work is done by netwave_pcmcia_config when a * card is inserted */ static int netwave_config(struct device *dev, struct ifmap *map) { return 0; } /* * Function netwave_hw_xmit (data, len, dev) */ static int netwave_hw_xmit(unsigned char* data, int len, struct device* dev) { unsigned long flags; unsigned int TxFreeList, curBuff, MaxData, DataOffset; int tmpcount; netwave_private *priv = (netwave_private *) dev->priv; u_char* ramBase = priv->ramBase; unsigned long iobase = dev->base_addr; /* Disable interrupts & save flags */ save_flags(flags); cli(); /* Check if there are transmit buffers available */ wait_WOC(iobase); if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) { /* No buffers available */ printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n", dev->name); return 1; } #if (LINUX_VERSION_CODE >= VERSION(2,1,25)) priv->stats.tx_bytes += len; #endif DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n", readb(ramBase + NETWAVE_EREG_SPCQ), readb(ramBase + NETWAVE_EREG_SPU), readb(ramBase + NETWAVE_EREG_LIF), readb(ramBase + NETWAVE_EREG_ISPLQ)); /* Now try to insert it into the adapters free memory */ wait_WOC(iobase); TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP); MaxData = get_uint16(ramBase + NETWAVE_EREG_TDP+2); DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4); DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n", TxFreeList, MaxData, DataOffset); /* Copy packet to the adapter fragment buffers */ curBuff = TxFreeList; tmpcount = 0; while (tmpcount < len) { int tmplen = len - tmpcount; copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount, (tmplen < MaxData) ? tmplen : MaxData); tmpcount += MaxData; /* Advance to next buffer */ curBuff = get_uint16(ramBase + curBuff); } /* Now issue transmit list */ wait_WOC(iobase); writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0); writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1); writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3); /* If watchdog not already active, activate it... */ if(priv->watchdog.prev == (struct timer_list *) NULL) { /* set timer to expire in WATCHDOG_JIFFIES */ priv->watchdog.expires = jiffies + WATCHDOG_JIFFIES; add_timer(&priv->watchdog); } restore_flags( flags); return 0; } static int netwave_start_xmit(struct sk_buff *skb, struct device *dev) { /* This flag indicate that the hardware can't perform a transmission. * Theoritically, NET3 check it before sending a packet to the driver, * but in fact it never do that and pool continuously. * As the watchdog will abort too long transmissions, we are quite safe... */ if (dev->tbusy) { /* Handled by watchdog */ return 1; /* If we get here, some higher level has decided we are broken. There should really be a 'kick me' function call instead. */ /*int tickssofar = jiffies - dev->trans_start;*/ /* printk("xmit called with busy. tickssofar %d\n", tickssofar); */ /*if (tickssofar < TX_TIMEOUT) return 1; */ /* Should also detect if the kernel tries to xmit * on a stopped card. */ /*if (netwave_debug > 0) printk(KERN_DEBUG "%s timed out.\n", dev->name); netwave_reset(dev); dev->trans_start = jiffies; dev->tbusy = 0;*/ } /* Sending a NULL skb means some higher layer thinks we've missed an * tx-done interrupt. Caution: dev_tint() handles the cli()/sti() * itself. */ #if (LINUX_VERSION_CODE < VERSION(2,1,25)) if (skb == NULL) { dev_tint(dev); return 0; } if (skb->len <= 0) return 0; #endif /* Block a timer-based transmit from overlapping. This could * better be done with atomic_swap(1, dev->tbusy, but set_bit() * works as well */ if ( test_and_set_bit(0, (void*)&dev->tbusy) != 0) printk("%s: Transmitter access conflict.\n", dev->name); else { short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; unsigned char* buf = skb->data; if (netwave_hw_xmit( buf, length, dev) == 1) { /* Some error, let's make them call us another time? */ dev->tbusy = 0; } dev->trans_start = jiffies; } DEV_KFREE_SKB(skb); return 0; } /* netwave_start_xmit */ /* * Function netwave_interrupt IRQ (irq, dev_id, regs) * * This function is the interrupt handler for the Netwave card. This * routine will be called whenever: * 1. A packet is received. * 2. A packet has successfully been transfered and the unit is * ready to transmit another packet. * 3. A command has completed execution. */ static void netwave_interrupt IRQ(int irq, void* dev_id, struct pt_regs *regs) { unsigned long iobase; u_char *ramBase; struct device *dev = (struct device *)DEV_ID; struct netwave_private *priv; int i; dev_link_t *link; if ((dev == NULL) | (!dev->start)) return; priv = (netwave_private *)dev->priv; if (dev->interrupt) { printk("%s: re-entering the interrupt handler.\n", dev->name); return; } dev->interrupt = 1; /* Find the correct dev_link_t */ for (link = dev_list; NULL != link; link = link->next) if (dev == link->priv) break; iobase = dev->base_addr; ramBase = priv->ramBase; /* Now find what caused the interrupt, check while interrupts ready */ for (i = 0; i < 10; i++) { u_char status; wait_WOC(iobase); if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02)) break; /* None of the interrupt sources asserted */ status = inb(iobase + NETWAVE_REG_ASR); if ( ! (link->state & DEV_PRESENT) || link->state & DEV_SUSPEND ) { DEBUG( 1, "netwave_interupt: Interrupt with status 0x%x " "from removed or suspended card!\n", status); break; } /* RxRdy */ if (status & 0x80) { netwave_rx(dev); /* wait_WOC(iobase); */ /* RxRdy cannot be reset directly by the host */ } /* RxErr */ if (status & 0x40) { u_char rser; rser = readb(ramBase + NETWAVE_EREG_RSER); if (rser & 0x04) { ++priv->stats.rx_dropped; ++priv->stats.rx_crc_errors; } if (rser & 0x02) ++priv->stats.rx_frame_errors; /* Clear the RxErr bit in RSER. RSER+4 is the * write part. Also clear the RxCRC (0x04) and * RxBig (0x02) bits if present */ wait_WOC(iobase); writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4); /* Write bit 6 high to ASCC to clear RxErr in ASR, * WOC must be set first! */ wait_WOC(iobase); writeb(0x40, ramBase + NETWAVE_EREG_ASCC); /* Remember to count up priv->stats on error packets */ ++priv->stats.rx_errors; } /* TxDN */ if (status & 0x20) { int txStatus; txStatus = readb(ramBase + NETWAVE_EREG_TSER); DEBUG(3, "Transmit done. TSER = %x id %x\n", txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1)); if (txStatus & 0x20) { /* Transmitting was okay, clear bits */ wait_WOC(iobase); writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4); ++priv->stats.tx_packets; } if (txStatus & 0xd0) { if (txStatus & 0x80) { ++priv->stats.collisions; /* Because of /proc/net/dev*/ /* ++priv->stats.tx_aborted_errors; */ /* printk("Collision. %ld\n", jiffies - dev->trans_start); */ } if (txStatus & 0x40) ++priv->stats.tx_carrier_errors; /* 0x80 TxGU Transmit giveup - nine times and no luck * 0x40 TxNOAP No access point. Discarded packet. * 0x10 TxErr Transmit error. Always set when * TxGU and TxNOAP is set. (Those are the only ones * to set TxErr). */ DEBUG(3, "netwave_interrupt: TxDN with error status %x\n", txStatus); /* Clear out TxGU, TxNOAP, TxErr and TxTrys */ wait_WOC(iobase); writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4); ++priv->stats.tx_errors; } DEBUG(3, "New status is TSER %x ASR %x\n", readb(ramBase + NETWAVE_EREG_TSER), inb(iobase + NETWAVE_REG_ASR)); /* If watchdog was activated, kill it ! */ del_timer(&priv->watchdog); dev->tbusy = 0; mark_bh(NET_BH); } /* TxBA, this would trigger on all error packets received */ /* if (status & 0x01) { if (netwave_debug > 3) printk(KERN_DEBUG "Transmit buffers available, %x\n", status); } */ } /* done.. */ dev->interrupt = 0; return; } /* netwave_interrupt */ /* * Function netwave_watchdog (a) * * Watchdog : when we start a transmission, we set a timer in the * kernel. If the transmission complete, this timer is disabled. If * it expire, we reset the card. * */ static void netwave_watchdog(u_long a) { struct device *dev; unsigned short iobase; dev = (struct device *) a; iobase = dev->base_addr; DEBUG( 1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name); netwave_reset(dev); /* We are not waiting anymore... */ dev->tbusy = 0; } /* netwave_watchdog */ static struct enet_statistics *netwave_get_stats(struct device *dev) { netwave_private *priv = (netwave_private*)dev->priv; update_stats(dev); DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x" " %x tx %x %x %x %x\n", readb(priv->ramBase + NETWAVE_EREG_SPCQ), readb(priv->ramBase + NETWAVE_EREG_SPU), readb(priv->ramBase + NETWAVE_EREG_LIF), readb(priv->ramBase + NETWAVE_EREG_ISPLQ), readb(priv->ramBase + NETWAVE_EREG_MHS), readb(priv->ramBase + NETWAVE_EREG_EC + 0xe), readb(priv->ramBase + NETWAVE_EREG_EC + 0xf), readb(priv->ramBase + NETWAVE_EREG_EC + 0x18), readb(priv->ramBase + NETWAVE_EREG_EC + 0x19), readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a), readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b)); return &priv->stats; } static void update_stats(struct device *dev) { unsigned long flags; save_flags(flags); cli(); /* netwave_private *priv = (netwave_private*) dev->priv; priv->stats.rx_packets = readb(priv->ramBase + 0x18e); priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */ restore_flags(flags); } static int netwave_rx(struct device *dev) { netwave_private *priv = (netwave_private*)(dev->priv); u_char *ramBase = priv->ramBase; u_long iobase = dev->base_addr; u_char rxStatus; struct sk_buff *skb = NULL; unsigned int curBuffer, rcvList; int rcvLen; int tmpcount = 0; int dataCount, dataOffset; int i; u_char *ptr; DEBUG(3, "xinw_rx: Receiving ... \n"); /* Receive max 10 packets for now. */ for (i = 0; i < 10; i++) { /* Any packets? */ wait_WOC(iobase); rxStatus = readb(ramBase + NETWAVE_EREG_RSER); if ( !( rxStatus & 0x80)) /* No more packets */ break; /* Check if multicast/broadcast or other */ /* multicast = (rxStatus & 0x20); */ /* The receive list pointer and length of the packet */ wait_WOC(iobase); rcvLen = get_int16( ramBase + NETWAVE_EREG_RDP); rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2); if (rcvLen < 0) { printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n", rcvLen); return 0; } skb = dev_alloc_skb(rcvLen+5); if (skb == NULL) { DEBUG(1, "netwave_rx: Could not allocate an sk_buff of " "length %d\n", rcvLen); ++priv->stats.rx_dropped; /* Tell the adapter to skip the packet */ wait_WOC(iobase); writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); return 0; } #if (LINUX_VERSION_CODE >= VERSION(1,3,0)) skb_reserve( skb, 2); /* Align IP on 16 byte */ #endif skb_put( skb, rcvLen); skb->dev = dev; /* Copy packet fragments to the skb data area */ ptr = (u_char*) skb->data; curBuffer = rcvList; tmpcount = 0; while ( tmpcount < rcvLen) { /* Get length and offset of current buffer */ dataCount = get_uint16( ramBase+curBuffer+2); dataOffset = get_uint16( ramBase+curBuffer+4); copy_from_pc( ptr + tmpcount, ramBase+curBuffer+dataOffset, dataCount); tmpcount += dataCount; /* Point to next buffer */ curBuffer = get_uint16(ramBase + curBuffer); } #if (LINUX_VERSION_CODE >= VERSION(1,3,0)) skb->protocol = eth_type_trans(skb,dev); #endif /* Queue packet for network layer */ netif_rx(skb); /* Got the packet, tell the adapter to skip it */ wait_WOC(iobase); writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1); DEBUG(3, "Packet reception ok\n"); priv->stats.rx_packets++; #if (LINUX_VERSION_CODE >= VERSION(2,1,25)) priv->stats.rx_bytes += skb->len; #endif } return 0; } static int netwave_open(struct device *dev) { dev_link_t *link; DEBUG(1, "netwave_open: starting.\n"); for (link = dev_list; link; link = link->next) if (link->priv == dev) break; if (!DEV_OK(link)) return -ENODEV; link->open++; MOD_INC_USE_COUNT; dev->interrupt = 0; dev->tbusy = 0; dev->start = 1; netwave_reset(dev); return 0; } static int netwave_close(struct device *dev) { dev_link_t *link; netwave_private *priv = (netwave_private *) dev->priv; DEBUG(1, "netwave_close: finishing.\n"); for (link = dev_list; link; link = link->next) if (link->priv == dev) break; if (link == NULL) return -ENODEV; /* If watchdog was activated, kill it ! */ del_timer(&priv->watchdog); link->open--; dev->start = 0; if (link->state & DEV_STALE_CONFIG) { link->release.expires = RUN_AT(5); link->state |= DEV_RELEASE_PENDING; add_timer(&link->release); } MOD_DEC_USE_COUNT; return 0; } int init_module(void) { servinfo_t serv; DEBUG(0, "%s\n", version); CardServices(GetCardServicesInfo, &serv); if (serv.Revision != CS_RELEASE_CODE) { printk("netwave_cs: Card Services release does not match!\n"); return -1; } register_pcmcia_driver(&dev_info, &netwave_attach, &netwave_detach); return 0; } void cleanup_module(void) { DEBUG(1, "netwave_cs: unloading\n"); unregister_pcmcia_driver(&dev_info); /* Do some cleanup of the device list */ netwave_flush_stale_links(); if(dev_list != NULL) /* Critical situation */ printk("netwave_cs: devices remaining when removing module\n"); } /* Set or clear the multicast filter for this adaptor. num_addrs == -1 Promiscuous mode, receive all packets num_addrs == 0 Normal mode, clear multicast list num_addrs > 0 Multicast mode, receive normal and MC packets, and do best-effort filtering. */ static void set_multicast_list(struct device *dev) { short iobase = dev->base_addr; u_char* ramBase = ((netwave_private*) dev->priv)->ramBase; u_char rcvMode = 0; #ifdef PCMCIA_DEBUG if (pc_debug > 2) { static int old = 0; if (old != dev->mc_count) { old = dev->mc_count; DEBUG(0, "%s: setting Rx mode to %d addresses.\n", dev->name, dev->mc_count); } } #endif if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) { /* Multicast Mode */ rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast; } else if (dev->flags & IFF_PROMISC) { /* Promiscous mode */ rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast; } else { /* Normal mode */ rcvMode = rxConfRxEna + rxConfBcast; } /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/ /* Now set receive mode */ wait_WOC(iobase); writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0); writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1); writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2); }