drivers/net/seeq8005.c

   1 /* seeq8005.c: A network driver for linux. */
   2 /*
   3         Based on skeleton.c,
   4         Written 1993-94 by Donald Becker.
   5         See the skeleton.c file for further copyright information.
   6
   7         This software may be used and distributed according to the terms
   8         of the GNU General Public License, incorporated herein by reference.
   9
  10         The author may be reached as hamish@zot.apana.org.au
  11
  12         This file is a network device driver for the SEEQ 8005 chipset and
  13         the Linux operating system.
  14
  15 */
  16
  17 static const char version[] =
  18         "seeq8005.c:v1.00 8/07/95 Hamish Coleman (hamish@zot.apana.org.au)\n";
  19
  20 /*
  21   Sources:
  22         SEEQ 8005 databook
  23
  24   Version history:
  25         1.00    Public release. cosmetic changes (no warnings now)
  26         0.68    Turning per- packet,interrupt debug messages off - testing for release.
  27         0.67    timing problems/bad buffer reads seem to be fixed now
  28         0.63    *!@$ protocol=eth_type_trans -- now packets flow
  29         0.56    Send working
  30         0.48    Receive working
  31 */
  32
  33 #include <linux/module.h>
  34 #include <linux/kernel.h>
  35 #include <linux/types.h>
  36 #include <linux/fcntl.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/ioport.h>
  39 #include <linux/in.h>
  40 #include <linux/slab.h>
  41 #include <linux/string.h>
  42 #include <linux/init.h>
  43 #include <linux/delay.h>
  44 #include <linux/errno.h>
  45 #include <linux/netdevice.h>
  46 #include <linux/etherdevice.h>
  47 #include <linux/skbuff.h>
  48
  49 #include <asm/system.h>
  50 #include <asm/bitops.h>
  51 #include <asm/io.h>
  52 #include <asm/dma.h>
  53
  54 #include "seeq8005.h"
  55
  56 /* First, a few definitions that the brave might change. */
  57 /* A zero-terminated list of I/O addresses to be probed. */
  58 static unsigned int seeq8005_portlist[] __initdata =
  59    { 0x300, 0x320, 0x340, 0x360, 0};
  60
  61 /* use 0 for production, 1 for verification, >2 for debug */
  62 #ifndef NET_DEBUG
  63 #define NET_DEBUG 1
  64 #endif
  65 static unsigned int net_debug = NET_DEBUG;
  66
  67 /* Information that need to be kept for each board. */
  68 struct net_local {
  69         struct net_device_stats stats;
  70         unsigned short receive_ptr;             /* What address in packet memory do we expect a recv_pkt_header? */
  71         long open_time;                         /* Useless example local info. */
  72 };
  73
  74 /* The station (ethernet) address prefix, used for IDing the board. */
  75 #define SA_ADDR0 0x00
  76 #define SA_ADDR1 0x80
  77 #define SA_ADDR2 0x4b
  78
  79 /* Index to functions, as function prototypes. */
  80
  81 static int seeq8005_probe1(struct net_device *dev, int ioaddr);
  82 static int seeq8005_open(struct net_device *dev);
  83 static void seeq8005_timeout(struct net_device *dev);
  84 static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev);
  85 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs *regs);
  86 static void seeq8005_rx(struct net_device *dev);
  87 static int seeq8005_close(struct net_device *dev);
  88 static struct net_device_stats *seeq8005_get_stats(struct net_device *dev);
  89 static void set_multicast_list(struct net_device *dev);
  90
  91 /* Example routines you must write ;->. */
  92 #define tx_done(dev)    (inw(SEEQ_STATUS) & SEEQSTAT_TX_ON)
  93 static void hardware_send_packet(struct net_device *dev, char *buf, int length);
  94 extern void seeq8005_init(struct net_device *dev, int startp);
  95 static inline void wait_for_buffer(struct net_device *dev);
  96
  97 \f
  98 /* Check for a network adaptor of this type, and return '0' iff one exists.
  99    If dev->base_addr == 0, probe all likely locations.
 100    If dev->base_addr == 1, always return failure.
 101    */
 102
 103 static int io = 0x320;
 104 static int irq = 10;
 105
 106 struct net_device * __init seeq8005_probe(int unit)
 107 {
 108         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
 109         unsigned *port;
 110         int err = 0;
 111
 112         if (!dev)
 113                 return ERR_PTR(-ENODEV);
 114
 115         if (unit >= 0) {
 116                 sprintf(dev->name, "eth%d", unit);
 117                 netdev_boot_setup_check(dev);
 118                 io = dev->base_addr;
 119                 irq = dev->irq;
 120         }
 121
 122         if (io > 0x1ff) {       /* Check a single specified location. */
 123                 err = seeq8005_probe1(dev, io);
 124         } else if (io != 0) {   /* Don't probe at all. */
 125                 err = -ENXIO;
 126         } else {
 127                 for (port = seeq8005_portlist; *port; port++) {
 128                         if (seeq8005_probe1(dev, *port) == 0)
 129                                 break;
 130                 }
 131                 if (!*port)
 132                         err = -ENODEV;
 133         }
 134         if (err)
 135                 goto out;
 136         err = register_netdev(dev);
 137         if (err)
 138                 goto out1;
 139         return dev;
 140 out1:
 141         release_region(dev->base_addr, SEEQ8005_IO_EXTENT);
 142 out:
 143         free_netdev(dev);
 144         return ERR_PTR(err);
 145 }
 146
 147 /* This is the real probe routine.  Linux has a history of friendly device
 148    probes on the ISA bus.  A good device probes avoids doing writes, and
 149    verifies that the correct device exists and functions.  */
 150
 151 static int __init seeq8005_probe1(struct net_device *dev, int ioaddr)
 152 {
 153         static unsigned version_printed;
 154         int i,j;
 155         unsigned char SA_prom[32];
 156         int old_cfg1;
 157         int old_cfg2;
 158         int old_stat;
 159         int old_dmaar;
 160         int old_rear;
 161         int retval;
 162
 163         if (!request_region(ioaddr, SEEQ8005_IO_EXTENT, "seeq8005"))
 164                 return -ENODEV;
 165
 166         if (net_debug>1)
 167                 printk("seeq8005: probing at 0x%x\n",ioaddr);
 168
 169         old_stat = inw(SEEQ_STATUS);                                    /* read status register */
 170         if (old_stat == 0xffff) {
 171                 retval = -ENODEV;
 172                 goto out;                                               /* assume that 0xffff == no device */
 173         }
 174         if ( (old_stat & 0x1800) != 0x1800 ) {                          /* assume that unused bits are 1, as my manual says */
 175                 if (net_debug>1) {
 176                         printk("seeq8005: reserved stat bits != 0x1800\n");
 177                         printk("          == 0x%04x\n",old_stat);
 178                 }
 179                 retval = -ENODEV;
 180                 goto out;
 181         }
 182
 183         old_rear = inw(SEEQ_REA);
 184         if (old_rear == 0xffff) {
 185                 outw(0,SEEQ_REA);
 186                 if (inw(SEEQ_REA) == 0xffff) {                          /* assume that 0xffff == no device */
 187                         retval = -ENODEV;
 188                         goto out;
 189                 }
 190         } else if ((old_rear & 0xff00) != 0xff00) {                     /* assume that unused bits are 1 */
 191                 if (net_debug>1) {
 192                         printk("seeq8005: unused rear bits != 0xff00\n");
 193                         printk("          == 0x%04x\n",old_rear);
 194                 }
 195                 retval = -ENODEV;
 196                 goto out;
 197         }
 198
 199         old_cfg2 = inw(SEEQ_CFG2);                                      /* read CFG2 register */
 200         old_cfg1 = inw(SEEQ_CFG1);
 201         old_dmaar = inw(SEEQ_DMAAR);
 202
 203         if (net_debug>4) {
 204                 printk("seeq8005: stat = 0x%04x\n",old_stat);
 205                 printk("seeq8005: cfg1 = 0x%04x\n",old_cfg1);
 206                 printk("seeq8005: cfg2 = 0x%04x\n",old_cfg2);
 207                 printk("seeq8005: raer = 0x%04x\n",old_rear);
 208                 printk("seeq8005: dmaar= 0x%04x\n",old_dmaar);
 209         }
 210
 211         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);      /* setup for reading PROM */
 212         outw( 0, SEEQ_DMAAR);                                           /* set starting PROM address */
 213         outw( SEEQCFG1_BUFFER_PROM, SEEQ_CFG1);                         /* set buffer to look at PROM */
 214
 215
 216         j=0;
 217         for(i=0; i <32; i++) {
 218                 j+= SA_prom[i] = inw(SEEQ_BUFFER) & 0xff;
 219         }
 220
 221 #if 0
 222         /* untested because I only have the one card */
 223         if ( (j&0xff) != 0 ) {                                          /* checksum appears to be 8bit = 0 */
 224                 if (net_debug>1) {                                      /* check this before deciding that we have a card */
 225                         printk("seeq8005: prom sum error\n");
 226                 }
 227                 outw( old_stat, SEEQ_STATUS);
 228                 outw( old_dmaar, SEEQ_DMAAR);
 229                 outw( old_cfg1, SEEQ_CFG1);
 230                 retval = -ENODEV;
 231                 goto out;
 232         }
 233 #endif
 234
 235         outw( SEEQCFG2_RESET, SEEQ_CFG2);                               /* reset the card */
 236         udelay(5);
 237         outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
 238
 239         if (net_debug) {
 240                 printk("seeq8005: prom sum = 0x%08x\n",j);
 241                 for(j=0; j<32; j+=16) {
 242                         printk("seeq8005: prom %02x: ",j);
 243                         for(i=0;i<16;i++) {
 244                                 printk("%02x ",SA_prom[j|i]);
 245                         }
 246                         printk(" ");
 247                         for(i=0;i<16;i++) {
 248                                 if ((SA_prom[j|i]>31)&&(SA_prom[j|i]<127)) {
 249                                         printk("%c", SA_prom[j|i]);
 250                                 } else {
 251                                         printk(" ");
 252                                 }
 253                         }
 254                         printk("\n");
 255                 }
 256         }
 257
 258 #if 0
 259         /*
 260          * testing the packet buffer memory doesn't work yet
 261          * but all other buffer accesses do
 262          *                      - fixing is not a priority
 263          */
 264         if (net_debug>1) {                                      /* test packet buffer memory */
 265                 printk("seeq8005: testing packet buffer ... ");
 266                 outw( SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
 267                 outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
 268                 outw( 0 , SEEQ_DMAAR);
 269                 for(i=0;i<32768;i++) {
 270                         outw(0x5a5a, SEEQ_BUFFER);
 271                 }
 272                 j=jiffies+HZ;
 273                 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_FIFO_EMPTY) != SEEQSTAT_FIFO_EMPTY) && time_before(jiffies, j) )
 274                         mb();
 275                 outw( 0 , SEEQ_DMAAR);
 276                 while ( ((inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, j+HZ))
 277                         mb();
 278                 if ( (inw(SEEQ_STATUS) & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
 279                         outw( SEEQCMD_WINDOW_INT_ACK | (inw(SEEQ_STATUS)& SEEQCMD_INT_MASK), SEEQ_CMD);
 280                 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
 281                 j=0;
 282                 for(i=0;i<32768;i++) {
 283                         if (inw(SEEQ_BUFFER) != 0x5a5a)
 284                                 j++;
 285                 }
 286                 if (j) {
 287                         printk("%i\n",j);
 288                 } else {
 289                         printk("ok.\n");
 290                 }
 291         }
 292 #endif
 293
 294         if (net_debug  &&  version_printed++ == 0)
 295                 printk(version);
 296
 297         printk("%s: %s found at %#3x, ", dev->name, "seeq8005", ioaddr);
 298
 299         /* Fill in the 'dev' fields. */
 300         dev->base_addr = ioaddr;
 301         dev->irq = irq;
 302
 303         /* Retrieve and print the ethernet address. */
 304         for (i = 0; i < 6; i++)
 305                 printk(" %2.2x", dev->dev_addr[i] = SA_prom[i+6]);
 306
 307         if (dev->irq == 0xff)
 308                 ;                       /* Do nothing: a user-level program will set it. */
 309         else if (dev->irq < 2) {        /* "Auto-IRQ" */
 310                 unsigned long cookie = probe_irq_on();
 311
 312                 outw( SEEQCMD_RX_INT_EN | SEEQCMD_SET_RX_ON | SEEQCMD_SET_RX_OFF, SEEQ_CMD );
 313
 314                 dev->irq = probe_irq_off(cookie);
 315
 316                 if (net_debug >= 2)
 317                         printk(" autoirq is %d\n", dev->irq);
 318         } else if (dev->irq == 2)
 319           /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
 320            * or don't know which one to set.
 321            */
 322           dev->irq = 9;
 323
 324 #if 0
 325         {
 326                  int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
 327                  if (irqval) {
 328                          printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
 329                                          dev->irq, irqval);
 330                          retval = -EAGAIN;
 331                          goto out;
 332                  }
 333         }
 334 #endif
 335         dev->open               = seeq8005_open;
 336         dev->stop               = seeq8005_close;
 337         dev->hard_start_xmit    = seeq8005_send_packet;
 338         dev->tx_timeout         = seeq8005_timeout;
 339         dev->watchdog_timeo     = HZ/20;
 340         dev->get_stats          = seeq8005_get_stats;
 341         dev->set_multicast_list = set_multicast_list;
 342         dev->flags &= ~IFF_MULTICAST;
 343
 344         return 0;
 345 out:
 346         release_region(ioaddr, SEEQ8005_IO_EXTENT);
 347         return retval;
 348 }
 349
 350 \f
 351 /* Open/initialize the board.  This is called (in the current kernel)
 352    sometime after booting when the 'ifconfig' program is run.
 353
 354    This routine should set everything up anew at each open, even
 355    registers that "should" only need to be set once at boot, so that
 356    there is non-reboot way to recover if something goes wrong.
 357    */
 358 static int seeq8005_open(struct net_device *dev)
 359 {
 360         struct net_local *lp = netdev_priv(dev);
 361
 362         {
 363                  int irqval = request_irq(dev->irq, &seeq8005_interrupt, 0, "seeq8005", dev);
 364                  if (irqval) {
 365                          printk ("%s: unable to get IRQ %d (irqval=%d).\n", dev->name,
 366                                          dev->irq, irqval);
 367                          return -EAGAIN;
 368                  }
 369         }
 370
 371         /* Reset the hardware here.  Don't forget to set the station address. */
 372         seeq8005_init(dev, 1);
 373
 374         lp->open_time = jiffies;
 375
 376         netif_start_queue(dev);
 377         return 0;
 378 }
 379
 380 static void seeq8005_timeout(struct net_device *dev)
 381 {
 382         int ioaddr = dev->base_addr;
 383         printk(KERN_WARNING "%s: transmit timed out, %s?\n", dev->name,
 384                    tx_done(dev) ? "IRQ conflict" : "network cable problem");
 385         /* Try to restart the adaptor. */
 386         seeq8005_init(dev, 1);
 387         dev->trans_start = jiffies;
 388         netif_wake_queue(dev);
 389 }
 390
 391 static int seeq8005_send_packet(struct sk_buff *skb, struct net_device *dev)
 392 {
 393         struct net_local *lp = netdev_priv(dev);
 394         short length = skb->len;
 395         unsigned char *buf;
 396
 397         if (length < ETH_ZLEN) {
 398                 skb = skb_padto(skb, ETH_ZLEN);
 399                 if (skb == NULL)
 400                         return 0;
 401                 length = ETH_ZLEN;
 402         }
 403         buf = skb->data;
 404
 405         /* Block a timer-based transmit from overlapping */
 406         netif_stop_queue(dev);
 407
 408         hardware_send_packet(dev, buf, length);
 409         dev->trans_start = jiffies;
 410         lp->stats.tx_bytes += length;
 411         dev_kfree_skb (skb);
 412         /* You might need to clean up and record Tx statistics here. */
 413
 414         return 0;
 415 }
 416 \f
 417 /* The typical workload of the driver:
 418    Handle the network interface interrupts. */
 419 static irqreturn_t seeq8005_interrupt(int irq, void *dev_id, struct pt_regs * regs)
 420 {
 421         struct net_device *dev = dev_id;
 422         struct net_local *lp;
 423         int ioaddr, status, boguscount = 0;
 424         int handled = 0;
 425
 426         ioaddr = dev->base_addr;
 427         lp = netdev_priv(dev);
 428
 429         status = inw(SEEQ_STATUS);
 430         do {
 431                 if (net_debug >2) {
 432                         printk("%s: int, status=0x%04x\n",dev->name,status);
 433                 }
 434
 435                 if (status & SEEQSTAT_WINDOW_INT) {
 436                         handled = 1;
 437                         outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 438                         if (net_debug) {
 439                                 printk("%s: window int!\n",dev->name);
 440                         }
 441                 }
 442                 if (status & SEEQSTAT_TX_INT) {
 443                         handled = 1;
 444                         outw( SEEQCMD_TX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 445                         lp->stats.tx_packets++;
 446                         netif_wake_queue(dev);  /* Inform upper layers. */
 447                 }
 448                 if (status & SEEQSTAT_RX_INT) {
 449                         handled = 1;
 450                         /* Got a packet(s). */
 451                         seeq8005_rx(dev);
 452                 }
 453                 status = inw(SEEQ_STATUS);
 454         } while ( (++boguscount < 10) && (status & SEEQSTAT_ANY_INT)) ;
 455
 456         if(net_debug>2) {
 457                 printk("%s: eoi\n",dev->name);
 458         }
 459         return IRQ_RETVAL(handled);
 460 }
 461
 462 /* We have a good packet(s), get it/them out of the buffers. */
 463 static void seeq8005_rx(struct net_device *dev)
 464 {
 465         struct net_local *lp = netdev_priv(dev);
 466         int boguscount = 10;
 467         int pkt_hdr;
 468         int ioaddr = dev->base_addr;
 469
 470         do {
 471                 int next_packet;
 472                 int pkt_len;
 473                 int i;
 474                 int status;
 475
 476                 status = inw(SEEQ_STATUS);
 477                 outw( lp->receive_ptr, SEEQ_DMAAR);
 478                 outw(SEEQCMD_FIFO_READ | SEEQCMD_RX_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 479                 wait_for_buffer(dev);
 480                 next_packet = ntohs(inw(SEEQ_BUFFER));
 481                 pkt_hdr = inw(SEEQ_BUFFER);
 482
 483                 if (net_debug>2) {
 484                         printk("%s: 0x%04x recv next=0x%04x, hdr=0x%04x\n",dev->name,lp->receive_ptr,next_packet,pkt_hdr);
 485                 }
 486
 487                 if ((next_packet == 0) || ((pkt_hdr & SEEQPKTH_CHAIN)==0)) {    /* Read all the frames? */
 488                         return;                                                 /* Done for now */
 489                 }
 490
 491                 if ((pkt_hdr & SEEQPKTS_DONE)==0)
 492                         break;
 493
 494                 if (next_packet < lp->receive_ptr) {
 495                         pkt_len = (next_packet + 0x10000 - ((DEFAULT_TEA+1)<<8)) - lp->receive_ptr - 4;
 496                 } else {
 497                         pkt_len = next_packet - lp->receive_ptr - 4;
 498                 }
 499
 500                 if (next_packet < ((DEFAULT_TEA+1)<<8)) {                       /* is the next_packet address sane? */
 501                         printk("%s: recv packet ring corrupt, resetting board\n",dev->name);
 502                         seeq8005_init(dev,1);
 503                         return;
 504                 }
 505
 506                 lp->receive_ptr = next_packet;
 507
 508                 if (net_debug>2) {
 509                         printk("%s: recv len=0x%04x\n",dev->name,pkt_len);
 510                 }
 511
 512                 if (pkt_hdr & SEEQPKTS_ANY_ERROR) {                             /* There was an error. */
 513                         lp->stats.rx_errors++;
 514                         if (pkt_hdr & SEEQPKTS_SHORT) lp->stats.rx_frame_errors++;
 515                         if (pkt_hdr & SEEQPKTS_DRIB) lp->stats.rx_frame_errors++;
 516                         if (pkt_hdr & SEEQPKTS_OVERSIZE) lp->stats.rx_over_errors++;
 517                         if (pkt_hdr & SEEQPKTS_CRC_ERR) lp->stats.rx_crc_errors++;
 518                         /* skip over this packet */
 519                         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_DMA_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 520                         outw( (lp->receive_ptr & 0xff00)>>8, SEEQ_REA);
 521                 } else {
 522                         /* Malloc up new buffer. */
 523                         struct sk_buff *skb;
 524                         unsigned char *buf;
 525
 526                         skb = dev_alloc_skb(pkt_len);
 527                         if (skb == NULL) {
 528                                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 529                                 lp->stats.rx_dropped++;
 530                                 break;
 531                         }
 532                         skb->dev = dev;
 533                         skb_reserve(skb, 2);    /* align data on 16 byte */
 534                         buf = skb_put(skb,pkt_len);
 535
 536                         insw(SEEQ_BUFFER, buf, (pkt_len + 1) >> 1);
 537
 538                         if (net_debug>2) {
 539                                 char * p = buf;
 540                                 printk("%s: recv ",dev->name);
 541                                 for(i=0;i<14;i++) {
 542                                         printk("%02x ",*(p++)&0xff);
 543                                 }
 544                                 printk("\n");
 545                         }
 546
 547                         skb->protocol=eth_type_trans(skb,dev);
 548                         netif_rx(skb);
 549                         dev->last_rx = jiffies;
 550                         lp->stats.rx_packets++;
 551                         lp->stats.rx_bytes += pkt_len;
 552                 }
 553         } while ((--boguscount) && (pkt_hdr & SEEQPKTH_CHAIN));
 554
 555         /* If any worth-while packets have been received, netif_rx()
 556            has done a mark_bh(NET_BH) for us and will work on them
 557            when we get to the bottom-half routine. */
 558         return;
 559 }
 560
 561 /* The inverse routine to net_open(). */
 562 static int seeq8005_close(struct net_device *dev)
 563 {
 564         struct net_local *lp = netdev_priv(dev);
 565         int ioaddr = dev->base_addr;
 566
 567         lp->open_time = 0;
 568
 569         netif_stop_queue(dev);
 570
 571         /* Flush the Tx and disable Rx here. */
 572         outw( SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
 573
 574         free_irq(dev->irq, dev);
 575
 576         /* Update the statistics here. */
 577
 578         return 0;
 579
 580 }
 581
 582 /* Get the current statistics.  This may be called with the card open or
 583    closed. */
 584 static struct net_device_stats *seeq8005_get_stats(struct net_device *dev)
 585 {
 586         struct net_local *lp = netdev_priv(dev);
 587
 588         return &lp->stats;
 589 }
 590
 591 /* Set or clear the multicast filter for this adaptor.
 592    num_addrs == -1      Promiscuous mode, receive all packets
 593    num_addrs == 0       Normal mode, clear multicast list
 594    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 595                         best-effort filtering.
 596  */
 597 static void set_multicast_list(struct net_device *dev)
 598 {
 599 /*
 600  * I _could_ do up to 6 addresses here, but won't (yet?)
 601  */
 602
 603 #if 0
 604         int ioaddr = dev->base_addr;
 605 /*
 606  * hmm, not even sure if my matching works _anyway_ - seem to be receiving
 607  * _everything_ . . .
 608  */
 609
 610         if (num_addrs) {                        /* Enable promiscuous mode */
 611                 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_ALL,  SEEQ_CFG1);
 612                 dev->flags|=IFF_PROMISC;
 613         } else {                                /* Disable promiscuous mode, use normal mode */
 614                 outw( (inw(SEEQ_CFG1) & ~SEEQCFG1_MATCH_MASK)| SEEQCFG1_MATCH_BROAD, SEEQ_CFG1);
 615         }
 616 #endif
 617 }
 618
 619 void seeq8005_init(struct net_device *dev, int startp)
 620 {
 621         struct net_local *lp = netdev_priv(dev);
 622         int ioaddr = dev->base_addr;
 623         int i;
 624
 625         outw(SEEQCFG2_RESET, SEEQ_CFG2);        /* reset device */
 626         udelay(5);
 627
 628         outw( SEEQCMD_FIFO_WRITE | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
 629         outw( 0, SEEQ_DMAAR);                   /* load start address into both low and high byte */
 630 /*      wait_for_buffer(dev); */                /* I think that you only need a wait for memory buffer */
 631         outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
 632
 633         for(i=0;i<6;i++) {                      /* set Station address */
 634                 outb(dev->dev_addr[i], SEEQ_BUFFER);
 635                 udelay(2);
 636         }
 637
 638         outw( SEEQCFG1_BUFFER_TEA, SEEQ_CFG1);  /* set xmit end area pointer to 16K */
 639         outb( DEFAULT_TEA, SEEQ_BUFFER);        /* this gives us 16K of send buffer and 48K of recv buffer */
 640
 641         lp->receive_ptr = (DEFAULT_TEA+1)<<8;   /* so we can find our packet_header */
 642         outw( lp->receive_ptr, SEEQ_RPR);       /* Receive Pointer Register is set to recv buffer memory */
 643
 644         outw( 0x00ff, SEEQ_REA);                /* Receive Area End */
 645
 646         if (net_debug>4) {
 647                 printk("%s: SA0 = ",dev->name);
 648
 649                 outw( SEEQCMD_FIFO_READ | SEEQCMD_SET_ALL_OFF, SEEQ_CMD);
 650                 outw( 0, SEEQ_DMAAR);
 651                 outw( SEEQCFG1_BUFFER_MAC0, SEEQ_CFG1);
 652
 653                 for(i=0;i<6;i++) {
 654                         printk("%02x ",inb(SEEQ_BUFFER));
 655                 }
 656                 printk("\n");
 657         }
 658
 659         outw( SEEQCFG1_MAC0_EN | SEEQCFG1_MATCH_BROAD | SEEQCFG1_BUFFER_BUFFER, SEEQ_CFG1);
 660         outw( SEEQCFG2_AUTO_REA | SEEQCFG2_CTRLO, SEEQ_CFG2);
 661         outw( SEEQCMD_SET_RX_ON | SEEQCMD_TX_INT_EN | SEEQCMD_RX_INT_EN, SEEQ_CMD);
 662
 663         if (net_debug>4) {
 664                 int old_cfg1;
 665                 old_cfg1 = inw(SEEQ_CFG1);
 666                 printk("%s: stat = 0x%04x\n",dev->name,inw(SEEQ_STATUS));
 667                 printk("%s: cfg1 = 0x%04x\n",dev->name,old_cfg1);
 668                 printk("%s: cfg2 = 0x%04x\n",dev->name,inw(SEEQ_CFG2));
 669                 printk("%s: raer = 0x%04x\n",dev->name,inw(SEEQ_REA));
 670                 printk("%s: dmaar= 0x%04x\n",dev->name,inw(SEEQ_DMAAR));
 671
 672         }
 673 }
 674
 675
 676 static void hardware_send_packet(struct net_device * dev, char *buf, int length)
 677 {
 678         int ioaddr = dev->base_addr;
 679         int status = inw(SEEQ_STATUS);
 680         int transmit_ptr = 0;
 681         int tmp;
 682
 683         if (net_debug>4) {
 684                 printk("%s: send 0x%04x\n",dev->name,length);
 685         }
 686
 687         /* Set FIFO to writemode and set packet-buffer address */
 688         outw( SEEQCMD_FIFO_WRITE | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 689         outw( transmit_ptr, SEEQ_DMAAR);
 690
 691         /* output SEEQ Packet header barfage */
 692         outw( htons(length + 4), SEEQ_BUFFER);
 693         outw( SEEQPKTH_XMIT | SEEQPKTH_DATA_FOLLOWS | SEEQPKTH_XMIT_INT_EN, SEEQ_BUFFER );
 694
 695         /* blat the buffer */
 696         outsw( SEEQ_BUFFER, buf, (length +1) >> 1);
 697         /* paranoia !! */
 698         outw( 0, SEEQ_BUFFER);
 699         outw( 0, SEEQ_BUFFER);
 700
 701         /* set address of start of transmit chain */
 702         outw( transmit_ptr, SEEQ_TPR);
 703
 704         /* drain FIFO */
 705         tmp = jiffies;
 706         while ( (((status=inw(SEEQ_STATUS)) & SEEQSTAT_FIFO_EMPTY) == 0) && (jiffies - tmp < HZ))
 707                 mb();
 708
 709         /* doit ! */
 710         outw( SEEQCMD_WINDOW_INT_ACK | SEEQCMD_SET_TX_ON | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 711
 712 }
 713
 714
 715 /*
 716  * wait_for_buffer
 717  *
 718  * This routine waits for the SEEQ chip to assert that the FIFO is ready
 719  * by checking for a window interrupt, and then clearing it. This has to
 720  * occur in the interrupt handler!
 721  */
 722 inline void wait_for_buffer(struct net_device * dev)
 723 {
 724         int ioaddr = dev->base_addr;
 725         unsigned long tmp;
 726         int status;
 727
 728         tmp = jiffies + HZ;
 729         while ( ( ((status=inw(SEEQ_STATUS)) & SEEQSTAT_WINDOW_INT) != SEEQSTAT_WINDOW_INT) && time_before(jiffies, tmp))
 730                 cpu_relax();
 731
 732         if ( (status & SEEQSTAT_WINDOW_INT) == SEEQSTAT_WINDOW_INT)
 733                 outw( SEEQCMD_WINDOW_INT_ACK | (status & SEEQCMD_INT_MASK), SEEQ_CMD);
 734 }
 735
 736 #ifdef MODULE
 737
 738 static struct net_device *dev_seeq;
 739 MODULE_LICENSE("GPL");
 740 MODULE_PARM(io, "i");
 741 MODULE_PARM(irq, "i");
 742 MODULE_PARM_DESC(io, "SEEQ 8005 I/O base address");
 743 MODULE_PARM_DESC(irq, "SEEQ 8005 IRQ number");
 744
 745 int init_module(void)
 746 {
 747         dev_seeq = seeq8005_probe(-1);
 748         if (IS_ERR(dev_seeq))
 749                 return PTR_ERR(dev_seeq);
 750         return 0;
 751 }
 752
 753 void cleanup_module(void)
 754 {
 755         unregister_netdev(dev_seeq);
 756         release_region(dev_seeq->base_addr, SEEQ8005_IO_EXTENT);
 757         free_netdev(dev_seeq);
 758 }
 759
 760 #endif /* MODULE */
 761 \f
 762 /*
 763  * Local variables:
 764  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
 765  *  version-control: t
 766  *  kept-new-versions: 5
 767  *  tab-width: 4
 768  * End:
 769  */