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