aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/dm9000.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/net/dm9000.c')
-rw-r--r--drivers/net/dm9000.c1159
1 files changed, 600 insertions, 559 deletions
diff --git a/drivers/net/dm9000.c b/drivers/net/dm9000.c
index 08a7365a7d10..952e10d686ec 100644
--- a/drivers/net/dm9000.c
+++ b/drivers/net/dm9000.c
@@ -44,9 +44,8 @@
44 44
45#define DM9000_PHY 0x40 /* PHY address 0x01 */ 45#define DM9000_PHY 0x40 /* PHY address 0x01 */
46 46
47#define CARDNAME "dm9000" 47#define CARDNAME "dm9000"
48#define PFX CARDNAME ": " 48#define DRV_VERSION "1.31"
49#define DRV_VERSION "1.30"
50 49
51#ifdef CONFIG_BLACKFIN 50#ifdef CONFIG_BLACKFIN
52#define readsb insb 51#define readsb insb
@@ -55,9 +54,6 @@
55#define writesb outsb 54#define writesb outsb
56#define writesw outsw 55#define writesw outsw
57#define writesl outsl 56#define writesl outsl
58#define DEFAULT_TRIGGER IRQF_TRIGGER_HIGH
59#else
60#define DEFAULT_TRIGGER (0)
61#endif 57#endif
62 58
63/* 59/*
@@ -85,23 +81,36 @@ MODULE_PARM_DESC(watchdog, "transmit timeout in milliseconds");
85 * these two devices. 81 * these two devices.
86 */ 82 */
87 83
84/* The driver supports the original DM9000E, and now the two newer
85 * devices, DM9000A and DM9000B.
86 */
87
88enum dm9000_type {
89 TYPE_DM9000E, /* original DM9000 */
90 TYPE_DM9000A,
91 TYPE_DM9000B
92};
93
88/* Structure/enum declaration ------------------------------- */ 94/* Structure/enum declaration ------------------------------- */
89typedef struct board_info { 95typedef struct board_info {
90 96
91 void __iomem *io_addr; /* Register I/O base address */ 97 void __iomem *io_addr; /* Register I/O base address */
92 void __iomem *io_data; /* Data I/O address */ 98 void __iomem *io_data; /* Data I/O address */
93 u16 irq; /* IRQ */ 99 u16 irq; /* IRQ */
94 100
95 u16 tx_pkt_cnt; 101 u16 tx_pkt_cnt;
96 u16 queue_pkt_len; 102 u16 queue_pkt_len;
97 u16 queue_start_addr; 103 u16 queue_start_addr;
98 u16 dbug_cnt; 104 u16 dbug_cnt;
99 u8 io_mode; /* 0:word, 2:byte */ 105 u8 io_mode; /* 0:word, 2:byte */
100 u8 phy_addr; 106 u8 phy_addr;
101 unsigned int flags; 107 u8 imr_all;
102 unsigned int in_suspend :1;
103 108
104 int debug_level; 109 unsigned int flags;
110 unsigned int in_suspend :1;
111 int debug_level;
112
113 enum dm9000_type type;
105 114
106 void (*inblk)(void __iomem *port, void *data, int length); 115 void (*inblk)(void __iomem *port, void *data, int length);
107 void (*outblk)(void __iomem *port, void *data, int length); 116 void (*outblk)(void __iomem *port, void *data, int length);
@@ -120,10 +129,10 @@ typedef struct board_info {
120 struct delayed_work phy_poll; 129 struct delayed_work phy_poll;
121 struct net_device *ndev; 130 struct net_device *ndev;
122 131
123 spinlock_t lock; 132 spinlock_t lock;
124 133
125 struct mii_if_info mii; 134 struct mii_if_info mii;
126 u32 msg_enable; 135 u32 msg_enable;
127} board_info_t; 136} board_info_t;
128 137
129/* debug code */ 138/* debug code */
@@ -140,26 +149,6 @@ static inline board_info_t *to_dm9000_board(struct net_device *dev)
140 return dev->priv; 149 return dev->priv;
141} 150}
142 151
143/* function declaration ------------------------------------- */
144static int dm9000_probe(struct platform_device *);
145static int dm9000_open(struct net_device *);
146static int dm9000_start_xmit(struct sk_buff *, struct net_device *);
147static int dm9000_stop(struct net_device *);
148static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd);
149
150static void dm9000_init_dm9000(struct net_device *);
151
152static irqreturn_t dm9000_interrupt(int, void *);
153
154static int dm9000_phy_read(struct net_device *dev, int phyaddr_unsused, int reg);
155static void dm9000_phy_write(struct net_device *dev, int phyaddr_unused, int reg,
156 int value);
157
158static void dm9000_read_eeprom(board_info_t *, int addr, u8 *to);
159static void dm9000_write_eeprom(board_info_t *, int addr, u8 *dp);
160static void dm9000_rx(struct net_device *);
161static void dm9000_hash_table(struct net_device *);
162
163/* DM9000 network board routine ---------------------------- */ 152/* DM9000 network board routine ---------------------------- */
164 153
165static void 154static void
@@ -302,52 +291,135 @@ static void dm9000_set_io(struct board_info *db, int byte_width)
302 291
303static void dm9000_schedule_poll(board_info_t *db) 292static void dm9000_schedule_poll(board_info_t *db)
304{ 293{
305 schedule_delayed_work(&db->phy_poll, HZ * 2); 294 if (db->type == TYPE_DM9000E)
295 schedule_delayed_work(&db->phy_poll, HZ * 2);
306} 296}
307 297
308/* Our watchdog timed out. Called by the networking layer */ 298static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
309static void dm9000_timeout(struct net_device *dev) 299{
300 board_info_t *dm = to_dm9000_board(dev);
301
302 if (!netif_running(dev))
303 return -EINVAL;
304
305 return generic_mii_ioctl(&dm->mii, if_mii(req), cmd, NULL);
306}
307
308static unsigned int
309dm9000_read_locked(board_info_t *db, int reg)
310{ 310{
311 board_info_t *db = (board_info_t *) dev->priv;
312 u8 reg_save;
313 unsigned long flags; 311 unsigned long flags;
312 unsigned int ret;
314 313
315 /* Save previous register address */ 314 spin_lock_irqsave(&db->lock, flags);
316 reg_save = readb(db->io_addr); 315 ret = ior(db, reg);
317 spin_lock_irqsave(&db->lock,flags); 316 spin_unlock_irqrestore(&db->lock, flags);
318 317
319 netif_stop_queue(dev); 318 return ret;
320 dm9000_reset(db); 319}
321 dm9000_init_dm9000(dev);
322 /* We can accept TX packets again */
323 dev->trans_start = jiffies;
324 netif_wake_queue(dev);
325 320
326 /* Restore previous register address */ 321static int dm9000_wait_eeprom(board_info_t *db)
327 writeb(reg_save, db->io_addr); 322{
328 spin_unlock_irqrestore(&db->lock,flags); 323 unsigned int status;
324 int timeout = 8; /* wait max 8msec */
325
326 /* The DM9000 data sheets say we should be able to
327 * poll the ERRE bit in EPCR to wait for the EEPROM
328 * operation. From testing several chips, this bit
329 * does not seem to work.
330 *
331 * We attempt to use the bit, but fall back to the
332 * timeout (which is why we do not return an error
333 * on expiry) to say that the EEPROM operation has
334 * completed.
335 */
336
337 while (1) {
338 status = dm9000_read_locked(db, DM9000_EPCR);
339
340 if ((status & EPCR_ERRE) == 0)
341 break;
342
343 msleep(1);
344
345 if (timeout-- < 0) {
346 dev_dbg(db->dev, "timeout waiting EEPROM\n");
347 break;
348 }
349 }
350
351 return 0;
329} 352}
330 353
331#ifdef CONFIG_NET_POLL_CONTROLLER
332/* 354/*
333 *Used by netconsole 355 * Read a word data from EEPROM
334 */ 356 */
335static void dm9000_poll_controller(struct net_device *dev) 357static void
358dm9000_read_eeprom(board_info_t *db, int offset, u8 *to)
336{ 359{
337 disable_irq(dev->irq); 360 unsigned long flags;
338 dm9000_interrupt(dev->irq,dev); 361
339 enable_irq(dev->irq); 362 if (db->flags & DM9000_PLATF_NO_EEPROM) {
363 to[0] = 0xff;
364 to[1] = 0xff;
365 return;
366 }
367
368 mutex_lock(&db->addr_lock);
369
370 spin_lock_irqsave(&db->lock, flags);
371
372 iow(db, DM9000_EPAR, offset);
373 iow(db, DM9000_EPCR, EPCR_ERPRR);
374
375 spin_unlock_irqrestore(&db->lock, flags);
376
377 dm9000_wait_eeprom(db);
378
379 /* delay for at-least 150uS */
380 msleep(1);
381
382 spin_lock_irqsave(&db->lock, flags);
383
384 iow(db, DM9000_EPCR, 0x0);
385
386 to[0] = ior(db, DM9000_EPDRL);
387 to[1] = ior(db, DM9000_EPDRH);
388
389 spin_unlock_irqrestore(&db->lock, flags);
390
391 mutex_unlock(&db->addr_lock);
340} 392}
341#endif
342 393
343static int dm9000_ioctl(struct net_device *dev, struct ifreq *req, int cmd) 394/*
395 * Write a word data to SROM
396 */
397static void
398dm9000_write_eeprom(board_info_t *db, int offset, u8 *data)
344{ 399{
345 board_info_t *dm = to_dm9000_board(dev); 400 unsigned long flags;
346 401
347 if (!netif_running(dev)) 402 if (db->flags & DM9000_PLATF_NO_EEPROM)
348 return -EINVAL; 403 return;
349 404
350 return generic_mii_ioctl(&dm->mii, if_mii(req), cmd, NULL); 405 mutex_lock(&db->addr_lock);
406
407 spin_lock_irqsave(&db->lock, flags);
408 iow(db, DM9000_EPAR, offset);
409 iow(db, DM9000_EPDRH, data[1]);
410 iow(db, DM9000_EPDRL, data[0]);
411 iow(db, DM9000_EPCR, EPCR_WEP | EPCR_ERPRW);
412 spin_unlock_irqrestore(&db->lock, flags);
413
414 dm9000_wait_eeprom(db);
415
416 mdelay(1); /* wait at least 150uS to clear */
417
418 spin_lock_irqsave(&db->lock, flags);
419 iow(db, DM9000_EPCR, 0);
420 spin_unlock_irqrestore(&db->lock, flags);
421
422 mutex_unlock(&db->addr_lock);
351} 423}
352 424
353/* ethtool ops */ 425/* ethtool ops */
@@ -400,7 +472,14 @@ static int dm9000_nway_reset(struct net_device *dev)
400static u32 dm9000_get_link(struct net_device *dev) 472static u32 dm9000_get_link(struct net_device *dev)
401{ 473{
402 board_info_t *dm = to_dm9000_board(dev); 474 board_info_t *dm = to_dm9000_board(dev);
403 return mii_link_ok(&dm->mii); 475 u32 ret;
476
477 if (dm->flags & DM9000_PLATF_EXT_PHY)
478 ret = mii_link_ok(&dm->mii);
479 else
480 ret = dm9000_read_locked(dm, DM9000_NSR) & NSR_LINKST ? 1 : 0;
481
482 return ret;
404} 483}
405 484
406#define DM_EEPROM_MAGIC (0x444D394B) 485#define DM_EEPROM_MAGIC (0x444D394B)
@@ -472,15 +551,48 @@ static const struct ethtool_ops dm9000_ethtool_ops = {
472 .set_eeprom = dm9000_set_eeprom, 551 .set_eeprom = dm9000_set_eeprom,
473}; 552};
474 553
554static void dm9000_show_carrier(board_info_t *db,
555 unsigned carrier, unsigned nsr)
556{
557 struct net_device *ndev = db->ndev;
558 unsigned ncr = dm9000_read_locked(db, DM9000_NCR);
559
560 if (carrier)
561 dev_info(db->dev, "%s: link up, %dMbps, %s-duplex, no LPA\n",
562 ndev->name, (nsr & NSR_SPEED) ? 10 : 100,
563 (ncr & NCR_FDX) ? "full" : "half");
564 else
565 dev_info(db->dev, "%s: link down\n", ndev->name);
566}
567
475static void 568static void
476dm9000_poll_work(struct work_struct *w) 569dm9000_poll_work(struct work_struct *w)
477{ 570{
478 struct delayed_work *dw = container_of(w, struct delayed_work, work); 571 struct delayed_work *dw = container_of(w, struct delayed_work, work);
479 board_info_t *db = container_of(dw, board_info_t, phy_poll); 572 board_info_t *db = container_of(dw, board_info_t, phy_poll);
573 struct net_device *ndev = db->ndev;
574
575 if (db->flags & DM9000_PLATF_SIMPLE_PHY &&
576 !(db->flags & DM9000_PLATF_EXT_PHY)) {
577 unsigned nsr = dm9000_read_locked(db, DM9000_NSR);
578 unsigned old_carrier = netif_carrier_ok(ndev) ? 1 : 0;
579 unsigned new_carrier;
480 580
481 mii_check_media(&db->mii, netif_msg_link(db), 0); 581 new_carrier = (nsr & NSR_LINKST) ? 1 : 0;
582
583 if (old_carrier != new_carrier) {
584 if (netif_msg_link(db))
585 dm9000_show_carrier(db, new_carrier, nsr);
586
587 if (!new_carrier)
588 netif_carrier_off(ndev);
589 else
590 netif_carrier_on(ndev);
591 }
592 } else
593 mii_check_media(&db->mii, netif_msg_link(db), 0);
482 594
483 if (netif_running(db->ndev)) 595 if (netif_running(ndev))
484 dm9000_schedule_poll(db); 596 dm9000_schedule_poll(db);
485} 597}
486 598
@@ -492,12 +604,6 @@ dm9000_poll_work(struct work_struct *w)
492static void 604static void
493dm9000_release_board(struct platform_device *pdev, struct board_info *db) 605dm9000_release_board(struct platform_device *pdev, struct board_info *db)
494{ 606{
495 if (db->data_res == NULL) {
496 if (db->addr_res != NULL)
497 release_mem_region((unsigned long)db->io_addr, 4);
498 return;
499 }
500
501 /* unmap our resources */ 607 /* unmap our resources */
502 608
503 iounmap(db->io_addr); 609 iounmap(db->io_addr);
@@ -505,288 +611,73 @@ dm9000_release_board(struct platform_device *pdev, struct board_info *db)
505 611
506 /* release the resources */ 612 /* release the resources */
507 613
508 if (db->data_req != NULL) { 614 release_resource(db->data_req);
509 release_resource(db->data_req); 615 kfree(db->data_req);
510 kfree(db->data_req);
511 }
512 616
513 if (db->addr_req != NULL) { 617 release_resource(db->addr_req);
514 release_resource(db->addr_req); 618 kfree(db->addr_req);
515 kfree(db->addr_req);
516 }
517} 619}
518 620
519#define res_size(_r) (((_r)->end - (_r)->start) + 1) 621static unsigned char dm9000_type_to_char(enum dm9000_type type)
520
521/*
522 * Search DM9000 board, allocate space and register it
523 */
524static int __devinit
525dm9000_probe(struct platform_device *pdev)
526{ 622{
527 struct dm9000_plat_data *pdata = pdev->dev.platform_data; 623 switch (type) {
528 struct board_info *db; /* Point a board information structure */ 624 case TYPE_DM9000E: return 'e';
529 struct net_device *ndev; 625 case TYPE_DM9000A: return 'a';
530 const unsigned char *mac_src; 626 case TYPE_DM9000B: return 'b';
531 unsigned long base;
532 int ret = 0;
533 int iosize;
534 int i;
535 u32 id_val;
536
537 /* Init network device */
538 ndev = alloc_etherdev(sizeof (struct board_info));
539 if (!ndev) {
540 dev_err(&pdev->dev, "could not allocate device.\n");
541 return -ENOMEM;
542 }
543
544 SET_NETDEV_DEV(ndev, &pdev->dev);
545
546 dev_dbg(&pdev->dev, "dm9000_probe()\n");
547
548 /* setup board info structure */
549 db = (struct board_info *) ndev->priv;
550 memset(db, 0, sizeof (*db));
551
552 db->dev = &pdev->dev;
553 db->ndev = ndev;
554
555 spin_lock_init(&db->lock);
556 mutex_init(&db->addr_lock);
557
558 INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);
559
560
561 if (pdev->num_resources < 2) {
562 ret = -ENODEV;
563 goto out;
564 } else if (pdev->num_resources == 2) {
565 base = pdev->resource[0].start;
566
567 if (!request_mem_region(base, 4, ndev->name)) {
568 ret = -EBUSY;
569 goto out;
570 }
571
572 ndev->base_addr = base;
573 ndev->irq = pdev->resource[1].start;
574 db->io_addr = (void __iomem *)base;
575 db->io_data = (void __iomem *)(base + 4);
576
577 /* ensure at least we have a default set of IO routines */
578 dm9000_set_io(db, 2);
579
580 } else {
581 db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
582 db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
583 db->irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
584
585 if (db->addr_res == NULL || db->data_res == NULL ||
586 db->irq_res == NULL) {
587 dev_err(db->dev, "insufficient resources\n");
588 ret = -ENOENT;
589 goto out;
590 }
591
592 i = res_size(db->addr_res);
593 db->addr_req = request_mem_region(db->addr_res->start, i,
594 pdev->name);
595
596 if (db->addr_req == NULL) {
597 dev_err(db->dev, "cannot claim address reg area\n");
598 ret = -EIO;
599 goto out;
600 }
601
602 db->io_addr = ioremap(db->addr_res->start, i);
603
604 if (db->io_addr == NULL) {
605 dev_err(db->dev, "failed to ioremap address reg\n");
606 ret = -EINVAL;
607 goto out;
608 }
609
610 iosize = res_size(db->data_res);
611 db->data_req = request_mem_region(db->data_res->start, iosize,
612 pdev->name);
613
614 if (db->data_req == NULL) {
615 dev_err(db->dev, "cannot claim data reg area\n");
616 ret = -EIO;
617 goto out;
618 }
619
620 db->io_data = ioremap(db->data_res->start, iosize);
621
622 if (db->io_data == NULL) {
623 dev_err(db->dev,"failed to ioremap data reg\n");
624 ret = -EINVAL;
625 goto out;
626 }
627
628 /* fill in parameters for net-dev structure */
629
630 ndev->base_addr = (unsigned long)db->io_addr;
631 ndev->irq = db->irq_res->start;
632
633 /* ensure at least we have a default set of IO routines */
634 dm9000_set_io(db, iosize);
635 } 627 }
636 628
637 /* check to see if anything is being over-ridden */ 629 return '?';
638 if (pdata != NULL) {
639 /* check to see if the driver wants to over-ride the
640 * default IO width */
641
642 if (pdata->flags & DM9000_PLATF_8BITONLY)
643 dm9000_set_io(db, 1);
644
645 if (pdata->flags & DM9000_PLATF_16BITONLY)
646 dm9000_set_io(db, 2);
647
648 if (pdata->flags & DM9000_PLATF_32BITONLY)
649 dm9000_set_io(db, 4);
650
651 /* check to see if there are any IO routine
652 * over-rides */
653
654 if (pdata->inblk != NULL)
655 db->inblk = pdata->inblk;
656
657 if (pdata->outblk != NULL)
658 db->outblk = pdata->outblk;
659
660 if (pdata->dumpblk != NULL)
661 db->dumpblk = pdata->dumpblk;
662
663 db->flags = pdata->flags;
664 }
665
666 dm9000_reset(db);
667
668 /* try two times, DM9000 sometimes gets the first read wrong */
669 for (i = 0; i < 8; i++) {
670 id_val = ior(db, DM9000_VIDL);
671 id_val |= (u32)ior(db, DM9000_VIDH) << 8;
672 id_val |= (u32)ior(db, DM9000_PIDL) << 16;
673 id_val |= (u32)ior(db, DM9000_PIDH) << 24;
674
675 if (id_val == DM9000_ID)
676 break;
677 dev_err(db->dev, "read wrong id 0x%08x\n", id_val);
678 }
679
680 if (id_val != DM9000_ID) {
681 dev_err(db->dev, "wrong id: 0x%08x\n", id_val);
682 ret = -ENODEV;
683 goto out;
684 }
685
686 /* from this point we assume that we have found a DM9000 */
687
688 /* driver system function */
689 ether_setup(ndev);
690
691 ndev->open = &dm9000_open;
692 ndev->hard_start_xmit = &dm9000_start_xmit;
693 ndev->tx_timeout = &dm9000_timeout;
694 ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
695 ndev->stop = &dm9000_stop;
696 ndev->set_multicast_list = &dm9000_hash_table;
697 ndev->ethtool_ops = &dm9000_ethtool_ops;
698 ndev->do_ioctl = &dm9000_ioctl;
699
700#ifdef CONFIG_NET_POLL_CONTROLLER
701 ndev->poll_controller = &dm9000_poll_controller;
702#endif
703
704 db->msg_enable = NETIF_MSG_LINK;
705 db->mii.phy_id_mask = 0x1f;
706 db->mii.reg_num_mask = 0x1f;
707 db->mii.force_media = 0;
708 db->mii.full_duplex = 0;
709 db->mii.dev = ndev;
710 db->mii.mdio_read = dm9000_phy_read;
711 db->mii.mdio_write = dm9000_phy_write;
712
713 mac_src = "eeprom";
714
715 /* try reading the node address from the attached EEPROM */
716 for (i = 0; i < 6; i += 2)
717 dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);
718
719 if (!is_valid_ether_addr(ndev->dev_addr)) {
720 /* try reading from mac */
721
722 mac_src = "chip";
723 for (i = 0; i < 6; i++)
724 ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
725 }
726
727 if (!is_valid_ether_addr(ndev->dev_addr))
728 dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
729 "set using ifconfig\n", ndev->name);
730
731 platform_set_drvdata(pdev, ndev);
732 ret = register_netdev(ndev);
733
734 if (ret == 0) {
735 DECLARE_MAC_BUF(mac);
736 printk("%s: dm9000 at %p,%p IRQ %d MAC: %s (%s)\n",
737 ndev->name, db->io_addr, db->io_data, ndev->irq,
738 print_mac(mac, ndev->dev_addr), mac_src);
739 }
740 return 0;
741
742out:
743 dev_err(db->dev, "not found (%d).\n", ret);
744
745 dm9000_release_board(pdev, db);
746 free_netdev(ndev);
747
748 return ret;
749} 630}
750 631
751/* 632/*
752 * Open the interface. 633 * Set DM9000 multicast address
753 * The interface is opened whenever "ifconfig" actives it.
754 */ 634 */
755static int 635static void
756dm9000_open(struct net_device *dev) 636dm9000_hash_table(struct net_device *dev)
757{ 637{
758 board_info_t *db = (board_info_t *) dev->priv; 638 board_info_t *db = (board_info_t *) dev->priv;
759 unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK; 639 struct dev_mc_list *mcptr = dev->mc_list;
640 int mc_cnt = dev->mc_count;
641 int i, oft;
642 u32 hash_val;
643 u16 hash_table[4];
644 u8 rcr = RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN;
645 unsigned long flags;
760 646
761 if (netif_msg_ifup(db)) 647 dm9000_dbg(db, 1, "entering %s\n", __func__);
762 dev_dbg(db->dev, "enabling %s\n", dev->name);
763 648
764 /* If there is no IRQ type specified, default to something that 649 spin_lock_irqsave(&db->lock, flags);
765 * may work, and tell the user that this is a problem */
766 650
767 if (irqflags == IRQF_TRIGGER_NONE) { 651 for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++)
768 dev_warn(db->dev, "WARNING: no IRQ resource flags set.\n"); 652 iow(db, oft, dev->dev_addr[i]);
769 irqflags = DEFAULT_TRIGGER;
770 }
771 653
772 irqflags |= IRQF_SHARED; 654 /* Clear Hash Table */
655 for (i = 0; i < 4; i++)
656 hash_table[i] = 0x0;
773 657
774 if (request_irq(dev->irq, &dm9000_interrupt, irqflags, dev->name, dev)) 658 /* broadcast address */
775 return -EAGAIN; 659 hash_table[3] = 0x8000;
776 660
777 /* Initialize DM9000 board */ 661 if (dev->flags & IFF_PROMISC)
778 dm9000_reset(db); 662 rcr |= RCR_PRMSC;
779 dm9000_init_dm9000(dev);
780 663
781 /* Init driver variable */ 664 if (dev->flags & IFF_ALLMULTI)
782 db->dbug_cnt = 0; 665 rcr |= RCR_ALL;
783 666
784 mii_check_media(&db->mii, netif_msg_link(db), 1); 667 /* the multicast address in Hash Table : 64 bits */
785 netif_start_queue(dev); 668 for (i = 0; i < mc_cnt; i++, mcptr = mcptr->next) {
786 669 hash_val = ether_crc_le(6, mcptr->dmi_addr) & 0x3f;
787 dm9000_schedule_poll(db); 670 hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
671 }
788 672
789 return 0; 673 /* Write the hash table to MAC MD table */
674 for (i = 0, oft = DM9000_MAR; i < 4; i++) {
675 iow(db, oft++, hash_table[i]);
676 iow(db, oft++, hash_table[i] >> 8);
677 }
678
679 iow(db, DM9000_RCR, rcr);
680 spin_unlock_irqrestore(&db->lock, flags);
790} 681}
791 682
792/* 683/*
@@ -795,7 +686,8 @@ dm9000_open(struct net_device *dev)
795static void 686static void
796dm9000_init_dm9000(struct net_device *dev) 687dm9000_init_dm9000(struct net_device *dev)
797{ 688{
798 board_info_t *db = (board_info_t *) dev->priv; 689 board_info_t *db = dev->priv;
690 unsigned int imr;
799 691
800 dm9000_dbg(db, 1, "entering %s\n", __func__); 692 dm9000_dbg(db, 1, "entering %s\n", __func__);
801 693
@@ -822,8 +714,14 @@ dm9000_init_dm9000(struct net_device *dev)
822 /* Set address filter table */ 714 /* Set address filter table */
823 dm9000_hash_table(dev); 715 dm9000_hash_table(dev);
824 716
717 imr = IMR_PAR | IMR_PTM | IMR_PRM;
718 if (db->type != TYPE_DM9000E)
719 imr |= IMR_LNKCHNG;
720
721 db->imr_all = imr;
722
825 /* Enable TX/RX interrupt mask */ 723 /* Enable TX/RX interrupt mask */
826 iow(db, DM9000_IMR, IMR_PAR | IMR_PTM | IMR_PRM); 724 iow(db, DM9000_IMR, imr);
827 725
828 /* Init Driver variable */ 726 /* Init Driver variable */
829 db->tx_pkt_cnt = 0; 727 db->tx_pkt_cnt = 0;
@@ -831,6 +729,29 @@ dm9000_init_dm9000(struct net_device *dev)
831 dev->trans_start = 0; 729 dev->trans_start = 0;
832} 730}
833 731
732/* Our watchdog timed out. Called by the networking layer */
733static void dm9000_timeout(struct net_device *dev)
734{
735 board_info_t *db = (board_info_t *) dev->priv;
736 u8 reg_save;
737 unsigned long flags;
738
739 /* Save previous register address */
740 reg_save = readb(db->io_addr);
741 spin_lock_irqsave(&db->lock, flags);
742
743 netif_stop_queue(dev);
744 dm9000_reset(db);
745 dm9000_init_dm9000(dev);
746 /* We can accept TX packets again */
747 dev->trans_start = jiffies;
748 netif_wake_queue(dev);
749
750 /* Restore previous register address */
751 writeb(reg_save, db->io_addr);
752 spin_unlock_irqrestore(&db->lock, flags);
753}
754
834/* 755/*
835 * Hardware start transmission. 756 * Hardware start transmission.
836 * Send a packet to media from the upper layer. 757 * Send a packet to media from the upper layer.
@@ -839,7 +760,7 @@ static int
839dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev) 760dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
840{ 761{
841 unsigned long flags; 762 unsigned long flags;
842 board_info_t *db = (board_info_t *) dev->priv; 763 board_info_t *db = dev->priv;
843 764
844 dm9000_dbg(db, 3, "%s:\n", __func__); 765 dm9000_dbg(db, 3, "%s:\n", __func__);
845 766
@@ -879,50 +800,12 @@ dm9000_start_xmit(struct sk_buff *skb, struct net_device *dev)
879 return 0; 800 return 0;
880} 801}
881 802
882static void
883dm9000_shutdown(struct net_device *dev)
884{
885 board_info_t *db = (board_info_t *) dev->priv;
886
887 /* RESET device */
888 dm9000_phy_write(dev, 0, MII_BMCR, BMCR_RESET); /* PHY RESET */
889 iow(db, DM9000_GPR, 0x01); /* Power-Down PHY */
890 iow(db, DM9000_IMR, IMR_PAR); /* Disable all interrupt */
891 iow(db, DM9000_RCR, 0x00); /* Disable RX */
892}
893
894/*
895 * Stop the interface.
896 * The interface is stopped when it is brought.
897 */
898static int
899dm9000_stop(struct net_device *ndev)
900{
901 board_info_t *db = (board_info_t *) ndev->priv;
902
903 if (netif_msg_ifdown(db))
904 dev_dbg(db->dev, "shutting down %s\n", ndev->name);
905
906 cancel_delayed_work_sync(&db->phy_poll);
907
908 netif_stop_queue(ndev);
909 netif_carrier_off(ndev);
910
911 /* free interrupt */
912 free_irq(ndev->irq, ndev);
913
914 dm9000_shutdown(ndev);
915
916 return 0;
917}
918
919/* 803/*
920 * DM9000 interrupt handler 804 * DM9000 interrupt handler
921 * receive the packet to upper layer, free the transmitted packet 805 * receive the packet to upper layer, free the transmitted packet
922 */ 806 */
923 807
924static void 808static void dm9000_tx_done(struct net_device *dev, board_info_t *db)
925dm9000_tx_done(struct net_device *dev, board_info_t * db)
926{ 809{
927 int tx_status = ior(db, DM9000_NSR); /* Got TX status */ 810 int tx_status = ior(db, DM9000_NSR); /* Got TX status */
928 811
@@ -945,52 +828,6 @@ dm9000_tx_done(struct net_device *dev, board_info_t * db)
945 } 828 }
946} 829}
947 830
948static irqreturn_t
949dm9000_interrupt(int irq, void *dev_id)
950{
951 struct net_device *dev = dev_id;
952 board_info_t *db = (board_info_t *) dev->priv;
953 int int_status;
954 u8 reg_save;
955
956 dm9000_dbg(db, 3, "entering %s\n", __func__);
957
958 /* A real interrupt coming */
959
960 spin_lock(&db->lock);
961
962 /* Save previous register address */
963 reg_save = readb(db->io_addr);
964
965 /* Disable all interrupts */
966 iow(db, DM9000_IMR, IMR_PAR);
967
968 /* Got DM9000 interrupt status */
969 int_status = ior(db, DM9000_ISR); /* Got ISR */
970 iow(db, DM9000_ISR, int_status); /* Clear ISR status */
971
972 if (netif_msg_intr(db))
973 dev_dbg(db->dev, "interrupt status %02x\n", int_status);
974
975 /* Received the coming packet */
976 if (int_status & ISR_PRS)
977 dm9000_rx(dev);
978
979 /* Trnasmit Interrupt check */
980 if (int_status & ISR_PTS)
981 dm9000_tx_done(dev, db);
982
983 /* Re-enable interrupt mask */
984 iow(db, DM9000_IMR, IMR_PAR | IMR_PTM | IMR_PRM);
985
986 /* Restore previous register address */
987 writeb(reg_save, db->io_addr);
988
989 spin_unlock(&db->lock);
990
991 return IRQ_HANDLED;
992}
993
994struct dm9000_rxhdr { 831struct dm9000_rxhdr {
995 u8 RxPktReady; 832 u8 RxPktReady;
996 u8 RxStatus; 833 u8 RxStatus;
@@ -1094,173 +931,109 @@ dm9000_rx(struct net_device *dev)
1094 } while (rxbyte == DM9000_PKT_RDY); 931 } while (rxbyte == DM9000_PKT_RDY);
1095} 932}
1096 933
1097static unsigned int 934static irqreturn_t dm9000_interrupt(int irq, void *dev_id)
1098dm9000_read_locked(board_info_t *db, int reg)
1099{ 935{
1100 unsigned long flags; 936 struct net_device *dev = dev_id;
1101 unsigned int ret; 937 board_info_t *db = dev->priv;
938 int int_status;
939 u8 reg_save;
1102 940
1103 spin_lock_irqsave(&db->lock, flags); 941 dm9000_dbg(db, 3, "entering %s\n", __func__);
1104 ret = ior(db, reg);
1105 spin_unlock_irqrestore(&db->lock, flags);
1106 942
1107 return ret; 943 /* A real interrupt coming */
1108}
1109 944
1110static int dm9000_wait_eeprom(board_info_t *db) 945 spin_lock(&db->lock);
1111{
1112 unsigned int status;
1113 int timeout = 8; /* wait max 8msec */
1114 946
1115 /* The DM9000 data sheets say we should be able to 947 /* Save previous register address */
1116 * poll the ERRE bit in EPCR to wait for the EEPROM 948 reg_save = readb(db->io_addr);
1117 * operation. From testing several chips, this bit
1118 * does not seem to work.
1119 *
1120 * We attempt to use the bit, but fall back to the
1121 * timeout (which is why we do not return an error
1122 * on expiry) to say that the EEPROM operation has
1123 * completed.
1124 */
1125 949
1126 while (1) { 950 /* Disable all interrupts */
1127 status = dm9000_read_locked(db, DM9000_EPCR); 951 iow(db, DM9000_IMR, IMR_PAR);
1128 952
1129 if ((status & EPCR_ERRE) == 0) 953 /* Got DM9000 interrupt status */
1130 break; 954 int_status = ior(db, DM9000_ISR); /* Got ISR */
955 iow(db, DM9000_ISR, int_status); /* Clear ISR status */
1131 956
1132 if (timeout-- < 0) { 957 if (netif_msg_intr(db))
1133 dev_dbg(db->dev, "timeout waiting EEPROM\n"); 958 dev_dbg(db->dev, "interrupt status %02x\n", int_status);
1134 break;
1135 }
1136 }
1137 959
1138 return 0; 960 /* Received the coming packet */
1139} 961 if (int_status & ISR_PRS)
962 dm9000_rx(dev);
1140 963
1141/* 964 /* Trnasmit Interrupt check */
1142 * Read a word data from EEPROM 965 if (int_status & ISR_PTS)
1143 */ 966 dm9000_tx_done(dev, db);
1144static void
1145dm9000_read_eeprom(board_info_t *db, int offset, u8 *to)
1146{
1147 unsigned long flags;
1148 967
1149 if (db->flags & DM9000_PLATF_NO_EEPROM) { 968 if (db->type != TYPE_DM9000E) {
1150 to[0] = 0xff; 969 if (int_status & ISR_LNKCHNG) {
1151 to[1] = 0xff; 970 /* fire a link-change request */
1152 return; 971 schedule_delayed_work(&db->phy_poll, 1);
972 }
1153 } 973 }
1154 974
1155 mutex_lock(&db->addr_lock); 975 /* Re-enable interrupt mask */
1156 976 iow(db, DM9000_IMR, db->imr_all);
1157 spin_lock_irqsave(&db->lock, flags);
1158
1159 iow(db, DM9000_EPAR, offset);
1160 iow(db, DM9000_EPCR, EPCR_ERPRR);
1161
1162 spin_unlock_irqrestore(&db->lock, flags);
1163
1164 dm9000_wait_eeprom(db);
1165
1166 /* delay for at-least 150uS */
1167 msleep(1);
1168
1169 spin_lock_irqsave(&db->lock, flags);
1170
1171 iow(db, DM9000_EPCR, 0x0);
1172 977
1173 to[0] = ior(db, DM9000_EPDRL); 978 /* Restore previous register address */
1174 to[1] = ior(db, DM9000_EPDRH); 979 writeb(reg_save, db->io_addr);
1175 980
1176 spin_unlock_irqrestore(&db->lock, flags); 981 spin_unlock(&db->lock);
1177 982
1178 mutex_unlock(&db->addr_lock); 983 return IRQ_HANDLED;
1179} 984}
1180 985
986#ifdef CONFIG_NET_POLL_CONTROLLER
1181/* 987/*
1182 * Write a word data to SROM 988 *Used by netconsole
1183 */ 989 */
1184static void 990static void dm9000_poll_controller(struct net_device *dev)
1185dm9000_write_eeprom(board_info_t *db, int offset, u8 *data)
1186{ 991{
1187 unsigned long flags; 992 disable_irq(dev->irq);
1188 993 dm9000_interrupt(dev->irq, dev);
1189 if (db->flags & DM9000_PLATF_NO_EEPROM) 994 enable_irq(dev->irq);
1190 return;
1191
1192 mutex_lock(&db->addr_lock);
1193
1194 spin_lock_irqsave(&db->lock, flags);
1195 iow(db, DM9000_EPAR, offset);
1196 iow(db, DM9000_EPDRH, data[1]);
1197 iow(db, DM9000_EPDRL, data[0]);
1198 iow(db, DM9000_EPCR, EPCR_WEP | EPCR_ERPRW);
1199 spin_unlock_irqrestore(&db->lock, flags);
1200
1201 dm9000_wait_eeprom(db);
1202
1203 mdelay(1); /* wait at least 150uS to clear */
1204
1205 spin_lock_irqsave(&db->lock, flags);
1206 iow(db, DM9000_EPCR, 0);
1207 spin_unlock_irqrestore(&db->lock, flags);
1208
1209 mutex_unlock(&db->addr_lock);
1210} 995}
996#endif
1211 997
1212/* 998/*
1213 * Set DM9000 multicast address 999 * Open the interface.
1000 * The interface is opened whenever "ifconfig" actives it.
1214 */ 1001 */
1215static void 1002static int
1216dm9000_hash_table(struct net_device *dev) 1003dm9000_open(struct net_device *dev)
1217{ 1004{
1218 board_info_t *db = (board_info_t *) dev->priv; 1005 board_info_t *db = dev->priv;
1219 struct dev_mc_list *mcptr = dev->mc_list; 1006 unsigned long irqflags = db->irq_res->flags & IRQF_TRIGGER_MASK;
1220 int mc_cnt = dev->mc_count;
1221 int i, oft;
1222 u32 hash_val;
1223 u16 hash_table[4];
1224 u8 rcr = RCR_DIS_LONG | RCR_DIS_CRC | RCR_RXEN;
1225 unsigned long flags;
1226
1227 dm9000_dbg(db, 1, "entering %s\n", __func__);
1228 1007
1229 spin_lock_irqsave(&db->lock, flags); 1008 if (netif_msg_ifup(db))
1009 dev_dbg(db->dev, "enabling %s\n", dev->name);
1230 1010
1231 for (i = 0, oft = DM9000_PAR; i < 6; i++, oft++) 1011 /* If there is no IRQ type specified, default to something that
1232 iow(db, oft, dev->dev_addr[i]); 1012 * may work, and tell the user that this is a problem */
1233 1013
1234 /* Clear Hash Table */ 1014 if (irqflags == IRQF_TRIGGER_NONE)
1235 for (i = 0; i < 4; i++) 1015 dev_warn(db->dev, "WARNING: no IRQ resource flags set.\n");
1236 hash_table[i] = 0x0;
1237 1016
1238 /* broadcast address */ 1017 irqflags |= IRQF_SHARED;
1239 hash_table[3] = 0x8000;
1240 1018
1241 if (dev->flags & IFF_PROMISC) 1019 if (request_irq(dev->irq, &dm9000_interrupt, irqflags, dev->name, dev))
1242 rcr |= RCR_PRMSC; 1020 return -EAGAIN;
1243 1021
1244 if (dev->flags & IFF_ALLMULTI) 1022 /* Initialize DM9000 board */
1245 rcr |= RCR_ALL; 1023 dm9000_reset(db);
1024 dm9000_init_dm9000(dev);
1246 1025
1247 /* the multicast address in Hash Table : 64 bits */ 1026 /* Init driver variable */
1248 for (i = 0; i < mc_cnt; i++, mcptr = mcptr->next) { 1027 db->dbug_cnt = 0;
1249 hash_val = ether_crc_le(6, mcptr->dmi_addr) & 0x3f;
1250 hash_table[hash_val / 16] |= (u16) 1 << (hash_val % 16);
1251 }
1252 1028
1253 /* Write the hash table to MAC MD table */ 1029 mii_check_media(&db->mii, netif_msg_link(db), 1);
1254 for (i = 0, oft = DM9000_MAR; i < 4; i++) { 1030 netif_start_queue(dev);
1255 iow(db, oft++, hash_table[i]); 1031
1256 iow(db, oft++, hash_table[i] >> 8); 1032 dm9000_schedule_poll(db);
1257 }
1258 1033
1259 iow(db, DM9000_RCR, rcr); 1034 return 0;
1260 spin_unlock_irqrestore(&db->lock, flags);
1261} 1035}
1262 1036
1263
1264/* 1037/*
1265 * Sleep, either by using msleep() or if we are suspending, then 1038 * Sleep, either by using msleep() or if we are suspending, then
1266 * use mdelay() to sleep. 1039 * use mdelay() to sleep.
@@ -1323,7 +1096,8 @@ dm9000_phy_read(struct net_device *dev, int phy_reg_unused, int reg)
1323 * Write a word to phyxcer 1096 * Write a word to phyxcer
1324 */ 1097 */
1325static void 1098static void
1326dm9000_phy_write(struct net_device *dev, int phyaddr_unused, int reg, int value) 1099dm9000_phy_write(struct net_device *dev,
1100 int phyaddr_unused, int reg, int value)
1327{ 1101{
1328 board_info_t *db = (board_info_t *) dev->priv; 1102 board_info_t *db = (board_info_t *) dev->priv;
1329 unsigned long flags; 1103 unsigned long flags;
@@ -1363,6 +1137,273 @@ dm9000_phy_write(struct net_device *dev, int phyaddr_unused, int reg, int value)
1363 mutex_unlock(&db->addr_lock); 1137 mutex_unlock(&db->addr_lock);
1364} 1138}
1365 1139
1140static void
1141dm9000_shutdown(struct net_device *dev)
1142{
1143 board_info_t *db = dev->priv;
1144
1145 /* RESET device */
1146 dm9000_phy_write(dev, 0, MII_BMCR, BMCR_RESET); /* PHY RESET */
1147 iow(db, DM9000_GPR, 0x01); /* Power-Down PHY */
1148 iow(db, DM9000_IMR, IMR_PAR); /* Disable all interrupt */
1149 iow(db, DM9000_RCR, 0x00); /* Disable RX */
1150}
1151
1152/*
1153 * Stop the interface.
1154 * The interface is stopped when it is brought.
1155 */
1156static int
1157dm9000_stop(struct net_device *ndev)
1158{
1159 board_info_t *db = ndev->priv;
1160
1161 if (netif_msg_ifdown(db))
1162 dev_dbg(db->dev, "shutting down %s\n", ndev->name);
1163
1164 cancel_delayed_work_sync(&db->phy_poll);
1165
1166 netif_stop_queue(ndev);
1167 netif_carrier_off(ndev);
1168
1169 /* free interrupt */
1170 free_irq(ndev->irq, ndev);
1171
1172 dm9000_shutdown(ndev);
1173
1174 return 0;
1175}
1176
1177#define res_size(_r) (((_r)->end - (_r)->start) + 1)
1178
1179/*
1180 * Search DM9000 board, allocate space and register it
1181 */
1182static int __devinit
1183dm9000_probe(struct platform_device *pdev)
1184{
1185 struct dm9000_plat_data *pdata = pdev->dev.platform_data;
1186 struct board_info *db; /* Point a board information structure */
1187 struct net_device *ndev;
1188 const unsigned char *mac_src;
1189 int ret = 0;
1190 int iosize;
1191 int i;
1192 u32 id_val;
1193
1194 /* Init network device */
1195 ndev = alloc_etherdev(sizeof(struct board_info));
1196 if (!ndev) {
1197 dev_err(&pdev->dev, "could not allocate device.\n");
1198 return -ENOMEM;
1199 }
1200
1201 SET_NETDEV_DEV(ndev, &pdev->dev);
1202
1203 dev_dbg(&pdev->dev, "dm9000_probe()\n");
1204
1205 /* setup board info structure */
1206 db = ndev->priv;
1207 memset(db, 0, sizeof(*db));
1208
1209 db->dev = &pdev->dev;
1210 db->ndev = ndev;
1211
1212 spin_lock_init(&db->lock);
1213 mutex_init(&db->addr_lock);
1214
1215 INIT_DELAYED_WORK(&db->phy_poll, dm9000_poll_work);
1216
1217 db->addr_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1218 db->data_res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
1219 db->irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1220
1221 if (db->addr_res == NULL || db->data_res == NULL ||
1222 db->irq_res == NULL) {
1223 dev_err(db->dev, "insufficient resources\n");
1224 ret = -ENOENT;
1225 goto out;
1226 }
1227
1228 iosize = res_size(db->addr_res);
1229 db->addr_req = request_mem_region(db->addr_res->start, iosize,
1230 pdev->name);
1231
1232 if (db->addr_req == NULL) {
1233 dev_err(db->dev, "cannot claim address reg area\n");
1234 ret = -EIO;
1235 goto out;
1236 }
1237
1238 db->io_addr = ioremap(db->addr_res->start, iosize);
1239
1240 if (db->io_addr == NULL) {
1241 dev_err(db->dev, "failed to ioremap address reg\n");
1242 ret = -EINVAL;
1243 goto out;
1244 }
1245
1246 iosize = res_size(db->data_res);
1247 db->data_req = request_mem_region(db->data_res->start, iosize,
1248 pdev->name);
1249
1250 if (db->data_req == NULL) {
1251 dev_err(db->dev, "cannot claim data reg area\n");
1252 ret = -EIO;
1253 goto out;
1254 }
1255
1256 db->io_data = ioremap(db->data_res->start, iosize);
1257
1258 if (db->io_data == NULL) {
1259 dev_err(db->dev, "failed to ioremap data reg\n");
1260 ret = -EINVAL;
1261 goto out;
1262 }
1263
1264 /* fill in parameters for net-dev structure */
1265 ndev->base_addr = (unsigned long)db->io_addr;
1266 ndev->irq = db->irq_res->start;
1267
1268 /* ensure at least we have a default set of IO routines */
1269 dm9000_set_io(db, iosize);
1270
1271 /* check to see if anything is being over-ridden */
1272 if (pdata != NULL) {
1273 /* check to see if the driver wants to over-ride the
1274 * default IO width */
1275
1276 if (pdata->flags & DM9000_PLATF_8BITONLY)
1277 dm9000_set_io(db, 1);
1278
1279 if (pdata->flags & DM9000_PLATF_16BITONLY)
1280 dm9000_set_io(db, 2);
1281
1282 if (pdata->flags & DM9000_PLATF_32BITONLY)
1283 dm9000_set_io(db, 4);
1284
1285 /* check to see if there are any IO routine
1286 * over-rides */
1287
1288 if (pdata->inblk != NULL)
1289 db->inblk = pdata->inblk;
1290
1291 if (pdata->outblk != NULL)
1292 db->outblk = pdata->outblk;
1293
1294 if (pdata->dumpblk != NULL)
1295 db->dumpblk = pdata->dumpblk;
1296
1297 db->flags = pdata->flags;
1298 }
1299
1300#ifdef CONFIG_DM9000_FORCE_SIMPLE_PHY_POLL
1301 db->flags |= DM9000_PLATF_SIMPLE_PHY;
1302#endif
1303
1304 dm9000_reset(db);
1305
1306 /* try multiple times, DM9000 sometimes gets the read wrong */
1307 for (i = 0; i < 8; i++) {
1308 id_val = ior(db, DM9000_VIDL);
1309 id_val |= (u32)ior(db, DM9000_VIDH) << 8;
1310 id_val |= (u32)ior(db, DM9000_PIDL) << 16;
1311 id_val |= (u32)ior(db, DM9000_PIDH) << 24;
1312
1313 if (id_val == DM9000_ID)
1314 break;
1315 dev_err(db->dev, "read wrong id 0x%08x\n", id_val);
1316 }
1317
1318 if (id_val != DM9000_ID) {
1319 dev_err(db->dev, "wrong id: 0x%08x\n", id_val);
1320 ret = -ENODEV;
1321 goto out;
1322 }
1323
1324 /* Identify what type of DM9000 we are working on */
1325
1326 id_val = ior(db, DM9000_CHIPR);
1327 dev_dbg(db->dev, "dm9000 revision 0x%02x\n", id_val);
1328
1329 switch (id_val) {
1330 case CHIPR_DM9000A:
1331 db->type = TYPE_DM9000A;
1332 break;
1333 case CHIPR_DM9000B:
1334 db->type = TYPE_DM9000B;
1335 break;
1336 default:
1337 dev_dbg(db->dev, "ID %02x => defaulting to DM9000E\n", id_val);
1338 db->type = TYPE_DM9000E;
1339 }
1340
1341 /* from this point we assume that we have found a DM9000 */
1342
1343 /* driver system function */
1344 ether_setup(ndev);
1345
1346 ndev->open = &dm9000_open;
1347 ndev->hard_start_xmit = &dm9000_start_xmit;
1348 ndev->tx_timeout = &dm9000_timeout;
1349 ndev->watchdog_timeo = msecs_to_jiffies(watchdog);
1350 ndev->stop = &dm9000_stop;
1351 ndev->set_multicast_list = &dm9000_hash_table;
1352 ndev->ethtool_ops = &dm9000_ethtool_ops;
1353 ndev->do_ioctl = &dm9000_ioctl;
1354
1355#ifdef CONFIG_NET_POLL_CONTROLLER
1356 ndev->poll_controller = &dm9000_poll_controller;
1357#endif
1358
1359 db->msg_enable = NETIF_MSG_LINK;
1360 db->mii.phy_id_mask = 0x1f;
1361 db->mii.reg_num_mask = 0x1f;
1362 db->mii.force_media = 0;
1363 db->mii.full_duplex = 0;
1364 db->mii.dev = ndev;
1365 db->mii.mdio_read = dm9000_phy_read;
1366 db->mii.mdio_write = dm9000_phy_write;
1367
1368 mac_src = "eeprom";
1369
1370 /* try reading the node address from the attached EEPROM */
1371 for (i = 0; i < 6; i += 2)
1372 dm9000_read_eeprom(db, i / 2, ndev->dev_addr+i);
1373
1374 if (!is_valid_ether_addr(ndev->dev_addr)) {
1375 /* try reading from mac */
1376
1377 mac_src = "chip";
1378 for (i = 0; i < 6; i++)
1379 ndev->dev_addr[i] = ior(db, i+DM9000_PAR);
1380 }
1381
1382 if (!is_valid_ether_addr(ndev->dev_addr))
1383 dev_warn(db->dev, "%s: Invalid ethernet MAC address. Please "
1384 "set using ifconfig\n", ndev->name);
1385
1386 platform_set_drvdata(pdev, ndev);
1387 ret = register_netdev(ndev);
1388
1389 if (ret == 0) {
1390 DECLARE_MAC_BUF(mac);
1391 printk(KERN_INFO "%s: dm9000%c at %p,%p IRQ %d MAC: %s (%s)\n",
1392 ndev->name, dm9000_type_to_char(db->type),
1393 db->io_addr, db->io_data, ndev->irq,
1394 print_mac(mac, ndev->dev_addr), mac_src);
1395 }
1396 return 0;
1397
1398out:
1399 dev_err(db->dev, "not found (%d).\n", ret);
1400
1401 dm9000_release_board(pdev, db);
1402 free_netdev(ndev);
1403
1404 return ret;
1405}
1406
1366static int 1407static int
1367dm9000_drv_suspend(struct platform_device *dev, pm_message_t state) 1408dm9000_drv_suspend(struct platform_device *dev, pm_message_t state)
1368{ 1409{
@@ -1432,7 +1473,7 @@ dm9000_init(void)
1432{ 1473{
1433 printk(KERN_INFO "%s Ethernet Driver, V%s\n", CARDNAME, DRV_VERSION); 1474 printk(KERN_INFO "%s Ethernet Driver, V%s\n", CARDNAME, DRV_VERSION);
1434 1475
1435 return platform_driver_register(&dm9000_driver); /* search board and register */ 1476 return platform_driver_register(&dm9000_driver);
1436} 1477}
1437 1478
1438static void __exit 1479static void __exit
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-07 10:53:01 -0500