File: /usr/src/linux/drivers/net/appletalk/cops.c
1 /* cops.c: LocalTalk driver for Linux.
2 *
3 * Authors:
4 * - Jay Schulist <jschlst@samba.org>
5 *
6 * With more than a little help from;
7 * - Alan Cox <Alan.Cox@linux.org>
8 *
9 * Derived from:
10 * - skeleton.c: A network driver outline for linux.
11 * Written 1993-94 by Donald Becker.
12 * - ltpc.c: A driver for the LocalTalk PC card.
13 * Written by Bradford W. Johnson.
14 *
15 * Copyright 1993 United States Government as represented by the
16 * Director, National Security Agency.
17 *
18 * This software may be used and distributed according to the terms
19 * of the GNU General Public License, incorporated herein by reference.
20 *
21 * Changes:
22 * 19970608 Alan Cox Allowed dual card type support
23 * Can set board type in insmod
24 * Hooks for cops_setup routine
25 * (not yet implemented).
26 * 19971101 Jay Schulist Fixes for multiple lt* devices.
27 * 19980607 Steven Hirsch Fixed the badly broken support
28 * for Tangent type cards. Only
29 * tested on Daystar LT200. Some
30 * cleanup of formatting and program
31 * logic. Added emacs 'local-vars'
32 * setup for Jay's brace style.
33 * 20000211 Alan Cox Cleaned up for softnet
34 */
35
36 static const char *version =
37 "cops.c:v0.04 6/7/98 Jay Schulist <jschlst@samba.org>\n";
38 /*
39 * Sources:
40 * COPS Localtalk SDK. This provides almost all of the information
41 * needed.
42 */
43
44 /*
45 * insmod/modprobe configurable stuff.
46 * - IO Port, choose one your card supports or 0 if you dare.
47 * - IRQ, also choose one your card supports or nothing and let
48 * the driver figure it out.
49 */
50
51 #include <linux/config.h>
52 #include <linux/module.h>
53
54 #include <linux/kernel.h>
55 #include <linux/sched.h>
56 #include <linux/types.h>
57 #include <linux/fcntl.h>
58 #include <linux/interrupt.h>
59 #include <linux/ptrace.h>
60 #include <linux/ioport.h>
61 #include <linux/in.h>
62 #include <linux/slab.h>
63 #include <linux/string.h>
64 #include <asm/system.h>
65 #include <asm/bitops.h>
66 #include <asm/io.h>
67 #include <asm/dma.h>
68 #include <linux/errno.h>
69 #include <linux/init.h>
70
71 #include <linux/netdevice.h>
72 #include <linux/etherdevice.h>
73 #include <linux/skbuff.h>
74
75 #include <linux/if_arp.h>
76 #include <linux/if_ltalk.h> /* For ltalk_setup() */
77 #include <linux/delay.h> /* For udelay() */
78 #include <linux/atalk.h>
79
80 #include "cops.h" /* Our Stuff */
81 #include "cops_ltdrv.h" /* Firmware code for Tangent type cards. */
82 #include "cops_ffdrv.h" /* Firmware code for Dayna type cards. */
83
84 /*
85 * The name of the card. Is used for messages and in the requests for
86 * io regions, irqs and dma channels
87 */
88
89 static const char *cardname = "cops";
90
91 #ifdef CONFIG_COPS_DAYNA
92 static int board_type = DAYNA; /* Module exported */
93 #else
94 static int board_type = TANGENT;
95 #endif
96
97 #ifdef MODULE
98 static int io = 0x240; /* Default IO for Dayna */
99 static int irq = 5; /* Default IRQ */
100 #else
101 static int io; /* Default IO for Dayna */
102 #endif
103
104 /*
105 * COPS Autoprobe information.
106 * Right now if port address is right but IRQ is not 5 this will
107 * return a 5 no matter what since we will still get a status response.
108 * Need one more additional check to narrow down after we have gotten
109 * the ioaddr. But since only other possible IRQs is 3 and 4 so no real
110 * hurry on this. I *STRONGLY* recommend using IRQ 5 for your card with
111 * this driver.
112 *
113 * This driver has 2 modes and they are: Dayna mode and Tangent mode.
114 * Each mode corresponds with the type of card. It has been found
115 * that there are 2 main types of cards and all other cards are
116 * the same and just have different names or only have minor differences
117 * such as more IO ports. As this driver is tested it will
118 * become more clear on exactly what cards are supported. The driver
119 * defaults to using Dayna mode. To change the drivers mode, simply
120 * select Dayna or Tangent mode when configuring the kernel.
121 *
122 * This driver should support:
123 * TANGENT driver mode:
124 * Tangent ATB-II, Novell NL-1000, Daystar Digital LT-200,
125 * COPS LT-1
126 * DAYNA driver mode:
127 * Dayna DL2000/DaynaTalk PC (Half Length), COPS LT-95,
128 * Farallon PhoneNET PC III, Farallon PhoneNET PC II
129 * Other cards possibly supported mode unkown though:
130 * Dayna DL2000 (Full length), COPS LT/M (Micro-Channel)
131 *
132 * Cards NOT supported by this driver but supported by the ltpc.c
133 * driver written by Bradford W. Johnson <johns393@maroon.tc.umn.edu>
134 * Farallon PhoneNET PC
135 * Original Apple LocalTalk PC card
136 *
137 * N.B.
138 *
139 * The Daystar Digital LT200 boards do not support interrupt-driven
140 * IO. You must specify 'irq=0xff' as a module parameter to invoke
141 * polled mode. I also believe that the port probing logic is quite
142 * dangerous at best and certainly hopeless for a polled card. Best to
143 * specify both. - Steve H.
144 *
145 */
146
147 /*
148 * Zero terminated list of IO ports to probe.
149 */
150
151 static unsigned int cops_portlist[] = {
152 0x240, 0x340, 0x200, 0x210, 0x220, 0x230, 0x260,
153 0x2A0, 0x300, 0x310, 0x320, 0x330, 0x350, 0x360,
154 0
155 };
156
157 /*
158 * Zero terminated list of IRQ ports to probe.
159 */
160
161 static int cops_irqlist[] = {
162 5, 4, 3, 0
163 };
164
165 static struct timer_list cops_timer;
166
167 /* use 0 for production, 1 for verification, 2 for debug, 3 for verbose debug */
168 #ifndef COPS_DEBUG
169 #define COPS_DEBUG 1
170 #endif
171 static unsigned int cops_debug = COPS_DEBUG;
172
173 /* The number of low I/O ports used by the card. */
174 #define COPS_IO_EXTENT 8
175
176 /* Information that needs to be kept for each board. */
177
178 struct cops_local
179 {
180 struct net_device_stats stats;
181 int board; /* Holds what board type is. */
182 int nodeid; /* Set to 1 once have nodeid. */
183 unsigned char node_acquire; /* Node ID when acquired. */
184 struct at_addr node_addr; /* Full node address */
185 };
186
187 /* Index to functions, as function prototypes. */
188 extern int cops_probe (struct net_device *dev);
189 static int cops_probe1 (struct net_device *dev, int ioaddr);
190 static int cops_irq (int ioaddr, int board);
191
192 static int cops_open (struct net_device *dev);
193 static int cops_jumpstart (struct net_device *dev);
194 static void cops_reset (struct net_device *dev, int sleep);
195 static void cops_load (struct net_device *dev);
196 static int cops_nodeid (struct net_device *dev, int nodeid);
197
198 static void cops_interrupt (int irq, void *dev_id, struct pt_regs *regs);
199 static void cops_poll (unsigned long ltdev);
200 static void cops_timeout(struct net_device *dev);
201 static void cops_rx (struct net_device *dev);
202 static int cops_send_packet (struct sk_buff *skb, struct net_device *dev);
203 static void set_multicast_list (struct net_device *dev);
204 static int cops_hard_header (struct sk_buff *skb, struct net_device *dev,
205 unsigned short type, void *daddr, void *saddr,
206 unsigned len);
207
208 static int cops_ioctl (struct net_device *dev, struct ifreq *rq, int cmd);
209 static int cops_close (struct net_device *dev);
210 static struct net_device_stats *cops_get_stats (struct net_device *dev);
211
212
213 /*
214 * Check for a network adaptor of this type, and return '0' iff one exists.
215 * If dev->base_addr == 0, probe all likely locations.
216 * If dev->base_addr in [1..0x1ff], always return failure.
217 * otherwise go with what we pass in.
218 */
219 int __init cops_probe(struct net_device *dev)
220 {
221 int i;
222 int base_addr = dev->base_addr;
223
224 SET_MODULE_OWNER(dev);
225
226 if(base_addr == 0 && io)
227 base_addr=io;
228
229 if(base_addr > 0x1ff) /* Check a single specified location. */
230 return cops_probe1(dev, base_addr);
231 else if(base_addr != 0) /* Don't probe at all. */
232 return -ENXIO;
233
234 /* FIXME Does this really work for cards which generate irq?
235 * It's definitely N.G. for polled Tangent. sh
236 * Dayna cards don't autoprobe well at all, but if your card is
237 * at IRQ 5 & IO 0x240 we find it every time. ;) JS
238 */
239 for(i=0; cops_portlist[i]; i++)
240 if(cops_probe1(dev, cops_portlist[i]) == 0)
241 return 0;
242
243 return -ENODEV;
244 }
245
246 /*
247 * This is the real probe routine. Linux has a history of friendly device
248 * probes on the ISA bus. A good device probes avoids doing writes, and
249 * verifies that the correct device exists and functions.
250 */
251 static int __init cops_probe1(struct net_device *dev, int ioaddr)
252 {
253 struct cops_local *lp;
254 static unsigned version_printed;
255 int board = board_type;
256 int retval;
257
258 if(cops_debug && version_printed++ == 0)
259 printk("%s", version);
260
261 /* Grab the region so no one else tries to probe our ioports. */
262 if (!request_region(ioaddr, COPS_IO_EXTENT, dev->name))
263 return -EBUSY;
264
265 /*
266 * Since this board has jumpered interrupts, allocate the interrupt
267 * vector now. There is no point in waiting since no other device
268 * can use the interrupt, and this marks the irq as busy. Jumpered
269 * interrupts are typically not reported by the boards, and we must
270 * used AutoIRQ to find them.
271 */
272 switch (dev->irq)
273 {
274 case 0:
275 /* COPS AutoIRQ routine */
276 dev->irq = cops_irq(ioaddr, board);
277 if(!dev->irq) {
278 retval = -EINVAL; /* No IRQ found on this port */
279 goto err_out;
280 }
281
282 case 1:
283 retval = -EINVAL;
284 goto err_out;
285
286 /* Fixup for users that don't know that IRQ 2 is really
287 * IRQ 9, or don't know which one to set.
288 */
289 case 2:
290 dev->irq = 9;
291 break;
292
293 /* Polled operation requested. Although irq of zero passed as
294 * a parameter tells the init routines to probe, we'll
295 * overload it to denote polled operation at runtime.
296 */
297 case 0xff:
298 dev->irq = 0;
299 break;
300
301 default:
302 break;
303 }
304
305 /* Reserve any actual interrupt. */
306 if(dev->irq) {
307 retval = request_irq(dev->irq, &cops_interrupt, 0, dev->name, dev);
308 if (retval)
309 goto err_out;
310 }
311
312 dev->base_addr = ioaddr;
313
314 /* Initialize the private device structure. */
315 dev->priv = kmalloc(sizeof(struct cops_local), GFP_KERNEL);
316 if(dev->priv == NULL) {
317 if (dev->irq)
318 free_irq(dev->irq, dev);
319 retval = -ENOMEM;
320 goto err_out;
321 }
322
323 lp = (struct cops_local *)dev->priv;
324 memset(lp, 0, sizeof(struct cops_local));
325
326 /* Copy local board variable to lp struct. */
327 lp->board = board;
328
329 /* Fill in the fields of the device structure with LocalTalk values. */
330 ltalk_setup(dev);
331
332 dev->hard_start_xmit = cops_send_packet;
333 dev->tx_timeout = cops_timeout;
334 dev->watchdog_timeo = HZ * 2;
335 dev->hard_header = cops_hard_header;
336 dev->get_stats = cops_get_stats;
337 dev->open = cops_open;
338 dev->stop = cops_close;
339 dev->do_ioctl = cops_ioctl;
340 dev->set_multicast_list = set_multicast_list;
341 dev->mc_list = NULL;
342
343 /* Tell the user where the card is and what mode we're in. */
344 if(board==DAYNA)
345 printk("%s: %s at %#3x, using IRQ %d, in Dayna mode.\n",
346 dev->name, cardname, ioaddr, dev->irq);
347 if(board==TANGENT) {
348 if(dev->irq)
349 printk("%s: %s at %#3x, IRQ %d, in Tangent mode\n",
350 dev->name, cardname, ioaddr, dev->irq);
351 else
352 printk("%s: %s at %#3x, using polled IO, in Tangent mode.\n",
353 dev->name, cardname, ioaddr);
354
355 }
356 return 0;
357
358 err_out:
359 release_region(ioaddr, COPS_IO_EXTENT);
360 return retval;
361 }
362
363 static int __init cops_irq (int ioaddr, int board)
364 { /*
365 * This does not use the IRQ to determine where the IRQ is. We just
366 * assume that when we get a correct status response that it's the IRQ.
367 * This really just verifies the IO port but since we only have access
368 * to such a small number of IRQs (5, 4, 3) this is not bad.
369 * This will probably not work for more than one card.
370 */
371 int irqaddr=0;
372 int i, x, status;
373
374 if(board==DAYNA)
375 {
376 outb(0, ioaddr+DAYNA_RESET);
377 inb(ioaddr+DAYNA_RESET);
378 mdelay(333);
379 }
380 if(board==TANGENT)
381 {
382 inb(ioaddr);
383 outb(0, ioaddr);
384 outb(0, ioaddr+TANG_RESET);
385 }
386
387 for(i=0; cops_irqlist[i] !=0; i++)
388 {
389 irqaddr = cops_irqlist[i];
390 for(x = 0xFFFF; x>0; x --) /* wait for response */
391 {
392 if(board==DAYNA)
393 {
394 status = (inb(ioaddr+DAYNA_CARD_STATUS)&3);
395 if(status == 1)
396 return irqaddr;
397 }
398 if(board==TANGENT)
399 {
400 if((inb(ioaddr+TANG_CARD_STATUS)& TANG_TX_READY) !=0)
401 return irqaddr;
402 }
403 }
404 }
405 return 0; /* no IRQ found */
406 }
407
408 /*
409 * Open/initialize the board. This is called (in the current kernel)
410 * sometime after booting when the 'ifconfig' program is run.
411 */
412 static int cops_open(struct net_device *dev)
413 {
414 struct cops_local *lp = (struct cops_local *)dev->priv;
415
416 if(dev->irq==0)
417 {
418 /*
419 * I don't know if the Dayna-style boards support polled
420 * operation. For now, only allow it for Tangent.
421 */
422 if(lp->board==TANGENT) /* Poll 20 times per second */
423 {
424 init_timer(&cops_timer);
425 cops_timer.function = cops_poll;
426 cops_timer.data = (unsigned long)dev;
427 cops_timer.expires = jiffies + 5;
428 add_timer(&cops_timer);
429 }
430 else
431 {
432 printk(KERN_WARNING "%s: No irq line set\n", dev->name);
433 return -EAGAIN;
434 }
435 }
436
437 cops_jumpstart(dev); /* Start the card up. */
438
439 netif_start_queue(dev);
440 return 0;
441 }
442
443 /*
444 * This allows for a dynamic start/restart of the entire card.
445 */
446 static int cops_jumpstart(struct net_device *dev)
447 {
448 struct cops_local *lp = (struct cops_local *)dev->priv;
449
450 /*
451 * Once the card has the firmware loaded and has acquired
452 * the nodeid, if it is reset it will lose it all.
453 */
454 cops_reset(dev,1); /* Need to reset card before load firmware. */
455 cops_load(dev); /* Load the firmware. */
456
457 /*
458 * If atalkd already gave us a nodeid we will use that
459 * one again, else we wait for atalkd to give us a nodeid
460 * in cops_ioctl. This may cause a problem if someone steals
461 * our nodeid while we are resetting.
462 */
463 if(lp->nodeid == 1)
464 cops_nodeid(dev,lp->node_acquire);
465
466 return 0;
467 }
468
469 static void tangent_wait_reset(int ioaddr)
470 {
471 int timeout=0;
472
473 while(timeout++ < 5 && (inb(ioaddr+TANG_CARD_STATUS)&TANG_TX_READY)==0)
474 mdelay(1); /* Wait 1 second */
475 }
476
477 /*
478 * Reset the LocalTalk board.
479 */
480 static void cops_reset(struct net_device *dev, int sleep)
481 {
482 struct cops_local *lp = (struct cops_local *)dev->priv;
483 int ioaddr=dev->base_addr;
484
485 if(lp->board==TANGENT)
486 {
487 inb(ioaddr); /* Clear request latch. */
488 outb(0,ioaddr); /* Clear the TANG_TX_READY flop. */
489 outb(0, ioaddr+TANG_RESET); /* Reset the adapter. */
490
491 tangent_wait_reset(ioaddr);
492 outb(0, ioaddr+TANG_CLEAR_INT);
493 }
494 if(lp->board==DAYNA)
495 {
496 outb(0, ioaddr+DAYNA_RESET); /* Assert the reset port */
497 inb(ioaddr+DAYNA_RESET); /* Clear the reset */
498 if(sleep)
499 {
500 long snap=jiffies;
501
502 /* Let card finish initializing, about 1/3 second */
503 while(jiffies-snap<HZ/3)
504 schedule();
505 }
506 else
507 mdelay(333);
508 }
509 netif_wake_queue(dev);
510 return;
511 }
512
513 static void cops_load (struct net_device *dev)
514 {
515 struct ifreq ifr;
516 struct ltfirmware *ltf= (struct ltfirmware *)&ifr.ifr_data;
517 struct cops_local *lp=(struct cops_local *)dev->priv;
518 int ioaddr=dev->base_addr;
519 int length, i = 0;
520
521 strcpy(ifr.ifr_name,"lt0");
522
523 /* Get card's firmware code and do some checks on it. */
524 #ifdef CONFIG_COPS_DAYNA
525 if(lp->board==DAYNA)
526 {
527 ltf->length=sizeof(ffdrv_code);
528 ltf->data=ffdrv_code;
529 }
530 else
531 #endif
532 #ifdef CONFIG_COPS_TANGENT
533 if(lp->board==TANGENT)
534 {
535 ltf->length=sizeof(ltdrv_code);
536 ltf->data=ltdrv_code;
537 }
538 else
539 #endif
540 {
541 printk(KERN_INFO "%s; unsupported board type.\n", dev->name);
542 return;
543 }
544
545 /* Check to make sure firmware is correct length. */
546 if(lp->board==DAYNA && ltf->length!=5983)
547 {
548 printk(KERN_WARNING "%s: Firmware is not length of FFDRV.BIN.\n", dev->name);
549 return;
550 }
551 if(lp->board==TANGENT && ltf->length!=2501)
552 {
553 printk(KERN_WARNING "%s: Firmware is not length of DRVCODE.BIN.\n", dev->name);
554 return;
555 }
556
557 if(lp->board==DAYNA)
558 {
559 /*
560 * We must wait for a status response
561 * with the DAYNA board.
562 */
563 while(++i<65536)
564 {
565 if((inb(ioaddr+DAYNA_CARD_STATUS)&3)==1)
566 break;
567 }
568
569 if(i==65536)
570 return;
571 }
572
573 /*
574 * Upload the firmware and kick. Byte-by-byte works nicely here.
575 */
576 i=0;
577 length = ltf->length;
578 while(length--)
579 {
580 outb(ltf->data[i], ioaddr);
581 i++;
582 }
583
584 if(cops_debug > 1)
585 printk("%s: Uploaded firmware - %d bytes of %d bytes.\n",
586 dev->name, i, ltf->length);
587
588 if(lp->board==DAYNA) /* Tell Dayna to run the firmware code. */
589 outb(1, ioaddr+DAYNA_INT_CARD);
590 else /* Tell Tang to run the firmware code. */
591 inb(ioaddr);
592
593 if(lp->board==TANGENT)
594 {
595 tangent_wait_reset(ioaddr);
596 inb(ioaddr); /* Clear initial ready signal. */
597 }
598
599 return;
600 }
601
602 /*
603 * Get the LocalTalk Nodeid from the card. We can suggest
604 * any nodeid 1-254. The card will try and get that exact
605 * address else we can specify 0 as the nodeid and the card
606 * will autoprobe for a nodeid.
607 */
608 static int cops_nodeid (struct net_device *dev, int nodeid)
609 {
610 struct cops_local *lp = (struct cops_local *) dev->priv;
611 int ioaddr = dev->base_addr;
612
613 if(lp->board == DAYNA)
614 {
615 /* Empty any pending adapter responses. */
616 while((inb(ioaddr+DAYNA_CARD_STATUS)&DAYNA_TX_READY)==0)
617 {
618 outb(0, ioaddr+COPS_CLEAR_INT); /* Clear interrupts. */
619 if((inb(ioaddr+DAYNA_CARD_STATUS)&0x03)==DAYNA_RX_REQUEST)
620 cops_rx(dev); /* Kick any packets waiting. */
621 schedule();
622 }
623
624 outb(2, ioaddr); /* Output command packet length as 2. */
625 outb(0, ioaddr);
626 outb(LAP_INIT, ioaddr); /* Send LAP_INIT command byte. */
627 outb(nodeid, ioaddr); /* Suggest node address. */
628 }
629
630 if(lp->board == TANGENT)
631 {
632 /* Empty any pending adapter responses. */
633 while(inb(ioaddr+TANG_CARD_STATUS)&TANG_RX_READY)
634 {
635 outb(0, ioaddr+COPS_CLEAR_INT); /* Clear interrupt. */
636 cops_rx(dev); /* Kick out packets waiting. */
637 schedule();
638 }
639
640 /* Not sure what Tangent does if nodeid picked is used. */
641 if(nodeid == 0) /* Seed. */
642 nodeid = jiffies&0xFF; /* Get a random try */
643 outb(2, ioaddr); /* Command length LSB */
644 outb(0, ioaddr); /* Command length MSB */
645 outb(LAP_INIT, ioaddr); /* Send LAP_INIT byte */
646 outb(nodeid, ioaddr); /* LAP address hint. */
647 outb(0xFF, ioaddr); /* Int. level to use */
648 }
649
650 lp->node_acquire=0; /* Set nodeid holder to 0. */
651 while(lp->node_acquire==0) /* Get *True* nodeid finally. */
652 {
653 outb(0, ioaddr+COPS_CLEAR_INT); /* Clear any interrupt. */
654
655 if(lp->board == DAYNA)
656 {
657 if((inb(ioaddr+DAYNA_CARD_STATUS)&0x03)==DAYNA_RX_REQUEST)
658 cops_rx(dev); /* Grab the nodeid put in lp->node_acquire. */
659 }
660 if(lp->board == TANGENT)
661 {
662 if(inb(ioaddr+TANG_CARD_STATUS)&TANG_RX_READY)
663 cops_rx(dev); /* Grab the nodeid put in lp->node_acquire. */
664 }
665 schedule();
666 }
667
668 if(cops_debug > 1)
669 printk(KERN_DEBUG "%s: Node ID %d has been acquired.\n",
670 dev->name, lp->node_acquire);
671
672 lp->nodeid=1; /* Set got nodeid to 1. */
673
674 return 0;
675 }
676
677 /*
678 * Poll the Tangent type cards to see if we have work.
679 */
680
681 static void cops_poll(unsigned long ltdev)
682 {
683 int ioaddr, status;
684 int boguscount = 0;
685
686 struct net_device *dev = (struct net_device *)ltdev;
687
688 del_timer(&cops_timer);
689
690 if(dev == NULL)
691 return; /* We've been downed */
692
693 ioaddr = dev->base_addr;
694 do {
695 status=inb(ioaddr+TANG_CARD_STATUS);
696 if(status & TANG_RX_READY)
697 cops_rx(dev);
698 if(status & TANG_TX_READY)
699 netif_wake_queue(dev);
700 status = inb(ioaddr+TANG_CARD_STATUS);
701 } while((++boguscount < 20) && (status&(TANG_RX_READY|TANG_TX_READY)));
702
703 cops_timer.expires = jiffies+5;
704 add_timer(&cops_timer);
705
706 return;
707 }
708
709 /*
710 * The typical workload of the driver:
711 * Handle the network interface interrupts.
712 */
713 static void cops_interrupt(int irq, void *dev_id, struct pt_regs * regs)
714 {
715 struct net_device *dev = dev_id;
716 struct cops_local *lp;
717 int ioaddr, status;
718 int boguscount = 0;
719
720 ioaddr = dev->base_addr;
721 lp = (struct cops_local *)dev->priv;
722
723 if(lp->board==DAYNA)
724 {
725 do {
726 outb(0, ioaddr + COPS_CLEAR_INT);
727 status=inb(ioaddr+DAYNA_CARD_STATUS);
728 if((status&0x03)==DAYNA_RX_REQUEST)
729 cops_rx(dev);
730 netif_wake_queue(dev);
731 } while(++boguscount < 20);
732 }
733 else
734 {
735 do {
736 status=inb(ioaddr+TANG_CARD_STATUS);
737 if(status & TANG_RX_READY)
738 cops_rx(dev);
739 if(status & TANG_TX_READY)
740 netif_wake_queue(dev);
741 status=inb(ioaddr+TANG_CARD_STATUS);
742 } while((++boguscount < 20) && (status&(TANG_RX_READY|TANG_TX_READY)));
743 }
744
745 return;
746 }
747
748 /*
749 * We have a good packet(s), get it/them out of the buffers.
750 */
751 static void cops_rx(struct net_device *dev)
752 {
753 int pkt_len = 0;
754 int rsp_type = 0;
755 struct sk_buff *skb = NULL;
756 struct cops_local *lp = dev->priv;
757 int ioaddr = dev->base_addr;
758 int boguscount = 0;
759 unsigned long flags;
760
761
762 save_flags(flags);
763 cli(); /* Disable interrupts. */
764
765 if(lp->board==DAYNA)
766 {
767 outb(0, ioaddr); /* Send out Zero length. */
768 outb(0, ioaddr);
769 outb(DATA_READ, ioaddr); /* Send read command out. */
770
771 /* Wait for DMA to turn around. */
772 while(++boguscount<1000000)
773 {
774 barrier();
775 if((inb(ioaddr+DAYNA_CARD_STATUS)&0x03)==DAYNA_RX_READY)
776 break;
777 }
778
779 if(boguscount==1000000)
780 {
781 printk(KERN_WARNING "%s: DMA timed out.\n",dev->name);
782 restore_flags(flags);
783 return;
784 }
785 }
786
787 /* Get response length. */
788 if(lp->board==DAYNA)
789 pkt_len = inb(ioaddr) & 0xFF;
790 else
791 pkt_len = inb(ioaddr) & 0x00FF;
792 pkt_len |= (inb(ioaddr) << 8);
793 /* Input IO code. */
794 rsp_type=inb(ioaddr);
795
796 /* Malloc up new buffer. */
797 skb = dev_alloc_skb(pkt_len);
798 if(skb == NULL)
799 {
800 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n",
801 dev->name);
802 lp->stats.rx_dropped++;
803 while(pkt_len--) /* Discard packet */
804 inb(ioaddr);
805 restore_flags(flags);
806 return;
807 }
808 skb->dev = dev;
809 skb_put(skb, pkt_len);
810 skb->protocol = htons(ETH_P_LOCALTALK);
811
812 insb(ioaddr, skb->data, pkt_len); /* Eat the Data */
813
814 if(lp->board==DAYNA)
815 outb(1, ioaddr+DAYNA_INT_CARD); /* Interrupt the card */
816
817 restore_flags(flags); /* Restore interrupts. */
818
819 /* Check for bad response length */
820 if(pkt_len < 0 || pkt_len > MAX_LLAP_SIZE)
821 {
822 printk(KERN_WARNING "%s: Bad packet length of %d bytes.\n",
823 dev->name, pkt_len);
824 lp->stats.tx_errors++;
825 dev_kfree_skb_any(skb);
826 return;
827 }
828
829 /* Set nodeid and then get out. */
830 if(rsp_type == LAP_INIT_RSP)
831 { /* Nodeid taken from received packet. */
832 lp->node_acquire = skb->data[0];
833 dev_kfree_skb_any(skb);
834 return;
835 }
836
837 /* One last check to make sure we have a good packet. */
838 if(rsp_type != LAP_RESPONSE)
839 {
840 printk(KERN_WARNING "%s: Bad packet type %d.\n", dev->name, rsp_type);
841 lp->stats.tx_errors++;
842 dev_kfree_skb_any(skb);
843 return;
844 }
845
846 skb->mac.raw = skb->data; /* Point to entire packet. */
847 skb_pull(skb,3);
848 skb->h.raw = skb->data; /* Point to data (Skip header). */
849
850 /* Update the counters. */
851 lp->stats.rx_packets++;
852 lp->stats.rx_bytes += skb->len;
853
854 /* Send packet to a higher place. */
855 netif_rx(skb);
856 dev->last_rx = jiffies;
857 }
858
859 static void cops_timeout(struct net_device *dev)
860 {
861 struct cops_local *lp = (struct cops_local *)dev->priv;
862 int ioaddr = dev->base_addr;
863
864 lp->stats.tx_errors++;
865 if(lp->board==TANGENT)
866 {
867 if((inb(ioaddr+TANG_CARD_STATUS)&TANG_TX_READY)==0)
868 printk(KERN_WARNING "%s: No TX complete interrupt.\n", dev->name);
869 }
870 printk(KERN_WARNING "%s: Transmit timed out.\n", dev->name);
871 cops_jumpstart(dev); /* Restart the card. */
872 dev->trans_start = jiffies;
873 netif_wake_queue(dev);
874 }
875
876
877 /*
878 * Make the card transmit a LocalTalk packet.
879 */
880
881 static int cops_send_packet(struct sk_buff *skb, struct net_device *dev)
882 {
883 struct cops_local *lp = (struct cops_local *)dev->priv;
884 int ioaddr = dev->base_addr;
885 unsigned long flags;
886
887 /*
888 * Block a timer-based transmit from overlapping.
889 */
890
891 netif_stop_queue(dev);
892
893 save_flags(flags);
894 cli(); /* Disable interrupts. */
895 if(lp->board == DAYNA) /* Wait for adapter transmit buffer. */
896 while((inb(ioaddr+DAYNA_CARD_STATUS)&DAYNA_TX_READY)==0);
897 if(lp->board == TANGENT) /* Wait for adapter transmit buffer. */
898 while((inb(ioaddr+TANG_CARD_STATUS)&TANG_TX_READY)==0);
899
900 /* Output IO length. */
901 outb(skb->len, ioaddr);
902 if(lp->board == DAYNA)
903 outb(skb->len >> 8, ioaddr);
904 else
905 outb((skb->len >> 8)&0x0FF, ioaddr);
906
907 /* Output IO code. */
908 outb(LAP_WRITE, ioaddr);
909
910 if(lp->board == DAYNA) /* Check the transmit buffer again. */
911 while((inb(ioaddr+DAYNA_CARD_STATUS)&DAYNA_TX_READY)==0);
912
913 outsb(ioaddr, skb->data, skb->len); /* Send out the data. */
914
915 if(lp->board==DAYNA) /* Dayna requires you kick the card */
916 outb(1, ioaddr+DAYNA_INT_CARD);
917
918 restore_flags(flags); /* Restore interrupts. */
919
920 /* Done sending packet, update counters and cleanup. */
921 lp->stats.tx_packets++;
922 lp->stats.tx_bytes += skb->len;
923 dev->trans_start = jiffies;
924 dev_kfree_skb (skb);
925 return 0;
926 }
927
928 /*
929 * Dummy function to keep the Appletalk layer happy.
930 */
931
932 static void set_multicast_list(struct net_device *dev)
933 {
934 if(cops_debug >= 3)
935 printk("%s: set_multicast_list executed\n", dev->name);
936 }
937
938 /*
939 * Another Dummy function to keep the Appletalk layer happy.
940 */
941
942 static int cops_hard_header(struct sk_buff *skb, struct net_device *dev,
943 unsigned short type, void *daddr, void *saddr,
944 unsigned len)
945 {
946 if(cops_debug >= 3)
947 printk("%s: cops_hard_header executed. Wow!\n", dev->name);
948 return 0;
949 }
950
951 /*
952 * System ioctls for the COPS LocalTalk card.
953 */
954
955 static int cops_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
956 {
957 struct cops_local *lp = (struct cops_local *)dev->priv;
958 struct sockaddr_at *sa=(struct sockaddr_at *)&ifr->ifr_addr;
959 struct at_addr *aa=(struct at_addr *)&lp->node_addr;
960
961 switch(cmd)
962 {
963 case SIOCSIFADDR:
964 /* Get and set the nodeid and network # atalkd wants. */
965 cops_nodeid(dev, sa->sat_addr.s_node);
966 aa->s_net = sa->sat_addr.s_net;
967 aa->s_node = lp->node_acquire;
968
969 /* Set broardcast address. */
970 dev->broadcast[0] = 0xFF;
971
972 /* Set hardware address. */
973 dev->dev_addr[0] = aa->s_node;
974 dev->addr_len = 1;
975 return 0;
976
977 case SIOCGIFADDR:
978 sa->sat_addr.s_net = aa->s_net;
979 sa->sat_addr.s_node = aa->s_node;
980 return 0;
981
982 default:
983 return -EOPNOTSUPP;
984 }
985 }
986
987 /*
988 * The inverse routine to cops_open().
989 */
990
991 static int cops_close(struct net_device *dev)
992 {
993 struct cops_local *lp = (struct cops_local *)dev->priv;
994
995 /* If we were running polled, yank the timer.
996 */
997 if(lp->board==TANGENT && dev->irq==0)
998 del_timer(&cops_timer);
999
1000 netif_stop_queue(dev);
1001 return 0;
1002 }
1003
1004 /*
1005 * Get the current statistics.
1006 * This may be called with the card open or closed.
1007 */
1008 static struct net_device_stats *cops_get_stats(struct net_device *dev)
1009 {
1010 struct cops_local *lp = (struct cops_local *)dev->priv;
1011 return &lp->stats;
1012 }
1013
1014 #ifdef MODULE
1015 static struct net_device cops0_dev = { init: cops_probe };
1016
1017 MODULE_LICENSE("GPL");
1018 MODULE_PARM(io, "i");
1019 MODULE_PARM(irq, "i");
1020 MODULE_PARM(board_type, "i");
1021
1022 int init_module(void)
1023 {
1024 int result, err;
1025
1026 if(io == 0)
1027 printk(KERN_WARNING "%s: You shouldn't autoprobe with insmod\n",
1028 cardname);
1029
1030 /* Copy the parameters from insmod into the device structure. */
1031 cops0_dev.base_addr = io;
1032 cops0_dev.irq = irq;
1033
1034 err=dev_alloc_name(&cops0_dev, "lt%d");
1035 if(err < 0)
1036 return err;
1037
1038 if((result = register_netdev(&cops0_dev)) != 0)
1039 return result;
1040
1041 return 0;
1042 }
1043
1044 void cleanup_module(void)
1045 {
1046 /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
1047 unregister_netdev(&cops0_dev);
1048 kfree(cops0_dev.priv);
1049 if(cops0_dev.irq)
1050 free_irq(cops0_dev.irq, &cops0_dev);
1051 release_region(cops0_dev.base_addr, COPS_IO_EXTENT);
1052 }
1053 #endif /* MODULE */
1054
1055 /*
1056 * Local variables:
1057 * compile-command: "gcc -DMODVERSIONS -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -c cops.c"
1058 * c-basic-offset: 4
1059 * c-file-offsets: ((substatement-open . 0))
1060 * End:
1061 */
1062