drivers/net/ewrk3.c

/* */
This source file includes following definitions.
ewrk3_probe
ewrk3_hw_init
ewrk3_open
ewrk3_init
ewrk3_queue_pkt
ewrk3_interrupt
ewrk3_rx
ewrk3_tx
ewrk3_close
ewrk3_get_stats
set_multicast_list
SetMulticastFilter
isa_probe
eisa_probe
alloc_device
Read_EEPROM
Write_EEPROM
EthwrkSignature
DevicePresent
aprom_crc
ewrk3_ioctl
asc2hex
init_module
cleanup_module
   1 /*  ewrk3.c: A DIGITAL EtherWORKS 3 ethernet driver for linux.
   2 
   3     Written 1994 by David C. Davies.
   4 
   5     Copyright 1994 Digital Equipment Corporation.
   6 
   7     This software may be used and distributed according to the terms of
   8     the GNU Public License, incorporated herein by reference.
   9 
  10     This driver is written for the Digital Equipment Corporation series
  11     of EtherWORKS ethernet cards:
  12 
  13         DE203 Turbo (BNC)
  14         DE204 Turbo (TP)
  15         DE205 Turbo (TP BNC)
  16 
  17     The driver has been tested on a relatively busy  network using the DE205
  18     card and benchmarked with 'ttcp': it transferred 16M  of data at 975kB/s
  19     (7.8Mb/s) to a DECstation 5000/200.
  20 
  21     The author may    be  reached as davies@wanton.lkg.dec.com  or   Digital
  22     Equipment Corporation, 550 King Street, Littleton MA 01460.
  23 
  24     =========================================================================
  25     This driver has been written  substantially  from scratch, although  its
  26     inheritance of style and stack interface from 'depca.c' and in turn from
  27     Donald Becker's 'lance.c' should be obvious.
  28 
  29     The  DE203/4/5 boards  all  use a new proprietary   chip in place of the
  30     LANCE chip used in prior cards  (DEPCA, DE100, DE200/1/2, DE210, DE422).
  31     Use the depca.c driver in the standard distribution  for the LANCE based
  32     cards from DIGITAL; this driver will not work with them.
  33 
  34     The DE203/4/5 cards have 2  main modes: shared memory  and I/O only. I/O
  35     only makes  all the card accesses through  I/O transactions and  no high
  36     (shared)  memory is used. This  mode provides a >48% performance penalty
  37     and  is deprecated in this  driver,  although allowed to provide initial
  38     setup when hardstrapped.
  39 
  40     The shared memory mode comes in 3 flavours: 2kB, 32kB and 64kB. There is
  41     no point in using any mode other than the 2kB  mode - their performances
  42     are virtually identical, although the driver has  been tested in the 2kB
  43     and 32kB modes. I would suggest you uncomment the line:
  44 
  45                              FORCE_2K_MODE;
  46 
  47     to allow the driver to configure the card as a  2kB card at your current
  48     base  address, thus leaving more  room to clutter  your  system box with
  49     other memory hungry boards.
  50 
  51     Upto 21 ISA and 7 EISA cards can be supported under this driver, limited
  52     primarily by the  available  IRQ   lines.   I have   checked   different
  53     configurations  of multiple depca  cards and  ewrk3 cards  and  have not
  54     found a problem yet (provided you have at least depca.c v0.38) ...
  55 
  56     The board IRQ setting   must be at  an unused  IRQ which is  auto-probed
  57     using  Donald  Becker's autoprobe  routines.   All  these cards   are at
  58     {5,10,11,15}.
  59 
  60     No 16MB memory  limitation should exist with this  driver as DMA is  not
  61     used and the common memory area is in low memory on the network card (my
  62     current system has 20MB and I've not had problems yet).
  63 
  64     The ability to load  this driver as a  loadable module has been included
  65     and used  extensively during the  driver development (to save those long
  66     reboot sequences). To utilise this ability, you have to do 8 things:
  67 
  68     0) have a copy of the loadable modules code installed on your system.
  69     1) copy ewrk3.c from the  /linux/drivers/net directory to your favourite
  70     temporary directory.
  71     2) edit the  source code near  line 1340 to reflect  the I/O address and
  72     IRQ you're using.
  73     3) compile  ewrk3.c, but include -DMODULE in  the command line to ensure
  74     that the correct bits are compiled (see end of source code).
  75     4) if you are wanting to add a new  card, goto 5. Otherwise, recompile a
  76     kernel with the ewrk3 configuration turned off and reboot.
  77     5) insmod ewrk3.o
  78     6) run the net startup bits for your new eth?? interface manually 
  79     (usually /etc/rc.inet[12] at boot time). 
  80     7) enjoy!
  81     
  82     [Alan Cox: Changed this so you can insmod ewrk3.o irq=x io=y]
  83 
  84     Note that autoprobing is not allowed in loadable modules - the system is
  85     already up and running and you're messing with interrupts.
  86 
  87     To unload a module, turn off the associated interface 
  88     'ifconfig eth?? down' then 'rmmod ewrk3'.
  89 
  90     Promiscuous   mode has been  turned  off  in this driver,   but  all the
  91     multicast  address bits  have been   turned on. This  improved the  send
  92     performance on a busy network by about 13%.
  93 
  94     Ioctl's have now been provided (primarily because  I wanted to grab some
  95     packet size statistics). They  are patterned after 'plipconfig.c' from a
  96     suggestion by Alan Cox.  Using these  ioctls, you can enable promiscuous
  97     mode, add/delete multicast  addresses, change the hardware address,  get
  98     packet size distribution statistics and muck around with the control and
  99     status register. I'll add others if and when the need arises.
 100 
 101     TO DO:
 102     ------
 103 
 104 
 105     Revision History
 106     ----------------
 107 
 108     Version   Date        Description
 109   
 110       0.1     26-aug-94   Initial writing. ALPHA code release.
 111       0.11    31-aug-94   Fixed: 2k mode memory base calc., 
 112                                  LeMAC version calc.,
 113                                  IRQ vector assignments during autoprobe.
 114       0.12    31-aug-94   Tested working on LeMAC2 (DE20[345]-AC) card.
 115                           Fixed up MCA hash table algorithm.
 116       0.20     4-sep-94   Added IOCTL functionality.
 117       0.21    14-sep-94   Added I/O mode.
 118       0.21axp 15-sep-94   Special version for ALPHA AXP Linux V1.0
 119       0.22    16-sep-94   Added more IOCTLs & tidied up.
 120       0.23    21-sep-94   Added transmit cut through
 121       0.24    31-oct-94   Added uid checks in some ioctls
 122       0.30     1-nov-94   BETA code release
 123       0.31     5-dec-94   Added check/snarf_region code.
 124 
 125     =========================================================================
 126 */
 127 
 128 static char *version = "ewrk3.c:v0.31 12/5/94 davies@wanton.lkg.dec.com\n";
 129 
 130 #include <stdarg.h>
 131 #include <linux/kernel.h>
 132 #include <linux/sched.h>
 133 #include <linux/string.h>
 134 #include <linux/ptrace.h>
 135 #include <linux/errno.h>
 136 #include <linux/ioport.h>
 137 #include <linux/malloc.h>
 138 #include <linux/interrupt.h>
 139 #include <asm/bitops.h>
 140 #include <asm/io.h>
 141 #include <asm/dma.h>
 142 #include <asm/segment.h>
 143 
 144 #include <linux/netdevice.h>
 145 #include <linux/etherdevice.h>
 146 #include <linux/skbuff.h>
 147 
 148 #include <linux/time.h>
 149 #include <linux/types.h>
 150 #include <linux/unistd.h>
 151 
 152 #ifdef MODULE
 153 #include <linux/module.h>
 154 #include <linux/version.h>
 155 #endif /* MODULE */
 156 
 157 #include "ewrk3.h"
 158 
 159 #ifdef EWRK3_DEBUG
 160 static int ewrk3_debug = EWRK3_DEBUG;
 161 #else
 162 static int ewrk3_debug = 1;
 163 #endif
 164 
 165 #ifndef PROBE_LENGTH
 166 #define PROBE_LENGTH    32
 167 #endif
 168 
 169 #ifndef PROBE_SEQUENCE
 170 #define PROBE_SEQUENCE "FF0055AAFF0055AA"
 171 #endif
 172 
 173 #ifndef EWRK3_SIGNATURE
 174 #define EWRK3_SIGNATURE {"DE203","DE204","DE205",""}
 175 #define EWRK3_NAME_LENGTH 8
 176 #endif
 177 
 178 #ifndef EWRK3_RAM_BASE_ADDRESSES
 179 #define EWRK3_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0x00000}
 180 #endif
 181 
 182 /*
 183 ** Sets up the search areas for the autoprobe. You can disable an area
 184 ** by writing a zero into the corresponding bit position in EWRK3_IO_SEARCH.
 185 ** The LSb -> I/O 0x100. Each bit increments the I/O location searched by 0x20.
 186 ** Bit 24 -> I/O 0x400.
 187 **
 188 ** By default, probes at locations:
 189 **             0x1e0   (may conflict with hard disk)
 190 **             0x320   (may conflict with hard disk)
 191 **             0x3e0   (may conflict with floppy disk)
 192 **
 193 ** are disabled.
 194 */
 195 
 196 #define EWRK3_IO_BASE 0x100             /* Start address for probe search */
 197 #define EWRK3_IOP_INC 0x20              /* I/O address increment */
 198 #define EWRK3_IO_SEARCH 0x007dff7f      /* probe search mask */
 199 static long mem_chkd = EWRK3_IO_SEARCH; /* holds which I/O addrs should be */
 200                                         /* checked, for multi-EWRK3 case */
 201 
 202 #ifndef MAX_NUM_EWRK3S
 203 #define MAX_NUM_EWRK3S 21
 204 #endif
 205 
 206 #ifndef EWRK3_EISA_IO_PORTS 
 207 #define EWRK3_EISA_IO_PORTS 0x0c00      /* I/O port base address, slot 0 */
 208 #endif
 209 
 210 #ifndef MAX_EISA_SLOTS
 211 #define MAX_EISA_SLOTS 8
 212 #define EISA_SLOT_INC 0x1000
 213 #endif
 214 
 215 #ifndef CRC_POLYNOMIAL
 216 #define CRC_POLYNOMIAL 0x04c11db7       /* Ethernet CRC polynomial */
 217 #endif /* CRC_POLYNOMIAL */
 218 
 219 /*
 220 ** EtherWORKS 3 shared memory window sizes
 221 */
 222 #define IO_ONLY         0x00
 223 #define SHMEM_2K        0x800
 224 #define SHMEM_32K       0x8000
 225 #define SHMEM_64K       0x10000
 226 
 227 /*
 228 ** EtherWORKS 3 IRQ ENABLE/DISABLE
 229 */
 230 static unsigned char irq_mask = TNEM|TXDM|RNEM|RXDM;
 231 
 232 #define ENABLE_IRQs \
 233   icr |= irq_mask;\
 234   outb(icr, EWRK3_ICR)                      /* Enable the IRQs */
 235 
 236 #define DISABLE_IRQs \
 237   icr = inb(EWRK3_ICR);\
 238   icr &= ~irq_mask;\
 239   outb(icr, EWRK3_ICR)                      /* Disable the IRQs */
 240 
 241 /*
 242 ** EtherWORKS 3 START/STOP
 243 */
 244 #define START_EWRK3 \
 245   csr = inb(EWRK3_CSR);\
 246   csr &= ~(TXD|RXD);\
 247   outb(csr, EWRK3_CSR)                      /* Enable the TX and/or RX */
 248 
 249 #define STOP_EWRK3 \
 250   csr = (TXD|RXD);\
 251   outb(csr, EWRK3_CSR)                      /* Disable the TX and/or RX */
 252 
 253 /*
 254 ** The EtherWORKS 3 private structure
 255 */
 256 #define EWRK3_PKT_STAT_SZ 16
 257 #define EWRK3_PKT_BIN_SZ  128           /* Should be >=100 unless you
 258                                            increase EWRK3_PKT_STAT_SZ */
 259 
 260 struct ewrk3_private {
 261     long shmem_base;                    /* Shared memory start address */
 262     long shmem_length;                  /* Shared memory window length */
 263     struct enet_statistics stats;       /* Public stats */
 264     struct {
 265       unsigned long bins[EWRK3_PKT_STAT_SZ]; /* Private stats counters */
 266       unsigned long unicast;
 267       unsigned long multicast;
 268       unsigned long broadcast;
 269       unsigned long excessive_collisions;
 270       unsigned long tx_underruns;
 271       unsigned long excessive_underruns;
 272     } pktStats;
 273     short mPage;                        /* Maximum 2kB Page number */
 274     unsigned char lemac;                /* Chip rev. level */
 275     unsigned char hard_strapped;        /* Don't allow a full open */
 276     unsigned char lock;                 /* Lock the page register */
 277     unsigned char txc;                  /* Transmit cut through */
 278 };
 279 
 280 /*
 281 ** Force the EtherWORKS 3 card to be in 2kB MODE
 282 */
 283 #define FORCE_2K_MODE \
 284   shmem_length = SHMEM_2K;\
 285   outb(((mem_start - 0x80000) >> 11), EWRK3_MBR)
 286 
 287 /*
 288 ** Public Functions
 289 */
 290 static int ewrk3_open(struct device *dev);
 291 static int ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
 292 static void ewrk3_interrupt(int irq, struct pt_regs *regs);
 293 static int ewrk3_close(struct device *dev);
 294 static struct enet_statistics *ewrk3_get_stats(struct device *dev);
 295 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 296 static int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
 297 
 298 /*
 299 ** Private functions
 300 */
 301 static int  ewrk3_hw_init(struct device *dev, short iobase);
 302 static void ewrk3_init(struct device *dev);
 303 static int  ewrk3_rx(struct device *dev);
 304 static int  ewrk3_tx(struct device *dev);
 305 
 306 static void EthwrkSignature(char * name, char *eeprom_image);
 307 static int  DevicePresent(short iobase);
 308 static void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table);
 309 
 310 static int  Read_EEPROM(short iobase, unsigned char eaddr);
 311 static int  Write_EEPROM(short data, short iobase, unsigned char eaddr);
 312 static unsigned char aprom_crc (struct device *dev, unsigned char *eeprom_image, char chipType);
 313 
 314 #ifndef MODULE
 315 static struct device *isa_probe(struct device *dev);
 316 static struct device *eisa_probe(struct device *dev);
 317 static struct device *alloc_device(struct device *dev, int iobase);
 318 
 319 static int num_ewrk3s = 0, num_eth = 0;
 320 static unsigned char irq[] = {5,0,10,3,11,9,15,12};
 321 
 322 #else
 323 int  init_module(void);
 324 void cleanup_module(void);
 325 
 326 #endif /* MODULE */
 327 
 328 static int autoprobed = 0;
 329 
 330 /*
 331 ** Miscellaneous defines...
 332 */
 333 #define INIT_EWRK3 {\
 334     int i;\
 335     outb(EEPROM_INIT, EWRK3_IOPR);\
 336     for (i=0;i<5000;i++) inb(EWRK3_CSR);\
 337                    }
 338 
 339 
 340 
 341 
 342 int ewrk3_probe(struct device *dev)
     /*  */
 343 {
 344   int base_addr = dev->base_addr;
 345   int status = -ENODEV;
 346 #ifndef MODULE
 347   struct device *eth0;
 348 #endif
 349 
 350   if (base_addr > 0x0ff) {            /* Check a single specified location. */
 351     if (!autoprobed) {                /* Module or fixed location */
 352       if (!check_region(base_addr, EWRK3_IOP_INC)) {
 353         if (((mem_chkd >> ((base_addr - EWRK3_IO_BASE)/ EWRK3_IOP_INC))&0x01)==1) {
 354           if (DevicePresent(base_addr) == 0) {      /* Is EWRK3 really here? */
 355             request_region(base_addr, EWRK3_IOP_INC,"ewrk3"); /* Register I/O region */
 356             status = ewrk3_hw_init(dev, base_addr);
 357           } else {
 358             printk("ewrk3_probe(): No device found\n");
 359             mem_chkd &= ~(0x01 << ((base_addr - EWRK3_IO_BASE)/EWRK3_IOP_INC));
 360           }
 361         }
 362       } else {
 363         printk("%s: ewrk3_probe(): Detected a device already registered at 0x%02x\n", dev->name, base_addr);
 364         mem_chkd &= ~(0x01 << ((base_addr - EWRK3_IO_BASE)/EWRK3_IOP_INC));
 365       }
 366     } else {                          /* already know what ewrk3 h/w is here */
 367       status = ewrk3_hw_init(dev, base_addr);
 368     }
 369   } else if (base_addr > 0) {         /* Don't probe at all. */
 370     status = -ENXIO;
 371 
 372 #ifdef MODULE
 373   } else {
 374     printk("Autoprobing is not supported when loading a module based driver.\n");
 375     status = -EIO;
 376 #else
 377   } else if (!autoprobed) {           /* First probe for the EWRK3 test */
 378                                       /* pattern in ROM */
 379     eth0=isa_probe(dev);
 380     eth0=eisa_probe(eth0);
 381     if (dev->priv) status=0;
 382     autoprobed = 1;
 383   } else {
 384     status = -ENXIO;
 385 #endif /* MODULE */
 386     
 387   }
 388 
 389   if (status) dev->base_addr = base_addr;
 390 
 391   return status;
 392 }
 393 
 394 static int
 395 ewrk3_hw_init(struct device *dev, short iobase)
     /*  */
 396 {
 397   struct ewrk3_private *lp;
 398   int i, status=0;
 399   unsigned long mem_start, shmem_length;
 400   char name[EWRK3_NAME_LENGTH + 1];
 401   unsigned char cr, cmr, icr, nicsr, lemac, hard_strapped = 0;
 402   unsigned char eeprom_image[EEPROM_MAX], chksum, eisa_cr = 0;
 403 
 404   /*
 405   ** Stop the EWRK3. Enable the DBR ROM. Disable interrupts and remote boot.
 406   ** This also disables the EISA_ENABLE bit in the EISA Control Register.
 407   */
 408   if (iobase > 0x400) eisa_cr = inb(EISA_CR);
 409   INIT_EWRK3;
 410 
 411   nicsr = inb(EWRK3_CSR);
 412 
 413   /*
 414   ** Disable & mask all board interrupts
 415   */
 416   DISABLE_IRQs;
 417 
 418   if (nicsr == TXD|RXD) {
 419 
 420     /*
 421     ** Check that the EEPROM is alive and well and not living on Pluto...
 422     */
 423     for (chksum=0, i=0; i<EEPROM_MAX; i+=2) {
 424       union {
 425         short val;
 426         char c[2];
 427       } tmp;
 428 
 429       tmp.val = (short)Read_EEPROM(iobase, (i>>1));
 430       eeprom_image[i] = tmp.c[0];
 431       eeprom_image[i+1] = tmp.c[1];
 432 
 433       chksum += eeprom_image[i] + eeprom_image[i+1];
 434     }
 435 
 436     if (chksum != 0) {                             /* Bad EEPROM Data! */
 437       printk("%s: Device has a bad on-board EEPROM.\n", dev->name);
 438       status = -ENXIO;
 439     } else {
 440       /* 
 441       ** Now find out what kind of EWRK3 we have.
 442       */
 443       EthwrkSignature(name, eeprom_image);
 444 
 445       if (*name != '\0') {                         /* found a EWRK3 device */
 446         dev->base_addr = iobase;
 447       
 448         if (iobase > 0x400) {
 449           outb(eisa_cr, EISA_CR);                  /* Rewrite the EISA CR */
 450         }
 451 
 452         lemac = eeprom_image[EEPROM_CHIPVER];
 453         cmr = inb(EWRK3_CMR);
 454 
 455         if (((lemac == LeMAC) && ((cmr & NO_EEPROM) != NO_EEPROM)) ||
 456             ((lemac == LeMAC2) && !(cmr & HS))) {
 457           printk("%s: %s at %#3x", dev->name, name, iobase);
 458           hard_strapped = 1;
 459         } else if ((iobase&0x0fff)==EWRK3_EISA_IO_PORTS) {
 460                                                    /* EISA slot address */
 461           printk("%s: %s at %#3x (EISA slot %d)", 
 462                                  dev->name, name, iobase, ((iobase>>12)&0x0f));
 463         } else {                                   /* ISA port address */
 464           printk("%s: %s at %#3x", dev->name, name, iobase);
 465         }
 466         
 467         if (!status) {
 468           printk(", h/w address ");
 469           if (lemac == LeMAC2) {
 470             for (i = 0;i < ETH_ALEN - 1;i++) { /* get the ethernet address */
 471               printk("%2.2x:", dev->dev_addr[i] = 
 472                                               eeprom_image[EEPROM_PADDR0 + i]);
 473               outb(eeprom_image[EEPROM_PADDR0 + i], EWRK3_PAR0 + i);
 474             }
 475             printk("%2.2x,\n",dev->dev_addr[i] = eeprom_image[EEPROM_PADDR0 + i]);
 476             outb(eeprom_image[EEPROM_PADDR0 + i], EWRK3_PAR0 + i);
 477           } else {
 478             DevicePresent(iobase);          /* needed after the EWRK3_INIT */
 479             for (i = 0; i < ETH_ALEN - 1; i++) { /* get the ethernet addr. */
 480               printk("%2.2x:", dev->dev_addr[i] = inb(EWRK3_APROM));
 481               outb(dev->dev_addr[i], EWRK3_PAR0 + i);
 482             }
 483             printk("%2.2x,\n", dev->dev_addr[i] = inb(EWRK3_APROM));
 484             outb(dev->dev_addr[i], EWRK3_PAR0 + i);
 485           }
 486 
 487           if (aprom_crc(dev, eeprom_image, lemac)) {
 488             printk("      which has an EEPROM CRC error.\n");
 489             status = -ENXIO;
 490           } else {
 491             if (lemac == LeMAC2) {            /* Special LeMAC2 CMR things */
 492               cmr &= ~(RA | WB | LINK | POLARITY | _0WS);         
 493               if (eeprom_image[EEPROM_MISC0] & READ_AHEAD)    cmr |= RA;
 494               if (eeprom_image[EEPROM_MISC0] & WRITE_BEHIND)  cmr |= WB;
 495               if (eeprom_image[EEPROM_NETMAN0] & NETMAN_POL)  cmr |= POLARITY;
 496               if (eeprom_image[EEPROM_NETMAN0] & NETMAN_LINK) cmr |= LINK;
 497               if (eeprom_image[EEPROM_MISC0] & _0WS_ENA)      cmr |= _0WS;
 498             }
 499             if (eeprom_image[EEPROM_SETUP] & SETUP_DRAM)      cmr |= DRAM;
 500             outb(cmr, EWRK3_CMR);
 501 
 502             cr = inb(EWRK3_CR);               /* Set up the Control Register */
 503             cr |= eeprom_image[EEPROM_SETUP] & SETUP_APD;
 504             if (cr & SETUP_APD) cr |= eeprom_image[EEPROM_SETUP] & SETUP_PS;
 505             cr |= eeprom_image[EEPROM_MISC0] & FAST_BUS;
 506             cr |= eeprom_image[EEPROM_MISC0] & ENA_16;
 507             outb(cr, EWRK3_CR);
 508 
 509             /* 
 510             ** Determine the base address and window length for the EWRK3
 511             ** RAM from the memory base register.
 512             */
 513             mem_start = inb(EWRK3_MBR);
 514             shmem_length = 0;
 515             if (mem_start != 0) {
 516               if ((mem_start >= 0x0a) && (mem_start <= 0x0f)) {
 517                 mem_start *= SHMEM_64K;
 518                 shmem_length = SHMEM_64K;
 519               } else if ((mem_start >= 0x14) && (mem_start <= 0x1f)) {
 520                 mem_start *= SHMEM_32K;
 521                 shmem_length = SHMEM_32K;
 522               } else if ((mem_start >= 0x40) && (mem_start <= 0xff)) {
 523                 mem_start = mem_start * SHMEM_2K + 0x80000;
 524                 shmem_length = SHMEM_2K;
 525               } else {
 526                 status = -ENXIO;
 527               }
 528             }
 529           
 530             /*
 531             ** See the top of this source code for comments about
 532             ** uncommenting this line.
 533             */
 534 /*          FORCE_2K_MODE;*/
 535 
 536             if (!status) {
 537               if (hard_strapped) {
 538                 printk("      is hard strapped.\n");
 539               } else if (mem_start) {
 540                 printk("      has a %dk RAM window", (int)(shmem_length >> 10));
 541                 printk(" at 0x%.5lx", mem_start);
 542               } else {
 543                 printk("      is in I/O only mode");
 544               }
 545             
 546               /* private area & initialise */
 547               dev->priv = (void *) kmalloc(sizeof(struct ewrk3_private), 
 548                                                                    GFP_KERNEL);
 549               lp = (struct ewrk3_private *)dev->priv;
 550               memset(dev->priv, 0, sizeof(struct ewrk3_private));
 551               lp->shmem_base = mem_start;
 552               lp->shmem_length = shmem_length;
 553               lp->lemac = lemac;
 554               lp->hard_strapped = hard_strapped;
 555 
 556               lp->mPage = 64;
 557               if (cmr & DRAM) lp->mPage <<= 1 ;     /* 2 DRAMS on module */ 
 558 
 559               if (!hard_strapped) {
 560                 /*
 561                 ** Enable EWRK3 board interrupts for autoprobing
 562                 */
 563                 icr |= IE;                         /* Enable interrupts */
 564                 outb(icr, EWRK3_ICR);
 565             
 566                 /* The DMA channel may be passed in on this parameter. */
 567                 dev->dma = 0;
 568         
 569                 /* To auto-IRQ we enable the initialization-done and DMA err,
 570                    interrupts. For now we will always get a DMA error. */
 571                 if (dev->irq < 2) {
 572 #ifndef MODULE
 573                   unsigned char irqnum;
 574               
 575                   autoirq_setup(0);
 576 
 577                   /* 
 578                   ** Trigger a TNE interrupt.
 579                   */
 580                   icr |=TNEM;
 581                   outb(1,EWRK3_TDQ);          /* Write to the TX done queue */
 582                   outb(icr, EWRK3_ICR);       /* Unmask the TXD interrupt */
 583               
 584                   irqnum = irq[((icr & IRQ_SEL) >> 4)];
 585               
 586                   dev->irq = autoirq_report(1);
 587                   if ((dev->irq) && (irqnum == dev->irq)) {
 588                     printk(" and uses IRQ%d.\n", dev->irq);
 589                   } else {
 590                     if (!dev->irq) {
 591                       printk(" and failed to detect IRQ line.\n");
 592                     } else if ((irqnum == 1) && (lemac == LeMAC2)) {
 593                       printk(" and an illegal IRQ line detected.\n");
 594                     } else {
 595                       printk(", but incorrect IRQ line detected.\n");
 596                     }
 597                     status = -ENXIO;
 598                   }
 599                 
 600                   DISABLE_IRQs;                 /* Mask all interrupts */
 601 
 602 #endif /* MODULE */
 603                 } else {
 604                   printk(" and requires IRQ%d.\n", dev->irq);
 605                 }
 606               }
 607             } else {
 608               status = -ENXIO;
 609             }
 610           }
 611         }
 612       } else {
 613         status = -ENXIO;
 614       }
 615     }
 616 
 617     if (!status) {
 618       if (ewrk3_debug > 0) {
 619         printk(version);
 620       }
 621       
 622       /* The EWRK3-specific entries in the device structure. */
 623       dev->open = &ewrk3_open;
 624       dev->hard_start_xmit = &ewrk3_queue_pkt;
 625       dev->stop = &ewrk3_close;
 626       dev->get_stats = &ewrk3_get_stats;
 627 #ifdef HAVE_MULTICAST
 628       dev->set_multicast_list = &set_multicast_list;
 629 #endif
 630       dev->do_ioctl = &ewrk3_ioctl;
 631 
 632       dev->mem_start = 0;
 633         
 634       /* Fill in the generic field of the device structure. */
 635       ether_setup(dev);
 636     }
 637   } else {
 638     status = -ENXIO;
 639   }
 640 
 641   return status;
 642 }
 643 
 644 
 645 static int
 646 ewrk3_open(struct device *dev)
     /*  */
 647 {
 648   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
 649   int i, iobase = dev->base_addr;
 650   int status = 0;
 651   unsigned char icr, csr;
 652 
 653   /*
 654   ** Stop the TX and RX...
 655   */
 656   STOP_EWRK3;
 657 
 658   if (!lp->hard_strapped) {
 659     if (request_irq(dev->irq, &ewrk3_interrupt, 0, "ewrk3")) {
 660       printk("ewrk3_open(): Requested IRQ%d is busy\n",dev->irq);
 661       status = -EAGAIN;
 662     } else {
 663 
 664       irq2dev_map[dev->irq] = dev;
 665 
 666       /* 
 667       ** Re-initialize the EWRK3... 
 668       */
 669       ewrk3_init(dev);
 670 
 671       if (ewrk3_debug > 1){
 672         printk("%s: ewrk3 open with irq %d\n",dev->name,dev->irq);
 673         printk("\tphysical address: ");
 674         for (i=0;i<6;i++){
 675           printk("%2.2x:",(short)dev->dev_addr[i]);
 676         }
 677         printk("\n");
 678         printk("\tchecked memory: 0x%08lx\n",mem_chkd);
 679         if (lp->shmem_length == 0) {
 680           printk("\tno shared memory, I/O only mode\n");
 681         } else {
 682           printk("\tstart of shared memory: 0x%08lx\n",lp->shmem_base);
 683           printk("\twindow length: 0x%04lx\n",lp->shmem_length);
 684         }
 685         printk("\t# of DRAMS: %d\n",((inb(EWRK3_CMR) & 0x02) ? 2 : 1));
 686         printk("\tcsr:  0x%02x\n", inb(EWRK3_CSR));
 687         printk("\tcr:   0x%02x\n", inb(EWRK3_CR));
 688         printk("\ticr:  0x%02x\n", inb(EWRK3_ICR));
 689         printk("\tcmr:  0x%02x\n", inb(EWRK3_CMR));
 690         printk("\tfmqc: 0x%02x\n", inb(EWRK3_FMQC));
 691       }
 692 
 693       dev->tbusy = 0;                         
 694       dev->start = 1;
 695       dev->interrupt = UNMASK_INTERRUPTS;
 696 
 697       /*
 698       ** Unmask EWRK3 board interrupts
 699       */
 700       icr = inb(EWRK3_ICR);
 701       ENABLE_IRQs;
 702 
 703     }
 704   } else {
 705     dev->start = 0;
 706     dev->tbusy = 1;
 707     printk("%s: ewrk3 available for hard strapped set up only.\n", dev->name);
 708     printk("      Run the 'ewrk3setup' utility or remove the hard straps.\n");
 709   }
 710 
 711 #ifdef MODULE
 712     MOD_INC_USE_COUNT;
 713 #endif       
 714 
 715 
 716   return status;
 717 }
 718 
 719 /*
 720 ** Initialize the EtherWORKS 3 operating conditions
 721 */
 722 static void
 723 ewrk3_init(struct device *dev)
     /*  */
 724 {
 725   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
 726   char csr, page;
 727   short iobase = dev->base_addr;
 728   
 729   /* 
 730   ** Enable all multicasts 
 731   */
 732   set_multicast_list(dev, HASH_TABLE_LEN, NULL);
 733 
 734   /*
 735   ** Clean out any remaining entries in all the queues here
 736   */
 737   while (inb(EWRK3_TQ));
 738   while (inb(EWRK3_TDQ));
 739   while (inb(EWRK3_RQ));
 740   while (inb(EWRK3_FMQ));
 741 
 742   /*
 743   ** Write a clean free memory queue
 744   */
 745   for (page=1;page<lp->mPage;page++) {      /* Write the free page numbers */
 746     outb(page, EWRK3_FMQ);                  /* to the Free Memory Queue */
 747   }
 748 
 749   lp->lock = 0;                             /* Ensure there are no locks */
 750 
 751   START_EWRK3;                              /* Enable the TX and/or RX */
 752 }
 753 
 754 /* 
 755 ** Writes a socket buffer to the free page queue
 756 */
 757 static int
 758 ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
     /*  */
 759 {
 760   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
 761   int iobase = dev->base_addr;
 762   int status = 0;
 763   unsigned char icr, csr;
 764 
 765   /* Transmitter timeout, serious problems. */
 766   if (dev->tbusy || lp->lock) {
 767     int tickssofar = jiffies - dev->trans_start;
 768     if (tickssofar < 10) {
 769       status = -1;
 770     } else if (!lp->hard_strapped) {
 771       printk("%s: transmit timed/locked out, status %04x, resetting.\n",
 772                                                    dev->name, inb(EWRK3_CSR));
 773         
 774       /*
 775       ** Mask all board interrupts
 776       */
 777       DISABLE_IRQs;
 778 
 779       /*
 780       ** Stop the TX and RX...
 781       */
 782       STOP_EWRK3;
 783 
 784       ewrk3_init(dev);
 785 
 786       /*
 787       ** Unmask EWRK3 board interrupts
 788       */
 789       ENABLE_IRQs;
 790 
 791       dev->tbusy=0;
 792       dev->trans_start = jiffies;
 793     }
 794   } else if (skb == NULL) {
 795     dev_tint(dev);
 796   } else if (skb->len > 0) {
 797 
 798     /* 
 799     ** Block a timer-based transmit from overlapping.  This could better be
 800     ** done with atomic_swap(1, dev->tbusy), but set_bit() works as well. 
 801     */
 802     if (set_bit(0, (void*)&dev->tbusy) != 0)
 803       printk("%s: Transmitter access conflict.\n", dev->name);
 804 
 805     DISABLE_IRQs;                      /* So that the page # remains correct */
 806     
 807     /* 
 808     ** Get a free page from the FMQ when resources are available
 809     */
 810     if (inb(EWRK3_FMQC) > 0) {
 811       unsigned char *buf;
 812       unsigned char page;
 813 
 814       if ((page = inb(EWRK3_FMQ)) < lp->mPage) {
 815         buf = NULL;
 816 
 817         /*
 818         ** Set up shared memory window and pointer into the window
 819         */
 820         while (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
 821         if (lp->shmem_length == IO_ONLY) {
 822           outb(page, EWRK3_IOPR);
 823         } else if (lp->shmem_length == SHMEM_2K) {
 824           buf = (char *) lp->shmem_base;
 825           outb(page, EWRK3_MPR);
 826         } else if (lp->shmem_length == SHMEM_32K) {
 827           buf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
 828           outb((page >> 4), EWRK3_MPR);
 829         } else if (lp->shmem_length == SHMEM_64K) {
 830           buf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
 831           outb((page >> 5), EWRK3_MPR);
 832         } else {
 833           status = -1;
 834           printk("%s: Oops - your private data area is hosed!\n",dev->name);
 835         }
 836 
 837         if (!status) {
 838 
 839           /* 
 840           ** Set up the buffer control structures and copy the data from
 841           ** the socket buffer to the shared memory .
 842           */
 843 
 844           if (lp->shmem_length == IO_ONLY) {
 845             int i;
 846             unsigned char *p = skb->data;
 847             
 848             outb((char)(QMODE | PAD | IFC), EWRK3_DATA);
 849             outb((char)(skb->len & 0xff), EWRK3_DATA);
 850             outb((char)((skb->len >> 8) & 0xff), EWRK3_DATA);
 851             outb((char)0x04, EWRK3_DATA);
 852             for (i=0; i<skb->len; i++) {
 853               outb(*p++, EWRK3_DATA);
 854             }
 855             outb(page, EWRK3_TQ);                     /* Start sending pkt */
 856           } else {
 857             *buf++ = (char)(QMODE | PAD | IFC);       /* control byte */
 858             *buf++ = (char)(skb->len & 0xff);         /* length (16 bit xfer)*/
 859             if (lp->txc) {
 860               *buf++ = (char)(((skb->len >> 8) & 0xff) | XCT);
 861               *buf++ = 0x04;                          /* index byte */
 862               *(buf + skb->len) = 0x00;               /* Write the XCT flag */
 863               memcpy(buf, skb->data, PRELOAD);        /* Write PRELOAD bytes */
 864               outb(page, EWRK3_TQ);                   /* Start sending pkt */
 865               memcpy(buf + PRELOAD, skb->data + PRELOAD, skb->len - PRELOAD);
 866               *(buf + skb->len) = 0xff;               /* Write the XCT flag */
 867             } else {
 868               *buf++ = (char)((skb->len >> 8) & 0xff);
 869               *buf++ = 0x04;                          /* index byte */
 870               memcpy(buf, skb->data, skb->len);       /* Write data bytes */
 871               outb(page, EWRK3_TQ);                   /* Start sending pkt */
 872             }
 873           }
 874 
 875           dev->trans_start = jiffies;
 876 
 877           dev_kfree_skb (skb, FREE_WRITE);
 878 
 879         } else {              /* return unused page to the free memory queue */
 880           outb(page, EWRK3_FMQ);
 881         }
 882         lp->lock = 0;         /* unlock the page register */
 883       } else {
 884         printk("ewrk3_queue_pkt(): Invalid free memory page (%d).\n",
 885                                                          (unsigned char) page);
 886       }
 887     } else {
 888       printk("ewrk3_queue_pkt(): No free resources...\n");
 889       printk("ewrk3_queue_pkt(): CSR: %02x ICR: %02x FMQC: %02x\n",inb(EWRK3_CSR),inb(EWRK3_ICR),inb(EWRK3_FMQC));
 890     }
 891     
 892     /* Check for free resources: clear 'tbusy' if there are some */
 893     if (inb(EWRK3_FMQC) > 0) {
 894       dev->tbusy = 0;
 895     }
 896 
 897     ENABLE_IRQs;
 898   }
 899 
 900   return status;
 901 }
 902 
 903 /*
 904 ** The EWRK3 interrupt handler. 
 905 */
 906 static void
 907 ewrk3_interrupt(int irq, struct pt_regs * regs)
     /*  */
 908 {
 909     struct device *dev = (struct device *)(irq2dev_map[irq]);
 910     struct ewrk3_private *lp;
 911     int iobase;
 912     unsigned char icr, cr, csr;
 913 
 914     if (dev == NULL) {
 915         printk ("ewrk3_interrupt(): irq %d for unknown device.\n", irq);
 916     } else {
 917       lp = (struct ewrk3_private *)dev->priv;
 918       iobase = dev->base_addr;
 919 
 920       if (dev->interrupt)
 921         printk("%s: Re-entering the interrupt handler.\n", dev->name);
 922 
 923       dev->interrupt = MASK_INTERRUPTS;
 924 
 925       /* get the interrupt information */
 926       csr = inb(EWRK3_CSR);
 927 
 928       /* 
 929       ** Mask the EWRK3 board interrupts and turn on the LED 
 930       */
 931       DISABLE_IRQs;
 932 
 933       cr = inb(EWRK3_CR);
 934       cr |= LED;
 935       outb(cr, EWRK3_CR);
 936 
 937       if (csr & RNE)              /* Rx interrupt (packet[s] arrived) */
 938         ewrk3_rx(dev);
 939 
 940       if (csr & TNE)              /* Tx interrupt (packet sent) */
 941         ewrk3_tx(dev);
 942 
 943       /*
 944       ** Now deal with the TX/RX disable flags. These are set when there
 945       ** are no more resources. If resources free up then enable these
 946       ** interrupts, otherwise mask them - failure to do this will result
 947       ** in the system hanging in an interrupt loop.
 948       */
 949       if (inb(EWRK3_FMQC)) {      /* any resources available? */
 950         irq_mask |= TXDM|RXDM;    /* enable the interrupt source */
 951         csr &= ~(TXD|RXD);        /* ensure restart of a stalled TX or RX */
 952         outb(csr, EWRK3_CSR);
 953         dev->tbusy = 0;           /* clear TX busy flag */
 954         mark_bh(NET_BH);
 955       } else {
 956         irq_mask &= ~(TXDM|RXDM); /* disable the interrupt source */
 957       }
 958 
 959       /* Unmask the EWRK3 board interrupts and turn off the LED */
 960       cr &= ~LED;
 961       outb(cr, EWRK3_CR);
 962 
 963       dev->interrupt = UNMASK_INTERRUPTS;
 964 
 965       ENABLE_IRQs;
 966     }
 967 
 968     return;
 969 }
 970 
 971 static int
 972 ewrk3_rx(struct device *dev)
     /*  */
 973 {
 974   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
 975   int i, iobase = dev->base_addr;
 976   unsigned char page, tmpPage = 0, tmpLock = 0, *buf;
 977   int status = 0;
 978 
 979   while (inb(EWRK3_RQC) && !status) {        /* Whilst there's incoming data */
 980     if ((page = inb(EWRK3_RQ)) < lp->mPage) {/* Get next entry's buffer page */
 981       buf = NULL;
 982 
 983       /*
 984       ** Preempt any process using the current page register. Check for
 985       ** an existing lock to reduce time taken in I/O transactions.
 986       */
 987       if ((tmpLock = set_bit(0, (void *)&lp->lock)) == 1) {   /* Assert lock */
 988         if (lp->shmem_length == IO_ONLY) {              /* Get existing page */
 989           tmpPage = inb(EWRK3_IOPR);
 990         } else {
 991           tmpPage = inb(EWRK3_MPR);
 992         }
 993       }
 994 
 995       /*
 996       ** Set up shared memory window and pointer into the window
 997       */
 998       if (lp->shmem_length == IO_ONLY) {
 999         outb(page, EWRK3_IOPR);
1000       } else if (lp->shmem_length == SHMEM_2K) {
1001         buf = (char *) lp->shmem_base;
1002         outb(page, EWRK3_MPR);
1003       } else if (lp->shmem_length == SHMEM_32K) {
1004         buf = (char *)((((short)page << 11) & 0x7800) + lp->shmem_base);
1005         outb((page >> 4), EWRK3_MPR);
1006       } else if (lp->shmem_length == SHMEM_64K) {
1007         buf = (char *)((((short)page << 11) & 0xf800) + lp->shmem_base);
1008         outb((page >> 5), EWRK3_MPR);
1009       } else {
1010         status = -1;
1011         printk("%s: Oops - your private data area is hosed!\n",dev->name);
1012       }
1013 
1014       if (!status) {
1015         char rx_status;
1016         int pkt_len;
1017 
1018         if (lp->shmem_length == IO_ONLY) {
1019           rx_status = inb(EWRK3_DATA);
1020           pkt_len = inb(EWRK3_DATA);
1021           pkt_len |= ((unsigned short)inb(EWRK3_DATA) << 8);
1022         } else {
1023           rx_status = (char)(*buf++);
1024           pkt_len = (short)(*buf+((*(buf+1))<<8));
1025           buf+=3;
1026         }
1027 
1028         if (!(rx_status & ROK)) {           /* There was an error. */
1029           lp->stats.rx_errors++;            /* Update the error stats. */
1030           if (rx_status & DBE) lp->stats.rx_frame_errors++;
1031           if (rx_status & CRC) lp->stats.rx_crc_errors++;
1032           if (rx_status & PLL) lp->stats.rx_fifo_errors++;
1033         } else {
1034           struct sk_buff *skb;
1035 
1036           if ((skb = alloc_skb(pkt_len, GFP_ATOMIC)) != NULL) {
1037             skb->len = pkt_len;
1038             skb->dev = dev;
1039 
1040             if (lp->shmem_length == IO_ONLY) {
1041               unsigned char *p = skb->data;
1042 
1043               *p = inb(EWRK3_DATA);         /* dummy read */
1044               for (i=0; i<skb->len; i++) {
1045                 *p++ = inb(EWRK3_DATA);
1046               }
1047             } else {
1048               memcpy(skb->data, buf, pkt_len);
1049             }
1050 
1051             /* 
1052             ** Notify the upper protocol layers that there is another 
1053             ** packet to handle
1054             */
1055             netif_rx(skb);
1056 
1057             /*
1058             ** Update stats
1059             */
1060             lp->stats.rx_packets++;
1061             for (i=1; i<EWRK3_PKT_STAT_SZ-1; i++) {
1062               if (pkt_len < i*EWRK3_PKT_BIN_SZ) {
1063                 lp->pktStats.bins[i]++;
1064                 i = EWRK3_PKT_STAT_SZ;
1065               }
1066             }
1067             buf = skb->data;                  /* Look at the dest addr */
1068             if (buf[0] & 0x01) {              /* Multicast/Broadcast */
1069               if ((*(long *)&buf[0] == -1) && (*(short *)&buf[4] == -1)) {
1070                 lp->pktStats.broadcast++;
1071               } else {
1072                 lp->pktStats.multicast++;
1073               }
1074             } else if ((*(long *)&buf[0] == *(long *)&dev->dev_addr[0]) &&
1075                        (*(short *)&buf[4] == *(short *)&dev->dev_addr[4])) {
1076               lp->pktStats.unicast++;
1077             }
1078 
1079             lp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
1080             if (lp->pktStats.bins[0] == 0) {  /* Reset counters */
1081               memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1082             }
1083           } else {
1084             printk("%s: Insufficient memory; nuking packet.\n", dev->name);
1085             lp->stats.rx_dropped++;           /* Really, deferred. */
1086             break;
1087           }
1088         }
1089       }
1090       /*
1091       ** Return the received buffer to the free memory queue
1092       */
1093       outb(page, EWRK3_FMQ);
1094 
1095       if (tmpLock) {                          /* If a lock was preempted */
1096         if (lp->shmem_length == IO_ONLY) {    /* Replace old page */
1097           outb(tmpPage, EWRK3_IOPR);
1098         } else {
1099           outb(tmpPage, EWRK3_MPR);
1100         }
1101       }
1102       lp->lock = 0;                           /* Unlock the page register */
1103     } else {
1104       printk("ewrk3_rx(): Illegal page number, page %d\n",page);
1105       printk("ewrk3_rx(): CSR: %02x ICR: %02x FMQC: %02x\n",inb(EWRK3_CSR),inb(EWRK3_ICR),inb(EWRK3_FMQC));
1106     }
1107   }
1108   return status;
1109 }
1110 
1111 /*
1112 ** Buffer sent - check for TX buffer errors.
1113 */
1114 static int
1115 ewrk3_tx(struct device *dev)
     /*  */
1116 {
1117   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1118   int iobase = dev->base_addr;
1119   unsigned char tx_status;
1120 
1121   while ((tx_status = inb(EWRK3_TDQ)) > 0) {  /* Whilst there's old buffers */
1122     if (tx_status & VSTS) {                   /* The status is valid */
1123       if (tx_status & MAC_TXE) {
1124         lp->stats.tx_errors++;
1125         if (tx_status & MAC_NCL)    lp->stats.tx_carrier_errors++;
1126         if (tx_status & MAC_LCL)    lp->stats.tx_window_errors++;
1127         if (tx_status & MAC_CTU) {
1128           if ((tx_status & MAC_COLL) ^ MAC_XUR) {
1129             lp->pktStats.tx_underruns++;
1130           } else {
1131             lp->pktStats.excessive_underruns++;
1132           }
1133         } else  if (tx_status & MAC_COLL) {
1134           if ((tx_status & MAC_COLL) ^ MAC_XCOLL) {
1135             lp->stats.collisions++;
1136           } else {
1137             lp->pktStats.excessive_collisions++;
1138           }
1139         }
1140       } else {
1141         lp->stats.tx_packets++;
1142       }
1143     }
1144   }
1145 
1146   return 0;
1147 }
1148 
1149 static int
1150 ewrk3_close(struct device *dev)
     /*  */
1151 {
1152   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1153   int iobase = dev->base_addr;
1154   unsigned char icr, csr;
1155 
1156   dev->start = 0;
1157   dev->tbusy = 1;
1158 
1159   if (ewrk3_debug > 1) {
1160     printk("%s: Shutting down ethercard, status was %2.2x.\n",
1161            dev->name, inb(EWRK3_CSR));
1162   }
1163 
1164   /* 
1165   ** We stop the EWRK3 here... mask interrupts and stop TX & RX
1166   */
1167   DISABLE_IRQs;
1168 
1169   STOP_EWRK3;
1170 
1171   /*
1172   ** Clean out the TX and RX queues here (note that one entry
1173   ** may get added to either the TXD or RX queues if the the TX or RX
1174   ** just starts processing a packet before the STOP_EWRK3 command
1175   ** is received. This will be flushed in the ewrk3_open() call).
1176   */
1177   while (inb(EWRK3_TQ));
1178   while (inb(EWRK3_TDQ));
1179   while (inb(EWRK3_RQ));
1180 
1181   if (!lp->hard_strapped) {
1182     free_irq(dev->irq);
1183     
1184     irq2dev_map[dev->irq] = 0;
1185   }
1186 
1187 #ifdef MODULE
1188   MOD_DEC_USE_COUNT;
1189 #endif    
1190 
1191   return 0;
1192 }
1193 
1194 static struct enet_statistics *
1195 ewrk3_get_stats(struct device *dev)
     /*  */
1196 {
1197   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1198 
1199   /* Null body since there is no framing error counter */
1200     
1201   return &lp->stats;
1202 }
1203 
1204 /*
1205 ** Set or clear the multicast filter for this adaptor.
1206 ** num_addrs == -1      Promiscuous mode, receive all packets
1207 ** num_addrs == 0       Normal mode, clear multicast list
1208 ** num_addrs > 0        Multicast mode, receive normal and MC packets, and do
1209 **                      best-effort filtering.
1210 */
1211 static void
1212 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
1213 {
1214   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1215   int iobase = dev->base_addr;
1216   char *multicast_table;
1217   unsigned char csr;
1218 
1219   csr = inb(EWRK3_CSR);
1220 
1221   if (lp->shmem_length == IO_ONLY) {
1222     multicast_table = (char *) PAGE0_HTE;
1223   } else {
1224     multicast_table = (char *)(lp->shmem_base + PAGE0_HTE);
1225   }
1226 
1227   if (num_addrs >= 0) {
1228     SetMulticastFilter(dev, num_addrs, (char *)addrs, multicast_table);
1229     csr &= ~PME;
1230     csr |= MCE;
1231     outb(csr, EWRK3_CSR);
1232   } else {                             /* set promiscuous mode */
1233     csr |= PME;
1234     csr &= ~MCE;
1235     outb(csr, EWRK3_CSR);
1236   }
1237 }
1238 
1239 /*
1240 ** Calculate the hash code and update the logical address filter
1241 ** from a list of ethernet multicast addresses.
1242 ** Derived from a 'C' program in the AMD data book:
1243 ** "Am79C90 CMOS Local Area Network Controller for Ethernet (C-LANCE)", 
1244 ** Pub #17781, Rev. A, May 1993
1245 **
1246 */
1247 static void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table)
     /*  */
1248 {
1249   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1250   int iobase = dev->base_addr;
1251   char j, ctrl, bit, octet;
1252   short *p = (short *) multicast_table;
1253   unsigned short hashcode;
1254   int i;
1255   long int crc, poly = (long int) CRC_POLYNOMIAL;
1256 
1257   while (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
1258 
1259   if (lp->shmem_length == IO_ONLY) {
1260     outb(0, EWRK3_IOPR);
1261     outw((short)((long)multicast_table), EWRK3_PIR1);
1262   } else {
1263     outb(0, EWRK3_MPR);
1264   }
1265 
1266   if (num_addrs == HASH_TABLE_LEN) {
1267     for (i=0; i<(HASH_TABLE_LEN >> 3); i++) {
1268       if (lp->shmem_length == IO_ONLY) {
1269         outb(0xff, EWRK3_DATA);
1270       } else {                /* memset didn't work here */
1271         *p++ = 0xffff;
1272         i++;
1273       }
1274     }
1275   } else if (num_addrs == 0) {
1276     if (lp->shmem_length == IO_ONLY) {
1277       for (i=0; i<(HASH_TABLE_LEN >> 3); i++) {
1278         outb(0x00, EWRK3_DATA);
1279       } 
1280     } else {
1281       memset(multicast_table, 0, (HASH_TABLE_LEN >> 3));
1282     }
1283   } else {
1284     for (i=0;i<num_addrs;i++) {              /* for each address in the list */
1285       if (((char) *(addrs+ETH_ALEN*i) & 0x01) == 1) {/* multicast address? */ 
1286         crc = (long int) 0xffffffff;         /* init CRC for each address */
1287         for (octet=0;octet<ETH_ALEN;octet++) { /* for each address octet */
1288           for(j=0;j<8;j++) {                 /* process each address bit */
1289             bit = (((char)* (addrs+ETH_ALEN*i+octet)) >> j) & 0x01;
1290             ctrl = ((crc < 0) ? 1 : 0);      /* shift the control bit */
1291             crc <<= 1;                       /* shift the CRC */
1292             if (bit ^ ctrl) {                /* (bit) XOR (control bit) */
1293               crc ^= poly;                   /* (CRC) XOR (polynomial) */
1294             }
1295           }
1296         }
1297         hashcode = ((crc >>= 23) & 0x01);    /* hashcode is 9 MSb of CRC ... */
1298         for (j=0;j<8;j++) {                  /* ... in reverse order. */
1299           hashcode <<= 1;
1300           crc >>= 1;
1301           hashcode |= (crc & 0x01);
1302         }                                      
1303                                       
1304         octet = hashcode >> 3;               /* bit[3-8] -> octet in filter */
1305                                              /* bit[0-2] -> bit in octet */
1306         if (lp->shmem_length == IO_ONLY) {
1307           unsigned char tmp;
1308 
1309           outw((short)((long)multicast_table) + octet, EWRK3_PIR1);
1310           tmp = inb(EWRK3_DATA);
1311           tmp |= (1 << (hashcode & 0x07));
1312           outw((short)((long)multicast_table) + octet, EWRK3_PIR1);
1313           outb(tmp, EWRK3_DATA); 
1314         } else {
1315           multicast_table[octet] |= (1 << (hashcode & 0x07));
1316         }
1317       }
1318     }
1319   }
1320 
1321   lp->lock = 0;                              /* Unlock the page register */
1322 
1323   return;
1324 }
1325 
1326 #ifndef MODULE
1327 /*
1328 ** ISA bus I/O device probe
1329 */
1330 static struct device *isa_probe(struct device *dev)
     /*  */
1331 {
1332   int i, iobase, status;
1333   unsigned long int tmp = mem_chkd;
1334 
1335   for (status = -ENODEV, iobase = EWRK3_IO_BASE,i = 0; 
1336        i < 24;
1337        iobase += EWRK3_IOP_INC, i++) {
1338     if (tmp & 0x01) {
1339       /* Anything else registered here? */
1340       if (!check_region(iobase, EWRK3_IOP_INC)) {    
1341         if (DevicePresent(iobase) == 0) {
1342 /*
1343 ** Device found. Mark its (I/O) location for future reference. Only 24
1344 ** EtherWORKS devices can exist between 0x100 and 0x3e0.
1345 */
1346           request_region(iobase, EWRK3_IOP_INC,"ewrk3");
1347           if (num_ewrk3s > 0) {        /* only gets here in autoprobe */
1348             dev = alloc_device(dev, iobase);
1349           } else {
1350             if ((status = ewrk3_hw_init(dev, iobase)) == 0) {
1351               num_ewrk3s++;
1352             }
1353           }
1354           num_eth++;
1355         } else {
1356           mem_chkd &= ~(0x01 << ((iobase - EWRK3_IO_BASE)/EWRK3_IOP_INC));
1357         }
1358       } else {
1359         printk("%s: ewrk3_probe(): Detected a device already registered at 0x%02x\n", dev->name, iobase);
1360         mem_chkd &= ~(0x01 << ((iobase - EWRK3_IO_BASE)/EWRK3_IOP_INC));
1361       }
1362     }
1363     tmp >>= 1;
1364   }
1365 
1366   return dev;
1367 }
1368 
1369 /*
1370 ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
1371 ** the motherboard.
1372 */
1373 static struct device *eisa_probe(struct device *dev)
     /*  */
1374 {
1375   int i, iobase = EWRK3_EISA_IO_PORTS;
1376   int status;
1377 
1378   iobase+=EISA_SLOT_INC;            /* get the first slot address */
1379   for (status = -ENODEV, i=1; i<MAX_EISA_SLOTS; i++, iobase+=EISA_SLOT_INC) {
1380 
1381     /* Anything else registered here? */
1382     if (!check_region(iobase, EWRK3_IOP_INC)) {
1383       if (DevicePresent(iobase) == 0) {
1384 /*
1385 ** Device found. Mark its slot location for future reference. Only 7
1386 ** EtherWORKS devices can exist in EISA space....
1387 */
1388         mem_chkd |= (0x01 << (i + 24));
1389         request_region(iobase, EWRK3_IOP_INC,"ewrk3");
1390         if (num_ewrk3s > 0) {        /* only gets here in autoprobe */
1391           dev = alloc_device(dev, iobase);
1392         } else {
1393           if ((status = ewrk3_hw_init(dev, iobase)) == 0) {
1394             num_ewrk3s++;
1395           }
1396         }
1397         num_eth++;
1398       }
1399     }
1400   }
1401   return dev;
1402 }
1403 
1404 /*
1405 ** Allocate the device by pointing to the next available space in the
1406 ** device structure. Should one not be available, it is created.
1407 */
1408 static struct device *alloc_device(struct device *dev, int iobase)
     /*  */
1409 {
1410   /*
1411   ** Check the device structures for an end of list or unused device
1412   */
1413   while (dev->next != NULL) {
1414     if (dev->next->base_addr == 0xffe0) break;
1415     dev = dev->next;         /* walk through eth device list */
1416     num_eth++;               /* increment eth device number */
1417   }
1418 
1419   /*
1420   ** If no more device structures, malloc one up. If memory could
1421   ** not be allocated, print an error message.
1422   */
1423   if (dev->next == NULL) {
1424     dev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
1425                                          GFP_KERNEL);
1426     if (dev->next == NULL) {
1427       printk("eth%d: Device not initialised, insufficient memory\n",
1428              num_eth);
1429     }
1430   }
1431   
1432   /*
1433   ** If the memory was allocated, point to the new memory area
1434   ** and initialize it (name, I/O address, next device (NULL) and
1435   ** initialisation probe routine).
1436   */
1437   if ((dev->next != NULL) &&
1438       (num_eth > 0) && (num_eth < 9999)) {
1439     dev = dev->next;                    /* point to the new device */
1440     dev->name = (char *)(dev + sizeof(struct device));
1441     sprintf(dev->name,"eth%d", num_eth);/* New device name */
1442     dev->base_addr = iobase;            /* assign the io address */
1443     dev->next = NULL;                   /* mark the end of list */
1444     dev->init = &ewrk3_probe;           /* initialisation routine */
1445     num_ewrk3s++;
1446   }
1447 
1448   return dev;
1449 }
1450 #endif    /* MODULE */
1451 
1452 /*
1453 ** Read the EWRK3 EEPROM using this routine
1454 */
1455 static int Read_EEPROM(short iobase, unsigned char eaddr)
     /*  */
1456 {
1457   int i;
1458 
1459   outb((eaddr & 0x3f), EWRK3_PIR1);     /* set up 6 bits of address info */
1460   outb(EEPROM_RD, EWRK3_IOPR);          /* issue read command */
1461   for (i=0;i<5000;i++) inb(EWRK3_CSR);  /* wait 1msec */
1462 
1463   return inw(EWRK3_EPROM1);             /* 16 bits data return */
1464 }
1465 
1466 /*
1467 ** Write the EWRK3 EEPROM using this routine
1468 */
1469 static int Write_EEPROM(short data, short iobase, unsigned char eaddr)
     /*  */
1470 {
1471   int i;
1472 
1473   outb(EEPROM_WR_EN, EWRK3_IOPR);       /* issue write enable command */
1474   for (i=0;i<5000;i++) inb(EWRK3_CSR);  /* wait 1msec */
1475   outw(data, EWRK3_EPROM1);             /* write data to register */
1476   outb((eaddr & 0x3f), EWRK3_PIR1);     /* set up 6 bits of address info */
1477   outb(EEPROM_WR, EWRK3_IOPR);          /* issue write command */
1478   for (i=0;i<75000;i++) inb(EWRK3_CSR); /* wait 15msec */
1479   outb(EEPROM_WR_DIS, EWRK3_IOPR);      /* issue write disable command */
1480   for (i=0;i<5000;i++) inb(EWRK3_CSR);  /* wait 1msec */
1481 
1482   return 0;
1483 }
1484 
1485 /*
1486 ** Look for a particular board name in the on-board EEPROM.
1487 */
1488 static void EthwrkSignature(char *name, char *eeprom_image)
     /*  */
1489 {
1490   unsigned long i,j,k;
1491   char signatures[][EWRK3_NAME_LENGTH] = EWRK3_SIGNATURE;
1492 
1493   strcpy(name, "");
1494   for (i=0;*signatures[i] != '\0' && *name == '\0';i++) {
1495     for (j=EEPROM_PNAME7,k=0;j<=EEPROM_PNAME0 && k<strlen(signatures[i]);j++) {
1496       if (signatures[i][k] == eeprom_image[j]) {          /* track signature */
1497         k++;
1498       } else {                         /* lost signature; begin search again */
1499         k=0;
1500       }
1501     }
1502     if (k == strlen(signatures[i])) {
1503       for (k=0; k<EWRK3_NAME_LENGTH; k++) {
1504         name[k] = eeprom_image[EEPROM_PNAME7 + k];
1505         name[EWRK3_NAME_LENGTH] = '\0';
1506       }
1507     }
1508   }
1509 
1510   return;                                   /* return the device name string */
1511 }
1512 
1513 /*
1514 ** Look for a special sequence in the Ethernet station address PROM that
1515 ** is common across all EWRK3 products.
1516 */
1517 
1518 static int DevicePresent(short iobase)
     /*  */
1519 {
1520   static short fp=1,sigLength=0;
1521   static char devSig[] = PROBE_SEQUENCE;
1522   char data;
1523   int i, j, status = 0;
1524   static char asc2hex(char value);
1525 
1526 /* 
1527 ** Convert the ascii signature to a hex equivalent & pack in place 
1528 */
1529   if (fp) {                               /* only do this once!... */
1530     for (i=0,j=0;devSig[i] != '\0' && !status;i+=2,j++) {
1531       if ((devSig[i]=asc2hex(devSig[i]))>=0) {
1532         devSig[i]<<=4;
1533         if((devSig[i+1]=asc2hex(devSig[i+1]))>=0){
1534           devSig[j]=devSig[i]+devSig[i+1];
1535         } else {
1536           status= -1;
1537         }
1538       } else {
1539         status= -1;
1540       }
1541     }
1542     sigLength=j;
1543     fp = 0;
1544   }
1545 
1546 /* 
1547 ** Search the Ethernet address ROM for the signature. Since the ROM address
1548 ** counter can start at an arbitrary point, the search must include the entire
1549 ** probe sequence length plus the (length_of_the_signature - 1).
1550 ** Stop the search IMMEDIATELY after the signature is found so that the
1551 ** PROM address counter is correctly positioned at the start of the
1552 ** ethernet address for later read out.
1553 */
1554   if (!status) {
1555     for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
1556       data = inb(EWRK3_APROM);
1557       if (devSig[j] == data) {    /* track signature */
1558         j++;
1559       } else {                    /* lost signature; begin search again */
1560         j=0;
1561       }
1562     }
1563 
1564     if (j!=sigLength) {
1565       status = -ENODEV;           /* search failed */
1566     }
1567   }
1568 
1569   return status;
1570 }
1571 
1572 static unsigned char aprom_crc(struct device *dev, unsigned char *eeprom_image, char chipType)
     /*  */
1573 {
1574   long k;
1575   unsigned short j,chksum;
1576   unsigned char crc, lfsr, sd, status = 0;
1577   int iobase = dev->base_addr;
1578 
1579   if (chipType == LeMAC2) {
1580     for (crc=0x6a, j=0; j<ETH_ALEN; j++) {
1581       for (sd=inb(EWRK3_PAR0+j), k=0; k<8; k++, sd >>= 1) {
1582         lfsr = ((((crc & 0x02) >> 1) ^ (crc & 0x01)) ^ (sd & 0x01)) << 7;
1583         crc = (crc >> 1) + lfsr;
1584       }
1585     }
1586     if (crc != eeprom_image[EEPROM_PA_CRC]) status = -1;
1587   } else {
1588     for (k=0,j=0;j<3;j++) {
1589       k <<= 1 ;
1590       if (k > 0xffff) k-=0xffff;
1591       k += inw(EWRK3_PAR0 + (j<<1));
1592       if (k > 0xffff) k-=0xffff;
1593     }
1594     if (k == 0xffff) k=0;
1595     chksum = inb(EWRK3_APROM);
1596     chksum |= (inb(EWRK3_APROM)<<8);
1597     if (k != chksum) status = -1;
1598   }
1599 
1600   return status;
1601 }
1602 
1603 /*
1604 ** Perform IOCTL call functions here. Some are privileged operations and the
1605 ** effective uid is checked in those cases.
1606 */
1607 static int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
     /*  */
1608 {
1609   struct ewrk3_private *lp = (struct ewrk3_private *)dev->priv;
1610   struct ewrk3_ioctl *ioc = (struct ewrk3_ioctl *) &rq->ifr_data;
1611   int i, j, iobase = dev->base_addr, status = 0;
1612   unsigned char csr;
1613   union {
1614     unsigned char addr[HASH_TABLE_LEN * ETH_ALEN];
1615     unsigned short val[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1616   } tmp;
1617 
1618   switch(ioc->cmd) {
1619   case EWRK3_GET_HWADDR:             /* Get the hardware address */
1620     for (i=0; i<ETH_ALEN; i++) {
1621       tmp.addr[i] = dev->dev_addr[i];
1622     }
1623     ioc->len = ETH_ALEN;
1624     memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1625 
1626     break;
1627   case EWRK3_SET_HWADDR:             /* Set the hardware address */
1628     if (suser()) {
1629       csr = inb(EWRK3_CSR);
1630       csr |= (TXD|RXD);
1631       outb(csr, EWRK3_CSR);                  /* Disable the TX and RX */
1632 
1633       memcpy_fromfs(tmp.addr,ioc->data,ETH_ALEN);
1634       for (i=0; i<ETH_ALEN; i++) {
1635         dev->dev_addr[i] = tmp.addr[i];
1636         outb(tmp.addr[i], EWRK3_PAR0 + i);
1637       }
1638 
1639       csr &= ~(TXD|RXD);                       /* Enable the TX and RX */
1640       outb(csr, EWRK3_CSR);
1641     } else {
1642       status = -EPERM;
1643     }
1644 
1645     break;
1646   case EWRK3_SET_PROM:               /* Set Promiscuous Mode */
1647     if (suser()) {
1648       csr = inb(EWRK3_CSR);
1649       csr |= PME;
1650       csr &= ~MCE;
1651       outb(csr, EWRK3_CSR);
1652     } else {
1653       status = -EPERM;
1654     }
1655 
1656     break;
1657   case EWRK3_CLR_PROM:               /* Clear Promiscuous Mode */
1658     if (suser()) {
1659       csr = inb(EWRK3_CSR);
1660       csr &= ~PME;
1661       outb(csr, EWRK3_CSR);
1662     } else {
1663       status = -EPERM;
1664     }
1665 
1666     break;
1667   case EWRK3_SAY_BOO:                /* Say "Boo!" to the kernel log file */
1668     printk("%s: Boo!\n", dev->name);
1669 
1670     break;
1671   case EWRK3_GET_MCA:                /* Get the multicast address table */
1672     while (set_bit(0, (void *)&lp->lock) != 0); /* Wait for lock to free */
1673     if (lp->shmem_length == IO_ONLY) {
1674       outb(0, EWRK3_IOPR);
1675       outw(PAGE0_HTE, EWRK3_PIR1);
1676       for (i=0; i<(HASH_TABLE_LEN >> 3); i++) {
1677         tmp.addr[i] = inb(EWRK3_DATA);
1678       }
1679     } else {
1680       outb(0, EWRK3_MPR);
1681       memcpy(tmp.addr, (char *)(lp->shmem_base + PAGE0_HTE), (HASH_TABLE_LEN >> 3));
1682     }
1683     ioc->len = (HASH_TABLE_LEN >> 3);
1684     memcpy_tofs(ioc->data, tmp.addr, ioc->len); 
1685     lp->lock = 0;                               /* Unlock the page register */
1686 
1687     break;
1688   case EWRK3_SET_MCA:                /* Set a multicast address */
1689     if (suser()) {
1690       if (ioc->len != HASH_TABLE_LEN) {         /* MCA changes */
1691         memcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
1692       }
1693       set_multicast_list(dev, ioc->len, tmp.addr);
1694     } else {
1695       status = -EPERM;
1696     }
1697 
1698     break;
1699   case EWRK3_CLR_MCA:                /* Clear all multicast addresses */
1700     if (suser()) {
1701       set_multicast_list(dev, 0, NULL);
1702     } else {
1703       status = -EPERM;
1704     }
1705 
1706     break;
1707   case EWRK3_MCA_EN:                 /* Enable multicast addressing */
1708     if (suser()) {
1709       csr = inb(EWRK3_CSR);
1710       csr |= MCE;
1711       csr &= ~PME;
1712       outb(csr, EWRK3_CSR);
1713     } else {
1714       status = -EPERM;
1715     }
1716 
1717     break;
1718   case EWRK3_GET_STATS:              /* Get the driver statistics */
1719     cli();
1720     memcpy_tofs(ioc->data, &lp->pktStats, sizeof(lp->pktStats)); 
1721     ioc->len = EWRK3_PKT_STAT_SZ;
1722     sti();
1723 
1724     break;
1725   case EWRK3_CLR_STATS:              /* Zero out the driver statistics */
1726     if (suser()) {
1727       cli();
1728       memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1729       sti();
1730     } else {
1731       status = -EPERM;
1732     }
1733 
1734     break;
1735   case EWRK3_GET_CSR:                /* Get the CSR Register contents */
1736     tmp.addr[0] = inb(EWRK3_CSR);
1737     memcpy_tofs(ioc->data, tmp.addr, 1);
1738 
1739     break;
1740   case EWRK3_SET_CSR:                /* Set the CSR Register contents */
1741     if (suser()) {
1742       memcpy_fromfs(tmp.addr, ioc->data, 1);
1743       outb(tmp.addr[0], EWRK3_CSR);
1744     } else {
1745       status = -EPERM;
1746     }
1747 
1748     break;
1749   case EWRK3_GET_EEPROM:             /* Get the EEPROM contents */
1750     if (suser()) {
1751       for (i=0; i<(EEPROM_MAX>>1); i++) {
1752         tmp.val[i] = (short)Read_EEPROM(iobase, i);
1753       }
1754       i = EEPROM_MAX;
1755       tmp.addr[i++] = inb(EWRK3_CMR);            /* Config/Management Reg. */
1756       for (j=0;j<ETH_ALEN;j++) {
1757         tmp.addr[i++] = inb(EWRK3_PAR0 + j);
1758       }
1759       ioc->len = EEPROM_MAX + 1 + ETH_ALEN;
1760       memcpy_tofs(ioc->data, tmp.addr, ioc->len);
1761     } else {
1762       status = -EPERM;
1763     }
1764 
1765     break;
1766   case EWRK3_SET_EEPROM:             /* Set the EEPROM contents */
1767     if (suser()) {
1768       memcpy_fromfs(tmp.addr, ioc->data, EEPROM_MAX);
1769       for (i=0; i<(EEPROM_MAX>>1); i++) {
1770         Write_EEPROM(tmp.val[i], iobase, i);
1771       }
1772     } else {
1773       status = -EPERM;
1774     }
1775 
1776     break;
1777   case EWRK3_GET_CMR:                /* Get the CMR Register contents */
1778     tmp.addr[0] = inb(EWRK3_CMR);
1779     memcpy_tofs(ioc->data, tmp.addr, 1);
1780 
1781     break;
1782   case EWRK3_SET_TX_CUT_THRU:        /* Set TX cut through mode */
1783     if (suser()) {
1784       lp->txc = 1;
1785     } else {
1786       status = -EPERM;
1787     }
1788 
1789     break;
1790   case EWRK3_CLR_TX_CUT_THRU:        /* Clear TX cut through mode */
1791     if (suser()) {
1792       lp->txc = 0;
1793     } else {
1794       status = -EPERM;
1795     }
1796 
1797     break;
1798   default:
1799     status = -EOPNOTSUPP;
1800   }
1801 
1802   return status;
1803 }
1804 
1805 static char asc2hex(char value)
     /*  */
1806 {
1807   value -= 0x30;                  /* normalise to 0..9 range */
1808   if (value >= 0) {
1809     if (value > 9) {              /* but may not be 10..15 */
1810       value &= 0x1f;              /* make A..F & a..f be the same */
1811       value -= 0x07;              /* normalise to 10..15 range */
1812       if ((value < 0x0a) || (value > 0x0f)) { /* if outside range then... */
1813         value = -1;               /* ...signal error */
1814       }
1815     }
1816   } else {                        /* outside 0..9 range... */
1817     value = -1;                   /* ...signal error */
1818   }
1819   return value;                   /* return hex char or error */
1820 }
1821 
1822 #ifdef MODULE
1823 char kernel_version[] = UTS_RELEASE;
1824 static struct device thisEthwrk = {
1825   "        ", /* device name inserted by /linux/drivers/net/net_init.c */
1826   0, 0, 0, 0,
1827   0x300, 5,  /* I/O address, IRQ */
1828   0, 0, 0, NULL, ewrk3_probe };
1829         
1830         
1831 int io=0x300;   /* <--- EDIT THESE LINES FOR YOUR CONFIGURATION */
1832 int irq=5;      /* or use the insmod io= irq= options           */
1833 
1834 int
1835 init_module(void)
     /*  */
1836 {
1837   thisEthwrk.base_addr=io;
1838   thisEthwrk.irq=irq;
1839   if (register_netdev(&thisEthwrk) != 0)
1840     return -EIO;
1841   return 0;
1842 }
1843 
1844 void
1845 cleanup_module(void)
     /*  */
1846 {
1847   if (MOD_IN_USE) {
1848     printk("%s: device busy, remove delayed\n",thisEthwrk.name);
1849   } else {
1850     unregister_netdev(&thisEthwrk);
1851   }
1852 }
1853 #endif /* MODULE */
1854 
1855 
1856 /*
1857  * Local variables:
1858  *  kernel-compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O2 -m486 -c ewrk3.c"
1859  *
1860  *  module-compile-command: "gcc -D__KERNEL__ -DMODULE -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O2 -m486 -c ewrk3.c"
1861  * End:
1862  */
1863 
1864 
1865
/* */
root/drivers/net/ewrk3.c

DEFINITIONS
