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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pcnet32.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：53k
源码类别：

嵌入式Linux

开发平台：

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.25kf"
  26. #define DRV_RELDATE "17.11.2001"
  28. static const char *version =
  29. DRV_NAME ".c:v" DRV_VERSION " " DRV_RELDATE " tsbogend@alpha.franken.den";
  31. #include <linux/module.h>
  33. #include <linux/kernel.h>
  34. #include <linux/sched.h>
  35. #include <linux/string.h>
  36. #include <linux/ptrace.h>
  37. #include <linux/errno.h>
  38. #include <linux/ioport.h>
  39. #include <linux/slab.h>
  40. #include <linux/interrupt.h>
  41. #include <linux/pci.h>
  42. #include <linux/delay.h>
  43. #include <linux/init.h>
  44. #include <linux/ethtool.h>
  45. #include <linux/mii.h>
  46. #include <asm/bitops.h>
  47. #include <asm/io.h>
  48. #include <asm/dma.h>
  49. #include <asm/uaccess.h>
  51. #include <linux/netdevice.h>
  52. #include <linux/etherdevice.h>
  53. #include <linux/skbuff.h>
  54. #include <linux/spinlock.h>
  56. static unsigned int pcnet32_portlist[] __initdata = {0x300, 0x320, 0x340, 0x360, 0};
  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. static int pcnet32_debug = 1;
  68. static int tx_start = 1; /* Mapping -- 0:20, 1:64, 2:128, 3:~220 (depends on chip vers) */
  70. static struct net_device *pcnet32_dev;
  72. static const int max_interrupt_work = 80;
  73. static const int rx_copybreak = 200;
  75. #define PCNET32_PORT_AUI      0x00
  76. #define PCNET32_PORT_10BT     0x01
  77. #define PCNET32_PORT_GPSI     0x02
  78. #define PCNET32_PORT_MII      0x03
  80. #define PCNET32_PORT_PORTSEL  0x03
  81. #define PCNET32_PORT_ASEL     0x04
  82. #define PCNET32_PORT_100      0x40
  83. #define PCNET32_PORT_FD       0x80
  85. #define PCNET32_DMA_MASK 0xffffffff
  87. /*
  88.  * table to translate option values from tulip
  89.  * to internal options
  90.  */
  91. static unsigned char options_mapping[] = {
  92.     PCNET32_PORT_ASEL,    /*  0 Auto-select   */
  93.     PCNET32_PORT_AUI,    /*  1 BNC/AUI   */
  94.     PCNET32_PORT_AUI,    /*  2 AUI/BNC   */ 
  95.     PCNET32_PORT_ASEL,    /*  3 not supported   */
  96.     PCNET32_PORT_10BT | PCNET32_PORT_FD,    /*  4 10baseT-FD   */
  97.     PCNET32_PORT_ASEL,    /*  5 not supported   */
  98.     PCNET32_PORT_ASEL,    /*  6 not supported   */
  99.     PCNET32_PORT_ASEL,    /*  7 not supported   */
  100.     PCNET32_PORT_ASEL,    /*  8 not supported   */
  101.     PCNET32_PORT_MII,    /*  9 MII 10baseT   */
  102.     PCNET32_PORT_MII | PCNET32_PORT_FD,    /* 10 MII 10baseT-FD   */
  103.     PCNET32_PORT_MII,    /* 11 MII (autosel)   */
  104.     PCNET32_PORT_10BT,    /* 12 10BaseT   */
  105.     PCNET32_PORT_MII | PCNET32_PORT_100,    /* 13 MII 100BaseTx   */
  106.     PCNET32_PORT_MII | PCNET32_PORT_100 | PCNET32_PORT_FD, /* 14 MII 100BaseTx-FD */
  107.     PCNET32_PORT_ASEL    /* 15 not supported   */
  108. };
  110. #define MAX_UNITS 8
  111. static int options[MAX_UNITS];
  112. static int full_duplex[MAX_UNITS];
  114. /*
  115.  * Theory of Operation
  116.  * 
  117.  * This driver uses the same software structure as the normal lance
  118.  * driver. So look for a verbose description in lance.c. The differences
  119.  * to the normal lance driver is the use of the 32bit mode of PCnet32
  120.  * and PCnetPCI chips. Because these chips are 32bit chips, there is no
  121.  * 16MB limitation and we don't need bounce buffers.
  122.  */
  123.  
  124. /*
  125.  * History:
  126.  * v0.01:  Initial version
  127.  *    only tested on Alpha Noname Board
  128.  * v0.02:  changed IRQ handling for new interrupt scheme (dev_id)
  129.  *    tested on a ASUS SP3G
  130.  * v0.10:  fixed an odd problem with the 79C974 in a Compaq Deskpro XL
  131.  *    looks like the 974 doesn't like stopping and restarting in a
  132.  *    short period of time; now we do a reinit of the lance; the
  133.  *    bug was triggered by doing ifconfig eth0 <ip> broadcast <addr>
  134.  *    and hangs the machine (thanks to Klaus Liedl for debugging)
  135.  * v0.12:  by suggestion from Donald Becker: Renamed driver to pcnet32,
  136.  *    made it standalone (no need for lance.c)
  137.  * v0.13:  added additional PCI detecting for special PCI devices (Compaq)
  138.  * v0.14:  stripped down additional PCI probe (thanks to David C Niemi
  139.  *    and sveneric@xs4all.nl for testing this on their Compaq boxes)
  140.  * v0.15:  added 79C965 (VLB) probe
  141.  *    added interrupt sharing for PCI chips
  142.  * v0.16:  fixed set_multicast_list on Alpha machines
  143.  * v0.17:  removed hack from dev.c; now pcnet32 uses ethif_probe in Space.c
  144.  * v0.19:  changed setting of autoselect bit
  145.  * v0.20:  removed additional Compaq PCI probe; there is now a working one
  146.  *    in arch/i386/bios32.c
  147.  * v0.21:  added endian conversion for ppc, from work by cort@cs.nmt.edu
  148.  * v0.22:  added printing of status to ring dump
  149.  * v0.23:  changed enet_statistics to net_devive_stats
  150.  * v0.90:  added multicast filter
  151.  *    added module support
  152.  *    changed irq probe to new style
  153.  *    added PCnetFast chip id
  154.  *    added fix for receive stalls with Intel saturn chipsets
  155.  *    added in-place rx skbs like in the tulip driver
  156.  *    minor cleanups
  157.  * v0.91:  added PCnetFast+ chip id
  158.  *    back port to 2.0.x
  159.  * v1.00:  added some stuff from Donald Becker's 2.0.34 version
  160.  *    added support for byte counters in net_dev_stats
  161.  * v1.01:  do ring dumps, only when debugging the driver
  162.  *    increased the transmit timeout
  163.  * v1.02:  fixed memory leak in pcnet32_init_ring()
  164.  * v1.10:  workaround for stopped transmitter
  165.  *    added port selection for modules
  166.  *    detect special T1/E1 WAN card and setup port selection
  167.  * v1.11:  fixed wrong checking of Tx errors
  168.  * v1.20:  added check of return value kmalloc (cpeterso@cs.washington.edu)
  169.  *    added save original kmalloc addr for freeing (mcr@solidum.com)
  170.  *    added support for PCnetHome chip (joe@MIT.EDU)
  171.  *    rewritten PCI card detection
  172.  *    added dwio mode to get driver working on some PPC machines
  173.  * v1.21:  added mii selection and mii ioctl
  174.  * v1.22:  changed pci scanning code to make PPC people happy
  175.  *    fixed switching to 32bit mode in pcnet32_open() (thanks
  176.  *    to Michael Richard <mcr@solidum.com> for noticing this one)
  177.  *    added sub vendor/device id matching (thanks again to 
  178.  *    Michael Richard <mcr@solidum.com>)
  179.  *    added chip id for 79c973/975 (thanks to Zach Brown <zab@zabbo.net>)
  180.  * v1.23   fixed small bug, when manual selecting MII speed/duplex
  181.  * v1.24   Applied Thomas' patch to use TxStartPoint and thus decrease TxFIFO
  182.  *    underflows. Added tx_start_pt module parameter. Increased
  183.  *    TX_RING_SIZE from 16 to 32. Added #ifdef'd code to use DXSUFLO
  184.  *    for FAST[+] chipsets. <kaf@fc.hp.com>
  185.  * v1.24ac Added SMP spinlocking - Alan Cox <alan@redhat.com>
  186.  * v1.25kf Added No Interrupt on successful Tx for some Tx's <kaf@fc.hp.com>
  187.  * v1.26   Converted to pci_alloc_consistent, Jamey Hicks / George France
  188.  *                                           <jamey@crl.dec.com>
  189.  * v1.26p Fix oops on rmmod+insmod; plug i/o resource leak - Paul Gortmaker
  190.  */
  193. /*
  194.  * Set the number of Tx and Rx buffers, using Log_2(# buffers).
  195.  * Reasonable default values are 4 Tx buffers, and 16 Rx buffers.
  196.  * That translates to 2 (4 == 2^^2) and 4 (16 == 2^^4).
  197.  */
  198. #ifndef PCNET32_LOG_TX_BUFFERS
  199. #define PCNET32_LOG_TX_BUFFERS 4
  200. #define PCNET32_LOG_RX_BUFFERS 5
  201. #endif
  203. #define TX_RING_SIZE (1 << (PCNET32_LOG_TX_BUFFERS))
  204. #define TX_RING_MOD_MASK (TX_RING_SIZE - 1)
  205. #define TX_RING_LEN_BITS ((PCNET32_LOG_TX_BUFFERS) << 12)
  207. #define RX_RING_SIZE (1 << (PCNET32_LOG_RX_BUFFERS))
  208. #define RX_RING_MOD_MASK (RX_RING_SIZE - 1)
  209. #define RX_RING_LEN_BITS ((PCNET32_LOG_RX_BUFFERS) << 4)
  211. #define PKT_BUF_SZ 1544
  213. /* Offsets from base I/O address. */
  214. #define PCNET32_WIO_RDP 0x10
  215. #define PCNET32_WIO_RAP 0x12
  216. #define PCNET32_WIO_RESET 0x14
  217. #define PCNET32_WIO_BDP 0x16
  219. #define PCNET32_DWIO_RDP 0x10
  220. #define PCNET32_DWIO_RAP 0x14
  221. #define PCNET32_DWIO_RESET 0x18
  222. #define PCNET32_DWIO_BDP 0x1C
  224. #define PCNET32_TOTAL_SIZE 0x20
  226. #define CRC_POLYNOMIAL_LE 0xedb88320UL /* Ethernet CRC, little endian */
  228. /* The PCNET32 Rx and Tx ring descriptors. */
  229. struct pcnet32_rx_head {
  230.     u32 base;
  231.     s16 buf_length;
  232.     s16 status;    
  233.     u32 msg_length;
  234.     u32 reserved;
  235. };
  237. struct pcnet32_tx_head {
  238.     u32 base;
  239.     s16 length;
  240.     s16 status;
  241.     u32 misc;
  242.     u32 reserved;
  243. };
  245. /* The PCNET32 32-Bit initialization block, described in databook. */
  246. struct pcnet32_init_block {
  247.     u16 mode;
  248.     u16 tlen_rlen;
  249.     u8 phys_addr[6];
  250.     u16 reserved;
  251.     u32 filter[2];
  252.     /* Receive and transmit ring base, along with extra bits. */    
  253.     u32 rx_ring;
  254.     u32 tx_ring;
  255. };
  257. /* PCnet32 access functions */
  258. struct pcnet32_access {
  259.     u16 (*read_csr)(unsigned long, int);
  260.     void (*write_csr)(unsigned long, int, u16);
  261.     u16 (*read_bcr)(unsigned long, int);
  262.     void (*write_bcr)(unsigned long, int, u16);
  263.     u16 (*read_rap)(unsigned long);
  264.     void (*write_rap)(unsigned long, u16);
  265.     void (*reset)(unsigned long);
  266. };
  268. /*
  269.  * The first three fields of pcnet32_private are read by the ethernet device 
  270.  * so we allocate the structure should be allocated by pci_alloc_consistent().
  271.  */
  272. struct pcnet32_private {
  273.     /* The Tx and Rx ring entries must be aligned on 16-byte boundaries in 32bit mode. */
  274.     struct pcnet32_rx_head   rx_ring[RX_RING_SIZE];
  275.     struct pcnet32_tx_head   tx_ring[TX_RING_SIZE];
  276.     struct pcnet32_init_block init_block;
  277.     dma_addr_t dma_addr; /* DMA address of beginning of this object, returned by pci_alloc_consistent */
  278.     struct pci_dev *pci_dev; /* Pointer to the associated pci device structure */
  279.     const char *name;
  280.     /* The saved address of a sent-in-place packet/buffer, for skfree(). */
  281.     struct sk_buff *tx_skbuff[TX_RING_SIZE];
  282.     struct sk_buff *rx_skbuff[RX_RING_SIZE];
  283.     dma_addr_t tx_dma_addr[TX_RING_SIZE];
  284.     dma_addr_t rx_dma_addr[RX_RING_SIZE];
  285.     struct pcnet32_access a;
  286.     spinlock_t lock; /* Guard lock */
  287.     unsigned int cur_rx, cur_tx; /* The next free ring entry */
  288.     unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */
  289.     struct net_device_stats stats;
  290.     char tx_full;
  291.     int  options;
  292.     int  shared_irq:1, /* shared irq possible */
  293. ltint:1,
  294. #ifdef DO_DXSUFLO
  295.       dxsuflo:1,     /* disable transmit stop on uflo */
  296. #endif
  297. mii:1; /* mii port available */
  298.     struct net_device *next;
  299.     struct mii_if_info mii_if;
  300. };
  302. static int  pcnet32_probe_vlbus(int cards_found);
  303. static int  pcnet32_probe_pci(struct pci_dev *, const struct pci_device_id *);
  304. static int  pcnet32_probe1(unsigned long, unsigned char, int, int, struct pci_dev *);
  305. static int  pcnet32_open(struct net_device *);
  306. static int  pcnet32_init_ring(struct net_device *);
  307. static int  pcnet32_start_xmit(struct sk_buff *, struct net_device *);
  308. static int  pcnet32_rx(struct net_device *);
  309. static void pcnet32_tx_timeout (struct net_device *dev);
  310. static void pcnet32_interrupt(int, void *, struct pt_regs *);
  311. static int  pcnet32_close(struct net_device *);
  312. static struct net_device_stats *pcnet32_get_stats(struct net_device *);
  313. static void pcnet32_set_multicast_list(struct net_device *);
  314. static int  pcnet32_ioctl(struct net_device *, struct ifreq *, int);
  315. static int mdio_read(struct net_device *dev, int phy_id, int reg_num);
  316. static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val);
  318. enum pci_flags_bit {
  319.     PCI_USES_IO=1, PCI_USES_MEM=2, PCI_USES_MASTER=4,
  320.     PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3,
  321. };
  323. struct pcnet32_pci_id_info {
  324.     const char *name;
  325.     u16 vendor_id, device_id, svid, sdid, flags;
  326.     int io_size;
  327.     int (*probe1) (unsigned long, unsigned char, int, int, struct pci_dev *);
  328. };
  331. MODULE_DEVICE_TABLE (pci, pcnet32_pci_tbl);
  333. static u16 pcnet32_wio_read_csr (unsigned long addr, int index)
  334. {
  335.     outw (index, addr+PCNET32_WIO_RAP);
  336.     return inw (addr+PCNET32_WIO_RDP);
  337. }
  339. static void pcnet32_wio_write_csr (unsigned long addr, int index, u16 val)
  340. {
  341.     outw (index, addr+PCNET32_WIO_RAP);
  342.     outw (val, addr+PCNET32_WIO_RDP);
  343. }
  345. static u16 pcnet32_wio_read_bcr (unsigned long addr, int index)
  346. {
  347.     outw (index, addr+PCNET32_WIO_RAP);
  348.     return inw (addr+PCNET32_WIO_BDP);
  349. }
  351. static void pcnet32_wio_write_bcr (unsigned long addr, int index, u16 val)
  352. {
  353.     outw (index, addr+PCNET32_WIO_RAP);
  354.     outw (val, addr+PCNET32_WIO_BDP);
  355. }
  357. static u16 pcnet32_wio_read_rap (unsigned long addr)
  358. {
  359.     return inw (addr+PCNET32_WIO_RAP);
  360. }
  362. static void pcnet32_wio_write_rap (unsigned long addr, u16 val)
  363. {
  364.     outw (val, addr+PCNET32_WIO_RAP);
  365. }
  367. static void pcnet32_wio_reset (unsigned long addr)
  368. {
  369.     inw (addr+PCNET32_WIO_RESET);
  370. }
  372. static int pcnet32_wio_check (unsigned long addr)
  373. {
  374.     outw (88, addr+PCNET32_WIO_RAP);
  375.     return (inw (addr+PCNET32_WIO_RAP) == 88);
  376. }
  378. static struct pcnet32_access pcnet32_wio = {
  379.     pcnet32_wio_read_csr,
  380.     pcnet32_wio_write_csr,
  381.     pcnet32_wio_read_bcr,
  382.     pcnet32_wio_write_bcr,
  383.     pcnet32_wio_read_rap,
  384.     pcnet32_wio_write_rap,
  385.     pcnet32_wio_reset
  386. };
  388. static u16 pcnet32_dwio_read_csr (unsigned long addr, int index)
  389. {
  390.     outl (index, addr+PCNET32_DWIO_RAP);
  391.     return (inl (addr+PCNET32_DWIO_RDP) & 0xffff);
  392. }
  394. static void pcnet32_dwio_write_csr (unsigned long addr, int index, u16 val)
  395. {
  396.     outl (index, addr+PCNET32_DWIO_RAP);
  397.     outl (val, addr+PCNET32_DWIO_RDP);
  398. }
  400. static u16 pcnet32_dwio_read_bcr (unsigned long addr, int index)
  401. {
  402.     outl (index, addr+PCNET32_DWIO_RAP);
  403.     return (inl (addr+PCNET32_DWIO_BDP) & 0xffff);
  404. }
  406. static void pcnet32_dwio_write_bcr (unsigned long addr, int index, u16 val)
  407. {
  408.     outl (index, addr+PCNET32_DWIO_RAP);
  409.     outl (val, addr+PCNET32_DWIO_BDP);
  410. }
  412. static u16 pcnet32_dwio_read_rap (unsigned long addr)
  413. {
  414.     return (inl (addr+PCNET32_DWIO_RAP) & 0xffff);
  415. }
  417. static void pcnet32_dwio_write_rap (unsigned long addr, u16 val)
  418. {
  419.     outl (val, addr+PCNET32_DWIO_RAP);
  420. }
  422. static void pcnet32_dwio_reset (unsigned long addr)
  423. {
  424.     inl (addr+PCNET32_DWIO_RESET);
  425. }
  427. static int pcnet32_dwio_check (unsigned long addr)
  428. {
  429.     outl (88, addr+PCNET32_DWIO_RAP);
  430.     return ((inl (addr+PCNET32_DWIO_RAP) & 0xffff) == 88);
  431. }
  433. static struct pcnet32_access pcnet32_dwio = {
  434.     pcnet32_dwio_read_csr,
  435.     pcnet32_dwio_write_csr,
  436.     pcnet32_dwio_read_bcr,
  437.     pcnet32_dwio_write_bcr,
  438.     pcnet32_dwio_read_rap,
  439.     pcnet32_dwio_write_rap,
  440.     pcnet32_dwio_reset
  442. };
  446. /* only probes for non-PCI devices, the rest are handled by pci_register_driver via pcnet32_probe_pci*/
  447. static int __init pcnet32_probe_vlbus(int cards_found)
  448. {
  449.     unsigned long ioaddr = 0; // FIXME dev ? dev->base_addr: 0;
  450.     unsigned int  irq_line = 0; // FIXME dev ? dev->irq : 0;
  451.     int *port;
  452.     
  453.     printk(KERN_INFO "pcnet32_probe_vlbus: cards_found=%dn", cards_found);
  454. #ifndef __powerpc__
  455.     if (ioaddr > 0x1ff) {
  456. if (check_region(ioaddr, PCNET32_TOTAL_SIZE) == 0)
  457.     return pcnet32_probe1(ioaddr, irq_line, 0, 0, NULL);
  458. else
  459.     return -ENODEV;
  460.     } else
  461. #endif
  462. if (ioaddr != 0)
  463.     return -ENXIO;
  464.     
  465.     /* now look for PCnet32 VLB cards */
  466.     for (port = pcnet32_portlist; *port; port++) {
  467. unsigned long ioaddr = *port;
  469. if ( check_region(ioaddr, PCNET32_TOTAL_SIZE) == 0) {
  470.     /* check if there is really a pcnet chip on that ioaddr */
  471.     if ((inb(ioaddr + 14) == 0x57) &&
  472. (inb(ioaddr + 15) == 0x57) &&
  473. (pcnet32_probe1(ioaddr, 0, 0, 0, NULL) == 0))
  474. cards_found++;
  475. }
  476.     }
  477.     return cards_found ? 0: -ENODEV;
  478. }
  482. static int __devinit
  483. pcnet32_probe_pci(struct pci_dev *pdev, const struct pci_device_id *ent)
  484. {
  485.     static int card_idx;
  486.     long ioaddr;
  487.     int err = 0;
  489.     printk(KERN_INFO "pcnet32_probe_pci: found device %#08x.%#08xn", ent->vendor, ent->device);
  491.     if ((err = pci_enable_device(pdev)) < 0) {
  492. printk(KERN_ERR "pcnet32.c: failed to enable device -- err=%dn", err);
  493. return err;
  494.     }
  495.     pci_set_master(pdev);
  497.     ioaddr = pci_resource_start (pdev, 0);
  498.     printk(KERN_INFO "    ioaddr=%#08lx  resource_flags=%#08lxn", ioaddr, pci_resource_flags (pdev, 0));
  499.     if (!ioaddr) {
  500.         printk (KERN_ERR "no PCI IO resources, abortingn");
  501.         return -ENODEV;
  502.     }
  504.     if (!pci_dma_supported(pdev, PCNET32_DMA_MASK)) {
  505. printk(KERN_ERR "pcnet32.c: architecture does not support 32bit PCI busmaster DMAn");
  506. return -ENODEV;
  507.     }
  509.     return pcnet32_probe1(ioaddr, pdev->irq, 1, card_idx, pdev);
  510. }
  513. /* pcnet32_probe1 
  514.  *  Called from both pcnet32_probe_vlbus and pcnet_probe_pci.  
  515.  *  pdev will be NULL when called from pcnet32_probe_vlbus.
  516.  */
  517. static int __devinit
  518. pcnet32_probe1(unsigned long ioaddr, unsigned char irq_line, int shared, int card_idx, struct pci_dev *pdev)
  519. {
  520.     struct pcnet32_private *lp;
  521.     struct resource *res;
  522.     dma_addr_t lp_dma_addr;
  523.     int i,media,fdx = 0, mii = 0, fset = 0;
  524. #ifdef DO_DXSUFLO
  525.     int dxsuflo = 0;
  526. #endif
  527.     int ltint = 0;
  528.     int chip_version;
  529.     char *chipname;
  530.     struct net_device *dev;
  531.     struct pcnet32_access *a = NULL;
  533.     /* reset the chip */
  534.     pcnet32_dwio_reset(ioaddr);
  535.     pcnet32_wio_reset(ioaddr);
  537.     /* NOTE: 16-bit check is first, otherwise some older PCnet chips fail */
  538.     if (pcnet32_wio_read_csr (ioaddr, 0) == 4 && pcnet32_wio_check (ioaddr)) {
  539. a = &pcnet32_wio;
  540.     } else {
  541. if (pcnet32_dwio_read_csr (ioaddr, 0) == 4 && pcnet32_dwio_check(ioaddr)) {
  542.     a = &pcnet32_dwio;
  543. } else
  544.     return -ENODEV;
  545.     }
  547.     chip_version = a->read_csr (ioaddr, 88) | (a->read_csr (ioaddr,89) << 16);
  548.     if (pcnet32_debug > 2)
  549. printk(KERN_INFO "  PCnet chip version is %#x.n", chip_version);
  550.     if ((chip_version & 0xfff) != 0x003)
  551. return -ENODEV;
  552.     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 "pcnet32: pcnet32 media value %#x.n",  media);
  595. media &= ~3;
  596. media |= 1;
  597. #endif
  598. if (pcnet32_debug > 2)
  599.     printk(KERN_DEBUG "pcnet32: pcnet32 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 "pcnet32: PCnet version %#x, no PCnet32 chip.n",chip_version);
  608. return -ENODEV;
  609.     }
  611.     /*
  612.      * On selected chips turn on the BCR18:NOUFLO bit. This stops transmit
  613.      * starting until the packet is loaded. Strike one for reliability, lose
  614.      * one for latency - although on PCI this isnt a big loss. Older chips 
  615.      * have FIFO's smaller than a packet, so you can't do this.
  616.      */
  617.  
  618.     if(fset)
  619.     {
  620. a->write_bcr(ioaddr, 18, (a->read_bcr(ioaddr, 18) | 0x0800));
  621. a->write_csr(ioaddr, 80, (a->read_csr(ioaddr, 80) & 0x0C00) | 0x0c00);
  622. #ifdef DO_DXSUFLO
  623. dxsuflo = 1;
  624. #endif
  625. ltint = 1;
  626.     }
  627.     
  628.     dev = init_etherdev(NULL, 0);
  629.     if(dev==NULL)
  630. return -ENOMEM;
  632.     printk(KERN_INFO "%s: %s at %#3lx,", dev->name, chipname, ioaddr);
  634.     /* In most chips, after a chip reset, the ethernet address is read from the
  635.      * station address PROM at the base address and programmed into the
  636.      * "Physical Address Registers" CSR12-14.
  637.      * As a precautionary measure, we read the PROM values and complain if
  638.      * they disagree with the CSRs.  Either way, we use the CSR values, and
  639.      * double check that they are valid.
  640.      */
  641.     for (i = 0; i < 3; i++) {
  642. unsigned int val;
  643. val = a->read_csr(ioaddr, i+12) & 0x0ffff;
  644. /* There may be endianness issues here. */
  645. dev->dev_addr[2*i] = val & 0x0ff;
  646. dev->dev_addr[2*i+1] = (val >> 8) & 0x0ff;
  647.     }
  648.     {
  649. u8 promaddr[6];
  650. for (i = 0; i < 6; i++) {
  651.     promaddr[i] = inb(ioaddr + i);
  652. }
  653. if( memcmp( promaddr, dev->dev_addr, 6) )
  654. {
  655.     printk(" warning PROM address does not match CSR addressn");
  656. #if defined(__i386__)
  657.     printk(KERN_WARNING "%s: Probably a Compaq, using the PROM address of", dev->name);
  658.     memcpy(dev->dev_addr, promaddr, 6);
  659. #elif defined(__powerpc__)
  660.     if (!is_valid_ether_addr(dev->dev_addr)
  661. && is_valid_ether_addr(promaddr)) {
  662.     printk("n" KERN_WARNING "%s: using PROM address:",
  663.    dev->name);
  664.     memcpy(dev->dev_addr, promaddr, 6);
  665.     }
  666. #endif
  667. }          
  668.     }
  669.     /* if the ethernet address is not valid, force to 00:00:00:00:00:00 */
  670.     if( !is_valid_ether_addr(dev->dev_addr) )
  671. for (i = 0; i < 6; i++)
  672.     dev->dev_addr[i]=0;
  674.     for (i = 0; i < 6; i++)
  675. printk(" %2.2x", dev->dev_addr[i] );
  677.     if (((chip_version + 1) & 0xfffe) == 0x2624) { /* Version 0x2623 or 0x2624 */
  678. i = a->read_csr(ioaddr, 80) & 0x0C00;  /* Check tx_start_pt */
  679. printk("n" KERN_INFO "    tx_start_pt(0x%04x):",i);
  680. switch(i>>10) {
  681.     case 0: printk("  20 bytes,"); break;
  682.     case 1: printk("  64 bytes,"); break;
  683.     case 2: printk(" 128 bytes,"); break;
  684.     case 3: printk("~220 bytes,"); break;
  685. }
  686. i = a->read_bcr(ioaddr, 18);  /* Check Burst/Bus control */
  687. printk(" BCR18(%x):",i&0xffff);
  688. if (i & (1<<5)) printk("BurstWrEn ");
  689. if (i & (1<<6)) printk("BurstRdEn ");
  690. if (i & (1<<7)) printk("DWordIO ");
  691. if (i & (1<<11)) printk("NoUFlow ");
  692. i = a->read_bcr(ioaddr, 25);
  693. printk("n" KERN_INFO "    SRAMSIZE=0x%04x,",i<<8);
  694. i = a->read_bcr(ioaddr, 26);
  695. printk(" SRAM_BND=0x%04x,",i<<8);
  696. i = a->read_bcr(ioaddr, 27);
  697. if (i & (1<<14)) printk("LowLatRx");
  698.     }
  700.     dev->base_addr = ioaddr;
  701.     res = request_region(ioaddr, PCNET32_TOTAL_SIZE, chipname);
  702.     if (res == NULL)
  703. return -EBUSY;
  704.     
  705.     /* pci_alloc_consistent returns page-aligned memory, so we do not have to check the alignment */
  706.     if ((lp = pci_alloc_consistent(pdev, sizeof(*lp), &lp_dma_addr)) == NULL) {
  707. release_resource(res);
  708. return -ENOMEM;
  709.     }
  711.     memset(lp, 0, sizeof(*lp));
  712.     lp->dma_addr = lp_dma_addr;
  713.     lp->pci_dev = pdev;
  714.     printk("n" KERN_INFO "pcnet32: pcnet32_private lp=%p lp_dma_addr=%#08x", lp, lp_dma_addr);
  716.     spin_lock_init(&lp->lock);
  717.     
  718.     dev->priv = lp;
  719.     lp->name = chipname;
  720.     lp->shared_irq = shared;
  721.     lp->mii_if.full_duplex = fdx;
  722. #ifdef DO_DXSUFLO
  723.     lp->dxsuflo = dxsuflo;
  724. #endif
  725.     lp->ltint = ltint;
  726.     lp->mii = mii;
  727.     if (options[card_idx] > sizeof (options_mapping))
  728. lp->options = PCNET32_PORT_ASEL;
  729.     else
  730. lp->options = options_mapping[options[card_idx]];
  731.     lp->mii_if.dev = dev;
  732.     lp->mii_if.mdio_read = mdio_read;
  733.     lp->mii_if.mdio_write = mdio_write;
  734.     
  735.     if (fdx && !(lp->options & PCNET32_PORT_ASEL) && full_duplex[card_idx])
  736. lp->options |= PCNET32_PORT_FD;
  737.     
  738.     if (a == NULL) {
  739.       printk(KERN_ERR "pcnet32: No access methodsn");
  740.       pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
  741.       release_resource(res);
  742.       return -ENODEV;
  743.     }
  744.     lp->a = *a;
  745.     
  746.     /* detect special T1/E1 WAN card by checking for MAC address */
  747.     if (dev->dev_addr[0] == 0x00 && dev->dev_addr[1] == 0xe0 && dev->dev_addr[2] == 0x75)
  748. lp->options = PCNET32_PORT_FD | PCNET32_PORT_GPSI;
  750.     lp->init_block.mode = le16_to_cpu(0x0003); /* Disable Rx and Tx. */
  751.     lp->init_block.tlen_rlen = le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS); 
  752.     for (i = 0; i < 6; i++)
  753. lp->init_block.phys_addr[i] = dev->dev_addr[i];
  754.     lp->init_block.filter[0] = 0x00000000;
  755.     lp->init_block.filter[1] = 0x00000000;
  756.     lp->init_block.rx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, rx_ring));
  757.     lp->init_block.tx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, tx_ring));
  758.     
  759.     /* switch pcnet32 to 32bit mode */
  760.     a->write_bcr (ioaddr, 20, 2);
  762.     a->write_csr (ioaddr, 1, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) & 0xffff);
  763.     a->write_csr (ioaddr, 2, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) >> 16);
  764.     
  765.     if (irq_line) {
  766. dev->irq = irq_line;
  767.     }
  768.     
  769.     if (dev->irq >= 2)
  770. printk(" assigned IRQ %d.n", dev->irq);
  771.     else {
  772. unsigned long irq_mask = probe_irq_on();
  774. /*
  775.  * To auto-IRQ we enable the initialization-done and DMA error
  776.  * interrupts. For ISA boards we get a DMA error, but VLB and PCI
  777.  * boards will work.
  778.  */
  779. /* Trigger an initialization just for the interrupt. */
  780. a->write_csr (ioaddr, 0, 0x41);
  781. mdelay (1);
  783. dev->irq = probe_irq_off (irq_mask);
  784. if (dev->irq)
  785.     printk(", probed IRQ %d.n", dev->irq);
  786. else {
  787.     printk(", failed to detect IRQ line.n");
  788.     pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
  789.     release_resource(res);
  790.     return -ENODEV;
  791. }
  792.     }
  794.     if (pcnet32_debug > 0)
  795. printk(KERN_INFO "%s", version);
  796.     
  797.     /* The PCNET32-specific entries in the device structure. */
  798.     dev->open = &pcnet32_open;
  799.     dev->hard_start_xmit = &pcnet32_start_xmit;
  800.     dev->stop = &pcnet32_close;
  801.     dev->get_stats = &pcnet32_get_stats;
  802.     dev->set_multicast_list = &pcnet32_set_multicast_list;
  803.     dev->do_ioctl = &pcnet32_ioctl;
  804.     dev->tx_timeout = pcnet32_tx_timeout;
  805.     dev->watchdog_timeo = (HZ >> 1);
  807.     lp->next = pcnet32_dev;
  808.     pcnet32_dev = dev;
  810.     /* Fill in the generic fields of the device structure. */
  811.     ether_setup(dev);
  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. }
  861. lp->a.write_bcr (ioaddr, 9, val);
  862.     }
  863.     
  864.     /* set/reset GPSI bit in test register */
  865.     val = lp->a.read_csr (ioaddr, 124) & ~0x10;
  866.     if ((lp->options & PCNET32_PORT_PORTSEL) == PCNET32_PORT_GPSI)
  867. val |= 0x10;
  868.     lp->a.write_csr (ioaddr, 124, val);
  869.     
  870.     if (lp->mii && !(lp->options & PCNET32_PORT_ASEL)) {
  871. val = lp->a.read_bcr (ioaddr, 32) & ~0x38; /* disable Auto Negotiation, set 10Mpbs, HD */
  872. if (lp->options & PCNET32_PORT_FD)
  873.     val |= 0x10;
  874. if (lp->options & PCNET32_PORT_100)
  875.     val |= 0x08;
  876. lp->a.write_bcr (ioaddr, 32, val);
  877.     } else {
  878. if (lp->options & PCNET32_PORT_ASEL) {  /* enable auto negotiate, setup, disable fd */
  879. val = lp->a.read_bcr(ioaddr, 32) & ~0x98;
  880. val |= 0x20;
  881. lp->a.write_bcr(ioaddr, 32, val);
  882. }
  883.     }
  885. #ifdef DO_DXSUFLO 
  886.     if (lp->dxsuflo) { /* Disable transmit stop on underflow */
  887. val = lp->a.read_csr (ioaddr, 3);
  888. val |= 0x40;
  889. lp->a.write_csr (ioaddr, 3, val);
  890.     }
  891. #endif
  892.     if (lp->ltint) { /* Enable TxDone-intr inhibitor */
  893. val = lp->a.read_csr (ioaddr, 5);
  894. val |= (1<<14);
  895. lp->a.write_csr (ioaddr, 5, val);
  896.     }
  897.    
  898.     lp->init_block.mode = le16_to_cpu((lp->options & PCNET32_PORT_PORTSEL) << 7);
  899.     lp->init_block.filter[0] = 0x00000000;
  900.     lp->init_block.filter[1] = 0x00000000;
  901.     if (pcnet32_init_ring(dev))
  902. return -ENOMEM;
  903.     
  904.     /* Re-initialize the PCNET32, and start it when done. */
  905.     lp->a.write_csr (ioaddr, 1, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) &0xffff);
  906.     lp->a.write_csr (ioaddr, 2, (lp->dma_addr + offsetof(struct pcnet32_private, init_block)) >> 16);
  908.     lp->a.write_csr (ioaddr, 4, 0x0915);
  909.     lp->a.write_csr (ioaddr, 0, 0x0001);
  911.     netif_start_queue(dev);
  913.     i = 0;
  914.     while (i++ < 100)
  915. if (lp->a.read_csr (ioaddr, 0) & 0x0100)
  916.     break;
  917.     /* 
  918.      * We used to clear the InitDone bit, 0x0100, here but Mark Stockton
  919.      * reports that doing so triggers a bug in the '974.
  920.      */
  921.     lp->a.write_csr (ioaddr, 0, 0x0042);
  923.     if (pcnet32_debug > 2)
  924. printk(KERN_DEBUG "%s: pcnet32 open after %d ticks, init block %#x csr0 %4.4x.n",
  925.        dev->name, i, (u32) (lp->dma_addr + offsetof(struct pcnet32_private, init_block)),
  926.        lp->a.read_csr (ioaddr, 0));
  929.     MOD_INC_USE_COUNT;
  930.     
  931.     return 0; /* Always succeed */
  932. }
  934. /*
  935.  * The LANCE has been halted for one reason or another (busmaster memory
  936.  * arbitration error, Tx FIFO underflow, driver stopped it to reconfigure,
  937.  * etc.).  Modern LANCE variants always reload their ring-buffer
  938.  * configuration when restarted, so we must reinitialize our ring
  939.  * context before restarting.  As part of this reinitialization,
  940.  * find all packets still on the Tx ring and pretend that they had been
  941.  * sent (in effect, drop the packets on the floor) - the higher-level
  942.  * protocols will time out and retransmit.  It'd be better to shuffle
  943.  * these skbs to a temp list and then actually re-Tx them after
  944.  * restarting the chip, but I'm too lazy to do so right now.  dplatt@3do.com
  945.  */
  947. static void 
  948. pcnet32_purge_tx_ring(struct net_device *dev)
  949. {
  950.     struct pcnet32_private *lp = dev->priv;
  951.     int i;
  953.     for (i = 0; i < TX_RING_SIZE; i++) {
  954. if (lp->tx_skbuff[i]) {
  955.             pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[i], lp->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
  956.     dev_kfree_skb(lp->tx_skbuff[i]); 
  957.     lp->tx_skbuff[i] = NULL;
  958.             lp->tx_dma_addr[i] = 0;
  959. }
  960.     }
  961. }
  964. /* Initialize the PCNET32 Rx and Tx rings. */
  965. static int
  966. pcnet32_init_ring(struct net_device *dev)
  967. {
  968.     struct pcnet32_private *lp = dev->priv;
  969.     int i;
  971.     lp->tx_full = 0;
  972.     lp->cur_rx = lp->cur_tx = 0;
  973.     lp->dirty_rx = lp->dirty_tx = 0;
  975.     for (i = 0; i < RX_RING_SIZE; i++) {
  976.         struct sk_buff *rx_skbuff = lp->rx_skbuff[i];
  977. if (rx_skbuff == NULL) {
  978.     if (!(rx_skbuff = lp->rx_skbuff[i] = dev_alloc_skb (PKT_BUF_SZ))) {
  979. /* there is not much, we can do at this point */
  980. printk(KERN_ERR "%s: pcnet32_init_ring dev_alloc_skb failed.n",dev->name);
  981. return -1;
  982.     }
  983.     skb_reserve (rx_skbuff, 2);
  984. }
  985.         lp->rx_dma_addr[i] = pci_map_single(lp->pci_dev, rx_skbuff->tail, rx_skbuff->len, PCI_DMA_FROMDEVICE);
  986. lp->rx_ring[i].base = (u32)le32_to_cpu(lp->rx_dma_addr[i]);
  987. lp->rx_ring[i].buf_length = le16_to_cpu(-PKT_BUF_SZ);
  988. lp->rx_ring[i].status = le16_to_cpu(0x8000);
  989.     }
  990.     /* The Tx buffer address is filled in as needed, but we do need to clear
  991.        the upper ownership bit. */
  992.     for (i = 0; i < TX_RING_SIZE; i++) {
  993. lp->tx_ring[i].base = 0;
  994. lp->tx_ring[i].status = 0;
  995.         lp->tx_dma_addr[i] = 0;
  996.     }
  998.     lp->init_block.tlen_rlen = le16_to_cpu(TX_RING_LEN_BITS | RX_RING_LEN_BITS);
  999.     for (i = 0; i < 6; i++)
  1000. lp->init_block.phys_addr[i] = dev->dev_addr[i];
  1001.     lp->init_block.rx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, rx_ring));
  1002.     lp->init_block.tx_ring = (u32)le32_to_cpu(lp->dma_addr + offsetof(struct pcnet32_private, tx_ring));
  1003.     return 0;
  1004. }
  1006. static void
  1007. pcnet32_restart(struct net_device *dev, unsigned int csr0_bits)
  1008. {
  1009.     struct pcnet32_private *lp = dev->priv;
  1010.     unsigned long ioaddr = dev->base_addr;
  1011.     int i;
  1012.     
  1013.     pcnet32_purge_tx_ring(dev);
  1014.     if (pcnet32_init_ring(dev))
  1015. return;
  1016.     
  1017.     /* ReInit Ring */
  1018.     lp->a.write_csr (ioaddr, 0, 1);
  1019.     i = 0;
  1020.     while (i++ < 100)
  1021. if (lp->a.read_csr (ioaddr, 0) & 0x0100)
  1022.     break;
  1024.     lp->a.write_csr (ioaddr, 0, csr0_bits);
  1025. }
  1028. static void
  1029. pcnet32_tx_timeout (struct net_device *dev)
  1030. {
  1031.     struct pcnet32_private *lp = dev->priv;
  1032.     unsigned int ioaddr = dev->base_addr;
  1034.     /* Transmitter timeout, serious problems. */
  1035. printk(KERN_ERR "%s: transmit timed out, status %4.4x, resetting.n",
  1036.        dev->name, lp->a.read_csr (ioaddr, 0));
  1037. lp->a.write_csr (ioaddr, 0, 0x0004);
  1038. lp->stats.tx_errors++;
  1039. if (pcnet32_debug > 2) {
  1040.     int i;
  1041.     printk(KERN_DEBUG " Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
  1042.        lp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
  1043.        lp->cur_rx);
  1044.     for (i = 0 ; i < RX_RING_SIZE; i++)
  1045.     printk("%s %08x %04x %08x %04x", i & 1 ? "" : "n ",
  1046.    lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
  1047.    lp->rx_ring[i].msg_length, (unsigned)lp->rx_ring[i].status);
  1048.     for (i = 0 ; i < TX_RING_SIZE; i++)
  1049.     printk("%s %08x %04x %08x %04x", i & 1 ? "" : "n ",
  1050.    lp->tx_ring[i].base, -lp->tx_ring[i].length,
  1051.    lp->tx_ring[i].misc, (unsigned)lp->tx_ring[i].status);
  1052.     printk("n");
  1053. }
  1054. pcnet32_restart(dev, 0x0042);
  1056. dev->trans_start = jiffies;
  1057. netif_start_queue(dev);
  1058. }
  1061. static int
  1062. pcnet32_start_xmit(struct sk_buff *skb, struct net_device *dev)
  1063. {
  1064.     struct pcnet32_private *lp = dev->priv;
  1065.     unsigned int ioaddr = dev->base_addr;
  1066.     u16 status;
  1067.     int entry;
  1068.     unsigned long flags;
  1070.     if (pcnet32_debug > 3) {
  1071. printk(KERN_DEBUG "%s: pcnet32_start_xmit() called, csr0 %4.4x.n",
  1072.        dev->name, lp->a.read_csr (ioaddr, 0));
  1073.     }
  1075.     spin_lock_irqsave(&lp->lock, flags);
  1077.     /* Default status -- will not enable Successful-TxDone
  1078.      * interrupt when that option is available to us.
  1079.      */
  1080.     status = 0x8300;
  1081.     if ((lp->ltint) &&
  1082. ((lp->cur_tx - lp->dirty_tx == TX_RING_SIZE/2) ||
  1083.  (lp->cur_tx - lp->dirty_tx >= TX_RING_SIZE-2)))
  1084.     {
  1085. /* Enable Successful-TxDone interrupt if we have
  1086.  * 1/2 of, or nearly all of, our ring buffer Tx'd
  1087.  * but not yet cleaned up.  Thus, most of the time,
  1088.  * we will not enable Successful-TxDone interrupts.
  1089.  */
  1090. status = 0x9300;
  1091.     }
  1092.   
  1093.     /* Fill in a Tx ring entry */
  1094.   
  1095.     /* Mask to ring buffer boundary. */
  1096.     entry = lp->cur_tx & TX_RING_MOD_MASK;
  1097.   
  1098.     /* Caution: the write order is important here, set the base address
  1099.        with the "ownership" bits last. */
  1101.     lp->tx_ring[entry].length = le16_to_cpu(-skb->len);
  1103.     lp->tx_ring[entry].misc = 0x00000000;
  1105.     lp->tx_skbuff[entry] = skb;
  1106.     lp->tx_dma_addr[entry] = pci_map_single(lp->pci_dev, skb->data, skb->len, PCI_DMA_TODEVICE);
  1107.     lp->tx_ring[entry].base = (u32)le32_to_cpu(lp->tx_dma_addr[entry]);
  1108.     lp->tx_ring[entry].status = le16_to_cpu(status);
  1110.     lp->cur_tx++;
  1111.     lp->stats.tx_bytes += skb->len;
  1113.     /* Trigger an immediate send poll. */
  1114.     lp->a.write_csr (ioaddr, 0, 0x0048);
  1116.     dev->trans_start = jiffies;
  1118.     if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
  1119. netif_start_queue(dev);
  1120.     else {
  1121. lp->tx_full = 1;
  1122. netif_stop_queue(dev);
  1123.     }
  1124.     spin_unlock_irqrestore(&lp->lock, flags);
  1125.     return 0;
  1126. }
  1128. /* The PCNET32 interrupt handler. */
  1129. static void
  1130. pcnet32_interrupt(int irq, void *dev_id, struct pt_regs * regs)
  1131. {
  1132.     struct net_device *dev = dev_id;
  1133.     struct pcnet32_private *lp;
  1134.     unsigned long ioaddr;
  1135.     u16 csr0,rap;
  1136.     int boguscnt =  max_interrupt_work;
  1137.     int must_restart;
  1139.     if (dev == NULL) {
  1140. printk (KERN_DEBUG "pcnet32_interrupt(): irq %d for unknown device.n", irq);
  1141. return;
  1142.     }
  1144.     ioaddr = dev->base_addr;
  1145.     lp = dev->priv;
  1146.     
  1147.     spin_lock(&lp->lock);
  1148.     
  1149.     rap = lp->a.read_rap(ioaddr);
  1150.     while ((csr0 = lp->a.read_csr (ioaddr, 0)) & 0x8600 && --boguscnt >= 0) {
  1151. /* Acknowledge all of the current interrupt sources ASAP. */
  1152. lp->a.write_csr (ioaddr, 0, csr0 & ~0x004f);
  1154. must_restart = 0;
  1156. if (pcnet32_debug > 5)
  1157.     printk(KERN_DEBUG "%s: interrupt  csr0=%#2.2x new csr=%#2.2x.n",
  1158.    dev->name, csr0, lp->a.read_csr (ioaddr, 0));
  1160. if (csr0 & 0x0400) /* Rx interrupt */
  1161.     pcnet32_rx(dev);
  1163. if (csr0 & 0x0200) { /* Tx-done interrupt */
  1164.     unsigned int dirty_tx = lp->dirty_tx;
  1166.     while (dirty_tx < lp->cur_tx) {
  1167. int entry = dirty_tx & TX_RING_MOD_MASK;
  1168. int status = (short)le16_to_cpu(lp->tx_ring[entry].status);
  1170. if (status < 0)
  1171.     break; /* It still hasn't been Txed */
  1173. lp->tx_ring[entry].base = 0;
  1175. if (status & 0x4000) {
  1176.     /* There was an major error, log it. */
  1177.     int err_status = le32_to_cpu(lp->tx_ring[entry].misc);
  1178.     lp->stats.tx_errors++;
  1179.     if (err_status & 0x04000000) lp->stats.tx_aborted_errors++;
  1180.     if (err_status & 0x08000000) lp->stats.tx_carrier_errors++;
  1181.     if (err_status & 0x10000000) lp->stats.tx_window_errors++;
  1182. #ifndef DO_DXSUFLO
  1183.     if (err_status & 0x40000000) {
  1184. lp->stats.tx_fifo_errors++;
  1185. /* Ackk!  On FIFO errors the Tx unit is turned off! */
  1186. /* Remove this verbosity later! */
  1187. printk(KERN_ERR "%s: Tx FIFO error! CSR0=%4.4xn",
  1188.        dev->name, csr0);
  1189. must_restart = 1;
  1190.     }
  1191. #else
  1192.     if (err_status & 0x40000000) {
  1193. lp->stats.tx_fifo_errors++;
  1194. if (! lp->dxsuflo) {  /* If controller doesn't recover ... */
  1195.     /* Ackk!  On FIFO errors the Tx unit is turned off! */
  1196.     /* Remove this verbosity later! */
  1197.     printk(KERN_ERR "%s: Tx FIFO error! CSR0=%4.4xn",
  1198.    dev->name, csr0);
  1199.     must_restart = 1;
  1200. }
  1201.     }
  1202. #endif
  1203. } else {
  1204.     if (status & 0x1800)
  1205. lp->stats.collisions++;
  1206.     lp->stats.tx_packets++;
  1207. }
  1209. /* We must free the original skb */
  1210. if (lp->tx_skbuff[entry]) {
  1211.                     pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[entry], lp->tx_skbuff[entry]->len, PCI_DMA_TODEVICE);
  1212.     dev_kfree_skb_irq(lp->tx_skbuff[entry]);
  1213.     lp->tx_skbuff[entry] = 0;
  1214.                     lp->tx_dma_addr[entry] = 0;
  1215. }
  1216. dirty_tx++;
  1217.     }
  1219. #ifndef final_version
  1220.     if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
  1221. printk(KERN_ERR "out-of-sync dirty pointer, %d vs. %d, full=%d.n",
  1222.        dirty_tx, lp->cur_tx, lp->tx_full);
  1223. dirty_tx += TX_RING_SIZE;
  1224.     }
  1225. #endif
  1226.     if (lp->tx_full &&
  1227. netif_queue_stopped(dev) &&
  1228. dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
  1229. /* The ring is no longer full, clear tbusy. */
  1230. lp->tx_full = 0;
  1231. netif_wake_queue (dev);
  1232.     }
  1233.     lp->dirty_tx = dirty_tx;
  1234. }
  1236. /* Log misc errors. */
  1237. if (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
  1238. if (csr0 & 0x1000) {
  1239.     /*
  1240.      * this happens when our receive ring is full. This shouldn't
  1241.      * be a problem as we will see normal rx interrupts for the frames
  1242.      * in the receive ring. But there are some PCI chipsets (I can reproduce
  1243.      * this on SP3G with Intel saturn chipset) which have sometimes problems
  1244.      * and will fill up the receive ring with error descriptors. In this
  1245.      * situation we don't get a rx interrupt, but a missed frame interrupt sooner
  1246.      * or later. So we try to clean up our receive ring here.
  1247.      */
  1248.     pcnet32_rx(dev);
  1249.     lp->stats.rx_errors++; /* Missed a Rx frame. */
  1250. }
  1251. if (csr0 & 0x0800) {
  1252.     printk(KERN_ERR "%s: Bus master arbitration failure, status %4.4x.n",
  1253.    dev->name, csr0);
  1254.     /* unlike for the lance, there is no restart needed */
  1255. }
  1257. if (must_restart) {
  1258.     /* stop the chip to clear the error condition, then restart */
  1259.     lp->a.write_csr (ioaddr, 0, 0x0004);
  1260.     pcnet32_restart(dev, 0x0002);
  1261. }
  1262.     }
  1264.     /* Clear any other interrupt, and set interrupt enable. */
  1265.     lp->a.write_csr (ioaddr, 0, 0x7940);
  1266.     lp->a.write_rap(ioaddr,rap);
  1267.     
  1268.     if (pcnet32_debug > 4)
  1269. printk(KERN_DEBUG "%s: exiting interrupt, csr0=%#4.4x.n",
  1270.        dev->name, lp->a.read_csr (ioaddr, 0));
  1272.     spin_unlock(&lp->lock);
  1273. }
  1275. static int
  1276. pcnet32_rx(struct net_device *dev)
  1277. {
  1278.     struct pcnet32_private *lp = dev->priv;
  1279.     int entry = lp->cur_rx & RX_RING_MOD_MASK;
  1281.     /* If we own the next entry, it's a new packet. Send it up. */
  1282.     while ((short)le16_to_cpu(lp->rx_ring[entry].status) >= 0) {
  1283. int status = (short)le16_to_cpu(lp->rx_ring[entry].status) >> 8;
  1285. if (status != 0x03) { /* There was an error. */
  1286.     /* 
  1287.      * There is a tricky error noted by John Murphy,
  1288.      * <murf@perftech.com> to Russ Nelson: Even with full-sized
  1289.      * buffers it's possible for a jabber packet to use two
  1290.      * buffers, with only the last correctly noting the error.
  1291.      */
  1292.     if (status & 0x01) /* Only count a general error at the */
  1293. lp->stats.rx_errors++; /* end of a packet.*/
  1294.     if (status & 0x20) lp->stats.rx_frame_errors++;
  1295.     if (status & 0x10) lp->stats.rx_over_errors++;
  1296.     if (status & 0x08) lp->stats.rx_crc_errors++;
  1297.     if (status & 0x04) lp->stats.rx_fifo_errors++;
  1298.     lp->rx_ring[entry].status &= le16_to_cpu(0x03ff);
  1299. } else {
  1300.     /* Malloc up new buffer, compatible with net-2e. */
  1301.     short pkt_len = (le32_to_cpu(lp->rx_ring[entry].msg_length) & 0xfff)-4;
  1302.     struct sk_buff *skb;
  1304.     if(pkt_len < 60) {
  1305. printk(KERN_ERR "%s: Runt packet!n",dev->name);
  1306. lp->stats.rx_errors++;
  1307.     } else {
  1308. int rx_in_place = 0;
  1310. if (pkt_len > rx_copybreak) {
  1311.     struct sk_buff *newskb;
  1313.     if ((newskb = dev_alloc_skb (PKT_BUF_SZ))) {
  1314. skb_reserve (newskb, 2);
  1315. skb = lp->rx_skbuff[entry];
  1316. skb_put (skb, pkt_len);
  1317. lp->rx_skbuff[entry] = newskb;
  1318. newskb->dev = dev;
  1319.                         lp->rx_dma_addr[entry] = pci_map_single(lp->pci_dev, newskb->tail, newskb->len, PCI_DMA_FROMDEVICE);
  1320. lp->rx_ring[entry].base = le32_to_cpu(lp->rx_dma_addr[entry]);
  1321. rx_in_place = 1;
  1322.     } else
  1323. skb = NULL;
  1324. } else {
  1325.     skb = dev_alloc_skb(pkt_len+2);
  1326.                 }
  1327.     
  1328. if (skb == NULL) {
  1329.                     int i;
  1330.     printk(KERN_ERR "%s: Memory squeeze, deferring packet.n", dev->name);
  1331.     for (i = 0; i < RX_RING_SIZE; i++)
  1332. if ((short)le16_to_cpu(lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].status) < 0)
  1333.     break;
  1335.     if (i > RX_RING_SIZE -2) {
  1336. lp->stats.rx_dropped++;
  1337. lp->rx_ring[entry].status |= le16_to_cpu(0x8000);
  1338. lp->cur_rx++;
  1339.     }
  1340.     break;
  1341. }
  1342. skb->dev = dev;
  1343. if (!rx_in_place) {
  1344.     skb_reserve(skb,2); /* 16 byte align */
  1345.     skb_put(skb,pkt_len); /* Make room */
  1346.     eth_copy_and_sum(skb,
  1347.      (unsigned char *)(lp->rx_skbuff[entry]->tail),
  1348.      pkt_len,0);
  1349. }
  1350. lp->stats.rx_bytes += skb->len;
  1351. skb->protocol=eth_type_trans(skb,dev);
  1352. netif_rx(skb);
  1353. lp->stats.rx_packets++;
  1354.     }
  1355. }
  1356. /*
  1357.  * The docs say that the buffer length isn't touched, but Andrew Boyd
  1358.  * of QNX reports that some revs of the 79C965 clear it.
  1359.  */
  1360. lp->rx_ring[entry].buf_length = le16_to_cpu(-PKT_BUF_SZ);
  1361. lp->rx_ring[entry].status |= le16_to_cpu(0x8000);
  1362. entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
  1363.     }
  1365.     return 0;
  1366. }
  1368. static int
  1369. pcnet32_close(struct net_device *dev)
  1370. {
  1371.     unsigned long ioaddr = dev->base_addr;
  1372.     struct pcnet32_private *lp = dev->priv;
  1373.     int i;
  1375.     netif_stop_queue(dev);
  1377.     lp->stats.rx_missed_errors = lp->a.read_csr (ioaddr, 112);
  1379.     if (pcnet32_debug > 1)
  1380. printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.n",
  1381.        dev->name, lp->a.read_csr (ioaddr, 0));
  1383.     /* We stop the PCNET32 here -- it occasionally polls memory if we don't. */
  1384.     lp->a.write_csr (ioaddr, 0, 0x0004);
  1386.     /*
  1387.      * Switch back to 16bit mode to avoid problems with dumb 
  1388.      * DOS packet driver after a warm reboot
  1389.      */
  1390.     lp->a.write_bcr (ioaddr, 20, 4);
  1392.     free_irq(dev->irq, dev);
  1393.     
  1394.     /* free all allocated skbuffs */
  1395.     for (i = 0; i < RX_RING_SIZE; i++) {
  1396. lp->rx_ring[i].status = 0;     
  1397. if (lp->rx_skbuff[i]) {
  1398.             pci_unmap_single(lp->pci_dev, lp->rx_dma_addr[i], lp->rx_skbuff[i]->len, PCI_DMA_FROMDEVICE);
  1399.     dev_kfree_skb(lp->rx_skbuff[i]);
  1400.         }
  1401. lp->rx_skbuff[i] = NULL;
  1402.         lp->rx_dma_addr[i] = 0;
  1403.     }
  1404.     
  1405.     for (i = 0; i < TX_RING_SIZE; i++) {
  1406. if (lp->tx_skbuff[i]) {
  1407.             pci_unmap_single(lp->pci_dev, lp->tx_dma_addr[i], lp->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
  1408.     dev_kfree_skb(lp->tx_skbuff[i]);
  1409.         }
  1410. lp->tx_skbuff[i] = NULL;
  1411.         lp->tx_dma_addr[i] = 0;
  1412.     }
  1413.     
  1414.     MOD_DEC_USE_COUNT;
  1416.     return 0;
  1417. }
  1419. static struct net_device_stats *
  1420. pcnet32_get_stats(struct net_device *dev)
  1421. {
  1422.     struct pcnet32_private *lp = dev->priv;
  1423.     unsigned long ioaddr = dev->base_addr;
  1424.     u16 saved_addr;
  1425.     unsigned long flags;
  1427.     spin_lock_irqsave(&lp->lock, flags);
  1428.     saved_addr = lp->a.read_rap(ioaddr);
  1429.     lp->stats.rx_missed_errors = lp->a.read_csr (ioaddr, 112);
  1430.     lp->a.write_rap(ioaddr, saved_addr);
  1431.     spin_unlock_irqrestore(&lp->lock, flags);
  1433.     return &lp->stats;
  1434. }
  1436. /* taken from the sunlance driver, which it took from the depca driver */
  1437. static void pcnet32_load_multicast (struct net_device *dev)
  1438. {
  1439.     struct pcnet32_private *lp = dev->priv;
  1440.     volatile struct pcnet32_init_block *ib = &lp->init_block;
  1441.     volatile u16 *mcast_table = (u16 *)&ib->filter;
  1442.     struct dev_mc_list *dmi=dev->mc_list;
  1443.     char *addrs;
  1444.     int i, j, bit, byte;
  1445.     u32 crc, poly = CRC_POLYNOMIAL_LE;
  1447.     /* set all multicast bits */
  1448.     if (dev->flags & IFF_ALLMULTI){ 
  1449. ib->filter [0] = 0xffffffff;
  1450. ib->filter [1] = 0xffffffff;
  1451. return;
  1452.     }
  1453.     /* clear the multicast filter */
  1454.     ib->filter [0] = 0;
  1455.     ib->filter [1] = 0;
  1457.     /* Add addresses */
  1458.     for (i = 0; i < dev->mc_count; i++){
  1459. addrs = dmi->dmi_addr;
  1460. dmi   = dmi->next;
  1462. /* multicast address? */
  1463. if (!(*addrs & 1))
  1464.     continue;
  1466. crc = 0xffffffff;
  1467. for (byte = 0; byte < 6; byte++)
  1468.     for (bit = *addrs++, j = 0; j < 8; j++, bit >>= 1) {
  1469. int test;
  1471. test = ((bit ^ crc) & 0x01);
  1472. crc >>= 1;
  1474. if (test) {
  1475.     crc = crc ^ poly;
  1476. }
  1477.     }
  1479. crc = crc >> 26;
  1480. mcast_table [crc >> 4] |= 1 << (crc & 0xf);
  1481.     }
  1482.     return;
  1483. }
  1486. /*
  1487.  * Set or clear the multicast filter for this adaptor.
  1488.  */
  1489. static void pcnet32_set_multicast_list(struct net_device *dev)
  1490. {
  1491.     unsigned long ioaddr = dev->base_addr;
  1492.     struct pcnet32_private *lp = dev->priv;  
  1494.     if (dev->flags&IFF_PROMISC) {
  1495. /* Log any net taps. */
  1496. printk(KERN_INFO "%s: Promiscuous mode enabled.n", dev->name);
  1497. lp->init_block.mode = le16_to_cpu(0x8000 | (lp->options & PCNET32_PORT_PORTSEL) << 7);
  1498.     } else {
  1499. lp->init_block.mode = le16_to_cpu((lp->options & PCNET32_PORT_PORTSEL) << 7);
  1500. pcnet32_load_multicast (dev);
  1501.     }
  1502.     
  1503.     lp->a.write_csr (ioaddr, 0, 0x0004); /* Temporarily stop the lance. */
  1505.     pcnet32_restart(dev, 0x0042); /*  Resume normal operation */
  1506. }
  1508. static int mdio_read(struct net_device *dev, int phy_id, int reg_num)
  1509. {
  1510. struct pcnet32_private *lp = dev->priv;
  1511. unsigned long ioaddr = dev->base_addr;
  1512. u16 val_out;
  1513. int phyaddr;
  1515. if (!lp->mii)
  1516. return 0;
  1518. phyaddr = lp->a.read_bcr(ioaddr, 33);
  1520. lp->a.write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) | (reg_num & 0x1f));
  1521. val_out = lp->a.read_bcr(ioaddr, 34);
  1522. lp->a.write_bcr(ioaddr, 33, phyaddr);
  1524. return val_out;
  1525. }
  1527. static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val)
  1528. {
  1529. struct pcnet32_private *lp = dev->priv;
  1530. unsigned long ioaddr = dev->base_addr;
  1531. int phyaddr;
  1533. if (!lp->mii)
  1534. return;
  1536. phyaddr = lp->a.read_bcr(ioaddr, 33);
  1538. lp->a.write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) | (reg_num & 0x1f));
  1539. lp->a.write_bcr(ioaddr, 34, val);
  1540. lp->a.write_bcr(ioaddr, 33, phyaddr);
  1541. }
  1543. static int pcnet32_ethtool_ioctl (struct net_device *dev, void *useraddr)
  1544. {
  1545. struct pcnet32_private *lp = dev->priv;
  1546. u32 ethcmd;
  1547. int phyaddr = 0;
  1548. int phy_id = 0;
  1549. unsigned long ioaddr = dev->base_addr;
  1551. if (lp->mii) {
  1552. phyaddr = lp->a.read_bcr (ioaddr, 33);
  1553. phy_id = (phyaddr >> 5) & 0x1f;
  1554. lp->mii_if.phy_id = phy_id;
  1555. }
  1557. if (copy_from_user (&ethcmd, useraddr, sizeof (ethcmd)))
  1558. return -EFAULT;
  1560. switch (ethcmd) {
  1561. case ETHTOOL_GDRVINFO: {
  1562. struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
  1563. strcpy (info.driver, DRV_NAME);
  1564. strcpy (info.version, DRV_VERSION);
  1565. if (lp->pci_dev)
  1566. strcpy (info.bus_info, lp->pci_dev->slot_name);
  1567. else
  1568. sprintf(info.bus_info, "VLB 0x%lx", dev->base_addr);
  1569. if (copy_to_user (useraddr, &info, sizeof (info)))
  1570. return -EFAULT;
  1571. return 0;
  1572. }
  1574. /* get settings */
  1575. case ETHTOOL_GSET: {
  1576. struct ethtool_cmd ecmd = { ETHTOOL_GSET };
  1577. spin_lock_irq(&lp->lock);
  1578. mii_ethtool_gset(&lp->mii_if, &ecmd);
  1579. spin_unlock_irq(&lp->lock);
  1580. if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
  1581. return -EFAULT;
  1582. return 0;
  1583. }
  1584. /* set settings */
  1585. case ETHTOOL_SSET: {
  1586. int r;
  1587. struct ethtool_cmd ecmd;
  1588. if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
  1589. return -EFAULT;
  1590. spin_lock_irq(&lp->lock);
  1591. r = mii_ethtool_sset(&lp->mii_if, &ecmd);
  1592. spin_unlock_irq(&lp->lock);
  1593. return r;
  1594. }
  1595. /* restart autonegotiation */
  1596. case ETHTOOL_NWAY_RST: {
  1597. return mii_nway_restart(&lp->mii_if);
  1598. }
  1599. /* get link status */
  1600. case ETHTOOL_GLINK: {
  1601. struct ethtool_value edata = {ETHTOOL_GLINK};
  1602. edata.data = mii_link_ok(&lp->mii_if);
  1603. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1604. return -EFAULT;
  1605. return 0;
  1606. }
  1608. /* get message-level */
  1609. case ETHTOOL_GMSGLVL: {
  1610. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1611. edata.data = pcnet32_debug;
  1612. if (copy_to_user(useraddr, &edata, sizeof(edata)))
  1613. return -EFAULT;
  1614. return 0;
  1615. }
  1616. /* set message-level */
  1617. case ETHTOOL_SMSGLVL: {
  1618. struct ethtool_value edata;
  1619. if (copy_from_user(&edata, useraddr, sizeof(edata)))
  1620. return -EFAULT;
  1621. pcnet32_debug = edata.data;
  1622. return 0;
  1623. }
  1624. default:
  1625. break;
  1626. }
  1628. return -EOPNOTSUPP;
  1629. }
  1631. static int pcnet32_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  1632. {
  1633.     unsigned long ioaddr = dev->base_addr;
  1634.     struct pcnet32_private *lp = dev->priv;  
  1635.     struct mii_ioctl_data *data = (struct mii_ioctl_data *)&rq->ifr_data;
  1636.     int phyaddr = lp->a.read_bcr (ioaddr, 33);
  1638.     if (cmd == SIOCETHTOOL)
  1639. return pcnet32_ethtool_ioctl(dev, (void *) rq->ifr_data);
  1641.     if (lp->mii) {
  1642. switch(cmd) {
  1643. case SIOCGMIIPHY: /* Get address of MII PHY in use. */
  1644. case SIOCDEVPRIVATE: /* for binary compat, remove in 2.5 */
  1645.     data->phy_id = (phyaddr >> 5) & 0x1f;
  1646.     /* Fall Through */
  1647. case SIOCGMIIREG: /* Read MII PHY register. */
  1648. case SIOCDEVPRIVATE+1: /* for binary compat, remove in 2.5 */
  1649.     lp->a.write_bcr (ioaddr, 33, ((data->phy_id & 0x1f) << 5) | (data->reg_num & 0x1f));
  1650.     data->val_out = lp->a.read_bcr (ioaddr, 34);
  1651.     lp->a.write_bcr (ioaddr, 33, phyaddr);
  1652.     return 0;
  1653. case SIOCSMIIREG: /* Write MII PHY register. */
  1654. case SIOCDEVPRIVATE+2: /* for binary compat, remove in 2.5 */
  1655.     if (!capable(CAP_NET_ADMIN))
  1656. return -EPERM;
  1657.     lp->a.write_bcr (ioaddr, 33, ((data->phy_id & 0x1f) << 5) | (data->reg_num & 0x1f));
  1658.     lp->a.write_bcr (ioaddr, 34, data->val_in);
  1659.     lp->a.write_bcr (ioaddr, 33, phyaddr);
  1660.     return 0;
  1661. default:
  1662.     return -EOPNOTSUPP;
  1663. }
  1664.     }
  1665.     return -EOPNOTSUPP;
  1666. }
  1667.     
  1668. static struct pci_driver pcnet32_driver = {
  1669. name: DRV_NAME,
  1670. probe: pcnet32_probe_pci,
  1671. remove: NULL,
  1672. id_table: pcnet32_pci_tbl,
  1673. };
  1675. MODULE_PARM(debug, "i");
  1676. MODULE_PARM(max_interrupt_work, "i");
  1677. MODULE_PARM(rx_copybreak, "i");
  1678. MODULE_PARM(tx_start_pt, "i");
  1679. MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
  1680. MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");
  1681. MODULE_AUTHOR("Thomas Bogendoerfer");
  1682. MODULE_DESCRIPTION("Driver for PCnet32 and PCnetPCI based ethercards");
  1683. MODULE_LICENSE("GPL");
  1685. /* An additional parameter that may be passed in... */
  1686. static int debug = -1;
  1687. static int tx_start_pt = -1;
  1689. static int __init pcnet32_init_module(void)
  1690. {
  1691.     int cards_found = 0;
  1692.     int err;
  1694.     if (debug > 0)
  1695. pcnet32_debug = debug;
  1696.     if ((tx_start_pt >= 0) && (tx_start_pt <= 3))
  1697. tx_start = tx_start_pt;
  1698.     
  1699.     pcnet32_dev = NULL;
  1700.     /* find the PCI devices */
  1701. #define USE_PCI_REGISTER_DRIVER
  1702. #ifdef USE_PCI_REGISTER_DRIVER
  1703.     if ((err = pci_module_init(&pcnet32_driver)) < 0 )
  1704.        return err;
  1705. #else
  1706.     {
  1707.         struct pci_device_id *devid = pcnet32_pci_tbl;
  1708.         for (devid = pcnet32_pci_tbl; devid != NULL && devid->vendor != 0; devid++) {
  1709.             struct pci_dev *pdev = pci_find_subsys(devid->vendor, devid->device, devid->subvendor, devid->subdevice, NULL);
  1710.             if (pdev != NULL) {
  1711.                 if (pcnet32_probe_pci(pdev, devid) >= 0) {
  1712.                     cards_found++;
  1713.                 }
  1714.             }
  1715.         }
  1716.     }
  1717. #endif
  1718.     return 0;
  1719.     /* find any remaining VLbus devices */
  1720.     return pcnet32_probe_vlbus(cards_found);
  1721. }
  1723. static void __exit pcnet32_cleanup_module(void)
  1724. {
  1725.     struct net_device *next_dev;
  1727.     /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
  1728.     while (pcnet32_dev) {
  1729.         struct pcnet32_private *lp = pcnet32_dev->priv;
  1730. next_dev = lp->next;
  1731. unregister_netdev(pcnet32_dev);
  1732. release_region(pcnet32_dev->base_addr, PCNET32_TOTAL_SIZE);
  1733. if (lp->pci_dev != NULL)
  1734.     pci_unregister_driver(&pcnet32_driver);
  1735.         pci_free_consistent(lp->pci_dev, sizeof(*lp), lp, lp->dma_addr);
  1736. kfree(pcnet32_dev);
  1737. pcnet32_dev = next_dev;
  1738.     }
  1739. }
  1741. module_init(pcnet32_init_module);
  1742. module_exit(pcnet32_cleanup_module);
  1744. /*
  1745.  * Local variables:
  1746.  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c pcnet32.c"
  1747.  *  c-indent-level: 4
  1748.  *  tab-width: 8
  1749.  * End:
  1750.  */