projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / net / appletalk / ltpc.c
CommitLineData
1da177e4
LT		 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>
1da177e4
LT		 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>
5a0e3ad6 230#include <linux/gfp.h>
1da177e4
LT		 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
239static DEFINE_SPINLOCK(txqueue_lock);
240static DEFINE_SPINLOCK(mbox_lock);
241
242/* function prototypes */
243static int do_read(struct net_device *dev, void *cbuf, int cbuflen,
244 void *dbuf, int dbuflen);
245static int sendup_buffer (struct net_device *dev);
246
247/* Dma Memory related stuff, cribbed directly from 3c505.c */
248
249static 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 */
257static unsigned char *ltdmabuf;
258static unsigned char *ltdmacbuf;
259
260/* private struct, holds our appletalk address */
261
262struct ltpc_private
263{
1da177e4
LT		 264 struct atalk_addr my_addr;
265};
266
267/* transmit queue element struct */
268
269struct 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
283static struct xmitQel *xmQhd, *xmQtl;
284
285static 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
303static 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 */
330static struct xmitQel qels[16];
331
332/* and their corresponding mailboxes */
333static unsigned char mailbox[16];
334static unsigned char mboxinuse[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
335
336static 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
353static 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 */
369static 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 */
393static 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
415static 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
443static 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
466static 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 */
487static unsigned char rescbuf[2] = {LT_GETRESULT,0};
488static unsigned char resdbuf[2];
489
490static 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
496static 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
521loop:
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
631done:
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 return;
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 = (unsigned char *) cbuf;
657 qels[i].cbuflen = cbuflen;
658 qels[i].dbuf = (unsigned char *) 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 = (unsigned char *) cbuf;
681 qels[i].cbuflen = cbuflen;
682 qels[i].dbuf = (unsigned char *) 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;
699
0fc48098 700static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev);
1da177e4
LT		 701
702static int read_30 ( struct net_device *dev)
703{
704 lt_command c;
705 c.getflags.command = LT_GETFLAGS;
706 return do_read(dev, &c, sizeof(c.getflags),&c,0);
707}
708
709static int set_30 (struct net_device *dev,int x)
710{
711 lt_command c;
712 c.setflags.command = LT_SETFLAGS;
713 c.setflags.flags = x;
714 return do_write(dev, &c, sizeof(c.setflags),&c,0);
715}
716
717/* LLAP to DDP translation */
718
719static int sendup_buffer (struct net_device *dev)
720{
721 /* on entry, command is in ltdmacbuf, data in ltdmabuf */
722 /* called from idle, non-reentrant */
723
724 int dnode, snode, llaptype, len;
725 int sklen;
726 struct sk_buff *skb;
1da177e4
LT		 727 struct lt_rcvlap *ltc = (struct lt_rcvlap *) ltdmacbuf;
728
729 if (ltc->command != LT_RCVLAP) {
730 printk("unknown command 0x%02x from ltpc card\n",ltc->command);
731 return(-1);
732 }
733 dnode = ltc->dnode;
734 snode = ltc->snode;
735 llaptype = ltc->laptype;
736 len = ltc->length;
737
738 sklen = len;
739 if (llaptype == 1)
740 sklen += 8; /* correct for short ddp */
741 if(sklen > 800) {
742 printk(KERN_INFO "%s: nonsense length in ltpc command 0x14: 0x%08x\n",
743 dev->name,sklen);
744 return -1;
745 }
746
747 if ( (llaptype==0) || (llaptype>2) ) {
748 printk(KERN_INFO "%s: unknown LLAP type: %d\n",dev->name,llaptype);
749 return -1;
750 }
751
752
753 skb = dev_alloc_skb(3+sklen);
754 if (skb == NULL)
755 {
756 printk("%s: dropping packet due to memory squeeze.\n",
757 dev->name);
758 return -1;
759 }
760 skb->dev = dev;
761
762 if (sklen > len)
763 skb_reserve(skb,8);
764 skb_put(skb,len+3);
765 skb->protocol = htons(ETH_P_LOCALTALK);
766 /* add LLAP header */
767 skb->data[0] = dnode;
768 skb->data[1] = snode;
769 skb->data[2] = llaptype;
459a98ed 770 skb_reset_mac_header(skb); /* save pointer to llap header */
1da177e4
LT		 771 skb_pull(skb,3);
772
773 /* copy ddp(s,e)hdr + contents */
27d7ff46 774 skb_copy_to_linear_data(skb, ltdmabuf, len);
1da177e4 775
badff6d0 776 skb_reset_transport_header(skb);
1da177e4 777
4fafc123
SH		 778 dev->stats.rx_packets++;
779 dev->stats.rx_bytes += skb->len;
1da177e4
LT		 780
781 /* toss it onwards */
782 netif_rx(skb);
1da177e4
LT		 783 return 0;
784}
785
786/* the handler for the board interrupt */
787
788static irqreturn_t
7d12e780 789ltpc_interrupt(int irq, void *dev_id)
1da177e4
LT		 790{
791 struct net_device *dev = dev_id;
792
793 if (dev==NULL) {
794 printk("ltpc_interrupt: unknown device.\n");
795 return IRQ_NONE;
796 }
797
798 inb_p(dev->base_addr+6); /* disable further interrupts from board */
799
800 idle(dev); /* handle whatever is coming in */
801
802 /* idle re-enables interrupts from board */
803
804 return IRQ_HANDLED;
805}
806
807/***
808 *
809 * The ioctls that the driver responds to are:
810 *
811 * SIOCSIFADDR -- do probe using the passed node hint.
812 * SIOCGIFADDR -- return net, node.
813 *
814 * some of this stuff should be done elsewhere.
815 *
816 ***/
817
818static int ltpc_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
819{
820 struct sockaddr_at *sa = (struct sockaddr_at *) &ifr->ifr_addr;
821 /* we'll keep the localtalk node address in dev->pa_addr */
454d7c9b
WC		 822 struct ltpc_private *ltpc_priv = netdev_priv(dev);
823 struct atalk_addr *aa = &ltpc_priv->my_addr;
1da177e4
LT		 824 struct lt_init c;
825 int ltflags;
826
827 if(debug & DEBUG_VERBOSE) printk("ltpc_ioctl called\n");
828
829 switch(cmd) {
830 case SIOCSIFADDR:
831
832 aa->s_net = sa->sat_addr.s_net;
833
834 /* this does the probe and returns the node addr */
835 c.command = LT_INIT;
836 c.hint = sa->sat_addr.s_node;
837
838 aa->s_node = do_read(dev,&c,sizeof(c),&c,0);
839
840 /* get all llap frames raw */
841 ltflags = read_30(dev);
842 ltflags |= LT_FLAG_ALLLAP;
843 set_30 (dev,ltflags);
844
845 dev->broadcast[0] = 0xFF;
846 dev->dev_addr[0] = aa->s_node;
847
848 dev->addr_len=1;
849
850 return 0;
851
852 case SIOCGIFADDR:
853
854 sa->sat_addr.s_net = aa->s_net;
855 sa->sat_addr.s_node = aa->s_node;
856
857 return 0;
858
859 default:
860 return -EINVAL;
861 }
862}
863
864static void set_multicast_list(struct net_device *dev)
865{
866 /* This needs to be present to keep netatalk happy. */
867 /* Actually netatalk needs fixing! */
868}
869
1da177e4
LT		 870static int ltpc_poll_counter;
871
872static void ltpc_poll(unsigned long l)
873{
874 struct net_device *dev = (struct net_device *) l;
875
876 del_timer(&ltpc_timer);
877
878 if(debug & DEBUG_VERBOSE) {
879 if (!ltpc_poll_counter) {
880 ltpc_poll_counter = 50;
881 printk("ltpc poll is alive\n");
882 }
883 ltpc_poll_counter--;
884 }
885
886 if (!dev)
887 return; /* we've been downed */
888
889 /* poll 20 times per second */
890 idle(dev);
891 ltpc_timer.expires = jiffies + HZ/20;
892
893 add_timer(&ltpc_timer);
894}
895
896/* DDP to LLAP translation */
897
0fc48098 898static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev)
1da177e4
LT		 899{
900 /* in kernel 1.3.xx, on entry skb->data points to ddp header,
901 * and skb->len is the length of the ddp data + ddp header
902 */
1da177e4
LT		 903 int i;
904 struct lt_sendlap cbuf;
9c70220b 905 unsigned char *hdr;
1da177e4
LT		 906
907 cbuf.command = LT_SENDLAP;
908 cbuf.dnode = skb->data[0];
909 cbuf.laptype = skb->data[2];
910 skb_pull(skb,3); /* skip past LLAP header */
911 cbuf.length = skb->len; /* this is host order */
badff6d0 912 skb_reset_transport_header(skb);
1da177e4
LT		 913
914 if(debug & DEBUG_UPPER) {
915 printk("command ");
916 for(i=0;i<6;i++)
917 printk("%02x ",((unsigned char *)&cbuf)[i]);
918 printk("\n");
919 }
920
9c70220b
ACM		 921 hdr = skb_transport_header(skb);
922 do_write(dev, &cbuf, sizeof(cbuf), hdr, skb->len);
1da177e4
LT		 923
924 if(debug & DEBUG_UPPER) {
925 printk("sent %d ddp bytes\n",skb->len);
9c70220b
ACM		 926 for (i = 0; i < skb->len; i++)
927 printk("%02x ", hdr[i]);
1da177e4
LT		 928 printk("\n");
929 }
930
4fafc123
SH		 931 dev->stats.tx_packets++;
932 dev->stats.tx_bytes += skb->len;
1da177e4
LT		 933
934 dev_kfree_skb(skb);
6ed10654 935 return NETDEV_TX_OK;
1da177e4
LT		 936}
937
1da177e4
LT		 938/* initialization stuff */
939
940static int __init ltpc_probe_dma(int base, int dma)
941{
942 int want = (dma == 3) ? 2 : (dma == 1) ? 1 : 3;
943 unsigned long timeout;
944 unsigned long f;
945
946 if (want & 1) {
947 if (request_dma(1,"ltpc")) {
948 want &= ~1;
949 } else {
950 f=claim_dma_lock();
951 disable_dma(1);
952 clear_dma_ff(1);
953 set_dma_mode(1,DMA_MODE_WRITE);
954 set_dma_addr(1,virt_to_bus(ltdmabuf));
955 set_dma_count(1,sizeof(struct lt_mem));
956 enable_dma(1);
957 release_dma_lock(f);
958 }
959 }
960 if (want & 2) {
961 if (request_dma(3,"ltpc")) {
962 want &= ~2;
963 } else {
964 f=claim_dma_lock();
965 disable_dma(3);
966 clear_dma_ff(3);
967 set_dma_mode(3,DMA_MODE_WRITE);
968 set_dma_addr(3,virt_to_bus(ltdmabuf));
969 set_dma_count(3,sizeof(struct lt_mem));
970 enable_dma(3);
971 release_dma_lock(f);
972 }
973 }
974 /* set up request */
975
976 /* FIXME -- do timings better! */
977
978 ltdmabuf[0] = LT_READMEM;
979 ltdmabuf[1] = 1; /* mailbox */
980 ltdmabuf[2] = 0; ltdmabuf[3] = 0; /* address */
981 ltdmabuf[4] = 0; ltdmabuf[5] = 1; /* read 0x0100 bytes */
982 ltdmabuf[6] = 0; /* dunno if this is necessary */
983
984 inb_p(io+1);
985 inb_p(io+0);
986 timeout = jiffies+100*HZ/100;
987 while(time_before(jiffies, timeout)) {
988 if ( 0xfa == inb_p(io+6) ) break;
989 }
990
991 inb_p(io+3);
992 inb_p(io+2);
993 while(time_before(jiffies, timeout)) {
994 if ( 0xfb == inb_p(io+6) ) break;
995 }
996
997 /* release the other dma channel (if we opened both of them) */
998
999 if ((want & 2) && (get_dma_residue(3)==sizeof(struct lt_mem))) {
1000 want &= ~2;
1001 free_dma(3);
1002 }
1003
1004 if ((want & 1) && (get_dma_residue(1)==sizeof(struct lt_mem))) {
1005 want &= ~1;
1006 free_dma(1);
1007 }
1008
1009 if (!want)
1010 return 0;
1011
1012 return (want & 2) ? 3 : 1;
1013}
1014
816b26f5
SH		 1015static const struct net_device_ops ltpc_netdev = {
1016 .ndo_start_xmit = ltpc_xmit,
1017 .ndo_do_ioctl = ltpc_ioctl,
1018 .ndo_set_multicast_list = set_multicast_list,
1019};
1020
1da177e4
LT		 1021struct net_device * __init ltpc_probe(void)
1022{
1023 struct net_device *dev;
1024 int err = -ENOMEM;
1025 int x=0,y=0;
1026 int autoirq;
1027 unsigned long f;
1028 unsigned long timeout;
1029
3ef4e9a8 1030 dev = alloc_ltalkdev(sizeof(struct ltpc_private));
1da177e4
LT		 1031 if (!dev)
1032 goto out;
1033
1da177e4
LT		 1034 /* probe for the I/O port address */
1035
1036 if (io != 0x240 && request_region(0x220,8,"ltpc")) {
1037 x = inb_p(0x220+6);
1038 if ( (x!=0xff) && (x>=0xf0) ) {
1039 io = 0x220;
1040 goto got_port;
1041 }
1042 release_region(0x220,8);
1043 }
1044 if (io != 0x220 && request_region(0x240,8,"ltpc")) {
1045 y = inb_p(0x240+6);
1046 if ( (y!=0xff) && (y>=0xf0) ){
1047 io = 0x240;
1048 goto got_port;
1049 }
1050 release_region(0x240,8);
1051 }
1052
1053 /* give up in despair */
1054 printk(KERN_ERR "LocalTalk card not found; 220 = %02x, 240 = %02x.\n", x,y);
1055 err = -ENODEV;
1056 goto out1;
1057
1058 got_port:
1059 /* probe for the IRQ line */
1060 if (irq < 2) {
1061 unsigned long irq_mask;
1062
1063 irq_mask = probe_irq_on();
1064 /* reset the interrupt line */
1065 inb_p(io+7);
1066 inb_p(io+7);
1067 /* trigger an interrupt (I hope) */
1068 inb_p(io+6);
1069 mdelay(2);
1070 autoirq = probe_irq_off(irq_mask);
1071
1072 if (autoirq == 0) {
1073 printk(KERN_ERR "ltpc: probe at %#x failed to detect IRQ line.\n", io);
1074 } else {
1075 irq = autoirq;
1076 }
1077 }
1078
1079 /* allocate a DMA buffer */
1080 ltdmabuf = (unsigned char *) dma_mem_alloc(1000);
1081 if (!ltdmabuf) {
1082 printk(KERN_ERR "ltpc: mem alloc failed\n");
1083 err = -ENOMEM;
1084 goto out2;
1085 }
1086
1087 ltdmacbuf = &ltdmabuf[800];
1088
1089 if(debug & DEBUG_VERBOSE) {
1090 printk("ltdmabuf pointer %08lx\n",(unsigned long) ltdmabuf);
1091 }
1092
1093 /* reset the card */
1094
1095 inb_p(io+1);
1096 inb_p(io+3);
1097
2c4ee8f9 1098 msleep(20);
1da177e4
LT		 1099
1100 inb_p(io+0);
1101 inb_p(io+2);
1102 inb_p(io+7); /* clear reset */
1103 inb_p(io+4);
1104 inb_p(io+5);
1105 inb_p(io+5); /* enable dma */
1106 inb_p(io+6); /* tri-state interrupt line */
1107
2c4ee8f9 1108 ssleep(1);
1da177e4
LT		 1109
1110 /* now, figure out which dma channel we're using, unless it's
1111 already been specified */
1112 /* well, 0 is a legal DMA channel, but the LTPC card doesn't
1113 use it... */
1114 dma = ltpc_probe_dma(io, dma);
1115 if (!dma) { /* no dma channel */
1116 printk(KERN_ERR "No DMA channel found on ltpc card.\n");
1117 err = -ENODEV;
1118 goto out3;
1119 }
1120
1121 /* print out friendly message */
1122 if(irq)
1123 printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, IR%d, DMA%d.\n",io,irq,dma);
1124 else
1125 printk(KERN_INFO "Apple/Farallon LocalTalk-PC card at %03x, DMA%d. Using polled mode.\n",io,dma);
1126
816b26f5 1127 dev->netdev_ops = &ltpc_netdev;
1da177e4
LT		 1128 dev->base_addr = io;
1129 dev->irq = irq;
1130 dev->dma = dma;
1131
1132 /* the card will want to send a result at this point */
1133 /* (I think... leaving out this part makes the kernel crash,
1134 so I put it back in...) */
1135
1136 f=claim_dma_lock();
1137 disable_dma(dma);
1138 clear_dma_ff(dma);
1139 set_dma_mode(dma,DMA_MODE_READ);
1140 set_dma_addr(dma,virt_to_bus(ltdmabuf));
1141 set_dma_count(dma,0x100);
1142 enable_dma(dma);
1143 release_dma_lock(f);
1144
1145 (void) inb_p(io+3);
1146 (void) inb_p(io+2);
1147 timeout = jiffies+100*HZ/100;
1148
1149 while(time_before(jiffies, timeout)) {
1150 if( 0xf9 == inb_p(io+6))
1151 break;
1152 schedule();
1153 }
1154
1155 if(debug & DEBUG_VERBOSE) {
1156 printk("setting up timer and irq\n");
1157 }
1158
1159 /* grab it and don't let go :-) */
a0607fd3 1160 if (irq && request_irq( irq, ltpc_interrupt, 0, "ltpc", dev) >= 0)
1da177e4
LT		 1161 {
1162 (void) inb_p(io+7); /* enable interrupts from board */
1163 (void) inb_p(io+7); /* and reset irq line */
1164 } else {
1165 if( irq )
1166 printk(KERN_ERR "ltpc: IRQ already in use, using polled mode.\n");
1167 dev->irq = 0;
1168 /* polled mode -- 20 times per second */
1169 /* this is really, really slow... should it poll more often? */
1170 init_timer(&ltpc_timer);
1171 ltpc_timer.function=ltpc_poll;
1172 ltpc_timer.data = (unsigned long) dev;
1173
1174 ltpc_timer.expires = jiffies + HZ/20;
1175 add_timer(&ltpc_timer);
1176 }
1177 err = register_netdev(dev);
1178 if (err)
1179 goto out4;
1180
1181 return NULL;
1182out4:
1183 del_timer_sync(&ltpc_timer);
1184 if (dev->irq)
1185 free_irq(dev->irq, dev);
1186out3:
1187 free_pages((unsigned long)ltdmabuf, get_order(1000));
1188out2:
1189 release_region(io, 8);
1190out1:
1191 free_netdev(dev);
1192out:
1193 return ERR_PTR(err);
1194}
1195
1196#ifndef MODULE
1197/* handles "ltpc=io,irq,dma" kernel command lines */
1198static int __init ltpc_setup(char *str)
1199{
1200 int ints[5];
1201
1202 str = get_options(str, ARRAY_SIZE(ints), ints);
1203
1204 if (ints[0] == 0) {
1205 if (str && !strncmp(str, "auto", 4)) {
1206 /* do nothing :-) */
1207 }
1208 else {
1209 /* usage message */
1210 printk (KERN_ERR
1211 "ltpc: usage: ltpc=auto|iobase[,irq[,dma]]\n");
1212 return 0;
1213 }
1214 } else {
1215 io = ints[1];
1216 if (ints[0] > 1) {
1217 irq = ints[2];
1218 }
1219 if (ints[0] > 2) {
1220 dma = ints[3];
1221 }
98a1708d 1222 /* ignore any other parameters */
1da177e4
LT		 1223 }
1224 return 1;
1225}
1226
1227__setup("ltpc=", ltpc_setup);
1228#endif /* MODULE */
1229
1230static struct net_device *dev_ltpc;
1231
1232#ifdef MODULE
1233
1234MODULE_LICENSE("GPL");
1235module_param(debug, int, 0);
1236module_param(io, int, 0);
1237module_param(irq, int, 0);
1238module_param(dma, int, 0);
1239
1240
32c98747 1241static int __init ltpc_module_init(void)
1da177e4
LT		 1242{
1243 if(io == 0)
1244 printk(KERN_NOTICE
1245 "ltpc: Autoprobing is not recommended for modules\n");
1246
1247 dev_ltpc = ltpc_probe();
1248 if (IS_ERR(dev_ltpc))
1249 return PTR_ERR(dev_ltpc);
1250 return 0;
1251}
32c98747 1252module_init(ltpc_module_init);
1da177e4
LT		 1253#endif
1254
1255static void __exit ltpc_cleanup(void)
1256{
1257
1258 if(debug & DEBUG_VERBOSE) printk("unregister_netdev\n");
1259 unregister_netdev(dev_ltpc);
1260
1261 ltpc_timer.data = 0; /* signal the poll routine that we're done */
1262
1263 del_timer_sync(&ltpc_timer);
1264
1265 if(debug & DEBUG_VERBOSE) printk("freeing irq\n");
1266
1267 if (dev_ltpc->irq)
1268 free_irq(dev_ltpc->irq, dev_ltpc);
1269
1270 if(debug & DEBUG_VERBOSE) printk("freeing dma\n");
1271
1272 if (dev_ltpc->dma)
1273 free_dma(dev_ltpc->dma);
1274
1275 if(debug & DEBUG_VERBOSE) printk("freeing ioaddr\n");
1276
1277 if (dev_ltpc->base_addr)
1278 release_region(dev_ltpc->base_addr,8);
1279
1280 free_netdev(dev_ltpc);
1281
1282 if(debug & DEBUG_VERBOSE) printk("free_pages\n");
1283
1284 free_pages( (unsigned long) ltdmabuf, get_order(1000));
1285
1286 if(debug & DEBUG_VERBOSE) printk("returning from cleanup_module\n");
1287}
1288
1289module_exit(ltpc_cleanup);
kernel source for telekom puls (alcatel/mediatek)