drivers/net/plip.c

Name: Public Git Hosting - davej-history.git/blob - drivers/net/plip.c
Rating: 4.4 (1567 reviews)
 1 /* $Id: plip.c,v 1.12 1995/02/11 10:26:05 gniibe 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@super.org>
 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  *
 12  * Modularization and ifreq/ifmap support by Alan Cox.
 13  * Rewritten by Niibe Yutaka.
 14  *
 15  * This program is free software; you can redistribute it and/or
 16  * modify it under the terms of the GNU General Public License
 17  * as published by the Free Software Foundation; either version
 18  * 2 of the License, or (at your option) any later version.
 19  */
 20
 21 /*
 22  * Original version and the name 'PLIP' from Donald Becker <becker@super.org>
 23  * inspired by Russ Nelson's parallel port packet driver.
 24  *
 25  * NOTE:
 26  * Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0.
 27  * Because of the necessity to communicate to DOS machines with the
 28  * Crynwr packet driver, Peter Bauer changed the protocol again
 29  * back to original protocol.
 30  *
 31  * This version follows original PLIP protocol.
 32  * So, this PLIP can't communicate the PLIP of Linux v1.0.
 33  */
 34
 35 static const char*version ="NET3 PLIP version 2.0 gniibe@mri.co.jp\n";
 36
 37 /*
 38  Sources:
 39  Ideas and protocols came from Russ Nelson's <nelson@crynwr.com>
 40  "parallel.asm" parallel port packet driver.
 41
 42  The "Crynwr" parallel port standard specifies the following protocol:
 43  Trigger by sending '0x08' (this cause interrupt on other end)
 44  count-low octet
 45  count-high octet
 46  ... data octets
 47  checksum octet
 48  Each octet is sent as <wait for rx. '0x1?'> <send 0x10+(octet&0x0F)>
 49  <wait for rx. '0x0?'> <send 0x00+((octet>>4)&0x0F)>
 50
 51  The packet is encapsulated as if it were ethernet.
 52
 53  The cable used is a de facto standard parallel null cable -- sold as
 54  a "LapLink" cable by various places. You'll need a 12-conductor cable to
 55  make one yourself. The wiring is:
 56  SLCTIN 17 - 17
 57  GROUND 25 - 25
 58  D0->ERROR 2 - 15 15 - 2
 59  D1->SLCT 3 - 13 13 - 3
 60  D2->PAPOUT 4 - 12 12 - 4
 61  D3->ACK 5 - 10 10 - 5
 62  D4->BUSY 6 - 11 11 - 6
 63  Do not connect the other pins. They are
 64  D5,D6,D7 are 7,8,9
 65  STROBE is 1, FEED is 14, INIT is 16
 66  extra grounds are 18,19,20,21,22,23,24
 67 */
 68
 69 #ifdef MODULE
 70 #include <linux/module.h>
 71 #include <linux/version.h>
 72 #else
 73 #define MOD_INC_USE_COUNT
 74 #define MOD_DEC_USE_COUNT
 75 #endif
 76
 77 #include <linux/kernel.h>
 78 #include <linux/sched.h>
 79 #include <linux/types.h>
 80 #include <linux/fcntl.h>
 81 #include <linux/interrupt.h>
 82 #include <linux/string.h>
 83 #include <linux/ptrace.h>
 84 #include <linux/if_ether.h>
 85 #include <asm/system.h>
 86 #include <asm/io.h>
 87 #include <linux/in.h>
 88 #include <linux/errno.h>
 89 #include <linux/delay.h>
 90 #include <linux/lp.h>
 91
 92 #include <linux/netdevice.h>
 93 #include <linux/etherdevice.h>
 94 #include <linux/skbuff.h>
 95 #include <linux/if_plip.h>
 96
 97 #include <linux/tqueue.h>
 98 #include <linux/ioport.h>
 99 #include <asm/bitops.h>
 100 #include <asm/irq.h>
 101 #include <asm/byteorder.h>
 102
 103 /* Use 0 for production, 1 for verification, >2 for debug */
 104 #ifndef NET_DEBUG
 105 #define NET_DEBUG 1
 106 #endif
 107 static unsigned int net_debug = NET_DEBUG;
 108
 109 /* In micro second */
 110 #define PLIP_DELAY_UNIT 1
 111
 112 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */
 113 #define PLIP_TRIGGER_WAIT 500
 114
 115 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */
 116 #define PLIP_NIBBLE_WAIT 3000
 117
 118 #define PAR_INTR_ON (LP_PINITP|LP_PSELECP|LP_PINTEN)
 119 #define PAR_INTR_OFF (LP_PINITP|LP_PSELECP)
 120 #define PAR_DATA(dev) ((dev)->base_addr+0)
 121 #define PAR_STATUS(dev) ((dev)->base_addr+1)
 122 #define PAR_CONTROL(dev) ((dev)->base_addr+2)
 123
 124 /* Bottom halfs */
 125 static voidplip_kick_bh(struct device *dev);
 126 static voidplip_bh(struct device *dev);
 127
 128 /* Interrupt handler */
 129 static voidplip_interrupt(int irq,struct pt_regs *regs);
 130
 131 /* Functions for DEV methods */
 132 static intplip_rebuild_header(void*buff,struct device *dev,
 133 unsigned long raddr,struct sk_buff *skb);
 134 static intplip_tx_packet(struct sk_buff *skb,struct device *dev);
 135 static intplip_open(struct device *dev);
 136 static intplip_close(struct device *dev);
 137 static struct enet_statistics *plip_get_stats(struct device *dev);
 138 static intplip_config(struct device *dev,struct ifmap *map);
 139 static intplip_ioctl(struct device *dev,struct ifreq *ifr,int cmd);
 140 \f
 141 enum plip_connection_state {
 142  PLIP_CN_NONE=0,
 143  PLIP_CN_RECEIVE,
 144  PLIP_CN_SEND,
 145  PLIP_CN_CLOSING,
 146  PLIP_CN_ERROR
 147 };
 148
 149 enum plip_packet_state {
 150  PLIP_PK_DONE=0,
 151  PLIP_PK_TRIGGER,
 152  PLIP_PK_LENGTH_LSB,
 153  PLIP_PK_LENGTH_MSB,
 154  PLIP_PK_DATA,
 155  PLIP_PK_CHECKSUM
 156 };
 157
 158 enum plip_nibble_state {
 159  PLIP_NB_BEGIN,
 160  PLIP_NB_1,
 161  PLIP_NB_2,
 162 };
 163
 164 struct plip_local {
 165 enum plip_packet_state state;
 166 enum plip_nibble_state nibble;
 167 union{
 168 struct{
 169 #if defined(LITTLE_ENDIAN)
 170 unsigned char lsb;
 171 unsigned char msb;
 172 #elif defined(BIG_ENDIAN)
 173 unsigned char msb;
 174 unsigned char lsb;
 175 #else
 176 #error"Please fix the endianness defines in <asm/byteorder.h>"
 177 #endif
 178 } b;
 179 unsigned short h;
 180 } length;
 181 unsigned short byte;
 182 unsigned char checksum;
 183 unsigned char data;
 184 struct sk_buff *skb;
 185 };
 186
 187 struct net_local {
 188 struct enet_statistics enet_stats;
 189 struct tq_struct immediate;
 190 struct tq_struct deferred;
 191 struct plip_local snd_data;
 192 struct plip_local rcv_data;
 193 unsigned long trigger;
 194 unsigned long nibble;
 195 enum plip_connection_state connection;
 196 unsigned short timeout_count;
 197 char is_deferred;
 198 int(*orig_rebuild_header)(void*eth,struct device *dev,
 199 unsigned long raddr,struct sk_buff *skb);
 200 };
 201 \f
 202 /* Entry point of PLIP driver.
 203  Probe the hardware, and register/initialize the driver. */
 204 int
 205 plip_init(struct device *dev)
 206 {
 207 struct net_local *nl;
 208
 209 /* Check region before the probe */
 210 if(check_region(PAR_DATA(dev),3) <0)
 211 return-ENODEV;
 212
 213 /* Check that there is something at base_addr. */
 214 outb(0,PAR_DATA(dev));
 215 udelay(1000);
 216 if(inb(PAR_DATA(dev)) !=0)
 217 return-ENODEV;
 218
 219 printk(version);
 220 printk("%s: Parallel port at %#3lx, ", dev->name, dev->base_addr);
 221 if(dev->irq) {
 222 printk("using assigned IRQ %d.\n", dev->irq);
 223 }else{
 224 int irq =0;
 225 #ifdef MODULE
 226 /* dev->irq==0 means autoprobe, but we don't try to do so
 227  with module. We can change it by ifconfig */
 228 #else
 229 unsigned int irqs =probe_irq_on();
 230
 231 outb(0x00,PAR_CONTROL(dev));
 232 udelay(1000);
 233 outb(PAR_INTR_OFF,PAR_CONTROL(dev));
 234 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 235 outb(PAR_INTR_OFF,PAR_CONTROL(dev));
 236 udelay(1000);
 237  irq =probe_irq_off(irqs);
 238 #endif
 239 if(irq >0) {
 240  dev->irq = irq;
 241 printk("using probed IRQ %d.\n", dev->irq);
 242 }else
 243 printk("failed to detect IRQ(%d) --"
 244 " Please set IRQ by ifconfig.\n", irq);
 245 }
 246
 247 request_region(PAR_DATA(dev),3, dev->name);
 248
 249 /* Fill in the generic fields of the device structure. */
 250 ether_setup(dev);
 251
 252 /* Then, override parts of it */
 253  dev->hard_start_xmit = plip_tx_packet;
 254  dev->open = plip_open;
 255  dev->stop = plip_close;
 256  dev->get_stats = plip_get_stats;
 257  dev->set_config = plip_config;
 258  dev->do_ioctl = plip_ioctl;
 259  dev->flags = IFF_POINTOPOINT|IFF_NOARP;
 260
 261 /* Set the private structure */
 262  dev->priv =kmalloc(sizeof(struct net_local), GFP_KERNEL);
 263 if(dev->priv == NULL)
 264 return EAGAIN;
 265 memset(dev->priv,0,sizeof(struct net_local));
 266  nl = (struct net_local *) dev->priv;
 267
 268  nl->orig_rebuild_header = dev->rebuild_header;
 269  dev->rebuild_header = plip_rebuild_header;
 270
 271 /* Initialize constants */
 272  nl->trigger = PLIP_TRIGGER_WAIT;
 273  nl->nibble = PLIP_NIBBLE_WAIT;
 274
 275 /* Initialize task queue structures */
 276  nl->immediate.next = &tq_last;
 277  nl->immediate.sync =0;
 278  nl->immediate.routine = (void*)(void*)plip_bh;
 279  nl->immediate.data = dev;
 280
 281  nl->deferred.next = &tq_last;
 282  nl->deferred.sync =0;
 283  nl->deferred.routine = (void*)(void*)plip_kick_bh;
 284  nl->deferred.data = dev;
 285
 286 return0;
 287 }
 288 \f
 289 /* Bottom half handler for the delayed request.
 290  This routine is kicked by do_timer().
 291  Request `plip_bh' to be invoked. */
 292 static void
 293 plip_kick_bh(struct device *dev)
 294 {
 295 struct net_local *nl = (struct net_local *)dev->priv;
 296
 297 if(nl->is_deferred) {
 298 queue_task(&nl->immediate, &tq_immediate);
 299 mark_bh(IMMEDIATE_BH);
 300 }
 301 }
 302
 303 /* Forward declarations of internal routines */
 304 static intplip_none(struct device *,struct net_local *,
 305 struct plip_local *,struct plip_local *);
 306 static intplip_receive_packet(struct device *,struct net_local *,
 307 struct plip_local *,struct plip_local *);
 308 static intplip_send_packet(struct device *,struct net_local *,
 309 struct plip_local *,struct plip_local *);
 310 static intplip_connection_close(struct device *,struct net_local *,
 311 struct plip_local *,struct plip_local *);
 312 static intplip_error(struct device *,struct net_local *,
 313 struct plip_local *,struct plip_local *);
 314 static intplip_bh_timeout_error(struct device *dev,struct net_local *nl,
 315 struct plip_local *snd,
 316 struct plip_local *rcv,
 317 int error);
 318
 319 #define OK 0
 320 #define TIMEOUT 1
 321 #define ERROR 2
 322
 323 typedefint(*plip_func)(struct device *dev,struct net_local *nl,
 324 struct plip_local *snd,struct plip_local *rcv);
 325
 326 static plip_func connection_state_table[] =
 327 {
 328  plip_none,
 329  plip_receive_packet,
 330  plip_send_packet,
 331  plip_connection_close,
 332  plip_error
 333 };
 334
 335 /* Bottom half handler of PLIP. */
 336 static void
 337 plip_bh(struct device *dev)
 338 {
 339 struct net_local *nl = (struct net_local *)dev->priv;
 340 struct plip_local *snd = &nl->snd_data;
 341 struct plip_local *rcv = &nl->rcv_data;
 342  plip_func f;
 343 int r;
 344
 345  nl->is_deferred =0;
 346  f = connection_state_table[nl->connection];
 347 if((r = (*f)(dev, nl, snd, rcv)) != OK
 348 && (r =plip_bh_timeout_error(dev, nl, snd, rcv, r)) != OK) {
 349  nl->is_deferred =1;
 350 queue_task(&nl->deferred, &tq_timer);
 351 }
 352 }
 353
 354 static int
 355 plip_bh_timeout_error(struct device *dev,struct net_local *nl,
 356 struct plip_local *snd,struct plip_local *rcv,
 357 int error)
 358 {
 359 unsigned char c0;
 360
 361 cli();
 362 if(nl->connection == PLIP_CN_SEND) {
 363
 364 if(error != ERROR) {/* Timeout */
 365  nl->timeout_count++;
 366 if((snd->state == PLIP_PK_TRIGGER
 367 && nl->timeout_count <=10)
 368 || nl->timeout_count <=3) {
 369 sti();
 370 /* Try again later */
 371 return TIMEOUT;
 372 }
 373  c0 =inb(PAR_STATUS(dev));
 374 printk("%s: transmit timeout(%d,%02x)\n",
 375  dev->name, snd->state, c0);
 376 }
 377  nl->enet_stats.tx_errors++;
 378  nl->enet_stats.tx_aborted_errors++;
 379 }else if(nl->connection == PLIP_CN_RECEIVE) {
 380 if(rcv->state == PLIP_PK_TRIGGER) {
 381 /* Transmission was interrupted. */
 382 sti();
 383 return OK;
 384 }
 385 if(error != ERROR) {/* Timeout */
 386 if(++nl->timeout_count <=3) {
 387 sti();
 388 /* Try again later */
 389 return TIMEOUT;
 390 }
 391  c0 =inb(PAR_STATUS(dev));
 392 printk("%s: receive timeout(%d,%02x)\n",
 393  dev->name, rcv->state, c0);
 394 }
 395  nl->enet_stats.rx_dropped++;
 396 }
 397  rcv->state = PLIP_PK_DONE;
 398 if(rcv->skb) {
 399  rcv->skb->free =1;
 400 kfree_skb(rcv->skb, FREE_READ);
 401  rcv->skb = NULL;
 402 }
 403  snd->state = PLIP_PK_DONE;
 404 if(snd->skb) {
 405 dev_kfree_skb(snd->skb, FREE_WRITE);
 406  snd->skb = NULL;
 407 }
 408 disable_irq(dev->irq);
 409 outb(PAR_INTR_OFF,PAR_CONTROL(dev));
 410  dev->tbusy =1;
 411  nl->connection = PLIP_CN_ERROR;
 412 outb(0x00,PAR_DATA(dev));
 413 sti();
 414
 415 return TIMEOUT;
 416 }
 417 \f
 418 static int
 419 plip_none(struct device *dev,struct net_local *nl,
 420 struct plip_local *snd,struct plip_local *rcv)
 421 {
 422 return OK;
 423 }
 424
 425 /* PLIP_RECEIVE --- receive a byte(two nibbles)
 426  Returns OK on success, TIMEOUT on timeout */
 427 inlinestatic int
 428 plip_receive(unsigned short nibble_timeout,unsigned short status_addr,
 429 enum plip_nibble_state *ns_p,unsigned char*data_p)
 430 {
 431 unsigned char c0, c1;
 432 unsigned int cx;
 433
 434 switch(*ns_p) {
 435 case PLIP_NB_BEGIN:
 436  cx = nibble_timeout;
 437 while(1) {
 438  c0 =inb(status_addr);
 439 udelay(PLIP_DELAY_UNIT);
 440 if((c0 &0x80) ==0) {
 441  c1 =inb(status_addr);
 442 if(c0 == c1)
 443 break;
 444 }
 445 if(--cx ==0)
 446 return TIMEOUT;
 447 }
 448 *data_p = (c0 >>3) &0x0f;
 449 outb(0x10, --status_addr);/* send ACK */
 450  status_addr++;
 451 *ns_p = PLIP_NB_1;
 452
 453 case PLIP_NB_1:
 454  cx = nibble_timeout;
 455 while(1) {
 456  c0 =inb(status_addr);
 457 udelay(PLIP_DELAY_UNIT);
 458 if(c0 &0x80) {
 459  c1 =inb(status_addr);
 460 if(c0 == c1)
 461 break;
 462 }
 463 if(--cx ==0)
 464 return TIMEOUT;
 465 }
 466 *data_p |= (c0 <<1) &0xf0;
 467 outb(0x00, --status_addr);/* send ACK */
 468  status_addr++;
 469 *ns_p = PLIP_NB_BEGIN;
 470 return OK;
 471
 472 case PLIP_NB_2:
 473 break;
 474 }
 475 return TIMEOUT;/* XX: ?? */
 476 }
 477
 478 /* PLIP_RECEIVE_PACKET --- receive a packet */
 479 static int
 480 plip_receive_packet(struct device *dev,struct net_local *nl,
 481 struct plip_local *snd,struct plip_local *rcv)
 482 {
 483 unsigned short status_addr =PAR_STATUS(dev);
 484 unsigned short nibble_timeout = nl->nibble;
 485 unsigned char*lbuf;
 486
 487 switch(rcv->state) {
 488 case PLIP_PK_TRIGGER:
 489 disable_irq(dev->irq);
 490 outb(PAR_INTR_OFF,PAR_CONTROL(dev));
 491  dev->interrupt =0;
 492 outb(0x01,PAR_DATA(dev));/* send ACK */
 493 if(net_debug >2)
 494 printk("%s: receive start\n", dev->name);
 495  rcv->state = PLIP_PK_LENGTH_LSB;
 496  rcv->nibble = PLIP_NB_BEGIN;
 497
 498 case PLIP_PK_LENGTH_LSB:
 499 if(snd->state != PLIP_PK_DONE) {
 500 if(plip_receive(nl->trigger, status_addr,
 501 &rcv->nibble, &rcv->length.b.lsb)) {
 502 /* collision, here dev->tbusy == 1 */
 503  rcv->state = PLIP_PK_DONE;
 504  nl->is_deferred =1;
 505  nl->connection = PLIP_CN_SEND;
 506 queue_task(&nl->deferred, &tq_timer);
 507 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 508 enable_irq(dev->irq);
 509 return OK;
 510 }
 511 }else{
 512 if(plip_receive(nibble_timeout, status_addr,
 513 &rcv->nibble, &rcv->length.b.lsb))
 514 return TIMEOUT;
 515 }
 516  rcv->state = PLIP_PK_LENGTH_MSB;
 517
 518 case PLIP_PK_LENGTH_MSB:
 519 if(plip_receive(nibble_timeout, status_addr,
 520 &rcv->nibble, &rcv->length.b.msb))
 521 return TIMEOUT;
 522 if(rcv->length.h > dev->mtu || rcv->length.h <8) {
 523 printk("%s: bogus packet size %d.\n", dev->name, rcv->length.h);
 524 return ERROR;
 525 }
 526 /* Malloc up new buffer. */
 527  rcv->skb =dev_alloc_skb(rcv->length.h);
 528 if(rcv->skb == NULL) {
 529 printk("%s: Memory squeeze.\n", dev->name);
 530 return ERROR;
 531 }
 532 skb_put(rcv->skb,rcv->length.h);
 533  rcv->skb->dev = dev;
 534  rcv->state = PLIP_PK_DATA;
 535  rcv->byte =0;
 536  rcv->checksum =0;
 537
 538 case PLIP_PK_DATA:
 539  lbuf = rcv->skb->data;
 540 do
 541 if(plip_receive(nibble_timeout, status_addr,
 542 &rcv->nibble, &lbuf[rcv->byte]))
 543 return TIMEOUT;
 544 while(++rcv->byte < rcv->length.h);
 545 do
 546  rcv->checksum += lbuf[--rcv->byte];
 547 while(rcv->byte);
 548  rcv->state = PLIP_PK_CHECKSUM;
 549
 550 case PLIP_PK_CHECKSUM:
 551 if(plip_receive(nibble_timeout, status_addr,
 552 &rcv->nibble, &rcv->data))
 553 return TIMEOUT;
 554 if(rcv->data != rcv->checksum) {
 555  nl->enet_stats.rx_crc_errors++;
 556 if(net_debug)
 557 printk("%s: checksum error\n", dev->name);
 558 return ERROR;
 559 }
 560  rcv->state = PLIP_PK_DONE;
 561
 562 case PLIP_PK_DONE:
 563 /* Inform the upper layer for the arrival of a packet. */
 564  rcv->skb->protocol=eth_type_trans(rcv->skb, dev);
 565 netif_rx(rcv->skb);
 566  nl->enet_stats.rx_packets++;
 567  rcv->skb = NULL;
 568 if(net_debug >2)
 569 printk("%s: receive end\n", dev->name);
 570
 571 /* Close the connection. */
 572 outb(0x00,PAR_DATA(dev));
 573 cli();
 574 if(snd->state != PLIP_PK_DONE) {
 575  nl->connection = PLIP_CN_SEND;
 576 sti();
 577 queue_task(&nl->immediate, &tq_immediate);
 578 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 579 enable_irq(dev->irq);
 580 return OK;
 581 }else{
 582  nl->connection = PLIP_CN_NONE;
 583 sti();
 584 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 585 enable_irq(dev->irq);
 586 return OK;
 587 }
 588 }
 589 return OK;
 590 }
 591
 592 /* PLIP_SEND --- send a byte (two nibbles)
 593  Returns OK on success, TIMEOUT when timeout */
 594 inlinestatic int
 595 plip_send(unsigned short nibble_timeout,unsigned short data_addr,
 596 enum plip_nibble_state *ns_p,unsigned char data)
 597 {
 598 unsigned char c0;
 599 unsigned int cx;
 600
 601 switch(*ns_p) {
 602 case PLIP_NB_BEGIN:
 603 outb((data &0x0f), data_addr);
 604 *ns_p = PLIP_NB_1;
 605
 606 case PLIP_NB_1:
 607 outb(0x10| (data &0x0f), data_addr);
 608  cx = nibble_timeout;
 609  data_addr++;
 610 while(1) {
 611  c0 =inb(data_addr);
 612 if((c0 &0x80) ==0)
 613 break;
 614 if(--cx ==0)
 615 return TIMEOUT;
 616 udelay(PLIP_DELAY_UNIT);
 617 }
 618 outb(0x10| (data >>4), --data_addr);
 619 *ns_p = PLIP_NB_2;
 620
 621 case PLIP_NB_2:
 622 outb((data >>4), data_addr);
 623  data_addr++;
 624  cx = nibble_timeout;
 625 while(1) {
 626  c0 =inb(data_addr);
 627 if(c0 &0x80)
 628 break;
 629 if(--cx ==0)
 630 return TIMEOUT;
 631 udelay(PLIP_DELAY_UNIT);
 632 }
 633  data_addr--;
 634 *ns_p = PLIP_NB_BEGIN;
 635 return OK;
 636 }
 637 return TIMEOUT;
 638 }
 639
 640 /* PLIP_SEND_PACKET --- send a packet */
 641 static int
 642 plip_send_packet(struct device *dev,struct net_local *nl,
 643 struct plip_local *snd,struct plip_local *rcv)
 644 {
 645 unsigned short data_addr =PAR_DATA(dev);
 646 unsigned short nibble_timeout = nl->nibble;
 647 unsigned char*lbuf;
 648 unsigned char c0;
 649 unsigned int cx;
 650
 651 if(snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
 652 printk("%s: send skb lost\n", dev->name);
 653  snd->state = PLIP_PK_DONE;
 654  snd->skb = NULL;
 655 return ERROR;
 656 }
 657
 658 switch(snd->state) {
 659 case PLIP_PK_TRIGGER:
 660 /* Trigger remote rx interrupt. */
 661 outb(0x08, data_addr);
 662  cx = nl->trigger;
 663 while(1) {
 664 udelay(PLIP_DELAY_UNIT);
 665 cli();
 666 if(nl->connection == PLIP_CN_RECEIVE) {
 667 sti();
 668 /* interrupted */
 669  nl->enet_stats.collisions++;
 670 if(net_debug >1)
 671 printk("%s: collision.\n", dev->name);
 672 return OK;
 673 }
 674  c0 =inb(PAR_STATUS(dev));
 675 if(c0 &0x08) {
 676 disable_irq(dev->irq);
 677 outb(PAR_INTR_OFF,PAR_CONTROL(dev));
 678 if(net_debug >2)
 679 printk("%s: send start\n", dev->name);
 680  snd->state = PLIP_PK_LENGTH_LSB;
 681  snd->nibble = PLIP_NB_BEGIN;
 682  nl->timeout_count =0;
 683 sti();
 684 break;
 685 }
 686 sti();
 687 if(--cx ==0) {
 688 outb(0x00, data_addr);
 689 return TIMEOUT;
 690 }
 691 }
 692
 693 case PLIP_PK_LENGTH_LSB:
 694 if(plip_send(nibble_timeout, data_addr,
 695 &snd->nibble, snd->length.b.lsb))
 696 return TIMEOUT;
 697  snd->state = PLIP_PK_LENGTH_MSB;
 698
 699 case PLIP_PK_LENGTH_MSB:
 700 if(plip_send(nibble_timeout, data_addr,
 701 &snd->nibble, snd->length.b.msb))
 702 return TIMEOUT;
 703  snd->state = PLIP_PK_DATA;
 704  snd->byte =0;
 705  snd->checksum =0;
 706
 707 case PLIP_PK_DATA:
 708 do
 709 if(plip_send(nibble_timeout, data_addr,
 710 &snd->nibble, lbuf[snd->byte]))
 711 return TIMEOUT;
 712 while(++snd->byte < snd->length.h);
 713 do
 714  snd->checksum += lbuf[--snd->byte];
 715 while(snd->byte);
 716  snd->state = PLIP_PK_CHECKSUM;
 717
 718 case PLIP_PK_CHECKSUM:
 719 if(plip_send(nibble_timeout, data_addr,
 720 &snd->nibble, snd->checksum))
 721 return TIMEOUT;
 722
 723 dev_kfree_skb(snd->skb, FREE_WRITE);
 724  nl->enet_stats.tx_packets++;
 725  snd->state = PLIP_PK_DONE;
 726
 727 case PLIP_PK_DONE:
 728 /* Close the connection */
 729 outb(0x00, data_addr);
 730  snd->skb = NULL;
 731 if(net_debug >2)
 732 printk("%s: send end\n", dev->name);
 733  nl->connection = PLIP_CN_CLOSING;
 734  nl->is_deferred =1;
 735 queue_task(&nl->deferred, &tq_timer);
 736 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 737 enable_irq(dev->irq);
 738 return OK;
 739 }
 740 return OK;
 741 }
 742
 743 static int
 744 plip_connection_close(struct device *dev,struct net_local *nl,
 745 struct plip_local *snd,struct plip_local *rcv)
 746 {
 747 cli();
 748 if(nl->connection == PLIP_CN_CLOSING) {
 749  nl->connection = PLIP_CN_NONE;
 750  dev->tbusy =0;
 751 mark_bh(NET_BH);
 752 }
 753 sti();
 754 return OK;
 755 }
 756
 757 /* PLIP_ERROR --- wait till other end settled */
 758 static int
 759 plip_error(struct device *dev,struct net_local *nl,
 760 struct plip_local *snd,struct plip_local *rcv)
 761 {
 762 unsigned char status;
 763
 764  status =inb(PAR_STATUS(dev));
 765 if((status &0xf8) ==0x80) {
 766 if(net_debug >2)
 767 printk("%s: reset interface.\n", dev->name);
 768  nl->connection = PLIP_CN_NONE;
 769  dev->tbusy =0;
 770  dev->interrupt =0;
 771 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 772 enable_irq(dev->irq);
 773 mark_bh(NET_BH);
 774 }else{
 775  nl->is_deferred =1;
 776 queue_task(&nl->deferred, &tq_timer);
 777 }
 778
 779 return OK;
 780 }
 781 \f
 782 /* Handle the parallel port interrupts. */
 783 static void
 784 plip_interrupt(int irq,struct pt_regs * regs)
 785 {
 786 struct device *dev = (struct device *) irq2dev_map[irq];
 787 struct net_local *nl = (struct net_local *)dev->priv;
 788 struct plip_local *rcv = &nl->rcv_data;
 789 unsigned char c0;
 790
 791 if(dev == NULL) {
 792 printk("plip_interrupt: irq %d for unknown device.\n", irq);
 793 return;
 794 }
 795
 796 if(dev->interrupt)
 797 return;
 798
 799  c0 =inb(PAR_STATUS(dev));
 800 if((c0 &0xf8) !=0xc0) {
 801 if(net_debug >1)
 802 printk("%s: spurious interrupt\n", dev->name);
 803 return;
 804 }
 805  dev->interrupt =1;
 806 if(net_debug >3)
 807 printk("%s: interrupt.\n", dev->name);
 808
 809 cli();
 810 switch(nl->connection) {
 811 case PLIP_CN_CLOSING:
 812  dev->tbusy =0;
 813 case PLIP_CN_NONE:
 814 case PLIP_CN_SEND:
 815  dev->last_rx = jiffies;
 816  rcv->state = PLIP_PK_TRIGGER;
 817  nl->connection = PLIP_CN_RECEIVE;
 818  nl->timeout_count =0;
 819 queue_task(&nl->immediate, &tq_immediate);
 820 mark_bh(IMMEDIATE_BH);
 821 sti();
 822 break;
 823
 824 case PLIP_CN_RECEIVE:
 825 sti();
 826 printk("%s: receive interrupt when receiving packet\n", dev->name);
 827 break;
 828
 829 case PLIP_CN_ERROR:
 830 sti();
 831 printk("%s: receive interrupt in error state\n", dev->name);
 832 break;
 833 }
 834 }
 835 \f
 836 /* We don't need to send arp, for plip is point-to-point. */
 837 static int
 838 plip_rebuild_header(void*buff,struct device *dev,unsigned long dst,
 839 struct sk_buff *skb)
 840 {
 841 struct net_local *nl = (struct net_local *)dev->priv;
 842 struct ethhdr *eth = (struct ethhdr *)buff;
 843 int i;
 844
 845 if((dev->flags & IFF_NOARP)==0)
 846 return nl->orig_rebuild_header(buff, dev, dst, skb);
 847
 848 if(eth->h_proto !=htons(ETH_P_IP)) {
 849 printk("plip_rebuild_header: Don't know how to resolve type %d addresses?\n", (int)eth->h_proto);
 850 memcpy(eth->h_source, dev->dev_addr, dev->addr_len);
 851 return0;
 852 }
 853
 854 for(i=0; i < ETH_ALEN -sizeof(unsigned long); i++)
 855  eth->h_dest[i] =0xfc;
 856 memcpy(&(eth->h_dest[i]), &dst,sizeof(unsigned long));
 857 return0;
 858 }
 859
 860 static int
 861 plip_tx_packet(struct sk_buff *skb,struct device *dev)
 862 {
 863 struct net_local *nl = (struct net_local *)dev->priv;
 864 struct plip_local *snd = &nl->snd_data;
 865
 866 if(dev->tbusy)
 867 return1;
 868
 869 /* If some higher layer thinks we've missed an tx-done interrupt
 870  we are passed NULL. Caution: dev_tint() handles the cli()/sti()
 871  itself. */
 872 if(skb == NULL) {
 873 dev_tint(dev);
 874 return0;
 875 }
 876
 877 if(set_bit(0, (void*)&dev->tbusy) !=0) {
 878 printk("%s: Transmitter access conflict.\n", dev->name);
 879 return1;
 880 }
 881
 882 if(skb->len > dev->mtu) {
 883 printk("%s: packet too big, %d.\n", dev->name, (int)skb->len);
 884  dev->tbusy =0;
 885 return0;
 886 }
 887
 888 if(net_debug >2)
 889 printk("%s: send request\n", dev->name);
 890
 891 cli();
 892  dev->trans_start = jiffies;
 893  snd->skb = skb;
 894  snd->length.h = skb->len;
 895  snd->state = PLIP_PK_TRIGGER;
 896 if(nl->connection == PLIP_CN_NONE) {
 897  nl->connection = PLIP_CN_SEND;
 898  nl->timeout_count =0;
 899 }
 900 queue_task(&nl->immediate, &tq_immediate);
 901 mark_bh(IMMEDIATE_BH);
 902 sti();
 903
 904 return0;
 905 }
 906
 907 /* Open/initialize the board. This is called (in the current kernel)
 908  sometime after booting when the 'ifconfig' program is run.
 909
 910  This routine gets exclusive access to the parallel port by allocating
 911  its IRQ line.
 912  */
 913 static int
 914 plip_open(struct device *dev)
 915 {
 916 struct net_local *nl = (struct net_local *)dev->priv;
 917 int i;
 918
 919 if(dev->irq ==0) {
 920 printk("%s: IRQ is not set. Please set it by ifconfig.\n", dev->name);
 921 return-EAGAIN;
 922 }
 923 cli();
 924 if(request_irq(dev->irq , plip_interrupt,0, dev->name) !=0) {
 925 sti();
 926 printk("%s: couldn't get IRQ %d.\n", dev->name, dev->irq);
 927 return-EAGAIN;
 928 }
 929  irq2dev_map[dev->irq] = dev;
 930 sti();
 931
 932 /* Clear the data port. */
 933 outb(0x00,PAR_DATA(dev));
 934
 935 /* Enable rx interrupt. */
 936 outb(PAR_INTR_ON,PAR_CONTROL(dev));
 937
 938 /* Initialize the state machine. */
 939  nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE;
 940  nl->rcv_data.skb = nl->snd_data.skb = NULL;
 941  nl->connection = PLIP_CN_NONE;
 942  nl->is_deferred =0;
 943
 944 /* Fill in the MAC-level header. */
 945 for(i=0; i < ETH_ALEN -sizeof(unsigned long); i++)
 946  dev->dev_addr[i] =0xfc;
 947 memcpy(&(dev->dev_addr[i]), &dev->pa_addr,sizeof(unsigned long));
 948
 949  dev->interrupt =0;
 950  dev->start =1;
 951  dev->tbusy =0;
 952  MOD_INC_USE_COUNT;
 953 return0;
 954 }
 955
 956 /* The inverse routine to plip_open (). */
 957 static int
 958 plip_close(struct device *dev)
 959 {
 960 struct net_local *nl = (struct net_local *)dev->priv;
 961 struct plip_local *snd = &nl->snd_data;
 962 struct plip_local *rcv = &nl->rcv_data;
 963
 964  dev->tbusy =1;
 965  dev->start =0;
 966 cli();
 967 free_irq(dev->irq);
 968  irq2dev_map[dev->irq] = NULL;
 969  nl->is_deferred =0;
 970  nl->connection = PLIP_CN_NONE;
 971 sti();
 972 outb(0x00,PAR_DATA(dev));
 973
 974  snd->state = PLIP_PK_DONE;
 975 if(snd->skb) {
 976 dev_kfree_skb(snd->skb, FREE_WRITE);
 977  snd->skb = NULL;
 978 }
 979  rcv->state = PLIP_PK_DONE;
 980 if(rcv->skb) {
 981  rcv->skb->free =1;
 982 kfree_skb(rcv->skb, FREE_READ);
 983  rcv->skb = NULL;
 984 }
 985
 986 /* Reset. */
 987 outb(0x00,PAR_CONTROL(dev));
 988  MOD_DEC_USE_COUNT;
 989 return0;
 990 }
 991
 992 static struct enet_statistics *
 993 plip_get_stats(struct device *dev)
 994 {
 995 struct net_local *nl = (struct net_local *)dev->priv;
 996 struct enet_statistics *r = &nl->enet_stats;
 997
 998 return r;
 999 }
1000
1001 static int
1002 plip_config(struct device *dev,struct ifmap *map)
1003 {
1004 if(dev->flags & IFF_UP)
1005 return-EBUSY;
1006
1007 if(map->base_addr != (unsigned long)-1
1008 && map->base_addr != dev->base_addr)
1009 printk("%s: You cannot change base_addr of this interface (ignored).\n", dev->name);
1010
1011 if(map->irq != (unsigned char)-1)
1012  dev->irq = map->irq;
1013 return0;
1014 }
1015
1016 static int
1017 plip_ioctl(struct device *dev,struct ifreq *rq,int cmd)
1018 {
1019 struct net_local *nl = (struct net_local *) dev->priv;
1020 struct plipconf *pc = (struct plipconf *) &rq->ifr_data;
1021
1022 switch(pc->pcmd) {
1023 case PLIP_GET_TIMEOUT:
1024  pc->trigger = nl->trigger;
1025  pc->nibble = nl->nibble;
1026 break;
1027 case PLIP_SET_TIMEOUT:
1028  nl->trigger = pc->trigger;
1029  nl->nibble = pc->nibble;
1030 break;
1031 default:
1032 return-EOPNOTSUPP;
1033 }
1034 return0;
1035 }
1036 \f
1037 #ifdef MODULE
1038 char kernel_version[] = UTS_RELEASE;
1039
1040 static struct device dev_plip0 =
1041 {
1042 "plip0"/*"plip"*/,
1043 0,0,0,0,/* memory */
1044 0x3BC,5,/* base, irq */
1045 0,0,0, NULL, plip_init
1046 };
1047
1048 static struct device dev_plip1 =
1049 {
1050 "plip1"/*"plip"*/,
1051 0,0,0,0,/* memory */
1052 0x378,7,/* base, irq */
1053 0,0,0, NULL, plip_init
1054 };
1055
1056 static struct device dev_plip2 =
1057 {
1058 "plip2"/*"plip"*/,
1059 0,0,0,0,/* memory */
1060 0x278,2,/* base, irq */
1061 0,0,0, NULL, plip_init
1062 };
1063
1064 int
1065 init_module(void)
1066 {
1067 int devices=0;
1068
1069 if(register_netdev(&dev_plip0) !=0)
1070  devices++;
1071 if(register_netdev(&dev_plip1) !=0)
1072  devices++;
1073 if(register_netdev(&dev_plip2) !=0)
1074  devices++;
1075 if(devices ==0)
1076 return-EIO;
1077 return0;
1078 }
1079
1080 void
1081 cleanup_module(void)
1082 {
1083 if(dev_plip0.priv) {
1084 unregister_netdev(&dev_plip0);
1085 release_region(PAR_DATA(&dev_plip0),3);
1086 kfree_s(dev_plip0.priv,sizeof(struct net_local));
1087  dev_plip0.priv = NULL;
1088 }
1089 if(dev_plip1.priv) {
1090 unregister_netdev(&dev_plip1);
1091 release_region(PAR_DATA(&dev_plip1),3);
1092 kfree_s(dev_plip1.priv,sizeof(struct net_local));
1093  dev_plip1.priv = NULL;
1094 }
1095 if(dev_plip2.priv) {
1096 unregister_netdev(&dev_plip2);
1097 release_region(PAR_DATA(&dev_plip2),3);
1098 kfree_s(dev_plip2.priv,sizeof(struct net_local));
1099  dev_plip2.priv = NULL;
1100 }
1101 }
1102 #endif/* MODULE */
1103 \f
1104 /*
1105  * Local variables:
1106  * compile-command: "gcc -DMODULE -DCONFIG_MODVERSIONS -D__KERNEL__ -Wall -Wstrict-prototypes -O2 -g -fomit-frame-pointer -pipe -m486 -c plip.c"
1107  * End:
1108  */