2 * Davicom DM9000 Fast Ethernet driver for Linux.
3 * Copyright (C) 1997 Sten Wang
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * (C) Copyright 1997-1998 DAVICOM Semiconductor,Inc. All Rights Reserved.
17 * Additional updates, Copyright:
18 * Ben Dooks <ben@simtec.co.uk>
19 * Sascha Hauer <s.hauer@pengutronix.de>
22 #include <linux/module.h>
23 #include <linux/ioport.h>
24 #include <linux/netdevice.h>
25 #include <linux/etherdevice.h>
26 #include <linux/init.h>
27 #include <linux/skbuff.h>
28 #include <linux/spinlock.h>
29 #include <linux/crc32.h>
30 #include <linux/mii.h>
31 #include <linux/ethtool.h>
32 #include <linux/dm9000.h>
33 #include <linux/delay.h>
34 #include <linux/platform_device.h>
35 #include <linux/irq.h>
37 #include <asm/delay.h>
43 /* Board/System/Debug information/definition ---------------- */
45 #define DM9000_PHY 0x40 /* PHY address 0x01 */
47 #define CARDNAME "dm9000"
48 #define PFX CARDNAME ": "
49 #define DRV_VERSION "1.30"
51 #ifdef CONFIG_BLACKFIN
58 #define DEFAULT_TRIGGER IRQF_TRIGGER_HIGH
60 #define DEFAULT_TRIGGER (0)
64 * Transmit timeout, default 5 seconds.
66 static int watchdog
= 5000;
67 module_param(watchdog
, int, 0400);
68 MODULE_PARM_DESC(watchdog
, "transmit timeout in milliseconds");
70 /* DM9000 register address locking.
72 * The DM9000 uses an address register to control where data written
73 * to the data register goes. This means that the address register
74 * must be preserved over interrupts or similar calls.
76 * During interrupt and other critical calls, a spinlock is used to
77 * protect the system, but the calls themselves save the address
78 * in the address register in case they are interrupting another
79 * access to the device.
81 * For general accesses a lock is provided so that calls which are
82 * allowed to sleep are serialised so that the address register does
83 * not need to be saved. This lock also serves to serialise access
84 * to the EEPROM and PHY access registers which are shared between
88 /* Structure/enum declaration ------------------------------- */
89 typedef struct board_info
{
91 void __iomem
*io_addr
; /* Register I/O base address */
92 void __iomem
*io_data
; /* Data I/O address */
99 u8 io_mode
; /* 0:word, 2:byte */
102 unsigned int in_suspend
:1;
106 void (*inblk
)(void __iomem
*port
, void *data
, int length
);
107 void (*outblk
)(void __iomem
*port
, void *data
, int length
);
108 void (*dumpblk
)(void __iomem
*port
, int length
);
110 struct device
*dev
; /* parent device */
112 struct resource
*addr_res
; /* resources found */
113 struct resource
*data_res
;
114 struct resource
*addr_req
; /* resources requested */
115 struct resource
*data_req
;
116 struct resource
*irq_res
;
118 struct mutex addr_lock
; /* phy and eeprom access lock */
122 struct mii_if_info mii
;
128 #define dm9000_dbg(db, lev, msg...) do { \
129 if ((lev) < CONFIG_DM9000_DEBUGLEVEL && \
130 (lev) < db->debug_level) { \
131 dev_dbg(db->dev, msg); \
135 static inline board_info_t
*to_dm9000_board(struct net_device
*dev
)
140 /* function declaration ------------------------------------- */
141 static int dm9000_probe(struct platform_device
*);
142 static int dm9000_open(struct net_device
*);
143 static int dm9000_start_xmit(struct sk_buff
*, struct net_device
*);
144 static int dm9000_stop(struct net_device
*);
146 static void dm9000_init_dm9000(struct net_device
*);
148 static irqreturn_t
dm9000_interrupt(int, void *);
150 static int dm9000_phy_read(struct net_device
*dev
, int phyaddr_unsused
, int reg
);
151 static void dm9000_phy_write(struct net_device
*dev
, int phyaddr_unused
, int reg
,
154 static void dm9000_read_eeprom(board_info_t
*, int addr
, u8
*to
);
155 static void dm9000_write_eeprom(board_info_t
*, int addr
, u8
*dp
);
156 static void dm9000_rx(struct net_device
*);
157 static void dm9000_hash_table(struct net_device
*);
159 /* DM9000 network board routine ---------------------------- */
162 dm9000_reset(board_info_t
* db
)
164 dev_dbg(db
->dev
, "resetting device\n");
167 writeb(DM9000_NCR
, db
->io_addr
);
169 writeb(NCR_RST
, db
->io_data
);
174 * Read a byte from I/O port
177 ior(board_info_t
* db
, int reg
)
179 writeb(reg
, db
->io_addr
);
180 return readb(db
->io_data
);
184 * Write a byte to I/O port
188 iow(board_info_t
* db
, int reg
, int value
)
190 writeb(reg
, db
->io_addr
);
191 writeb(value
, db
->io_data
);
194 /* routines for sending block to chip */
196 static void dm9000_outblk_8bit(void __iomem
*reg
, void *data
, int count
)
198 writesb(reg
, data
, count
);
201 static void dm9000_outblk_16bit(void __iomem
*reg
, void *data
, int count
)
203 writesw(reg
, data
, (count
+1) >> 1);
206 static void dm9000_outblk_32bit(void __iomem
*reg
, void *data
, int count
)
208 writesl(reg
, data
, (count
+3) >> 2);
211 /* input block from chip to memory */
213 static void dm9000_inblk_8bit(void __iomem
*reg
, void *data
, int count
)
215 readsb(reg
, data
, count
);
219 static void dm9000_inblk_16bit(void __iomem
*reg
, void *data
, int count
)
221 readsw(reg
, data
, (count
+1) >> 1);
224 static void dm9000_inblk_32bit(void __iomem
*reg
, void *data
, int count
)
226 readsl(reg
, data
, (count
+3) >> 2);
229 /* dump block from chip to null */
231 static void dm9000_dumpblk_8bit(void __iomem
*reg
, int count
)
236 for (i
= 0; i
< count
; i
++)
240 static void dm9000_dumpblk_16bit(void __iomem
*reg
, int count
)
245 count
= (count
+ 1) >> 1;
247 for (i
= 0; i
< count
; i
++)
251 static void dm9000_dumpblk_32bit(void __iomem
*reg
, int count
)
256 count
= (count
+ 3) >> 2;
258 for (i
= 0; i
< count
; i
++)
264 * select the specified set of io routines to use with the
268 static void dm9000_set_io(struct board_info
*db
, int byte_width
)
270 /* use the size of the data resource to work out what IO
271 * routines we want to use
274 switch (byte_width
) {
276 db
->dumpblk
= dm9000_dumpblk_8bit
;
277 db
->outblk
= dm9000_outblk_8bit
;
278 db
->inblk
= dm9000_inblk_8bit
;
283 dev_dbg(db
->dev
, ": 3 byte IO, falling back to 16bit\n");
285 db
->dumpblk
= dm9000_dumpblk_16bit
;
286 db
->outblk
= dm9000_outblk_16bit
;
287 db
->inblk
= dm9000_inblk_16bit
;
292 db
->dumpblk
= dm9000_dumpblk_32bit
;
293 db
->outblk
= dm9000_outblk_32bit
;
294 db
->inblk
= dm9000_inblk_32bit
;
300 /* Our watchdog timed out. Called by the networking layer */
301 static void dm9000_timeout(struct net_device
*dev
)
303 board_info_t
*db
= (board_info_t
*) dev
->priv
;
307 /* Save previous register address */
308 reg_save
= readb(db
->io_addr
);
309 spin_lock_irqsave(&db
->lock
,flags
);
311 netif_stop_queue(dev
);
313 dm9000_init_dm9000(dev
);
314 /* We can accept TX packets again */
315 dev
->trans_start
= jiffies
;
316 netif_wake_queue(dev
);
318 /* Restore previous register address */
319 writeb(reg_save
, db
->io_addr
);
320 spin_unlock_irqrestore(&db
->lock
,flags
);
323 #ifdef CONFIG_NET_POLL_CONTROLLER
327 static void dm9000_poll_controller(struct net_device
*dev
)
329 disable_irq(dev
->irq
);
330 dm9000_interrupt(dev
->irq
,dev
);
331 enable_irq(dev
->irq
);
337 static void dm9000_get_drvinfo(struct net_device
*dev
,
338 struct ethtool_drvinfo
*info
)
340 board_info_t
*dm
= to_dm9000_board(dev
);
342 strcpy(info
->driver
, CARDNAME
);
343 strcpy(info
->version
, DRV_VERSION
);
344 strcpy(info
->bus_info
, to_platform_device(dm
->dev
)->name
);
347 static u32
dm9000_get_msglevel(struct net_device
*dev
)
349 board_info_t
*dm
= to_dm9000_board(dev
);
351 return dm
->msg_enable
;
354 static void dm9000_set_msglevel(struct net_device
*dev
, u32 value
)
356 board_info_t
*dm
= to_dm9000_board(dev
);
358 dm
->msg_enable
= value
;
361 static int dm9000_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
363 board_info_t
*dm
= to_dm9000_board(dev
);
365 mii_ethtool_gset(&dm
->mii
, cmd
);
369 static int dm9000_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
371 board_info_t
*dm
= to_dm9000_board(dev
);
373 return mii_ethtool_sset(&dm
->mii
, cmd
);
376 static int dm9000_nway_reset(struct net_device
*dev
)
378 board_info_t
*dm
= to_dm9000_board(dev
);
379 return mii_nway_restart(&dm
->mii
);
382 static u32
dm9000_get_link(struct net_device
*dev
)
384 board_info_t
*dm
= to_dm9000_board(dev
);
385 return mii_link_ok(&dm
->mii
);
388 #define DM_EEPROM_MAGIC (0x444D394B)
390 static int dm9000_get_eeprom_len(struct net_device
*dev
)
395 static int dm9000_get_eeprom(struct net_device
*dev
,
396 struct ethtool_eeprom
*ee
, u8
*data
)
398 board_info_t
*dm
= to_dm9000_board(dev
);
399 int offset
= ee
->offset
;
403 /* EEPROM access is aligned to two bytes */
405 if ((len
& 1) != 0 || (offset
& 1) != 0)
408 ee
->magic
= DM_EEPROM_MAGIC
;
410 for (i
= 0; i
< len
; i
+= 2)
411 dm9000_read_eeprom(dm
, (offset
+ i
) / 2, data
+ i
);
416 static int dm9000_set_eeprom(struct net_device
*dev
,
417 struct ethtool_eeprom
*ee
, u8
*data
)
419 board_info_t
*dm
= to_dm9000_board(dev
);
420 int offset
= ee
->offset
;
424 /* EEPROM access is aligned to two bytes */
426 if ((len
& 1) != 0 || (offset
& 1) != 0)
429 if (ee
->magic
!= DM_EEPROM_MAGIC
)
432 for (i
= 0; i
< len
; i
+= 2)
433 dm9000_write_eeprom(dm
, (offset
+ i
) / 2, data
+ i
);
438 static const struct ethtool_ops dm9000_ethtool_ops
= {
439 .get_drvinfo
= dm9000_get_drvinfo
,
440 .get_settings
= dm9000_get_settings
,
441 .set_settings
= dm9000_set_settings
,
442 .get_msglevel
= dm9000_get_msglevel
,
443 .set_msglevel
= dm9000_set_msglevel
,
444 .nway_reset
= dm9000_nway_reset
,
445 .get_link
= dm9000_get_link
,
446 .get_eeprom_len
= dm9000_get_eeprom_len
,
447 .get_eeprom
= dm9000_get_eeprom
,
448 .set_eeprom
= dm9000_set_eeprom
,
452 /* dm9000_release_board
454 * release a board, and any mapped resources
458 dm9000_release_board(struct platform_device
*pdev
, struct board_info
*db
)
460 if (db
->data_res
== NULL
) {
461 if (db
->addr_res
!= NULL
)
462 release_mem_region((unsigned long)db
->io_addr
, 4);
466 /* unmap our resources */
468 iounmap(db
->io_addr
);
469 iounmap(db
->io_data
);
471 /* release the resources */
473 if (db
->data_req
!= NULL
) {
474 release_resource(db
->data_req
);
478 if (db
->addr_req
!= NULL
) {
479 release_resource(db
->addr_req
);
484 #define res_size(_r) (((_r)->end - (_r)->start) + 1)
487 * Search DM9000 board, allocate space and register it
490 dm9000_probe(struct platform_device
*pdev
)
492 struct dm9000_plat_data
*pdata
= pdev
->dev
.platform_data
;
493 struct board_info
*db
; /* Point a board information structure */
494 struct net_device
*ndev
;
501 /* Init network device */
502 ndev
= alloc_etherdev(sizeof (struct board_info
));
504 dev_err(&pdev
->dev
, "could not allocate device.\n");
508 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
510 dev_dbg(&pdev
->dev
, "dm9000_probe()");
512 /* setup board info structure */
513 db
= (struct board_info
*) ndev
->priv
;
514 memset(db
, 0, sizeof (*db
));
516 db
->dev
= &pdev
->dev
;
518 spin_lock_init(&db
->lock
);
519 mutex_init(&db
->addr_lock
);
521 if (pdev
->num_resources
< 2) {
524 } else if (pdev
->num_resources
== 2) {
525 base
= pdev
->resource
[0].start
;
527 if (!request_mem_region(base
, 4, ndev
->name
)) {
532 ndev
->base_addr
= base
;
533 ndev
->irq
= pdev
->resource
[1].start
;
534 db
->io_addr
= (void __iomem
*)base
;
535 db
->io_data
= (void __iomem
*)(base
+ 4);
537 /* ensure at least we have a default set of IO routines */
538 dm9000_set_io(db
, 2);
541 db
->addr_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
542 db
->data_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
543 db
->irq_res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
545 if (db
->addr_res
== NULL
|| db
->data_res
== NULL
||
546 db
->irq_res
== NULL
) {
547 dev_err(db
->dev
, "insufficient resources\n");
552 i
= res_size(db
->addr_res
);
553 db
->addr_req
= request_mem_region(db
->addr_res
->start
, i
,
556 if (db
->addr_req
== NULL
) {
557 dev_err(db
->dev
, "cannot claim address reg area\n");
562 db
->io_addr
= ioremap(db
->addr_res
->start
, i
);
564 if (db
->io_addr
== NULL
) {
565 dev_err(db
->dev
, "failed to ioremap address reg\n");
570 iosize
= res_size(db
->data_res
);
571 db
->data_req
= request_mem_region(db
->data_res
->start
, iosize
,
574 if (db
->data_req
== NULL
) {
575 dev_err(db
->dev
, "cannot claim data reg area\n");
580 db
->io_data
= ioremap(db
->data_res
->start
, iosize
);
582 if (db
->io_data
== NULL
) {
583 dev_err(db
->dev
,"failed to ioremap data reg\n");
588 /* fill in parameters for net-dev structure */
590 ndev
->base_addr
= (unsigned long)db
->io_addr
;
591 ndev
->irq
= db
->irq_res
->start
;
593 /* ensure at least we have a default set of IO routines */
594 dm9000_set_io(db
, iosize
);
597 /* check to see if anything is being over-ridden */
599 /* check to see if the driver wants to over-ride the
600 * default IO width */
602 if (pdata
->flags
& DM9000_PLATF_8BITONLY
)
603 dm9000_set_io(db
, 1);
605 if (pdata
->flags
& DM9000_PLATF_16BITONLY
)
606 dm9000_set_io(db
, 2);
608 if (pdata
->flags
& DM9000_PLATF_32BITONLY
)
609 dm9000_set_io(db
, 4);
611 /* check to see if there are any IO routine
614 if (pdata
->inblk
!= NULL
)
615 db
->inblk
= pdata
->inblk
;
617 if (pdata
->outblk
!= NULL
)
618 db
->outblk
= pdata
->outblk
;
620 if (pdata
->dumpblk
!= NULL
)
621 db
->dumpblk
= pdata
->dumpblk
;
623 db
->flags
= pdata
->flags
;
628 /* try two times, DM9000 sometimes gets the first read wrong */
629 for (i
= 0; i
< 2; i
++) {
630 id_val
= ior(db
, DM9000_VIDL
);
631 id_val
|= (u32
)ior(db
, DM9000_VIDH
) << 8;
632 id_val
|= (u32
)ior(db
, DM9000_PIDL
) << 16;
633 id_val
|= (u32
)ior(db
, DM9000_PIDH
) << 24;
635 if (id_val
== DM9000_ID
)
637 dev_err(db
->dev
, "read wrong id 0x%08x\n", id_val
);
640 if (id_val
!= DM9000_ID
) {
641 dev_err(db
->dev
, "wrong id: 0x%08x\n", id_val
);
646 /* from this point we assume that we have found a DM9000 */
648 /* driver system function */
651 ndev
->open
= &dm9000_open
;
652 ndev
->hard_start_xmit
= &dm9000_start_xmit
;
653 ndev
->tx_timeout
= &dm9000_timeout
;
654 ndev
->watchdog_timeo
= msecs_to_jiffies(watchdog
);
655 ndev
->stop
= &dm9000_stop
;
656 ndev
->set_multicast_list
= &dm9000_hash_table
;
657 ndev
->ethtool_ops
= &dm9000_ethtool_ops
;
659 #ifdef CONFIG_NET_POLL_CONTROLLER
660 ndev
->poll_controller
= &dm9000_poll_controller
;
663 db
->msg_enable
= NETIF_MSG_LINK
;
664 db
->mii
.phy_id_mask
= 0x1f;
665 db
->mii
.reg_num_mask
= 0x1f;
666 db
->mii
.force_media
= 0;
667 db
->mii
.full_duplex
= 0;
669 db
->mii
.mdio_read
= dm9000_phy_read
;
670 db
->mii
.mdio_write
= dm9000_phy_write
;
672 /* try reading the node address from the attached EEPROM */
673 for (i
= 0; i
< 6; i
+= 2)
674 dm9000_read_eeprom(db
, i
/ 2, ndev
->dev_addr
+i
);
676 if (!is_valid_ether_addr(ndev
->dev_addr
)) {
677 /* try reading from mac */
679 for (i
= 0; i
< 6; i
++)
680 ndev
->dev_addr
[i
] = ior(db
, i
+DM9000_PAR
);
683 if (!is_valid_ether_addr(ndev
->dev_addr
))
684 dev_warn(db
->dev
, "%s: Invalid ethernet MAC address. Please "
685 "set using ifconfig\n", ndev
->name
);
687 platform_set_drvdata(pdev
, ndev
);
688 ret
= register_netdev(ndev
);
691 DECLARE_MAC_BUF(mac
);
692 printk("%s: dm9000 at %p,%p IRQ %d MAC: %s\n",
693 ndev
->name
, db
->io_addr
, db
->io_data
, ndev
->irq
,
694 print_mac(mac
, ndev
->dev_addr
));
699 dev_err(db
->dev
, "not found (%d).\n", ret
);
701 dm9000_release_board(pdev
, db
);
708 * Open the interface.
709 * The interface is opened whenever "ifconfig" actives it.
712 dm9000_open(struct net_device
*dev
)
714 board_info_t
*db
= (board_info_t
*) dev
->priv
;
715 unsigned long irqflags
= db
->irq_res
->flags
& IRQF_TRIGGER_MASK
;
717 if (netif_msg_ifup(db
))
718 dev_dbg(db
->dev
, "enabling %s\n", dev
->name
);
720 /* If there is no IRQ type specified, default to something that
721 * may work, and tell the user that this is a problem */
723 if (irqflags
== IRQF_TRIGGER_NONE
) {
724 dev_warn(db
->dev
, "WARNING: no IRQ resource flags set.\n");
725 irqflags
= DEFAULT_TRIGGER
;
728 irqflags
|= IRQF_SHARED
;
730 if (request_irq(dev
->irq
, &dm9000_interrupt
, irqflags
, dev
->name
, dev
))
733 /* Initialize DM9000 board */
735 dm9000_init_dm9000(dev
);
737 /* Init driver variable */
740 mii_check_media(&db
->mii
, netif_msg_link(db
), 1);
741 netif_start_queue(dev
);
747 * Initilize dm9000 board
750 dm9000_init_dm9000(struct net_device
*dev
)
752 board_info_t
*db
= (board_info_t
*) dev
->priv
;
754 dm9000_dbg(db
, 1, "entering %s\n", __func__
);
757 db
->io_mode
= ior(db
, DM9000_ISR
) >> 6; /* ISR bit7:6 keeps I/O mode */
759 /* GPIO0 on pre-activate PHY */
760 iow(db
, DM9000_GPR
, 0); /* REG_1F bit0 activate phyxcer */
761 iow(db
, DM9000_GPCR
, GPCR_GEP_CNTL
); /* Let GPIO0 output */
762 iow(db
, DM9000_GPR
, 0); /* Enable PHY */
764 if (db
->flags
& DM9000_PLATF_EXT_PHY
)
765 iow(db
, DM9000_NCR
, NCR_EXT_PHY
);
767 /* Program operating register */
768 iow(db
, DM9000_TCR
, 0); /* TX Polling clear */
769 iow(db
, DM9000_BPTR
, 0x3f); /* Less 3Kb, 200us */
770 iow(db
, DM9000_FCR
, 0xff); /* Flow Control */
771 iow(db
, DM9000_SMCR
, 0); /* Special Mode */
772 /* clear TX status */
773 iow(db
, DM9000_NSR
, NSR_WAKEST
| NSR_TX2END
| NSR_TX1END
);
774 iow(db
, DM9000_ISR
, ISR_CLR_STATUS
); /* Clear interrupt status */
776 /* Set address filter table */
777 dm9000_hash_table(dev
);
779 /* Activate DM9000 */
780 iow(db
, DM9000_RCR
, RCR_DIS_LONG
| RCR_DIS_CRC
| RCR_RXEN
);
781 /* Enable TX/RX interrupt mask */
782 iow(db
, DM9000_IMR
, IMR_PAR
| IMR_PTM
| IMR_PRM
);
784 /* Init Driver variable */
786 db
->queue_pkt_len
= 0;
787 dev
->trans_start
= 0;
791 * Hardware start transmission.
792 * Send a packet to media from the upper layer.
795 dm9000_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
798 board_info_t
*db
= (board_info_t
*) dev
->priv
;
800 dm9000_dbg(db
, 3, "%s:\n", __func__
);
802 if (db
->tx_pkt_cnt
> 1)
805 spin_lock_irqsave(&db
->lock
, flags
);
807 /* Move data to DM9000 TX RAM */
808 writeb(DM9000_MWCMD
, db
->io_addr
);
810 (db
->outblk
)(db
->io_data
, skb
->data
, skb
->len
);
811 dev
->stats
.tx_bytes
+= skb
->len
;
814 /* TX control: First packet immediately send, second packet queue */
815 if (db
->tx_pkt_cnt
== 1) {
816 /* Set TX length to DM9000 */
817 iow(db
, DM9000_TXPLL
, skb
->len
& 0xff);
818 iow(db
, DM9000_TXPLH
, (skb
->len
>> 8) & 0xff);
820 /* Issue TX polling command */
821 iow(db
, DM9000_TCR
, TCR_TXREQ
); /* Cleared after TX complete */
823 dev
->trans_start
= jiffies
; /* save the time stamp */
826 db
->queue_pkt_len
= skb
->len
;
827 netif_stop_queue(dev
);
830 spin_unlock_irqrestore(&db
->lock
, flags
);
839 dm9000_shutdown(struct net_device
*dev
)
841 board_info_t
*db
= (board_info_t
*) dev
->priv
;
844 dm9000_phy_write(dev
, 0, MII_BMCR
, BMCR_RESET
); /* PHY RESET */
845 iow(db
, DM9000_GPR
, 0x01); /* Power-Down PHY */
846 iow(db
, DM9000_IMR
, IMR_PAR
); /* Disable all interrupt */
847 iow(db
, DM9000_RCR
, 0x00); /* Disable RX */
851 * Stop the interface.
852 * The interface is stopped when it is brought.
855 dm9000_stop(struct net_device
*ndev
)
857 board_info_t
*db
= (board_info_t
*) ndev
->priv
;
859 if (netif_msg_ifdown(db
))
860 dev_dbg(db
->dev
, "shutting down %s\n", ndev
->name
);
862 netif_stop_queue(ndev
);
863 netif_carrier_off(ndev
);
866 free_irq(ndev
->irq
, ndev
);
868 dm9000_shutdown(ndev
);
874 * DM9000 interrupt handler
875 * receive the packet to upper layer, free the transmitted packet
879 dm9000_tx_done(struct net_device
*dev
, board_info_t
* db
)
881 int tx_status
= ior(db
, DM9000_NSR
); /* Got TX status */
883 if (tx_status
& (NSR_TX2END
| NSR_TX1END
)) {
884 /* One packet sent complete */
886 dev
->stats
.tx_packets
++;
888 if (netif_msg_tx_done(db
))
889 dev_dbg(db
->dev
, "tx done, NSR %02x\n", tx_status
);
891 /* Queue packet check & send */
892 if (db
->tx_pkt_cnt
> 0) {
893 iow(db
, DM9000_TXPLL
, db
->queue_pkt_len
& 0xff);
894 iow(db
, DM9000_TXPLH
, (db
->queue_pkt_len
>> 8) & 0xff);
895 iow(db
, DM9000_TCR
, TCR_TXREQ
);
896 dev
->trans_start
= jiffies
;
898 netif_wake_queue(dev
);
903 dm9000_interrupt(int irq
, void *dev_id
)
905 struct net_device
*dev
= dev_id
;
906 board_info_t
*db
= (board_info_t
*) dev
->priv
;
910 dm9000_dbg(db
, 3, "entering %s\n", __func__
);
912 /* A real interrupt coming */
914 spin_lock(&db
->lock
);
916 /* Save previous register address */
917 reg_save
= readb(db
->io_addr
);
919 /* Disable all interrupts */
920 iow(db
, DM9000_IMR
, IMR_PAR
);
922 /* Got DM9000 interrupt status */
923 int_status
= ior(db
, DM9000_ISR
); /* Got ISR */
924 iow(db
, DM9000_ISR
, int_status
); /* Clear ISR status */
926 if (netif_msg_intr(db
))
927 dev_dbg(db
->dev
, "interrupt status %02x\n", int_status
);
929 /* Received the coming packet */
930 if (int_status
& ISR_PRS
)
933 /* Trnasmit Interrupt check */
934 if (int_status
& ISR_PTS
)
935 dm9000_tx_done(dev
, db
);
937 /* Re-enable interrupt mask */
938 iow(db
, DM9000_IMR
, IMR_PAR
| IMR_PTM
| IMR_PRM
);
940 /* Restore previous register address */
941 writeb(reg_save
, db
->io_addr
);
943 spin_unlock(&db
->lock
);
948 struct dm9000_rxhdr
{
952 } __attribute__((__packed__
));
955 * Received a packet and pass to upper layer
958 dm9000_rx(struct net_device
*dev
)
960 board_info_t
*db
= (board_info_t
*) dev
->priv
;
961 struct dm9000_rxhdr rxhdr
;
967 /* Check packet ready or not */
969 ior(db
, DM9000_MRCMDX
); /* Dummy read */
971 /* Get most updated data */
972 rxbyte
= readb(db
->io_data
);
974 /* Status check: this byte must be 0 or 1 */
975 if (rxbyte
> DM9000_PKT_RDY
) {
976 dev_warn(db
->dev
, "status check fail: %d\n", rxbyte
);
977 iow(db
, DM9000_RCR
, 0x00); /* Stop Device */
978 iow(db
, DM9000_ISR
, IMR_PAR
); /* Stop INT request */
982 if (rxbyte
!= DM9000_PKT_RDY
)
985 /* A packet ready now & Get status/length */
987 writeb(DM9000_MRCMD
, db
->io_addr
);
989 (db
->inblk
)(db
->io_data
, &rxhdr
, sizeof(rxhdr
));
991 RxLen
= le16_to_cpu(rxhdr
.RxLen
);
993 if (netif_msg_rx_status(db
))
994 dev_dbg(db
->dev
, "RX: status %02x, length %04x\n",
995 rxhdr
.RxStatus
, RxLen
);
997 /* Packet Status check */
1000 if (netif_msg_rx_err(db
))
1001 dev_dbg(db
->dev
, "RX: Bad Packet (runt)\n");
1004 if (RxLen
> DM9000_PKT_MAX
) {
1005 dev_dbg(db
->dev
, "RST: RX Len:%x\n", RxLen
);
1008 if (rxhdr
.RxStatus
& 0xbf) {
1010 if (rxhdr
.RxStatus
& 0x01) {
1011 if (netif_msg_rx_err(db
))
1012 dev_dbg(db
->dev
, "fifo error\n");
1013 dev
->stats
.rx_fifo_errors
++;
1015 if (rxhdr
.RxStatus
& 0x02) {
1016 if (netif_msg_rx_err(db
))
1017 dev_dbg(db
->dev
, "crc error\n");
1018 dev
->stats
.rx_crc_errors
++;
1020 if (rxhdr
.RxStatus
& 0x80) {
1021 if (netif_msg_rx_err(db
))
1022 dev_dbg(db
->dev
, "length error\n");
1023 dev
->stats
.rx_length_errors
++;
1027 /* Move data from DM9000 */
1029 && ((skb
= dev_alloc_skb(RxLen
+ 4)) != NULL
)) {
1030 skb_reserve(skb
, 2);
1031 rdptr
= (u8
*) skb_put(skb
, RxLen
- 4);
1033 /* Read received packet from RX SRAM */
1035 (db
->inblk
)(db
->io_data
, rdptr
, RxLen
);
1036 dev
->stats
.rx_bytes
+= RxLen
;
1038 /* Pass to upper layer */
1039 skb
->protocol
= eth_type_trans(skb
, dev
);
1041 dev
->stats
.rx_packets
++;
1044 /* need to dump the packet's data */
1046 (db
->dumpblk
)(db
->io_data
, RxLen
);
1048 } while (rxbyte
== DM9000_PKT_RDY
);
1052 dm9000_read_locked(board_info_t
*db
, int reg
)
1054 unsigned long flags
;
1057 spin_lock_irqsave(&db
->lock
, flags
);
1059 spin_unlock_irqrestore(&db
->lock
, flags
);
1064 static int dm9000_wait_eeprom(board_info_t
*db
)
1066 unsigned int status
;
1067 int timeout
= 8; /* wait max 8msec */
1069 /* The DM9000 data sheets say we should be able to
1070 * poll the ERRE bit in EPCR to wait for the EEPROM
1071 * operation. From testing several chips, this bit
1072 * does not seem to work.
1074 * We attempt to use the bit, but fall back to the
1075 * timeout (which is why we do not return an error
1076 * on expiry) to say that the EEPROM operation has
1081 status
= dm9000_read_locked(db
, DM9000_EPCR
);
1083 if ((status
& EPCR_ERRE
) == 0)
1086 if (timeout
-- < 0) {
1087 dev_dbg(db
->dev
, "timeout waiting EEPROM\n");
1096 * Read a word data from EEPROM
1099 dm9000_read_eeprom(board_info_t
*db
, int offset
, u8
*to
)
1101 unsigned long flags
;
1103 mutex_lock(&db
->addr_lock
);
1105 spin_lock_irqsave(&db
->lock
, flags
);
1107 iow(db
, DM9000_EPAR
, offset
);
1108 iow(db
, DM9000_EPCR
, EPCR_ERPRR
);
1110 spin_unlock_irqrestore(&db
->lock
, flags
);
1112 dm9000_wait_eeprom(db
);
1114 /* delay for at-least 150uS */
1117 spin_lock_irqsave(&db
->lock
, flags
);
1119 iow(db
, DM9000_EPCR
, 0x0);
1121 to
[0] = ior(db
, DM9000_EPDRL
);
1122 to
[1] = ior(db
, DM9000_EPDRH
);
1124 spin_unlock_irqrestore(&db
->lock
, flags
);
1126 mutex_unlock(&db
->addr_lock
);
1130 * Write a word data to SROM
1133 dm9000_write_eeprom(board_info_t
*db
, int offset
, u8
*data
)
1135 unsigned long flags
;
1137 mutex_lock(&db
->addr_lock
);
1139 spin_lock_irqsave(&db
->lock
, flags
);
1140 iow(db
, DM9000_EPAR
, offset
);
1141 iow(db
, DM9000_EPDRH
, data
[1]);
1142 iow(db
, DM9000_EPDRL
, data
[0]);
1143 iow(db
, DM9000_EPCR
, EPCR_WEP
| EPCR_ERPRW
);
1144 spin_unlock_irqrestore(&db
->lock
, flags
);
1146 dm9000_wait_eeprom(db
);
1148 mdelay(1); /* wait at least 150uS to clear */
1150 spin_lock_irqsave(&db
->lock
, flags
);
1151 iow(db
, DM9000_EPCR
, 0);
1152 spin_unlock_irqrestore(&db
->lock
, flags
);
1154 mutex_unlock(&db
->addr_lock
);
1158 * Calculate the CRC valude of the Rx packet
1159 * flag = 1 : return the reverse CRC (for the received packet CRC)
1160 * 0 : return the normal CRC (for Hash Table index)
1163 static unsigned long
1164 cal_CRC(unsigned char *Data
, unsigned int Len
, u8 flag
)
1167 u32 crc
= ether_crc_le(Len
, Data
);
1176 * Set DM9000 multicast address
1179 dm9000_hash_table(struct net_device
*dev
)
1181 board_info_t
*db
= (board_info_t
*) dev
->priv
;
1182 struct dev_mc_list
*mcptr
= dev
->mc_list
;
1183 int mc_cnt
= dev
->mc_count
;
1185 u16 i
, oft
, hash_table
[4];
1186 unsigned long flags
;
1188 dm9000_dbg(db
, 1, "entering %s\n", __func__
);
1190 spin_lock_irqsave(&db
->lock
,flags
);
1192 for (i
= 0, oft
= 0x10; i
< 6; i
++, oft
++)
1193 iow(db
, oft
, dev
->dev_addr
[i
]);
1195 /* Clear Hash Table */
1196 for (i
= 0; i
< 4; i
++)
1197 hash_table
[i
] = 0x0;
1199 /* broadcast address */
1200 hash_table
[3] = 0x8000;
1202 /* the multicast address in Hash Table : 64 bits */
1203 for (i
= 0; i
< mc_cnt
; i
++, mcptr
= mcptr
->next
) {
1204 hash_val
= cal_CRC((char *) mcptr
->dmi_addr
, 6, 0) & 0x3f;
1205 hash_table
[hash_val
/ 16] |= (u16
) 1 << (hash_val
% 16);
1208 /* Write the hash table to MAC MD table */
1209 for (i
= 0, oft
= 0x16; i
< 4; i
++) {
1210 iow(db
, oft
++, hash_table
[i
] & 0xff);
1211 iow(db
, oft
++, (hash_table
[i
] >> 8) & 0xff);
1214 spin_unlock_irqrestore(&db
->lock
,flags
);
1219 * Sleep, either by using msleep() or if we are suspending, then
1220 * use mdelay() to sleep.
1222 static void dm9000_msleep(board_info_t
*db
, unsigned int ms
)
1231 * Read a word from phyxcer
1234 dm9000_phy_read(struct net_device
*dev
, int phy_reg_unused
, int reg
)
1236 board_info_t
*db
= (board_info_t
*) dev
->priv
;
1237 unsigned long flags
;
1238 unsigned int reg_save
;
1241 mutex_lock(&db
->addr_lock
);
1243 spin_lock_irqsave(&db
->lock
,flags
);
1245 /* Save previous register address */
1246 reg_save
= readb(db
->io_addr
);
1248 /* Fill the phyxcer register into REG_0C */
1249 iow(db
, DM9000_EPAR
, DM9000_PHY
| reg
);
1251 iow(db
, DM9000_EPCR
, 0xc); /* Issue phyxcer read command */
1253 writeb(reg_save
, db
->io_addr
);
1254 spin_unlock_irqrestore(&db
->lock
,flags
);
1256 dm9000_msleep(db
, 1); /* Wait read complete */
1258 spin_lock_irqsave(&db
->lock
,flags
);
1259 reg_save
= readb(db
->io_addr
);
1261 iow(db
, DM9000_EPCR
, 0x0); /* Clear phyxcer read command */
1263 /* The read data keeps on REG_0D & REG_0E */
1264 ret
= (ior(db
, DM9000_EPDRH
) << 8) | ior(db
, DM9000_EPDRL
);
1266 /* restore the previous address */
1267 writeb(reg_save
, db
->io_addr
);
1268 spin_unlock_irqrestore(&db
->lock
,flags
);
1270 mutex_unlock(&db
->addr_lock
);
1275 * Write a word to phyxcer
1278 dm9000_phy_write(struct net_device
*dev
, int phyaddr_unused
, int reg
, int value
)
1280 board_info_t
*db
= (board_info_t
*) dev
->priv
;
1281 unsigned long flags
;
1282 unsigned long reg_save
;
1284 mutex_lock(&db
->addr_lock
);
1286 spin_lock_irqsave(&db
->lock
,flags
);
1288 /* Save previous register address */
1289 reg_save
= readb(db
->io_addr
);
1291 /* Fill the phyxcer register into REG_0C */
1292 iow(db
, DM9000_EPAR
, DM9000_PHY
| reg
);
1294 /* Fill the written data into REG_0D & REG_0E */
1295 iow(db
, DM9000_EPDRL
, (value
& 0xff));
1296 iow(db
, DM9000_EPDRH
, ((value
>> 8) & 0xff));
1298 iow(db
, DM9000_EPCR
, 0xa); /* Issue phyxcer write command */
1300 writeb(reg_save
, db
->io_addr
);
1301 spin_unlock_irqrestore(&db
->lock
, flags
);
1303 dm9000_msleep(db
, 1); /* Wait write complete */
1305 spin_lock_irqsave(&db
->lock
,flags
);
1306 reg_save
= readb(db
->io_addr
);
1308 iow(db
, DM9000_EPCR
, 0x0); /* Clear phyxcer write command */
1310 /* restore the previous address */
1311 writeb(reg_save
, db
->io_addr
);
1313 spin_unlock_irqrestore(&db
->lock
, flags
);
1314 mutex_unlock(&db
->addr_lock
);
1318 dm9000_drv_suspend(struct platform_device
*dev
, pm_message_t state
)
1320 struct net_device
*ndev
= platform_get_drvdata(dev
);
1324 db
= (board_info_t
*) ndev
->priv
;
1327 if (netif_running(ndev
)) {
1328 netif_device_detach(ndev
);
1329 dm9000_shutdown(ndev
);
1336 dm9000_drv_resume(struct platform_device
*dev
)
1338 struct net_device
*ndev
= platform_get_drvdata(dev
);
1339 board_info_t
*db
= (board_info_t
*) ndev
->priv
;
1343 if (netif_running(ndev
)) {
1345 dm9000_init_dm9000(ndev
);
1347 netif_device_attach(ndev
);
1356 dm9000_drv_remove(struct platform_device
*pdev
)
1358 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1360 platform_set_drvdata(pdev
, NULL
);
1362 unregister_netdev(ndev
);
1363 dm9000_release_board(pdev
, (board_info_t
*) ndev
->priv
);
1364 free_netdev(ndev
); /* free device structure */
1366 dev_dbg(&pdev
->dev
, "released and freed device\n");
1370 static struct platform_driver dm9000_driver
= {
1373 .owner
= THIS_MODULE
,
1375 .probe
= dm9000_probe
,
1376 .remove
= dm9000_drv_remove
,
1377 .suspend
= dm9000_drv_suspend
,
1378 .resume
= dm9000_drv_resume
,
1384 printk(KERN_INFO
"%s Ethernet Driver, V%s\n", CARDNAME
, DRV_VERSION
);
1386 return platform_driver_register(&dm9000_driver
); /* search board and register */
1390 dm9000_cleanup(void)
1392 platform_driver_unregister(&dm9000_driver
);
1395 module_init(dm9000_init
);
1396 module_exit(dm9000_cleanup
);
1398 MODULE_AUTHOR("Sascha Hauer, Ben Dooks");
1399 MODULE_DESCRIPTION("Davicom DM9000 network driver");
1400 MODULE_LICENSE("GPL");