drivers/net/wireless/netwave_cs.c

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