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 */ 200static int debug; 201#define DEBUG_VERBOSE 1 202#define DEBUG_UPPER 2 203#define DEBUG_LOWER 4 204 205static int io; 206static int irq; 207static 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 <net/Space.h> 233 234#include <asm/dma.h> 235#include <asm/io.h> 236 237/* our stuff */ 238#include "ltpc.h" 239 240static DEFINE_SPINLOCK(txqueue_lock); 241static DEFINE_SPINLOCK(mbox_lock); 242 243/* function prototypes */ 244static int do_read(struct net_device *dev, void *cbuf, int cbuflen, 245 void *dbuf, int dbuflen); 246static int sendup_buffer (struct net_device *dev); 247 248/* Dma Memory related stuff, cribbed directly from 3c505.c */ 249 250static unsigned long dma_mem_alloc(int size) 251{ 252 int order = get_order(size); 253 254 return __get_dma_pages(GFP_KERNEL, order); 255} 256 257/* DMA data buffer, DMA command buffer */ 258static unsigned char *ltdmabuf; 259static unsigned char *ltdmacbuf; 260 261/* private struct, holds our appletalk address */ 262 263struct ltpc_private 264{ 265 struct atalk_addr my_addr; 266}; 267 268/* transmit queue element struct */ 269 270struct xmitQel { 271 struct xmitQel *next; 272 /* command buffer */ 273 unsigned char *cbuf; 274 short cbuflen; 275 /* data buffer */ 276 unsigned char *dbuf; 277 short dbuflen; 278 unsigned char QWrite; /* read or write data */ 279 unsigned char mailbox; 280}; 281 282/* the transmit queue itself */ 283 284static struct xmitQel *xmQhd, *xmQtl; 285 286static void enQ(struct xmitQel *qel) 287{ 288 unsigned long flags; 289 qel->next = NULL; 290 291 spin_lock_irqsave(&txqueue_lock, flags); 292 if (xmQtl) { 293 xmQtl->next = qel; 294 } else { 295 xmQhd = qel; 296 } 297 xmQtl = qel; 298 spin_unlock_irqrestore(&txqueue_lock, flags); 299 300 if (debug & DEBUG_LOWER) 301 printk("enqueued a 0x%02x command\n",qel->cbuf[0]); 302} 303 304static struct xmitQel *deQ(void) 305{ 306 unsigned long flags; 307 int i; 308 struct xmitQel *qel=NULL; 309 310 spin_lock_irqsave(&txqueue_lock, flags); 311 if (xmQhd) { 312 qel = xmQhd; 313 xmQhd = qel->next; 314 if(!xmQhd) xmQtl = NULL; 315 } 316 spin_unlock_irqrestore(&txqueue_lock, flags); 317 318 if ((debug & DEBUG_LOWER) && qel) { 319 int n; 320 printk(KERN_DEBUG "ltpc: dequeued command "); 321 n = qel->cbuflen; 322 if (n>100) n=100; 323 for(i=0;i<n;i++) printk("%02x ",qel->cbuf[i]); 324 printk("\n"); 325 } 326 327 return qel; 328} 329 330/* and... the queue elements we'll be using */ 331static struct xmitQel qels[16]; 332 333/* and their corresponding mailboxes */ 334static unsigned char mailbox[16]; 335static unsigned char mboxinuse[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; 336 337static int wait_timeout(struct net_device *dev, int c) 338{ 339 /* returns true if it stayed c */ 340 /* this uses base+6, but it's ok */ 341 int i; 342 343 /* twenty second or so total */ 344 345 for(i=0;i<200000;i++) { 346 if ( c != inb_p(dev->base_addr+6) ) return 0; 347 udelay(100); 348 } 349 return 1; /* timed out */ 350} 351 352/* get the first free mailbox */ 353 354static int getmbox(void) 355{ 356 unsigned long flags; 357 int i; 358 359 spin_lock_irqsave(&mbox_lock, flags); 360 for(i=1;i<16;i++) if(!mboxinuse[i]) { 361 mboxinuse[i]=1; 362 spin_unlock_irqrestore(&mbox_lock, flags); 363 return i; 364 } 365 spin_unlock_irqrestore(&mbox_lock, flags); 366 return 0; 367} 368 369/* read a command from the card */ 370static void handlefc(struct net_device *dev) 371{ 372 /* called *only* from idle, non-reentrant */ 373 int dma = dev->dma; 374 int base = dev->base_addr; 375 unsigned long flags; 376 377 378 flags=claim_dma_lock(); 379 disable_dma(dma); 380 clear_dma_ff(dma); 381 set_dma_mode(dma,DMA_MODE_READ); 382 set_dma_addr(dma,virt_to_bus(ltdmacbuf)); 383 set_dma_count(dma,50); 384 enable_dma(dma); 385 release_dma_lock(flags); 386 387 inb_p(base+3); 388 inb_p(base+2); 389 390 if ( wait_timeout(dev,0xfc) ) printk("timed out in handlefc\n"); 391} 392 393/* read data from the card */ 394static void handlefd(struct net_device *dev) 395{ 396 int dma = dev->dma; 397 int base = dev->base_addr; 398 unsigned long flags; 399 400 flags=claim_dma_lock(); 401 disable_dma(dma); 402 clear_dma_ff(dma); 403 set_dma_mode(dma,DMA_MODE_READ); 404 set_dma_addr(dma,virt_to_bus(ltdmabuf)); 405 set_dma_count(dma,800); 406 enable_dma(dma); 407 release_dma_lock(flags); 408 409 inb_p(base+3); 410 inb_p(base+2); 411 412 if ( wait_timeout(dev,0xfd) ) printk("timed out in handlefd\n"); 413 sendup_buffer(dev); 414} 415 416static void handlewrite(struct net_device *dev) 417{ 418 /* called *only* from idle, non-reentrant */ 419 /* on entry, 0xfb and ltdmabuf holds data */ 420 int dma = dev->dma; 421 int base = dev->base_addr; 422 unsigned long flags; 423 424 flags=claim_dma_lock(); 425 disable_dma(dma); 426 clear_dma_ff(dma); 427 set_dma_mode(dma,DMA_MODE_WRITE); 428 set_dma_addr(dma,virt_to_bus(ltdmabuf)); 429 set_dma_count(dma,800); 430 enable_dma(dma); 431 release_dma_lock(flags); 432 433 inb_p(base+3); 434 inb_p(base+2); 435 436 if ( wait_timeout(dev,0xfb) ) { 437 flags=claim_dma_lock(); 438 printk("timed out in handlewrite, dma res %d\n", 439 get_dma_residue(dev->dma) ); 440 release_dma_lock(flags); 441 } 442} 443 444static void handleread(struct net_device *dev) 445{ 446 /* on entry, 0xfb */ 447 /* on exit, ltdmabuf holds data */ 448 int dma = dev->dma; 449 int base = dev->base_addr; 450 unsigned long flags; 451 452 453 flags=claim_dma_lock(); 454 disable_dma(dma); 455 clear_dma_ff(dma); 456 set_dma_mode(dma,DMA_MODE_READ); 457 set_dma_addr(dma,virt_to_bus(ltdmabuf)); 458 set_dma_count(dma,800); 459 enable_dma(dma); 460 release_dma_lock(flags); 461 462 inb_p(base+3); 463 inb_p(base+2); 464 if ( wait_timeout(dev,0xfb) ) printk("timed out in handleread\n"); 465} 466 467static void handlecommand(struct net_device *dev) 468{ 469 /* on entry, 0xfa and ltdmacbuf holds command */ 470 int dma = dev->dma; 471 int base = dev->base_addr; 472 unsigned long flags; 473 474 flags=claim_dma_lock(); 475 disable_dma(dma); 476 clear_dma_ff(dma); 477 set_dma_mode(dma,DMA_MODE_WRITE); 478 set_dma_addr(dma,virt_to_bus(ltdmacbuf)); 479 set_dma_count(dma,50); 480 enable_dma(dma); 481 release_dma_lock(flags); 482 inb_p(base+3); 483 inb_p(base+2); 484 if ( wait_timeout(dev,0xfa) ) printk("timed out in handlecommand\n"); 485} 486 487/* ready made command for getting the result from the card */ 488static unsigned char rescbuf[2] = {LT_GETRESULT,0}; 489static unsigned char resdbuf[2]; 490 491static int QInIdle; 492 493/* idle expects to be called with the IRQ line high -- either because of 494 * an interrupt, or because the line is tri-stated 495 */ 496 497static void idle(struct net_device *dev) 498{ 499 unsigned long flags; 500 int state; 501 /* FIXME This is initialized to shut the warning up, but I need to 502 * think this through again. 503 */ 504 struct xmitQel *q = NULL; 505 int oops; 506 int i; 507 int base = dev->base_addr; 508 509 spin_lock_irqsave(&txqueue_lock, flags); 510 if(QInIdle) { 511 spin_unlock_irqrestore(&txqueue_lock, flags); 512 return; 513 } 514 QInIdle = 1; 515 spin_unlock_irqrestore(&txqueue_lock, flags); 516 517 /* this tri-states the IRQ line */ 518 (void) inb_p(base+6); 519 520 oops = 100; 521 522loop: 523 if (0>oops--) { 524 printk("idle: looped too many times\n"); 525 goto done; 526 } 527 528 state = inb_p(base+6); 529 if (state != inb_p(base+6)) goto loop; 530 531 switch(state) { 532 case 0xfc: 533 /* incoming command */ 534 if (debug & DEBUG_LOWER) printk("idle: fc\n"); 535 handlefc(dev); 536 break; 537 case 0xfd: 538 /* incoming data */ 539 if(debug & DEBUG_LOWER) printk("idle: fd\n"); 540 handlefd(dev); 541 break; 542 case 0xf9: 543 /* result ready */ 544 if (debug & DEBUG_LOWER) printk("idle: f9\n"); 545 if(!mboxinuse[0]) { 546 mboxinuse[0] = 1; 547 qels[0].cbuf = rescbuf; 548 qels[0].cbuflen = 2; 549 qels[0].dbuf = resdbuf; 550 qels[0].dbuflen = 2; 551 qels[0].QWrite = 0; 552 qels[0].mailbox = 0; 553 enQ(&qels[0]); 554 } 555 inb_p(dev->base_addr+1); 556 inb_p(dev->base_addr+0); 557 if( wait_timeout(dev,0xf9) ) 558 printk("timed out idle f9\n"); 559 break; 560 case 0xf8: 561 /* ?? */ 562 if (xmQhd) { 563 inb_p(dev->base_addr+1); 564 inb_p(dev->base_addr+0); 565 if(wait_timeout(dev,0xf8) ) 566 printk("timed out idle f8\n"); 567 } else { 568 goto done; 569 } 570 break; 571 case 0xfa: 572 /* waiting for command */ 573 if(debug & DEBUG_LOWER) printk("idle: fa\n"); 574 if (xmQhd) { 575 q=deQ(); 576 memcpy(ltdmacbuf,q->cbuf,q->cbuflen); 577 ltdmacbuf[1] = q->mailbox; 578 if (debug>1) { 579 int n; 580 printk("ltpc: sent command "); 581 n = q->cbuflen; 582 if (n>100) n=100; 583 for(i=0;i<n;i++) 584 printk("%02x ",ltdmacbuf[i]); 585 printk("\n"); 586 } 587 handlecommand(dev); 588 if(0xfa==inb_p(base+6)) { 589 /* we timed out, so return */ 590 goto done; 591 } 592 } else { 593 /* we don't seem to have a command */ 594 if (!mboxinuse[0]) { 595 mboxinuse[0] = 1; 596 qels[0].cbuf = rescbuf; 597 qels[0].cbuflen = 2; 598 qels[0].dbuf = resdbuf; 599 qels[0].dbuflen = 2; 600 qels[0].QWrite = 0; 601 qels[0].mailbox = 0; 602 enQ(&qels[0]); 603 } else { 604 printk("trouble: response command already queued\n"); 605 goto done; 606 } 607 } 608 break; 609 case 0Xfb: 610 /* data transfer ready */ 611 if(debug & DEBUG_LOWER) printk("idle: fb\n"); 612 if(q->QWrite) { 613 memcpy(ltdmabuf,q->dbuf,q->dbuflen); 614 handlewrite(dev); 615 } else { 616 handleread(dev); 617 /* non-zero mailbox numbers are for 618 commmands, 0 is for GETRESULT 619 requests */ 620 if(q->mailbox) { 621 memcpy(q->dbuf,ltdmabuf,q->dbuflen); 622 } else { 623 /* this was a result */ 624 mailbox[ 0x0f & ltdmabuf[0] ] = ltdmabuf[1]; 625 mboxinuse[0]=0; 626 } 627 } 628 break; 629 } 630 goto loop; 631 632done: 633 QInIdle=0; 634 635 /* now set the interrupts back as appropriate */ 636 /* the first read takes it out of tri-state (but still high) */ 637 /* the second resets it */ 638 /* note that after this point, any read of base+6 will 639 trigger an interrupt */ 640 641 if (dev->irq) { 642 inb_p(base+7); 643 inb_p(base+7); 644 } 645} 646 647 648static int do_write(struct net_device *dev, void *cbuf, int cbuflen, 649 void *dbuf, int dbuflen) 650{ 651 652 int i = getmbox(); 653 int ret; 654 655 if(i) { 656 qels[i].cbuf = cbuf; 657 qels[i].cbuflen = cbuflen; 658 qels[i].dbuf = dbuf; 659 qels[i].dbuflen = dbuflen; 660 qels[i].QWrite = 1; 661 qels[i].mailbox = i; /* this should be initted rather */ 662 enQ(&qels[i]); 663 idle(dev); 664 ret = mailbox[i]; 665 mboxinuse[i]=0; 666 return ret; 667 } 668 printk("ltpc: could not allocate mbox\n"); 669 return -1; 670} 671 672static int do_read(struct net_device *dev, void *cbuf, int cbuflen, 673 void *dbuf, int dbuflen) 674{ 675 676 int i = getmbox(); 677 int ret; 678 679 if(i) { 680 qels[i].cbuf = cbuf; 681 qels[i].cbuflen = cbuflen; 682 qels[i].dbuf = dbuf; 683 qels[i].dbuflen = dbuflen; 684 qels[i].QWrite = 0; 685 qels[i].mailbox = i; /* this should be initted rather */ 686 enQ(&qels[i]); 687 idle(dev); 688 ret = mailbox[i]; 689 mboxinuse[i]=0; 690 return ret; 691 } 692 printk("ltpc: could not allocate mbox\n"); 693 return -1; 694} 695 696/* end of idle handlers -- what should be seen is do_read, do_write */ 697 698static struct timer_list ltpc_timer; 699static struct net_device *ltpc_timer_dev; 700 701static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev); 702 703static int read_30 ( struct net_device *dev) 704{ 705 lt_command c; 706 c.getflags.command = LT_GETFLAGS; 707 return do_read(dev, &c, sizeof(c.getflags),&c,0); 708} 709 710static int set_30 (struct net_device *dev,int x) 711{ 712 lt_command c; 713 c.setflags.command = LT_SETFLAGS; 714 c.setflags.flags = x; 715 return do_write(dev, &c, sizeof(c.setflags),&c,0); 716} 717 718/* LLAP to DDP translation */ 719 720static int sendup_buffer (struct net_device *dev) 721{ 722 /* on entry, command is in ltdmacbuf, data in ltdmabuf */ 723 /* called from idle, non-reentrant */ 724 725 int dnode, snode, llaptype, len; 726 int sklen; 727 struct sk_buff *skb; 728 struct lt_rcvlap *ltc = (struct lt_rcvlap *) ltdmacbuf; 729 730 if (ltc->command != LT_RCVLAP) { 731 printk("unknown command 0x%02x from ltpc card\n",ltc->command); 732 return -1; 733 } 734 dnode = ltc->dnode; 735 snode = ltc->snode; 736 llaptype = ltc->laptype; 737 len = ltc->length; 738 739 sklen = len; 740 if (llaptype == 1) 741 sklen += 8; /* correct for short ddp */ 742 if(sklen > 800) { 743 printk(KERN_INFO "%s: nonsense length in ltpc command 0x14: 0x%08x\n", 744 dev->name,sklen); 745 return -1; 746 } 747 748 if ( (llaptype==0) || (llaptype>2) ) { 749 printk(KERN_INFO "%s: unknown LLAP type: %d\n",dev->name,llaptype); 750 return -1; 751 } 752 753 754 skb = dev_alloc_skb(3+sklen); 755 if (skb == NULL) 756 { 757 printk("%s: dropping packet due to memory squeeze.\n", 758 dev->name); 759 return -1; 760 } 761 skb->dev = dev; 762 763 if (sklen > len) 764 skb_reserve(skb,8); 765 skb_put(skb,len+3); 766 skb->protocol = htons(ETH_P_LOCALTALK); 767 /* add LLAP header */ 768 skb->data[0] = dnode; 769 skb->data[1] = snode; 770 skb->data[2] = llaptype; 771 skb_reset_mac_header(skb); /* save pointer to llap header */ 772 skb_pull(skb,3); 773 774 /* copy ddp(s,e)hdr + contents */ 775 skb_copy_to_linear_data(skb, ltdmabuf, len); 776 777 skb_reset_transport_header(skb); 778 779 dev->stats.rx_packets++; 780 dev->stats.rx_bytes += skb->len; 781 782 /* toss it onwards */ 783 netif_rx(skb); 784 return 0; 785} 786 787/* the handler for the board interrupt */ 788 789static irqreturn_t 790ltpc_interrupt(int irq, void *dev_id) 791{ 792 struct net_device *dev = dev_id; 793 794 if (dev==NULL) { 795 printk("ltpc_interrupt: unknown device.\n"); 796 return IRQ_NONE; 797 } 798 799 inb_p(dev->base_addr+6); /* disable further interrupts from board */ 800 801 idle(dev); /* handle whatever is coming in */ 802 803 /* idle re-enables interrupts from board */ 804 805 return IRQ_HANDLED; 806} 807 808/*** 809 * 810 * The ioctls that the driver responds to are: 811 * 812 * SIOCSIFADDR -- do probe using the passed node hint. 813 * SIOCGIFADDR -- return net, node. 814 * 815 * some of this stuff should be done elsewhere. 816 * 817 ***/ 818 819static int ltpc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 820{ 821 struct sockaddr_at *sa = (struct sockaddr_at *) &ifr->ifr_addr; 822 /* we'll keep the localtalk node address in dev->pa_addr */ 823 struct ltpc_private *ltpc_priv = netdev_priv(dev); 824 struct atalk_addr *aa = <pc_priv->my_addr; 825 struct lt_init c; 826 int ltflags; 827 828 if(debug & DEBUG_VERBOSE) printk("ltpc_ioctl called\n"); 829 830 switch(cmd) { 831 case SIOCSIFADDR: 832 833 aa->s_net = sa->sat_addr.s_net; 834 835 /* this does the probe and returns the node addr */ 836 c.command = LT_INIT; 837 c.hint = sa->sat_addr.s_node; 838 839 aa->s_node = do_read(dev,&c,sizeof(c),&c,0); 840 841 /* get all llap frames raw */ 842 ltflags = read_30(dev); 843 ltflags |= LT_FLAG_ALLLAP; 844 set_30 (dev,ltflags); 845 846 dev->broadcast[0] = 0xFF; 847 dev->dev_addr[0] = aa->s_node; 848 849 dev->addr_len=1; 850 851 return 0; 852 853 case SIOCGIFADDR: 854 855 sa->sat_addr.s_net = aa->s_net; 856 sa->sat_addr.s_node = aa->s_node; 857 858 return 0; 859 860 default: 861 return -EINVAL; 862 } 863} 864 865static void set_multicast_list(struct net_device *dev) 866{ 867 /* This needs to be present to keep netatalk happy. */ 868 /* Actually netatalk needs fixing! */ 869} 870 871static int ltpc_poll_counter; 872 873static void ltpc_poll(struct timer_list *unused) 874{ 875 del_timer(<pc_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 /* poll 20 times per second */ 886 idle(ltpc_timer_dev); 887 ltpc_timer.expires = jiffies + HZ/20; 888 add_timer(<pc_timer); 889} 890 891/* DDP to LLAP translation */ 892 893static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev) 894{ 895 /* in kernel 1.3.xx, on entry skb->data points to ddp header, 896 * and skb->len is the length of the ddp data + ddp header 897 */ 898 int i; 899 struct lt_sendlap cbuf; 900 unsigned char *hdr; 901 902 cbuf.command = LT_SENDLAP; 903 cbuf.dnode = skb->data[0]; 904 cbuf.laptype = skb->data[2]; 905 skb_pull(skb,3); /* skip past LLAP header */ 906 cbuf.length = skb->len; /* this is host order */ 907 skb_reset_transport_header(skb); 908 909 if(debug & DEBUG_UPPER) { 910 printk("command "); 911 for(i=0;i<6;i++) 912 printk("%02x ",((unsigned char *)&cbuf)[i]); 913 printk("\n"); 914 } 915 916 hdr = skb_transport_header(skb); 917 do_write(dev, &cbuf, sizeof(cbuf), hdr, skb->len); 918 919 if(debug & DEBUG_UPPER) { 920 printk("sent %d ddp bytes\n",skb->len); 921 for (i = 0; i < skb->len; i++) 922 printk("%02x ", hdr[i]); 923 printk("\n"); 924 } 925 926 dev->stats.tx_packets++; 927 dev->stats.tx_bytes += skb->len; 928 929 dev_kfree_skb(skb); 930 return NETDEV_TX_OK; 931} 932 933/* initialization stuff */ 934 935static int __init ltpc_probe_dma(int base, int dma) 936{ 937 int want = (dma == 3) ? 2 : (dma == 1) ? 1 : 3; 938 unsigned long timeout; 939 unsigned long f; 940 941 if (want & 1) { 942 if (request_dma(1,"ltpc")) { 943 want &= ~1; 944 } else { 945 f=claim_dma_lock(); 946 disable_dma(1); 947 clear_dma_ff(1); 948 set_dma_mode(1,DMA_MODE_WRITE); 949 set_dma_addr(1,virt_to_bus(ltdmabuf)); 950 set_dma_count(1,sizeof(struct lt_mem)); 951 enable_dma(1); 952 release_dma_lock(f); 953 } 954 } 955 if (want & 2) { 956 if (request_dma(3,"ltpc")) { 957 want &= ~2; 958 } else { 959 f=claim_dma_lock(); 960 disable_dma(3); 961 clear_dma_ff(3); 962 set_dma_mode(3,DMA_MODE_WRITE); 963 set_dma_addr(3,virt_to_bus(ltdmabuf)); 964 set_dma_count(3,sizeof(struct lt_mem)); 965 enable_dma(3); 966 release_dma_lock(f); 967 } 968 } 969 /* set up request */ 970 971 /* FIXME -- do timings better! */ 972 973 ltdmabuf[0] = LT_READMEM; 974 ltdmabuf[1] = 1; /* mailbox */ 975 ltdmabuf[2] = 0; ltdmabuf[3] = 0; /* address */ 976 ltdmabuf[4] = 0; ltdmabuf[5] = 1; /* read 0x0100 bytes */ 977 ltdmabuf[6] = 0; /* dunno if this is necessary */ 978 979 inb_p(io+1); 980 inb_p(io+0); 981 timeout = jiffies+100*HZ/100; 982 while(time_before(jiffies, timeout)) { 983 if ( 0xfa == inb_p(io+6) ) break; 984 } 985 986 inb_p(io+3); 987 inb_p(io+2); 988 while(time_before(jiffies, timeout)) { 989 if ( 0xfb == inb_p(io+6) ) break; 990 } 991 992 /* release the other dma channel (if we opened both of them) */ 993 994 if ((want & 2) && (get_dma_residue(3)==sizeof(struct lt_mem))) { 995 want &= ~2; 996 free_dma(3); 997 } 998 999 if ((want & 1) && (get_dma_residue(1)==sizeof(struct lt_mem))) { 1000 want &= ~1; 1001 free_dma(1); 1002 } 1003 1004 if (!want) 1005 return 0; 1006 1007 return (want & 2) ? 3 : 1; 1008} 1009 1010static const struct net_device_ops ltpc_netdev = { 1011 .ndo_start_xmit = ltpc_xmit, 1012 .ndo_do_ioctl = ltpc_ioctl, 1013 .ndo_set_rx_mode = set_multicast_list, 1014}; 1015 1016struct net_device * __init ltpc_probe(void) 1017{ 1018 struct net_device *dev; 1019 int err = -ENOMEM; 1020 int x=0,y=0; 1021 int autoirq; 1022 unsigned long f; 1023 unsigned long timeout; 1024 1025 dev = alloc_ltalkdev(sizeof(struct ltpc_private)); 1026 if (!dev) 1027 goto out; 1028 1029 /* probe for the I/O port address */ 1030 1031 if (io != 0x240 && request_region(0x220,8,"ltpc")) { 1032 x = inb_p(0x220+6); 1033 if ( (x!=0xff) && (x>=0xf0) ) { 1034 io = 0x220; 1035 goto got_port; 1036 } 1037 release_region(0x220,8); 1038 } 1039 if (io != 0x220 && request_region(0x240,8,"ltpc")) { 1040 y = inb_p(0x240+6); 1041 if ( (y!=0xff) && (y>=0xf0) ){ 1042 io = 0x240; 1043 goto got_port; 1044 } 1045 release_region(0x240,8); 1046 } 1047 1048 /* give up in despair */ 1049 printk(KERN_ERR "LocalTalk card not found; 220 = %02x, 240 = %02x.\n", x,y); 1050 err = -ENODEV; 1051 goto out1; 1052 1053 got_port: 1054 /* probe for the IRQ line */ 1055 if (irq < 2) { 1056 unsigned long irq_mask; 1057 1058 irq_mask = probe_irq_on(); 1059 /* reset the interrupt line */ 1060 inb_p(io+7); 1061 inb_p(io+7); 1062 /* trigger an interrupt (I hope) */ 1063 inb_p(io+6); 1064 mdelay(2); 1065 autoirq = probe_irq_off(irq_mask); 1066 1067 if (autoirq == 0) { 1068 printk(KERN_ERR "ltpc: probe at %#x failed to detect IRQ line.\n", io); 1069 } else { 1070 irq = autoirq; 1071 } 1072 } 1073 1074 /* allocate a DMA buffer */ 1075 ltdmabuf = (unsigned char *) dma_mem_alloc(1000); 1076 if (!ltdmabuf) { 1077 printk(KERN_ERR "ltpc: mem alloc failed\n"); 1078 err = -ENOMEM; 1079 goto out2; 1080 } 1081 1082 ltdmacbuf = <dmabuf[800]; 1083 1084 if(debug & DEBUG_VERBOSE) { 1085 printk("ltdmabuf pointer %08lx\n",(unsigned long) ltdmabuf); 1086 } 1087 1088 /* reset the card */ 1089 1090 inb_p(io+1); 1091 inb_p(io+3); 1092 1093 msleep(20); 1094 1095 inb_p(io+0); 1096 inb_p(io+2); 1097 inb_p(io+7); /* clear reset */ 1098 inb_p(io+4); 1099 inb_p(io+5); 1100 inb_p(io+5); /* enable dma */ 1101 inb_p(io+6); /* tri-state interrupt line */ 1102 1103 ssleep(1); 1104 1105 /* now, figure out which dma channel we're using, unless it's 1106 already been specified */ 1107 /* well, 0 is a legal DMA channel, but the LTPC card doesn't 1108 use it... */ 1109 dma = ltpc_probe_dma(io, dma); 1110 if (!dma) { /* no dma channel */ 1111 printk(KERN_ERR "No DMA channel found on ltpc card.\n"); 1112 err = -ENODEV; 1113 goto out3; 1114 } 1115 1116 /* print out friendly message */ 1117 if(irq) 1118 printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, IR%d, DMA%d.\n",io,irq,dma); 1119 else 1120 printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, DMA%d. Using polled mode.\n",io,dma); 1121 1122 dev->netdev_ops = <pc_netdev; 1123 dev->base_addr = io; 1124 dev->irq = irq; 1125 dev->dma = dma; 1126 1127 /* the card will want to send a result at this point */ 1128 /* (I think... leaving out this part makes the kernel crash, 1129 so I put it back in...) */ 1130 1131 f=claim_dma_lock(); 1132 disable_dma(dma); 1133 clear_dma_ff(dma); 1134 set_dma_mode(dma,DMA_MODE_READ); 1135 set_dma_addr(dma,virt_to_bus(ltdmabuf)); 1136 set_dma_count(dma,0x100); 1137 enable_dma(dma); 1138 release_dma_lock(f); 1139 1140 (void) inb_p(io+3); 1141 (void) inb_p(io+2); 1142 timeout = jiffies+100*HZ/100; 1143 1144 while(time_before(jiffies, timeout)) { 1145 if( 0xf9 == inb_p(io+6)) 1146 break; 1147 schedule(); 1148 } 1149 1150 if(debug & DEBUG_VERBOSE) { 1151 printk("setting up timer and irq\n"); 1152 } 1153 1154 /* grab it and don't let go :-) */ 1155 if (irq && request_irq( irq, ltpc_interrupt, 0, "ltpc", dev) >= 0) 1156 { 1157 (void) inb_p(io+7); /* enable interrupts from board */ 1158 (void) inb_p(io+7); /* and reset irq line */ 1159 } else { 1160 if( irq ) 1161 printk(KERN_ERR "ltpc: IRQ already in use, using polled mode.\n"); 1162 dev->irq = 0; 1163 /* polled mode -- 20 times per second */ 1164 /* this is really, really slow... should it poll more often? */ 1165 ltpc_timer_dev = dev; 1166 timer_setup(<pc_timer, ltpc_poll, 0); 1167 1168 ltpc_timer.expires = jiffies + HZ/20; 1169 add_timer(<pc_timer); 1170 } 1171 err = register_netdev(dev); 1172 if (err) 1173 goto out4; 1174 1175 return NULL; 1176out4: 1177 del_timer_sync(<pc_timer); 1178 if (dev->irq) 1179 free_irq(dev->irq, dev); 1180out3: 1181 free_pages((unsigned long)ltdmabuf, get_order(1000)); 1182out2: 1183 release_region(io, 8); 1184out1: 1185 free_netdev(dev); 1186out: 1187 return ERR_PTR(err); 1188} 1189 1190#ifndef MODULE 1191/* handles "ltpc=io,irq,dma" kernel command lines */ 1192static int __init ltpc_setup(char *str) 1193{ 1194 int ints[5]; 1195 1196 str = get_options(str, ARRAY_SIZE(ints), ints); 1197 1198 if (ints[0] == 0) { 1199 if (str && !strncmp(str, "auto", 4)) { 1200 /* do nothing :-) */ 1201 } 1202 else { 1203 /* usage message */ 1204 printk (KERN_ERR 1205 "ltpc: usage: ltpc=auto|iobase[,irq[,dma]]\n"); 1206 return 0; 1207 } 1208 } else { 1209 io = ints[1]; 1210 if (ints[0] > 1) { 1211 irq = ints[2]; 1212 } 1213 if (ints[0] > 2) { 1214 dma = ints[3]; 1215 } 1216 /* ignore any other parameters */ 1217 } 1218 return 1; 1219} 1220 1221__setup("ltpc=", ltpc_setup); 1222#endif /* MODULE */ 1223 1224static struct net_device *dev_ltpc; 1225 1226#ifdef MODULE 1227 1228MODULE_LICENSE("GPL"); 1229module_param(debug, int, 0); 1230module_param_hw(io, int, ioport, 0); 1231module_param_hw(irq, int, irq, 0); 1232module_param_hw(dma, int, dma, 0); 1233 1234 1235static int __init ltpc_module_init(void) 1236{ 1237 if(io == 0) 1238 printk(KERN_NOTICE 1239 "ltpc: Autoprobing is not recommended for modules\n"); 1240 1241 dev_ltpc = ltpc_probe(); 1242 return PTR_ERR_OR_ZERO(dev_ltpc); 1243} 1244module_init(ltpc_module_init); 1245#endif 1246 1247static void __exit ltpc_cleanup(void) 1248{ 1249 1250 if(debug & DEBUG_VERBOSE) printk("unregister_netdev\n"); 1251 unregister_netdev(dev_ltpc); 1252 1253 del_timer_sync(<pc_timer); 1254 1255 if(debug & DEBUG_VERBOSE) printk("freeing irq\n"); 1256 1257 if (dev_ltpc->irq) 1258 free_irq(dev_ltpc->irq, dev_ltpc); 1259 1260 if(debug & DEBUG_VERBOSE) printk("freeing dma\n"); 1261 1262 if (dev_ltpc->dma) 1263 free_dma(dev_ltpc->dma); 1264 1265 if(debug & DEBUG_VERBOSE) printk("freeing ioaddr\n"); 1266 1267 if (dev_ltpc->base_addr) 1268 release_region(dev_ltpc->base_addr,8); 1269 1270 free_netdev(dev_ltpc); 1271 1272 if(debug & DEBUG_VERBOSE) printk("free_pages\n"); 1273 1274 free_pages( (unsigned long) ltdmabuf, get_order(1000)); 1275 1276 if(debug & DEBUG_VERBOSE) printk("returning from cleanup_module\n"); 1277} 1278 1279module_exit(ltpc_cleanup); 1280