forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1005 lines
29 KiB
1005 lines
29 KiB
/* cops.c: LocalTalk driver for Linux. |
|
* |
|
* Authors: |
|
* - Jay Schulist <[email protected]> |
|
* |
|
* With more than a little help from; |
|
* - Alan Cox <[email protected]> |
|
* |
|
* Derived from: |
|
* - skeleton.c: A network driver outline for linux. |
|
* Written 1993-94 by Donald Becker. |
|
* - ltpc.c: A driver for the LocalTalk PC card. |
|
* Written by Bradford W. Johnson. |
|
* |
|
* Copyright 1993 United States Government as represented by the |
|
* Director, National Security Agency. |
|
* |
|
* This software may be used and distributed according to the terms |
|
* of the GNU General Public License, incorporated herein by reference. |
|
* |
|
* Changes: |
|
* 19970608 Alan Cox Allowed dual card type support |
|
* Can set board type in insmod |
|
* Hooks for cops_setup routine |
|
* (not yet implemented). |
|
* 19971101 Jay Schulist Fixes for multiple lt* devices. |
|
* 19980607 Steven Hirsch Fixed the badly broken support |
|
* for Tangent type cards. Only |
|
* tested on Daystar LT200. Some |
|
* cleanup of formatting and program |
|
* logic. Added emacs 'local-vars' |
|
* setup for Jay's brace style. |
|
* 20000211 Alan Cox Cleaned up for softnet |
|
*/ |
|
|
|
static const char *version = |
|
"cops.c:v0.04 6/7/98 Jay Schulist <[email protected]>\n"; |
|
/* |
|
* Sources: |
|
* COPS Localtalk SDK. This provides almost all of the information |
|
* needed. |
|
*/ |
|
|
|
/* |
|
* insmod/modprobe configurable stuff. |
|
* - IO Port, choose one your card supports or 0 if you dare. |
|
* - IRQ, also choose one your card supports or nothing and let |
|
* the driver figure it out. |
|
*/ |
|
|
|
#include <linux/module.h> |
|
#include <linux/kernel.h> |
|
#include <linux/types.h> |
|
#include <linux/fcntl.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/ptrace.h> |
|
#include <linux/ioport.h> |
|
#include <linux/in.h> |
|
#include <linux/string.h> |
|
#include <linux/errno.h> |
|
#include <linux/init.h> |
|
#include <linux/netdevice.h> |
|
#include <linux/etherdevice.h> |
|
#include <linux/skbuff.h> |
|
#include <linux/if_arp.h> |
|
#include <linux/if_ltalk.h> |
|
#include <linux/delay.h> /* For udelay() */ |
|
#include <linux/atalk.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/bitops.h> |
|
#include <linux/jiffies.h> |
|
|
|
#include <net/Space.h> |
|
|
|
#include <asm/io.h> |
|
#include <asm/dma.h> |
|
|
|
#include "cops.h" /* Our Stuff */ |
|
#include "cops_ltdrv.h" /* Firmware code for Tangent type cards. */ |
|
#include "cops_ffdrv.h" /* Firmware code for Dayna type cards. */ |
|
|
|
/* |
|
* The name of the card. Is used for messages and in the requests for |
|
* io regions, irqs and dma channels |
|
*/ |
|
|
|
static const char *cardname = "cops"; |
|
|
|
#ifdef CONFIG_COPS_DAYNA |
|
static int board_type = DAYNA; /* Module exported */ |
|
#else |
|
static int board_type = TANGENT; |
|
#endif |
|
|
|
static int io = 0x240; /* Default IO for Dayna */ |
|
static int irq = 5; /* Default IRQ */ |
|
|
|
/* |
|
* COPS Autoprobe information. |
|
* Right now if port address is right but IRQ is not 5 this will |
|
* return a 5 no matter what since we will still get a status response. |
|
* Need one more additional check to narrow down after we have gotten |
|
* the ioaddr. But since only other possible IRQs is 3 and 4 so no real |
|
* hurry on this. I *STRONGLY* recommend using IRQ 5 for your card with |
|
* this driver. |
|
* |
|
* This driver has 2 modes and they are: Dayna mode and Tangent mode. |
|
* Each mode corresponds with the type of card. It has been found |
|
* that there are 2 main types of cards and all other cards are |
|
* the same and just have different names or only have minor differences |
|
* such as more IO ports. As this driver is tested it will |
|
* become more clear on exactly what cards are supported. The driver |
|
* defaults to using Dayna mode. To change the drivers mode, simply |
|
* select Dayna or Tangent mode when configuring the kernel. |
|
* |
|
* This driver should support: |
|
* TANGENT driver mode: |
|
* Tangent ATB-II, Novell NL-1000, Daystar Digital LT-200, |
|
* COPS LT-1 |
|
* DAYNA driver mode: |
|
* Dayna DL2000/DaynaTalk PC (Half Length), COPS LT-95, |
|
* Farallon PhoneNET PC III, Farallon PhoneNET PC II |
|
* Other cards possibly supported mode unknown though: |
|
* Dayna DL2000 (Full length), COPS LT/M (Micro-Channel) |
|
* |
|
* Cards NOT supported by this driver but supported by the ltpc.c |
|
* driver written by Bradford W. Johnson <[email protected]> |
|
* Farallon PhoneNET PC |
|
* Original Apple LocalTalk PC card |
|
* |
|
* N.B. |
|
* |
|
* The Daystar Digital LT200 boards do not support interrupt-driven |
|
* IO. You must specify 'irq=0xff' as a module parameter to invoke |
|
* polled mode. I also believe that the port probing logic is quite |
|
* dangerous at best and certainly hopeless for a polled card. Best to |
|
* specify both. - Steve H. |
|
* |
|
*/ |
|
|
|
/* |
|
* Zero terminated list of IO ports to probe. |
|
*/ |
|
|
|
static unsigned int ports[] = { |
|
0x240, 0x340, 0x200, 0x210, 0x220, 0x230, 0x260, |
|
0x2A0, 0x300, 0x310, 0x320, 0x330, 0x350, 0x360, |
|
0 |
|
}; |
|
|
|
/* |
|
* Zero terminated list of IRQ ports to probe. |
|
*/ |
|
|
|
static int cops_irqlist[] = { |
|
5, 4, 3, 0 |
|
}; |
|
|
|
static struct timer_list cops_timer; |
|
static struct net_device *cops_timer_dev; |
|
|
|
/* use 0 for production, 1 for verification, 2 for debug, 3 for verbose debug */ |
|
#ifndef COPS_DEBUG |
|
#define COPS_DEBUG 1 |
|
#endif |
|
static unsigned int cops_debug = COPS_DEBUG; |
|
|
|
/* The number of low I/O ports used by the card. */ |
|
#define COPS_IO_EXTENT 8 |
|
|
|
/* Information that needs to be kept for each board. */ |
|
|
|
struct cops_local |
|
{ |
|
int board; /* Holds what board type is. */ |
|
int nodeid; /* Set to 1 once have nodeid. */ |
|
unsigned char node_acquire; /* Node ID when acquired. */ |
|
struct atalk_addr node_addr; /* Full node address */ |
|
spinlock_t lock; /* RX/TX lock */ |
|
}; |
|
|
|
/* Index to functions, as function prototypes. */ |
|
static int cops_probe1 (struct net_device *dev, int ioaddr); |
|
static int cops_irq (int ioaddr, int board); |
|
|
|
static int cops_open (struct net_device *dev); |
|
static int cops_jumpstart (struct net_device *dev); |
|
static void cops_reset (struct net_device *dev, int sleep); |
|
static void cops_load (struct net_device *dev); |
|
static int cops_nodeid (struct net_device *dev, int nodeid); |
|
|
|
static irqreturn_t cops_interrupt (int irq, void *dev_id); |
|
static void cops_poll(struct timer_list *t); |
|
static void cops_timeout(struct net_device *dev, unsigned int txqueue); |
|
static void cops_rx (struct net_device *dev); |
|
static netdev_tx_t cops_send_packet (struct sk_buff *skb, |
|
struct net_device *dev); |
|
static void set_multicast_list (struct net_device *dev); |
|
static int cops_ioctl (struct net_device *dev, struct ifreq *rq, int cmd); |
|
static int cops_close (struct net_device *dev); |
|
|
|
static void cleanup_card(struct net_device *dev) |
|
{ |
|
if (dev->irq) |
|
free_irq(dev->irq, dev); |
|
release_region(dev->base_addr, COPS_IO_EXTENT); |
|
} |
|
|
|
/* |
|
* Check for a network adaptor of this type, and return '0' iff one exists. |
|
* If dev->base_addr == 0, probe all likely locations. |
|
* If dev->base_addr in [1..0x1ff], always return failure. |
|
* otherwise go with what we pass in. |
|
*/ |
|
struct net_device * __init cops_probe(int unit) |
|
{ |
|
struct net_device *dev; |
|
unsigned *port; |
|
int base_addr; |
|
int err = 0; |
|
|
|
dev = alloc_ltalkdev(sizeof(struct cops_local)); |
|
if (!dev) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
if (unit >= 0) { |
|
sprintf(dev->name, "lt%d", unit); |
|
netdev_boot_setup_check(dev); |
|
irq = dev->irq; |
|
base_addr = dev->base_addr; |
|
} else { |
|
base_addr = dev->base_addr = io; |
|
} |
|
|
|
if (base_addr > 0x1ff) { /* Check a single specified location. */ |
|
err = cops_probe1(dev, base_addr); |
|
} else if (base_addr != 0) { /* Don't probe at all. */ |
|
err = -ENXIO; |
|
} else { |
|
/* FIXME Does this really work for cards which generate irq? |
|
* It's definitely N.G. for polled Tangent. sh |
|
* Dayna cards don't autoprobe well at all, but if your card is |
|
* at IRQ 5 & IO 0x240 we find it every time. ;) JS |
|
*/ |
|
for (port = ports; *port && cops_probe1(dev, *port) < 0; port++) |
|
; |
|
if (!*port) |
|
err = -ENODEV; |
|
} |
|
if (err) |
|
goto out; |
|
err = register_netdev(dev); |
|
if (err) |
|
goto out1; |
|
return dev; |
|
out1: |
|
cleanup_card(dev); |
|
out: |
|
free_netdev(dev); |
|
return ERR_PTR(err); |
|
} |
|
|
|
static const struct net_device_ops cops_netdev_ops = { |
|
.ndo_open = cops_open, |
|
.ndo_stop = cops_close, |
|
.ndo_start_xmit = cops_send_packet, |
|
.ndo_tx_timeout = cops_timeout, |
|
.ndo_do_ioctl = cops_ioctl, |
|
.ndo_set_rx_mode = set_multicast_list, |
|
}; |
|
|
|
/* |
|
* This is the real probe routine. Linux has a history of friendly device |
|
* probes on the ISA bus. A good device probes avoids doing writes, and |
|
* verifies that the correct device exists and functions. |
|
*/ |
|
static int __init cops_probe1(struct net_device *dev, int ioaddr) |
|
{ |
|
struct cops_local *lp; |
|
static unsigned version_printed; |
|
int board = board_type; |
|
int retval; |
|
|
|
if(cops_debug && version_printed++ == 0) |
|
printk("%s", version); |
|
|
|
/* Grab the region so no one else tries to probe our ioports. */ |
|
if (!request_region(ioaddr, COPS_IO_EXTENT, dev->name)) |
|
return -EBUSY; |
|
|
|
/* |
|
* Since this board has jumpered interrupts, allocate the interrupt |
|
* vector now. There is no point in waiting since no other device |
|
* can use the interrupt, and this marks the irq as busy. Jumpered |
|
* interrupts are typically not reported by the boards, and we must |
|
* used AutoIRQ to find them. |
|
*/ |
|
dev->irq = irq; |
|
switch (dev->irq) |
|
{ |
|
case 0: |
|
/* COPS AutoIRQ routine */ |
|
dev->irq = cops_irq(ioaddr, board); |
|
if (dev->irq) |
|
break; |
|
fallthrough; /* Once no IRQ found on this port */ |
|
case 1: |
|
retval = -EINVAL; |
|
goto err_out; |
|
|
|
/* Fixup for users that don't know that IRQ 2 is really |
|
* IRQ 9, or don't know which one to set. |
|
*/ |
|
case 2: |
|
dev->irq = 9; |
|
break; |
|
|
|
/* Polled operation requested. Although irq of zero passed as |
|
* a parameter tells the init routines to probe, we'll |
|
* overload it to denote polled operation at runtime. |
|
*/ |
|
case 0xff: |
|
dev->irq = 0; |
|
break; |
|
|
|
default: |
|
break; |
|
} |
|
|
|
/* Reserve any actual interrupt. */ |
|
if (dev->irq) { |
|
retval = request_irq(dev->irq, cops_interrupt, 0, dev->name, dev); |
|
if (retval) |
|
goto err_out; |
|
} |
|
|
|
dev->base_addr = ioaddr; |
|
|
|
lp = netdev_priv(dev); |
|
spin_lock_init(&lp->lock); |
|
|
|
/* Copy local board variable to lp struct. */ |
|
lp->board = board; |
|
|
|
dev->netdev_ops = &cops_netdev_ops; |
|
dev->watchdog_timeo = HZ * 2; |
|
|
|
|
|
/* Tell the user where the card is and what mode we're in. */ |
|
if(board==DAYNA) |
|
printk("%s: %s at %#3x, using IRQ %d, in Dayna mode.\n", |
|
dev->name, cardname, ioaddr, dev->irq); |
|
if(board==TANGENT) { |
|
if(dev->irq) |
|
printk("%s: %s at %#3x, IRQ %d, in Tangent mode\n", |
|
dev->name, cardname, ioaddr, dev->irq); |
|
else |
|
printk("%s: %s at %#3x, using polled IO, in Tangent mode.\n", |
|
dev->name, cardname, ioaddr); |
|
|
|
} |
|
return 0; |
|
|
|
err_out: |
|
release_region(ioaddr, COPS_IO_EXTENT); |
|
return retval; |
|
} |
|
|
|
static int __init cops_irq (int ioaddr, int board) |
|
{ /* |
|
* This does not use the IRQ to determine where the IRQ is. We just |
|
* assume that when we get a correct status response that it's the IRQ. |
|
* This really just verifies the IO port but since we only have access |
|
* to such a small number of IRQs (5, 4, 3) this is not bad. |
|
* This will probably not work for more than one card. |
|
*/ |
|
int irqaddr=0; |
|
int i, x, status; |
|
|
|
if(board==DAYNA) |
|
{ |
|
outb(0, ioaddr+DAYNA_RESET); |
|
inb(ioaddr+DAYNA_RESET); |
|
mdelay(333); |
|
} |
|
if(board==TANGENT) |
|
{ |
|
inb(ioaddr); |
|
outb(0, ioaddr); |
|
outb(0, ioaddr+TANG_RESET); |
|
} |
|
|
|
for(i=0; cops_irqlist[i] !=0; i++) |
|
{ |
|
irqaddr = cops_irqlist[i]; |
|
for(x = 0xFFFF; x>0; x --) /* wait for response */ |
|
{ |
|
if(board==DAYNA) |
|
{ |
|
status = (inb(ioaddr+DAYNA_CARD_STATUS)&3); |
|
if(status == 1) |
|
return irqaddr; |
|
} |
|
if(board==TANGENT) |
|
{ |
|
if((inb(ioaddr+TANG_CARD_STATUS)& TANG_TX_READY) !=0) |
|
return irqaddr; |
|
} |
|
} |
|
} |
|
return 0; /* no IRQ found */ |
|
} |
|
|
|
/* |
|
* Open/initialize the board. This is called (in the current kernel) |
|
* sometime after booting when the 'ifconfig' program is run. |
|
*/ |
|
static int cops_open(struct net_device *dev) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
|
|
if(dev->irq==0) |
|
{ |
|
/* |
|
* I don't know if the Dayna-style boards support polled |
|
* operation. For now, only allow it for Tangent. |
|
*/ |
|
if(lp->board==TANGENT) /* Poll 20 times per second */ |
|
{ |
|
cops_timer_dev = dev; |
|
timer_setup(&cops_timer, cops_poll, 0); |
|
cops_timer.expires = jiffies + HZ/20; |
|
add_timer(&cops_timer); |
|
} |
|
else |
|
{ |
|
printk(KERN_WARNING "%s: No irq line set\n", dev->name); |
|
return -EAGAIN; |
|
} |
|
} |
|
|
|
cops_jumpstart(dev); /* Start the card up. */ |
|
|
|
netif_start_queue(dev); |
|
return 0; |
|
} |
|
|
|
/* |
|
* This allows for a dynamic start/restart of the entire card. |
|
*/ |
|
static int cops_jumpstart(struct net_device *dev) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
|
|
/* |
|
* Once the card has the firmware loaded and has acquired |
|
* the nodeid, if it is reset it will lose it all. |
|
*/ |
|
cops_reset(dev,1); /* Need to reset card before load firmware. */ |
|
cops_load(dev); /* Load the firmware. */ |
|
|
|
/* |
|
* If atalkd already gave us a nodeid we will use that |
|
* one again, else we wait for atalkd to give us a nodeid |
|
* in cops_ioctl. This may cause a problem if someone steals |
|
* our nodeid while we are resetting. |
|
*/ |
|
if(lp->nodeid == 1) |
|
cops_nodeid(dev,lp->node_acquire); |
|
|
|
return 0; |
|
} |
|
|
|
static void tangent_wait_reset(int ioaddr) |
|
{ |
|
int timeout=0; |
|
|
|
while(timeout++ < 5 && (inb(ioaddr+TANG_CARD_STATUS)&TANG_TX_READY)==0) |
|
mdelay(1); /* Wait 1 second */ |
|
} |
|
|
|
/* |
|
* Reset the LocalTalk board. |
|
*/ |
|
static void cops_reset(struct net_device *dev, int sleep) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
int ioaddr=dev->base_addr; |
|
|
|
if(lp->board==TANGENT) |
|
{ |
|
inb(ioaddr); /* Clear request latch. */ |
|
outb(0,ioaddr); /* Clear the TANG_TX_READY flop. */ |
|
outb(0, ioaddr+TANG_RESET); /* Reset the adapter. */ |
|
|
|
tangent_wait_reset(ioaddr); |
|
outb(0, ioaddr+TANG_CLEAR_INT); |
|
} |
|
if(lp->board==DAYNA) |
|
{ |
|
outb(0, ioaddr+DAYNA_RESET); /* Assert the reset port */ |
|
inb(ioaddr+DAYNA_RESET); /* Clear the reset */ |
|
if (sleep) |
|
msleep(333); |
|
else |
|
mdelay(333); |
|
} |
|
|
|
netif_wake_queue(dev); |
|
} |
|
|
|
static void cops_load (struct net_device *dev) |
|
{ |
|
struct ifreq ifr; |
|
struct ltfirmware *ltf= (struct ltfirmware *)&ifr.ifr_ifru; |
|
struct cops_local *lp = netdev_priv(dev); |
|
int ioaddr=dev->base_addr; |
|
int length, i = 0; |
|
|
|
strcpy(ifr.ifr_name,"lt0"); |
|
|
|
/* Get card's firmware code and do some checks on it. */ |
|
#ifdef CONFIG_COPS_DAYNA |
|
if(lp->board==DAYNA) |
|
{ |
|
ltf->length=sizeof(ffdrv_code); |
|
ltf->data=ffdrv_code; |
|
} |
|
else |
|
#endif |
|
#ifdef CONFIG_COPS_TANGENT |
|
if(lp->board==TANGENT) |
|
{ |
|
ltf->length=sizeof(ltdrv_code); |
|
ltf->data=ltdrv_code; |
|
} |
|
else |
|
#endif |
|
{ |
|
printk(KERN_INFO "%s; unsupported board type.\n", dev->name); |
|
return; |
|
} |
|
|
|
/* Check to make sure firmware is correct length. */ |
|
if(lp->board==DAYNA && ltf->length!=5983) |
|
{ |
|
printk(KERN_WARNING "%s: Firmware is not length of FFDRV.BIN.\n", dev->name); |
|
return; |
|
} |
|
if(lp->board==TANGENT && ltf->length!=2501) |
|
{ |
|
printk(KERN_WARNING "%s: Firmware is not length of DRVCODE.BIN.\n", dev->name); |
|
return; |
|
} |
|
|
|
if(lp->board==DAYNA) |
|
{ |
|
/* |
|
* We must wait for a status response |
|
* with the DAYNA board. |
|
*/ |
|
while(++i<65536) |
|
{ |
|
if((inb(ioaddr+DAYNA_CARD_STATUS)&3)==1) |
|
break; |
|
} |
|
|
|
if(i==65536) |
|
return; |
|
} |
|
|
|
/* |
|
* Upload the firmware and kick. Byte-by-byte works nicely here. |
|
*/ |
|
i=0; |
|
length = ltf->length; |
|
while(length--) |
|
{ |
|
outb(ltf->data[i], ioaddr); |
|
i++; |
|
} |
|
|
|
if(cops_debug > 1) |
|
printk("%s: Uploaded firmware - %d bytes of %d bytes.\n", |
|
dev->name, i, ltf->length); |
|
|
|
if(lp->board==DAYNA) /* Tell Dayna to run the firmware code. */ |
|
outb(1, ioaddr+DAYNA_INT_CARD); |
|
else /* Tell Tang to run the firmware code. */ |
|
inb(ioaddr); |
|
|
|
if(lp->board==TANGENT) |
|
{ |
|
tangent_wait_reset(ioaddr); |
|
inb(ioaddr); /* Clear initial ready signal. */ |
|
} |
|
} |
|
|
|
/* |
|
* Get the LocalTalk Nodeid from the card. We can suggest |
|
* any nodeid 1-254. The card will try and get that exact |
|
* address else we can specify 0 as the nodeid and the card |
|
* will autoprobe for a nodeid. |
|
*/ |
|
static int cops_nodeid (struct net_device *dev, int nodeid) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
int ioaddr = dev->base_addr; |
|
|
|
if(lp->board == DAYNA) |
|
{ |
|
/* Empty any pending adapter responses. */ |
|
while((inb(ioaddr+DAYNA_CARD_STATUS)&DAYNA_TX_READY)==0) |
|
{ |
|
outb(0, ioaddr+COPS_CLEAR_INT); /* Clear interrupts. */ |
|
if((inb(ioaddr+DAYNA_CARD_STATUS)&0x03)==DAYNA_RX_REQUEST) |
|
cops_rx(dev); /* Kick any packets waiting. */ |
|
schedule(); |
|
} |
|
|
|
outb(2, ioaddr); /* Output command packet length as 2. */ |
|
outb(0, ioaddr); |
|
outb(LAP_INIT, ioaddr); /* Send LAP_INIT command byte. */ |
|
outb(nodeid, ioaddr); /* Suggest node address. */ |
|
} |
|
|
|
if(lp->board == TANGENT) |
|
{ |
|
/* Empty any pending adapter responses. */ |
|
while(inb(ioaddr+TANG_CARD_STATUS)&TANG_RX_READY) |
|
{ |
|
outb(0, ioaddr+COPS_CLEAR_INT); /* Clear interrupt. */ |
|
cops_rx(dev); /* Kick out packets waiting. */ |
|
schedule(); |
|
} |
|
|
|
/* Not sure what Tangent does if nodeid picked is used. */ |
|
if(nodeid == 0) /* Seed. */ |
|
nodeid = jiffies&0xFF; /* Get a random try */ |
|
outb(2, ioaddr); /* Command length LSB */ |
|
outb(0, ioaddr); /* Command length MSB */ |
|
outb(LAP_INIT, ioaddr); /* Send LAP_INIT byte */ |
|
outb(nodeid, ioaddr); /* LAP address hint. */ |
|
outb(0xFF, ioaddr); /* Int. level to use */ |
|
} |
|
|
|
lp->node_acquire=0; /* Set nodeid holder to 0. */ |
|
while(lp->node_acquire==0) /* Get *True* nodeid finally. */ |
|
{ |
|
outb(0, ioaddr+COPS_CLEAR_INT); /* Clear any interrupt. */ |
|
|
|
if(lp->board == DAYNA) |
|
{ |
|
if((inb(ioaddr+DAYNA_CARD_STATUS)&0x03)==DAYNA_RX_REQUEST) |
|
cops_rx(dev); /* Grab the nodeid put in lp->node_acquire. */ |
|
} |
|
if(lp->board == TANGENT) |
|
{ |
|
if(inb(ioaddr+TANG_CARD_STATUS)&TANG_RX_READY) |
|
cops_rx(dev); /* Grab the nodeid put in lp->node_acquire. */ |
|
} |
|
schedule(); |
|
} |
|
|
|
if(cops_debug > 1) |
|
printk(KERN_DEBUG "%s: Node ID %d has been acquired.\n", |
|
dev->name, lp->node_acquire); |
|
|
|
lp->nodeid=1; /* Set got nodeid to 1. */ |
|
|
|
return 0; |
|
} |
|
|
|
/* |
|
* Poll the Tangent type cards to see if we have work. |
|
*/ |
|
|
|
static void cops_poll(struct timer_list *unused) |
|
{ |
|
int ioaddr, status; |
|
int boguscount = 0; |
|
struct net_device *dev = cops_timer_dev; |
|
|
|
del_timer(&cops_timer); |
|
|
|
if(dev == NULL) |
|
return; /* We've been downed */ |
|
|
|
ioaddr = dev->base_addr; |
|
do { |
|
status=inb(ioaddr+TANG_CARD_STATUS); |
|
if(status & TANG_RX_READY) |
|
cops_rx(dev); |
|
if(status & TANG_TX_READY) |
|
netif_wake_queue(dev); |
|
status = inb(ioaddr+TANG_CARD_STATUS); |
|
} while((++boguscount < 20) && (status&(TANG_RX_READY|TANG_TX_READY))); |
|
|
|
/* poll 20 times per second */ |
|
cops_timer.expires = jiffies + HZ/20; |
|
add_timer(&cops_timer); |
|
} |
|
|
|
/* |
|
* The typical workload of the driver: |
|
* Handle the network interface interrupts. |
|
*/ |
|
static irqreturn_t cops_interrupt(int irq, void *dev_id) |
|
{ |
|
struct net_device *dev = dev_id; |
|
struct cops_local *lp; |
|
int ioaddr, status; |
|
int boguscount = 0; |
|
|
|
ioaddr = dev->base_addr; |
|
lp = netdev_priv(dev); |
|
|
|
if(lp->board==DAYNA) |
|
{ |
|
do { |
|
outb(0, ioaddr + COPS_CLEAR_INT); |
|
status=inb(ioaddr+DAYNA_CARD_STATUS); |
|
if((status&0x03)==DAYNA_RX_REQUEST) |
|
cops_rx(dev); |
|
netif_wake_queue(dev); |
|
} while(++boguscount < 20); |
|
} |
|
else |
|
{ |
|
do { |
|
status=inb(ioaddr+TANG_CARD_STATUS); |
|
if(status & TANG_RX_READY) |
|
cops_rx(dev); |
|
if(status & TANG_TX_READY) |
|
netif_wake_queue(dev); |
|
status=inb(ioaddr+TANG_CARD_STATUS); |
|
} while((++boguscount < 20) && (status&(TANG_RX_READY|TANG_TX_READY))); |
|
} |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
/* |
|
* We have a good packet(s), get it/them out of the buffers. |
|
*/ |
|
static void cops_rx(struct net_device *dev) |
|
{ |
|
int pkt_len = 0; |
|
int rsp_type = 0; |
|
struct sk_buff *skb = NULL; |
|
struct cops_local *lp = netdev_priv(dev); |
|
int ioaddr = dev->base_addr; |
|
int boguscount = 0; |
|
unsigned long flags; |
|
|
|
|
|
spin_lock_irqsave(&lp->lock, flags); |
|
|
|
if(lp->board==DAYNA) |
|
{ |
|
outb(0, ioaddr); /* Send out Zero length. */ |
|
outb(0, ioaddr); |
|
outb(DATA_READ, ioaddr); /* Send read command out. */ |
|
|
|
/* Wait for DMA to turn around. */ |
|
while(++boguscount<1000000) |
|
{ |
|
barrier(); |
|
if((inb(ioaddr+DAYNA_CARD_STATUS)&0x03)==DAYNA_RX_READY) |
|
break; |
|
} |
|
|
|
if(boguscount==1000000) |
|
{ |
|
printk(KERN_WARNING "%s: DMA timed out.\n",dev->name); |
|
spin_unlock_irqrestore(&lp->lock, flags); |
|
return; |
|
} |
|
} |
|
|
|
/* Get response length. */ |
|
pkt_len = inb(ioaddr); |
|
pkt_len |= (inb(ioaddr) << 8); |
|
/* Input IO code. */ |
|
rsp_type=inb(ioaddr); |
|
|
|
/* Malloc up new buffer. */ |
|
skb = dev_alloc_skb(pkt_len); |
|
if(skb == NULL) |
|
{ |
|
printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", |
|
dev->name); |
|
dev->stats.rx_dropped++; |
|
while(pkt_len--) /* Discard packet */ |
|
inb(ioaddr); |
|
spin_unlock_irqrestore(&lp->lock, flags); |
|
return; |
|
} |
|
skb->dev = dev; |
|
skb_put(skb, pkt_len); |
|
skb->protocol = htons(ETH_P_LOCALTALK); |
|
|
|
insb(ioaddr, skb->data, pkt_len); /* Eat the Data */ |
|
|
|
if(lp->board==DAYNA) |
|
outb(1, ioaddr+DAYNA_INT_CARD); /* Interrupt the card */ |
|
|
|
spin_unlock_irqrestore(&lp->lock, flags); /* Restore interrupts. */ |
|
|
|
/* Check for bad response length */ |
|
if(pkt_len < 0 || pkt_len > MAX_LLAP_SIZE) |
|
{ |
|
printk(KERN_WARNING "%s: Bad packet length of %d bytes.\n", |
|
dev->name, pkt_len); |
|
dev->stats.tx_errors++; |
|
dev_kfree_skb_any(skb); |
|
return; |
|
} |
|
|
|
/* Set nodeid and then get out. */ |
|
if(rsp_type == LAP_INIT_RSP) |
|
{ /* Nodeid taken from received packet. */ |
|
lp->node_acquire = skb->data[0]; |
|
dev_kfree_skb_any(skb); |
|
return; |
|
} |
|
|
|
/* One last check to make sure we have a good packet. */ |
|
if(rsp_type != LAP_RESPONSE) |
|
{ |
|
printk(KERN_WARNING "%s: Bad packet type %d.\n", dev->name, rsp_type); |
|
dev->stats.tx_errors++; |
|
dev_kfree_skb_any(skb); |
|
return; |
|
} |
|
|
|
skb_reset_mac_header(skb); /* Point to entire packet. */ |
|
skb_pull(skb,3); |
|
skb_reset_transport_header(skb); /* Point to data (Skip header). */ |
|
|
|
/* Update the counters. */ |
|
dev->stats.rx_packets++; |
|
dev->stats.rx_bytes += skb->len; |
|
|
|
/* Send packet to a higher place. */ |
|
netif_rx(skb); |
|
} |
|
|
|
static void cops_timeout(struct net_device *dev, unsigned int txqueue) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
int ioaddr = dev->base_addr; |
|
|
|
dev->stats.tx_errors++; |
|
if(lp->board==TANGENT) |
|
{ |
|
if((inb(ioaddr+TANG_CARD_STATUS)&TANG_TX_READY)==0) |
|
printk(KERN_WARNING "%s: No TX complete interrupt.\n", dev->name); |
|
} |
|
printk(KERN_WARNING "%s: Transmit timed out.\n", dev->name); |
|
cops_jumpstart(dev); /* Restart the card. */ |
|
netif_trans_update(dev); /* prevent tx timeout */ |
|
netif_wake_queue(dev); |
|
} |
|
|
|
|
|
/* |
|
* Make the card transmit a LocalTalk packet. |
|
*/ |
|
|
|
static netdev_tx_t cops_send_packet(struct sk_buff *skb, |
|
struct net_device *dev) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
int ioaddr = dev->base_addr; |
|
unsigned long flags; |
|
|
|
/* |
|
* Block a timer-based transmit from overlapping. |
|
*/ |
|
|
|
netif_stop_queue(dev); |
|
|
|
spin_lock_irqsave(&lp->lock, flags); |
|
if(lp->board == DAYNA) /* Wait for adapter transmit buffer. */ |
|
while((inb(ioaddr+DAYNA_CARD_STATUS)&DAYNA_TX_READY)==0) |
|
cpu_relax(); |
|
if(lp->board == TANGENT) /* Wait for adapter transmit buffer. */ |
|
while((inb(ioaddr+TANG_CARD_STATUS)&TANG_TX_READY)==0) |
|
cpu_relax(); |
|
|
|
/* Output IO length. */ |
|
outb(skb->len, ioaddr); |
|
outb(skb->len >> 8, ioaddr); |
|
|
|
/* Output IO code. */ |
|
outb(LAP_WRITE, ioaddr); |
|
|
|
if(lp->board == DAYNA) /* Check the transmit buffer again. */ |
|
while((inb(ioaddr+DAYNA_CARD_STATUS)&DAYNA_TX_READY)==0); |
|
|
|
outsb(ioaddr, skb->data, skb->len); /* Send out the data. */ |
|
|
|
if(lp->board==DAYNA) /* Dayna requires you kick the card */ |
|
outb(1, ioaddr+DAYNA_INT_CARD); |
|
|
|
spin_unlock_irqrestore(&lp->lock, flags); /* Restore interrupts. */ |
|
|
|
/* Done sending packet, update counters and cleanup. */ |
|
dev->stats.tx_packets++; |
|
dev->stats.tx_bytes += skb->len; |
|
dev_kfree_skb (skb); |
|
return NETDEV_TX_OK; |
|
} |
|
|
|
/* |
|
* Dummy function to keep the Appletalk layer happy. |
|
*/ |
|
|
|
static void set_multicast_list(struct net_device *dev) |
|
{ |
|
if(cops_debug >= 3) |
|
printk("%s: set_multicast_list executed\n", dev->name); |
|
} |
|
|
|
/* |
|
* System ioctls for the COPS LocalTalk card. |
|
*/ |
|
|
|
static int cops_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
struct sockaddr_at *sa = (struct sockaddr_at *)&ifr->ifr_addr; |
|
struct atalk_addr *aa = &lp->node_addr; |
|
|
|
switch(cmd) |
|
{ |
|
case SIOCSIFADDR: |
|
/* Get and set the nodeid and network # atalkd wants. */ |
|
cops_nodeid(dev, sa->sat_addr.s_node); |
|
aa->s_net = sa->sat_addr.s_net; |
|
aa->s_node = lp->node_acquire; |
|
|
|
/* Set broardcast address. */ |
|
dev->broadcast[0] = 0xFF; |
|
|
|
/* Set hardware address. */ |
|
dev->dev_addr[0] = aa->s_node; |
|
dev->addr_len = 1; |
|
return 0; |
|
|
|
case SIOCGIFADDR: |
|
sa->sat_addr.s_net = aa->s_net; |
|
sa->sat_addr.s_node = aa->s_node; |
|
return 0; |
|
|
|
default: |
|
return -EOPNOTSUPP; |
|
} |
|
} |
|
|
|
/* |
|
* The inverse routine to cops_open(). |
|
*/ |
|
|
|
static int cops_close(struct net_device *dev) |
|
{ |
|
struct cops_local *lp = netdev_priv(dev); |
|
|
|
/* If we were running polled, yank the timer. |
|
*/ |
|
if(lp->board==TANGENT && dev->irq==0) |
|
del_timer(&cops_timer); |
|
|
|
netif_stop_queue(dev); |
|
return 0; |
|
} |
|
|
|
|
|
#ifdef MODULE |
|
static struct net_device *cops_dev; |
|
|
|
MODULE_LICENSE("GPL"); |
|
module_param_hw(io, int, ioport, 0); |
|
module_param_hw(irq, int, irq, 0); |
|
module_param_hw(board_type, int, other, 0); |
|
|
|
static int __init cops_module_init(void) |
|
{ |
|
if (io == 0) |
|
printk(KERN_WARNING "%s: You shouldn't autoprobe with insmod\n", |
|
cardname); |
|
cops_dev = cops_probe(-1); |
|
return PTR_ERR_OR_ZERO(cops_dev); |
|
} |
|
|
|
static void __exit cops_module_exit(void) |
|
{ |
|
unregister_netdev(cops_dev); |
|
cleanup_card(cops_dev); |
|
free_netdev(cops_dev); |
|
} |
|
module_init(cops_module_init); |
|
module_exit(cops_module_exit); |
|
#endif /* MODULE */
|
|
|