开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ewrk3.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：58k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ewrk3.c：源码内容
  1. /*  ewrk3.c: A DIGITAL EtherWORKS 3 ethernet driver for Linux.
  3.    Written 1994 by David C. Davies.
  5.    Copyright 1994 Digital Equipment Corporation.
  7.    This software may be used and distributed according to the terms of
  8.    the GNU General Public License, incorporated herein by reference.
  10.    This driver is written for the Digital Equipment Corporation series
  11.    of EtherWORKS ethernet cards:
  13.    DE203 Turbo (BNC)
  14.    DE204 Turbo (TP)
  15.    DE205 Turbo (TP BNC)
  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.
  21.    The author may be reached at davies@maniac.ultranet.com.
  23.    =========================================================================
  24.    This driver has been written  substantially  from scratch, although  its
  25.    inheritance of style and stack interface from 'depca.c' and in turn from
  26.    Donald Becker's 'lance.c' should be obvious.
  28.    The  DE203/4/5 boards  all  use a new proprietary   chip in place of the
  29.    LANCE chip used in prior cards  (DEPCA, DE100, DE200/1/2, DE210, DE422).
  30.    Use the depca.c driver in the standard distribution  for the LANCE based
  31.    cards from DIGITAL; this driver will not work with them.
  33.    The DE203/4/5 cards have 2  main modes: shared memory  and I/O only. I/O
  34.    only makes  all the card accesses through  I/O transactions and  no high
  35.    (shared)  memory is used. This  mode provides a >48% performance penalty
  36.    and  is deprecated in this  driver,  although allowed to provide initial
  37.    setup when hardstrapped.
  39.    The shared memory mode comes in 3 flavours: 2kB, 32kB and 64kB. There is
  40.    no point in using any mode other than the 2kB  mode - their performances
  41.    are virtually identical, although the driver has  been tested in the 2kB
  42.    and 32kB modes. I would suggest you uncomment the line:
  44.    FORCE_2K_MODE;
  46.    to allow the driver to configure the card as a  2kB card at your current
  47.    base  address, thus leaving more  room to clutter  your  system box with
  48.    other memory hungry boards.
  50.    As many ISA  and EISA cards  can be supported  under this driver  as you
  51.    wish, limited primarily  by the available IRQ lines,  rather than by the
  52.    available I/O addresses  (24 ISA,  16 EISA).   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) ...
  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}.
  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).
  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:
  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 1898 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.    [Alan Cox: Changed this so you can insmod ewrk3.o irq=x io=y]
  79.    [Adam Kropelin: now accepts irq=x1,x2 io=y1,y2 for multiple cards]
  80.    6) run the net startup bits for your new eth?? interface manually
  81.    (usually /etc/rc.inet[12] at boot time).
  82.    7) enjoy!
  84.    Note that autoprobing is not allowed in loadable modules - the system is
  85.    already up and running and you're messing with interrupts.
  87.    To unload a module, turn off the associated interface
  88.    'ifconfig eth?? down' then 'rmmod ewrk3'.
  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%.
  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.
  101.    TO DO:
  102.    ------
  105.    Revision History
  106.    ----------------
  108.    Version   Date        Description
  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/allocate region code.
  124.    0.32    16-jan-95   Broadcast packet fix.
  125.    0.33    10-Feb-95   Fix recognition bug reported by <bkm@star.rl.ac.uk>.
  126.    0.40    27-Dec-95   Rationalise MODULE and autoprobe code.
  127.    Rewrite for portability & updated.
  128.    ALPHA support from <jestabro@amt.tay1.dec.com>
  129.    Added verify_area() calls in ewrk3_ioctl() from
  130.    suggestion by <heiko@colossus.escape.de>.
  131.    Add new multicasting code.
  132.    0.41    20-Jan-96   Fix IRQ set up problem reported by
  133.    <kenneth@bbs.sas.ntu.ac.sg>.
  134.    0.42    22-Apr-96   Fix alloc_device() bug <jari@markkus2.fimr.fi>
  135.    0.43    16-Aug-96   Update alloc_device() to conform to de4x5.c
  136.    0.44    08-Nov-01   use library crc32 functions <Matt_Domsch@dell.com>
  137.    0.45    19-Jul-02   fix unaligned access on alpha <martin@bruli.net>
  138.    0.46    10-Oct-02   Multiple NIC support when module <akropel1@rochester.rr.com>
  139.    0.47    18-Oct-02   ethtool support <akropel1@rochester.rr.com>
  140.    0.48    18-Oct-02   cli/sti removal for 2.5 <vda@port.imtp.ilyichevsk.odessa.ua>
  141.    ioctl locking, signature search cleanup <akropel1@rochester.rr.com>
  143.    =========================================================================
  144.  */
  146. #include <linux/module.h>
  148. #include <linux/kernel.h>
  149. #include <linux/sched.h>
  150. #include <linux/string.h>
  151. #include <linux/errno.h>
  152. #include <linux/ioport.h>
  153. #include <linux/slab.h>
  154. #include <linux/interrupt.h>
  155. #include <linux/delay.h>
  156. #include <linux/init.h>
  157. #include <linux/crc32.h>
  158. #include <asm/bitops.h>
  159. #include <asm/io.h>
  160. #include <asm/dma.h>
  161. #include <asm/uaccess.h>
  163. #include <linux/netdevice.h>
  164. #include <linux/etherdevice.h>
  165. #include <linux/skbuff.h>
  166. #include <linux/ethtool.h>
  168. #include <linux/time.h>
  169. #include <linux/types.h>
  170. #include <linux/unistd.h>
  171. #include <linux/ctype.h>
  173. #include "ewrk3.h"
  175. #define DRV_NAME "ewrk3"
  176. #define DRV_VERSION "0.48"
  178. static char version[] __initdata =
  179. DRV_NAME ":v" DRV_VERSION " 2002/10/18 davies@maniac.ultranet.comn";
  181. #ifdef EWRK3_DEBUG
  182. static int ewrk3_debug = EWRK3_DEBUG;
  183. #else
  184. static int ewrk3_debug = 1;
  185. #endif
  187. #define EWRK3_NDA 0xffe0 /* No Device Address */
  189. #define PROBE_LENGTH    32
  190. #define ETH_PROM_SIG    0xAA5500FFUL
  192. #ifndef EWRK3_SIGNATURE
  193. #define EWRK3_SIGNATURE {"DE203","DE204","DE205",""}
  194. #define EWRK3_STRLEN 8
  195. #endif
  197. #ifndef EWRK3_RAM_BASE_ADDRESSES
  198. #define EWRK3_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0x00000}
  199. #endif
  201. /*
  202.    ** Sets up the I/O area for the autoprobe.
  203.  */
  204. #define EWRK3_IO_BASE 0x100 /* Start address for probe search */
  205. #define EWRK3_IOP_INC 0x20 /* I/O address increment */
  206. #define EWRK3_TOTAL_SIZE 0x20 /* required I/O address length */
  208. /* If you change this, remember to also change MODULE_PARM array limits */
  209. #ifndef MAX_NUM_EWRK3S
  210. #define MAX_NUM_EWRK3S 21
  211. #endif
  213. #ifndef EWRK3_EISA_IO_PORTS
  214. #define EWRK3_EISA_IO_PORTS 0x0c00 /* I/O port base address, slot 0 */
  215. #endif
  217. #ifndef MAX_EISA_SLOTS
  218. #define MAX_EISA_SLOTS 16
  219. #define EISA_SLOT_INC 0x1000
  220. #endif
  222. #define QUEUE_PKT_TIMEOUT (1*HZ) /* Jiffies */
  224. /*
  225.    ** EtherWORKS 3 shared memory window sizes
  226.  */
  227. #define IO_ONLY         0x00
  228. #define SHMEM_2K        0x800
  229. #define SHMEM_32K       0x8000
  230. #define SHMEM_64K       0x10000
  232. /*
  233.    ** EtherWORKS 3 IRQ ENABLE/DISABLE
  234.  */
  235. #define ENABLE_IRQs { 
  236.   icr |= lp->irq_mask;
  237.   outb(icr, EWRK3_ICR);                     /* Enable the IRQs */
  238. }
  240. #define DISABLE_IRQs { 
  241.   icr = inb(EWRK3_ICR);
  242.   icr &= ~lp->irq_mask;
  243.   outb(icr, EWRK3_ICR);                     /* Disable the IRQs */
  244. }
  246. /*
  247.    ** EtherWORKS 3 START/STOP
  248.  */
  249. #define START_EWRK3 { 
  250.   csr = inb(EWRK3_CSR);
  251.   csr &= ~(CSR_TXD|CSR_RXD);
  252.   outb(csr, EWRK3_CSR);                     /* Enable the TX and/or RX */
  253. }
  255. #define STOP_EWRK3 { 
  256.   csr = (CSR_TXD|CSR_RXD);
  257.   outb(csr, EWRK3_CSR);                     /* Disable the TX and/or RX */
  258. }
  260. /*
  261.    ** The EtherWORKS 3 private structure
  262.  */
  263. #define EWRK3_PKT_STAT_SZ 16
  264. #define EWRK3_PKT_BIN_SZ  128 /* Should be >=100 unless you
  265.    increase EWRK3_PKT_STAT_SZ */
  267. struct ewrk3_stats {
  268. u32 bins[EWRK3_PKT_STAT_SZ];
  269. u32 unicast;
  270. u32 multicast;
  271. u32 broadcast;
  272. u32 excessive_collisions;
  273. u32 tx_underruns;
  274. u32 excessive_underruns;
  275. };
  277. struct ewrk3_private {
  278. char adapter_name[80]; /* Name exported to /proc/ioports */
  279. u_long shmem_base; /* Shared memory start address */
  280. u_long shmem_length; /* Shared memory window length */
  281. struct net_device_stats stats; /* Public stats */
  282. struct ewrk3_stats pktStats; /* Private stats counters */
  283. u_char irq_mask; /* Adapter IRQ mask bits */
  284. u_char mPage; /* Maximum 2kB Page number */
  285. u_char lemac; /* Chip rev. level */
  286. u_char hard_strapped; /* Don't allow a full open */
  287. u_char txc; /* Transmit cut through */
  288. u_char *mctbl; /* Pointer to the multicast table */
  289. u_char led_mask; /* Used to reserve LED access for ethtool */
  290. spinlock_t hw_lock;
  291. };
  293. /*
  294.    ** Force the EtherWORKS 3 card to be in 2kB MODE
  295.  */
  296. #define FORCE_2K_MODE { 
  297.   shmem_length = SHMEM_2K;
  298.   outb(((mem_start - 0x80000) >> 11), EWRK3_MBR);
  299. }
  301. /*
  302.    ** Public Functions
  303.  */
  304. static int ewrk3_open(struct net_device *dev);
  305. static int ewrk3_queue_pkt(struct sk_buff *skb, struct net_device *dev);
  306. static void ewrk3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  307. static int ewrk3_close(struct net_device *dev);
  308. static struct net_device_stats *ewrk3_get_stats(struct net_device *dev);
  309. static void set_multicast_list(struct net_device *dev);
  310. static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  312. /*
  313.    ** Private functions
  314.  */
  315. static int ewrk3_hw_init(struct net_device *dev, u_long iobase);
  316. static void ewrk3_init(struct net_device *dev);
  317. static int ewrk3_rx(struct net_device *dev);
  318. static int ewrk3_tx(struct net_device *dev);
  319. static void ewrk3_timeout(struct net_device *dev);
  321. static void EthwrkSignature(char *name, char *eeprom_image);
  322. static int DevicePresent(u_long iobase);
  323. static void SetMulticastFilter(struct net_device *dev);
  324. static int EISA_signature(char *name, s32 eisa_id);
  326. static int Read_EEPROM(u_long iobase, u_char eaddr);
  327. static int Write_EEPROM(short data, u_long iobase, u_char eaddr);
  328. static u_char get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType);
  330. static void isa_probe(struct net_device *dev, u_long iobase);
  331. static void eisa_probe(struct net_device *dev, u_long iobase);
  332. static struct net_device *alloc_device(struct net_device *dev, u_long iobase);
  333. static int ewrk3_dev_index(char *s);
  334. static struct net_device *insert_device(struct net_device *dev, u_long iobase, int (*init) (struct net_device *));
  337. #ifdef MODULE
  338. int init_module(void);
  339. void cleanup_module(void);
  340. static int autoprobed = 1, loading_module = 1;
  342. #else
  343. static u_char irq[] =
  344. {5, 0, 10, 3, 11, 9, 15, 12};
  345. static int autoprobed, loading_module;
  347. #endif /* MODULE */
  349. static char name[EWRK3_STRLEN + 1];
  350. static int num_ewrk3s, num_eth;
  352. /*
  353.    ** Miscellaneous defines...
  354.  */
  355. #define INIT_EWRK3 {
  356.     outb(EEPROM_INIT, EWRK3_IOPR);
  357.     mdelay(1);
  358. }
  360. int __init ewrk3_probe(struct net_device *dev)
  361. {
  362. int tmp = num_ewrk3s, status = -ENODEV;
  363. u_long iobase = dev->base_addr;
  365. SET_MODULE_OWNER(dev);
  367. if ((iobase == 0) && loading_module) {
  368. printk("Autoprobing is not supported when loading a module based driver.n");
  369. status = -EIO;
  370. } else { /* First probe for the Ethernet */
  371. /* Address PROM pattern */
  372. isa_probe(dev, iobase);
  373. eisa_probe(dev, iobase);
  375. if ((tmp == num_ewrk3s) && (iobase != 0) && loading_module) {
  376. printk("%s: ewrk3_probe() cannot find device at 0x%04lx.n", dev->name,
  377.        iobase);
  378. }
  379. /*
  380.    ** Walk the device list to check that at least one device
  381.    ** initialised OK
  382.  */
  383. for (; (dev->priv == NULL) && (dev->next != NULL); dev = dev->next);
  385. if (dev->priv)
  386. status = 0;
  387. if (iobase == 0)
  388. autoprobed = 1;
  389. }
  391. return status;
  392. }
  394. static int __init 
  395. ewrk3_hw_init(struct net_device *dev, u_long iobase)
  396. {
  397. struct ewrk3_private *lp;
  398. int i, status = 0;
  399. u_long mem_start, shmem_length;
  400. u_char cr, cmr, icr, nicsr, lemac, hard_strapped = 0;
  401. u_char eeprom_image[EEPROM_MAX], chksum, eisa_cr = 0;
  403. /*
  404.    ** Stop the EWRK3. Enable the DBR ROM. Disable interrupts and remote boot.
  405.    ** This also disables the EISA_ENABLE bit in the EISA Control Register.
  406.  */
  407. if (iobase > 0x400)
  408. eisa_cr = inb(EISA_CR);
  409. INIT_EWRK3;
  411. nicsr = inb(EWRK3_CSR);
  413. icr = inb(EWRK3_ICR);
  414. icr &= 0x70;
  415. outb(icr, EWRK3_ICR); /* Disable all the IRQs */
  417. if (nicsr == (CSR_TXD | CSR_RXD)) {
  419. /* Check that the EEPROM is alive and well and not living on Pluto... */
  420. for (chksum = 0, i = 0; i < EEPROM_MAX; i += 2) {
  421. union {
  422. short val;
  423. char c[2];
  424. } tmp;
  426. tmp.val = (short) Read_EEPROM(iobase, (i >> 1));
  427. eeprom_image[i] = tmp.c[0];
  428. eeprom_image[i + 1] = tmp.c[1];
  429. chksum += eeprom_image[i] + eeprom_image[i + 1];
  430. }
  432. if (chksum != 0) { /* Bad EEPROM Data! */
  433. printk("%s: Device has a bad on-board EEPROM.n", dev->name);
  434. status = -ENXIO;
  435. } else {
  436. EthwrkSignature(name, eeprom_image);
  437. if (*name != '') { /* found a EWRK3 device */
  438. dev->base_addr = iobase;
  440. if (iobase > 0x400) {
  441. outb(eisa_cr, EISA_CR); /* Rewrite the EISA CR */
  442. }
  443. lemac = eeprom_image[EEPROM_CHIPVER];
  444. cmr = inb(EWRK3_CMR);
  446. if (((lemac == LeMAC) && ((cmr & CMR_NO_EEPROM) != CMR_NO_EEPROM)) ||
  447. ((lemac == LeMAC2) && !(cmr & CMR_HS))) {
  448. printk("%s: %s at %#4lx", dev->name, name, iobase);
  449. hard_strapped = 1;
  450. } else if ((iobase & 0x0fff) == EWRK3_EISA_IO_PORTS) {
  451. /* EISA slot address */
  452. printk("%s: %s at %#4lx (EISA slot %ld)",
  453.        dev->name, name, iobase, ((iobase >> 12) & 0x0f));
  454. } else { /* ISA port address */
  455. printk("%s: %s at %#4lx", dev->name, name, iobase);
  456. }
  458. if (!status) {
  459. printk(", h/w address ");
  460. if (lemac != LeMAC2)
  461. DevicePresent(iobase); /* need after EWRK3_INIT */
  462. status = get_hw_addr(dev, eeprom_image, lemac);
  463. for (i = 0; i < ETH_ALEN - 1; i++) { /* get the ethernet addr. */
  464. printk("%2.2x:", dev->dev_addr[i]);
  465. }
  466. printk("%2.2x,n", dev->dev_addr[i]);
  468. if (status) {
  469. printk("      which has an EEPROM CRC error.n");
  470. status = -ENXIO;
  471. } else {
  472. if (lemac == LeMAC2) { /* Special LeMAC2 CMR things */
  473. cmr &= ~(CMR_RA | CMR_WB | CMR_LINK | CMR_POLARITY | CMR_0WS);
  474. if (eeprom_image[EEPROM_MISC0] & READ_AHEAD)
  475. cmr |= CMR_RA;
  476. if (eeprom_image[EEPROM_MISC0] & WRITE_BEHIND)
  477. cmr |= CMR_WB;
  478. if (eeprom_image[EEPROM_NETMAN0] & NETMAN_POL)
  479. cmr |= CMR_POLARITY;
  480. if (eeprom_image[EEPROM_NETMAN0] & NETMAN_LINK)
  481. cmr |= CMR_LINK;
  482. if (eeprom_image[EEPROM_MISC0] & _0WS_ENA)
  483. cmr |= CMR_0WS;
  484. }
  485. if (eeprom_image[EEPROM_SETUP] & SETUP_DRAM)
  486. cmr |= CMR_DRAM;
  487. outb(cmr, EWRK3_CMR);
  489. cr = inb(EWRK3_CR); /* Set up the Control Register */
  490. cr |= eeprom_image[EEPROM_SETUP] & SETUP_APD;
  491. if (cr & SETUP_APD)
  492. cr |= eeprom_image[EEPROM_SETUP] & SETUP_PS;
  493. cr |= eeprom_image[EEPROM_MISC0] & FAST_BUS;
  494. cr |= eeprom_image[EEPROM_MISC0] & ENA_16;
  495. outb(cr, EWRK3_CR);
  497. /*
  498.    ** Determine the base address and window length for the EWRK3
  499.    ** RAM from the memory base register.
  500.  */
  501. mem_start = inb(EWRK3_MBR);
  502. shmem_length = 0;
  503. if (mem_start != 0) {
  504. if ((mem_start >= 0x0a) && (mem_start <= 0x0f)) {
  505. mem_start *= SHMEM_64K;
  506. shmem_length = SHMEM_64K;
  507. } else if ((mem_start >= 0x14) && (mem_start <= 0x1f)) {
  508. mem_start *= SHMEM_32K;
  509. shmem_length = SHMEM_32K;
  510. } else if ((mem_start >= 0x40) && (mem_start <= 0xff)) {
  511. mem_start = mem_start * SHMEM_2K + 0x80000;
  512. shmem_length = SHMEM_2K;
  513. } else {
  514. status = -ENXIO;
  515. }
  516. }
  517. /*
  518.    ** See the top of this source code for comments about
  519.    ** uncommenting this line.
  520.  */
  521. /*          FORCE_2K_MODE; */
  523. if (!status) {
  524. if (hard_strapped) {
  525. printk("      is hard strapped.n");
  526. } else if (mem_start) {
  527. printk("      has a %dk RAM window", (int) (shmem_length >> 10));
  528. printk(" at 0x%.5lx", mem_start);
  529. } else {
  530. printk("      is in I/O only mode");
  531. }
  533. /* private area & initialise */
  534. dev->priv = (void *) kmalloc(sizeof(struct ewrk3_private),
  535.      GFP_KERNEL);
  536. if (dev->priv == NULL) {
  537. return -ENOMEM;
  538. }
  539. lp = (struct ewrk3_private *) dev->priv;
  540. memset(dev->priv, 0, sizeof(struct ewrk3_private));
  541. lp->shmem_base = mem_start;
  542. lp->shmem_length = shmem_length;
  543. lp->lemac = lemac;
  544. lp->hard_strapped = hard_strapped;
  545. lp->led_mask = CR_LED;
  546. spin_lock_init(&lp->hw_lock);
  548. lp->mPage = 64;
  549. if (cmr & CMR_DRAM)
  550. lp->mPage <<= 1; /* 2 DRAMS on module */
  552. sprintf(lp->adapter_name, "%s (%s)", name, dev->name);
  553. request_region(iobase, EWRK3_TOTAL_SIZE, lp->adapter_name);
  555. lp->irq_mask = ICR_TNEM | ICR_TXDM | ICR_RNEM | ICR_RXDM;
  557. if (!hard_strapped) {
  558. /*
  559.    ** Enable EWRK3 board interrupts for autoprobing
  560.  */
  561. icr |= ICR_IE; /* Enable interrupts */
  562. outb(icr, EWRK3_ICR);
  564. /* The DMA channel may be passed in on this parameter. */
  565. dev->dma = 0;
  567. /* To auto-IRQ we enable the initialization-done and DMA err,
  568.    interrupts. For now we will always get a DMA error. */
  569. if (dev->irq < 2) {
  570. #ifndef MODULE
  571. u_char irqnum;
  572. unsigned long irq_mask, delay;
  575. irq_mask = probe_irq_on();
  577. /*
  578.    ** Trigger a TNE interrupt.
  579.  */
  580. icr |= ICR_TNEM;
  581. outb(1, EWRK3_TDQ); /* Write to the TX done queue */
  582. outb(icr, EWRK3_ICR); /* Unmask the TXD interrupt */
  584. irqnum = irq[((icr & IRQ_SEL) >> 4)];
  586. delay = jiffies + HZ/50;
  587. while (time_before(jiffies, delay)) ;
  588. dev->irq = probe_irq_off(irq_mask);
  589. if ((dev->irq) && (irqnum == dev->irq)) {
  590. printk(" and uses IRQ%d.n", dev->irq);
  591. } else {
  592. if (!dev->irq) {
  593. printk(" and failed to detect IRQ line.n");
  594. } else if ((irqnum == 1) && (lemac == LeMAC2)) {
  595. printk(" and an illegal IRQ line detected.n");
  596. } else {
  597. printk(", but incorrect IRQ line detected.n");
  598. }
  599. status = -ENXIO;
  600. }
  602. DISABLE_IRQs; /* Mask all interrupts */
  604. #endif /* MODULE */
  605. } else {
  606. printk(" and requires IRQ%d.n", dev->irq);
  607. }
  608. }
  609. if (status)
  610. release_region(iobase, EWRK3_TOTAL_SIZE);
  611. } else {
  612. status = -ENXIO;
  613. }
  614. }
  615. }
  616. } else {
  617. status = -ENXIO;
  618. }
  619. }
  621. if (!status) {
  622. if (ewrk3_debug > 1) {
  623. printk(version);
  624. }
  625. /* The EWRK3-specific entries in the device structure. */
  626. dev->open = ewrk3_open;
  627. dev->hard_start_xmit = ewrk3_queue_pkt;
  628. dev->stop = ewrk3_close;
  629. dev->get_stats = ewrk3_get_stats;
  630. dev->set_multicast_list = set_multicast_list;
  631. dev->do_ioctl = ewrk3_ioctl;
  632. dev->tx_timeout = ewrk3_timeout;
  633. dev->watchdog_timeo = QUEUE_PKT_TIMEOUT;
  635. dev->mem_start = 0;
  637. /* Fill in the generic field of the device structure. */
  638. ether_setup(dev);
  639. }
  640. } else {
  641. status = -ENXIO;
  642. }
  643. return status;
  644. }
  647. static int ewrk3_open(struct net_device *dev)
  648. {
  649. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  650. u_long iobase = dev->base_addr;
  651. int i, status = 0;
  652. u_char icr, csr;
  654. /*
  655.    ** Stop the TX and RX...
  656.  */
  657. STOP_EWRK3;
  659. if (!lp->hard_strapped) {
  660. if (request_irq(dev->irq, (void *) ewrk3_interrupt, 0, "ewrk3", dev)) {
  661. printk("ewrk3_open(): Requested IRQ%d is busyn", dev->irq);
  662. status = -EAGAIN;
  663. } else {
  665. /*
  666.    ** Re-initialize the EWRK3...
  667.  */
  668. ewrk3_init(dev);
  670. if (ewrk3_debug > 1) {
  671. printk("%s: ewrk3 open with irq %dn", dev->name, dev->irq);
  672. printk("  physical address: ");
  673. for (i = 0; i < 5; i++) {
  674. printk("%2.2x:", (u_char) dev->dev_addr[i]);
  675. }
  676. printk("%2.2xn", (u_char) dev->dev_addr[i]);
  677. if (lp->shmem_length == 0) {
  678. printk("  no shared memory, I/O only moden");
  679. } else {
  680. printk("  start of shared memory: 0x%08lxn", lp->shmem_base);
  681. printk("  window length: 0x%04lxn", lp->shmem_length);
  682. }
  683. printk("  # of DRAMS: %dn", ((inb(EWRK3_CMR) & 0x02) ? 2 : 1));
  684. printk("  csr:  0x%02xn", inb(EWRK3_CSR));
  685. printk("  cr:   0x%02xn", inb(EWRK3_CR));
  686. printk("  icr:  0x%02xn", inb(EWRK3_ICR));
  687. printk("  cmr:  0x%02xn", inb(EWRK3_CMR));
  688. printk("  fmqc: 0x%02xn", inb(EWRK3_FMQC));
  689. }
  690. netif_start_queue(dev);
  691. /*
  692.    ** Unmask EWRK3 board interrupts
  693.  */
  694. icr = inb(EWRK3_ICR);
  695. ENABLE_IRQs;
  697. }
  698. } else {
  699. printk(KERN_ERR "%s: ewrk3 available for hard strapped set up only.n", dev->name);
  700. printk(KERN_ERR "      Run the 'ewrk3setup' utility or remove the hard straps.n");
  701. return -EINVAL;
  702. }
  704. return status;
  705. }
  707. /*
  708.    ** Initialize the EtherWORKS 3 operating conditions
  709.  */
  710. static void ewrk3_init(struct net_device *dev)
  711. {
  712. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  713. u_char csr, page;
  714. u_long iobase = dev->base_addr;
  716. /*
  717.    ** Enable any multicasts
  718.  */
  719. set_multicast_list(dev);
  721. /*
  722.    ** Clean out any remaining entries in all the queues here
  723.  */
  724. while (inb(EWRK3_TQ));
  725. while (inb(EWRK3_TDQ));
  726. while (inb(EWRK3_RQ));
  727. while (inb(EWRK3_FMQ));
  729. /*
  730.    ** Write a clean free memory queue
  731.  */
  732. for (page = 1; page < lp->mPage; page++) { /* Write the free page numbers */
  733. outb(page, EWRK3_FMQ); /* to the Free Memory Queue */
  734. }
  736. START_EWRK3; /* Enable the TX and/or RX */
  737. }
  739. /*
  740.  *  Transmit timeout
  741.  */
  742.  
  743. static void ewrk3_timeout(struct net_device *dev)
  744. {
  745. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  746. u_char icr, csr;
  747. u_long iobase = dev->base_addr;
  749. if (!lp->hard_strapped) 
  750. {
  751. printk(KERN_WARNING"%s: transmit timed/locked out, status %04x, resetting.n",
  752.        dev->name, inb(EWRK3_CSR));
  754. /*
  755.    ** Mask all board interrupts
  756.  */
  757. DISABLE_IRQs;
  759. /*
  760.    ** Stop the TX and RX...
  761.  */
  762. STOP_EWRK3;
  764. ewrk3_init(dev);
  766. /*
  767.    ** Unmask EWRK3 board interrupts
  768.  */
  769. ENABLE_IRQs;
  771. dev->trans_start = jiffies;
  772. netif_wake_queue(dev);
  773. }
  774. }
  776. /*
  777.    ** Writes a socket buffer to the free page queue
  778.  */
  779. static int ewrk3_queue_pkt (struct sk_buff *skb, struct net_device *dev)
  780. {
  781. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  782. u_long iobase = dev->base_addr;
  783. u_long buf = 0;
  784. u_char icr;
  785. u_char page;
  787. spin_lock_irq (&lp->hw_lock);
  788. DISABLE_IRQs;
  790. /* if no resources available, exit, request packet be queued */
  791. if (inb (EWRK3_FMQC) == 0) {
  792. printk (KERN_WARNING "%s: ewrk3_queue_pkt(): No free resources...n",
  793. dev->name);
  794. printk (KERN_WARNING "%s: ewrk3_queue_pkt(): CSR: %02x ICR: %02x FMQC: %02xn",
  795. dev->name, inb (EWRK3_CSR), inb (EWRK3_ICR),
  796. inb (EWRK3_FMQC));
  797. goto err_out;
  798. }
  800. /*
  801.  ** Get a free page from the FMQ
  802.  */
  803. if ((page = inb (EWRK3_FMQ)) >= lp->mPage) {
  804. printk ("ewrk3_queue_pkt(): Invalid free memory page (%d).n",
  805.      (u_char) page);
  806. goto err_out;
  807. }
  810. /*
  811.  ** Set up shared memory window and pointer into the window
  812.  */
  813. if (lp->shmem_length == IO_ONLY) {
  814. outb (page, EWRK3_IOPR);
  815. } else if (lp->shmem_length == SHMEM_2K) {
  816. buf = lp->shmem_base;
  817. outb (page, EWRK3_MPR);
  818. } else if (lp->shmem_length == SHMEM_32K) {
  819. buf = ((((short) page << 11) & 0x7800) + lp->shmem_base);
  820. outb ((page >> 4), EWRK3_MPR);
  821. } else if (lp->shmem_length == SHMEM_64K) {
  822. buf = ((((short) page << 11) & 0xf800) + lp->shmem_base);
  823. outb ((page >> 5), EWRK3_MPR);
  824. } else {
  825. printk (KERN_ERR "%s: Oops - your private data area is hosed!n",
  826. dev->name);
  827. BUG ();
  828. }
  830. /*
  831.  ** Set up the buffer control structures and copy the data from
  832.  ** the socket buffer to the shared memory .
  833.  */
  834. if (lp->shmem_length == IO_ONLY) {
  835. int i;
  836. u_char *p = skb->data;
  837. outb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), EWRK3_DATA);
  838. outb ((char) (skb->len & 0xff), EWRK3_DATA);
  839. outb ((char) ((skb->len >> 8) & 0xff), EWRK3_DATA);
  840. outb ((char) 0x04, EWRK3_DATA);
  841. for (i = 0; i < skb->len; i++) {
  842. outb (*p++, EWRK3_DATA);
  843. }
  844. outb (page, EWRK3_TQ); /* Start sending pkt */
  845. } else {
  846. isa_writeb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), buf); /* ctrl byte */
  847. buf += 1;
  848. isa_writeb ((char) (skb->len & 0xff), buf); /* length (16 bit xfer) */
  849. buf += 1;
  850. if (lp->txc) {
  851. isa_writeb ((char)
  852.     (((skb->len >> 8) & 0xff) | XCT), buf);
  853. buf += 1;
  854. isa_writeb (0x04, buf); /* index byte */
  855. buf += 1;
  856. isa_writeb (0x00, (buf + skb->len)); /* Write the XCT flag */
  857. isa_memcpy_toio (buf, skb->data, PRELOAD); /* Write PRELOAD bytes */
  858. outb (page, EWRK3_TQ); /* Start sending pkt */
  859. isa_memcpy_toio (buf + PRELOAD,
  860.  skb->data + PRELOAD,
  861.  skb->len - PRELOAD);
  862. isa_writeb (0xff, (buf + skb->len)); /* Write the XCT flag */
  863. } else {
  864. isa_writeb ((char)
  865.     ((skb->len >> 8) & 0xff), buf);
  866. buf += 1;
  867. isa_writeb (0x04, buf); /* index byte */
  868. buf += 1;
  869. isa_memcpy_toio (buf, skb->data, skb->len); /* Write data bytes */
  870. outb (page, EWRK3_TQ); /* Start sending pkt */
  871. }
  872. }
  874. ENABLE_IRQs;
  875. spin_unlock_irq (&lp->hw_lock);
  877. lp->stats.tx_bytes += skb->len;
  878. dev->trans_start = jiffies;
  879. dev_kfree_skb (skb);
  881. /* Check for free resources: stop Tx queue if there are none */
  882. if (inb (EWRK3_FMQC) == 0)
  883. netif_stop_queue (dev);
  885. return 0;
  887. err_out:
  888. ENABLE_IRQs;
  889. spin_unlock_irq (&lp->hw_lock);
  890. return 1;
  891. }
  893. /*
  894.    ** The EWRK3 interrupt handler.
  895.  */
  896. static void ewrk3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  897. {
  898. struct net_device *dev = dev_id;
  899. struct ewrk3_private *lp;
  900. u_long iobase;
  901. u_char icr, cr, csr;
  903. lp = (struct ewrk3_private *) dev->priv;
  904. iobase = dev->base_addr;
  906. /* get the interrupt information */
  907. csr = inb(EWRK3_CSR);
  909. /*
  910.  ** Mask the EWRK3 board interrupts and turn on the LED
  911.  */
  912. spin_lock(&lp->hw_lock);
  913. DISABLE_IRQs;
  915. cr = inb(EWRK3_CR);
  916. cr |= lp->led_mask;
  917. outb(cr, EWRK3_CR);
  919. if (csr & CSR_RNE) /* Rx interrupt (packet[s] arrived) */
  920. ewrk3_rx(dev);
  922. if (csr & CSR_TNE) /* Tx interrupt (packet sent) */
  923. ewrk3_tx(dev);
  925. /*
  926.  ** Now deal with the TX/RX disable flags. These are set when there
  927.  ** are no more resources. If resources free up then enable these
  928.  ** interrupts, otherwise mask them - failure to do this will result
  929.  ** in the system hanging in an interrupt loop.
  930.  */
  931. if (inb(EWRK3_FMQC)) { /* any resources available? */
  932. lp->irq_mask |= ICR_TXDM | ICR_RXDM; /* enable the interrupt source */
  933. csr &= ~(CSR_TXD | CSR_RXD); /* ensure restart of a stalled TX or RX */
  934. outb(csr, EWRK3_CSR);
  935. netif_wake_queue(dev);
  936. } else {
  937. lp->irq_mask &= ~(ICR_TXDM | ICR_RXDM); /* disable the interrupt source */
  938. }
  940. /* Unmask the EWRK3 board interrupts and turn off the LED */
  941. cr &= ~(lp->led_mask);
  942. outb(cr, EWRK3_CR);
  943. ENABLE_IRQs;
  944. spin_unlock(&lp->hw_lock);
  945. }
  947. /* Called with lp->hw_lock held */
  948. static int ewrk3_rx(struct net_device *dev)
  949. {
  950. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  951. u_long iobase = dev->base_addr;
  952. int i, status = 0;
  953. u_char page;
  954. u_long buf = 0;
  956. while (inb(EWRK3_RQC) && !status) { /* Whilst there's incoming data */
  957. if ((page = inb(EWRK3_RQ)) < lp->mPage) { /* Get next entry's buffer page */
  958. /*
  959.    ** Set up shared memory window and pointer into the window
  960.  */
  961. if (lp->shmem_length == IO_ONLY) {
  962. outb(page, EWRK3_IOPR);
  963. } else if (lp->shmem_length == SHMEM_2K) {
  964. buf = lp->shmem_base;
  965. outb(page, EWRK3_MPR);
  966. } else if (lp->shmem_length == SHMEM_32K) {
  967. buf = ((((short) page << 11) & 0x7800) + lp->shmem_base);
  968. outb((page >> 4), EWRK3_MPR);
  969. } else if (lp->shmem_length == SHMEM_64K) {
  970. buf = ((((short) page << 11) & 0xf800) + lp->shmem_base);
  971. outb((page >> 5), EWRK3_MPR);
  972. } else {
  973. status = -1;
  974. printk("%s: Oops - your private data area is hosed!n", dev->name);
  975. }
  977. if (!status) {
  978. char rx_status;
  979. int pkt_len;
  981. if (lp->shmem_length == IO_ONLY) {
  982. rx_status = inb(EWRK3_DATA);
  983. pkt_len = inb(EWRK3_DATA);
  984. pkt_len |= ((u_short) inb(EWRK3_DATA) << 8);
  985. } else {
  986. rx_status = isa_readb(buf);
  987. buf += 1;
  988. pkt_len = isa_readw(buf);
  989. buf += 3;
  990. }
  992. if (!(rx_status & R_ROK)) { /* There was an error. */
  993. lp->stats.rx_errors++; /* Update the error stats. */
  994. if (rx_status & R_DBE)
  995. lp->stats.rx_frame_errors++;
  996. if (rx_status & R_CRC)
  997. lp->stats.rx_crc_errors++;
  998. if (rx_status & R_PLL)
  999. lp->stats.rx_fifo_errors++;
  1000. } else {
  1001. struct sk_buff *skb;
  1003. if ((skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
  1004. unsigned char *p;
  1005. skb->dev = dev;
  1006. skb_reserve(skb, 2); /* Align to 16 bytes */
  1007. p = skb_put(skb, pkt_len);
  1009. if (lp->shmem_length == IO_ONLY) {
  1010. *p = inb(EWRK3_DATA); /* dummy read */
  1011. for (i = 0; i < pkt_len; i++) {
  1012. *p++ = inb(EWRK3_DATA);
  1013. }
  1014. } else {
  1015. isa_memcpy_fromio(p, buf, pkt_len);
  1016. }
  1018. for (i = 1; i < EWRK3_PKT_STAT_SZ - 1; i++) {
  1019. if (pkt_len < i * EWRK3_PKT_BIN_SZ) {
  1020. lp->pktStats.bins[i]++;
  1021. i = EWRK3_PKT_STAT_SZ;
  1022. }
  1023. }
  1024. p = skb->data; /* Look at the dest addr */
  1025. if (p[0] & 0x01) { /* Multicast/Broadcast */
  1026. if ((*(s16 *) & p[0] == -1) && (*(s16 *) & p[2] == -1) && (*(s16 *) & p[4] == -1)) {
  1027. lp->pktStats.broadcast++;
  1028. } else {
  1029. lp->pktStats.multicast++;
  1030. }
  1031. } else if ((*(s16 *) & p[0] == *(s16 *) & dev->dev_addr[0]) &&
  1032.    (*(s16 *) & p[2] == *(s16 *) & dev->dev_addr[2]) &&
  1033.    (*(s16 *) & p[4] == *(s16 *) & dev->dev_addr[4])) {
  1034. lp->pktStats.unicast++;
  1035. }
  1036. lp->pktStats.bins[0]++; /* Duplicates stats.rx_packets */
  1037. if (lp->pktStats.bins[0] == 0) { /* Reset counters */
  1038. memset(&lp->pktStats, 0, sizeof(lp->pktStats));
  1039. }
  1040. /*
  1041.    ** Notify the upper protocol layers that there is another
  1042.    ** packet to handle
  1043.  */
  1044. skb->protocol = eth_type_trans(skb, dev);
  1045. netif_rx(skb);
  1047. /*
  1048.    ** Update stats
  1049.  */
  1050. dev->last_rx = jiffies;
  1051. lp->stats.rx_packets++;
  1052. lp->stats.rx_bytes += pkt_len;
  1053. } else {
  1054. printk("%s: Insufficient memory; nuking packet.n", dev->name);
  1055. lp->stats.rx_dropped++; /* Really, deferred. */
  1056. break;
  1057. }
  1058. }
  1059. }
  1060. /*
  1061.    ** Return the received buffer to the free memory queue
  1062.  */
  1063. outb(page, EWRK3_FMQ);
  1064. } else {
  1065. printk("ewrk3_rx(): Illegal page number, page %dn", page);
  1066. printk("ewrk3_rx(): CSR: %02x ICR: %02x FMQC: %02xn", inb(EWRK3_CSR), inb(EWRK3_ICR), inb(EWRK3_FMQC));
  1067. }
  1068. }
  1069. return status;
  1070. }
  1072. /*
  1073. ** Buffer sent - check for TX buffer errors.
  1074. ** Called with lp->hw_lock held
  1075. */
  1076. static int ewrk3_tx(struct net_device *dev)
  1077. {
  1078. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1079. u_long iobase = dev->base_addr;
  1080. u_char tx_status;
  1082. while ((tx_status = inb(EWRK3_TDQ)) > 0) { /* Whilst there's old buffers */
  1083. if (tx_status & T_VSTS) { /* The status is valid */
  1084. if (tx_status & T_TXE) {
  1085. lp->stats.tx_errors++;
  1086. if (tx_status & T_NCL)
  1087. lp->stats.tx_carrier_errors++;
  1088. if (tx_status & T_LCL)
  1089. lp->stats.tx_window_errors++;
  1090. if (tx_status & T_CTU) {
  1091. if ((tx_status & T_COLL) ^ T_XUR) {
  1092. lp->pktStats.tx_underruns++;
  1093. } else {
  1094. lp->pktStats.excessive_underruns++;
  1095. }
  1096. } else if (tx_status & T_COLL) {
  1097. if ((tx_status & T_COLL) ^ T_XCOLL) {
  1098. lp->stats.collisions++;
  1099. } else {
  1100. lp->pktStats.excessive_collisions++;
  1101. }
  1102. }
  1103. } else {
  1104. lp->stats.tx_packets++;
  1105. }
  1106. }
  1107. }
  1109. return 0;
  1110. }
  1112. static int ewrk3_close(struct net_device *dev)
  1113. {
  1114. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1115. u_long iobase = dev->base_addr;
  1116. u_char icr, csr;
  1118. netif_stop_queue(dev);
  1120. if (ewrk3_debug > 1) {
  1121. printk("%s: Shutting down ethercard, status was %2.2x.n",
  1122.        dev->name, inb(EWRK3_CSR));
  1123. }
  1124. /*
  1125.    ** We stop the EWRK3 here... mask interrupts and stop TX & RX
  1126.  */
  1127. DISABLE_IRQs;
  1129. STOP_EWRK3;
  1131. /*
  1132.    ** Clean out the TX and RX queues here (note that one entry
  1133.    ** may get added to either the TXD or RX queues if the TX or RX
  1134.    ** just starts processing a packet before the STOP_EWRK3 command
  1135.    ** is received. This will be flushed in the ewrk3_open() call).
  1136.  */
  1137. while (inb(EWRK3_TQ));
  1138. while (inb(EWRK3_TDQ));
  1139. while (inb(EWRK3_RQ));
  1141. if (!lp->hard_strapped) {
  1142. free_irq(dev->irq, dev);
  1143. }
  1144. return 0;
  1145. }
  1147. static struct net_device_stats *ewrk3_get_stats(struct net_device *dev)
  1148. {
  1149. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1151. /* Null body since there is no framing error counter */
  1152. return &lp->stats;
  1153. }
  1155. /*
  1156.    ** Set or clear the multicast filter for this adapter.
  1157.  */
  1158. static void set_multicast_list(struct net_device *dev)
  1159. {
  1160. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1161. u_long iobase = dev->base_addr;
  1162. u_char csr;
  1164. csr = inb(EWRK3_CSR);
  1166. if (lp->shmem_length == IO_ONLY) {
  1167. lp->mctbl = (char *) PAGE0_HTE;
  1168. } else {
  1169. lp->mctbl = (char *) (lp->shmem_base + PAGE0_HTE);
  1170. }
  1172. csr &= ~(CSR_PME | CSR_MCE);
  1173. if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
  1174. csr |= CSR_PME;
  1175. outb(csr, EWRK3_CSR);
  1176. } else {
  1177. SetMulticastFilter(dev);
  1178. csr |= CSR_MCE;
  1179. outb(csr, EWRK3_CSR);
  1180. }
  1181. }
  1183. /*
  1184.    ** Calculate the hash code and update the logical address filter
  1185.    ** from a list of ethernet multicast addresses.
  1186.    ** Little endian crc one liner from Matt Thomas, DEC.
  1187.    **
  1188.    ** Note that when clearing the table, the broadcast bit must remain asserted
  1189.    ** to receive broadcast messages.
  1190.  */
  1191. static void SetMulticastFilter(struct net_device *dev)
  1192. {
  1193. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1194. struct dev_mc_list *dmi = dev->mc_list;
  1195. u_long iobase = dev->base_addr;
  1196. int i;
  1197. char *addrs, bit, byte;
  1198. short *p = (short *) lp->mctbl;
  1199. u16 hashcode;
  1200. u32 crc;
  1202. spin_lock_irq(&lp->hw_lock);
  1204. if (lp->shmem_length == IO_ONLY) {
  1205. outb(0, EWRK3_IOPR);
  1206. outw(EEPROM_OFFSET(lp->mctbl), EWRK3_PIR1);
  1207. } else {
  1208. outb(0, EWRK3_MPR);
  1209. }
  1211. if (dev->flags & IFF_ALLMULTI) {
  1212. for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
  1213. if (lp->shmem_length == IO_ONLY) {
  1214. outb(0xff, EWRK3_DATA);
  1215. } else { /* memset didn't work here */
  1216. isa_writew(0xffff, (int) p);
  1217. p++;
  1218. i++;
  1219. }
  1220. }
  1221. } else {
  1222. /* Clear table except for broadcast bit */
  1223. if (lp->shmem_length == IO_ONLY) {
  1224. for (i = 0; i < (HASH_TABLE_LEN >> 4) - 1; i++) {
  1225. outb(0x00, EWRK3_DATA);
  1226. }
  1227. outb(0x80, EWRK3_DATA);
  1228. i++; /* insert the broadcast bit */
  1229. for (; i < (HASH_TABLE_LEN >> 3); i++) {
  1230. outb(0x00, EWRK3_DATA);
  1231. }
  1232. } else {
  1233. isa_memset_io((int) lp->mctbl, 0, (HASH_TABLE_LEN >> 3));
  1234. isa_writeb(0x80, (int) (lp->mctbl + (HASH_TABLE_LEN >> 4) - 1));
  1235. }
  1237. /* Update table */
  1238. for (i = 0; i < dev->mc_count; i++) { /* for each address in the list */
  1239. addrs = dmi->dmi_addr;
  1240. dmi = dmi->next;
  1241. if ((*addrs & 0x01) == 1) { /* multicast address? */
  1242. crc = ether_crc_le(ETH_ALEN, addrs);
  1243. hashcode = crc & ((1 << 9) - 1); /* hashcode is 9 LSb of CRC */
  1245. byte = hashcode >> 3; /* bit[3-8] -> byte in filter */
  1246. bit = 1 << (hashcode & 0x07); /* bit[0-2] -> bit in byte */
  1248. if (lp->shmem_length == IO_ONLY) {
  1249. u_char tmp;
  1251. outw((short) ((long) lp->mctbl) + byte, EWRK3_PIR1);
  1252. tmp = inb(EWRK3_DATA);
  1253. tmp |= bit;
  1254. outw((short) ((long) lp->mctbl) + byte, EWRK3_PIR1);
  1255. outb(tmp, EWRK3_DATA);
  1256. } else {
  1257. isa_writeb(isa_readb((int)(lp->mctbl + byte)) | bit, (int)(lp->mctbl + byte));
  1258. }
  1259. }
  1260. }
  1261. }
  1263. spin_unlock_irq(&lp->hw_lock);
  1264. }
  1266. /*
  1267.    ** ISA bus I/O device probe
  1268.  */
  1269. static void __init isa_probe(struct net_device *dev, u_long ioaddr)
  1270. {
  1271. int i = num_ewrk3s, maxSlots;
  1272. u_long iobase;
  1274. if (!ioaddr && autoprobed)
  1275. return; /* Been here before ! */
  1276. if (ioaddr >= 0x400)
  1277. return; /* Not ISA */
  1279. if (ioaddr == 0) { /* Autoprobing */
  1280. iobase = EWRK3_IO_BASE; /* Get the first slot address */
  1281. maxSlots = 24;
  1282. } else { /* Probe a specific location */
  1283. iobase = ioaddr;
  1284. maxSlots = i + 1;
  1285. }
  1287. for (; (i < maxSlots) && (dev != NULL); iobase += EWRK3_IOP_INC, i++) {
  1288. if (!check_region(iobase, EWRK3_TOTAL_SIZE)) {
  1289. if (DevicePresent(iobase) == 0) {
  1290. if ((dev = alloc_device(dev, iobase)) != NULL) {
  1291. if (ewrk3_hw_init(dev, iobase) == 0) {
  1292. num_ewrk3s++;
  1293. }
  1294. num_eth++;
  1295. }
  1296. }
  1297. } else if (autoprobed) {
  1298. printk("%s: region already allocated at 0x%04lx.n", dev->name, iobase);
  1299. }
  1300. }
  1302. return;
  1303. }
  1305. /*
  1306.    ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
  1307.    ** the motherboard.
  1308.  */
  1309. static void __init eisa_probe(struct net_device *dev, u_long ioaddr)
  1310. {
  1311. int i, maxSlots;
  1312. u_long iobase;
  1313. char name[EWRK3_STRLEN];
  1315. if (!ioaddr && autoprobed)
  1316. return; /* Been here before ! */
  1317. if (ioaddr < 0x1000)
  1318. return; /* Not EISA */
  1320. if (ioaddr == 0) { /* Autoprobing */
  1321. iobase = EISA_SLOT_INC; /* Get the first slot address */
  1322. i = 1;
  1323. maxSlots = MAX_EISA_SLOTS;
  1324. } else { /* Probe a specific location */
  1325. iobase = ioaddr;
  1326. i = (ioaddr >> 12);
  1327. maxSlots = i + 1;
  1328. }
  1330. for (i = 1; (i < maxSlots) && (dev != NULL); i++, iobase += EISA_SLOT_INC) {
  1331. if (EISA_signature(name, EISA_ID) == 0) {
  1332. if (!check_region(iobase, EWRK3_TOTAL_SIZE)) {
  1333. if (DevicePresent(iobase) == 0) {
  1334. if ((dev = alloc_device(dev, iobase)) != NULL) {
  1335. if (ewrk3_hw_init(dev, iobase) == 0) {
  1336. num_ewrk3s++;
  1337. }
  1338. num_eth++;
  1339. }
  1340. }
  1341. } else if (autoprobed) {
  1342. printk("%s: region already allocated at 0x%04lx.n", dev->name, iobase);
  1343. }
  1344. }
  1345. }
  1347. return;
  1348. }
  1350. /*
  1351.    ** Search the entire 'eth' device list for a fixed probe. If a match isn't
  1352.    ** found then check for an autoprobe or unused device location. If they
  1353.    ** are not available then insert a new device structure at the end of
  1354.    ** the current list.
  1355.  */
  1356. static struct net_device * __init  alloc_device(struct net_device *dev, u_long iobase)
  1357. {
  1358. struct net_device *adev = NULL;
  1359. int fixed = 0, new_dev = 0;
  1361. num_eth = ewrk3_dev_index(dev->name);
  1362. if (loading_module)
  1363. return dev;
  1365. while (1) {
  1366. if (((dev->base_addr == EWRK3_NDA) || (dev->base_addr == 0)) && !adev) {
  1367. adev = dev;
  1368. } else if ((dev->priv == NULL) && (dev->base_addr == iobase)) {
  1369. fixed = 1;
  1370. } else {
  1371. if (dev->next == NULL) {
  1372. new_dev = 1;
  1373. } else if (strncmp(dev->next->name, "eth", 3) != 0) {
  1374. new_dev = 1;
  1375. }
  1376. }
  1377. if ((dev->next == NULL) || new_dev || fixed)
  1378. break;
  1379. dev = dev->next;
  1380. num_eth++;
  1381. }
  1382. if (adev && !fixed) {
  1383. dev = adev;
  1384. num_eth = ewrk3_dev_index(dev->name);
  1385. new_dev = 0;
  1386. }
  1387. if (((dev->next == NULL) &&
  1388.      ((dev->base_addr != EWRK3_NDA) && (dev->base_addr != 0)) && !fixed) ||
  1389.     new_dev) {
  1390. num_eth++; /* New device */
  1391. dev = insert_device(dev, iobase, ewrk3_probe);
  1392. }
  1393. return dev;
  1394. }
  1396. /*
  1397.    ** If at end of eth device list and can't use current entry, malloc
  1398.    ** one up. If memory could not be allocated, print an error message.
  1399.  */
  1400. static struct net_device * __init
  1401. insert_device(struct net_device *dev, u_long iobase, int (*init) (struct net_device *))
  1402. {
  1403. struct net_device *new;
  1405. new = (struct net_device *) kmalloc(sizeof(struct net_device) + 8, GFP_KERNEL);
  1406. if (new == NULL) {
  1407. printk("eth%d: Device not initialised, insufficient memoryn", num_eth);
  1408. return NULL;
  1409. } else {
  1410. new->next = dev->next;
  1411. dev->next = new;
  1412. dev = dev->next; /* point to the new device */
  1413. if (num_eth > 9999) {
  1414. sprintf(dev->name, "eth????"); /* New device name */
  1415. } else {
  1416. sprintf(dev->name, "eth%d", num_eth); /* New device name */
  1417. }
  1418. dev->base_addr = iobase; /* assign the io address */
  1419. dev->init = init; /* initialisation routine */
  1420. }
  1422. return dev;
  1423. }
  1425. static int __init 
  1426. ewrk3_dev_index(char *s)
  1427. {
  1428. int i = 0, j = 0;
  1430. for (; *s; s++) {
  1431. if (isdigit(*s)) {
  1432. j = 1;
  1433. i = (i * 10) + (*s - '0');
  1434. } else if (j)
  1435. break;
  1436. }
  1438. return i;
  1439. }
  1441. /*
  1442.    ** Read the EWRK3 EEPROM using this routine
  1443.  */
  1444. static int Read_EEPROM(u_long iobase, u_char eaddr)
  1445. {
  1446. int i;
  1448. outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
  1449. outb(EEPROM_RD, EWRK3_IOPR); /* issue read command */
  1450. for (i = 0; i < 5000; i++)
  1451. inb(EWRK3_CSR); /* wait 1msec */
  1453. return inw(EWRK3_EPROM1); /* 16 bits data return */
  1454. }
  1456. /*
  1457.    ** Write the EWRK3 EEPROM using this routine
  1458.  */
  1459. static int Write_EEPROM(short data, u_long iobase, u_char eaddr)
  1460. {
  1461. int i;
  1463. outb(EEPROM_WR_EN, EWRK3_IOPR); /* issue write enable command */
  1464. for (i = 0; i < 5000; i++)
  1465. inb(EWRK3_CSR); /* wait 1msec */
  1466. outw(data, EWRK3_EPROM1); /* write data to register */
  1467. outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
  1468. outb(EEPROM_WR, EWRK3_IOPR); /* issue write command */
  1469. for (i = 0; i < 75000; i++)
  1470. inb(EWRK3_CSR); /* wait 15msec */
  1471. outb(EEPROM_WR_DIS, EWRK3_IOPR); /* issue write disable command */
  1472. for (i = 0; i < 5000; i++)
  1473. inb(EWRK3_CSR); /* wait 1msec */
  1475. return 0;
  1476. }
  1478. /*
  1479.    ** Look for a particular board name in the on-board EEPROM.
  1480.  */
  1481. static void __init EthwrkSignature(char *name, char *eeprom_image)
  1482. {
  1483. int i;
  1484. char *signatures[] = EWRK3_SIGNATURE;
  1486. for (i=0; *signatures[i] != ''; i++)
  1487. if( !strncmp(eeprom_image+EEPROM_PNAME7, signatures[i], strlen(signatures[i])) )
  1488. break;
  1490. if (*signatures[i] != '') {
  1491. memcpy(name, eeprom_image+EEPROM_PNAME7, EWRK3_STRLEN);
  1492. name[EWRK3_STRLEN] = '';
  1493. } else
  1494. name[0] = '';
  1496. return;
  1497. }
  1499. /*
  1500.    ** Look for a special sequence in the Ethernet station address PROM that
  1501.    ** is common across all EWRK3 products.
  1502.    **
  1503.    ** Search the Ethernet address ROM for the signature. Since the ROM address
  1504.    ** counter can start at an arbitrary point, the search must include the entire
  1505.    ** probe sequence length plus the (length_of_the_signature - 1).
  1506.    ** Stop the search IMMEDIATELY after the signature is found so that the
  1507.    ** PROM address counter is correctly positioned at the start of the
  1508.    ** ethernet address for later read out.
  1509.  */
  1511. static int __init DevicePresent(u_long iobase)
  1512. {
  1513. union {
  1514. struct {
  1515. u32 a;
  1516. u32 b;
  1517. } llsig;
  1518. char Sig[sizeof(u32) << 1];
  1519. }
  1520. dev;
  1521. short sigLength;
  1522. char data;
  1523. int i, j, status = 0;
  1525. dev.llsig.a = ETH_PROM_SIG;
  1526. dev.llsig.b = ETH_PROM_SIG;
  1527. sigLength = sizeof(u32) << 1;
  1529. for (i = 0, j = 0; j < sigLength && i < PROBE_LENGTH + sigLength - 1; i++) {
  1530. data = inb(EWRK3_APROM);
  1531. if (dev.Sig[j] == data) { /* track signature */
  1532. j++;
  1533. } else { /* lost signature; begin search again */
  1534. if (data == dev.Sig[0]) {
  1535. j = 1;
  1536. } else {
  1537. j = 0;
  1538. }
  1539. }
  1540. }
  1542. if (j != sigLength) {
  1543. status = -ENODEV; /* search failed */
  1544. }
  1545. return status;
  1546. }
  1548. static u_char __init get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType)
  1549. {
  1550. int i, j, k;
  1551. u_short chksum;
  1552. u_char crc, lfsr, sd, status = 0;
  1553. u_long iobase = dev->base_addr;
  1554. u16 tmp;
  1556. if (chipType == LeMAC2) {
  1557. for (crc = 0x6a, j = 0; j < ETH_ALEN; j++) {
  1558. sd = dev->dev_addr[j] = eeprom_image[EEPROM_PADDR0 + j];
  1559. outb(dev->dev_addr[j], EWRK3_PAR0 + j);
  1560. for (k = 0; k < 8; k++, sd >>= 1) {
  1561. lfsr = ((((crc & 0x02) >> 1) ^ (crc & 0x01)) ^ (sd & 0x01)) << 7;
  1562. crc = (crc >> 1) + lfsr;
  1563. }
  1564. }
  1565. if (crc != eeprom_image[EEPROM_PA_CRC])
  1566. status = -1;
  1567. } else {
  1568. for (i = 0, k = 0; i < ETH_ALEN;) {
  1569. k <<= 1;
  1570. if (k > 0xffff)
  1571. k -= 0xffff;
  1573. k += (u_char) (tmp = inb(EWRK3_APROM));
  1574. dev->dev_addr[i] = (u_char) tmp;
  1575. outb(dev->dev_addr[i], EWRK3_PAR0 + i);
  1576. i++;
  1577. k += (u_short) ((tmp = inb(EWRK3_APROM)) << 8);
  1578. dev->dev_addr[i] = (u_char) tmp;
  1579. outb(dev->dev_addr[i], EWRK3_PAR0 + i);
  1580. i++;
  1582. if (k > 0xffff)
  1583. k -= 0xffff;
  1584. }
  1585. if (k == 0xffff)
  1586. k = 0;
  1587. chksum = inb(EWRK3_APROM);
  1588. chksum |= (inb(EWRK3_APROM) << 8);
  1589. if (k != chksum)
  1590. status = -1;
  1591. }
  1593. return status;
  1594. }
  1596. /*
  1597.    ** Look for a particular board name in the EISA configuration space
  1598.  */
  1599. static int __init EISA_signature(char *name, s32 eisa_id)
  1600. {
  1601. u_long i;
  1602. char *signatures[] = EWRK3_SIGNATURE;
  1603. char ManCode[EWRK3_STRLEN];
  1604. union {
  1605. s32 ID;
  1606. char Id[4];
  1607. } Eisa;
  1608. int status = 0;
  1610. *name = '';
  1611. for (i = 0; i < 4; i++) {
  1612. Eisa.Id[i] = inb(eisa_id + i);
  1613. }
  1615. ManCode[0] = (((Eisa.Id[0] >> 2) & 0x1f) + 0x40);
  1616. ManCode[1] = (((Eisa.Id[1] & 0xe0) >> 5) + ((Eisa.Id[0] & 0x03) << 3) + 0x40);
  1617. ManCode[2] = (((Eisa.Id[2] >> 4) & 0x0f) + 0x30);
  1618. ManCode[3] = ((Eisa.Id[2] & 0x0f) + 0x30);
  1619. ManCode[4] = (((Eisa.Id[3] >> 4) & 0x0f) + 0x30);
  1620. ManCode[5] = '';
  1622. for (i = 0; (*signatures[i] != '') && (*name == ''); i++) {
  1623. if (strstr(ManCode, signatures[i]) != NULL) {
  1624. strcpy(name, ManCode);
  1625. status = 1;
  1626. }
  1627. }
  1629. return status; /* return the device name string */
  1630. }
  1632. static int ewrk3_ethtool_ioctl(struct net_device *dev, void *useraddr)
  1633. {
  1634. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1635. u_long iobase = dev->base_addr;
  1636. u32 ethcmd;
  1638. if (get_user(ethcmd, (u32 *)useraddr))
  1639. return -EFAULT;
  1641. switch (ethcmd) {
  1643. /* Get driver info */
  1644. case ETHTOOL_GDRVINFO: {
  1645. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1646. int fwrev = Read_EEPROM(dev->base_addr, EEPROM_REVLVL);
  1648. strcpy(info.driver, DRV_NAME);
  1649. strcpy(info.version, DRV_VERSION);
  1650. sprintf(info.fw_version, "%d", fwrev);
  1651. strcpy(info.bus_info, "N/A");
  1652. info.eedump_len = EEPROM_MAX;
  1653. if (copy_to_user(useraddr, &info, sizeof(info)))
  1654. return -EFAULT;
  1655. return 0;
  1656. }
  1658. /* Get settings */
  1659. case ETHTOOL_GSET: {
  1660. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  1661. u_char cr = inb(EWRK3_CR);
  1663. switch (lp->adapter_name[4]) {
  1664. case '3': /* DE203 */
  1665. ecmd.supported = SUPPORTED_BNC;
  1666. ecmd.port = PORT_BNC;
  1667. break;
  1669. case '4': /* DE204 */
  1670. ecmd.supported = SUPPORTED_TP;
  1671. ecmd.port = PORT_TP;
  1672. break;
  1674. case '5': /* DE205 */
  1675. ecmd.supported = SUPPORTED_TP | SUPPORTED_BNC | SUPPORTED_AUI;
  1676. ecmd.autoneg = !(cr & CR_APD);
  1677. /*
  1678. ** Port is only valid if autoneg is disabled
  1679. ** and even then we don't know if AUI is jumpered.
  1680. */
  1681. if (!ecmd.autoneg)
  1682. ecmd.port = (cr & CR_PSEL) ? PORT_BNC : PORT_TP;
  1683. break;
  1684. }
  1686. ecmd.supported |= SUPPORTED_10baseT_Half;
  1687. ecmd.speed = SPEED_10;
  1688. ecmd.duplex = DUPLEX_HALF;
  1690. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1691. return -EFAULT;
  1692. return 0;
  1693. }
  1695. /* Set settings */
  1696. case ETHTOOL_SSET: {
  1697. struct ethtool_cmd ecmd;
  1698. u_char cr;
  1699. u_long flags;
  1701. /* DE205 is the only card with anything to set */
  1702. if (lp->adapter_name[4] != '5')
  1703. return -EOPNOTSUPP;
  1705. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  1706. return -EFAULT;
  1708. /* Sanity-check parameters */
  1709. if (ecmd.speed != SPEED_10)
  1710. return -EINVAL;
  1711. if (ecmd.port != PORT_TP && ecmd.port != PORT_BNC)
  1712. return -EINVAL; /* AUI is not software-selectable */
  1713. if (ecmd.transceiver != XCVR_INTERNAL)
  1714. return -EINVAL;
  1715. if (ecmd.duplex != DUPLEX_HALF)
  1716. return -EINVAL;
  1717. if (ecmd.phy_address != 0)
  1718. return -EINVAL;
  1720. spin_lock_irqsave(&lp->hw_lock, flags);
  1721. cr = inb(EWRK3_CR);
  1723. /* If Autoneg is set, change to Auto Port mode */
  1724. /* Otherwise, disable Auto Port and set port explicitly */
  1725. if (ecmd.autoneg) {
  1726. cr &= ~CR_APD;
  1727. } else {
  1728. cr |= CR_APD;
  1729. if (ecmd.port == PORT_TP)
  1730. cr &= ~CR_PSEL; /* Force TP */
  1731. else
  1732. cr |= CR_PSEL; /* Force BNC */
  1733. }
  1735. /* Commit the changes */
  1736. outb(cr, EWRK3_CR);
  1738. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1739. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1740. return -EFAULT;
  1741. return 0;
  1742. }
  1744. /* Get link status */
  1745. case ETHTOOL_GLINK: {
  1746. struct ethtool_value edata = { ETHTOOL_GLINK };
  1747. u_char cmr = inb(EWRK3_CMR);
  1749. /* DE203 has BNC only and link status does not apply */
  1750. if (lp->adapter_name[4] == '3')
  1751. return -EOPNOTSUPP;
  1753. /* On DE204 this is always valid since TP is the only port. */
  1754. /* On DE205 this reflects TP status even if BNC or AUI is selected. */
  1755. edata.data = !(cmr & CMR_LINK);
  1757. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1758. return -EFAULT;
  1759. return 0;
  1760. }
  1762. #ifdef BROKEN
  1763. /* Blink LED for identification */
  1764. case ETHTOOL_PHYS_ID: {
  1765. struct ethtool_value edata;
  1766. u_long flags;
  1767. long delay, ret;
  1768. u_char cr;
  1769. int count;
  1770. wait_queue_head_t wait;
  1772. init_waitqueue_head(&wait);
  1774. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1775. return -EFAULT;
  1777. /* Toggle LED 4x per second */
  1778. delay = HZ >> 2;
  1779. count = edata.data << 2;
  1781. spin_lock_irqsave(&lp->hw_lock, flags);
  1783. /* Bail if a PHYS_ID is already in progress */
  1784. if (lp->led_mask == 0) {
  1785. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1786. return -EBUSY;
  1787. }
  1789. /* Prevent ISR from twiddling the LED */
  1790. lp->led_mask = 0;
  1792. while (count--) {
  1793. /* Toggle the LED */
  1794. cr = inb(EWRK3_CR);
  1795. outb(cr ^ CR_LED, EWRK3_CR);
  1797. /* Wait a little while */
  1798. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1799. ret = delay;
  1800. __wait_event_interruptible_timeout(wait, 0, ret);
  1801. spin_lock_irqsave(&lp->hw_lock, flags);
  1803. /* Exit if we got a signal */
  1804. if (ret == -ERESTARTSYS)
  1805. goto out;
  1806. }
  1808. ret = 0;
  1809. out:
  1810. lp->led_mask = CR_LED;
  1811. cr = inb(EWRK3_CR);
  1812. outb(cr & ~CR_LED, EWRK3_CR);
  1813. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1814. return ret;
  1815. }
  1816. #endif /* BROKEN */
  1818. }
  1820. return -EOPNOTSUPP;
  1821. }
  1823. /*
  1824.    ** Perform IOCTL call functions here. Some are privileged operations and the
  1825.    ** effective uid is checked in those cases.
  1826.  */
  1827. static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1828. {
  1829. struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
  1830. struct ewrk3_ioctl *ioc = (struct ewrk3_ioctl *) &rq->ifr_data;
  1831. u_long iobase = dev->base_addr;
  1832. int i, j, status = 0;
  1833. u_char csr;
  1834. unsigned long flags;
  1835. union ewrk3_addr {
  1836. u_char addr[HASH_TABLE_LEN * ETH_ALEN];
  1837. u_short val[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
  1838. };
  1840. union ewrk3_addr *tmp;
  1842. /* ethtool IOCTLs are handled elsewhere */
  1843. if (cmd == SIOCETHTOOL)
  1844. return ewrk3_ethtool_ioctl(dev, (void *)rq->ifr_data);
  1846. /* Other than ethtool, all we handle are private IOCTLs */
  1847. if (cmd != EWRK3IOCTL)
  1848. return -EOPNOTSUPP;
  1850. tmp = kmalloc(sizeof(union ewrk3_addr), GFP_KERNEL);
  1851. if(tmp==NULL)
  1852. return -ENOMEM;
  1854. switch (ioc->cmd) {
  1855. case EWRK3_GET_HWADDR: /* Get the hardware address */
  1856. for (i = 0; i < ETH_ALEN; i++) {
  1857. tmp->addr[i] = dev->dev_addr[i];
  1858. }
  1859. ioc->len = ETH_ALEN;
  1860. if (copy_to_user(ioc->data, tmp->addr, ioc->len))
  1861. status = -EFAULT;
  1862. break;
  1864. case EWRK3_SET_HWADDR: /* Set the hardware address */
  1865. if (capable(CAP_NET_ADMIN)) {
  1866. spin_lock_irqsave(&lp->hw_lock, flags);
  1867. csr = inb(EWRK3_CSR);
  1868. csr |= (CSR_TXD | CSR_RXD);
  1869. outb(csr, EWRK3_CSR); /* Disable the TX and RX */
  1870. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1872. if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN)) {
  1873. status = -EFAULT;
  1874. break;
  1875. }
  1876. spin_lock_irqsave(&lp->hw_lock, flags);
  1877. for (i = 0; i < ETH_ALEN; i++) {
  1878. dev->dev_addr[i] = tmp->addr[i];
  1879. outb(tmp->addr[i], EWRK3_PAR0 + i);
  1880. }
  1882. csr = inb(EWRK3_CSR);
  1883. csr &= ~(CSR_TXD | CSR_RXD); /* Enable the TX and RX */
  1884. outb(csr, EWRK3_CSR);
  1885. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1886. } else {
  1887. status = -EPERM;
  1888. }
  1890. break;
  1891. case EWRK3_SET_PROM: /* Set Promiscuous Mode */
  1892. if (capable(CAP_NET_ADMIN)) {
  1893. spin_lock_irqsave(&lp->hw_lock, flags);
  1894. csr = inb(EWRK3_CSR);
  1895. csr |= CSR_PME;
  1896. csr &= ~CSR_MCE;
  1897. outb(csr, EWRK3_CSR);
  1898. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1899. } else {
  1900. status = -EPERM;
  1901. }
  1903. break;
  1904. case EWRK3_CLR_PROM: /* Clear Promiscuous Mode */
  1905. if (capable(CAP_NET_ADMIN)) {
  1906. spin_lock_irqsave(&lp->hw_lock, flags);
  1907. csr = inb(EWRK3_CSR);
  1908. csr &= ~CSR_PME;
  1909. outb(csr, EWRK3_CSR);
  1910. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1911. } else {
  1912. status = -EPERM;
  1913. }
  1915. break;
  1916. case EWRK3_GET_MCA: /* Get the multicast address table */
  1917. spin_lock_irqsave(&lp->hw_lock, flags);
  1918. if (lp->shmem_length == IO_ONLY) {
  1919. outb(0, EWRK3_IOPR);
  1920. outw(PAGE0_HTE, EWRK3_PIR1);
  1921. for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
  1922. tmp->addr[i] = inb(EWRK3_DATA);
  1923. }
  1924. } else {
  1925. outb(0, EWRK3_MPR);
  1926. isa_memcpy_fromio(tmp->addr, lp->shmem_base + PAGE0_HTE, (HASH_TABLE_LEN >> 3));
  1927. }
  1928. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1930. ioc->len = (HASH_TABLE_LEN >> 3);
  1931. if (copy_to_user(ioc->data, tmp->addr, ioc->len))
  1932. status = -EFAULT;
  1934. break;
  1935. case EWRK3_SET_MCA: /* Set a multicast address */
  1936. if (capable(CAP_NET_ADMIN)) {
  1937. if (ioc->len > 1024)
  1938. {
  1939. status = -EINVAL;
  1940. break;
  1941. }
  1942. if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN * ioc->len)) {
  1943. status = -EFAULT;
  1944. break;
  1945. }
  1946. set_multicast_list(dev);
  1947. } else {
  1948. status = -EPERM;
  1949. }
  1951. break;
  1952. case EWRK3_CLR_MCA: /* Clear all multicast addresses */
  1953. if (capable(CAP_NET_ADMIN)) {
  1954. set_multicast_list(dev);
  1955. } else {
  1956. status = -EPERM;
  1957. }
  1959. break;
  1960. case EWRK3_MCA_EN: /* Enable multicast addressing */
  1961. if (capable(CAP_NET_ADMIN)) {
  1962. spin_lock_irqsave(&lp->hw_lock, flags);
  1963. csr = inb(EWRK3_CSR);
  1964. csr |= CSR_MCE;
  1965. csr &= ~CSR_PME;
  1966. outb(csr, EWRK3_CSR);
  1967. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1968. } else {
  1969. status = -EPERM;
  1970. }
  1972. break;
  1973. case EWRK3_GET_STATS: { /* Get the driver statistics */
  1974. struct ewrk3_stats *tmp_stats =
  1975.          kmalloc(sizeof(lp->pktStats), GFP_KERNEL);
  1976. if (!tmp_stats) return -ENOMEM;
  1978. spin_lock_irqsave(&lp->hw_lock, flags);
  1979. memcpy(tmp_stats, &lp->pktStats, sizeof(lp->pktStats));
  1980. spin_unlock_irqrestore(&lp->hw_lock, flags);
  1982. ioc->len = sizeof(lp->pktStats);
  1983. if (copy_to_user(ioc->data, tmp_stats, sizeof(lp->pktStats)))
  1984.      status = -EFAULT;
  1985. kfree(tmp_stats);
  1986. break;
  1987. }
  1988. case EWRK3_CLR_STATS: /* Zero out the driver statistics */
  1989. if (capable(CAP_NET_ADMIN)) {
  1990. spin_lock_irqsave(&lp->hw_lock, flags);
  1991. memset(&lp->pktStats, 0, sizeof(lp->pktStats));
  1992. spin_unlock_irqrestore(&lp->hw_lock,flags);
  1993. } else {
  1994. status = -EPERM;
  1995. }
  1997. break;
  1998. case EWRK3_GET_CSR: /* Get the CSR Register contents */
  1999. tmp->addr[0] = inb(EWRK3_CSR);
  2000. ioc->len = 1;
  2001. if (copy_to_user(ioc->data, tmp->addr, ioc->len))
  2002. status = -EFAULT;
  2003. break;
  2004. case EWRK3_SET_CSR: /* Set the CSR Register contents */
  2005. if (capable(CAP_NET_ADMIN)) {
  2006. if (copy_from_user(tmp->addr, ioc->data, 1)) {
  2007. status = -EFAULT;
  2008. break;
  2009. }
  2010. outb(tmp->addr[0], EWRK3_CSR);
  2011. } else {
  2012. status = -EPERM;
  2013. }
  2015. break;
  2016. case EWRK3_GET_EEPROM: /* Get the EEPROM contents */
  2017. if (capable(CAP_NET_ADMIN)) {
  2018. for (i = 0; i < (EEPROM_MAX >> 1); i++) {
  2019. tmp->val[i] = (short) Read_EEPROM(iobase, i);
  2020. }
  2021. i = EEPROM_MAX;
  2022. tmp->addr[i++] = inb(EWRK3_CMR); /* Config/Management Reg. */
  2023. for (j = 0; j < ETH_ALEN; j++) {
  2024. tmp->addr[i++] = inb(EWRK3_PAR0 + j);
  2025. }
  2026. ioc->len = EEPROM_MAX + 1 + ETH_ALEN;
  2027. if (copy_to_user(ioc->data, tmp->addr, ioc->len))
  2028. status = -EFAULT;
  2029. } else {
  2030. status = -EPERM;
  2031. }
  2033. break;
  2034. case EWRK3_SET_EEPROM: /* Set the EEPROM contents */
  2035. if (capable(CAP_NET_ADMIN)) {
  2036. if (copy_from_user(tmp->addr, ioc->data, EEPROM_MAX)) {
  2037. status = -EFAULT;
  2038. break;
  2039. }
  2040. for (i = 0; i < (EEPROM_MAX >> 1); i++) {
  2041. Write_EEPROM(tmp->val[i], iobase, i);
  2042. }
  2043. } else {
  2044. status = -EPERM;
  2045. }
  2047. break;
  2048. case EWRK3_GET_CMR: /* Get the CMR Register contents */
  2049. tmp->addr[0] = inb(EWRK3_CMR);
  2050. ioc->len = 1;
  2051. if (copy_to_user(ioc->data, tmp->addr, ioc->len))
  2052. status = -EFAULT;
  2053. break;
  2054. case EWRK3_SET_TX_CUT_THRU: /* Set TX cut through mode */
  2055. if (capable(CAP_NET_ADMIN)) {
  2056. lp->txc = 1;
  2057. } else {
  2058. status = -EPERM;
  2059. }
  2061. break;
  2062. case EWRK3_CLR_TX_CUT_THRU: /* Clear TX cut through mode */
  2063. if (capable(CAP_NET_ADMIN)) {
  2064. lp->txc = 0;
  2065. } else {
  2066. status = -EPERM;
  2067. }
  2069. break;
  2070. default:
  2071. status = -EOPNOTSUPP;
  2072. }
  2073. kfree(tmp);
  2074. return status;
  2075. }
  2077. #ifdef MODULE
  2078. static struct net_device *ewrk3_devs[MAX_NUM_EWRK3S];
  2079. static int ndevs;
  2080. static int io[MAX_NUM_EWRK3S+1] = { 0x300, 0, }; /* <--- EDIT THESE LINES FOR YOUR CONFIGURATION */
  2081. static int irq[MAX_NUM_EWRK3S+1] = { 5, 0, }; /* or use the insmod io= irq= options           */
  2083. /* '21' below should really be 'MAX_NUM_EWRK3S' */
  2084. MODULE_PARM(io, "0-21i");
  2085. MODULE_PARM(irq, "0-21i");
  2086. MODULE_PARM_DESC(io, "EtherWORKS 3 I/O base address(es)");
  2087. MODULE_PARM_DESC(irq, "EtherWORKS 3 IRQ number(s)");
  2089. int init_module(void)
  2090. {
  2091. int i=0;
  2093. while( io[i] && irq[i] ) {
  2094. ewrk3_devs[ndevs] = kmalloc(sizeof(struct net_device), GFP_KERNEL);
  2095. if (!ewrk3_devs[ndevs])
  2096. goto error; 
  2097. memset(ewrk3_devs[ndevs], 0, sizeof(struct net_device));
  2098. ewrk3_devs[ndevs]->base_addr = io[i];
  2099. ewrk3_devs[ndevs]->irq = irq[i];
  2100. ewrk3_devs[ndevs]->init = ewrk3_probe;
  2102. if (register_netdev(ewrk3_devs[ndevs]) == 0)
  2103. ndevs++;
  2104. else
  2105. kfree(ewrk3_devs[ndevs]);
  2107. i++;
  2108. }
  2110. return ndevs ? 0 : -EIO;
  2112. error:
  2113. cleanup_module();
  2114. return -ENOMEM;
  2115. }
  2117. void cleanup_module(void)
  2118. {
  2119. int i;
  2121. for( i=0; i<ndevs; i++ ) {
  2122. unregister_netdev(ewrk3_devs[i]);
  2123. if (ewrk3_devs[i]->priv) {
  2124. kfree(ewrk3_devs[i]->priv);
  2125. ewrk3_devs[i]->priv = NULL;
  2126. }
  2127. ewrk3_devs[i]->irq = 0;
  2129. release_region(ewrk3_devs[i]->base_addr, EWRK3_TOTAL_SIZE);
  2130. kfree(ewrk3_devs[i]);
  2131. ewrk3_devs[i] = NULL;
  2132. }
  2133. }
  2134. #endif /* MODULE */
  2135. MODULE_LICENSE("GPL");
  2139. /*
  2140.  * Local variables:
  2141.  *  compile-command: "gcc -D__KERNEL__ -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c ewrk3.c"
  2142.  *
  2143.  *  compile-command: "gcc -D__KERNEL__ -DMODULE -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c ewrk3.c"
  2144.  * End:
  2145.  */