1 /* $Id: plip.c,v 1.3.6.2 1997/04/16 15:07:56 phil Exp $ */ 2 /* PLIP: A parallel port "network" driver for Linux. */ 3 /* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */ 4 /* 5 * Authors: Donald Becker <becker@scyld.com> 6 * Tommy Thorn <thorn@daimi.aau.dk> 7 * Tanabe Hiroyasu <hiro@sanpo.t.u-tokyo.ac.jp> 8 * Alan Cox <gw4pts@gw4pts.ampr.org> 9 * Peter Bauer <100136.3530@compuserve.com> 10 * Niibe Yutaka <gniibe@mri.co.jp> 11 * Nimrod Zimerman <zimerman@mailandnews.com> 12 * 13 * Enhancements: 14 * Modularization and ifreq/ifmap support by Alan Cox. 15 * Rewritten by Niibe Yutaka. 16 * parport-sharing awareness code by Philip Blundell. 17 * SMP locking by Niibe Yutaka. 18 * Support for parallel ports with no IRQ (poll mode), 19 * Modifications to use the parallel port API 20 * by Nimrod Zimerman. 21 * 22 * Fixes: 23 * Niibe Yutaka 24 * - Module initialization. 25 * - MTU fix. 26 * - Make sure other end is OK, before sending a packet. 27 * - Fix immediate timer problem. 28 * 29 * Al Viro 30 * - Changed {enable,disable}_irq handling to make it work 31 * with new ("stack") semantics. 32 * 33 * This program is free software; you can redistribute it and/or 34 * modify it under the terms of the GNU General Public License 35 * as published by the Free Software Foundation; either version 36 * 2 of the License, or (at your option) any later version. 37 */ 38 39 /* 40 * Original version and the name 'PLIP' from Donald Becker <becker@scyld.com> 41 * inspired by Russ Nelson's parallel port packet driver. 42 * 43 * NOTE: 44 * Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0. 45 * Because of the necessity to communicate to DOS machines with the 46 * Crynwr packet driver, Peter Bauer changed the protocol again 47 * back to original protocol. 48 * 49 * This version follows original PLIP protocol. 50 * So, this PLIP can't communicate the PLIP of Linux v1.0. 51 */ 52 53 /* 54 * To use with DOS box, please do (Turn on ARP switch): 55 * # ifconfig plip[0-2] arp 56 */ 57 static const char version[] = "NET3 PLIP version 2.4-parport gniibe@mri.co.jp\n"; 58 59 /* 60 Sources: 61 Ideas and protocols came from Russ Nelson's <nelson@crynwr.com> 62 "parallel.asm" parallel port packet driver. 63 64 The "Crynwr" parallel port standard specifies the following protocol: 65 Trigger by sending nibble '0x8' (this causes interrupt on other end) 66 count-low octet 67 count-high octet 68 ... data octets 69 checksum octet 70 Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)> 71 <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)> 72 73 The packet is encapsulated as if it were ethernet. 74 75 The cable used is a de facto standard parallel null cable -- sold as 76 a "LapLink" cable by various places. You'll need a 12-conductor cable to 77 make one yourself. The wiring is: 78 SLCTIN 17 - 17 79 GROUND 25 - 25 80 D0->ERROR 2 - 15 15 - 2 81 D1->SLCT 3 - 13 13 - 3 82 D2->PAPOUT 4 - 12 12 - 4 83 D3->ACK 5 - 10 10 - 5 84 D4->BUSY 6 - 11 11 - 6 85 Do not connect the other pins. They are 86 D5,D6,D7 are 7,8,9 87 STROBE is 1, FEED is 14, INIT is 16 88 extra grounds are 18,19,20,21,22,23,24 89 */ 90 91 #include <linux/module.h> 92 #include <linux/kernel.h> 93 #include <linux/types.h> 94 #include <linux/fcntl.h> 95 #include <linux/interrupt.h> 96 #include <linux/string.h> 97 #include <linux/slab.h> 98 #include <linux/if_ether.h> 99 #include <linux/in.h> 100 #include <linux/errno.h> 101 #include <linux/delay.h> 102 #include <linux/init.h> 103 #include <linux/netdevice.h> 104 #include <linux/etherdevice.h> 105 #include <linux/inetdevice.h> 106 #include <linux/skbuff.h> 107 #include <linux/if_plip.h> 108 #include <linux/workqueue.h> 109 #include <linux/spinlock.h> 110 #include <linux/completion.h> 111 #include <linux/parport.h> 112 #include <linux/bitops.h> 113 114 #include <net/neighbour.h> 115 116 #include <asm/irq.h> 117 #include <asm/byteorder.h> 118 119 /* Maximum number of devices to support. */ 120 #define PLIP_MAX 8 121 122 /* Use 0 for production, 1 for verification, >2 for debug */ 123 #ifndef NET_DEBUG 124 #define NET_DEBUG 1 125 #endif 126 static const unsigned int net_debug = NET_DEBUG; 127 128 #define ENABLE(irq) if (irq != -1) enable_irq(irq) 129 #define DISABLE(irq) if (irq != -1) disable_irq(irq) 130 131 /* In micro second */ 132 #define PLIP_DELAY_UNIT 1 133 134 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */ 135 #define PLIP_TRIGGER_WAIT 500 136 137 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */ 138 #define PLIP_NIBBLE_WAIT 3000 139 140 /* Bottom halves */ 141 static void plip_kick_bh(struct work_struct *work); 142 static void plip_bh(struct work_struct *work); 143 static void plip_timer_bh(struct work_struct *work); 144 145 /* Interrupt handler */ 146 static void plip_interrupt(void *dev_id); 147 148 /* Functions for DEV methods */ 149 static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev); 150 static int plip_hard_header(struct sk_buff *skb, struct net_device *dev, 151 unsigned short type, const void *daddr, 152 const void *saddr, unsigned len); 153 static int plip_hard_header_cache(const struct neighbour *neigh, 154 struct hh_cache *hh, __be16 type); 155 static int plip_open(struct net_device *dev); 156 static int plip_close(struct net_device *dev); 157 static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd); 158 static int plip_preempt(void *handle); 159 static void plip_wakeup(void *handle); 160 161 enum plip_connection_state { 162 PLIP_CN_NONE=0, 163 PLIP_CN_RECEIVE, 164 PLIP_CN_SEND, 165 PLIP_CN_CLOSING, 166 PLIP_CN_ERROR 167 }; 168 169 enum plip_packet_state { 170 PLIP_PK_DONE=0, 171 PLIP_PK_TRIGGER, 172 PLIP_PK_LENGTH_LSB, 173 PLIP_PK_LENGTH_MSB, 174 PLIP_PK_DATA, 175 PLIP_PK_CHECKSUM 176 }; 177 178 enum plip_nibble_state { 179 PLIP_NB_BEGIN, 180 PLIP_NB_1, 181 PLIP_NB_2, 182 }; 183 184 struct plip_local { 185 enum plip_packet_state state; 186 enum plip_nibble_state nibble; 187 union { 188 struct { 189 #if defined(__LITTLE_ENDIAN) 190 unsigned char lsb; 191 unsigned char msb; 192 #elif defined(__BIG_ENDIAN) 193 unsigned char msb; 194 unsigned char lsb; 195 #else 196 #error "Please fix the endianness defines in <asm/byteorder.h>" 197 #endif 198 } b; 199 unsigned short h; 200 } length; 201 unsigned short byte; 202 unsigned char checksum; 203 unsigned char data; 204 struct sk_buff *skb; 205 }; 206 207 struct net_local { 208 struct net_device *dev; 209 struct work_struct immediate; 210 struct delayed_work deferred; 211 struct delayed_work timer; 212 struct plip_local snd_data; 213 struct plip_local rcv_data; 214 struct pardevice *pardev; 215 unsigned long trigger; 216 unsigned long nibble; 217 enum plip_connection_state connection; 218 unsigned short timeout_count; 219 int is_deferred; 220 int port_owner; 221 int should_relinquish; 222 spinlock_t lock; 223 atomic_t kill_timer; 224 struct completion killed_timer_cmp; 225 }; 226 227 static inline void enable_parport_interrupts (struct net_device *dev) 228 { 229 if (dev->irq != -1) 230 { 231 struct parport *port = 232 ((struct net_local *)netdev_priv(dev))->pardev->port; 233 port->ops->enable_irq (port); 234 } 235 } 236 237 static inline void disable_parport_interrupts (struct net_device *dev) 238 { 239 if (dev->irq != -1) 240 { 241 struct parport *port = 242 ((struct net_local *)netdev_priv(dev))->pardev->port; 243 port->ops->disable_irq (port); 244 } 245 } 246 247 static inline void write_data (struct net_device *dev, unsigned char data) 248 { 249 struct parport *port = 250 ((struct net_local *)netdev_priv(dev))->pardev->port; 251 252 port->ops->write_data (port, data); 253 } 254 255 static inline unsigned char read_status (struct net_device *dev) 256 { 257 struct parport *port = 258 ((struct net_local *)netdev_priv(dev))->pardev->port; 259 260 return port->ops->read_status (port); 261 } 262 263 static const struct header_ops plip_header_ops = { 264 .create = plip_hard_header, 265 .cache = plip_hard_header_cache, 266 }; 267 268 static const struct net_device_ops plip_netdev_ops = { 269 .ndo_open = plip_open, 270 .ndo_stop = plip_close, 271 .ndo_start_xmit = plip_tx_packet, 272 .ndo_do_ioctl = plip_ioctl, 273 .ndo_set_mac_address = eth_mac_addr, 274 .ndo_validate_addr = eth_validate_addr, 275 }; 276 277 /* Entry point of PLIP driver. 278 Probe the hardware, and register/initialize the driver. 279 280 PLIP is rather weird, because of the way it interacts with the parport 281 system. It is _not_ initialised from Space.c. Instead, plip_init() 282 is called, and that function makes up a "struct net_device" for each port, and 283 then calls us here. 284 285 */ 286 static void 287 plip_init_netdev(struct net_device *dev) 288 { 289 struct net_local *nl = netdev_priv(dev); 290 291 /* Then, override parts of it */ 292 dev->tx_queue_len = 10; 293 dev->flags = IFF_POINTOPOINT|IFF_NOARP; 294 memset(dev->dev_addr, 0xfc, ETH_ALEN); 295 296 dev->netdev_ops = &plip_netdev_ops; 297 dev->header_ops = &plip_header_ops; 298 299 300 nl->port_owner = 0; 301 302 /* Initialize constants */ 303 nl->trigger = PLIP_TRIGGER_WAIT; 304 nl->nibble = PLIP_NIBBLE_WAIT; 305 306 /* Initialize task queue structures */ 307 INIT_WORK(&nl->immediate, plip_bh); 308 INIT_DELAYED_WORK(&nl->deferred, plip_kick_bh); 309 310 if (dev->irq == -1) 311 INIT_DELAYED_WORK(&nl->timer, plip_timer_bh); 312 313 spin_lock_init(&nl->lock); 314 } 315 316 /* Bottom half handler for the delayed request. 317 This routine is kicked by do_timer(). 318 Request `plip_bh' to be invoked. */ 319 static void 320 plip_kick_bh(struct work_struct *work) 321 { 322 struct net_local *nl = 323 container_of(work, struct net_local, deferred.work); 324 325 if (nl->is_deferred) 326 schedule_work(&nl->immediate); 327 } 328 329 /* Forward declarations of internal routines */ 330 static int plip_none(struct net_device *, struct net_local *, 331 struct plip_local *, struct plip_local *); 332 static int plip_receive_packet(struct net_device *, struct net_local *, 333 struct plip_local *, struct plip_local *); 334 static int plip_send_packet(struct net_device *, struct net_local *, 335 struct plip_local *, struct plip_local *); 336 static int plip_connection_close(struct net_device *, struct net_local *, 337 struct plip_local *, struct plip_local *); 338 static int plip_error(struct net_device *, struct net_local *, 339 struct plip_local *, struct plip_local *); 340 static int plip_bh_timeout_error(struct net_device *dev, struct net_local *nl, 341 struct plip_local *snd, 342 struct plip_local *rcv, 343 int error); 344 345 #define OK 0 346 #define TIMEOUT 1 347 #define ERROR 2 348 #define HS_TIMEOUT 3 349 350 typedef int (*plip_func)(struct net_device *dev, struct net_local *nl, 351 struct plip_local *snd, struct plip_local *rcv); 352 353 static const plip_func connection_state_table[] = 354 { 355 plip_none, 356 plip_receive_packet, 357 plip_send_packet, 358 plip_connection_close, 359 plip_error 360 }; 361 362 /* Bottom half handler of PLIP. */ 363 static void 364 plip_bh(struct work_struct *work) 365 { 366 struct net_local *nl = container_of(work, struct net_local, immediate); 367 struct plip_local *snd = &nl->snd_data; 368 struct plip_local *rcv = &nl->rcv_data; 369 plip_func f; 370 int r; 371 372 nl->is_deferred = 0; 373 f = connection_state_table[nl->connection]; 374 if ((r = (*f)(nl->dev, nl, snd, rcv)) != OK && 375 (r = plip_bh_timeout_error(nl->dev, nl, snd, rcv, r)) != OK) { 376 nl->is_deferred = 1; 377 schedule_delayed_work(&nl->deferred, 1); 378 } 379 } 380 381 static void 382 plip_timer_bh(struct work_struct *work) 383 { 384 struct net_local *nl = 385 container_of(work, struct net_local, timer.work); 386 387 if (!(atomic_read (&nl->kill_timer))) { 388 plip_interrupt (nl->dev); 389 390 schedule_delayed_work(&nl->timer, 1); 391 } 392 else { 393 complete(&nl->killed_timer_cmp); 394 } 395 } 396 397 static int 398 plip_bh_timeout_error(struct net_device *dev, struct net_local *nl, 399 struct plip_local *snd, struct plip_local *rcv, 400 int error) 401 { 402 unsigned char c0; 403 /* 404 * This is tricky. If we got here from the beginning of send (either 405 * with ERROR or HS_TIMEOUT) we have IRQ enabled. Otherwise it's 406 * already disabled. With the old variant of {enable,disable}_irq() 407 * extra disable_irq() was a no-op. Now it became mortal - it's 408 * unbalanced and thus we'll never re-enable IRQ (until rmmod plip, 409 * that is). So we have to treat HS_TIMEOUT and ERROR from send 410 * in a special way. 411 */ 412 413 spin_lock_irq(&nl->lock); 414 if (nl->connection == PLIP_CN_SEND) { 415 416 if (error != ERROR) { /* Timeout */ 417 nl->timeout_count++; 418 if ((error == HS_TIMEOUT && nl->timeout_count <= 10) || 419 nl->timeout_count <= 3) { 420 spin_unlock_irq(&nl->lock); 421 /* Try again later */ 422 return TIMEOUT; 423 } 424 c0 = read_status(dev); 425 printk(KERN_WARNING "%s: transmit timeout(%d,%02x)\n", 426 dev->name, snd->state, c0); 427 } else 428 error = HS_TIMEOUT; 429 dev->stats.tx_errors++; 430 dev->stats.tx_aborted_errors++; 431 } else if (nl->connection == PLIP_CN_RECEIVE) { 432 if (rcv->state == PLIP_PK_TRIGGER) { 433 /* Transmission was interrupted. */ 434 spin_unlock_irq(&nl->lock); 435 return OK; 436 } 437 if (error != ERROR) { /* Timeout */ 438 if (++nl->timeout_count <= 3) { 439 spin_unlock_irq(&nl->lock); 440 /* Try again later */ 441 return TIMEOUT; 442 } 443 c0 = read_status(dev); 444 printk(KERN_WARNING "%s: receive timeout(%d,%02x)\n", 445 dev->name, rcv->state, c0); 446 } 447 dev->stats.rx_dropped++; 448 } 449 rcv->state = PLIP_PK_DONE; 450 if (rcv->skb) { 451 kfree_skb(rcv->skb); 452 rcv->skb = NULL; 453 } 454 snd->state = PLIP_PK_DONE; 455 if (snd->skb) { 456 dev_kfree_skb(snd->skb); 457 snd->skb = NULL; 458 } 459 spin_unlock_irq(&nl->lock); 460 if (error == HS_TIMEOUT) { 461 DISABLE(dev->irq); 462 synchronize_irq(dev->irq); 463 } 464 disable_parport_interrupts (dev); 465 netif_stop_queue (dev); 466 nl->connection = PLIP_CN_ERROR; 467 write_data (dev, 0x00); 468 469 return TIMEOUT; 470 } 471 472 static int 473 plip_none(struct net_device *dev, struct net_local *nl, 474 struct plip_local *snd, struct plip_local *rcv) 475 { 476 return OK; 477 } 478 479 /* PLIP_RECEIVE --- receive a byte(two nibbles) 480 Returns OK on success, TIMEOUT on timeout */ 481 static inline int 482 plip_receive(unsigned short nibble_timeout, struct net_device *dev, 483 enum plip_nibble_state *ns_p, unsigned char *data_p) 484 { 485 unsigned char c0, c1; 486 unsigned int cx; 487 488 switch (*ns_p) { 489 case PLIP_NB_BEGIN: 490 cx = nibble_timeout; 491 while (1) { 492 c0 = read_status(dev); 493 udelay(PLIP_DELAY_UNIT); 494 if ((c0 & 0x80) == 0) { 495 c1 = read_status(dev); 496 if (c0 == c1) 497 break; 498 } 499 if (--cx == 0) 500 return TIMEOUT; 501 } 502 *data_p = (c0 >> 3) & 0x0f; 503 write_data (dev, 0x10); /* send ACK */ 504 *ns_p = PLIP_NB_1; 505 /* fall through */ 506 507 case PLIP_NB_1: 508 cx = nibble_timeout; 509 while (1) { 510 c0 = read_status(dev); 511 udelay(PLIP_DELAY_UNIT); 512 if (c0 & 0x80) { 513 c1 = read_status(dev); 514 if (c0 == c1) 515 break; 516 } 517 if (--cx == 0) 518 return TIMEOUT; 519 } 520 *data_p |= (c0 << 1) & 0xf0; 521 write_data (dev, 0x00); /* send ACK */ 522 *ns_p = PLIP_NB_BEGIN; 523 case PLIP_NB_2: 524 break; 525 } 526 return OK; 527 } 528 529 /* 530 * Determine the packet's protocol ID. The rule here is that we 531 * assume 802.3 if the type field is short enough to be a length. 532 * This is normal practice and works for any 'now in use' protocol. 533 * 534 * PLIP is ethernet ish but the daddr might not be valid if unicast. 535 * PLIP fortunately has no bus architecture (its Point-to-point). 536 * 537 * We can't fix the daddr thing as that quirk (more bug) is embedded 538 * in far too many old systems not all even running Linux. 539 */ 540 541 static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev) 542 { 543 struct ethhdr *eth; 544 unsigned char *rawp; 545 546 skb_reset_mac_header(skb); 547 skb_pull(skb,dev->hard_header_len); 548 eth = eth_hdr(skb); 549 550 if(is_multicast_ether_addr(eth->h_dest)) 551 { 552 if(ether_addr_equal_64bits(eth->h_dest, dev->broadcast)) 553 skb->pkt_type=PACKET_BROADCAST; 554 else 555 skb->pkt_type=PACKET_MULTICAST; 556 } 557 558 /* 559 * This ALLMULTI check should be redundant by 1.4 560 * so don't forget to remove it. 561 */ 562 563 if (ntohs(eth->h_proto) >= ETH_P_802_3_MIN) 564 return eth->h_proto; 565 566 rawp = skb->data; 567 568 /* 569 * This is a magic hack to spot IPX packets. Older Novell breaks 570 * the protocol design and runs IPX over 802.3 without an 802.2 LLC 571 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This 572 * won't work for fault tolerant netware but does for the rest. 573 */ 574 if (*(unsigned short *)rawp == 0xFFFF) 575 return htons(ETH_P_802_3); 576 577 /* 578 * Real 802.2 LLC 579 */ 580 return htons(ETH_P_802_2); 581 } 582 583 /* PLIP_RECEIVE_PACKET --- receive a packet */ 584 static int 585 plip_receive_packet(struct net_device *dev, struct net_local *nl, 586 struct plip_local *snd, struct plip_local *rcv) 587 { 588 unsigned short nibble_timeout = nl->nibble; 589 unsigned char *lbuf; 590 591 switch (rcv->state) { 592 case PLIP_PK_TRIGGER: 593 DISABLE(dev->irq); 594 /* Don't need to synchronize irq, as we can safely ignore it */ 595 disable_parport_interrupts (dev); 596 write_data (dev, 0x01); /* send ACK */ 597 if (net_debug > 2) 598 printk(KERN_DEBUG "%s: receive start\n", dev->name); 599 rcv->state = PLIP_PK_LENGTH_LSB; 600 rcv->nibble = PLIP_NB_BEGIN; 601 /* fall through */ 602 603 case PLIP_PK_LENGTH_LSB: 604 if (snd->state != PLIP_PK_DONE) { 605 if (plip_receive(nl->trigger, dev, 606 &rcv->nibble, &rcv->length.b.lsb)) { 607 /* collision, here dev->tbusy == 1 */ 608 rcv->state = PLIP_PK_DONE; 609 nl->is_deferred = 1; 610 nl->connection = PLIP_CN_SEND; 611 schedule_delayed_work(&nl->deferred, 1); 612 enable_parport_interrupts (dev); 613 ENABLE(dev->irq); 614 return OK; 615 } 616 } else { 617 if (plip_receive(nibble_timeout, dev, 618 &rcv->nibble, &rcv->length.b.lsb)) 619 return TIMEOUT; 620 } 621 rcv->state = PLIP_PK_LENGTH_MSB; 622 /* fall through */ 623 624 case PLIP_PK_LENGTH_MSB: 625 if (plip_receive(nibble_timeout, dev, 626 &rcv->nibble, &rcv->length.b.msb)) 627 return TIMEOUT; 628 if (rcv->length.h > dev->mtu + dev->hard_header_len || 629 rcv->length.h < 8) { 630 printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h); 631 return ERROR; 632 } 633 /* Malloc up new buffer. */ 634 rcv->skb = dev_alloc_skb(rcv->length.h + 2); 635 if (rcv->skb == NULL) { 636 printk(KERN_ERR "%s: Memory squeeze.\n", dev->name); 637 return ERROR; 638 } 639 skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */ 640 skb_put(rcv->skb,rcv->length.h); 641 rcv->skb->dev = dev; 642 rcv->state = PLIP_PK_DATA; 643 rcv->byte = 0; 644 rcv->checksum = 0; 645 /* fall through */ 646 647 case PLIP_PK_DATA: 648 lbuf = rcv->skb->data; 649 do { 650 if (plip_receive(nibble_timeout, dev, 651 &rcv->nibble, &lbuf[rcv->byte])) 652 return TIMEOUT; 653 } while (++rcv->byte < rcv->length.h); 654 do { 655 rcv->checksum += lbuf[--rcv->byte]; 656 } while (rcv->byte); 657 rcv->state = PLIP_PK_CHECKSUM; 658 /* fall through */ 659 660 case PLIP_PK_CHECKSUM: 661 if (plip_receive(nibble_timeout, dev, 662 &rcv->nibble, &rcv->data)) 663 return TIMEOUT; 664 if (rcv->data != rcv->checksum) { 665 dev->stats.rx_crc_errors++; 666 if (net_debug) 667 printk(KERN_DEBUG "%s: checksum error\n", dev->name); 668 return ERROR; 669 } 670 rcv->state = PLIP_PK_DONE; 671 /* fall through */ 672 673 case PLIP_PK_DONE: 674 /* Inform the upper layer for the arrival of a packet. */ 675 rcv->skb->protocol=plip_type_trans(rcv->skb, dev); 676 netif_rx_ni(rcv->skb); 677 dev->stats.rx_bytes += rcv->length.h; 678 dev->stats.rx_packets++; 679 rcv->skb = NULL; 680 if (net_debug > 2) 681 printk(KERN_DEBUG "%s: receive end\n", dev->name); 682 683 /* Close the connection. */ 684 write_data (dev, 0x00); 685 spin_lock_irq(&nl->lock); 686 if (snd->state != PLIP_PK_DONE) { 687 nl->connection = PLIP_CN_SEND; 688 spin_unlock_irq(&nl->lock); 689 schedule_work(&nl->immediate); 690 enable_parport_interrupts (dev); 691 ENABLE(dev->irq); 692 return OK; 693 } else { 694 nl->connection = PLIP_CN_NONE; 695 spin_unlock_irq(&nl->lock); 696 enable_parport_interrupts (dev); 697 ENABLE(dev->irq); 698 return OK; 699 } 700 } 701 return OK; 702 } 703 704 /* PLIP_SEND --- send a byte (two nibbles) 705 Returns OK on success, TIMEOUT when timeout */ 706 static inline int 707 plip_send(unsigned short nibble_timeout, struct net_device *dev, 708 enum plip_nibble_state *ns_p, unsigned char data) 709 { 710 unsigned char c0; 711 unsigned int cx; 712 713 switch (*ns_p) { 714 case PLIP_NB_BEGIN: 715 write_data (dev, data & 0x0f); 716 *ns_p = PLIP_NB_1; 717 /* fall through */ 718 719 case PLIP_NB_1: 720 write_data (dev, 0x10 | (data & 0x0f)); 721 cx = nibble_timeout; 722 while (1) { 723 c0 = read_status(dev); 724 if ((c0 & 0x80) == 0) 725 break; 726 if (--cx == 0) 727 return TIMEOUT; 728 udelay(PLIP_DELAY_UNIT); 729 } 730 write_data (dev, 0x10 | (data >> 4)); 731 *ns_p = PLIP_NB_2; 732 /* fall through */ 733 734 case PLIP_NB_2: 735 write_data (dev, (data >> 4)); 736 cx = nibble_timeout; 737 while (1) { 738 c0 = read_status(dev); 739 if (c0 & 0x80) 740 break; 741 if (--cx == 0) 742 return TIMEOUT; 743 udelay(PLIP_DELAY_UNIT); 744 } 745 *ns_p = PLIP_NB_BEGIN; 746 return OK; 747 } 748 return OK; 749 } 750 751 /* PLIP_SEND_PACKET --- send a packet */ 752 static int 753 plip_send_packet(struct net_device *dev, struct net_local *nl, 754 struct plip_local *snd, struct plip_local *rcv) 755 { 756 unsigned short nibble_timeout = nl->nibble; 757 unsigned char *lbuf; 758 unsigned char c0; 759 unsigned int cx; 760 761 if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) { 762 printk(KERN_DEBUG "%s: send skb lost\n", dev->name); 763 snd->state = PLIP_PK_DONE; 764 snd->skb = NULL; 765 return ERROR; 766 } 767 768 switch (snd->state) { 769 case PLIP_PK_TRIGGER: 770 if ((read_status(dev) & 0xf8) != 0x80) 771 return HS_TIMEOUT; 772 773 /* Trigger remote rx interrupt. */ 774 write_data (dev, 0x08); 775 cx = nl->trigger; 776 while (1) { 777 udelay(PLIP_DELAY_UNIT); 778 spin_lock_irq(&nl->lock); 779 if (nl->connection == PLIP_CN_RECEIVE) { 780 spin_unlock_irq(&nl->lock); 781 /* Interrupted. */ 782 dev->stats.collisions++; 783 return OK; 784 } 785 c0 = read_status(dev); 786 if (c0 & 0x08) { 787 spin_unlock_irq(&nl->lock); 788 DISABLE(dev->irq); 789 synchronize_irq(dev->irq); 790 if (nl->connection == PLIP_CN_RECEIVE) { 791 /* Interrupted. 792 We don't need to enable irq, 793 as it is soon disabled. */ 794 /* Yes, we do. New variant of 795 {enable,disable}_irq *counts* 796 them. -- AV */ 797 ENABLE(dev->irq); 798 dev->stats.collisions++; 799 return OK; 800 } 801 disable_parport_interrupts (dev); 802 if (net_debug > 2) 803 printk(KERN_DEBUG "%s: send start\n", dev->name); 804 snd->state = PLIP_PK_LENGTH_LSB; 805 snd->nibble = PLIP_NB_BEGIN; 806 nl->timeout_count = 0; 807 break; 808 } 809 spin_unlock_irq(&nl->lock); 810 if (--cx == 0) { 811 write_data (dev, 0x00); 812 return HS_TIMEOUT; 813 } 814 } 815 816 case PLIP_PK_LENGTH_LSB: 817 if (plip_send(nibble_timeout, dev, 818 &snd->nibble, snd->length.b.lsb)) 819 return TIMEOUT; 820 snd->state = PLIP_PK_LENGTH_MSB; 821 /* fall through */ 822 823 case PLIP_PK_LENGTH_MSB: 824 if (plip_send(nibble_timeout, dev, 825 &snd->nibble, snd->length.b.msb)) 826 return TIMEOUT; 827 snd->state = PLIP_PK_DATA; 828 snd->byte = 0; 829 snd->checksum = 0; 830 /* fall through */ 831 832 case PLIP_PK_DATA: 833 do { 834 if (plip_send(nibble_timeout, dev, 835 &snd->nibble, lbuf[snd->byte])) 836 return TIMEOUT; 837 } while (++snd->byte < snd->length.h); 838 do { 839 snd->checksum += lbuf[--snd->byte]; 840 } while (snd->byte); 841 snd->state = PLIP_PK_CHECKSUM; 842 /* fall through */ 843 844 case PLIP_PK_CHECKSUM: 845 if (plip_send(nibble_timeout, dev, 846 &snd->nibble, snd->checksum)) 847 return TIMEOUT; 848 849 dev->stats.tx_bytes += snd->skb->len; 850 dev_kfree_skb(snd->skb); 851 dev->stats.tx_packets++; 852 snd->state = PLIP_PK_DONE; 853 /* fall through */ 854 855 case PLIP_PK_DONE: 856 /* Close the connection */ 857 write_data (dev, 0x00); 858 snd->skb = NULL; 859 if (net_debug > 2) 860 printk(KERN_DEBUG "%s: send end\n", dev->name); 861 nl->connection = PLIP_CN_CLOSING; 862 nl->is_deferred = 1; 863 schedule_delayed_work(&nl->deferred, 1); 864 enable_parport_interrupts (dev); 865 ENABLE(dev->irq); 866 return OK; 867 } 868 return OK; 869 } 870 871 static int 872 plip_connection_close(struct net_device *dev, struct net_local *nl, 873 struct plip_local *snd, struct plip_local *rcv) 874 { 875 spin_lock_irq(&nl->lock); 876 if (nl->connection == PLIP_CN_CLOSING) { 877 nl->connection = PLIP_CN_NONE; 878 netif_wake_queue (dev); 879 } 880 spin_unlock_irq(&nl->lock); 881 if (nl->should_relinquish) { 882 nl->should_relinquish = nl->port_owner = 0; 883 parport_release(nl->pardev); 884 } 885 return OK; 886 } 887 888 /* PLIP_ERROR --- wait till other end settled */ 889 static int 890 plip_error(struct net_device *dev, struct net_local *nl, 891 struct plip_local *snd, struct plip_local *rcv) 892 { 893 unsigned char status; 894 895 status = read_status(dev); 896 if ((status & 0xf8) == 0x80) { 897 if (net_debug > 2) 898 printk(KERN_DEBUG "%s: reset interface.\n", dev->name); 899 nl->connection = PLIP_CN_NONE; 900 nl->should_relinquish = 0; 901 netif_start_queue (dev); 902 enable_parport_interrupts (dev); 903 ENABLE(dev->irq); 904 netif_wake_queue (dev); 905 } else { 906 nl->is_deferred = 1; 907 schedule_delayed_work(&nl->deferred, 1); 908 } 909 910 return OK; 911 } 912 913 /* Handle the parallel port interrupts. */ 914 static void 915 plip_interrupt(void *dev_id) 916 { 917 struct net_device *dev = dev_id; 918 struct net_local *nl; 919 struct plip_local *rcv; 920 unsigned char c0; 921 unsigned long flags; 922 923 nl = netdev_priv(dev); 924 rcv = &nl->rcv_data; 925 926 spin_lock_irqsave (&nl->lock, flags); 927 928 c0 = read_status(dev); 929 if ((c0 & 0xf8) != 0xc0) { 930 if ((dev->irq != -1) && (net_debug > 1)) 931 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name); 932 spin_unlock_irqrestore (&nl->lock, flags); 933 return; 934 } 935 936 if (net_debug > 3) 937 printk(KERN_DEBUG "%s: interrupt.\n", dev->name); 938 939 switch (nl->connection) { 940 case PLIP_CN_CLOSING: 941 netif_wake_queue (dev); 942 /* fall through */ 943 case PLIP_CN_NONE: 944 case PLIP_CN_SEND: 945 rcv->state = PLIP_PK_TRIGGER; 946 nl->connection = PLIP_CN_RECEIVE; 947 nl->timeout_count = 0; 948 schedule_work(&nl->immediate); 949 break; 950 951 case PLIP_CN_RECEIVE: 952 /* May occur because there is race condition 953 around test and set of dev->interrupt. 954 Ignore this interrupt. */ 955 break; 956 957 case PLIP_CN_ERROR: 958 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name); 959 break; 960 } 961 962 spin_unlock_irqrestore(&nl->lock, flags); 963 } 964 965 static int 966 plip_tx_packet(struct sk_buff *skb, struct net_device *dev) 967 { 968 struct net_local *nl = netdev_priv(dev); 969 struct plip_local *snd = &nl->snd_data; 970 971 if (netif_queue_stopped(dev)) 972 return NETDEV_TX_BUSY; 973 974 /* We may need to grab the bus */ 975 if (!nl->port_owner) { 976 if (parport_claim(nl->pardev)) 977 return NETDEV_TX_BUSY; 978 nl->port_owner = 1; 979 } 980 981 netif_stop_queue (dev); 982 983 if (skb->len > dev->mtu + dev->hard_header_len) { 984 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len); 985 netif_start_queue (dev); 986 return NETDEV_TX_BUSY; 987 } 988 989 if (net_debug > 2) 990 printk(KERN_DEBUG "%s: send request\n", dev->name); 991 992 spin_lock_irq(&nl->lock); 993 snd->skb = skb; 994 snd->length.h = skb->len; 995 snd->state = PLIP_PK_TRIGGER; 996 if (nl->connection == PLIP_CN_NONE) { 997 nl->connection = PLIP_CN_SEND; 998 nl->timeout_count = 0; 999 } 1000 schedule_work(&nl->immediate); 1001 spin_unlock_irq(&nl->lock); 1002 1003 return NETDEV_TX_OK; 1004 } 1005 1006 static void 1007 plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth) 1008 { 1009 const struct in_device *in_dev; 1010 1011 rcu_read_lock(); 1012 in_dev = __in_dev_get_rcu(dev); 1013 if (in_dev) { 1014 /* Any address will do - we take the first */ 1015 const struct in_ifaddr *ifa = in_dev->ifa_list; 1016 if (ifa) { 1017 memcpy(eth->h_source, dev->dev_addr, ETH_ALEN); 1018 memset(eth->h_dest, 0xfc, 2); 1019 memcpy(eth->h_dest+2, &ifa->ifa_address, 4); 1020 } 1021 } 1022 rcu_read_unlock(); 1023 } 1024 1025 static int 1026 plip_hard_header(struct sk_buff *skb, struct net_device *dev, 1027 unsigned short type, const void *daddr, 1028 const void *saddr, unsigned len) 1029 { 1030 int ret; 1031 1032 ret = eth_header(skb, dev, type, daddr, saddr, len); 1033 if (ret >= 0) 1034 plip_rewrite_address (dev, (struct ethhdr *)skb->data); 1035 1036 return ret; 1037 } 1038 1039 static int plip_hard_header_cache(const struct neighbour *neigh, 1040 struct hh_cache *hh, __be16 type) 1041 { 1042 int ret; 1043 1044 ret = eth_header_cache(neigh, hh, type); 1045 if (ret == 0) { 1046 struct ethhdr *eth; 1047 1048 eth = (struct ethhdr*)(((u8*)hh->hh_data) + 1049 HH_DATA_OFF(sizeof(*eth))); 1050 plip_rewrite_address (neigh->dev, eth); 1051 } 1052 1053 return ret; 1054 } 1055 1056 /* Open/initialize the board. This is called (in the current kernel) 1057 sometime after booting when the 'ifconfig' program is run. 1058 1059 This routine gets exclusive access to the parallel port by allocating 1060 its IRQ line. 1061 */ 1062 static int 1063 plip_open(struct net_device *dev) 1064 { 1065 struct net_local *nl = netdev_priv(dev); 1066 struct in_device *in_dev; 1067 1068 /* Grab the port */ 1069 if (!nl->port_owner) { 1070 if (parport_claim(nl->pardev)) return -EAGAIN; 1071 nl->port_owner = 1; 1072 } 1073 1074 nl->should_relinquish = 0; 1075 1076 /* Clear the data port. */ 1077 write_data (dev, 0x00); 1078 1079 /* Enable rx interrupt. */ 1080 enable_parport_interrupts (dev); 1081 if (dev->irq == -1) 1082 { 1083 atomic_set (&nl->kill_timer, 0); 1084 schedule_delayed_work(&nl->timer, 1); 1085 } 1086 1087 /* Initialize the state machine. */ 1088 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE; 1089 nl->rcv_data.skb = nl->snd_data.skb = NULL; 1090 nl->connection = PLIP_CN_NONE; 1091 nl->is_deferred = 0; 1092 1093 /* Fill in the MAC-level header. 1094 We used to abuse dev->broadcast to store the point-to-point 1095 MAC address, but we no longer do it. Instead, we fetch the 1096 interface address whenever it is needed, which is cheap enough 1097 because we use the hh_cache. Actually, abusing dev->broadcast 1098 didn't work, because when using plip_open the point-to-point 1099 address isn't yet known. 1100 PLIP doesn't have a real MAC address, but we need it to be 1101 DOS compatible, and to properly support taps (otherwise, 1102 when the device address isn't identical to the address of a 1103 received frame, the kernel incorrectly drops it). */ 1104 1105 in_dev=__in_dev_get_rtnl(dev); 1106 if (in_dev) { 1107 /* Any address will do - we take the first. We already 1108 have the first two bytes filled with 0xfc, from 1109 plip_init_dev(). */ 1110 struct in_ifaddr *ifa=in_dev->ifa_list; 1111 if (ifa != NULL) { 1112 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4); 1113 } 1114 } 1115 1116 netif_start_queue (dev); 1117 1118 return 0; 1119 } 1120 1121 /* The inverse routine to plip_open (). */ 1122 static int 1123 plip_close(struct net_device *dev) 1124 { 1125 struct net_local *nl = netdev_priv(dev); 1126 struct plip_local *snd = &nl->snd_data; 1127 struct plip_local *rcv = &nl->rcv_data; 1128 1129 netif_stop_queue (dev); 1130 DISABLE(dev->irq); 1131 synchronize_irq(dev->irq); 1132 1133 if (dev->irq == -1) 1134 { 1135 init_completion(&nl->killed_timer_cmp); 1136 atomic_set (&nl->kill_timer, 1); 1137 wait_for_completion(&nl->killed_timer_cmp); 1138 } 1139 1140 #ifdef NOTDEF 1141 outb(0x00, PAR_DATA(dev)); 1142 #endif 1143 nl->is_deferred = 0; 1144 nl->connection = PLIP_CN_NONE; 1145 if (nl->port_owner) { 1146 parport_release(nl->pardev); 1147 nl->port_owner = 0; 1148 } 1149 1150 snd->state = PLIP_PK_DONE; 1151 if (snd->skb) { 1152 dev_kfree_skb(snd->skb); 1153 snd->skb = NULL; 1154 } 1155 rcv->state = PLIP_PK_DONE; 1156 if (rcv->skb) { 1157 kfree_skb(rcv->skb); 1158 rcv->skb = NULL; 1159 } 1160 1161 #ifdef NOTDEF 1162 /* Reset. */ 1163 outb(0x00, PAR_CONTROL(dev)); 1164 #endif 1165 return 0; 1166 } 1167 1168 static int 1169 plip_preempt(void *handle) 1170 { 1171 struct net_device *dev = (struct net_device *)handle; 1172 struct net_local *nl = netdev_priv(dev); 1173 1174 /* Stand our ground if a datagram is on the wire */ 1175 if (nl->connection != PLIP_CN_NONE) { 1176 nl->should_relinquish = 1; 1177 return 1; 1178 } 1179 1180 nl->port_owner = 0; /* Remember that we released the bus */ 1181 return 0; 1182 } 1183 1184 static void 1185 plip_wakeup(void *handle) 1186 { 1187 struct net_device *dev = (struct net_device *)handle; 1188 struct net_local *nl = netdev_priv(dev); 1189 1190 if (nl->port_owner) { 1191 /* Why are we being woken up? */ 1192 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name); 1193 if (!parport_claim(nl->pardev)) 1194 /* bus_owner is already set (but why?) */ 1195 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name); 1196 else 1197 return; 1198 } 1199 1200 if (!(dev->flags & IFF_UP)) 1201 /* Don't need the port when the interface is down */ 1202 return; 1203 1204 if (!parport_claim(nl->pardev)) { 1205 nl->port_owner = 1; 1206 /* Clear the data port. */ 1207 write_data (dev, 0x00); 1208 } 1209 } 1210 1211 static int 1212 plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1213 { 1214 struct net_local *nl = netdev_priv(dev); 1215 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru; 1216 1217 if (cmd != SIOCDEVPLIP) 1218 return -EOPNOTSUPP; 1219 1220 switch(pc->pcmd) { 1221 case PLIP_GET_TIMEOUT: 1222 pc->trigger = nl->trigger; 1223 pc->nibble = nl->nibble; 1224 break; 1225 case PLIP_SET_TIMEOUT: 1226 if(!capable(CAP_NET_ADMIN)) 1227 return -EPERM; 1228 nl->trigger = pc->trigger; 1229 nl->nibble = pc->nibble; 1230 break; 1231 default: 1232 return -EOPNOTSUPP; 1233 } 1234 return 0; 1235 } 1236 1237 static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 }; 1238 static int timid; 1239 1240 module_param_array(parport, int, NULL, 0); 1241 module_param(timid, int, 0); 1242 MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip"); 1243 1244 static struct net_device *dev_plip[PLIP_MAX] = { NULL, }; 1245 1246 static inline int 1247 plip_searchfor(int list[], int a) 1248 { 1249 int i; 1250 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) { 1251 if (list[i] == a) return 1; 1252 } 1253 return 0; 1254 } 1255 1256 /* plip_attach() is called (by the parport code) when a port is 1257 * available to use. */ 1258 static void plip_attach (struct parport *port) 1259 { 1260 static int unit; 1261 struct net_device *dev; 1262 struct net_local *nl; 1263 char name[IFNAMSIZ]; 1264 struct pardev_cb plip_cb; 1265 1266 if ((parport[0] == -1 && (!timid || !port->devices)) || 1267 plip_searchfor(parport, port->number)) { 1268 if (unit == PLIP_MAX) { 1269 printk(KERN_ERR "plip: too many devices\n"); 1270 return; 1271 } 1272 1273 sprintf(name, "plip%d", unit); 1274 dev = alloc_etherdev(sizeof(struct net_local)); 1275 if (!dev) 1276 return; 1277 1278 strcpy(dev->name, name); 1279 1280 dev->irq = port->irq; 1281 dev->base_addr = port->base; 1282 if (port->irq == -1) { 1283 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode," 1284 "which is fairly inefficient!\n", port->name); 1285 } 1286 1287 nl = netdev_priv(dev); 1288 nl->dev = dev; 1289 1290 memset(&plip_cb, 0, sizeof(plip_cb)); 1291 plip_cb.private = dev; 1292 plip_cb.preempt = plip_preempt; 1293 plip_cb.wakeup = plip_wakeup; 1294 plip_cb.irq_func = plip_interrupt; 1295 1296 nl->pardev = parport_register_dev_model(port, dev->name, 1297 &plip_cb, unit); 1298 1299 if (!nl->pardev) { 1300 printk(KERN_ERR "%s: parport_register failed\n", name); 1301 goto err_free_dev; 1302 } 1303 1304 plip_init_netdev(dev); 1305 1306 if (register_netdev(dev)) { 1307 printk(KERN_ERR "%s: network register failed\n", name); 1308 goto err_parport_unregister; 1309 } 1310 1311 printk(KERN_INFO "%s", version); 1312 if (dev->irq != -1) 1313 printk(KERN_INFO "%s: Parallel port at %#3lx, " 1314 "using IRQ %d.\n", 1315 dev->name, dev->base_addr, dev->irq); 1316 else 1317 printk(KERN_INFO "%s: Parallel port at %#3lx, " 1318 "not using IRQ.\n", 1319 dev->name, dev->base_addr); 1320 dev_plip[unit++] = dev; 1321 } 1322 return; 1323 1324 err_parport_unregister: 1325 parport_unregister_device(nl->pardev); 1326 err_free_dev: 1327 free_netdev(dev); 1328 } 1329 1330 /* plip_detach() is called (by the parport code) when a port is 1331 * no longer available to use. */ 1332 static void plip_detach (struct parport *port) 1333 { 1334 /* Nothing to do */ 1335 } 1336 1337 static int plip_probe(struct pardevice *par_dev) 1338 { 1339 struct device_driver *drv = par_dev->dev.driver; 1340 int len = strlen(drv->name); 1341 1342 if (strncmp(par_dev->name, drv->name, len)) 1343 return -ENODEV; 1344 1345 return 0; 1346 } 1347 1348 static struct parport_driver plip_driver = { 1349 .name = "plip", 1350 .probe = plip_probe, 1351 .match_port = plip_attach, 1352 .detach = plip_detach, 1353 .devmodel = true, 1354 }; 1355 1356 static void __exit plip_cleanup_module (void) 1357 { 1358 struct net_device *dev; 1359 int i; 1360 1361 for (i=0; i < PLIP_MAX; i++) { 1362 if ((dev = dev_plip[i])) { 1363 struct net_local *nl = netdev_priv(dev); 1364 unregister_netdev(dev); 1365 if (nl->port_owner) 1366 parport_release(nl->pardev); 1367 parport_unregister_device(nl->pardev); 1368 free_netdev(dev); 1369 dev_plip[i] = NULL; 1370 } 1371 } 1372 1373 parport_unregister_driver(&plip_driver); 1374 } 1375 1376 #ifndef MODULE 1377 1378 static int parport_ptr; 1379 1380 static int __init plip_setup(char *str) 1381 { 1382 int ints[4]; 1383 1384 str = get_options(str, ARRAY_SIZE(ints), ints); 1385 1386 /* Ugh. */ 1387 if (!strncmp(str, "parport", 7)) { 1388 int n = simple_strtoul(str+7, NULL, 10); 1389 if (parport_ptr < PLIP_MAX) 1390 parport[parport_ptr++] = n; 1391 else 1392 printk(KERN_INFO "plip: too many ports, %s ignored.\n", 1393 str); 1394 } else if (!strcmp(str, "timid")) { 1395 timid = 1; 1396 } else { 1397 if (ints[0] == 0 || ints[1] == 0) { 1398 /* disable driver on "plip=" or "plip=0" */ 1399 parport[0] = -2; 1400 } else { 1401 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n", 1402 ints[1]); 1403 } 1404 } 1405 return 1; 1406 } 1407 1408 __setup("plip=", plip_setup); 1409 1410 #endif /* !MODULE */ 1411 1412 static int __init plip_init (void) 1413 { 1414 if (parport[0] == -2) 1415 return 0; 1416 1417 if (parport[0] != -1 && timid) { 1418 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n"); 1419 timid = 0; 1420 } 1421 1422 if (parport_register_driver (&plip_driver)) { 1423 printk (KERN_WARNING "plip: couldn't register driver\n"); 1424 return 1; 1425 } 1426 1427 return 0; 1428 } 1429 1430 module_init(plip_init); 1431 module_exit(plip_cleanup_module); 1432 MODULE_LICENSE("GPL"); 1433