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