drivers/net/seeq8005.c

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

DEFINITIONS
