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