drivers/net/ethernet/cirrus/mac89x0.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
readreg_io
writereg_io
readreg
writereg
mac89x0_device_probe
net_open
net_send_packet
net_interrupt
net_rx
net_close
net_get_stats
set_multicast_list
set_mac_address
mac89x0_device_remove
   1 /* mac89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */
   2 /*
   3         Written 1996 by Russell Nelson, with reference to skeleton.c
   4         written 1993-1994 by Donald Becker.
   5 
   6         This software may be used and distributed according to the terms
   7         of the GNU General Public License, incorporated herein by reference.
   8 
   9         The author may be reached at nelson@crynwr.com, Crynwr
  10         Software, 11 Grant St., Potsdam, NY 13676
  11 
  12   Changelog:
  13 
  14   Mike Cruse        : mcruse@cti-ltd.com
  15                     : Changes for Linux 2.0 compatibility.
  16                     : Added dev_id parameter in net_interrupt(),
  17                     : request_irq() and free_irq(). Just NULL for now.
  18 
  19   Mike Cruse        : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
  20                     : in net_open() and net_close() so kerneld would know
  21                     : that the module is in use and wouldn't eject the
  22                     : driver prematurely.
  23 
  24   Mike Cruse        : Rewrote init_module() and cleanup_module using 8390.c
  25                     : as an example. Disabled autoprobing in init_module(),
  26                     : not a good thing to do to other devices while Linux
  27                     : is running from all accounts.
  28 
  29   Alan Cox          : Removed 1.2 support, added 2.1 extra counters.
  30 
  31   David Huggins-Daines <dhd@debian.org>
  32 
  33   Split this off into mac89x0.c, and gutted it of all parts which are
  34   not relevant to the existing CS8900 cards on the Macintosh
  35   (i.e. basically the Daynaport CS and LC cards).  To be precise:
  36 
  37     * Removed all the media-detection stuff, because these cards are
  38     TP-only.
  39 
  40     * Lobotomized the ISA interrupt bogosity, because these cards use
  41     a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
  42 
  43     * Basically eliminated everything not relevant to getting the
  44     cards minimally functioning on the Macintosh.
  45 
  46   I might add that these cards are badly designed even from the Mac
  47   standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
  48   I/O space and NuBus interrupts for these cards, but neglected to
  49   provide anything even remotely resembling a NuBus ROM.  Therefore we
  50   have to probe for them in a brain-damaged ISA-like fashion.
  51 
  52   Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
  53   check kmalloc and release the allocated memory on failure in
  54   mac89x0_probe and in init_module
  55   use local_irq_{save,restore}(flags) in net_get_stat, not just
  56   local_irq_{dis,en}able()
  57 */
  58 
  59 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  60 
  61 static const char version[] =
  62 "cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
  63 
  64 #include <linux/module.h>
  65 
  66 /*
  67   Sources:
  68 
  69         Crynwr packet driver epktisa.
  70 
  71         Crystal Semiconductor data sheets.
  72 
  73 */
  74 
  75 #include <linux/kernel.h>
  76 #include <linux/types.h>
  77 #include <linux/fcntl.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/ioport.h>
  80 #include <linux/in.h>
  81 #include <linux/string.h>
  82 #include <linux/nubus.h>
  83 #include <linux/errno.h>
  84 #include <linux/init.h>
  85 #include <linux/netdevice.h>
  86 #include <linux/platform_device.h>
  87 #include <linux/etherdevice.h>
  88 #include <linux/skbuff.h>
  89 #include <linux/delay.h>
  90 #include <linux/bitops.h>
  91 #include <linux/gfp.h>
  92 
  93 #include <asm/io.h>
  94 #include <asm/hwtest.h>
  95 #include <asm/macints.h>
  96 
  97 #include "cs89x0.h"
  98 
  99 static int debug = -1;
 100 module_param(debug, int, 0);
 101 MODULE_PARM_DESC(debug, "debug message level");
 102 
 103 /* Information that need to be kept for each board. */
 104 struct net_local {
 105         int msg_enable;
 106         int chip_type;          /* one of: CS8900, CS8920, CS8920M */
 107         char chip_revision;     /* revision letter of the chip ('A'...) */
 108         int send_cmd;           /* the propercommand used to send a packet. */
 109         int rx_mode;
 110         int curr_rx_cfg;
 111         int send_underrun;      /* keep track of how many underruns in a row we get */
 112 };
 113 
 114 /* Index to functions, as function prototypes. */
 115 static int net_open(struct net_device *dev);
 116 static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev);
 117 static irqreturn_t net_interrupt(int irq, void *dev_id);
 118 static void set_multicast_list(struct net_device *dev);
 119 static void net_rx(struct net_device *dev);
 120 static int net_close(struct net_device *dev);
 121 static struct net_device_stats *net_get_stats(struct net_device *dev);
 122 static int set_mac_address(struct net_device *dev, void *addr);
 123 
 124 /* For reading/writing registers ISA-style */
 125 static inline int
 126 readreg_io(struct net_device *dev, int portno)
 127 {
 128         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 129         return swab16(nubus_readw(dev->base_addr + DATA_PORT));
 130 }
 131 
 132 static inline void
 133 writereg_io(struct net_device *dev, int portno, int value)
 134 {
 135         nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
 136         nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
 137 }
 138 
 139 /* These are for reading/writing registers in shared memory */
 140 static inline int
 141 readreg(struct net_device *dev, int portno)
 142 {
 143         return swab16(nubus_readw(dev->mem_start + portno));
 144 }
 145 
 146 static inline void
 147 writereg(struct net_device *dev, int portno, int value)
 148 {
 149         nubus_writew(swab16(value), dev->mem_start + portno);
 150 }
 151 
 152 static const struct net_device_ops mac89x0_netdev_ops = {
 153         .ndo_open               = net_open,
 154         .ndo_stop               = net_close,
 155         .ndo_start_xmit         = net_send_packet,
 156         .ndo_get_stats          = net_get_stats,
 157         .ndo_set_rx_mode        = set_multicast_list,
 158         .ndo_set_mac_address    = set_mac_address,
 159         .ndo_validate_addr      = eth_validate_addr,
 160 };
 161 
 162 /* Probe for the CS8900 card in slot E.  We won't bother looking
 163    anywhere else until we have a really good reason to do so. */
 164 static int mac89x0_device_probe(struct platform_device *pdev)
 165 {
 166         struct net_device *dev;
 167         struct net_local *lp;
 168         int i, slot;
 169         unsigned rev_type = 0;
 170         unsigned long ioaddr;
 171         unsigned short sig;
 172         int err = -ENODEV;
 173         struct nubus_rsrc *fres;
 174 
 175         dev = alloc_etherdev(sizeof(struct net_local));
 176         if (!dev)
 177                 return -ENOMEM;
 178 
 179         /* We might have to parameterize this later */
 180         slot = 0xE;
 181         /* Get out now if there's a real NuBus card in slot E */
 182         for_each_func_rsrc(fres)
 183                 if (fres->board->slot == slot)
 184                         goto out;
 185 
 186         /* The pseudo-ISA bits always live at offset 0x300 (gee,
 187            wonder why...) */
 188         ioaddr = (unsigned long)
 189                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
 190         {
 191                 int card_present;
 192 
 193                 card_present = (hwreg_present((void *)ioaddr + 4) &&
 194                                 hwreg_present((void *)ioaddr + DATA_PORT));
 195                 if (!card_present)
 196                         goto out;
 197         }
 198 
 199         nubus_writew(0, ioaddr + ADD_PORT);
 200         sig = nubus_readw(ioaddr + DATA_PORT);
 201         if (sig != swab16(CHIP_EISA_ID_SIG))
 202                 goto out;
 203 
 204         SET_NETDEV_DEV(dev, &pdev->dev);
 205 
 206         /* Initialize the net_device structure. */
 207         lp = netdev_priv(dev);
 208 
 209         lp->msg_enable = netif_msg_init(debug, 0);
 210 
 211         /* Fill in the 'dev' fields. */
 212         dev->base_addr = ioaddr;
 213         dev->mem_start = (unsigned long)
 214                 nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
 215         dev->mem_end = dev->mem_start + 0x1000;
 216 
 217         /* Turn on shared memory */
 218         writereg_io(dev, PP_BusCTL, MEMORY_ON);
 219 
 220         /* get the chip type */
 221         rev_type = readreg(dev, PRODUCT_ID_ADD);
 222         lp->chip_type = rev_type &~ REVISON_BITS;
 223         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 224 
 225         /* Check the chip type and revision in order to set the correct send command
 226         CS8920 revision C and CS8900 revision F can use the faster send. */
 227         lp->send_cmd = TX_AFTER_381;
 228         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
 229                 lp->send_cmd = TX_NOW;
 230         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
 231                 lp->send_cmd = TX_NOW;
 232 
 233         netif_dbg(lp, drv, dev, "%s", version);
 234 
 235         pr_info("cs89%c0%s rev %c found at %#8lx\n",
 236                 lp->chip_type == CS8900 ? '0' : '2',
 237                 lp->chip_type == CS8920M ? "M" : "",
 238                 lp->chip_revision, dev->base_addr);
 239 
 240         /* Try to read the MAC address */
 241         if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
 242                 pr_info("No EEPROM, giving up now.\n");
 243                 goto out1;
 244         } else {
 245                 for (i = 0; i < ETH_ALEN; i += 2) {
 246                         /* Big-endian (why??!) */
 247                         unsigned short s = readreg(dev, PP_IA + i);
 248                         dev->dev_addr[i] = s >> 8;
 249                         dev->dev_addr[i+1] = s & 0xff;
 250                 }
 251         }
 252 
 253         dev->irq = SLOT2IRQ(slot);
 254 
 255         /* print the IRQ and ethernet address. */
 256 
 257         pr_info("MAC %pM, IRQ %d\n", dev->dev_addr, dev->irq);
 258 
 259         dev->netdev_ops         = &mac89x0_netdev_ops;
 260 
 261         err = register_netdev(dev);
 262         if (err)
 263                 goto out1;
 264 
 265         platform_set_drvdata(pdev, dev);
 266         return 0;
 267 out1:
 268         nubus_writew(0, dev->base_addr + ADD_PORT);
 269 out:
 270         free_netdev(dev);
 271         return err;
 272 }
 273 
 274 /* Open/initialize the board.  This is called (in the current kernel)
 275    sometime after booting when the 'ifconfig' program is run.
 276 
 277    This routine should set everything up anew at each open, even
 278    registers that "should" only need to be set once at boot, so that
 279    there is non-reboot way to recover if something goes wrong.
 280    */
 281 static int
 282 net_open(struct net_device *dev)
 283 {
 284         struct net_local *lp = netdev_priv(dev);
 285         int i;
 286 
 287         /* Disable the interrupt for now */
 288         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
 289 
 290         /* Grab the interrupt */
 291         if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
 292                 return -EAGAIN;
 293 
 294         /* Set up the IRQ - Apparently magic */
 295         if (lp->chip_type == CS8900)
 296                 writereg(dev, PP_CS8900_ISAINT, 0);
 297         else
 298                 writereg(dev, PP_CS8920_ISAINT, 0);
 299 
 300         /* set the Ethernet address */
 301         for (i=0; i < ETH_ALEN/2; i++)
 302                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 303 
 304         /* Turn on both receive and transmit operations */
 305         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
 306 
 307         /* Receive only error free packets addressed to this card */
 308         lp->rx_mode = 0;
 309         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
 310 
 311         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
 312 
 313         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
 314 
 315         writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
 316                TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
 317 
 318         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
 319                  TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
 320 
 321         /* now that we've got our act together, enable everything */
 322         writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
 323         netif_start_queue(dev);
 324         return 0;
 325 }
 326 
 327 static netdev_tx_t
 328 net_send_packet(struct sk_buff *skb, struct net_device *dev)
 329 {
 330         struct net_local *lp = netdev_priv(dev);
 331         unsigned long flags;
 332 
 333         netif_dbg(lp, tx_queued, dev, "sent %d byte packet of type %x\n",
 334                   skb->len, skb->data[ETH_ALEN + ETH_ALEN] << 8 |
 335                   skb->data[ETH_ALEN + ETH_ALEN + 1]);
 336 
 337         /* keep the upload from being interrupted, since we
 338            ask the chip to start transmitting before the
 339            whole packet has been completely uploaded. */
 340         local_irq_save(flags);
 341         netif_stop_queue(dev);
 342 
 343         /* initiate a transmit sequence */
 344         writereg(dev, PP_TxCMD, lp->send_cmd);
 345         writereg(dev, PP_TxLength, skb->len);
 346 
 347         /* Test to see if the chip has allocated memory for the packet */
 348         if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
 349                 /* Gasp!  It hasn't.  But that shouldn't happen since
 350                    we're waiting for TxOk, so return 1 and requeue this packet. */
 351                 local_irq_restore(flags);
 352                 return NETDEV_TX_BUSY;
 353         }
 354 
 355         /* Write the contents of the packet */
 356         skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
 357                                   skb->len+1);
 358 
 359         local_irq_restore(flags);
 360         dev_kfree_skb (skb);
 361 
 362         return NETDEV_TX_OK;
 363 }
 364 
 365 /* The typical workload of the driver:
 366    Handle the network interface interrupts. */
 367 static irqreturn_t net_interrupt(int irq, void *dev_id)
 368 {
 369         struct net_device *dev = dev_id;
 370         struct net_local *lp;
 371         int ioaddr, status;
 372 
 373         ioaddr = dev->base_addr;
 374         lp = netdev_priv(dev);
 375 
 376         /* we MUST read all the events out of the ISQ, otherwise we'll never
 377            get interrupted again.  As a consequence, we can't have any limit
 378            on the number of times we loop in the interrupt handler.  The
 379            hardware guarantees that eventually we'll run out of events.  Of
 380            course, if you're on a slow machine, and packets are arriving
 381            faster than you can read them off, you're screwed.  Hasta la
 382            vista, baby!  */
 383         while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
 384                 netif_dbg(lp, intr, dev, "status=%04x\n", status);
 385                 switch(status & ISQ_EVENT_MASK) {
 386                 case ISQ_RECEIVER_EVENT:
 387                         /* Got a packet(s). */
 388                         net_rx(dev);
 389                         break;
 390                 case ISQ_TRANSMITTER_EVENT:
 391                         dev->stats.tx_packets++;
 392                         netif_wake_queue(dev);
 393                         if ((status & TX_OK) == 0)
 394                                 dev->stats.tx_errors++;
 395                         if (status & TX_LOST_CRS)
 396                                 dev->stats.tx_carrier_errors++;
 397                         if (status & TX_SQE_ERROR)
 398                                 dev->stats.tx_heartbeat_errors++;
 399                         if (status & TX_LATE_COL)
 400                                 dev->stats.tx_window_errors++;
 401                         if (status & TX_16_COL)
 402                                 dev->stats.tx_aborted_errors++;
 403                         break;
 404                 case ISQ_BUFFER_EVENT:
 405                         if (status & READY_FOR_TX) {
 406                                 /* we tried to transmit a packet earlier,
 407                                    but inexplicably ran out of buffers.
 408                                    That shouldn't happen since we only ever
 409                                    load one packet.  Shrug.  Do the right
 410                                    thing anyway. */
 411                                 netif_wake_queue(dev);
 412                         }
 413                         if (status & TX_UNDERRUN) {
 414                                 netif_dbg(lp, tx_err, dev, "transmit underrun\n");
 415                                 lp->send_underrun++;
 416                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
 417                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
 418                         }
 419                         break;
 420                 case ISQ_RX_MISS_EVENT:
 421                         dev->stats.rx_missed_errors += (status >> 6);
 422                         break;
 423                 case ISQ_TX_COL_EVENT:
 424                         dev->stats.collisions += (status >> 6);
 425                         break;
 426                 }
 427         }
 428         return IRQ_HANDLED;
 429 }
 430 
 431 /* We have a good packet(s), get it/them out of the buffers. */
 432 static void
 433 net_rx(struct net_device *dev)
 434 {
 435         struct net_local *lp = netdev_priv(dev);
 436         struct sk_buff *skb;
 437         int status, length;
 438 
 439         status = readreg(dev, PP_RxStatus);
 440         if ((status & RX_OK) == 0) {
 441                 dev->stats.rx_errors++;
 442                 if (status & RX_RUNT)
 443                                 dev->stats.rx_length_errors++;
 444                 if (status & RX_EXTRA_DATA)
 445                                 dev->stats.rx_length_errors++;
 446                 if ((status & RX_CRC_ERROR) &&
 447                     !(status & (RX_EXTRA_DATA|RX_RUNT)))
 448                         /* per str 172 */
 449                         dev->stats.rx_crc_errors++;
 450                 if (status & RX_DRIBBLE)
 451                                 dev->stats.rx_frame_errors++;
 452                 return;
 453         }
 454 
 455         length = readreg(dev, PP_RxLength);
 456         /* Malloc up new buffer. */
 457         skb = alloc_skb(length, GFP_ATOMIC);
 458         if (skb == NULL) {
 459                 dev->stats.rx_dropped++;
 460                 return;
 461         }
 462         skb_put(skb, length);
 463 
 464         skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
 465                                 length);
 466 
 467         netif_dbg(lp, rx_status, dev, "received %d byte packet of type %x\n",
 468                   length, skb->data[ETH_ALEN + ETH_ALEN] << 8 |
 469                   skb->data[ETH_ALEN + ETH_ALEN + 1]);
 470 
 471         skb->protocol=eth_type_trans(skb,dev);
 472         netif_rx(skb);
 473         dev->stats.rx_packets++;
 474         dev->stats.rx_bytes += length;
 475 }
 476 
 477 /* The inverse routine to net_open(). */
 478 static int
 479 net_close(struct net_device *dev)
 480 {
 481 
 482         writereg(dev, PP_RxCFG, 0);
 483         writereg(dev, PP_TxCFG, 0);
 484         writereg(dev, PP_BufCFG, 0);
 485         writereg(dev, PP_BusCTL, 0);
 486 
 487         netif_stop_queue(dev);
 488 
 489         free_irq(dev->irq, dev);
 490 
 491         /* Update the statistics here. */
 492 
 493         return 0;
 494 
 495 }
 496 
 497 /* Get the current statistics.  This may be called with the card open or
 498    closed. */
 499 static struct net_device_stats *
 500 net_get_stats(struct net_device *dev)
 501 {
 502         unsigned long flags;
 503 
 504         local_irq_save(flags);
 505         /* Update the statistics from the device registers. */
 506         dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
 507         dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
 508         local_irq_restore(flags);
 509 
 510         return &dev->stats;
 511 }
 512 
 513 static void set_multicast_list(struct net_device *dev)
 514 {
 515         struct net_local *lp = netdev_priv(dev);
 516 
 517         if(dev->flags&IFF_PROMISC)
 518         {
 519                 lp->rx_mode = RX_ALL_ACCEPT;
 520         } else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
 521                 /* The multicast-accept list is initialized to accept-all, and we
 522                    rely on higher-level filtering for now. */
 523                 lp->rx_mode = RX_MULTCAST_ACCEPT;
 524         }
 525         else
 526                 lp->rx_mode = 0;
 527 
 528         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
 529 
 530         /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
 531         writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
 532              (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
 533 }
 534 
 535 
 536 static int set_mac_address(struct net_device *dev, void *addr)
 537 {
 538         struct sockaddr *saddr = addr;
 539         int i;
 540 
 541         if (!is_valid_ether_addr(saddr->sa_data))
 542                 return -EADDRNOTAVAIL;
 543 
 544         memcpy(dev->dev_addr, saddr->sa_data, ETH_ALEN);
 545         netdev_info(dev, "Setting MAC address to %pM\n", dev->dev_addr);
 546 
 547         /* set the Ethernet address */
 548         for (i=0; i < ETH_ALEN/2; i++)
 549                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
 550 
 551         return 0;
 552 }
 553 
 554 MODULE_LICENSE("GPL");
 555 
 556 static int mac89x0_device_remove(struct platform_device *pdev)
 557 {
 558         struct net_device *dev = platform_get_drvdata(pdev);
 559 
 560         unregister_netdev(dev);
 561         nubus_writew(0, dev->base_addr + ADD_PORT);
 562         free_netdev(dev);
 563         return 0;
 564 }
 565 
 566 static struct platform_driver mac89x0_platform_driver = {
 567         .probe = mac89x0_device_probe,
 568         .remove = mac89x0_device_remove,
 569         .driver = {
 570                 .name = "mac89x0",
 571         },
 572 };
 573 
 574 module_platform_driver(mac89x0_platform_driver);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/net/ethernet/cirrus/mac89x0.c

DEFINITIONS
