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