drivers/net/appletalk/ltpc.c

   1 /***    ltpc.c -- a driver for the LocalTalk PC card.
   2  *
   3  *      Copyright (c) 1995,1996 Bradford W. Johnson <johns393@maroon.tc.umn.edu>
   4  *
   5  *      This software may be used and distributed according to the terms
   6  *      of the GNU General Public License, incorporated herein by reference.
   7  *
   8  *      This is ALPHA code at best.  It may not work for you.  It may
   9  *      damage your equipment.  It may damage your relations with other
  10  *      users of your network.  Use it at your own risk!
  11  *
  12  *      Based in part on:
  13  *      skeleton.c      by Donald Becker
  14  *      dummy.c         by Nick Holloway and Alan Cox
  15  *      loopback.c      by Ross Biro, Fred van Kampen, Donald Becker
  16  *      the netatalk source code (UMICH)
  17  *      lots of work on the card...
  18  *
  19  *      I do not have access to the (proprietary) SDK that goes with the card.
  20  *      If you do, I don't want to know about it, and you can probably write
  21  *      a better driver yourself anyway.  This does mean that the pieces that
  22  *      talk to the card are guesswork on my part, so use at your own risk!
  23  *
  24  *      This is my first try at writing Linux networking code, and is also
  25  *      guesswork.  Again, use at your own risk!  (Although on this part, I'd
  26  *      welcome suggestions)
  27  *
  28  *      This is a loadable kernel module which seems to work at my site
  29  *      consisting of a 1.2.13 linux box running netatalk 1.3.3, and with
  30  *      the kernel support from 1.3.3b2 including patches routing.patch
  31  *      and ddp.disappears.from.chooser.  In order to run it, you will need
  32  *      to patch ddp.c and aarp.c in the kernel, but only a little...
  33  *
  34  *      I'm fairly confident that while this is arguably badly written, the
  35  *      problems that people experience will be "higher level", that is, with
  36  *      complications in the netatalk code.  The driver itself doesn't do
  37  *      anything terribly complicated -- it pretends to be an ether device
  38  *      as far as netatalk is concerned, strips the DDP data out of the ether
  39  *      frame and builds a LLAP packet to send out the card.  In the other
  40  *      direction, it receives LLAP frames from the card and builds a fake
  41  *      ether packet that it then tosses up to the networking code.  You can
  42  *      argue (correctly) that this is an ugly way to do things, but it
  43  *      requires a minimal amount of fooling with the code in ddp.c and aarp.c.
  44  *
  45  *      The card will do a lot more than is used here -- I *think* it has the
  46  *      layers up through ATP.  Even if you knew how that part works (which I
  47  *      don't) it would be a big job to carve up the kernel ddp code to insert
  48  *      things at a higher level, and probably a bad idea...
  49  *
  50  *      There are a number of other cards that do LocalTalk on the PC.  If
  51  *      nobody finds any insurmountable (at the netatalk level) problems
  52  *      here, this driver should encourage people to put some work into the
  53  *      other cards (some of which I gather are still commercially available)
  54  *      and also to put hooks for LocalTalk into the official ddp code.
  55  *
  56  *      I welcome comments and suggestions.  This is my first try at Linux
  57  *      networking stuff, and there are probably lots of things that I did
  58  *      suboptimally.
  59  *
  60  ***/
  61
  62 /***
  63  *
  64  * $Log: ltpc.c,v $
  65  * Revision 1.1.2.1  2000/03/01 05:35:07  jgarzik
  66  * at and tr cleanup
  67  *
  68  * Revision 1.8  1997/01/28 05:44:54  bradford
  69  * Clean up for non-module a little.
  70  * Hacked about a bit to clean things up - Alan Cox
  71  * Probably broken it from the origina 1.8
  72  *
  73
  74  * 1998/11/09: David Huggins-Daines <dhd@debian.org>
  75  * Cleaned up the initialization code to use the standard autoirq methods,
  76    and to probe for things in the standard order of i/o, irq, dma.  This
  77    removes the "reset the reset" hack, because I couldn't figure out an
  78    easy way to get the card to trigger an interrupt after it.
  79  * Added support for passing configuration parameters on the kernel command
  80    line and through insmod
  81  * Changed the device name from "ltalk0" to "lt0", both to conform with the
  82    other localtalk driver, and to clear up the inconsistency between the
  83    module and the non-module versions of the driver :-)
  84  * Added a bunch of comments (I was going to make some enums for the state
  85    codes and the register offsets, but I'm still not sure exactly what their
  86    semantics are)
  87  * Don't poll anymore in interrupt-driven mode
  88  * It seems to work as a module now (as of 2.1.127), but I don't think
  89    I'm responsible for that...
  90
  91  *
  92  * Revision 1.7  1996/12/12 03:42:33  bradford
  93  * DMA alloc cribbed from 3c505.c.
  94  *
  95  * Revision 1.6  1996/12/12 03:18:58  bradford
  96  * Added virt_to_bus; works in 2.1.13.
  97  *
  98  * Revision 1.5  1996/12/12 03:13:22  root
  99  * xmitQel initialization -- think through better though.
 100  *
 101  * Revision 1.4  1996/06/18 14:55:55  root
 102  * Change names to ltpc. Tabs. Took a shot at dma alloc,
 103  * although more needs to be done eventually.
 104  *
 105  * Revision 1.3  1996/05/22 14:59:39  root
 106  * Change dev->open, dev->close to track dummy.c in 1.99.(around 7)
 107  *
 108  * Revision 1.2  1996/05/22 14:58:24  root
 109  * Change tabs mostly.
 110  *
 111  * Revision 1.1  1996/04/23 04:45:09  root
 112  * Initial revision
 113  *
 114  * Revision 0.16  1996/03/05 15:59:56  root
 115  * Change ARPHRD_LOCALTLK definition to the "real" one.
 116  *
 117  * Revision 0.15  1996/03/05 06:28:30  root
 118  * Changes for kernel 1.3.70.  Still need a few patches to kernel, but
 119  * it's getting closer.
 120  *
 121  * Revision 0.14  1996/02/25 17:38:32  root
 122  * More cleanups.  Removed query to card on get_stats.
 123  *
 124  * Revision 0.13  1996/02/21  16:27:40  root
 125  * Refix debug_print_skb.  Fix mac.raw gotcha that appeared in 1.3.65.
 126  * Clean up receive code a little.
 127  *
 128  * Revision 0.12  1996/02/19  16:34:53  root
 129  * Fix debug_print_skb.  Kludge outgoing snet to 0 when using startup
 130  * range.  Change debug to mask: 1 for verbose, 2 for higher level stuff
 131  * including packet printing, 4 for lower level (card i/o) stuff.
 132  *
 133  * Revision 0.11  1996/02/12  15:53:38  root
 134  * Added router sends (requires new aarp.c patch)
 135  *
 136  * Revision 0.10  1996/02/11  00:19:35  root
 137  * Change source LTALK_LOGGING debug switch to insmod ... debug=2.
 138  *
 139  * Revision 0.9  1996/02/10  23:59:35  root
 140  * Fixed those fixes for 1.2 -- DANGER!  The at.h that comes with netatalk
 141  * has a *different* definition of struct sockaddr_at than the Linux kernel
 142  * does.  This is an "insidious and invidious" bug...
 143  * (Actually the preceding comment is false -- it's the atalk.h in the
 144  * ancient atalk-0.06 that's the problem)
 145  *
 146  * Revision 0.8  1996/02/10 19:09:00  root
 147  * Merge 1.3 changes.  Tested OK under 1.3.60.
 148  *
 149  * Revision 0.7  1996/02/10 17:56:56  root
 150  * Added debug=1 parameter on insmod for debugging prints.  Tried
 151  * to fix timer unload on rmmod, but I don't think that's the problem.
 152  *
 153  * Revision 0.6  1995/12/31  19:01:09  root
 154  * Clean up rmmod, irq comments per feedback from Corin Anderson (Thanks Corey!)
 155  * Clean up initial probing -- sometimes the card wakes up latched in reset.
 156  *
 157  * Revision 0.5  1995/12/22  06:03:44  root
 158  * Added comments in front and cleaned up a bit.
 159  * This version sent out to people.
 160  *
 161  * Revision 0.4  1995/12/18  03:46:44  root
 162  * Return shortDDP to longDDP fake to 0/0.  Added command structs.
 163  *
 164  ***/
 165
 166 /* ltpc jumpers are:
 167 *
 168 *       Interrupts -- set at most one.  If none are set, the driver uses
 169 *       polled mode.  Because the card was developed in the XT era, the
 170 *       original documentation refers to IRQ2.  Since you'll be running
 171 *       this on an AT (or later) class machine, that really means IRQ9.
 172 *
 173 *       SW1     IRQ 4
 174 *       SW2     IRQ 3
 175 *       SW3     IRQ 9 (2 in original card documentation only applies to XT)
 176 *
 177 *
 178 *       DMA -- choose DMA 1 or 3, and set both corresponding switches.
 179 *
 180 *       SW4     DMA 3
 181 *       SW5     DMA 1
 182 *       SW6     DMA 3
 183 *       SW7     DMA 1
 184 *
 185 *
 186 *       I/O address -- choose one.
 187 *
 188 *       SW8     220 / 240
 189 */
 190
 191 /*      To have some stuff logged, do
 192 *       insmod ltpc.o debug=1
 193 *
 194 *       For a whole bunch of stuff, use higher numbers.
 195 *
 196 *       The default is 0, i.e. no messages except for the probe results.
 197 */
 198
 199 /* insmod-tweakable variables */
 200 static int debug;
 201 #define DEBUG_VERBOSE 1
 202 #define DEBUG_UPPER 2
 203 #define DEBUG_LOWER 4
 204
 205 static int io;
 206 static int irq;
 207 static int dma;
 208
 209 #include <linux/module.h>
 210 #include <linux/kernel.h>
 211 #include <linux/types.h>
 212 #include <linux/fcntl.h>
 213 #include <linux/interrupt.h>
 214 #include <linux/ptrace.h>
 215 #include <linux/ioport.h>
 216 #include <linux/spinlock.h>
 217 #include <linux/in.h>
 218 #include <linux/string.h>
 219 #include <linux/errno.h>
 220 #include <linux/init.h>
 221 #include <linux/netdevice.h>
 222 #include <linux/etherdevice.h>
 223 #include <linux/skbuff.h>
 224 #include <linux/if_arp.h>
 225 #include <linux/if_ltalk.h>
 226 #include <linux/delay.h>
 227 #include <linux/timer.h>
 228 #include <linux/atalk.h>
 229 #include <linux/bitops.h>
 230 #include <linux/gfp.h>
 231
 232 #include <asm/system.h>
 233 #include <asm/dma.h>
 234 #include <asm/io.h>
 235
 236 /* our stuff */
 237 #include "ltpc.h"
 238
 239 static DEFINE_SPINLOCK(txqueue_lock);
 240 static DEFINE_SPINLOCK(mbox_lock);
 241
 242 /* function prototypes */
 243 static int do_read(struct net_device *dev, void *cbuf, int cbuflen,
 244         void *dbuf, int dbuflen);
 245 static int sendup_buffer (struct net_device *dev);
 246
 247 /* Dma Memory related stuff, cribbed directly from 3c505.c */
 248
 249 static unsigned long dma_mem_alloc(int size)
 250 {
 251         int order = get_order(size);
 252
 253         return __get_dma_pages(GFP_KERNEL, order);
 254 }
 255
 256 /* DMA data buffer, DMA command buffer */
 257 static unsigned char *ltdmabuf;
 258 static unsigned char *ltdmacbuf;
 259
 260 /* private struct, holds our appletalk address */
 261
 262 struct ltpc_private
 263 {
 264         struct atalk_addr my_addr;
 265 };
 266
 267 /* transmit queue element struct */
 268
 269 struct xmitQel {
 270         struct xmitQel *next;
 271         /* command buffer */
 272         unsigned char *cbuf;
 273         short cbuflen;
 274         /* data buffer */
 275         unsigned char *dbuf;
 276         short dbuflen;
 277         unsigned char QWrite;   /* read or write data */
 278         unsigned char mailbox;
 279 };
 280
 281 /* the transmit queue itself */
 282
 283 static struct xmitQel *xmQhd, *xmQtl;
 284
 285 static void enQ(struct xmitQel *qel)
 286 {
 287         unsigned long flags;
 288         qel->next = NULL;
 289
 290         spin_lock_irqsave(&txqueue_lock, flags);
 291         if (xmQtl) {
 292                 xmQtl->next = qel;
 293         } else {
 294                 xmQhd = qel;
 295         }
 296         xmQtl = qel;
 297         spin_unlock_irqrestore(&txqueue_lock, flags);
 298
 299         if (debug & DEBUG_LOWER)
 300                 printk("enqueued a 0x%02x command\n",qel->cbuf[0]);
 301 }
 302
 303 static struct xmitQel *deQ(void)
 304 {
 305         unsigned long flags;
 306         int i;
 307         struct xmitQel *qel=NULL;
 308
 309         spin_lock_irqsave(&txqueue_lock, flags);
 310         if (xmQhd) {
 311                 qel = xmQhd;
 312                 xmQhd = qel->next;
 313                 if(!xmQhd) xmQtl = NULL;
 314         }
 315         spin_unlock_irqrestore(&txqueue_lock, flags);
 316
 317         if ((debug & DEBUG_LOWER) && qel) {
 318                 int n;
 319                 printk(KERN_DEBUG "ltpc: dequeued command ");
 320                 n = qel->cbuflen;
 321                 if (n>100) n=100;
 322                 for(i=0;i<n;i++) printk("%02x ",qel->cbuf[i]);
 323                 printk("\n");
 324         }
 325
 326         return qel;
 327 }
 328
 329 /* and... the queue elements we'll be using */
 330 static struct xmitQel qels[16];
 331
 332 /* and their corresponding mailboxes */
 333 static unsigned char mailbox[16];
 334 static unsigned char mboxinuse[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 335
 336 static int wait_timeout(struct net_device *dev, int c)
 337 {
 338         /* returns true if it stayed c */
 339         /* this uses base+6, but it's ok */
 340         int i;
 341
 342         /* twenty second or so total */
 343
 344         for(i=0;i<200000;i++) {
 345                 if ( c != inb_p(dev->base_addr+6) ) return 0;
 346                 udelay(100);
 347         }
 348         return 1; /* timed out */
 349 }
 350
 351 /* get the first free mailbox */
 352
 353 static int getmbox(void)
 354 {
 355         unsigned long flags;
 356         int i;
 357
 358         spin_lock_irqsave(&mbox_lock, flags);
 359         for(i=1;i<16;i++) if(!mboxinuse[i]) {
 360                 mboxinuse[i]=1;
 361                 spin_unlock_irqrestore(&mbox_lock, flags);
 362                 return i;
 363         }
 364         spin_unlock_irqrestore(&mbox_lock, flags);
 365         return 0;
 366 }
 367
 368 /* read a command from the card */
 369 static void handlefc(struct net_device *dev)
 370 {
 371         /* called *only* from idle, non-reentrant */
 372         int dma = dev->dma;
 373         int base = dev->base_addr;
 374         unsigned long flags;
 375
 376
 377         flags=claim_dma_lock();
 378         disable_dma(dma);
 379         clear_dma_ff(dma);
 380         set_dma_mode(dma,DMA_MODE_READ);
 381         set_dma_addr(dma,virt_to_bus(ltdmacbuf));
 382         set_dma_count(dma,50);
 383         enable_dma(dma);
 384         release_dma_lock(flags);
 385
 386         inb_p(base+3);
 387         inb_p(base+2);
 388
 389         if ( wait_timeout(dev,0xfc) ) printk("timed out in handlefc\n");
 390 }
 391
 392 /* read data from the card */
 393 static void handlefd(struct net_device *dev)
 394 {
 395         int dma = dev->dma;
 396         int base = dev->base_addr;
 397         unsigned long flags;
 398
 399         flags=claim_dma_lock();
 400         disable_dma(dma);
 401         clear_dma_ff(dma);
 402         set_dma_mode(dma,DMA_MODE_READ);
 403         set_dma_addr(dma,virt_to_bus(ltdmabuf));
 404         set_dma_count(dma,800);
 405         enable_dma(dma);
 406         release_dma_lock(flags);
 407
 408         inb_p(base+3);
 409         inb_p(base+2);
 410
 411         if ( wait_timeout(dev,0xfd) ) printk("timed out in handlefd\n");
 412         sendup_buffer(dev);
 413 }
 414
 415 static void handlewrite(struct net_device *dev)
 416 {
 417         /* called *only* from idle, non-reentrant */
 418         /* on entry, 0xfb and ltdmabuf holds data */
 419         int dma = dev->dma;
 420         int base = dev->base_addr;
 421         unsigned long flags;
 422
 423         flags=claim_dma_lock();
 424         disable_dma(dma);
 425         clear_dma_ff(dma);
 426         set_dma_mode(dma,DMA_MODE_WRITE);
 427         set_dma_addr(dma,virt_to_bus(ltdmabuf));
 428         set_dma_count(dma,800);
 429         enable_dma(dma);
 430         release_dma_lock(flags);
 431
 432         inb_p(base+3);
 433         inb_p(base+2);
 434
 435         if ( wait_timeout(dev,0xfb) ) {
 436                 flags=claim_dma_lock();
 437                 printk("timed out in handlewrite, dma res %d\n",
 438                         get_dma_residue(dev->dma) );
 439                 release_dma_lock(flags);
 440         }
 441 }
 442
 443 static void handleread(struct net_device *dev)
 444 {
 445         /* on entry, 0xfb */
 446         /* on exit, ltdmabuf holds data */
 447         int dma = dev->dma;
 448         int base = dev->base_addr;
 449         unsigned long flags;
 450
 451
 452         flags=claim_dma_lock();
 453         disable_dma(dma);
 454         clear_dma_ff(dma);
 455         set_dma_mode(dma,DMA_MODE_READ);
 456         set_dma_addr(dma,virt_to_bus(ltdmabuf));
 457         set_dma_count(dma,800);
 458         enable_dma(dma);
 459         release_dma_lock(flags);
 460
 461         inb_p(base+3);
 462         inb_p(base+2);
 463         if ( wait_timeout(dev,0xfb) ) printk("timed out in handleread\n");
 464 }
 465
 466 static void handlecommand(struct net_device *dev)
 467 {
 468         /* on entry, 0xfa and ltdmacbuf holds command */
 469         int dma = dev->dma;
 470         int base = dev->base_addr;
 471         unsigned long flags;
 472
 473         flags=claim_dma_lock();
 474         disable_dma(dma);
 475         clear_dma_ff(dma);
 476         set_dma_mode(dma,DMA_MODE_WRITE);
 477         set_dma_addr(dma,virt_to_bus(ltdmacbuf));
 478         set_dma_count(dma,50);
 479         enable_dma(dma);
 480         release_dma_lock(flags);
 481         inb_p(base+3);
 482         inb_p(base+2);
 483         if ( wait_timeout(dev,0xfa) ) printk("timed out in handlecommand\n");
 484 }
 485
 486 /* ready made command for getting the result from the card */
 487 static unsigned char rescbuf[2] = {LT_GETRESULT,0};
 488 static unsigned char resdbuf[2];
 489
 490 static int QInIdle;
 491
 492 /* idle expects to be called with the IRQ line high -- either because of
 493  * an interrupt, or because the line is tri-stated
 494  */
 495
 496 static void idle(struct net_device *dev)
 497 {
 498         unsigned long flags;
 499         int state;
 500         /* FIXME This is initialized to shut the warning up, but I need to
 501          * think this through again.
 502          */
 503         struct xmitQel *q = NULL;
 504         int oops;
 505         int i;
 506         int base = dev->base_addr;
 507
 508         spin_lock_irqsave(&txqueue_lock, flags);
 509         if(QInIdle) {
 510                 spin_unlock_irqrestore(&txqueue_lock, flags);
 511                 return;
 512         }
 513         QInIdle = 1;
 514         spin_unlock_irqrestore(&txqueue_lock, flags);
 515
 516         /* this tri-states the IRQ line */
 517         (void) inb_p(base+6);
 518
 519         oops = 100;
 520
 521 loop:
 522         if (0>oops--) {
 523                 printk("idle: looped too many times\n");
 524                 goto done;
 525         }
 526
 527         state = inb_p(base+6);
 528         if (state != inb_p(base+6)) goto loop;
 529
 530         switch(state) {
 531                 case 0xfc:
 532                         /* incoming command */
 533                         if (debug & DEBUG_LOWER) printk("idle: fc\n");
 534                         handlefc(dev);
 535                         break;
 536                 case 0xfd:
 537                         /* incoming data */
 538                         if(debug & DEBUG_LOWER) printk("idle: fd\n");
 539                         handlefd(dev);
 540                         break;
 541                 case 0xf9:
 542                         /* result ready */
 543                         if (debug & DEBUG_LOWER) printk("idle: f9\n");
 544                         if(!mboxinuse[0]) {
 545                                 mboxinuse[0] = 1;
 546                                 qels[0].cbuf = rescbuf;
 547                                 qels[0].cbuflen = 2;
 548                                 qels[0].dbuf = resdbuf;
 549                                 qels[0].dbuflen = 2;
 550                                 qels[0].QWrite = 0;
 551                                 qels[0].mailbox = 0;
 552                                 enQ(&qels[0]);
 553                         }
 554                         inb_p(dev->base_addr+1);
 555                         inb_p(dev->base_addr+0);
 556                         if( wait_timeout(dev,0xf9) )
 557                                 printk("timed out idle f9\n");
 558                         break;
 559                 case 0xf8:
 560                         /* ?? */
 561                         if (xmQhd) {
 562                                 inb_p(dev->base_addr+1);
 563                                 inb_p(dev->base_addr+0);
 564                                 if(wait_timeout(dev,0xf8) )
 565                                         printk("timed out idle f8\n");
 566                         } else {
 567                                 goto done;
 568                         }
 569                         break;
 570                 case 0xfa:
 571                         /* waiting for command */
 572                         if(debug & DEBUG_LOWER) printk("idle: fa\n");
 573                         if (xmQhd) {
 574                                 q=deQ();
 575                                 memcpy(ltdmacbuf,q->cbuf,q->cbuflen);
 576                                 ltdmacbuf[1] = q->mailbox;
 577                                 if (debug>1) {
 578                                         int n;
 579                                         printk("ltpc: sent command     ");
 580                                         n = q->cbuflen;
 581                                         if (n>100) n=100;
 582                                         for(i=0;i<n;i++)
 583                                                 printk("%02x ",ltdmacbuf[i]);
 584                                         printk("\n");
 585                                 }
 586                                 handlecommand(dev);
 587                                         if(0xfa==inb_p(base+6)) {
 588                                                 /* we timed out, so return */
 589                                                 goto done;
 590                                         }
 591                         } else {
 592                                 /* we don't seem to have a command */
 593                                 if (!mboxinuse[0]) {
 594                                         mboxinuse[0] = 1;
 595                                         qels[0].cbuf = rescbuf;
 596                                         qels[0].cbuflen = 2;
 597                                         qels[0].dbuf = resdbuf;
 598                                         qels[0].dbuflen = 2;
 599                                         qels[0].QWrite = 0;
 600                                         qels[0].mailbox = 0;
 601                                         enQ(&qels[0]);
 602                                 } else {
 603                                         printk("trouble: response command already queued\n");
 604                                         goto done;
 605                                 }
 606                         }
 607                         break;
 608                 case 0Xfb:
 609                         /* data transfer ready */
 610                         if(debug & DEBUG_LOWER) printk("idle: fb\n");
 611                         if(q->QWrite) {
 612                                 memcpy(ltdmabuf,q->dbuf,q->dbuflen);
 613                                 handlewrite(dev);
 614                         } else {
 615                                 handleread(dev);
 616                                 /* non-zero mailbox numbers are for
 617                                    commmands, 0 is for GETRESULT
 618                                    requests */
 619                                 if(q->mailbox) {
 620                                         memcpy(q->dbuf,ltdmabuf,q->dbuflen);
 621                                 } else {
 622                                         /* this was a result */
 623                                         mailbox[ 0x0f & ltdmabuf[0] ] = ltdmabuf[1];
 624                                         mboxinuse[0]=0;
 625                                 }
 626                         }
 627                         break;
 628         }
 629         goto loop;
 630
 631 done:
 632         QInIdle=0;
 633
 634         /* now set the interrupts back as appropriate */
 635         /* the first read takes it out of tri-state (but still high) */
 636         /* the second resets it */
 637         /* note that after this point, any read of base+6 will
 638            trigger an interrupt */
 639
 640         if (dev->irq) {
 641                 inb_p(base+7);
 642                 inb_p(base+7);
 643         }
 644 }
 645
 646
 647 static int do_write(struct net_device *dev, void *cbuf, int cbuflen,
 648         void *dbuf, int dbuflen)
 649 {
 650
 651         int i = getmbox();
 652         int ret;
 653
 654         if(i) {
 655                 qels[i].cbuf = (unsigned char *) cbuf;
 656                 qels[i].cbuflen = cbuflen;
 657                 qels[i].dbuf = (unsigned char *) dbuf;
 658                 qels[i].dbuflen = dbuflen;
 659                 qels[i].QWrite = 1;
 660                 qels[i].mailbox = i;  /* this should be initted rather */
 661                 enQ(&qels[i]);
 662                 idle(dev);
 663                 ret = mailbox[i];
 664                 mboxinuse[i]=0;
 665                 return ret;
 666         }
 667         printk("ltpc: could not allocate mbox\n");
 668         return -1;
 669 }
 670
 671 static int do_read(struct net_device *dev, void *cbuf, int cbuflen,
 672         void *dbuf, int dbuflen)
 673 {
 674
 675         int i = getmbox();
 676         int ret;
 677
 678         if(i) {
 679                 qels[i].cbuf = (unsigned char *) cbuf;
 680                 qels[i].cbuflen = cbuflen;
 681                 qels[i].dbuf = (unsigned char *) dbuf;
 682                 qels[i].dbuflen = dbuflen;
 683                 qels[i].QWrite = 0;
 684                 qels[i].mailbox = i;  /* this should be initted rather */
 685                 enQ(&qels[i]);
 686                 idle(dev);
 687                 ret = mailbox[i];
 688                 mboxinuse[i]=0;
 689                 return ret;
 690         }
 691         printk("ltpc: could not allocate mbox\n");
 692         return -1;
 693 }
 694
 695 /* end of idle handlers -- what should be seen is do_read, do_write */
 696
 697 static struct timer_list ltpc_timer;
 698
 699 static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev);
 700
 701 static int read_30 ( struct net_device *dev)
 702 {
 703         lt_command c;
 704         c.getflags.command = LT_GETFLAGS;
 705         return do_read(dev, &c, sizeof(c.getflags),&c,0);
 706 }
 707
 708 static int set_30 (struct net_device *dev,int x)
 709 {
 710         lt_command c;
 711         c.setflags.command = LT_SETFLAGS;
 712         c.setflags.flags = x;
 713         return do_write(dev, &c, sizeof(c.setflags),&c,0);
 714 }
 715
 716 /* LLAP to DDP translation */
 717
 718 static int sendup_buffer (struct net_device *dev)
 719 {
 720         /* on entry, command is in ltdmacbuf, data in ltdmabuf */
 721         /* called from idle, non-reentrant */
 722
 723         int dnode, snode, llaptype, len;
 724         int sklen;
 725         struct sk_buff *skb;
 726         struct lt_rcvlap *ltc = (struct lt_rcvlap *) ltdmacbuf;
 727
 728         if (ltc->command != LT_RCVLAP) {
 729                 printk("unknown command 0x%02x from ltpc card\n",ltc->command);
 730                 return -1;
 731         }
 732         dnode = ltc->dnode;
 733         snode = ltc->snode;
 734         llaptype = ltc->laptype;
 735         len = ltc->length;
 736
 737         sklen = len;
 738         if (llaptype == 1)
 739                 sklen += 8;  /* correct for short ddp */
 740         if(sklen > 800) {
 741                 printk(KERN_INFO "%s: nonsense length in ltpc command 0x14: 0x%08x\n",
 742                         dev->name,sklen);
 743                 return -1;
 744         }
 745
 746         if ( (llaptype==0) || (llaptype>2) ) {
 747                 printk(KERN_INFO "%s: unknown LLAP type: %d\n",dev->name,llaptype);
 748                 return -1;
 749         }
 750
 751
 752         skb = dev_alloc_skb(3+sklen);
 753         if (skb == NULL)
 754         {
 755                 printk("%s: dropping packet due to memory squeeze.\n",
 756                         dev->name);
 757                 return -1;
 758         }
 759         skb->dev = dev;
 760
 761         if (sklen > len)
 762                 skb_reserve(skb,8);
 763         skb_put(skb,len+3);
 764         skb->protocol = htons(ETH_P_LOCALTALK);
 765         /* add LLAP header */
 766         skb->data[0] = dnode;
 767         skb->data[1] = snode;
 768         skb->data[2] = llaptype;
 769         skb_reset_mac_header(skb);      /* save pointer to llap header */
 770         skb_pull(skb,3);
 771
 772         /* copy ddp(s,e)hdr + contents */
 773         skb_copy_to_linear_data(skb, ltdmabuf, len);
 774
 775         skb_reset_transport_header(skb);
 776
 777         dev->stats.rx_packets++;
 778         dev->stats.rx_bytes += skb->len;
 779
 780         /* toss it onwards */
 781         netif_rx(skb);
 782         return 0;
 783 }
 784
 785 /* the handler for the board interrupt */
 786
 787 static irqreturn_t
 788 ltpc_interrupt(int irq, void *dev_id)
 789 {
 790         struct net_device *dev = dev_id;
 791
 792         if (dev==NULL) {
 793                 printk("ltpc_interrupt: unknown device.\n");
 794                 return IRQ_NONE;
 795         }
 796
 797         inb_p(dev->base_addr+6);  /* disable further interrupts from board */
 798
 799         idle(dev); /* handle whatever is coming in */
 800
 801         /* idle re-enables interrupts from board */
 802
 803         return IRQ_HANDLED;
 804 }
 805
 806 /***
 807  *
 808  *    The ioctls that the driver responds to are:
 809  *
 810  *    SIOCSIFADDR -- do probe using the passed node hint.
 811  *    SIOCGIFADDR -- return net, node.
 812  *
 813  *    some of this stuff should be done elsewhere.
 814  *
 815  ***/
 816
 817 static int ltpc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 818 {
 819         struct sockaddr_at *sa = (struct sockaddr_at *) &ifr->ifr_addr;
 820         /* we'll keep the localtalk node address in dev->pa_addr */
 821         struct ltpc_private *ltpc_priv = netdev_priv(dev);
 822         struct atalk_addr *aa = &ltpc_priv->my_addr;
 823         struct lt_init c;
 824         int ltflags;
 825
 826         if(debug & DEBUG_VERBOSE) printk("ltpc_ioctl called\n");
 827
 828         switch(cmd) {
 829                 case SIOCSIFADDR:
 830
 831                         aa->s_net  = sa->sat_addr.s_net;
 832
 833                         /* this does the probe and returns the node addr */
 834                         c.command = LT_INIT;
 835                         c.hint = sa->sat_addr.s_node;
 836
 837                         aa->s_node = do_read(dev,&c,sizeof(c),&c,0);
 838
 839                         /* get all llap frames raw */
 840                         ltflags = read_30(dev);
 841                         ltflags |= LT_FLAG_ALLLAP;
 842                         set_30 (dev,ltflags);
 843
 844                         dev->broadcast[0] = 0xFF;
 845                         dev->dev_addr[0] = aa->s_node;
 846
 847                         dev->addr_len=1;
 848
 849                         return 0;
 850
 851                 case SIOCGIFADDR:
 852
 853                         sa->sat_addr.s_net = aa->s_net;
 854                         sa->sat_addr.s_node = aa->s_node;
 855
 856                         return 0;
 857
 858                 default:
 859                         return -EINVAL;
 860         }
 861 }
 862
 863 static void set_multicast_list(struct net_device *dev)
 864 {
 865         /* This needs to be present to keep netatalk happy. */
 866         /* Actually netatalk needs fixing! */
 867 }
 868
 869 static int ltpc_poll_counter;
 870
 871 static void ltpc_poll(unsigned long l)
 872 {
 873         struct net_device *dev = (struct net_device *) l;
 874
 875         del_timer(&ltpc_timer);
 876
 877         if(debug & DEBUG_VERBOSE) {
 878                 if (!ltpc_poll_counter) {
 879                         ltpc_poll_counter = 50;
 880                         printk("ltpc poll is alive\n");
 881                 }
 882                 ltpc_poll_counter--;
 883         }
 884
 885         if (!dev)
 886                 return;  /* we've been downed */
 887
 888         /* poll 20 times per second */
 889         idle(dev);
 890         ltpc_timer.expires = jiffies + HZ/20;
 891
 892         add_timer(&ltpc_timer);
 893 }
 894
 895 /* DDP to LLAP translation */
 896
 897 static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev)
 898 {
 899         /* in kernel 1.3.xx, on entry skb->data points to ddp header,
 900          * and skb->len is the length of the ddp data + ddp header
 901          */
 902         int i;
 903         struct lt_sendlap cbuf;
 904         unsigned char *hdr;
 905
 906         cbuf.command = LT_SENDLAP;
 907         cbuf.dnode = skb->data[0];
 908         cbuf.laptype = skb->data[2];
 909         skb_pull(skb,3);        /* skip past LLAP header */
 910         cbuf.length = skb->len; /* this is host order */
 911         skb_reset_transport_header(skb);
 912
 913         if(debug & DEBUG_UPPER) {
 914                 printk("command ");
 915                 for(i=0;i<6;i++)
 916                         printk("%02x ",((unsigned char *)&cbuf)[i]);
 917                 printk("\n");
 918         }
 919
 920         hdr = skb_transport_header(skb);
 921         do_write(dev, &cbuf, sizeof(cbuf), hdr, skb->len);
 922
 923         if(debug & DEBUG_UPPER) {
 924                 printk("sent %d ddp bytes\n",skb->len);
 925                 for (i = 0; i < skb->len; i++)
 926                         printk("%02x ", hdr[i]);
 927                 printk("\n");
 928         }
 929
 930         dev->stats.tx_packets++;
 931         dev->stats.tx_bytes += skb->len;
 932
 933         dev_kfree_skb(skb);
 934         return NETDEV_TX_OK;
 935 }
 936
 937 /* initialization stuff */
 938
 939 static int __init ltpc_probe_dma(int base, int dma)
 940 {
 941         int want = (dma == 3) ? 2 : (dma == 1) ? 1 : 3;
 942         unsigned long timeout;
 943         unsigned long f;
 944
 945         if (want & 1) {
 946                 if (request_dma(1,"ltpc")) {
 947                         want &= ~1;
 948                 } else {
 949                         f=claim_dma_lock();
 950                         disable_dma(1);
 951                         clear_dma_ff(1);
 952                         set_dma_mode(1,DMA_MODE_WRITE);
 953                         set_dma_addr(1,virt_to_bus(ltdmabuf));
 954                         set_dma_count(1,sizeof(struct lt_mem));
 955                         enable_dma(1);
 956                         release_dma_lock(f);
 957                 }
 958         }
 959         if (want & 2) {
 960                 if (request_dma(3,"ltpc")) {
 961                         want &= ~2;
 962                 } else {
 963                         f=claim_dma_lock();
 964                         disable_dma(3);
 965                         clear_dma_ff(3);
 966                         set_dma_mode(3,DMA_MODE_WRITE);
 967                         set_dma_addr(3,virt_to_bus(ltdmabuf));
 968                         set_dma_count(3,sizeof(struct lt_mem));
 969                         enable_dma(3);
 970                         release_dma_lock(f);
 971                 }
 972         }
 973         /* set up request */
 974
 975         /* FIXME -- do timings better! */
 976
 977         ltdmabuf[0] = LT_READMEM;
 978         ltdmabuf[1] = 1;  /* mailbox */
 979         ltdmabuf[2] = 0; ltdmabuf[3] = 0;  /* address */
 980         ltdmabuf[4] = 0; ltdmabuf[5] = 1;  /* read 0x0100 bytes */
 981         ltdmabuf[6] = 0; /* dunno if this is necessary */
 982
 983         inb_p(io+1);
 984         inb_p(io+0);
 985         timeout = jiffies+100*HZ/100;
 986         while(time_before(jiffies, timeout)) {
 987                 if ( 0xfa == inb_p(io+6) ) break;
 988         }
 989
 990         inb_p(io+3);
 991         inb_p(io+2);
 992         while(time_before(jiffies, timeout)) {
 993                 if ( 0xfb == inb_p(io+6) ) break;
 994         }
 995
 996         /* release the other dma channel (if we opened both of them) */
 997
 998         if ((want & 2) && (get_dma_residue(3)==sizeof(struct lt_mem))) {
 999                 want &= ~2;
1000                 free_dma(3);
1001         }
1002
1003         if ((want & 1) && (get_dma_residue(1)==sizeof(struct lt_mem))) {
1004                 want &= ~1;
1005                 free_dma(1);
1006         }
1007
1008         if (!want)
1009                 return 0;
1010
1011         return (want & 2) ? 3 : 1;
1012 }
1013
1014 static const struct net_device_ops ltpc_netdev = {
1015         .ndo_start_xmit         = ltpc_xmit,
1016         .ndo_do_ioctl           = ltpc_ioctl,
1017         .ndo_set_multicast_list = set_multicast_list,
1018 };
1019
1020 struct net_device * __init ltpc_probe(void)
1021 {
1022         struct net_device *dev;
1023         int err = -ENOMEM;
1024         int x=0,y=0;
1025         int autoirq;
1026         unsigned long f;
1027         unsigned long timeout;
1028
1029         dev = alloc_ltalkdev(sizeof(struct ltpc_private));
1030         if (!dev)
1031                 goto out;
1032
1033         /* probe for the I/O port address */
1034
1035         if (io != 0x240 && request_region(0x220,8,"ltpc")) {
1036                 x = inb_p(0x220+6);
1037                 if ( (x!=0xff) && (x>=0xf0) ) {
1038                         io = 0x220;
1039                         goto got_port;
1040                 }
1041                 release_region(0x220,8);
1042         }
1043         if (io != 0x220 && request_region(0x240,8,"ltpc")) {
1044                 y = inb_p(0x240+6);
1045                 if ( (y!=0xff) && (y>=0xf0) ){
1046                         io = 0x240;
1047                         goto got_port;
1048                 }
1049                 release_region(0x240,8);
1050         }
1051
1052         /* give up in despair */
1053         printk(KERN_ERR "LocalTalk card not found; 220 = %02x, 240 = %02x.\n", x,y);
1054         err = -ENODEV;
1055         goto out1;
1056
1057  got_port:
1058         /* probe for the IRQ line */
1059         if (irq < 2) {
1060                 unsigned long irq_mask;
1061
1062                 irq_mask = probe_irq_on();
1063                 /* reset the interrupt line */
1064                 inb_p(io+7);
1065                 inb_p(io+7);
1066                 /* trigger an interrupt (I hope) */
1067                 inb_p(io+6);
1068                 mdelay(2);
1069                 autoirq = probe_irq_off(irq_mask);
1070
1071                 if (autoirq == 0) {
1072                         printk(KERN_ERR "ltpc: probe at %#x failed to detect IRQ line.\n", io);
1073                 } else {
1074                         irq = autoirq;
1075                 }
1076         }
1077
1078         /* allocate a DMA buffer */
1079         ltdmabuf = (unsigned char *) dma_mem_alloc(1000);
1080         if (!ltdmabuf) {
1081                 printk(KERN_ERR "ltpc: mem alloc failed\n");
1082                 err = -ENOMEM;
1083                 goto out2;
1084         }
1085
1086         ltdmacbuf = &ltdmabuf[800];
1087
1088         if(debug & DEBUG_VERBOSE) {
1089                 printk("ltdmabuf pointer %08lx\n",(unsigned long) ltdmabuf);
1090         }
1091
1092         /* reset the card */
1093
1094         inb_p(io+1);
1095         inb_p(io+3);
1096
1097         msleep(20);
1098
1099         inb_p(io+0);
1100         inb_p(io+2);
1101         inb_p(io+7); /* clear reset */
1102         inb_p(io+4);
1103         inb_p(io+5);
1104         inb_p(io+5); /* enable dma */
1105         inb_p(io+6); /* tri-state interrupt line */
1106
1107         ssleep(1);
1108
1109         /* now, figure out which dma channel we're using, unless it's
1110            already been specified */
1111         /* well, 0 is a legal DMA channel, but the LTPC card doesn't
1112            use it... */
1113         dma = ltpc_probe_dma(io, dma);
1114         if (!dma) {  /* no dma channel */
1115                 printk(KERN_ERR "No DMA channel found on ltpc card.\n");
1116                 err = -ENODEV;
1117                 goto out3;
1118         }
1119
1120         /* print out friendly message */
1121         if(irq)
1122                 printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, IR%d, DMA%d.\n",io,irq,dma);
1123         else
1124                 printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, DMA%d.  Using polled mode.\n",io,dma);
1125
1126         dev->netdev_ops = &ltpc_netdev;
1127         dev->base_addr = io;
1128         dev->irq = irq;
1129         dev->dma = dma;
1130
1131         /* the card will want to send a result at this point */
1132         /* (I think... leaving out this part makes the kernel crash,
1133            so I put it back in...) */
1134
1135         f=claim_dma_lock();
1136         disable_dma(dma);
1137         clear_dma_ff(dma);
1138         set_dma_mode(dma,DMA_MODE_READ);
1139         set_dma_addr(dma,virt_to_bus(ltdmabuf));
1140         set_dma_count(dma,0x100);
1141         enable_dma(dma);
1142         release_dma_lock(f);
1143
1144         (void) inb_p(io+3);
1145         (void) inb_p(io+2);
1146         timeout = jiffies+100*HZ/100;
1147
1148         while(time_before(jiffies, timeout)) {
1149                 if( 0xf9 == inb_p(io+6))
1150                         break;
1151                 schedule();
1152         }
1153
1154         if(debug & DEBUG_VERBOSE) {
1155                 printk("setting up timer and irq\n");
1156         }
1157
1158         /* grab it and don't let go :-) */
1159         if (irq && request_irq( irq, ltpc_interrupt, 0, "ltpc", dev) >= 0)
1160         {
1161                 (void) inb_p(io+7);  /* enable interrupts from board */
1162                 (void) inb_p(io+7);  /* and reset irq line */
1163         } else {
1164                 if( irq )
1165                         printk(KERN_ERR "ltpc: IRQ already in use, using polled mode.\n");
1166                 dev->irq = 0;
1167                 /* polled mode -- 20 times per second */
1168                 /* this is really, really slow... should it poll more often? */
1169                 init_timer(&ltpc_timer);
1170                 ltpc_timer.function=ltpc_poll;
1171                 ltpc_timer.data = (unsigned long) dev;
1172
1173                 ltpc_timer.expires = jiffies + HZ/20;
1174                 add_timer(&ltpc_timer);
1175         }
1176         err = register_netdev(dev);
1177         if (err)
1178                 goto out4;
1179
1180         return NULL;
1181 out4:
1182         del_timer_sync(&ltpc_timer);
1183         if (dev->irq)
1184                 free_irq(dev->irq, dev);
1185 out3:
1186         free_pages((unsigned long)ltdmabuf, get_order(1000));
1187 out2:
1188         release_region(io, 8);
1189 out1:
1190         free_netdev(dev);
1191 out:
1192         return ERR_PTR(err);
1193 }
1194
1195 #ifndef MODULE
1196 /* handles "ltpc=io,irq,dma" kernel command lines */
1197 static int __init ltpc_setup(char *str)
1198 {
1199         int ints[5];
1200
1201         str = get_options(str, ARRAY_SIZE(ints), ints);
1202
1203         if (ints[0] == 0) {
1204                 if (str && !strncmp(str, "auto", 4)) {
1205                         /* do nothing :-) */
1206                 }
1207                 else {
1208                         /* usage message */
1209                         printk (KERN_ERR
1210                                 "ltpc: usage: ltpc=auto|iobase[,irq[,dma]]\n");
1211                         return 0;
1212                 }
1213         } else {
1214                 io = ints[1];
1215                 if (ints[0] > 1) {
1216                         irq = ints[2];
1217                 }
1218                 if (ints[0] > 2) {
1219                         dma = ints[3];
1220                 }
1221                 /* ignore any other parameters */
1222         }
1223         return 1;
1224 }
1225
1226 __setup("ltpc=", ltpc_setup);
1227 #endif /* MODULE */
1228
1229 static struct net_device *dev_ltpc;
1230
1231 #ifdef MODULE
1232
1233 MODULE_LICENSE("GPL");
1234 module_param(debug, int, 0);
1235 module_param(io, int, 0);
1236 module_param(irq, int, 0);
1237 module_param(dma, int, 0);
1238
1239
1240 static int __init ltpc_module_init(void)
1241 {
1242         if(io == 0)
1243                 printk(KERN_NOTICE
1244                        "ltpc: Autoprobing is not recommended for modules\n");
1245
1246         dev_ltpc = ltpc_probe();
1247         if (IS_ERR(dev_ltpc))
1248                 return PTR_ERR(dev_ltpc);
1249         return 0;
1250 }
1251 module_init(ltpc_module_init);
1252 #endif
1253
1254 static void __exit ltpc_cleanup(void)
1255 {
1256
1257         if(debug & DEBUG_VERBOSE) printk("unregister_netdev\n");
1258         unregister_netdev(dev_ltpc);
1259
1260         ltpc_timer.data = 0;  /* signal the poll routine that we're done */
1261
1262         del_timer_sync(&ltpc_timer);
1263
1264         if(debug & DEBUG_VERBOSE) printk("freeing irq\n");
1265
1266         if (dev_ltpc->irq)
1267                 free_irq(dev_ltpc->irq, dev_ltpc);
1268
1269         if(debug & DEBUG_VERBOSE) printk("freeing dma\n");
1270
1271         if (dev_ltpc->dma)
1272                 free_dma(dev_ltpc->dma);
1273
1274         if(debug & DEBUG_VERBOSE) printk("freeing ioaddr\n");
1275
1276         if (dev_ltpc->base_addr)
1277                 release_region(dev_ltpc->base_addr,8);
1278
1279         free_netdev(dev_ltpc);
1280
1281         if(debug & DEBUG_VERBOSE) printk("free_pages\n");
1282
1283         free_pages( (unsigned long) ltdmabuf, get_order(1000));
1284
1285         if(debug & DEBUG_VERBOSE) printk("returning from cleanup_module\n");
1286 }
1287
1288 module_exit(ltpc_cleanup);