drivers/net/ethernet/dec/tulip/dmfe.c

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