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