drivers/net/lasi_82596.c

   1 /* lasi_82596.c -- driver for the intel 82596 ethernet controller, as
   2    munged into HPPA boxen .
   3
   4    This driver is based upon 82596.c, original credits are below...
   5    but there were too many hoops which HP wants jumped through to
   6    keep this code in there in a sane manner.
   7
   8    3 primary sources of the mess --
   9    1) hppa needs *lots* of cacheline flushing to keep this kind of
  10    MMIO running.
  11
  12    2) The 82596 needs to see all of its pointers as their physical
  13    address.  Thus virt_to_bus/bus_to_virt are *everywhere*.
  14
  15    3) The implementation HP is using seems to be significantly pickier
  16    about when and how the command and RX units are started.  some
  17    command ordering was changed.
  18
  19    Examination of the mach driver leads one to believe that there
  20    might be a saner way to pull this off...  anyone who feels like a
  21    full rewrite can be my guest.
  22
  23    Split 02/13/2000 Sam Creasey (sammy@oh.verio.com)
  24
  25    02/01/2000  Initial modifications for parisc by Helge Deller (deller@gmx.de)
  26    03/02/2000  changes for better/correct(?) cache-flushing (deller)
  27 */
  28
  29 /* 82596.c: A generic 82596 ethernet driver for linux. */
  30 /*
  31    Based on Apricot.c
  32    Written 1994 by Mark Evans.
  33    This driver is for the Apricot 82596 bus-master interface
  34
  35    Modularised 12/94 Mark Evans
  36
  37
  38    Modified to support the 82596 ethernet chips on 680x0 VME boards.
  39    by Richard Hirst <richard@sleepie.demon.co.uk>
  40    Renamed to be 82596.c
  41
  42    980825:  Changed to receive directly in to sk_buffs which are
  43    allocated at open() time.  Eliminates copy on incoming frames
  44    (small ones are still copied).  Shared data now held in a
  45    non-cached page, so we can run on 68060 in copyback mode.
  46
  47    TBD:
  48    * look at deferring rx frames rather than discarding (as per tulip)
  49    * handle tx ring full as per tulip
  50    * performace test to tune rx_copybreak
  51
  52    Most of my modifications relate to the braindead big-endian
  53    implementation by Intel.  When the i596 is operating in
  54    'big-endian' mode, it thinks a 32 bit value of 0x12345678
  55    should be stored as 0x56781234.  This is a real pain, when
  56    you have linked lists which are shared by the 680x0 and the
  57    i596.
  58
  59    Driver skeleton
  60    Written 1993 by Donald Becker.
  61    Copyright 1993 United States Government as represented by the Director,
  62    National Security Agency. This software may only be used and distributed
  63    according to the terms of the GNU General Public License as modified by SRC,
  64    incorporated herein by reference.
  65
  66    The author may be reached as becker@scyld.com, or C/O
  67    Scyld Computing Corporation, 410 Severn Ave., Suite 210, Annapolis MD 21403
  68
  69  */
  70
  71 #include <linux/module.h>
  72 #include <linux/kernel.h>
  73 #include <linux/string.h>
  74 #include <linux/ptrace.h>
  75 #include <linux/errno.h>
  76 #include <linux/ioport.h>
  77 #include <linux/slab.h>
  78 #include <linux/interrupt.h>
  79 #include <linux/delay.h>
  80 #include <linux/netdevice.h>
  81 #include <linux/etherdevice.h>
  82 #include <linux/skbuff.h>
  83 #include <linux/init.h>
  84 #include <linux/pci.h>
  85 #include <linux/types.h>
  86
  87 #include <asm/bitops.h>
  88 #include <asm/io.h>
  89 #include <asm/pgtable.h>
  90 #include <asm/irq.h>
  91 #include <asm/pdc.h>
  92 #include <asm/cache.h>
  93 #include <asm/parisc-device.h>
  94
  95 static char version[] __devinitdata =
  96         "82596.c $Revision: 1.29 $\n";
  97
  98 /* DEBUG flags
  99  */
 100
 101 #define DEB_INIT        0x0001
 102 #define DEB_PROBE       0x0002
 103 #define DEB_SERIOUS     0x0004
 104 #define DEB_ERRORS      0x0008
 105 #define DEB_MULTI       0x0010
 106 #define DEB_TDR         0x0020
 107 #define DEB_OPEN        0x0040
 108 #define DEB_RESET       0x0080
 109 #define DEB_ADDCMD      0x0100
 110 #define DEB_STATUS      0x0200
 111 #define DEB_STARTTX     0x0400
 112 #define DEB_RXADDR      0x0800
 113 #define DEB_TXADDR      0x1000
 114 #define DEB_RXFRAME     0x2000
 115 #define DEB_INTS        0x4000
 116 #define DEB_STRUCT      0x8000
 117 #define DEB_ANY         0xffff
 118
 119
 120 #define DEB(x,y)        if (i596_debug & (x)) { y; }
 121
 122
 123 #define  CHECK_WBACK(addr,len) \
 124         do { dma_cache_sync((void *)addr, len, DMA_TO_DEVICE); } while (0)
 125
 126 #define  CHECK_INV(addr,len) \
 127         do { dma_cache_sync((void *)addr,len, DMA_FROM_DEVICE); } while(0)
 128
 129 #define  CHECK_WBACK_INV(addr,len) \
 130         do { dma_cache_sync((void *)addr,len, DMA_BIDIRECTIONAL); } while (0)
 131
 132
 133 #define PA_I82596_RESET         0       /* Offsets relative to LASI-LAN-Addr.*/
 134 #define PA_CPU_PORT_L_ACCESS    4
 135 #define PA_CHANNEL_ATTENTION    8
 136
 137
 138 /*
 139  * Define various macros for Channel Attention, word swapping etc., dependent
 140  * on architecture.  MVME and BVME are 680x0 based, otherwise it is Intel.
 141  */
 142
 143 #ifdef __BIG_ENDIAN
 144 #define WSWAPrfd(x)  (((u32)(x)<<16) | ((((u32)(x)))>>16))
 145 #define WSWAPrbd(x)  (((u32)(x)<<16) | ((((u32)(x)))>>16))
 146 #define WSWAPiscp(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
 147 #define WSWAPscb(x)  (((u32)(x)<<16) | ((((u32)(x)))>>16))
 148 #define WSWAPcmd(x)  (((u32)(x)<<16) | ((((u32)(x)))>>16))
 149 #define WSWAPtbd(x)  (((u32)(x)<<16) | ((((u32)(x)))>>16))
 150 #define WSWAPchar(x) (((u32)(x)<<16) | ((((u32)(x)))>>16))
 151 #define ISCP_BUSY       0x00010000
 152 #define MACH_IS_APRICOT 0
 153 #else
 154 #define WSWAPrfd(x)     ((struct i596_rfd *)(x))
 155 #define WSWAPrbd(x)     ((struct i596_rbd *)(x))
 156 #define WSWAPiscp(x)    ((struct i596_iscp *)(x))
 157 #define WSWAPscb(x)     ((struct i596_scb *)(x))
 158 #define WSWAPcmd(x)     ((struct i596_cmd *)(x))
 159 #define WSWAPtbd(x)     ((struct i596_tbd *)(x))
 160 #define WSWAPchar(x)    ((char *)(x))
 161 #define ISCP_BUSY       0x0001
 162 #define MACH_IS_APRICOT 1
 163 #endif
 164
 165 /*
 166  * The MPU_PORT command allows direct access to the 82596. With PORT access
 167  * the following commands are available (p5-18). The 32-bit port command
 168  * must be word-swapped with the most significant word written first.
 169  * This only applies to VME boards.
 170  */
 171 #define PORT_RESET              0x00    /* reset 82596 */
 172 #define PORT_SELFTEST           0x01    /* selftest */
 173 #define PORT_ALTSCP             0x02    /* alternate SCB address */
 174 #define PORT_ALTDUMP            0x03    /* Alternate DUMP address */
 175
 176 static int i596_debug = (DEB_SERIOUS|DEB_PROBE);
 177
 178 MODULE_AUTHOR("Richard Hirst");
 179 MODULE_DESCRIPTION("i82596 driver");
 180 MODULE_LICENSE("GPL");
 181 MODULE_PARM(i596_debug, "i");
 182 MODULE_PARM_DESC(i596_debug, "lasi_82596 debug mask");
 183
 184 /* Copy frames shorter than rx_copybreak, otherwise pass on up in
 185  * a full sized sk_buff.  Value of 100 stolen from tulip.c (!alpha).
 186  */
 187 static int rx_copybreak = 100;
 188
 189 #define MAX_DRIVERS     4       /* max count of drivers */
 190
 191 #define PKT_BUF_SZ      1536
 192 #define MAX_MC_CNT      64
 193
 194 #define I596_NULL ((u32)0xffffffff)
 195
 196 #define CMD_EOL         0x8000  /* The last command of the list, stop. */
 197 #define CMD_SUSP        0x4000  /* Suspend after doing cmd. */
 198 #define CMD_INTR        0x2000  /* Interrupt after doing cmd. */
 199
 200 #define CMD_FLEX        0x0008  /* Enable flexible memory model */
 201
 202 enum commands {
 203         CmdNOp = 0, CmdSASetup = 1, CmdConfigure = 2, CmdMulticastList = 3,
 204         CmdTx = 4, CmdTDR = 5, CmdDump = 6, CmdDiagnose = 7
 205 };
 206
 207 #define STAT_C          0x8000  /* Set to 0 after execution */
 208 #define STAT_B          0x4000  /* Command being executed */
 209 #define STAT_OK         0x2000  /* Command executed ok */
 210 #define STAT_A          0x1000  /* Command aborted */
 211
 212 #define  CUC_START      0x0100
 213 #define  CUC_RESUME     0x0200
 214 #define  CUC_SUSPEND    0x0300
 215 #define  CUC_ABORT      0x0400
 216 #define  RX_START       0x0010
 217 #define  RX_RESUME      0x0020
 218 #define  RX_SUSPEND     0x0030
 219 #define  RX_ABORT       0x0040
 220
 221 #define TX_TIMEOUT      5
 222
 223 #define OPT_SWAP_PORT   0x0001  /* Need to wordswp on the MPU port */
 224
 225
 226 struct i596_reg {
 227         unsigned short porthi;
 228         unsigned short portlo;
 229         u32            ca;
 230 };
 231
 232 #define EOF             0x8000
 233 #define SIZE_MASK       0x3fff
 234
 235 struct i596_tbd {
 236         unsigned short size;
 237         unsigned short pad;
 238         dma_addr_t     next;
 239         dma_addr_t     data;
 240         u32 cache_pad[5];               /* Total 32 bytes... */
 241 };
 242
 243 /* The command structure has two 'next' pointers; v_next is the address of
 244  * the next command as seen by the CPU, b_next is the address of the next
 245  * command as seen by the 82596.  The b_next pointer, as used by the 82596
 246  * always references the status field of the next command, rather than the
 247  * v_next field, because the 82596 is unaware of v_next.  It may seem more
 248  * logical to put v_next at the end of the structure, but we cannot do that
 249  * because the 82596 expects other fields to be there, depending on command
 250  * type.
 251  */
 252
 253 struct i596_cmd {
 254         struct i596_cmd *v_next;        /* Address from CPUs viewpoint */
 255         unsigned short status;
 256         unsigned short command;
 257         dma_addr_t     b_next;  /* Address from i596 viewpoint */
 258 };
 259
 260 struct tx_cmd {
 261         struct i596_cmd cmd;
 262         dma_addr_t     tbd;
 263         unsigned short size;
 264         unsigned short pad;
 265         struct sk_buff *skb;            /* So we can free it after tx */
 266         dma_addr_t dma_addr;
 267 #ifdef __LP64__
 268         u32 cache_pad[6];               /* Total 64 bytes... */
 269 #else
 270         u32 cache_pad[1];               /* Total 32 bytes... */
 271 #endif
 272 };
 273
 274 struct tdr_cmd {
 275         struct i596_cmd cmd;
 276         unsigned short status;
 277         unsigned short pad;
 278 };
 279
 280 struct mc_cmd {
 281         struct i596_cmd cmd;
 282         short mc_cnt;
 283         char mc_addrs[MAX_MC_CNT*6];
 284 };
 285
 286 struct sa_cmd {
 287         struct i596_cmd cmd;
 288         char eth_addr[8];
 289 };
 290
 291 struct cf_cmd {
 292         struct i596_cmd cmd;
 293         char i596_config[16];
 294 };
 295
 296 struct i596_rfd {
 297         unsigned short stat;
 298         unsigned short cmd;
 299         dma_addr_t     b_next;  /* Address from i596 viewpoint */
 300         dma_addr_t     rbd;
 301         unsigned short count;
 302         unsigned short size;
 303         struct i596_rfd *v_next;        /* Address from CPUs viewpoint */
 304         struct i596_rfd *v_prev;
 305 #ifndef __LP64__
 306         u32 cache_pad[2];               /* Total 32 bytes... */
 307 #endif
 308 };
 309
 310 struct i596_rbd {
 311     /* hardware data */
 312     unsigned short count;
 313     unsigned short zero1;
 314     dma_addr_t     b_next;
 315     dma_addr_t     b_data;              /* Address from i596 viewpoint */
 316     unsigned short size;
 317     unsigned short zero2;
 318     /* driver data */
 319     struct sk_buff *skb;
 320     struct i596_rbd *v_next;
 321     dma_addr_t     b_addr;              /* This rbd addr from i596 view */
 322     unsigned char *v_data;              /* Address from CPUs viewpoint */
 323                                         /* Total 32 bytes... */
 324 #ifdef __LP64__
 325     u32 cache_pad[4];
 326 #endif
 327 };
 328
 329 /* These values as chosen so struct i596_private fits in one page... */
 330
 331 #define TX_RING_SIZE 32
 332 #define RX_RING_SIZE 16
 333
 334 struct i596_scb {
 335         unsigned short status;
 336         unsigned short command;
 337         dma_addr_t    cmd;
 338         dma_addr_t    rfd;
 339         u32           crc_err;
 340         u32           align_err;
 341         u32           resource_err;
 342         u32           over_err;
 343         u32           rcvdt_err;
 344         u32           short_err;
 345         unsigned short t_on;
 346         unsigned short t_off;
 347 };
 348
 349 struct i596_iscp {
 350         u32           stat;
 351         dma_addr_t    scb;
 352 };
 353
 354 struct i596_scp {
 355         u32           sysbus;
 356         u32            pad;
 357         dma_addr_t    iscp;
 358 };
 359
 360 struct i596_private {
 361         volatile struct i596_scp scp            __attribute__((aligned(32)));
 362         volatile struct i596_iscp iscp          __attribute__((aligned(32)));
 363         volatile struct i596_scb scb            __attribute__((aligned(32)));
 364         struct sa_cmd sa_cmd                    __attribute__((aligned(32)));
 365         struct cf_cmd cf_cmd                    __attribute__((aligned(32)));
 366         struct tdr_cmd tdr_cmd                  __attribute__((aligned(32)));
 367         struct mc_cmd mc_cmd                    __attribute__((aligned(32)));
 368         struct i596_rfd rfds[RX_RING_SIZE]      __attribute__((aligned(32)));
 369         struct i596_rbd rbds[RX_RING_SIZE]      __attribute__((aligned(32)));
 370         struct tx_cmd tx_cmds[TX_RING_SIZE]     __attribute__((aligned(32)));
 371         struct i596_tbd tbds[TX_RING_SIZE]      __attribute__((aligned(32)));
 372         u32    stat;
 373         int last_restart;
 374         struct i596_rfd *rfd_head;
 375         struct i596_rbd *rbd_head;
 376         struct i596_cmd *cmd_tail;
 377         struct i596_cmd *cmd_head;
 378         int cmd_backlog;
 379         u32    last_cmd;
 380         struct net_device_stats stats;
 381         int next_tx_cmd;
 382         int options;
 383         spinlock_t lock;
 384         dma_addr_t dma_addr;
 385         struct device *dev;
 386 };
 387
 388 static char init_setup[] =
 389 {
 390         0x8E,                   /* length, prefetch on */
 391         0xC8,                   /* fifo to 8, monitor off */
 392         0x80,                   /* don't save bad frames */
 393         0x2E,                   /* No source address insertion, 8 byte preamble */
 394         0x00,                   /* priority and backoff defaults */
 395         0x60,                   /* interframe spacing */
 396         0x00,                   /* slot time LSB */
 397         0xf2,                   /* slot time and retries */
 398         0x00,                   /* promiscuous mode */
 399         0x00,                   /* collision detect */
 400         0x40,                   /* minimum frame length */
 401         0xff,
 402         0x00,
 403         0x7f /*  *multi IA */ };
 404
 405 static int i596_open(struct net_device *dev);
 406 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev);
 407 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs);
 408 static int i596_close(struct net_device *dev);
 409 static struct net_device_stats *i596_get_stats(struct net_device *dev);
 410 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd);
 411 static void i596_tx_timeout (struct net_device *dev);
 412 static void print_eth(unsigned char *buf, char *str);
 413 static void set_multicast_list(struct net_device *dev);
 414
 415 static int rx_ring_size = RX_RING_SIZE;
 416 static int ticks_limit = 100;
 417 static int max_cmd_backlog = TX_RING_SIZE-1;
 418
 419
 420 static inline void CA(struct net_device *dev)
 421 {
 422         gsc_writel(0, dev->base_addr + PA_CHANNEL_ATTENTION);
 423 }
 424
 425
 426 static inline void MPU_PORT(struct net_device *dev, int c, dma_addr_t x)
 427 {
 428         struct i596_private *lp = dev->priv;
 429
 430         u32 v = (u32) (c) | (u32) (x);
 431         u16 a, b;
 432
 433         if (lp->options & OPT_SWAP_PORT) {
 434                 a = v >> 16;
 435                 b = v & 0xffff;
 436         } else {
 437                 a = v & 0xffff;
 438                 b = v >> 16;
 439         }
 440
 441         gsc_writel(a, dev->base_addr + PA_CPU_PORT_L_ACCESS);
 442         udelay(1);
 443         gsc_writel(b, dev->base_addr + PA_CPU_PORT_L_ACCESS);
 444 }
 445
 446
 447 static inline int wait_istat(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
 448 {
 449         CHECK_INV(&(lp->iscp), sizeof(struct i596_iscp));
 450         while (--delcnt && lp->iscp.stat) {
 451                 udelay(10);
 452                 CHECK_INV(&(lp->iscp), sizeof(struct i596_iscp));
 453         }
 454         if (!delcnt) {
 455                 printk("%s: %s, iscp.stat %04x, didn't clear\n",
 456                      dev->name, str, lp->iscp.stat);
 457                 return -1;
 458         }
 459         else
 460                 return 0;
 461 }
 462
 463
 464 static inline int wait_cmd(struct net_device *dev, struct i596_private *lp, int delcnt, char *str)
 465 {
 466         CHECK_INV(&(lp->scb), sizeof(struct i596_scb));
 467         while (--delcnt && lp->scb.command) {
 468                 udelay(10);
 469                 CHECK_INV(&(lp->scb), sizeof(struct i596_scb));
 470         }
 471         if (!delcnt) {
 472                 printk("%s: %s, status %4.4x, cmd %4.4x.\n",
 473                      dev->name, str, lp->scb.status, lp->scb.command);
 474                 return -1;
 475         }
 476         else
 477                 return 0;
 478 }
 479
 480
 481 static void i596_display_data(struct net_device *dev)
 482 {
 483         struct i596_private *lp = dev->priv;
 484         struct i596_cmd *cmd;
 485         struct i596_rfd *rfd;
 486         struct i596_rbd *rbd;
 487
 488         printk("lp and scp at %p, .sysbus = %08x, .iscp = %08x\n",
 489                &lp->scp, lp->scp.sysbus, lp->scp.iscp);
 490         printk("iscp at %p, iscp.stat = %08x, .scb = %08x\n",
 491                &lp->iscp, lp->iscp.stat, lp->iscp.scb);
 492         printk("scb at %p, scb.status = %04x, .command = %04x,"
 493                 " .cmd = %08x, .rfd = %08x\n",
 494                &lp->scb, lp->scb.status, lp->scb.command,
 495                 lp->scb.cmd, lp->scb.rfd);
 496         printk("   errors: crc %x, align %x, resource %x,"
 497                " over %x, rcvdt %x, short %x\n",
 498                 lp->scb.crc_err, lp->scb.align_err, lp->scb.resource_err,
 499                 lp->scb.over_err, lp->scb.rcvdt_err, lp->scb.short_err);
 500         cmd = lp->cmd_head;
 501         while (cmd != NULL) {
 502                 printk("cmd at %p, .status = %04x, .command = %04x, .b_next = %08x\n",
 503                   cmd, cmd->status, cmd->command, cmd->b_next);
 504                 cmd = cmd->v_next;
 505         }
 506         rfd = lp->rfd_head;
 507         printk("rfd_head = %p\n", rfd);
 508         do {
 509                 printk ("   %p .stat %04x, .cmd %04x, b_next %08x, rbd %08x,"
 510                         " count %04x\n",
 511                         rfd, rfd->stat, rfd->cmd, rfd->b_next, rfd->rbd,
 512                         rfd->count);
 513                 rfd = rfd->v_next;
 514         } while (rfd != lp->rfd_head);
 515         rbd = lp->rbd_head;
 516         printk("rbd_head = %p\n", rbd);
 517         do {
 518                 printk("   %p .count %04x, b_next %08x, b_data %08x, size %04x\n",
 519                         rbd, rbd->count, rbd->b_next, rbd->b_data, rbd->size);
 520                 rbd = rbd->v_next;
 521         } while (rbd != lp->rbd_head);
 522         CHECK_INV(lp, sizeof(struct i596_private));
 523 }
 524
 525
 526 #if defined(ENABLE_MVME16x_NET) || defined(ENABLE_BVME6000_NET)
 527 static void i596_error(int irq, void *dev_id, struct pt_regs *regs)
 528 {
 529         struct net_device *dev = dev_id;
 530         volatile unsigned char *pcc2 = (unsigned char *) 0xfff42000;
 531
 532         pcc2[0x28] = 1;
 533         pcc2[0x2b] = 0x1d;
 534         printk("%s: Error interrupt\n", dev->name);
 535         i596_display_data(dev);
 536 }
 537 #endif
 538
 539 #define virt_to_dma(lp,v) ((lp)->dma_addr + (dma_addr_t)((unsigned long)(v)-(unsigned long)(lp)))
 540
 541 static inline void init_rx_bufs(struct net_device *dev)
 542 {
 543         struct i596_private *lp = dev->priv;
 544         int i;
 545         struct i596_rfd *rfd;
 546         struct i596_rbd *rbd;
 547
 548         /* First build the Receive Buffer Descriptor List */
 549
 550         for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
 551                 dma_addr_t dma_addr;
 552                 struct sk_buff *skb = dev_alloc_skb(PKT_BUF_SZ + 4);
 553
 554                 if (skb == NULL)
 555                         panic("82596: alloc_skb() failed");
 556                 skb_reserve(skb, 2);
 557                 dma_addr = dma_map_single(lp->dev, skb->tail,PKT_BUF_SZ,
 558                                           DMA_FROM_DEVICE);
 559                 skb->dev = dev;
 560                 rbd->v_next = rbd+1;
 561                 rbd->b_next = WSWAPrbd(virt_to_dma(lp,rbd+1));
 562                 rbd->b_addr = WSWAPrbd(virt_to_dma(lp,rbd));
 563                 rbd->skb = skb;
 564                 rbd->v_data = skb->tail;
 565                 rbd->b_data = WSWAPchar(dma_addr);
 566                 rbd->size = PKT_BUF_SZ;
 567         }
 568         lp->rbd_head = lp->rbds;
 569         rbd = lp->rbds + rx_ring_size - 1;
 570         rbd->v_next = lp->rbds;
 571         rbd->b_next = WSWAPrbd(virt_to_dma(lp,lp->rbds));
 572
 573         /* Now build the Receive Frame Descriptor List */
 574
 575         for (i = 0, rfd = lp->rfds; i < rx_ring_size; i++, rfd++) {
 576                 rfd->rbd = I596_NULL;
 577                 rfd->v_next = rfd+1;
 578                 rfd->v_prev = rfd-1;
 579                 rfd->b_next = WSWAPrfd(virt_to_dma(lp,rfd+1));
 580                 rfd->cmd = CMD_FLEX;
 581         }
 582         lp->rfd_head = lp->rfds;
 583         lp->scb.rfd = WSWAPrfd(virt_to_dma(lp,lp->rfds));
 584         rfd = lp->rfds;
 585         rfd->rbd = WSWAPrbd(virt_to_dma(lp,lp->rbd_head));
 586         rfd->v_prev = lp->rfds + rx_ring_size - 1;
 587         rfd = lp->rfds + rx_ring_size - 1;
 588         rfd->v_next = lp->rfds;
 589         rfd->b_next = WSWAPrfd(virt_to_dma(lp,lp->rfds));
 590         rfd->cmd = CMD_EOL|CMD_FLEX;
 591
 592         CHECK_WBACK_INV(lp, sizeof(struct i596_private));
 593 }
 594
 595 static inline void remove_rx_bufs(struct net_device *dev)
 596 {
 597         struct i596_private *lp = dev->priv;
 598         struct i596_rbd *rbd;
 599         int i;
 600
 601         for (i = 0, rbd = lp->rbds; i < rx_ring_size; i++, rbd++) {
 602                 if (rbd->skb == NULL)
 603                         break;
 604                 dma_unmap_single(lp->dev,
 605                                  (dma_addr_t)WSWAPchar(rbd->b_data),
 606                                  PKT_BUF_SZ, DMA_FROM_DEVICE);
 607                 dev_kfree_skb(rbd->skb);
 608         }
 609 }
 610
 611
 612 static void rebuild_rx_bufs(struct net_device *dev)
 613 {
 614         struct i596_private *lp = dev->priv;
 615         int i;
 616
 617         /* Ensure rx frame/buffer descriptors are tidy */
 618
 619         for (i = 0; i < rx_ring_size; i++) {
 620                 lp->rfds[i].rbd = I596_NULL;
 621                 lp->rfds[i].cmd = CMD_FLEX;
 622         }
 623         lp->rfds[rx_ring_size-1].cmd = CMD_EOL|CMD_FLEX;
 624         lp->rfd_head = lp->rfds;
 625         lp->scb.rfd = WSWAPrfd(virt_to_dma(lp,lp->rfds));
 626         lp->rbd_head = lp->rbds;
 627         lp->rfds[0].rbd = WSWAPrbd(virt_to_dma(lp,lp->rbds));
 628
 629         CHECK_WBACK_INV(lp, sizeof(struct i596_private));
 630 }
 631
 632
 633 static int init_i596_mem(struct net_device *dev)
 634 {
 635         struct i596_private *lp = dev->priv;
 636         unsigned long flags;
 637
 638         disable_irq(dev->irq);  /* disable IRQs from LAN */
 639         DEB(DEB_INIT,
 640                 printk("RESET 82596 port: %08lX (with IRQ%d disabled)\n",
 641                        dev->base_addr + PA_I82596_RESET,
 642                        dev->irq));
 643
 644         gsc_writel(0, (void*)(dev->base_addr + PA_I82596_RESET)); /* Hard Reset */
 645         udelay(100);                    /* Wait 100us - seems to help */
 646
 647         /* change the scp address */
 648
 649         lp->last_cmd = jiffies;
 650
 651
 652         lp->scp.sysbus = 0x0000006c;
 653         lp->scp.iscp = WSWAPiscp(virt_to_dma(lp,&(lp->iscp)));
 654         lp->iscp.scb = WSWAPscb(virt_to_dma(lp,&(lp->scb)));
 655         lp->iscp.stat = ISCP_BUSY;
 656         lp->cmd_backlog = 0;
 657
 658         lp->cmd_head = NULL;
 659         lp->scb.cmd = I596_NULL;
 660
 661         DEB(DEB_INIT,printk("%s: starting i82596.\n", dev->name));
 662
 663         CHECK_WBACK(&(lp->scp), sizeof(struct i596_scp));
 664         CHECK_WBACK(&(lp->iscp), sizeof(struct i596_iscp));
 665
 666         MPU_PORT(dev, PORT_ALTSCP, virt_to_dma(lp,&lp->scp));
 667
 668         CA(dev);
 669
 670         if (wait_istat(dev,lp,1000,"initialization timed out"))
 671                 goto failed;
 672         DEB(DEB_INIT,printk("%s: i82596 initialization successful\n", dev->name));
 673
 674         /* Ensure rx frame/buffer descriptors are tidy */
 675         rebuild_rx_bufs(dev);
 676
 677         lp->scb.command = 0;
 678         CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
 679
 680         enable_irq(dev->irq);   /* enable IRQs from LAN */
 681
 682         DEB(DEB_INIT,printk("%s: queuing CmdConfigure\n", dev->name));
 683         memcpy(lp->cf_cmd.i596_config, init_setup, 14);
 684         lp->cf_cmd.cmd.command = CmdConfigure;
 685         CHECK_WBACK(&(lp->cf_cmd), sizeof(struct cf_cmd));
 686         i596_add_cmd(dev, &lp->cf_cmd.cmd);
 687
 688         DEB(DEB_INIT,printk("%s: queuing CmdSASetup\n", dev->name));
 689         memcpy(lp->sa_cmd.eth_addr, dev->dev_addr, 6);
 690         lp->sa_cmd.cmd.command = CmdSASetup;
 691         CHECK_WBACK(&(lp->sa_cmd), sizeof(struct sa_cmd));
 692         i596_add_cmd(dev, &lp->sa_cmd.cmd);
 693
 694         DEB(DEB_INIT,printk("%s: queuing CmdTDR\n", dev->name));
 695         lp->tdr_cmd.cmd.command = CmdTDR;
 696         CHECK_WBACK(&(lp->tdr_cmd), sizeof(struct tdr_cmd));
 697         i596_add_cmd(dev, &lp->tdr_cmd.cmd);
 698
 699         spin_lock_irqsave (&lp->lock, flags);
 700
 701         if (wait_cmd(dev,lp,1000,"timed out waiting to issue RX_START")) {
 702                 spin_unlock_irqrestore (&lp->lock, flags);
 703                 goto failed;
 704         }
 705         DEB(DEB_INIT,printk("%s: Issuing RX_START\n", dev->name));
 706         lp->scb.command = RX_START;
 707         lp->scb.rfd = WSWAPrfd(virt_to_dma(lp,lp->rfds));
 708         CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
 709
 710         CA(dev);
 711
 712         spin_unlock_irqrestore (&lp->lock, flags);
 713
 714         if (wait_cmd(dev,lp,1000,"RX_START not processed"))
 715                 goto failed;
 716         DEB(DEB_INIT,printk("%s: Receive unit started OK\n", dev->name));
 717
 718         return 0;
 719
 720 failed:
 721         printk("%s: Failed to initialise 82596\n", dev->name);
 722         MPU_PORT(dev, PORT_RESET, 0);
 723         return -1;
 724 }
 725
 726
 727 static inline int i596_rx(struct net_device *dev)
 728 {
 729         struct i596_private *lp = dev->priv;
 730         struct i596_rfd *rfd;
 731         struct i596_rbd *rbd;
 732         int frames = 0;
 733
 734         DEB(DEB_RXFRAME,printk ("i596_rx(), rfd_head %p, rbd_head %p\n",
 735                         lp->rfd_head, lp->rbd_head));
 736
 737
 738         rfd = lp->rfd_head;             /* Ref next frame to check */
 739
 740         CHECK_INV(rfd, sizeof(struct i596_rfd));
 741         while ((rfd->stat) & STAT_C) {  /* Loop while complete frames */
 742                 if (rfd->rbd == I596_NULL)
 743                         rbd = NULL;
 744                 else if (rfd->rbd == lp->rbd_head->b_addr) {
 745                         rbd = lp->rbd_head;
 746                         CHECK_INV(rbd, sizeof(struct i596_rbd));
 747                 }
 748                 else {
 749                         printk("%s: rbd chain broken!\n", dev->name);
 750                         /* XXX Now what? */
 751                         rbd = NULL;
 752                 }
 753                 DEB(DEB_RXFRAME, printk("  rfd %p, rfd.rbd %08x, rfd.stat %04x\n",
 754                         rfd, rfd->rbd, rfd->stat));
 755
 756                 if (rbd != NULL && ((rfd->stat) & STAT_OK)) {
 757                         /* a good frame */
 758                         int pkt_len = rbd->count & 0x3fff;
 759                         struct sk_buff *skb = rbd->skb;
 760                         int rx_in_place = 0;
 761
 762                         DEB(DEB_RXADDR,print_eth(rbd->v_data, "received"));
 763                         frames++;
 764
 765                         /* Check if the packet is long enough to just accept
 766                          * without copying to a properly sized skbuff.
 767                          */
 768
 769                         if (pkt_len > rx_copybreak) {
 770                                 struct sk_buff *newskb;
 771                                 dma_addr_t dma_addr;
 772
 773                                 dma_unmap_single(lp->dev,(dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
 774                                 /* Get fresh skbuff to replace filled one. */
 775                                 newskb = dev_alloc_skb(PKT_BUF_SZ + 4);
 776                                 if (newskb == NULL) {
 777                                         skb = NULL;     /* drop pkt */
 778                                         goto memory_squeeze;
 779                                 }
 780                                 skb_reserve(newskb, 2);
 781
 782                                 /* Pass up the skb already on the Rx ring. */
 783                                 skb_put(skb, pkt_len);
 784                                 rx_in_place = 1;
 785                                 rbd->skb = newskb;
 786                                 newskb->dev = dev;
 787                                 dma_addr = dma_map_single(lp->dev, newskb->tail, PKT_BUF_SZ, DMA_FROM_DEVICE);
 788                                 rbd->v_data = newskb->tail;
 789                                 rbd->b_data = WSWAPchar(dma_addr);
 790                                 CHECK_WBACK_INV(rbd, sizeof(struct i596_rbd));
 791                         }
 792                         else
 793                                 skb = dev_alloc_skb(pkt_len + 2);
 794 memory_squeeze:
 795                         if (skb == NULL) {
 796                                 /* XXX tulip.c can defer packets here!! */
 797                                 printk ("%s: i596_rx Memory squeeze, dropping packet.\n", dev->name);
 798                                 lp->stats.rx_dropped++;
 799                         }
 800                         else {
 801                                 skb->dev = dev;
 802                                 if (!rx_in_place) {
 803                                         /* 16 byte align the data fields */
 804                                         dma_sync_single_for_cpu(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
 805                                         skb_reserve(skb, 2);
 806                                         memcpy(skb_put(skb,pkt_len), rbd->v_data, pkt_len);
 807                                         dma_sync_single_for_device(lp->dev, (dma_addr_t)WSWAPchar(rbd->b_data), PKT_BUF_SZ, DMA_FROM_DEVICE);
 808                                 }
 809                                 skb->len = pkt_len;
 810                                 skb->protocol=eth_type_trans(skb,dev);
 811                                 netif_rx(skb);
 812                                 dev->last_rx = jiffies;
 813                                 lp->stats.rx_packets++;
 814                                 lp->stats.rx_bytes+=pkt_len;
 815                         }
 816                 }
 817                 else {
 818                         DEB(DEB_ERRORS, printk("%s: Error, rfd.stat = 0x%04x\n",
 819                                         dev->name, rfd->stat));
 820                         lp->stats.rx_errors++;
 821                         if ((rfd->stat) & 0x0001)
 822                                 lp->stats.collisions++;
 823                         if ((rfd->stat) & 0x0080)
 824                                 lp->stats.rx_length_errors++;
 825                         if ((rfd->stat) & 0x0100)
 826                                 lp->stats.rx_over_errors++;
 827                         if ((rfd->stat) & 0x0200)
 828                                 lp->stats.rx_fifo_errors++;
 829                         if ((rfd->stat) & 0x0400)
 830                                 lp->stats.rx_frame_errors++;
 831                         if ((rfd->stat) & 0x0800)
 832                                 lp->stats.rx_crc_errors++;
 833                         if ((rfd->stat) & 0x1000)
 834                                 lp->stats.rx_length_errors++;
 835                 }
 836
 837                 /* Clear the buffer descriptor count and EOF + F flags */
 838
 839                 if (rbd != NULL && (rbd->count & 0x4000)) {
 840                         rbd->count = 0;
 841                         lp->rbd_head = rbd->v_next;
 842                         CHECK_WBACK_INV(rbd, sizeof(struct i596_rbd));
 843                 }
 844
 845                 /* Tidy the frame descriptor, marking it as end of list */
 846
 847                 rfd->rbd = I596_NULL;
 848                 rfd->stat = 0;
 849                 rfd->cmd = CMD_EOL|CMD_FLEX;
 850                 rfd->count = 0;
 851
 852                 /* Remove end-of-list from old end descriptor */
 853
 854                 rfd->v_prev->cmd = CMD_FLEX;
 855
 856                 /* Update record of next frame descriptor to process */
 857
 858                 lp->scb.rfd = rfd->b_next;
 859                 lp->rfd_head = rfd->v_next;
 860                 CHECK_WBACK_INV(rfd->v_prev, sizeof(struct i596_rfd));
 861                 CHECK_WBACK_INV(rfd, sizeof(struct i596_rfd));
 862                 rfd = lp->rfd_head;
 863                 CHECK_INV(rfd, sizeof(struct i596_rfd));
 864         }
 865
 866         DEB(DEB_RXFRAME,printk ("frames %d\n", frames));
 867
 868         return 0;
 869 }
 870
 871
 872 static inline void i596_cleanup_cmd(struct net_device *dev, struct i596_private *lp)
 873 {
 874         struct i596_cmd *ptr;
 875
 876         while (lp->cmd_head != NULL) {
 877                 ptr = lp->cmd_head;
 878                 lp->cmd_head = ptr->v_next;
 879                 lp->cmd_backlog--;
 880
 881                 switch ((ptr->command) & 0x7) {
 882                 case CmdTx:
 883                         {
 884                                 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
 885                                 struct sk_buff *skb = tx_cmd->skb;
 886                                 dma_unmap_single(lp->dev, tx_cmd->dma_addr, skb->len, DMA_TO_DEVICE);
 887
 888                                 dev_kfree_skb(skb);
 889
 890                                 lp->stats.tx_errors++;
 891                                 lp->stats.tx_aborted_errors++;
 892
 893                                 ptr->v_next = NULL;
 894                                 ptr->b_next = I596_NULL;
 895                                 tx_cmd->cmd.command = 0;  /* Mark as free */
 896                                 break;
 897                         }
 898                 default:
 899                         ptr->v_next = NULL;
 900                         ptr->b_next = I596_NULL;
 901                 }
 902                 CHECK_WBACK_INV(ptr, sizeof(struct i596_cmd));
 903         }
 904
 905         wait_cmd(dev,lp,100,"i596_cleanup_cmd timed out");
 906         lp->scb.cmd = I596_NULL;
 907         CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
 908 }
 909
 910
 911 static inline void i596_reset(struct net_device *dev, struct i596_private *lp)
 912 {
 913         unsigned long flags;
 914
 915         DEB(DEB_RESET,printk("i596_reset\n"));
 916
 917         spin_lock_irqsave (&lp->lock, flags);
 918
 919         wait_cmd(dev,lp,100,"i596_reset timed out");
 920
 921         netif_stop_queue(dev);
 922
 923         /* FIXME: this command might cause an lpmc */
 924         lp->scb.command = CUC_ABORT | RX_ABORT;
 925         CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
 926         CA(dev);
 927
 928         /* wait for shutdown */
 929         wait_cmd(dev,lp,1000,"i596_reset 2 timed out");
 930         spin_unlock_irqrestore (&lp->lock, flags);
 931
 932         i596_cleanup_cmd(dev,lp);
 933         i596_rx(dev);
 934
 935         netif_start_queue(dev);
 936         init_i596_mem(dev);
 937 }
 938
 939
 940 static void i596_add_cmd(struct net_device *dev, struct i596_cmd *cmd)
 941 {
 942         struct i596_private *lp = dev->priv;
 943         unsigned long flags;
 944
 945         DEB(DEB_ADDCMD,printk("i596_add_cmd cmd_head %p\n", lp->cmd_head));
 946
 947         cmd->status = 0;
 948         cmd->command |= (CMD_EOL | CMD_INTR);
 949         cmd->v_next = NULL;
 950         cmd->b_next = I596_NULL;
 951         CHECK_WBACK(cmd, sizeof(struct i596_cmd));
 952
 953         spin_lock_irqsave (&lp->lock, flags);
 954
 955         if (lp->cmd_head != NULL) {
 956                 lp->cmd_tail->v_next = cmd;
 957                 lp->cmd_tail->b_next = WSWAPcmd(virt_to_dma(lp,&cmd->status));
 958                 CHECK_WBACK(lp->cmd_tail, sizeof(struct i596_cmd));
 959         } else {
 960                 lp->cmd_head = cmd;
 961                 wait_cmd(dev,lp,100,"i596_add_cmd timed out");
 962                 lp->scb.cmd = WSWAPcmd(virt_to_dma(lp,&cmd->status));
 963                 lp->scb.command = CUC_START;
 964                 CHECK_WBACK(&(lp->scb), sizeof(struct i596_scb));
 965                 CA(dev);
 966         }
 967         lp->cmd_tail = cmd;
 968         lp->cmd_backlog++;
 969
 970         spin_unlock_irqrestore (&lp->lock, flags);
 971
 972         if (lp->cmd_backlog > max_cmd_backlog) {
 973                 unsigned long tickssofar = jiffies - lp->last_cmd;
 974
 975                 if (tickssofar < ticks_limit)
 976                         return;
 977
 978                 printk("%s: command unit timed out, status resetting.\n", dev->name);
 979 #if 1
 980                 i596_reset(dev, lp);
 981 #endif
 982         }
 983 }
 984
 985 #if 0
 986 /* this function makes a perfectly adequate probe...  but we have a
 987    device list */
 988 static int i596_test(struct net_device *dev)
 989 {
 990         struct i596_private *lp = dev->priv;
 991         volatile int *tint;
 992         u32 data;
 993
 994         tint = (volatile int *)(&(lp->scp));
 995         data = virt_to_dma(lp,tint);
 996
 997         tint[1] = -1;
 998         CHECK_WBACK(tint,PAGE_SIZE);
 999
1000         MPU_PORT(dev, 1, data);
1001
1002         for(data = 1000000; data; data--) {
1003                 CHECK_INV(tint,PAGE_SIZE);
1004                 if(tint[1] != -1)
1005                         break;
1006
1007         }
1008
1009         printk("i596_test result %d\n", tint[1]);
1010
1011 }
1012 #endif
1013
1014
1015 static int i596_open(struct net_device *dev)
1016 {
1017         DEB(DEB_OPEN,printk("%s: i596_open() irq %d.\n", dev->name, dev->irq));
1018
1019         if (request_irq(dev->irq, &i596_interrupt, 0, "i82596", dev)) {
1020                 printk("%s: IRQ %d not free\n", dev->name, dev->irq);
1021                 goto out;
1022         }
1023
1024         init_rx_bufs(dev);
1025
1026         if (init_i596_mem(dev)) {
1027                 printk("%s: Failed to init memory\n", dev->name);
1028                 goto out_remove_rx_bufs;
1029         }
1030
1031         netif_start_queue(dev);
1032
1033         return 0;
1034
1035 out_remove_rx_bufs:
1036         remove_rx_bufs(dev);
1037         free_irq(dev->irq, dev);
1038 out:
1039         return -EAGAIN;
1040 }
1041
1042 static void i596_tx_timeout (struct net_device *dev)
1043 {
1044         struct i596_private *lp = dev->priv;
1045
1046         /* Transmitter timeout, serious problems. */
1047         DEB(DEB_ERRORS,printk("%s: transmit timed out, status resetting.\n",
1048                         dev->name));
1049
1050         lp->stats.tx_errors++;
1051
1052         /* Try to restart the adaptor */
1053         if (lp->last_restart == lp->stats.tx_packets) {
1054                 DEB(DEB_ERRORS,printk ("Resetting board.\n"));
1055                 /* Shutdown and restart */
1056                 i596_reset (dev, lp);
1057         } else {
1058                 /* Issue a channel attention signal */
1059                 DEB(DEB_ERRORS,printk ("Kicking board.\n"));
1060                 lp->scb.command = CUC_START | RX_START;
1061                 CHECK_WBACK_INV(&(lp->scb), sizeof(struct i596_scb));
1062                 CA (dev);
1063                 lp->last_restart = lp->stats.tx_packets;
1064         }
1065
1066         dev->trans_start = jiffies;
1067         netif_wake_queue (dev);
1068 }
1069
1070
1071 static int i596_start_xmit(struct sk_buff *skb, struct net_device *dev)
1072 {
1073         struct i596_private *lp = dev->priv;
1074         struct tx_cmd *tx_cmd;
1075         struct i596_tbd *tbd;
1076         short length = skb->len;
1077         dev->trans_start = jiffies;
1078
1079         DEB(DEB_STARTTX,printk("%s: i596_start_xmit(%x,%p) called\n", dev->name,
1080                                 skb->len, skb->data));
1081
1082         if (length < ETH_ZLEN) {
1083                 skb = skb_padto(skb, ETH_ZLEN);
1084                 if (skb == NULL)
1085                         return 0;
1086                 length = ETH_ZLEN;
1087         }
1088
1089         netif_stop_queue(dev);
1090
1091         tx_cmd = lp->tx_cmds + lp->next_tx_cmd;
1092         tbd = lp->tbds + lp->next_tx_cmd;
1093
1094         if (tx_cmd->cmd.command) {
1095                 DEB(DEB_ERRORS,printk ("%s: xmit ring full, dropping packet.\n",
1096                                 dev->name));
1097                 lp->stats.tx_dropped++;
1098
1099                 dev_kfree_skb(skb);
1100         } else {
1101                 if (++lp->next_tx_cmd == TX_RING_SIZE)
1102                         lp->next_tx_cmd = 0;
1103                 tx_cmd->tbd = WSWAPtbd(virt_to_dma(lp,tbd));
1104                 tbd->next = I596_NULL;
1105
1106                 tx_cmd->cmd.command = CMD_FLEX | CmdTx;
1107                 tx_cmd->skb = skb;
1108
1109                 tx_cmd->pad = 0;
1110                 tx_cmd->size = 0;
1111                 tbd->pad = 0;
1112                 tbd->size = EOF | length;
1113
1114                 tx_cmd->dma_addr = dma_map_single(lp->dev, skb->data, skb->len,
1115                                 DMA_TO_DEVICE);
1116                 tbd->data = WSWAPchar(tx_cmd->dma_addr);
1117
1118                 DEB(DEB_TXADDR,print_eth(skb->data, "tx-queued"));
1119                 CHECK_WBACK_INV(tx_cmd, sizeof(struct tx_cmd));
1120                 CHECK_WBACK_INV(tbd, sizeof(struct i596_tbd));
1121                 i596_add_cmd(dev, &tx_cmd->cmd);
1122
1123                 lp->stats.tx_packets++;
1124                 lp->stats.tx_bytes += length;
1125         }
1126
1127         netif_start_queue(dev);
1128
1129         return 0;
1130 }
1131
1132 static void print_eth(unsigned char *add, char *str)
1133 {
1134         int i;
1135
1136         printk("i596 0x%p, ", add);
1137         for (i = 0; i < 6; i++)
1138                 printk(" %02X", add[i + 6]);
1139         printk(" -->");
1140         for (i = 0; i < 6; i++)
1141                 printk(" %02X", add[i]);
1142         printk(" %02X%02X, %s\n", add[12], add[13], str);
1143 }
1144
1145
1146 #define LAN_PROM_ADDR   0xF0810000
1147
1148 static int __devinit i82596_probe(struct net_device *dev,
1149                                   struct device *gen_dev)
1150 {
1151         int i;
1152         struct i596_private *lp;
1153         char eth_addr[6];
1154         dma_addr_t dma_addr;
1155
1156         /* This lot is ensure things have been cache line aligned. */
1157         if (sizeof(struct i596_rfd) != 32) {
1158             printk("82596: sizeof(struct i596_rfd) = %d\n",
1159                             sizeof(struct i596_rfd));
1160             return -ENODEV;
1161         }
1162         if ((sizeof(struct i596_rbd) % 32) != 0) {
1163             printk("82596: sizeof(struct i596_rbd) = %d\n",
1164                             sizeof(struct i596_rbd));
1165             return -ENODEV;
1166         }
1167         if ((sizeof(struct tx_cmd) % 32) != 0) {
1168             printk("82596: sizeof(struct tx_cmd) = %d\n",
1169                             sizeof(struct tx_cmd));
1170             return -ENODEV;
1171         }
1172         if (sizeof(struct i596_tbd) != 32) {
1173             printk("82596: sizeof(struct i596_tbd) = %d\n",
1174                             sizeof(struct i596_tbd));
1175             return -ENODEV;
1176         }
1177 #ifndef __LP64__
1178         if (sizeof(struct i596_private) > 4096) {
1179             printk("82596: sizeof(struct i596_private) = %d\n",
1180                             sizeof(struct i596_private));
1181             return -ENODEV;
1182         }
1183 #endif
1184
1185         if (!dev->base_addr || !dev->irq)
1186                 return -ENODEV;
1187
1188         if (pdc_lan_station_id(eth_addr, dev->base_addr)) {
1189                 for (i=0; i < 6; i++) {
1190                         eth_addr[i] = gsc_readb(LAN_PROM_ADDR + i);
1191                 }
1192                 printk("82596.c: MAC of HP700 LAN read from EEPROM\n");
1193         }
1194
1195         dev->mem_start = (unsigned long) dma_alloc_noncoherent(gen_dev,
1196                 sizeof(struct i596_private), &dma_addr, GFP_KERNEL);
1197         if (!dev->mem_start) {
1198                 printk("%s: Couldn't get shared memory\n", dev->name);
1199                 return -ENOMEM;
1200         }
1201
1202         DEB(DEB_PROBE,printk("%s: 82596 at %#3lx,", dev->name, dev->base_addr));
1203
1204         for (i = 0; i < 6; i++)
1205                 DEB(DEB_PROBE,printk(" %2.2X", dev->dev_addr[i] = eth_addr[i]));
1206
1207         DEB(DEB_PROBE,printk(" IRQ %d.\n", dev->irq));
1208
1209         DEB(DEB_PROBE,printk(version));
1210
1211         /* The 82596-specific entries in the device structure. */
1212         dev->open = i596_open;
1213         dev->stop = i596_close;
1214         dev->hard_start_xmit = i596_start_xmit;
1215         dev->get_stats = i596_get_stats;
1216         dev->set_multicast_list = set_multicast_list;
1217         dev->tx_timeout = i596_tx_timeout;
1218         dev->watchdog_timeo = TX_TIMEOUT;
1219
1220         dev->priv = (void *)(dev->mem_start);
1221
1222         lp = dev->priv;
1223         DEB(DEB_INIT,printk ("%s: lp at 0x%08lx (%d bytes), lp->scb at 0x%08lx\n",
1224                 dev->name, (unsigned long)lp,
1225                 sizeof(struct i596_private), (unsigned long)&lp->scb));
1226         memset(lp, 0, sizeof(struct i596_private));
1227
1228         lp->scb.command = 0;
1229         lp->scb.cmd = I596_NULL;
1230         lp->scb.rfd = I596_NULL;
1231         lp->lock = SPIN_LOCK_UNLOCKED;
1232         lp->dma_addr = dma_addr;
1233         lp->dev = gen_dev;
1234
1235         CHECK_WBACK_INV(dev->mem_start, sizeof(struct i596_private));
1236
1237         return 0;
1238 }
1239
1240
1241 static irqreturn_t i596_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1242 {
1243         struct net_device *dev = dev_id;
1244         struct i596_private *lp;
1245         unsigned short status, ack_cmd = 0;
1246
1247         if (dev == NULL) {
1248                 printk("i596_interrupt(): irq %d for unknown device.\n", irq);
1249                 return IRQ_NONE;
1250         }
1251
1252         lp = dev->priv;
1253
1254         spin_lock (&lp->lock);
1255
1256         wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1257         status = lp->scb.status;
1258
1259         DEB(DEB_INTS,printk("%s: i596 interrupt, IRQ %d, status %4.4x.\n",
1260                         dev->name, irq, status));
1261
1262         ack_cmd = status & 0xf000;
1263
1264         if (!ack_cmd) {
1265                 DEB(DEB_ERRORS, printk("%s: interrupt with no events\n", dev->name));
1266                 spin_unlock (&lp->lock);
1267                 return IRQ_NONE;
1268         }
1269
1270         if ((status & 0x8000) || (status & 0x2000)) {
1271                 struct i596_cmd *ptr;
1272
1273                 if ((status & 0x8000))
1274                         DEB(DEB_INTS,printk("%s: i596 interrupt completed command.\n", dev->name));
1275                 if ((status & 0x2000))
1276                         DEB(DEB_INTS,printk("%s: i596 interrupt command unit inactive %x.\n", dev->name, status & 0x0700));
1277
1278                 while (lp->cmd_head != NULL) {
1279                         CHECK_INV(lp->cmd_head, sizeof(struct i596_cmd));
1280                         if (!(lp->cmd_head->status & STAT_C))
1281                                 break;
1282
1283                         ptr = lp->cmd_head;
1284
1285                         DEB(DEB_STATUS,printk("cmd_head->status = %04x, ->command = %04x\n",
1286                                        lp->cmd_head->status, lp->cmd_head->command));
1287                         lp->cmd_head = ptr->v_next;
1288                         lp->cmd_backlog--;
1289
1290                         switch ((ptr->command) & 0x7) {
1291                         case CmdTx:
1292                             {
1293                                 struct tx_cmd *tx_cmd = (struct tx_cmd *) ptr;
1294                                 struct sk_buff *skb = tx_cmd->skb;
1295
1296                                 if ((ptr->status) & STAT_OK) {
1297                                         DEB(DEB_TXADDR,print_eth(skb->data, "tx-done"));
1298                                 } else {
1299                                         lp->stats.tx_errors++;
1300                                         if ((ptr->status) & 0x0020)
1301                                                 lp->stats.collisions++;
1302                                         if (!((ptr->status) & 0x0040))
1303                                                 lp->stats.tx_heartbeat_errors++;
1304                                         if ((ptr->status) & 0x0400)
1305                                                 lp->stats.tx_carrier_errors++;
1306                                         if ((ptr->status) & 0x0800)
1307                                                 lp->stats.collisions++;
1308                                         if ((ptr->status) & 0x1000)
1309                                                 lp->stats.tx_aborted_errors++;
1310                                 }
1311                                 dma_unmap_single(lp->dev, tx_cmd->dma_addr, skb->len, DMA_TO_DEVICE);
1312                                 dev_kfree_skb_irq(skb);
1313
1314                                 tx_cmd->cmd.command = 0; /* Mark free */
1315                                 break;
1316                             }
1317                         case CmdTDR:
1318                             {
1319                                 unsigned short status = ((struct tdr_cmd *)ptr)->status;
1320
1321                                 if (status & 0x8000) {
1322                                         DEB(DEB_ANY,printk("%s: link ok.\n", dev->name));
1323                                 } else {
1324                                         if (status & 0x4000)
1325                                                 printk("%s: Transceiver problem.\n", dev->name);
1326                                         if (status & 0x2000)
1327                                                 printk("%s: Termination problem.\n", dev->name);
1328                                         if (status & 0x1000)
1329                                                 printk("%s: Short circuit.\n", dev->name);
1330
1331                                         DEB(DEB_TDR,printk("%s: Time %d.\n", dev->name, status & 0x07ff));
1332                                 }
1333                                 break;
1334                             }
1335                         case CmdConfigure:
1336                                 /* Zap command so set_multicast_list() knows it is free */
1337                                 ptr->command = 0;
1338                                 break;
1339                         }
1340                         ptr->v_next = NULL;
1341                         ptr->b_next = I596_NULL;
1342                         CHECK_WBACK(ptr, sizeof(struct i596_cmd));
1343                         lp->last_cmd = jiffies;
1344                 }
1345
1346                 /* This mess is arranging that only the last of any outstanding
1347                  * commands has the interrupt bit set.  Should probably really
1348                  * only add to the cmd queue when the CU is stopped.
1349                  */
1350                 ptr = lp->cmd_head;
1351                 while ((ptr != NULL) && (ptr != lp->cmd_tail)) {
1352                         struct i596_cmd *prev = ptr;
1353
1354                         ptr->command &= 0x1fff;
1355                         ptr = ptr->v_next;
1356                         CHECK_WBACK_INV(prev, sizeof(struct i596_cmd));
1357                 }
1358
1359                 if ((lp->cmd_head != NULL))
1360                         ack_cmd |= CUC_START;
1361                 lp->scb.cmd = WSWAPcmd(virt_to_dma(lp,&lp->cmd_head->status));
1362                 CHECK_WBACK_INV(&lp->scb, sizeof(struct i596_scb));
1363         }
1364         if ((status & 0x1000) || (status & 0x4000)) {
1365                 if ((status & 0x4000))
1366                         DEB(DEB_INTS,printk("%s: i596 interrupt received a frame.\n", dev->name));
1367                 i596_rx(dev);
1368                 /* Only RX_START if stopped - RGH 07-07-96 */
1369                 if (status & 0x1000) {
1370                         if (netif_running(dev)) {
1371                                 DEB(DEB_ERRORS,printk("%s: i596 interrupt receive unit inactive, status 0x%x\n", dev->name, status));
1372                                 ack_cmd |= RX_START;
1373                                 lp->stats.rx_errors++;
1374                                 lp->stats.rx_fifo_errors++;
1375                                 rebuild_rx_bufs(dev);
1376                         }
1377                 }
1378         }
1379         wait_cmd(dev,lp,100,"i596 interrupt, timeout");
1380         lp->scb.command = ack_cmd;
1381         CHECK_WBACK(&lp->scb, sizeof(struct i596_scb));
1382
1383         /* DANGER: I suspect that some kind of interrupt
1384          acknowledgement aside from acking the 82596 might be needed
1385          here...  but it's running acceptably without */
1386
1387         CA(dev);
1388
1389         wait_cmd(dev,lp,100,"i596 interrupt, exit timeout");
1390         DEB(DEB_INTS,printk("%s: exiting interrupt.\n", dev->name));
1391
1392         spin_unlock (&lp->lock);
1393         return IRQ_HANDLED;
1394 }
1395
1396 static int i596_close(struct net_device *dev)
1397 {
1398         struct i596_private *lp = dev->priv;
1399         unsigned long flags;
1400
1401         netif_stop_queue(dev);
1402
1403         DEB(DEB_INIT,printk("%s: Shutting down ethercard, status was %4.4x.\n",
1404                        dev->name, lp->scb.status));
1405
1406         spin_lock_irqsave(&lp->lock, flags);
1407
1408         wait_cmd(dev,lp,100,"close1 timed out");
1409         lp->scb.command = CUC_ABORT | RX_ABORT;
1410         CHECK_WBACK(&lp->scb, sizeof(struct i596_scb));
1411
1412         CA(dev);
1413
1414         wait_cmd(dev,lp,100,"close2 timed out");
1415         spin_unlock_irqrestore(&lp->lock, flags);
1416         DEB(DEB_STRUCT,i596_display_data(dev));
1417         i596_cleanup_cmd(dev,lp);
1418
1419         disable_irq(dev->irq);
1420
1421         free_irq(dev->irq, dev);
1422         remove_rx_bufs(dev);
1423
1424         MOD_DEC_USE_COUNT;
1425
1426         return 0;
1427 }
1428
1429 static struct net_device_stats *
1430  i596_get_stats(struct net_device *dev)
1431 {
1432         struct i596_private *lp = dev->priv;
1433
1434         return &lp->stats;
1435 }
1436
1437 /*
1438  *    Set or clear the multicast filter for this adaptor.
1439  */
1440
1441 static void set_multicast_list(struct net_device *dev)
1442 {
1443         struct i596_private *lp = dev->priv;
1444         int config = 0, cnt;
1445
1446         DEB(DEB_MULTI,printk("%s: set multicast list, %d entries, promisc %s, allmulti %s\n", dev->name, dev->mc_count, dev->flags & IFF_PROMISC ? "ON" : "OFF", dev->flags & IFF_ALLMULTI ? "ON" : "OFF"));
1447
1448         if ((dev->flags & IFF_PROMISC) && !(lp->cf_cmd.i596_config[8] & 0x01)) {
1449                 lp->cf_cmd.i596_config[8] |= 0x01;
1450                 config = 1;
1451         }
1452         if (!(dev->flags & IFF_PROMISC) && (lp->cf_cmd.i596_config[8] & 0x01)) {
1453                 lp->cf_cmd.i596_config[8] &= ~0x01;
1454                 config = 1;
1455         }
1456         if ((dev->flags & IFF_ALLMULTI) && (lp->cf_cmd.i596_config[11] & 0x20)) {
1457                 lp->cf_cmd.i596_config[11] &= ~0x20;
1458                 config = 1;
1459         }
1460         if (!(dev->flags & IFF_ALLMULTI) && !(lp->cf_cmd.i596_config[11] & 0x20)) {
1461                 lp->cf_cmd.i596_config[11] |= 0x20;
1462                 config = 1;
1463         }
1464         if (config) {
1465                 if (lp->cf_cmd.cmd.command)
1466                         printk("%s: config change request already queued\n",
1467                                dev->name);
1468                 else {
1469                         lp->cf_cmd.cmd.command = CmdConfigure;
1470                         CHECK_WBACK_INV(&lp->cf_cmd, sizeof(struct cf_cmd));
1471                         i596_add_cmd(dev, &lp->cf_cmd.cmd);
1472                 }
1473         }
1474
1475         cnt = dev->mc_count;
1476         if (cnt > MAX_MC_CNT)
1477         {
1478                 cnt = MAX_MC_CNT;
1479                 printk("%s: Only %d multicast addresses supported",
1480                         dev->name, cnt);
1481         }
1482
1483         if (dev->mc_count > 0) {
1484                 struct dev_mc_list *dmi;
1485                 unsigned char *cp;
1486                 struct mc_cmd *cmd;
1487
1488                 cmd = &lp->mc_cmd;
1489                 cmd->cmd.command = CmdMulticastList;
1490                 cmd->mc_cnt = dev->mc_count * 6;
1491                 cp = cmd->mc_addrs;
1492                 for (dmi = dev->mc_list; cnt && dmi != NULL; dmi = dmi->next, cnt--, cp += 6) {
1493                         memcpy(cp, dmi->dmi_addr, 6);
1494                         if (i596_debug > 1)
1495                                 DEB(DEB_MULTI,printk("%s: Adding address %02x:%02x:%02x:%02x:%02x:%02x\n",
1496                                                 dev->name, cp[0],cp[1],cp[2],cp[3],cp[4],cp[5]));
1497                 }
1498                 CHECK_WBACK_INV(&lp->mc_cmd, sizeof(struct mc_cmd));
1499                 i596_add_cmd(dev, &cmd->cmd);
1500         }
1501 }
1502
1503 MODULE_PARM(debug, "i");
1504 MODULE_PARM_DESC(debug, "lasi_82596 debug mask");
1505 static int debug = -1;
1506
1507 static int num_drivers;
1508 static struct net_device *netdevs[MAX_DRIVERS];
1509
1510 static int __devinit
1511 lan_init_chip(struct parisc_device *dev)
1512 {
1513         struct  net_device *netdevice;
1514         int     retval;
1515
1516         if (num_drivers >= MAX_DRIVERS) {
1517                 /* max count of possible i82596 drivers reached */
1518                 return -ENODEV;
1519         }
1520
1521         if (!dev->irq) {
1522                 printk(KERN_ERR __FILE__ ": IRQ not found for i82596 at 0x%lx\n", dev->hpa);
1523                 return -ENODEV;
1524         }
1525
1526         printk(KERN_INFO "Found i82596 at 0x%lx, IRQ %d\n", dev->hpa, dev->irq);
1527
1528         netdevice = alloc_etherdev(0);
1529         if (!netdevice)
1530                 return -ENOMEM;
1531
1532         netdevice->base_addr = dev->hpa;
1533         netdevice->irq = dev->irq;
1534
1535         retval = i82596_probe(netdevice, &dev->dev);
1536         if (retval) {
1537                 free_netdev(netdevice);
1538                 return -ENODEV;
1539         }
1540
1541         retval = register_netdev(netdevice);
1542         if (retval) {
1543                 struct i596_private *lp = netdevice->priv;
1544                 printk(KERN_WARNING __FILE__ ": register_netdevice ret'd %d\n", retval);
1545                 dma_free_noncoherent(lp->dev, sizeof(struct i596_private),
1546                                     (void *)netdevice->mem_start, lp->dma_addr);
1547                 free_netdev(netdevice);
1548                 return -ENODEV;
1549         };
1550         if (dev->id.sversion == 0x72) {
1551                 ((struct i596_private *)netdevice->priv)->options = OPT_SWAP_PORT;
1552         }
1553
1554         netdevs[num_drivers++] = netdevice;
1555
1556         return retval;
1557 }
1558
1559
1560 static struct parisc_device_id lan_tbl[] = {
1561         { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x0008a },
1562         { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00072 },
1563         { 0, }
1564 };
1565
1566 MODULE_DEVICE_TABLE(parisc, lan_tbl);
1567
1568 static struct parisc_driver lan_driver = {
1569         .name           = "Apricot",
1570         .id_table       = lan_tbl,
1571         .probe          = lan_init_chip,
1572 };
1573
1574 static int __devinit lasi_82596_init(void)
1575 {
1576         if (debug >= 0)
1577                 i596_debug = debug;
1578         return register_parisc_driver(&lan_driver);
1579 }
1580
1581 module_init(lasi_82596_init);
1582
1583 static void __exit lasi_82596_exit(void)
1584 {
1585         int i;
1586
1587         for (i=0; i<MAX_DRIVERS; i++) {
1588                 struct i596_private *lp;
1589                 struct net_device *netdevice;
1590
1591                 netdevice = netdevs[i];
1592                 if (!netdevice)
1593                         continue;
1594
1595                 unregister_netdev(netdevice);
1596
1597                 lp = netdevice->priv;
1598                 dma_free_noncoherent(lp->dev, sizeof(struct i596_private),
1599                                        (void *)netdevice->mem_start, lp->dma_addr);
1600                 free_netdev(netdevice);
1601         }
1602
1603         unregister_parisc_driver(&lan_driver);
1604 }
1605
1606 module_exit(lasi_82596_exit);