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