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