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