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