2 A Davicom DM9102/DM9102A/DM9102A+DM9801/DM9102A+DM9802 NIC fast
3 ethernet driver for Linux.
4 Copyright (C) 1997 Sten Wang
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.
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.
16 DAVICOM Web-Site: www.davicom.com.tw
18 Author: Sten Wang, 886-3-5798797-8517, E-mail: sten_wang@davicom.com.tw
19 Maintainer: Tobias Ringstrom <tori@unhappy.mine.nu>
21 (C)Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
23 Marcelo Tosatti <marcelo@conectiva.com.br> :
24 Made it compile in 2.3 (device to net_device)
26 Alan Cox <alan@lxorguk.ukuu.org.uk> :
27 Cleaned up for kernel merge.
28 Removed the back compatibility support
29 Reformatted, fixing spelling etc as I went
30 Removed IRQ 0-15 assumption
32 Jeff Garzik <jgarzik@pobox.com> :
33 Updated to use new PCI driver API.
34 Resource usage cleanups.
35 Report driver version to user.
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.
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.
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.
52 Alan Cox <alan@lxorguk.ukuu.org.uk>
53 Added new PCI identifiers provided by Clear Zhang at ALi
54 for their 1563 ethernet device.
58 Check on 64 bit boxes.
59 Check and fix on big endian boxes.
61 Test and make sure PCI latency is now correct for all cases.
64 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
66 #define DRV_NAME "dmfe"
67 #define DRV_VERSION "1.36.4"
68 #define DRV_RELDATE "2002-01-17"
70 #include <linux/module.h>
71 #include <linux/kernel.h>
72 #include <linux/string.h>
73 #include <linux/timer.h>
74 #include <linux/ptrace.h>
75 #include <linux/errno.h>
76 #include <linux/ioport.h>
77 #include <linux/interrupt.h>
78 #include <linux/pci.h>
79 #include <linux/dma-mapping.h>
80 #include <linux/init.h>
81 #include <linux/netdevice.h>
82 #include <linux/etherdevice.h>
83 #include <linux/ethtool.h>
84 #include <linux/skbuff.h>
85 #include <linux/delay.h>
86 #include <linux/spinlock.h>
87 #include <linux/crc32.h>
88 #include <linux/bitops.h>
90 #include <asm/processor.h>
93 #include <asm/uaccess.h>
96 #ifdef CONFIG_TULIP_DM910X
101 /* Board/System/Debug information/definition ---------------- */
102 #define PCI_DM9132_ID 0x91321282 /* Davicom DM9132 ID */
103 #define PCI_DM9102_ID 0x91021282 /* Davicom DM9102 ID */
104 #define PCI_DM9100_ID 0x91001282 /* Davicom DM9100 ID */
105 #define PCI_DM9009_ID 0x90091282 /* Davicom DM9009 ID */
107 #define DM9102_IO_SIZE 0x80
108 #define DM9102A_IO_SIZE 0x100
109 #define TX_MAX_SEND_CNT 0x1 /* Maximum tx packet per time */
110 #define TX_DESC_CNT 0x10 /* Allocated Tx descriptors */
111 #define RX_DESC_CNT 0x20 /* Allocated Rx descriptors */
112 #define TX_FREE_DESC_CNT (TX_DESC_CNT - 2) /* Max TX packet count */
113 #define TX_WAKE_DESC_CNT (TX_DESC_CNT - 3) /* TX wakeup count */
114 #define DESC_ALL_CNT (TX_DESC_CNT + RX_DESC_CNT)
115 #define TX_BUF_ALLOC 0x600
116 #define RX_ALLOC_SIZE 0x620
117 #define DM910X_RESET 1
118 #define CR0_DEFAULT 0x00E00000 /* TX & RX burst mode */
119 #define CR6_DEFAULT 0x00080000 /* HD */
120 #define CR7_DEFAULT 0x180c1
121 #define CR15_DEFAULT 0x06 /* TxJabber RxWatchdog */
122 #define TDES0_ERR_MASK 0x4302 /* TXJT, LC, EC, FUE */
123 #define MAX_PACKET_SIZE 1514
124 #define DMFE_MAX_MULTICAST 14
125 #define RX_COPY_SIZE 100
126 #define MAX_CHECK_PACKET 0x8000
127 #define DM9801_NOISE_FLOOR 8
128 #define DM9802_NOISE_FLOOR 5
130 #define DMFE_WOL_LINKCHANGE 0x20000000
131 #define DMFE_WOL_SAMPLEPACKET 0x10000000
132 #define DMFE_WOL_MAGICPACKET 0x08000000
136 #define DMFE_100MHF 1
138 #define DMFE_100MFD 5
140 #define DMFE_1M_HPNA 0x10
142 #define DMFE_TXTH_72 0x400000 /* TX TH 72 byte */
143 #define DMFE_TXTH_96 0x404000 /* TX TH 96 byte */
144 #define DMFE_TXTH_128 0x0000 /* TX TH 128 byte */
145 #define DMFE_TXTH_256 0x4000 /* TX TH 256 byte */
146 #define DMFE_TXTH_512 0x8000 /* TX TH 512 byte */
147 #define DMFE_TXTH_1K 0xC000 /* TX TH 1K byte */
149 #define DMFE_TIMER_WUT (jiffies + HZ * 1)/* timer wakeup time : 1 second */
150 #define DMFE_TX_TIMEOUT ((3*HZ)/2) /* tx packet time-out time 1.5 s" */
151 #define DMFE_TX_KICK (HZ/2) /* tx packet Kick-out time 0.5 s" */
153 #define dw32(reg, val) iowrite32(val, ioaddr + (reg))
154 #define dw16(reg, val) iowrite16(val, ioaddr + (reg))
155 #define dr32(reg) ioread32(ioaddr + (reg))
156 #define dr16(reg) ioread16(ioaddr + (reg))
157 #define dr8(reg) ioread8(ioaddr + (reg))
159 #define DMFE_DBUG(dbug_now, msg, value) \
161 if (dmfe_debug || (dbug_now)) \
163 (msg), (long) (value)); \
166 #define SHOW_MEDIA_TYPE(mode) \
167 pr_info("Change Speed to %sMhz %s duplex\n" , \
168 (mode & 1) ? "100":"10", \
169 (mode & 4) ? "full":"half");
172 /* CR9 definition: SROM/MII */
173 #define CR9_SROM_READ 0x4800
175 #define CR9_SRCLK 0x2
176 #define CR9_CRDOUT 0x8
177 #define SROM_DATA_0 0x0
178 #define SROM_DATA_1 0x4
179 #define PHY_DATA_1 0x20000
180 #define PHY_DATA_0 0x00000
181 #define MDCLKH 0x10000
183 #define PHY_POWER_DOWN 0x800
185 #define SROM_V41_CODE 0x14
187 #define __CHK_IO_SIZE(pci_id, dev_rev) \
188 (( ((pci_id)==PCI_DM9132_ID) || ((dev_rev) >= 0x30) ) ? \
189 DM9102A_IO_SIZE: DM9102_IO_SIZE)
191 #define CHK_IO_SIZE(pci_dev) \
192 (__CHK_IO_SIZE(((pci_dev)->device << 16) | (pci_dev)->vendor, \
193 (pci_dev)->revision))
196 #define DEVICE net_device
198 /* Structure/enum declaration ------------------------------- */
200 __le32 tdes0
, tdes1
, tdes2
, tdes3
; /* Data for the card */
201 char *tx_buf_ptr
; /* Data for us */
202 struct tx_desc
*next_tx_desc
;
203 } __attribute__(( aligned(32) ));
206 __le32 rdes0
, rdes1
, rdes2
, rdes3
; /* Data for the card */
207 struct sk_buff
*rx_skb_ptr
; /* Data for us */
208 struct rx_desc
*next_rx_desc
;
209 } __attribute__(( aligned(32) ));
211 struct dmfe_board_info
{
212 u32 chip_id
; /* Chip vendor/Device ID */
213 u8 chip_revision
; /* Chip revision */
214 struct net_device
*next_dev
; /* next device */
215 struct pci_dev
*pdev
; /* PCI device */
218 void __iomem
*ioaddr
; /* I/O base address */
225 /* pointer for memory physical address */
226 dma_addr_t buf_pool_dma_ptr
; /* Tx buffer pool memory */
227 dma_addr_t buf_pool_dma_start
; /* Tx buffer pool align dword */
228 dma_addr_t desc_pool_dma_ptr
; /* descriptor pool memory */
229 dma_addr_t first_tx_desc_dma
;
230 dma_addr_t first_rx_desc_dma
;
232 /* descriptor pointer */
233 unsigned char *buf_pool_ptr
; /* Tx buffer pool memory */
234 unsigned char *buf_pool_start
; /* Tx buffer pool align dword */
235 unsigned char *desc_pool_ptr
; /* descriptor pool memory */
236 struct tx_desc
*first_tx_desc
;
237 struct tx_desc
*tx_insert_ptr
;
238 struct tx_desc
*tx_remove_ptr
;
239 struct rx_desc
*first_rx_desc
;
240 struct rx_desc
*rx_insert_ptr
;
241 struct rx_desc
*rx_ready_ptr
; /* packet come pointer */
242 unsigned long tx_packet_cnt
; /* transmitted packet count */
243 unsigned long tx_queue_cnt
; /* wait to send packet count */
244 unsigned long rx_avail_cnt
; /* available rx descriptor count */
245 unsigned long interval_rx_cnt
; /* rx packet count a callback time */
247 u16 HPNA_command
; /* For HPNA register 16 */
248 u16 HPNA_timer
; /* For HPNA remote device check */
250 u16 NIC_capability
; /* NIC media capability */
251 u16 PHY_reg4
; /* Saved Phyxcer register 4 value */
253 u8 HPNA_present
; /* 0:none, 1:DM9801, 2:DM9802 */
254 u8 chip_type
; /* Keep DM9102A chip type */
255 u8 media_mode
; /* user specify media mode */
256 u8 op_mode
; /* real work media mode */
258 u8 wait_reset
; /* Hardware failed, need to reset */
259 u8 dm910x_chk_mode
; /* Operating mode check */
260 u8 first_in_callback
; /* Flag to record state */
261 u8 wol_mode
; /* user WOL settings */
262 struct timer_list timer
;
264 /* Driver defined statistic counter */
265 unsigned long tx_fifo_underrun
;
266 unsigned long tx_loss_carrier
;
267 unsigned long tx_no_carrier
;
268 unsigned long tx_late_collision
;
269 unsigned long tx_excessive_collision
;
270 unsigned long tx_jabber_timeout
;
271 unsigned long reset_count
;
272 unsigned long reset_cr8
;
273 unsigned long reset_fatal
;
274 unsigned long reset_TXtimeout
;
277 unsigned char srom
[128];
281 DCR0
= 0x00, DCR1
= 0x08, DCR2
= 0x10, DCR3
= 0x18, DCR4
= 0x20,
282 DCR5
= 0x28, DCR6
= 0x30, DCR7
= 0x38, DCR8
= 0x40, DCR9
= 0x48,
283 DCR10
= 0x50, DCR11
= 0x58, DCR12
= 0x60, DCR13
= 0x68, DCR14
= 0x70,
288 CR6_RXSC
= 0x2, CR6_PBF
= 0x8, CR6_PM
= 0x40, CR6_PAM
= 0x80,
289 CR6_FDM
= 0x200, CR6_TXSC
= 0x2000, CR6_STI
= 0x100000,
290 CR6_SFT
= 0x200000, CR6_RXA
= 0x40000000, CR6_NO_PURGE
= 0x20000000
293 /* Global variable declaration ----------------------------- */
294 static int printed_version
;
295 static const char version
[] =
296 "Davicom DM9xxx net driver, version " DRV_VERSION
" (" DRV_RELDATE
")";
298 static int dmfe_debug
;
299 static unsigned char dmfe_media_mode
= DMFE_AUTO
;
300 static u32 dmfe_cr6_user_set
;
302 /* For module input parameter */
305 static unsigned char mode
= 8;
306 static u8 chkmode
= 1;
307 static u8 HPNA_mode
; /* Default: Low Power/High Speed */
308 static u8 HPNA_rx_cmd
; /* Default: Disable Rx remote command */
309 static u8 HPNA_tx_cmd
; /* Default: Don't issue remote command */
310 static u8 HPNA_NoiseFloor
; /* Default: HPNA NoiseFloor */
311 static u8 SF_mode
; /* Special Function: 1:VLAN, 2:RX Flow Control
312 4: TX pause packet */
315 /* function declaration ------------------------------------- */
316 static int dmfe_open(struct DEVICE
*);
317 static netdev_tx_t
dmfe_start_xmit(struct sk_buff
*, struct DEVICE
*);
318 static int dmfe_stop(struct DEVICE
*);
319 static void dmfe_set_filter_mode(struct DEVICE
*);
320 static const struct ethtool_ops netdev_ethtool_ops
;
321 static u16
read_srom_word(void __iomem
*, int);
322 static irqreturn_t
dmfe_interrupt(int , void *);
323 #ifdef CONFIG_NET_POLL_CONTROLLER
324 static void poll_dmfe (struct net_device
*dev
);
326 static void dmfe_descriptor_init(struct net_device
*);
327 static void allocate_rx_buffer(struct net_device
*);
328 static void update_cr6(u32
, void __iomem
*);
329 static void send_filter_frame(struct DEVICE
*);
330 static void dm9132_id_table(struct DEVICE
*);
331 static u16
phy_read(void __iomem
*, u8
, u8
, u32
);
332 static void phy_write(void __iomem
*, u8
, u8
, u16
, u32
);
333 static void phy_write_1bit(void __iomem
*, u32
);
334 static u16
phy_read_1bit(void __iomem
*);
335 static u8
dmfe_sense_speed(struct dmfe_board_info
*);
336 static void dmfe_process_mode(struct dmfe_board_info
*);
337 static void dmfe_timer(unsigned long);
338 static inline u32
cal_CRC(unsigned char *, unsigned int, u8
);
339 static void dmfe_rx_packet(struct DEVICE
*, struct dmfe_board_info
*);
340 static void dmfe_free_tx_pkt(struct DEVICE
*, struct dmfe_board_info
*);
341 static void dmfe_reuse_skb(struct dmfe_board_info
*, struct sk_buff
*);
342 static void dmfe_dynamic_reset(struct DEVICE
*);
343 static void dmfe_free_rxbuffer(struct dmfe_board_info
*);
344 static void dmfe_init_dm910x(struct DEVICE
*);
345 static void dmfe_parse_srom(struct dmfe_board_info
*);
346 static void dmfe_program_DM9801(struct dmfe_board_info
*, int);
347 static void dmfe_program_DM9802(struct dmfe_board_info
*);
348 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info
* );
349 static void dmfe_set_phyxcer(struct dmfe_board_info
*);
351 /* DM910X network board routine ---------------------------- */
353 static const struct net_device_ops netdev_ops
= {
354 .ndo_open
= dmfe_open
,
355 .ndo_stop
= dmfe_stop
,
356 .ndo_start_xmit
= dmfe_start_xmit
,
357 .ndo_set_rx_mode
= dmfe_set_filter_mode
,
358 .ndo_change_mtu
= eth_change_mtu
,
359 .ndo_set_mac_address
= eth_mac_addr
,
360 .ndo_validate_addr
= eth_validate_addr
,
361 #ifdef CONFIG_NET_POLL_CONTROLLER
362 .ndo_poll_controller
= poll_dmfe
,
367 * Search DM910X board ,allocate space and register it
370 static int dmfe_init_one(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
372 struct dmfe_board_info
*db
; /* board information structure */
373 struct net_device
*dev
;
377 DMFE_DBUG(0, "dmfe_init_one()", 0);
379 if (!printed_version
++)
380 pr_info("%s\n", version
);
383 * SPARC on-board DM910x chips should be handled by the main
384 * tulip driver, except for early DM9100s.
386 #ifdef CONFIG_TULIP_DM910X
387 if ((ent
->driver_data
== PCI_DM9100_ID
&& pdev
->revision
>= 0x30) ||
388 ent
->driver_data
== PCI_DM9102_ID
) {
389 struct device_node
*dp
= pci_device_to_OF_node(pdev
);
391 if (dp
&& of_get_property(dp
, "local-mac-address", NULL
)) {
392 pr_info("skipping on-board DM910x (use tulip)\n");
398 /* Init network device */
399 dev
= alloc_etherdev(sizeof(*db
));
402 SET_NETDEV_DEV(dev
, &pdev
->dev
);
404 if (pci_set_dma_mask(pdev
, DMA_BIT_MASK(32))) {
405 pr_warn("32-bit PCI DMA not available\n");
410 /* Enable Master/IO access, Disable memory access */
411 err
= pci_enable_device(pdev
);
415 if (!pci_resource_start(pdev
, 0)) {
416 pr_err("I/O base is zero\n");
418 goto err_out_disable
;
421 if (pci_resource_len(pdev
, 0) < (CHK_IO_SIZE(pdev
)) ) {
422 pr_err("Allocated I/O size too small\n");
424 goto err_out_disable
;
427 #if 0 /* pci_{enable_device,set_master} sets minimum latency for us now */
429 /* Set Latency Timer 80h */
430 /* FIXME: setting values > 32 breaks some SiS 559x stuff.
431 Need a PCI quirk.. */
433 pci_write_config_byte(pdev
, PCI_LATENCY_TIMER
, 0x80);
436 if (pci_request_regions(pdev
, DRV_NAME
)) {
437 pr_err("Failed to request PCI regions\n");
439 goto err_out_disable
;
442 /* Init system & device */
443 db
= netdev_priv(dev
);
445 /* Allocate Tx/Rx descriptor memory */
446 db
->desc_pool_ptr
= pci_alloc_consistent(pdev
, sizeof(struct tx_desc
) *
447 DESC_ALL_CNT
+ 0x20, &db
->desc_pool_dma_ptr
);
448 if (!db
->desc_pool_ptr
) {
453 db
->buf_pool_ptr
= pci_alloc_consistent(pdev
, TX_BUF_ALLOC
*
454 TX_DESC_CNT
+ 4, &db
->buf_pool_dma_ptr
);
455 if (!db
->buf_pool_ptr
) {
457 goto err_out_free_desc
;
460 db
->first_tx_desc
= (struct tx_desc
*) db
->desc_pool_ptr
;
461 db
->first_tx_desc_dma
= db
->desc_pool_dma_ptr
;
462 db
->buf_pool_start
= db
->buf_pool_ptr
;
463 db
->buf_pool_dma_start
= db
->buf_pool_dma_ptr
;
465 db
->chip_id
= ent
->driver_data
;
467 db
->ioaddr
= pci_iomap(pdev
, 0, 0);
470 goto err_out_free_buf
;
473 db
->chip_revision
= pdev
->revision
;
478 pci_set_drvdata(pdev
, dev
);
479 dev
->netdev_ops
= &netdev_ops
;
480 dev
->ethtool_ops
= &netdev_ethtool_ops
;
481 netif_carrier_off(dev
);
482 spin_lock_init(&db
->lock
);
484 pci_read_config_dword(pdev
, 0x50, &pci_pmr
);
486 if ( (pci_pmr
== 0x10000) && (db
->chip_revision
== 0x31) )
487 db
->chip_type
= 1; /* DM9102A E3 */
491 /* read 64 word srom data */
492 for (i
= 0; i
< 64; i
++) {
493 ((__le16
*) db
->srom
)[i
] =
494 cpu_to_le16(read_srom_word(db
->ioaddr
, i
));
497 /* Set Node address */
498 for (i
= 0; i
< 6; i
++)
499 dev
->dev_addr
[i
] = db
->srom
[20 + i
];
501 err
= register_netdev (dev
);
505 dev_info(&dev
->dev
, "Davicom DM%04lx at pci%s, %pM, irq %d\n",
506 ent
->driver_data
>> 16,
507 pci_name(pdev
), dev
->dev_addr
, pdev
->irq
);
509 pci_set_master(pdev
);
514 pci_iounmap(pdev
, db
->ioaddr
);
516 pci_free_consistent(pdev
, TX_BUF_ALLOC
* TX_DESC_CNT
+ 4,
517 db
->buf_pool_ptr
, db
->buf_pool_dma_ptr
);
519 pci_free_consistent(pdev
, sizeof(struct tx_desc
) * DESC_ALL_CNT
+ 0x20,
520 db
->desc_pool_ptr
, db
->desc_pool_dma_ptr
);
522 pci_release_regions(pdev
);
524 pci_disable_device(pdev
);
532 static void dmfe_remove_one(struct pci_dev
*pdev
)
534 struct net_device
*dev
= pci_get_drvdata(pdev
);
535 struct dmfe_board_info
*db
= netdev_priv(dev
);
537 DMFE_DBUG(0, "dmfe_remove_one()", 0);
541 unregister_netdev(dev
);
542 pci_iounmap(db
->pdev
, db
->ioaddr
);
543 pci_free_consistent(db
->pdev
, sizeof(struct tx_desc
) *
544 DESC_ALL_CNT
+ 0x20, db
->desc_pool_ptr
,
545 db
->desc_pool_dma_ptr
);
546 pci_free_consistent(db
->pdev
, TX_BUF_ALLOC
* TX_DESC_CNT
+ 4,
547 db
->buf_pool_ptr
, db
->buf_pool_dma_ptr
);
548 pci_release_regions(pdev
);
549 free_netdev(dev
); /* free board information */
552 DMFE_DBUG(0, "dmfe_remove_one() exit", 0);
557 * Open the interface.
558 * The interface is opened whenever "ifconfig" actives it.
561 static int dmfe_open(struct DEVICE
*dev
)
563 struct dmfe_board_info
*db
= netdev_priv(dev
);
564 const int irq
= db
->pdev
->irq
;
567 DMFE_DBUG(0, "dmfe_open", 0);
569 ret
= request_irq(irq
, dmfe_interrupt
, IRQF_SHARED
, dev
->name
, dev
);
573 /* system variable init */
574 db
->cr6_data
= CR6_DEFAULT
| dmfe_cr6_user_set
;
575 db
->tx_packet_cnt
= 0;
576 db
->tx_queue_cnt
= 0;
577 db
->rx_avail_cnt
= 0;
580 db
->first_in_callback
= 0;
581 db
->NIC_capability
= 0xf; /* All capability*/
582 db
->PHY_reg4
= 0x1e0;
584 /* CR6 operation mode decision */
585 if ( !chkmode
|| (db
->chip_id
== PCI_DM9132_ID
) ||
586 (db
->chip_revision
>= 0x30) ) {
587 db
->cr6_data
|= DMFE_TXTH_256
;
588 db
->cr0_data
= CR0_DEFAULT
;
589 db
->dm910x_chk_mode
=4; /* Enter the normal mode */
591 db
->cr6_data
|= CR6_SFT
; /* Store & Forward mode */
593 db
->dm910x_chk_mode
= 1; /* Enter the check mode */
596 /* Initialize DM910X board */
597 dmfe_init_dm910x(dev
);
599 /* Active System Interface */
600 netif_wake_queue(dev
);
602 /* set and active a timer process */
603 init_timer(&db
->timer
);
604 db
->timer
.expires
= DMFE_TIMER_WUT
+ HZ
* 2;
605 db
->timer
.data
= (unsigned long)dev
;
606 db
->timer
.function
= dmfe_timer
;
607 add_timer(&db
->timer
);
613 /* Initialize DM910X board
615 * Initialize TX/Rx descriptor chain structure
616 * Send the set-up frame
617 * Enable Tx/Rx machine
620 static void dmfe_init_dm910x(struct DEVICE
*dev
)
622 struct dmfe_board_info
*db
= netdev_priv(dev
);
623 void __iomem
*ioaddr
= db
->ioaddr
;
625 DMFE_DBUG(0, "dmfe_init_dm910x()", 0);
627 /* Reset DM910x MAC controller */
628 dw32(DCR0
, DM910X_RESET
); /* RESET MAC */
630 dw32(DCR0
, db
->cr0_data
);
633 /* Phy addr : DM910(A)2/DM9132/9801, phy address = 1 */
636 /* Parser SROM and media mode */
638 db
->media_mode
= dmfe_media_mode
;
640 /* RESET Phyxcer Chip by GPR port bit 7 */
641 dw32(DCR12
, 0x180); /* Let bit 7 output port */
642 if (db
->chip_id
== PCI_DM9009_ID
) {
643 dw32(DCR12
, 0x80); /* Issue RESET signal */
644 mdelay(300); /* Delay 300 ms */
646 dw32(DCR12
, 0x0); /* Clear RESET signal */
648 /* Process Phyxcer Media Mode */
649 if ( !(db
->media_mode
& 0x10) ) /* Force 1M mode */
650 dmfe_set_phyxcer(db
);
652 /* Media Mode Process */
653 if ( !(db
->media_mode
& DMFE_AUTO
) )
654 db
->op_mode
= db
->media_mode
; /* Force Mode */
656 /* Initialize Transmit/Receive decriptor and CR3/4 */
657 dmfe_descriptor_init(dev
);
659 /* Init CR6 to program DM910x operation */
660 update_cr6(db
->cr6_data
, ioaddr
);
662 /* Send setup frame */
663 if (db
->chip_id
== PCI_DM9132_ID
)
664 dm9132_id_table(dev
); /* DM9132 */
666 send_filter_frame(dev
); /* DM9102/DM9102A */
668 /* Init CR7, interrupt active bit */
669 db
->cr7_data
= CR7_DEFAULT
;
670 dw32(DCR7
, db
->cr7_data
);
672 /* Init CR15, Tx jabber and Rx watchdog timer */
673 dw32(DCR15
, db
->cr15_data
);
675 /* Enable DM910X Tx/Rx function */
676 db
->cr6_data
|= CR6_RXSC
| CR6_TXSC
| 0x40000;
677 update_cr6(db
->cr6_data
, ioaddr
);
682 * Hardware start transmission.
683 * Send a packet to media from the upper layer.
686 static netdev_tx_t
dmfe_start_xmit(struct sk_buff
*skb
,
689 struct dmfe_board_info
*db
= netdev_priv(dev
);
690 void __iomem
*ioaddr
= db
->ioaddr
;
691 struct tx_desc
*txptr
;
694 DMFE_DBUG(0, "dmfe_start_xmit", 0);
696 /* Too large packet check */
697 if (skb
->len
> MAX_PACKET_SIZE
) {
698 pr_err("big packet = %d\n", (u16
)skb
->len
);
699 dev_kfree_skb_any(skb
);
703 /* Resource flag check */
704 netif_stop_queue(dev
);
706 spin_lock_irqsave(&db
->lock
, flags
);
708 /* No Tx resource check, it never happen nromally */
709 if (db
->tx_queue_cnt
>= TX_FREE_DESC_CNT
) {
710 spin_unlock_irqrestore(&db
->lock
, flags
);
711 pr_err("No Tx resource %ld\n", db
->tx_queue_cnt
);
712 return NETDEV_TX_BUSY
;
715 /* Disable NIC interrupt */
718 /* transmit this packet */
719 txptr
= db
->tx_insert_ptr
;
720 skb_copy_from_linear_data(skb
, txptr
->tx_buf_ptr
, skb
->len
);
721 txptr
->tdes1
= cpu_to_le32(0xe1000000 | skb
->len
);
723 /* Point to next transmit free descriptor */
724 db
->tx_insert_ptr
= txptr
->next_tx_desc
;
726 /* Transmit Packet Process */
727 if ( (!db
->tx_queue_cnt
) && (db
->tx_packet_cnt
< TX_MAX_SEND_CNT
) ) {
728 txptr
->tdes0
= cpu_to_le32(0x80000000); /* Set owner bit */
729 db
->tx_packet_cnt
++; /* Ready to send */
730 dw32(DCR1
, 0x1); /* Issue Tx polling */
731 dev
->trans_start
= jiffies
; /* saved time stamp */
733 db
->tx_queue_cnt
++; /* queue TX packet */
734 dw32(DCR1
, 0x1); /* Issue Tx polling */
737 /* Tx resource check */
738 if ( db
->tx_queue_cnt
< TX_FREE_DESC_CNT
)
739 netif_wake_queue(dev
);
741 /* Restore CR7 to enable interrupt */
742 spin_unlock_irqrestore(&db
->lock
, flags
);
743 dw32(DCR7
, db
->cr7_data
);
746 dev_consume_skb_any(skb
);
753 * Stop the interface.
754 * The interface is stopped when it is brought.
757 static int dmfe_stop(struct DEVICE
*dev
)
759 struct dmfe_board_info
*db
= netdev_priv(dev
);
760 void __iomem
*ioaddr
= db
->ioaddr
;
762 DMFE_DBUG(0, "dmfe_stop", 0);
765 netif_stop_queue(dev
);
768 del_timer_sync(&db
->timer
);
770 /* Reset & stop DM910X board */
771 dw32(DCR0
, DM910X_RESET
);
773 phy_write(ioaddr
, db
->phy_addr
, 0, 0x8000, db
->chip_id
);
776 free_irq(db
->pdev
->irq
, dev
);
778 /* free allocated rx buffer */
779 dmfe_free_rxbuffer(db
);
782 /* show statistic counter */
783 printk("FU:%lx EC:%lx LC:%lx NC:%lx LOC:%lx TXJT:%lx RESET:%lx RCR8:%lx FAL:%lx TT:%lx\n",
784 db
->tx_fifo_underrun
, db
->tx_excessive_collision
,
785 db
->tx_late_collision
, db
->tx_no_carrier
, db
->tx_loss_carrier
,
786 db
->tx_jabber_timeout
, db
->reset_count
, db
->reset_cr8
,
787 db
->reset_fatal
, db
->reset_TXtimeout
);
795 * DM9102 insterrupt handler
796 * receive the packet to upper layer, free the transmitted packet
799 static irqreturn_t
dmfe_interrupt(int irq
, void *dev_id
)
801 struct DEVICE
*dev
= dev_id
;
802 struct dmfe_board_info
*db
= netdev_priv(dev
);
803 void __iomem
*ioaddr
= db
->ioaddr
;
806 DMFE_DBUG(0, "dmfe_interrupt()", 0);
808 spin_lock_irqsave(&db
->lock
, flags
);
810 /* Got DM910X status */
811 db
->cr5_data
= dr32(DCR5
);
812 dw32(DCR5
, db
->cr5_data
);
813 if ( !(db
->cr5_data
& 0xc1) ) {
814 spin_unlock_irqrestore(&db
->lock
, flags
);
818 /* Disable all interrupt in CR7 to solve the interrupt edge problem */
821 /* Check system status */
822 if (db
->cr5_data
& 0x2000) {
823 /* system bus error happen */
824 DMFE_DBUG(1, "System bus error happen. CR5=", db
->cr5_data
);
826 db
->wait_reset
= 1; /* Need to RESET */
827 spin_unlock_irqrestore(&db
->lock
, flags
);
831 /* Received the coming packet */
832 if ( (db
->cr5_data
& 0x40) && db
->rx_avail_cnt
)
833 dmfe_rx_packet(dev
, db
);
835 /* reallocate rx descriptor buffer */
836 if (db
->rx_avail_cnt
<RX_DESC_CNT
)
837 allocate_rx_buffer(dev
);
839 /* Free the transmitted descriptor */
840 if ( db
->cr5_data
& 0x01)
841 dmfe_free_tx_pkt(dev
, db
);
844 if (db
->dm910x_chk_mode
& 0x2) {
845 db
->dm910x_chk_mode
= 0x4;
846 db
->cr6_data
|= 0x100;
847 update_cr6(db
->cr6_data
, ioaddr
);
850 /* Restore CR7 to enable interrupt mask */
851 dw32(DCR7
, db
->cr7_data
);
853 spin_unlock_irqrestore(&db
->lock
, flags
);
858 #ifdef CONFIG_NET_POLL_CONTROLLER
860 * Polling 'interrupt' - used by things like netconsole to send skbs
861 * without having to re-enable interrupts. It's not called while
862 * the interrupt routine is executing.
865 static void poll_dmfe (struct net_device
*dev
)
867 struct dmfe_board_info
*db
= netdev_priv(dev
);
868 const int irq
= db
->pdev
->irq
;
870 /* disable_irq here is not very nice, but with the lockless
871 interrupt handler we have no other choice. */
873 dmfe_interrupt (irq
, dev
);
879 * Free TX resource after TX complete
882 static void dmfe_free_tx_pkt(struct DEVICE
*dev
, struct dmfe_board_info
* db
)
884 struct tx_desc
*txptr
;
885 void __iomem
*ioaddr
= db
->ioaddr
;
888 txptr
= db
->tx_remove_ptr
;
889 while(db
->tx_packet_cnt
) {
890 tdes0
= le32_to_cpu(txptr
->tdes0
);
891 if (tdes0
& 0x80000000)
894 /* A packet sent completed */
896 dev
->stats
.tx_packets
++;
898 /* Transmit statistic counter */
899 if ( tdes0
!= 0x7fffffff ) {
900 dev
->stats
.collisions
+= (tdes0
>> 3) & 0xf;
901 dev
->stats
.tx_bytes
+= le32_to_cpu(txptr
->tdes1
) & 0x7ff;
902 if (tdes0
& TDES0_ERR_MASK
) {
903 dev
->stats
.tx_errors
++;
905 if (tdes0
& 0x0002) { /* UnderRun */
906 db
->tx_fifo_underrun
++;
907 if ( !(db
->cr6_data
& CR6_SFT
) ) {
908 db
->cr6_data
= db
->cr6_data
| CR6_SFT
;
909 update_cr6(db
->cr6_data
, ioaddr
);
913 db
->tx_excessive_collision
++;
915 db
->tx_late_collision
++;
919 db
->tx_loss_carrier
++;
921 db
->tx_jabber_timeout
++;
925 txptr
= txptr
->next_tx_desc
;
928 /* Update TX remove pointer to next */
929 db
->tx_remove_ptr
= txptr
;
931 /* Send the Tx packet in queue */
932 if ( (db
->tx_packet_cnt
< TX_MAX_SEND_CNT
) && db
->tx_queue_cnt
) {
933 txptr
->tdes0
= cpu_to_le32(0x80000000); /* Set owner bit */
934 db
->tx_packet_cnt
++; /* Ready to send */
936 dw32(DCR1
, 0x1); /* Issue Tx polling */
937 dev
->trans_start
= jiffies
; /* saved time stamp */
940 /* Resource available check */
941 if ( db
->tx_queue_cnt
< TX_WAKE_DESC_CNT
)
942 netif_wake_queue(dev
); /* Active upper layer, send again */
947 * Calculate the CRC valude of the Rx packet
948 * flag = 1 : return the reverse CRC (for the received packet CRC)
949 * 0 : return the normal CRC (for Hash Table index)
952 static inline u32
cal_CRC(unsigned char * Data
, unsigned int Len
, u8 flag
)
954 u32 crc
= crc32(~0, Data
, Len
);
955 if (flag
) crc
= ~crc
;
961 * Receive the come packet and pass to upper layer
964 static void dmfe_rx_packet(struct DEVICE
*dev
, struct dmfe_board_info
* db
)
966 struct rx_desc
*rxptr
;
967 struct sk_buff
*skb
, *newskb
;
971 rxptr
= db
->rx_ready_ptr
;
973 while(db
->rx_avail_cnt
) {
974 rdes0
= le32_to_cpu(rxptr
->rdes0
);
975 if (rdes0
& 0x80000000) /* packet owner check */
979 db
->interval_rx_cnt
++;
981 pci_unmap_single(db
->pdev
, le32_to_cpu(rxptr
->rdes2
),
982 RX_ALLOC_SIZE
, PCI_DMA_FROMDEVICE
);
984 if ( (rdes0
& 0x300) != 0x300) {
985 /* A packet without First/Last flag */
987 DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0
);
988 dmfe_reuse_skb(db
, rxptr
->rx_skb_ptr
);
990 /* A packet with First/Last flag */
991 rxlen
= ( (rdes0
>> 16) & 0x3fff) - 4;
993 /* error summary bit check */
994 if (rdes0
& 0x8000) {
995 /* This is a error packet */
996 dev
->stats
.rx_errors
++;
998 dev
->stats
.rx_fifo_errors
++;
1000 dev
->stats
.rx_crc_errors
++;
1002 dev
->stats
.rx_length_errors
++;
1005 if ( !(rdes0
& 0x8000) ||
1006 ((db
->cr6_data
& CR6_PM
) && (rxlen
>6)) ) {
1007 skb
= rxptr
->rx_skb_ptr
;
1009 /* Received Packet CRC check need or not */
1010 if ( (db
->dm910x_chk_mode
& 1) &&
1011 (cal_CRC(skb
->data
, rxlen
, 1) !=
1012 (*(u32
*) (skb
->data
+rxlen
) ))) { /* FIXME (?) */
1013 /* Found a error received packet */
1014 dmfe_reuse_skb(db
, rxptr
->rx_skb_ptr
);
1015 db
->dm910x_chk_mode
= 3;
1017 /* Good packet, send to upper layer */
1018 /* Shorst packet used new SKB */
1019 if ((rxlen
< RX_COPY_SIZE
) &&
1020 ((newskb
= netdev_alloc_skb(dev
, rxlen
+ 2))
1024 /* size less than COPY_SIZE, allocate a rxlen SKB */
1025 skb_reserve(skb
, 2); /* 16byte align */
1026 skb_copy_from_linear_data(rxptr
->rx_skb_ptr
,
1027 skb_put(skb
, rxlen
),
1029 dmfe_reuse_skb(db
, rxptr
->rx_skb_ptr
);
1031 skb_put(skb
, rxlen
);
1033 skb
->protocol
= eth_type_trans(skb
, dev
);
1035 dev
->stats
.rx_packets
++;
1036 dev
->stats
.rx_bytes
+= rxlen
;
1039 /* Reuse SKB buffer when the packet is error */
1040 DMFE_DBUG(0, "Reuse SK buffer, rdes0", rdes0
);
1041 dmfe_reuse_skb(db
, rxptr
->rx_skb_ptr
);
1045 rxptr
= rxptr
->next_rx_desc
;
1048 db
->rx_ready_ptr
= rxptr
;
1052 * Set DM910X multicast address
1055 static void dmfe_set_filter_mode(struct DEVICE
* dev
)
1057 struct dmfe_board_info
*db
= netdev_priv(dev
);
1058 unsigned long flags
;
1059 int mc_count
= netdev_mc_count(dev
);
1061 DMFE_DBUG(0, "dmfe_set_filter_mode()", 0);
1062 spin_lock_irqsave(&db
->lock
, flags
);
1064 if (dev
->flags
& IFF_PROMISC
) {
1065 DMFE_DBUG(0, "Enable PROM Mode", 0);
1066 db
->cr6_data
|= CR6_PM
| CR6_PBF
;
1067 update_cr6(db
->cr6_data
, db
->ioaddr
);
1068 spin_unlock_irqrestore(&db
->lock
, flags
);
1072 if (dev
->flags
& IFF_ALLMULTI
|| mc_count
> DMFE_MAX_MULTICAST
) {
1073 DMFE_DBUG(0, "Pass all multicast address", mc_count
);
1074 db
->cr6_data
&= ~(CR6_PM
| CR6_PBF
);
1075 db
->cr6_data
|= CR6_PAM
;
1076 spin_unlock_irqrestore(&db
->lock
, flags
);
1080 DMFE_DBUG(0, "Set multicast address", mc_count
);
1081 if (db
->chip_id
== PCI_DM9132_ID
)
1082 dm9132_id_table(dev
); /* DM9132 */
1084 send_filter_frame(dev
); /* DM9102/DM9102A */
1085 spin_unlock_irqrestore(&db
->lock
, flags
);
1092 static void dmfe_ethtool_get_drvinfo(struct net_device
*dev
,
1093 struct ethtool_drvinfo
*info
)
1095 struct dmfe_board_info
*np
= netdev_priv(dev
);
1097 strlcpy(info
->driver
, DRV_NAME
, sizeof(info
->driver
));
1098 strlcpy(info
->version
, DRV_VERSION
, sizeof(info
->version
));
1099 strlcpy(info
->bus_info
, pci_name(np
->pdev
), sizeof(info
->bus_info
));
1102 static int dmfe_ethtool_set_wol(struct net_device
*dev
,
1103 struct ethtool_wolinfo
*wolinfo
)
1105 struct dmfe_board_info
*db
= netdev_priv(dev
);
1107 if (wolinfo
->wolopts
& (WAKE_UCAST
| WAKE_MCAST
| WAKE_BCAST
|
1108 WAKE_ARP
| WAKE_MAGICSECURE
))
1111 db
->wol_mode
= wolinfo
->wolopts
;
1115 static void dmfe_ethtool_get_wol(struct net_device
*dev
,
1116 struct ethtool_wolinfo
*wolinfo
)
1118 struct dmfe_board_info
*db
= netdev_priv(dev
);
1120 wolinfo
->supported
= WAKE_PHY
| WAKE_MAGIC
;
1121 wolinfo
->wolopts
= db
->wol_mode
;
1125 static const struct ethtool_ops netdev_ethtool_ops
= {
1126 .get_drvinfo
= dmfe_ethtool_get_drvinfo
,
1127 .get_link
= ethtool_op_get_link
,
1128 .set_wol
= dmfe_ethtool_set_wol
,
1129 .get_wol
= dmfe_ethtool_get_wol
,
1133 * A periodic timer routine
1134 * Dynamic media sense, allocate Rx buffer...
1137 static void dmfe_timer(unsigned long data
)
1139 struct net_device
*dev
= (struct net_device
*)data
;
1140 struct dmfe_board_info
*db
= netdev_priv(dev
);
1141 void __iomem
*ioaddr
= db
->ioaddr
;
1143 unsigned char tmp_cr12
;
1144 unsigned long flags
;
1146 int link_ok
, link_ok_phy
;
1148 DMFE_DBUG(0, "dmfe_timer()", 0);
1149 spin_lock_irqsave(&db
->lock
, flags
);
1151 /* Media mode process when Link OK before enter this route */
1152 if (db
->first_in_callback
== 0) {
1153 db
->first_in_callback
= 1;
1154 if (db
->chip_type
&& (db
->chip_id
==PCI_DM9102_ID
)) {
1155 db
->cr6_data
&= ~0x40000;
1156 update_cr6(db
->cr6_data
, ioaddr
);
1157 phy_write(ioaddr
, db
->phy_addr
, 0, 0x1000, db
->chip_id
);
1158 db
->cr6_data
|= 0x40000;
1159 update_cr6(db
->cr6_data
, ioaddr
);
1160 db
->timer
.expires
= DMFE_TIMER_WUT
+ HZ
* 2;
1161 add_timer(&db
->timer
);
1162 spin_unlock_irqrestore(&db
->lock
, flags
);
1168 /* Operating Mode Check */
1169 if ( (db
->dm910x_chk_mode
& 0x1) &&
1170 (dev
->stats
.rx_packets
> MAX_CHECK_PACKET
) )
1171 db
->dm910x_chk_mode
= 0x4;
1173 /* Dynamic reset DM910X : system error or transmit time-out */
1174 tmp_cr8
= dr32(DCR8
);
1175 if ( (db
->interval_rx_cnt
==0) && (tmp_cr8
) ) {
1179 db
->interval_rx_cnt
= 0;
1181 /* TX polling kick monitor */
1182 if ( db
->tx_packet_cnt
&&
1183 time_after(jiffies
, dev_trans_start(dev
) + DMFE_TX_KICK
) ) {
1184 dw32(DCR1
, 0x1); /* Tx polling again */
1187 if (time_after(jiffies
, dev_trans_start(dev
) + DMFE_TX_TIMEOUT
) ) {
1188 db
->reset_TXtimeout
++;
1190 dev_warn(&dev
->dev
, "Tx timeout - resetting\n");
1194 if (db
->wait_reset
) {
1195 DMFE_DBUG(0, "Dynamic Reset device", db
->tx_packet_cnt
);
1197 dmfe_dynamic_reset(dev
);
1198 db
->first_in_callback
= 0;
1199 db
->timer
.expires
= DMFE_TIMER_WUT
;
1200 add_timer(&db
->timer
);
1201 spin_unlock_irqrestore(&db
->lock
, flags
);
1205 /* Link status check, Dynamic media type change */
1206 if (db
->chip_id
== PCI_DM9132_ID
)
1207 tmp_cr12
= dr8(DCR9
+ 3); /* DM9132 */
1209 tmp_cr12
= dr8(DCR12
); /* DM9102/DM9102A */
1211 if ( ((db
->chip_id
== PCI_DM9102_ID
) &&
1212 (db
->chip_revision
== 0x30)) ||
1213 ((db
->chip_id
== PCI_DM9132_ID
) &&
1214 (db
->chip_revision
== 0x10)) ) {
1222 /*0x43 is used instead of 0x3 because bit 6 should represent
1223 link status of external PHY */
1224 link_ok
= (tmp_cr12
& 0x43) ? 1 : 0;
1227 /* If chip reports that link is failed it could be because external
1228 PHY link status pin is not connected correctly to chip
1229 To be sure ask PHY too.
1232 /* need a dummy read because of PHY's register latch*/
1233 phy_read (db
->ioaddr
, db
->phy_addr
, 1, db
->chip_id
);
1234 link_ok_phy
= (phy_read (db
->ioaddr
,
1235 db
->phy_addr
, 1, db
->chip_id
) & 0x4) ? 1 : 0;
1237 if (link_ok_phy
!= link_ok
) {
1238 DMFE_DBUG (0, "PHY and chip report different link status", 0);
1239 link_ok
= link_ok
| link_ok_phy
;
1242 if ( !link_ok
&& netif_carrier_ok(dev
)) {
1244 DMFE_DBUG(0, "Link Failed", tmp_cr12
);
1245 netif_carrier_off(dev
);
1247 /* For Force 10/100M Half/Full mode: Enable Auto-Nego mode */
1248 /* AUTO or force 1M Homerun/Longrun don't need */
1249 if ( !(db
->media_mode
& 0x38) )
1250 phy_write(db
->ioaddr
, db
->phy_addr
,
1251 0, 0x1000, db
->chip_id
);
1253 /* AUTO mode, if INT phyxcer link failed, select EXT device */
1254 if (db
->media_mode
& DMFE_AUTO
) {
1255 /* 10/100M link failed, used 1M Home-Net */
1256 db
->cr6_data
|=0x00040000; /* bit18=1, MII */
1257 db
->cr6_data
&=~0x00000200; /* bit9=0, HD mode */
1258 update_cr6(db
->cr6_data
, ioaddr
);
1260 } else if (!netif_carrier_ok(dev
)) {
1262 DMFE_DBUG(0, "Link link OK", tmp_cr12
);
1264 /* Auto Sense Speed */
1265 if ( !(db
->media_mode
& DMFE_AUTO
) || !dmfe_sense_speed(db
)) {
1266 netif_carrier_on(dev
);
1267 SHOW_MEDIA_TYPE(db
->op_mode
);
1270 dmfe_process_mode(db
);
1273 /* HPNA remote command check */
1274 if (db
->HPNA_command
& 0xf00) {
1276 if (!db
->HPNA_timer
)
1277 dmfe_HPNA_remote_cmd_chk(db
);
1280 /* Timer active again */
1281 db
->timer
.expires
= DMFE_TIMER_WUT
;
1282 add_timer(&db
->timer
);
1283 spin_unlock_irqrestore(&db
->lock
, flags
);
1288 * Dynamic reset the DM910X board
1290 * Free Tx/Rx allocated memory
1291 * Reset DM910X board
1292 * Re-initialize DM910X board
1295 static void dmfe_dynamic_reset(struct net_device
*dev
)
1297 struct dmfe_board_info
*db
= netdev_priv(dev
);
1298 void __iomem
*ioaddr
= db
->ioaddr
;
1300 DMFE_DBUG(0, "dmfe_dynamic_reset()", 0);
1302 /* Sopt MAC controller */
1303 db
->cr6_data
&= ~(CR6_RXSC
| CR6_TXSC
); /* Disable Tx/Rx */
1304 update_cr6(db
->cr6_data
, ioaddr
);
1305 dw32(DCR7
, 0); /* Disable Interrupt */
1306 dw32(DCR5
, dr32(DCR5
));
1308 /* Disable upper layer interface */
1309 netif_stop_queue(dev
);
1311 /* Free Rx Allocate buffer */
1312 dmfe_free_rxbuffer(db
);
1314 /* system variable init */
1315 db
->tx_packet_cnt
= 0;
1316 db
->tx_queue_cnt
= 0;
1317 db
->rx_avail_cnt
= 0;
1318 netif_carrier_off(dev
);
1321 /* Re-initialize DM910X board */
1322 dmfe_init_dm910x(dev
);
1324 /* Restart upper layer interface */
1325 netif_wake_queue(dev
);
1330 * free all allocated rx buffer
1333 static void dmfe_free_rxbuffer(struct dmfe_board_info
* db
)
1335 DMFE_DBUG(0, "dmfe_free_rxbuffer()", 0);
1337 /* free allocated rx buffer */
1338 while (db
->rx_avail_cnt
) {
1339 dev_kfree_skb(db
->rx_ready_ptr
->rx_skb_ptr
);
1340 db
->rx_ready_ptr
= db
->rx_ready_ptr
->next_rx_desc
;
1347 * Reuse the SK buffer
1350 static void dmfe_reuse_skb(struct dmfe_board_info
*db
, struct sk_buff
* skb
)
1352 struct rx_desc
*rxptr
= db
->rx_insert_ptr
;
1354 if (!(rxptr
->rdes0
& cpu_to_le32(0x80000000))) {
1355 rxptr
->rx_skb_ptr
= skb
;
1356 rxptr
->rdes2
= cpu_to_le32( pci_map_single(db
->pdev
,
1357 skb
->data
, RX_ALLOC_SIZE
, PCI_DMA_FROMDEVICE
) );
1359 rxptr
->rdes0
= cpu_to_le32(0x80000000);
1361 db
->rx_insert_ptr
= rxptr
->next_rx_desc
;
1363 DMFE_DBUG(0, "SK Buffer reuse method error", db
->rx_avail_cnt
);
1368 * Initialize transmit/Receive descriptor
1369 * Using Chain structure, and allocate Tx/Rx buffer
1372 static void dmfe_descriptor_init(struct net_device
*dev
)
1374 struct dmfe_board_info
*db
= netdev_priv(dev
);
1375 void __iomem
*ioaddr
= db
->ioaddr
;
1376 struct tx_desc
*tmp_tx
;
1377 struct rx_desc
*tmp_rx
;
1378 unsigned char *tmp_buf
;
1379 dma_addr_t tmp_tx_dma
, tmp_rx_dma
;
1380 dma_addr_t tmp_buf_dma
;
1383 DMFE_DBUG(0, "dmfe_descriptor_init()", 0);
1385 /* tx descriptor start pointer */
1386 db
->tx_insert_ptr
= db
->first_tx_desc
;
1387 db
->tx_remove_ptr
= db
->first_tx_desc
;
1388 dw32(DCR4
, db
->first_tx_desc_dma
); /* TX DESC address */
1390 /* rx descriptor start pointer */
1391 db
->first_rx_desc
= (void *)db
->first_tx_desc
+
1392 sizeof(struct tx_desc
) * TX_DESC_CNT
;
1394 db
->first_rx_desc_dma
= db
->first_tx_desc_dma
+
1395 sizeof(struct tx_desc
) * TX_DESC_CNT
;
1396 db
->rx_insert_ptr
= db
->first_rx_desc
;
1397 db
->rx_ready_ptr
= db
->first_rx_desc
;
1398 dw32(DCR3
, db
->first_rx_desc_dma
); /* RX DESC address */
1400 /* Init Transmit chain */
1401 tmp_buf
= db
->buf_pool_start
;
1402 tmp_buf_dma
= db
->buf_pool_dma_start
;
1403 tmp_tx_dma
= db
->first_tx_desc_dma
;
1404 for (tmp_tx
= db
->first_tx_desc
, i
= 0; i
< TX_DESC_CNT
; i
++, tmp_tx
++) {
1405 tmp_tx
->tx_buf_ptr
= tmp_buf
;
1406 tmp_tx
->tdes0
= cpu_to_le32(0);
1407 tmp_tx
->tdes1
= cpu_to_le32(0x81000000); /* IC, chain */
1408 tmp_tx
->tdes2
= cpu_to_le32(tmp_buf_dma
);
1409 tmp_tx_dma
+= sizeof(struct tx_desc
);
1410 tmp_tx
->tdes3
= cpu_to_le32(tmp_tx_dma
);
1411 tmp_tx
->next_tx_desc
= tmp_tx
+ 1;
1412 tmp_buf
= tmp_buf
+ TX_BUF_ALLOC
;
1413 tmp_buf_dma
= tmp_buf_dma
+ TX_BUF_ALLOC
;
1415 (--tmp_tx
)->tdes3
= cpu_to_le32(db
->first_tx_desc_dma
);
1416 tmp_tx
->next_tx_desc
= db
->first_tx_desc
;
1418 /* Init Receive descriptor chain */
1419 tmp_rx_dma
=db
->first_rx_desc_dma
;
1420 for (tmp_rx
= db
->first_rx_desc
, i
= 0; i
< RX_DESC_CNT
; i
++, tmp_rx
++) {
1421 tmp_rx
->rdes0
= cpu_to_le32(0);
1422 tmp_rx
->rdes1
= cpu_to_le32(0x01000600);
1423 tmp_rx_dma
+= sizeof(struct rx_desc
);
1424 tmp_rx
->rdes3
= cpu_to_le32(tmp_rx_dma
);
1425 tmp_rx
->next_rx_desc
= tmp_rx
+ 1;
1427 (--tmp_rx
)->rdes3
= cpu_to_le32(db
->first_rx_desc_dma
);
1428 tmp_rx
->next_rx_desc
= db
->first_rx_desc
;
1430 /* pre-allocate Rx buffer */
1431 allocate_rx_buffer(dev
);
1437 * Firstly stop DM910X , then written value and start
1440 static void update_cr6(u32 cr6_data
, void __iomem
*ioaddr
)
1444 cr6_tmp
= cr6_data
& ~0x2002; /* stop Tx/Rx */
1445 dw32(DCR6
, cr6_tmp
);
1447 dw32(DCR6
, cr6_data
);
1453 * Send a setup frame for DM9132
1454 * This setup frame initialize DM910X address filter mode
1457 static void dm9132_id_table(struct net_device
*dev
)
1459 struct dmfe_board_info
*db
= netdev_priv(dev
);
1460 void __iomem
*ioaddr
= db
->ioaddr
+ 0xc0;
1461 u16
*addrptr
= (u16
*)dev
->dev_addr
;
1462 struct netdev_hw_addr
*ha
;
1463 u16 i
, hash_table
[4];
1466 for (i
= 0; i
< 3; i
++) {
1467 dw16(0, addrptr
[i
]);
1471 /* Clear Hash Table */
1472 memset(hash_table
, 0, sizeof(hash_table
));
1474 /* broadcast address */
1475 hash_table
[3] = 0x8000;
1477 /* the multicast address in Hash Table : 64 bits */
1478 netdev_for_each_mc_addr(ha
, dev
) {
1479 u32 hash_val
= cal_CRC((char *)ha
->addr
, 6, 0) & 0x3f;
1481 hash_table
[hash_val
/ 16] |= (u16
) 1 << (hash_val
% 16);
1484 /* Write the hash table to MAC MD table */
1485 for (i
= 0; i
< 4; i
++, ioaddr
+= 4)
1486 dw16(0, hash_table
[i
]);
1491 * Send a setup frame for DM9102/DM9102A
1492 * This setup frame initialize DM910X address filter mode
1495 static void send_filter_frame(struct net_device
*dev
)
1497 struct dmfe_board_info
*db
= netdev_priv(dev
);
1498 struct netdev_hw_addr
*ha
;
1499 struct tx_desc
*txptr
;
1504 DMFE_DBUG(0, "send_filter_frame()", 0);
1506 txptr
= db
->tx_insert_ptr
;
1507 suptr
= (u32
*) txptr
->tx_buf_ptr
;
1510 addrptr
= (u16
*) dev
->dev_addr
;
1511 *suptr
++ = addrptr
[0];
1512 *suptr
++ = addrptr
[1];
1513 *suptr
++ = addrptr
[2];
1515 /* broadcast address */
1520 /* fit the multicast address */
1521 netdev_for_each_mc_addr(ha
, dev
) {
1522 addrptr
= (u16
*) ha
->addr
;
1523 *suptr
++ = addrptr
[0];
1524 *suptr
++ = addrptr
[1];
1525 *suptr
++ = addrptr
[2];
1528 for (i
= netdev_mc_count(dev
); i
< 14; i
++) {
1534 /* prepare the setup frame */
1535 db
->tx_insert_ptr
= txptr
->next_tx_desc
;
1536 txptr
->tdes1
= cpu_to_le32(0x890000c0);
1538 /* Resource Check and Send the setup packet */
1539 if (!db
->tx_packet_cnt
) {
1540 void __iomem
*ioaddr
= db
->ioaddr
;
1542 /* Resource Empty */
1543 db
->tx_packet_cnt
++;
1544 txptr
->tdes0
= cpu_to_le32(0x80000000);
1545 update_cr6(db
->cr6_data
| 0x2000, ioaddr
);
1546 dw32(DCR1
, 0x1); /* Issue Tx polling */
1547 update_cr6(db
->cr6_data
, ioaddr
);
1548 dev
->trans_start
= jiffies
;
1550 db
->tx_queue_cnt
++; /* Put in TX queue */
1555 * Allocate rx buffer,
1556 * As possible as allocate maxiumn Rx buffer
1559 static void allocate_rx_buffer(struct net_device
*dev
)
1561 struct dmfe_board_info
*db
= netdev_priv(dev
);
1562 struct rx_desc
*rxptr
;
1563 struct sk_buff
*skb
;
1565 rxptr
= db
->rx_insert_ptr
;
1567 while(db
->rx_avail_cnt
< RX_DESC_CNT
) {
1568 if ( ( skb
= netdev_alloc_skb(dev
, RX_ALLOC_SIZE
) ) == NULL
)
1570 rxptr
->rx_skb_ptr
= skb
; /* FIXME (?) */
1571 rxptr
->rdes2
= cpu_to_le32( pci_map_single(db
->pdev
, skb
->data
,
1572 RX_ALLOC_SIZE
, PCI_DMA_FROMDEVICE
) );
1574 rxptr
->rdes0
= cpu_to_le32(0x80000000);
1575 rxptr
= rxptr
->next_rx_desc
;
1579 db
->rx_insert_ptr
= rxptr
;
1582 static void srom_clk_write(void __iomem
*ioaddr
, u32 data
)
1584 static const u32 cmd
[] = {
1585 CR9_SROM_READ
| CR9_SRCS
,
1586 CR9_SROM_READ
| CR9_SRCS
| CR9_SRCLK
,
1587 CR9_SROM_READ
| CR9_SRCS
1591 for (i
= 0; i
< ARRAY_SIZE(cmd
); i
++) {
1592 dw32(DCR9
, data
| cmd
[i
]);
1598 * Read one word data from the serial ROM
1600 static u16
read_srom_word(void __iomem
*ioaddr
, int offset
)
1605 dw32(DCR9
, CR9_SROM_READ
);
1607 dw32(DCR9
, CR9_SROM_READ
| CR9_SRCS
);
1610 /* Send the Read Command 110b */
1611 srom_clk_write(ioaddr
, SROM_DATA_1
);
1612 srom_clk_write(ioaddr
, SROM_DATA_1
);
1613 srom_clk_write(ioaddr
, SROM_DATA_0
);
1615 /* Send the offset */
1616 for (i
= 5; i
>= 0; i
--) {
1617 srom_data
= (offset
& (1 << i
)) ? SROM_DATA_1
: SROM_DATA_0
;
1618 srom_clk_write(ioaddr
, srom_data
);
1621 dw32(DCR9
, CR9_SROM_READ
| CR9_SRCS
);
1624 for (i
= 16; i
> 0; i
--) {
1625 dw32(DCR9
, CR9_SROM_READ
| CR9_SRCS
| CR9_SRCLK
);
1627 srom_data
= (srom_data
<< 1) |
1628 ((dr32(DCR9
) & CR9_CRDOUT
) ? 1 : 0);
1629 dw32(DCR9
, CR9_SROM_READ
| CR9_SRCS
);
1633 dw32(DCR9
, CR9_SROM_READ
);
1640 * Auto sense the media mode
1643 static u8
dmfe_sense_speed(struct dmfe_board_info
*db
)
1645 void __iomem
*ioaddr
= db
->ioaddr
;
1649 /* CR6 bit18=0, select 10/100M */
1650 update_cr6(db
->cr6_data
& ~0x40000, ioaddr
);
1652 phy_mode
= phy_read(db
->ioaddr
, db
->phy_addr
, 1, db
->chip_id
);
1653 phy_mode
= phy_read(db
->ioaddr
, db
->phy_addr
, 1, db
->chip_id
);
1655 if ( (phy_mode
& 0x24) == 0x24 ) {
1656 if (db
->chip_id
== PCI_DM9132_ID
) /* DM9132 */
1657 phy_mode
= phy_read(db
->ioaddr
,
1658 db
->phy_addr
, 7, db
->chip_id
) & 0xf000;
1659 else /* DM9102/DM9102A */
1660 phy_mode
= phy_read(db
->ioaddr
,
1661 db
->phy_addr
, 17, db
->chip_id
) & 0xf000;
1663 case 0x1000: db
->op_mode
= DMFE_10MHF
; break;
1664 case 0x2000: db
->op_mode
= DMFE_10MFD
; break;
1665 case 0x4000: db
->op_mode
= DMFE_100MHF
; break;
1666 case 0x8000: db
->op_mode
= DMFE_100MFD
; break;
1667 default: db
->op_mode
= DMFE_10MHF
;
1672 db
->op_mode
= DMFE_10MHF
;
1673 DMFE_DBUG(0, "Link Failed :", phy_mode
);
1682 * Set 10/100 phyxcer capability
1683 * AUTO mode : phyxcer register4 is NIC capability
1684 * Force mode: phyxcer register4 is the force media
1687 static void dmfe_set_phyxcer(struct dmfe_board_info
*db
)
1689 void __iomem
*ioaddr
= db
->ioaddr
;
1692 /* Select 10/100M phyxcer */
1693 db
->cr6_data
&= ~0x40000;
1694 update_cr6(db
->cr6_data
, ioaddr
);
1696 /* DM9009 Chip: Phyxcer reg18 bit12=0 */
1697 if (db
->chip_id
== PCI_DM9009_ID
) {
1698 phy_reg
= phy_read(db
->ioaddr
,
1699 db
->phy_addr
, 18, db
->chip_id
) & ~0x1000;
1701 phy_write(db
->ioaddr
,
1702 db
->phy_addr
, 18, phy_reg
, db
->chip_id
);
1705 /* Phyxcer capability setting */
1706 phy_reg
= phy_read(db
->ioaddr
, db
->phy_addr
, 4, db
->chip_id
) & ~0x01e0;
1708 if (db
->media_mode
& DMFE_AUTO
) {
1710 phy_reg
|= db
->PHY_reg4
;
1713 switch(db
->media_mode
) {
1714 case DMFE_10MHF
: phy_reg
|= 0x20; break;
1715 case DMFE_10MFD
: phy_reg
|= 0x40; break;
1716 case DMFE_100MHF
: phy_reg
|= 0x80; break;
1717 case DMFE_100MFD
: phy_reg
|= 0x100; break;
1719 if (db
->chip_id
== PCI_DM9009_ID
) phy_reg
&= 0x61;
1722 /* Write new capability to Phyxcer Reg4 */
1723 if ( !(phy_reg
& 0x01e0)) {
1724 phy_reg
|=db
->PHY_reg4
;
1725 db
->media_mode
|=DMFE_AUTO
;
1727 phy_write(db
->ioaddr
, db
->phy_addr
, 4, phy_reg
, db
->chip_id
);
1729 /* Restart Auto-Negotiation */
1730 if ( db
->chip_type
&& (db
->chip_id
== PCI_DM9102_ID
) )
1731 phy_write(db
->ioaddr
, db
->phy_addr
, 0, 0x1800, db
->chip_id
);
1732 if ( !db
->chip_type
)
1733 phy_write(db
->ioaddr
, db
->phy_addr
, 0, 0x1200, db
->chip_id
);
1739 * AUTO mode : PHY controller in Auto-negotiation Mode
1740 * Force mode: PHY controller in force mode with HUB
1741 * N-way force capability with SWITCH
1744 static void dmfe_process_mode(struct dmfe_board_info
*db
)
1748 /* Full Duplex Mode Check */
1749 if (db
->op_mode
& 0x4)
1750 db
->cr6_data
|= CR6_FDM
; /* Set Full Duplex Bit */
1752 db
->cr6_data
&= ~CR6_FDM
; /* Clear Full Duplex Bit */
1754 /* Transciver Selection */
1755 if (db
->op_mode
& 0x10) /* 1M HomePNA */
1756 db
->cr6_data
|= 0x40000;/* External MII select */
1758 db
->cr6_data
&= ~0x40000;/* Internal 10/100 transciver */
1760 update_cr6(db
->cr6_data
, db
->ioaddr
);
1762 /* 10/100M phyxcer force mode need */
1763 if ( !(db
->media_mode
& 0x18)) {
1765 phy_reg
= phy_read(db
->ioaddr
, db
->phy_addr
, 6, db
->chip_id
);
1766 if ( !(phy_reg
& 0x1) ) {
1767 /* parter without N-Way capability */
1769 switch(db
->op_mode
) {
1770 case DMFE_10MHF
: phy_reg
= 0x0; break;
1771 case DMFE_10MFD
: phy_reg
= 0x100; break;
1772 case DMFE_100MHF
: phy_reg
= 0x2000; break;
1773 case DMFE_100MFD
: phy_reg
= 0x2100; break;
1775 phy_write(db
->ioaddr
,
1776 db
->phy_addr
, 0, phy_reg
, db
->chip_id
);
1777 if ( db
->chip_type
&& (db
->chip_id
== PCI_DM9102_ID
) )
1779 phy_write(db
->ioaddr
,
1780 db
->phy_addr
, 0, phy_reg
, db
->chip_id
);
1787 * Write a word to Phy register
1790 static void phy_write(void __iomem
*ioaddr
, u8 phy_addr
, u8 offset
,
1791 u16 phy_data
, u32 chip_id
)
1795 if (chip_id
== PCI_DM9132_ID
) {
1796 dw16(0x80 + offset
* 4, phy_data
);
1798 /* DM9102/DM9102A Chip */
1800 /* Send 33 synchronization clock to Phy controller */
1801 for (i
= 0; i
< 35; i
++)
1802 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1804 /* Send start command(01) to Phy */
1805 phy_write_1bit(ioaddr
, PHY_DATA_0
);
1806 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1808 /* Send write command(01) to Phy */
1809 phy_write_1bit(ioaddr
, PHY_DATA_0
);
1810 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1812 /* Send Phy address */
1813 for (i
= 0x10; i
> 0; i
= i
>> 1)
1814 phy_write_1bit(ioaddr
,
1815 phy_addr
& i
? PHY_DATA_1
: PHY_DATA_0
);
1817 /* Send register address */
1818 for (i
= 0x10; i
> 0; i
= i
>> 1)
1819 phy_write_1bit(ioaddr
,
1820 offset
& i
? PHY_DATA_1
: PHY_DATA_0
);
1822 /* written trasnition */
1823 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1824 phy_write_1bit(ioaddr
, PHY_DATA_0
);
1826 /* Write a word data to PHY controller */
1827 for ( i
= 0x8000; i
> 0; i
>>= 1)
1828 phy_write_1bit(ioaddr
,
1829 phy_data
& i
? PHY_DATA_1
: PHY_DATA_0
);
1835 * Read a word data from phy register
1838 static u16
phy_read(void __iomem
*ioaddr
, u8 phy_addr
, u8 offset
, u32 chip_id
)
1843 if (chip_id
== PCI_DM9132_ID
) {
1845 phy_data
= dr16(0x80 + offset
* 4);
1847 /* DM9102/DM9102A Chip */
1849 /* Send 33 synchronization clock to Phy controller */
1850 for (i
= 0; i
< 35; i
++)
1851 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1853 /* Send start command(01) to Phy */
1854 phy_write_1bit(ioaddr
, PHY_DATA_0
);
1855 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1857 /* Send read command(10) to Phy */
1858 phy_write_1bit(ioaddr
, PHY_DATA_1
);
1859 phy_write_1bit(ioaddr
, PHY_DATA_0
);
1861 /* Send Phy address */
1862 for (i
= 0x10; i
> 0; i
= i
>> 1)
1863 phy_write_1bit(ioaddr
,
1864 phy_addr
& i
? PHY_DATA_1
: PHY_DATA_0
);
1866 /* Send register address */
1867 for (i
= 0x10; i
> 0; i
= i
>> 1)
1868 phy_write_1bit(ioaddr
,
1869 offset
& i
? PHY_DATA_1
: PHY_DATA_0
);
1871 /* Skip transition state */
1872 phy_read_1bit(ioaddr
);
1874 /* read 16bit data */
1875 for (phy_data
= 0, i
= 0; i
< 16; i
++) {
1877 phy_data
|= phy_read_1bit(ioaddr
);
1886 * Write one bit data to Phy Controller
1889 static void phy_write_1bit(void __iomem
*ioaddr
, u32 phy_data
)
1891 dw32(DCR9
, phy_data
); /* MII Clock Low */
1893 dw32(DCR9
, phy_data
| MDCLKH
); /* MII Clock High */
1895 dw32(DCR9
, phy_data
); /* MII Clock Low */
1901 * Read one bit phy data from PHY controller
1904 static u16
phy_read_1bit(void __iomem
*ioaddr
)
1908 dw32(DCR9
, 0x50000);
1910 phy_data
= (dr32(DCR9
) >> 19) & 0x1;
1911 dw32(DCR9
, 0x40000);
1919 * Parser SROM and media mode
1922 static void dmfe_parse_srom(struct dmfe_board_info
* db
)
1924 char * srom
= db
->srom
;
1925 int dmfe_mode
, tmp_reg
;
1927 DMFE_DBUG(0, "dmfe_parse_srom() ", 0);
1930 db
->cr15_data
= CR15_DEFAULT
;
1932 /* Check SROM Version */
1933 if ( ( (int) srom
[18] & 0xff) == SROM_V41_CODE
) {
1935 /* Get NIC support media mode */
1936 db
->NIC_capability
= le16_to_cpup((__le16
*) (srom
+ 34));
1938 for (tmp_reg
= 1; tmp_reg
< 0x10; tmp_reg
<<= 1) {
1939 switch( db
->NIC_capability
& tmp_reg
) {
1940 case 0x1: db
->PHY_reg4
|= 0x0020; break;
1941 case 0x2: db
->PHY_reg4
|= 0x0040; break;
1942 case 0x4: db
->PHY_reg4
|= 0x0080; break;
1943 case 0x8: db
->PHY_reg4
|= 0x0100; break;
1947 /* Media Mode Force or not check */
1948 dmfe_mode
= (le32_to_cpup((__le32
*) (srom
+ 34)) &
1949 le32_to_cpup((__le32
*) (srom
+ 36)));
1951 case 0x4: dmfe_media_mode
= DMFE_100MHF
; break; /* 100MHF */
1952 case 0x2: dmfe_media_mode
= DMFE_10MFD
; break; /* 10MFD */
1953 case 0x8: dmfe_media_mode
= DMFE_100MFD
; break; /* 100MFD */
1955 case 0x200: dmfe_media_mode
= DMFE_1M_HPNA
; break;/* HomePNA */
1958 /* Special Function setting */
1960 if ( (SF_mode
& 0x1) || (srom
[43] & 0x80) )
1961 db
->cr15_data
|= 0x40;
1964 if ( (SF_mode
& 0x2) || (srom
[40] & 0x1) )
1965 db
->cr15_data
|= 0x400;
1967 /* TX pause packet */
1968 if ( (SF_mode
& 0x4) || (srom
[40] & 0xe) )
1969 db
->cr15_data
|= 0x9800;
1972 /* Parse HPNA parameter */
1973 db
->HPNA_command
= 1;
1975 /* Accept remote command or not */
1976 if (HPNA_rx_cmd
== 0)
1977 db
->HPNA_command
|= 0x8000;
1979 /* Issue remote command & operation mode */
1980 if (HPNA_tx_cmd
== 1)
1981 switch(HPNA_mode
) { /* Issue Remote Command */
1982 case 0: db
->HPNA_command
|= 0x0904; break;
1983 case 1: db
->HPNA_command
|= 0x0a00; break;
1984 case 2: db
->HPNA_command
|= 0x0506; break;
1985 case 3: db
->HPNA_command
|= 0x0602; break;
1988 switch(HPNA_mode
) { /* Don't Issue */
1989 case 0: db
->HPNA_command
|= 0x0004; break;
1990 case 1: db
->HPNA_command
|= 0x0000; break;
1991 case 2: db
->HPNA_command
|= 0x0006; break;
1992 case 3: db
->HPNA_command
|= 0x0002; break;
1995 /* Check DM9801 or DM9802 present or not */
1996 db
->HPNA_present
= 0;
1997 update_cr6(db
->cr6_data
| 0x40000, db
->ioaddr
);
1998 tmp_reg
= phy_read(db
->ioaddr
, db
->phy_addr
, 3, db
->chip_id
);
1999 if ( ( tmp_reg
& 0xfff0 ) == 0xb900 ) {
2000 /* DM9801 or DM9802 present */
2002 if ( phy_read(db
->ioaddr
, db
->phy_addr
, 31, db
->chip_id
) == 0x4404) {
2003 /* DM9801 HomeRun */
2004 db
->HPNA_present
= 1;
2005 dmfe_program_DM9801(db
, tmp_reg
);
2007 /* DM9802 LongRun */
2008 db
->HPNA_present
= 2;
2009 dmfe_program_DM9802(db
);
2017 * Init HomeRun DM9801
2020 static void dmfe_program_DM9801(struct dmfe_board_info
* db
, int HPNA_rev
)
2024 if ( !HPNA_NoiseFloor
) HPNA_NoiseFloor
= DM9801_NOISE_FLOOR
;
2026 case 0xb900: /* DM9801 E3 */
2027 db
->HPNA_command
|= 0x1000;
2028 reg25
= phy_read(db
->ioaddr
, db
->phy_addr
, 24, db
->chip_id
);
2029 reg25
= ( (reg25
+ HPNA_NoiseFloor
) & 0xff) | 0xf000;
2030 reg17
= phy_read(db
->ioaddr
, db
->phy_addr
, 17, db
->chip_id
);
2032 case 0xb901: /* DM9801 E4 */
2033 reg25
= phy_read(db
->ioaddr
, db
->phy_addr
, 25, db
->chip_id
);
2034 reg25
= (reg25
& 0xff00) + HPNA_NoiseFloor
;
2035 reg17
= phy_read(db
->ioaddr
, db
->phy_addr
, 17, db
->chip_id
);
2036 reg17
= (reg17
& 0xfff0) + HPNA_NoiseFloor
+ 3;
2038 case 0xb902: /* DM9801 E5 */
2039 case 0xb903: /* DM9801 E6 */
2041 db
->HPNA_command
|= 0x1000;
2042 reg25
= phy_read(db
->ioaddr
, db
->phy_addr
, 25, db
->chip_id
);
2043 reg25
= (reg25
& 0xff00) + HPNA_NoiseFloor
- 5;
2044 reg17
= phy_read(db
->ioaddr
, db
->phy_addr
, 17, db
->chip_id
);
2045 reg17
= (reg17
& 0xfff0) + HPNA_NoiseFloor
;
2048 phy_write(db
->ioaddr
, db
->phy_addr
, 16, db
->HPNA_command
, db
->chip_id
);
2049 phy_write(db
->ioaddr
, db
->phy_addr
, 17, reg17
, db
->chip_id
);
2050 phy_write(db
->ioaddr
, db
->phy_addr
, 25, reg25
, db
->chip_id
);
2055 * Init HomeRun DM9802
2058 static void dmfe_program_DM9802(struct dmfe_board_info
* db
)
2062 if ( !HPNA_NoiseFloor
) HPNA_NoiseFloor
= DM9802_NOISE_FLOOR
;
2063 phy_write(db
->ioaddr
, db
->phy_addr
, 16, db
->HPNA_command
, db
->chip_id
);
2064 phy_reg
= phy_read(db
->ioaddr
, db
->phy_addr
, 25, db
->chip_id
);
2065 phy_reg
= ( phy_reg
& 0xff00) + HPNA_NoiseFloor
;
2066 phy_write(db
->ioaddr
, db
->phy_addr
, 25, phy_reg
, db
->chip_id
);
2071 * Check remote HPNA power and speed status. If not correct,
2072 * issue command again.
2075 static void dmfe_HPNA_remote_cmd_chk(struct dmfe_board_info
* db
)
2079 /* Got remote device status */
2080 phy_reg
= phy_read(db
->ioaddr
, db
->phy_addr
, 17, db
->chip_id
) & 0x60;
2082 case 0x00: phy_reg
= 0x0a00;break; /* LP/LS */
2083 case 0x20: phy_reg
= 0x0900;break; /* LP/HS */
2084 case 0x40: phy_reg
= 0x0600;break; /* HP/LS */
2085 case 0x60: phy_reg
= 0x0500;break; /* HP/HS */
2088 /* Check remote device status match our setting ot not */
2089 if ( phy_reg
!= (db
->HPNA_command
& 0x0f00) ) {
2090 phy_write(db
->ioaddr
, db
->phy_addr
, 16, db
->HPNA_command
,
2094 db
->HPNA_timer
=600; /* Match, every 10 minutes, check */
2099 static const struct pci_device_id dmfe_pci_tbl
[] = {
2100 { 0x1282, 0x9132, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, PCI_DM9132_ID
},
2101 { 0x1282, 0x9102, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, PCI_DM9102_ID
},
2102 { 0x1282, 0x9100, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, PCI_DM9100_ID
},
2103 { 0x1282, 0x9009, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, PCI_DM9009_ID
},
2106 MODULE_DEVICE_TABLE(pci
, dmfe_pci_tbl
);
2110 static int dmfe_suspend(struct pci_dev
*pci_dev
, pm_message_t state
)
2112 struct net_device
*dev
= pci_get_drvdata(pci_dev
);
2113 struct dmfe_board_info
*db
= netdev_priv(dev
);
2114 void __iomem
*ioaddr
= db
->ioaddr
;
2117 /* Disable upper layer interface */
2118 netif_device_detach(dev
);
2121 db
->cr6_data
&= ~(CR6_RXSC
| CR6_TXSC
);
2122 update_cr6(db
->cr6_data
, ioaddr
);
2124 /* Disable Interrupt */
2126 dw32(DCR5
, dr32(DCR5
));
2128 /* Fre RX buffers */
2129 dmfe_free_rxbuffer(db
);
2132 pci_read_config_dword(pci_dev
, 0x40, &tmp
);
2133 tmp
&= ~(DMFE_WOL_LINKCHANGE
|DMFE_WOL_MAGICPACKET
);
2135 if (db
->wol_mode
& WAKE_PHY
)
2136 tmp
|= DMFE_WOL_LINKCHANGE
;
2137 if (db
->wol_mode
& WAKE_MAGIC
)
2138 tmp
|= DMFE_WOL_MAGICPACKET
;
2140 pci_write_config_dword(pci_dev
, 0x40, tmp
);
2142 pci_enable_wake(pci_dev
, PCI_D3hot
, 1);
2143 pci_enable_wake(pci_dev
, PCI_D3cold
, 1);
2145 /* Power down device*/
2146 pci_save_state(pci_dev
);
2147 pci_set_power_state(pci_dev
, pci_choose_state (pci_dev
, state
));
2152 static int dmfe_resume(struct pci_dev
*pci_dev
)
2154 struct net_device
*dev
= pci_get_drvdata(pci_dev
);
2157 pci_set_power_state(pci_dev
, PCI_D0
);
2158 pci_restore_state(pci_dev
);
2160 /* Re-initialize DM910X board */
2161 dmfe_init_dm910x(dev
);
2164 pci_read_config_dword(pci_dev
, 0x40, &tmp
);
2166 tmp
&= ~(DMFE_WOL_LINKCHANGE
| DMFE_WOL_MAGICPACKET
);
2167 pci_write_config_dword(pci_dev
, 0x40, tmp
);
2169 pci_enable_wake(pci_dev
, PCI_D3hot
, 0);
2170 pci_enable_wake(pci_dev
, PCI_D3cold
, 0);
2172 /* Restart upper layer interface */
2173 netif_device_attach(dev
);
2178 #define dmfe_suspend NULL
2179 #define dmfe_resume NULL
2182 static struct pci_driver dmfe_driver
= {
2184 .id_table
= dmfe_pci_tbl
,
2185 .probe
= dmfe_init_one
,
2186 .remove
= dmfe_remove_one
,
2187 .suspend
= dmfe_suspend
,
2188 .resume
= dmfe_resume
2191 MODULE_AUTHOR("Sten Wang, sten_wang@davicom.com.tw");
2192 MODULE_DESCRIPTION("Davicom DM910X fast ethernet driver");
2193 MODULE_LICENSE("GPL");
2194 MODULE_VERSION(DRV_VERSION
);
2196 module_param(debug
, int, 0);
2197 module_param(mode
, byte
, 0);
2198 module_param(cr6set
, int, 0);
2199 module_param(chkmode
, byte
, 0);
2200 module_param(HPNA_mode
, byte
, 0);
2201 module_param(HPNA_rx_cmd
, byte
, 0);
2202 module_param(HPNA_tx_cmd
, byte
, 0);
2203 module_param(HPNA_NoiseFloor
, byte
, 0);
2204 module_param(SF_mode
, byte
, 0);
2205 MODULE_PARM_DESC(debug
, "Davicom DM9xxx enable debugging (0-1)");
2206 MODULE_PARM_DESC(mode
, "Davicom DM9xxx: "
2207 "Bit 0: 10/100Mbps, bit 2: duplex, bit 8: HomePNA");
2209 MODULE_PARM_DESC(SF_mode
, "Davicom DM9xxx special function "
2210 "(bit 0: VLAN, bit 1 Flow Control, bit 2: TX pause packet)");
2213 * when user used insmod to add module, system invoked init_module()
2214 * to initialize and register.
2217 static int __init
dmfe_init_module(void)
2221 pr_info("%s\n", version
);
2222 printed_version
= 1;
2224 DMFE_DBUG(0, "init_module() ", debug
);
2227 dmfe_debug
= debug
; /* set debug flag */
2229 dmfe_cr6_user_set
= cr6set
;
2237 dmfe_media_mode
= mode
;
2239 default:dmfe_media_mode
= DMFE_AUTO
;
2244 HPNA_mode
= 0; /* Default: LP/HS */
2245 if (HPNA_rx_cmd
> 1)
2246 HPNA_rx_cmd
= 0; /* Default: Ignored remote cmd */
2247 if (HPNA_tx_cmd
> 1)
2248 HPNA_tx_cmd
= 0; /* Default: Don't issue remote cmd */
2249 if (HPNA_NoiseFloor
> 15)
2250 HPNA_NoiseFloor
= 0;
2252 rc
= pci_register_driver(&dmfe_driver
);
2262 * when user used rmmod to delete module, system invoked clean_module()
2263 * to un-register all registered services.
2266 static void __exit
dmfe_cleanup_module(void)
2268 DMFE_DBUG(0, "dmfe_clean_module() ", debug
);
2269 pci_unregister_driver(&dmfe_driver
);
2272 module_init(dmfe_init_module
);
2273 module_exit(dmfe_cleanup_module
);