1/* $Id: plip.c,v 1.3.6.2 1997/04/16 15:07:56 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 */ 57static 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/system.h> 117#include <asm/irq.h> 118#include <asm/byteorder.h> 119 120/* Maximum number of devices to support. */ 121#define PLIP_MAX 8 122 123/* Use 0 for production, 1 for verification, >2 for debug */ 124#ifndef NET_DEBUG 125#define NET_DEBUG 1 126#endif 127static const unsigned int net_debug = NET_DEBUG; 128 129#define ENABLE(irq) if (irq != -1) enable_irq(irq) 130#define DISABLE(irq) if (irq != -1) disable_irq(irq) 131 132/* In micro second */ 133#define PLIP_DELAY_UNIT 1 134 135/* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */ 136#define PLIP_TRIGGER_WAIT 500 137 138/* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */ 139#define PLIP_NIBBLE_WAIT 3000 140 141/* Bottom halves */ 142static void plip_kick_bh(struct work_struct *work); 143static void plip_bh(struct work_struct *work); 144static void plip_timer_bh(struct work_struct *work); 145 146/* Interrupt handler */ 147static void plip_interrupt(void *dev_id); 148 149/* Functions for DEV methods */ 150static int plip_tx_packet(struct sk_buff *skb, struct net_device *dev); 151static int plip_hard_header(struct sk_buff *skb, struct net_device *dev, 152 unsigned short type, const void *daddr, 153 const void *saddr, unsigned len); 154static int plip_hard_header_cache(const struct neighbour *neigh, 155 struct hh_cache *hh); 156static int plip_open(struct net_device *dev); 157static int plip_close(struct net_device *dev); 158static int plip_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd); 159static int plip_preempt(void *handle); 160static void plip_wakeup(void *handle); 161 162enum plip_connection_state { 163 PLIP_CN_NONE=0, 164 PLIP_CN_RECEIVE, 165 PLIP_CN_SEND, 166 PLIP_CN_CLOSING, 167 PLIP_CN_ERROR 168}; 169 170enum plip_packet_state { 171 PLIP_PK_DONE=0, 172 PLIP_PK_TRIGGER, 173 PLIP_PK_LENGTH_LSB, 174 PLIP_PK_LENGTH_MSB, 175 PLIP_PK_DATA, 176 PLIP_PK_CHECKSUM 177}; 178 179enum plip_nibble_state { 180 PLIP_NB_BEGIN, 181 PLIP_NB_1, 182 PLIP_NB_2, 183}; 184 185struct plip_local { 186 enum plip_packet_state state; 187 enum plip_nibble_state nibble; 188 union { 189 struct { 190#if defined(__LITTLE_ENDIAN) 191 unsigned char lsb; 192 unsigned char msb; 193#elif defined(__BIG_ENDIAN) 194 unsigned char msb; 195 unsigned char lsb; 196#else 197#error "Please fix the endianness defines in <asm/byteorder.h>" 198#endif 199 } b; 200 unsigned short h; 201 } length; 202 unsigned short byte; 203 unsigned char checksum; 204 unsigned char data; 205 struct sk_buff *skb; 206}; 207 208struct net_local { 209 struct net_device *dev; 210 struct work_struct immediate; 211 struct delayed_work deferred; 212 struct delayed_work timer; 213 struct plip_local snd_data; 214 struct plip_local rcv_data; 215 struct pardevice *pardev; 216 unsigned long trigger; 217 unsigned long nibble; 218 enum plip_connection_state connection; 219 unsigned short timeout_count; 220 int is_deferred; 221 int port_owner; 222 int should_relinquish; 223 spinlock_t lock; 224 atomic_t kill_timer; 225 struct completion killed_timer_cmp; 226}; 227 228static inline void enable_parport_interrupts (struct net_device *dev) 229{ 230 if (dev->irq != -1) 231 { 232 struct parport *port = 233 ((struct net_local *)netdev_priv(dev))->pardev->port; 234 port->ops->enable_irq (port); 235 } 236} 237 238static inline void disable_parport_interrupts (struct net_device *dev) 239{ 240 if (dev->irq != -1) 241 { 242 struct parport *port = 243 ((struct net_local *)netdev_priv(dev))->pardev->port; 244 port->ops->disable_irq (port); 245 } 246} 247 248static inline void write_data (struct net_device *dev, unsigned char data) 249{ 250 struct parport *port = 251 ((struct net_local *)netdev_priv(dev))->pardev->port; 252 253 port->ops->write_data (port, data); 254} 255 256static inline unsigned char read_status (struct net_device *dev) 257{ 258 struct parport *port = 259 ((struct net_local *)netdev_priv(dev))->pardev->port; 260 261 return port->ops->read_status (port); 262} 263 264static const struct header_ops plip_header_ops = { 265 .create = plip_hard_header, 266 .cache = plip_hard_header_cache, 267}; 268 269static const struct net_device_ops plip_netdev_ops = { 270 .ndo_open = plip_open, 271 .ndo_stop = plip_close, 272 .ndo_start_xmit = plip_tx_packet, 273 .ndo_do_ioctl = plip_ioctl, 274 .ndo_change_mtu = eth_change_mtu, 275 .ndo_set_mac_address = eth_mac_addr, 276 .ndo_validate_addr = eth_validate_addr, 277}; 278 279/* Entry point of PLIP driver. 280 Probe the hardware, and register/initialize the driver. 281 282 PLIP is rather weird, because of the way it interacts with the parport 283 system. It is _not_ initialised from Space.c. Instead, plip_init() 284 is called, and that function makes up a "struct net_device" for each port, and 285 then calls us here. 286 287 */ 288static void 289plip_init_netdev(struct net_device *dev) 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 memset(dev->dev_addr, 0xfc, ETH_ALEN); 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. */ 321static void 322plip_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 */ 332static int plip_none(struct net_device *, struct net_local *, 333 struct plip_local *, struct plip_local *); 334static int plip_receive_packet(struct net_device *, struct net_local *, 335 struct plip_local *, struct plip_local *); 336static int plip_send_packet(struct net_device *, struct net_local *, 337 struct plip_local *, struct plip_local *); 338static int plip_connection_close(struct net_device *, struct net_local *, 339 struct plip_local *, struct plip_local *); 340static int plip_error(struct net_device *, struct net_local *, 341 struct plip_local *, struct plip_local *); 342static 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 352typedef int (*plip_func)(struct net_device *dev, struct net_local *nl, 353 struct plip_local *snd, struct plip_local *rcv); 354 355static 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. */ 365static void 366plip_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 383static void 384plip_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 399static int 400plip_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 kfree_skb(rcv->skb); 454 rcv->skb = NULL; 455 } 456 snd->state = PLIP_PK_DONE; 457 if (snd->skb) { 458 dev_kfree_skb(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 474static int 475plip_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 */ 483static inline int 484plip_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 508 case PLIP_NB_1: 509 cx = nibble_timeout; 510 while (1) { 511 c0 = read_status(dev); 512 udelay(PLIP_DELAY_UNIT); 513 if (c0 & 0x80) { 514 c1 = read_status(dev); 515 if (c0 == c1) 516 break; 517 } 518 if (--cx == 0) 519 return TIMEOUT; 520 } 521 *data_p |= (c0 << 1) & 0xf0; 522 write_data (dev, 0x00); /* send ACK */ 523 *ns_p = PLIP_NB_BEGIN; 524 case PLIP_NB_2: 525 break; 526 } 527 return OK; 528} 529 530/* 531 * Determine the packet's protocol ID. The rule here is that we 532 * assume 802.3 if the type field is short enough to be a length. 533 * This is normal practice and works for any 'now in use' protocol. 534 * 535 * PLIP is ethernet ish but the daddr might not be valid if unicast. 536 * PLIP fortunately has no bus architecture (its Point-to-point). 537 * 538 * We can't fix the daddr thing as that quirk (more bug) is embedded 539 * in far too many old systems not all even running Linux. 540 */ 541 542static __be16 plip_type_trans(struct sk_buff *skb, struct net_device *dev) 543{ 544 struct ethhdr *eth; 545 unsigned char *rawp; 546 547 skb_reset_mac_header(skb); 548 skb_pull(skb,dev->hard_header_len); 549 eth = eth_hdr(skb); 550 551 if(*eth->h_dest&1) 552 { 553 if(memcmp(eth->h_dest,dev->broadcast, ETH_ALEN)==0) 554 skb->pkt_type=PACKET_BROADCAST; 555 else 556 skb->pkt_type=PACKET_MULTICAST; 557 } 558 559 /* 560 * This ALLMULTI check should be redundant by 1.4 561 * so don't forget to remove it. 562 */ 563 564 if (ntohs(eth->h_proto) >= 1536) 565 return eth->h_proto; 566 567 rawp = skb->data; 568 569 /* 570 * This is a magic hack to spot IPX packets. Older Novell breaks 571 * the protocol design and runs IPX over 802.3 without an 802.2 LLC 572 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This 573 * won't work for fault tolerant netware but does for the rest. 574 */ 575 if (*(unsigned short *)rawp == 0xFFFF) 576 return htons(ETH_P_802_3); 577 578 /* 579 * Real 802.2 LLC 580 */ 581 return htons(ETH_P_802_2); 582} 583 584/* PLIP_RECEIVE_PACKET --- receive a packet */ 585static int 586plip_receive_packet(struct net_device *dev, struct net_local *nl, 587 struct plip_local *snd, struct plip_local *rcv) 588{ 589 unsigned short nibble_timeout = nl->nibble; 590 unsigned char *lbuf; 591 592 switch (rcv->state) { 593 case PLIP_PK_TRIGGER: 594 DISABLE(dev->irq); 595 /* Don't need to synchronize irq, as we can safely ignore it */ 596 disable_parport_interrupts (dev); 597 write_data (dev, 0x01); /* send ACK */ 598 if (net_debug > 2) 599 printk(KERN_DEBUG "%s: receive start\n", dev->name); 600 rcv->state = PLIP_PK_LENGTH_LSB; 601 rcv->nibble = PLIP_NB_BEGIN; 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 623 case PLIP_PK_LENGTH_MSB: 624 if (plip_receive(nibble_timeout, dev, 625 &rcv->nibble, &rcv->length.b.msb)) 626 return TIMEOUT; 627 if (rcv->length.h > dev->mtu + dev->hard_header_len || 628 rcv->length.h < 8) { 629 printk(KERN_WARNING "%s: bogus packet size %d.\n", dev->name, rcv->length.h); 630 return ERROR; 631 } 632 /* Malloc up new buffer. */ 633 rcv->skb = dev_alloc_skb(rcv->length.h + 2); 634 if (rcv->skb == NULL) { 635 printk(KERN_ERR "%s: Memory squeeze.\n", dev->name); 636 return ERROR; 637 } 638 skb_reserve(rcv->skb, 2); /* Align IP on 16 byte boundaries */ 639 skb_put(rcv->skb,rcv->length.h); 640 rcv->skb->dev = dev; 641 rcv->state = PLIP_PK_DATA; 642 rcv->byte = 0; 643 rcv->checksum = 0; 644 645 case PLIP_PK_DATA: 646 lbuf = rcv->skb->data; 647 do { 648 if (plip_receive(nibble_timeout, dev, 649 &rcv->nibble, &lbuf[rcv->byte])) 650 return TIMEOUT; 651 } while (++rcv->byte < rcv->length.h); 652 do { 653 rcv->checksum += lbuf[--rcv->byte]; 654 } while (rcv->byte); 655 rcv->state = PLIP_PK_CHECKSUM; 656 657 case PLIP_PK_CHECKSUM: 658 if (plip_receive(nibble_timeout, dev, 659 &rcv->nibble, &rcv->data)) 660 return TIMEOUT; 661 if (rcv->data != rcv->checksum) { 662 dev->stats.rx_crc_errors++; 663 if (net_debug) 664 printk(KERN_DEBUG "%s: checksum error\n", dev->name); 665 return ERROR; 666 } 667 rcv->state = PLIP_PK_DONE; 668 669 case PLIP_PK_DONE: 670 /* Inform the upper layer for the arrival of a packet. */ 671 rcv->skb->protocol=plip_type_trans(rcv->skb, dev); 672 netif_rx_ni(rcv->skb); 673 dev->stats.rx_bytes += rcv->length.h; 674 dev->stats.rx_packets++; 675 rcv->skb = NULL; 676 if (net_debug > 2) 677 printk(KERN_DEBUG "%s: receive end\n", dev->name); 678 679 /* Close the connection. */ 680 write_data (dev, 0x00); 681 spin_lock_irq(&nl->lock); 682 if (snd->state != PLIP_PK_DONE) { 683 nl->connection = PLIP_CN_SEND; 684 spin_unlock_irq(&nl->lock); 685 schedule_work(&nl->immediate); 686 enable_parport_interrupts (dev); 687 ENABLE(dev->irq); 688 return OK; 689 } else { 690 nl->connection = PLIP_CN_NONE; 691 spin_unlock_irq(&nl->lock); 692 enable_parport_interrupts (dev); 693 ENABLE(dev->irq); 694 return OK; 695 } 696 } 697 return OK; 698} 699 700/* PLIP_SEND --- send a byte (two nibbles) 701 Returns OK on success, TIMEOUT when timeout */ 702static inline int 703plip_send(unsigned short nibble_timeout, struct net_device *dev, 704 enum plip_nibble_state *ns_p, unsigned char data) 705{ 706 unsigned char c0; 707 unsigned int cx; 708 709 switch (*ns_p) { 710 case PLIP_NB_BEGIN: 711 write_data (dev, data & 0x0f); 712 *ns_p = PLIP_NB_1; 713 714 case PLIP_NB_1: 715 write_data (dev, 0x10 | (data & 0x0f)); 716 cx = nibble_timeout; 717 while (1) { 718 c0 = read_status(dev); 719 if ((c0 & 0x80) == 0) 720 break; 721 if (--cx == 0) 722 return TIMEOUT; 723 udelay(PLIP_DELAY_UNIT); 724 } 725 write_data (dev, 0x10 | (data >> 4)); 726 *ns_p = PLIP_NB_2; 727 728 case PLIP_NB_2: 729 write_data (dev, (data >> 4)); 730 cx = nibble_timeout; 731 while (1) { 732 c0 = read_status(dev); 733 if (c0 & 0x80) 734 break; 735 if (--cx == 0) 736 return TIMEOUT; 737 udelay(PLIP_DELAY_UNIT); 738 } 739 *ns_p = PLIP_NB_BEGIN; 740 return OK; 741 } 742 return OK; 743} 744 745/* PLIP_SEND_PACKET --- send a packet */ 746static int 747plip_send_packet(struct net_device *dev, struct net_local *nl, 748 struct plip_local *snd, struct plip_local *rcv) 749{ 750 unsigned short nibble_timeout = nl->nibble; 751 unsigned char *lbuf; 752 unsigned char c0; 753 unsigned int cx; 754 755 if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) { 756 printk(KERN_DEBUG "%s: send skb lost\n", dev->name); 757 snd->state = PLIP_PK_DONE; 758 snd->skb = NULL; 759 return ERROR; 760 } 761 762 switch (snd->state) { 763 case PLIP_PK_TRIGGER: 764 if ((read_status(dev) & 0xf8) != 0x80) 765 return HS_TIMEOUT; 766 767 /* Trigger remote rx interrupt. */ 768 write_data (dev, 0x08); 769 cx = nl->trigger; 770 while (1) { 771 udelay(PLIP_DELAY_UNIT); 772 spin_lock_irq(&nl->lock); 773 if (nl->connection == PLIP_CN_RECEIVE) { 774 spin_unlock_irq(&nl->lock); 775 /* Interrupted. */ 776 dev->stats.collisions++; 777 return OK; 778 } 779 c0 = read_status(dev); 780 if (c0 & 0x08) { 781 spin_unlock_irq(&nl->lock); 782 DISABLE(dev->irq); 783 synchronize_irq(dev->irq); 784 if (nl->connection == PLIP_CN_RECEIVE) { 785 /* Interrupted. 786 We don't need to enable irq, 787 as it is soon disabled. */ 788 /* Yes, we do. New variant of 789 {enable,disable}_irq *counts* 790 them. -- AV */ 791 ENABLE(dev->irq); 792 dev->stats.collisions++; 793 return OK; 794 } 795 disable_parport_interrupts (dev); 796 if (net_debug > 2) 797 printk(KERN_DEBUG "%s: send start\n", dev->name); 798 snd->state = PLIP_PK_LENGTH_LSB; 799 snd->nibble = PLIP_NB_BEGIN; 800 nl->timeout_count = 0; 801 break; 802 } 803 spin_unlock_irq(&nl->lock); 804 if (--cx == 0) { 805 write_data (dev, 0x00); 806 return HS_TIMEOUT; 807 } 808 } 809 810 case PLIP_PK_LENGTH_LSB: 811 if (plip_send(nibble_timeout, dev, 812 &snd->nibble, snd->length.b.lsb)) 813 return TIMEOUT; 814 snd->state = PLIP_PK_LENGTH_MSB; 815 816 case PLIP_PK_LENGTH_MSB: 817 if (plip_send(nibble_timeout, dev, 818 &snd->nibble, snd->length.b.msb)) 819 return TIMEOUT; 820 snd->state = PLIP_PK_DATA; 821 snd->byte = 0; 822 snd->checksum = 0; 823 824 case PLIP_PK_DATA: 825 do { 826 if (plip_send(nibble_timeout, dev, 827 &snd->nibble, lbuf[snd->byte])) 828 return TIMEOUT; 829 } while (++snd->byte < snd->length.h); 830 do { 831 snd->checksum += lbuf[--snd->byte]; 832 } while (snd->byte); 833 snd->state = PLIP_PK_CHECKSUM; 834 835 case PLIP_PK_CHECKSUM: 836 if (plip_send(nibble_timeout, dev, 837 &snd->nibble, snd->checksum)) 838 return TIMEOUT; 839 840 dev->stats.tx_bytes += snd->skb->len; 841 dev_kfree_skb(snd->skb); 842 dev->stats.tx_packets++; 843 snd->state = PLIP_PK_DONE; 844 845 case PLIP_PK_DONE: 846 /* Close the connection */ 847 write_data (dev, 0x00); 848 snd->skb = NULL; 849 if (net_debug > 2) 850 printk(KERN_DEBUG "%s: send end\n", dev->name); 851 nl->connection = PLIP_CN_CLOSING; 852 nl->is_deferred = 1; 853 schedule_delayed_work(&nl->deferred, 1); 854 enable_parport_interrupts (dev); 855 ENABLE(dev->irq); 856 return OK; 857 } 858 return OK; 859} 860 861static int 862plip_connection_close(struct net_device *dev, struct net_local *nl, 863 struct plip_local *snd, struct plip_local *rcv) 864{ 865 spin_lock_irq(&nl->lock); 866 if (nl->connection == PLIP_CN_CLOSING) { 867 nl->connection = PLIP_CN_NONE; 868 netif_wake_queue (dev); 869 } 870 spin_unlock_irq(&nl->lock); 871 if (nl->should_relinquish) { 872 nl->should_relinquish = nl->port_owner = 0; 873 parport_release(nl->pardev); 874 } 875 return OK; 876} 877 878/* PLIP_ERROR --- wait till other end settled */ 879static int 880plip_error(struct net_device *dev, struct net_local *nl, 881 struct plip_local *snd, struct plip_local *rcv) 882{ 883 unsigned char status; 884 885 status = read_status(dev); 886 if ((status & 0xf8) == 0x80) { 887 if (net_debug > 2) 888 printk(KERN_DEBUG "%s: reset interface.\n", dev->name); 889 nl->connection = PLIP_CN_NONE; 890 nl->should_relinquish = 0; 891 netif_start_queue (dev); 892 enable_parport_interrupts (dev); 893 ENABLE(dev->irq); 894 netif_wake_queue (dev); 895 } else { 896 nl->is_deferred = 1; 897 schedule_delayed_work(&nl->deferred, 1); 898 } 899 900 return OK; 901} 902 903/* Handle the parallel port interrupts. */ 904static void 905plip_interrupt(void *dev_id) 906{ 907 struct net_device *dev = dev_id; 908 struct net_local *nl; 909 struct plip_local *rcv; 910 unsigned char c0; 911 unsigned long flags; 912 913 nl = netdev_priv(dev); 914 rcv = &nl->rcv_data; 915 916 spin_lock_irqsave (&nl->lock, flags); 917 918 c0 = read_status(dev); 919 if ((c0 & 0xf8) != 0xc0) { 920 if ((dev->irq != -1) && (net_debug > 1)) 921 printk(KERN_DEBUG "%s: spurious interrupt\n", dev->name); 922 spin_unlock_irqrestore (&nl->lock, flags); 923 return; 924 } 925 926 if (net_debug > 3) 927 printk(KERN_DEBUG "%s: interrupt.\n", dev->name); 928 929 switch (nl->connection) { 930 case PLIP_CN_CLOSING: 931 netif_wake_queue (dev); 932 case PLIP_CN_NONE: 933 case PLIP_CN_SEND: 934 rcv->state = PLIP_PK_TRIGGER; 935 nl->connection = PLIP_CN_RECEIVE; 936 nl->timeout_count = 0; 937 schedule_work(&nl->immediate); 938 break; 939 940 case PLIP_CN_RECEIVE: 941 /* May occur because there is race condition 942 around test and set of dev->interrupt. 943 Ignore this interrupt. */ 944 break; 945 946 case PLIP_CN_ERROR: 947 printk(KERN_ERR "%s: receive interrupt in error state\n", dev->name); 948 break; 949 } 950 951 spin_unlock_irqrestore(&nl->lock, flags); 952} 953 954static int 955plip_tx_packet(struct sk_buff *skb, struct net_device *dev) 956{ 957 struct net_local *nl = netdev_priv(dev); 958 struct plip_local *snd = &nl->snd_data; 959 960 if (netif_queue_stopped(dev)) 961 return NETDEV_TX_BUSY; 962 963 /* We may need to grab the bus */ 964 if (!nl->port_owner) { 965 if (parport_claim(nl->pardev)) 966 return NETDEV_TX_BUSY; 967 nl->port_owner = 1; 968 } 969 970 netif_stop_queue (dev); 971 972 if (skb->len > dev->mtu + dev->hard_header_len) { 973 printk(KERN_WARNING "%s: packet too big, %d.\n", dev->name, (int)skb->len); 974 netif_start_queue (dev); 975 return NETDEV_TX_BUSY; 976 } 977 978 if (net_debug > 2) 979 printk(KERN_DEBUG "%s: send request\n", dev->name); 980 981 spin_lock_irq(&nl->lock); 982 snd->skb = skb; 983 snd->length.h = skb->len; 984 snd->state = PLIP_PK_TRIGGER; 985 if (nl->connection == PLIP_CN_NONE) { 986 nl->connection = PLIP_CN_SEND; 987 nl->timeout_count = 0; 988 } 989 schedule_work(&nl->immediate); 990 spin_unlock_irq(&nl->lock); 991 992 return NETDEV_TX_OK; 993} 994 995static void 996plip_rewrite_address(const struct net_device *dev, struct ethhdr *eth) 997{ 998 const struct in_device *in_dev = dev->ip_ptr; 999 1000 if (in_dev) { 1001 /* Any address will do - we take the first */ 1002 const struct in_ifaddr *ifa = in_dev->ifa_list; 1003 if (ifa) { 1004 memcpy(eth->h_source, dev->dev_addr, 6); 1005 memset(eth->h_dest, 0xfc, 2); 1006 memcpy(eth->h_dest+2, &ifa->ifa_address, 4); 1007 } 1008 } 1009} 1010 1011static int 1012plip_hard_header(struct sk_buff *skb, struct net_device *dev, 1013 unsigned short type, const void *daddr, 1014 const void *saddr, unsigned len) 1015{ 1016 int ret; 1017 1018 ret = eth_header(skb, dev, type, daddr, saddr, len); 1019 if (ret >= 0) 1020 plip_rewrite_address (dev, (struct ethhdr *)skb->data); 1021 1022 return ret; 1023} 1024 1025static int plip_hard_header_cache(const struct neighbour *neigh, 1026 struct hh_cache *hh) 1027{ 1028 int ret; 1029 1030 ret = eth_header_cache(neigh, hh); 1031 if (ret == 0) { 1032 struct ethhdr *eth; 1033 1034 eth = (struct ethhdr*)(((u8*)hh->hh_data) + 1035 HH_DATA_OFF(sizeof(*eth))); 1036 plip_rewrite_address (neigh->dev, eth); 1037 } 1038 1039 return ret; 1040} 1041 1042/* Open/initialize the board. This is called (in the current kernel) 1043 sometime after booting when the 'ifconfig' program is run. 1044 1045 This routine gets exclusive access to the parallel port by allocating 1046 its IRQ line. 1047 */ 1048static int 1049plip_open(struct net_device *dev) 1050{ 1051 struct net_local *nl = netdev_priv(dev); 1052 struct in_device *in_dev; 1053 1054 /* Grab the port */ 1055 if (!nl->port_owner) { 1056 if (parport_claim(nl->pardev)) return -EAGAIN; 1057 nl->port_owner = 1; 1058 } 1059 1060 nl->should_relinquish = 0; 1061 1062 /* Clear the data port. */ 1063 write_data (dev, 0x00); 1064 1065 /* Enable rx interrupt. */ 1066 enable_parport_interrupts (dev); 1067 if (dev->irq == -1) 1068 { 1069 atomic_set (&nl->kill_timer, 0); 1070 schedule_delayed_work(&nl->timer, 1); 1071 } 1072 1073 /* Initialize the state machine. */ 1074 nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE; 1075 nl->rcv_data.skb = nl->snd_data.skb = NULL; 1076 nl->connection = PLIP_CN_NONE; 1077 nl->is_deferred = 0; 1078 1079 /* Fill in the MAC-level header. 1080 We used to abuse dev->broadcast to store the point-to-point 1081 MAC address, but we no longer do it. Instead, we fetch the 1082 interface address whenever it is needed, which is cheap enough 1083 because we use the hh_cache. Actually, abusing dev->broadcast 1084 didn't work, because when using plip_open the point-to-point 1085 address isn't yet known. 1086 PLIP doesn't have a real MAC address, but we need it to be 1087 DOS compatible, and to properly support taps (otherwise, 1088 when the device address isn't identical to the address of a 1089 received frame, the kernel incorrectly drops it). */ 1090 1091 if ((in_dev=dev->ip_ptr) != NULL) { 1092 /* Any address will do - we take the first. We already 1093 have the first two bytes filled with 0xfc, from 1094 plip_init_dev(). */ 1095 struct in_ifaddr *ifa=in_dev->ifa_list; 1096 if (ifa != NULL) { 1097 memcpy(dev->dev_addr+2, &ifa->ifa_local, 4); 1098 } 1099 } 1100 1101 netif_start_queue (dev); 1102 1103 return 0; 1104} 1105 1106/* The inverse routine to plip_open (). */ 1107static int 1108plip_close(struct net_device *dev) 1109{ 1110 struct net_local *nl = netdev_priv(dev); 1111 struct plip_local *snd = &nl->snd_data; 1112 struct plip_local *rcv = &nl->rcv_data; 1113 1114 netif_stop_queue (dev); 1115 DISABLE(dev->irq); 1116 synchronize_irq(dev->irq); 1117 1118 if (dev->irq == -1) 1119 { 1120 init_completion(&nl->killed_timer_cmp); 1121 atomic_set (&nl->kill_timer, 1); 1122 wait_for_completion(&nl->killed_timer_cmp); 1123 } 1124 1125#ifdef NOTDEF 1126 outb(0x00, PAR_DATA(dev)); 1127#endif 1128 nl->is_deferred = 0; 1129 nl->connection = PLIP_CN_NONE; 1130 if (nl->port_owner) { 1131 parport_release(nl->pardev); 1132 nl->port_owner = 0; 1133 } 1134 1135 snd->state = PLIP_PK_DONE; 1136 if (snd->skb) { 1137 dev_kfree_skb(snd->skb); 1138 snd->skb = NULL; 1139 } 1140 rcv->state = PLIP_PK_DONE; 1141 if (rcv->skb) { 1142 kfree_skb(rcv->skb); 1143 rcv->skb = NULL; 1144 } 1145 1146#ifdef NOTDEF 1147 /* Reset. */ 1148 outb(0x00, PAR_CONTROL(dev)); 1149#endif 1150 return 0; 1151} 1152 1153static int 1154plip_preempt(void *handle) 1155{ 1156 struct net_device *dev = (struct net_device *)handle; 1157 struct net_local *nl = netdev_priv(dev); 1158 1159 /* Stand our ground if a datagram is on the wire */ 1160 if (nl->connection != PLIP_CN_NONE) { 1161 nl->should_relinquish = 1; 1162 return 1; 1163 } 1164 1165 nl->port_owner = 0; /* Remember that we released the bus */ 1166 return 0; 1167} 1168 1169static void 1170plip_wakeup(void *handle) 1171{ 1172 struct net_device *dev = (struct net_device *)handle; 1173 struct net_local *nl = netdev_priv(dev); 1174 1175 if (nl->port_owner) { 1176 /* Why are we being woken up? */ 1177 printk(KERN_DEBUG "%s: why am I being woken up?\n", dev->name); 1178 if (!parport_claim(nl->pardev)) 1179 /* bus_owner is already set (but why?) */ 1180 printk(KERN_DEBUG "%s: I'm broken.\n", dev->name); 1181 else 1182 return; 1183 } 1184 1185 if (!(dev->flags & IFF_UP)) 1186 /* Don't need the port when the interface is down */ 1187 return; 1188 1189 if (!parport_claim(nl->pardev)) { 1190 nl->port_owner = 1; 1191 /* Clear the data port. */ 1192 write_data (dev, 0x00); 1193 } 1194} 1195 1196static int 1197plip_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 1198{ 1199 struct net_local *nl = netdev_priv(dev); 1200 struct plipconf *pc = (struct plipconf *) &rq->ifr_ifru; 1201 1202 if (cmd != SIOCDEVPLIP) 1203 return -EOPNOTSUPP; 1204 1205 switch(pc->pcmd) { 1206 case PLIP_GET_TIMEOUT: 1207 pc->trigger = nl->trigger; 1208 pc->nibble = nl->nibble; 1209 break; 1210 case PLIP_SET_TIMEOUT: 1211 if(!capable(CAP_NET_ADMIN)) 1212 return -EPERM; 1213 nl->trigger = pc->trigger; 1214 nl->nibble = pc->nibble; 1215 break; 1216 default: 1217 return -EOPNOTSUPP; 1218 } 1219 return 0; 1220} 1221 1222static int parport[PLIP_MAX] = { [0 ... PLIP_MAX-1] = -1 }; 1223static int timid; 1224 1225module_param_array(parport, int, NULL, 0); 1226module_param(timid, int, 0); 1227MODULE_PARM_DESC(parport, "List of parport device numbers to use by plip"); 1228 1229static struct net_device *dev_plip[PLIP_MAX] = { NULL, }; 1230 1231static inline int 1232plip_searchfor(int list[], int a) 1233{ 1234 int i; 1235 for (i = 0; i < PLIP_MAX && list[i] != -1; i++) { 1236 if (list[i] == a) return 1; 1237 } 1238 return 0; 1239} 1240 1241/* plip_attach() is called (by the parport code) when a port is 1242 * available to use. */ 1243static void plip_attach (struct parport *port) 1244{ 1245 static int unit; 1246 struct net_device *dev; 1247 struct net_local *nl; 1248 char name[IFNAMSIZ]; 1249 1250 if ((parport[0] == -1 && (!timid || !port->devices)) || 1251 plip_searchfor(parport, port->number)) { 1252 if (unit == PLIP_MAX) { 1253 printk(KERN_ERR "plip: too many devices\n"); 1254 return; 1255 } 1256 1257 sprintf(name, "plip%d", unit); 1258 dev = alloc_etherdev(sizeof(struct net_local)); 1259 if (!dev) { 1260 printk(KERN_ERR "plip: memory squeeze\n"); 1261 return; 1262 } 1263 1264 strcpy(dev->name, name); 1265 1266 dev->irq = port->irq; 1267 dev->base_addr = port->base; 1268 if (port->irq == -1) { 1269 printk(KERN_INFO "plip: %s has no IRQ. Using IRQ-less mode," 1270 "which is fairly inefficient!\n", port->name); 1271 } 1272 1273 nl = netdev_priv(dev); 1274 nl->dev = dev; 1275 nl->pardev = parport_register_device(port, dev->name, plip_preempt, 1276 plip_wakeup, plip_interrupt, 1277 0, dev); 1278 1279 if (!nl->pardev) { 1280 printk(KERN_ERR "%s: parport_register failed\n", name); 1281 goto err_free_dev; 1282 return; 1283 } 1284 1285 plip_init_netdev(dev); 1286 1287 if (register_netdev(dev)) { 1288 printk(KERN_ERR "%s: network register failed\n", name); 1289 goto err_parport_unregister; 1290 } 1291 1292 printk(KERN_INFO "%s", version); 1293 if (dev->irq != -1) 1294 printk(KERN_INFO "%s: Parallel port at %#3lx, " 1295 "using IRQ %d.\n", 1296 dev->name, dev->base_addr, dev->irq); 1297 else 1298 printk(KERN_INFO "%s: Parallel port at %#3lx, " 1299 "not using IRQ.\n", 1300 dev->name, dev->base_addr); 1301 dev_plip[unit++] = dev; 1302 } 1303 return; 1304 1305err_parport_unregister: 1306 parport_unregister_device(nl->pardev); 1307err_free_dev: 1308 free_netdev(dev); 1309} 1310 1311/* plip_detach() is called (by the parport code) when a port is 1312 * no longer available to use. */ 1313static void plip_detach (struct parport *port) 1314{ 1315 /* Nothing to do */ 1316} 1317 1318static struct parport_driver plip_driver = { 1319 .name = "plip", 1320 .attach = plip_attach, 1321 .detach = plip_detach 1322}; 1323 1324static void __exit plip_cleanup_module (void) 1325{ 1326 struct net_device *dev; 1327 int i; 1328 1329 parport_unregister_driver (&plip_driver); 1330 1331 for (i=0; i < PLIP_MAX; i++) { 1332 if ((dev = dev_plip[i])) { 1333 struct net_local *nl = netdev_priv(dev); 1334 unregister_netdev(dev); 1335 if (nl->port_owner) 1336 parport_release(nl->pardev); 1337 parport_unregister_device(nl->pardev); 1338 free_netdev(dev); 1339 dev_plip[i] = NULL; 1340 } 1341 } 1342} 1343 1344#ifndef MODULE 1345 1346static int parport_ptr; 1347 1348static int __init plip_setup(char *str) 1349{ 1350 int ints[4]; 1351 1352 str = get_options(str, ARRAY_SIZE(ints), ints); 1353 1354 /* Ugh. */ 1355 if (!strncmp(str, "parport", 7)) { 1356 int n = simple_strtoul(str+7, NULL, 10); 1357 if (parport_ptr < PLIP_MAX) 1358 parport[parport_ptr++] = n; 1359 else 1360 printk(KERN_INFO "plip: too many ports, %s ignored.\n", 1361 str); 1362 } else if (!strcmp(str, "timid")) { 1363 timid = 1; 1364 } else { 1365 if (ints[0] == 0 || ints[1] == 0) { 1366 /* disable driver on "plip=" or "plip=0" */ 1367 parport[0] = -2; 1368 } else { 1369 printk(KERN_WARNING "warning: 'plip=0x%x' ignored\n", 1370 ints[1]); 1371 } 1372 } 1373 return 1; 1374} 1375 1376__setup("plip=", plip_setup); 1377 1378#endif /* !MODULE */ 1379 1380static int __init plip_init (void) 1381{ 1382 if (parport[0] == -2) 1383 return 0; 1384 1385 if (parport[0] != -1 && timid) { 1386 printk(KERN_WARNING "plip: warning, ignoring `timid' since specific ports given.\n"); 1387 timid = 0; 1388 } 1389 1390 if (parport_register_driver (&plip_driver)) { 1391 printk (KERN_WARNING "plip: couldn't register driver\n"); 1392 return 1; 1393 } 1394 1395 return 0; 1396} 1397 1398module_init(plip_init); 1399module_exit(plip_cleanup_module); 1400MODULE_LICENSE("GPL"); 1401