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