drivers/net/at1700.c

/* */
This source file includes following definitions.
at1700_probe
at1700_probe1
read_eeprom
net_open
net_send_packet
net_interrupt
net_rx
net_close
net_get_stats
set_multicast_list
   1 /* at1700.c: A network device driver for  the Allied Telesis AT1700.
   2 
   3         Written 1993-94 by Donald Becker.
   4 
   5         Copyright 1993 United States Government as represented by the
   6         Director, National Security Agency.
   7 
   8         This software may be used and distributed according to the terms
   9         of the GNU Public License, incorporated herein by reference.
  10 
  11         The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
  12         Center of Excellence in Space Data and Information Sciences
  13            Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  14 
  15         This is a device driver for the Allied Telesis AT1700, which is a
  16         straight-forward Fujitsu MB86965 implementation.
  17 
  18   Sources:
  19     The Fujitsu MB86695 datasheet.
  20 
  21         After the initial version of this driver was written Gerry Sockins of
  22         ATI provided their EEPROM configuration code header file.
  23     Thanks to NIIBE Yutaka <gniibe@mri.co.jp> for bug fixes.
  24 
  25   Bugs:
  26         The MB86695 has a design flaw that makes all probes unreliable.  Not
  27         only is it difficult to detect, it also moves around in I/O space in
  28         response to inb()s from other device probes!
  29 */
  30 
  31 static char *version =
  32         "at1700.c:v1.10 9/24/94  Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  33 
  34 #include <linux/config.h>
  35 
  36 #include <linux/kernel.h>
  37 #include <linux/sched.h>
  38 #include <linux/types.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/ptrace.h>
  42 #include <linux/ioport.h>
  43 #include <linux/in.h>
  44 #include <linux/malloc.h>
  45 #include <linux/string.h>
  46 #include <asm/system.h>
  47 #include <asm/bitops.h>
  48 #include <asm/io.h>
  49 #include <asm/dma.h>
  50 #include <linux/errno.h>
  51 
  52 #include <linux/netdevice.h>
  53 #include <linux/etherdevice.h>
  54 #include <linux/skbuff.h>
  55 extern struct device *init_etherdev(struct device *dev, int sizeof_private,
  56                                                                         unsigned long *mem_startp);
  57 
  58 /* This unusual address order is used to verify the CONFIG register. */
  59 static int at1700_probe_list[] =
  60 {0x260, 0x280, 0x2a0, 0x240, 0x340, 0x320, 0x380, 0x300, 0};
  61 
  62 /* use 0 for production, 1 for verification, >2 for debug */
  63 #ifndef NET_DEBUG
  64 #define NET_DEBUG 1
  65 #endif
  66 static unsigned int net_debug = NET_DEBUG;
  67 
  68 typedef unsigned char uchar;
  69 
  70 /* Information that need to be kept for each board. */
  71 struct net_local {
  72         struct enet_statistics stats;
  73         long open_time;                         /* Useless example local info. */
  74         uint tx_started:1;                      /* Number of packet on the Tx queue. */
  75         uchar tx_queue;                         /* Number of packet on the Tx queue. */
  76         ushort tx_queue_len;            /* Current length of the Tx queue. */
  77 };
  78 
  79 
  80 /* Offsets from the base address. */
  81 #define STATUS                  0
  82 #define TX_STATUS               0
  83 #define RX_STATUS               1
  84 #define TX_INTR                 2               /* Bit-mapped interrupt enable registers. */
  85 #define RX_INTR                 3
  86 #define TX_MODE                 4
  87 #define RX_MODE                 5
  88 #define CONFIG_0                6               /* Misc. configuration settings. */
  89 #define CONFIG_1                7
  90 /* Run-time register bank 2 definitions. */
  91 #define DATAPORT                8               /* Word-wide DMA or programmed-I/O dataport. */
  92 #define TX_START                10
  93 #define MODE13                  13
  94 #define EEPROM_Ctrl     16
  95 #define EEPROM_Data     17
  96 #define IOCONFIG                19
  97 #define RESET                   31              /* Write to reset some parts of the chip. */
  98 #define AT1700_IO_EXTENT        32
  99 
 100 /*  EEPROM_Ctrl bits. */
 101 #define EE_SHIFT_CLK    0x40    /* EEPROM shift clock, in reg. 16. */
 102 #define EE_CS                   0x20    /* EEPROM chip select, in reg. 16. */
 103 #define EE_DATA_WRITE   0x80    /* EEPROM chip data in, in reg. 17. */
 104 #define EE_DATA_READ    0x80    /* EEPROM chip data out, in reg. 17. */
 105 
 106 /* Delay between EEPROM clock transitions. */
 107 #define eeprom_delay()  do { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }} while (0)
 108 
 109 /* The EEPROM commands include the alway-set leading bit. */
 110 #define EE_WRITE_CMD    (5 << 6)
 111 #define EE_READ_CMD             (6 << 6)
 112 #define EE_ERASE_CMD    (7 << 6)
 113 
 114 
 115 /* Index to functions, as function prototypes. */
 116 
 117 extern int at1700_probe(struct device *dev);
 118 
 119 static int at1700_probe1(struct device *dev, short ioaddr);
 120 static int read_eeprom(int ioaddr, int location);
 121 static int net_open(struct device *dev);
 122 static int      net_send_packet(struct sk_buff *skb, struct device *dev);
 123 static void net_interrupt(int irq, struct pt_regs *regs);
 124 static void net_rx(struct device *dev);
 125 static int net_close(struct device *dev);
 126 static struct enet_statistics *net_get_stats(struct device *dev);
 127 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 128 
 129 
 130 /* Check for a network adaptor of this type, and return '0' iff one exists.
 131    If dev->base_addr == 0, probe all likely locations.
 132    If dev->base_addr == 1, always return failure.
 133    If dev->base_addr == 2, allocate space for the device and return success
 134    (detachable devices only).
 135    */
 136 #ifdef HAVE_DEVLIST
 137 /* Support for a alternate probe manager, which will eliminate the
 138    boilerplate below. */
 139 struct netdev_entry at1700_drv =
 140 {"at1700", at1700_probe1, AT1700_IO_EXTENT, at1700_probe_list};
 141 #else
 142 int
 143 at1700_probe(struct device *dev)
     /*  */
 144 {
 145         int i;
 146         int base_addr = dev ? dev->base_addr : 0;
 147 
 148         if (base_addr > 0x1ff)          /* Check a single specified location. */
 149                 return at1700_probe1(dev, base_addr);
 150         else if (base_addr != 0)        /* Don't probe at all. */
 151                 return ENXIO;
 152 
 153         for (i = 0; at1700_probe_list[i]; i++) {
 154                 int ioaddr = at1700_probe_list[i];
 155                 if (check_region(ioaddr, AT1700_IO_EXTENT))
 156                         continue;
 157                 if (at1700_probe1(dev, ioaddr) == 0)
 158                         return 0;
 159         }
 160 
 161         return ENODEV;
 162 }
 163 #endif
 164 
 165 /* The Fujitsu datasheet suggests that the NIC be probed for by checking its
 166    "signature", the default bit pattern after a reset.  This *doesn't* work --
 167    there is no way to reset the bus interface without a complete power-cycle!
 168 
 169    It turns out that ATI came to the same conclusion I did: the only thing
 170    that can be done is checking a few bits and then diving right into an
 171    EEPROM read. */
 172 
 173 int at1700_probe1(struct device *dev, short ioaddr)
     /*  */
 174 {
 175         char irqmap[8] = {3, 4, 5, 9, 10, 11, 14, 15};
 176         unsigned int i, irq;
 177 
 178         /* Resetting the chip doesn't reset the ISA interface, so don't bother.
 179            That means we have to be careful with the register values we probe for.
 180            */
 181 #ifdef notdef
 182         printk("at1700 probe at %#x, eeprom is %4.4x %4.4x %4.4x ctrl %4.4x.\n",
 183                    ioaddr, read_eeprom(ioaddr, 4), read_eeprom(ioaddr, 5),
 184                    read_eeprom(ioaddr, 6), inw(ioaddr + EEPROM_Ctrl));
 185 #endif
 186         if (at1700_probe_list[inb(ioaddr + IOCONFIG) & 0x07] != ioaddr
 187                 || read_eeprom(ioaddr, 4) != 0x0000
 188                 || read_eeprom(ioaddr, 5) & 0xff00 != 0xF400)
 189                 return -ENODEV;
 190 
 191         /* Reset the internal state machines. */
 192         outb(0, ioaddr + RESET);
 193 
 194         irq = irqmap[(read_eeprom(ioaddr, 12)&0x04)
 195                                  | (read_eeprom(ioaddr, 0)>>14)];
 196 
 197         /* Snarf the interrupt vector now. */
 198         if (request_irq(irq, &net_interrupt, 0, "at1700")) {
 199                 printk ("AT1700 found at %#3x, but it's unusable due to a conflict on"
 200                                 "IRQ %d.\n", ioaddr, irq);
 201                 return EAGAIN;
 202         }
 203 
 204         /* Allocate a new 'dev' if needed. */
 205         if (dev == NULL)
 206                 dev = init_etherdev(0, sizeof(struct net_local), 0);
 207 
 208         /* Grab the region so that we can find another board if the IRQ request
 209            fails. */
 210         request_region(ioaddr, AT1700_IO_EXTENT,"at1700");
 211 
 212         printk("%s: AT1700 found at %#3x, IRQ %d, address ", dev->name,
 213                    ioaddr, irq);
 214 
 215         dev->base_addr = ioaddr;
 216         dev->irq = irq;
 217         irq2dev_map[irq] = dev;
 218 
 219         for(i = 0; i < 3; i++) {
 220                 unsigned short eeprom_val = read_eeprom(ioaddr, 4+i);
 221                 printk("%04x", eeprom_val);
 222                 ((unsigned short *)dev->dev_addr)[i] = ntohs(eeprom_val);
 223         }
 224 
 225         /* The EEPROM word 12 bit 0x0400 means use regular 100 ohm 10baseT signals,
 226            rather than 150 ohm shielded twisted pair compensation.
 227            0x0000 == auto-sense the interface
 228            0x0800 == use TP interface
 229            0x1800 == use coax interface
 230            */
 231         {
 232                 char *porttype[] = {"auto-sense", "10baseT", "auto-sense", "10base2"};
 233                 ushort setup_value = read_eeprom(ioaddr, 12);
 234 
 235                 dev->if_port = setup_value >> 8;
 236                 printk(" %s interface.\n", porttype[(dev->if_port>>3) & 3]);
 237         }
 238 
 239         /* Set the station address in bank zero. */
 240         outb(0xe0, ioaddr + 7);
 241         for (i = 0; i < 6; i++)
 242                 outb(dev->dev_addr[i], ioaddr + 8 + i);
 243 
 244         /* Switch to bank 1 and set the multicast table to accept none. */
 245         outb(0xe4, ioaddr + 7);
 246         for (i = 0; i < 8; i++)
 247                 outb(0x00, ioaddr + 8 + i);
 248 
 249         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 250            bus access, two 4K Tx queues, and disabled Tx and Rx. */
 251         outb(0xda, ioaddr + CONFIG_0);
 252 
 253         /* Switch to bank 2 and lock our I/O address. */
 254         outb(0xe8, ioaddr + 7);
 255         outb(dev->if_port, MODE13);
 256 
 257         /* Power-down the chip.  Aren't we green! */
 258         outb(0x00, ioaddr + CONFIG_1);
 259 
 260         if (net_debug)
 261                 printk(version);
 262 
 263         /* Initialize the device structure. */
 264         if (dev->priv == NULL)
 265                 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
 266         memset(dev->priv, 0, sizeof(struct net_local));
 267 
 268         dev->open               = net_open;
 269         dev->stop               = net_close;
 270         dev->hard_start_xmit = net_send_packet;
 271         dev->get_stats  = net_get_stats;
 272         dev->set_multicast_list = &set_multicast_list;
 273 
 274         /* Fill in the fields of 'dev' with ethernet-generic values. */
 275            
 276         ether_setup(dev);
 277         return 0;
 278 }
 279 
 280 static int read_eeprom(int ioaddr, int location)
     /*  */
 281 {
 282         int i;
 283         unsigned short retval = 0;
 284         short ee_addr = ioaddr + EEPROM_Ctrl;
 285         short ee_daddr = ioaddr + EEPROM_Data;
 286         int read_cmd = location | EE_READ_CMD;
 287         short ctrl_val = EE_CS;
 288         
 289         outb(ctrl_val, ee_addr);
 290         
 291         /* Shift the read command bits out. */
 292         for (i = 9; i >= 0; i--) {
 293                 short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
 294                 outb(dataval, ee_daddr);
 295                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);    /* EEPROM clock tick. */
 296                 eeprom_delay();
 297                 outb(EE_CS, ee_addr);   /* Finish EEPROM a clock tick. */
 298                 eeprom_delay();
 299         }
 300         outb(EE_CS, ee_addr);
 301         
 302         for (i = 16; i > 0; i--) {
 303                 outb(EE_CS | EE_SHIFT_CLK, ee_addr);
 304                 eeprom_delay();
 305                 retval = (retval << 1) | ((inb(ee_daddr) & EE_DATA_READ) ? 1 : 0);
 306                 outb(EE_CS, ee_addr);
 307                 eeprom_delay();
 308         }
 309 
 310         /* Terminate the EEPROM access. */
 311         ctrl_val &= ~EE_CS;
 312         outb(ctrl_val | EE_SHIFT_CLK, ee_addr);
 313         eeprom_delay();
 314         outb(ctrl_val, ee_addr);
 315         eeprom_delay();
 316         return retval;
 317 }
 318 
 319 
 320 
 321 static int net_open(struct device *dev)
     /*  */
 322 {
 323         struct net_local *lp = (struct net_local *)dev->priv;
 324         int ioaddr = dev->base_addr;
 325         int i;
 326 
 327         /* Powerup the chip, initialize config register 1, and select bank 0. */
 328         outb(0xe0, ioaddr + CONFIG_1);
 329 
 330         /* Set the station address in bank zero. */
 331         for (i = 0; i < 6; i++)
 332                 outb(dev->dev_addr[i], ioaddr + 8 + i);
 333 
 334         /* Switch to bank 1 and set the multicast table to accept none. */
 335         outb(0xe4, ioaddr + 7);
 336         for (i = 0; i < 8; i++)
 337                 outb(0x00, ioaddr + 8 + i);
 338 
 339         /* Set the configuration register 0 to 32K 100ns. byte-wide memory, 16 bit
 340            bus access, and two 4K Tx queues. */
 341         outb(0xda, ioaddr + CONFIG_0);
 342 
 343         /* Same config 0, except enable the Rx and Tx. */
 344         outb(0x5a, ioaddr + CONFIG_0);
 345         /* Switch to register bank 2 for the run-time registers. */
 346         outb(0xe8, ioaddr + CONFIG_1);
 347 
 348         /* Turn on Rx interrupts, leave Tx interrupts off until packet Tx. */
 349         outb(0x00, ioaddr + TX_INTR);
 350         outb(0x81, ioaddr + RX_INTR);
 351 
 352         lp->open_time = jiffies;
 353 
 354         dev->tbusy = 0;
 355         dev->interrupt = 0;
 356         dev->start = 1;
 357 
 358         return 0;
 359 }
 360 
 361 static int
 362 net_send_packet(struct sk_buff *skb, struct device *dev)
     /*  */
 363 {
 364         struct net_local *lp = (struct net_local *)dev->priv;
 365         int ioaddr = dev->base_addr;
 366 
 367         if (dev->tbusy) {
 368                 /* If we get here, some higher level has decided we are broken.
 369                    There should really be a "kick me" function call instead. */
 370                 int tickssofar = jiffies - dev->trans_start;
 371                 if (tickssofar < 10)
 372                         return 1;
 373                 printk("%s: transmit timed out with status %04x, %s?\n", dev->name,
 374                            inw(ioaddr + STATUS), inb(ioaddr + TX_STATUS) & 0x80
 375                            ? "IRQ conflict" : "network cable problem");
 376                 printk("%s: timeout registers: %04x %04x %04x %04x %04x %04x %04x %04x.\n",
 377                            dev->name, inw(ioaddr + 0), inw(ioaddr + 2), inw(ioaddr + 4),
 378                            inw(ioaddr + 6), inw(ioaddr + 8), inw(ioaddr + 10),
 379                            inw(ioaddr + 12), inw(ioaddr + 14));
 380                 lp->stats.tx_errors++;
 381                 /* ToDo: We should try to restart the adaptor... */
 382                 outw(0xffff, ioaddr + 24);
 383                 outw(0xffff, ioaddr + TX_STATUS);
 384                 outw(0xe85a, ioaddr + CONFIG_0);
 385                 outw(0x8100, ioaddr + TX_INTR);
 386                 dev->tbusy=0;
 387                 dev->trans_start = jiffies;
 388         }
 389 
 390         /* If some higher layer thinks we've missed an tx-done interrupt
 391            we are passed NULL. Caution: dev_tint() handles the cli()/sti()
 392            itself. */
 393         if (skb == NULL) {
 394                 dev_tint(dev);
 395                 return 0;
 396         }
 397 
 398         /* Block a timer-based transmit from overlapping.  This could better be
 399            done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 400         if (set_bit(0, (void*)&dev->tbusy) != 0)
 401                 printk("%s: Transmitter access conflict.\n", dev->name);
 402         else {
 403                 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 404                 unsigned char *buf = skb->data;
 405 
 406                 /* Turn off the possible Tx interrupts. */
 407                 outb(0x00, ioaddr + TX_INTR);
 408                 
 409                 outw(length, ioaddr + DATAPORT);
 410                 outsw(ioaddr + DATAPORT, buf, (length + 1) >> 1);
 411 
 412                 lp->tx_queue++;
 413                 lp->tx_queue_len += length + 2;
 414 
 415                 if (lp->tx_started == 0) {
 416                         /* If the Tx is idle, always trigger a transmit. */
 417                         outb(0x80 | lp->tx_queue, ioaddr + TX_START);
 418                         lp->tx_queue = 0;
 419                         lp->tx_queue_len = 0;
 420                         dev->trans_start = jiffies;
 421                         lp->tx_started = 1;
 422                         dev->tbusy = 0;
 423                 } else if (lp->tx_queue_len < 4096 - 1502)
 424                         /* Yes, there is room for one more packet. */
 425                         dev->tbusy = 0;
 426 
 427                 /* Turn on Tx interrupts back on. */
 428                 outb(0x82, ioaddr + TX_INTR);
 429         }
 430         dev_kfree_skb (skb, FREE_WRITE);
 431 
 432         return 0;
 433 }
 434 
 435 /* The typical workload of the driver:
 436    Handle the network interface interrupts. */
 437 static void
 438 net_interrupt(int irq, struct pt_regs *regs)
     /*  */
 439 {
 440         struct device *dev = (struct device *)(irq2dev_map[irq]);
 441         struct net_local *lp;
 442         int ioaddr, status;
 443 
 444         if (dev == NULL) {
 445                 printk ("at1700_interrupt(): irq %d for unknown device.\n", irq);
 446                 return;
 447         }
 448         dev->interrupt = 1;
 449 
 450         ioaddr = dev->base_addr;
 451         lp = (struct net_local *)dev->priv;
 452         status = inw(ioaddr + TX_STATUS);
 453         outw(status, ioaddr + TX_STATUS);
 454 
 455         if (net_debug > 4)
 456                 printk("%s: Interrupt with status %04x.\n", dev->name, status);
 457         if (status & 0xff00
 458                 ||  (inb(ioaddr + RX_MODE) & 0x40) == 0) {                      /* Got a packet(s). */
 459                 net_rx(dev);
 460         }
 461         if (status & 0x00ff) {
 462                 if (status & 0x80) {
 463                         lp->stats.tx_packets++;
 464                         if (lp->tx_queue) {
 465                                 outb(0x80 | lp->tx_queue, ioaddr + TX_START);
 466                                 lp->tx_queue = 0;
 467                                 lp->tx_queue_len = 0;
 468                                 dev->trans_start = jiffies;
 469                                 dev->tbusy = 0;
 470                                 mark_bh(NET_BH);        /* Inform upper layers. */
 471                         } else {
 472                                 lp->tx_started = 0;
 473                                 /* Turn on Tx interrupts off. */
 474                                 outb(0x00, ioaddr + TX_INTR);
 475                                 dev->tbusy = 0;
 476                                 mark_bh(NET_BH);        /* Inform upper layers. */
 477                         }
 478                 }
 479         }
 480 
 481         dev->interrupt = 0;
 482         return;
 483 }
 484 
 485 /* We have a good packet(s), get it/them out of the buffers. */
 486 static void
 487 net_rx(struct device *dev)
     /*  */
 488 {
 489         struct net_local *lp = (struct net_local *)dev->priv;
 490         int ioaddr = dev->base_addr;
 491         int boguscount = 5;
 492 
 493         while ((inb(ioaddr + RX_MODE) & 0x40) == 0) {
 494                 ushort status = inw(ioaddr + DATAPORT);
 495 
 496                 if (net_debug > 4)
 497                         printk("%s: Rxing packet mode %02x status %04x.\n",
 498                                    dev->name, inb(ioaddr + RX_MODE), status);
 499 #ifndef final_version
 500                 if (status == 0) {
 501                         outb(0x05, ioaddr + 14);
 502                         break;
 503                 }
 504 #endif
 505 
 506                 if ((status & 0xF0) != 0x20) {  /* There was an error. */
 507                         lp->stats.rx_errors++;
 508                         if (status & 0x08) lp->stats.rx_length_errors++;
 509                         if (status & 0x04) lp->stats.rx_frame_errors++;
 510                         if (status & 0x02) lp->stats.rx_crc_errors++;
 511                         if (status & 0x01) lp->stats.rx_over_errors++;
 512                 } else {
 513                         ushort pkt_len = inw(ioaddr + DATAPORT);
 514                         /* Malloc up new buffer. */
 515                         struct sk_buff *skb;
 516 
 517                         if (pkt_len > 1550) {
 518                                 printk("%s: The AT1700 claimed a very large packet, size %d.\n",
 519                                            dev->name, pkt_len);
 520                                 outb(0x05, ioaddr + 14);
 521                                 lp->stats.rx_errors++;
 522                                 break;
 523                         }
 524                         skb = alloc_skb(pkt_len+1, GFP_ATOMIC);
 525                         if (skb == NULL) {
 526                                 printk("%s: Memory squeeze, dropping packet (len %d).\n",
 527                                            dev->name, pkt_len);
 528                                 outb(0x05, ioaddr + 14);
 529                                 lp->stats.rx_dropped++;
 530                                 break;
 531                         }
 532                         skb->len = pkt_len;
 533                         skb->dev = dev;
 534 
 535                         insw(ioaddr + DATAPORT, skb->data, (pkt_len + 1) >> 1);
 536 
 537                         if (net_debug > 5) {
 538                                 int i;
 539                                 printk("%s: Rxed packet of length %d: ", dev->name, pkt_len);
 540                                 for (i = 0; i < 14; i++)
 541                                         printk(" %02x", skb->data[i]);
 542                                 printk(".\n");
 543                         }
 544 
 545                         netif_rx(skb);
 546                         lp->stats.rx_packets++;
 547                 }
 548                 if (--boguscount <= 0)
 549                         break;
 550         }
 551 
 552         /* If any worth-while packets have been received, dev_rint()
 553            has done a mark_bh(NET_BH) for us and will work on them
 554            when we get to the bottom-half routine. */
 555         {
 556                 int i;
 557                 for (i = 0; i < 20; i++) {
 558                         if ((inb(ioaddr + RX_MODE) & 0x40) == 0x40)
 559                                 break;
 560                         inw(ioaddr + DATAPORT);                         /* dummy status read */
 561                         outb(0x05, ioaddr + 14);
 562                 }
 563 
 564                 if (net_debug > 5)
 565                         printk("%s: Exint Rx packet with mode %02x after %d ticks.\n", 
 566                                    dev->name, inb(ioaddr + RX_MODE), i);
 567         }
 568         return;
 569 }
 570 
 571 /* The inverse routine to net_open(). */
 572 static int net_close(struct device *dev)
     /*  */
 573 {
 574         struct net_local *lp = (struct net_local *)dev->priv;
 575         int ioaddr = dev->base_addr;
 576 
 577         lp->open_time = 0;
 578 
 579         dev->tbusy = 1;
 580         dev->start = 0;
 581 
 582         /* Set configuration register 0 to disable Tx and Rx. */
 583         outb(0xda, ioaddr + CONFIG_0);
 584 
 585         /* Update the statistics -- ToDo. */
 586 
 587         /* Power-down the chip.  Green, green, green! */
 588         outb(0x00, ioaddr + CONFIG_1);
 589 
 590         return 0;
 591 }
 592 
 593 /* Get the current statistics.  This may be called with the card open or
 594    closed. */
 595 static struct enet_statistics *
 596 net_get_stats(struct device *dev)
     /*  */
 597 {
 598         struct net_local *lp = (struct net_local *)dev->priv;
 599 
 600         cli();
 601         /* ToDo: Update the statistics from the device registers. */
 602         sti();
 603 
 604         return &lp->stats;
 605 }
 606 
 607 /* Set or clear the multicast filter for this adaptor.
 608    num_addrs == -1      Promiscuous mode, receive all packets
 609    num_addrs == 0       Normal mode, clear multicast list
 610    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 611                         best-effort filtering.
 612  */
 613 static void
 614 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
 615 {
 616         short ioaddr = dev->base_addr;
 617         if (num_addrs) {
 618                 outb(3, ioaddr + RX_MODE);      /* Enable promiscuous mode */
 619         } else
 620                 outb(2, ioaddr + RX_MODE);      /* Disable promiscuous, use normal mode */
 621 }
 622 
 623 /*
 624  * Local variables:
 625  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c at1700.c"
 626  *  version-control: t
 627  *  kept-new-versions: 5
 628  *  tab-width: 4
 629  *  c-indent-level: 4
 630  * End:
 631  */
/* */
root/drivers/net/at1700.c

DEFINITIONS
