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