root/drivers/net/arcnet.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. arcnet_probe
  2. arcnet_ioprobe
  3. arcnet_memprobe
  4. arcnet_open
  5. arcnet_close
  6. arcnet_send_packet
  7. arcnet_continue_tx
  8. careful_xmit_wait
  9. arcnet_prepare_tx
  10. arcnet_go_tx
  11. arcnet_interrupt
  12. arcnet_inthandler
  13. arcnet_rx
  14. arcnet_timer
  15. arcnet_get_stats
  16. set_multicast_list
  17. arcnet_reset
  18. arc_header
  19. arc_rebuild_header
  20. arc_type_trans
  21. init_module
  22. cleanup_module

   1 /* arcnet.c
   2         Written 1994-95 by Avery Pennarun, derived from skeleton.c by
   3         Donald Becker.
   4 
   5         Contact Avery at: apenwarr@tourism.807-city.on.ca or
   6         RR #5 Pole Line Road, Thunder Bay, ON, Canada P7C 5M9
   7         
   8         **********************
   9 
  10         skeleton.c Written 1993 by Donald Becker.
  11         Copyright 1993 United States Government as represented by the
  12         Director, National Security Agency.  This software may only be used
  13         and distributed according to the terms of the GNU Public License as
  14         modified by SRC, incorporated herein by reference.
  15          
  16         **********************
  17 
  18 
  19         v1.0 (95/02/15)
  20           - Initial non-alpha release.
  21         
  22          
  23         TO DO:
  24         
  25          - Test in systems with NON-ARCnet network cards, just to see if
  26            autoprobe kills anything.  With any luck, it won't.  (It's pretty
  27            careful.)
  28                 - Except some unfriendly NE2000's die. (0.40)
  29          - cards with shared memory that can be "turned off?"
  30          - NFS mount freezes after several megabytes to SOSS for DOS. 
  31            unmount/remount works.  Is this arcnet-specific?  I don't know.
  32          - Add support for the various stupid bugs ("I didn't read the RFC"
  33            syndrome) in MS Windows for Workgroups and LanMan.
  34            
  35          - get the net people to probe last for arcnet, and first for ne2000
  36            in Space.c...  
  37  */
  38  
  39 /**************************************************************************/
  40 
  41 /* define this if you want to use the new but possibly dangerous ioprobe
  42  * If you get lockups right after status5, you probably need
  43  * to undefine this.  It should make more cards probe correctly,
  44  * I hope.
  45  */
  46 #define DANGER_PROBE
  47 
  48 /* define this if you want to use the "extra delays" which were removed
  49  * in 0.41 since they seemed needless.
  50  */
  51 #undef EXTRA_DELAYS
  52 
  53 /* undefine this if you want to use the non-IRQ-driven transmitter. (possibly
  54  * safer, although it takes more CPU time and IRQ_XMIT seems fine right now)
  55  */
  56 #define IRQ_XMIT
  57  
  58 /* define this for "careful" transmitting.  Try with and without if you have
  59  * problems.  If you use IRQ_XMIT, do NOT define this.
  60  */
  61 #undef CAREFUL_XMIT
  62 
  63 /* define this for an extra-careful memory detect.  This should work all
  64  * the time now, but you never know.
  65  */
  66 #define STRICT_MEM_DETECT
  67 
  68 /* define this to use the "old-style" limited MTU by default.  It basically
  69  * disables packet splitting.  ifconfig can still be used to reset the MTU.
  70  *
  71  * leave this disabled if possible, so it will use ethernet defaults,
  72  * which is our goal.
  73  */
  74 #undef LIMIT_MTU
  75 
  76 /* define this if you have a problem with the card getting "stuck" now and
  77  * then, which can only be fixed by a reboot or resetting the card manually
  78  * via ifconfig up/down.  ARCnet will set a timer function which is called
  79  * 8 times every second.
  80  *
  81  * This should no longer be necessary.  if you experience "stuck" ARCnet
  82  * drivers, please email apenwarr@tourism.807-city.on.ca or I will remove
  83  * this feature in a future release.
  84  */
  85 #undef USE_TIMER_HANDLER
  86 
  87 /**************************************************************************/
  88  
  89 static char *version =
  90  "arcnet.c:v1.00 95/02/15 Avery Pennarun <apenwarr@tourism.807-city.on.ca>\n";
  91 
  92 /*
  93   Sources:
  94         Crynwr arcnet.com/arcether.com packet drivers.
  95         arcnet.c v0.00 dated 1/1/94 and apparently by
  96                 Donald Becker - it didn't work :)
  97         skeleton.c v0.05 dated 11/16/93 by Donald Becker
  98                 (from Linux Kernel 1.1.45)
  99         ...I sure wish I had the ARCnet data sheets right about now!
 100         RFC's 1201 and 1051 (mostly 1201) - re: ARCnet IP packets
 101         net/inet/eth.c (from kernel 1.1.50) for header-building info...
 102         Alternate Linux ARCnet source by V.Shergin <vsher@sao.stavropol.su>
 103         Textual information and more alternate source from Joachim Koenig
 104                 <jojo@repas.de>
 105 */
 106 
 107 #include <linux/config.h>
 108 #ifdef MODULE
 109 #include <linux/module.h>
 110 #include <linux/version.h>
 111 #endif /* MODULE */
 112 
 113 #include <linux/kernel.h>
 114 #include <linux/sched.h>
 115 #include <linux/types.h>
 116 #include <linux/fcntl.h>
 117 #include <linux/interrupt.h>
 118 #include <linux/ptrace.h>
 119 #include <linux/ioport.h>
 120 #include <linux/in.h>
 121 #include <linux/malloc.h>
 122 #include <linux/string.h>
 123 #include <linux/timer.h>
 124 #include <linux/errno.h>
 125 #include <linux/delay.h>
 126 
 127 #include <asm/system.h>
 128 #include <asm/bitops.h>
 129 #include <asm/io.h>
 130 #include <asm/dma.h>
 131 
 132 #include <linux/netdevice.h>
 133 #include <linux/etherdevice.h>
 134 #include <linux/skbuff.h>
 135 #include "arp.h"
 136 
 137 
 138 /* debug levels:
 139  * D_OFF        production
 140  * D_NORMAL     verification
 141  * D_INIT       show init/detect messages
 142  * D_DURING     show messages during normal use (ie interrupts)
 143  * D_TX         show tx packets
 144  * D_RX         show tx+rx packets
 145  */
 146 #define D_OFF           0
 147 #define D_NORMAL        1
 148 #define D_INIT          2
 149 #define D_EXTRA         3
 150 #define D_DURING        4
 151 #define D_TX            5
 152 #define D_RX            6
 153 
 154 #ifndef NET_DEBUG
 155 #define NET_DEBUG       D_INIT
 156 #endif
 157 static unsigned int net_debug = NET_DEBUG;
 158 
 159 #ifndef HAVE_AUTOIRQ
 160 /* From auto_irq.c, in ioport.h for later versions. */
 161 extern void autoirq_setup(int waittime);
 162 extern int autoirq_report(int waittime);
 163 /* The map from IRQ number (as passed to the interrupt handler) to
 164    'struct device'. */
 165 extern struct device *irq2dev_map[16];
 166 #endif
 167 
 168 #ifndef HAVE_PORTRESERVE
 169 #define check_region(ioaddr, size)              0
 170 #define request_region(ioaddr, size)            do ; while (0)
 171 #endif
 172 
 173 /* macro to simplify debug checking */
 174 #define BUGLVL(x) if (net_debug>=x)
 175 
 176 /* The number of low I/O ports used by the ethercard. */
 177 #define ETHERCARD_TOTAL_SIZE    16
 178 
 179 
 180 /* Handy defines for ARCnet specific stuff */
 181         /* COM 9026 (?) --> ARCnet register addresses */
 182 #define INTMASK (ioaddr+0)              /* writable */
 183 #define STATUS  (ioaddr+0)              /* readable */
 184 #define COMMAND (ioaddr+1)      /* writable, returns random vals on read (?) */
 185 #define RESET  (ioaddr+8)               /* software reset writable */
 186 
 187         /* time needed for various things (in clock ticks, 1/100 sec) */
 188 #define RESETtime 40            /* reset */
 189 #define XMITtime 10             /* send (?) */
 190 #define ACKtime 10              /* acknowledge (?) */
 191 
 192         /* these are the max/min lengths of packet data. (including
 193          * ClientData header)
 194          * note: packet sizes 250, 251, 252 are impossible (God knows why)
 195          *  so exception packets become necessary.
 196          *
 197          * These numbers are compared with the length of the full packet,
 198          * including ClientData header.
 199          */
 200 #define MTU     (253+EXTRA_CLIENTDATA)  /* normal packet max size */
 201 #define MinTU   (257+EXTRA_CLIENTDATA)  /* extended packet min size */
 202 #define XMTU    (508+EXTRA_CLIENTDATA)  /* extended packet max size */
 203 
 204         /* status/interrupt mask bit fields */
 205 #define TXFREEflag      0x001            /* transmitter available */
 206 #define TXACKflag       0x002            /* transmitted msg. ackd */
 207 #define RECONflag       0x004            /* system reconfigured */
 208 #define TESTflag        0x008            /* test flag */
 209 #define RESETflag       0x010            /* power-on-reset */
 210 #define RES1flag        0x020            /* unused */
 211 #define RES2flag        0x040            /* unused */
 212 #define NORXflag        0x080            /* receiver inhibited */
 213 
 214        /* in the command register, the following bits have these meanings:
 215         *                0-2     command
 216         *                3-4     page number (for enable rcv/xmt command)
 217         *                 7      receive broadcasts
 218         */
 219 #define NOTXcmd         0x001            /* disable transmitter */
 220 #define NORXcmd         0x002            /* disable receiver */
 221 #define TXcmd           0x003            /* enable transmitter */
 222 #define RXcmd           0x004            /* enable receiver */
 223 #define CONFIGcmd       0x005            /* define configuration */
 224 #define CFLAGScmd       0x006            /* clear flags */
 225 #define TESTcmd         0x007            /* load test flags */
 226 
 227        /* flags for "clear flags" command */
 228 #define RESETclear      0x008            /* power-on-reset */
 229 #define CONFIGclear     0x010            /* system reconfigured */
 230 
 231       /* flags for "load test flags" command */
 232 #define TESTload        0x008            /* test flag (diagnostic) */
 233 
 234       /* byte deposited into first address of buffers on reset */
 235 #define TESTvalue       0321             /* that's octal for 0xD1 :) */
 236 
 237       /* for "enable receiver" command */
 238 #define RXbcasts        0x080            /* receive broadcasts */
 239 
 240       /* flags for "define configuration" command */
 241 #define NORMALconf      0x000            /* 1-249 byte packets */
 242 #define EXTconf         0x008            /* 250-504 byte packets */
 243 
 244         /* buffers (4 total) used for receive and xmit.
 245          */
 246 #define EnableReceiver()        outb(RXcmd|(recbuf<<3)|RXbcasts,COMMAND)
 247 /*#define TXbuf         2 (Obsoleted by ping-pong xmits) */
 248 
 249         /* Protocol ID's */
 250 #define ARC_P_IP        212             /* 0xD4 */
 251 #define ARC_P_ARP       213             /* 0xD5 */
 252 #define ARC_P_RARP      214             /* 0xD6 */
 253 #define ARC_P_IPX       250             /* 0xFA */
 254 #define ARC_P_LANSOFT   251             /* 0xFB */
 255 #define ARC_P_ATALK     0xDD
 256 
 257         /* Length of time between "stuck" checks */
 258 #define TIMERval        (HZ/8)          /* about 1/8 second */
 259 
 260         /* these structures define the format of an arcnet packet. */
 261 #define NORMAL          0
 262 #define EXTENDED        1
 263 #define EXCEPTION       2
 264 
 265         /* the header required by the card itself */
 266 struct HardHeader
 267 {
 268         u_char  source,         /* source ARCnet - filled in automagically */
 269                 destination,    /* destination ARCnet - 0 for broadcast */
 270                 offset1,        /* offset of ClientData (256-byte packets) */
 271                 offset2;        /* offset of ClientData (512-byte packets) */
 272 };
 273 
 274         /* a complete ARCnet packet */
 275 union ArcPacket
 276 {
 277         struct HardHeader hardheader;   /* the hardware header */
 278         u_char raw[512];                /* raw packet info, incl ClientData */
 279 };
 280 
 281         /* the "client data" header - RFC-1201 information
 282          * notice that this screws up if it's not an even number of bytes
 283          * <sigh>
 284          */
 285 struct ClientData
 286 {
 287         /* data that's NOT part of real packet */
 288         u_char  daddr;          /* Destination address - stored here,
 289                                  *   but WE MUST GET RID OF IT BEFORE SENDING A
 290                                  *   PACKET!!
 291                                  */
 292         u_char  stupid;         /* filler to make struct an even # of bytes */
 293         
 294         /* data that IS part of real packet */
 295         u_char  protocol_id,    /* ARC_P_IP, ARC_P_ARP, or ARC_P_RARP */
 296                 split_flag;     /* for use with split packets */
 297         u_short sequence;       /* sequence number (?) */
 298 };
 299 #define EXTRA_CLIENTDATA (sizeof(struct ClientData)-4)
 300 
 301 
 302 /* "Incoming" is information needed for each address that could be sending
 303  * to us.  Mostly for partially-received split packets.
 304  */
 305 struct Incoming
 306 {
 307         struct sk_buff *skb;            /* packet data buffer             */
 308         unsigned char lastpacket,       /* number of last packet (from 1) */
 309                       numpackets;       /* number of packets in split     */
 310         u_short sequence;               /* sequence number of assembly    */
 311 };
 312 
 313 struct Outgoing
 314 {
 315         struct sk_buff *skb;            /* buffer from upper levels */
 316         struct ClientData *hdr;         /* clientdata of last packet */
 317         u_char *data;                   /* pointer to data in packet */
 318         short length,                   /* bytes total */
 319               dataleft,                 /* bytes left */
 320               segnum,                   /* segment being sent */
 321               numsegs,                  /* number of segments */
 322               seglen;                   /* length of segment */
 323 };
 324 
 325 
 326 /* Information that needs to be kept for each board. */
 327 struct arcnet_local {
 328         struct enet_statistics stats;
 329         u_char arcnum;          /* arcnet number - our 8-bit address */
 330         u_short sequence;       /* sequence number (incs with each packet) */
 331         u_char recbuf,          /* receive buffer # (0 or 1) */
 332                txbuf,           /* transmit buffer # (2 or 3) */
 333                txready;         /* buffer where a packet is ready to send */
 334         short intx,             /* in TX routine? */
 335               in_txhandler,     /* in TX_IRQ handler? */
 336               sending;          /* transmit in progress? */
 337         short tx_left;          /* segments of split packet left to TX */
 338         struct timer_list timer; /* the timer interrupt struct */
 339         struct Incoming incoming[256];  /* one from each address */
 340         struct Outgoing outgoing; /* packet currently being sent */
 341 };
 342 
 343 
 344 /* Index to functions, as function prototypes. */
 345 extern int arcnet_probe(struct device *dev);
 346 #ifndef MODULE
 347 static int arcnet_memprobe(struct device *dev,u_char *addr);
 348 static int arcnet_ioprobe(struct device *dev, short ioaddr);
 349 #endif
 350 
 351 static int arcnet_open(struct device *dev);
 352 static int arcnet_close(struct device *dev);
 353 
 354 static int arcnet_send_packet(struct sk_buff *skb, struct device *dev);
 355 #ifdef CAREFUL_XMIT
 356  static void careful_xmit_wait(struct device *dev);
 357 #else
 358  #define careful_xmit_wait(dev)
 359 #endif
 360 static void arcnet_continue_tx(struct device *dev);
 361 static void arcnet_prepare_tx(struct device *dev,struct ClientData *hdr,
 362                 short length,char *data);
 363 static void arcnet_go_tx(struct device *dev);
 364 
 365 static void arcnet_interrupt(int irq,struct pt_regs *regs);
 366 static void arcnet_inthandler(struct device *dev);
 367 static void arcnet_rx(struct device *dev,int recbuf);
 368 
 369 #ifdef USE_TIMER_HANDLER
 370 static void arcnet_timer(unsigned long arg);
 371 #endif
 372 
 373 static struct enet_statistics *arcnet_get_stats(struct device *dev);
 374 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 375 
 376         /* annoying functions for header/arp/etc building */
 377 int arc_header(unsigned char *buff,struct device *dev,unsigned short type,
 378                 void *daddr,void *saddr,unsigned len,struct sk_buff *skb);
 379 int arc_rebuild_header(void *eth,struct device *dev,unsigned long raddr,
 380                 struct sk_buff *skb);
 381 unsigned short arc_type_trans(struct sk_buff *skb,struct device *dev);
 382 
 383 static int arcnet_reset(struct device *dev);
 384 
 385 #ifdef MODULE
 386 int  init_module(void);
 387 void cleanup_module(void);
 388 #endif
 389 
 390 #define tx_done(dev) 1
 391 
 392 /*
 393 #define JIFFER(time) for (delayval=jiffies+(time); delayval>jiffies;);
 394 */
 395 #define JIFFER(time) for (delayval=0; delayval<(time*10); delayval++) \
 396                 udelay(1000);
 397 
 398 #ifdef EXTRA_DELAYS
 399  #define XJIFFER(time) JIFFER(time)
 400 #else
 401  #define XJIFFER(time)
 402 #endif
 403 
 404 
 405 /* Check for a network adaptor of this type, and return '0' if one exists.
 406  *  If dev->base_addr == 0, probe all likely locations.
 407  *  If dev->base_addr == 1, always return failure.
 408  *  If dev->base_addr == 2, allocate space for the device and return success
 409  *  (detachable devices only).
 410  */
 411 int
 412 arcnet_probe(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 413 {
 414 #ifndef MODULE
 415         /* I refuse to probe anything less than 0x200, because anyone using
 416          * an address like that should probably be shot.
 417          */
 418         int *port, ports[] = {/* first the suggested values! */
 419                               0x300,0x2E0,0x2F0,0x2D0,
 420                               /* ...now everything else possible. */
 421                               0x200,0x210,0x220,0x230,0x240,0x250,0x260,0x270,
 422                               0x280,0x290,0x2a0,0x2b0,0x2c0,
 423                                     0x310,0x320,0x330,0x340,0x350,0x360,0x370,
 424                               0x380,0x390,0x3a0,/* video ports, */0x3e0,0x3f0,
 425                               /* a null ends the list */
 426                               0};
 427         /* I'm not going to probe below 0xA0000 either, for similar reasons.
 428          */
 429         unsigned long *addr, addrs[] = {0xD0000,0xE0000,0xA0000,0xB0000,
 430                                         0xC0000,0xF0000,
 431                                         /* from <mdrejhon@magi.com> */
 432                                         0xE1000,
 433                                         0xDD000,0xDC000,
 434                                         0xD9000,0xD8000,0xD5000,0xD4000,0xD1000,
 435                                         0xCD000,0xCC000,
 436                                         0xC9000,0xC8000,0xC5000,0xC4000,
 437                                         /* terminator */
 438                                         0};
 439         int base_addr=dev->base_addr, status=0;
 440 #endif /* MODULE */
 441         int delayval;
 442         struct arcnet_local *lp;
 443 
 444         if (net_debug)
 445         {
 446                 printk(version);
 447                 printk("arcnet: ***\n");
 448                 printk("arcnet: * Read linux/drivers/net/README.arcnet for important release notes!\n");
 449                 printk("arcnet: ***\n");
 450         }
 451         
 452         BUGLVL(D_INIT)
 453                 printk("arcnet: given: base %lXh, IRQ %Xh, shmem %lXh\n",
 454                         dev->base_addr,dev->irq,dev->mem_start);
 455                         
 456 #ifndef MODULE
 457         if (base_addr > 0x1ff)          /* Check a single specified location. */
 458                 status=arcnet_ioprobe(dev, base_addr);
 459         else if (base_addr > 0)         /* Don't probe at all. */
 460                 return ENXIO;
 461         else for (port = &ports[0]; *port; port++)
 462         {
 463                 int ioaddr = *port;
 464                 if (check_region(ioaddr, ETHERCARD_TOTAL_SIZE))
 465                 {
 466                         BUGLVL(D_INIT)
 467                                 printk("arcnet: Skipping %Xh because of check_region...\n",
 468                                         ioaddr);
 469                         continue;
 470                 }
 471 
 472                 status=arcnet_ioprobe(dev, ioaddr);
 473                 if (!status) break;
 474         }
 475         
 476         if (status) return status;
 477 
 478         /* ioprobe turned out okay.  Now give it a couple seconds to finish
 479          * initializing...
 480          */
 481         BUGLVL(D_INIT)
 482                 printk("arcnet: ioprobe okay!  Waiting for reset...\n");
 483         JIFFER(100);
 484 
 485         /* okay, now we have to find the shared memory area. */
 486         BUGLVL(D_INIT)
 487                 printk("arcnet: starting memory probe, given %lXh\n",
 488                         dev->mem_start);
 489         if (dev->mem_start)     /* value given - probe just that one */
 490         {
 491                 status=arcnet_memprobe(dev,(u_char *)dev->mem_start);
 492                 if (status) return status;
 493         }
 494         else                    /* no value given - probe everything */
 495         {
 496                 for (addr = &addrs[0]; *addr; addr++) {
 497                         status=arcnet_memprobe(dev,(u_char *)(*addr));
 498                         if (!status) break;
 499                 }
 500                 
 501                 if (status) return status;
 502         }
 503 #else /* MODULE */
 504         if (!dev->base_addr || !dev->irq || !dev->mem_start 
 505                 || !dev->rmem_start)
 506         {
 507                 printk("arcnet: loadable modules can't autoprobe!\n");
 508                 printk("arcnet:  try using io=, irqnum=, and shmem= on the insmod line.\n");
 509                 printk("arcnet:  you may also need num= to change the device name. (ie. num=1 for arc1)\n");
 510                 return ENODEV;
 511         }
 512 #endif
 513         /* now reserve the irq... */
 514         {       
 515                 int irqval = request_irq(dev->irq, &arcnet_interrupt, 0,
 516                         "arcnet");
 517                 if (irqval) {
 518                         printk("%s: unable to get IRQ %d (irqval=%d).\n",
 519                                 dev->name,dev->irq, irqval);
 520                         return EAGAIN;
 521                  }
 522          }
 523          
 524         /* Grab the region so we can find another board if autoIRQ fails. */
 525         request_region(dev->base_addr, ETHERCARD_TOTAL_SIZE,"arcnet");
 526         
 527         printk("%s: ARCnet card found at %03lXh, IRQ %d, ShMem at %lXh.\n", 
 528                 dev->name, dev->base_addr, dev->irq, dev->mem_start);
 529 
 530         /* Initialize the device structure. */
 531         dev->priv = kmalloc(sizeof(struct arcnet_local), GFP_KERNEL);
 532         memset(dev->priv, 0, sizeof(struct arcnet_local));
 533         lp=(struct arcnet_local *)(dev->priv);
 534 
 535         dev->open               = arcnet_open;
 536         dev->stop               = arcnet_close;
 537         dev->hard_start_xmit = arcnet_send_packet;
 538         dev->get_stats  = arcnet_get_stats;
 539 #ifdef HAVE_MULTICAST
 540         dev->set_multicast_list = &set_multicast_list;
 541 #endif
 542 
 543         /* Fill in the fields of the device structure with ethernet-generic values. */
 544         ether_setup(dev);
 545 
 546         /* And now fill particular ones with arcnet values :) */
 547         
 548         dev->type=ARPHRD_ARCNET;
 549         dev->hard_header_len=sizeof(struct ClientData);
 550         BUGLVL(D_EXTRA)
 551                 printk("arcnet: ClientData header size is %d.\narcnet: HardHeader size is %d.\n",
 552                         sizeof(struct ClientData),sizeof(struct HardHeader));
 553 #if LIMIT_MTU   /* the old way - normally, now use ethernet default */
 554         dev->mtu=512-sizeof(struct HardHeader)+EXTRA_CLIENTDATA;
 555 #endif
 556                 /* since we strip EXTRA_CLIENTDATA bytes off before sending,
 557                  * we let Linux add that many bytes to the packet data...
 558                  */
 559         dev->addr_len=1;
 560         dev->broadcast[0]=0x00;
 561         
 562         BUGLVL(D_INIT) printk("arcnet: arcnet_probe: resetting card.\n");
 563         arcnet_reset(dev);
 564         JIFFER(50);
 565         BUGLVL(D_NORMAL)
 566                 printk("arcnet: We appear to be station %d (%02Xh)\n",
 567                         lp->arcnum,lp->arcnum);
 568         if (lp->arcnum==0)
 569                 printk("arcnet: WARNING!  Station address 0 is reserved for broadcasts!\n");
 570         if (lp->arcnum==255)
 571                 printk("arcnet: WARNING!  Station address 255 may confuse DOS networking programs!\n");
 572         dev->dev_addr[0]=lp->arcnum;
 573         lp->sequence=1;
 574         lp->recbuf=0;
 575 
 576         dev->hard_header        = arc_header;
 577         dev->rebuild_header     = arc_rebuild_header;
 578         dev->type_trans         = arc_type_trans;
 579 
 580         return 0;
 581 }
 582 
 583 #ifndef MODULE
 584 
 585 int arcnet_ioprobe(struct device *dev, short ioaddr)
     /* [previous][next][first][last][top][bottom][index][help] */
 586 {
 587         int delayval,airq;
 588 
 589         BUGLVL(D_INIT)
 590                 printk("arcnet: probing address %Xh\n",ioaddr);
 591 
 592         BUGLVL(D_INIT)
 593                 printk("arcnet:  status1=%Xh\n",inb(STATUS));
 594 
 595                 
 596         /* very simple - all we have to do is reset the card, and if there's
 597          * no irq, it's not an ARCnet.  We can also kill two birds with
 598          * one stone because we detect the IRQ at the same time :)
 599          */
 600          
 601         /* reset the card by reading the reset port */
 602         inb(RESET);
 603         JIFFER(RESETtime);
 604 
 605         /* if status port is FF, there's certainly no arcnet... give up. */
 606         if (inb(STATUS)==0xFF)
 607         {
 608                 BUGLVL(D_INIT)
 609                         printk("arcnet:  probe failed.  Status port empty.\n");
 610                 return ENODEV;
 611         }
 612 
 613         /* we'll try to be reasonably sure it's an arcnet by making sure
 614          * the value of the COMMAND port changes automatically once in a
 615          * while.  I have no idea what those values ARE, but at least
 616          * they work.
 617          */
 618         {
 619                 int initval,curval;
 620                 
 621                 curval=initval=inb(COMMAND);
 622                 delayval=jiffies+5;
 623                 while (delayval>=jiffies && curval==initval)
 624                         curval=inb(COMMAND);
 625                         
 626                 if (curval==initval)
 627                 {
 628                         printk("arcnet:  probe failed.  never-changing command port (%02Xh).\n",
 629                                 initval);
 630                         return ENODEV;
 631                 }
 632         }
 633 
 634         BUGLVL(D_INIT)
 635                 printk("arcnet:  status2=%Xh\n",inb(STATUS));
 636 
 637         /* now we turn the reset bit off so we can IRQ next reset... */
 638         outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
 639         XJIFFER(ACKtime);
 640         if (inb(STATUS) & RESETflag) /* reset flag STILL on */
 641         {
 642                 BUGLVL(D_INIT)
 643                         printk("arcnet:  probe failed.  eternal reset flag1...(status=%Xh)\n",
 644                                 inb(STATUS));
 645                 return ENODEV;
 646         }
 647 
 648         /* set up automatic IRQ detection */
 649         autoirq_setup(0);
 650         
 651         /* enable reset IRQ's (shouldn't be necessary, but worth a try) */
 652         outb(RESETflag,INTMASK);
 653 
 654         /* now reset it again to generate an IRQ */
 655         inb(RESET);
 656         JIFFER(RESETtime);
 657 
 658         BUGLVL(D_INIT)
 659                 printk("arcnet:  status3=%Xh\n",inb(STATUS));
 660 
 661         /* and turn the reset flag back off */
 662         outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
 663         XJIFFER(ACKtime);
 664 
 665         BUGLVL(D_INIT)
 666                 printk("arcnet:  status4=%Xh\n",inb(STATUS));
 667 
 668         /* enable reset IRQ's again */
 669         outb(RESETflag,INTMASK);
 670 
 671         /* now reset it again to generate an IRQ */
 672         inb(RESET);
 673         JIFFER(RESETtime);
 674         
 675         BUGLVL(D_INIT)
 676                 printk("arcnet:  status5=%Xh\n",inb(STATUS));
 677 
 678         /* if we do this, we're sure to get an IRQ since the card has
 679          * just reset and the NORXflag is on until we tell it to start
 680          * receiving.
 681          *
 682          * However, this could, theoretically, cause a lockup.  Maybe I'm just
 683          * not very good at theory! :)
 684          */
 685 #ifdef DANGER_PROBE
 686         outb(NORXflag,INTMASK);
 687         JIFFER(RESETtime);
 688         outb(0,INTMASK);
 689 #endif
 690 
 691         /* and turn the reset flag back off */
 692         outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
 693         XJIFFER(ACKtime);
 694 
 695         airq = autoirq_report(0);
 696         if (net_debug>=D_INIT && airq)
 697                 printk("arcnet:  autoirq is %d\n", airq);
 698 
 699         /* if there was no autoirq AND the user hasn't set any defaults,
 700          * give up.
 701          */
 702         if (!airq && !(dev->base_addr && dev->irq))
 703         {
 704                 BUGLVL(D_INIT)
 705                         printk("arcnet:  probe failed.  no autoirq...\n");
 706                 return ENODEV;
 707         }
 708 
 709         /* otherwise we probably have a card.  Let's make sure. */
 710         
 711         if (inb(STATUS) & RESETflag) /* reset flag on */
 712         {
 713                 /* now we turn the reset bit off */
 714                 outb(CFLAGScmd|RESETclear|CONFIGclear,COMMAND);
 715                 XJIFFER(ACKtime);
 716         }
 717         
 718         if (inb(STATUS) & RESETflag) /* reset flag STILL on */
 719         {
 720                 BUGLVL(D_INIT)
 721                         printk("arcnet:  probe failed.  eternal reset flag...(status=%Xh)\n",
 722                                 inb(STATUS));
 723                 return ENODEV;
 724         }
 725         
 726         /* okay, we've got a real, live ARCnet on our hands. */
 727         if (!dev->base_addr) dev->base_addr=ioaddr;
 728         
 729         if (dev->irq < 2)               /* "Auto-IRQ" */
 730         {
 731                 /* we already did the autoirq above, so store the values */
 732                 dev->irq=airq;
 733         }
 734         else if (dev->irq == 2)
 735         {
 736                 if (net_debug)
 737                         printk("arcnet: IRQ2 == IRQ9, don't worry.\n");
 738                 dev->irq = 9;
 739         }
 740 
 741         BUGLVL(D_INIT)
 742                 printk("arcnet: irq and base address seem okay. (%lXh, IRQ %d)\n",
 743                         dev->base_addr,dev->irq);
 744         return 0;
 745 }
 746 
 747 
 748 /* A memory probe that is called after the card is reset.
 749  * It checks for the official TESTvalue in byte 0 and makes sure the buffer
 750  * has certain characteristics of an ARCnet...
 751  */
 752 int arcnet_memprobe(struct device *dev,u_char *addr)
     /* [previous][next][first][last][top][bottom][index][help] */
 753 {
 754         BUGLVL(D_INIT)
 755                 printk("arcnet: probing memory at %lXh\n",(u_long)addr);
 756                 
 757         dev->mem_start=0;
 758 
 759 #ifdef STRICT_MEM_DETECT /* probably better. */
 760         /* ARCnet memory byte 0 is TESTvalue */
 761         if (addr[0]!=TESTvalue)
 762         {
 763                 BUGLVL(D_INIT)
 764                         printk("arcnet:  probe failed.  addr=%lXh, addr[0]=%Xh (not %Xh)\n",
 765                                 (unsigned long)addr,addr[0],TESTvalue);
 766                 return ENODEV;
 767         }
 768         
 769         /* now verify the shared memory writability */
 770         addr[0]=0x42;
 771         if (addr[0]!=0x42)
 772         {
 773                 BUGLVL(D_INIT)
 774                         printk("arcnet:  probe failed.  addr=%lXh, addr[0]=%Xh (not 42h)\n",
 775                                 (unsigned long)addr,addr[0]);
 776                 return ENODEV;
 777         }
 778 #else
 779         if (addr[0]!=TESTvalue)
 780         {
 781                 BUGLVL(D_INIT)
 782                         printk("arcnet:  probe failed.  addr=%lXh, addr[0]=%Xh (not %Xh)\n",
 783                                 (unsigned long)addr,addr[0],TESTvalue);
 784                 return ENODEV;
 785         }
 786 #endif
 787 
 788         /* got it!  fill in dev */
 789         dev->mem_start=(unsigned long)addr;
 790         dev->mem_end=dev->mem_start+512*4-1;
 791         dev->rmem_start=dev->mem_start+512*0;
 792         dev->rmem_end=dev->mem_start+512*2-1;
 793 
 794         return 0;
 795 }
 796 
 797 #endif /* MODULE */
 798 
 799 
 800 /* Open/initialize the board.  This is called (in the current kernel)
 801    sometime after booting when the 'ifconfig' program is run.
 802 
 803    This routine should set everything up anew at each open, even
 804    registers that "should" only need to be set once at boot, so that
 805    there is non-reboot way to recover if something goes wrong.
 806    */
 807 static int
 808 arcnet_open(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 809 {
 810         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
 811 /*      int ioaddr = dev->base_addr;*/
 812 
 813         if (dev->metric>=10)
 814         {
 815                 net_debug=dev->metric-10;
 816                 dev->metric=1;
 817         }
 818 
 819         if (net_debug) printk(version);
 820 
 821 #if 0   /* Yup, they're hardwired in arcnets */
 822         /* This is used if the interrupt line can turned off (shared).
 823            See 3c503.c for an example of selecting the IRQ at config-time. */
 824         if (request_irq(dev->irq, &arcnet_interrupt, 0, "arcnet")) {
 825                 return -EAGAIN;
 826         }
 827 #endif
 828 
 829         irq2dev_map[dev->irq] = dev;
 830 
 831         /* Reset the hardware here. */
 832         BUGLVL(D_EXTRA) printk("arcnet: arcnet_open: resetting card.\n");
 833         
 834         /* try to reset - twice if it fails the first time */
 835         if (arcnet_reset(dev) && arcnet_reset(dev))
 836                 return -ENODEV;
 837         
 838 /*      chipset_init(dev, 1);*/
 839 /*      outb(0x00, ioaddr);*/
 840 
 841 /*      lp->open_time = jiffies;*/
 842 
 843         dev->tbusy=0;
 844         dev->interrupt=0;
 845         dev->start=1;
 846         lp->intx=0;
 847         lp->in_txhandler=0;
 848 
 849 #ifdef USE_TIMER_HANDLER
 850         /* grab a timer handler to recover from any missed IRQ's */
 851         init_timer(&lp->timer);
 852         lp->timer.expires = TIMERval;         /* length of time */
 853         lp->timer.data = (unsigned long)dev;  /* pointer to "dev" structure */
 854         lp->timer.function = &arcnet_timer;    /* timer handler */
 855         add_timer(&lp->timer);
 856 #endif
 857 
 858 #ifdef MODULE
 859         MOD_INC_USE_COUNT;
 860 #endif
 861                                         
 862         return 0;
 863 }
 864 
 865 
 866 /* The inverse routine to arcnet_open(). */
 867 static int
 868 arcnet_close(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 869 {
 870         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
 871         int ioaddr = dev->base_addr;
 872 #ifdef EXTRA_DELAYS
 873         int delayval;
 874 #endif
 875 
 876 /*      lp->open_time = 0;*/
 877 
 878         dev->tbusy = 1;
 879         dev->start = 0;
 880         
 881         /* release the timer */
 882         del_timer(&lp->timer);
 883 
 884         /* Flush the Tx and disable Rx here.     */
 885         /* resetting the card should do the job. */
 886         /*inb(RESET);*/
 887 
 888         outb(0,INTMASK);        /* no IRQ's */
 889         outb(NOTXcmd,COMMAND);  /* disable transmit */
 890         XJIFFER(ACKtime);
 891         outb(NORXcmd,COMMAND);  /* disable receive */
 892 
 893         /* Update the statistics here. */
 894         
 895 #ifdef MODULE
 896         MOD_DEC_USE_COUNT;
 897 #endif
 898 
 899         return 0;
 900 }
 901 
 902 
 903 static int
 904 arcnet_send_packet(struct sk_buff *skb, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 905 {
 906         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
 907         int ioaddr=dev->base_addr;
 908 /*      short daddr;*/
 909 
 910         lp->intx++;
 911 
 912         BUGLVL(D_DURING)
 913                 printk("arcnet: transmit requested (status=%Xh, inTX=%d)\n",
 914                         inb(STATUS),lp->intx);
 915 
 916         if (dev->tbusy || lp->in_txhandler)
 917         {
 918                 /* If we get here, some higher level has decided we are broken.
 919                    There should really be a "kick me" function call instead. */
 920                 int tickssofar = jiffies - dev->trans_start;
 921                 int recbuf=lp->recbuf;
 922                 int status=inb(STATUS);
 923                 
 924                 /* resume any stopped tx's */
 925 #if 0
 926                 if (lp->txready && (inb(STATUS)&TXFREEflag))
 927                 {
 928                         printk("arcnet: kickme: starting a TX (status=%Xh)\n",
 929                                 inb(STATUS));
 930                         arcnet_go_tx(dev);
 931                         lp->intx--;
 932                         return 1;
 933                 }
 934 #endif
 935                 
 936                 if (tickssofar < 5) 
 937                 {
 938                         BUGLVL(D_DURING)
 939                                 printk("arcnet: premature kickme! (status=%Xh ticks=%d o.skb=%ph numsegs=%d segnum=%d\n",
 940                                         status,tickssofar,lp->outgoing.skb,
 941                                         lp->outgoing.numsegs,
 942                                         lp->outgoing.segnum);
 943                         lp->intx--;
 944                         return 1;
 945                 }
 946 
 947                 BUGLVL(D_INIT)
 948                         printk("arcnet: transmit timed out (status=%Xh, inTX=%d, tickssofar=%d)\n",
 949                                 status,lp->intx,tickssofar);
 950 
 951                 /* Try to restart the adaptor. */
 952                 /*arcnet_reset(dev);*/
 953                 
 954                 if (status&NORXflag) EnableReceiver();
 955                 if (!(status&TXFREEflag)) outb(NOTXcmd,COMMAND);
 956                 dev->trans_start = jiffies;
 957 
 958                 if (lp->outgoing.skb)
 959                         dev_kfree_skb(lp->outgoing.skb,FREE_WRITE);
 960                 lp->outgoing.skb=NULL;
 961 
 962                 dev->tbusy=0;
 963                 mark_bh(NET_BH);
 964                 lp->intx=0;
 965                 lp->in_txhandler=0;
 966                 lp->txready=0;
 967                 lp->sending=0;
 968 
 969                 return 1;
 970         }
 971 
 972         /* If some higher layer thinks we've missed a tx-done interrupt
 973            we are passed NULL. Caution: dev_tint() handles the cli()/sti()
 974            itself. */
 975         if (skb == NULL) {
 976                 BUGLVL(D_INIT)
 977                         printk("arcnet: tx passed null skb (status=%Xh, inTX=%d, tickssofar=%ld)\n",
 978                                 inb(STATUS),lp->intx,jiffies-dev->trans_start);
 979                 dev_tint(dev);
 980                 lp->intx--;
 981                 return 0;
 982         }
 983         
 984         if (lp->txready)        /* transmit already in progress! */
 985         {
 986                 printk("arcnet: trying to start new packet while busy!\n");
 987                 printk("arcnet: marking as not ready.\n");
 988                 lp->txready=0;
 989                 return 1;
 990         }
 991 
 992         /* Block a timer-based transmit from overlapping.  This could better be
 993            done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
 994         if (set_bit(0, (void*)&dev->tbusy) != 0)
 995         {
 996             printk("arcnet: transmitter called with busy bit set! (status=%Xh, inTX=%d, tickssofar=%ld)\n",
 997                         inb(STATUS),lp->intx,jiffies-dev->trans_start);
 998             lp->intx--;
 999             return -EBUSY;
1000         }
1001         else {
1002                 struct Outgoing *out=&(lp->outgoing);
1003                 out->length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
1004                 out->hdr=(struct ClientData*)skb->data;
1005                 out->skb=skb;
1006 
1007 #ifdef IRQ_XMIT
1008                 if (lp->txready && inb(STATUS)&TXFREEflag)
1009                         arcnet_go_tx(dev);
1010 #endif
1011 
1012                 
1013                 if (out->length<=XMTU)  /* fits in one packet? */
1014                 {
1015                         BUGLVL(D_TX) printk("arcnet: not splitting %d-byte packet. (split_flag=%d)\n",
1016                                         out->length,out->hdr->split_flag);
1017                         BUGLVL(D_INIT) if (out->hdr->split_flag)
1018                                 printk("arcnet: short packet has split_flag set?! (split_flag=%d)\n",
1019                                         out->hdr->split_flag);
1020                         out->numsegs=1;
1021                         out->segnum=1;
1022                         arcnet_prepare_tx(dev,out->hdr,
1023                                 out->length-sizeof(struct ClientData),
1024                                 ((char *)skb->data)+sizeof(struct ClientData));
1025                         careful_xmit_wait(dev);
1026 
1027                         /* done right away */
1028                         dev_kfree_skb(out->skb,FREE_WRITE);
1029                         out->skb=NULL;
1030                                         
1031                         if (!lp->sending)
1032                         {
1033                                 arcnet_go_tx(dev);
1034                                 
1035                                 /* inform upper layers */
1036                                 dev->tbusy=0;
1037                                 mark_bh(NET_BH);
1038                         }
1039                 }
1040                 else                    /* too big for one - split it */
1041                 {
1042                         int maxsegsize=XMTU-sizeof(struct ClientData);
1043 
1044                         out->data=(u_char *)skb->data
1045                                         + sizeof(struct ClientData);
1046                         out->dataleft=out->length-sizeof(struct ClientData);
1047                         out->numsegs=(out->dataleft+maxsegsize-1)/maxsegsize;
1048                                 
1049                         out->segnum=0;
1050                                 
1051                         BUGLVL(D_TX) printk("arcnet: packet (%d bytes) split into %d fragments:\n",
1052                                 out->length,out->numsegs);
1053 
1054 #ifdef IRQ_XMIT
1055                         /* if a packet waiting, launch it */
1056                         if (lp->txready && inb(STATUS)&TXFREEflag)
1057                                 arcnet_go_tx(dev);
1058 
1059                         if (!lp->txready)
1060                         {
1061                                 /* prepare a packet, launch it and prepare
1062                                  * another.
1063                                  */
1064                                 arcnet_continue_tx(dev);
1065                                 if (!lp->sending)
1066                                 {
1067                                         arcnet_go_tx(dev);
1068                                         arcnet_continue_tx(dev);
1069                                         if (!lp->sending)
1070                                                 arcnet_go_tx(dev);
1071                                 }
1072                         }
1073                         
1074                         /* if segnum==numsegs, the transmission is finished;
1075                          * free the skb right away.
1076                          */
1077                         if (out->segnum==out->numsegs)
1078                         {
1079                                 /* transmit completed */
1080                                 out->segnum++;
1081                                 if (out->skb)
1082                                         dev_kfree_skb(out->skb,FREE_WRITE);
1083                                 out->skb=NULL;
1084 #if 0
1085                                 /* inform upper layers */
1086                                 dev->tbusy=0;
1087                                 mark_bh(NET_BH);
1088 #endif
1089                         }
1090                         
1091 #else /* non-irq xmit */
1092                         while (out->segnum<out->numsegs)
1093                         {
1094                                 arcnet_continue_tx(dev);
1095                                 careful_xmit_wait(dev);
1096                                 arcnet_go_tx(dev);
1097                                 dev->trans_start=jiffies;
1098                         }
1099 
1100                         dev_kfree_skb(out->skb,FREE_WRITE);
1101                         out->skb=NULL;
1102 
1103                         /* inform upper layers */
1104                         dev->tbusy = 0;
1105                         mark_bh(NET_BH);
1106 #endif
1107                 }
1108         }
1109 
1110         lp->intx--;
1111         lp->stats.tx_packets++;
1112         dev->trans_start=jiffies;
1113         return 0;
1114 }
1115 
1116 static void arcnet_continue_tx(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1117 {
1118         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1119         int maxsegsize=XMTU-sizeof(struct ClientData);
1120         struct Outgoing *out=&(lp->outgoing);
1121         
1122         if (lp->txready)
1123         {
1124                 printk("arcnet: continue_tx: called with packet in buffer!\n");
1125                 return;
1126         }
1127 
1128         if (out->segnum>=out->numsegs)
1129         {
1130                 printk("arcnet: continue_tx: building segment %d of %d!\n",
1131                         out->segnum+1,out->numsegs);
1132         }
1133 
1134         if (!out->segnum)       /* first packet */
1135                 out->hdr->split_flag=((out->numsegs-2)<<1)+1;
1136         else
1137                 out->hdr->split_flag=out->segnum<<1;
1138 
1139         out->seglen=maxsegsize;
1140         if (out->seglen>out->dataleft) out->seglen=out->dataleft;
1141                         
1142         BUGLVL(D_TX) printk("arcnet: building packet #%d (%d bytes) of %d (%d total), splitflag=%d\n",
1143                 out->segnum+1,out->seglen,out->numsegs,
1144                 out->length,out->hdr->split_flag);
1145 
1146         arcnet_prepare_tx(dev,out->hdr,out->seglen,out->data);
1147                 
1148         out->dataleft-=out->seglen;
1149         out->data+=out->seglen;
1150         out->segnum++;
1151 }
1152 
1153 #ifdef CAREFUL_XMIT
1154 static void careful_xmit_wait(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1155 {
1156         int ioaddr=dev->base_addr;
1157         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1158 
1159         /* wait patiently for tx to become available again */
1160         while ( !(inb(STATUS)&TXFREEflag) )
1161         {
1162                 if (jiffies-dev->trans_start > 20 || !dev->tbusy)
1163                 {
1164                         BUGLVL(D_INIT)
1165                                 printk("arcnet: CAREFUL_XMIT timeout. (busy=%d, status=%Xh)\n",
1166                                         dev->tbusy,inb(STATUS));
1167                         lp->stats.tx_errors++;
1168                         
1169                         outb(NOTXcmd,COMMAND);
1170                         return;
1171                 }
1172         }
1173         BUGLVL(D_TX) printk("arcnet: transmit completed successfully. (status=%Xh)\n",
1174                                 inb(STATUS));
1175 }
1176 #endif
1177 
1178 static void
1179 arcnet_prepare_tx(struct device *dev,struct ClientData *hdr,short length,
     /* [previous][next][first][last][top][bottom][index][help] */
1180                 char *data)
1181 {
1182 /*      int ioaddr = dev->base_addr;*/
1183         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1184         struct ClientData *arcsoft;
1185         union ArcPacket *arcpacket = 
1186                 (union ArcPacket *)(dev->mem_start+512*(lp->txbuf^1));
1187         u_char pkttype;
1188         int offset;
1189         short daddr;
1190         
1191         lp->txbuf=lp->txbuf^1;  /* XOR with 1 to alternate between 2 and 3 */
1192         
1193         length+=sizeof(struct ClientData);
1194 
1195         BUGLVL(D_TX)
1196                 printk("arcnet: arcnet_prep_tx: hdr:%ph, length:%d, data:%ph\n",
1197                         hdr,length,data);
1198 
1199         /* clean out the page to make debugging make more sense :) */
1200         BUGLVL(D_DURING)
1201                 memset((void *)dev->mem_start+lp->txbuf*512,0x42,512);
1202 
1203         daddr=arcpacket->hardheader.destination=hdr->daddr;
1204 
1205         /* load packet into shared memory */
1206         if (length<=MTU)        /* Normal (256-byte) Packet */
1207         {
1208                 pkttype=NORMAL;
1209                         
1210                 arcpacket->hardheader.offset1=offset=256-length
1211                                 + EXTRA_CLIENTDATA;
1212                 arcsoft=(struct ClientData *)
1213                         (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1214         }
1215         else if (length>=MinTU) /* Extended (512-byte) Packet */
1216         {
1217                 pkttype=EXTENDED;
1218                 
1219                 arcpacket->hardheader.offset1=0;
1220                 arcpacket->hardheader.offset2=offset=512-length
1221                         + EXTRA_CLIENTDATA;
1222                 arcsoft=(struct ClientData *)
1223                         (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1224         }
1225         else                            /* Exception Packet */
1226         {
1227                 pkttype=EXCEPTION;
1228                 
1229                 arcpacket->hardheader.offset1=0;
1230                 arcpacket->hardheader.offset2=offset=512-length-4
1231                         + EXTRA_CLIENTDATA;
1232                 arcsoft=(struct ClientData *)
1233                         (&arcpacket->raw[offset+4-EXTRA_CLIENTDATA]);
1234                 
1235                 /* exception-specific stuff - these four bytes
1236                  * make the packet long enough to fit in a 512-byte
1237                  * frame.
1238                  */
1239                 arcpacket->raw[offset+0]=arcsoft->protocol_id;
1240                 arcpacket->raw[offset+1]=0xFF; /* FF flag */
1241                         arcpacket->raw[offset+2]=0xFF; /* FF padding */
1242                         arcpacket->raw[offset+3]=0xFF; /* FF padding */
1243         }
1244 
1245 
1246         /* copy the packet into ARCnet shmem
1247          *  - the first bytes of ClientData header are skipped
1248          */
1249         memcpy((u_char*)arcsoft+EXTRA_CLIENTDATA,
1250                 (u_char*)hdr+EXTRA_CLIENTDATA,
1251                 sizeof(struct ClientData)-EXTRA_CLIENTDATA);
1252         memcpy((u_char*)arcsoft+sizeof(struct ClientData),
1253                 data,
1254                 length-sizeof(struct ClientData));
1255                 
1256         BUGLVL(D_DURING) printk("arcnet: transmitting packet to station %02Xh (%d bytes, type=%d)\n",
1257                         daddr,length,pkttype);
1258                         
1259         BUGLVL(D_TX)
1260         {
1261                 int countx,county;
1262                 
1263                 printk("arcnet: packet dump [tx] follows:");
1264 
1265                 for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1266                 {
1267                         printk("\n[%04X] ",county*16);
1268                         for (countx=0; countx<16; countx++)
1269                                 printk("%02X ",
1270                                         arcpacket->raw[county*16+countx]);
1271                 }
1272                 
1273                 printk("\n");
1274         }
1275 #ifdef CAREFUL_XMIT
1276  #if 0
1277         careful_xmit_wait(dev);
1278 
1279         /* if we're not broadcasting, make sure the xmit was ack'd.
1280          * if it wasn't, there is probably no card with that
1281          * address... or else it missed our tx somehow.
1282          */
1283         if (daddr && !(inb(STATUS)&TXACKflag))
1284         {       
1285                 BUGLVL(D_INIT)
1286                         printk("arcnet: transmit not acknowledged. (status=%Xh, daddr=%02Xh)\n",
1287                                 inb(STATUS),daddr);
1288                 lp->stats.tx_errors++;
1289                 return -ENONET; /* "machine is not on the network" */
1290         }
1291  #endif
1292 #endif
1293         lp->txready=lp->txbuf;  /* packet is ready for sending */
1294 
1295 #if 0
1296 #ifdef IRQ_XMIT
1297         if (inb(STATUS)&TXFREEflag) arcnet_go_tx(dev);
1298 #endif
1299 #endif
1300 }
1301 
1302 static void
1303 arcnet_go_tx(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1304 {
1305         struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
1306         int ioaddr=dev->base_addr;
1307 
1308         BUGLVL(D_DURING)
1309                 printk("arcnet: go_tx: status=%Xh\n",
1310                         inb(STATUS));
1311         
1312         if (!(inb(STATUS)&TXFREEflag) || !lp->txready) return;
1313 
1314         /* start sending */
1315         outb(TXcmd|(lp->txready<<3),COMMAND);
1316 
1317 #ifdef IRQ_XMIT
1318         outb(TXFREEflag|NORXflag,INTMASK);
1319 #endif
1320 
1321         dev->trans_start = jiffies;
1322         lp->txready=0;
1323         lp->sending++;
1324 }
1325 
1326 
1327 /* The typical workload of the driver:
1328    Handle the network interface interrupts. */
1329 static void
1330 arcnet_interrupt(int irq,struct pt_regs *regs)
     /* [previous][next][first][last][top][bottom][index][help] */
1331 {
1332         struct device *dev = (struct device *)(irq2dev_map[irq]);
1333 
1334         if (dev == NULL) {
1335                 if (net_debug >= D_DURING)
1336                         printk("arcnet: irq %d for unknown device.\n", irq);
1337                 return;
1338         }
1339         
1340         arcnet_inthandler(dev);
1341 }
1342 
1343 static void
1344 arcnet_inthandler(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1345 {       
1346         struct arcnet_local *lp;
1347         int ioaddr, status, boguscount = 3, didsomething;
1348         
1349         dev->interrupt = 1;
1350         sti();
1351 
1352         ioaddr = dev->base_addr;
1353         lp = (struct arcnet_local *)dev->priv;
1354 
1355 #ifdef IRQ_XMIT
1356         outb(0,INTMASK);
1357 #endif
1358         
1359         BUGLVL(D_DURING)
1360                 printk("arcnet: in net_interrupt (status=%Xh)\n",inb(STATUS));
1361 
1362         do
1363         {
1364                 status = inb(STATUS);
1365                 didsomething=0;
1366         
1367                 if (!dev->start)
1368                 {
1369                         BUGLVL(D_EXTRA)
1370                                 printk("arcnet: ARCnet not yet initialized.  irq ignored. (status=%Xh)\n",
1371                                         status);
1372 #ifdef IRQ_XMIT
1373                         if (!(status&NORXflag))
1374                                 outb(NORXflag,INTMASK);
1375 #endif
1376                         dev->interrupt=0;
1377                         return;
1378                 }
1379         
1380                 /* RESET flag was enabled - card is resetting and if RX
1381                  * is disabled, it's NOT because we just got a packet.
1382                  */
1383                 if (status & RESETflag)
1384                 {
1385                         BUGLVL(D_INIT)
1386                                 printk("arcnet: reset irq (status=%Xh)\n",
1387                                         status);
1388                         dev->interrupt=0;
1389                         return;
1390                 }
1391 
1392 #if 1   /* yes, it's silly to disable this part but it makes good testing */
1393                 /* RX is inhibited - we must have received something. */
1394                 if (status & NORXflag)
1395                 {
1396                         int recbuf=lp->recbuf=!lp->recbuf;
1397 
1398                         BUGLVL(D_DURING)
1399                                 printk("arcnet: receive irq (status=%Xh)\n",
1400                                         status);
1401 
1402                         /* enable receive of our next packet */
1403                         EnableReceiver();
1404                 
1405                         /* Got a packet. */
1406                         arcnet_rx(dev,!recbuf);
1407                         
1408                         didsomething++;
1409                 }
1410 #endif
1411 #ifdef IRQ_XMIT
1412                 /* it can only be an xmit-done irq if we're xmitting :) */
1413                 if (status&TXFREEflag && !lp->in_txhandler && lp->sending)
1414                 {
1415                         struct Outgoing *out=&(lp->outgoing);
1416                         
1417                         lp->in_txhandler++;
1418                         lp->sending--;
1419                         
1420                         BUGLVL(D_DURING)
1421                                 printk("arcnet: TX IRQ (stat=%Xh, numsegs=%d, segnum=%d, skb=%ph)\n",
1422                                         status,out->numsegs,out->segnum,out->skb);
1423                                         
1424                         /* send packet if there is one */
1425                         if (lp->txready)
1426                         {
1427                                 arcnet_go_tx(dev);
1428                                 didsomething++;
1429                         }
1430                         
1431                         if (lp->intx)
1432                         {
1433                                 lp->in_txhandler--;
1434                                 continue;
1435                         }
1436 
1437                         if (!lp->outgoing.skb)
1438                         {
1439                                 BUGLVL(D_DURING)
1440                                         printk("arcnet: TX IRQ done: no split to continue.\n");
1441                                 
1442                                 /* inform upper layers */
1443                                 if (!lp->txready && dev->tbusy)
1444                                 {
1445                                         dev->tbusy=0;
1446                                         mark_bh(NET_BH);
1447                                 }
1448                                 
1449                                 lp->in_txhandler--;
1450                                 continue;
1451                         }
1452                         
1453                         /*lp->stats.tx_packets++;*/
1454                         
1455                         /* if more than one segment, and not all segments
1456                          * are done, then continue xmit.
1457                          */
1458                         if (out->segnum<out->numsegs)
1459                                 arcnet_continue_tx(dev);
1460                         if (lp->txready && !lp->sending)
1461                                 arcnet_go_tx(dev);
1462 
1463                         /* if segnum==numsegs, the transmission is finished;
1464                          * free the skb.
1465                          */
1466                         if (out->segnum>=out->numsegs)
1467                         {
1468                                 /* transmit completed */
1469                                 out->segnum++;
1470                                 if (out->skb)
1471                                         dev_kfree_skb(out->skb,FREE_WRITE);
1472                                 out->skb=NULL;
1473 
1474                                 /* inform upper layers */
1475                                 if (!lp->txready && dev->tbusy)
1476                                 {
1477                                         dev->tbusy=0;
1478                                         mark_bh(NET_BH);
1479                                 }
1480                         }
1481                         didsomething++;
1482                         
1483                         lp->in_txhandler--;
1484                 }
1485 #endif /* IRQ_XMIT */
1486         } while (--boguscount && didsomething);
1487 
1488         BUGLVL(D_DURING)
1489                 printk("arcnet: net_interrupt complete (status=%Xh)\n",
1490                         inb(STATUS));
1491 
1492 #ifdef IRQ_XMIT
1493         if (dev->start && lp->sending )
1494                 outb(NORXflag|TXFREEflag,INTMASK);
1495         else
1496                 outb(NORXflag,INTMASK);
1497 #endif
1498 
1499         dev->interrupt=0;
1500 }
1501 
1502 /* A packet has arrived; grab it from the buffers and possibly unsplit it.
1503  */
1504 static void
1505 arcnet_rx(struct device *dev,int recbuf)
     /* [previous][next][first][last][top][bottom][index][help] */
1506 {
1507         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1508         int ioaddr = dev->base_addr;
1509 /*      int status = inb(STATUS);*/
1510 
1511         struct sk_buff *skb;
1512 
1513         union ArcPacket *arcpacket=
1514                 (union ArcPacket *)(dev->mem_start+recbuf*512);
1515         struct ClientData *soft,*arcsoft;
1516         short length,offset;
1517         u_char pkttype,daddr,saddr;
1518 
1519         daddr=arcpacket->hardheader.destination;
1520         saddr=arcpacket->hardheader.source;
1521         
1522         /* if source is 0, it's not a "used" packet! */
1523         if (saddr==0)
1524         {
1525                 /*BUGLVL(D_DURING)*/
1526                         printk("arcnet: discarding old packet. (status=%Xh)\n",
1527                                 inb(STATUS));
1528                 lp->stats.rx_errors++;
1529                 return;
1530         }
1531         arcpacket->hardheader.source=0;
1532         
1533         if (arcpacket->hardheader.offset1) /* Normal Packet */
1534         {
1535                 offset=arcpacket->hardheader.offset1;
1536                 arcsoft=(struct ClientData *)
1537                         (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1538                 length=256-offset+EXTRA_CLIENTDATA;
1539                 pkttype=NORMAL;
1540         }
1541         else            /* ExtendedPacket or ExceptionPacket */
1542         {
1543                 offset=arcpacket->hardheader.offset2;
1544                 arcsoft=(struct ClientData *)
1545                         (&arcpacket->raw[offset-EXTRA_CLIENTDATA]);
1546 
1547                 if (arcsoft->split_flag!=0xFF)  /* Extended Packet */
1548                 {
1549                         length=512-offset+EXTRA_CLIENTDATA;
1550                         pkttype=EXTENDED;
1551                 }
1552                 else                            /* Exception Packet */
1553                 {
1554                         /* skip over 4-byte junkola */
1555                         arcsoft=(struct ClientData *)
1556                                 ((u_char *)arcsoft + 4);
1557                         length=512-offset+EXTRA_CLIENTDATA-4;
1558                         pkttype=EXCEPTION;
1559                 }
1560         }
1561         
1562         if (!arcsoft->split_flag)               /* not split */
1563         {
1564                 struct Incoming *in=&lp->incoming[saddr];
1565 
1566                 BUGLVL(D_RX) printk("arcnet: incoming is not split (splitflag=%d)\n",
1567                         arcsoft->split_flag);
1568                         
1569                 if (in->skb)    /* already assembling one! */
1570                 {
1571                         BUGLVL(D_INIT) printk("arcnet: aborting assembly (seq=%d) for unsplit packet (splitflag=%d, seq=%d)\n",
1572                                 in->sequence,arcsoft->split_flag,
1573                                 arcsoft->sequence);
1574                         kfree_skb(in->skb,FREE_WRITE);
1575                         in->skb=NULL;
1576                 }
1577                 
1578                 in->sequence=arcsoft->sequence;
1579 
1580                 skb = alloc_skb(length, GFP_ATOMIC);
1581                 if (skb == NULL) {
1582                         printk("%s: Memory squeeze, dropping packet.\n", 
1583                                 dev->name);
1584                         lp->stats.rx_dropped++;
1585                         return;
1586                 }
1587                 soft=(struct ClientData *)skb->data;
1588                 
1589                 skb->len = length;
1590                 skb->dev = dev;
1591                 
1592                 memcpy((u_char *)soft+EXTRA_CLIENTDATA,
1593                         (u_char *)arcsoft+EXTRA_CLIENTDATA,
1594                         length-EXTRA_CLIENTDATA);
1595                 soft->daddr=daddr;
1596                 
1597                 BUGLVL(D_DURING)
1598                         printk("arcnet: received packet from %02Xh to %02Xh (%d bytes, type=%d)\n",
1599                                 saddr,daddr,length,pkttype);
1600                 BUGLVL(D_RX)
1601                 {
1602                         int countx,county;
1603                         
1604                         printk("arcnet: packet dump [rx-unsplit] follows:");
1605 
1606                         for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1607                         {
1608                                 printk("\n[%04X] ",county*16);
1609                                 for (countx=0; countx<16; countx++)
1610                                         printk("%02X ",
1611                                                 arcpacket->raw[county*16+countx]);
1612                         }
1613                         
1614                         printk("\n");
1615                 }
1616 
1617                 /* ARP packets have problems when sent from DOS.
1618                  * source address is always 0!  So we take the hardware
1619                  * source addr (which is impossible to fumble) and insert
1620                  * it ourselves.
1621                  */
1622                 if (soft->protocol_id == ARC_P_ARP)
1623                 {
1624                         struct arphdr *arp=(struct arphdr *)
1625                                         ((char *)soft+sizeof(struct ClientData));
1626 
1627                         /* make sure addresses are the right length */
1628                         if (arp->ar_hln==1 && arp->ar_pln==4)
1629                         {
1630                                 char *cptr=(char *)(arp)+sizeof(struct arphdr);
1631                                 
1632                                 if (!*cptr)     /* is saddr = 00? */
1633                                 {
1634                                         BUGLVL(D_DURING)
1635                                                 printk("arcnet: ARP source address was 00h, set to %02Xh.\n",
1636                                                         saddr);
1637                                         *cptr=saddr;
1638                                 }
1639                                 else BUGLVL(D_DURING) 
1640                                 {
1641                                         printk("arcnet: ARP source address (%Xh) is fine.\n",
1642                                                 *cptr);
1643                                 }
1644                         }
1645                         else
1646                         {
1647                                 printk("arcnet: funny-shaped ARP packet. (%Xh, %Xh)\n",
1648                                         arp->ar_hln,arp->ar_pln);
1649                         }
1650                 }
1651 
1652                 netif_rx(skb);
1653                 lp->stats.rx_packets++;
1654          }
1655          else                   /* split packet */
1656          {
1657                  /* NOTE:  MSDOS ARP packet correction should only need to
1658                   * apply to unsplit packets, since ARP packets are so short.
1659                   *
1660                   * My interpretation of the RFC1201 (ARCnet) document is that
1661                   * if a packet is received out of order, the entire assembly
1662                   * process should be aborted.
1663                   *
1664                   * The RFC also mentions "it is possible for successfully
1665                   * received packets to be retransmitted."  As of 0.40 all
1666                   * previously received packets are allowed, not just the
1667                   * most recent one.
1668                   *
1669                   * We allow multiple assembly processes, one for each
1670                   * ARCnet card possible on the network.  Seems rather like
1671                   * a waste of memory.  Necessary?
1672                   */
1673                   
1674                 struct Incoming *in=&lp->incoming[saddr];
1675                 
1676                 BUGLVL(D_RX) printk("arcnet: packet is split (splitflag=%d, seq=%d)\n",
1677                         arcsoft->split_flag,in->sequence);
1678 
1679                 if (in->skb && in->sequence!=arcsoft->sequence)
1680                 {
1681                         BUGLVL(D_INIT) printk("arcnet: wrong seq number, aborting assembly (expected=%d, seq=%d, splitflag=%d)\n",      
1682                                 in->sequence,arcsoft->sequence,
1683                                 arcsoft->split_flag);
1684                         kfree_skb(in->skb,FREE_WRITE);
1685                         in->skb=NULL;
1686                         in->lastpacket=in->numpackets=0;
1687                 }
1688                   
1689                 if (arcsoft->split_flag & 1)    /* first packet in split */
1690                 {
1691                         BUGLVL(D_RX) printk("arcnet: brand new splitpacket (splitflag=%d)\n",
1692                                 arcsoft->split_flag);
1693                         if (in->skb)    /* already assembling one! */
1694                         {
1695                                 BUGLVL(D_INIT) printk("arcnet: aborting previous (seq=%d) assembly (splitflag=%d, seq=%d)\n",
1696                                         in->sequence,arcsoft->split_flag,
1697                                         arcsoft->sequence);
1698                                 kfree_skb(in->skb,FREE_WRITE);
1699                         }
1700 
1701                         in->sequence=arcsoft->sequence;
1702                         in->numpackets=((unsigned)arcsoft->split_flag>>1)+2;
1703                         in->lastpacket=1;
1704                         
1705                         if (in->numpackets>16)
1706                         {
1707                                 printk("arcnet: incoming packet more than 16 segments; dropping. (splitflag=%d)\n",
1708                                         arcsoft->split_flag);
1709                                 lp->stats.rx_dropped++;
1710                                 return;
1711                         }
1712                 
1713                         in->skb=skb=alloc_skb(508*in->numpackets
1714                                         + sizeof(struct ClientData),
1715                                         GFP_ATOMIC);
1716                         if (skb == NULL) {
1717                                 printk("%s: (split) memory squeeze, dropping packet.\n", 
1718                                         dev->name);
1719                                 lp->stats.rx_dropped++;
1720                                 return;
1721                         }
1722                                         
1723                         /* I don't know what this is for, but it DOES avoid
1724                          * warnings...
1725                          */
1726                         skb->free=1;
1727                         
1728                         if (skb==NULL)
1729                         {
1730                                 printk("%s: Memory squeeze, dropping packet.\n", 
1731                                         dev->name);
1732                                 lp->stats.rx_dropped++;
1733                                 return;
1734                         }
1735                         soft=(struct ClientData *)skb->data;
1736                         
1737                         skb->len=sizeof(struct ClientData);
1738                         skb->dev=dev;
1739 
1740                         memcpy((u_char *)soft+EXTRA_CLIENTDATA,
1741                                 (u_char *)arcsoft+EXTRA_CLIENTDATA,
1742                                 sizeof(struct ClientData)-EXTRA_CLIENTDATA);
1743                         soft->split_flag=0; /* final packet won't be split */
1744                 }
1745                 else                    /* not first packet */
1746                 {
1747                         int packetnum=((unsigned)arcsoft->split_flag>>1) + 1;
1748 
1749                         /* if we're not assembling, there's no point
1750                          * trying to continue.
1751                          */                     
1752                         if (!in->skb)
1753                         {
1754                                 BUGLVL(D_INIT) printk("arcnet: can't continue split without starting first! (splitflag=%d, seq=%d)\n",
1755                                         arcsoft->split_flag,arcsoft->sequence);
1756                                 return;
1757                         }
1758 
1759                         in->lastpacket++;
1760                         if (packetnum!=in->lastpacket) /* not the right flag! */
1761                         {
1762                                 /* harmless duplicate? ignore. */
1763                                 if (packetnum<=in->lastpacket-1)
1764                                 {
1765                                         BUGLVL(D_INIT) printk("arcnet: duplicate splitpacket ignored! (splitflag=%d)\n",
1766                                                 arcsoft->split_flag);
1767                                         return;
1768                                 }
1769                                 
1770                                 /* "bad" duplicate, kill reassembly */
1771                                 BUGLVL(D_INIT) printk("arcnet: out-of-order splitpacket, reassembly (seq=%d) aborted (splitflag=%d, seq=%d)\n", 
1772                                         in->sequence,arcsoft->split_flag,
1773                                         arcsoft->sequence);
1774                                 kfree_skb(in->skb,FREE_WRITE);
1775                                 in->skb=NULL;
1776                                 in->lastpacket=in->numpackets=0;
1777                                 return;
1778                         }
1779 
1780                         soft=(struct ClientData *)in->skb->data;
1781                 }
1782                 
1783                 skb=in->skb;
1784                 
1785                 memcpy(skb->data+skb->len,
1786                        (u_char *)arcsoft+sizeof(struct ClientData),
1787                        length-sizeof(struct ClientData));
1788 
1789                 skb->len+=length-sizeof(struct ClientData);
1790                 
1791                 soft->daddr=daddr;
1792                 
1793                 BUGLVL(D_DURING)
1794                         printk("arcnet: received packet from %02Xh to %02Xh (%d bytes, type=%d)\n",
1795                                 saddr,daddr,length,pkttype);
1796                 BUGLVL(D_RX)
1797                 {
1798                         int countx,county;
1799                         
1800                         printk("arcnet: packet dump [rx-split] follows:");
1801 
1802                         for (county=0; county<16+(pkttype!=NORMAL)*16; county++)
1803                         {
1804                                 printk("\n[%04X] ",county*16);
1805                                 for (countx=0; countx<16; countx++)
1806                                         printk("%02X ",
1807                                                 arcpacket->raw[county*16+countx]);
1808                         }
1809                         
1810                         printk("\n");
1811                 }
1812                 
1813                 /* are we done? */
1814                 if (in->lastpacket == in->numpackets)
1815                 {
1816                         if (!skb || !in->skb)
1817                                 printk("arcnet: ?!? done reassembling packet, no skb? (skb=%ph, in->skb=%ph)\n",
1818                                         skb,in->skb);
1819                         in->skb=NULL;
1820                         in->lastpacket=in->numpackets=0;
1821                         netif_rx(skb);
1822                         lp->stats.rx_packets++;
1823                 }
1824          }
1825         
1826         /* If any worth-while packets have been received, dev_rint()
1827            has done a mark_bh(NET_BH) for us and will work on them
1828            when we get to the bottom-half routine. */
1829         /* arcnet: pardon? */
1830 }
1831 
1832 
1833 #ifdef USE_TIMER_HANDLER
1834 /* this function is called every once in a while to make sure the ARCnet
1835  * isn't stuck.
1836  *
1837  * If we miss a receive IRQ, the receiver (and IRQ) is permanently disabled
1838  * and we might never receive a packet again!  This will check if this
1839  * is the case, and if so, re-enable the receiver.
1840  */
1841 static void
1842 arcnet_timer(unsigned long arg)
     /* [previous][next][first][last][top][bottom][index][help] */
1843 {
1844         struct device *dev=(struct device *)arg;
1845         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1846         short ioaddr=dev->base_addr;
1847         int status=inb(STATUS);
1848 
1849         /* if we didn't interrupt the IRQ handler, and RX's are still
1850          * disabled, and we're not resetting the card... then we're stuck!
1851          */
1852         if (!dev->interrupt && dev->start
1853           && status&NORXflag && !status&RESETflag)
1854         {
1855                 BUGLVL(D_INIT)
1856                         printk("arcnet: timer: ARCnet was stuck!  (status=%Xh)\n",
1857                                 status);
1858                 
1859                 arcnet_inthandler(dev);
1860         }
1861 
1862         /* requeue ourselves */
1863         init_timer(&lp->timer);
1864         lp->timer.expires=TIMERval;
1865         add_timer(&lp->timer);
1866 }
1867 #endif
1868 
1869 /* Get the current statistics.  This may be called with the card open or
1870    closed. */
1871 static struct enet_statistics *
1872 arcnet_get_stats(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1873 {
1874         struct arcnet_local *lp = (struct arcnet_local *)dev->priv;
1875 /*      short ioaddr = dev->base_addr;*/
1876 
1877         return &lp->stats;
1878 }
1879 
1880 /* Set or clear the multicast filter for this adaptor.
1881    num_addrs == -1      Promiscuous mode, receive all packets
1882    num_addrs == 0       Normal mode, clear multicast list
1883    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
1884                         best-effort filtering.
1885  */
1886 static void
1887 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /* [previous][next][first][last][top][bottom][index][help] */
1888 {
1889 #if 0     /* no promiscuous mode at all */
1890         struct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
1891 
1892         short ioaddr = dev->base_addr;
1893         if (num_addrs) {
1894                 outw(69, ioaddr);               /* Enable promiscuous mode */
1895         } else
1896                 outw(99, ioaddr);               /* Disable promiscuous mode, use normal mode */
1897 #endif
1898 }
1899 
1900 int arcnet_reset(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
1901 {
1902         struct arcnet_local *lp=(struct arcnet_local *)dev->priv;
1903         short ioaddr=dev->base_addr;
1904         int delayval,recbuf=lp->recbuf;
1905         
1906         outb(0,INTMASK);        /* no IRQ's, please! */
1907         
1908         BUGLVL(D_INIT)
1909                 printk("arcnet: Resetting %s (status=%Xh)\n",
1910                         dev->name,inb(STATUS));
1911 
1912         inb(RESET);             /* Reset by reading this port */
1913         JIFFER(RESETtime);
1914 
1915         outb(CFLAGScmd|RESETclear, COMMAND); /* clear flags & end reset */
1916         outb(CFLAGScmd|CONFIGclear,COMMAND);
1917 
1918         /* after a reset, the first byte of shared mem is TESTvalue and the
1919          * second byte is our 8-bit ARCnet address
1920          */
1921         {
1922                 u_char *cardmem = (u_char *) dev->mem_start;
1923                 if (cardmem[0] != TESTvalue)
1924                 {
1925                         BUGLVL(D_INIT)
1926                                 printk("arcnet: reset failed: TESTvalue not present.\n");
1927                         return 1;
1928                 }
1929                 lp->arcnum=cardmem[1];  /* save address for later use */
1930         }
1931         
1932         /* clear out status variables */
1933         recbuf=lp->recbuf=0;
1934         lp->txbuf=2;
1935         /*dev->tbusy=0;*/
1936 
1937         /* enable extended (512-byte) packets */
1938         outb(CONFIGcmd|EXTconf,COMMAND);
1939         XJIFFER(ACKtime);
1940         
1941         /* clean out all the memory to make debugging make more sense :) */
1942         BUGLVL(D_DURING)
1943                 memset((void *)dev->mem_start,0x42,2048);
1944         
1945         /* and enable receive of our first packet to the first buffer */
1946         EnableReceiver();
1947 
1948         /* re-enable interrupts */
1949         outb(NORXflag,INTMASK);
1950         
1951         /* done!  return success. */
1952         return 0;
1953 }
1954 
1955 
1956 /*
1957  *       Create the ARCnet ClientData header for an arbitrary protocol layer
1958  *
1959  *      saddr=NULL      means use device source address (always will anyway)
1960  *      daddr=NULL      means leave destination address (eg unresolved arp)
1961  */
1962 int arc_header(unsigned char *buff,struct device *dev,unsigned short type,
     /* [previous][next][first][last][top][bottom][index][help] */
1963                 void *daddr,void *saddr,unsigned len,struct sk_buff *skb)
1964 {
1965         struct ClientData *head = (struct ClientData *)buff;
1966         struct arcnet_local *lp=(struct arcnet_local *)(dev->priv);
1967 
1968         /* set the protocol ID according to RFC-1201 */
1969         switch(type)
1970         {
1971         case ETH_P_IP:
1972                 head->protocol_id=ARC_P_IP;
1973                 break;
1974         case ETH_P_ARP:
1975                 head->protocol_id=ARC_P_ARP;
1976                 break;
1977         case ETH_P_RARP:
1978                 head->protocol_id=ARC_P_RARP;
1979                 break;
1980         case ETH_P_IPX:
1981                 head->protocol_id=ARC_P_IPX;
1982                 break;
1983         default:
1984                 printk("arcnet: I don't understand protocol %d (%Xh)\n",
1985                         type,type);
1986                 return 0;
1987         }       
1988 
1989 #if 0
1990         /*
1991          *      Set the source hardware address.
1992          *      AVE: we can't do this, so we don't.  Code below is directly
1993          *           stolen from eth.c driver and won't work.
1994          */
1995         if(saddr)
1996                 memcpy(eth->h_source,saddr,dev->addr_len);
1997         else
1998                 memcpy(eth->h_source,dev->dev_addr,dev->addr_len);
1999 #endif
2000 
2001 #if 0
2002         /*
2003          *      Anyway, the loopback-device should never use this function... 
2004          *
2005          *      And the chances of it using the ARCnet version of it are so
2006          *      tiny that I don't think we have to worry :)
2007          */
2008         if (dev->flags & IFF_LOOPBACK) 
2009         {
2010                 memset(eth->h_dest, 0, dev->addr_len);
2011                 return(dev->hard_header_len);
2012         }
2013 #endif
2014 
2015         head->split_flag=0;     /* split packets are done elsewhere */
2016         head->sequence=(lp->sequence++);
2017 
2018         /* supposedly if daddr is NULL, we should ignore it... */
2019         if(daddr)
2020         {
2021                 head->daddr=((u_char*)daddr)[0];
2022                 return dev->hard_header_len;
2023         }
2024         else
2025                 head->daddr=0;  /* better fill one in anyway */
2026                 
2027         return -dev->hard_header_len;
2028 }
2029 
2030 
2031 /*
2032  *      Rebuild the ARCnet ClientData header. This is called after an ARP
2033  *      (or in future other address resolution) has completed on this
2034  *      sk_buff. We now let ARP fill in the other fields.
2035  */
2036 int arc_rebuild_header(void *buff,struct device *dev,unsigned long dst,
     /* [previous][next][first][last][top][bottom][index][help] */
2037                 struct sk_buff *skb)
2038 {
2039         struct ClientData *head = (struct ClientData *)buff;
2040 
2041         /*
2042          *      Only ARP/IP is currently supported
2043          */
2044          
2045         if(head->protocol_id != ARC_P_IP) 
2046         {
2047                 printk("arcnet: I don't understand resolve type %d (%Xh) addresses!\n",
2048                         head->protocol_id,head->protocol_id);
2049                 head->daddr=0;
2050                 /*memcpy(eth->h_source, dev->dev_addr, dev->addr_len);*/
2051                 return 0;
2052         }
2053 
2054         /*
2055          *      Try and get ARP to resolve the header.
2056          */
2057 #ifdef CONFIG_INET       
2058         return arp_find(&(head->daddr), dst, dev, dev->pa_addr, skb)? 1 : 0;
2059 #else
2060         return 0;       
2061 #endif  
2062 }
2063                 
2064 /*
2065  *      Determine the packet's protocol ID.
2066  *
2067  *      With ARCnet we have to convert everything to Ethernet-style stuff.
2068  */
2069 unsigned short arc_type_trans(struct sk_buff *skb,struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
2070 {
2071         struct ClientData *head = (struct ClientData *) skb->data;
2072         /*unsigned char *rawp;*/
2073         
2074         if (head->daddr==0)
2075                 skb->pkt_type=PACKET_BROADCAST;
2076                 
2077 #if 0 /* code for ethernet with multicast */
2078         if(*eth->h_dest&1)
2079         {
2080                 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0)
2081                         skb->pkt_type=PACKET_BROADCAST;
2082                 else
2083                         skb->pkt_type=PACKET_MULTICAST;
2084         }
2085 #endif
2086         
2087         if(dev->flags&IFF_PROMISC)
2088         {
2089                 /* if we're not sending to ourselves :) */
2090                 if (head->daddr != dev->dev_addr[0])
2091                         skb->pkt_type=PACKET_OTHERHOST;
2092         }
2093         
2094         /* now return the protocol number */
2095         switch (head->protocol_id)
2096         {
2097         case ARC_P_IP:          return htons(ETH_P_IP);
2098         case ARC_P_ARP:         return htons(ETH_P_ARP);
2099         case ARC_P_RARP:        return htons(ETH_P_RARP);
2100         case ARC_P_IPX:         return htons(ETH_P_IPX);
2101         case ARC_P_LANSOFT: /* don't understand.  fall through. */
2102         case ARC_P_ATALK:   /* appletalk - don't understand.  fall through. */
2103         default:
2104                 BUGLVL(D_DURING)
2105                         printk("arcnet: received packet of unknown protocol id %d (%Xh)\n",
2106                                 head->protocol_id,head->protocol_id);
2107                 return 0;
2108         }
2109 
2110 #if 0 /* more ethernet-specific junk */
2111         if (ntohs(eth->h_proto) >= 1536)
2112                 return eth->h_proto;
2113                 
2114         rawp = (unsigned char *)(eth + 1);
2115         
2116         if (*(unsigned short *)rawp == 0xFFFF)
2117                 return htons(ETH_P_802_3);
2118         if (*(unsigned short *)rawp == 0xAAAA)
2119                 return htons(ETH_P_SNAP);
2120                 
2121         return htons(ETH_P_802_2);
2122 #endif
2123 
2124         return htons(ETH_P_IP);
2125 }
2126 
2127 #ifdef MODULE
2128 char kernel_version[] = UTS_RELEASE;
2129 static struct device thisARCnet = {
2130   "      ",/* if blank, device name inserted by /linux/drivers/net/net_init.c */
2131   0, 0, 0, 0,
2132   0, 0,  /* I/O address, IRQ */
2133   0, 0, 0, NULL, arcnet_probe };
2134         
2135         
2136 int io=0x0;     /* <--- EDIT THESE LINES FOR YOUR CONFIGURATION */
2137 int irqnum=0;   /* or use the insmod io= irq= shmem= options */
2138 int shmem=0;
2139 int num=0;      /* number of device (ie for arc0, arc1, arc2...) */
2140 
2141 int
2142 init_module(void)
     /* [previous][next][first][last][top][bottom][index][help] */
2143 {
2144         sprintf(thisARCnet.name,"arc%d",num);
2145 
2146         thisARCnet.base_addr=io;
2147 
2148         thisARCnet.irq=irqnum;
2149         if (thisARCnet.irq==2) thisARCnet.irq=9;
2150 
2151         if (shmem)
2152         {
2153                 thisARCnet.mem_start=shmem;
2154                 thisARCnet.mem_end=thisARCnet.mem_start+512*4-1;
2155                 thisARCnet.rmem_start=thisARCnet.mem_start+512*0;
2156                 thisARCnet.rmem_end=thisARCnet.mem_start+512*2-1;
2157         }
2158 
2159         if (register_netdev(&thisARCnet) != 0)
2160                 return -EIO;
2161         return 0;
2162 }
2163 
2164 void
2165 cleanup_module(void)
     /* [previous][next][first][last][top][bottom][index][help] */
2166 {
2167   if (MOD_IN_USE) {
2168     printk("%s: device busy, remove delayed\n",thisARCnet.name);
2169   } else {
2170     if (thisARCnet.start) arcnet_close(&thisARCnet);
2171     if (thisARCnet.irq) free_irq(thisARCnet.irq);
2172     if (thisARCnet.base_addr) release_region(thisARCnet.base_addr,
2173                                                 ETHERCARD_TOTAL_SIZE);
2174     unregister_netdev(&thisARCnet);
2175   }
2176 }
2177 
2178 #endif /* MODULE */
2179 
2180 
2181 
2182 /*
2183  * Local variables:
2184  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c skeleton.c"
2185  *  version-control: t
2186  *  kept-new-versions: 5
2187  *  tab-width: 4
2188  * End:
2189  */
2190 

/* [previous][next][first][last][top][bottom][index][help] */