text: /*      cops.c: LocalTalk driver for Linux.
   *
   *	Authors:
   *      - Jay Schulist <jschlst@samba.org>
   *
   *	With more than a little help from;
   *	- Alan Cox <alan@lxorguk.ukuu.org.uk>
   *
   *      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 <jschlst@samba.org>\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 <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 <johns393@maroon.tc.umn.edu>
   *		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;
  
  /* 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 (unsigned long ltdev);
  static void cops_timeout(struct net_device *dev);
  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;
  			/* No IRQ found on this port, fallthrough */
  		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 */
  		{
  		    init_timer(&cops_timer);
  		    cops_timer.function = cops_poll;
  		    cops_timer.data 	= (unsigned long)dev;
  		    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(unsigned long ltdev)
  {
  	int ioaddr, status;
  	int boguscount = 0;
  
  	struct net_device *dev = (struct net_device *)ltdev;
  
  	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. */
  	if(lp->board==DAYNA)
          	pkt_len = inb(ioaddr) & 0xFF;
  	else
  		pkt_len = inb(ioaddr) & 0x00FF;
          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)
  {
          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. */
  	dev->trans_start = jiffies; /* 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);
  	if(lp->board == DAYNA)
                 	outb(skb->len >> 8, ioaddr);
  	else
  		outb((skb->len >> 8)&0x0FF, 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(io, int, 0);
  module_param(irq, int, 0);
  module_param(board_type, int, 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_RET(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 */
  