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