1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
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/slab.h>
219#include <linux/string.h>
220#include <linux/errno.h>
221#include <linux/init.h>
222#include <linux/netdevice.h>
223#include <linux/etherdevice.h>
224#include <linux/skbuff.h>
225#include <linux/if_arp.h>
226#include <linux/if_ltalk.h>
227#include <linux/delay.h>
228#include <linux/timer.h>
229#include <linux/atalk.h>
230#include <linux/bitops.h>
231
232#include <asm/system.h>
233#include <asm/dma.h>
234#include <asm/io.h>
235
236
237#include "ltpc.h"
238
239static DEFINE_SPINLOCK(txqueue_lock);
240static DEFINE_SPINLOCK(mbox_lock);
241
242
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
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
257static unsigned char *ltdmabuf;
258static unsigned char *ltdmacbuf;
259
260
261
262struct ltpc_private
263{
264 struct atalk_addr my_addr;
265};
266
267
268
269struct xmitQel {
270 struct xmitQel *next;
271
272 unsigned char *cbuf;
273 short cbuflen;
274
275 unsigned char *dbuf;
276 short dbuflen;
277 unsigned char QWrite;
278 unsigned char mailbox;
279};
280
281
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
330static struct xmitQel qels[16];
331
332
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
339
340 int i;
341
342
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;
349}
350
351
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
369static void handlefc(struct net_device *dev)
370{
371
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
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
418
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
446
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
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
487static unsigned char rescbuf[2] = {LT_GETRESULT,0};
488static unsigned char resdbuf[2];
489
490static int QInIdle;
491
492
493
494
495
496static void idle(struct net_device *dev)
497{
498 unsigned long flags;
499 int state;
500
501
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
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
533 if (debug & DEBUG_LOWER) printk("idle: fc\n");
534 handlefc(dev);
535 break;
536 case 0xfd:
537
538 if(debug & DEBUG_LOWER) printk("idle: fd\n");
539 handlefd(dev);
540 break;
541 case 0xf9:
542
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
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
589 goto done;
590 }
591 } else {
592
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
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
617
618
619 if(q->mailbox) {
620 memcpy(q->dbuf,ltdmabuf,q->dbuflen);
621 } else {
622
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
635
636
637
638
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;
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;
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
697
698static struct timer_list ltpc_timer;
699
700static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev);
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
718
719static int sendup_buffer (struct net_device *dev)
720{
721
722
723
724 int dnode, snode, llaptype, len;
725 int sklen;
726 struct sk_buff *skb;
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;
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
767 skb->data[0] = dnode;
768 skb->data[1] = snode;
769 skb->data[2] = llaptype;
770 skb_reset_mac_header(skb);
771 skb_pull(skb,3);
772
773
774 skb_copy_to_linear_data(skb, ltdmabuf, len);
775
776 skb_reset_transport_header(skb);
777
778 dev->stats.rx_packets++;
779 dev->stats.rx_bytes += skb->len;
780
781
782 netif_rx(skb);
783 return 0;
784}
785
786
787
788static irqreturn_t
789ltpc_interrupt(int irq, void *dev_id)
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);
799
800 idle(dev);
801
802
803
804 return IRQ_HANDLED;
805}
806
807
808
809
810
811
812
813
814
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
822 struct ltpc_private *ltpc_priv = netdev_priv(dev);
823 struct atalk_addr *aa = <pc_priv->my_addr;
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
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
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
867
868}
869
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(<pc_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;
888
889
890 idle(dev);
891 ltpc_timer.expires = jiffies + HZ/20;
892
893 add_timer(<pc_timer);
894}
895
896
897
898static netdev_tx_t ltpc_xmit(struct sk_buff *skb, struct net_device *dev)
899{
900
901
902
903 int i;
904 struct lt_sendlap cbuf;
905 unsigned char *hdr;
906
907 cbuf.command = LT_SENDLAP;
908 cbuf.dnode = skb->data[0];
909 cbuf.laptype = skb->data[2];
910 skb_pull(skb,3);
911 cbuf.length = skb->len;
912 skb_reset_transport_header(skb);
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
921 hdr = skb_transport_header(skb);
922 do_write(dev, &cbuf, sizeof(cbuf), hdr, skb->len);
923
924 if(debug & DEBUG_UPPER) {
925 printk("sent %d ddp bytes\n",skb->len);
926 for (i = 0; i < skb->len; i++)
927 printk("%02x ", hdr[i]);
928 printk("\n");
929 }
930
931 dev->stats.tx_packets++;
932 dev->stats.tx_bytes += skb->len;
933
934 dev_kfree_skb(skb);
935 return NETDEV_TX_OK;
936}
937
938
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
975
976
977
978 ltdmabuf[0] = LT_READMEM;
979 ltdmabuf[1] = 1;
980 ltdmabuf[2] = 0; ltdmabuf[3] = 0;
981 ltdmabuf[4] = 0; ltdmabuf[5] = 1;
982 ltdmabuf[6] = 0;
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
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
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
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
1030 dev = alloc_ltalkdev(sizeof(struct ltpc_private));
1031 if (!dev)
1032 goto out;
1033
1034
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
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
1060 if (irq < 2) {
1061 unsigned long irq_mask;
1062
1063 irq_mask = probe_irq_on();
1064
1065 inb_p(io+7);
1066 inb_p(io+7);
1067
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
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 = <dmabuf[800];
1088
1089 if(debug & DEBUG_VERBOSE) {
1090 printk("ltdmabuf pointer %08lx\n",(unsigned long) ltdmabuf);
1091 }
1092
1093
1094
1095 inb_p(io+1);
1096 inb_p(io+3);
1097
1098 msleep(20);
1099
1100 inb_p(io+0);
1101 inb_p(io+2);
1102 inb_p(io+7);
1103 inb_p(io+4);
1104 inb_p(io+5);
1105 inb_p(io+5);
1106 inb_p(io+6);
1107
1108 ssleep(1);
1109
1110
1111
1112
1113
1114 dma = ltpc_probe_dma(io, dma);
1115 if (!dma) {
1116 printk(KERN_ERR "No DMA channel found on ltpc card.\n");
1117 err = -ENODEV;
1118 goto out3;
1119 }
1120
1121
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
1127 dev->netdev_ops = <pc_netdev;
1128 dev->mc_list = NULL;
1129 dev->base_addr = io;
1130 dev->irq = irq;
1131 dev->dma = dma;
1132
1133
1134
1135
1136
1137 f=claim_dma_lock();
1138 disable_dma(dma);
1139 clear_dma_ff(dma);
1140 set_dma_mode(dma,DMA_MODE_READ);
1141 set_dma_addr(dma,virt_to_bus(ltdmabuf));
1142 set_dma_count(dma,0x100);
1143 enable_dma(dma);
1144 release_dma_lock(f);
1145
1146 (void) inb_p(io+3);
1147 (void) inb_p(io+2);
1148 timeout = jiffies+100*HZ/100;
1149
1150 while(time_before(jiffies, timeout)) {
1151 if( 0xf9 == inb_p(io+6))
1152 break;
1153 schedule();
1154 }
1155
1156 if(debug & DEBUG_VERBOSE) {
1157 printk("setting up timer and irq\n");
1158 }
1159
1160
1161 if (irq && request_irq( irq, <pc_interrupt, 0, "ltpc", dev) >= 0)
1162 {
1163 (void) inb_p(io+7);
1164 (void) inb_p(io+7);
1165 } else {
1166 if( irq )
1167 printk(KERN_ERR "ltpc: IRQ already in use, using polled mode.\n");
1168 dev->irq = 0;
1169
1170
1171 init_timer(<pc_timer);
1172 ltpc_timer.function=ltpc_poll;
1173 ltpc_timer.data = (unsigned long) dev;
1174
1175 ltpc_timer.expires = jiffies + HZ/20;
1176 add_timer(<pc_timer);
1177 }
1178 err = register_netdev(dev);
1179 if (err)
1180 goto out4;
1181
1182 return NULL;
1183out4:
1184 del_timer_sync(<pc_timer);
1185 if (dev->irq)
1186 free_irq(dev->irq, dev);
1187out3:
1188 free_pages((unsigned long)ltdmabuf, get_order(1000));
1189out2:
1190 release_region(io, 8);
1191out1:
1192 free_netdev(dev);
1193out:
1194 return ERR_PTR(err);
1195}
1196
1197#ifndef MODULE
1198
1199static int __init ltpc_setup(char *str)
1200{
1201 int ints[5];
1202
1203 str = get_options(str, ARRAY_SIZE(ints), ints);
1204
1205 if (ints[0] == 0) {
1206 if (str && !strncmp(str, "auto", 4)) {
1207
1208 }
1209 else {
1210
1211 printk (KERN_ERR
1212 "ltpc: usage: ltpc=auto|iobase[,irq[,dma]]\n");
1213 return 0;
1214 }
1215 } else {
1216 io = ints[1];
1217 if (ints[0] > 1) {
1218 irq = ints[2];
1219 }
1220 if (ints[0] > 2) {
1221 dma = ints[3];
1222 }
1223
1224 }
1225 return 1;
1226}
1227
1228__setup("ltpc=", ltpc_setup);
1229#endif
1230
1231static struct net_device *dev_ltpc;
1232
1233#ifdef MODULE
1234
1235MODULE_LICENSE("GPL");
1236module_param(debug, int, 0);
1237module_param(io, int, 0);
1238module_param(irq, int, 0);
1239module_param(dma, int, 0);
1240
1241
1242static int __init ltpc_module_init(void)
1243{
1244 if(io == 0)
1245 printk(KERN_NOTICE
1246 "ltpc: Autoprobing is not recommended for modules\n");
1247
1248 dev_ltpc = ltpc_probe();
1249 if (IS_ERR(dev_ltpc))
1250 return PTR_ERR(dev_ltpc);
1251 return 0;
1252}
1253module_init(ltpc_module_init);
1254#endif
1255
1256static void __exit ltpc_cleanup(void)
1257{
1258
1259 if(debug & DEBUG_VERBOSE) printk("unregister_netdev\n");
1260 unregister_netdev(dev_ltpc);
1261
1262 ltpc_timer.data = 0;
1263
1264 del_timer_sync(<pc_timer);
1265
1266 if(debug & DEBUG_VERBOSE) printk("freeing irq\n");
1267
1268 if (dev_ltpc->irq)
1269 free_irq(dev_ltpc->irq, dev_ltpc);
1270
1271 if(debug & DEBUG_VERBOSE) printk("freeing dma\n");
1272
1273 if (dev_ltpc->dma)
1274 free_dma(dev_ltpc->dma);
1275
1276 if(debug & DEBUG_VERBOSE) printk("freeing ioaddr\n");
1277
1278 if (dev_ltpc->base_addr)
1279 release_region(dev_ltpc->base_addr,8);
1280
1281 free_netdev(dev_ltpc);
1282
1283 if(debug & DEBUG_VERBOSE) printk("free_pages\n");
1284
1285 free_pages( (unsigned long) ltdmabuf, get_order(1000));
1286
1287 if(debug & DEBUG_VERBOSE) printk("returning from cleanup_module\n");
1288}
1289
1290module_exit(ltpc_cleanup);
1291