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