Changeset 10453


Ignore:
Timestamp:
2008-02-13T15:35:18+01:00 (9 years ago)
Author:
florian
Message:

Upgrade rdc to 2.6.24

Location:
trunk/target/linux/rdc
Files:
1 deleted
5 edited
6 copied
2 moved

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/rdc/Makefile

    r10443 r10453  
    1212FEATURES:=squashfs jffs2 pci 
    1313 
    14 LINUX_VERSION:=2.6.23.16 
     14LINUX_VERSION:=2.6.24.2 
    1515 
    1616include $(INCLUDE_DIR)/target.mk 
  • trunk/target/linux/rdc/config-2.6.24

    r10438 r10453  
    11# CONFIG_60XX_WDT is not set 
     2# CONFIG_64BIT is not set 
    23# CONFIG_8139TOO is not set 
    34# CONFIG_ACQUIRE_WDT is not set 
     
    1112CONFIG_ARCH_POPULATES_NODE_MAP=y 
    1213# CONFIG_ARCH_SUPPORTS_MSI is not set 
     14CONFIG_ARCH_SUPPORTS_OPROFILE=y 
    1315CONFIG_ATA=m 
    1416# CONFIG_ATA_NONSTANDARD is not set 
    1517CONFIG_ATA_PIIX=m 
     18# CONFIG_AUDIT_ARCH is not set 
    1619CONFIG_BASE_SMALL=0 
    1720CONFIG_BINFMT_AOUT=m 
    1821CONFIG_BINFMT_MISC=m 
    1922CONFIG_BITREVERSE=y 
    20 # CONFIG_BLK_DEV_HD is not set 
    21 # CONFIG_BLK_DEV_HD_IDE is not set 
    2223CONFIG_BLK_DEV_IDE=m 
    2324CONFIG_BLK_DEV_IDEDISK=m 
    2425# CONFIG_BLK_DEV_IDEDMA is not set 
     26# CONFIG_BLK_DEV_PLATFORM is not set 
    2527CONFIG_BOUNCE=y 
    2628# CONFIG_BROADCOM_PHY is not set 
     29# CONFIG_BT_HCIUART_LL is not set 
    2730CONFIG_CLOCKSOURCE_WATCHDOG=y 
    2831# CONFIG_COMPAT_VDSO is not set 
    2932# CONFIG_CPU5_WDT is not set 
    3033# CONFIG_CPU_FREQ is not set 
     34# CONFIG_CPU_IDLE is not set 
    3135CONFIG_CRYPTO_AES_586=m 
    3236# CONFIG_CRYPTO_HW is not set 
     
    4044# CONFIG_DELL_RBU is not set 
    4145CONFIG_DEVPORT=y 
     46# CONFIG_DMADEVICES is not set 
    4247CONFIG_DMI=y 
    4348CONFIG_DMIID=y 
     
    5358CONFIG_GENERIC_BUG=y 
    5459CONFIG_GENERIC_CLOCKEVENTS=y 
     60CONFIG_GENERIC_CLOCKEVENTS_BUILD=y 
    5561CONFIG_GENERIC_CMOS_UPDATE=y 
     62# CONFIG_GENERIC_CPU is not set 
    5663CONFIG_GENERIC_GPIO=y 
    5764CONFIG_GENERIC_IOMAP=y 
    5865CONFIG_GENERIC_ISA_DMA=y 
     66# CONFIG_GENERIC_TIME_VSYSCALL is not set 
    5967# CONFIG_GEN_RTC is not set 
    6068# CONFIG_HANGCHECK_TIMER is not set 
     
    6472CONFIG_HIBERNATION_UP_POSSIBLE=y 
    6573CONFIG_HID=m 
     74# CONFIG_HIDRAW is not set 
    6675CONFIG_HID_SUPPORT=y 
    6776# CONFIG_HIGHMEM4G is not set 
     
    8796# CONFIG_IBMASR is not set 
    8897# CONFIG_IBM_ASM is not set 
     98# CONFIG_IBM_NEW_EMAC_EMAC4 is not set 
     99# CONFIG_IBM_NEW_EMAC_RGMII is not set 
     100# CONFIG_IBM_NEW_EMAC_TAH is not set 
     101# CONFIG_IBM_NEW_EMAC_ZMII is not set 
    89102CONFIG_ICPLUS_PHY=y 
    90103CONFIG_IDE=m 
    91104# CONFIG_IDEPCI_PCIBUS_ORDER is not set 
     105CONFIG_IDE_ARCH_OBSOLETE_INIT=y 
    92106# CONFIG_IDE_ARM is not set 
    93107# CONFIG_IDE_GENERIC is not set 
    94108# CONFIG_IDE_PROC_FS is not set 
    95 # CONFIG_IKCONFIG is not set 
    96109CONFIG_INITRAMFS_SOURCE="" 
    97110CONFIG_INPUT=m 
     
    103116# CONFIG_ISA is not set 
    104117CONFIG_ISA_DMA_API=y 
     118# CONFIG_IT8712F_WDT is not set 
    105119# CONFIG_ITCO_WDT is not set 
    106120CONFIG_JFS_FS=m 
     
    109123# CONFIG_KVM is not set 
    110124CONFIG_LBD=y 
     125# CONFIG_LEDS_ALIX is not set 
    111126CONFIG_LEDS_GPIO=y 
     127# CONFIG_LGUEST is not set 
    112128CONFIG_LSF=y 
    113129# CONFIG_M386 is not set 
     
    119135# CONFIG_MACHZ_WDT is not set 
    120136# CONFIG_MACINTOSH_DRIVERS is not set 
     137# CONFIG_MARKERS is not set 
    121138CONFIG_MATH_EMULATION=y 
    122139# CONFIG_MCA is not set 
     
    124141# CONFIG_MCRUSOE is not set 
    125142# CONFIG_MCYRIXIII is not set 
     143# CONFIG_MDIO_BITBANG is not set 
    126144# CONFIG_MEFFICEON is not set 
    127145# CONFIG_MGEODEGX1 is not set 
     
    136154# CONFIG_MPENTIUMIII is not set 
    137155# CONFIG_MPENTIUMM is not set 
     156# CONFIG_MPSC is not set 
    138157CONFIG_MTD=y 
    139158# CONFIG_MTD_ABSENT is not set 
     
    204223CONFIG_NVRAM=y 
    205224CONFIG_PAGE_OFFSET=0xC0000000 
    206 # CONFIG_PARAVIRT is not set 
     225# CONFIG_PARAVIRT_GUEST is not set 
    207226CONFIG_PATA_ARTOP=m 
     227# CONFIG_PATA_CS5536 is not set 
     228# CONFIG_PATA_NS87415 is not set 
    208229# CONFIG_PC8736x_GPIO is not set 
    209230# CONFIG_PC87413_WDT is not set 
     
    214235CONFIG_PCI_BIOS=y 
    215236CONFIG_PCI_DIRECT=y 
     237CONFIG_PCI_DOMAINS=y 
    216238CONFIG_PCI_GOANY=y 
    217239# CONFIG_PCI_GOBIOS is not set 
     
    228250# CONFIG_RELOCATABLE is not set 
    229251# CONFIG_RTC is not set 
     252# CONFIG_RWSEM_GENERIC_SPINLOCK is not set 
    230253CONFIG_RWSEM_XCHGADD_ALGORITHM=y 
     254# CONFIG_SBC7240_WDT is not set 
    231255# CONFIG_SBC8360_WDT is not set 
    232256# CONFIG_SBC_EPX_C3_WATCHDOG is not set 
    233257# CONFIG_SC1200_WDT is not set 
    234258# CONFIG_SC520_WDT is not set 
     259CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y 
    235260# CONFIG_SCSI_LOWLEVEL_PCMCIA is not set 
    236261# CONFIG_SCSI_MULTI_LUN is not set 
     
    240265CONFIG_SEMAPHORE_SLEEPERS=y 
    241266# CONFIG_SERIAL_8250_EXTENDED is not set 
     267CONFIG_SLABINFO=y 
    242268# CONFIG_SMP is not set 
    243269# CONFIG_SMSC37B787_WDT is not set 
     
    247273# CONFIG_SONYPI is not set 
    248274# CONFIG_SPARSEMEM_STATIC is not set 
     275# CONFIG_SPARSEMEM_VMEMMAP_ENABLE is not set 
     276CONFIG_SSB_POSSIBLE=y 
    249277CONFIG_SYSVIPC_SYSCTL=y 
    250278# CONFIG_TELCLOCK is not set 
     
    260288# CONFIG_USB_PWC_DEBUG is not set 
    261289# CONFIG_USB_R8A66597_HCD is not set 
     290# CONFIG_USB_SERIAL_CH341 is not set 
    262291# CONFIG_USB_SERIAL_OTI6858 is not set 
    263292# CONFIG_USB_UHCI_HCD is not set 
     
    268297CONFIG_VIDEO_CAPTURE_DRIVERS=y 
    269298CONFIG_VIDEO_CPIA2=m 
     299# CONFIG_VIDEO_TCM825X is not set 
    270300CONFIG_VIDEO_V4L1=y 
     301# CONFIG_VIDEO_VP27SMPX is not set 
    271302CONFIG_VIRTUALIZATION=y 
    272303# CONFIG_VM86 is not set 
     
    280311CONFIG_X86=y 
    281312CONFIG_X86_32=y 
     313# CONFIG_X86_64 is not set 
    282314CONFIG_X86_ALIGNMENT_16=y 
    283315# CONFIG_X86_BIGSMP is not set 
     
    307339# CONFIG_X86_VISWS is not set 
    308340# CONFIG_X86_VOYAGER is not set 
     341# CONFIG_X86_VSMP is not set 
    309342CONFIG_X86_WP_WORKS_OK=y 
    310343CONFIG_X86_XADD=y 
     344# CONFIG_ZONE_DMA32 is not set 
  • trunk/target/linux/rdc/files/drivers/net/r6040.c

    r9328 r10453  
    1 /* r6040.c: A RDC R6040 FastEthernet driver for linux. */ 
    21/* 
    3         Re-written 2004 by Sten Wang. 
    4  
    5         Copyright 1994-2000 by Donald Becker. 
    6         Copyright 1993 United States Government as represented by the 
    7         Director, National Security Agency.      This software may be used and 
    8         distributed according to the terms of the GNU General Public License, 
    9         incorporated herein by reference. 
    10  
    11         This driver is for RDC R6040 FastEthernet MAC series. 
    12         For kernel version after 2.4.22 
    13  
    14         Modification List 
    15         ----------      ------------------------------------------------ 
    16         10-07-2007      Clean up the driver using checkpatch 
    17         08-24-2006      Support at linux 2.6.10 above 
    18         03-24-2006      Support NAPI 
    19         03-21-2006      By Charies,change spin_lock_irqsave(lp->lock, flags)  
    20                         to spin_lock_irqsave(&lp->lock, flags) 
    21                         in set_multicast_list 
    22         03-15-2006      Modify the set_multicast_list ,due to when re-plug the ethernet, 
    23                         it will forget the previous setting 
    24         07-12-2005      Tim, modify the set_multicast_list 
    25         03-28-2005      Tim, modify some error mac register offset in  
    26                         function set_multicast_list 
    27         03-27-2005      Tim, Add the internal state machine reset 
    28                         Sten, If multicast address more than 4, enter PROM mode 
    29                         Changed rdc to r6040 
    30         12-22-2004      Sten Init MAC MBCR register=0x012A 
    31                         PHY_CAP = 0x01E1 
    32  
    33         Need to Do LIst: 
    34         1. If multicast address more than 4, use the multicast address hash 
     2 * RDC R6040 Fast Ethernet MAC support 
     3 * 
     4 * Copyright (C) 2004 Sten Wang <sten.wang@rdc.com.tw> 
     5 * Copyright (C) 2007 
     6 *      Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us> 
     7 *      Florian Fainelli <florian@openwrt.org> 
     8 * 
     9 * This program is free software; you can redistribute it and/or 
     10 * modify it under the terms of the GNU General Public License 
     11 * as published by the Free Software Foundation; either version 2 
     12 * of the License, or (at your option) any later version. 
     13 * 
     14 * This program is distributed in the hope that it will be useful, 
     15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     17 * GNU General Public License for more details. 
     18 * 
     19 * You should have received a copy of the GNU General Public License 
     20 * along with this program; if not, write to the 
     21 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 
     22 * Boston, MA  02110-1301, USA. 
    3523*/ 
    3624 
    37 #define DRV_NAME        "r6040" 
    38 #define DRV_VERSION     "0.13" 
    39 #define DRV_RELDATE     "24Aug2006" 
    40  
    41 /* PHY CHIP Address */ 
    42 #define PHY1_ADDR       1       /* For MAC1 */ 
    43 #define PHY2_ADDR       2       /* For MAC2 */ 
    44 #define PHY_MODE        0x3100  /* PHY CHIP Register 0 */ 
    45 #define PHY_CAP         0x01E1  /* PHY CHIP Register 4 */ 
    46  
    47 /* Time in jiffies before concluding the transmitter is hung. */ 
    48 #define TX_TIMEOUT      (6000 * HZ / 1000) 
    49 #define TIMER_WUT       (jiffies + HZ * 1)/* timer wakeup time : 1 second */ 
    50  
    51 /* RDC MAC ID */ 
    52 #define RDC_MAC_ID      0x6040 
    53  
    54 /* RDC MAC I/O Size */ 
    55 #define R6040_IO_SIZE   256 
    56  
    57 /* RDC Chip PCI Command */ 
    58 #define R6040_PCI_CMD   0x0005  /* IO, Master */ 
    59  
    60 /* MAX RDC MAC */ 
    61 #define MAX_MAC         2 
    62  
    63 /* MAC setting */ 
    64 #define TX_DCNT         0x80    /* TX descriptor count */ 
    65 #define RX_DCNT         0x80    /* RX descriptor count */ 
    66 #define MAX_BUF_SIZE    0x600 
    67 #define ALLOC_DESC_SIZE ((TX_DCNT+RX_DCNT)*sizeof(struct r6040_descriptor)+0x10) 
    68 #define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register */ 
    69  
    70 /* PHY settings */ 
    71 #define ICPLUS_PHY_ID   0x0243 
    72  
    73 /* Debug enable or not */ 
    74 #define RDC_DEBUG       0 
    75  
    76 #if RDC_DEBUG > 1 
    77 #define RDC_DBUG(msg, value) printk(KERN_ERR "%s %x\n", msg, value); 
    78 #else 
    79 #define RDC_DBUG(msg, value) 
    80 #endif 
    81  
    82  
     25#include <linux/kernel.h> 
    8326#include <linux/module.h> 
    8427#include <linux/version.h> 
    85 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 
    8628#include <linux/moduleparam.h> 
    87 #endif 
    88 #include <linux/kernel.h> 
    8929#include <linux/string.h> 
    9030#include <linux/timer.h> 
     
    10343#include <linux/crc32.h> 
    10444#include <linux/spinlock.h> 
     45#include <linux/bitops.h> 
     46#include <linux/io.h> 
     47#include <linux/irq.h> 
     48#include <linux/uaccess.h> 
    10549 
    10650#include <asm/processor.h> 
    107 #include <asm/bitops.h> 
    108 #include <asm/io.h> 
    109 #include <asm/irq.h> 
    110 #include <asm/uaccess.h> 
    111  
    112 MODULE_AUTHOR("Sten Wang <sten.wang@rdc.com.tw>, Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us>, Florian Fainelli <florian@openwrt.org>"); 
     51 
     52#define DRV_NAME        "r6040" 
     53#define DRV_VERSION     "0.16" 
     54#define DRV_RELDATE     "10Nov2007" 
     55 
     56/* PHY CHIP Address */ 
     57#define PHY1_ADDR       1       /* For MAC1 */ 
     58#define PHY2_ADDR       2       /* For MAC2 */ 
     59#define PHY_MODE        0x3100  /* PHY CHIP Register 0 */ 
     60#define PHY_CAP         0x01E1  /* PHY CHIP Register 4 */ 
     61 
     62/* Time in jiffies before concluding the transmitter is hung. */ 
     63#define TX_TIMEOUT      (6000 * HZ / 1000) 
     64#define TIMER_WUT       (jiffies + HZ * 1)/* timer wakeup time : 1 second */ 
     65 
     66/* RDC MAC I/O Size */ 
     67#define R6040_IO_SIZE   256 
     68 
     69/* MAX RDC MAC */ 
     70#define MAX_MAC         2 
     71 
     72/* MAC registers */ 
     73#define MCR0            0x00    /* Control register 0 */ 
     74#define MCR1            0x04    /* Control register 1 */ 
     75#define  MAC_RST        0x0001  /* Reset the MAC */ 
     76#define MBCR            0x08    /* Bus control */ 
     77#define MT_ICR          0x0C    /* TX interrupt control */ 
     78#define MR_ICR          0x10    /* RX interrupt control */ 
     79#define MTPR            0x14    /* TX poll command register */ 
     80#define MR_BSR          0x18    /* RX buffer size */ 
     81#define MR_DCR          0x1A    /* RX descriptor control */ 
     82#define MLSR            0x1C    /* Last status */ 
     83#define MMDIO           0x20    /* MDIO control register */ 
     84#define  MDIO_WRITE     0x4000  /* MDIO write */ 
     85#define  MDIO_READ      0x2000  /* MDIO read */ 
     86#define MMRD            0x24    /* MDIO read data register */ 
     87#define MMWD            0x28    /* MDIO write data register */ 
     88#define MTD_SA0         0x2C    /* TX descriptor start address 0 */ 
     89#define MTD_SA1         0x30    /* TX descriptor start address 1 */ 
     90#define MRD_SA0         0x34    /* RX descriptor start address 0 */ 
     91#define MRD_SA1         0x38    /* RX descriptor start address 1 */ 
     92#define MISR            0x3C    /* Status register */ 
     93#define MIER            0x40    /* INT enable register */ 
     94#define  MSK_INT        0x0000  /* Mask off interrupts */ 
     95#define ME_CISR         0x44    /* Event counter INT status */ 
     96#define ME_CIER         0x48    /* Event counter INT enable  */ 
     97#define MR_CNT          0x50    /* Successfully received packet counter */ 
     98#define ME_CNT0         0x52    /* Event counter 0 */ 
     99#define ME_CNT1         0x54    /* Event counter 1 */ 
     100#define ME_CNT2         0x56    /* Event counter 2 */ 
     101#define ME_CNT3         0x58    /* Event counter 3 */ 
     102#define MT_CNT          0x5A    /* Successfully transmit packet counter */ 
     103#define ME_CNT4         0x5C    /* Event counter 4 */ 
     104#define MP_CNT          0x5E    /* Pause frame counter register */ 
     105#define MAR0            0x60    /* Hash table 0 */ 
     106#define MAR1            0x62    /* Hash table 1 */ 
     107#define MAR2            0x64    /* Hash table 2 */ 
     108#define MAR3            0x66    /* Hash table 3 */ 
     109#define MID_0L          0x68    /* Multicast address MID0 Low */ 
     110#define MID_0M          0x6A    /* Multicast address MID0 Medium */ 
     111#define MID_0H          0x6C    /* Multicast address MID0 High */ 
     112#define MID_1L          0x70    /* MID1 Low */ 
     113#define MID_1M          0x72    /* MID1 Medium */ 
     114#define MID_1H          0x74    /* MID1 High */ 
     115#define MID_2L          0x78    /* MID2 Low */ 
     116#define MID_2M          0x7A    /* MID2 Medium */ 
     117#define MID_2H          0x7C    /* MID2 High */ 
     118#define MID_3L          0x80    /* MID3 Low */ 
     119#define MID_3M          0x82    /* MID3 Medium */ 
     120#define MID_3H          0x84    /* MID3 High */ 
     121#define PHY_CC          0x88    /* PHY status change configuration register */ 
     122#define PHY_ST          0x8A    /* PHY status register */ 
     123#define MAC_SM          0xAC    /* MAC status machine */ 
     124#define MAC_ID          0xBE    /* Identifier register */ 
     125 
     126#define TX_DCNT         0x80    /* TX descriptor count */ 
     127#define RX_DCNT         0x80    /* RX descriptor count */ 
     128#define MAX_BUF_SIZE    0x600 
     129#define RX_DESC_SIZE    (RX_DCNT * sizeof(struct r6040_descriptor)) 
     130#define TX_DESC_SIZE    (TX_DCNT * sizeof(struct r6040_descriptor)) 
     131#define MBCR_DEFAULT    0x012A  /* MAC Bus Control Register */ 
     132#define MCAST_MAX       4       /* Max number multicast addresses to filter */ 
     133 
     134/* PHY settings */ 
     135#define ICPLUS_PHY_ID   0x0243 
     136 
     137MODULE_AUTHOR("Sten Wang <sten.wang@rdc.com.tw>," 
     138        "Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us>," 
     139        "Florian Fainelli <florian@openwrt.org>"); 
    113140MODULE_LICENSE("GPL"); 
    114 #ifdef CONFIG_R6040_NAPI 
    115 MODULE_DESCRIPTION("RDC R6040 NAPI PCI FastEthernet Driver"); 
    116 #else 
    117 MODULE_DESCRIPTION("RDC R6040 PCI FastEthernet Driver"); 
    118 #endif 
    119  
    120 #define R6040_INT_MASK                  0x0011 
     141MODULE_DESCRIPTION("RDC R6040 NAPI PCI FastEthernet driver"); 
     142 
     143#define RX_INT                         0x0001 
     144#define TX_INT                         0x0010 
     145#define RX_NO_DESC_INT                 0x0002 
     146#define INT_MASK                 (RX_INT | TX_INT) 
    121147 
    122148struct r6040_descriptor { 
    123149        u16     status, len;            /* 0-3 */ 
    124         u32     buf;                    /* 4-7 */ 
    125         u32     ndesc;                  /* 8-B */ 
     150        __le32  buf;                    /* 4-7 */ 
     151        __le32  ndesc;                  /* 8-B */ 
    126152        u32     rev1;                   /* C-F */ 
    127153        char    *vbufp;                 /* 10-13 */ 
     
    132158 
    133159struct r6040_private { 
    134         struct net_device_stats stats; 
    135160        spinlock_t lock;                /* driver lock */ 
    136161        struct timer_list timer; 
    137162        struct pci_dev *pdev; 
    138  
    139163        struct r6040_descriptor *rx_insert_ptr; 
    140164        struct r6040_descriptor *rx_remove_ptr; 
    141165        struct r6040_descriptor *tx_insert_ptr; 
    142166        struct r6040_descriptor *tx_remove_ptr; 
     167        struct r6040_descriptor *rx_ring; 
     168        struct r6040_descriptor *tx_ring; 
     169        dma_addr_t rx_ring_dma; 
     170        dma_addr_t tx_ring_dma; 
    143171        u16     tx_free_desc, rx_free_desc, phy_addr, phy_mode; 
    144172        u16     mcr0, mcr1; 
    145         dma_addr_t desc_dma; 
    146         char    *desc_pool; 
    147173        u16     switch_sig; 
     174        struct net_device *dev; 
     175        struct mii_if_info mii_if; 
     176        struct napi_struct napi; 
     177        struct net_device_stats stats; 
     178        u16     napi_rx_running; 
     179        void __iomem *base; 
    148180}; 
    149181 
    150 struct r6040_chip_info { 
    151         const char *name; 
    152         u16 pci_flags; 
    153         int io_size; 
    154         int drv_flags; 
     182static char version[] __devinitdata = KERN_INFO DRV_NAME 
     183        ": RDC R6040 NAPI net driver," 
     184        "version "DRV_VERSION " (" DRV_RELDATE ")\n"; 
     185 
     186static int phy_table[] = { PHY1_ADDR, PHY2_ADDR }; 
     187 
     188/* Read a word data from PHY Chip */ 
     189static int phy_read(void __iomem *ioaddr, int phy_addr, int reg) 
     190{ 
     191        int limit = 2048; 
     192        u16 cmd; 
     193 
     194        iowrite16(MDIO_READ + reg + (phy_addr << 8), ioaddr + MMDIO); 
     195        /* Wait for the read bit to be cleared */ 
     196        while (limit--) { 
     197                cmd = ioread16(ioaddr + MMDIO); 
     198                if (cmd & MDIO_READ) 
     199                        break; 
     200        } 
     201 
     202        return ioread16(ioaddr + MMRD); 
     203} 
     204 
     205/* Write a word data from PHY Chip */ 
     206static void phy_write(void __iomem *ioaddr, int phy_addr, int reg, u16 val) 
     207{ 
     208        int limit = 2048; 
     209        u16 cmd; 
     210 
     211        iowrite16(val, ioaddr + MMWD); 
     212        /* Write the command to the MDIO bus */ 
     213        iowrite16(MDIO_WRITE + reg + (phy_addr << 8), ioaddr + MMDIO); 
     214        /* Wait for the write bit to be cleared */ 
     215        while (limit--) { 
     216                cmd = ioread16(ioaddr + MMDIO); 
     217                if (cmd & MDIO_WRITE) 
     218                        break; 
     219        } 
     220} 
     221 
     222static int mdio_read(struct net_device *dev, int mii_id, int reg) 
     223{ 
     224        struct r6040_private *lp = netdev_priv(dev); 
     225        void __iomem *ioaddr = lp->base; 
     226 
     227        return (phy_read(ioaddr, lp->phy_addr, reg)); 
     228} 
     229 
     230static void mdio_write(struct net_device *dev, int mii_id, int reg, int val) 
     231{ 
     232        struct r6040_private *lp = netdev_priv(dev); 
     233        void __iomem *ioaddr = lp->base; 
     234 
     235        phy_write(ioaddr, lp->phy_addr, reg, val); 
     236} 
     237 
     238static void r6040_tx_timeout(struct net_device *dev) 
     239{ 
     240        struct r6040_private *priv = netdev_priv(dev); 
     241 
     242        disable_irq(dev->irq); 
     243        napi_disable(&priv->napi); 
     244        spin_lock(&priv->lock); 
     245        dev->stats.tx_errors++; 
     246        spin_unlock(&priv->lock); 
     247 
     248        netif_stop_queue(dev); 
     249} 
     250 
     251/* Allocate skb buffer for rx descriptor */ 
     252static void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev) 
     253{ 
     254        struct r6040_descriptor *descptr; 
     255        void __iomem *ioaddr = lp->base; 
     256 
     257        descptr = lp->rx_insert_ptr; 
     258        while (lp->rx_free_desc < RX_DCNT) { 
     259                descptr->skb_ptr = dev_alloc_skb(MAX_BUF_SIZE); 
     260 
     261                if (!descptr->skb_ptr) 
     262                        break; 
     263                descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, 
     264                        descptr->skb_ptr->data, 
     265                        MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
     266                descptr->status = 0x8000; 
     267                descptr = descptr->vndescp; 
     268                lp->rx_free_desc++; 
     269                /* Trigger RX DMA */ 
     270                iowrite16(lp->mcr0 | 0x0002, ioaddr); 
     271        } 
     272        lp->rx_insert_ptr = descptr; 
     273} 
     274 
     275 
     276static struct net_device_stats *r6040_get_stats(struct net_device *dev) 
     277{ 
     278        struct r6040_private *priv = netdev_priv(dev); 
     279        void __iomem *ioaddr = priv->base; 
     280        unsigned long flags; 
     281 
     282        spin_lock_irqsave(&priv->lock, flags); 
     283        priv->stats.rx_crc_errors += ioread8(ioaddr + ME_CNT1); 
     284        priv->stats.multicast += ioread8(ioaddr + ME_CNT0); 
     285        spin_unlock_irqrestore(&priv->lock, flags); 
     286 
     287        return &priv->stats; 
     288} 
     289 
     290/* Stop RDC MAC and Free the allocated resource */ 
     291static void r6040_down(struct net_device *dev) 
     292{ 
     293        struct r6040_private *lp = netdev_priv(dev); 
     294        void __iomem *ioaddr = lp->base; 
     295        struct pci_dev *pdev = lp->pdev; 
     296        int i; 
     297        int limit = 2048; 
     298        u16 *adrp; 
     299        u16 cmd; 
     300 
     301        /* Stop MAC */ 
     302        iowrite16(MSK_INT, ioaddr + MIER);      /* Mask Off Interrupt */ 
     303        iowrite16(MAC_RST, ioaddr + MCR1);      /* Reset RDC MAC */ 
     304        while (limit--) { 
     305                cmd = ioread16(ioaddr + MCR1); 
     306                if (cmd & 0x1) 
     307                        break; 
     308        } 
     309 
     310        /* Restore MAC Address to MIDx */ 
     311        adrp = (u16 *) dev->dev_addr; 
     312        iowrite16(adrp[0], ioaddr + MID_0L); 
     313        iowrite16(adrp[1], ioaddr + MID_0M); 
     314        iowrite16(adrp[2], ioaddr + MID_0H); 
     315        free_irq(dev->irq, dev); 
     316        /* Free RX buffer */ 
     317        for (i = 0; i < RX_DCNT; i++) { 
     318                if (lp->rx_insert_ptr->skb_ptr) { 
     319                        pci_unmap_single(lp->pdev, lp->rx_insert_ptr->buf, 
     320                                MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
     321                        dev_kfree_skb(lp->rx_insert_ptr->skb_ptr); 
     322                        lp->rx_insert_ptr->skb_ptr = NULL; 
     323                } 
     324                lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp; 
     325        } 
     326 
     327        /* Free TX buffer */ 
     328        for (i = 0; i < TX_DCNT; i++) { 
     329                if (lp->tx_insert_ptr->skb_ptr) { 
     330                        pci_unmap_single(lp->pdev, lp->tx_insert_ptr->buf, 
     331                                MAX_BUF_SIZE, PCI_DMA_TODEVICE); 
     332                        dev_kfree_skb(lp->tx_insert_ptr->skb_ptr); 
     333                        lp->rx_insert_ptr->skb_ptr = NULL; 
     334                } 
     335                lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp; 
     336        } 
     337 
     338        /* Free Descriptor memory */ 
     339        pci_free_consistent(pdev, RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma); 
     340        pci_free_consistent(pdev, TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma); 
     341} 
     342 
     343static int r6040_close(struct net_device *dev) 
     344{ 
     345        struct r6040_private *lp = netdev_priv(dev); 
     346 
     347        /* deleted timer */ 
     348        del_timer_sync(&lp->timer); 
     349 
     350        spin_lock_irq(&lp->lock); 
     351        netif_stop_queue(dev); 
     352        r6040_down(dev); 
     353        spin_unlock_irq(&lp->lock); 
     354 
     355        return 0; 
     356} 
     357 
     358/* Status of PHY CHIP */ 
     359static int phy_mode_chk(struct net_device *dev) 
     360{ 
     361        struct r6040_private *lp = netdev_priv(dev); 
     362        void __iomem *ioaddr = lp->base; 
     363        int phy_dat; 
     364 
     365        /* PHY Link Status Check */ 
     366        phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
     367        if (!(phy_dat & 0x4)) 
     368                phy_dat = 0x8000;       /* Link Failed, full duplex */ 
     369 
     370        /* PHY Chip Auto-Negotiation Status */ 
     371        phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
     372        if (phy_dat & 0x0020) { 
     373                /* Auto Negotiation Mode */ 
     374                phy_dat = phy_read(ioaddr, lp->phy_addr, 5); 
     375                phy_dat &= phy_read(ioaddr, lp->phy_addr, 4); 
     376                if (phy_dat & 0x140) 
     377                        /* Force full duplex */ 
     378                        phy_dat = 0x8000; 
     379                else 
     380                        phy_dat = 0; 
     381        } else { 
     382                /* Force Mode */ 
     383                phy_dat = phy_read(ioaddr, lp->phy_addr, 0); 
     384                if (phy_dat & 0x100) 
     385                        phy_dat = 0x8000; 
     386                else 
     387                        phy_dat = 0x0000; 
     388        } 
     389 
     390        return phy_dat; 
    155391}; 
    156392 
    157 #ifdef CONFIG_R6040_NAPI 
    158 static int NAPI_status; 
     393static void r6040_set_carrier(struct mii_if_info *mii) 
     394{ 
     395        if (phy_mode_chk(mii->dev)) { 
     396                /* autoneg is off: Link is always assumed to be up */ 
     397                if (!netif_carrier_ok(mii->dev)) 
     398                        netif_carrier_on(mii->dev); 
     399        } else 
     400                phy_mode_chk(mii->dev); 
     401} 
     402 
     403static int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 
     404{ 
     405        struct r6040_private *lp = netdev_priv(dev); 
     406        struct mii_ioctl_data *data = if_mii(rq); 
     407        int rc; 
     408 
     409        if (!netif_running(dev)) 
     410                return -EINVAL; 
     411        spin_lock_irq(&lp->lock); 
     412        rc = generic_mii_ioctl(&lp->mii_if, data, cmd, NULL); 
     413        spin_unlock_irq(&lp->lock); 
     414        r6040_set_carrier(&lp->mii_if); 
     415        return rc; 
     416} 
     417 
     418static int r6040_rx(struct net_device *dev, int limit) 
     419{ 
     420        struct r6040_private *priv = netdev_priv(dev); 
     421        int count; 
     422        void __iomem *ioaddr = priv->base; 
     423        u16 err; 
     424 
     425        for (count = 0; count < limit; ++count) { 
     426                struct r6040_descriptor *descptr = priv->rx_remove_ptr; 
     427                struct sk_buff *skb_ptr; 
     428 
     429                /* Disable RX interrupt */ 
     430                iowrite16(ioread16(ioaddr + MIER) & (~RX_INT), ioaddr + MIER); 
     431                descptr = priv->rx_remove_ptr; 
     432 
     433                /* Check for errors */ 
     434                err = ioread16(ioaddr + MLSR); 
     435                if (err & 0x0400) priv->stats.rx_errors++; 
     436                /* RX FIFO over-run */ 
     437                if (err & 0x8000) priv->stats.rx_fifo_errors++; 
     438                /* RX descriptor unavailable */ 
     439                if (err & 0x0080) priv->stats.rx_frame_errors++; 
     440                /* Received packet with length over buffer lenght */ 
     441                if (err & 0x0020) priv->stats.rx_over_errors++; 
     442                /* Received packet with too long or short */ 
     443                if (err & (0x0010|0x0008)) priv->stats.rx_length_errors++; 
     444                /* Received packet with CRC errors */ 
     445                if (err & 0x0004) { 
     446                        spin_lock(&priv->lock); 
     447                        priv->stats.rx_crc_errors++; 
     448                        spin_unlock(&priv->lock); 
     449                } 
     450 
     451                while (priv->rx_free_desc) { 
     452                        /* No RX packet */ 
     453                        if (descptr->status & 0x8000) 
     454                                break; 
     455                        skb_ptr = descptr->skb_ptr; 
     456                        if (!skb_ptr) { 
     457                                printk(KERN_ERR "%s: Inconsistent RX" 
     458                                        "descriptor chain\n", 
     459                                        dev->name); 
     460                                break; 
     461                        } 
     462                        descptr->skb_ptr = NULL; 
     463                        skb_ptr->dev = priv->dev; 
     464                        /* Do not count the CRC */ 
     465                        skb_put(skb_ptr, descptr->len - 4); 
     466                        pci_unmap_single(priv->pdev, descptr->buf, 
     467                                MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
     468                        skb_ptr->protocol = eth_type_trans(skb_ptr, priv->dev); 
     469                        /* Send to upper layer */ 
     470                        netif_receive_skb(skb_ptr); 
     471                        dev->last_rx = jiffies; 
     472                        priv->dev->stats.rx_packets++; 
     473                        priv->dev->stats.rx_bytes += descptr->len; 
     474                        /* To next descriptor */ 
     475                        descptr = descptr->vndescp; 
     476                        priv->rx_free_desc--; 
     477                } 
     478                priv->rx_remove_ptr = descptr; 
     479        } 
     480        /* Allocate new RX buffer */ 
     481        if (priv->rx_free_desc < RX_DCNT) 
     482                rx_buf_alloc(priv, priv->dev); 
     483 
     484        return count; 
     485} 
     486 
     487static void r6040_tx(struct net_device *dev) 
     488{ 
     489        struct r6040_private *priv = netdev_priv(dev); 
     490        struct r6040_descriptor *descptr; 
     491        void __iomem *ioaddr = priv->base; 
     492        struct sk_buff *skb_ptr; 
     493        u16 err; 
     494 
     495        spin_lock(&priv->lock); 
     496        descptr = priv->tx_remove_ptr; 
     497        while (priv->tx_free_desc < TX_DCNT) { 
     498                /* Check for errors */ 
     499                err = ioread16(ioaddr + MLSR); 
     500 
     501                if (err & 0x0200) priv->stats.rx_fifo_errors++; 
     502                if (err & (0x2000 | 0x4000)) priv->stats.tx_carrier_errors++; 
     503 
     504                if (descptr->status & 0x8000) 
     505                        break; /* Not complte */ 
     506                skb_ptr = descptr->skb_ptr; 
     507                pci_unmap_single(priv->pdev, descptr->buf, 
     508                        skb_ptr->len, PCI_DMA_TODEVICE); 
     509                /* Free buffer */ 
     510                dev_kfree_skb_irq(skb_ptr); 
     511                descptr->skb_ptr = NULL; 
     512                /* To next descriptor */ 
     513                descptr = descptr->vndescp; 
     514                priv->tx_free_desc++; 
     515        } 
     516        priv->tx_remove_ptr = descptr; 
     517 
     518        if (priv->tx_free_desc) 
     519                netif_wake_queue(dev); 
     520        spin_unlock(&priv->lock); 
     521} 
     522 
     523static int r6040_poll(struct napi_struct *napi, int budget) 
     524{ 
     525        struct r6040_private *priv = 
     526                container_of(napi, struct r6040_private, napi); 
     527        struct net_device *dev = priv->dev; 
     528        void __iomem *ioaddr = priv->base; 
     529        int work_done; 
     530 
     531        work_done = r6040_rx(dev, budget); 
     532 
     533        if (work_done < budget) { 
     534                netif_rx_complete(dev, napi); 
     535                /* Enable RX interrupt */ 
     536                iowrite16(ioread16(ioaddr + MIER) | RX_INT, ioaddr + MIER); 
     537        } 
     538        return work_done; 
     539} 
     540 
     541/* The RDC interrupt handler. */ 
     542static irqreturn_t r6040_interrupt(int irq, void *dev_id) 
     543{ 
     544        struct net_device *dev = dev_id; 
     545        struct r6040_private *lp = netdev_priv(dev); 
     546        void __iomem *ioaddr = lp->base; 
     547        u16 status; 
     548        int handled = 1; 
     549 
     550        /* Mask off RDC MAC interrupt */ 
     551        iowrite16(MSK_INT, ioaddr + MIER); 
     552        /* Read MISR status and clear */ 
     553        status = ioread16(ioaddr + MISR); 
     554 
     555        if (status == 0x0000 || status == 0xffff) 
     556                return IRQ_NONE; 
     557 
     558        /* RX interrupt request */ 
     559        if (status & 0x01) { 
     560                netif_rx_schedule(dev, &lp->napi); 
     561                iowrite16(TX_INT, ioaddr + MIER); 
     562        } 
     563 
     564        /* TX interrupt request */ 
     565        if (status & 0x10) 
     566                r6040_tx(dev); 
     567 
     568        return IRQ_RETVAL(handled); 
     569} 
     570 
     571#ifdef CONFIG_NET_POLL_CONTROLLER 
     572static void r6040_poll_controller(struct net_device *dev) 
     573{ 
     574        disable_irq(dev->irq); 
     575        r6040_interrupt(dev->irq, dev); 
     576        enable_irq(dev->irq); 
     577} 
    159578#endif 
    160579 
    161 static int __devinitdata printed_version; 
    162 #ifdef CONFIG_R6040_NAPI 
    163 static char version[] __devinitdata = 
    164         KERN_INFO DRV_NAME ": RDC R6040 NAPI net driver, version "DRV_VERSION " (" DRV_RELDATE ")\n"; 
    165 #else 
    166 static char version[] __devinitdata = 
    167         KERN_INFO DRV_NAME ": RDC R6040 net driver, version "DRV_VERSION " (" DRV_RELDATE ")\n"; 
    168 #endif 
    169 static struct r6040_chip_info r6040_chip_info[] __devinitdata = 
    170 { 
    171         { "RDC R6040 Knight", R6040_PCI_CMD, R6040_IO_SIZE, 0} 
    172 }; 
    173 static char *parent; 
    174  
    175 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 
    176 static int NUM_MAC_TABLE = 2 ; 
    177 module_param(parent, charp, 0444); 
    178 #else 
    179 MODULE_PARM(parent, "s"); 
    180 #endif 
    181 MODULE_PARM_DESC(parent, "Parent network device name"); 
    182  
    183 static int phy_table[] = { 0x1, 0x2}; 
    184 static u8 adr_table[2][8] = { 
    185         {0x00, 0x00, 0x60, 0x00, 0x00, 0x01}, 
    186         {0x00, 0x00, 0x60, 0x00, 0x00, 0x02} 
    187 }; 
    188  
    189 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 10) 
    190         module_param_array(adr_table, int, &NUM_MAC_TABLE, 0644); 
    191 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0) 
    192         module_param_array(adr_table, int, NUM_MAC_TABLE, 0644); 
    193 #else 
    194         MODULE_PARM(adr_table, "2-4i"); 
    195 #endif 
    196 MODULE_PARM_DESC(adr_table, "MAC Address (assigned)"); 
    197  
    198 static int r6040_open(struct net_device *dev); 
    199 static int r6040_start_xmit(struct sk_buff *skb, struct net_device *dev); 
    200 static irqreturn_t r6040_interrupt(int irq, void *dev_id); 
    201 static struct net_device_stats *r6040_get_stats(struct net_device *dev); 
    202 static int r6040_close(struct net_device *dev); 
    203 static void set_multicast_list(struct net_device *dev); 
    204 static struct ethtool_ops netdev_ethtool_ops; 
    205 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd); 
    206 static void r6040_down(struct net_device *dev); 
    207 static void r6040_up(struct net_device *dev); 
    208 static void r6040_tx_timeout (struct net_device *dev); 
    209 static void r6040_timer(unsigned long); 
    210  
    211 static int phy_mode_chk(struct net_device *dev); 
    212 static int phy_read(int ioaddr, int phy_adr, int reg_idx); 
    213 static void phy_write(int ioaddr, int phy_adr, int reg_idx, int dat); 
    214 static void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev); 
    215 #ifdef CONFIG_R6040_NAPI 
    216 static int r6040_poll(struct net_device *netdev, int *budget); 
    217 #endif 
    218  
    219  
    220 static int __devinit r6040_init_one (struct pci_dev *pdev, 
    221                                          const struct pci_device_id *ent) 
    222 { 
    223         struct net_device *dev; 
    224         struct r6040_private *lp; 
    225         int ioaddr, io_size, err; 
    226         static int card_idx = -1; 
    227         int chip_id = (int)ent->driver_data; 
    228  
    229         RDC_DBUG("r6040_init_one()", 0); 
    230  
    231         if (printed_version++) 
    232                 printk(KERN_INFO "%s\n", version); 
    233  
    234         err = pci_enable_device(pdev); 
    235         if (err) 
    236                 return err; 
    237  
    238         /* this should always be supported */ 
    239         if (pci_set_dma_mask(pdev, 0xffffffff)) { 
    240                 printk(KERN_ERR DRV_NAME "32-bit PCI DMA addresses not supported by the card!?\n"); 
    241                 return  -ENODEV; 
    242         } 
    243  
    244         /* IO Size check */ 
    245         io_size = r6040_chip_info[chip_id].io_size; 
    246         if (pci_resource_len  (pdev, 0) < io_size) { 
    247                 return  -ENODEV; 
    248         } 
    249  
    250         ioaddr = pci_resource_start (pdev, 0);  /* IO map base address */ 
    251         pci_set_master(pdev); 
    252  
    253         dev = alloc_etherdev(sizeof(struct r6040_private)); 
    254         if (dev == NULL) 
     580static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring, 
     581                                 dma_addr_t desc_dma, int size) 
     582{ 
     583        struct r6040_descriptor *desc = desc_ring; 
     584        dma_addr_t mapping = desc_dma; 
     585 
     586        while (size-- > 0) { 
     587                mapping += sizeof(sizeof(*desc)); 
     588                desc->ndesc = cpu_to_le32(mapping); 
     589                desc->vndescp = desc + 1; 
     590                desc++; 
     591        } 
     592        desc--; 
     593        desc->ndesc = cpu_to_le32(desc_dma); 
     594        desc->vndescp = desc_ring; 
     595} 
     596 
     597/* Init RDC MAC */ 
     598static void r6040_up(struct net_device *dev) 
     599{ 
     600        struct r6040_private *lp = netdev_priv(dev); 
     601        void __iomem *ioaddr = lp->base; 
     602 
     603        /* Initialize */ 
     604        lp->tx_free_desc = TX_DCNT; 
     605        lp->rx_free_desc = 0; 
     606        /* Init descriptor */ 
     607        lp->tx_remove_ptr = lp->tx_insert_ptr = lp->tx_ring; 
     608        lp->rx_remove_ptr = lp->rx_insert_ptr = lp->rx_ring; 
     609        /* Init TX descriptor */ 
     610        r6040_init_ring_desc(lp->tx_ring, lp->tx_ring_dma, TX_DCNT); 
     611 
     612        /* Init RX descriptor */ 
     613        r6040_init_ring_desc(lp->rx_ring, lp->rx_ring_dma, RX_DCNT); 
     614 
     615        /* Allocate buffer for RX descriptor */ 
     616        rx_buf_alloc(lp, dev); 
     617 
     618        /* 
     619         * TX and RX descriptor start registers. 
     620         * Lower 16-bits to MxD_SA0. Higher 16-bits to MxD_SA1. 
     621         */ 
     622        iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0); 
     623        iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1); 
     624 
     625        iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0); 
     626        iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1); 
     627 
     628        /* Buffer Size Register */ 
     629        iowrite16(MAX_BUF_SIZE, ioaddr + MR_BSR); 
     630        /* Read the PHY ID */ 
     631        lp->switch_sig = phy_read(ioaddr, 0, 2); 
     632 
     633        if (lp->switch_sig  == ICPLUS_PHY_ID) { 
     634                phy_write(ioaddr, 29, 31, 0x175C); /* Enable registers */ 
     635                lp->phy_mode = 0x8000; 
     636        } else { 
     637                /* PHY Mode Check */ 
     638                phy_write(ioaddr, lp->phy_addr, 4, PHY_CAP); 
     639                phy_write(ioaddr, lp->phy_addr, 0, PHY_MODE); 
     640 
     641                if (PHY_MODE == 0x3100) 
     642                        lp->phy_mode = phy_mode_chk(dev); 
     643                else 
     644                        lp->phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
     645        } 
     646        /* MAC Bus Control Register */ 
     647        iowrite16(MBCR_DEFAULT, ioaddr + MBCR); 
     648 
     649        /* MAC TX/RX Enable */ 
     650        lp->mcr0 |= lp->phy_mode; 
     651        iowrite16(lp->mcr0, ioaddr); 
     652 
     653        /* set interrupt waiting time and packet numbers */ 
     654        iowrite16(0x0F06, ioaddr + MT_ICR); 
     655        iowrite16(0x0F06, ioaddr + MR_ICR); 
     656 
     657        /* improve performance (by RDC guys) */ 
     658        phy_write(ioaddr, 30, 17, (phy_read(ioaddr, 30, 17) | 0x4000)); 
     659        phy_write(ioaddr, 30, 17, ~((~phy_read(ioaddr, 30, 17)) | 0x2000)); 
     660        phy_write(ioaddr, 0, 19, 0x0000); 
     661        phy_write(ioaddr, 0, 30, 0x01F0); 
     662 
     663        /* Interrupt Mask Register */ 
     664        iowrite16(INT_MASK, ioaddr + MIER); 
     665} 
     666 
     667/* 
     668  A periodic timer routine 
     669        Polling PHY Chip Link Status 
     670*/ 
     671static void r6040_timer(unsigned long data) 
     672{ 
     673        struct net_device *dev = (struct net_device *)data; 
     674        struct r6040_private *lp = netdev_priv(dev); 
     675        void __iomem *ioaddr = lp->base; 
     676        u16 phy_mode; 
     677 
     678        /* Polling PHY Chip Status */ 
     679        if (PHY_MODE == 0x3100) 
     680                phy_mode = phy_mode_chk(dev); 
     681        else 
     682                phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
     683 
     684        if (phy_mode != lp->phy_mode) { 
     685                lp->phy_mode = phy_mode; 
     686                lp->mcr0 = (lp->mcr0 & 0x7fff) | phy_mode; 
     687                iowrite16(lp->mcr0, ioaddr); 
     688                printk(KERN_INFO "Link Change %x \n", ioread16(ioaddr)); 
     689        } 
     690 
     691        /* Timer active again */ 
     692        lp->timer.expires = TIMER_WUT; 
     693        add_timer(&lp->timer); 
     694} 
     695 
     696/* Read/set MAC address routines */ 
     697static void r6040_mac_address(struct net_device *dev) 
     698{ 
     699        struct r6040_private *lp = netdev_priv(dev); 
     700        void __iomem *ioaddr = lp->base; 
     701        u16 *adrp; 
     702 
     703        /* MAC operation register */ 
     704        iowrite16(0x01, ioaddr + MCR1); /* Reset MAC */ 
     705        iowrite16(2, ioaddr + MAC_SM); /* Reset internal state machine */ 
     706        iowrite16(0, ioaddr + MAC_SM); 
     707        udelay(5000); 
     708 
     709        /* Restore MAC Address */ 
     710        adrp = (u16 *) dev->dev_addr; 
     711        iowrite16(adrp[0], ioaddr + MID_0L); 
     712        iowrite16(adrp[1], ioaddr + MID_0M); 
     713        iowrite16(adrp[2], ioaddr + MID_0H); 
     714} 
     715 
     716static int r6040_open(struct net_device *dev) 
     717{ 
     718        struct r6040_private *lp = netdev_priv(dev); 
     719        int ret; 
     720 
     721        /* Request IRQ and Register interrupt handler */ 
     722        ret = request_irq(dev->irq, &r6040_interrupt, 
     723                IRQF_SHARED, dev->name, dev); 
     724        if (ret) 
     725                return ret; 
     726 
     727        /* Set MAC address */ 
     728        r6040_mac_address(dev); 
     729 
     730        /* Allocate Descriptor memory */ 
     731        lp->rx_ring = 
     732                pci_alloc_consistent(lp->pdev, RX_DESC_SIZE, &lp->rx_ring_dma); 
     733        if (!lp->rx_ring) 
    255734                return -ENOMEM; 
    256         SET_MODULE_OWNER(dev); 
    257  
    258         if (pci_request_regions(pdev, DRV_NAME)) { 
    259                 printk(KERN_ERR DRV_NAME ": Failed to request PCI regions\n"); 
    260                 err = -ENODEV; 
    261                 goto err_out_disable; 
    262         } 
    263  
    264         /* Init system & device */ 
    265         lp = dev->priv; 
    266         dev->base_addr = ioaddr; 
    267         dev->irq = pdev->irq; 
    268  
    269         spin_lock_init(&lp->lock); 
    270         pci_set_drvdata(pdev, dev); 
    271  
    272         /* Set MAC address */ 
    273         card_idx++; 
    274         memcpy(dev->dev_addr, (u8 *)&adr_table[card_idx][0], 6); 
    275  
    276         /* Link new device into r6040_root_dev */ 
    277         lp->pdev = pdev; 
    278  
    279         /* Init RDC private data */ 
    280         lp->mcr0 = 0x1002; 
    281         lp->phy_addr = phy_table[card_idx]; 
    282         lp->switch_sig = 0; 
    283  
    284         /* The RDC-specific entries in the device structure. */ 
    285         dev->open = &r6040_open; 
    286         dev->hard_start_xmit = &r6040_start_xmit; 
    287         dev->stop = &r6040_close; 
    288         dev->get_stats = &r6040_get_stats; 
    289         dev->set_multicast_list = &set_multicast_list; 
    290         dev->do_ioctl = &netdev_ioctl; 
    291         dev->ethtool_ops = &netdev_ethtool_ops; 
    292         dev->tx_timeout = &r6040_tx_timeout; 
    293         dev->watchdog_timeo = TX_TIMEOUT; 
    294 #ifdef CONFIG_R6040_NAPI 
    295         dev->poll = &r6040_poll; 
    296         dev->weight = 64; 
    297 #endif 
    298  
    299         /* Register net device. After this dev->name assign */ 
    300         err = register_netdev(dev); 
    301         if (err) { 
    302                 printk(KERN_ERR DRV_NAME ": Failed to register net device\n"); 
    303                 goto err_out_res; 
    304         } 
    305  
    306         netif_carrier_on(dev); 
    307         return 0; 
    308  
    309 err_out_res: 
    310         pci_release_regions(pdev); 
    311 err_out_disable: 
    312         pci_disable_device(pdev); 
    313         pci_set_drvdata(pdev, NULL); 
    314         kfree(dev); 
    315  
    316         return err; 
    317 } 
    318  
    319 static void __devexit r6040_remove_one (struct pci_dev *pdev) 
    320 { 
    321         struct net_device *dev = pci_get_drvdata(pdev); 
    322          
    323         unregister_netdev(dev); 
    324         pci_release_regions(pdev); 
    325         kfree(dev); 
    326         pci_disable_device(pdev); 
    327         pci_set_drvdata(pdev, NULL); 
    328 } 
    329  
    330 static int 
    331 r6040_open(struct net_device *dev) 
    332 { 
    333         struct r6040_private *lp = dev->priv; 
    334         int i; 
    335  
    336         RDC_DBUG("r6040_open()", 0); 
    337  
    338         /* Request IRQ and Register interrupt handler */ 
    339         i = request_irq(dev->irq, &r6040_interrupt, SA_SHIRQ, dev->name, dev); 
    340         if (i) return i; 
    341  
    342         /* Allocate Descriptor memory */ 
    343         lp->desc_pool = pci_alloc_consistent(lp->pdev, ALLOC_DESC_SIZE, &lp->desc_dma); 
    344         if (!lp->desc_pool) 
     735 
     736        lp->tx_ring = 
     737                pci_alloc_consistent(lp->pdev, TX_DESC_SIZE, &lp->tx_ring_dma); 
     738        if (!lp->tx_ring) { 
     739                pci_free_consistent(lp->pdev, RX_DESC_SIZE, lp->rx_ring, 
     740                                     lp->rx_ring_dma); 
    345741                return -ENOMEM; 
     742        } 
    346743 
    347744        r6040_up(dev); 
    348745 
     746        napi_enable(&lp->napi); 
    349747        netif_start_queue(dev); 
    350748 
     
    360758} 
    361759 
    362 static void 
    363 r6040_tx_timeout (struct net_device *dev) 
    364 { 
    365         struct r6040_private *lp = dev->priv; 
    366         /* int ioaddr = dev->base_addr; 
    367         struct r6040_descriptor *descptr = lp->tx_remove_ptr; */ 
    368  
    369         RDC_DBUG("r6040_tx_timeout()", 0); 
    370  
    371         /* Transmitter timeout, serious problems. */ 
    372         /* Sten: Nothing need to do so far. */ 
    373         printk(KERN_ERR DRV_NAME ": Big Trobule, transmit timeout/n"); 
    374         lp->stats.tx_errors++; 
    375         netif_stop_queue(dev); 
    376  
    377 //printk("<RDC> XMT timedout: CR0 %x, CR40 %x, CR3C %x, CR2C %x, CR30 %x, CR34 %x, CR38 %x\n", inw(ioaddr), inw(ioaddr+0x40), inw(ioaddr+0x3c), inw(ioaddr+0x2c), inw(ioaddr+0x30), inw(ioaddr+0x34), inw(ioaddr+0x38)); 
    378  
    379 //printk("<RDC> XMT_TO: %08lx:%04x %04x %08lx %08lx %08lx %08lx\n", descptr, descptr->status, descptr->len, descptr->buf, descptr->skb_ptr, descptr->ndesc, descptr->vndescp); 
    380 } 
    381  
    382  
    383 static int 
    384 r6040_start_xmit(struct sk_buff *skb, struct net_device *dev) 
    385 { 
    386         struct r6040_private *lp = dev->priv; 
     760static int r6040_start_xmit(struct sk_buff *skb, struct net_device *dev) 
     761{ 
     762        struct r6040_private *lp = netdev_priv(dev); 
    387763        struct r6040_descriptor *descptr; 
    388         int ioaddr = dev->base_addr; 
     764        void __iomem *ioaddr = lp->base; 
    389765        unsigned long flags; 
    390  
    391         RDC_DBUG("r6040_start_xmit()", 0); 
    392  
    393         if (skb == NULL)        /* NULL skb directly return */ 
    394                 return 0; 
    395         if (skb->len >= MAX_BUF_SIZE) { /* Packet too long, drop it */ 
    396                 dev_kfree_skb(skb); 
    397                 return 0; 
    398         } 
     766        int ret = NETDEV_TX_OK; 
    399767 
    400768        /* Critical Section */ 
     
    402770 
    403771        /* TX resource check */ 
    404         if (!lp->tx_free_desc) {  
     772        if (!lp->tx_free_desc) { 
    405773                spin_unlock_irqrestore(&lp->lock, flags); 
    406                 printk(KERN_ERR DRV_NAME ": NO TX DESC "); 
    407                 return 1; 
     774                netif_stop_queue(dev); 
     775                printk(KERN_ERR DRV_NAME ": no tx descriptor\n"); 
     776                ret = NETDEV_TX_BUSY; 
     777                return ret; 
    408778        } 
    409779 
    410780        /* Statistic Counter */ 
    411         lp->stats.tx_packets++; 
    412         lp->stats.tx_bytes += skb->len; 
    413          
     781        dev->stats.tx_packets++; 
     782        dev->stats.tx_bytes += skb->len; 
    414783        /* Set TX descriptor & Transmit it */ 
    415784        lp->tx_free_desc--; 
    416785        descptr = lp->tx_insert_ptr; 
    417         if (skb->len < 0x3c) 
    418                 descptr->len = 0x3c; 
     786        if (skb->len < MISR) 
     787                descptr->len = MISR; 
    419788        else 
    420789                descptr->len = skb->len; 
    421790 
    422791        descptr->skb_ptr = skb; 
    423         descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, skb->data, skb->len, PCI_DMA_TODEVICE)); 
     792        descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, 
     793                skb->data, skb->len, PCI_DMA_TODEVICE)); 
    424794        descptr->status = 0x8000; 
    425         outw(0x01, ioaddr + 0x14); 
     795        /* Trigger the MAC to check the TX descriptor */ 
     796        iowrite16(0x01, ioaddr + MTPR); 
    426797        lp->tx_insert_ptr = descptr->vndescp; 
    427798 
    428 #if RDC_DEBUG 
    429  printk("Xmit(): %08lx:%04x %04x %08lx %08lx %08lx %08lx\n", descptr, descptr->status, descptr->len, descptr->buf, descptr->skb_ptr, descptr->ndesc, descptr->vndescp); 
    430 #endif 
    431  
    432799        /* If no tx resource, stop */ 
    433         if (!lp->tx_free_desc)  
     800        if (!lp->tx_free_desc) 
    434801                netif_stop_queue(dev); 
    435802 
    436803        dev->trans_start = jiffies; 
    437804        spin_unlock_irqrestore(&lp->lock, flags); 
    438         return 0; 
    439 } 
    440  
    441 /* The RDC interrupt handler. */ 
    442 static irqreturn_t 
    443 r6040_interrupt(int irq, void *dev_id) 
    444 { 
    445         struct net_device *dev = dev_id; 
    446         struct r6040_private *lp; 
    447         struct r6040_descriptor *descptr; 
    448         struct sk_buff *skb_ptr; 
    449         int ioaddr, status; 
     805        return ret; 
     806} 
     807 
     808static void r6040_multicast_list(struct net_device *dev) 
     809{ 
     810        struct r6040_private *lp = netdev_priv(dev); 
     811        void __iomem *ioaddr = lp->base; 
     812        u16 *adrp; 
     813        u16 reg; 
    450814        unsigned long flags; 
    451 #ifdef CONFIG_R6040_NAPI 
    452         int handled = 1; 
    453 #else 
    454         int handled = 0; 
    455 #endif 
    456  
    457         RDC_DBUG("r6040_interrupt()", 0); 
    458         if (dev == NULL) { 
    459                 printk (KERN_ERR DRV_NAME ": INT() unknown device.\n"); 
    460                 return IRQ_RETVAL(handled); 
    461         } 
    462  
    463         lp = (struct r6040_private *)dev->priv; 
    464         spin_lock_irqsave(&lp->lock, flags); 
    465  
    466         /* Check MAC Interrupt status */ 
    467         ioaddr = dev->base_addr; 
    468         outw(0x0, ioaddr + 0x40);       /* Mask Off RDC MAC interrupt */ 
    469         status = inw(ioaddr + 0x3c);    /* Read INTR status and clear */ 
    470          
    471  
    472 #ifdef CONFIG_R6040_NAPI 
    473         if (netif_rx_schedule_prep(dev)) { 
    474                 NAPI_status = status; 
    475                 __netif_rx_schedule(dev); 
    476         } 
    477  
    478         spin_unlock_irqrestore(&lp->lock, flags); 
    479         return IRQ_RETVAL(handled); 
    480 #else            
    481         /* TX interrupt request */ 
    482         if (status & 0x10) { 
    483                 handled = 1; 
    484                 descptr = lp->tx_remove_ptr; 
    485                 while (lp->tx_free_desc < TX_DCNT) { 
    486                         if (descptr->status & 0x8000) 
    487                                 break; /* Not complte */ 
    488                         skb_ptr = descptr->skb_ptr; 
    489                         pci_unmap_single(lp->pdev, descptr->buf, skb_ptr->len, PCI_DMA_TODEVICE); 
    490                         dev_kfree_skb_irq(skb_ptr); /* Free buffer */ 
    491                         descptr->skb_ptr = 0; 
    492                         descptr = descptr->vndescp; /* To next descriptor */ 
    493                         lp->tx_free_desc++; 
    494                 } 
    495                 lp->tx_remove_ptr = descptr; 
    496                 if (lp->tx_free_desc) 
    497                         netif_wake_queue(dev); 
    498         }  
    499  
    500         /* RX interrupt request */ 
    501         if (status & 0x01) { 
    502                 handled = 1; 
    503                 descptr = lp->rx_remove_ptr; 
    504                 while(lp->rx_free_desc) { 
    505                         if (descptr->status & 0x8000) break; /* No Rx packet */ 
    506                         skb_ptr = descptr->skb_ptr; 
    507                         descptr->skb_ptr = 0; 
    508                         skb_ptr->dev = dev; 
    509                         skb_put(skb_ptr, descptr->len - 4); 
    510                         pci_unmap_single(lp->pdev, descptr->buf, MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    511                         skb_ptr->protocol = eth_type_trans(skb_ptr, dev); 
    512                         netif_rx(skb_ptr);  /* Send to upper layer */ 
    513                         lp->stats.rx_packets++; 
    514                         lp->stats.rx_bytes += descptr->len; 
    515                         descptr = descptr->vndescp; /* To next descriptor */ 
    516                         lp->rx_free_desc--; 
    517                 } 
    518                 lp->rx_remove_ptr = descptr; 
    519         } 
    520  
    521         /* Allocate new RX buffer */ 
    522         if (lp->rx_free_desc < RX_DCNT) rx_buf_alloc(lp,dev); 
    523  
    524         outw(R6040_INT_MASK, ioaddr + 0x40);    /* TX/RX interrupt enable */ 
    525         spin_unlock_irqrestore(&lp->lock, flags); 
    526 #endif 
    527         return IRQ_RETVAL(handled); 
    528 } 
    529  
    530  
    531 static struct net_device_stats * 
    532 r6040_get_stats(struct net_device *dev) 
    533 { 
    534         struct r6040_private *lp = dev->priv; 
    535  
    536         RDC_DBUG("r6040_get_stats()", 0); 
    537         return &lp->stats; 
    538 } 
    539  
    540 /* 
    541  *     Set or clear the multicast filter for this adaptor. 
    542  */ 
    543 static void 
    544 set_multicast_list(struct net_device *dev) 
    545 { 
    546         struct r6040_private *lp = dev->priv; 
    547         struct dev_mc_list *mcptr; 
    548         int ioaddr = dev->base_addr; 
    549         u16 *adrp, i; 
    550         unsigned long flags; 
    551  
    552         RDC_DBUG("set_multicast_list()", 0); 
     815        struct dev_mc_list *dmi = dev->mc_list; 
     816        int i; 
    553817 
    554818        /* MAC Address */ 
    555         adrp = (u16 *) dev->dev_addr; 
    556         outw(adrp[0], ioaddr + 0x68); 
    557         outw(adrp[1], ioaddr + 0x6A); 
    558         outw(adrp[2], ioaddr + 0x6C); 
    559  
    560  
    561 #if RDC_DEBUG 
    562         printk("MAC ADDR: %04x %04x %04x\n", adrp[0], adrp[1], adrp[2]); 
    563 #endif 
     819        adrp = (u16 *)dev->dev_addr; 
     820        iowrite16(adrp[0], ioaddr + MID_0L); 
     821        iowrite16(adrp[1], ioaddr + MID_0M); 
     822        iowrite16(adrp[2], ioaddr + MID_0H); 
    564823 
    565824        /* Promiscous Mode */ 
    566825        spin_lock_irqsave(&lp->lock, flags); 
    567         i = inw(ioaddr) & ~0x0120;              /* Clear AMCP & PROM */ 
     826 
     827        /* Clear AMCP & PROM bits */ 
     828        reg = ioread16(ioaddr) & ~0x0120; 
    568829        if (dev->flags & IFF_PROMISC) { 
    569                 i |= 0x0020; 
     830                reg |= 0x0020; 
    570831                lp->mcr0 |= 0x0020; 
    571832        } 
    572         if (dev->mc_count > 4) 
    573                 i |= 0x0020;    /* Too many multicast address */ 
    574  
    575         outw(i, ioaddr); 
     833        /* Too many multicast addresses 
     834         * accept all traffic */ 
     835        else if ((dev->mc_count > MCAST_MAX) 
     836                || (dev->flags & IFF_ALLMULTI)) 
     837                reg |= 0x0020; 
     838 
     839        iowrite16(reg, ioaddr); 
    576840        spin_unlock_irqrestore(&lp->lock, flags); 
    577          
    578         /* Multicast Address */ 
    579         if (dev->mc_count > 4)  /* Wait to do: Hash Table for multicast */ 
    580                 return; 
    581  
     841 
     842        /* Build the hash table */ 
     843        if (dev->mc_count > MCAST_MAX) { 
     844                u16 hash_table[4]; 
     845                u32 crc; 
     846 
     847                for (i = 0; i < 4; i++) 
     848                        hash_table[i] = 0; 
     849 
     850                for (i = 0; i < dev->mc_count; i++) { 
     851                        char *addrs = dmi->dmi_addr; 
     852 
     853                        dmi = dmi->next; 
     854 
     855                        if (!(*addrs & 1)) 
     856                                continue; 
     857 
     858                        crc = ether_crc_le(6, addrs); 
     859                        crc >>= 26; 
     860                        hash_table[crc >> 4] |= 1 << (15 - (crc & 0xf)); 
     861                } 
     862                /* Write the index of the hash table */ 
     863                for (i = 0; i < 4; i++) 
     864                        iowrite16(hash_table[i] << 14, ioaddr + MCR1); 
     865                /* Fill the MAC hash tables with their values */ 
     866                iowrite16(hash_table[0], ioaddr + MAR0); 
     867                iowrite16(hash_table[1], ioaddr + MAR1); 
     868                iowrite16(hash_table[2], ioaddr + MAR2); 
     869                iowrite16(hash_table[3], ioaddr + MAR3); 
     870        } 
    582871        /* Multicast Address 1~4 case */ 
    583         for (i = 0, mcptr = dev->mc_list; (i < dev->mc_count) && (i < 4); i++) { 
    584                 adrp = (u16 *)mcptr->dmi_addr; 
    585                 outw(adrp[0], ioaddr + 0x70 + 8*i); 
    586                 outw(adrp[1], ioaddr + 0x72 + 8*i); 
    587                 outw(adrp[2], ioaddr + 0x74 + 8*i); 
    588                 mcptr = mcptr->next; 
    589 #if RDC_DEBUG 
    590         printk("M_ADDR: %04x %04x %04x\n", adrp[0], adrp[1], adrp[2]); 
    591 #endif 
    592         } 
    593         for (i = dev->mc_count; i < 4; i++) { 
    594                 outw(0xffff, ioaddr + 0x68 + 8*i); 
    595                 outw(0xffff, ioaddr + 0x6A + 8*i); 
    596                 outw(0xffff, ioaddr + 0x6C + 8*i); 
    597         } 
    598 } 
    599  
    600 static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info) 
    601 { 
    602         struct r6040_private *rp = dev->priv; 
    603  
    604         strcpy (info->driver, DRV_NAME); 
    605         strcpy (info->version, DRV_VERSION); 
    606         strcpy (info->bus_info, pci_name(rp->pdev)); 
     872        for (i = 0, dmi; (i < dev->mc_count) && (i < MCAST_MAX); i++) { 
     873                adrp = (u16 *)dmi->dmi_addr; 
     874                iowrite16(adrp[0], ioaddr + MID_1L + 8*i); 
     875                iowrite16(adrp[1], ioaddr + MID_1M + 8*i); 
     876                iowrite16(adrp[2], ioaddr + MID_1H + 8*i); 
     877                dmi = dmi->next; 
     878        } 
     879        for (i = dev->mc_count; i < MCAST_MAX; i++) { 
     880                iowrite16(0xffff, ioaddr + MID_0L + 8*i); 
     881                iowrite16(0xffff, ioaddr + MID_0M + 8*i); 
     882                iowrite16(0xffff, ioaddr + MID_0H + 8*i); 
     883        } 
     884} 
     885 
     886static void netdev_get_drvinfo(struct net_device *dev, 
     887                        struct ethtool_drvinfo *info) 
     888{ 
     889        struct r6040_private *rp = netdev_priv(dev); 
     890 
     891        strcpy(info->driver, DRV_NAME); 
     892        strcpy(info->version, DRV_VERSION); 
     893        strcpy(info->bus_info, pci_name(rp->pdev)); 
     894} 
     895 
     896static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
     897{ 
     898        struct r6040_private *rp = netdev_priv(dev); 
     899        int rc; 
     900 
     901        spin_lock_irq(&rp->lock); 
     902        rc = mii_ethtool_gset(&rp->mii_if, cmd); 
     903        spin_unlock_irq(&rp->lock); 
     904 
     905        return rc; 
     906} 
     907 
     908static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 
     909{ 
     910        struct r6040_private *rp = netdev_priv(dev); 
     911        int rc; 
     912 
     913        spin_lock_irq(&rp->lock); 
     914        rc = mii_ethtool_sset(&rp->mii_if, cmd); 
     915        spin_unlock_irq(&rp->lock); 
     916        r6040_set_carrier(&rp->mii_if); 
     917 
     918        return rc; 
     919} 
     920 
     921static u32 netdev_get_link(struct net_device *dev) 
     922{ 
     923        struct r6040_private *rp = netdev_priv(dev); 
     924 
     925        return mii_link_ok(&rp->mii_if); 
    607926} 
    608927 
    609928static struct ethtool_ops netdev_ethtool_ops = { 
    610929        .get_drvinfo            = netdev_get_drvinfo, 
     930        .get_settings           = netdev_get_settings, 
     931        .set_settings           = netdev_set_settings, 
     932        .get_link               = netdev_get_link, 
    611933}; 
    612934 
    613 static int 
    614 r6040_close(struct net_device *dev) 
    615 { 
    616         struct r6040_private *lp = dev->priv; 
    617  
    618         RDC_DBUG("r6040_close()", 0); 
    619  
    620         /* deleted timer */ 
    621         del_timer_sync(&lp->timer); 
    622  
    623         spin_lock_irq(&lp->lock); 
    624  
    625         netif_stop_queue(dev); 
    626  
    627         r6040_down(dev); 
    628  
    629         spin_unlock_irq(&lp->lock); 
    630  
     935static int __devinit r6040_init_one(struct pci_dev *pdev, 
     936                                         const struct pci_device_id *ent) 
     937{ 
     938        struct net_device *dev; 
     939        struct r6040_private *lp; 
     940        void __iomem *ioaddr; 
     941        int err, io_size = R6040_IO_SIZE; 
     942        static int card_idx = -1; 
     943        int bar = 0; 
     944        long pioaddr; 
     945        u16 *adrp; 
     946 
     947        printk(KERN_INFO "%s\n", version); 
     948 
     949        err = pci_enable_device(pdev); 
     950        if (err) 
     951                return err; 
     952 
     953        /* this should always be supported */ 
     954        if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) { 
     955                printk(KERN_ERR DRV_NAME "32-bit PCI DMA addresses" 
     956                                "not supported by the card\n"); 
     957                return -ENODEV; 
     958        } 
     959        if (pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) { 
     960                printk(KERN_ERR DRV_NAME "32-bit PCI DMA addresses" 
     961                                "not supported by the card\n"); 
     962                return -ENODEV; 
     963        } 
     964 
     965        /* IO Size check */ 
     966        if (pci_resource_len(pdev, 0) < io_size) { 
     967                printk(KERN_ERR "Insufficient PCI resources, aborting\n"); 
     968                return -EIO; 
     969        } 
     970 
     971        pioaddr = pci_resource_start(pdev, 0);  /* IO map base address */ 
     972        pci_set_master(pdev); 
     973 
     974        dev = alloc_etherdev(sizeof(struct r6040_private)); 
     975        if (!dev) { 
     976                printk(KERN_ERR "Failed to allocate etherdev\n"); 
     977                return -ENOMEM; 
     978        } 
     979        SET_NETDEV_DEV(dev, &pdev->dev); 
     980        lp = netdev_priv(dev); 
     981        lp->pdev = pdev; 
     982 
     983        if (pci_request_regions(pdev, DRV_NAME)) { 
     984                printk(KERN_ERR DRV_NAME ": Failed to request PCI regions\n"); 
     985                err = -ENODEV; 
     986                goto err_out_disable; 
     987        } 
     988 
     989        ioaddr = pci_iomap(pdev, bar, io_size); 
     990        if (!ioaddr) { 
     991                printk(KERN_ERR "ioremap failed for device %s\n", 
     992                        pci_name(pdev)); 
     993                return -EIO; 
     994        } 
     995 
     996        /* Init system & device */ 
     997        lp->base = ioaddr; 
     998        dev->irq = pdev->irq; 
     999 
     1000        spin_lock_init(&lp->lock); 
     1001        pci_set_drvdata(pdev, dev); 
     1002 
     1003        /* Set MAC address */ 
     1004        card_idx++; 
     1005 
     1006        adrp = (u16 *)dev->dev_addr; 
     1007        adrp[0] = ioread16(ioaddr + MID_0L); 
     1008        adrp[1] = ioread16(ioaddr + MID_0M); 
     1009        adrp[2] = ioread16(ioaddr + MID_0H); 
     1010 
     1011        /* Link new device into r6040_root_dev */ 
     1012        lp->pdev = pdev; 
     1013 
     1014        /* Init RDC private data */ 
     1015        lp->mcr0 = 0x1002; 
     1016        lp->phy_addr = phy_table[card_idx]; 
     1017        lp->switch_sig = 0; 
     1018 
     1019        /* The RDC-specific entries in the device structure. */ 
     1020        dev->open = &r6040_open; 
     1021        dev->hard_start_xmit = &r6040_start_xmit; 
     1022        dev->stop = &r6040_close; 
     1023        dev->get_stats = r6040_get_stats; 
     1024        dev->set_multicast_list = &r6040_multicast_list; 
     1025        dev->do_ioctl = &r6040_ioctl; 
     1026        dev->ethtool_ops = &netdev_ethtool_ops; 
     1027        dev->tx_timeout = &r6040_tx_timeout; 
     1028        dev->watchdog_timeo = TX_TIMEOUT; 
     1029#ifdef CONFIG_NET_POLL_CONTROLLER 
     1030        dev->poll_controller = r6040_poll_controller; 
     1031#endif 
     1032        netif_napi_add(dev, &lp->napi, r6040_poll, 64); 
     1033        lp->mii_if.dev = dev; 
     1034        lp->mii_if.mdio_read = mdio_read; 
     1035        lp->mii_if.mdio_write = mdio_write; 
     1036        lp->mii_if.phy_id = lp->phy_addr; 
     1037        lp->mii_if.phy_id_mask = 0x1f; 
     1038        lp->mii_if.reg_num_mask = 0x1f; 
     1039 
     1040        /* Register net device. After this dev->name assign */ 
     1041        err = register_netdev(dev); 
     1042        if (err) { 
     1043                printk(KERN_ERR DRV_NAME ": Failed to register net device\n"); 
     1044                goto err_out_res; 
     1045        } 
    6311046        return 0; 
    632 } 
    633  
    634 static int netdev_ioctl (struct net_device *dev, struct ifreq *rq, int cmd) 
    635 { 
    636         struct r6040_private *lp = dev->priv; 
    637  
    638         RDC_DBUG("netdev_ioctl()", 0); 
    639  
    640         if (lp->switch_sig == ICPLUS_PHY_ID && cmd == SIOCDEVPRIVATE) { 
    641                 unsigned long *data = (unsigned long *)rq->ifr_data, args[4]; 
    642                 int ioaddr = dev->base_addr; 
    643                 unsigned int val; 
    644  
    645                 data = (unsigned long *)rq->ifr_data; 
    646                 if (copy_from_user(args, data, 4*sizeof(unsigned long))) 
    647                         return -EFAULT; 
    648  
    649                 /* port priority */ 
    650                 if(args[0]&(1<<31))phy_write(ioaddr, 29, 19, (phy_read(ioaddr, 29, 19) | 0x2000));      /* port 0 */ 
    651                 if(args[0]&(1<<29))phy_write(ioaddr, 29, 19, (phy_read(ioaddr, 29, 19) | 0x0020));      /* port 1 */ 
    652                 if(args[0]&(1<<27))phy_write(ioaddr, 29, 20, (phy_read(ioaddr, 29, 20) | 0x2000));      /* port 2 */ 
    653                 if(args[0]&(1<<25))phy_write(ioaddr, 29, 20, (phy_read(ioaddr, 29, 20) | 0x0020));      /* port 3 */ 
    654  
    655         } 
    656         return -EOPNOTSUPP; 
    657 } 
    658  
    659 /** 
    660         Stop RDC MAC and Free the allocated resource 
    661  */ 
    662 static void r6040_down(struct net_device *dev) 
    663 { 
    664         struct r6040_private *lp = dev->priv; 
    665         int i; 
    666         int ioaddr = dev->base_addr; 
    667  
    668         RDC_DBUG("r6040_down()", 0); 
    669  
    670         /* Stop MAC */ 
    671         outw(0x0000, ioaddr + 0x40);    /* Mask Off Interrupt */ 
    672         outw(0x0001, ioaddr + 0x04);    /* Reset RDC MAC */ 
    673         i = 0; 
    674         do{}while((i++ < 2048) && (inw(ioaddr + 0x04) & 0x1)); 
    675          
    676         free_irq(dev->irq, dev); 
    677  
    678         /* Free RX buffer */ 
    679         for (i = 0; i < RX_DCNT; i++) { 
    680                 if (lp->rx_insert_ptr->skb_ptr) { 
    681                         pci_unmap_single(lp->pdev, lp->rx_insert_ptr->buf, MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    682                         dev_kfree_skb(lp->rx_insert_ptr->skb_ptr); 
    683                         lp->rx_insert_ptr->skb_ptr = 0; 
    684                 } 
    685                 lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp; 
    686         } 
    687  
    688         /* Free TX buffer */ 
    689         for (i = 0; i < TX_DCNT; i++) { 
    690                 if (lp->tx_insert_ptr->skb_ptr) { 
    691                         pci_unmap_single(lp->pdev, lp->tx_insert_ptr->buf, MAX_BUF_SIZE, PCI_DMA_TODEVICE); 
    692                         dev_kfree_skb(lp->tx_insert_ptr->skb_ptr); 
    693                         lp->rx_insert_ptr->skb_ptr = 0; 
    694                 } 
    695                 lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp; 
    696         } 
    697  
    698         /* Free Descriptor memory */ 
    699         pci_free_consistent(lp->pdev, ALLOC_DESC_SIZE, lp->desc_pool, lp->desc_dma); 
    700 } 
    701  
    702  
    703  
    704 #ifdef CONFIG_R6040_NAPI 
    705 static int r6040_poll(struct net_device *dev, int *budget) 
    706 { 
    707         struct r6040_private *lp; 
    708         struct r6040_descriptor *descptr; 
    709         struct sk_buff *skb_ptr; 
    710         int ioaddr, status; 
    711         unsigned long flags; 
    712          
    713          
    714         ioaddr = dev->base_addr; 
    715         lp = (struct r6040_private *)dev->priv; 
    716         unsigned long rx_work = dev->quota; 
    717         unsigned long rx;        
    718 #if 1 
    719         /* TX interrupt request */ 
    720         if (NAPI_status & 0x10) { 
    721                 descptr = lp->tx_remove_ptr; 
    722                 while (lp->tx_free_desc < TX_DCNT) { 
    723                         if (descptr->status & 0x8000) 
    724                                 break; /* Not complte */ 
    725                          
    726                         skb_ptr = descptr->skb_ptr; 
    727                         pci_unmap_single(lp->pdev, descptr->buf, skb_ptr->len, PCI_DMA_TODEVICE); 
    728                         dev_kfree_skb_irq(skb_ptr); /* Free buffer */ 
    729                         descptr->skb_ptr = 0; 
    730                         descptr = descptr->vndescp; /* To next descriptor */ 
    731                         lp->tx_free_desc++; 
    732                 } 
    733                 lp->tx_remove_ptr = descptr; 
    734                 if (lp->tx_free_desc) netif_wake_queue(dev); 
    735         } 
    736 #endif   
    737 #if 1 
    738         /* RX interrupt request */ 
    739         if (NAPI_status & 0x01) { 
    740                 descptr = lp->rx_remove_ptr; 
    741                 while (lp->rx_free_desc) { 
    742                         if (descptr->status & 0x8000) 
    743                                 break; /* No Rx packet */ 
    744                         skb_ptr = descptr->skb_ptr; 
    745                         descptr->skb_ptr = 0; 
    746                         skb_ptr->dev = dev; 
    747                         skb_put(skb_ptr, descptr->len - 4); 
    748                         pci_unmap_single(lp->pdev, descptr->buf, MAX_BUF_SIZE, PCI_DMA_FROMDEVICE); 
    749                         skb_ptr->protocol = eth_type_trans(skb_ptr, dev); 
    750                         netif_receive_skb(skb_ptr); /* Send to upper layer */ 
    751                         lp->stats.rx_packets++; 
    752                         lp->stats.rx_bytes += descptr->len; 
    753                         descptr = descptr->vndescp; /* To next descriptor */ 
    754                         lp->rx_free_desc--; 
    755                 } 
    756                 lp->rx_remove_ptr = descptr; 
    757         } 
    758         /* Allocate new RX buffer */ 
    759         if (lp->rx_free_desc < RX_DCNT) 
    760                 rx_buf_alloc(lp, dev); 
    761          
    762         local_irq_disable(); 
    763         netif_rx_complete(dev); 
    764         outw(R6040_INT_MASK, ioaddr + 0x40); 
    765         local_irq_enable(); 
    766         return 0; 
    767 #endif           
    768 } 
    769 #endif 
    770  
    771 /* Init RDC MAC */ 
    772 static void r6040_up(struct net_device *dev) 
    773 { 
    774         struct r6040_private *lp = dev->priv; 
    775         struct r6040_descriptor *descptr; 
    776         int i; 
    777         int ioaddr = dev->base_addr; 
    778         u32 tmp_addr; 
    779         dma_addr_t desc_dma, start_dma; 
    780          
    781         RDC_DBUG("r6040_up()", 0); 
    782  
    783         /* Initilize */ 
    784         lp->tx_free_desc = TX_DCNT; 
    785         lp->rx_free_desc = 0; 
    786  
    787         /* Init descriptor */ 
    788         memset(lp->desc_pool, 0, ALLOC_DESC_SIZE); /* Let all descriptor = 0 */ 
    789         lp->tx_insert_ptr = (struct r6040_descriptor *)lp->desc_pool; 
    790         lp->tx_remove_ptr = lp->tx_insert_ptr; 
    791         lp->rx_insert_ptr = (struct r6040_descriptor *)lp->tx_insert_ptr+TX_DCNT; 
    792         lp->rx_remove_ptr = lp->rx_insert_ptr; 
    793  
    794         /* Init TX descriptor */ 
    795         descptr = lp->tx_insert_ptr; 
    796         desc_dma = lp->desc_dma; 
    797         start_dma = desc_dma; 
    798         for (i = 0; i < TX_DCNT; i++) { 
    799                 descptr->ndesc = cpu_to_le32(desc_dma + sizeof(struct r6040_descriptor)); 
    800                 descptr->vndescp = (descptr + 1); 
    801                 descptr = (descptr + 1); 
    802                 desc_dma += sizeof(struct r6040_descriptor); 
    803         } 
    804         (descptr - 1)->ndesc = cpu_to_le32(start_dma); 
    805         (descptr - 1)->vndescp = lp->tx_insert_ptr; 
    806  
    807         /* Init RX descriptor */ 
    808         start_dma = desc_dma; 
    809         descptr = lp->rx_insert_ptr; 
    810         for (i = 0; i < RX_DCNT; i++) { 
    811                 descptr->ndesc = cpu_to_le32(desc_dma + sizeof(struct r6040_descriptor)); 
    812                 descptr->vndescp = (descptr + 1); 
    813                 descptr = (descptr + 1); 
    814                 desc_dma += sizeof(struct r6040_descriptor); 
    815         } 
    816         (descptr - 1)->ndesc = cpu_to_le32(start_dma); 
    817         (descptr - 1)->vndescp = lp->rx_insert_ptr; 
    818  
    819         /* Allocate buffer for RX descriptor */ 
    820         rx_buf_alloc(lp, dev); 
    821  
    822 #if RDC_DEBUG 
    823 descptr = lp->tx_insert_ptr; 
    824 for (i = 0; i < TX_DCNT; i++) { 
    825  printk("%08lx:%04x %04x %08lx %08lx %08lx %08lx\n", descptr, descptr->status, descptr->len, descptr->buf, descptr->skb_ptr, descptr->ndesc, descptr->vndescp); 
    826  descptr = descptr->vndescp; 
    827 } 
    828 descptr = lp->rx_insert_ptr; 
    829 for (i = 0; i < RX_DCNT; i++) { 
    830  printk("%08lx:%04x %04x %08lx %08lx %08lx %08lx\n", descptr, descptr->status, descptr->len, descptr->buf, descptr->skb_ptr, descptr->ndesc, descptr->vndescp); 
    831  descptr = descptr->vndescp; 
    832 } 
    833 #endif 
    834  
    835         /* MAC operation register */ 
    836         outw(0x01, ioaddr+0x04);        /* Reset MAC */ 
    837         outw(2, ioaddr+0xAC);           /* Reset internal state machine */ 
    838         outw(0, ioaddr+0xAC); 
    839         udelay(5000); 
    840  
    841         /* TX and RX descriptor start Register */ 
    842         tmp_addr = cpu_to_le32(lp->tx_insert_ptr); 
    843         tmp_addr = virt_to_bus((volatile void *)tmp_addr); 
    844         outw((u16) tmp_addr, ioaddr+0x2c); 
    845         outw(tmp_addr >> 16, ioaddr+0x30); 
    846         tmp_addr = cpu_to_le32(lp->rx_insert_ptr); 
    847         tmp_addr = virt_to_bus((volatile void *)tmp_addr); 
    848         outw((u16) tmp_addr, ioaddr+0x34); 
    849         outw(tmp_addr >> 16, ioaddr+0x38); 
    850  
    851         /* Buffer Size Register */ 
    852         outw(MAX_BUF_SIZE, ioaddr+0x18); 
    853  
    854         if ((lp->switch_sig = phy_read(ioaddr, 0, 2)) == ICPLUS_PHY_ID) { 
    855                 phy_write(ioaddr, 29,31, 0x175C); /* Enable registers */ 
    856                 lp->phy_mode = 0x8000; 
    857         } else { 
    858                 /* PHY Mode Check */ 
    859                 phy_write(ioaddr, lp->phy_addr, 4, PHY_CAP); 
    860                 phy_write(ioaddr, lp->phy_addr, 0, PHY_MODE); 
    861  
    862                 if (PHY_MODE == 0x3100) 
    863                         lp->phy_mode = phy_mode_chk(dev); 
    864                 else 
    865                         lp->phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
    866         } 
    867         /* MAC Bus Control Register */ 
    868         outw(MBCR_DEFAULT, ioaddr+0x8); 
    869  
    870         /* MAC TX/RX Enable */ 
    871         lp->mcr0 |= lp->phy_mode; 
    872         outw(lp->mcr0, ioaddr); 
    873  
    874         /* set interrupt waiting time and packet numbers */ 
    875         outw(0x0802, ioaddr + 0x0C); 
    876         outw(0x0802, ioaddr + 0x10); 
    877  
    878         /* upgrade performance (by RDC guys) */ 
    879         phy_write(ioaddr, 30, 17, (phy_read(ioaddr, 30, 17) | 0x4000));        //bit 14=1 
    880         phy_write(ioaddr, 30, 17, ~((~phy_read(ioaddr, 30, 17)) | 0x2000));    //bit 13=0 
    881         phy_write(ioaddr, 0, 19, 0x0000); 
    882         phy_write(ioaddr, 0, 30, 0x01F0); 
    883  
    884         /* Interrupt Mask Register */ 
    885         outw(R6040_INT_MASK, ioaddr + 0x40); 
    886 } 
    887  
    888 /* 
    889   A periodic timer routine 
    890         Polling PHY Chip Link Status 
    891 */ 
    892 static void r6040_timer(unsigned long data) 
    893 { 
    894         struct net_device *dev = (struct net_device *)data; 
    895         struct r6040_private *lp = dev->priv; 
    896         u16 ioaddr = dev->base_addr, phy_mode; 
    897  
    898         RDC_DBUG("r6040_timer()", 0); 
    899  
    900         /* Polling PHY Chip Status */ 
    901         if (PHY_MODE == 0x3100)  
    902                 phy_mode = phy_mode_chk(dev); 
    903         else 
    904                 phy_mode = (PHY_MODE & 0x0100) ? 0x8000:0x0; 
    905  
    906         if (phy_mode != lp->phy_mode) { 
    907                 lp->phy_mode = phy_mode; 
    908                 lp->mcr0 = (lp->mcr0 & 0x7fff) | phy_mode; 
    909                 outw(lp->mcr0, ioaddr); 
    910                 printk(KERN_INFO "Link Change %x \n", inw(ioaddr)); 
    911         } 
    912  
    913         /* Debug */ 
    914 //      printk("<RDC> Timer: CR0 %x CR40 %x CR3C %x\n", inw(ioaddr), inw(ioaddr+0x40), inw(ioaddr+0x3c)); 
    915  
    916         /* Timer active again */ 
    917         lp->timer.expires = TIMER_WUT; 
    918         add_timer(&lp->timer); 
    919 } 
    920  
    921 /* Allocate skb buffer for rx descriptor */ 
    922 static void rx_buf_alloc(struct r6040_private *lp, struct net_device *dev) 
    923 { 
    924         struct r6040_descriptor *descptr; 
    925         int ioaddr = dev->base_addr ; 
    926  
    927         RDC_DBUG("rx_buf_alloc()", 0); 
    928  
    929         descptr = lp->rx_insert_ptr; 
    930         while (lp->rx_free_desc < RX_DCNT) { 
    931                 descptr->skb_ptr = dev_alloc_skb(MAX_BUF_SIZE); 
    932  
    933                 if (!descptr->skb_ptr) 
    934                         break; 
    935                 descptr->buf = cpu_to_le32(pci_map_single(lp->pdev, descptr->skb_ptr->tail, MAX_BUF_SIZE, PCI_DMA_FROMDEVICE)); 
    936                 descptr->status = 0x8000; 
    937                 descptr = descptr->vndescp; 
    938                 lp->rx_free_desc++; 
    939                 outw(lp->mcr0 | 0x0002, ioaddr); /* Trigger Rx DMA */ 
    940         } 
    941         lp->rx_insert_ptr = descptr; 
    942 } 
    943  
    944 /* Status of PHY CHIP */ 
    945 static int phy_mode_chk(struct net_device *dev) 
    946 { 
    947         struct r6040_private *lp = dev->priv; 
    948         int ioaddr = dev->base_addr, phy_dat; 
    949  
    950         RDC_DBUG("phy_mode_chk()", 0); 
    951  
    952         /* PHY Link Status Check */ 
    953         phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
    954         if (!(phy_dat & 0x4)) 
    955                 return 0x8000;  /* Link Failed, full duplex */ 
    956  
    957         /* PHY Chip Auto-Negotiation Status */ 
    958         phy_dat = phy_read(ioaddr, lp->phy_addr, 1); 
    959         if (phy_dat & 0x0020) { 
    960                 /* Auto Negotiation Mode */ 
    961                 phy_dat = phy_read(ioaddr, lp->phy_addr, 5); 
    962                 phy_dat &= phy_read(ioaddr, lp->phy_addr, 4); 
    963                 if (phy_dat & 0x140) 
    964                         phy_dat = 0x8000; 
    965                 else 
    966                         phy_dat = 0; 
    967         } else { 
    968                 /* Force Mode */ 
    969                 phy_dat = phy_read(ioaddr, lp->phy_addr, 0); 
    970                 if (phy_dat & 0x100) phy_dat = 0x8000; 
    971                 else phy_dat = 0x0000; 
    972         } 
    973  
    974         return phy_dat; 
    975 }; 
    976  
    977 /* Read a word data from PHY Chip */ 
    978 static int phy_read(int ioaddr, int phy_addr, int reg_idx) 
    979 { 
    980         int i = 0; 
    981  
    982         RDC_DBUG("phy_read()", 0); 
    983         outw(0x2000 + reg_idx + (phy_addr << 8), ioaddr + 0x20); 
    984         do {} while ((i++ < 2048) && (inw(ioaddr + 0x20) & 0x2000)); 
    985  
    986         return inw(ioaddr + 0x24); 
    987 } 
    988  
    989 /* Write a word data from PHY Chip */ 
    990 static void phy_write(int ioaddr, int phy_addr, int reg_idx, int dat) 
    991 { 
    992         int i = 0; 
    993  
    994         RDC_DBUG("phy_write()", 0); 
    995         outw(dat, ioaddr + 0x28); 
    996         outw(0x4000 + reg_idx + (phy_addr << 8), ioaddr + 0x20); 
    997         do{}while( (i++ < 2048) && (inw(ioaddr + 0x20) & 0x4000) ); 
    998 } 
    999  
    1000 enum { 
    1001         RDC_6040 = 0 
    1002 }; 
     1047 
     1048err_out_res: 
     1049        pci_release_regions(pdev); 
     1050err_out_disable: 
     1051        pci_disable_device(pdev); 
     1052        pci_set_drvdata(pdev, NULL); 
     1053        free_netdev(dev); 
     1054 
     1055        return err; 
     1056} 
     1057 
     1058static void __devexit r6040_remove_one(struct pci_dev *pdev) 
     1059{ 
     1060        struct net_device *dev = pci_get_drvdata(pdev); 
     1061 
     1062        unregister_netdev(dev); 
     1063        pci_release_regions(pdev); 
     1064        free_netdev(dev); 
     1065        pci_disable_device(pdev); 
     1066        pci_set_drvdata(pdev, NULL); 
     1067} 
     1068 
    10031069 
    10041070static struct pci_device_id r6040_pci_tbl[] = { 
    1005         {PCI_VENDOR_ID_RDC, PCI_DEVICE_ID_RDC_R6040, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RDC_6040}, 
    1006         /*{0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, 0, 0, RDC_6040},*/ 
    1007         {0,} 
     1071        { PCI_DEVICE(PCI_VENDOR_ID_RDC, 0x6040) }, 
     1072        { 0 } 
    10081073}; 
    10091074MODULE_DEVICE_TABLE(pci, r6040_pci_tbl); 
    10101075 
    10111076static struct pci_driver r6040_driver = { 
    1012         .name           = "r6040", 
     1077        .name           = DRV_NAME, 
    10131078        .id_table       = r6040_pci_tbl, 
    10141079        .probe          = r6040_init_one, 
     
    10171082 
    10181083 
    1019 static int __init r6040_init (void) 
    1020 { 
    1021         RDC_DBUG("r6040_init()", 0); 
    1022  
    1023         printk(KERN_INFO "%s\n", version); 
    1024         printed_version = 1; 
    1025  
    1026         if (parent != NULL) { 
    1027                 struct net_device *the_parent = dev_get_by_name(parent); 
    1028  
    1029                 if (the_parent == NULL) { 
    1030                         printk (KERN_ERR DRV_NAME ": Unknown device \"%s\" specified.\n", parent); 
    1031                         return -EINVAL; 
    1032                 } 
    1033                 memcpy((u8 *)&adr_table[0][0], the_parent->dev_addr, 6); 
    1034                 memcpy((u8 *)&adr_table[1][0], the_parent->dev_addr, 6); 
    1035                 ++*(u8 *)&adr_table[0][5]; 
    1036         } 
    1037         return pci_register_driver (&r6040_driver); 
    1038 } 
    1039  
    1040  
    1041 static void __exit r6040_cleanup (void) 
    1042 { 
    1043         RDC_DBUG("r6040_cleanup()", 0); 
    1044         pci_unregister_driver (&r6040_driver); 
     1084static int __init r6040_init(void) 
     1085{ 
     1086        return pci_register_driver(&r6040_driver); 
     1087} 
     1088 
     1089 
     1090static void __exit r6040_cleanup(void) 
     1091{ 
     1092        pci_unregister_driver(&r6040_driver); 
    10451093} 
    10461094 
  • trunk/target/linux/rdc/patches/001-x86_generic_gpio.patch

    r9267 r10453  
    1 diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig 
     1diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig 
    22index 97b64d7..f8c1d32 100644 
    3 --- a/arch/i386/Kconfig 
    4 +++ b/arch/i386/Kconfig 
     3--- a/arch/x86/Kconfig 
     4+++ b/arch/x86/Kconfig 
    55@@ -79,6 +79,10 @@ config GENERIC_BUG 
    66        default y 
  • trunk/target/linux/rdc/patches/004-rdc_fixes.patch

    r9328 r10453  
    1 diff -urN linux-2.6.19/arch/i386/Kconfig linux-2.6.19.new/arch/i386/Kconfig 
    2 --- linux-2.6.19/arch/i386/Kconfig      2006-11-29 22:57:37.000000000 +0100 
    3 +++ linux-2.6.19.new/arch/i386/Kconfig  2006-12-17 17:13:33.000000000 +0100 
    4 @@ -180,6 +180,16 @@ 
    5           Only choose this option if you have such a system, otherwise you 
    6           should say N here. 
     1diff -urN linux-2.6.24/arch/x86/Kconfig linux-2.6.24.new/arch/x86/Kconfig 
     2--- linux-2.6.24/arch/x86/Kconfig       2008-01-24 23:58:37.000000000 +0100 
     3+++ linux-2.6.24.new/arch/x86/Kconfig   2008-02-11 18:24:27.000000000 +0100 
     4@@ -300,6 +300,17 @@ 
     5          supposed to run on these EM64T-based machines.  Only choose this option 
     6          if you have one of these machines. 
    77  
    88+config X86_RDC 
     
    1010+       select GENERIC_GPIO 
    1111+       select LEDS_GPIO 
     12+       select LEDS_CLASS 
    1213+       help 
    13 +         Support for RDC 3211 systems. Say 'Y' here if the kernel is  
    14 +         supposed to run on an IA-32 RDC R3211 system. 
    15 +         Only choose this option if you have such as system, otherwise you 
    16 +         should say N here. 
     14+          Support for RDC 3211 systems. Say 'Y' here if the kernel is 
     15+          supposed to run on an IA-32 RDC R3211 system. 
     16+          Only choose this option if you have such as system, otherwise you 
     17+          should say N here. 
    1718+ 
    1819 endchoice 
    1920  
    20  config ACPI_SRAT 
    21 diff -urN linux-2.6.19/arch/i386/Makefile linux-2.6.19.new/arch/i386/Makefile 
    22 --- linux-2.6.19/arch/i386/Makefile     2006-11-29 22:57:37.000000000 +0100 
    23 +++ linux-2.6.19.new/arch/i386/Makefile 2006-12-17 17:13:33.000000000 +0100 
    24 @@ -92,6 +92,10 @@ 
    25  mflags-$(CONFIG_X86_ES7000)    := -Iinclude/asm-i386/mach-es7000 
    26  mcore-$(CONFIG_X86_ES7000)     := mach-default 
    27  core-$(CONFIG_X86_ES7000)      := arch/i386/mach-es7000/ 
     21 config SCHED_NO_NO_OMIT_FRAME_POINTER 
     22diff -urN linux-2.6.24/arch/x86/kernel/reboot_fixups_32.c linux-2.6.24.new/arch/x86/kernel/reboot_fixups_32.c 
     23--- linux-2.6.24/arch/x86/kernel/reboot_fixups_32.c     2008-01-24 23:58:37.000000000 +0100 
     24+++ linux-2.6.24.new/arch/x86/kernel/reboot_fixups_32.c 2008-02-11 18:26:18.000000000 +0100 
     25@@ -30,6 +30,17 @@ 
     26        udelay(50); /* shouldn't get here but be safe and spin a while */ 
     27 } 
     28  
     29+static void r8610_reset(struct pci_dev *dev) 
     30+{ 
     31+       int i; 
     32+ 
     33+       outl(0x80003840,0xCF8); 
     34+       i=inl(0xCFC); 
     35+       i |= 0x1600; 
     36+       outl(i,0xCFC); 
     37+       outb(1,0x92); 
     38+} 
     39+ 
     40 struct device_fixup { 
     41        unsigned int vendor; 
     42        unsigned int device; 
     43@@ -40,6 +51,7 @@ 
     44 { PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY, cs5530a_warm_reset }, 
     45 { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA, cs5536_warm_reset }, 
     46 { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE, cs5530a_warm_reset }, 
     47+{ PCI_VENDOR_ID_RDC, PCI_DEVICE_ID_RDC_R6030, r8610_reset }, 
     48 }; 
     49  
     50 /* 
     51diff -urN linux-2.6.24/arch/x86/Makefile_32 linux-2.6.24.new/arch/x86/Makefile_32 
     52--- linux-2.6.24/arch/x86/Makefile_32   2008-01-24 23:58:37.000000000 +0100 
     53+++ linux-2.6.24.new/arch/x86/Makefile_32       2008-02-11 18:25:12.000000000 +0100 
     54@@ -99,6 +99,11 @@ 
     55 mcore-$(CONFIG_X86_ES7000)     := arch/x86/mach-default 
     56 core-$(CONFIG_X86_ES7000)      := arch/x86/mach-es7000/ 
     57  
    2858+# RDC subarch support 
    29 +mflags-$(CONFIG_X86_RDC)       := -Iinclude/asm-i386/mach-rdc 
    30 +mcore-$(CONFIG_X86_RDC)                := mach-default 
    31 +core-$(CONFIG_X86_RDC)         += arch/i386/mach-rdc/ 
     59+mflags-$(CONFIG_X86_RDC)       := -Iinclude/asm-x86/mach-rdc 
     60+mcore-$(CONFIG_X86_RDC)        := arch/x86/mach-default 
     61+core-$(CONFIG_X86_RDC)         += arch/x86/mach-rdc/ 
     62+ 
     63 # Xen paravirtualization support 
     64 core-$(CONFIG_XEN)             += arch/x86/xen/ 
    3265  
    33  # default subarch .h files 
    34  mflags-y += -Iinclude/asm-i386/mach-default 
    35 --- timex.h     2007-08-07 10:44:03.816112250 -0700 
    36 +++ linux/include/asm-i386/timex.h      2007-08-07 10:48:47.905866750 -0700 
    37 @@ -11,6 +11,8 @@ 
     66diff -urN linux-2.6.24/include/asm-x86/timex.h linux-2.6.24.new/include/asm-x86/timex.h 
     67--- linux-2.6.24/include/asm-x86/timex.h        2008-01-24 23:58:37.000000000 +0100 
     68+++ linux-2.6.24.new/include/asm-x86/timex.h    2008-02-11 18:25:43.000000000 +0100 
     69@@ -7,6 +7,8 @@ 
    3870  
    3971 #ifdef CONFIG_X86_ELAN 
    40  #  define CLOCK_TICK_RATE 1189200 /* AMD Elan has different frequency! */ 
     72 #  define PIT_TICK_RATE 1189200 /* AMD Elan has different frequency! */ 
    4173+#elif defined(CONFIG_X86_RDC) 
    42 +#  define CLOCK_TICK_RATE 1041667 /* Underlying HZ for R8610 */ 
     74+#  define PIT_TICK_RATE 1041667 /* Underlying HZ for R8610 */ 
    4375 #else 
    44  #  define CLOCK_TICK_RATE 1193182 /* Underlying HZ */ 
     76 #  define PIT_TICK_RATE 1193182 /* Underlying HZ */ 
    4577 #endif 
    46 --- reboot_fixups.c     2007-08-07 12:02:00.908412250 -0700 
    47 +++ linux/arch/i386/kernel/reboot_fixups.c      2007-08-07 12:18:49.391438500 -0700 
    48 @@ -13,6 +13,17 @@ 
    49  #include <linux/pci.h> 
    50  #include <asm/reboot_fixups.h> 
    51  #include <asm/msr.h> 
    52 + 
    53 +static void r8610_reset(struct pci_dev *dev) 
    54 +{ 
    55 +       int i; 
    56 + 
    57 +       outl(0x80003840,0xCF8); 
    58 +       i=inl(0xCFC); 
    59 +       i |= 0x1600; 
    60 +       outl(i,0xCFC); 
    61 +       outb(1,0x92); 
    62 +} 
    63   
    64  static void cs5530a_warm_reset(struct pci_dev *dev) 
    65  { 
    66 @@ -40,6 +53,7 @@ 
    67  }; 
    68   
    69  static struct device_fixup fixups_table[] = { 
    70 +{ PCI_VENDOR_ID_RDC, PCI_DEVICE_ID_RDC_R6030, r8610_reset }, 
    71  { PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_LEGACY, cs5530a_warm_reset }, 
    72  { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA, cs5536_warm_reset }, 
    73  }; 
  • trunk/target/linux/rdc/patches/600-x86_lzma.patch

    r8233 r10453  
    1 diff -Naur linux-old/arch/i386/boot/compressed/LzmaDecode.c linux-lzma/arch/i386/boot/compressed/LzmaDecode.c 
    2 --- linux-old/arch/i386/boot/compressed/LzmaDecode.c    1969-12-31 19:00:00.000000000 -0500 
    3 +++ linux-lzma/arch/i386/boot/compressed/LzmaDecode.c   2005-06-05 00:07:38.000000000 -0400 
     1diff -Naur linux-old/arch/x86/boot/compressed/LzmaDecode.c linux-lzma/arch/i386/boot/compressed/LzmaDecode.c 
     2--- linux-old/arch/x86/boot/compressed/LzmaDecode.c     1969-12-31 19:00:00.000000000 -0500 
     3+++ linux-lzma/arch/x86/boot/compressed/LzmaDecode.c    2005-06-05 00:07:38.000000000 -0400 
    44@@ -0,0 +1,586 @@ 
    55+/* 
     
    589589+  return LZMA_RESULT_OK; 
    590590+} 
    591 diff -Naur linux-old/arch/i386/boot/compressed/LzmaDecode.h linux-lzma/arch/i386/boot/compressed/LzmaDecode.h 
    592 --- linux-old/arch/i386/boot/compressed/LzmaDecode.h    1969-12-31 19:00:00.000000000 -0500 
    593 +++ linux-lzma/arch/i386/boot/compressed/LzmaDecode.h   2005-06-05 00:07:39.000000000 -0400 
     591diff -Naur linux-old/arch/x86/boot/compressed/LzmaDecode.h linux-lzma/arch/i386/boot/compressed/LzmaDecode.h 
     592--- linux-old/arch/x86/boot/compressed/LzmaDecode.h     1969-12-31 19:00:00.000000000 -0500 
     593+++ linux-lzma/arch/x86/boot/compressed/LzmaDecode.h    2005-06-05 00:07:39.000000000 -0400 
    594594@@ -0,0 +1,100 @@ 
    595595+/*  
     
    693693+ 
    694694+#endif 
    695 diff -Naur linux-old/arch/i386/boot/compressed/lzma_misc.c linux-lzma/arch/i386/boot/compressed/lzma_misc.c 
    696 --- linux-old/arch/i386/boot/compressed/lzma_misc.c     1969-12-31 19:00:00.000000000 -0500 
    697 +++ linux-lzma/arch/i386/boot/compressed/lzma_misc.c    2005-06-04 21:33:48.000000000 -0400 
     695diff -Naur linux-old/arch/x86/boot/compressed/lzma_misc.c linux-lzma/arch/i386/boot/compressed/lzma_misc.c 
     696--- linux-old/arch/x86/boot/compressed/lzma_misc.c      1969-12-31 19:00:00.000000000 -0500 
     697+++ linux-lzma/arch/x86/boot/compressed/lzma_misc.c     2005-06-04 21:33:48.000000000 -0400 
    698698@@ -0,0 +1,281 @@ 
    699699+/* 
     
    978978+       return; 
    979979+} 
    980 diff -Naur linux-old/arch/i386/boot/compressed/Makefile linux-lzma/arch/i386/boot/compressed/Makefile 
    981 --- linux-old/arch/i386/boot/compressed/Makefile        2005-06-04 21:53:40.000000000 -0400 
    982 +++ linux-lzma/arch/i386/boot/compressed/Makefile       2005-06-05 00:25:23.000000000 -0400 
    983 @@ -4,7 +4,7 @@ 
    984  # create a compressed vmlinux image from the original vmlinux 
    985  # 
    986   
    987 -targets                := vmlinux vmlinux.bin vmlinux.bin.gz head.o misc.o piggy.o \ 
    988 +targets                := vmlinux vmlinux.bin vmlinux.bin.lzma head.o lzma_misc.o piggy.o \ 
    989                         vmlinux.bin.all vmlinux.relocs 
    990  EXTRA_AFLAGS   := -traditional 
    991   
    992 @@ -17,7 +17,7 @@ 
    993            $(call cc-option,-fno-stack-protector) 
    994  LDFLAGS := -m elf_i386 
    995   
    996 -$(obj)/vmlinux: $(src)/vmlinux.lds $(obj)/head.o $(obj)/misc.o $(obj)/piggy.o FORCE 
    997 +$(obj)/vmlinux: $(src)/vmlinux.lds $(obj)/head.o $(obj)/lzma_misc.o $(obj)/piggy.o FORCE 
    998         $(call if_changed,ld) 
    999         @: 
    1000   
    1001 @@ -37,14 +37,14 @@ 
    1002         $(call if_changed,relocbin) 
    1003   
    1004  ifdef CONFIG_RELOCATABLE 
    1005 -$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin.all FORCE 
    1006 -       $(call if_changed,gzip) 
    1007 +$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin.all FORCE 
    1008 +       $(call if_changed,lzma) 
    1009  else 
    1010 -$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE 
    1011 -       $(call if_changed,gzip) 
    1012 +$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE 
    1013 +       $(call if_changed,lzma) 
    1014  endif 
    1015   
    1016  LDFLAGS_piggy.o := -r --format binary --oformat elf32-i386 -T 
    1017   
    1018 -$(obj)/piggy.o: $(src)/vmlinux.scr $(obj)/vmlinux.bin.gz FORCE 
    1019 +$(obj)/piggy.o: $(src)/vmlinux.scr $(obj)/vmlinux.bin.lzma FORCE 
    1020         $(call if_changed,ld) 
    1021980diff -urN linux-2.6.19.2/scripts/Makefile.lib linux-2.6.19.2.new/scripts/Makefile.lib 
    1022981--- linux-2.6.19.2/scripts/Makefile.lib 2007-01-10 20:10:37.000000000 +0100 
     
    10411000+lzma e "$@" 
    10421001+echo -ne "\x$(echo $len | cut -c 7,8)\x$(echo $len | cut -c 5,6)\x$(echo $len | cut -c 3,4)\x$(echo $len | cut -c 1,2)" >> "$2" 
     1002diff -urN linux-2.6.24/arch/x86/boot/compressed/Makefile_32 linux-2.6.24.new/arch/x86/boot/compressed/Makefile_32 
     1003--- linux-2.6.24/arch/x86/boot/compressed/Makefile_32   2008-01-24 23:58:37.000000000 +0100 
     1004+++ linux-2.6.24.new/arch/x86/boot/compressed/Makefile_32       2008-02-13 15:21:03.000000000 +0100 
     1005@@ -4,8 +4,8 @@ 
     1006 # create a compressed vmlinux image from the original vmlinux 
     1007 # 
     1008  
     1009-targets                := vmlinux vmlinux.bin vmlinux.bin.gz head_32.o misc_32.o piggy.o \ 
     1010-                       vmlinux.bin.all vmlinux.relocs 
     1011+targets                := vmlinux vmlinux.bin vmlinux.bin.lzma head_32.o piggy.o \ 
     1012+                       vmlinux.bin.all vmlinux.relocs lzma_misc.o 
     1013 EXTRA_AFLAGS   := -traditional 
     1014  
     1015 LDFLAGS_vmlinux := -T 
     1016@@ -17,7 +17,7 @@ 
     1017           $(call cc-option,-fno-stack-protector) 
     1018 LDFLAGS := -m elf_i386 
     1019  
     1020-$(obj)/vmlinux: $(src)/vmlinux_32.lds $(obj)/head_32.o $(obj)/misc_32.o $(obj)/piggy.o FORCE 
     1021+$(obj)/vmlinux: $(src)/vmlinux_32.lds $(obj)/head_32.o $(obj)/lzma_misc.o $(obj)/piggy.o FORCE 
     1022        $(call if_changed,ld) 
     1023        @: 
     1024  
     1025@@ -37,14 +37,14 @@ 
     1026        $(call if_changed,relocbin) 
     1027  
     1028 ifdef CONFIG_RELOCATABLE 
     1029-$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin.all FORCE 
     1030-       $(call if_changed,gzip) 
     1031+$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin.all FORCE 
     1032+       $(call if_changed,lzma) 
     1033 else 
     1034-$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE 
     1035-       $(call if_changed,gzip) 
     1036+$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE 
     1037+       $(call if_changed,lzma) 
     1038 endif 
     1039  
     1040 LDFLAGS_piggy.o := -r --format binary --oformat elf32-i386 -T 
     1041  
     1042-$(obj)/piggy.o: $(src)/vmlinux_32.scr $(obj)/vmlinux.bin.gz FORCE 
     1043+$(obj)/piggy.o: $(src)/vmlinux_32.scr $(obj)/vmlinux.bin.lzma FORCE 
     1044        $(call if_changed,ld) 
Note: See TracChangeset for help on using the changeset viewer.