drivers/net/sgiseeq.c

   1 /*
   2  * sgiseeq.c: Seeq8003 ethernet driver for SGI machines.
   3  *
   4  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
   5  */
   6
   7 #undef DEBUG
   8
   9 #include <linux/kernel.h>
  10 #include <linux/module.h>
  11 #include <linux/errno.h>
  12 #include <linux/init.h>
  13 #include <linux/types.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/slab.h>
  16 #include <linux/string.h>
  17 #include <linux/delay.h>
  18 #include <linux/netdevice.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/skbuff.h>
  22
  23 #include <asm/sgi/hpc3.h>
  24 #include <asm/sgi/ip22.h>
  25 #include <asm/sgi/seeq.h>
  26
  27 #include "sgiseeq.h"
  28
  29 static char *sgiseeqstr = "SGI Seeq8003";
  30
  31 /*
  32  * If you want speed, you do something silly, it always has worked for me.  So,
  33  * with that in mind, I've decided to make this driver look completely like a
  34  * stupid Lance from a driver architecture perspective.  Only difference is that
  35  * here our "ring buffer" looks and acts like a real Lance one does but is
  36  * layed out like how the HPC DMA and the Seeq want it to.  You'd be surprised
  37  * how a stupid idea like this can pay off in performance, not to mention
  38  * making this driver 2,000 times easier to write. ;-)
  39  */
  40
  41 /* Tune these if we tend to run out often etc. */
  42 #define SEEQ_RX_BUFFERS  16
  43 #define SEEQ_TX_BUFFERS  16
  44
  45 #define PKT_BUF_SZ       1584
  46
  47 #define NEXT_RX(i)  (((i) + 1) & (SEEQ_RX_BUFFERS - 1))
  48 #define NEXT_TX(i)  (((i) + 1) & (SEEQ_TX_BUFFERS - 1))
  49 #define PREV_RX(i)  (((i) - 1) & (SEEQ_RX_BUFFERS - 1))
  50 #define PREV_TX(i)  (((i) - 1) & (SEEQ_TX_BUFFERS - 1))
  51
  52 #define TX_BUFFS_AVAIL(sp) ((sp->tx_old <= sp->tx_new) ? \
  53                             sp->tx_old + (SEEQ_TX_BUFFERS - 1) - sp->tx_new : \
  54                             sp->tx_old - sp->tx_new - 1)
  55
  56 struct sgiseeq_rx_desc {
  57         volatile struct hpc_dma_desc rdma;
  58         volatile signed int buf_vaddr;
  59 };
  60
  61 struct sgiseeq_tx_desc {
  62         volatile struct hpc_dma_desc tdma;
  63         volatile signed int buf_vaddr;
  64 };
  65
  66 /*
  67  * Warning: This structure is layed out in a certain way because HPC dma
  68  *          descriptors must be 8-byte aligned.  So don't touch this without
  69  *          some care.
  70  */
  71 struct sgiseeq_init_block { /* Note the name ;-) */
  72         struct sgiseeq_rx_desc rxvector[SEEQ_RX_BUFFERS];
  73         struct sgiseeq_tx_desc txvector[SEEQ_TX_BUFFERS];
  74 };
  75
  76 struct sgiseeq_private {
  77         struct sgiseeq_init_block *srings;
  78         dma_addr_t srings_dma;
  79
  80         /* Ptrs to the descriptors in uncached space. */
  81         struct sgiseeq_rx_desc *rx_desc;
  82         struct sgiseeq_tx_desc *tx_desc;
  83
  84         char *name;
  85         struct hpc3_ethregs *hregs;
  86         struct sgiseeq_regs *sregs;
  87
  88         /* Ring entry counters. */
  89         unsigned int rx_new, tx_new;
  90         unsigned int rx_old, tx_old;
  91
  92         int is_edlc;
  93         unsigned char control;
  94         unsigned char mode;
  95
  96         spinlock_t tx_lock;
  97 };
  98
  99 static inline void hpc3_eth_reset(struct hpc3_ethregs *hregs)
 100 {
 101         hregs->reset = HPC3_ERST_CRESET | HPC3_ERST_CLRIRQ;
 102         udelay(20);
 103         hregs->reset = 0;
 104 }
 105
 106 static inline void reset_hpc3_and_seeq(struct hpc3_ethregs *hregs,
 107                                        struct sgiseeq_regs *sregs)
 108 {
 109         hregs->rx_ctrl = hregs->tx_ctrl = 0;
 110         hpc3_eth_reset(hregs);
 111 }
 112
 113 #define RSTAT_GO_BITS (SEEQ_RCMD_IGOOD | SEEQ_RCMD_IEOF | SEEQ_RCMD_ISHORT | \
 114                        SEEQ_RCMD_IDRIB | SEEQ_RCMD_ICRC)
 115
 116 static inline void seeq_go(struct sgiseeq_private *sp,
 117                            struct hpc3_ethregs *hregs,
 118                            struct sgiseeq_regs *sregs)
 119 {
 120         sregs->rstat = sp->mode | RSTAT_GO_BITS;
 121         hregs->rx_ctrl = HPC3_ERXCTRL_ACTIVE;
 122 }
 123
 124 static inline void __sgiseeq_set_mac_address(struct net_device *dev)
 125 {
 126         struct sgiseeq_private *sp = netdev_priv(dev);
 127         struct sgiseeq_regs *sregs = sp->sregs;
 128         int i;
 129
 130         sregs->tstat = SEEQ_TCMD_RB0;
 131         for (i = 0; i < 6; i++)
 132                 sregs->rw.eth_addr[i] = dev->dev_addr[i];
 133 }
 134
 135 static int sgiseeq_set_mac_address(struct net_device *dev, void *addr)
 136 {
 137         struct sgiseeq_private *sp = netdev_priv(dev);
 138         struct sockaddr *sa = addr;
 139
 140         memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
 141
 142         spin_lock_irq(&sp->tx_lock);
 143         __sgiseeq_set_mac_address(dev);
 144         spin_unlock_irq(&sp->tx_lock);
 145
 146         return 0;
 147 }
 148
 149 #define TCNTINFO_INIT (HPCDMA_EOX | HPCDMA_ETXD)
 150 #define RCNTCFG_INIT  (HPCDMA_OWN | HPCDMA_EORP | HPCDMA_XIE)
 151 #define RCNTINFO_INIT (RCNTCFG_INIT | (PKT_BUF_SZ & HPCDMA_BCNT))
 152
 153 static int seeq_init_ring(struct net_device *dev)
 154 {
 155         struct sgiseeq_private *sp = netdev_priv(dev);
 156         int i;
 157
 158         netif_stop_queue(dev);
 159         sp->rx_new = sp->tx_new = 0;
 160         sp->rx_old = sp->tx_old = 0;
 161
 162         __sgiseeq_set_mac_address(dev);
 163
 164         /* Setup tx ring. */
 165         for(i = 0; i < SEEQ_TX_BUFFERS; i++) {
 166                 if (!sp->tx_desc[i].tdma.pbuf) {
 167                         unsigned long buffer;
 168
 169                         buffer = (unsigned long) kmalloc(PKT_BUF_SZ, GFP_KERNEL);
 170                         if (!buffer)
 171                                 return -ENOMEM;
 172                         sp->tx_desc[i].buf_vaddr = CKSEG1ADDR(buffer);
 173                         sp->tx_desc[i].tdma.pbuf = CPHYSADDR(buffer);
 174                 }
 175                 sp->tx_desc[i].tdma.cntinfo = TCNTINFO_INIT;
 176         }
 177
 178         /* And now the rx ring. */
 179         for (i = 0; i < SEEQ_RX_BUFFERS; i++) {
 180                 if (!sp->rx_desc[i].rdma.pbuf) {
 181                         unsigned long buffer;
 182
 183                         buffer = (unsigned long) kmalloc(PKT_BUF_SZ, GFP_KERNEL);
 184                         if (!buffer)
 185                                 return -ENOMEM;
 186                         sp->rx_desc[i].buf_vaddr = CKSEG1ADDR(buffer);
 187                         sp->rx_desc[i].rdma.pbuf = CPHYSADDR(buffer);
 188                 }
 189                 sp->rx_desc[i].rdma.cntinfo = RCNTINFO_INIT;
 190         }
 191         sp->rx_desc[i - 1].rdma.cntinfo |= HPCDMA_EOR;
 192         return 0;
 193 }
 194
 195 #ifdef DEBUG
 196 static struct sgiseeq_private *gpriv;
 197 static struct net_device *gdev;
 198
 199 static void sgiseeq_dump_rings(void)
 200 {
 201         static int once;
 202         struct sgiseeq_rx_desc *r = gpriv->rx_desc;
 203         struct sgiseeq_tx_desc *t = gpriv->tx_desc;
 204         struct hpc3_ethregs *hregs = gpriv->hregs;
 205         int i;
 206
 207         if (once)
 208                 return;
 209         once++;
 210         printk("RING DUMP:\n");
 211         for (i = 0; i < SEEQ_RX_BUFFERS; i++) {
 212                 printk("RX [%d]: @(%p) [%08x,%08x,%08x] ",
 213                        i, (&r[i]), r[i].rdma.pbuf, r[i].rdma.cntinfo,
 214                        r[i].rdma.pnext);
 215                 i += 1;
 216                 printk("-- [%d]: @(%p) [%08x,%08x,%08x]\n",
 217                        i, (&r[i]), r[i].rdma.pbuf, r[i].rdma.cntinfo,
 218                        r[i].rdma.pnext);
 219         }
 220         for (i = 0; i < SEEQ_TX_BUFFERS; i++) {
 221                 printk("TX [%d]: @(%p) [%08x,%08x,%08x] ",
 222                        i, (&t[i]), t[i].tdma.pbuf, t[i].tdma.cntinfo,
 223                        t[i].tdma.pnext);
 224                 i += 1;
 225                 printk("-- [%d]: @(%p) [%08x,%08x,%08x]\n",
 226                        i, (&t[i]), t[i].tdma.pbuf, t[i].tdma.cntinfo,
 227                        t[i].tdma.pnext);
 228         }
 229         printk("INFO: [rx_new = %d rx_old=%d] [tx_new = %d tx_old = %d]\n",
 230                gpriv->rx_new, gpriv->rx_old, gpriv->tx_new, gpriv->tx_old);
 231         printk("RREGS: rx_cbptr[%08x] rx_ndptr[%08x] rx_ctrl[%08x]\n",
 232                hregs->rx_cbptr, hregs->rx_ndptr, hregs->rx_ctrl);
 233         printk("TREGS: tx_cbptr[%08x] tx_ndptr[%08x] tx_ctrl[%08x]\n",
 234                hregs->tx_cbptr, hregs->tx_ndptr, hregs->tx_ctrl);
 235 }
 236 #endif
 237
 238 #define TSTAT_INIT_SEEQ (SEEQ_TCMD_IPT|SEEQ_TCMD_I16|SEEQ_TCMD_IC|SEEQ_TCMD_IUF)
 239 #define TSTAT_INIT_EDLC ((TSTAT_INIT_SEEQ) | SEEQ_TCMD_RB2)
 240
 241 static int init_seeq(struct net_device *dev, struct sgiseeq_private *sp,
 242                      struct sgiseeq_regs *sregs)
 243 {
 244         struct hpc3_ethregs *hregs = sp->hregs;
 245         int err;
 246
 247         reset_hpc3_and_seeq(hregs, sregs);
 248         err = seeq_init_ring(dev);
 249         if (err)
 250                 return err;
 251
 252         /* Setup to field the proper interrupt types. */
 253         if (sp->is_edlc) {
 254                 sregs->tstat = TSTAT_INIT_EDLC;
 255                 sregs->rw.wregs.control = sp->control;
 256                 sregs->rw.wregs.frame_gap = 0;
 257         } else {
 258                 sregs->tstat = TSTAT_INIT_SEEQ;
 259         }
 260
 261         hregs->rx_ndptr = CPHYSADDR(sp->rx_desc);
 262         hregs->tx_ndptr = CPHYSADDR(sp->tx_desc);
 263
 264         seeq_go(sp, hregs, sregs);
 265         return 0;
 266 }
 267
 268 static void record_rx_errors(struct net_device *dev, unsigned char status)
 269 {
 270         if (status & SEEQ_RSTAT_OVERF ||
 271             status & SEEQ_RSTAT_SFRAME)
 272                 dev->stats.rx_over_errors++;
 273         if (status & SEEQ_RSTAT_CERROR)
 274                 dev->stats.rx_crc_errors++;
 275         if (status & SEEQ_RSTAT_DERROR)
 276                 dev->stats.rx_frame_errors++;
 277         if (status & SEEQ_RSTAT_REOF)
 278                 dev->stats.rx_errors++;
 279 }
 280
 281 static inline void rx_maybe_restart(struct sgiseeq_private *sp,
 282                                     struct hpc3_ethregs *hregs,
 283                                     struct sgiseeq_regs *sregs)
 284 {
 285         if (!(hregs->rx_ctrl & HPC3_ERXCTRL_ACTIVE)) {
 286                 hregs->rx_ndptr = CPHYSADDR(sp->rx_desc + sp->rx_new);
 287                 seeq_go(sp, hregs, sregs);
 288         }
 289 }
 290
 291 #define for_each_rx(rd, sp) for((rd) = &(sp)->rx_desc[(sp)->rx_new]; \
 292                                 !((rd)->rdma.cntinfo & HPCDMA_OWN); \
 293                                 (rd) = &(sp)->rx_desc[(sp)->rx_new])
 294
 295 static inline void sgiseeq_rx(struct net_device *dev, struct sgiseeq_private *sp,
 296                               struct hpc3_ethregs *hregs,
 297                               struct sgiseeq_regs *sregs)
 298 {
 299         struct sgiseeq_rx_desc *rd;
 300         struct sk_buff *skb = NULL;
 301         unsigned char pkt_status;
 302         unsigned char *pkt_pointer = NULL;
 303         int len = 0;
 304         unsigned int orig_end = PREV_RX(sp->rx_new);
 305
 306         /* Service every received packet. */
 307         for_each_rx(rd, sp) {
 308                 len = PKT_BUF_SZ - (rd->rdma.cntinfo & HPCDMA_BCNT) - 3;
 309                 pkt_pointer = (unsigned char *)(long)rd->buf_vaddr;
 310                 pkt_status = pkt_pointer[len + 2];
 311
 312                 if (pkt_status & SEEQ_RSTAT_FIG) {
 313                         /* Packet is OK. */
 314                         skb = dev_alloc_skb(len + 2);
 315
 316                         if (skb) {
 317                                 skb_reserve(skb, 2);
 318                                 skb_put(skb, len);
 319
 320                                 /* Copy out of kseg1 to avoid silly cache flush. */
 321                                 skb_copy_to_linear_data(skb, pkt_pointer + 2, len);
 322                                 skb->protocol = eth_type_trans(skb, dev);
 323
 324                                 /* We don't want to receive our own packets */
 325                                 if (memcmp(eth_hdr(skb)->h_source, dev->dev_addr, ETH_ALEN)) {
 326                                         netif_rx(skb);
 327                                         dev->last_rx = jiffies;
 328                                         dev->stats.rx_packets++;
 329                                         dev->stats.rx_bytes += len;
 330                                 } else {
 331                                         /* Silently drop my own packets */
 332                                         dev_kfree_skb_irq(skb);
 333                                 }
 334                         } else {
 335                                 printk (KERN_NOTICE "%s: Memory squeeze, deferring packet.\n",
 336                                         dev->name);
 337                                 dev->stats.rx_dropped++;
 338                         }
 339                 } else {
 340                         record_rx_errors(dev, pkt_status);
 341                 }
 342
 343                 /* Return the entry to the ring pool. */
 344                 rd->rdma.cntinfo = RCNTINFO_INIT;
 345                 sp->rx_new = NEXT_RX(sp->rx_new);
 346         }
 347         sp->rx_desc[orig_end].rdma.cntinfo &= ~(HPCDMA_EOR);
 348         sp->rx_desc[PREV_RX(sp->rx_new)].rdma.cntinfo |= HPCDMA_EOR;
 349         rx_maybe_restart(sp, hregs, sregs);
 350 }
 351
 352 static inline void tx_maybe_reset_collisions(struct sgiseeq_private *sp,
 353                                              struct sgiseeq_regs *sregs)
 354 {
 355         if (sp->is_edlc) {
 356                 sregs->rw.wregs.control = sp->control & ~(SEEQ_CTRL_XCNT);
 357                 sregs->rw.wregs.control = sp->control;
 358         }
 359 }
 360
 361 static inline void kick_tx(struct sgiseeq_tx_desc *td,
 362                            struct hpc3_ethregs *hregs)
 363 {
 364         /* If the HPC aint doin nothin, and there are more packets
 365          * with ETXD cleared and XIU set we must make very certain
 366          * that we restart the HPC else we risk locking up the
 367          * adapter.  The following code is only safe iff the HPCDMA
 368          * is not active!
 369          */
 370         while ((td->tdma.cntinfo & (HPCDMA_XIU | HPCDMA_ETXD)) ==
 371               (HPCDMA_XIU | HPCDMA_ETXD))
 372                 td = (struct sgiseeq_tx_desc *)(long) CKSEG1ADDR(td->tdma.pnext);
 373         if (td->tdma.cntinfo & HPCDMA_XIU) {
 374                 hregs->tx_ndptr = CPHYSADDR(td);
 375                 hregs->tx_ctrl = HPC3_ETXCTRL_ACTIVE;
 376         }
 377 }
 378
 379 static inline void sgiseeq_tx(struct net_device *dev, struct sgiseeq_private *sp,
 380                               struct hpc3_ethregs *hregs,
 381                               struct sgiseeq_regs *sregs)
 382 {
 383         struct sgiseeq_tx_desc *td;
 384         unsigned long status = hregs->tx_ctrl;
 385         int j;
 386
 387         tx_maybe_reset_collisions(sp, sregs);
 388
 389         if (!(status & (HPC3_ETXCTRL_ACTIVE | SEEQ_TSTAT_PTRANS))) {
 390                 /* Oops, HPC detected some sort of error. */
 391                 if (status & SEEQ_TSTAT_R16)
 392                         dev->stats.tx_aborted_errors++;
 393                 if (status & SEEQ_TSTAT_UFLOW)
 394                         dev->stats.tx_fifo_errors++;
 395                 if (status & SEEQ_TSTAT_LCLS)
 396                         dev->stats.collisions++;
 397         }
 398
 399         /* Ack 'em... */
 400         for (j = sp->tx_old; j != sp->tx_new; j = NEXT_TX(j)) {
 401                 td = &sp->tx_desc[j];
 402
 403                 if (!(td->tdma.cntinfo & (HPCDMA_XIU)))
 404                         break;
 405                 if (!(td->tdma.cntinfo & (HPCDMA_ETXD))) {
 406                         if (!(status & HPC3_ETXCTRL_ACTIVE)) {
 407                                 hregs->tx_ndptr = CPHYSADDR(td);
 408                                 hregs->tx_ctrl = HPC3_ETXCTRL_ACTIVE;
 409                         }
 410                         break;
 411                 }
 412                 dev->stats.tx_packets++;
 413                 sp->tx_old = NEXT_TX(sp->tx_old);
 414                 td->tdma.cntinfo &= ~(HPCDMA_XIU | HPCDMA_XIE);
 415                 td->tdma.cntinfo |= HPCDMA_EOX;
 416         }
 417 }
 418
 419 static irqreturn_t sgiseeq_interrupt(int irq, void *dev_id)
 420 {
 421         struct net_device *dev = (struct net_device *) dev_id;
 422         struct sgiseeq_private *sp = netdev_priv(dev);
 423         struct hpc3_ethregs *hregs = sp->hregs;
 424         struct sgiseeq_regs *sregs = sp->sregs;
 425
 426         spin_lock(&sp->tx_lock);
 427
 428         /* Ack the IRQ and set software state. */
 429         hregs->reset = HPC3_ERST_CLRIRQ;
 430
 431         /* Always check for received packets. */
 432         sgiseeq_rx(dev, sp, hregs, sregs);
 433
 434         /* Only check for tx acks if we have something queued. */
 435         if (sp->tx_old != sp->tx_new)
 436                 sgiseeq_tx(dev, sp, hregs, sregs);
 437
 438         if ((TX_BUFFS_AVAIL(sp) > 0) && netif_queue_stopped(dev)) {
 439                 netif_wake_queue(dev);
 440         }
 441         spin_unlock(&sp->tx_lock);
 442
 443         return IRQ_HANDLED;
 444 }
 445
 446 static int sgiseeq_open(struct net_device *dev)
 447 {
 448         struct sgiseeq_private *sp = netdev_priv(dev);
 449         struct sgiseeq_regs *sregs = sp->sregs;
 450         unsigned int irq = dev->irq;
 451         int err;
 452
 453         if (request_irq(irq, sgiseeq_interrupt, 0, sgiseeqstr, dev)) {
 454                 printk(KERN_ERR "Seeq8003: Can't get irq %d\n", dev->irq);
 455                 err = -EAGAIN;
 456         }
 457
 458         err = init_seeq(dev, sp, sregs);
 459         if (err)
 460                 goto out_free_irq;
 461
 462         netif_start_queue(dev);
 463
 464         return 0;
 465
 466 out_free_irq:
 467         free_irq(irq, dev);
 468
 469         return err;
 470 }
 471
 472 static int sgiseeq_close(struct net_device *dev)
 473 {
 474         struct sgiseeq_private *sp = netdev_priv(dev);
 475         struct sgiseeq_regs *sregs = sp->sregs;
 476         unsigned int irq = dev->irq;
 477
 478         netif_stop_queue(dev);
 479
 480         /* Shutdown the Seeq. */
 481         reset_hpc3_and_seeq(sp->hregs, sregs);
 482         free_irq(irq, dev);
 483
 484         return 0;
 485 }
 486
 487 static inline int sgiseeq_reset(struct net_device *dev)
 488 {
 489         struct sgiseeq_private *sp = netdev_priv(dev);
 490         struct sgiseeq_regs *sregs = sp->sregs;
 491         int err;
 492
 493         err = init_seeq(dev, sp, sregs);
 494         if (err)
 495                 return err;
 496
 497         dev->trans_start = jiffies;
 498         netif_wake_queue(dev);
 499
 500         return 0;
 501 }
 502
 503 static int sgiseeq_start_xmit(struct sk_buff *skb, struct net_device *dev)
 504 {
 505         struct sgiseeq_private *sp = netdev_priv(dev);
 506         struct hpc3_ethregs *hregs = sp->hregs;
 507         unsigned long flags;
 508         struct sgiseeq_tx_desc *td;
 509         int skblen, len, entry;
 510
 511         spin_lock_irqsave(&sp->tx_lock, flags);
 512
 513         /* Setup... */
 514         skblen = skb->len;
 515         len = (skblen <= ETH_ZLEN) ? ETH_ZLEN : skblen;
 516         dev->stats.tx_bytes += len;
 517         entry = sp->tx_new;
 518         td = &sp->tx_desc[entry];
 519
 520         /* Create entry.  There are so many races with adding a new
 521          * descriptor to the chain:
 522          * 1) Assume that the HPC is off processing a DMA chain while
 523          *    we are changing all of the following.
 524          * 2) Do no allow the HPC to look at a new descriptor until
 525          *    we have completely set up it's state.  This means, do
 526          *    not clear HPCDMA_EOX in the current last descritptor
 527          *    until the one we are adding looks consistent and could
 528          *    be processes right now.
 529          * 3) The tx interrupt code must notice when we've added a new
 530          *    entry and the HPC got to the end of the chain before we
 531          *    added this new entry and restarted it.
 532          */
 533         skb_copy_from_linear_data(skb, (char *)(long)td->buf_vaddr, skblen);
 534         if (len != skblen)
 535                 memset((char *)(long)td->buf_vaddr + skb->len, 0, len-skblen);
 536         td->tdma.cntinfo = (len & HPCDMA_BCNT) |
 537                            HPCDMA_XIU | HPCDMA_EOXP | HPCDMA_XIE | HPCDMA_EOX;
 538         if (sp->tx_old != sp->tx_new) {
 539                 struct sgiseeq_tx_desc *backend;
 540
 541                 backend = &sp->tx_desc[PREV_TX(sp->tx_new)];
 542                 backend->tdma.cntinfo &= ~HPCDMA_EOX;
 543         }
 544         sp->tx_new = NEXT_TX(sp->tx_new); /* Advance. */
 545
 546         /* Maybe kick the HPC back into motion. */
 547         if (!(hregs->tx_ctrl & HPC3_ETXCTRL_ACTIVE))
 548                 kick_tx(&sp->tx_desc[sp->tx_old], hregs);
 549
 550         dev->trans_start = jiffies;
 551         dev_kfree_skb(skb);
 552
 553         if (!TX_BUFFS_AVAIL(sp))
 554                 netif_stop_queue(dev);
 555         spin_unlock_irqrestore(&sp->tx_lock, flags);
 556
 557         return 0;
 558 }
 559
 560 static void timeout(struct net_device *dev)
 561 {
 562         printk(KERN_NOTICE "%s: transmit timed out, resetting\n", dev->name);
 563         sgiseeq_reset(dev);
 564
 565         dev->trans_start = jiffies;
 566         netif_wake_queue(dev);
 567 }
 568
 569 static void sgiseeq_set_multicast(struct net_device *dev)
 570 {
 571         struct sgiseeq_private *sp = (struct sgiseeq_private *) dev->priv;
 572         unsigned char oldmode = sp->mode;
 573
 574         if(dev->flags & IFF_PROMISC)
 575                 sp->mode = SEEQ_RCMD_RANY;
 576         else if ((dev->flags & IFF_ALLMULTI) || dev->mc_count)
 577                 sp->mode = SEEQ_RCMD_RBMCAST;
 578         else
 579                 sp->mode = SEEQ_RCMD_RBCAST;
 580
 581         /* XXX I know this sucks, but is there a better way to reprogram
 582          * XXX the receiver? At least, this shouldn't happen too often.
 583          */
 584
 585         if (oldmode != sp->mode)
 586                 sgiseeq_reset(dev);
 587 }
 588
 589 static inline void setup_tx_ring(struct sgiseeq_tx_desc *buf, int nbufs)
 590 {
 591         int i = 0;
 592
 593         while (i < (nbufs - 1)) {
 594                 buf[i].tdma.pnext = CPHYSADDR(buf + i + 1);
 595                 buf[i].tdma.pbuf = 0;
 596                 i++;
 597         }
 598         buf[i].tdma.pnext = CPHYSADDR(buf);
 599 }
 600
 601 static inline void setup_rx_ring(struct sgiseeq_rx_desc *buf, int nbufs)
 602 {
 603         int i = 0;
 604
 605         while (i < (nbufs - 1)) {
 606                 buf[i].rdma.pnext = CPHYSADDR(buf + i + 1);
 607                 buf[i].rdma.pbuf = 0;
 608                 i++;
 609         }
 610         buf[i].rdma.pbuf = 0;
 611         buf[i].rdma.pnext = CPHYSADDR(buf);
 612 }
 613
 614 #define ALIGNED(x)  ((((unsigned long)(x)) + 0xf) & ~(0xf))
 615
 616 static int __init sgiseeq_probe(struct platform_device *pdev)
 617 {
 618         struct sgiseeq_platform_data *pd = pdev->dev.platform_data;
 619         struct hpc3_regs *hpcregs = pd->hpc;
 620         struct sgiseeq_init_block *sr;
 621         unsigned int irq = pd->irq;
 622         struct sgiseeq_private *sp;
 623         struct net_device *dev;
 624         int err, i;
 625         DECLARE_MAC_BUF(mac);
 626
 627         dev = alloc_etherdev(sizeof (struct sgiseeq_private));
 628         if (!dev) {
 629                 printk(KERN_ERR "Sgiseeq: Etherdev alloc failed, aborting.\n");
 630                 err = -ENOMEM;
 631                 goto err_out;
 632         }
 633
 634         platform_set_drvdata(pdev, dev);
 635         sp = netdev_priv(dev);
 636
 637         /* Make private data page aligned */
 638         sr = dma_alloc_coherent(&pdev->dev, sizeof(*sp->srings),
 639                                 &sp->srings_dma, GFP_KERNEL);
 640         if (!sr) {
 641                 printk(KERN_ERR "Sgiseeq: Page alloc failed, aborting.\n");
 642                 err = -ENOMEM;
 643                 goto err_out_free_dev;
 644         }
 645         sp->srings = sr;
 646         sp->rx_desc = sp->srings->rxvector;
 647         sp->tx_desc = sp->srings->txvector;
 648
 649         /* A couple calculations now, saves many cycles later. */
 650         setup_rx_ring(sp->rx_desc, SEEQ_RX_BUFFERS);
 651         setup_tx_ring(sp->tx_desc, SEEQ_TX_BUFFERS);
 652
 653         memcpy(dev->dev_addr, pd->mac, ETH_ALEN);
 654
 655 #ifdef DEBUG
 656         gpriv = sp;
 657         gdev = dev;
 658 #endif
 659         sp->sregs = (struct sgiseeq_regs *) &hpcregs->eth_ext[0];
 660         sp->hregs = &hpcregs->ethregs;
 661         sp->name = sgiseeqstr;
 662         sp->mode = SEEQ_RCMD_RBCAST;
 663
 664         /* Setup PIO and DMA transfer timing */
 665         sp->hregs->pconfig = 0x161;
 666         sp->hregs->dconfig = HPC3_EDCFG_FIRQ | HPC3_EDCFG_FEOP |
 667                              HPC3_EDCFG_FRXDC | HPC3_EDCFG_PTO | 0x026;
 668
 669         /* Setup PIO and DMA transfer timing */
 670         sp->hregs->pconfig = 0x161;
 671         sp->hregs->dconfig = HPC3_EDCFG_FIRQ | HPC3_EDCFG_FEOP |
 672                              HPC3_EDCFG_FRXDC | HPC3_EDCFG_PTO | 0x026;
 673
 674         /* Reset the chip. */
 675         hpc3_eth_reset(sp->hregs);
 676
 677         sp->is_edlc = !(sp->sregs->rw.rregs.collision_tx[0] & 0xff);
 678         if (sp->is_edlc)
 679                 sp->control = SEEQ_CTRL_XCNT | SEEQ_CTRL_ACCNT |
 680                               SEEQ_CTRL_SFLAG | SEEQ_CTRL_ESHORT |
 681                               SEEQ_CTRL_ENCARR;
 682
 683         dev->open               = sgiseeq_open;
 684         dev->stop               = sgiseeq_close;
 685         dev->hard_start_xmit    = sgiseeq_start_xmit;
 686         dev->tx_timeout         = timeout;
 687         dev->watchdog_timeo     = (200 * HZ) / 1000;
 688         dev->set_multicast_list = sgiseeq_set_multicast;
 689         dev->set_mac_address    = sgiseeq_set_mac_address;
 690         dev->irq                = irq;
 691
 692         if (register_netdev(dev)) {
 693                 printk(KERN_ERR "Sgiseeq: Cannot register net device, "
 694                        "aborting.\n");
 695                 err = -ENODEV;
 696                 goto err_out_free_page;
 697         }
 698
 699         printk(KERN_INFO "%s: %s %s\n",
 700                dev->name, sgiseeqstr, print_mac(mac, dev->dev_addr));
 701
 702         return 0;
 703
 704 err_out_free_page:
 705         free_page((unsigned long) sp->srings);
 706 err_out_free_dev:
 707         kfree(dev);
 708
 709 err_out:
 710         return err;
 711 }
 712
 713 static int __exit sgiseeq_remove(struct platform_device *pdev)
 714 {
 715         struct net_device *dev = platform_get_drvdata(pdev);
 716         struct sgiseeq_private *sp = netdev_priv(dev);
 717
 718         unregister_netdev(dev);
 719         dma_free_coherent(&pdev->dev, sizeof(*sp->srings), sp->srings,
 720                           sp->srings_dma);
 721         free_netdev(dev);
 722         platform_set_drvdata(pdev, NULL);
 723
 724         return 0;
 725 }
 726
 727 static struct platform_driver sgiseeq_driver = {
 728         .probe  = sgiseeq_probe,
 729         .remove = __devexit_p(sgiseeq_remove),
 730         .driver = {
 731                 .name   = "sgiseeq"
 732         }
 733 };
 734
 735 static int __init sgiseeq_module_init(void)
 736 {
 737         if (platform_driver_register(&sgiseeq_driver)) {
 738                 printk(KERN_ERR "Driver registration failed\n");
 739                 return -ENODEV;
 740         }
 741
 742         return 0;
 743 }
 744
 745 static void __exit sgiseeq_module_exit(void)
 746 {
 747         platform_driver_unregister(&sgiseeq_driver);
 748 }
 749
 750 module_init(sgiseeq_module_init);
 751 module_exit(sgiseeq_module_exit);
 752
 753 MODULE_DESCRIPTION("SGI Seeq 8003 driver");
 754 MODULE_AUTHOR("Linux/MIPS Mailing List <linux-mips@linux-mips.org>");
 755 MODULE_LICENSE("GPL");