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

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

Linux/Unix编程

开发平台：

Unix_Linux

pcnet32.c：源码内容
  1. /* pcnet32.c: An AMD PCnet32 ethernet driver for linux. */
  2. /*
  3.  * Copyright 1996-1999 Thomas Bogendoerfer
  4.  * 
  5.  * Derived from the lance driver written 1993,1994,1995 by Donald Becker.
  6.  * 
  7.  * Copyright 1993 United States Government as represented by the
  8.  * Director, National Security Agency.
  9.  * 
  10.  * This software may be used and distributed according to the terms
  11.  * of the GNU General Public License, incorporated herein by reference.
  12.  *
  13.  * This driver is for PCnet32 and PCnetPCI based ethercards
  14.  */
  15. /**************************************************************************
  16.  *  23 Oct, 2000.
  17.  *  Fixed a few bugs, related to running the controller in 32bit mode.
  18.  *
  19.  *  Carsten Langgaard, carstenl@mips.com
  20.  *  Copyright (C) 2000 MIPS Technologies, Inc.  All rights reserved.
  21.  *
  22.  *************************************************************************/
  24. #define DRV_NAME "pcnet32"
  25. #define DRV_VERSION "1.27b"
  26. #define DRV_RELDATE "01.10.2002"
  27. #define PFX DRV_NAME ": "
  29. static const char *version =
  30. DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " tsbogend@alpha.franken.den";
  32. #include <linux/module.h>
  34. #include <linux/kernel.h>
  35. #include <linux/sched.h>
  36. #include <linux/string.h>
  37. #include <linux/ptrace.h>
  38. #include <linux/errno.h>
  39. #include <linux/ioport.h>
  40. #include <linux/slab.h>
  41. #include <linux/interrupt.h>
  42. #include <linux/pci.h>
  43. #include <linux/delay.h>
  44. #include <linux/init.h>
  45. #include <linux/ethtool.h>
  46. #include <linux/mii.h>
  47. #include <linux/crc32.h>
  48. #include <asm/bitops.h>
  49. #include <asm/io.h>
  50. #include <asm/dma.h>
  51. #include <asm/uaccess.h>
  53. #include <linux/netdevice.h>
  54. #include <linux/etherdevice.h>
  55. #include <linux/skbuff.h>
  56. #include <linux/spinlock.h>
  58. /*
  59.  * PCI device identifiers for "new style" Linux PCI Device Drivers
  60.  */
  61. static struct pci_device_id pcnet32_pci_tbl[] __devinitdata = {
  62.     { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LANCE_HOME, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  63.     { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_LANCE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
  64.     { 0, }
  65. };
  67. MODULE_DEVICE_TABLE (pci, pcnet32_pci_tbl);
  69. int cards_found __initdata;
  71. /* 
  72.  * VLB I/O addresses 
  73.  */
  74. static unsigned int pcnet32_portlist[] __initdata = 
  75. { 0x300, 0x320, 0x340, 0x360, 0 };
  79. static int pcnet32_debug = 1;
  80. static int tx_start = 1; /* Mapping -- 0:20, 1:64, 2:128, 3:~220 (depends on chip vers) */
  81. static int pcnet32vlb;  /* check for VLB cards ? */
  83. static struct net_device *pcnet32_dev;
  85. static int max_interrupt_work = 80;
  86. static int rx_copybreak = 200;
  88. #define PCNET32_PORT_AUI      0x00
  89. #define PCNET32_PORT_10BT     0x01
  90. #define PCNET32_PORT_GPSI     0x02
  91. #define PCNET32_PORT_MII      0x03
  93. #define PCNET32_PORT_PORTSEL  0x03
  94. #define PCNET32_PORT_ASEL     0x04
  95. #define PCNET32_PORT_100      0x40
  96. #define PCNET32_PORT_FD       0x80
  98. #define PCNET32_DMA_MASK 0xffffffff
  100. #define PCNET32_WATCHDOG_TIMEOUT (jiffies + (2 * HZ))
  102. /*
  103.  * table to translate option values from tulip
  104.  * to internal options
  105.  */
  106. static unsigned char options_mapping[] = {
  107.     PCNET32_PORT_ASEL,    /*  0 Auto-select   */
  108.     PCNET32_PORT_AUI,    /*  1 BNC/AUI   */
  109.     PCNET32_PORT_AUI,    /*  2 AUI/BNC   */ 
  110.     PCNET32_PORT_ASEL,    /*  3 not supported   */
  111.     PCNET32_PORT_10BT | PCNET32_PORT_FD,   /*  4 10baseT-FD   */
  112.     PCNET32_PORT_ASEL,    /*  5 not supported   */
  113.     PCNET32_PORT_ASEL,    /*  6 not supported   */
  114.     PCNET32_PORT_ASEL,    /*  7 not supported   */
  115.     PCNET32_PORT_ASEL,    /*  8 not supported   */
  116.     PCNET32_PORT_MII,    /*  9 MII 10baseT   */
  117.     PCNET32_PORT_MII | PCNET32_PORT_FD,    /* 10 MII 10baseT-FD   */
  118.     PCNET32_PORT_MII,    /* 11 MII (autosel)   */
  119.     PCNET32_PORT_10BT,    /* 12 10BaseT   */
  120.     PCNET32_PORT_MII | PCNET32_PORT_100,   /* 13 MII 100BaseTx   */
  121.     PCNET32_PORT_MII | PCNET32_PORT_100 | PCNET32_PORT_FD, /* 14 MII 100BaseTx-FD */
  122.     PCNET32_PORT_ASEL    /* 15 not supported   */
  123. };
  125. #define MAX_UNITS 8 /* More are supported, limit only on options */
  126. static int options[MAX_UNITS];
  127. static int full_duplex[MAX_UNITS];
  129. /*
  130.  * Theory of Operation
  131.  * 
  132.  * This driver uses the same software structure as the normal lance
  133.  * driver. So look for a verbose description in lance.c. The differences
  134.  * to the normal lance driver is the use of the 32bit mode of PCnet32
  135.  * and PCnetPCI chips. Because these chips are 32bit chips, there is no
  136.  * 16MB limitation and we don't need bounce buffers.
  137.  */
  138.  
  139. /*
  140.  * History:
  141.  * v0.01:  Initial version
  142.  *    only tested on Alpha Noname Board
  143.  * v0.02:  changed IRQ handling for new interrupt scheme (dev_id)
  144.  *    tested on a ASUS SP3G
  145.  * v0.10:  fixed an odd problem with the 79C974 in a Compaq Deskpro XL
  146.  *    looks like the 974 doesn't like stopping and restarting in a
  147.  *    short period of time; now we do a reinit of the lance; the
  148.  *    bug was triggered by doing ifconfig eth0 <ip> broadcast <addr>
  149.  *    and hangs the machine (thanks to Klaus Liedl for debugging)
  150.  * v0.12:  by suggestion from Donald Becker: Renamed driver to pcnet32,
  151.  *    made it standalone (no need for lance.c)
  152.  * v0.13:  added additional PCI detecting for special PCI devices (Compaq)
  153.  * v0.14:  stripped down additional PCI probe (thanks to David C Niemi
  154.  *    and sveneric@xs4all.nl for testing this on their Compaq boxes)
  155.  * v0.15:  added 79C965 (VLB) probe
  156.  *    added interrupt sharing for PCI chips
  157.  * v0.16:  fixed set_multicast_list on Alpha machines
  158.  * v0.17:  removed hack from dev.c; now pcnet32 uses ethif_probe in Space.c
  159.  * v0.19:  changed setting of autoselect bit
  160.  * v0.20:  removed additional Compaq PCI probe; there is now a working one
  161.  *    in arch/i386/bios32.c
  162.  * v0.21:  added endian conversion for ppc, from work by cort@cs.nmt.edu
  163.  * v0.22:  added printing of status to ring dump
  164.  * v0.23:  changed enet_statistics to net_devive_stats
  165.  * v0.90:  added multicast filter
  166.  *    added module support
  167.  *    changed irq probe to new style
  168.  *    added PCnetFast chip id
  169.  *    added fix for receive stalls with Intel saturn chipsets
  170.  *    added in-place rx skbs like in the tulip driver
  171.  *    minor cleanups
  172.  * v0.91:  added PCnetFast+ chip id
  173.  *    back port to 2.0.x
  174.  * v1.00:  added some stuff from Donald Becker's 2.0.34 version
  175.  *    added support for byte counters in net_dev_stats
  176.  * v1.01:  do ring dumps, only when debugging the driver
  177.  *    increased the transmit timeout
  178.  * v1.02:  fixed memory leak in pcnet32_init_ring()
  179.  * v1.10:  workaround for stopped transmitter
  180.  *    added port selection for modules
  181.  *    detect special T1/E1 WAN card and setup port selection
  182.  * v1.11:  fixed wrong checking of Tx errors
  183.  * v1.20:  added check of return value kmalloc (cpeterso@cs.washington.edu)
  184.  *    added save original kmalloc addr for freeing (mcr@solidum.com)
  185.  *    added support for PCnetHome chip (joe@MIT.EDU)
  186.  *    rewritten PCI card detection
  187.  *    added dwio mode to get driver working on some PPC machines
  188.  * v1.21:  added mii selection and mii ioctl
  189.  * v1.22:  changed pci scanning code to make PPC people happy
  190.  *    fixed switching to 32bit mode in pcnet32_open() (thanks
  191.  *    to Michael Richard <mcr@solidum.com> for noticing this one)
  192.  *    added sub vendor/device id matching (thanks again to 
  193.  *    Michael Richard <mcr@solidum.com>)
  194.  *    added chip id for 79c973/975 (thanks to Zach Brown <zab@zabbo.net>)
  195.  * v1.23   fixed small bug, when manual selecting MII speed/duplex
  196.  * v1.24   Applied Thomas' patch to use TxStartPoint and thus decrease TxFIFO
  197.  *    underflows. Added tx_start_pt module parameter. Increased
  198.  *    TX_RING_SIZE from 16 to 32. Added #ifdef'd code to use DXSUFLO
  199.  *    for FAST[+] chipsets. <kaf@fc.hp.com>
  200.  * v1.24ac Added SMP spinlocking - Alan Cox <alan@redhat.com>
  201.  * v1.25kf Added No Interrupt on successful Tx for some Tx's <kaf@fc.hp.com>
  202.  * v1.26   Converted to pci_alloc_consistent, Jamey Hicks / George France
  203.  *                                           <jamey@crl.dec.com>
  204.  * -    Fixed a few bugs, related to running the controller in 32bit mode.
  205.  *    23 Oct, 2000.  Carsten Langgaard, carstenl@mips.com
  206.  *    Copyright (C) 2000 MIPS Technologies, Inc.  All rights reserved.
  207.  * v1.26p  Fix oops on rmmod+insmod; plug i/o resource leak - Paul Gortmaker
  208.  * v1.27   improved CSR/PROM address detection, lots of cleanups,
  209.  *     new pcnet32vlb module option, HP-PARISC support,
  210.  *     added module parameter descriptions, 
  211.  *     initial ethtool support - Helge Deller <deller@gmx.de>
  212.  * v1.27a  Sun Feb 10 2002 Go Taniguchi <go@turbolinux.co.jp>
  213.  *    use alloc_etherdev and register_netdev
  214.  *    fix pci probe not increment cards_found
  215.  *    FD auto negotiate error workaround for xSeries250
  216.  *    clean up and using new mii module
  217.  * v1.27b  Sep 30 2002 Kent Yoder <yoder1@us.ibm.com>
  218.  *     Added timer for cable connection state changes.
  219.  */
  222. /*
  223.  * Set the number of Tx and Rx buffers, using Log_2(# buffers).
  224.  * Reasonable default values are 4 Tx buffers, and 16 Rx buffers.
  225.  * That translates to 2 (4 == 2^^2) and 4 (16 == 2^^4).
  226.  */
  227. #ifndef PCNET32_LOG_TX_BUFFERS
  228. #define PCNET32_LOG_TX_BUFFERS 4
  229. #define PCNET32_LOG_RX_BUFFERS 5
  230. #endif
  232. #define TX_RING_SIZE (1 << (PCNET32_LOG_TX_BUFFERS))
  233. #define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
  234. #define TX_RING_LEN_BITS ((PCNET32_LOG_TX_BUFFERS) << 12)
  236. #define RX_RING_SIZE (1 << (PCNET32_LOG_RX_BUFFERS))
  237. #define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
  238. #define RX_RING_LEN_BITS ((PCNET32_LOG_RX_BUFFERS) << 4)
  240. #define PKT_BUF_SZ 1544
  242. /* Offsets from base I/O address. */
  243. #define PCNET32_WIO_RDP 0x10
  244. #define PCNET32_WIO_RAP 0x12
  245. #define PCNET32_WIO_RESET 0x14
  246. #define PCNET32_WIO_BDP 0x16
  248. #define PCNET32_DWIO_RDP 0x10
  249. #define PCNET32_DWIO_RAP 0x14
  250. #define PCNET32_DWIO_RESET 0x18
  251. #define PCNET32_DWIO_BDP 0x1C
  253. #define PCNET32_TOTAL_SIZE 0x20
  255. /* The PCNET32 Rx and Tx ring descriptors. */
  256. struct pcnet32_rx_head {
  257.     u32 base;
  258.     s16 buf_length;
  259.     s16 status;    
  260.     u32 msg_length;
  261.     u32 reserved;
  262. };
  264. struct pcnet32_tx_head {
  265.     u32 base;
  266.     s16 length;
  267.     s16 status;
  268.     u32 misc;
  269.     u32 reserved;
  270. };
  272. /* The PCNET32 32-Bit initialization block, described in databook. */
  273. struct pcnet32_init_block {
  274.     u16 mode;
  275.     u16 tlen_rlen;
  276.     u8 phys_addr[6];
  277.     u16 reserved;
  278.     u32 filter[2];
  279.     /* Receive and transmit ring base, along with extra bits. */    
  280.     u32 rx_ring;
  281.     u32 tx_ring;
  282. };
  284. /* PCnet32 access functions */
  285. struct pcnet32_access {
  286.     u16 (*read_csr)(unsigned long, int);
  287.     void (*write_csr)(unsigned long, int, u16);
  288.     u16 (*read_bcr)(unsigned long, int);
  289.     void (*write_bcr)(unsigned long, int, u16);
  290.     u16 (*read_rap)(unsigned long);
  291.     void (*write_rap)(unsigned long, u16);
  292.     void (*reset)(unsigned long);
  293. };
  295. /*
  296.  * The first three fields of pcnet32_private are read by the ethernet device 
  297.  * so we allocate the structure should be allocated by pci_alloc_consistent().
  298.  */
  299. struct pcnet32_private {
  300.     /* The Tx and Rx ring entries must be aligned on 16-byte boundaries in 32bit mode. */
  301.     struct pcnet32_rx_head    rx_ring[RX_RING_SIZE];
  302.     struct pcnet32_tx_head    tx_ring[TX_RING_SIZE];
  303.     struct pcnet32_init_block init_block;
  304.     dma_addr_t  dma_addr; /* DMA address of beginning of this object, 
  305.    returned by pci_alloc_consistent */
  306.     struct pci_dev *pci_dev; /* Pointer to the associated pci device structure */
  307.     const char *name;
  308.     /* The saved address of a sent-in-place packet/buffer, for skfree(). */
  309.     struct sk_buff *tx_skbuff[TX_RING_SIZE];
  310.     struct sk_buff *rx_skbuff[RX_RING_SIZE];
  311.     dma_addr_t tx_dma_addr[TX_RING_SIZE];
  312.     dma_addr_t rx_dma_addr[RX_RING_SIZE];
  313.     struct pcnet32_access a;
  314.     spinlock_t lock; /* Guard lock */
  315.     unsigned int cur_rx, cur_tx; /* The next free ring entry */
  316.     unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */
  317.     struct net_device_stats stats;
  318.     char tx_full;
  319.     int options;
  320.     int shared_irq:1, /* shared irq possible */
  321. ltint:1, /* enable TxDone-intr inhibitor */
  322. dxsuflo:1, /* disable transmit stop on uflo */
  323. mii:1; /* mii port available */
  324.     struct net_device *next;
  325.     struct mii_if_info mii_if;
  326.     struct timer_list watchdog_timer;
  327. };
  329. static void pcnet32_probe_vlbus(void);
  330. static int  pcnet32_probe_pci(struct pci_dev *, const struct pci_device_id *);
  331. static int  pcnet32_probe1(unsigned long, unsigned int, int, struct pci_dev *);
  332. static int  pcnet32_open(struct net_device *);
  333. static int  pcnet32_init_ring(struct net_device *);
  334. static int  pcnet32_start_xmit(struct sk_buff *, struct net_device *);
  335. static int  pcnet32_rx(struct net_device *);
  336. static void pcnet32_tx_timeout (struct net_device *dev);
  337. static void pcnet32_interrupt(int, void *, struct pt_regs *);
  338. static int  pcnet32_close(struct net_device *);
  339. static struct net_device_stats *pcnet32_get_stats(struct net_device *);
  340. static void pcnet32_set_multicast_list(struct net_device *);
  341. static int  pcnet32_ioctl(struct net_device *, struct ifreq *, int);
  342. static void pcnet32_watchdog(struct net_device *);
  343. static int mdio_read(struct net_device *dev, int phy_id, int reg_num);
  344. static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val);
  346. enum pci_flags_bit {
  347.     PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
  348.     PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3,
  349. };
  352. static u16 pcnet32_wio_read_csr (unsigned long addr, int index)
  353. {
  354.     outw (index, addr+PCNET32_WIO_RAP);
  355.     return inw (addr+PCNET32_WIO_RDP);
  356. }
  358. static void pcnet32_wio_write_csr (unsigned long addr, int index, u16 val)
  359. {
  360.     outw (index, addr+PCNET32_WIO_RAP);
  361.     outw (val, addr+PCNET32_WIO_RDP);
  362. }
  364. static u16 pcnet32_wio_read_bcr (unsigned long addr, int index)
  365. {
  366.     outw (index, addr+PCNET32_WIO_RAP);
  367.     return inw (addr+PCNET32_WIO_BDP);
  368. }
  370. static void pcnet32_wio_write_bcr (unsigned long addr, int index, u16 val)
  371. {
  372.     outw (index, addr+PCNET32_WIO_RAP);
  373.     outw (val, addr+PCNET32_WIO_BDP);
  374. }
  376. static u16 pcnet32_wio_read_rap (unsigned long addr)
  377. {
  378.     return inw (addr+PCNET32_WIO_RAP);
  379. }
  381. static void pcnet32_wio_write_rap (unsigned long addr, u16 val)
  382. {
  383.     outw (val, addr+PCNET32_WIO_RAP);
  384. }
  386. static void pcnet32_wio_reset (unsigned long addr)
  387. {
  388.     inw (addr+PCNET32_WIO_RESET);
  389. }
  391. static int pcnet32_wio_check (unsigned long addr)
  392. {
  393.     outw (88, addr+PCNET32_WIO_RAP);
  394.     return (inw (addr+PCNET32_WIO_RAP) == 88);
  395. }
  397. static struct pcnet32_access pcnet32_wio = {
  398.     read_csr: pcnet32_wio_read_csr,
  399.     write_csr: pcnet32_wio_write_csr,
  400.     read_bcr: pcnet32_wio_read_bcr,
  401.     write_bcr: pcnet32_wio_write_bcr,
  402.     read_rap: pcnet32_wio_read_rap,
  403.     write_rap: pcnet32_wio_write_rap,
  404.     reset: pcnet32_wio_reset
  405. };
  407. static u16 pcnet32_dwio_read_csr (unsigned long addr, int index)
  408. {
  409.     outl (index, addr+PCNET32_DWIO_RAP);
  410.     return (inl (addr+PCNET32_DWIO_RDP) & 0xffff);
  411. }
  413. static void pcnet32_dwio_write_csr (unsigned long addr, int index, u16 val)
  414. {
  415.     outl (index, addr+PCNET32_DWIO_RAP);
  416.     outl (val, addr+PCNET32_DWIO_RDP);
  417. }
  419. static u16 pcnet32_dwio_read_bcr (unsigned long addr, int index)
  420. {
  421.     outl (index, addr+PCNET32_DWIO_RAP);
  422.     return (inl (addr+PCNET32_DWIO_BDP) & 0xffff);
  423. }
  425. static void pcnet32_dwio_write_bcr (unsigned long addr, int index, u16 val)
  426. {
  427.     outl (index, addr+PCNET32_DWIO_RAP);
  428.     outl (val, addr+PCNET32_DWIO_BDP);
  429. }
  431. static u16 pcnet32_dwio_read_rap (unsigned long addr)
  432. {
  433.     return (inl (addr+PCNET32_DWIO_RAP) & 0xffff);
  434. }
  436. static void pcnet32_dwio_write_rap (unsigned long addr, u16 val)
  437. {
  438.     outl (val, addr+PCNET32_DWIO_RAP);
  439. }
  441. static void pcnet32_dwio_reset (unsigned long addr)
  442. {
  443.     inl (addr+PCNET32_DWIO_RESET);
  444. }
  446. static int pcnet32_dwio_check (unsigned long addr)
  447. {
  448.     outl (88, addr+PCNET32_DWIO_RAP);
  449.     return ((inl (addr+PCNET32_DWIO_RAP) & 0xffff) == 88);
  450. }
  452. static struct pcnet32_access pcnet32_dwio = {
  453.     read_csr: pcnet32_dwio_read_csr,
  454.     write_csr: pcnet32_dwio_write_csr,
  455.     read_bcr: pcnet32_dwio_read_bcr,
  456.     write_bcr: pcnet32_dwio_write_bcr,
  457.     read_rap: pcnet32_dwio_read_rap,
  458.     write_rap: pcnet32_dwio_write_rap,
  459.     reset: pcnet32_dwio_reset
  460. };
  464. /* only probes for non-PCI devices, the rest are handled by 
  465.  * pci_register_driver via pcnet32_probe_pci */
  467. static void __devinit
  468. pcnet32_probe_vlbus(void)
  469. {
  470.     unsigned int *port, ioaddr;
  471.     
  472.     /* search for PCnet32 VLB cards at known addresses */
  473.     for (port = pcnet32_portlist; (ioaddr = *port); port++) {
  474. if (!check_region(ioaddr, PCNET32_TOTAL_SIZE)) {
  475.     /* check if there is really a pcnet chip on that ioaddr */
  476.     if ((inb(ioaddr + 14) == 0x57) && (inb(ioaddr + 15) == 0x57))
  477. pcnet32_probe1(ioaddr, 0, 0, NULL);
  478. }
  479.     }
  480. }
  483. static int __devinit
  484. pcnet32_probe_pci(struct pci_dev *pdev, const struct pci_device_id *ent)
  485. {
  486.     unsigned long ioaddr;
  487.     int err;
  489.     err = pci_enable_device(pdev);
  490.     if (err < 0) {
  491. printk(KERN_ERR PFX "failed to enable device -- err=%dn", err);
  492. return err;
  493.     }
  494.     pci_set_master(pdev);
  496.     ioaddr = pci_resource_start (pdev, 0);
  497.     if (!ioaddr) {
  498.         printk (KERN_ERR PFX "card has no PCI IO resources, abortingn");
  499.         return -ENODEV;
  500.     }
  501.     
  502.     if (!pci_dma_supported(pdev, PCNET32_DMA_MASK)) {
  503. printk(KERN_ERR PFX "architecture does not support 32bit PCI busmaster DMAn");
  504. return -ENODEV;
  505.     }
  507.     return pcnet32_probe1(ioaddr, pdev->irq, 1, pdev);
  508. }
  511. /* pcnet32_probe1 
  512.  *  Called from both pcnet32_probe_vlbus and pcnet_probe_pci.  
  513.  *  pdev will be NULL when called from pcnet32_probe_vlbus.
  514.  */
  515. static int __devinit
  516. pcnet32_probe1(unsigned long ioaddr, unsigned int irq_line, int shared,
  517. struct pci_dev *pdev)
  518. {
  519.     struct pcnet32_private *lp;
  520.     dma_addr_t lp_dma_addr;
  521.     int i, media;
  522.     int fdx, mii, fset, dxsuflo, ltint;
  523.     int chip_version;
  524.     char *chipname;
  525.     struct net_device *dev;
  526.     struct pcnet32_access *a = NULL;
  527.     u8 promaddr[6];
  529.     /* reset the chip */
  530.     pcnet32_wio_reset(ioaddr);
  532.     /* NOTE: 16-bit check is first, otherwise some older PCnet chips fail */
  533.     if (pcnet32_wio_read_csr(ioaddr, 0) == 4 && pcnet32_wio_check(ioaddr)) {
  534. a = &pcnet32_wio;
  535.     } else {
  536. pcnet32_dwio_reset(ioaddr);
  537. if (pcnet32_dwio_read_csr(ioaddr, 0) == 4 && pcnet32_dwio_check(ioaddr)) {
  538.     a = &pcnet32_dwio;
  539. } else
  540.     return -ENODEV;
  541.     }
  543.     chip_version = a->read_csr(ioaddr, 88) | (a->read_csr(ioaddr,89) << 16);
  544.     if (pcnet32_debug > 2)
  545. printk(KERN_INFO "  PCnet chip version is %#x.n", chip_version);
  546.     if ((chip_version & 0xfff) != 0x003)
  547. return -ENODEV;
  548.     
  549.     /* initialize variables */
  550.     fdx = mii = fset = dxsuflo = ltint = 0;
  551.     chip_version = (chip_version >> 12) & 0xffff;
  553.     switch (chip_version) {
  554.     case 0x2420:
  555. chipname = "PCnet/PCI 79C970"; /* PCI */
  556. break;
  557.     case 0x2430:
  558. if (shared)
  559.     chipname = "PCnet/PCI 79C970"; /* 970 gives the wrong chip id back */
  560. else
  561.     chipname = "PCnet/32 79C965"; /* 486/VL bus */
  562. break;
  563.     case 0x2621:
  564. chipname = "PCnet/PCI II 79C970A"; /* PCI */
  565. fdx = 1;
  566. break;
  567.     case 0x2623:
  568. chipname = "PCnet/FAST 79C971"; /* PCI */
  569. fdx = 1; mii = 1; fset = 1;
  570. ltint = 1;
  571. break;
  572.     case 0x2624:
  573. chipname = "PCnet/FAST+ 79C972"; /* PCI */
  574. fdx = 1; mii = 1; fset = 1;
  575. break;
  576.     case 0x2625:
  577. chipname = "PCnet/FAST III 79C973"; /* PCI */
  578. fdx = 1; mii = 1;
  579. break;
  580.     case 0x2626:
  581. chipname = "PCnet/Home 79C978"; /* PCI */
  582. fdx = 1;
  583. /* 
  584.  * This is based on specs published at www.amd.com.  This section
  585.  * assumes that a card with a 79C978 wants to go into 1Mb HomePNA
  586.  * mode.  The 79C978 can also go into standard ethernet, and there
  587.  * probably should be some sort of module option to select the
  588.  * mode by which the card should operate
  589.  */
  590. /* switch to home wiring mode */
  591. media = a->read_bcr(ioaddr, 49);
  592. #if 0
  593. if (pcnet32_debug > 2)
  594.     printk(KERN_DEBUG PFX "media value %#x.n",  media);
  595. media &= ~3;
  596. media |= 1;
  597. #endif
  598. if (pcnet32_debug > 2)
  599.     printk(KERN_DEBUG PFX "media reset to %#x.n",  media);
  600. a->write_bcr(ioaddr, 49, media);
  601. break;
  602.     case 0x2627:
  603. chipname = "PCnet/FAST III 79C975"; /* PCI */
  604. fdx = 1; mii = 1;
  605. break;
  606.     default:
  607. printk(KERN_INFO PFX "PCnet version %#x, no PCnet32 chip.n",
  608. chip_version);
  609. return -ENODEV;
  610.     }
  612.     /*
  613.      * On selected chips turn on the BCR18:NOUFLO bit. This stops transmit
  614.      * starting until the packet is loaded. Strike one for reliability, lose
  615.      * one for latency - although on PCI this isnt a big loss. Older chips 
  616.      * have FIFO's smaller than a packet, so you can't do this.
  617.      */
  618.  
  619.     if(fset)
  620.     {
  621. a->write_bcr(ioaddr, 18, (a->read_bcr(ioaddr, 18) | 0x0800));
  622. a->write_csr(ioaddr, 80, (a->read_csr(ioaddr, 80) & 0x0C00) | 0x0c00);
  623. dxsuflo = 1;
  624. ltint = 1;
  625.     }
  626.     
  627.     dev = alloc_etherdev(0);
  628.     if(!dev)
  629. return -ENOMEM;
  631.     printk(KERN_INFO PFX "%s at %#3lx,", chipname, ioaddr);
  633.     /* In most chips, after a chip reset, the ethernet address is read from the
  634.      * station address PROM at the base address and programmed into the
  635.      * "Physical Address Registers" CSR12-14.
  636.      * As a precautionary measure, we read the PROM values and complain if
  637.      * they disagree with the CSRs.  Either way, we use the CSR values, and
  638.      * double check that they are valid.
  639.      */
  640.     for (i = 0; i < 3; i++) {
  641. unsigned int val;
  642. val = a->read_csr(ioaddr, i+12) & 0x0ffff;
  643. /* There may be endianness issues here. */
  644. dev->dev_addr[2*i] = val & 0x0ff;
  645. dev->dev_addr[2*i+1] = (val >> 8) & 0x0ff;
  646.     }
  648.     /* read PROM address and compare with CSR address */
  649.     for (i = 0; i < 6; i++)
  650. promaddr[i] = inb(ioaddr + i);
  651.     
  652.     if( memcmp( promaddr, dev->dev_addr, 6)
  653. || !is_valid_ether_addr(dev->dev_addr) ) {
  654. #ifndef __powerpc__
  655. if( is_valid_ether_addr(promaddr) ){
  656. #else
  657. if( !is_valid_ether_addr(dev->dev_addr)
  658.     && is_valid_ether_addr(promaddr)) {
  659. #endif
  660.     printk(" warning: CSR address invalid,n");
  661.     printk(KERN_INFO "    using instead PROM address of");
  662.     memcpy(dev->dev_addr, promaddr, 6);
  663. }
  664.     }
  666.     /* if the ethernet address is not valid, force to 00:00:00:00:00:00 */
  667.     if( !is_valid_ether_addr(dev->dev_addr) )
  668. memset(dev->dev_addr, 0, sizeof(dev->dev_addr));
  670.     for (i = 0; i < 6; i++)
  671. printk(" %2.2x", dev->dev_addr[i] );
  673.     if (((chip_version + 1) & 0xfffe) == 0x2624) { /* Version 0x2623 or 0x2624 */
  674. i = a->read_csr(ioaddr, 80) & 0x0C00;  /* Check tx_start_pt */
  675. printk("n" KERN_INFO "    tx_start_pt(0x%04x):",i);
  676. switch(i>>10) {
  677.     case 0: printk("  20 bytes,"); break;
  678.     case 1: printk("  64 bytes,"); break;
  679.     case 2: printk(" 128 bytes,"); break;
  680.     case 3: printk("~220 bytes,"); break;
  681. }
  682. i = a->read_bcr(ioaddr, 18);  /* Check Burst/Bus control */
  683. printk(" BCR18(%x):",i&0xffff);
  684. if (i & (1<<5)) printk("BurstWrEn ");
  685. if (i & (1<<6)) printk("BurstRdEn ");
  686. if (i & (1<<7)) printk("DWordIO ");
  687. if (i & (1<<11)) printk("NoUFlow ");
  688. i = a->read_bcr(ioaddr, 25);
  689. printk("n" KERN_INFO "    SRAMSIZE=0x%04x,",i<<8);
  690. i = a->read_bcr(ioaddr, 26);
  691. printk(" SRAM_BND=0x%04x,",i<<8);
  692. i = a->read_bcr(ioaddr, 27);
  693. if (i & (1<<14)) printk("LowLatRx");
  694.     }
  696.     dev->base_addr = ioaddr;
  697.     if (request_region(ioaddr, PCNET32_TOTAL_SIZE, chipname) == NULL)
  698. return -EBUSY;
  699.     
  700.     /* pci_alloc_consistent returns page-aligned memory, so we do not have to check the alignment */
  701.     if ((lp = pci_alloc_consistent(pdev, sizeof(*lp), &lp_dma_addr)) == NULL) {
  702. release_region(ioaddr, PCNET32_TOTAL_SIZE);
  703. return -ENOMEM;
  704.     }
  706.     memset(lp, 0, sizeof(*lp));
  707.     lp->dma_addr = lp_dma_addr;
  708.     lp->pci_dev = pdev;
  710.     spin_lock_init(&lp->lock);
  711.     
  712.     dev->priv = lp;
  713.     lp->name = chipname;
  714.     lp->shared_irq = shared;
  715.     lp->mii_if.full_duplex = fdx;
  716.     lp->dxsuflo = dxsuflo;
  717.     lp->ltint = ltint;
  718.     lp->mii = mii;
  719.     if ((cards_found >= MAX_UNITS) || (options[cards_found] > sizeof(options_mapping)))
  720. lp->options = PCNET32_PORT_ASEL;
  721.     else
  722. lp->options = options_mapping[options[cards_found]];
  723.     lp->mii_if.dev = dev;
  724.     lp->mii_if.mdio_read = mdio_read;
  725.     lp->mii_if.mdio_write = mdio_write;
  726.     
  727.     if (fdx && !(lp->options & PCNET32_PORT_ASEL) && 
  728. ((cards_found>=MAX_UNITS) || full_duplex[cards_found]))
  729. lp->options |= PCNET32_PORT_FD;
  730.     
  731.     if (!a) {
  732.       printk(KERN_ERR PFX "No access methodsn");
  733.       pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
  734.       release_region(ioaddr, PCNET32_TOTAL_SIZE);
  735.       return -ENODEV;
  736.     }
  737.     lp->a = *a;
  738.     
  739.     /* detect special T1/E1 WAN card by checking for MAC address */
  740.     if (dev->dev_addr[0] == 0x00 && dev->dev_addr[1] == 0xe0 && dev->dev_addr[2] == 0x75)
  741. lp->options = PCNET32_PORT_FD | PCNET32_PORT_GPSI;
  743.     lp->init_block.mode = le16_to_cpu(0x0003); /* Disable Rx and Tx. */
  744.     lp->init_block.tlen_rlen = le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS); 
  745.     for (i = 0; i < 6; i++)
  746. lp->init_block.phys_addr[i] = dev->dev_addr[i];
  747.     lp->init_block.filter[0] = 0x00000000;
  748.     lp->init_block.filter[1] = 0x00000000;
  749.     lp->init_block.rx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, rx_ring));
  750.     lp->init_block.tx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, tx_ring));
  751.     
  752.     /* switch pcnet32 to 32bit mode */
  753.     a->write_bcr (ioaddr, 20, 2);
  755.     a->write_csr (ioaddr, 1, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) & 0xffff);
  756.     a->write_csr (ioaddr, 2, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) >> 16);
  757.     
  758.     if (irq_line) {
  759. dev->irq = irq_line;
  760.     }
  761.     
  762.     if (dev->irq >= 2)
  763. printk(" assigned IRQ %d.n", dev->irq);
  764.     else {
  765. unsigned long irq_mask = probe_irq_on();
  767. /*
  768.  * To auto-IRQ we enable the initialization-done and DMA error
  769.  * interrupts. For ISA boards we get a DMA error, but VLB and PCI
  770.  * boards will work.
  771.  */
  772. /* Trigger an initialization just for the interrupt. */
  773. a->write_csr (ioaddr, 0, 0x41);
  774. mdelay (1);
  776. dev->irq = probe_irq_off (irq_mask);
  777. if (dev->irq)
  778.     printk(", probed IRQ %d.n", dev->irq);
  779. else {
  780.     printk(", failed to detect IRQ line.n");
  781.     pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
  782.     release_region(ioaddr, PCNET32_TOTAL_SIZE);
  783.     return -ENODEV;
  784. }
  785.     }
  787.     /* Set the mii phy_id so that we can query the link state */
  788.     if (lp->mii)
  789. lp->mii_if.phy_id = ((lp->a.read_bcr (ioaddr, 33)) >> 5) & 0x1f;
  791.     init_timer (&lp->watchdog_timer);
  792.     lp->watchdog_timer.data = (unsigned long) dev;
  793.     lp->watchdog_timer.function = (void *) &pcnet32_watchdog;
  794.     
  795.     /* The PCNET32-specific entries in the device structure. */
  796.     dev->open = &pcnet32_open;
  797.     dev->hard_start_xmit = &pcnet32_start_xmit;
  798.     dev->stop = &pcnet32_close;
  799.     dev->get_stats = &pcnet32_get_stats;
  800.     dev->set_multicast_list = &pcnet32_set_multicast_list;
  801.     dev->do_ioctl = &pcnet32_ioctl;
  802.     dev->tx_timeout = pcnet32_tx_timeout;
  803.     dev->watchdog_timeo = (5*HZ);
  805.     lp->next = pcnet32_dev;
  806.     pcnet32_dev = dev;
  808.     /* Fill in the generic fields of the device structure. */
  809.     register_netdev(dev);
  810.     printk(KERN_INFO "%s: registered as %sn",dev->name, lp->name);
  811.     cards_found++;
  812.     return 0;
  813. }
  816. static int
  817. pcnet32_open(struct net_device *dev)
  818. {
  819.     struct pcnet32_private *lp = dev->priv;
  820.     unsigned long ioaddr = dev->base_addr;
  821.     u16 val;
  822.     int i;
  824.     if (dev->irq == 0 ||
  825. request_irq(dev->irq, &pcnet32_interrupt,
  826.     lp->shared_irq ? SA_SHIRQ : 0, lp->name, (void *)dev)) {
  827. return -EAGAIN;
  828.     }
  830.     /* Check for a valid station address */
  831.     if( !is_valid_ether_addr(dev->dev_addr) )
  832. return -EINVAL;
  834.     /* Reset the PCNET32 */
  835.     lp->a.reset (ioaddr);
  837.     /* switch pcnet32 to 32bit mode */
  838.     lp->a.write_bcr (ioaddr, 20, 2);
  840.     if (pcnet32_debug > 1)
  841. printk(KERN_DEBUG "%s: pcnet32_open() irq %d tx/rx rings %#x/%#x init %#x.n",
  842.        dev->name, dev->irq,
  843.        (u32) (lp->dma_addr + offsetof(struct pcnet32_private, tx_ring)),
  844.        (u32) (lp->dma_addr + offsetof(struct pcnet32_private, rx_ring)),
  845.        (u32) (lp->dma_addr + offsetof(struct pcnet32_private, init_block)));
  846.     
  847.     /* set/reset autoselect bit */
  848.     val = lp->a.read_bcr (ioaddr, 2) & ~2;
  849.     if (lp->options & PCNET32_PORT_ASEL)
  850. val |= 2;
  851.     lp->a.write_bcr (ioaddr, 2, val);
  852.     
  853.     /* handle full duplex setting */
  854.     if (lp->mii_if.full_duplex) {
  855. val = lp->a.read_bcr (ioaddr, 9) & ~3;
  856. if (lp->options & PCNET32_PORT_FD) {
  857.     val |= 1;
  858.     if (lp->options == (PCNET32_PORT_FD | PCNET32_PORT_AUI))
  859. val |= 2;
  860. } else if (lp->options & PCNET32_PORT_ASEL) {
  861. /* workaround of xSeries250, turn on for 79C975 only */
  862.     i = ((lp->a.read_csr(ioaddr, 88) | (lp->a.read_csr(ioaddr,89) << 16)) >> 12) & 0xffff;
  863.     if (i == 0x2627) val |= 3;
  864. }
  865. lp->a.write_bcr (ioaddr, 9, val);
  866.     }
  867.     
  868.     /* set/reset GPSI bit in test register */
  869.     val = lp->a.read_csr (ioaddr, 124) & ~0x10;
  870.     if ((lp->options & PCNET32_PORT_PORTSEL) == PCNET32_PORT_GPSI)
  871. val |= 0x10;
  872.     lp->a.write_csr (ioaddr, 124, val);
  873.     
  874.     if (lp->mii && !(lp->options & PCNET32_PORT_ASEL)) {
  875. val = lp->a.read_bcr (ioaddr, 32) & ~0x38; /* disable Auto Negotiation, set 10Mpbs, HD */
  876. if (lp->options & PCNET32_PORT_FD)
  877.     val |= 0x10;
  878. if (lp->options & PCNET32_PORT_100)
  879.     val |= 0x08;
  880. lp->a.write_bcr (ioaddr, 32, val);
  881.     } else {
  882. if (lp->options & PCNET32_PORT_ASEL) {  /* enable auto negotiate, setup, disable fd */
  883. val = lp->a.read_bcr(ioaddr, 32) & ~0x98;
  884. val |= 0x20;
  885. lp->a.write_bcr(ioaddr, 32, val);
  886. }
  887.     }
  889. #ifdef DO_DXSUFLO 
  890.     if (lp->dxsuflo) { /* Disable transmit stop on underflow */
  891. val = lp->a.read_csr (ioaddr, 3);
  892. val |= 0x40;
  893. lp->a.write_csr (ioaddr, 3, val);
  894.     }
  895. #endif
  897.     if (lp->ltint) { /* Enable TxDone-intr inhibitor */
  898. val = lp->a.read_csr (ioaddr, 5);
  899. val |= (1<<14);
  900. lp->a.write_csr (ioaddr, 5, val);
  901.     }
  902.    
  903.     lp->init_block.mode = le16_to_cpu((lp->options & PCNET32_PORT_PORTSEL) << 7);
  904.     lp->init_block.filter[0] = 0x00000000;
  905.     lp->init_block.filter[1] = 0x00000000;
  906.     if (pcnet32_init_ring(dev))
  907. return -ENOMEM;
  908.     
  909.     /* Re-initialize the PCNET32, and start it when done. */
  910.     lp->a.write_csr (ioaddr, 1, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) &0xffff);
  911.     lp->a.write_csr (ioaddr, 2, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) >> 16);
  913.     lp->a.write_csr (ioaddr, 4, 0x0915);
  914.     lp->a.write_csr (ioaddr, 0, 0x0001);
  916.     netif_start_queue(dev);
  918.     /* If we have mii, print the link status and start the watchdog */
  919.     if (lp->mii) {
  920. mii_check_media (&lp->mii_if, 1, 1);
  921. mod_timer (&(lp->watchdog_timer), PCNET32_WATCHDOG_TIMEOUT);
  922.     }
  923.     
  924.     i = 0;
  925.     while (i++ < 100)
  926. if (lp->a.read_csr (ioaddr, 0) & 0x0100)
  927.     break;
  928.     /* 
  929.      * We used to clear the InitDone bit, 0x0100, here but Mark Stockton
  930.      * reports that doing so triggers a bug in the '974.
  931.      */
  932.     lp->a.write_csr (ioaddr, 0, 0x0042);
  934.     if (pcnet32_debug > 2)
  935. printk(KERN_DEBUG "%s: pcnet32 open after %d ticks, init block %#x csr0 %4.4x.n",
  936.        dev->name, i, (u32) (lp->dma_addr + offsetof(struct pcnet32_private, init_block)),
  937.        lp->a.read_csr(ioaddr, 0));
  940.     MOD_INC_USE_COUNT;
  941.     
  942.     return 0; /* Always succeed */
  943. }
  945. /*
  946.  * The LANCE has been halted for one reason or another (busmaster memory
  947.  * arbitration error, Tx FIFO underflow, driver stopped it to reconfigure,
  948.  * etc.).  Modern LANCE variants always reload their ring-buffer
  949.  * configuration when restarted, so we must reinitialize our ring
  950.  * context before restarting.  As part of this reinitialization,
  951.  * find all packets still on the Tx ring and pretend that they had been
  952.  * sent (in effect, drop the packets on the floor) - the higher-level
  953.  * protocols will time out and retransmit.  It'd be better to shuffle
  954.  * these skbs to a temp list and then actually re-Tx them after
  955.  * restarting the chip, but I'm too lazy to do so right now.  dplatt@3do.com
  956.  */
  958. static void 
  959. pcnet32_purge_tx_ring(struct net_device *dev)
  960. {
  961.     struct pcnet32_private *lp = dev->priv;
  962.     int i;
  964.     for (i = 0; i < TX_RING_SIZE; i++) {
  965. if (lp->tx_skbuff[i]) {
  966.             pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[i], lp->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
  967.     dev_kfree_skb_any(lp->tx_skbuff[i]); 
  968.     lp->tx_skbuff[i] = NULL;
  969.             lp->tx_dma_addr[i] = 0;
  970. }
  971.     }
  972. }
  975. /* Initialize the PCNET32 Rx and Tx rings. */
  976. static int
  977. pcnet32_init_ring(struct net_device *dev)
  978. {
  979.     struct pcnet32_private *lp = dev->priv;
  980.     int i;
  982.     lp->tx_full = 0;
  983.     lp->cur_rx = lp->cur_tx = 0;
  984.     lp->dirty_rx = lp->dirty_tx = 0;
  986.     for (i = 0; i < RX_RING_SIZE; i++) {
  987.         struct sk_buff *rx_skbuff = lp->rx_skbuff[i];
  988. if (rx_skbuff == NULL) {
  989.     if (!(rx_skbuff = lp->rx_skbuff[i] = dev_alloc_skb (PKT_BUF_SZ))) {
  990. /* there is not much, we can do at this point */
  991. printk(KERN_ERR "%s: pcnet32_init_ring dev_alloc_skb failed.n",dev->name);
  992. return -1;
  993.     }
  994.     skb_reserve (rx_skbuff, 2);
  995. }
  996.         lp->rx_dma_addr[i] = pci_map_single(lp->pci_dev, rx_skbuff->tail, rx_skbuff->len, PCI_DMA_FROMDEVICE);
  997. lp->rx_ring[i].base = (u32)le32_to_cpu(lp->rx_dma_addr[i]);
  998. lp->rx_ring[i].buf_length = le16_to_cpu(-PKT_BUF_SZ);
  999. lp->rx_ring[i].status = le16_to_cpu(0x8000);
  1000.     }
  1001.     /* The Tx buffer address is filled in as needed, but we do need to clear
  1002.        the upper ownership bit. */
  1003.     for (i = 0; i < TX_RING_SIZE; i++) {
  1004. lp->tx_ring[i].base = 0;
  1005. lp->tx_ring[i].status = 0;
  1006.         lp->tx_dma_addr[i] = 0;
  1007.     }
  1009.     lp->init_block.tlen_rlen = le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS);
  1010.     for (i = 0; i < 6; i++)
  1011. lp->init_block.phys_addr[i] = dev->dev_addr[i];
  1012.     lp->init_block.rx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, rx_ring));
  1013.     lp->init_block.tx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, tx_ring));
  1014.     return 0;
  1015. }
  1017. static void
  1018. pcnet32_restart(struct net_device *dev, unsigned int csr0_bits)
  1019. {
  1020.     struct pcnet32_private *lp = dev->priv;
  1021.     unsigned long ioaddr = dev->base_addr;
  1022.     int i;
  1023.     
  1024.     pcnet32_purge_tx_ring(dev);
  1025.     if (pcnet32_init_ring(dev))
  1026. return;
  1027.     
  1028.     /* ReInit Ring */
  1029.     lp->a.write_csr (ioaddr, 0, 1);
  1030.     i = 0;
  1031.     while (i++ < 100)
  1032. if (lp->a.read_csr (ioaddr, 0) & 0x0100)
  1033.     break;
  1035.     lp->a.write_csr (ioaddr, 0, csr0_bits);
  1036. }
  1039. static void
  1040. pcnet32_tx_timeout (struct net_device *dev)
  1041. {
  1042.     struct pcnet32_private *lp = dev->priv;
  1043.     unsigned long ioaddr = dev->base_addr, flags;
  1045.     spin_lock_irqsave(&lp->lock, flags);
  1046.     /* Transmitter timeout, serious problems. */
  1047. printk(KERN_ERR "%s: transmit timed out, status %4.4x, resetting.n",
  1048.        dev->name, lp->a.read_csr(ioaddr, 0));
  1049. lp->a.write_csr (ioaddr, 0, 0x0004);
  1050. lp->stats.tx_errors++;
  1051. if (pcnet32_debug > 2) {
  1052.     int i;
  1053.     printk(KERN_DEBUG " Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
  1054.        lp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
  1055.        lp->cur_rx);
  1056.     for (i = 0 ; i < RX_RING_SIZE; i++)
  1057.     printk("%s %08x %04x %08x %04x", i & 1 ? "" : "n ",
  1058.    lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
  1059.    lp->rx_ring[i].msg_length, (unsigned)lp->rx_ring[i].status);
  1060.     for (i = 0 ; i < TX_RING_SIZE; i++)
  1061.     printk("%s %08x %04x %08x %04x", i & 1 ? "" : "n ",
  1062.    lp->tx_ring[i].base, -lp->tx_ring[i].length,
  1063.    lp->tx_ring[i].misc, (unsigned)lp->tx_ring[i].status);
  1064.     printk("n");
  1065. }
  1066. pcnet32_restart(dev, 0x0042);
  1068. dev->trans_start = jiffies;
  1069. netif_start_queue(dev);
  1071. spin_unlock_irqrestore(&lp->lock, flags);
  1072. }
  1075. static int
  1076. pcnet32_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1077. {
  1078.     struct pcnet32_private *lp = dev->priv;
  1079.     unsigned long ioaddr = dev->base_addr;
  1080.     u16 status;
  1081.     int entry;
  1082.     unsigned long flags;
  1084.     if (pcnet32_debug > 3) {
  1085. printk(KERN_DEBUG "%s: pcnet32_start_xmit() called, csr0 %4.4x.n",
  1086.        dev->name, lp->a.read_csr(ioaddr, 0));
  1087.     }
  1089.     spin_lock_irqsave(&lp->lock, flags);
  1091.     /* Default status -- will not enable Successful-TxDone
  1092.      * interrupt when that option is available to us.
  1093.      */
  1094.     status = 0x8300;
  1095.     if ((lp->ltint) &&
  1096. ((lp->cur_tx - lp->dirty_tx == TX_RING_SIZE/2) ||
  1097.  (lp->cur_tx - lp->dirty_tx >= TX_RING_SIZE-2)))
  1098.     {
  1099. /* Enable Successful-TxDone interrupt if we have
  1100.  * 1/2 of, or nearly all of, our ring buffer Tx'd
  1101.  * but not yet cleaned up.  Thus, most of the time,
  1102.  * we will not enable Successful-TxDone interrupts.
  1103.  */
  1104. status = 0x9300;
  1105.     }
  1106.   
  1107.     /* Fill in a Tx ring entry */
  1108.   
  1109.     /* Mask to ring buffer boundary. */
  1110.     entry = lp->cur_tx & TX_RING_MOD_MASK;
  1111.   
  1112.     /* Caution: the write order is important here, set the base address
  1113.        with the "ownership" bits last. */
  1115.     lp->tx_ring[entry].length = le16_to_cpu(-skb->len);
  1117.     lp->tx_ring[entry].misc = 0x00000000;
  1119.     lp->tx_skbuff[entry] = skb;
  1120.     lp->tx_dma_addr[entry] = pci_map_single(lp->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE);
  1121.     lp->tx_ring[entry].base = (u32)le32_to_cpu(lp->tx_dma_addr[entry]);
  1122.     lp->tx_ring[entry].status = le16_to_cpu(status);
  1124.     lp->cur_tx++;
  1125.     lp->stats.tx_bytes += skb->len;
  1127.     /* Trigger an immediate send poll. */
  1128.     lp->a.write_csr (ioaddr, 0, 0x0048);
  1130.     dev->trans_start = jiffies;
  1132.     if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
  1133. netif_start_queue(dev);
  1134.     else {
  1135. lp->tx_full = 1;
  1136. netif_stop_queue(dev);
  1137.     }
  1138.     spin_unlock_irqrestore(&lp->lock, flags);
  1139.     return 0;
  1140. }
  1142. /* The PCNET32 interrupt handler. */
  1143. static void
  1144. pcnet32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  1145. {
  1146.     struct net_device *dev = dev_id;
  1147.     struct pcnet32_private *lp;
  1148.     unsigned long ioaddr;
  1149.     u16 csr0,rap;
  1150.     int boguscnt =  max_interrupt_work;
  1151.     int must_restart;
  1153.     if (!dev) {
  1154. printk (KERN_DEBUG "%s(): irq %d for unknown devicen",
  1155. __FUNCTION__, irq);
  1156. return;
  1157.     }
  1159.     ioaddr = dev->base_addr;
  1160.     lp = dev->priv;
  1161.     
  1162.     spin_lock(&lp->lock);
  1163.     
  1164.     rap = lp->a.read_rap(ioaddr);
  1165.     while ((csr0 = lp->a.read_csr (ioaddr, 0)) & 0x8600 && --boguscnt >= 0) {
  1166. /* Acknowledge all of the current interrupt sources ASAP. */
  1167. lp->a.write_csr (ioaddr, 0, csr0 & ~0x004f);
  1169. must_restart = 0;
  1171. if (pcnet32_debug > 5)
  1172.     printk(KERN_DEBUG "%s: interrupt  csr0=%#2.2x new csr=%#2.2x.n",
  1173.    dev->name, csr0, lp->a.read_csr (ioaddr, 0));
  1175. if (csr0 & 0x0400) /* Rx interrupt */
  1176.     pcnet32_rx(dev);
  1178. if (csr0 & 0x0200) { /* Tx-done interrupt */
  1179.     unsigned int dirty_tx = lp->dirty_tx;
  1181.     while (dirty_tx < lp->cur_tx) {
  1182. int entry = dirty_tx & TX_RING_MOD_MASK;
  1183. int status = (short)le16_to_cpu(lp->tx_ring[entry].status);
  1185. if (status < 0)
  1186.     break; /* It still hasn't been Txed */
  1188. lp->tx_ring[entry].base = 0;
  1190. if (status & 0x4000) {
  1191.     /* There was an major error, log it. */
  1192.     int err_status = le32_to_cpu(lp->tx_ring[entry].misc);
  1193.     lp->stats.tx_errors++;
  1194.     if (err_status & 0x04000000) lp->stats.tx_aborted_errors++;
  1195.     if (err_status & 0x08000000) lp->stats.tx_carrier_errors++;
  1196.     if (err_status & 0x10000000) lp->stats.tx_window_errors++;
  1197. #ifndef DO_DXSUFLO
  1198.     if (err_status & 0x40000000) {
  1199. lp->stats.tx_fifo_errors++;
  1200. /* Ackk!  On FIFO errors the Tx unit is turned off! */
  1201. /* Remove this verbosity later! */
  1202. printk(KERN_ERR "%s: Tx FIFO error! CSR0=%4.4xn",
  1203.        dev->name, csr0);
  1204. must_restart = 1;
  1205.     }
  1206. #else
  1207.     if (err_status & 0x40000000) {
  1208. lp->stats.tx_fifo_errors++;
  1209. if (! lp->dxsuflo) {  /* If controller doesn't recover ... */
  1210.     /* Ackk!  On FIFO errors the Tx unit is turned off! */
  1211.     /* Remove this verbosity later! */
  1212.     printk(KERN_ERR "%s: Tx FIFO error! CSR0=%4.4xn",
  1213.    dev->name, csr0);
  1214.     must_restart = 1;
  1215. }
  1216.     }
  1217. #endif
  1218. } else {
  1219.     if (status & 0x1800)
  1220. lp->stats.collisions++;
  1221.     lp->stats.tx_packets++;
  1222. }
  1224. /* We must free the original skb */
  1225. if (lp->tx_skbuff[entry]) {
  1226.                     pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[entry],
  1227. lp->tx_skbuff[entry]->len, PCI_DMA_TODEVICE);
  1228.     dev_kfree_skb_irq(lp->tx_skbuff[entry]);
  1229.     lp->tx_skbuff[entry] = 0;
  1230.                     lp->tx_dma_addr[entry] = 0;
  1231. }
  1232. dirty_tx++;
  1233.     }
  1235.     if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
  1236. printk(KERN_ERR "%s: out-of-sync dirty pointer, %d vs. %d, full=%d.n",
  1237. dev->name, dirty_tx, lp->cur_tx, lp->tx_full);
  1238. dirty_tx += TX_RING_SIZE;
  1239.     }
  1241.     if (lp->tx_full &&
  1242. netif_queue_stopped(dev) &&
  1243. dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
  1244. /* The ring is no longer full, clear tbusy. */
  1245. lp->tx_full = 0;
  1246. netif_wake_queue (dev);
  1247.     }
  1248.     lp->dirty_tx = dirty_tx;
  1249. }
  1251. /* Log misc errors. */
  1252. if (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
  1253. if (csr0 & 0x1000) {
  1254.     /*
  1255.      * this happens when our receive ring is full. This shouldn't
  1256.      * be a problem as we will see normal rx interrupts for the frames
  1257.      * in the receive ring. But there are some PCI chipsets (I can reproduce
  1258.      * this on SP3G with Intel saturn chipset) which have sometimes problems
  1259.      * and will fill up the receive ring with error descriptors. In this
  1260.      * situation we don't get a rx interrupt, but a missed frame interrupt sooner
  1261.      * or later. So we try to clean up our receive ring here.
  1262.      */
  1263.     pcnet32_rx(dev);
  1264.     lp->stats.rx_errors++; /* Missed a Rx frame. */
  1265. }
  1266. if (csr0 & 0x0800) {
  1267.     printk(KERN_ERR "%s: Bus master arbitration failure, status %4.4x.n",
  1268.    dev->name, csr0);
  1269.     /* unlike for the lance, there is no restart needed */
  1270. }
  1272. if (must_restart) {
  1273.     /* stop the chip to clear the error condition, then restart */
  1274.     lp->a.write_csr (ioaddr, 0, 0x0004);
  1275.     pcnet32_restart(dev, 0x0002);
  1276. }
  1277.     }
  1279.     /* Clear any other interrupt, and set interrupt enable. */
  1280.     lp->a.write_csr (ioaddr, 0, 0x7940);
  1281.     lp->a.write_rap (ioaddr,rap);
  1282.     
  1283.     if (pcnet32_debug > 4)
  1284. printk(KERN_DEBUG "%s: exiting interrupt, csr0=%#4.4x.n",
  1285.        dev->name, lp->a.read_csr (ioaddr, 0));
  1287.     spin_unlock(&lp->lock);
  1288. }
  1290. static int
  1291. pcnet32_rx(struct net_device *dev)
  1292. {
  1293.     struct pcnet32_private *lp = dev->priv;
  1294.     int entry = lp->cur_rx & RX_RING_MOD_MASK;
  1296.     /* If we own the next entry, it's a new packet. Send it up. */
  1297.     while ((short)le16_to_cpu(lp->rx_ring[entry].status) >= 0) {
  1298. int status = (short)le16_to_cpu(lp->rx_ring[entry].status) >> 8;
  1300. if (status != 0x03) { /* There was an error. */
  1301.     /* 
  1302.      * There is a tricky error noted by John Murphy,
  1303.      * <murf@perftech.com> to Russ Nelson: Even with full-sized
  1304.      * buffers it's possible for a jabber packet to use two
  1305.      * buffers, with only the last correctly noting the error.
  1306.      */
  1307.     if (status & 0x01) /* Only count a general error at the */
  1308. lp->stats.rx_errors++; /* end of a packet.*/
  1309.     if (status & 0x20) lp->stats.rx_frame_errors++;
  1310.     if (status & 0x10) lp->stats.rx_over_errors++;
  1311.     if (status & 0x08) lp->stats.rx_crc_errors++;
  1312.     if (status & 0x04) lp->stats.rx_fifo_errors++;
  1313.     lp->rx_ring[entry].status &= le16_to_cpu(0x03ff);
  1314. } else {
  1315.     /* Malloc up new buffer, compatible with net-2e. */
  1316.     short pkt_len = (le32_to_cpu(lp->rx_ring[entry].msg_length) & 0xfff)-4;
  1317.     struct sk_buff *skb;
  1319.     if(pkt_len < 60) {
  1320. printk(KERN_ERR "%s: Runt packet!n",dev->name);
  1321. lp->stats.rx_errors++;
  1322.     } else {
  1323. int rx_in_place = 0;
  1325. if (pkt_len > rx_copybreak) {
  1326.     struct sk_buff *newskb;
  1328.     if ((newskb = dev_alloc_skb (PKT_BUF_SZ))) {
  1329. skb_reserve (newskb, 2);
  1330. skb = lp->rx_skbuff[entry];
  1331. pci_unmap_single(lp->pci_dev, lp->rx_dma_addr[entry], skb->len, PCI_DMA_FROMDEVICE);
  1332. skb_put (skb, pkt_len);
  1333. lp->rx_skbuff[entry] = newskb;
  1334. newskb->dev = dev;
  1335.                         lp->rx_dma_addr[entry] = 
  1336. pci_map_single(lp->pci_dev, newskb->tail,
  1337. newskb->len, PCI_DMA_FROMDEVICE);
  1338. lp->rx_ring[entry].base = le32_to_cpu(lp->rx_dma_addr[entry]);
  1339. rx_in_place = 1;
  1340.     } else
  1341. skb = NULL;
  1342. } else {
  1343.     skb = dev_alloc_skb(pkt_len+2);
  1344.                 }
  1345.     
  1346. if (skb == NULL) {
  1347.                     int i;
  1348.     printk(KERN_ERR "%s: Memory squeeze, deferring packet.n", dev->name);
  1349.     for (i = 0; i < RX_RING_SIZE; i++)
  1350. if ((short)le16_to_cpu(lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].status) < 0)
  1351.     break;
  1353.     if (i > RX_RING_SIZE -2) {
  1354. lp->stats.rx_dropped++;
  1355. lp->rx_ring[entry].status |= le16_to_cpu(0x8000);
  1356. lp->cur_rx++;
  1357.     }
  1358.     break;
  1359. }
  1360. skb->dev = dev;
  1361. if (!rx_in_place) {
  1362.     skb_reserve(skb,2); /* 16 byte align */
  1363.     skb_put(skb,pkt_len); /* Make room */
  1364.     eth_copy_and_sum(skb,
  1365.      (unsigned char *)(lp->rx_skbuff[entry]->tail),
  1366.      pkt_len,0);
  1367. }
  1368. lp->stats.rx_bytes += skb->len;
  1369. skb->protocol=eth_type_trans(skb,dev);
  1370. netif_rx(skb);
  1371. dev->last_rx = jiffies;
  1372. lp->stats.rx_packets++;
  1373.     }
  1374. }
  1375. /*
  1376.  * The docs say that the buffer length isn't touched, but Andrew Boyd
  1377.  * of QNX reports that some revs of the 79C965 clear it.
  1378.  */
  1379. lp->rx_ring[entry].buf_length = le16_to_cpu(-PKT_BUF_SZ);
  1380. lp->rx_ring[entry].status |= le16_to_cpu(0x8000);
  1381. entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
  1382.     }
  1384.     return 0;
  1385. }
  1387. static int
  1388. pcnet32_close(struct net_device *dev)
  1389. {
  1390.     unsigned long ioaddr = dev->base_addr;
  1391.     struct pcnet32_private *lp = dev->priv;
  1392.     int i;
  1394.     del_timer_sync(&lp->watchdog_timer);
  1396.     netif_stop_queue(dev);
  1398.     lp->stats.rx_missed_errors = lp->a.read_csr (ioaddr, 112);
  1400.     if (pcnet32_debug > 1)
  1401. printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.n",
  1402.        dev->name, lp->a.read_csr (ioaddr, 0));
  1404.     /* We stop the PCNET32 here -- it occasionally polls memory if we don't. */
  1405.     lp->a.write_csr (ioaddr, 0, 0x0004);
  1407.     /*
  1408.      * Switch back to 16bit mode to avoid problems with dumb 
  1409.      * DOS packet driver after a warm reboot
  1410.      */
  1411.     lp->a.write_bcr (ioaddr, 20, 4);
  1413.     free_irq(dev->irq, dev);
  1414.     
  1415.     /* free all allocated skbuffs */
  1416.     for (i = 0; i < RX_RING_SIZE; i++) {
  1417. lp->rx_ring[i].status = 0;     
  1418. if (lp->rx_skbuff[i]) {
  1419.             pci_unmap_single(lp->pci_dev, lp->rx_dma_addr[i], lp->rx_skbuff[i]->len, PCI_DMA_FROMDEVICE);
  1420.     dev_kfree_skb(lp->rx_skbuff[i]);
  1421.         }
  1422. lp->rx_skbuff[i] = NULL;
  1423.         lp->rx_dma_addr[i] = 0;
  1424.     }
  1425.     
  1426.     for (i = 0; i < TX_RING_SIZE; i++) {
  1427. if (lp->tx_skbuff[i]) {
  1428.             pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[i], lp->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
  1429.     dev_kfree_skb(lp->tx_skbuff[i]);
  1430.         }
  1431. lp->tx_skbuff[i] = NULL;
  1432.         lp->tx_dma_addr[i] = 0;
  1433.     }
  1434.     
  1435.     MOD_DEC_USE_COUNT;
  1437.     return 0;
  1438. }
  1440. static struct net_device_stats *
  1441. pcnet32_get_stats(struct net_device *dev)
  1442. {
  1443.     struct pcnet32_private *lp = dev->priv;
  1444.     unsigned long ioaddr = dev->base_addr;
  1445.     u16 saved_addr;
  1446.     unsigned long flags;
  1448.     spin_lock_irqsave(&lp->lock, flags);
  1449.     saved_addr = lp->a.read_rap(ioaddr);
  1450.     lp->stats.rx_missed_errors = lp->a.read_csr (ioaddr, 112);
  1451.     lp->a.write_rap(ioaddr, saved_addr);
  1452.     spin_unlock_irqrestore(&lp->lock, flags);
  1454.     return &lp->stats;
  1455. }
  1457. /* taken from the sunlance driver, which it took from the depca driver */
  1458. static void pcnet32_load_multicast (struct net_device *dev)
  1459. {
  1460.     struct pcnet32_private *lp = dev->priv;
  1461.     volatile struct pcnet32_init_block *ib = &lp->init_block;
  1462.     volatile u16 *mcast_table = (u16 *)&ib->filter;
  1463.     struct dev_mc_list *dmi=dev->mc_list;
  1464.     char *addrs;
  1465.     int i;
  1466.     u32 crc;
  1468.     /* set all multicast bits */
  1469.     if (dev->flags & IFF_ALLMULTI){ 
  1470. ib->filter[0] = 0xffffffff;
  1471. ib->filter[1] = 0xffffffff;
  1472. return;
  1473.     }
  1474.     /* clear the multicast filter */
  1475.     ib->filter[0] = 0;
  1476.     ib->filter[1] = 0;
  1478.     /* Add addresses */
  1479.     for (i = 0; i < dev->mc_count; i++){
  1480. addrs = dmi->dmi_addr;
  1481. dmi   = dmi->next;
  1483. /* multicast address? */
  1484. if (!(*addrs & 1))
  1485.     continue;
  1487. crc = ether_crc_le(6, addrs);
  1488. crc = crc >> 26;
  1489. mcast_table [crc >> 4] |= 1 << (crc & 0xf);
  1490.     }
  1491.     return;
  1492. }
  1495. /*
  1496.  * Set or clear the multicast filter for this adaptor.
  1497.  */
  1498. static void pcnet32_set_multicast_list(struct net_device *dev)
  1499. {
  1500.     unsigned long ioaddr = dev->base_addr, flags;
  1501.     struct pcnet32_private *lp = dev->priv;  
  1503.     spin_lock_irqsave(&lp->lock, flags);
  1504.     if (dev->flags&IFF_PROMISC) {
  1505. /* Log any net taps. */
  1506. printk(KERN_INFO "%s: Promiscuous mode enabled.n", dev->name);
  1507. lp->init_block.mode = le16_to_cpu(0x8000 | (lp->options & PCNET32_PORT_PORTSEL) << 7);
  1508.     } else {
  1509. lp->init_block.mode = le16_to_cpu((lp->options & PCNET32_PORT_PORTSEL) << 7);
  1510. pcnet32_load_multicast (dev);
  1511.     }
  1512.     
  1513.     lp->a.write_csr (ioaddr, 0, 0x0004); /* Temporarily stop the lance. */
  1515.     pcnet32_restart(dev, 0x0042); /*  Resume normal operation */
  1516.     spin_unlock_irqrestore(&lp->lock, flags);
  1517. }
  1519. static int mdio_read(struct net_device *dev, int phy_id, int reg_num)
  1520. {
  1521. struct pcnet32_private *lp = dev->priv;
  1522. unsigned long ioaddr = dev->base_addr;
  1523. u16 val_out;
  1524. int phyaddr;
  1526. if (!lp->mii)
  1527. return 0;
  1529. phyaddr = lp->a.read_bcr(ioaddr, 33);
  1531. lp->a.write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) | (reg_num & 0x1f));
  1532. val_out = lp->a.read_bcr(ioaddr, 34);
  1533. lp->a.write_bcr(ioaddr, 33, phyaddr);
  1535. return val_out;
  1536. }
  1538. static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val)
  1539. {
  1540. struct pcnet32_private *lp = dev->priv;
  1541. unsigned long ioaddr = dev->base_addr;
  1542. int phyaddr;
  1544. if (!lp->mii)
  1545. return;
  1547. phyaddr = lp->a.read_bcr(ioaddr, 33);
  1549. lp->a.write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) | (reg_num & 0x1f));
  1550. lp->a.write_bcr(ioaddr, 34, val);
  1551. lp->a.write_bcr(ioaddr, 33, phyaddr);
  1552. }
  1554. static int pcnet32_ethtool_ioctl (struct net_device *dev, void *useraddr)
  1555. {
  1556. struct pcnet32_private *lp = dev->priv;
  1557. u32 ethcmd;
  1558. int phyaddr = 0;
  1559. int phy_id = 0;
  1560. unsigned long ioaddr = dev->base_addr;
  1562. if (lp->mii) {
  1563. phyaddr = lp->a.read_bcr (ioaddr, 33);
  1564. phy_id = (phyaddr >> 5) & 0x1f;
  1565. lp->mii_if.phy_id = phy_id;
  1566. }
  1568. if (copy_from_user (&ethcmd, useraddr, sizeof (ethcmd)))
  1569. return -EFAULT;
  1571. switch (ethcmd) {
  1572. case ETHTOOL_GDRVINFO: {
  1573. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1574. strcpy (info.driver, DRV_NAME);
  1575. strcpy (info.version, DRV_VERSION);
  1576. if (lp->pci_dev)
  1577. strcpy (info.bus_info, lp->pci_dev->slot_name);
  1578. else
  1579. sprintf(info.bus_info, "VLB 0x%lx", dev->base_addr);
  1580. if (copy_to_user (useraddr, &info, sizeof (info)))
  1581. return -EFAULT;
  1582. return 0;
  1583. }
  1585. /* get settings */
  1586. case ETHTOOL_GSET: {
  1587. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  1588. spin_lock_irq(&lp->lock);
  1589. mii_ethtool_gset(&lp->mii_if, &ecmd);
  1590. spin_unlock_irq(&lp->lock);
  1591. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1592. return -EFAULT;
  1593. return 0;
  1594. }
  1595. /* set settings */
  1596. case ETHTOOL_SSET: {
  1597. int r;
  1598. struct ethtool_cmd ecmd;
  1599. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  1600. return -EFAULT;
  1601. spin_lock_irq(&lp->lock);
  1602. r = mii_ethtool_sset(&lp->mii_if, &ecmd);
  1603. spin_unlock_irq(&lp->lock);
  1604. return r;
  1605. }
  1606. /* restart autonegotiation */
  1607. case ETHTOOL_NWAY_RST: {
  1608. return mii_nway_restart(&lp->mii_if);
  1609. }
  1610. /* get link status */
  1611. case ETHTOOL_GLINK: {
  1612. struct ethtool_value edata = {ETHTOOL_GLINK};
  1613. edata.data = mii_link_ok(&lp->mii_if);
  1614. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1615. return -EFAULT;
  1616. return 0;
  1617. }
  1619. /* get message-level */
  1620. case ETHTOOL_GMSGLVL: {
  1621. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1622. edata.data = pcnet32_debug;
  1623. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1624. return -EFAULT;
  1625. return 0;
  1626. }
  1627. /* set message-level */
  1628. case ETHTOOL_SMSGLVL: {
  1629. struct ethtool_value edata;
  1630. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1631. return -EFAULT;
  1632. pcnet32_debug = edata.data;
  1633. return 0;
  1634. }
  1635. default:
  1636. break;
  1637. }
  1639. return -EOPNOTSUPP;
  1640. }
  1642. static int pcnet32_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1643. {
  1644.     unsigned long ioaddr = dev->base_addr;
  1645.     struct pcnet32_private *lp = dev->priv;  
  1646.     struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  1647.     int phyaddr = lp->a.read_bcr (ioaddr, 33);
  1649.     if (cmd == SIOCETHTOOL)
  1650. return pcnet32_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1652.     if (lp->mii) {
  1653. switch(cmd) {
  1654. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  1655.     data->phy_id = (phyaddr >> 5) & 0x1f;
  1656.     /* Fall Through */
  1657. case SIOCGMIIREG: /* Read MII PHY register. */
  1658.     lp->a.write_bcr (ioaddr, 33, ((data->phy_id & 0x1f) << 5) | (data->reg_num & 0x1f));
  1659.     data->val_out = lp->a.read_bcr (ioaddr, 34);
  1660.     lp->a.write_bcr (ioaddr, 33, phyaddr);
  1661.     return 0;
  1662. case SIOCSMIIREG: /* Write MII PHY register. */
  1663.     if (!capable(CAP_NET_ADMIN))
  1664. return -EPERM;
  1665.     lp->a.write_bcr (ioaddr, 33, ((data->phy_id & 0x1f) << 5) | (data->reg_num & 0x1f));
  1666.     lp->a.write_bcr (ioaddr, 34, data->val_in);
  1667.     lp->a.write_bcr (ioaddr, 33, phyaddr);
  1668.     return 0;
  1669. default:
  1670.     return -EOPNOTSUPP;
  1671. }
  1672.     }
  1673.     return -EOPNOTSUPP;
  1674. }
  1676. static void pcnet32_watchdog(struct net_device *dev)
  1677. {
  1678.     struct pcnet32_private *lp = dev->priv;
  1680.     /* Print the link status if it has changed */
  1681.     if (lp->mii)
  1682. mii_check_media (&lp->mii_if, 1, 0);
  1684.     mod_timer (&(lp->watchdog_timer), PCNET32_WATCHDOG_TIMEOUT);
  1685. }
  1687. static struct pci_driver pcnet32_driver = {
  1688.     name: DRV_NAME,
  1689.     probe: pcnet32_probe_pci,
  1690.     id_table: pcnet32_pci_tbl,
  1691. };
  1693. MODULE_PARM(debug, "i");
  1694. MODULE_PARM_DESC(debug, DRV_NAME " debug level (0-6)");
  1695. MODULE_PARM(max_interrupt_work, "i");
  1696. MODULE_PARM_DESC(max_interrupt_work, DRV_NAME " maximum events handled per interrupt");  
  1697. MODULE_PARM(rx_copybreak, "i");
  1698. MODULE_PARM_DESC(rx_copybreak, DRV_NAME " copy breakpoint for copy-only-tiny-frames"); 
  1699. MODULE_PARM(tx_start_pt, "i");
  1700. MODULE_PARM_DESC(tx_start_pt, DRV_NAME " transmit start point (0-3)"); 
  1701. MODULE_PARM(pcnet32vlb, "i");
  1702. MODULE_PARM_DESC(pcnet32vlb, DRV_NAME " Vesa local bus (VLB) support (0/1)"); 
  1703. MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
  1704. MODULE_PARM_DESC(options, DRV_NAME " initial option setting(s) (0-15)"); 
  1705. MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
  1706. MODULE_PARM_DESC(full_duplex, DRV_NAME " full duplex setting(s) (1)");
  1708. MODULE_AUTHOR("Thomas Bogendoerfer");
  1709. MODULE_DESCRIPTION("Driver for PCnet32 and PCnetPCI based ethercards");
  1710. MODULE_LICENSE("GPL");
  1712. /* An additional parameter that may be passed in... */
  1713. static int debug = -1;
  1714. static int tx_start_pt = -1;
  1716. static int __init pcnet32_init_module(void)
  1717. {
  1718.     printk(KERN_INFO "%s", version);
  1720.     if (debug > 0)
  1721. pcnet32_debug = debug;
  1723.     if ((tx_start_pt >= 0) && (tx_start_pt <= 3))
  1724. tx_start = tx_start_pt;
  1726.     /* find the PCI devices */
  1727.     pci_module_init(&pcnet32_driver);
  1729.     /* should we find any remaining VLbus devices ? */
  1730.     if (pcnet32vlb)
  1731. pcnet32_probe_vlbus();
  1733.     if (cards_found)
  1734. printk(KERN_INFO PFX "%d cards_found.n", cards_found);
  1735.     
  1736.     return cards_found ? 0 : -ENODEV;
  1737. }
  1739. static void __exit pcnet32_cleanup_module(void)
  1740. {
  1741.     struct net_device *next_dev;
  1743.     /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
  1744.     while (pcnet32_dev) {
  1745. struct pcnet32_private *lp = pcnet32_dev->priv;
  1746. next_dev = lp->next;
  1747. unregister_netdev(pcnet32_dev);
  1748. release_region(pcnet32_dev->base_addr, PCNET32_TOTAL_SIZE);
  1749. if (lp->pci_dev)
  1750.     pci_unregister_driver(&pcnet32_driver);
  1751. pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
  1752. kfree(pcnet32_dev);
  1753. pcnet32_dev = next_dev;
  1754.     }
  1755. }
  1757. module_init(pcnet32_init_module);
  1758. module_exit(pcnet32_cleanup_module);
  1760. /*
  1761.  * Local variables:
  1762.  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c pcnet32.c"
  1763.  *  c-indent-level: 4
  1764.  *  tab-width: 8
  1765.  * End:
  1766.  */