drivers/net/tulip/dmfe.c

   1 /*
   2     A Davicom DM9102/DM9102A/DM9102A+DM9801/DM9102A+DM9802 NIC fast
   3     ethernet driver for Linux.
   4     Copyright (C) 1997  Sten Wang
   5
   6     This program is free software; you can redistribute it and/or
   7     modify it under the terms of the GNU General Public License
   8     as published by the Free Software Foundation; either version 2
   9     of the License, or (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     DAVICOM Web-Site: www.davicom.com.tw
  17
  18     Author: Sten Wang, 886-3-5798797-8517, E-mail: sten_wang@davicom.com.tw
  19     Maintainer: Tobias Ringstrom <tori@unhappy.mine.nu>
  20
  21     (C)Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
  22
  23     Marcelo Tosatti <marcelo@conectiva.com.br> :
  24     Made it compile in 2.3 (device to net_device)
  25
  26     Alan Cox <alan@lxorguk.ukuu.org.uk> :
  27     Cleaned up for kernel merge.
  28     Removed the back compatibility support
  29     Reformatted, fixing spelling etc as I went
  30     Removed IRQ 0-15 assumption
  31
  32     Jeff Garzik <jgarzik@pobox.com> :
  33     Updated to use new PCI driver API.
  34     Resource usage cleanups.
  35     Report driver version to user.
  36
  37     Tobias Ringstrom <tori@unhappy.mine.nu> :
  38     Cleaned up and added SMP safety.  Thanks go to Jeff Garzik,
  39     Andrew Morton and Frank Davis for the SMP safety fixes.
  40
  41     Vojtech Pavlik <vojtech@suse.cz> :
  42     Cleaned up pointer arithmetics.
  43     Fixed a lot of 64bit issues.
  44     Cleaned up printk()s a bit.
  45     Fixed some obvious big endian problems.
  46
  47     Tobias Ringstrom <tori@unhappy.mine.nu> :
  48     Use time_after for jiffies calculation.  Added ethtool
  49     support.  Updated PCI resource allocation.  Do not
  50     forget to unmap PCI mapped skbs.
  51
  52     Alan Cox <alan@lxorguk.ukuu.org.uk>
  53     Added new PCI identifiers provided by Clear Zhang at ALi
  54     for their 1563 ethernet device.
  55
  56     TODO
  57
  58     Check on 64 bit boxes.
  59     Check and fix on big endian boxes.
  60
  61     Test and make sure PCI latency is now correct for all cases.
  62 */
  63
  64 #define DRV_NAME        "dmfe"
  65 #define DRV_VERSION     "1.36.4"
  66 #define DRV_RELDATE     "2002-01-17"
  67
  68 #include <linux/module.h>
  69 #include <linux/kernel.h>
  70 #include <linux/string.h>
  71 #include <linux/timer.h>
  72 #include <linux/ptrace.h>
  73 #include <linux/errno.h>
  74 #include <linux/ioport.h>
  75 #include <linux/slab.h>
  76 #include <linux/interrupt.h>
  77 #include <linux/pci.h>
  78 #include <linux/dma-mapping.h>
  79 #include <linux/init.h>
  80 #include <linux/netdevice.h>
  81 #include <linux/etherdevice.h>
  82 #include <linux/ethtool.h>
  83 #include <linux/skbuff.h>
  84 #include <linux/delay.h>
  85 #include <linux/spinlock.h>
  86 #include <linux/crc32.h>
  87 #include <linux/bitops.h>
  88
  89 #include <asm/processor.h>
  90 #include <asm/io.h>
  91 #include <asm/dma.h>
  92 #include <asm/uaccess.h>
  93 #include <asm/irq.h>
  94
  95 #ifdef CONFIG_TULIP_DM910X
  96 #include <linux/of.h>
  97 #endif
  98
  99
 100 /* Board/System/Debug information/definition ---------------- */
 101 #define PCI_DM9132_ID   0x91321282      /* Davicom DM9132 ID */
 102 #define PCI_DM9102_ID   0x91021282      /* Davicom DM9102 ID */
 103 #define PCI_DM9100_ID   0x91001282      /* Davicom DM9100 ID */
 104 #define PCI_DM9009_ID   0x90091282      /* Davicom DM9009 ID */
 105
 106 #define DM9102_IO_SIZE  0x80
 107 #define DM9102A_IO_SIZE 0x100
 108 #define TX_MAX_SEND_CNT 0x1             /* Maximum tx packet per time */
 109 #define TX_DESC_CNT     0x10            /* Allocated Tx descriptors */
 110 #define RX_DESC_CNT     0x20            /* Allocated Rx descriptors */
 111 #define TX_FREE_DESC_CNT (TX_DESC_CNT - 2)      /* Max TX packet count */
 112 #define TX_WAKE_DESC_CNT (TX_DESC_CNT - 3)      /* TX wakeup count */
 113 #define DESC_ALL_CNT    (TX_DESC_CNT + RX_DESC_CNT)
 114 #define TX_BUF_ALLOC    0x600
 115 #define RX_ALLOC_SIZE   0x620
 116 #define DM910X_RESET    1
 117 #define CR0_DEFAULT     0x00E00000      /* TX & RX burst mode */
 118 #define CR6_DEFAULT     0x00080000      /* HD */
 119 #define CR7_DEFAULT     0x180c1
 120 #define CR15_DEFAULT    0x06            /* TxJabber RxWatchdog */
 121 #define TDES0_ERR_MASK  0x4302          /* TXJT, LC, EC, FUE */
 122 #define MAX_PACKET_SIZE 1514
 123 #define DMFE_MAX_MULTICAST 14
 124 #define RX_COPY_SIZE    100
 125 #define MAX_CHECK_PACKET 0x8000
 126 #define DM9801_NOISE_FLOOR 8
 127 #define DM9802_NOISE_FLOOR 5
 128
 129 #define DMFE_WOL_LINKCHANGE     0x20000000
 130 #define DMFE_WOL_SAMPLEPACKET   0x10000000
 131 #define DMFE_WOL_MAGICPACKET    0x08000000
 132
 133
 134 #define DMFE_10MHF      0
 135 #define DMFE_100MHF     1
 136 #define DMFE_10MFD      4
 137 #define DMFE_100MFD     5
 138 #define DMFE_AUTO       8
 139 #define DMFE_1M_HPNA    0x10
 140
 141 #define DMFE_TXTH_72    0x400000        /* TX TH 72 byte */
 142 #define DMFE_TXTH_96    0x404000        /* TX TH 96 byte */
 143 #define DMFE_TXTH_128   0x0000          /* TX TH 128 byte */
 144 #define DMFE_TXTH_256   0x4000          /* TX TH 256 byte */
 145 #define DMFE_TXTH_512   0x8000          /* TX TH 512 byte */
 146 #define DMFE_TXTH_1K    0xC000          /* TX TH 1K  byte */
 147
 148 #define DMFE_TIMER_WUT  (jiffies + HZ * 1)/* timer wakeup time : 1 second */
 149 #define DMFE_TX_TIMEOUT ((3*HZ)/2)      /* tx packet time-out time 1.5 s" */
 150 #define DMFE_TX_KICK    (HZ/2)  /* tx packet Kick-out time 0.5 s" */
 151
 152 #define DMFE_DBUG(dbug_now, msg, value) \
 153         do { \
 154                 if (dmfe_debug || (dbug_now)) \
 155                         printk(KERN_ERR DRV_NAME ": %s %lx\n",\
 156                                 (msg), (long) (value)); \
 157         } while (0)
 158
 159 #define SHOW_MEDIA_TYPE(mode) \
 160         printk (KERN_INFO DRV_NAME ": Change Speed to %sMhz %s duplex\n" , \
 161                 (mode & 1) ? "100":"10", (mode & 4) ? "full":"half");
 162
 163
 164 /* CR9 definition: SROM/MII */
 165 #define CR9_SROM_READ   0x4800
 166 #define CR9_SRCS        0x1
 167 #define CR9_SRCLK       0x2
 168 #define CR9_CRDOUT      0x8
 169 #define SROM_DATA_0     0x0
 170 #define SROM_DATA_1     0x4
 171 #define PHY_DATA_1      0x20000
 172 #define PHY_DATA_0      0x00000
 173 #define MDCLKH          0x10000
 174
 175 #define PHY_POWER_DOWN  0x800
 176
 177 #define SROM_V41_CODE   0x14
 178
 179 #define SROM_CLK_WRITE(data, ioaddr) \
 180         outl(data|CR9_SROM_READ|CR9_SRCS,ioaddr); \
 181         udelay(5); \
 182         outl(data|CR9_SROM_READ|CR9_SRCS|CR9_SRCLK,ioaddr); \
 183         udelay(5); \
 184         outl(data|CR9_SROM_READ|CR9_SRCS,ioaddr); \
 185         udelay(5);
 186
 187 #define __CHK_IO_SIZE(pci_id, dev_rev) \
 188  (( ((pci_id)==PCI_DM9132_ID) || ((dev_rev) >= 0x30) ) ? \
 189         DM9102A_IO_SIZE: DM9102_IO_SIZE)
 190
 191 #define CHK_IO_SIZE(pci_dev) \
 192         (__CHK_IO_SIZE(((pci_dev)->device << 16) | (pci_dev)->vendor, \
 193         (pci_dev)->revision))
 194
 195 /* Sten Check */
 196 #define DEVICE net_device
 197
 198 /* Structure/enum declaration ------------------------------- */
 199 struct tx_desc {
 200         __le32 tdes0, tdes1, tdes2, tdes3; /* Data for the card */
 201         char *tx_buf_ptr;               /* Data for us */
 202         struct tx_desc *next_tx_desc;
 203 } __attribute__(( aligned(32) ));
 204
 205 struct rx_desc {
 206         __le32 rdes0, rdes1, rdes2, rdes3; /* Data for the card */
 207         struct sk_buff *rx_skb_ptr;     /* Data for us */
 208         struct rx_desc *next_rx_desc;
 209 } __attribute__(( aligned(32) ));
 210
 211 struct dmfe_board_info {
 212         u32 chip_id;                    /* Chip vendor/Device ID */
 213         u8 chip_revision;               /* Chip revision */
 214         struct DEVICE *next_dev;        /* next device */
 215         struct pci_dev *pdev;           /* PCI device */
 216         spinlock_t lock;
 217
 218         long ioaddr;                    /* I/O base address */
 219         u32 cr0_data;
 220         u32 cr5_data;
 221         u32 cr6_data;
 222         u32 cr7_data;
 223         u32 cr15_data;
 224
 225         /* pointer for memory physical address */
 226         dma_addr_t buf_pool_dma_ptr;    /* Tx buffer pool memory */
 227         dma_addr_t buf_pool_dma_start;  /* Tx buffer pool align dword */
 228         dma_addr_t desc_pool_dma_ptr;   /* descriptor pool memory */
 229         dma_addr_t first_tx_desc_dma;
 230         dma_addr_t first_rx_desc_dma;
 231
 232         /* descriptor pointer */
 233         unsigned char *buf_pool_ptr;    /* Tx buffer pool memory */
 234         unsigned char *buf_pool_start;  /* Tx buffer pool align dword */
 235         unsigned char *desc_pool_ptr;   /* descriptor pool memory */
 236         struct tx_desc *first_tx_desc;
 237         struct tx_desc *tx_insert_ptr;
 238         struct tx_desc *tx_remove_ptr;
 239         struct rx_desc *first_rx_desc;
 240         struct rx_desc *rx_insert_ptr;
 241         struct rx_desc *rx_ready_ptr;   /* packet come pointer */
 242         unsigned long tx_packet_cnt;    /* transmitted packet count */
 243         unsigned long tx_queue_cnt;     /* wait to send packet count */
 244         unsigned long rx_avail_cnt;     /* available rx descriptor count */
 245         unsigned long interval_rx_cnt;  /* rx packet count a callback time */
 246
 247         u16 HPNA_command;               /* For HPNA register 16 */
 248         u16 HPNA_timer;                 /* For HPNA remote device check */
 249         u16 dbug_cnt;
 250         u16 NIC_capability;             /* NIC media capability */
 251         u16 PHY_reg4;                   /* Saved Phyxcer register 4 value */
 252
 253         u8 HPNA_present;                /* 0:none, 1:DM9801, 2:DM9802 */
 254         u8 chip_type;                   /* Keep DM9102A chip type */
 255         u8 media_mode;                  /* user specify media mode */
 256         u8 op_mode;                     /* real work media mode */
 257         u8 phy_addr;
 258         u8 wait_reset;                  /* Hardware failed, need to reset */
 259         u8 dm910x_chk_mode;             /* Operating mode check */
 260         u8 first_in_callback;           /* Flag to record state */
 261         u8 wol_mode;                    /* user WOL settings */
 262         struct timer_list timer;
 263
 264         /* Driver defined statistic counter */
 265         unsigned long tx_fifo_underrun;
 266         unsigned long tx_loss_carrier;
 267         unsigned long tx_no_carrier;
 268         unsigned long tx_late_collision;
 269         unsigned long tx_excessive_collision;
 270         unsigned long tx_jabber_timeout;
 271         unsigned long reset_count;
 272         unsigned long reset_cr8;
 273         unsigned long reset_fatal;
 274         unsigned long reset_TXtimeout;
 275
 276         /* NIC SROM data */
 277         unsigned char srom[128];
 278 };
 279
 280 enum dmfe_offsets {
 281         DCR0 = 0x00, DCR1 = 0x08, DCR2 = 0x10, DCR3 = 0x18, DCR4 = 0x20,
 282         DCR5 = 0x28, DCR6 = 0x30, DCR7 = 0x38, DCR8 = 0x40, DCR9 = 0x48,
 283         DCR10 = 0x50, DCR11 = 0x58, DCR12 = 0x60, DCR13 = 0x68, DCR14 = 0x70,
 284         DCR15 = 0x78
 285 };
 286
 287 enum dmfe_CR6_bits {
 288         CR6_RXSC = 0x2, CR6_PBF = 0x8, CR6_PM = 0x40, CR6_PAM = 0x80,
 289         CR6_FDM = 0x200, CR6_TXSC = 0x2000, CR6_STI = 0x100000,
 290         CR6_SFT = 0x200000, CR6_RXA = 0x40000000, CR6_NO_PURGE = 0x20000000
 291 };
 292
 293 /* Global variable declaration ----------------------------- */
 294 static int __devinitdata printed_version;
 295 static const char version[] __devinitconst =
 296         KERN_INFO DRV_NAME ": Davicom DM9xxx net driver, version "
 297         DRV_VERSION " (" DRV_RELDATE ")\n";
 298
 299 static int dmfe_debug;
 300 static unsigned char dmfe_media_mode = DMFE_AUTO;
 301 static u32 dmfe_cr6_user_set;
 302
 303 /* For module input parameter */
 304 static int debug;
 305 static u32 cr6set;
 306 static unsigned char mode = 8;
 307 static u8 chkmode = 1;
 308 static u8 HPNA_mode;            /* Default: Low Power/High Speed */
 309 static u8 HPNA_rx_cmd;          /* Default: Disable Rx remote command */
 310 static u8 HPNA_tx_cmd;          /* Default: Don't issue remote command */
 311 static u8 HPNA_NoiseFloor;      /* Default: HPNA NoiseFloor */
 312 static u8 SF_mode;              /* Special Function: 1:VLAN, 2:RX Flow Control
 313                                    4: TX pause packet */
 314
 315
 316 /* function declaration ------------------------------------- */
 317 static int dmfe_open(struct DEVICE *);
 318 static netdev_tx_t dmfe_start_xmit(struct sk_buff *, struct DEVICE *);
 319 static int dmfe_stop(struct DEVICE *);
 320 static void dmfe_set_filter_mode(struct DEVICE *);
 321 static const struct ethtool_ops netdev_ethtool_ops;
 322 static u16 read_srom_word(long ,int);
 323 static irqreturn_t dmfe_interrupt(int , void *);
 324 #ifdef CONFIG_NET_POLL_CONTROLLER
 325 static void poll_dmfe (struct net_device *dev);
 326 #endif
 327 static void dmfe_descriptor_init(struct dmfe_board_info *, unsigned long);
 328 static void allocate_rx_buffer(struct dmfe_board_info *);
 329 static void update_cr6(u32, unsigned long);
 330 static void send_filter_frame(struct DEVICE * ,int);
 331 static void dm9132_id_table(struct DEVICE * ,int);
 332 static u16 phy_read(unsigned long, u8, u8, u32);
 333 static void phy_write(unsigned long, u8, u8, u16, u32);
 334 static void phy_write_1bit(unsigned long, u32);
 335 static u16 phy_read_1bit(unsigned long);
 336 static u8 dmfe_sense_speed(struct dmfe_board_info *);
 337 static void dmfe_process_mode(struct dmfe_board_info *);
 338 static void dmfe_timer(unsigned long);
 339 static inline u32 cal_CRC(unsigned char *, unsigned int, u8);
 340 static void dmfe_rx_packet(struct DEVICE *, struct dmfe_board_info *);
 341 static void dmfe_free_tx_pkt(struct DEVICE *, struct dmfe_board_info *);
 342 static void dmfe_reuse_skb(struct dmfe_board_info *, struct sk_buff *);
 343 static void dmfe_dynamic_reset(struct DEVICE *);
 344 static void dmfe_free_rxbuffer(struct dmfe_board_info *);
 345 static void dmfe_init_dm910x(struct DEVICE *);
 346 static void dmfe_parse_srom(struct dmfe_board_info *);
 347 static void dmfe_program_DM9801(struct dmfe_board_info *, int);
 348 static void dmfe_program_DM9802(struct dmfe_board_info *);
 349 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * );
 350 static void dmfe_set_phyxcer(struct dmfe_board_info *);
 351
 352 /* DM910X network board routine ---------------------------- */
 353
 354 static const struct net_device_ops netdev_ops = {
 355         .ndo_open               = dmfe_open,
 356         .ndo_stop               = dmfe_stop,
 357         .ndo_start_xmit         = dmfe_start_xmit,
 358         .ndo_set_multicast_list = dmfe_set_filter_mode,
 359         .ndo_change_mtu         = eth_change_mtu,
 360         .ndo_set_mac_address    = eth_mac_addr,
 361         .ndo_validate_addr      = eth_validate_addr,
 362 #ifdef CONFIG_NET_POLL_CONTROLLER
 363         .ndo_poll_controller    = poll_dmfe,
 364 #endif
 365 };
 366
 367 /*
 368  *      Search DM910X board ,allocate space and register it
 369  */
 370
 371 static int __devinit dmfe_init_one (struct pci_dev *pdev,
 372                                     const struct pci_device_id *ent)
 373 {
 374         struct dmfe_board_info *db;     /* board information structure */
 375         struct net_device *dev;
 376         u32 pci_pmr;
 377         int i, err;
 378
 379         DMFE_DBUG(0, "dmfe_init_one()", 0);
 380
 381         if (!printed_version++)
 382                 printk(version);
 383
 384         /*
 385          *      SPARC on-board DM910x chips should be handled by the main
 386          *      tulip driver, except for early DM9100s.
 387          */
 388 #ifdef CONFIG_TULIP_DM910X
 389         if ((ent->driver_data == PCI_DM9100_ID && pdev->revision >= 0x30) ||
 390             ent->driver_data == PCI_DM9102_ID) {
 391                 struct device_node *dp = pci_device_to_OF_node(pdev);
 392
 393                 if (dp && of_get_property(dp, "local-mac-address", NULL)) {
 394                         printk(KERN_INFO DRV_NAME
 395                                ": skipping on-board DM910x (use tulip)\n");
 396                         return -ENODEV;
 397                 }
 398         }
 399 #endif
 400
 401         /* Init network device */
 402         dev = alloc_etherdev(sizeof(*db));
 403         if (dev == NULL)
 404                 return -ENOMEM;
 405         SET_NETDEV_DEV(dev, &pdev->dev);
 406
 407         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
 408                 printk(KERN_WARNING DRV_NAME
 409                         ": 32-bit PCI DMA not available.\n");
 410                 err = -ENODEV;
 411                 goto err_out_free;
 412         }
 413
 414         /* Enable Master/IO access, Disable memory access */
 415         err = pci_enable_device(pdev);
 416         if (err)
 417                 goto err_out_free;
 418
 419         if (!pci_resource_start(pdev, 0)) {
 420                 printk(KERN_ERR DRV_NAME ": I/O base is zero\n");
 421                 err = -ENODEV;
 422                 goto err_out_disable;
 423         }
 424
 425         if (pci_resource_len(pdev, 0) < (CHK_IO_SIZE(pdev)) ) {
 426                 printk(KERN_ERR DRV_NAME ": Allocated I/O size too small\n");
 427                 err = -ENODEV;
 428                 goto err_out_disable;
 429         }
 430
 431 #if 0   /* pci_{enable_device,set_master} sets minimum latency for us now */
 432
 433         /* Set Latency Timer 80h */
 434         /* FIXME: setting values > 32 breaks some SiS 559x stuff.
 435            Need a PCI quirk.. */
 436
 437         pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 0x80);
 438 #endif
 439
 440         if (pci_request_regions(pdev, DRV_NAME)) {
 441                 printk(KERN_ERR DRV_NAME ": Failed to request PCI regions\n");
 442                 err = -ENODEV;
 443                 goto err_out_disable;
 444         }
 445
 446         /* Init system & device */
 447         db = netdev_priv(dev);
 448
 449         /* Allocate Tx/Rx descriptor memory */
 450         db->desc_pool_ptr = pci_alloc_consistent(pdev, sizeof(struct tx_desc) *
 451                         DESC_ALL_CNT + 0x20, &db->desc_pool_dma_ptr);
 452         if (!db->desc_pool_ptr)
 453                 goto err_out_res;
 454
 455         db->buf_pool_ptr = pci_alloc_consistent(pdev, TX_BUF_ALLOC *
 456                         TX_DESC_CNT + 4, &db->buf_pool_dma_ptr);
 457         if (!db->buf_pool_ptr)
 458                 goto err_out_free_desc;
 459
 460         db->first_tx_desc = (struct tx_desc *) db->desc_pool_ptr;
 461         db->first_tx_desc_dma = db->desc_pool_dma_ptr;
 462         db->buf_pool_start = db->buf_pool_ptr;
 463         db->buf_pool_dma_start = db->buf_pool_dma_ptr;
 464
 465         db->chip_id = ent->driver_data;
 466         db->ioaddr = pci_resource_start(pdev, 0);
 467         db->chip_revision = pdev->revision;
 468         db->wol_mode = 0;
 469
 470         db->pdev = pdev;
 471
 472         dev->base_addr = db->ioaddr;
 473         dev->irq = pdev->irq;
 474         pci_set_drvdata(pdev, dev);
 475         dev->netdev_ops = &netdev_ops;
 476         dev->ethtool_ops = &netdev_ethtool_ops;
 477         netif_carrier_off(dev);
 478         spin_lock_init(&db->lock);
 479
 480         pci_read_config_dword(pdev, 0x50, &pci_pmr);
 481         pci_pmr &= 0x70000;
 482         if ( (pci_pmr == 0x10000) && (db->chip_revision == 0x31) )
 483                 db->chip_type = 1;      /* DM9102A E3 */
 484         else
 485                 db->chip_type = 0;
 486
 487         /* read 64 word srom data */
 488         for (i = 0; i < 64; i++)
 489                 ((__le16 *) db->srom)[i] =
 490                         cpu_to_le16(read_srom_word(db->ioaddr, i));
 491
 492         /* Set Node address */
 493         for (i = 0; i < 6; i++)
 494                 dev->dev_addr[i] = db->srom[20 + i];
 495
 496         err = register_netdev (dev);
 497         if (err)
 498                 goto err_out_free_buf;
 499
 500         printk(KERN_INFO "%s: Davicom DM%04lx at pci%s, %pM, irq %d.\n",
 501                dev->name,
 502                ent->driver_data >> 16,
 503                pci_name(pdev),
 504                dev->dev_addr,
 505                dev->irq);
 506
 507         pci_set_master(pdev);
 508
 509         return 0;
 510
 511 err_out_free_buf:
 512         pci_free_consistent(pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4,
 513                             db->buf_pool_ptr, db->buf_pool_dma_ptr);
 514 err_out_free_desc:
 515         pci_free_consistent(pdev, sizeof(struct tx_desc) * DESC_ALL_CNT + 0x20,
 516                             db->desc_pool_ptr, db->desc_pool_dma_ptr);
 517 err_out_res:
 518         pci_release_regions(pdev);
 519 err_out_disable:
 520         pci_disable_device(pdev);
 521 err_out_free:
 522         pci_set_drvdata(pdev, NULL);
 523         free_netdev(dev);
 524
 525         return err;
 526 }
 527
 528
 529 static void __devexit dmfe_remove_one (struct pci_dev *pdev)
 530 {
 531         struct net_device *dev = pci_get_drvdata(pdev);
 532         struct dmfe_board_info *db = netdev_priv(dev);
 533
 534         DMFE_DBUG(0, "dmfe_remove_one()", 0);
 535
 536         if (dev) {
 537
 538                 unregister_netdev(dev);
 539
 540                 pci_free_consistent(db->pdev, sizeof(struct tx_desc) *
 541                                         DESC_ALL_CNT + 0x20, db->desc_pool_ptr,
 542                                         db->desc_pool_dma_ptr);
 543                 pci_free_consistent(db->pdev, TX_BUF_ALLOC * TX_DESC_CNT + 4,
 544                                         db->buf_pool_ptr, db->buf_pool_dma_ptr);
 545                 pci_release_regions(pdev);
 546                 free_netdev(dev);       /* free board information */
 547
 548                 pci_set_drvdata(pdev, NULL);
 549         }
 550
 551         DMFE_DBUG(0, "dmfe_remove_one() exit", 0);
 552 }
 553
 554
 555 /*
 556  *      Open the interface.
 557  *      The interface is opened whenever "ifconfig" actives it.
 558  */
 559
 560 static int dmfe_open(struct DEVICE *dev)
 561 {
 562         int ret;
 563         struct dmfe_board_info *db = netdev_priv(dev);
 564
 565         DMFE_DBUG(0, "dmfe_open", 0);
 566
 567         ret = request_irq(dev->irq, dmfe_interrupt,
 568                           IRQF_SHARED, dev->name, dev);
 569         if (ret)
 570                 return ret;
 571
 572         /* system variable init */
 573         db->cr6_data = CR6_DEFAULT | dmfe_cr6_user_set;
 574         db->tx_packet_cnt = 0;
 575         db->tx_queue_cnt = 0;
 576         db->rx_avail_cnt = 0;
 577         db->wait_reset = 0;
 578
 579         db->first_in_callback = 0;
 580         db->NIC_capability = 0xf;       /* All capability*/
 581         db->PHY_reg4 = 0x1e0;
 582
 583         /* CR6 operation mode decision */
 584         if ( !chkmode || (db->chip_id == PCI_DM9132_ID) ||
 585                 (db->chip_revision >= 0x30) ) {
 586                 db->cr6_data |= DMFE_TXTH_256;
 587                 db->cr0_data = CR0_DEFAULT;
 588                 db->dm910x_chk_mode=4;          /* Enter the normal mode */
 589         } else {
 590                 db->cr6_data |= CR6_SFT;        /* Store & Forward mode */
 591                 db->cr0_data = 0;
 592                 db->dm910x_chk_mode = 1;        /* Enter the check mode */
 593         }
 594
 595         /* Initilize DM910X board */
 596         dmfe_init_dm910x(dev);
 597
 598         /* Active System Interface */
 599         netif_wake_queue(dev);
 600
 601         /* set and active a timer process */
 602         init_timer(&db->timer);
 603         db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
 604         db->timer.data = (unsigned long)dev;
 605         db->timer.function = &dmfe_timer;
 606         add_timer(&db->timer);
 607
 608         return 0;
 609 }
 610
 611
 612 /*      Initilize DM910X board
 613  *      Reset DM910X board
 614  *      Initilize TX/Rx descriptor chain structure
 615  *      Send the set-up frame
 616  *      Enable Tx/Rx machine
 617  */
 618
 619 static void dmfe_init_dm910x(struct DEVICE *dev)
 620 {
 621         struct dmfe_board_info *db = netdev_priv(dev);
 622         unsigned long ioaddr = db->ioaddr;
 623
 624         DMFE_DBUG(0, "dmfe_init_dm910x()", 0);
 625
 626         /* Reset DM910x MAC controller */
 627         outl(DM910X_RESET, ioaddr + DCR0);      /* RESET MAC */
 628         udelay(100);
 629         outl(db->cr0_data, ioaddr + DCR0);
 630         udelay(5);
 631
 632         /* Phy addr : DM910(A)2/DM9132/9801, phy address = 1 */
 633         db->phy_addr = 1;
 634
 635         /* Parser SROM and media mode */
 636         dmfe_parse_srom(db);
 637         db->media_mode = dmfe_media_mode;
 638
 639         /* RESET Phyxcer Chip by GPR port bit 7 */
 640         outl(0x180, ioaddr + DCR12);            /* Let bit 7 output port */
 641         if (db->chip_id == PCI_DM9009_ID) {
 642                 outl(0x80, ioaddr + DCR12);     /* Issue RESET signal */
 643                 mdelay(300);                    /* Delay 300 ms */
 644         }
 645         outl(0x0, ioaddr + DCR12);      /* Clear RESET signal */
 646
 647         /* Process Phyxcer Media Mode */
 648         if ( !(db->media_mode & 0x10) ) /* Force 1M mode */
 649                 dmfe_set_phyxcer(db);
 650
 651         /* Media Mode Process */
 652         if ( !(db->media_mode & DMFE_AUTO) )
 653                 db->op_mode = db->media_mode;   /* Force Mode */
 654
 655         /* Initiliaze Transmit/Receive decriptor and CR3/4 */
 656         dmfe_descriptor_init(db, ioaddr);
 657
 658         /* Init CR6 to program DM910x operation */
 659         update_cr6(db->cr6_data, ioaddr);
 660
 661         /* Send setup frame */
 662         if (db->chip_id == PCI_DM9132_ID)
 663                 dm9132_id_table(dev, dev->mc_count);    /* DM9132 */
 664         else
 665                 send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
 666
 667         /* Init CR7, interrupt active bit */
 668         db->cr7_data = CR7_DEFAULT;
 669         outl(db->cr7_data, ioaddr + DCR7);
 670
 671         /* Init CR15, Tx jabber and Rx watchdog timer */
 672         outl(db->cr15_data, ioaddr + DCR15);
 673
 674         /* Enable DM910X Tx/Rx function */
 675         db->cr6_data |= CR6_RXSC | CR6_TXSC | 0x40000;
 676         update_cr6(db->cr6_data, ioaddr);
 677 }
 678
 679
 680 /*
 681  *      Hardware start transmission.
 682  *      Send a packet to media from the upper layer.
 683  */
 684
 685 static netdev_tx_t dmfe_start_xmit(struct sk_buff *skb,
 686                                          struct DEVICE *dev)
 687 {
 688         struct dmfe_board_info *db = netdev_priv(dev);
 689         struct tx_desc *txptr;
 690         unsigned long flags;
 691
 692         DMFE_DBUG(0, "dmfe_start_xmit", 0);
 693
 694         /* Resource flag check */
 695         netif_stop_queue(dev);
 696
 697         /* Too large packet check */
 698         if (skb->len > MAX_PACKET_SIZE) {
 699                 printk(KERN_ERR DRV_NAME ": big packet = %d\n", (u16)skb->len);
 700                 dev_kfree_skb(skb);
 701                 return NETDEV_TX_OK;
 702         }
 703
 704         spin_lock_irqsave(&db->lock, flags);
 705
 706         /* No Tx resource check, it never happen nromally */
 707         if (db->tx_queue_cnt >= TX_FREE_DESC_CNT) {
 708                 spin_unlock_irqrestore(&db->lock, flags);
 709                 printk(KERN_ERR DRV_NAME ": No Tx resource %ld\n",
 710                        db->tx_queue_cnt);
 711                 return NETDEV_TX_BUSY;
 712         }
 713
 714         /* Disable NIC interrupt */
 715         outl(0, dev->base_addr + DCR7);
 716
 717         /* transmit this packet */
 718         txptr = db->tx_insert_ptr;
 719         skb_copy_from_linear_data(skb, txptr->tx_buf_ptr, skb->len);
 720         txptr->tdes1 = cpu_to_le32(0xe1000000 | skb->len);
 721
 722         /* Point to next transmit free descriptor */
 723         db->tx_insert_ptr = txptr->next_tx_desc;
 724
 725         /* Transmit Packet Process */
 726         if ( (!db->tx_queue_cnt) && (db->tx_packet_cnt < TX_MAX_SEND_CNT) ) {
 727                 txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
 728                 db->tx_packet_cnt++;                    /* Ready to send */
 729                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
 730                 dev->trans_start = jiffies;             /* saved time stamp */
 731         } else {
 732                 db->tx_queue_cnt++;                     /* queue TX packet */
 733                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
 734         }
 735
 736         /* Tx resource check */
 737         if ( db->tx_queue_cnt < TX_FREE_DESC_CNT )
 738                 netif_wake_queue(dev);
 739
 740         /* Restore CR7 to enable interrupt */
 741         spin_unlock_irqrestore(&db->lock, flags);
 742         outl(db->cr7_data, dev->base_addr + DCR7);
 743
 744         /* free this SKB */
 745         dev_kfree_skb(skb);
 746
 747         return NETDEV_TX_OK;
 748 }
 749
 750
 751 /*
 752  *      Stop the interface.
 753  *      The interface is stopped when it is brought.
 754  */
 755
 756 static int dmfe_stop(struct DEVICE *dev)
 757 {
 758         struct dmfe_board_info *db = netdev_priv(dev);
 759         unsigned long ioaddr = dev->base_addr;
 760
 761         DMFE_DBUG(0, "dmfe_stop", 0);
 762
 763         /* disable system */
 764         netif_stop_queue(dev);
 765
 766         /* deleted timer */
 767         del_timer_sync(&db->timer);
 768
 769         /* Reset & stop DM910X board */
 770         outl(DM910X_RESET, ioaddr + DCR0);
 771         udelay(5);
 772         phy_write(db->ioaddr, db->phy_addr, 0, 0x8000, db->chip_id);
 773
 774         /* free interrupt */
 775         free_irq(dev->irq, dev);
 776
 777         /* free allocated rx buffer */
 778         dmfe_free_rxbuffer(db);
 779
 780 #if 0
 781         /* show statistic counter */
 782         printk(DRV_NAME ": FU:%lx EC:%lx LC:%lx NC:%lx"
 783                 " LOC:%lx TXJT:%lx RESET:%lx RCR8:%lx FAL:%lx TT:%lx\n",
 784                 db->tx_fifo_underrun, db->tx_excessive_collision,
 785                 db->tx_late_collision, db->tx_no_carrier, db->tx_loss_carrier,
 786                 db->tx_jabber_timeout, db->reset_count, db->reset_cr8,
 787                 db->reset_fatal, db->reset_TXtimeout);
 788 #endif
 789
 790         return 0;
 791 }
 792
 793
 794 /*
 795  *      DM9102 insterrupt handler
 796  *      receive the packet to upper layer, free the transmitted packet
 797  */
 798
 799 static irqreturn_t dmfe_interrupt(int irq, void *dev_id)
 800 {
 801         struct DEVICE *dev = dev_id;
 802         struct dmfe_board_info *db = netdev_priv(dev);
 803         unsigned long ioaddr = dev->base_addr;
 804         unsigned long flags;
 805
 806         DMFE_DBUG(0, "dmfe_interrupt()", 0);
 807
 808         spin_lock_irqsave(&db->lock, flags);
 809
 810         /* Got DM910X status */
 811         db->cr5_data = inl(ioaddr + DCR5);
 812         outl(db->cr5_data, ioaddr + DCR5);
 813         if ( !(db->cr5_data & 0xc1) ) {
 814                 spin_unlock_irqrestore(&db->lock, flags);
 815                 return IRQ_HANDLED;
 816         }
 817
 818         /* Disable all interrupt in CR7 to solve the interrupt edge problem */
 819         outl(0, ioaddr + DCR7);
 820
 821         /* Check system status */
 822         if (db->cr5_data & 0x2000) {
 823                 /* system bus error happen */
 824                 DMFE_DBUG(1, "System bus error happen. CR5=", db->cr5_data);
 825                 db->reset_fatal++;
 826                 db->wait_reset = 1;     /* Need to RESET */
 827                 spin_unlock_irqrestore(&db->lock, flags);
 828                 return IRQ_HANDLED;
 829         }
 830
 831          /* Received the coming packet */
 832         if ( (db->cr5_data & 0x40) && db->rx_avail_cnt )
 833                 dmfe_rx_packet(dev, db);
 834
 835         /* reallocate rx descriptor buffer */
 836         if (db->rx_avail_cnt<RX_DESC_CNT)
 837                 allocate_rx_buffer(db);
 838
 839         /* Free the transmitted descriptor */
 840         if ( db->cr5_data & 0x01)
 841                 dmfe_free_tx_pkt(dev, db);
 842
 843         /* Mode Check */
 844         if (db->dm910x_chk_mode & 0x2) {
 845                 db->dm910x_chk_mode = 0x4;
 846                 db->cr6_data |= 0x100;
 847                 update_cr6(db->cr6_data, db->ioaddr);
 848         }
 849
 850         /* Restore CR7 to enable interrupt mask */
 851         outl(db->cr7_data, ioaddr + DCR7);
 852
 853         spin_unlock_irqrestore(&db->lock, flags);
 854         return IRQ_HANDLED;
 855 }
 856
 857
 858 #ifdef CONFIG_NET_POLL_CONTROLLER
 859 /*
 860  * Polling 'interrupt' - used by things like netconsole to send skbs
 861  * without having to re-enable interrupts. It's not called while
 862  * the interrupt routine is executing.
 863  */
 864
 865 static void poll_dmfe (struct net_device *dev)
 866 {
 867         /* disable_irq here is not very nice, but with the lockless
 868            interrupt handler we have no other choice. */
 869         disable_irq(dev->irq);
 870         dmfe_interrupt (dev->irq, dev);
 871         enable_irq(dev->irq);
 872 }
 873 #endif
 874
 875 /*
 876  *      Free TX resource after TX complete
 877  */
 878
 879 static void dmfe_free_tx_pkt(struct DEVICE *dev, struct dmfe_board_info * db)
 880 {
 881         struct tx_desc *txptr;
 882         unsigned long ioaddr = dev->base_addr;
 883         u32 tdes0;
 884
 885         txptr = db->tx_remove_ptr;
 886         while(db->tx_packet_cnt) {
 887                 tdes0 = le32_to_cpu(txptr->tdes0);
 888                 /* printk(DRV_NAME ": tdes0=%x\n", tdes0); */
 889                 if (tdes0 & 0x80000000)
 890                         break;
 891
 892                 /* A packet sent completed */
 893                 db->tx_packet_cnt--;
 894                 dev->stats.tx_packets++;
 895
 896                 /* Transmit statistic counter */
 897                 if ( tdes0 != 0x7fffffff ) {
 898                         /* printk(DRV_NAME ": tdes0=%x\n", tdes0); */
 899                         dev->stats.collisions += (tdes0 >> 3) & 0xf;
 900                         dev->stats.tx_bytes += le32_to_cpu(txptr->tdes1) & 0x7ff;
 901                         if (tdes0 & TDES0_ERR_MASK) {
 902                                 dev->stats.tx_errors++;
 903
 904                                 if (tdes0 & 0x0002) {   /* UnderRun */
 905                                         db->tx_fifo_underrun++;
 906                                         if ( !(db->cr6_data & CR6_SFT) ) {
 907                                                 db->cr6_data = db->cr6_data | CR6_SFT;
 908                                                 update_cr6(db->cr6_data, db->ioaddr);
 909                                         }
 910                                 }
 911                                 if (tdes0 & 0x0100)
 912                                         db->tx_excessive_collision++;
 913                                 if (tdes0 & 0x0200)
 914                                         db->tx_late_collision++;
 915                                 if (tdes0 & 0x0400)
 916                                         db->tx_no_carrier++;
 917                                 if (tdes0 & 0x0800)
 918                                         db->tx_loss_carrier++;
 919                                 if (tdes0 & 0x4000)
 920                                         db->tx_jabber_timeout++;
 921                         }
 922                 }
 923
 924                 txptr = txptr->next_tx_desc;
 925         }/* End of while */
 926
 927         /* Update TX remove pointer to next */
 928         db->tx_remove_ptr = txptr;
 929
 930         /* Send the Tx packet in queue */
 931         if ( (db->tx_packet_cnt < TX_MAX_SEND_CNT) && db->tx_queue_cnt ) {
 932                 txptr->tdes0 = cpu_to_le32(0x80000000); /* Set owner bit */
 933                 db->tx_packet_cnt++;                    /* Ready to send */
 934                 db->tx_queue_cnt--;
 935                 outl(0x1, ioaddr + DCR1);               /* Issue Tx polling */
 936                 dev->trans_start = jiffies;             /* saved time stamp */
 937         }
 938
 939         /* Resource available check */
 940         if ( db->tx_queue_cnt < TX_WAKE_DESC_CNT )
 941                 netif_wake_queue(dev);  /* Active upper layer, send again */
 942 }
 943
 944
 945 /*
 946  *      Calculate the CRC valude of the Rx packet
 947  *      flag =  1 : return the reverse CRC (for the received packet CRC)
 948  *              0 : return the normal CRC (for Hash Table index)
 949  */
 950
 951 static inline u32 cal_CRC(unsigned char * Data, unsigned int Len, u8 flag)
 952 {
 953         u32 crc = crc32(~0, Data, Len);
 954         if (flag) crc = ~crc;
 955         return crc;
 956 }
 957
 958
 959 /*
 960  *      Receive the come packet and pass to upper layer
 961  */
 962
 963 static void dmfe_rx_packet(struct DEVICE *dev, struct dmfe_board_info * db)
 964 {
 965         struct rx_desc *rxptr;
 966         struct sk_buff *skb, *newskb;
 967         int rxlen;
 968         u32 rdes0;
 969
 970         rxptr = db->rx_ready_ptr;
 971
 972         while(db->rx_avail_cnt) {
 973                 rdes0 = le32_to_cpu(rxptr->rdes0);
 974                 if (rdes0 & 0x80000000) /* packet owner check */
 975                         break;
 976
 977                 db->rx_avail_cnt--;
 978                 db->interval_rx_cnt++;
 979
 980                 pci_unmap_single(db->pdev, le32_to_cpu(rxptr->rdes2),
 981                                  RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE);
 982
 983                 if ( (rdes0 & 0x300) != 0x300) {
 984                         /* A packet without First/Last flag */
 985                         /* reuse this SKB */
 986                         DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
 987                         dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
 988                 } else {
 989                         /* A packet with First/Last flag */
 990                         rxlen = ( (rdes0 >> 16) & 0x3fff) - 4;
 991
 992                         /* error summary bit check */
 993                         if (rdes0 & 0x8000) {
 994                                 /* This is a error packet */
 995                                 //printk(DRV_NAME ": rdes0: %lx\n", rdes0);
 996                                 dev->stats.rx_errors++;
 997                                 if (rdes0 & 1)
 998                                         dev->stats.rx_fifo_errors++;
 999                                 if (rdes0 & 2)
1000                                         dev->stats.rx_crc_errors++;
1001                                 if (rdes0 & 0x80)
1002                                         dev->stats.rx_length_errors++;
1003                         }
1004
1005                         if ( !(rdes0 & 0x8000) ||
1006                                 ((db->cr6_data & CR6_PM) && (rxlen>6)) ) {
1007                                 skb = rxptr->rx_skb_ptr;
1008
1009                                 /* Received Packet CRC check need or not */
1010                                 if ( (db->dm910x_chk_mode & 1) &&
1011                                         (cal_CRC(skb->data, rxlen, 1) !=
1012                                         (*(u32 *) (skb->data+rxlen) ))) { /* FIXME (?) */
1013                                         /* Found a error received packet */
1014                                         dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
1015                                         db->dm910x_chk_mode = 3;
1016                                 } else {
1017                                         /* Good packet, send to upper layer */
1018                                         /* Shorst packet used new SKB */
1019                                         if ((rxlen < RX_COPY_SIZE) &&
1020                                                 ((newskb = dev_alloc_skb(rxlen + 2))
1021                                                 != NULL)) {
1022
1023                                                 skb = newskb;
1024                                                 /* size less than COPY_SIZE, allocate a rxlen SKB */
1025                                                 skb_reserve(skb, 2); /* 16byte align */
1026                                                 skb_copy_from_linear_data(rxptr->rx_skb_ptr,
1027                                                           skb_put(skb, rxlen),
1028                                                                           rxlen);
1029                                                 dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
1030                                         } else
1031                                                 skb_put(skb, rxlen);
1032
1033                                         skb->protocol = eth_type_trans(skb, dev);
1034                                         netif_rx(skb);
1035                                         dev->stats.rx_packets++;
1036                                         dev->stats.rx_bytes += rxlen;
1037                                 }
1038                         } else {
1039                                 /* Reuse SKB buffer when the packet is error */
1040                                 DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0);
1041                                 dmfe_reuse_skb(db, rxptr->rx_skb_ptr);
1042                         }
1043                 }
1044
1045                 rxptr = rxptr->next_rx_desc;
1046         }
1047
1048         db->rx_ready_ptr = rxptr;
1049 }
1050
1051 /*
1052  * Set DM910X multicast address
1053  */
1054
1055 static void dmfe_set_filter_mode(struct DEVICE * dev)
1056 {
1057         struct dmfe_board_info *db = netdev_priv(dev);
1058         unsigned long flags;
1059
1060         DMFE_DBUG(0, "dmfe_set_filter_mode()", 0);
1061         spin_lock_irqsave(&db->lock, flags);
1062
1063         if (dev->flags & IFF_PROMISC) {
1064                 DMFE_DBUG(0, "Enable PROM Mode", 0);
1065                 db->cr6_data |= CR6_PM | CR6_PBF;
1066                 update_cr6(db->cr6_data, db->ioaddr);
1067                 spin_unlock_irqrestore(&db->lock, flags);
1068                 return;
1069         }
1070
1071         if (dev->flags & IFF_ALLMULTI || dev->mc_count > DMFE_MAX_MULTICAST) {
1072                 DMFE_DBUG(0, "Pass all multicast address", dev->mc_count);
1073                 db->cr6_data &= ~(CR6_PM | CR6_PBF);
1074                 db->cr6_data |= CR6_PAM;
1075                 spin_unlock_irqrestore(&db->lock, flags);
1076                 return;
1077         }
1078
1079         DMFE_DBUG(0, "Set multicast address", dev->mc_count);
1080         if (db->chip_id == PCI_DM9132_ID)
1081                 dm9132_id_table(dev, dev->mc_count);    /* DM9132 */
1082         else
1083                 send_filter_frame(dev, dev->mc_count);  /* DM9102/DM9102A */
1084         spin_unlock_irqrestore(&db->lock, flags);
1085 }
1086
1087 /*
1088  *      Ethtool interace
1089  */
1090
1091 static void dmfe_ethtool_get_drvinfo(struct net_device *dev,
1092                                struct ethtool_drvinfo *info)
1093 {
1094         struct dmfe_board_info *np = netdev_priv(dev);
1095
1096         strcpy(info->driver, DRV_NAME);
1097         strcpy(info->version, DRV_VERSION);
1098         if (np->pdev)
1099                 strcpy(info->bus_info, pci_name(np->pdev));
1100         else
1101                 sprintf(info->bus_info, "EISA 0x%lx %d",
1102                         dev->base_addr, dev->irq);
1103 }
1104
1105 static int dmfe_ethtool_set_wol(struct net_device *dev,
1106                                 struct ethtool_wolinfo *wolinfo)
1107 {
1108         struct dmfe_board_info *db = netdev_priv(dev);
1109
1110         if (wolinfo->wolopts & (WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |
1111                                 WAKE_ARP | WAKE_MAGICSECURE))
1112                    return -EOPNOTSUPP;
1113
1114         db->wol_mode = wolinfo->wolopts;
1115         return 0;
1116 }
1117
1118 static void dmfe_ethtool_get_wol(struct net_device *dev,
1119                                  struct ethtool_wolinfo *wolinfo)
1120 {
1121         struct dmfe_board_info *db = netdev_priv(dev);
1122
1123         wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
1124         wolinfo->wolopts = db->wol_mode;
1125         return;
1126 }
1127
1128
1129 static const struct ethtool_ops netdev_ethtool_ops = {
1130         .get_drvinfo            = dmfe_ethtool_get_drvinfo,
1131         .get_link               = ethtool_op_get_link,
1132         .set_wol                = dmfe_ethtool_set_wol,
1133         .get_wol                = dmfe_ethtool_get_wol,
1134 };
1135
1136 /*
1137  *      A periodic timer routine
1138  *      Dynamic media sense, allocate Rx buffer...
1139  */
1140
1141 static void dmfe_timer(unsigned long data)
1142 {
1143         u32 tmp_cr8;
1144         unsigned char tmp_cr12;
1145         struct DEVICE *dev = (struct DEVICE *) data;
1146         struct dmfe_board_info *db = netdev_priv(dev);
1147         unsigned long flags;
1148
1149         int link_ok, link_ok_phy;
1150
1151         DMFE_DBUG(0, "dmfe_timer()", 0);
1152         spin_lock_irqsave(&db->lock, flags);
1153
1154         /* Media mode process when Link OK before enter this route */
1155         if (db->first_in_callback == 0) {
1156                 db->first_in_callback = 1;
1157                 if (db->chip_type && (db->chip_id==PCI_DM9102_ID)) {
1158                         db->cr6_data &= ~0x40000;
1159                         update_cr6(db->cr6_data, db->ioaddr);
1160                         phy_write(db->ioaddr,
1161                                   db->phy_addr, 0, 0x1000, db->chip_id);
1162                         db->cr6_data |= 0x40000;
1163                         update_cr6(db->cr6_data, db->ioaddr);
1164                         db->timer.expires = DMFE_TIMER_WUT + HZ * 2;
1165                         add_timer(&db->timer);
1166                         spin_unlock_irqrestore(&db->lock, flags);
1167                         return;
1168                 }
1169         }
1170
1171
1172         /* Operating Mode Check */
1173         if ( (db->dm910x_chk_mode & 0x1) &&
1174                 (dev->stats.rx_packets > MAX_CHECK_PACKET) )
1175                 db->dm910x_chk_mode = 0x4;
1176
1177         /* Dynamic reset DM910X : system error or transmit time-out */
1178         tmp_cr8 = inl(db->ioaddr + DCR8);
1179         if ( (db->interval_rx_cnt==0) && (tmp_cr8) ) {
1180                 db->reset_cr8++;
1181                 db->wait_reset = 1;
1182         }
1183         db->interval_rx_cnt = 0;
1184
1185         /* TX polling kick monitor */
1186         if ( db->tx_packet_cnt &&
1187              time_after(jiffies, dev->trans_start + DMFE_TX_KICK) ) {
1188                 outl(0x1, dev->base_addr + DCR1);   /* Tx polling again */
1189
1190                 /* TX Timeout */
1191                 if ( time_after(jiffies, dev->trans_start + DMFE_TX_TIMEOUT) ) {
1192                         db->reset_TXtimeout++;
1193                         db->wait_reset = 1;
1194                         printk(KERN_WARNING "%s: Tx timeout - resetting\n",
1195                                dev->name);
1196                 }
1197         }
1198
1199         if (db->wait_reset) {
1200                 DMFE_DBUG(0, "Dynamic Reset device", db->tx_packet_cnt);
1201                 db->reset_count++;
1202                 dmfe_dynamic_reset(dev);
1203                 db->first_in_callback = 0;
1204                 db->timer.expires = DMFE_TIMER_WUT;
1205                 add_timer(&db->timer);
1206                 spin_unlock_irqrestore(&db->lock, flags);
1207                 return;
1208         }
1209
1210         /* Link status check, Dynamic media type change */
1211         if (db->chip_id == PCI_DM9132_ID)
1212                 tmp_cr12 = inb(db->ioaddr + DCR9 + 3);  /* DM9132 */
1213         else
1214                 tmp_cr12 = inb(db->ioaddr + DCR12);     /* DM9102/DM9102A */
1215
1216         if ( ((db->chip_id == PCI_DM9102_ID) &&
1217                 (db->chip_revision == 0x30)) ||
1218                 ((db->chip_id == PCI_DM9132_ID) &&
1219                 (db->chip_revision == 0x10)) ) {
1220                 /* DM9102A Chip */
1221                 if (tmp_cr12 & 2)
1222                         link_ok = 0;
1223                 else
1224                         link_ok = 1;
1225         }
1226         else
1227                 /*0x43 is used instead of 0x3 because bit 6 should represent
1228                         link status of external PHY */
1229                 link_ok = (tmp_cr12 & 0x43) ? 1 : 0;
1230
1231
1232         /* If chip reports that link is failed it could be because external
1233                 PHY link status pin is not conected correctly to chip
1234                 To be sure ask PHY too.
1235         */
1236
1237         /* need a dummy read because of PHY's register latch*/
1238         phy_read (db->ioaddr, db->phy_addr, 1, db->chip_id);
1239         link_ok_phy = (phy_read (db->ioaddr,
1240                        db->phy_addr, 1, db->chip_id) & 0x4) ? 1 : 0;
1241
1242         if (link_ok_phy != link_ok) {
1243                 DMFE_DBUG (0, "PHY and chip report different link status", 0);
1244                 link_ok = link_ok | link_ok_phy;
1245         }
1246
1247         if ( !link_ok && netif_carrier_ok(dev)) {
1248                 /* Link Failed */
1249                 DMFE_DBUG(0, "Link Failed", tmp_cr12);
1250                 netif_carrier_off(dev);
1251
1252                 /* For Force 10/100M Half/Full mode: Enable Auto-Nego mode */
1253                 /* AUTO or force 1M Homerun/Longrun don't need */
1254                 if ( !(db->media_mode & 0x38) )
1255                         phy_write(db->ioaddr, db->phy_addr,
1256                                   0, 0x1000, db->chip_id);
1257
1258                 /* AUTO mode, if INT phyxcer link failed, select EXT device */
1259                 if (db->media_mode & DMFE_AUTO) {
1260                         /* 10/100M link failed, used 1M Home-Net */
1261                         db->cr6_data|=0x00040000;       /* bit18=1, MII */
1262                         db->cr6_data&=~0x00000200;      /* bit9=0, HD mode */
1263                         update_cr6(db->cr6_data, db->ioaddr);
1264                 }
1265         } else if (!netif_carrier_ok(dev)) {
1266
1267                 DMFE_DBUG(0, "Link link OK", tmp_cr12);
1268
1269                 /* Auto Sense Speed */
1270                 if ( !(db->media_mode & DMFE_AUTO) || !dmfe_sense_speed(db)) {
1271                         netif_carrier_on(dev);
1272                         SHOW_MEDIA_TYPE(db->op_mode);
1273                 }
1274
1275                 dmfe_process_mode(db);
1276         }
1277
1278         /* HPNA remote command check */
1279         if (db->HPNA_command & 0xf00) {
1280                 db->HPNA_timer--;
1281                 if (!db->HPNA_timer)
1282                         dmfe_HPNA_remote_cmd_chk(db);
1283         }
1284
1285         /* Timer active again */
1286         db->timer.expires = DMFE_TIMER_WUT;
1287         add_timer(&db->timer);
1288         spin_unlock_irqrestore(&db->lock, flags);
1289 }
1290
1291
1292 /*
1293  *      Dynamic reset the DM910X board
1294  *      Stop DM910X board
1295  *      Free Tx/Rx allocated memory
1296  *      Reset DM910X board
1297  *      Re-initilize DM910X board
1298  */
1299
1300 static void dmfe_dynamic_reset(struct DEVICE *dev)
1301 {
1302         struct dmfe_board_info *db = netdev_priv(dev);
1303
1304         DMFE_DBUG(0, "dmfe_dynamic_reset()", 0);
1305
1306         /* Sopt MAC controller */
1307         db->cr6_data &= ~(CR6_RXSC | CR6_TXSC); /* Disable Tx/Rx */
1308         update_cr6(db->cr6_data, dev->base_addr);
1309         outl(0, dev->base_addr + DCR7);         /* Disable Interrupt */
1310         outl(inl(dev->base_addr + DCR5), dev->base_addr + DCR5);
1311
1312         /* Disable upper layer interface */
1313         netif_stop_queue(dev);
1314
1315         /* Free Rx Allocate buffer */
1316         dmfe_free_rxbuffer(db);
1317
1318         /* system variable init */
1319         db->tx_packet_cnt = 0;
1320         db->tx_queue_cnt = 0;
1321         db->rx_avail_cnt = 0;
1322         netif_carrier_off(dev);
1323         db->wait_reset = 0;
1324
1325         /* Re-initilize DM910X board */
1326         dmfe_init_dm910x(dev);
1327
1328         /* Restart upper layer interface */
1329         netif_wake_queue(dev);
1330 }
1331
1332
1333 /*
1334  *      free all allocated rx buffer
1335  */
1336
1337 static void dmfe_free_rxbuffer(struct dmfe_board_info * db)
1338 {
1339         DMFE_DBUG(0, "dmfe_free_rxbuffer()", 0);
1340
1341         /* free allocated rx buffer */
1342         while (db->rx_avail_cnt) {
1343                 dev_kfree_skb(db->rx_ready_ptr->rx_skb_ptr);
1344                 db->rx_ready_ptr = db->rx_ready_ptr->next_rx_desc;
1345                 db->rx_avail_cnt--;
1346         }
1347 }
1348
1349
1350 /*
1351  *      Reuse the SK buffer
1352  */
1353
1354 static void dmfe_reuse_skb(struct dmfe_board_info *db, struct sk_buff * skb)
1355 {
1356         struct rx_desc *rxptr = db->rx_insert_ptr;
1357
1358         if (!(rxptr->rdes0 & cpu_to_le32(0x80000000))) {
1359                 rxptr->rx_skb_ptr = skb;
1360                 rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev,
1361                             skb->data, RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1362                 wmb();
1363                 rxptr->rdes0 = cpu_to_le32(0x80000000);
1364                 db->rx_avail_cnt++;
1365                 db->rx_insert_ptr = rxptr->next_rx_desc;
1366         } else
1367                 DMFE_DBUG(0, "SK Buffer reuse method error", db->rx_avail_cnt);
1368 }
1369
1370
1371 /*
1372  *      Initialize transmit/Receive descriptor
1373  *      Using Chain structure, and allocate Tx/Rx buffer
1374  */
1375
1376 static void dmfe_descriptor_init(struct dmfe_board_info *db, unsigned long ioaddr)
1377 {
1378         struct tx_desc *tmp_tx;
1379         struct rx_desc *tmp_rx;
1380         unsigned char *tmp_buf;
1381         dma_addr_t tmp_tx_dma, tmp_rx_dma;
1382         dma_addr_t tmp_buf_dma;
1383         int i;
1384
1385         DMFE_DBUG(0, "dmfe_descriptor_init()", 0);
1386
1387         /* tx descriptor start pointer */
1388         db->tx_insert_ptr = db->first_tx_desc;
1389         db->tx_remove_ptr = db->first_tx_desc;
1390         outl(db->first_tx_desc_dma, ioaddr + DCR4);     /* TX DESC address */
1391
1392         /* rx descriptor start pointer */
1393         db->first_rx_desc = (void *)db->first_tx_desc +
1394                         sizeof(struct tx_desc) * TX_DESC_CNT;
1395
1396         db->first_rx_desc_dma =  db->first_tx_desc_dma +
1397                         sizeof(struct tx_desc) * TX_DESC_CNT;
1398         db->rx_insert_ptr = db->first_rx_desc;
1399         db->rx_ready_ptr = db->first_rx_desc;
1400         outl(db->first_rx_desc_dma, ioaddr + DCR3);     /* RX DESC address */
1401
1402         /* Init Transmit chain */
1403         tmp_buf = db->buf_pool_start;
1404         tmp_buf_dma = db->buf_pool_dma_start;
1405         tmp_tx_dma = db->first_tx_desc_dma;
1406         for (tmp_tx = db->first_tx_desc, i = 0; i < TX_DESC_CNT; i++, tmp_tx++) {
1407                 tmp_tx->tx_buf_ptr = tmp_buf;
1408                 tmp_tx->tdes0 = cpu_to_le32(0);
1409                 tmp_tx->tdes1 = cpu_to_le32(0x81000000);        /* IC, chain */
1410                 tmp_tx->tdes2 = cpu_to_le32(tmp_buf_dma);
1411                 tmp_tx_dma += sizeof(struct tx_desc);
1412                 tmp_tx->tdes3 = cpu_to_le32(tmp_tx_dma);
1413                 tmp_tx->next_tx_desc = tmp_tx + 1;
1414                 tmp_buf = tmp_buf + TX_BUF_ALLOC;
1415                 tmp_buf_dma = tmp_buf_dma + TX_BUF_ALLOC;
1416         }
1417         (--tmp_tx)->tdes3 = cpu_to_le32(db->first_tx_desc_dma);
1418         tmp_tx->next_tx_desc = db->first_tx_desc;
1419
1420          /* Init Receive descriptor chain */
1421         tmp_rx_dma=db->first_rx_desc_dma;
1422         for (tmp_rx = db->first_rx_desc, i = 0; i < RX_DESC_CNT; i++, tmp_rx++) {
1423                 tmp_rx->rdes0 = cpu_to_le32(0);
1424                 tmp_rx->rdes1 = cpu_to_le32(0x01000600);
1425                 tmp_rx_dma += sizeof(struct rx_desc);
1426                 tmp_rx->rdes3 = cpu_to_le32(tmp_rx_dma);
1427                 tmp_rx->next_rx_desc = tmp_rx + 1;
1428         }
1429         (--tmp_rx)->rdes3 = cpu_to_le32(db->first_rx_desc_dma);
1430         tmp_rx->next_rx_desc = db->first_rx_desc;
1431
1432         /* pre-allocate Rx buffer */
1433         allocate_rx_buffer(db);
1434 }
1435
1436
1437 /*
1438  *      Update CR6 value
1439  *      Firstly stop DM910X , then written value and start
1440  */
1441
1442 static void update_cr6(u32 cr6_data, unsigned long ioaddr)
1443 {
1444         u32 cr6_tmp;
1445
1446         cr6_tmp = cr6_data & ~0x2002;           /* stop Tx/Rx */
1447         outl(cr6_tmp, ioaddr + DCR6);
1448         udelay(5);
1449         outl(cr6_data, ioaddr + DCR6);
1450         udelay(5);
1451 }
1452
1453
1454 /*
1455  *      Send a setup frame for DM9132
1456  *      This setup frame initilize DM910X address filter mode
1457 */
1458
1459 static void dm9132_id_table(struct DEVICE *dev, int mc_cnt)
1460 {
1461         struct dev_mc_list *mcptr;
1462         u16 * addrptr;
1463         unsigned long ioaddr = dev->base_addr+0xc0;             /* ID Table */
1464         u32 hash_val;
1465         u16 i, hash_table[4];
1466
1467         DMFE_DBUG(0, "dm9132_id_table()", 0);
1468
1469         /* Node address */
1470         addrptr = (u16 *) dev->dev_addr;
1471         outw(addrptr[0], ioaddr);
1472         ioaddr += 4;
1473         outw(addrptr[1], ioaddr);
1474         ioaddr += 4;
1475         outw(addrptr[2], ioaddr);
1476         ioaddr += 4;
1477
1478         /* Clear Hash Table */
1479         for (i = 0; i < 4; i++)
1480                 hash_table[i] = 0x0;
1481
1482         /* broadcast address */
1483         hash_table[3] = 0x8000;
1484
1485         /* the multicast address in Hash Table : 64 bits */
1486         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
1487                 hash_val = cal_CRC( (char *) mcptr->dmi_addr, 6, 0) & 0x3f;
1488                 hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
1489         }
1490
1491         /* Write the hash table to MAC MD table */
1492         for (i = 0; i < 4; i++, ioaddr += 4)
1493                 outw(hash_table[i], ioaddr);
1494 }
1495
1496
1497 /*
1498  *      Send a setup frame for DM9102/DM9102A
1499  *      This setup frame initilize DM910X address filter mode
1500  */
1501
1502 static void send_filter_frame(struct DEVICE *dev, int mc_cnt)
1503 {
1504         struct dmfe_board_info *db = netdev_priv(dev);
1505         struct dev_mc_list *mcptr;
1506         struct tx_desc *txptr;
1507         u16 * addrptr;
1508         u32 * suptr;
1509         int i;
1510
1511         DMFE_DBUG(0, "send_filter_frame()", 0);
1512
1513         txptr = db->tx_insert_ptr;
1514         suptr = (u32 *) txptr->tx_buf_ptr;
1515
1516         /* Node address */
1517         addrptr = (u16 *) dev->dev_addr;
1518         *suptr++ = addrptr[0];
1519         *suptr++ = addrptr[1];
1520         *suptr++ = addrptr[2];
1521
1522         /* broadcast address */
1523         *suptr++ = 0xffff;
1524         *suptr++ = 0xffff;
1525         *suptr++ = 0xffff;
1526
1527         /* fit the multicast address */
1528         for (mcptr = dev->mc_list, i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
1529                 addrptr = (u16 *) mcptr->dmi_addr;
1530                 *suptr++ = addrptr[0];
1531                 *suptr++ = addrptr[1];
1532                 *suptr++ = addrptr[2];
1533         }
1534
1535         for (; i<14; i++) {
1536                 *suptr++ = 0xffff;
1537                 *suptr++ = 0xffff;
1538                 *suptr++ = 0xffff;
1539         }
1540
1541         /* prepare the setup frame */
1542         db->tx_insert_ptr = txptr->next_tx_desc;
1543         txptr->tdes1 = cpu_to_le32(0x890000c0);
1544
1545         /* Resource Check and Send the setup packet */
1546         if (!db->tx_packet_cnt) {
1547                 /* Resource Empty */
1548                 db->tx_packet_cnt++;
1549                 txptr->tdes0 = cpu_to_le32(0x80000000);
1550                 update_cr6(db->cr6_data | 0x2000, dev->base_addr);
1551                 outl(0x1, dev->base_addr + DCR1);       /* Issue Tx polling */
1552                 update_cr6(db->cr6_data, dev->base_addr);
1553                 dev->trans_start = jiffies;
1554         } else
1555                 db->tx_queue_cnt++;     /* Put in TX queue */
1556 }
1557
1558
1559 /*
1560  *      Allocate rx buffer,
1561  *      As possible as allocate maxiumn Rx buffer
1562  */
1563
1564 static void allocate_rx_buffer(struct dmfe_board_info *db)
1565 {
1566         struct rx_desc *rxptr;
1567         struct sk_buff *skb;
1568
1569         rxptr = db->rx_insert_ptr;
1570
1571         while(db->rx_avail_cnt < RX_DESC_CNT) {
1572                 if ( ( skb = dev_alloc_skb(RX_ALLOC_SIZE) ) == NULL )
1573                         break;
1574                 rxptr->rx_skb_ptr = skb; /* FIXME (?) */
1575                 rxptr->rdes2 = cpu_to_le32( pci_map_single(db->pdev, skb->data,
1576                                     RX_ALLOC_SIZE, PCI_DMA_FROMDEVICE) );
1577                 wmb();
1578                 rxptr->rdes0 = cpu_to_le32(0x80000000);
1579                 rxptr = rxptr->next_rx_desc;
1580                 db->rx_avail_cnt++;
1581         }
1582
1583         db->rx_insert_ptr = rxptr;
1584 }
1585
1586
1587 /*
1588  *      Read one word data from the serial ROM
1589  */
1590
1591 static u16 read_srom_word(long ioaddr, int offset)
1592 {
1593         int i;
1594         u16 srom_data = 0;
1595         long cr9_ioaddr = ioaddr + DCR9;
1596
1597         outl(CR9_SROM_READ, cr9_ioaddr);
1598         outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1599
1600         /* Send the Read Command 110b */
1601         SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
1602         SROM_CLK_WRITE(SROM_DATA_1, cr9_ioaddr);
1603         SROM_CLK_WRITE(SROM_DATA_0, cr9_ioaddr);
1604
1605         /* Send the offset */
1606         for (i = 5; i >= 0; i--) {
1607                 srom_data = (offset & (1 << i)) ? SROM_DATA_1 : SROM_DATA_0;
1608                 SROM_CLK_WRITE(srom_data, cr9_ioaddr);
1609         }
1610
1611         outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1612
1613         for (i = 16; i > 0; i--) {
1614                 outl(CR9_SROM_READ | CR9_SRCS | CR9_SRCLK, cr9_ioaddr);
1615                 udelay(5);
1616                 srom_data = (srom_data << 1) |
1617                                 ((inl(cr9_ioaddr) & CR9_CRDOUT) ? 1 : 0);
1618                 outl(CR9_SROM_READ | CR9_SRCS, cr9_ioaddr);
1619                 udelay(5);
1620         }
1621
1622         outl(CR9_SROM_READ, cr9_ioaddr);
1623         return srom_data;
1624 }
1625
1626
1627 /*
1628  *      Auto sense the media mode
1629  */
1630
1631 static u8 dmfe_sense_speed(struct dmfe_board_info * db)
1632 {
1633         u8 ErrFlag = 0;
1634         u16 phy_mode;
1635
1636         /* CR6 bit18=0, select 10/100M */
1637         update_cr6( (db->cr6_data & ~0x40000), db->ioaddr);
1638
1639         phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
1640         phy_mode = phy_read(db->ioaddr, db->phy_addr, 1, db->chip_id);
1641
1642         if ( (phy_mode & 0x24) == 0x24 ) {
1643                 if (db->chip_id == PCI_DM9132_ID)       /* DM9132 */
1644                         phy_mode = phy_read(db->ioaddr,
1645                                     db->phy_addr, 7, db->chip_id) & 0xf000;
1646                 else                            /* DM9102/DM9102A */
1647                         phy_mode = phy_read(db->ioaddr,
1648                                     db->phy_addr, 17, db->chip_id) & 0xf000;
1649                 /* printk(DRV_NAME ": Phy_mode %x ",phy_mode); */
1650                 switch (phy_mode) {
1651                 case 0x1000: db->op_mode = DMFE_10MHF; break;
1652                 case 0x2000: db->op_mode = DMFE_10MFD; break;
1653                 case 0x4000: db->op_mode = DMFE_100MHF; break;
1654                 case 0x8000: db->op_mode = DMFE_100MFD; break;
1655                 default: db->op_mode = DMFE_10MHF;
1656                         ErrFlag = 1;
1657                         break;
1658                 }
1659         } else {
1660                 db->op_mode = DMFE_10MHF;
1661                 DMFE_DBUG(0, "Link Failed :", phy_mode);
1662                 ErrFlag = 1;
1663         }
1664
1665         return ErrFlag;
1666 }
1667
1668
1669 /*
1670  *      Set 10/100 phyxcer capability
1671  *      AUTO mode : phyxcer register4 is NIC capability
1672  *      Force mode: phyxcer register4 is the force media
1673  */
1674
1675 static void dmfe_set_phyxcer(struct dmfe_board_info *db)
1676 {
1677         u16 phy_reg;
1678
1679         /* Select 10/100M phyxcer */
1680         db->cr6_data &= ~0x40000;
1681         update_cr6(db->cr6_data, db->ioaddr);
1682
1683         /* DM9009 Chip: Phyxcer reg18 bit12=0 */
1684         if (db->chip_id == PCI_DM9009_ID) {
1685                 phy_reg = phy_read(db->ioaddr,
1686                                    db->phy_addr, 18, db->chip_id) & ~0x1000;
1687
1688                 phy_write(db->ioaddr,
1689                           db->phy_addr, 18, phy_reg, db->chip_id);
1690         }
1691
1692         /* Phyxcer capability setting */
1693         phy_reg = phy_read(db->ioaddr, db->phy_addr, 4, db->chip_id) & ~0x01e0;
1694
1695         if (db->media_mode & DMFE_AUTO) {
1696                 /* AUTO Mode */
1697                 phy_reg |= db->PHY_reg4;
1698         } else {
1699                 /* Force Mode */
1700                 switch(db->media_mode) {
1701                 case DMFE_10MHF: phy_reg |= 0x20; break;
1702                 case DMFE_10MFD: phy_reg |= 0x40; break;
1703                 case DMFE_100MHF: phy_reg |= 0x80; break;
1704                 case DMFE_100MFD: phy_reg |= 0x100; break;
1705                 }
1706                 if (db->chip_id == PCI_DM9009_ID) phy_reg &= 0x61;
1707         }
1708
1709         /* Write new capability to Phyxcer Reg4 */
1710         if ( !(phy_reg & 0x01e0)) {
1711                 phy_reg|=db->PHY_reg4;
1712                 db->media_mode|=DMFE_AUTO;
1713         }
1714         phy_write(db->ioaddr, db->phy_addr, 4, phy_reg, db->chip_id);
1715
1716         /* Restart Auto-Negotiation */
1717         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
1718                 phy_write(db->ioaddr, db->phy_addr, 0, 0x1800, db->chip_id);
1719         if ( !db->chip_type )
1720                 phy_write(db->ioaddr, db->phy_addr, 0, 0x1200, db->chip_id);
1721 }
1722
1723
1724 /*
1725  *      Process op-mode
1726  *      AUTO mode : PHY controller in Auto-negotiation Mode
1727  *      Force mode: PHY controller in force mode with HUB
1728  *                      N-way force capability with SWITCH
1729  */
1730
1731 static void dmfe_process_mode(struct dmfe_board_info *db)
1732 {
1733         u16 phy_reg;
1734
1735         /* Full Duplex Mode Check */
1736         if (db->op_mode & 0x4)
1737                 db->cr6_data |= CR6_FDM;        /* Set Full Duplex Bit */
1738         else
1739                 db->cr6_data &= ~CR6_FDM;       /* Clear Full Duplex Bit */
1740
1741         /* Transciver Selection */
1742         if (db->op_mode & 0x10)         /* 1M HomePNA */
1743                 db->cr6_data |= 0x40000;/* External MII select */
1744         else
1745                 db->cr6_data &= ~0x40000;/* Internal 10/100 transciver */
1746
1747         update_cr6(db->cr6_data, db->ioaddr);
1748
1749         /* 10/100M phyxcer force mode need */
1750         if ( !(db->media_mode & 0x18)) {
1751                 /* Forece Mode */
1752                 phy_reg = phy_read(db->ioaddr, db->phy_addr, 6, db->chip_id);
1753                 if ( !(phy_reg & 0x1) ) {
1754                         /* parter without N-Way capability */
1755                         phy_reg = 0x0;
1756                         switch(db->op_mode) {
1757                         case DMFE_10MHF: phy_reg = 0x0; break;
1758                         case DMFE_10MFD: phy_reg = 0x100; break;
1759                         case DMFE_100MHF: phy_reg = 0x2000; break;
1760                         case DMFE_100MFD: phy_reg = 0x2100; break;
1761                         }
1762                         phy_write(db->ioaddr,
1763                                   db->phy_addr, 0, phy_reg, db->chip_id);
1764                         if ( db->chip_type && (db->chip_id == PCI_DM9102_ID) )
1765                                 mdelay(20);
1766                         phy_write(db->ioaddr,
1767                                   db->phy_addr, 0, phy_reg, db->chip_id);
1768                 }
1769         }
1770 }
1771
1772
1773 /*
1774  *      Write a word to Phy register
1775  */
1776
1777 static void phy_write(unsigned long iobase, u8 phy_addr, u8 offset,
1778                       u16 phy_data, u32 chip_id)
1779 {
1780         u16 i;
1781         unsigned long ioaddr;
1782
1783         if (chip_id == PCI_DM9132_ID) {
1784                 ioaddr = iobase + 0x80 + offset * 4;
1785                 outw(phy_data, ioaddr);
1786         } else {
1787                 /* DM9102/DM9102A Chip */
1788                 ioaddr = iobase + DCR9;
1789
1790                 /* Send 33 synchronization clock to Phy controller */
1791                 for (i = 0; i < 35; i++)
1792                         phy_write_1bit(ioaddr, PHY_DATA_1);
1793
1794                 /* Send start command(01) to Phy */
1795                 phy_write_1bit(ioaddr, PHY_DATA_0);
1796                 phy_write_1bit(ioaddr, PHY_DATA_1);
1797
1798                 /* Send write command(01) to Phy */
1799                 phy_write_1bit(ioaddr, PHY_DATA_0);
1800                 phy_write_1bit(ioaddr, PHY_DATA_1);
1801
1802                 /* Send Phy address */
1803                 for (i = 0x10; i > 0; i = i >> 1)
1804                         phy_write_1bit(ioaddr,
1805                                        phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
1806
1807                 /* Send register address */
1808                 for (i = 0x10; i > 0; i = i >> 1)
1809                         phy_write_1bit(ioaddr,
1810                                        offset & i ? PHY_DATA_1 : PHY_DATA_0);
1811
1812                 /* written trasnition */
1813                 phy_write_1bit(ioaddr, PHY_DATA_1);
1814                 phy_write_1bit(ioaddr, PHY_DATA_0);
1815
1816                 /* Write a word data to PHY controller */
1817                 for ( i = 0x8000; i > 0; i >>= 1)
1818                         phy_write_1bit(ioaddr,
1819                                        phy_data & i ? PHY_DATA_1 : PHY_DATA_0);
1820         }
1821 }
1822
1823
1824 /*
1825  *      Read a word data from phy register
1826  */
1827
1828 static u16 phy_read(unsigned long iobase, u8 phy_addr, u8 offset, u32 chip_id)
1829 {
1830         int i;
1831         u16 phy_data;
1832         unsigned long ioaddr;
1833
1834         if (chip_id == PCI_DM9132_ID) {
1835                 /* DM9132 Chip */
1836                 ioaddr = iobase + 0x80 + offset * 4;
1837                 phy_data = inw(ioaddr);
1838         } else {
1839                 /* DM9102/DM9102A Chip */
1840                 ioaddr = iobase + DCR9;
1841
1842                 /* Send 33 synchronization clock to Phy controller */
1843                 for (i = 0; i < 35; i++)
1844                         phy_write_1bit(ioaddr, PHY_DATA_1);
1845
1846                 /* Send start command(01) to Phy */
1847                 phy_write_1bit(ioaddr, PHY_DATA_0);
1848                 phy_write_1bit(ioaddr, PHY_DATA_1);
1849
1850                 /* Send read command(10) to Phy */
1851                 phy_write_1bit(ioaddr, PHY_DATA_1);
1852                 phy_write_1bit(ioaddr, PHY_DATA_0);
1853
1854                 /* Send Phy address */
1855                 for (i = 0x10; i > 0; i = i >> 1)
1856                         phy_write_1bit(ioaddr,
1857                                        phy_addr & i ? PHY_DATA_1 : PHY_DATA_0);
1858
1859                 /* Send register address */
1860                 for (i = 0x10; i > 0; i = i >> 1)
1861                         phy_write_1bit(ioaddr,
1862                                        offset & i ? PHY_DATA_1 : PHY_DATA_0);
1863
1864                 /* Skip transition state */
1865                 phy_read_1bit(ioaddr);
1866
1867                 /* read 16bit data */
1868                 for (phy_data = 0, i = 0; i < 16; i++) {
1869                         phy_data <<= 1;
1870                         phy_data |= phy_read_1bit(ioaddr);
1871                 }
1872         }
1873
1874         return phy_data;
1875 }
1876
1877
1878 /*
1879  *      Write one bit data to Phy Controller
1880  */
1881
1882 static void phy_write_1bit(unsigned long ioaddr, u32 phy_data)
1883 {
1884         outl(phy_data, ioaddr);                 /* MII Clock Low */
1885         udelay(1);
1886         outl(phy_data | MDCLKH, ioaddr);        /* MII Clock High */
1887         udelay(1);
1888         outl(phy_data, ioaddr);                 /* MII Clock Low */
1889         udelay(1);
1890 }
1891
1892
1893 /*
1894  *      Read one bit phy data from PHY controller
1895  */
1896
1897 static u16 phy_read_1bit(unsigned long ioaddr)
1898 {
1899         u16 phy_data;
1900
1901         outl(0x50000, ioaddr);
1902         udelay(1);
1903         phy_data = ( inl(ioaddr) >> 19 ) & 0x1;
1904         outl(0x40000, ioaddr);
1905         udelay(1);
1906
1907         return phy_data;
1908 }
1909
1910
1911 /*
1912  *      Parser SROM and media mode
1913  */
1914
1915 static void dmfe_parse_srom(struct dmfe_board_info * db)
1916 {
1917         char * srom = db->srom;
1918         int dmfe_mode, tmp_reg;
1919
1920         DMFE_DBUG(0, "dmfe_parse_srom() ", 0);
1921
1922         /* Init CR15 */
1923         db->cr15_data = CR15_DEFAULT;
1924
1925         /* Check SROM Version */
1926         if ( ( (int) srom[18] & 0xff) == SROM_V41_CODE) {
1927                 /* SROM V4.01 */
1928                 /* Get NIC support media mode */
1929                 db->NIC_capability = le16_to_cpup((__le16 *) (srom + 34));
1930                 db->PHY_reg4 = 0;
1931                 for (tmp_reg = 1; tmp_reg < 0x10; tmp_reg <<= 1) {
1932                         switch( db->NIC_capability & tmp_reg ) {
1933                         case 0x1: db->PHY_reg4 |= 0x0020; break;
1934                         case 0x2: db->PHY_reg4 |= 0x0040; break;
1935                         case 0x4: db->PHY_reg4 |= 0x0080; break;
1936                         case 0x8: db->PHY_reg4 |= 0x0100; break;
1937                         }
1938                 }
1939
1940                 /* Media Mode Force or not check */
1941                 dmfe_mode = (le32_to_cpup((__le32 *) (srom + 34)) &
1942                              le32_to_cpup((__le32 *) (srom + 36)));
1943                 switch(dmfe_mode) {
1944                 case 0x4: dmfe_media_mode = DMFE_100MHF; break; /* 100MHF */
1945                 case 0x2: dmfe_media_mode = DMFE_10MFD; break;  /* 10MFD */
1946                 case 0x8: dmfe_media_mode = DMFE_100MFD; break; /* 100MFD */
1947                 case 0x100:
1948                 case 0x200: dmfe_media_mode = DMFE_1M_HPNA; break;/* HomePNA */
1949                 }
1950
1951                 /* Special Function setting */
1952                 /* VLAN function */
1953                 if ( (SF_mode & 0x1) || (srom[43] & 0x80) )
1954                         db->cr15_data |= 0x40;
1955
1956                 /* Flow Control */
1957                 if ( (SF_mode & 0x2) || (srom[40] & 0x1) )
1958                         db->cr15_data |= 0x400;
1959
1960                 /* TX pause packet */
1961                 if ( (SF_mode & 0x4) || (srom[40] & 0xe) )
1962                         db->cr15_data |= 0x9800;
1963         }
1964
1965         /* Parse HPNA parameter */
1966         db->HPNA_command = 1;
1967
1968         /* Accept remote command or not */
1969         if (HPNA_rx_cmd == 0)
1970                 db->HPNA_command |= 0x8000;
1971
1972          /* Issue remote command & operation mode */
1973         if (HPNA_tx_cmd == 1)
1974                 switch(HPNA_mode) {     /* Issue Remote Command */
1975                 case 0: db->HPNA_command |= 0x0904; break;
1976                 case 1: db->HPNA_command |= 0x0a00; break;
1977                 case 2: db->HPNA_command |= 0x0506; break;
1978                 case 3: db->HPNA_command |= 0x0602; break;
1979                 }
1980         else
1981                 switch(HPNA_mode) {     /* Don't Issue */
1982                 case 0: db->HPNA_command |= 0x0004; break;
1983                 case 1: db->HPNA_command |= 0x0000; break;
1984                 case 2: db->HPNA_command |= 0x0006; break;
1985                 case 3: db->HPNA_command |= 0x0002; break;
1986                 }
1987
1988         /* Check DM9801 or DM9802 present or not */
1989         db->HPNA_present = 0;
1990         update_cr6(db->cr6_data|0x40000, db->ioaddr);
1991         tmp_reg = phy_read(db->ioaddr, db->phy_addr, 3, db->chip_id);
1992         if ( ( tmp_reg & 0xfff0 ) == 0xb900 ) {
1993                 /* DM9801 or DM9802 present */
1994                 db->HPNA_timer = 8;
1995                 if ( phy_read(db->ioaddr, db->phy_addr, 31, db->chip_id) == 0x4404) {
1996                         /* DM9801 HomeRun */
1997                         db->HPNA_present = 1;
1998                         dmfe_program_DM9801(db, tmp_reg);
1999                 } else {
2000                         /* DM9802 LongRun */
2001                         db->HPNA_present = 2;
2002                         dmfe_program_DM9802(db);
2003                 }
2004         }
2005
2006 }
2007
2008
2009 /*
2010  *      Init HomeRun DM9801
2011  */
2012
2013 static void dmfe_program_DM9801(struct dmfe_board_info * db, int HPNA_rev)
2014 {
2015         uint reg17, reg25;
2016
2017         if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9801_NOISE_FLOOR;
2018         switch(HPNA_rev) {
2019         case 0xb900: /* DM9801 E3 */
2020                 db->HPNA_command |= 0x1000;
2021                 reg25 = phy_read(db->ioaddr, db->phy_addr, 24, db->chip_id);
2022                 reg25 = ( (reg25 + HPNA_NoiseFloor) & 0xff) | 0xf000;
2023                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
2024                 break;
2025         case 0xb901: /* DM9801 E4 */
2026                 reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
2027                 reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor;
2028                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
2029                 reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor + 3;
2030                 break;
2031         case 0xb902: /* DM9801 E5 */
2032         case 0xb903: /* DM9801 E6 */
2033         default:
2034                 db->HPNA_command |= 0x1000;
2035                 reg25 = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
2036                 reg25 = (reg25 & 0xff00) + HPNA_NoiseFloor - 5;
2037                 reg17 = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id);
2038                 reg17 = (reg17 & 0xfff0) + HPNA_NoiseFloor;
2039                 break;
2040         }
2041         phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
2042         phy_write(db->ioaddr, db->phy_addr, 17, reg17, db->chip_id);
2043         phy_write(db->ioaddr, db->phy_addr, 25, reg25, db->chip_id);
2044 }
2045
2046
2047 /*
2048  *      Init HomeRun DM9802
2049  */
2050
2051 static void dmfe_program_DM9802(struct dmfe_board_info * db)
2052 {
2053         uint phy_reg;
2054
2055         if ( !HPNA_NoiseFloor ) HPNA_NoiseFloor = DM9802_NOISE_FLOOR;
2056         phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command, db->chip_id);
2057         phy_reg = phy_read(db->ioaddr, db->phy_addr, 25, db->chip_id);
2058         phy_reg = ( phy_reg & 0xff00) + HPNA_NoiseFloor;
2059         phy_write(db->ioaddr, db->phy_addr, 25, phy_reg, db->chip_id);
2060 }
2061
2062
2063 /*
2064  *      Check remote HPNA power and speed status. If not correct,
2065  *      issue command again.
2066 */
2067
2068 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info * db)
2069 {
2070         uint phy_reg;
2071
2072         /* Got remote device status */
2073         phy_reg = phy_read(db->ioaddr, db->phy_addr, 17, db->chip_id) & 0x60;
2074         switch(phy_reg) {
2075         case 0x00: phy_reg = 0x0a00;break; /* LP/LS */
2076         case 0x20: phy_reg = 0x0900;break; /* LP/HS */
2077         case 0x40: phy_reg = 0x0600;break; /* HP/LS */
2078         case 0x60: phy_reg = 0x0500;break; /* HP/HS */
2079         }
2080
2081         /* Check remote device status match our setting ot not */
2082         if ( phy_reg != (db->HPNA_command & 0x0f00) ) {
2083                 phy_write(db->ioaddr, db->phy_addr, 16, db->HPNA_command,
2084                           db->chip_id);
2085                 db->HPNA_timer=8;
2086         } else
2087                 db->HPNA_timer=600;     /* Match, every 10 minutes, check */
2088 }
2089
2090
2091
2092 static struct pci_device_id dmfe_pci_tbl[] = {
2093         { 0x1282, 0x9132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9132_ID },
2094         { 0x1282, 0x9102, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9102_ID },
2095         { 0x1282, 0x9100, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9100_ID },
2096         { 0x1282, 0x9009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PCI_DM9009_ID },
2097         { 0, }
2098 };
2099 MODULE_DEVICE_TABLE(pci, dmfe_pci_tbl);
2100
2101
2102 #ifdef CONFIG_PM
2103 static int dmfe_suspend(struct pci_dev *pci_dev, pm_message_t state)
2104 {
2105         struct net_device *dev = pci_get_drvdata(pci_dev);
2106         struct dmfe_board_info *db = netdev_priv(dev);
2107         u32 tmp;
2108
2109         /* Disable upper layer interface */
2110         netif_device_detach(dev);
2111
2112         /* Disable Tx/Rx */
2113         db->cr6_data &= ~(CR6_RXSC | CR6_TXSC);
2114         update_cr6(db->cr6_data, dev->base_addr);
2115
2116         /* Disable Interrupt */
2117         outl(0, dev->base_addr + DCR7);
2118         outl(inl (dev->base_addr + DCR5), dev->base_addr + DCR5);
2119
2120         /* Fre RX buffers */
2121         dmfe_free_rxbuffer(db);
2122
2123         /* Enable WOL */
2124         pci_read_config_dword(pci_dev, 0x40, &tmp);
2125         tmp &= ~(DMFE_WOL_LINKCHANGE|DMFE_WOL_MAGICPACKET);
2126
2127         if (db->wol_mode & WAKE_PHY)
2128                 tmp |= DMFE_WOL_LINKCHANGE;
2129         if (db->wol_mode & WAKE_MAGIC)
2130                 tmp |= DMFE_WOL_MAGICPACKET;
2131
2132         pci_write_config_dword(pci_dev, 0x40, tmp);
2133
2134         pci_enable_wake(pci_dev, PCI_D3hot, 1);
2135         pci_enable_wake(pci_dev, PCI_D3cold, 1);
2136
2137         /* Power down device*/
2138         pci_save_state(pci_dev);
2139         pci_set_power_state(pci_dev, pci_choose_state (pci_dev, state));
2140
2141         return 0;
2142 }
2143
2144 static int dmfe_resume(struct pci_dev *pci_dev)
2145 {
2146         struct net_device *dev = pci_get_drvdata(pci_dev);
2147         u32 tmp;
2148
2149         pci_set_power_state(pci_dev, PCI_D0);
2150         pci_restore_state(pci_dev);
2151
2152         /* Re-initilize DM910X board */
2153         dmfe_init_dm910x(dev);
2154
2155         /* Disable WOL */
2156         pci_read_config_dword(pci_dev, 0x40, &tmp);
2157
2158         tmp &= ~(DMFE_WOL_LINKCHANGE | DMFE_WOL_MAGICPACKET);
2159         pci_write_config_dword(pci_dev, 0x40, tmp);
2160
2161         pci_enable_wake(pci_dev, PCI_D3hot, 0);
2162         pci_enable_wake(pci_dev, PCI_D3cold, 0);
2163
2164         /* Restart upper layer interface */
2165         netif_device_attach(dev);
2166
2167         return 0;
2168 }
2169 #else
2170 #define dmfe_suspend NULL
2171 #define dmfe_resume NULL
2172 #endif
2173
2174 static struct pci_driver dmfe_driver = {
2175         .name           = "dmfe",
2176         .id_table       = dmfe_pci_tbl,
2177         .probe          = dmfe_init_one,
2178         .remove         = __devexit_p(dmfe_remove_one),
2179         .suspend        = dmfe_suspend,
2180         .resume         = dmfe_resume
2181 };
2182
2183 MODULE_AUTHOR("Sten Wang, sten_wang@davicom.com.tw");
2184 MODULE_DESCRIPTION("Davicom DM910X fast ethernet driver");
2185 MODULE_LICENSE("GPL");
2186 MODULE_VERSION(DRV_VERSION);
2187
2188 module_param(debug, int, 0);
2189 module_param(mode, byte, 0);
2190 module_param(cr6set, int, 0);
2191 module_param(chkmode, byte, 0);
2192 module_param(HPNA_mode, byte, 0);
2193 module_param(HPNA_rx_cmd, byte, 0);
2194 module_param(HPNA_tx_cmd, byte, 0);
2195 module_param(HPNA_NoiseFloor, byte, 0);
2196 module_param(SF_mode, byte, 0);
2197 MODULE_PARM_DESC(debug, "Davicom DM9xxx enable debugging (0-1)");
2198 MODULE_PARM_DESC(mode, "Davicom DM9xxx: "
2199                 "Bit 0: 10/100Mbps, bit 2: duplex, bit 8: HomePNA");
2200
2201 MODULE_PARM_DESC(SF_mode, "Davicom DM9xxx special function "
2202                 "(bit 0: VLAN, bit 1 Flow Control, bit 2: TX pause packet)");
2203
2204 /*      Description:
2205  *      when user used insmod to add module, system invoked init_module()
2206  *      to initilize and register.
2207  */
2208
2209 static int __init dmfe_init_module(void)
2210 {
2211         int rc;
2212
2213         printk(version);
2214         printed_version = 1;
2215
2216         DMFE_DBUG(0, "init_module() ", debug);
2217
2218         if (debug)
2219                 dmfe_debug = debug;     /* set debug flag */
2220         if (cr6set)
2221                 dmfe_cr6_user_set = cr6set;
2222
2223         switch(mode) {
2224         case DMFE_10MHF:
2225         case DMFE_100MHF:
2226         case DMFE_10MFD:
2227         case DMFE_100MFD:
2228         case DMFE_1M_HPNA:
2229                 dmfe_media_mode = mode;
2230                 break;
2231         default:dmfe_media_mode = DMFE_AUTO;
2232                 break;
2233         }
2234
2235         if (HPNA_mode > 4)
2236                 HPNA_mode = 0;          /* Default: LP/HS */
2237         if (HPNA_rx_cmd > 1)
2238                 HPNA_rx_cmd = 0;        /* Default: Ignored remote cmd */
2239         if (HPNA_tx_cmd > 1)
2240                 HPNA_tx_cmd = 0;        /* Default: Don't issue remote cmd */
2241         if (HPNA_NoiseFloor > 15)
2242                 HPNA_NoiseFloor = 0;
2243
2244         rc = pci_register_driver(&dmfe_driver);
2245         if (rc < 0)
2246                 return rc;
2247
2248         return 0;
2249 }
2250
2251
2252 /*
2253  *      Description:
2254  *      when user used rmmod to delete module, system invoked clean_module()
2255  *      to un-register all registered services.
2256  */
2257
2258 static void __exit dmfe_cleanup_module(void)
2259 {
2260         DMFE_DBUG(0, "dmfe_clean_module() ", debug);
2261         pci_unregister_driver(&dmfe_driver);
2262 }
2263
2264 module_init(dmfe_init_module);
2265 module_exit(dmfe_cleanup_module);