Date: Thu, 22 May 1997 17:06:03 +0200 From: jongk@prac.cs.utwente.nl (Kars de Jong) To: linux-m68k@phil.uni-sb.de Subject: L68K: The PLIP driver... Sender: owner-linux-m68k@phil.uni-sb.de Reply-To: linux-m68k@phil.uni-sb.de Hello all, Well, I've solved the problem with PLIP and serial comms, it was indeed the sharing of the RI line of the serial port with the SEL line of the parallel port. Grr. So, I had to move another line. The wiring is described in the driver itself, please be careful or you'll fry your ports. For which I will take no responsibility, of course. :-) I've only tested this as a module, so I don't know if it will work when you compile it in the kernel. I use 2.0 kernels, so this was all done relative to 2.0.29. The kernel itself needs a patch too: I need the CIA A base and the cia_*_irq() functions. I tried using disable_irq() and enable_irq(), but that didn't work. The CIA interrupt needs to be cleared before it is enabled again, and the normal functions don't seem to do that. And since the PLIP driver turns interrupts on and off all the time, this is needed. First, the kernel patch, relative to 2.0.29: --- /rincewind/var/src/linux/arch/m68k/amiga/ksyms.c Sat Oct 19 13:33:17 1996 +++ arch/m68k/amiga/ksyms.c Fri Apr 25 19:46:48 1997 @@ -3,6 +3,7 @@ #include #include #include +#include extern volatile u_short amiga_audio_min_period; extern u_short amiga_audio_period; @@ -25,6 +26,10 @@ X(zorro_config_board), X(zorro_unconfig_board), X(zorro_unused_z2ram), + + X(ciaa_base), + X(cia_set_irq), + X(cia_able_irq), /* example X(something_you_need), And, the PLIP driver (this is not a patch, this is just the file. Put it in drivers/net, and compile it (the compile command I used is included as an Emacs compile-command at the bottom of the file). Have fun with it! This only works for a PC and an Amiga. If you want to use it between 2 Amigas, the cable needs to be adapted (of course) and you need to put the same patch in the PLIP driver as the one I sent to the mailing list recently. I won't expand this version too much, because I think it IS possible to make an 8 bit version of the protocol. I'll be working on that, and keep you informed :=). Atari folks: How's your hardware? Can PLIP work for you as well? Please let me know. Here comes the driver: /* PLIP: A parallel port "network" driver for Linux. */ /* This driver is for parallel port with 5-bit cable (LapLink (R) cable). */ /* * Authors: Donald Becker, * Tommy Thorn, * Tanabe Hiroyasu, * Alan Cox, * Peter Bauer, <100136.3530@compuserve.com> * Niibe Yutaka, * Kars de Jong, * Robert Boermans, * * Modularization and ifreq/ifmap support by Alan Cox. * Rewritten by Niibe Yutaka. * * Linux/m68k version by Kars de Jong, with help from * Robert Boermans. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. */ /* * Original version and the name 'PLIP' from Donald Becker * inspired by Russ Nelson's parallel port packet driver. * * NOTE: * Tanabe Hiroyasu had changed the protocol, and it was in Linux v1.0. * Because of the necessity to communicate to DOS machines with the * Crynwr packet driver, Peter Bauer changed the protocol again * back to original protocol. * * This version follows original PLIP protocol. * So, this PLIP can't communicate the PLIP of Linux v1.0. */ /* Sources: Ideas and protocols came from Russ Nelson's "parallel.asm" parallel port packet driver. The "Crynwr" parallel port standard specifies the following protocol: Trigger by sending '0x08' (this cause interrupt on other end) count-low octet count-high octet ... data octets checksum octet Each octet is sent as >4)&0x0F)> The packet is encapsulated as if it were ethernet. The cable used is a de facto standard parallel null cable -- sold as a "LapLink" cable by various places, which needs to be slightly modified on the Amiga side. You'll need a 11-conductor cable to make one yourself. The wiring is: GROUND 25 - 25 D0->ERROR 2 - 15 D7->D0 9 - 2 D1->SLCT 3 - 13 D5->D1 7 - 3 D2->PAPOUT 4 - 12 POUT->D2 12 - 4 D3->ACK 5 - 10 ACK->D3,D6->D3 10, 8 - 5 D4->BUSY 6 - 11 BUSY->D4 11 - 6 !!! Left hand side is the Amiga, right hand side the PC. !!! To modify a standard cable: - Cut the line connecting pin 17 to pin 17, it's not used by the protocol and there is no SLCTIN pin on the Amiga. - On the Amiga side, the wire connected to pin 15 has to be moved to pin 9, because the Amiga has no ERROR pin. - On the Amiga side, the wire connected to pin 13 has to be moved to pin 7, because the SEL line is shared with the serial port and it gives problems to use it (lockups). - On the Amiga side, you need an extra wire connecting pin 10 to pin 8, because the ACK line is used as a data signal and on the Amiga you can't read it as such. Do not connect the other pins. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CONFIG_AMIGA #include #include #define CLEARINT cia_set_irq(&ciaa_base, CIA_ICR_FLG) #define DISABLEINT cia_able_irq(&ciaa_base, CIA_ICR_FLG) #define ENABLEINT cia_able_irq(&ciaa_base, CIA_ICR_FLG | CIA_ICR_SETCLR) #endif /* CONFIG_AMIGA */ /* Use 0 for production, 1 for verification, >2 for debug */ #ifndef NET_DEBUG #define NET_DEBUG 1 #endif static unsigned int net_debug = NET_DEBUG; /* In micro second */ #define PLIP_DELAY_UNIT 1 /* Connection time out = PLIP_TRIGGER_WAIT * PLIP_DELAY_UNIT usec */ #define PLIP_TRIGGER_WAIT 500 /* Nibble time out = PLIP_NIBBLE_WAIT * PLIP_DELAY_UNIT usec */ #define PLIP_NIBBLE_WAIT 3000 /* Bottom halfs */ static void plip_kick_bh(struct device *dev); static void plip_bh(struct device *dev); /* Interrupt handler */ static void plip_interrupt(int irq, void *dev_id, struct pt_regs *regs); /* Functions for DEV methods */ static int plip_rebuild_header(void *buff, struct device *dev, unsigned long raddr, struct sk_buff *skb); static int plip_tx_packet(struct sk_buff *skb, struct device *dev); static int plip_open(struct device *dev); static int plip_close(struct device *dev); static struct enet_statistics *plip_get_stats(struct device *dev); static int plip_config(struct device *dev, struct ifmap *map); static int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd); enum plip_connection_state { PLIP_CN_NONE=0, PLIP_CN_RECEIVE, PLIP_CN_SEND, PLIP_CN_CLOSING, PLIP_CN_ERROR }; enum plip_packet_state { PLIP_PK_DONE=0, PLIP_PK_TRIGGER, PLIP_PK_LENGTH_LSB, PLIP_PK_LENGTH_MSB, PLIP_PK_DATA, PLIP_PK_CHECKSUM }; enum plip_nibble_state { PLIP_NB_BEGIN=0, PLIP_NB_1, PLIP_NB_2, }; struct plip_local { enum plip_packet_state state; enum plip_nibble_state nibble; union { struct { #if defined(__LITTLE_ENDIAN) unsigned char lsb; unsigned char msb; #elif defined(__BIG_ENDIAN) unsigned char msb; unsigned char lsb; #else #error "Please fix the endianness defines in " #endif } b; unsigned short h; } length; unsigned short byte; unsigned char checksum; unsigned char data; struct sk_buff *skb; }; struct net_local { struct enet_statistics enet_stats; struct tq_struct immediate; struct tq_struct deferred; struct plip_local snd_data; struct plip_local rcv_data; unsigned long trigger; unsigned long nibble; enum plip_connection_state connection; unsigned short timeout_count; char is_deferred; int (*orig_rebuild_header)(void *eth, struct device *dev, unsigned long raddr, struct sk_buff *skb); }; static unsigned char atransl[256], btransl[256], atransh[256], btransh[256]; static struct device *plip_dev = NULL; /* Entry point of PLIP driver. Probe the hardware, and register/initialize the driver. */ int plip_init(struct device *dev) { struct net_local *nl; int i; #ifdef CONFIG_AMIGA if (MACH_IS_AMIGA && AMIGAHW_PRESENT(AMI_PARALLEL)) { ciaa.ddrb = 0x1f; ciab.ddra &= ~0x3; dev->base_addr = (long)&ciaa.prb; } else return -ENODEV; #endif printk(KERN_INFO "NET3 m68k PLIP version 0.4 jongk@cs.utwente.nl\n"); printk(KERN_INFO "%s: Parallel port at 0x%08lx\n", dev->name, (long)dev->base_addr); /* Fill in the nibble lookup tables */ for (i = 0; i < 256; i++) { atransh[i] = atransl[i] = btransh[i] = btransl[i] = 0; if (i & 2) { btransl[i] |= 0x04; btransh[i] |= 0x40; } if (i & 0x20) { atransl[i] |= 0x02; atransh[i] |= 0x20; } if (i & 0x40) { atransl[i] |= 0x08; atransh[i] |= 0x80; } if (i & 0x80) { atransl[i] |= 0x01; atransh[i] |= 0x10; } } /* Fill in the generic fields of the device structure. */ ether_setup(dev); /* Then, override parts of it */ dev->hard_start_xmit = plip_tx_packet; dev->open = plip_open; dev->stop = plip_close; dev->get_stats = plip_get_stats; dev->set_config = plip_config; dev->do_ioctl = plip_ioctl; dev->tx_queue_len = 10; dev->flags = IFF_POINTOPOINT|IFF_NOARP; /* Set the private structure */ dev->priv = kmalloc(sizeof (struct net_local), GFP_KERNEL); if (dev->priv == NULL) { printk(KERN_ERR "%s: out of memory\n", dev->name); return -ENOMEM; } memset(dev->priv, 0, sizeof(struct net_local)); nl = (struct net_local *) dev->priv; nl->orig_rebuild_header = dev->rebuild_header; dev->rebuild_header = plip_rebuild_header; /* Initialize constants */ nl->trigger = PLIP_TRIGGER_WAIT; nl->nibble = PLIP_NIBBLE_WAIT; /* Initialize task queue structures */ nl->immediate.next = NULL; nl->immediate.sync = 0; nl->immediate.routine = (void *)(void *)plip_bh; nl->immediate.data = dev; nl->deferred.next = NULL; nl->deferred.sync = 0; nl->deferred.routine = (void *)(void *)plip_kick_bh; nl->deferred.data = dev; return 0; } /* Bottom half handler for the delayed request. This routine is kicked by do_timer(). Request `plip_bh' to be invoked. */ static void plip_kick_bh(struct device *dev) { struct net_local *nl = (struct net_local *)dev->priv; if (nl->is_deferred) { queue_task(&nl->immediate, &tq_immediate); mark_bh(IMMEDIATE_BH); } } /* Forward declarations of internal routines */ static int plip_none(struct device *, struct net_local *, struct plip_local *, struct plip_local *); static int plip_receive_packet(struct device *, struct net_local *, struct plip_local *, struct plip_local *); static int plip_send_packet(struct device *, struct net_local *, struct plip_local *, struct plip_local *); static int plip_connection_close(struct device *, struct net_local *, struct plip_local *, struct plip_local *); static int plip_error(struct device *, struct net_local *, struct plip_local *, struct plip_local *); static int plip_bh_timeout_error(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv, int error); #define OK 0 #define TIMEOUT 1 #define ERROR 2 typedef int (*plip_func)(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv); static plip_func connection_state_table[] = { plip_none, plip_receive_packet, plip_send_packet, plip_connection_close, plip_error }; /* Bottom half handler of PLIP. */ static void plip_bh(struct device *dev) { struct net_local *nl = (struct net_local *)dev->priv; struct plip_local *snd = &nl->snd_data; struct plip_local *rcv = &nl->rcv_data; plip_func f; int r; nl->is_deferred = 0; f = connection_state_table[nl->connection]; if ((r = (*f)(dev, nl, snd, rcv)) != OK && (r = plip_bh_timeout_error(dev, nl, snd, rcv, r)) != OK) { nl->is_deferred = 1; queue_task(&nl->deferred, &tq_timer); } } static int plip_bh_timeout_error(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv, int error) { unsigned long flags; save_flags(flags); cli(); if (nl->connection == PLIP_CN_SEND) { if (error != ERROR) { /* Timeout */ nl->timeout_count++; if ((snd->state == PLIP_PK_TRIGGER && nl->timeout_count <= 10) || nl->timeout_count <= 3) { restore_flags(flags); /* Try again later */ return TIMEOUT; } if (net_debug > 1) printk("%s: transmit timeout(%d,%02x)\n", dev->name, snd->state, (((ciab.pra & 0x3) ^ 1) | (ciaa.prb & 0xe0)) & 0xe3); } nl->enet_stats.tx_errors++; nl->enet_stats.tx_aborted_errors++; } else if (nl->connection == PLIP_CN_RECEIVE) { if (rcv->state == PLIP_PK_TRIGGER) { /* Transmission was interrupted. */ restore_flags(flags); return OK; } if (error != ERROR) { /* Timeout */ if (++nl->timeout_count <= 3) { restore_flags(flags); /* Try again later */ return TIMEOUT; } if (net_debug > 1) printk("%s: receive timeout(%d,%02x)\n", dev->name, rcv->state, (((ciab.pra & 0x3) ^ 1) | (ciaa.prb & 0xe0)) & 0xe3); } nl->enet_stats.rx_dropped++; } rcv->state = PLIP_PK_DONE; if (rcv->skb) { rcv->skb->free = 1; kfree_skb(rcv->skb, FREE_READ); rcv->skb = NULL; } snd->state = PLIP_PK_DONE; if (snd->skb) { dev_kfree_skb(snd->skb, FREE_WRITE); snd->skb = NULL; } DISABLEINT; dev->tbusy = 1; nl->connection = PLIP_CN_ERROR; ciaa.prb = 0x00; restore_flags(flags); return TIMEOUT; } static int plip_none(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv) { return OK; } /* PLIP_RECEIVE --- receive a byte(two nibbles) Returns OK on success, TIMEOUT on timeout */ inline static int plip_receive(unsigned short nibble_timeout, unsigned short status_addr, enum plip_nibble_state *ns_p, unsigned char *data_p) { unsigned char c0; unsigned int cx; switch (*ns_p) { case PLIP_NB_BEGIN: cx = nibble_timeout; while (1) { c0 = ciab.pra; if ((c0 & 1)) { /* if ((ciab.pra & 0x3) == (c0 & 0x3)) */ break; } if (--cx == 0) return TIMEOUT; } *data_p = (btransl[ciab.pra] | atransl[ciaa.prb]); ciaa.prb = 0x10; /* send ACK */ *ns_p = PLIP_NB_1; case PLIP_NB_1: cx = nibble_timeout; while (1) { c0 = ciab.pra; if ((c0 & 1) == 0) { /* if ((ciab.pra & 0x3) == (c0 & 0x3)) */ break; } if (--cx == 0) return TIMEOUT; } *data_p |= (btransh[ciab.pra] | atransh[ciaa.prb]); ciaa.prb = 0x00; /* send ACK */ *ns_p = PLIP_NB_BEGIN; case PLIP_NB_2: break; } return OK; } /* PLIP_RECEIVE_PACKET --- receive a packet */ static int plip_receive_packet(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv) { unsigned short status_addr = 0; unsigned short nibble_timeout = nl->nibble; unsigned char *lbuf; unsigned long flags; switch (rcv->state) { case PLIP_PK_TRIGGER: DISABLEINT; dev->interrupt = 0; ciaa.prb = 0x01; /* send ACK */ if (net_debug > 2) printk("%s: receive start\n", dev->name); rcv->state = PLIP_PK_LENGTH_LSB; rcv->nibble = PLIP_NB_BEGIN; case PLIP_PK_LENGTH_LSB: if (snd->state != PLIP_PK_DONE) { if (plip_receive(nl->trigger, status_addr, &rcv->nibble, &rcv->length.b.lsb)) { /* collision, here dev->tbusy == 1 */ rcv->state = PLIP_PK_DONE; nl->is_deferred = 1; nl->connection = PLIP_CN_SEND; queue_task(&nl->deferred, &tq_timer); CLEARINT; ENABLEINT; return OK; } } else { if (plip_receive(nibble_timeout, status_addr, &rcv->nibble, &rcv->length.b.lsb)) return TIMEOUT; } rcv->state = PLIP_PK_LENGTH_MSB; case PLIP_PK_LENGTH_MSB: if (plip_receive(nibble_timeout, status_addr, &rcv->nibble, &rcv->length.b.msb)) return TIMEOUT; if (rcv->length.h > dev->mtu + dev->hard_header_len || rcv->length.h < 8) { printk("%s: bogus packet size %d.\n", dev->name, rcv->length.h); return ERROR; } /* Malloc up new buffer. */ rcv->skb = dev_alloc_skb(rcv->length.h); if (rcv->skb == NULL) { printk("%s: Memory squeeze.\n", dev->name); return ERROR; } skb_put(rcv->skb,rcv->length.h); rcv->skb->dev = dev; rcv->state = PLIP_PK_DATA; rcv->byte = 0; rcv->checksum = 0; case PLIP_PK_DATA: lbuf = rcv->skb->data; do if (plip_receive(nibble_timeout, status_addr, &rcv->nibble, &lbuf[rcv->byte])) return TIMEOUT; while (++rcv->byte < rcv->length.h); do rcv->checksum += lbuf[--rcv->byte]; while (rcv->byte); rcv->state = PLIP_PK_CHECKSUM; case PLIP_PK_CHECKSUM: if (plip_receive(nibble_timeout, status_addr, &rcv->nibble, &rcv->data)) return TIMEOUT; if (rcv->data != rcv->checksum) { nl->enet_stats.rx_crc_errors++; if (net_debug) printk("%s: checksum error\n", dev->name); return ERROR; } rcv->state = PLIP_PK_DONE; case PLIP_PK_DONE: /* Inform the upper layer for the arrival of a packet. */ rcv->skb->protocol=eth_type_trans(rcv->skb, dev); netif_rx(rcv->skb); nl->enet_stats.rx_packets++; rcv->skb = NULL; if (net_debug > 2) printk("%s: receive end\n", dev->name); /* Close the connection. */ ciaa.prb = 0x00; save_flags(flags); cli(); if (snd->state != PLIP_PK_DONE) { nl->connection = PLIP_CN_SEND; restore_flags(flags); queue_task(&nl->immediate, &tq_immediate); mark_bh(IMMEDIATE_BH); CLEARINT; ENABLEINT; return OK; } else { nl->connection = PLIP_CN_NONE; restore_flags(flags); CLEARINT; ENABLEINT; return OK; } } return OK; } /* PLIP_SEND --- send a byte (two nibbles) Returns OK on success, TIMEOUT when timeout */ inline static int plip_send(unsigned short nibble_timeout, unsigned short data_addr, enum plip_nibble_state *ns_p, unsigned char data) { unsigned int cx; switch (*ns_p) { case PLIP_NB_BEGIN: ciaa.prb = (data & 0x0f); *ns_p = PLIP_NB_1; case PLIP_NB_1: ciaa.prb = (0x10 | (data & 0x0f)); cx = nibble_timeout; while (1) { if ((ciab.pra & 1)) break; if (--cx == 0) return TIMEOUT; } ciaa.prb = (0x10 | (data >> 4)); *ns_p = PLIP_NB_2; case PLIP_NB_2: ciaa.prb = (data >> 4); cx = nibble_timeout; while (1) { if ((ciab.pra & 1) == 0) break; if (--cx == 0) return TIMEOUT; } *ns_p = PLIP_NB_BEGIN; return OK; } return OK; } /* PLIP_SEND_PACKET --- send a packet */ static int plip_send_packet(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv) { unsigned short data_addr = 0; unsigned short nibble_timeout = nl->nibble; unsigned char *lbuf; unsigned int cx; if (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) { printk("%s: send skb lost\n", dev->name); snd->state = PLIP_PK_DONE; snd->skb = NULL; return ERROR; } switch (snd->state) { case PLIP_PK_TRIGGER: if ((((ciaa.prb & 0xe0) | (ciab.pra & 0x3)) & 0xe3) != 0x00) return TIMEOUT; /* Trigger remote rx interrupt. */ ciaa.prb = 0x08; cx = nl->trigger; while (1) { unsigned long flags; save_flags(flags); cli(); if (nl->connection == PLIP_CN_RECEIVE) { restore_flags(flags); /* interrupted */ nl->enet_stats.collisions++; if (net_debug > 1) printk("%s: collision.\n", dev->name); return OK; } if (ciaa.prb & 0x80) { DISABLEINT; if (net_debug > 2) printk("%s: send start\n", dev->name); snd->state = PLIP_PK_LENGTH_LSB; snd->nibble = PLIP_NB_BEGIN; nl->timeout_count = 0; restore_flags(flags); break; } restore_flags(flags); if (--cx == 0) { ciaa.prb = 0x00; return TIMEOUT; } } case PLIP_PK_LENGTH_LSB: if (plip_send(nibble_timeout, data_addr, &snd->nibble, snd->length.b.lsb)) return TIMEOUT; snd->state = PLIP_PK_LENGTH_MSB; case PLIP_PK_LENGTH_MSB: if (plip_send(nibble_timeout, data_addr, &snd->nibble, snd->length.b.msb)) return TIMEOUT; snd->state = PLIP_PK_DATA; snd->byte = 0; snd->checksum = 0; case PLIP_PK_DATA: do if (plip_send(nibble_timeout, data_addr, &snd->nibble, lbuf[snd->byte])) return TIMEOUT; while (++snd->byte < snd->length.h); do snd->checksum += lbuf[--snd->byte]; while (snd->byte); snd->state = PLIP_PK_CHECKSUM; case PLIP_PK_CHECKSUM: if (plip_send(nibble_timeout, data_addr, &snd->nibble, snd->checksum)) return TIMEOUT; dev_kfree_skb(snd->skb, FREE_WRITE); nl->enet_stats.tx_packets++; snd->state = PLIP_PK_DONE; case PLIP_PK_DONE: /* Close the connection */ ciaa.prb = 0x00; snd->skb = NULL; if (net_debug > 2) printk("%s: send end\n", dev->name); nl->connection = PLIP_CN_CLOSING; nl->is_deferred = 1; queue_task(&nl->deferred, &tq_timer); CLEARINT; ENABLEINT; return OK; } return OK; } static int plip_connection_close(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv) { unsigned long flags; save_flags(flags); cli(); if (nl->connection == PLIP_CN_CLOSING) { nl->connection = PLIP_CN_NONE; dev->tbusy = 0; mark_bh(NET_BH); } restore_flags(flags); return OK; } /* PLIP_ERROR --- wait till other end settled */ static int plip_error(struct device *dev, struct net_local *nl, struct plip_local *snd, struct plip_local *rcv) { if ((((ciaa.prb & 0xe0) | (ciab.pra & 0x3)) & 0xe3) == 0) { if (net_debug > 2) printk("%s: reset interface.\n", dev->name); nl->connection = PLIP_CN_NONE; dev->tbusy = 0; dev->interrupt = 0; CLEARINT; ENABLEINT; mark_bh(NET_BH); } else { nl->is_deferred = 1; queue_task(&nl->deferred, &tq_timer); } return OK; } /* Handle the parallel port interrupts. */ static void plip_interrupt(int irq, void *dev_id, struct pt_regs * regs) { struct device *dev = (struct device *) plip_dev; struct net_local *nl = (struct net_local *)dev->priv; struct plip_local *rcv = &nl->rcv_data; unsigned long flags; if (dev == NULL) { printk ("plip_interrupt: irq %d for unknown device.\n", irq); return; } if (dev->interrupt) return; if ((((ciab.pra & 0x3) | (ciaa.prb & 0xe0)) & 0xe3) != 0x40) { if (net_debug > 1) printk("%s: spurious interrupt (%02x)\n", dev->name, (((ciab.pra & 0x3) ^ 1) | (ciaa.prb & 0xe0)) & 0xe3); return; } dev->interrupt = 1; if (net_debug > 3) printk("%s: interrupt.\n", dev->name); save_flags(flags); cli(); switch (nl->connection) { case PLIP_CN_CLOSING: dev->tbusy = 0; case PLIP_CN_NONE: case PLIP_CN_SEND: dev->last_rx = jiffies; rcv->state = PLIP_PK_TRIGGER; nl->connection = PLIP_CN_RECEIVE; nl->timeout_count = 0; queue_task(&nl->immediate, &tq_immediate); mark_bh(IMMEDIATE_BH); restore_flags(flags); break; case PLIP_CN_RECEIVE: restore_flags(flags); printk("%s: receive interrupt when receiving packet\n", dev->name); break; case PLIP_CN_ERROR: restore_flags(flags); printk("%s: receive interrupt in error state\n", dev->name); break; } } /* We don't need to send arp, for plip is point-to-point. */ static int plip_rebuild_header(void *buff, struct device *dev, unsigned long dst, struct sk_buff *skb) { struct net_local *nl = (struct net_local *)dev->priv; struct ethhdr *eth = (struct ethhdr *)buff; int i; if ((dev->flags & IFF_NOARP)==0) return nl->orig_rebuild_header(buff, dev, dst, skb); if (eth->h_proto != htons(ETH_P_IP)) { printk("plip_rebuild_header: Don't know how to resolve type %d addresses?\n", (int)eth->h_proto); memcpy(eth->h_source, dev->dev_addr, dev->addr_len); return 0; } for (i=0; i < ETH_ALEN - sizeof(u32); i++) eth->h_dest[i] = 0xfc; *(u32 *)(eth->h_dest+i) = dst; return 0; } static int plip_tx_packet(struct sk_buff *skb, struct device *dev) { struct net_local *nl = (struct net_local *)dev->priv; struct plip_local *snd = &nl->snd_data; unsigned long flags; if (dev->tbusy) return 1; /* If some higher layer thinks we've missed an tx-done interrupt we are passed NULL. Caution: dev_tint() handles the cli()/sti() itself. */ if (skb == NULL) { dev_tint(dev); return 0; } if (set_bit(0, (void*)&dev->tbusy) != 0) { printk("%s: Transmitter access conflict.\n", dev->name); return 1; } if (skb->len > dev->mtu + dev->hard_header_len) { printk("%s: packet too big, %d.\n", dev->name, (int)skb->len); dev->tbusy = 0; return 0; } if (net_debug > 2) printk("%s: send request\n", dev->name); save_flags(flags); cli(); dev->trans_start = jiffies; snd->skb = skb; snd->length.h = skb->len; snd->state = PLIP_PK_TRIGGER; if (nl->connection == PLIP_CN_NONE) { nl->connection = PLIP_CN_SEND; nl->timeout_count = 0; } queue_task(&nl->immediate, &tq_immediate); mark_bh(IMMEDIATE_BH); restore_flags(flags); return 0; } /* Open/initialize the board. This is called (in the current kernel) sometime after booting when the 'ifconfig' program is run. This routine gets exclusive access to the parallel port by allocating its IRQ line. */ static int plip_open(struct device *dev) { struct net_local *nl = (struct net_local *)dev->priv; int i; unsigned long flags; save_flags(flags); cli(); if (request_irq(IRQ_AMIGA_CIAA_FLG, plip_interrupt, 0, dev->name, plip_interrupt)) { restore_flags(flags); printk("%s: couldn't get IRQ.\n", dev->name); return -EAGAIN; } dev->irq = IRQ_AMIGA_CIAA_FLG & ~IRQ_MACHSPEC; plip_dev = dev; restore_flags(flags); /* Clear the data port. */ ciaa.prb = 0x00; /* Initialize the state machine. */ nl->rcv_data.state = nl->snd_data.state = PLIP_PK_DONE; nl->rcv_data.skb = nl->snd_data.skb = NULL; nl->connection = PLIP_CN_NONE; nl->is_deferred = 0; /* Fill in the MAC-level header. */ for (i=0; i < ETH_ALEN - sizeof(u32); i++) dev->dev_addr[i] = 0xfc; *(u32 *)(dev->dev_addr+i) = dev->pa_addr; dev->interrupt = 0; dev->start = 1; dev->tbusy = 0; MOD_INC_USE_COUNT; return 0; } /* The inverse routine to plip_open (). */ static int plip_close(struct device *dev) { struct net_local *nl = (struct net_local *)dev->priv; struct plip_local *snd = &nl->snd_data; struct plip_local *rcv = &nl->rcv_data; unsigned long flags; dev->tbusy = 1; dev->start = 0; save_flags(flags); cli(); CLEARINT; free_irq((dev->irq | IRQ_MACHSPEC), plip_interrupt); plip_dev = NULL; nl->is_deferred = 0; nl->connection = PLIP_CN_NONE; restore_flags(flags); ciaa.prb = 0x00; snd->state = PLIP_PK_DONE; if (snd->skb) { dev_kfree_skb(snd->skb, FREE_WRITE); snd->skb = NULL; } rcv->state = PLIP_PK_DONE; if (rcv->skb) { rcv->skb->free = 1; kfree_skb(rcv->skb, FREE_READ); rcv->skb = NULL; } MOD_DEC_USE_COUNT; return 0; } static struct enet_statistics * plip_get_stats(struct device *dev) { struct net_local *nl = (struct net_local *)dev->priv; struct enet_statistics *r = &nl->enet_stats; return r; } static int plip_config(struct device *dev, struct ifmap *map) { if (dev->flags & IFF_UP) return -EBUSY; if (map->base_addr != (unsigned long)-1 && map->base_addr != dev->base_addr) printk("%s: You cannot change base_addr of this interface (ignored).\n", dev->name); if (map->irq != (unsigned char)-1) dev->irq = map->irq; return 0; } static int plip_ioctl(struct device *dev, struct ifreq *rq, int cmd) { struct net_local *nl = (struct net_local *) dev->priv; struct plipconf *pc = (struct plipconf *) &rq->ifr_data; switch(pc->pcmd) { case PLIP_GET_TIMEOUT: pc->trigger = nl->trigger; pc->nibble = nl->nibble; break; case PLIP_SET_TIMEOUT: nl->trigger = pc->trigger; nl->nibble = pc->nibble; break; default: return -EOPNOTSUPP; } return 0; } #ifdef MODULE static struct device dev_plip = { "plip0", 0, 0, 0, 0, /* memory */ 0, 0, /* base, irq */ 0, 0, 0, NULL, plip_init }; int init_module(void) { int devices=0; if (register_netdev(&dev_plip) == 0) devices++; if (devices == 0) { printk(KERN_INFO "plip: no interfaces found\n"); return -EIO; } return 0; } void cleanup_module(void) { if (dev_plip.priv) { unregister_netdev(&dev_plip); kfree_s(dev_plip.priv, sizeof(struct net_local)); dev_plip.priv = NULL; } } #endif /* MODULE */ /* * Local variables: * compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer -fstrength-reduce -pipe -c plip.c" * End: */