drivers/net/wireless/netwave_cs.c

   1 /*********************************************************************
   2  *
   3  * Filename:      netwave_cs.c
   4  * Version:       0.4.1
   5  * Description:   Netwave AirSurfer Wireless LAN PC Card driver
   6  * Status:        Experimental.
   7  * Authors:       John Markus Bjørndalen <johnm@cs.uit.no>
   8  *                Dag Brattli <dagb@cs.uit.no>
   9  *                David Hinds <dahinds@users.sourceforge.net>
  10  * Created at:    A long time ago!
  11  * Modified at:   Mon Nov 10 11:54:37 1997
  12  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  13  *
  14  *     Copyright (c) 1997 University of Tromsø, Norway
  15  *
  16  * Revision History:
  17  *
  18  *   08-Nov-97 15:14:47   John Markus Bjørndalen <johnm@cs.uit.no>
  19  *    - Fixed some bugs in netwave_rx and cleaned it up a bit.
  20  *      (One of the bugs would have destroyed packets when receiving
  21  *      multiple packets per interrupt).
  22  *    - Cleaned up parts of newave_hw_xmit.
  23  *    - A few general cleanups.
  24  *   24-Oct-97 13:17:36   Dag Brattli <dagb@cs.uit.no>
  25  *    - Fixed netwave_rx receive function (got updated docs)
  26  *   Others:
  27  *    - Changed name from xircnw to netwave, take a look at
  28  *      http://www.netwave-wireless.com
  29  *    - Some reorganizing of the code
  30  *    - Removed possible race condition between interrupt handler and transmit
  31  *      function
  32  *    - Started to add wireless extensions, but still needs some coding
  33  *    - Added watchdog for better handling of transmission timeouts
  34  *      (hopefully this works better)
  35  ********************************************************************/
  36
  37 /* To have statistics (just packets sent) define this */
  38 #undef NETWAVE_STATS
  39
  40 #include <linux/config.h>
  41 #include <linux/module.h>
  42 #include <linux/kernel.h>
  43 #include <linux/init.h>
  44 #include <linux/types.h>
  45 #include <linux/fcntl.h>
  46 #include <linux/interrupt.h>
  47 #include <linux/ptrace.h>
  48 #include <linux/ioport.h>
  49 #include <linux/in.h>
  50 #include <linux/slab.h>
  51 #include <linux/string.h>
  52 #include <linux/timer.h>
  53 #include <linux/errno.h>
  54 #include <linux/netdevice.h>
  55 #include <linux/etherdevice.h>
  56 #include <linux/skbuff.h>
  57 #include <linux/bitops.h>
  58 #ifdef CONFIG_NET_RADIO
  59 #include <linux/wireless.h>
  60 #include <net/iw_handler.h>
  61 #endif
  62
  63 #include <pcmcia/cs_types.h>
  64 #include <pcmcia/cs.h>
  65 #include <pcmcia/cistpl.h>
  66 #include <pcmcia/cisreg.h>
  67 #include <pcmcia/ds.h>
  68 #include <pcmcia/mem_op.h>
  69
  70 #include <asm/system.h>
  71 #include <asm/io.h>
  72 #include <asm/dma.h>
  73
  74 #define NETWAVE_REGOFF         0x8000
  75 /* The Netwave IO registers, offsets to iobase */
  76 #define NETWAVE_REG_COR        0x0
  77 #define NETWAVE_REG_CCSR       0x2
  78 #define NETWAVE_REG_ASR        0x4
  79 #define NETWAVE_REG_IMR        0xa
  80 #define NETWAVE_REG_PMR        0xc
  81 #define NETWAVE_REG_IOLOW      0x6
  82 #define NETWAVE_REG_IOHI       0x7
  83 #define NETWAVE_REG_IOCONTROL  0x8
  84 #define NETWAVE_REG_DATA       0xf
  85 /* The Netwave Extended IO registers, offsets to RamBase */
  86 #define NETWAVE_EREG_ASCC      0x114
  87 #define NETWAVE_EREG_RSER      0x120
  88 #define NETWAVE_EREG_RSERW     0x124
  89 #define NETWAVE_EREG_TSER      0x130
  90 #define NETWAVE_EREG_TSERW     0x134
  91 #define NETWAVE_EREG_CB        0x100
  92 #define NETWAVE_EREG_SPCQ      0x154
  93 #define NETWAVE_EREG_SPU       0x155
  94 #define NETWAVE_EREG_LIF       0x14e
  95 #define NETWAVE_EREG_ISPLQ     0x156
  96 #define NETWAVE_EREG_HHC       0x158
  97 #define NETWAVE_EREG_NI        0x16e
  98 #define NETWAVE_EREG_MHS       0x16b
  99 #define NETWAVE_EREG_TDP       0x140
 100 #define NETWAVE_EREG_RDP       0x150
 101 #define NETWAVE_EREG_PA        0x160
 102 #define NETWAVE_EREG_EC        0x180
 103 #define NETWAVE_EREG_CRBP      0x17a
 104 #define NETWAVE_EREG_ARW       0x166
 105
 106 /*
 107  * Commands used in the extended command buffer
 108  * NETWAVE_EREG_CB (0x100-0x10F)
 109  */
 110 #define NETWAVE_CMD_NOP        0x00
 111 #define NETWAVE_CMD_SRC        0x01
 112 #define NETWAVE_CMD_STC        0x02
 113 #define NETWAVE_CMD_AMA        0x03
 114 #define NETWAVE_CMD_DMA        0x04
 115 #define NETWAVE_CMD_SAMA       0x05
 116 #define NETWAVE_CMD_ER         0x06
 117 #define NETWAVE_CMD_DR         0x07
 118 #define NETWAVE_CMD_TL         0x08
 119 #define NETWAVE_CMD_SRP        0x09
 120 #define NETWAVE_CMD_SSK        0x0a
 121 #define NETWAVE_CMD_SMD        0x0b
 122 #define NETWAVE_CMD_SAPD       0x0c
 123 #define NETWAVE_CMD_SSS        0x11
 124 /* End of Command marker */
 125 #define NETWAVE_CMD_EOC        0x00
 126
 127 /* ASR register bits */
 128 #define NETWAVE_ASR_RXRDY   0x80
 129 #define NETWAVE_ASR_TXBA    0x01
 130
 131 #define TX_TIMEOUT              ((32*HZ)/100)
 132
 133 static const unsigned int imrConfRFU1 = 0x10; /* RFU interrupt mask, keep high */
 134 static const unsigned int imrConfIENA = 0x02; /* Interrupt enable */
 135
 136 static const unsigned int corConfIENA   = 0x01; /* Interrupt enable */
 137 static const unsigned int corConfLVLREQ = 0x40; /* Keep high */
 138
 139 static const unsigned int rxConfRxEna  = 0x80; /* Receive Enable */
 140 static const unsigned int rxConfMAC    = 0x20; /* MAC host receive mode*/
 141 static const unsigned int rxConfPro    = 0x10; /* Promiscuous */
 142 static const unsigned int rxConfAMP    = 0x08; /* Accept Multicast Packets */
 143 static const unsigned int rxConfBcast  = 0x04; /* Accept Broadcast Packets */
 144
 145 static const unsigned int txConfTxEna  = 0x80; /* Transmit Enable */
 146 static const unsigned int txConfMAC    = 0x20; /* Host sends MAC mode */
 147 static const unsigned int txConfEUD    = 0x10; /* Enable Uni-Data packets */
 148 static const unsigned int txConfKey    = 0x02; /* Scramble data packets */
 149 static const unsigned int txConfLoop   = 0x01; /* Loopback mode */
 150
 151 /*
 152    All the PCMCIA modules use PCMCIA_DEBUG to control debugging.  If
 153    you do not define PCMCIA_DEBUG at all, all the debug code will be
 154    left out.  If you compile with PCMCIA_DEBUG=0, the debug code will
 155    be present but disabled -- but it can then be enabled for specific
 156    modules at load time with a 'pc_debug=#' option to insmod.
 157 */
 158
 159 #ifdef PCMCIA_DEBUG
 160 static int pc_debug = PCMCIA_DEBUG;
 161 module_param(pc_debug, int, 0);
 162 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
 163 static char *version =
 164 "netwave_cs.c 0.3.0 Thu Jul 17 14:36:02 1997 (John Markus Bjørndalen)\n";
 165 #else
 166 #define DEBUG(n, args...)
 167 #endif
 168
 169 static dev_info_t dev_info = "netwave_cs";
 170
 171 /*====================================================================*/
 172
 173 /* Parameters that can be set with 'insmod' */
 174
 175 /* Choose the domain, default is 0x100 */
 176 static u_int  domain = 0x100;
 177
 178 /* Scramble key, range from 0x0 to 0xffff.
 179  * 0x0 is no scrambling.
 180  */
 181 static u_int  scramble_key = 0x0;
 182
 183 /* Shared memory speed, in ns. The documentation states that
 184  * the card should not be read faster than every 400ns.
 185  * This timing should be provided by the HBA. If it becomes a
 186  * problem, try setting mem_speed to 400.
 187  */
 188 static int mem_speed;
 189
 190 module_param(domain, int, 0);
 191 module_param(scramble_key, int, 0);
 192 module_param(mem_speed, int, 0);
 193
 194 /*====================================================================*/
 195
 196 /* PCMCIA (Card Services) related functions */
 197 static void netwave_release(dev_link_t *link);     /* Card removal */
 198 static int  netwave_event(event_t event, int priority,
 199                                               event_callback_args_t *args);
 200 static void netwave_pcmcia_config(dev_link_t *arg); /* Runs after card
 201                                                                                                            insertion */
 202 static dev_link_t *netwave_attach(void);     /* Create instance */
 203 static void netwave_detach(struct pcmcia_device *p_dev);    /* Destroy instance */
 204
 205 /* Hardware configuration */
 206 static void netwave_doreset(kio_addr_t iobase, u_char __iomem *ramBase);
 207 static void netwave_reset(struct net_device *dev);
 208
 209 /* Misc device stuff */
 210 static int netwave_open(struct net_device *dev);  /* Open the device */
 211 static int netwave_close(struct net_device *dev); /* Close the device */
 212
 213 /* Packet transmission and Packet reception */
 214 static int netwave_start_xmit( struct sk_buff *skb, struct net_device *dev);
 215 static int netwave_rx( struct net_device *dev);
 216
 217 /* Interrupt routines */
 218 static irqreturn_t netwave_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 219 static void netwave_watchdog(struct net_device *);
 220
 221 /* Statistics */
 222 static void update_stats(struct net_device *dev);
 223 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
 224
 225 /* Wireless extensions */
 226 static struct iw_statistics* netwave_get_wireless_stats(struct net_device *dev);
 227
 228 static void set_multicast_list(struct net_device *dev);
 229
 230 /*
 231    A linked list of "instances" of the skeleton device.  Each actual
 232    PCMCIA card corresponds to one device instance, and is described
 233    by one dev_link_t structure (defined in ds.h).
 234
 235    You may not want to use a linked list for this -- for example, the
 236    memory card driver uses an array of dev_link_t pointers, where minor
 237    device numbers are used to derive the corresponding array index.
 238 */
 239 static dev_link_t *dev_list;
 240
 241 /*
 242    A dev_link_t structure has fields for most things that are needed
 243    to keep track of a socket, but there will usually be some device
 244    specific information that also needs to be kept track of.  The
 245    'priv' pointer in a dev_link_t structure can be used to point to
 246    a device-specific private data structure, like this.
 247
 248    A driver needs to provide a dev_node_t structure for each device
 249    on a card.  In some cases, there is only one device per card (for
 250    example, ethernet cards, modems).  In other cases, there may be
 251    many actual or logical devices (SCSI adapters, memory cards with
 252    multiple partitions).  The dev_node_t structures need to be kept
 253    in a linked list starting at the 'dev' field of a dev_link_t
 254    structure.  We allocate them in the card's private data structure,
 255    because they generally can't be allocated dynamically.
 256 */
 257
 258 static const struct iw_handler_def      netwave_handler_def;
 259
 260 #define SIOCGIPSNAP     SIOCIWFIRSTPRIV + 1     /* Site Survey Snapshot */
 261
 262 #define MAX_ESA 10
 263
 264 typedef struct net_addr {
 265     u_char addr48[6];
 266 } net_addr;
 267
 268 struct site_survey {
 269     u_short length;
 270     u_char  struct_revision;
 271     u_char  roaming_state;
 272
 273     u_char  sp_existsFlag;
 274     u_char  sp_link_quality;
 275     u_char  sp_max_link_quality;
 276     u_char  linkQualityGoodFairBoundary;
 277     u_char  linkQualityFairPoorBoundary;
 278     u_char  sp_utilization;
 279     u_char  sp_goodness;
 280     u_char  sp_hotheadcount;
 281     u_char  roaming_condition;
 282
 283     net_addr sp;
 284     u_char   numAPs;
 285     net_addr nearByAccessPoints[MAX_ESA];
 286 };
 287
 288 typedef struct netwave_private {
 289     dev_link_t link;
 290     spinlock_t  spinlock;       /* Serialize access to the hardware (SMP) */
 291     dev_node_t node;
 292     u_char     __iomem *ramBase;
 293     int        timeoutCounter;
 294     int        lastExec;
 295     struct timer_list      watchdog;    /* To avoid blocking state */
 296     struct site_survey     nss;
 297     struct net_device_stats stats;
 298     struct iw_statistics   iw_stats;    /* Wireless stats */
 299 } netwave_private;
 300
 301 #ifdef NETWAVE_STATS
 302 static struct net_device_stats *netwave_get_stats(struct net_device *dev);
 303 #endif
 304
 305 /*
 306  * The Netwave card is little-endian, so won't work for big endian
 307  * systems.
 308  */
 309 static inline unsigned short get_uint16(u_char __iomem *staddr)
 310 {
 311     return readw(staddr); /* Return only 16 bits */
 312 }
 313
 314 static inline short get_int16(u_char __iomem * staddr)
 315 {
 316     return readw(staddr);
 317 }
 318
 319 /*
 320  * Wait until the WOC (Write Operation Complete) bit in the
 321  * ASR (Adapter Status Register) is asserted.
 322  * This should have aborted if it takes too long time.
 323  */
 324 static inline void wait_WOC(unsigned int iobase)
 325 {
 326     /* Spin lock */
 327     while ((inb(iobase + NETWAVE_REG_ASR) & 0x8) != 0x8) ;
 328 }
 329
 330 static void netwave_snapshot(netwave_private *priv, u_char __iomem *ramBase,
 331                              kio_addr_t iobase) {
 332     u_short resultBuffer;
 333
 334     /* if time since last snapshot is > 1 sec. (100 jiffies?)  then take
 335      * new snapshot, else return cached data. This is the recommended rate.
 336      */
 337     if ( jiffies - priv->lastExec > 100) {
 338         /* Take site survey  snapshot */
 339         /*printk( KERN_DEBUG "Taking new snapshot. %ld\n", jiffies -
 340           priv->lastExec); */
 341         wait_WOC(iobase);
 342         writeb(NETWAVE_CMD_SSS, ramBase + NETWAVE_EREG_CB + 0);
 343         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
 344         wait_WOC(iobase);
 345
 346         /* Get result and copy to cach */
 347         resultBuffer = readw(ramBase + NETWAVE_EREG_CRBP);
 348         copy_from_pc( &priv->nss, ramBase+resultBuffer,
 349                       sizeof(struct site_survey));
 350     }
 351 }
 352
 353 /*
 354  * Function netwave_get_wireless_stats (dev)
 355  *
 356  *    Wireless extensions statistics
 357  *
 358  */
 359 static struct iw_statistics *netwave_get_wireless_stats(struct net_device *dev)
 360 {
 361     unsigned long flags;
 362     kio_addr_t iobase = dev->base_addr;
 363     netwave_private *priv = netdev_priv(dev);
 364     u_char __iomem *ramBase = priv->ramBase;
 365     struct iw_statistics* wstats;
 366
 367     wstats = &priv->iw_stats;
 368
 369     spin_lock_irqsave(&priv->spinlock, flags);
 370
 371     netwave_snapshot( priv, ramBase, iobase);
 372
 373     wstats->status = priv->nss.roaming_state;
 374     wstats->qual.qual = readb( ramBase + NETWAVE_EREG_SPCQ);
 375     wstats->qual.level = readb( ramBase + NETWAVE_EREG_ISPLQ);
 376     wstats->qual.noise = readb( ramBase + NETWAVE_EREG_SPU) & 0x3f;
 377     wstats->discard.nwid = 0L;
 378     wstats->discard.code = 0L;
 379     wstats->discard.misc = 0L;
 380
 381     spin_unlock_irqrestore(&priv->spinlock, flags);
 382
 383     return &priv->iw_stats;
 384 }
 385
 386 /*
 387  * Function netwave_attach (void)
 388  *
 389  *     Creates an "instance" of the driver, allocating local data
 390  *     structures for one device.  The device is registered with Card
 391  *     Services.
 392  *
 393  *     The dev_link structure is initialized, but we don't actually
 394  *     configure the card at this point -- we wait until we receive a
 395  *     card insertion event.
 396  */
 397 static dev_link_t *netwave_attach(void)
 398 {
 399     client_reg_t client_reg;
 400     dev_link_t *link;
 401     struct net_device *dev;
 402     netwave_private *priv;
 403     int ret;
 404
 405     DEBUG(0, "netwave_attach()\n");
 406
 407     /* Initialize the dev_link_t structure */
 408     dev = alloc_etherdev(sizeof(netwave_private));
 409     if (!dev)
 410         return NULL;
 411     priv = netdev_priv(dev);
 412     link = &priv->link;
 413     link->priv = dev;
 414
 415     /* The io structure describes IO port mapping */
 416     link->io.NumPorts1 = 16;
 417     link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 418     /* link->io.NumPorts2 = 16;
 419        link->io.Attributes2 = IO_DATA_PATH_WIDTH_16; */
 420     link->io.IOAddrLines = 5;
 421
 422     /* Interrupt setup */
 423     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 424     link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 425     link->irq.Handler = &netwave_interrupt;
 426
 427     /* General socket configuration */
 428     link->conf.Attributes = CONF_ENABLE_IRQ;
 429     link->conf.Vcc = 50;
 430     link->conf.IntType = INT_MEMORY_AND_IO;
 431     link->conf.ConfigIndex = 1;
 432     link->conf.Present = PRESENT_OPTION;
 433
 434     /* Netwave private struct init. link/dev/node already taken care of,
 435      * other stuff zero'd - Jean II */
 436     spin_lock_init(&priv->spinlock);
 437
 438     /* Netwave specific entries in the device structure */
 439     SET_MODULE_OWNER(dev);
 440     dev->hard_start_xmit = &netwave_start_xmit;
 441     dev->get_stats  = &netwave_get_stats;
 442     dev->set_multicast_list = &set_multicast_list;
 443     /* wireless extensions */
 444     dev->wireless_handlers = (struct iw_handler_def *)&netwave_handler_def;
 445
 446     dev->tx_timeout = &netwave_watchdog;
 447     dev->watchdog_timeo = TX_TIMEOUT;
 448
 449     dev->open = &netwave_open;
 450     dev->stop = &netwave_close;
 451     link->irq.Instance = dev;
 452
 453     /* Register with Card Services */
 454     link->next = dev_list;
 455     dev_list = link;
 456     client_reg.dev_info = &dev_info;
 457     client_reg.Version = 0x0210;
 458     client_reg.event_callback_args.client_data = link;
 459     ret = pcmcia_register_client(&link->handle, &client_reg);
 460     if (ret != 0) {
 461         cs_error(link->handle, RegisterClient, ret);
 462         netwave_detach(link->handle);
 463         return NULL;
 464     }
 465
 466     return link;
 467 } /* netwave_attach */
 468
 469 /*
 470  * Function netwave_detach (link)
 471  *
 472  *    This deletes a driver "instance".  The device is de-registered
 473  *    with Card Services.  If it has been released, all local data
 474  *    structures are freed.  Otherwise, the structures will be freed
 475  *    when the device is released.
 476  */
 477 static void netwave_detach(struct pcmcia_device *p_dev)
 478 {
 479     dev_link_t *link = dev_to_instance(p_dev);
 480     struct net_device *dev = link->priv;
 481     dev_link_t **linkp;
 482
 483     DEBUG(0, "netwave_detach(0x%p)\n", link);
 484
 485     /*
 486           If the device is currently configured and active, we won't
 487           actually delete it yet.  Instead, it is marked so that when
 488           the release() function is called, that will trigger a proper
 489           detach().
 490         */
 491     if (link->state & DEV_CONFIG)
 492         netwave_release(link);
 493
 494     /* Locate device structure */
 495     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 496         if (*linkp == link) break;
 497     if (*linkp == NULL)
 498       {
 499         DEBUG(1, "netwave_cs: detach fail, '%s' not in list\n",
 500               link->dev->dev_name);
 501         return;
 502       }
 503
 504     /* Unlink device structure, free pieces */
 505     *linkp = link->next;
 506     if (link->dev)
 507         unregister_netdev(dev);
 508     free_netdev(dev);
 509
 510 } /* netwave_detach */
 511
 512 /*
 513  * Wireless Handler : get protocol name
 514  */
 515 static int netwave_get_name(struct net_device *dev,
 516                             struct iw_request_info *info,
 517                             union iwreq_data *wrqu,
 518                             char *extra)
 519 {
 520         strcpy(wrqu->name, "Netwave");
 521         return 0;
 522 }
 523
 524 /*
 525  * Wireless Handler : set Network ID
 526  */
 527 static int netwave_set_nwid(struct net_device *dev,
 528                             struct iw_request_info *info,
 529                             union iwreq_data *wrqu,
 530                             char *extra)
 531 {
 532         unsigned long flags;
 533         kio_addr_t iobase = dev->base_addr;
 534         netwave_private *priv = netdev_priv(dev);
 535         u_char __iomem *ramBase = priv->ramBase;
 536
 537         /* Disable interrupts & save flags */
 538         spin_lock_irqsave(&priv->spinlock, flags);
 539
 540         if(!wrqu->nwid.disabled) {
 541             domain = wrqu->nwid.value;
 542             printk( KERN_DEBUG "Setting domain to 0x%x%02x\n",
 543                     (domain >> 8) & 0x01, domain & 0xff);
 544             wait_WOC(iobase);
 545             writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
 546             writeb( domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
 547             writeb((domain >>8 ) & 0x01,ramBase + NETWAVE_EREG_CB+2);
 548             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
 549         }
 550
 551         /* ReEnable interrupts & restore flags */
 552         spin_unlock_irqrestore(&priv->spinlock, flags);
 553
 554         return 0;
 555 }
 556
 557 /*
 558  * Wireless Handler : get Network ID
 559  */
 560 static int netwave_get_nwid(struct net_device *dev,
 561                             struct iw_request_info *info,
 562                             union iwreq_data *wrqu,
 563                             char *extra)
 564 {
 565         wrqu->nwid.value = domain;
 566         wrqu->nwid.disabled = 0;
 567         wrqu->nwid.fixed = 1;
 568         return 0;
 569 }
 570
 571 /*
 572  * Wireless Handler : set scramble key
 573  */
 574 static int netwave_set_scramble(struct net_device *dev,
 575                                 struct iw_request_info *info,
 576                                 union iwreq_data *wrqu,
 577                                 char *key)
 578 {
 579         unsigned long flags;
 580         kio_addr_t iobase = dev->base_addr;
 581         netwave_private *priv = netdev_priv(dev);
 582         u_char __iomem *ramBase = priv->ramBase;
 583
 584         /* Disable interrupts & save flags */
 585         spin_lock_irqsave(&priv->spinlock, flags);
 586
 587         scramble_key = (key[0] << 8) | key[1];
 588         wait_WOC(iobase);
 589         writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
 590         writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
 591         writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
 592         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
 593
 594         /* ReEnable interrupts & restore flags */
 595         spin_unlock_irqrestore(&priv->spinlock, flags);
 596
 597         return 0;
 598 }
 599
 600 /*
 601  * Wireless Handler : get scramble key
 602  */
 603 static int netwave_get_scramble(struct net_device *dev,
 604                                 struct iw_request_info *info,
 605                                 union iwreq_data *wrqu,
 606                                 char *key)
 607 {
 608         key[1] = scramble_key & 0xff;
 609         key[0] = (scramble_key>>8) & 0xff;
 610         wrqu->encoding.flags = IW_ENCODE_ENABLED;
 611         wrqu->encoding.length = 2;
 612         return 0;
 613 }
 614
 615 /*
 616  * Wireless Handler : get mode
 617  */
 618 static int netwave_get_mode(struct net_device *dev,
 619                             struct iw_request_info *info,
 620                             union iwreq_data *wrqu,
 621                             char *extra)
 622 {
 623         if(domain & 0x100)
 624                 wrqu->mode = IW_MODE_INFRA;
 625         else
 626                 wrqu->mode = IW_MODE_ADHOC;
 627
 628         return 0;
 629 }
 630
 631 /*
 632  * Wireless Handler : get range info
 633  */
 634 static int netwave_get_range(struct net_device *dev,
 635                              struct iw_request_info *info,
 636                              union iwreq_data *wrqu,
 637                              char *extra)
 638 {
 639         struct iw_range *range = (struct iw_range *) extra;
 640         int ret = 0;
 641
 642         /* Set the length (very important for backward compatibility) */
 643         wrqu->data.length = sizeof(struct iw_range);
 644
 645         /* Set all the info we don't care or don't know about to zero */
 646         memset(range, 0, sizeof(struct iw_range));
 647
 648         /* Set the Wireless Extension versions */
 649         range->we_version_compiled = WIRELESS_EXT;
 650         range->we_version_source = 9;   /* Nothing for us in v10 and v11 */
 651
 652         /* Set information in the range struct */
 653         range->throughput = 450 * 1000; /* don't argue on this ! */
 654         range->min_nwid = 0x0000;
 655         range->max_nwid = 0x01FF;
 656
 657         range->num_channels = range->num_frequency = 0;
 658
 659         range->sensitivity = 0x3F;
 660         range->max_qual.qual = 255;
 661         range->max_qual.level = 255;
 662         range->max_qual.noise = 0;
 663
 664         range->num_bitrates = 1;
 665         range->bitrate[0] = 1000000;    /* 1 Mb/s */
 666
 667         range->encoding_size[0] = 2;            /* 16 bits scrambling */
 668         range->num_encoding_sizes = 1;
 669         range->max_encoding_tokens = 1; /* Only one key possible */
 670
 671         return ret;
 672 }
 673
 674 /*
 675  * Wireless Private Handler : get snapshot
 676  */
 677 static int netwave_get_snap(struct net_device *dev,
 678                             struct iw_request_info *info,
 679                             union iwreq_data *wrqu,
 680                             char *extra)
 681 {
 682         unsigned long flags;
 683         kio_addr_t iobase = dev->base_addr;
 684         netwave_private *priv = netdev_priv(dev);
 685         u_char __iomem *ramBase = priv->ramBase;
 686
 687         /* Disable interrupts & save flags */
 688         spin_lock_irqsave(&priv->spinlock, flags);
 689
 690         /* Take snapshot of environment */
 691         netwave_snapshot( priv, ramBase, iobase);
 692         wrqu->data.length = priv->nss.length;
 693         memcpy(extra, (u_char *) &priv->nss, sizeof( struct site_survey));
 694
 695         priv->lastExec = jiffies;
 696
 697         /* ReEnable interrupts & restore flags */
 698         spin_unlock_irqrestore(&priv->spinlock, flags);
 699
 700         return(0);
 701 }
 702
 703 /*
 704  * Structures to export the Wireless Handlers
 705  *     This is the stuff that are treated the wireless extensions (iwconfig)
 706  */
 707
 708 static const struct iw_priv_args netwave_private_args[] = {
 709 /*{ cmd,         set_args,                            get_args, name } */
 710   { SIOCGIPSNAP, 0,
 711     IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof(struct site_survey),
 712     "getsitesurvey" },
 713 };
 714
 715 static const iw_handler         netwave_handler[] =
 716 {
 717         NULL,                           /* SIOCSIWNAME */
 718         netwave_get_name,               /* SIOCGIWNAME */
 719         netwave_set_nwid,               /* SIOCSIWNWID */
 720         netwave_get_nwid,               /* SIOCGIWNWID */
 721         NULL,                           /* SIOCSIWFREQ */
 722         NULL,                           /* SIOCGIWFREQ */
 723         NULL,                           /* SIOCSIWMODE */
 724         netwave_get_mode,               /* SIOCGIWMODE */
 725         NULL,                           /* SIOCSIWSENS */
 726         NULL,                           /* SIOCGIWSENS */
 727         NULL,                           /* SIOCSIWRANGE */
 728         netwave_get_range,              /* SIOCGIWRANGE */
 729         NULL,                           /* SIOCSIWPRIV */
 730         NULL,                           /* SIOCGIWPRIV */
 731         NULL,                           /* SIOCSIWSTATS */
 732         NULL,                           /* SIOCGIWSTATS */
 733         NULL,                           /* SIOCSIWSPY */
 734         NULL,                           /* SIOCGIWSPY */
 735         NULL,                           /* -- hole -- */
 736         NULL,                           /* -- hole -- */
 737         NULL,                           /* SIOCSIWAP */
 738         NULL,                           /* SIOCGIWAP */
 739         NULL,                           /* -- hole -- */
 740         NULL,                           /* SIOCGIWAPLIST */
 741         NULL,                           /* -- hole -- */
 742         NULL,                           /* -- hole -- */
 743         NULL,                           /* SIOCSIWESSID */
 744         NULL,                           /* SIOCGIWESSID */
 745         NULL,                           /* SIOCSIWNICKN */
 746         NULL,                           /* SIOCGIWNICKN */
 747         NULL,                           /* -- hole -- */
 748         NULL,                           /* -- hole -- */
 749         NULL,                           /* SIOCSIWRATE */
 750         NULL,                           /* SIOCGIWRATE */
 751         NULL,                           /* SIOCSIWRTS */
 752         NULL,                           /* SIOCGIWRTS */
 753         NULL,                           /* SIOCSIWFRAG */
 754         NULL,                           /* SIOCGIWFRAG */
 755         NULL,                           /* SIOCSIWTXPOW */
 756         NULL,                           /* SIOCGIWTXPOW */
 757         NULL,                           /* SIOCSIWRETRY */
 758         NULL,                           /* SIOCGIWRETRY */
 759         netwave_set_scramble,           /* SIOCSIWENCODE */
 760         netwave_get_scramble,           /* SIOCGIWENCODE */
 761 };
 762
 763 static const iw_handler         netwave_private_handler[] =
 764 {
 765         NULL,                           /* SIOCIWFIRSTPRIV */
 766         netwave_get_snap,               /* SIOCIWFIRSTPRIV + 1 */
 767 };
 768
 769 static const struct iw_handler_def      netwave_handler_def =
 770 {
 771         .num_standard   = sizeof(netwave_handler)/sizeof(iw_handler),
 772         .num_private    = sizeof(netwave_private_handler)/sizeof(iw_handler),
 773         .num_private_args = sizeof(netwave_private_args)/sizeof(struct iw_priv_args),
 774         .standard       = (iw_handler *) netwave_handler,
 775         .private        = (iw_handler *) netwave_private_handler,
 776         .private_args   = (struct iw_priv_args *) netwave_private_args,
 777         .get_wireless_stats = netwave_get_wireless_stats,
 778 };
 779
 780 /*
 781  * Function netwave_pcmcia_config (link)
 782  *
 783  *     netwave_pcmcia_config() is scheduled to run after a CARD_INSERTION
 784  *     event is received, to configure the PCMCIA socket, and to make the
 785  *     device available to the system.
 786  *
 787  */
 788
 789 #define CS_CHECK(fn, ret) \
 790 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 791
 792 static void netwave_pcmcia_config(dev_link_t *link) {
 793     client_handle_t handle = link->handle;
 794     struct net_device *dev = link->priv;
 795     netwave_private *priv = netdev_priv(dev);
 796     tuple_t tuple;
 797     cisparse_t parse;
 798     int i, j, last_ret, last_fn;
 799     u_char buf[64];
 800     win_req_t req;
 801     memreq_t mem;
 802     u_char __iomem *ramBase = NULL;
 803
 804     DEBUG(0, "netwave_pcmcia_config(0x%p)\n", link);
 805
 806     /*
 807       This reads the card's CONFIG tuple to find its configuration
 808       registers.
 809     */
 810     tuple.Attributes = 0;
 811     tuple.TupleData = (cisdata_t *) buf;
 812     tuple.TupleDataMax = 64;
 813     tuple.TupleOffset = 0;
 814     tuple.DesiredTuple = CISTPL_CONFIG;
 815     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 816     CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 817     CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 818     link->conf.ConfigBase = parse.config.base;
 819     link->conf.Present = parse.config.rmask[0];
 820
 821     /* Configure card */
 822     link->state |= DEV_CONFIG;
 823
 824     /*
 825      *  Try allocating IO ports.  This tries a few fixed addresses.
 826      *  If you want, you can also read the card's config table to
 827      *  pick addresses -- see the serial driver for an example.
 828      */
 829     for (i = j = 0x0; j < 0x400; j += 0x20) {
 830         link->io.BasePort1 = j ^ 0x300;
 831         i = pcmcia_request_io(link->handle, &link->io);
 832         if (i == CS_SUCCESS) break;
 833     }
 834     if (i != CS_SUCCESS) {
 835         cs_error(link->handle, RequestIO, i);
 836         goto failed;
 837     }
 838
 839     /*
 840      *  Now allocate an interrupt line.  Note that this does not
 841      *  actually assign a handler to the interrupt.
 842      */
 843     CS_CHECK(RequestIRQ, pcmcia_request_irq(handle, &link->irq));
 844
 845     /*
 846      *  This actually configures the PCMCIA socket -- setting up
 847      *  the I/O windows and the interrupt mapping.
 848      */
 849     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(handle, &link->conf));
 850
 851     /*
 852      *  Allocate a 32K memory window.  Note that the dev_link_t
 853      *  structure provides space for one window handle -- if your
 854      *  device needs several windows, you'll need to keep track of
 855      *  the handles in your private data structure, dev->priv.
 856      */
 857     DEBUG(1, "Setting mem speed of %d\n", mem_speed);
 858
 859     req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
 860     req.Base = 0; req.Size = 0x8000;
 861     req.AccessSpeed = mem_speed;
 862     CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &link->win));
 863     mem.CardOffset = 0x20000; mem.Page = 0;
 864     CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
 865
 866     /* Store base address of the common window frame */
 867     ramBase = ioremap(req.Base, 0x8000);
 868     priv->ramBase = ramBase;
 869
 870     dev->irq = link->irq.AssignedIRQ;
 871     dev->base_addr = link->io.BasePort1;
 872     SET_NETDEV_DEV(dev, &handle_to_dev(handle));
 873
 874     if (register_netdev(dev) != 0) {
 875         printk(KERN_DEBUG "netwave_cs: register_netdev() failed\n");
 876         goto failed;
 877     }
 878
 879     strcpy(priv->node.dev_name, dev->name);
 880     link->dev = &priv->node;
 881     link->state &= ~DEV_CONFIG_PENDING;
 882
 883     /* Reset card before reading physical address */
 884     netwave_doreset(dev->base_addr, ramBase);
 885
 886     /* Read the ethernet address and fill in the Netwave registers. */
 887     for (i = 0; i < 6; i++)
 888         dev->dev_addr[i] = readb(ramBase + NETWAVE_EREG_PA + i);
 889
 890     printk(KERN_INFO "%s: Netwave: port %#3lx, irq %d, mem %lx id "
 891            "%c%c, hw_addr ", dev->name, dev->base_addr, dev->irq,
 892            (u_long) ramBase, (int) readb(ramBase+NETWAVE_EREG_NI),
 893            (int) readb(ramBase+NETWAVE_EREG_NI+1));
 894     for (i = 0; i < 6; i++)
 895         printk("%02X%s", dev->dev_addr[i], ((i<5) ? ":" : "\n"));
 896
 897     /* get revision words */
 898     printk(KERN_DEBUG "Netwave_reset: revision %04x %04x\n",
 899            get_uint16(ramBase + NETWAVE_EREG_ARW),
 900            get_uint16(ramBase + NETWAVE_EREG_ARW+2));
 901     return;
 902
 903 cs_failed:
 904     cs_error(link->handle, last_fn, last_ret);
 905 failed:
 906     netwave_release(link);
 907 } /* netwave_pcmcia_config */
 908
 909 /*
 910  * Function netwave_release (arg)
 911  *
 912  *    After a card is removed, netwave_release() will unregister the net
 913  *    device, and release the PCMCIA configuration.  If the device is
 914  *    still open, this will be postponed until it is closed.
 915  */
 916 static void netwave_release(dev_link_t *link)
 917 {
 918     struct net_device *dev = link->priv;
 919     netwave_private *priv = netdev_priv(dev);
 920
 921     DEBUG(0, "netwave_release(0x%p)\n", link);
 922
 923     /* Don't bother checking to see if these succeed or not */
 924     if (link->win) {
 925         iounmap(priv->ramBase);
 926         pcmcia_release_window(link->win);
 927     }
 928     pcmcia_release_configuration(link->handle);
 929     pcmcia_release_io(link->handle, &link->io);
 930     pcmcia_release_irq(link->handle, &link->irq);
 931
 932     link->state &= ~DEV_CONFIG;
 933 }
 934
 935 static int netwave_suspend(struct pcmcia_device *p_dev)
 936 {
 937         dev_link_t *link = dev_to_instance(p_dev);
 938         struct net_device *dev = link->priv;
 939
 940         link->state |= DEV_SUSPEND;
 941         if (link->state & DEV_CONFIG) {
 942                 if (link->open)
 943                         netif_device_detach(dev);
 944                 pcmcia_release_configuration(link->handle);
 945         }
 946
 947         return 0;
 948 }
 949
 950 static int netwave_resume(struct pcmcia_device *p_dev)
 951 {
 952         dev_link_t *link = dev_to_instance(p_dev);
 953         struct net_device *dev = link->priv;
 954
 955         link->state &= ~DEV_SUSPEND;
 956         if (link->state & DEV_CONFIG) {
 957                 pcmcia_request_configuration(link->handle, &link->conf);
 958                 if (link->open) {
 959                         netwave_reset(dev);
 960                         netif_device_attach(dev);
 961                 }
 962         }
 963
 964         return 0;
 965 }
 966
 967
 968 /*
 969  * Function netwave_event (event, priority, args)
 970  *
 971  *    The card status event handler.  Mostly, this schedules other
 972  *    stuff to run after an event is received.  A CARD_REMOVAL event
 973  *    also sets some flags to discourage the net drivers from trying
 974  *    to talk to the card any more.
 975  *
 976  *    When a CARD_REMOVAL event is received, we immediately set a flag
 977  *    to block future accesses to this device.  All the functions that
 978  *    actually access the device should check this flag to make sure
 979  *    the card is still present.
 980  *
 981  */
 982 static int netwave_event(event_t event, int priority,
 983                          event_callback_args_t *args)
 984 {
 985     dev_link_t *link = args->client_data;
 986
 987     DEBUG(1, "netwave_event(0x%06x)\n", event);
 988
 989     switch (event) {
 990     case CS_EVENT_CARD_INSERTION:
 991         link->state |= DEV_PRESENT | DEV_CONFIG_PENDING;
 992         netwave_pcmcia_config( link);
 993         break;
 994     }
 995     return 0;
 996 } /* netwave_event */
 997
 998 /*
 999  * Function netwave_doreset (ioBase, ramBase)
1000  *
1001  *    Proper hardware reset of the card.
1002  */
1003 static void netwave_doreset(kio_addr_t ioBase, u_char __iomem *ramBase)
1004 {
1005     /* Reset card */
1006     wait_WOC(ioBase);
1007     outb(0x80, ioBase + NETWAVE_REG_PMR);
1008     writeb(0x08, ramBase + NETWAVE_EREG_ASCC); /* Bit 3 is WOC */
1009     outb(0x0, ioBase + NETWAVE_REG_PMR); /* release reset */
1010 }
1011
1012 /*
1013  * Function netwave_reset (dev)
1014  *
1015  *    Reset and restore all of the netwave registers
1016  */
1017 static void netwave_reset(struct net_device *dev) {
1018     /* u_char state; */
1019     netwave_private *priv = netdev_priv(dev);
1020     u_char __iomem *ramBase = priv->ramBase;
1021     kio_addr_t iobase = dev->base_addr;
1022
1023     DEBUG(0, "netwave_reset: Done with hardware reset\n");
1024
1025     priv->timeoutCounter = 0;
1026
1027     /* Reset card */
1028     netwave_doreset(iobase, ramBase);
1029     printk(KERN_DEBUG "netwave_reset: Done with hardware reset\n");
1030
1031     /* Write a NOP to check the card */
1032     wait_WOC(iobase);
1033     writeb(NETWAVE_CMD_NOP, ramBase + NETWAVE_EREG_CB + 0);
1034     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1035
1036     /* Set receive conf */
1037     wait_WOC(iobase);
1038     writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1039     writeb(rxConfRxEna + rxConfBcast, ramBase + NETWAVE_EREG_CB + 1);
1040     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1041
1042     /* Set transmit conf */
1043     wait_WOC(iobase);
1044     writeb(NETWAVE_CMD_STC, ramBase + NETWAVE_EREG_CB + 0);
1045     writeb(txConfTxEna, ramBase + NETWAVE_EREG_CB + 1);
1046     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1047
1048     /* Now set the MU Domain */
1049     printk(KERN_DEBUG "Setting domain to 0x%x%02x\n", (domain >> 8) & 0x01, domain & 0xff);
1050     wait_WOC(iobase);
1051     writeb(NETWAVE_CMD_SMD, ramBase + NETWAVE_EREG_CB + 0);
1052     writeb(domain & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1053     writeb((domain>>8) & 0x01, ramBase + NETWAVE_EREG_CB + 2);
1054     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1055
1056     /* Set scramble key */
1057     printk(KERN_DEBUG "Setting scramble key to 0x%x\n", scramble_key);
1058     wait_WOC(iobase);
1059     writeb(NETWAVE_CMD_SSK, ramBase + NETWAVE_EREG_CB + 0);
1060     writeb(scramble_key & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1061     writeb((scramble_key>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1062     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1063
1064     /* Enable interrupts, bit 4 high to keep unused
1065      * source from interrupting us, bit 2 high to
1066      * set interrupt enable, 567 to enable TxDN,
1067      * RxErr and RxRdy
1068      */
1069     wait_WOC(iobase);
1070     outb(imrConfIENA+imrConfRFU1, iobase + NETWAVE_REG_IMR);
1071
1072     /* Hent 4 bytes fra 0x170. Skal vaere 0a,29,88,36
1073      * waitWOC
1074      * skriv 80 til d000:3688
1075      * sjekk om det ble 80
1076      */
1077
1078     /* Enable Receiver */
1079     wait_WOC(iobase);
1080     writeb(NETWAVE_CMD_ER, ramBase + NETWAVE_EREG_CB + 0);
1081     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1082
1083     /* Set the IENA bit in COR */
1084     wait_WOC(iobase);
1085     outb(corConfIENA + corConfLVLREQ, iobase + NETWAVE_REG_COR);
1086 }
1087
1088 /*
1089  * Function netwave_hw_xmit (data, len, dev)
1090  */
1091 static int netwave_hw_xmit(unsigned char* data, int len,
1092                            struct net_device* dev) {
1093     unsigned long flags;
1094     unsigned int TxFreeList,
1095                  curBuff,
1096                  MaxData,
1097                  DataOffset;
1098     int tmpcount;
1099
1100     netwave_private *priv = netdev_priv(dev);
1101     u_char __iomem * ramBase = priv->ramBase;
1102     kio_addr_t iobase = dev->base_addr;
1103
1104     /* Disable interrupts & save flags */
1105     spin_lock_irqsave(&priv->spinlock, flags);
1106
1107     /* Check if there are transmit buffers available */
1108     wait_WOC(iobase);
1109     if ((inb(iobase+NETWAVE_REG_ASR) & NETWAVE_ASR_TXBA) == 0) {
1110         /* No buffers available */
1111         printk(KERN_DEBUG "netwave_hw_xmit: %s - no xmit buffers available.\n",
1112                dev->name);
1113         spin_unlock_irqrestore(&priv->spinlock, flags);
1114         return 1;
1115     }
1116
1117     priv->stats.tx_bytes += len;
1118
1119     DEBUG(3, "Transmitting with SPCQ %x SPU %x LIF %x ISPLQ %x\n",
1120           readb(ramBase + NETWAVE_EREG_SPCQ),
1121           readb(ramBase + NETWAVE_EREG_SPU),
1122           readb(ramBase + NETWAVE_EREG_LIF),
1123           readb(ramBase + NETWAVE_EREG_ISPLQ));
1124
1125     /* Now try to insert it into the adapters free memory */
1126     wait_WOC(iobase);
1127     TxFreeList = get_uint16(ramBase + NETWAVE_EREG_TDP);
1128     MaxData    = get_uint16(ramBase + NETWAVE_EREG_TDP+2);
1129     DataOffset = get_uint16(ramBase + NETWAVE_EREG_TDP+4);
1130
1131     DEBUG(3, "TxFreeList %x, MaxData %x, DataOffset %x\n",
1132           TxFreeList, MaxData, DataOffset);
1133
1134     /* Copy packet to the adapter fragment buffers */
1135     curBuff = TxFreeList;
1136     tmpcount = 0;
1137     while (tmpcount < len) {
1138         int tmplen = len - tmpcount;
1139         copy_to_pc(ramBase + curBuff + DataOffset, data + tmpcount,
1140                    (tmplen < MaxData) ? tmplen : MaxData);
1141         tmpcount += MaxData;
1142
1143         /* Advance to next buffer */
1144         curBuff = get_uint16(ramBase + curBuff);
1145     }
1146
1147     /* Now issue transmit list */
1148     wait_WOC(iobase);
1149     writeb(NETWAVE_CMD_TL, ramBase + NETWAVE_EREG_CB + 0);
1150     writeb(len & 0xff, ramBase + NETWAVE_EREG_CB + 1);
1151     writeb((len>>8) & 0xff, ramBase + NETWAVE_EREG_CB + 2);
1152     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 3);
1153
1154     spin_unlock_irqrestore(&priv->spinlock, flags);
1155     return 0;
1156 }
1157
1158 static int netwave_start_xmit(struct sk_buff *skb, struct net_device *dev) {
1159         /* This flag indicate that the hardware can't perform a transmission.
1160          * Theoritically, NET3 check it before sending a packet to the driver,
1161          * but in fact it never do that and pool continuously.
1162          * As the watchdog will abort too long transmissions, we are quite safe...
1163          */
1164
1165     netif_stop_queue(dev);
1166
1167     {
1168         short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1169         unsigned char* buf = skb->data;
1170
1171         if (netwave_hw_xmit( buf, length, dev) == 1) {
1172             /* Some error, let's make them call us another time? */
1173             netif_start_queue(dev);
1174         }
1175         dev->trans_start = jiffies;
1176     }
1177     dev_kfree_skb(skb);
1178
1179     return 0;
1180 } /* netwave_start_xmit */
1181
1182 /*
1183  * Function netwave_interrupt (irq, dev_id, regs)
1184  *
1185  *    This function is the interrupt handler for the Netwave card. This
1186  *    routine will be called whenever:
1187  *        1. A packet is received.
1188  *        2. A packet has successfully been transferred and the unit is
1189  *           ready to transmit another packet.
1190  *        3. A command has completed execution.
1191  */
1192 static irqreturn_t netwave_interrupt(int irq, void* dev_id, struct pt_regs *regs)
1193 {
1194     kio_addr_t iobase;
1195     u_char __iomem *ramBase;
1196     struct net_device *dev = (struct net_device *)dev_id;
1197     struct netwave_private *priv = netdev_priv(dev);
1198     dev_link_t *link = &priv->link;
1199     int i;
1200
1201     if (!netif_device_present(dev))
1202         return IRQ_NONE;
1203
1204     iobase = dev->base_addr;
1205     ramBase = priv->ramBase;
1206
1207     /* Now find what caused the interrupt, check while interrupts ready */
1208     for (i = 0; i < 10; i++) {
1209         u_char status;
1210
1211         wait_WOC(iobase);
1212         if (!(inb(iobase+NETWAVE_REG_CCSR) & 0x02))
1213             break; /* None of the interrupt sources asserted (normal exit) */
1214
1215         status = inb(iobase + NETWAVE_REG_ASR);
1216
1217         if (!DEV_OK(link)) {
1218             DEBUG(1, "netwave_interrupt: Interrupt with status 0x%x "
1219                   "from removed or suspended card!\n", status);
1220             break;
1221         }
1222
1223         /* RxRdy */
1224         if (status & 0x80) {
1225             netwave_rx(dev);
1226             /* wait_WOC(iobase); */
1227             /* RxRdy cannot be reset directly by the host */
1228         }
1229         /* RxErr */
1230         if (status & 0x40) {
1231             u_char rser;
1232
1233             rser = readb(ramBase + NETWAVE_EREG_RSER);
1234
1235             if (rser & 0x04) {
1236                 ++priv->stats.rx_dropped;
1237                 ++priv->stats.rx_crc_errors;
1238             }
1239             if (rser & 0x02)
1240                 ++priv->stats.rx_frame_errors;
1241
1242             /* Clear the RxErr bit in RSER. RSER+4 is the
1243              * write part. Also clear the RxCRC (0x04) and
1244              * RxBig (0x02) bits if present */
1245             wait_WOC(iobase);
1246             writeb(0x40 | (rser & 0x06), ramBase + NETWAVE_EREG_RSER + 4);
1247
1248             /* Write bit 6 high to ASCC to clear RxErr in ASR,
1249              * WOC must be set first!
1250              */
1251             wait_WOC(iobase);
1252             writeb(0x40, ramBase + NETWAVE_EREG_ASCC);
1253
1254             /* Remember to count up priv->stats on error packets */
1255             ++priv->stats.rx_errors;
1256         }
1257         /* TxDN */
1258         if (status & 0x20) {
1259             int txStatus;
1260
1261             txStatus = readb(ramBase + NETWAVE_EREG_TSER);
1262             DEBUG(3, "Transmit done. TSER = %x id %x\n",
1263                   txStatus, readb(ramBase + NETWAVE_EREG_TSER + 1));
1264
1265             if (txStatus & 0x20) {
1266                 /* Transmitting was okay, clear bits */
1267                 wait_WOC(iobase);
1268                 writeb(0x2f, ramBase + NETWAVE_EREG_TSER + 4);
1269                 ++priv->stats.tx_packets;
1270             }
1271
1272             if (txStatus & 0xd0) {
1273                 if (txStatus & 0x80) {
1274                     ++priv->stats.collisions; /* Because of /proc/net/dev*/
1275                     /* ++priv->stats.tx_aborted_errors; */
1276                     /* printk("Collision. %ld\n", jiffies - dev->trans_start); */
1277                 }
1278                 if (txStatus & 0x40)
1279                     ++priv->stats.tx_carrier_errors;
1280                 /* 0x80 TxGU Transmit giveup - nine times and no luck
1281                  * 0x40 TxNOAP No access point. Discarded packet.
1282                  * 0x10 TxErr Transmit error. Always set when
1283                  *      TxGU and TxNOAP is set. (Those are the only ones
1284                  *      to set TxErr).
1285                  */
1286                 DEBUG(3, "netwave_interrupt: TxDN with error status %x\n",
1287                       txStatus);
1288
1289                 /* Clear out TxGU, TxNOAP, TxErr and TxTrys */
1290                 wait_WOC(iobase);
1291                 writeb(0xdf & txStatus, ramBase+NETWAVE_EREG_TSER+4);
1292                 ++priv->stats.tx_errors;
1293             }
1294             DEBUG(3, "New status is TSER %x ASR %x\n",
1295                   readb(ramBase + NETWAVE_EREG_TSER),
1296                   inb(iobase + NETWAVE_REG_ASR));
1297
1298             netif_wake_queue(dev);
1299         }
1300         /* TxBA, this would trigger on all error packets received */
1301         /* if (status & 0x01) {
1302            DEBUG(4, "Transmit buffers available, %x\n", status);
1303            }
1304            */
1305     }
1306     /* Handled if we looped at least one time - Jean II */
1307     return IRQ_RETVAL(i);
1308 } /* netwave_interrupt */
1309
1310 /*
1311  * Function netwave_watchdog (a)
1312  *
1313  *    Watchdog : when we start a transmission, we set a timer in the
1314  *    kernel.  If the transmission complete, this timer is disabled. If
1315  *    it expire, we reset the card.
1316  *
1317  */
1318 static void netwave_watchdog(struct net_device *dev) {
1319
1320     DEBUG(1, "%s: netwave_watchdog: watchdog timer expired\n", dev->name);
1321     netwave_reset(dev);
1322     dev->trans_start = jiffies;
1323     netif_wake_queue(dev);
1324 } /* netwave_watchdog */
1325
1326 static struct net_device_stats *netwave_get_stats(struct net_device *dev) {
1327     netwave_private *priv = netdev_priv(dev);
1328
1329     update_stats(dev);
1330
1331     DEBUG(2, "netwave: SPCQ %x SPU %x LIF %x ISPLQ %x MHS %x rxtx %x"
1332           " %x tx %x %x %x %x\n",
1333           readb(priv->ramBase + NETWAVE_EREG_SPCQ),
1334           readb(priv->ramBase + NETWAVE_EREG_SPU),
1335           readb(priv->ramBase + NETWAVE_EREG_LIF),
1336           readb(priv->ramBase + NETWAVE_EREG_ISPLQ),
1337           readb(priv->ramBase + NETWAVE_EREG_MHS),
1338           readb(priv->ramBase + NETWAVE_EREG_EC + 0xe),
1339           readb(priv->ramBase + NETWAVE_EREG_EC + 0xf),
1340           readb(priv->ramBase + NETWAVE_EREG_EC + 0x18),
1341           readb(priv->ramBase + NETWAVE_EREG_EC + 0x19),
1342           readb(priv->ramBase + NETWAVE_EREG_EC + 0x1a),
1343           readb(priv->ramBase + NETWAVE_EREG_EC + 0x1b));
1344
1345     return &priv->stats;
1346 }
1347
1348 static void update_stats(struct net_device *dev) {
1349     //unsigned long flags;
1350 /*     netwave_private *priv = netdev_priv(dev); */
1351
1352     //spin_lock_irqsave(&priv->spinlock, flags);
1353
1354 /*    priv->stats.rx_packets = readb(priv->ramBase + 0x18e);
1355     priv->stats.tx_packets = readb(priv->ramBase + 0x18f); */
1356
1357     //spin_unlock_irqrestore(&priv->spinlock, flags);
1358 }
1359
1360 static int netwave_rx(struct net_device *dev)
1361 {
1362     netwave_private *priv = netdev_priv(dev);
1363     u_char __iomem *ramBase = priv->ramBase;
1364     kio_addr_t iobase = dev->base_addr;
1365     u_char rxStatus;
1366     struct sk_buff *skb = NULL;
1367     unsigned int curBuffer,
1368                 rcvList;
1369     int rcvLen;
1370     int tmpcount = 0;
1371     int dataCount, dataOffset;
1372     int i;
1373     u_char *ptr;
1374
1375     DEBUG(3, "xinw_rx: Receiving ... \n");
1376
1377     /* Receive max 10 packets for now. */
1378     for (i = 0; i < 10; i++) {
1379         /* Any packets? */
1380         wait_WOC(iobase);
1381         rxStatus = readb(ramBase + NETWAVE_EREG_RSER);
1382         if ( !( rxStatus & 0x80)) /* No more packets */
1383             break;
1384
1385         /* Check if multicast/broadcast or other */
1386         /* multicast = (rxStatus & 0x20);  */
1387
1388         /* The receive list pointer and length of the packet */
1389         wait_WOC(iobase);
1390         rcvLen  = get_int16( ramBase + NETWAVE_EREG_RDP);
1391         rcvList = get_uint16( ramBase + NETWAVE_EREG_RDP + 2);
1392
1393         if (rcvLen < 0) {
1394             printk(KERN_DEBUG "netwave_rx: Receive packet with len %d\n",
1395                    rcvLen);
1396             return 0;
1397         }
1398
1399         skb = dev_alloc_skb(rcvLen+5);
1400         if (skb == NULL) {
1401             DEBUG(1, "netwave_rx: Could not allocate an sk_buff of "
1402                   "length %d\n", rcvLen);
1403             ++priv->stats.rx_dropped;
1404             /* Tell the adapter to skip the packet */
1405             wait_WOC(iobase);
1406             writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1407             writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1408             return 0;
1409         }
1410
1411         skb_reserve( skb, 2);  /* Align IP on 16 byte */
1412         skb_put( skb, rcvLen);
1413         skb->dev = dev;
1414
1415         /* Copy packet fragments to the skb data area */
1416         ptr = (u_char*) skb->data;
1417         curBuffer = rcvList;
1418         tmpcount = 0;
1419         while ( tmpcount < rcvLen) {
1420             /* Get length and offset of current buffer */
1421             dataCount  = get_uint16( ramBase+curBuffer+2);
1422             dataOffset = get_uint16( ramBase+curBuffer+4);
1423
1424             copy_from_pc( ptr + tmpcount,
1425                           ramBase+curBuffer+dataOffset, dataCount);
1426
1427             tmpcount += dataCount;
1428
1429             /* Point to next buffer */
1430             curBuffer = get_uint16(ramBase + curBuffer);
1431         }
1432
1433         skb->protocol = eth_type_trans(skb,dev);
1434         /* Queue packet for network layer */
1435         netif_rx(skb);
1436
1437         dev->last_rx = jiffies;
1438         priv->stats.rx_packets++;
1439         priv->stats.rx_bytes += rcvLen;
1440
1441         /* Got the packet, tell the adapter to skip it */
1442         wait_WOC(iobase);
1443         writeb(NETWAVE_CMD_SRP, ramBase + NETWAVE_EREG_CB + 0);
1444         writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 1);
1445         DEBUG(3, "Packet reception ok\n");
1446     }
1447     return 0;
1448 }
1449
1450 static int netwave_open(struct net_device *dev) {
1451     netwave_private *priv = netdev_priv(dev);
1452     dev_link_t *link = &priv->link;
1453
1454     DEBUG(1, "netwave_open: starting.\n");
1455
1456     if (!DEV_OK(link))
1457         return -ENODEV;
1458
1459     link->open++;
1460
1461     netif_start_queue(dev);
1462     netwave_reset(dev);
1463
1464     return 0;
1465 }
1466
1467 static int netwave_close(struct net_device *dev) {
1468     netwave_private *priv = netdev_priv(dev);
1469     dev_link_t *link = &priv->link;
1470
1471     DEBUG(1, "netwave_close: finishing.\n");
1472
1473     link->open--;
1474     netif_stop_queue(dev);
1475
1476     return 0;
1477 }
1478
1479 static struct pcmcia_device_id netwave_ids[] = {
1480         PCMCIA_DEVICE_PROD_ID12("Xircom", "CreditCard Netwave", 0x2e3ee845, 0x54e28a28),
1481         PCMCIA_DEVICE_NULL,
1482 };
1483 MODULE_DEVICE_TABLE(pcmcia, netwave_ids);
1484
1485 static struct pcmcia_driver netwave_driver = {
1486         .owner          = THIS_MODULE,
1487         .drv            = {
1488                 .name   = "netwave_cs",
1489         },
1490         .attach         = netwave_attach,
1491         .event          = netwave_event,
1492         .remove         = netwave_detach,
1493         .id_table       = netwave_ids,
1494         .suspend        = netwave_suspend,
1495         .resume         = netwave_resume,
1496 };
1497
1498 static int __init init_netwave_cs(void)
1499 {
1500         return pcmcia_register_driver(&netwave_driver);
1501 }
1502
1503 static void __exit exit_netwave_cs(void)
1504 {
1505         pcmcia_unregister_driver(&netwave_driver);
1506         BUG_ON(dev_list != NULL);
1507 }
1508
1509 module_init(init_netwave_cs);
1510 module_exit(exit_netwave_cs);
1511
1512 /* Set or clear the multicast filter for this adaptor.
1513    num_addrs == -1      Promiscuous mode, receive all packets
1514    num_addrs == 0       Normal mode, clear multicast list
1515    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
1516    best-effort filtering.
1517  */
1518 static void set_multicast_list(struct net_device *dev)
1519 {
1520     kio_addr_t iobase = dev->base_addr;
1521     netwave_private *priv = netdev_priv(dev);
1522     u_char __iomem * ramBase = priv->ramBase;
1523     u_char  rcvMode = 0;
1524
1525 #ifdef PCMCIA_DEBUG
1526     if (pc_debug > 2) {
1527         static int old;
1528         if (old != dev->mc_count) {
1529             old = dev->mc_count;
1530             DEBUG(0, "%s: setting Rx mode to %d addresses.\n",
1531                   dev->name, dev->mc_count);
1532         }
1533     }
1534 #endif
1535
1536     if (dev->mc_count || (dev->flags & IFF_ALLMULTI)) {
1537         /* Multicast Mode */
1538         rcvMode = rxConfRxEna + rxConfAMP + rxConfBcast;
1539     } else if (dev->flags & IFF_PROMISC) {
1540         /* Promiscous mode */
1541         rcvMode = rxConfRxEna + rxConfPro + rxConfAMP + rxConfBcast;
1542     } else {
1543         /* Normal mode */
1544         rcvMode = rxConfRxEna + rxConfBcast;
1545     }
1546
1547     /* printk("netwave set_multicast_list: rcvMode to %x\n", rcvMode);*/
1548     /* Now set receive mode */
1549     wait_WOC(iobase);
1550     writeb(NETWAVE_CMD_SRC, ramBase + NETWAVE_EREG_CB + 0);
1551     writeb(rcvMode, ramBase + NETWAVE_EREG_CB + 1);
1552     writeb(NETWAVE_CMD_EOC, ramBase + NETWAVE_EREG_CB + 2);
1553 }
1554 MODULE_LICENSE("GPL");