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