Return to smc-ultra.c CVS log

Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net

Annotation of Gnu-Mach/i386/i386at/gpl/linux/net/smc-ultra.c, revision 1.1

1.1     ! root        1: /* smc-ultra.c: A SMC Ultra ethernet driver for linux. */
        !             2: /*
        !             3:        Written 1993,1994,1995 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 [email protected], 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 driver for the SMC Ultra and SMC EtherEZ ethercards.
        !            16: 
        !            17:        This driver uses the cards in the 8390-compatible, shared memory mode.
        !            18:        Most of the run-time complexity is handled by the generic code in
        !            19:        8390.c.  The code in this file is responsible for
        !            20: 
        !            21:                ultra_probe()           Detecting and initializing the card.
        !            22:                ultra_probe1()  
        !            23: 
        !            24:                ultra_open()            The card-specific details of starting, stopping
        !            25:                ultra_reset_8390()      and resetting the 8390 NIC core.
        !            26:                ultra_close()
        !            27: 
        !            28:                ultra_block_input()             Routines for reading and writing blocks of
        !            29:                ultra_block_output()    packet buffer memory.
        !            30: 
        !            31:        This driver enables the shared memory only when doing the actual data
        !            32:        transfers to avoid a bug in early version of the card that corrupted
        !            33:        data transferred by a AHA1542.
        !            34: 
        !            35:        This driver does not support the programmed-I/O data transfer mode of
        !            36:        the EtherEZ.  That support (if available) is smc-ez.c.  Nor does it
        !            37:        use the non-8390-compatible "Altego" mode. (No support currently planned.)
        !            38: 
        !            39:        Changelog:
        !            40: 
        !            41:        Paul Gortmaker  : multiple card support for module users.
        !            42: */
        !            43: 
        !            44: static const char *version =
        !            45:        "smc-ultra.c:v1.12 1/18/95 Donald Becker ([email protected])\n";
        !            46: 
        !            47: 
        !            48: #include <linux/module.h>
        !            49: 
        !            50: #include <linux/kernel.h>
        !            51: #include <linux/sched.h>
        !            52: #include <linux/errno.h>
        !            53: #include <linux/string.h>
        !            54: #include <asm/io.h>
        !            55: #include <asm/system.h>
        !            56: 
        !            57: #include <linux/netdevice.h>
        !            58: #include <linux/etherdevice.h>
        !            59: #include "8390.h"
        !            60: 
        !            61: /* A zero-terminated list of I/O addresses to be probed. */
        !            62: static unsigned int ultra_portlist[] =
        !            63: {0x200, 0x220, 0x240, 0x280, 0x300, 0x340, 0x380, 0};
        !            64: 
        !            65: int ultra_probe(struct device *dev);
        !            66: int ultra_probe1(struct device *dev, int ioaddr);
        !            67: 
        !            68: static int ultra_open(struct device *dev);
        !            69: static void ultra_reset_8390(struct device *dev);
        !            70: static void ultra_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, 
        !            71:                                                int ring_page);
        !            72: static void ultra_block_input(struct device *dev, int count,
        !            73:                                                  struct sk_buff *skb, int ring_offset);
        !            74: static void ultra_block_output(struct device *dev, int count,
        !            75:                                                        const unsigned char *buf, const start_page);
        !            76: static int ultra_close_card(struct device *dev);
        !            77: 
        !            78: 
        !            79: #define START_PG               0x00    /* First page of TX buffer */
        !            80: 
        !            81: #define ULTRA_CMDREG   0               /* Offset to ASIC command register. */
        !            82: #define         ULTRA_RESET    0x80    /* Board reset, in ULTRA_CMDREG. */
        !            83: #define         ULTRA_MEMENB   0x40    /* Enable the shared memory. */
        !            84: #define ULTRA_NIC_OFFSET  16   /* NIC register offset from the base_addr. */
        !            85: #define ULTRA_IO_EXTENT 32
        !            86: 
        !            87: /*     Probe for the Ultra.  This looks like a 8013 with the station
        !            88:        address PROM at I/O ports <base>+8 to <base>+13, with a checksum
        !            89:        following.
        !            90: */
        !            91: #ifdef HAVE_DEVLIST
        !            92: struct netdev_entry ultra_drv =
        !            93: {"ultra", ultra_probe1, NETCARD_IO_EXTENT, netcard_portlist};
        !            94: #else
        !            95: 
        !            96: int ultra_probe(struct device *dev)
        !            97: {
        !            98:        int i;
        !            99:        int base_addr = dev ? dev->base_addr : 0;
        !           100: 
        !           101:        if (base_addr > 0x1ff)          /* Check a single specified location. */
        !           102:                return ultra_probe1(dev, base_addr);
        !           103:        else if (base_addr != 0)        /* Don't probe at all. */
        !           104:                return ENXIO;
        !           105: 
        !           106:        for (i = 0; ultra_portlist[i]; i++) {
        !           107:                int ioaddr = ultra_portlist[i];
        !           108:                if (check_region(ioaddr, ULTRA_IO_EXTENT))
        !           109:                        continue;
        !           110:                if (ultra_probe1(dev, ioaddr) == 0)
        !           111:                        return 0;
        !           112:        }
        !           113: 
        !           114:        return ENODEV;
        !           115: }
        !           116: #endif
        !           117: 
        !           118: int ultra_probe1(struct device *dev, int ioaddr)
        !           119: {
        !           120:        int i;
        !           121:        int checksum = 0;
        !           122:        const char *model_name;
        !           123:        unsigned char eeprom_irq = 0;
        !           124:        static unsigned version_printed = 0;
        !           125:        /* Values from various config regs. */
        !           126:        unsigned char num_pages, irqreg, addr;
        !           127:        unsigned char idreg = inb(ioaddr + 7);
        !           128:        unsigned char reg4 = inb(ioaddr + 4) & 0x7f;
        !           129: 
        !           130:        /* Check the ID nibble. */
        !           131:        if ((idreg & 0xF0) != 0x20                      /* SMC Ultra */
        !           132:                && (idreg & 0xF0) != 0x40)              /* SMC EtherEZ */
        !           133:                return ENODEV;
        !           134: 
        !           135:        /* Select the station address register set. */
        !           136:        outb(reg4, ioaddr + 4);
        !           137: 
        !           138:        for (i = 0; i < 8; i++)
        !           139:                checksum += inb(ioaddr + 8 + i);
        !           140:        if ((checksum & 0xff) != 0xFF)
        !           141:                return ENODEV;
        !           142: 
        !           143:        /* We should have a "dev" from Space.c or the static module table. */
        !           144:        if (dev == NULL) {
        !           145:                printk("smc-ultra.c: Passed a NULL device.\n");
        !           146:                dev = init_etherdev(0, 0);
        !           147:        }
        !           148: 
        !           149:        if (ei_debug  &&  version_printed++ == 0)
        !           150:                printk(version);
        !           151: 
        !           152:        model_name = (idreg & 0xF0) == 0x20 ? "SMC Ultra" : "SMC EtherEZ";
        !           153: 
        !           154:        printk("%s: %s at %#3x,", dev->name, model_name, ioaddr);
        !           155: 
        !           156:        for (i = 0; i < 6; i++)
        !           157:                printk(" %2.2X", dev->dev_addr[i] = inb(ioaddr + 8 + i));
        !           158: 
        !           159:        /* Switch from the station address to the alternate register set and
        !           160:           read the useful registers there. */
        !           161:        outb(0x80 | reg4, ioaddr + 4);
        !           162: 
        !           163:        /* Enabled FINE16 mode to avoid BIOS ROM width mismatches @ reboot. */
        !           164:        outb(0x80 | inb(ioaddr + 0x0c), ioaddr + 0x0c);
        !           165:        irqreg = inb(ioaddr + 0xd);
        !           166:        addr = inb(ioaddr + 0xb);
        !           167: 
        !           168:        /* Switch back to the station address register set so that the MS-DOS driver
        !           169:           can find the card after a warm boot. */
        !           170:        outb(reg4, ioaddr + 4);
        !           171: 
        !           172:        if (dev->irq < 2) {
        !           173:                unsigned char irqmap[] = {0, 9, 3, 5, 7, 10, 11, 15};
        !           174:                int irq;
        !           175: 
        !           176:                /* The IRQ bits are split. */
        !           177:                irq = irqmap[((irqreg & 0x40) >> 4) + ((irqreg & 0x0c) >> 2)];
        !           178: 
        !           179:                if (irq == 0) {
        !           180:                        printk(", failed to detect IRQ line.\n");
        !           181:                        return -EAGAIN;
        !           182:                }
        !           183:                dev->irq = irq;
        !           184:                eeprom_irq = 1;
        !           185:        }
        !           186: 
        !           187:        /* Allocate dev->priv and fill in 8390 specific dev fields. */
        !           188:        if (ethdev_init(dev)) {
        !           189:                printk (", no memory for dev->priv.\n");
        !           190:                 return -ENOMEM;
        !           191:         }
        !           192:  
        !           193:        /* OK, we are certain this is going to work.  Setup the device. */
        !           194:        request_region(ioaddr, ULTRA_IO_EXTENT, model_name);
        !           195: 
        !           196:        /* The 8390 isn't at the base address, so fake the offset */
        !           197:        dev->base_addr = ioaddr+ULTRA_NIC_OFFSET;
        !           198: 
        !           199:        {
        !           200:                int addr_tbl[4] = {0x0C0000, 0x0E0000, 0xFC0000, 0xFE0000};
        !           201:                short num_pages_tbl[4] = {0x20, 0x40, 0x80, 0xff};
        !           202: 
        !           203:                dev->mem_start = ((addr & 0x0f) << 13) + addr_tbl[(addr >> 6) & 3] ;
        !           204:                num_pages = num_pages_tbl[(addr >> 4) & 3];
        !           205:        }
        !           206: 
        !           207:        ei_status.name = model_name;
        !           208:        ei_status.word16 = 1;
        !           209:        ei_status.tx_start_page = START_PG;
        !           210:        ei_status.rx_start_page = START_PG + TX_PAGES;
        !           211:        ei_status.stop_page = num_pages;
        !           212: 
        !           213:        dev->rmem_start = dev->mem_start + TX_PAGES*256;
        !           214:        dev->mem_end = dev->rmem_end
        !           215:                = dev->mem_start + (ei_status.stop_page - START_PG)*256;
        !           216: 
        !           217:        printk(",%s IRQ %d memory %#lx-%#lx.\n", eeprom_irq ? "" : "assigned ",
        !           218:                   dev->irq, dev->mem_start, dev->mem_end-1);
        !           219: 
        !           220:        ei_status.reset_8390 = &ultra_reset_8390;
        !           221:        ei_status.block_input = &ultra_block_input;
        !           222:        ei_status.block_output = &ultra_block_output;
        !           223:        ei_status.get_8390_hdr = &ultra_get_8390_hdr;
        !           224:        dev->open = &ultra_open;
        !           225:        dev->stop = &ultra_close_card;
        !           226:        NS8390_init(dev, 0);
        !           227: 
        !           228:        return 0;
        !           229: }
        !           230: 
        !           231: static int
        !           232: ultra_open(struct device *dev)
        !           233: {
        !           234:        int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC addr */
        !           235: 
        !           236:        if (request_irq(dev->irq, ei_interrupt, 0, ei_status.name))
        !           237:                return -EAGAIN;
        !           238: 
        !           239:        outb(ULTRA_MEMENB, ioaddr);     /* Enable memory, 16 bit mode. */
        !           240:        outb(0x80, ioaddr + 5);
        !           241:        outb(0x01, ioaddr + 6);         /* Enable interrupts and memory. */
        !           242:        ei_open(dev);
        !           243:        MOD_INC_USE_COUNT;
        !           244:        return 0;
        !           245: }
        !           246: 
        !           247: static void
        !           248: ultra_reset_8390(struct device *dev)
        !           249: {
        !           250:        int cmd_port = dev->base_addr - ULTRA_NIC_OFFSET; /* ASIC base addr */
        !           251: 
        !           252:        outb(ULTRA_RESET, cmd_port);
        !           253:        if (ei_debug > 1) printk("resetting Ultra, t=%ld...", jiffies);
        !           254:        ei_status.txing = 0;
        !           255: 
        !           256:        outb(ULTRA_MEMENB, cmd_port);
        !           257: 
        !           258:        if (ei_debug > 1) printk("reset done\n");
        !           259:        return;
        !           260: }
        !           261: 
        !           262: /* Grab the 8390 specific header. Similar to the block_input routine, but
        !           263:    we don't need to be concerned with ring wrap as the header will be at
        !           264:    the start of a page, so we optimize accordingly. */
        !           265: 
        !           266: static void
        !           267: ultra_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
        !           268: {
        !           269: 
        !           270:        unsigned long hdr_start = dev->mem_start + ((ring_page - START_PG)<<8);
        !           271: 
        !           272:        outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);  /* shmem on */
        !           273: #ifdef notdef
        !           274:        /* Officially this is what we are doing, but the readl() is faster */
        !           275:        memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
        !           276: #else
        !           277:        ((unsigned int*)hdr)[0] = readl(hdr_start);
        !           278: #endif
        !           279:        outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* shmem off */
        !           280: }
        !           281: 
        !           282: /* Block input and output are easy on shared memory ethercards, the only
        !           283:    complication is when the ring buffer wraps. */
        !           284: 
        !           285: static void
        !           286: ultra_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
        !           287: {
        !           288:        unsigned long xfer_start = dev->mem_start + ring_offset - (START_PG<<8);
        !           289: 
        !           290:        /* Enable shared memory. */
        !           291:        outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
        !           292: 
        !           293:        if (xfer_start + count > dev->rmem_end) {
        !           294:                /* We must wrap the input move. */
        !           295:                int semi_count = dev->rmem_end - xfer_start;
        !           296:                memcpy_fromio(skb->data, xfer_start, semi_count);
        !           297:                count -= semi_count;
        !           298:                memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
        !           299:        } else {
        !           300:                /* Packet is in one chunk -- we can copy + cksum. */
        !           301:                eth_io_copy_and_sum(skb, xfer_start, count, 0);
        !           302:        }
        !           303: 
        !           304:        outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET);  /* Disable memory. */
        !           305: }
        !           306: 
        !           307: static void
        !           308: ultra_block_output(struct device *dev, int count, const unsigned char *buf,
        !           309:                                int start_page)
        !           310: {
        !           311:        unsigned long shmem = dev->mem_start + ((start_page - START_PG)<<8);
        !           312: 
        !           313:        /* Enable shared memory. */
        !           314:        outb(ULTRA_MEMENB, dev->base_addr - ULTRA_NIC_OFFSET);
        !           315: 
        !           316:        memcpy_toio(shmem, buf, count);
        !           317: 
        !           318:        outb(0x00, dev->base_addr - ULTRA_NIC_OFFSET); /* Disable memory. */
        !           319: }
        !           320: 
        !           321: static int
        !           322: ultra_close_card(struct device *dev)
        !           323: {
        !           324:        int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET; /* CMDREG */
        !           325: 
        !           326:        dev->start = 0;
        !           327:        dev->tbusy = 1;
        !           328: 
        !           329:        if (ei_debug > 1)
        !           330:                printk("%s: Shutting down ethercard.\n", dev->name);
        !           331: 
        !           332:        outb(0x00, ioaddr + 6);         /* Disable interrupts. */
        !           333:        free_irq(dev->irq);
        !           334:        irq2dev_map[dev->irq] = 0;
        !           335: 
        !           336:        NS8390_init(dev, 0);
        !           337: 
        !           338:        /* We should someday disable shared memory and change to 8-bit mode
        !           339:           "just in case"... */
        !           340: 
        !           341:        MOD_DEC_USE_COUNT;
        !           342: 
        !           343:        return 0;
        !           344: }
        !           345: 
        !           346: 
        !           347: #ifdef MODULE
        !           348: #define MAX_ULTRA_CARDS        4       /* Max number of Ultra cards per module */
        !           349: #define NAMELEN                8       /* # of chars for storing dev->name */
        !           350: static char namelist[NAMELEN * MAX_ULTRA_CARDS] = { 0, };
        !           351: static struct device dev_ultra[MAX_ULTRA_CARDS] = {
        !           352:        {
        !           353:                NULL,           /* assign a chunk of namelist[] below */
        !           354:                0, 0, 0, 0,
        !           355:                0, 0,
        !           356:                0, 0, 0, NULL, NULL
        !           357:        },
        !           358: };
        !           359: 
        !           360: static int io[MAX_ULTRA_CARDS] = { 0, };
        !           361: static int irq[MAX_ULTRA_CARDS]  = { 0, };
        !           362: 
        !           363: /* This is set up so that only a single autoprobe takes place per call.
        !           364: ISA device autoprobes on a running machine are not recommended. */
        !           365: int
        !           366: init_module(void)
        !           367: {
        !           368:        int this_dev, found = 0;
        !           369: 
        !           370:        for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
        !           371:                struct device *dev = &dev_ultra[this_dev];
        !           372:                dev->name = namelist+(NAMELEN*this_dev);
        !           373:                dev->irq = irq[this_dev];
        !           374:                dev->base_addr = io[this_dev];
        !           375:                dev->init = ultra_probe;
        !           376:                if (io[this_dev] == 0)  {
        !           377:                        if (this_dev != 0) break; /* only autoprobe 1st one */
        !           378:                        printk(KERN_NOTICE "smc-ultra.c: Presently autoprobing (not recommended) for a single card.\n");
        !           379:                }
        !           380:                if (register_netdev(dev) != 0) {
        !           381:                        printk(KERN_WARNING "smc-ultra.c: No SMC Ultra card found (i/o = 0x%x).\n", io[this_dev]);
        !           382:                        if (found != 0) return 0;       /* Got at least one. */
        !           383:                        return -ENXIO;
        !           384:                }
        !           385:                found++;
        !           386:        }
        !           387: 
        !           388:        return 0;
        !           389: }
        !           390: 
        !           391: void
        !           392: cleanup_module(void)
        !           393: {
        !           394:        int this_dev;
        !           395: 
        !           396:        for (this_dev = 0; this_dev < MAX_ULTRA_CARDS; this_dev++) {
        !           397:                struct device *dev = &dev_ultra[this_dev];
        !           398:                if (dev->priv != NULL) {
        !           399:                        /* NB: ultra_close_card() does free_irq + irq2dev */
        !           400:                        int ioaddr = dev->base_addr - ULTRA_NIC_OFFSET;
        !           401:                        kfree(dev->priv);
        !           402:                        dev->priv = NULL;
        !           403:                        release_region(ioaddr, ULTRA_IO_EXTENT);
        !           404:                        unregister_netdev(dev);
        !           405:                }
        !           406:        }
        !           407: }
        !           408: #endif /* MODULE */
        !           409: 
        !           410: 
        !           411: /*
        !           412:  * Local variables:
        !           413:  *  compile-command: "gcc -D__KERNEL__ -Wall -O6 -I/usr/src/linux/net/inet -c smc-ultra.c"
        !           414:  *  version-control: t
        !           415:  *  kept-new-versions: 5
        !           416:  *  c-indent-level: 4
        !           417:  *  tab-width: 4
        !           418:  * End:
        !           419:  */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.