drivers/net/oaknet.c

   1 /*
   2  *
   3  *    Copyright (c) 1999-2000 Grant Erickson <grant@lcse.umn.edu>
   4  *
   5  *    Module name: oaknet.c
   6  *
   7  *    Description:
   8  *      Driver for the National Semiconductor DP83902AV Ethernet controller
   9  *      on-board the IBM PowerPC "Oak" evaluation board. Adapted from the
  10  *      various other 8390 drivers written by Donald Becker and Paul Gortmaker.
  11  *
  12  *      Additional inspiration from the "tcd8390.c" driver from TiVo, Inc.
  13  *      and "enetLib.c" from IBM.
  14  *
  15  */
  16
  17 #include <linux/module.h>
  18 #include <linux/errno.h>
  19 #include <linux/delay.h>
  20 #include <linux/netdevice.h>
  21 #include <linux/etherdevice.h>
  22 #include <linux/init.h>
  23 #include <linux/jiffies.h>
  24
  25 #include <asm/board.h>
  26 #include <asm/io.h>
  27
  28 #include "8390.h"
  29
  30
  31 /* Preprocessor Defines */
  32
  33 #if !defined(TRUE) || TRUE != 1
  34 #define TRUE    1
  35 #endif
  36
  37 #if !defined(FALSE) || FALSE != 0
  38 #define FALSE   0
  39 #endif
  40
  41 #define OAKNET_START_PG         0x20    /* First page of TX buffer */
  42 #define OAKNET_STOP_PG          0x40    /* Last pagge +1 of RX ring */
  43
  44 #define OAKNET_WAIT             (2 * HZ / 100)  /* 20 ms */
  45
  46 /* Experimenting with some fixes for a broken driver... */
  47
  48 #define OAKNET_DISINT
  49 #define OAKNET_HEADCHECK
  50 #define OAKNET_RWFIX
  51
  52
  53 /* Global Variables */
  54
  55 static const char *name = "National DP83902AV";
  56
  57 static struct net_device *oaknet_devs;
  58
  59
  60 /* Function Prototypes */
  61
  62 static int       oaknet_open(struct net_device *dev);
  63 static int       oaknet_close(struct net_device *dev);
  64
  65 static void      oaknet_reset_8390(struct net_device *dev);
  66 static void      oaknet_get_8390_hdr(struct net_device *dev,
  67                                      struct e8390_pkt_hdr *hdr, int ring_page);
  68 static void      oaknet_block_input(struct net_device *dev, int count,
  69                                     struct sk_buff *skb, int ring_offset);
  70 static void      oaknet_block_output(struct net_device *dev, int count,
  71                                      const unsigned char *buf, int start_page);
  72
  73 static void      oaknet_dma_error(struct net_device *dev, const char *name);
  74
  75
  76 /*
  77  * int oaknet_init()
  78  *
  79  * Description:
  80  *   This routine performs all the necessary platform-specific initiali-
  81  *   zation and set-up for the IBM "Oak" evaluation board's National
  82  *   Semiconductor DP83902AV "ST-NIC" Ethernet controller.
  83  *
  84  * Input(s):
  85  *   N/A
  86  *
  87  * Output(s):
  88  *   N/A
  89  *
  90  * Returns:
  91  *   0 if OK, otherwise system error number on error.
  92  *
  93  */
  94 static int __init oaknet_init(void)
  95 {
  96         register int i;
  97         int reg0, regd;
  98         int ret = -ENOMEM;
  99         struct net_device *dev;
 100 #if 0
 101         unsigned long ioaddr = OAKNET_IO_BASE;
 102 #else
 103         unsigned long ioaddr = ioremap(OAKNET_IO_BASE, OAKNET_IO_SIZE);
 104 #endif
 105         bd_t *bip = (bd_t *)__res;
 106
 107         if (!ioaddr)
 108                 return -ENOMEM;
 109
 110         dev = alloc_ei_netdev();
 111         if (!dev)
 112                 goto out_unmap;
 113
 114         ret = -EBUSY;
 115         if (!request_region(OAKNET_IO_BASE, OAKNET_IO_SIZE, name))
 116                 goto out_dev;
 117
 118         /* Quick register check to see if the device is really there. */
 119
 120         ret = -ENODEV;
 121         if ((reg0 = ei_ibp(ioaddr)) == 0xFF)
 122                 goto out_region;
 123
 124         /*
 125          * That worked. Now a more thorough check, using the multicast
 126          * address registers, that the device is definitely out there
 127          * and semi-functional.
 128          */
 129
 130         ei_obp(E8390_NODMA + E8390_PAGE1 + E8390_STOP, ioaddr + E8390_CMD);
 131         regd = ei_ibp(ioaddr + 0x0D);
 132         ei_obp(0xFF, ioaddr + 0x0D);
 133         ei_obp(E8390_NODMA + E8390_PAGE0, ioaddr + E8390_CMD);
 134         ei_ibp(ioaddr + EN0_COUNTER0);
 135
 136         /* It's no good. Fix things back up and leave. */
 137
 138         ret = -ENODEV;
 139         if (ei_ibp(ioaddr + EN0_COUNTER0) != 0) {
 140                 ei_obp(reg0, ioaddr);
 141                 ei_obp(regd, ioaddr + 0x0D);
 142                 goto out_region;
 143         }
 144
 145         SET_MODULE_OWNER(dev);
 146
 147         /*
 148          * This controller is on an embedded board, so the base address
 149          * and interrupt assignments are pre-assigned and unchageable.
 150          */
 151
 152         dev->base_addr = ioaddr;
 153         dev->irq = OAKNET_INT;
 154
 155         /*
 156          * Disable all chip interrupts for now and ACK all pending
 157          * interrupts.
 158          */
 159
 160         ei_obp(0x0, ioaddr + EN0_IMR);
 161         ei_obp(0xFF, ioaddr + EN0_ISR);
 162
 163         /* Attempt to get the interrupt line */
 164
 165         ret = -EAGAIN;
 166         if (request_irq(dev->irq, ei_interrupt, 0, name, dev)) {
 167                 printk("%s: unable to request interrupt %d.\n",
 168                        name, dev->irq);
 169                 goto out_region;
 170         }
 171
 172         /* Tell the world about what and where we've found. */
 173
 174         printk("%s: %s at", dev->name, name);
 175         for (i = 0; i < ETHER_ADDR_LEN; ++i) {
 176                 dev->dev_addr[i] = bip->bi_enetaddr[i];
 177                 printk("%c%.2x", (i ? ':' : ' '), dev->dev_addr[i]);
 178         }
 179         printk(", found at %#lx, using IRQ %d.\n", dev->base_addr, dev->irq);
 180
 181         /* Set up some required driver fields and then we're done. */
 182
 183         ei_status.name          = name;
 184         ei_status.word16        = FALSE;
 185         ei_status.tx_start_page = OAKNET_START_PG;
 186         ei_status.rx_start_page = OAKNET_START_PG + TX_PAGES;
 187         ei_status.stop_page     = OAKNET_STOP_PG;
 188
 189         ei_status.reset_8390    = &oaknet_reset_8390;
 190         ei_status.block_input   = &oaknet_block_input;
 191         ei_status.block_output  = &oaknet_block_output;
 192         ei_status.get_8390_hdr  = &oaknet_get_8390_hdr;
 193
 194         dev->open = oaknet_open;
 195         dev->stop = oaknet_close;
 196 #ifdef CONFIG_NET_POLL_CONTROLLER
 197         dev->poll_controller = ei_poll;
 198 #endif
 199
 200         NS8390_init(dev, FALSE);
 201         ret = register_netdev(dev);
 202         if (ret)
 203                 goto out_irq;
 204
 205         oaknet_devs = dev;
 206         return 0;
 207
 208 out_irq;
 209         free_irq(dev->irq, dev);
 210 out_region:
 211         release_region(OAKNET_IO_BASE, OAKNET_IO_SIZE);
 212 out_dev:
 213         free_netdev(dev);
 214 out_unmap:
 215         iounmap(ioaddr);
 216         return ret;
 217 }
 218
 219 /*
 220  * static int oaknet_open()
 221  *
 222  * Description:
 223  *   This routine is a modest wrapper around ei_open, the 8390-generic,
 224  *   driver open routine. This just increments the module usage count
 225  *   and passes along the status from ei_open.
 226  *
 227  * Input(s):
 228  *  *dev - Pointer to the device structure for this driver.
 229  *
 230  * Output(s):
 231  *  *dev - Pointer to the device structure for this driver, potentially
 232  *         modified by ei_open.
 233  *
 234  * Returns:
 235  *   0 if OK, otherwise < 0 on error.
 236  *
 237  */
 238 static int
 239 oaknet_open(struct net_device *dev)
 240 {
 241         int status = ei_open(dev);
 242         return (status);
 243 }
 244
 245 /*
 246  * static int oaknet_close()
 247  *
 248  * Description:
 249  *   This routine is a modest wrapper around ei_close, the 8390-generic,
 250  *   driver close routine. This just decrements the module usage count
 251  *   and passes along the status from ei_close.
 252  *
 253  * Input(s):
 254  *  *dev - Pointer to the device structure for this driver.
 255  *
 256  * Output(s):
 257  *  *dev - Pointer to the device structure for this driver, potentially
 258  *         modified by ei_close.
 259  *
 260  * Returns:
 261  *   0 if OK, otherwise < 0 on error.
 262  *
 263  */
 264 static int
 265 oaknet_close(struct net_device *dev)
 266 {
 267         int status = ei_close(dev);
 268         return (status);
 269 }
 270
 271 /*
 272  * static void oaknet_reset_8390()
 273  *
 274  * Description:
 275  *   This routine resets the DP83902 chip.
 276  *
 277  * Input(s):
 278  *  *dev - Pointer to the device structure for this driver.
 279  *
 280  * Output(s):
 281  *   N/A
 282  *
 283  * Returns:
 284  *   N/A
 285  *
 286  */
 287 static void
 288 oaknet_reset_8390(struct net_device *dev)
 289 {
 290         int base = E8390_BASE;
 291
 292         /*
 293          * We have no provision of reseting the controller as is done
 294          * in other drivers, such as "ne.c". However, the following
 295          * seems to work well enough in the TiVo driver.
 296          */
 297
 298         printk("Resetting %s...\n", dev->name);
 299         ei_obp(E8390_STOP | E8390_NODMA | E8390_PAGE0, base + E8390_CMD);
 300         ei_status.txing = 0;
 301         ei_status.dmaing = 0;
 302 }
 303
 304 /*
 305  * static void oaknet_get_8390_hdr()
 306  *
 307  * Description:
 308  *   This routine grabs the 8390-specific header. It's similar to the
 309  *   block input routine, but we don't need to be concerned with ring wrap
 310  *   as the header will be at the start of a page, so we optimize accordingly.
 311  *
 312  * Input(s):
 313  *  *dev       - Pointer to the device structure for this driver.
 314  *  *hdr       - Pointer to storage for the 8390-specific packet header.
 315  *   ring_page - ?
 316  *
 317  * Output(s):
 318  *  *hdr       - Pointer to the 8390-specific packet header for the just-
 319  *               received frame.
 320  *
 321  * Returns:
 322  *   N/A
 323  *
 324  */
 325 static void
 326 oaknet_get_8390_hdr(struct net_device *dev, struct e8390_pkt_hdr *hdr,
 327                     int ring_page)
 328 {
 329         int base = dev->base_addr;
 330
 331         /*
 332          * This should NOT happen. If it does, it is the LAST thing you'll
 333          * see.
 334          */
 335
 336         if (ei_status.dmaing) {
 337                 oaknet_dma_error(dev, "oaknet_get_8390_hdr");
 338                 return;
 339         }
 340
 341         ei_status.dmaing |= 0x01;
 342         outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, base + OAKNET_CMD);
 343         outb_p(sizeof(struct e8390_pkt_hdr), base + EN0_RCNTLO);
 344         outb_p(0, base + EN0_RCNTHI);
 345         outb_p(0, base + EN0_RSARLO);           /* On page boundary */
 346         outb_p(ring_page, base + EN0_RSARHI);
 347         outb_p(E8390_RREAD + E8390_START, base + OAKNET_CMD);
 348
 349         if (ei_status.word16)
 350                 insw(base + OAKNET_DATA, hdr,
 351                      sizeof(struct e8390_pkt_hdr) >> 1);
 352         else
 353                 insb(base + OAKNET_DATA, hdr,
 354                      sizeof(struct e8390_pkt_hdr));
 355
 356         /* Byte-swap the packet byte count */
 357
 358         hdr->count = le16_to_cpu(hdr->count);
 359
 360         outb_p(ENISR_RDC, base + EN0_ISR);      /* ACK Remote DMA interrupt */
 361         ei_status.dmaing &= ~0x01;
 362 }
 363
 364 /*
 365  * XXX - Document me.
 366  */
 367 static void
 368 oaknet_block_input(struct net_device *dev, int count, struct sk_buff *skb,
 369                    int ring_offset)
 370 {
 371         int base = OAKNET_BASE;
 372         char *buf = skb->data;
 373
 374         /*
 375          * This should NOT happen. If it does, it is the LAST thing you'll
 376          * see.
 377          */
 378
 379         if (ei_status.dmaing) {
 380                 oaknet_dma_error(dev, "oaknet_block_input");
 381                 return;
 382         }
 383
 384 #ifdef OAKNET_DISINT
 385         save_flags(flags);
 386         cli();
 387 #endif
 388
 389         ei_status.dmaing |= 0x01;
 390         ei_obp(E8390_NODMA + E8390_PAGE0 + E8390_START, base + E8390_CMD);
 391         ei_obp(count & 0xff, base + EN0_RCNTLO);
 392         ei_obp(count >> 8, base + EN0_RCNTHI);
 393         ei_obp(ring_offset & 0xff, base + EN0_RSARLO);
 394         ei_obp(ring_offset >> 8, base + EN0_RSARHI);
 395         ei_obp(E8390_RREAD + E8390_START, base + E8390_CMD);
 396         if (ei_status.word16) {
 397                 ei_isw(base + E8390_DATA, buf, count >> 1);
 398                 if (count & 0x01) {
 399                         buf[count - 1] = ei_ib(base + E8390_DATA);
 400 #ifdef OAKNET_HEADCHECK
 401                         bytes++;
 402 #endif
 403                 }
 404         } else {
 405                 ei_isb(base + E8390_DATA, buf, count);
 406         }
 407 #ifdef OAKNET_HEADCHECK
 408         /*
 409          * This was for the ALPHA version only, but enough people have
 410          * been encountering problems so it is still here.  If you see
 411          * this message you either 1) have a slightly incompatible clone
 412          * or 2) have noise/speed problems with your bus.
 413          */
 414
 415         /* DMA termination address check... */
 416         {
 417                 int addr, tries = 20;
 418                 do {
 419                         /* DON'T check for 'ei_ibp(EN0_ISR) & ENISR_RDC' here
 420                            -- it's broken for Rx on some cards! */
 421                         int high = ei_ibp(base + EN0_RSARHI);
 422                         int low = ei_ibp(base + EN0_RSARLO);
 423                         addr = (high << 8) + low;
 424                         if (((ring_offset + bytes) & 0xff) == low)
 425                                 break;
 426                 } while (--tries > 0);
 427                 if (tries <= 0)
 428                         printk("%s: RX transfer address mismatch,"
 429                                "%#4.4x (expected) vs. %#4.4x (actual).\n",
 430                                dev->name, ring_offset + bytes, addr);
 431         }
 432 #endif
 433         ei_obp(ENISR_RDC, base + EN0_ISR);      /* ACK Remote DMA interrupt */
 434         ei_status.dmaing &= ~0x01;
 435
 436 #ifdef OAKNET_DISINT
 437         restore_flags(flags);
 438 #endif
 439 }
 440
 441 /*
 442  * static void oaknet_block_output()
 443  *
 444  * Description:
 445  *   This routine...
 446  *
 447  * Input(s):
 448  *  *dev        - Pointer to the device structure for this driver.
 449  *   count      - Number of bytes to be transferred.
 450  *  *buf        -
 451  *   start_page -
 452  *
 453  * Output(s):
 454  *   N/A
 455  *
 456  * Returns:
 457  *   N/A
 458  *
 459  */
 460 static void
 461 oaknet_block_output(struct net_device *dev, int count,
 462                     const unsigned char *buf, int start_page)
 463 {
 464         int base = E8390_BASE;
 465 #if 0
 466         int bug;
 467 #endif
 468         unsigned long start;
 469 #ifdef OAKNET_DISINT
 470         unsigned long flags;
 471 #endif
 472 #ifdef OAKNET_HEADCHECK
 473         int retries = 0;
 474 #endif
 475
 476         /* Round the count up for word writes. */
 477
 478         if (ei_status.word16 && (count & 0x1))
 479                 count++;
 480
 481         /*
 482          * This should NOT happen. If it does, it is the LAST thing you'll
 483          * see.
 484          */
 485
 486         if (ei_status.dmaing) {
 487                 oaknet_dma_error(dev, "oaknet_block_output");
 488                 return;
 489         }
 490
 491 #ifdef OAKNET_DISINT
 492         save_flags(flags);
 493         cli();
 494 #endif
 495
 496         ei_status.dmaing |= 0x01;
 497
 498         /* Make sure we are in page 0. */
 499
 500         ei_obp(E8390_PAGE0 + E8390_START + E8390_NODMA, base + E8390_CMD);
 501
 502 #ifdef OAKNET_HEADCHECK
 503 retry:
 504 #endif
 505
 506 #if 0
 507         /*
 508          * The 83902 documentation states that the processor needs to
 509          * do a "dummy read" before doing the remote write to work
 510          * around a chip bug they don't feel like fixing.
 511          */
 512
 513         bug = 0;
 514         while (1) {
 515                 unsigned int rdhi;
 516                 unsigned int rdlo;
 517
 518                 /* Now the normal output. */
 519                 ei_obp(ENISR_RDC, base + EN0_ISR);
 520                 ei_obp(count & 0xff, base + EN0_RCNTLO);
 521                 ei_obp(count >> 8,   base + EN0_RCNTHI);
 522                 ei_obp(0x00, base + EN0_RSARLO);
 523                 ei_obp(start_page, base + EN0_RSARHI);
 524
 525                 if (bug++)
 526                         break;
 527
 528                 /* Perform the dummy read */
 529                 rdhi = ei_ibp(base + EN0_CRDAHI);
 530                 rdlo = ei_ibp(base + EN0_CRDALO);
 531                 ei_obp(E8390_RREAD + E8390_START, base + E8390_CMD);
 532
 533                 while (1) {
 534                         unsigned int nrdhi;
 535                         unsigned int nrdlo;
 536                         nrdhi = ei_ibp(base + EN0_CRDAHI);
 537                         nrdlo = ei_ibp(base + EN0_CRDALO);
 538                         if ((rdhi != nrdhi) || (rdlo != nrdlo))
 539                                 break;
 540                 }
 541         }
 542 #else
 543 #ifdef OAKNET_RWFIX
 544         /*
 545          * Handle the read-before-write bug the same way as the
 546          * Crynwr packet driver -- the Nat'l Semi. method doesn't work.
 547          * Actually this doesn't always work either, but if you have
 548          * problems with your 83902 this is better than nothing!
 549          */
 550
 551         ei_obp(0x42, base + EN0_RCNTLO);
 552         ei_obp(0x00, base + EN0_RCNTHI);
 553         ei_obp(0x42, base + EN0_RSARLO);
 554         ei_obp(0x00, base + EN0_RSARHI);
 555         ei_obp(E8390_RREAD + E8390_START, base + E8390_CMD);
 556         /* Make certain that the dummy read has occurred. */
 557         udelay(6);
 558 #endif
 559
 560         ei_obp(ENISR_RDC, base + EN0_ISR);
 561
 562         /* Now the normal output. */
 563         ei_obp(count & 0xff, base + EN0_RCNTLO);
 564         ei_obp(count >> 8,   base + EN0_RCNTHI);
 565         ei_obp(0x00, base + EN0_RSARLO);
 566         ei_obp(start_page, base + EN0_RSARHI);
 567 #endif /* 0/1 */
 568
 569         ei_obp(E8390_RWRITE + E8390_START, base + E8390_CMD);
 570         if (ei_status.word16) {
 571                 ei_osw(E8390_BASE + E8390_DATA, buf, count >> 1);
 572         } else {
 573                 ei_osb(E8390_BASE + E8390_DATA, buf, count);
 574         }
 575
 576 #ifdef OAKNET_DISINT
 577         restore_flags(flags);
 578 #endif
 579
 580         start = jiffies;
 581
 582 #ifdef OAKNET_HEADCHECK
 583         /*
 584          * This was for the ALPHA version only, but enough people have
 585          * been encountering problems so it is still here.
 586          */
 587
 588         {
 589                 /* DMA termination address check... */
 590                 int addr, tries = 20;
 591                 do {
 592                         int high = ei_ibp(base + EN0_RSARHI);
 593                         int low = ei_ibp(base + EN0_RSARLO);
 594                         addr = (high << 8) + low;
 595                         if ((start_page << 8) + count == addr)
 596                                 break;
 597                 } while (--tries > 0);
 598
 599                 if (tries <= 0) {
 600                         printk("%s: Tx packet transfer address mismatch,"
 601                                "%#4.4x (expected) vs. %#4.4x (actual).\n",
 602                                dev->name, (start_page << 8) + count, addr);
 603                         if (retries++ == 0)
 604                                 goto retry;
 605                 }
 606         }
 607 #endif
 608
 609         while ((ei_ibp(base + EN0_ISR) & ENISR_RDC) == 0) {
 610                 if (time_after(jiffies, start + OAKNET_WAIT)) {
 611                         printk("%s: timeout waiting for Tx RDC.\n", dev->name);
 612                         oaknet_reset_8390(dev);
 613                         NS8390_init(dev, TRUE);
 614                         break;
 615                 }
 616         }
 617
 618         ei_obp(ENISR_RDC, base + EN0_ISR);      /* Ack intr. */
 619         ei_status.dmaing &= ~0x01;
 620 }
 621
 622 /*
 623  * static void oaknet_dma_error()
 624  *
 625  * Description:
 626  *   This routine prints out a last-ditch informative message to the console
 627  *   indicating that a DMA error occurred. If you see this, it's the last
 628  *   thing you'll see.
 629  *
 630  * Input(s):
 631  *  *dev  - Pointer to the device structure for this driver.
 632  *  *name - Informative text (e.g. function name) indicating where the
 633  *          DMA error occurred.
 634  *
 635  * Output(s):
 636  *   N/A
 637  *
 638  * Returns:
 639  *   N/A
 640  *
 641  */
 642 static void
 643 oaknet_dma_error(struct net_device *dev, const char *name)
 644 {
 645         printk(KERN_EMERG "%s: DMAing conflict in %s."
 646                "[DMAstat:%d][irqlock:%d][intr:%ld]\n",
 647                dev->name, name, ei_status.dmaing, ei_status.irqlock,
 648                dev->interrupt);
 649 }
 650
 651 /*
 652  * Oak Ethernet module unload interface.
 653  */
 654 static void __exit oaknet_cleanup_module (void)
 655 {
 656         /* Convert to loop once driver supports multiple devices. */
 657         unregister_netdev(oaknet_dev);
 658         free_irq(oaknet_devs->irq, oaknet_devs);
 659         release_region(oaknet_devs->base_addr, OAKNET_IO_SIZE);
 660         iounmap(ioaddr);
 661         free_netdev(oaknet_devs);
 662 }
 663
 664 module_init(oaknet_init);
 665 module_exit(oaknet_cleanup_module);
 666 MODULE_LICENSE("GPL");