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