Resent-Date: Fri, 22 Jan 1999 14:33:34 +0100 (MET) Subject: Amiga-Parport Driver for 2.2.0pre7 To: linux-m68k@phil.uni-sb.de (Linux Liste), linux-parport@torque.net, Jes.Sorensen@cern.ch (Jes Sorensen), alan@lxorguk.ukuu.org.uk (Alan Cox) Date: Fri, 22 Jan 1999 14:29:18 +0100 (CET) From: Joerg Dorchain Resent-From: linux-m68k@phil.uni-sb.de Hi all, I finally found some time to integrate the amiga parport into the 2.2.0pre7 kernel (to be precisly the version found at sunsite.auc.dk in the 680x0 section). It adds parport support for the Amiga builtin port and for the parallel port of the Multiface 3 expansion card. It is tested (somewaht) and found working on my machine. Please do further testing and report problems to me. The only high-level device I tested was the lp driver. I have no other parallel devices at hand. The atari driver should be easily adapted. Unfortunately I lost the patch for it. Can someone (Andreas?) please help out? I had to do some small changes to the interrupt code in parport_share.c. It became more "non-PC friendly", but still doesn't cope with shared interrupt too well. Jes, is it possible to include it in the next patch to give it more people for testing? It is marked as experimental and the old drivers for lp are still selected by default (although you might run into trouble if you use both the same time). Happy playing, Joerg --- ./arch/m68k/config.in.oldpp Thu Jan 21 14:39:31 1999 +++ ./arch/m68k/config.in Fri Jan 22 11:19:11 1999 @@ -94,6 +94,19 @@ fi fi bool '/proc/hardware support' CONFIG_PROC_HARDWARE + +if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then + tristate 'Parallel port support (EXPERIMENTAL, disables old lp driver!)' CONFIG_PARPORT + if [ "$CONFIG_PARPORT" != "n" ]; then + if [ "$CONFIG_AMIGA" != "n" ]; then + dep_tristate ' Amiga builtin port' CONFIG_PARPORT_AMIGA $CONFIG_PARPORT + if [ "$CONFIG_ZORRO" != "n" ]; then + dep_tristate ' Multiface III parallel port' CONFIG_PARPORT_MFC3 $CONFIG_PARPORT + fi + fi + fi +fi + endmenu source drivers/block/Config.in @@ -254,10 +267,17 @@ define_bool CONFIG_NVRAM y fi -tristate 'Parallel printer support' CONFIG_M68K_PRINTER -if [ "$CONFIG_ZORRO" = "y" ]; then - dep_tristate 'Multiface Card III parallel support' CONFIG_MULTIFACE_III_LP $CONFIG_M68K_PRINTER -fi +if [ "$CONFIG_PARPORT" = "n" ]; then + tristate 'Parallel printer support' CONFIG_M68K_PRINTER + if [ "$CONFIG_ZORRO" = "y" ]; then + dep_tristate 'Multiface Card III parallel support' CONFIG_MULTIFACE_III_LP $CONFIG_M68K_PRINTER + fi +else + dep_tristate 'Parallel printer support' CONFIG_PRINTER $CONFIG_PARPORT + if [ "$CONFIG_PRINTER" != "n" ]; then + bool ' Support IEEE1284 status readback' CONFIG_PRINTER_READBACK + fi +fi if [ "$CONFIG_AMIGA" = "y" ]; then tristate 'Amiga mouse support' CONFIG_AMIGAMOUSE fi --- ./drivers/char/lp.c.oldpp Fri Jan 22 11:32:04 1999 +++ ./drivers/char/lp.c Fri Jan 22 14:42:58 1999 @@ -177,7 +177,7 @@ #include #include -#undef LP_STATS +#define LP_STATS #include #include @@ -206,7 +206,7 @@ (((status) & (LP_POUTPA|LP_PSELECD|LP_PERRORP)) == \ (LP_PSELECD|LP_PERRORP)) -#undef LP_DEBUG +#define LP_DEBUG #undef LP_READ_DEBUG /* --- parport support ----------------------------------------- */ @@ -273,6 +273,7 @@ { unsigned long count = 0; #ifdef LP_STATS + unsigned long wait; /* JD: was undefined */ struct lp_stats *stats; #endif --- ./drivers/misc/parport_init.c.oldpp Thu Jan 21 14:36:23 1999 +++ ./drivers/misc/parport_init.c Fri Jan 22 11:19:11 1999 @@ -126,6 +126,12 @@ #ifdef CONFIG_PARPORT_AX parport_ax_init(); #endif +#ifdef CONFIG_PARPORT_AMIGA + parport_amiga_init(); +#endif +#ifdef CONFIG_PARPORT_MFC3 + parport_mfc3_init(); +#endif return 0; } #endif --- ./drivers/misc/parport_share.c.oldpp Thu Jan 21 13:12:25 1999 +++ ./drivers/misc/parport_share.c Fri Jan 22 14:46:49 1999 @@ -378,6 +378,15 @@ dev->waitprev = dev->waitnext = NULL; } +#if 0 + /* + * JD: This may work for PCs, but in general, disabling irqs from + * higher levels is a bad thing(tm). Use a hook function in the + * hardware driver if you really need to. + * FYI: On my machine, this call would not only disable the parport + * but also the SCSI, IDE and Ethernet irq (all shared) + */ + if (oldcad && port->irq != PARPORT_IRQ_NONE && !oldcad->irq_func) /* * If there was an irq pending it should hopefully happen @@ -390,6 +399,11 @@ */ if (port->irq != PARPORT_IRQ_NONE && !dev->irq_func) disable_irq(port->irq); + /* + * JD: This is badly wrong. There is hardware that needs software to + * acknowledge an interrupt, even if higher level don't need it. + */ +#endif /* 0 */ /* Now we do the change of devices */ write_lock_irqsave(&port->cad_lock, flags); --- ./drivers/misc/Makefile.oldpp Thu Jan 21 14:39:45 1999 +++ ./drivers/misc/Makefile Fri Jan 22 11:19:11 1999 @@ -34,6 +34,20 @@ M_OBJS += parport_ax.o endif endif + ifeq ($(CONFIG_PARPORT_AMIGA),y) + LX_OBJS += parport_amiga.o + else + ifeq ($(CONFIG_PARPORT_AMIGA),m) + M_OBJS += parport_amiga.o + endif + endif + ifeq ($(CONFIG_PARPORT_MFC3),y) + LX_OBJS += parport_mfc3.o + else + ifeq ($(CONFIG_PARPORT_MFC3),m) + M_OBJS += parport_mfc3.o + endif + endif LX_OBJS += parport_init.o else ifeq ($(CONFIG_PARPORT),m) @@ -49,6 +63,12 @@ endif ifeq ($(CONFIG_PARPORT_AX),m) M_OBJS += parport_ax.o + endif + ifeq ($(CONFIG_PARPORT_AMIGA),m) + M_OBJS += parport_amiga.o + endif + ifeq ($(CONFIG_PARPORT_MFC3),m) + M_OBJS += parport_mfc3.o endif endif --- ./drivers/misc/parport_mfc3.c.oldpp Fri Jan 22 11:19:11 1999 +++ ./drivers/misc/parport_mfc3.c Fri Jan 22 14:09:43 1999 @@ -0,0 +1,420 @@ +/* Low-level parallel port routines for the Multiface 3 card + * + * Author: Joerg Dorchain + * + * (C) The elitist m68k Users(TM) + * + * based on the existing parport_amiga and lp_mfc + * + * + * From the MFC3 documentation: + * + * Miscellaneous PIA Details + * ------------------------- + * + * The two open-drain interrupt outputs /IRQA and /IRQB are routed to + * /INT2 of the Z2 bus. + * + * The CPU data bus of the PIA (D0-D7) is connected to D8-D15 on the Z2 + * bus. This means that any PIA registers are accessed at even addresses. + * + * Centronics Pin Connections for the PIA + * -------------------------------------- + * + * The following table shows the connections between the PIA and the + * Centronics interface connector. These connections implement a single, but + * very complete, Centronics type interface. The Pin column gives the pin + * numbers of the PIA. The Centronics pin numbers can be found in the section + * "Parallel Connectors". + * + * + * Pin | PIA | Dir | Centronics Names + * -------+-----+-----+--------------------------------------------------------- + * 19 | CB2 | --> | /STROBE (aka /DRDY) + * 10-17 | PBx | <-> | DATA0 - DATA7 + * 18 | CB1 | <-- | /ACK + * 40 | CA1 | <-- | BUSY + * 3 | PA1 | <-- | PAPER-OUT (aka POUT) + * 4 | PA2 | <-- | SELECTED (aka SEL) + * 9 | PA7 | --> | /INIT (aka /RESET or /INPUT-PRIME) + * 6 | PA4 | <-- | /ERROR (aka /FAULT) + * 7 | PA5 | --> | DIR (aka /SELECT-IN) + * 8 | PA6 | --> | /AUTO-FEED-XT + * 39 | CA2 | --> | open + * 5 | PA3 | <-- | /ACK (same as CB1!) + * 2 | PA0 | <-- | BUSY (same as CA1!) + * -------+-----+-----+--------------------------------------------------------- + * + * Should be enough to understand some of the driver. + */ + +#include "multiface.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Maximum Number of Cards supported */ +#define MAX_MFC 5 + +#undef DEBUG +#ifdef DEBUG +#define DPRINTK printk +#else +static inline int DPRINTK() {return 0;} +#endif + +static struct parport *this_port[MAX_MFC] = {NULL, }; +static volatile int dummy; /* for trigger readds */ + +#define pia(dev) ((struct pia *)(dev->base)) +static struct parport_operations pp_mfc3_ops; + +static void mfc3_write_data(struct parport *p, unsigned char data) +{ +DPRINTK("write_data %c\n",data); + + dummy = pia(p)->pprb; /* clears irq bit */ + /* Triggers also /STROBE.*/ + pia(p)->pprb = data; +} + +static unsigned char mfc3_read_data(struct parport *p) +{ + /* clears interupt bit. Triggers also /STROBE. */ + return pia(p)->pprb; +} + +static unsigned char control_pc_to_mfc3(unsigned char control) +{ + unsigned char ret = 32|64; + + if (control & PARPORT_CONTROL_DIRECTION) /* XXX: What is this? */ + ; + if (control & PARPORT_CONTROL_INTEN) /* XXX: What is INTEN? */ + ; + if (control & PARPORT_CONTROL_SELECT) /* XXX: What is SELECP? */ + ret &= ~32; /* /SELECT_IN */ + if (control & PARPORT_CONTROL_INIT) /* INITP */ + ret |= 128; + if (control & PARPORT_CONTROL_AUTOFD) /* AUTOLF */ + ret &= ~64; + if (control & PARPORT_CONTROL_STROBE) /* Strobe */ + /* Handled directly by hardware */; + return ret; +} + +static unsigned char control_mfc3_to_pc(unsigned char control) +{ + unsigned char ret = PARPORT_CONTROL_INTEN | PARPORT_CONTROL_STROBE + | PARPORT_CONTROL_AUTOFD | PARPORT_CONTROL_SELECT; + + if (control & 128) /* /INITP */ + ret |= PARPORT_CONTROL_INIT; + if (control & 64) /* /AUTOLF */ + ret &= ~PARPORT_CONTROL_AUTOFD; + if (control & 32) /* /SELECT_IN */ + ret &= ~PARPORT_CONTROL_SELECT; + return ret; +} + +static void mfc3_write_control(struct parport *p, unsigned char control) +{ +DPRINTK("write_control %02x\n",control); + pia(p)->ppra = (pia(p)->ppra & 0x1f) | control_pc_to_mfc3(control); +} + +static unsigned char mfc3_read_control( struct parport *p) +{ +DPRINTK("read_control \n"); + return control_mfc3_to_pc(pia(p)->ppra & 0xe0); +} + +static unsigned char mfc3_frob_control( struct parport *p, unsigned char mask, unsigned char val) +{ + unsigned char old; + +DPRINTK("frob_control mask %02x, value %02x\n",mask,val); + old = mfc3_read_control(p); + mfc3_write_control(p, (old & ~mask) ^ val); + return old; +} + + +static unsigned char status_pc_to_mfc3(unsigned char status) +{ + unsigned char ret = 1; + + if (status & PARPORT_STATUS_BUSY) /* Busy */ + ret &= ~1; + if (status & PARPORT_STATUS_ACK) /* Ack */ + ret |= 8; + if (status & PARPORT_STATUS_PAPEROUT) /* PaperOut */ + ret |= 2; + if (status & PARPORT_STATUS_SELECT) /* select */ + ret |= 4; + if (status & PARPORT_STATUS_ERROR) /* error */ + ret |= 16; + return ret; +} + +static unsigned char status_mfc3_to_pc(unsigned char status) +{ + unsigned char ret = PARPORT_STATUS_BUSY; + + if (status & 1) /* Busy */ + ret &= ~PARPORT_STATUS_BUSY; + if (status & 2) /* PaperOut */ + ret |= PARPORT_STATUS_PAPEROUT; + if (status & 4) /* Selected */ + ret |= PARPORT_STATUS_SELECT; + if (status & 8) /* Ack */ + ret |= PARPORT_STATUS_ACK; + if (status & 16) /* /ERROR */ + ret |= PARPORT_STATUS_ERROR; + + return ret; +} + +static void mfc3_write_status( struct parport *p, unsigned char status) +{ +DPRINTK("write_status %02x\n",status); + pia(p)->ppra = (pia(p)->ppra & 0xe0) | status_pc_to_mfc3(status); +} + +static unsigned char mfc3_read_status(struct parport *p) +{ + unsigned char status; + + status = status_mfc3_to_pc(pia(p)->ppra & 0x1f); +DPRINTK("read_status %02x\n", status); + return status; +} + +static void mfc3_change_mode( struct parport *p, int m) +{ + /* XXX: This port only has one mode, and I am + not sure about the corresponding PC-style mode*/ +} + +static int use_cnt = 0; + +static void mfc3_interrupt(int irq, void *dev_id, struct pt_regs *regs) +{ + int i; + + for( i = 0; i < MAX_MFC; i++) + if (this_port[i] != NULL) + if (pia(this_port[i])->crb & 128) { /* Board caused interrupt */ + dummy = pia(this_port[i])->pprb; /* clear irq bit */ + parport_generic_irq(irq, this_port[i], regs); + } +} + +static void mfc3_release_resources(struct parport *p) +{ +DPRINTK("realease_resources\n"); + if (p->irq != PARPORT_IRQ_NONE) + if (--use_cnt == 0) + free_irq(IRQ_AMIGA_PORTS, &pp_mfc3_ops); +} + +static int mfc3_claim_resources(struct parport *p) +{ +DPRINTK("claim_resources\n"); + if (p->irq != PARPORT_IRQ_NONE) + if (use_cnt++ == 0) + if (request_irq(IRQ_AMIGA_PORTS, mfc3_interrupt, 0, p->name, &pp_mfc3_ops)) + return use_cnt--; + return 0; +} + +static void mfc3_init_state(struct parport_state *s) +{ + s->u.amiga.data = 0; + s->u.amiga.datadir = 255; + s->u.amiga.status = 0; + s->u.amiga.statusdir = 0xe0; +} + +static void mfc3_save_state(struct parport *p, struct parport_state *s) +{ + s->u.amiga.data = pia(p)->pprb; + pia(p)->crb &= ~PIA_DDR; + s->u.amiga.datadir = pia(p)->pddrb; + pia(p)->crb |= PIA_DDR; + s->u.amiga.status = pia(p)->ppra; + pia(p)->cra &= ~PIA_DDR; + s->u.amiga.statusdir = pia(p)->pddrb; + pia(p)->cra |= PIA_DDR; +} + +static void mfc3_restore_state(struct parport *p, struct parport_state *s) +{ + pia(p)->pprb = s->u.amiga.data; + pia(p)->crb &= ~PIA_DDR; + pia(p)->pddrb = s->u.amiga.datadir; + pia(p)->crb |= PIA_DDR; + pia(p)->ppra = s->u.amiga.status; + pia(p)->cra &= ~PIA_DDR; + pia(p)->pddrb = s->u.amiga.statusdir; + pia(p)->cra |= PIA_DDR; +} + +static void mfc3_enable_irq(struct parport *p) +{ + pia(p)->crb |= PIA_C1_ENABLE_IRQ; +} + +static void mfc3_disable_irq(struct parport *p) +{ + pia(p)->crb &= ~PIA_C1_ENABLE_IRQ; +} + +static void mfc3_inc_use_count(void) +{ + MOD_INC_USE_COUNT; +} + +static void mfc3_dec_use_count(void) +{ + MOD_DEC_USE_COUNT; +} + +static void mfc3_fill_inode(struct inode *inode, int fill) +{ +#ifdef MODULE + if (fill) + MOD_INC_USE_COUNT; + else + MOD_DEC_USE_COUNT; +#endif +} + +static struct parport_operations pp_mfc3_ops = { + mfc3_write_data, + mfc3_read_data, + + mfc3_write_control, + mfc3_read_control, + mfc3_frob_control, + + NULL, /* write_econtrol */ + NULL, /* read_econtrol */ + NULL, /* frob_econtrol */ + + mfc3_write_status, + mfc3_read_status, + + NULL, /* write fifo */ + NULL, /* read fifo */ + + mfc3_change_mode, + + + mfc3_release_resources, + mfc3_claim_resources, + + + NULL, /* epp_write_data */ + NULL, /* epp_read_data */ + NULL, /* epp_write_addr */ + NULL, /* epp_read_addr */ + NULL, /* epp_check_timeout */ + + NULL, /* epp_write_block */ + NULL, /* epp_read_block */ + + NULL, /* ecp_write_block */ + NULL, /* ecp_read_block */ + + mfc3_init_state, + mfc3_save_state, + mfc3_restore_state, + + mfc3_enable_irq, + mfc3_disable_irq, + mfc3_interrupt, + + mfc3_inc_use_count, + mfc3_dec_use_count, + mfc3_fill_inode +}; + +/* ----------- Initialisation code --------------------------------- */ + +__initfunc(int parport_mfc3_init(void)) +{ + struct parport *p; + int pias = 0; + struct pia *pp; + unsigned int key = 0; + const struct ConfigDev *cd; + + if (MACH_IS_AMIGA) { + while ((key = zorro_find(ZORRO_PROD_BSC_MULTIFACE_III, 0, key))) { + cd = zorro_get_board(key); + pp = (struct pia *)ZTWO_VADDR((((u_char *)cd->cd_BoardAddr)+PIABASE)); + if (pias < MAX_MFC) { + pp->crb = 0; + pp->pddrb = 255; /* all data pins output */ + pp->crb = PIA_DDR|32|8; + dummy = pp->pddrb; /* reading clears interrupt */ + pp->cra = 0; + pp->pddra = 0xe0; /* /RESET, /DIR ,/AUTO-FEED output */ + pp->cra = PIA_DDR; + pp->ppra = 0; /* reset printer */ + udelay(10); + pp->ppra = 128; + if ((p = parport_register_port((unsigned long)pp, + IRQ_AMIGA_PORTS, PARPORT_DMA_NONE, + &pp_mfc3_ops))) { + this_port[pias++] = p; + printk(KERN_INFO "%s: Multiface III port using irq\n", p->name); + /* XXX: set operating mode */ + parport_proc_register(p); + p->flags |= PARPORT_FLAG_COMA; + if (parport_probe_hook) + (*parport_probe_hook)(p); + zorro_config_board(key, 0); + p->private_data = (void *)key; + } + } + } + } + return pias; +} + +#ifdef MODULE + +MODULE_AUTHOR("Joerg Dorchain"); +MODULE_DESCRIPTION("Parport Driver for Multiface 3 expansion cards Paralllel Port"); +MODULE_SUPPORTED_DEVICE("Multiface 3 Parallel Port"); + +int init_module(void) +{ + return ! parport_mfc3_init(); +} + +void cleanup_module(void) +{ + int i; + + for (i = 0; i < MAX_MFC; i++) + if (this_port[i] != NULL) { + if (!(this_port[i]->flags & PARPORT_FLAG_COMA)) + parport_quiesce(this_port[i]); + parport_proc_unregister(this_port[i]); + parport_unregister_port(this_port[i]); + zorro_unconfig_board((unsigned int)this_port[i]->private_data, 0); + } +} +#endif + + --- ./drivers/misc/multiface.h.oldpp Fri Jan 22 11:19:11 1999 +++ ./drivers/misc/multiface.h Fri Jan 22 11:19:11 1999 @@ -0,0 +1,20 @@ +#ifndef _MULTIFACE_H_ +#define _MULTIFACE_H_ + +/* + * Defines for SerialMaster, Multiface Card II and Multiface Card III + * The addresses given below are offsets to the board base address + * + * 6.11.95 Joerg Dorchain (dorchain@mpi-sb.mpg.de) + * + */ + +#define PIA_REG_PADWIDTH 255 + +#define DUARTBASE 0x0000 +#define PITBASE 0x0100 +#define ROMBASE 0x0200 +#define PIABASE 0x4000 + +#endif + --- ./drivers/misc/parport_procfs.c.oldpp Thu Jan 21 14:39:45 1999 +++ ./drivers/misc/parport_procfs.c Fri Jan 22 11:19:11 1999 @@ -36,6 +36,13 @@ unsigned long count, void *data) { int retval = -EINVAL; + +#ifndef __mc68000__ +/* + * On m68k irq changing would not work that way. + * Besides, it isn't possible and doesn't make sense either + * JD + */ int newirq = PARPORT_IRQ_NONE; struct parport *pp = (struct parport *)data; int oldirq = pp->irq; @@ -110,6 +117,7 @@ pp->irq = newirq; out: +#endif /* __mc68000__ */ return retval; } --- ./drivers/misc/parport_amiga.c.oldpp Fri Jan 22 11:19:11 1999 +++ ./drivers/misc/parport_amiga.c Fri Jan 22 11:19:11 1999 @@ -0,0 +1,322 @@ +/* Low-level parallel port routines for the Amiga buildin port + * + * Author: Joerg Dorchain + * + * This is a complete rewrite of the code, but based heaviy upon the old + * lp_intern. code. + * + * The built-in Amiga parallel port provides one port at a fixed address + * with 8 bisdirecttional data lines (D0 - D7) and 3 bidirectional status + * lines (BUSY, POUT, SEL), 1 output control line /STROBE (raised automatically in + * hardware when the data register is accessed), and 1 input control line + * /ACK, able to cause an interrupt, but both not directly settable by + * software. + */ + +#include +#include +#include +#include +#include +#include +#include + +#undef DEBUG +#ifdef DEBUG +#define DPRINTK printk +#else +static inline int DPRINTK() {return 0;} +#endif + +static struct parport *this_port = NULL; + +static void amiga_write_data(struct parport *p, unsigned char data) +{ +DPRINTK("write_data %c\n",data); + /* Triggers also /STROBE. This behavior cannot be changed */ + ciaa.prb = data; +} + +static unsigned char amiga_read_data(struct parport *p) +{ + /* Triggers also /STROBE. This behavior cannot be changed */ + return ciaa.prb; +} + +#if 0 +static unsigned char control_pc_to_amiga(unsigned char control) +{ + unsigned char ret = 0; + + if (control & PARPORT_CONTROL_DIRECTION) /* XXX: What is this? */ + ; + if (control & PARPORT_CONTROL_INTEN) /* XXX: What is INTEN? */ + ; + if (control & PARPORT_CONTROL_SELECT) /* XXX: What is SELECP? */ + ; + if (control & PARPORT_CONTROL_INIT) /* INITP */ + /* reset connected to cpu reset pin */; + if (control & PARPORT_CONTROL_AUTOFD) /* AUTOLF */ + /* Not connected */; + if (control & PARPORT_CONTROL_STROBE) /* Strobe */ + /* Handled only directly by hardware */; + return ret; +} +#endif + +static unsigned char control_amiga_to_pc(unsigned char control) +{ + return PARPORT_CONTROL_INTEN | PARPORT_CONTROL_SELECT | + PARPORT_CONTROL_AUTOFD | PARPORT_CONTROL_STROBE; + /* fake value: interrupt enable, select in, no reset, + no autolf, no strobe - seems to be closest the wiring diagram */ +} + +static void amiga_write_control(struct parport *p, unsigned char control) +{ +DPRINTK("write_control %02x\n",control); + /* No implementation possible */ +} + +static unsigned char amiga_read_control( struct parport *p) +{ +DPRINTK("read_control \n"); + return control_amiga_to_pc(0); +} + +static unsigned char amiga_frob_control( struct parport *p, unsigned char mask, unsigned char val) +{ + unsigned char old; + +DPRINTK("frob_control mask %02x, value %02x\n",mask,val); + old = amiga_read_control(p); + amiga_write_control(p, (old & ~mask) ^ val); + return old; +} + + +static unsigned char status_pc_to_amiga(unsigned char status) +{ + unsigned char ret = 1; + + if (status & PARPORT_STATUS_BUSY) /* Busy */ + ret &= ~1; + if (status & PARPORT_STATUS_ACK) /* Ack */ + /* handled in hardware */; + if (status & PARPORT_STATUS_PAPEROUT) /* PaperOut */ + ret |= 2; + if (status & PARPORT_STATUS_SELECT) /* select */ + ret |= 4; + if (status & PARPORT_STATUS_ERROR) /* error */ + /* not connected */; + return ret; +} + +static unsigned char status_amiga_to_pc(unsigned char status) +{ + unsigned char ret = PARPORT_STATUS_BUSY | PARPORT_STATUS_ACK | PARPORT_STATUS_ERROR; + + if (status & 1) /* Busy */ + ret &= ~PARPORT_STATUS_BUSY; + if (status & 2) /* PaperOut */ + ret |= PARPORT_STATUS_PAPEROUT; + if (status & 4) /* Selected */ + ret |= PARPORT_STATUS_SELECT; + /* the rest is not connected or handled autonomously in hardware */ + + return ret; +} + +static void amiga_write_status( struct parport *p, unsigned char status) +{ +DPRINTK("write_status %02x\n",status); + ciab.pra |= (ciab.pra & 0xf8) | status_pc_to_amiga(status); +} + +static unsigned char amiga_read_status(struct parport *p) +{ + unsigned char status; + + status = status_amiga_to_pc(ciab.pra & 7); +DPRINTK("read_status %02x\n", status); + return status; +} + +static void amiga_change_mode( struct parport *p, int m) +{ + /* XXX: This port only has one mode, and I am + not sure about the corresponding PC-style mode*/ +} + +/* as this ports irq handling is already done, we use a generic funktion */ +static void amiga_interrupt(int irq, void *dev_id, struct pt_regs *regs) +{ + parport_generic_irq(irq, (struct parport *) dev_id, regs); +} + + +static void amiga_release_resources(struct parport *p) +{ +DPRINTK("realease_resources\n"); + if (p->irq != PARPORT_IRQ_NONE) + free_irq(IRQ_AMIGA_CIAA_FLG, p); +} + +static int amiga_claim_resources(struct parport *p) +{ +DPRINTK("claim_resources\n"); + return request_irq(IRQ_AMIGA_CIAA_FLG, amiga_interrupt, 0, p->name, p); +} + +static void amiga_init_state(struct parport_state *s) +{ + s->u.amiga.data = 0; + s->u.amiga.datadir = 255; + s->u.amiga.status = 0; + s->u.amiga.statusdir = 0; +} + +static void amiga_save_state(struct parport *p, struct parport_state *s) +{ + s->u.amiga.data = ciaa.prb; + s->u.amiga.datadir = ciaa.ddrb; + s->u.amiga.status = ciab.pra & 7; + s->u.amiga.statusdir = ciab.ddra & 7; +} + +static void amiga_restore_state(struct parport *p, struct parport_state *s) +{ + ciaa.prb = s->u.amiga.data; + ciaa.ddrb = s->u.amiga.datadir; + ciab.pra |= (ciab.pra & 0xf8) | s->u.amiga.status; + ciab.ddra |= (ciab.ddra & 0xf8) | s->u.amiga.statusdir; +} + +static void amiga_enable_irq(struct parport *p) +{ + enable_irq(IRQ_AMIGA_CIAA_FLG); +} + +static void amiga_disable_irq(struct parport *p) +{ + disable_irq(IRQ_AMIGA_CIAA_FLG); +} + +static void amiga_inc_use_count(void) +{ + MOD_INC_USE_COUNT; +} + +static void amiga_dec_use_count(void) +{ + MOD_DEC_USE_COUNT; +} + +static void amiga_fill_inode(struct inode *inode, int fill) +{ +#ifdef MODULE + if (fill) + MOD_INC_USE_COUNT; + else + MOD_DEC_USE_COUNT; +#endif +} + +static struct parport_operations pp_amiga_ops = { + amiga_write_data, + amiga_read_data, + + amiga_write_control, + amiga_read_control, + amiga_frob_control, + + NULL, /* write_econtrol */ + NULL, /* read_econtrol */ + NULL, /* frob_econtrol */ + + amiga_write_status, + amiga_read_status, + + NULL, /* write fifo */ + NULL, /* read fifo */ + + amiga_change_mode, + + + amiga_release_resources, + amiga_claim_resources, + + + NULL, /* epp_write_data */ + NULL, /* epp_read_data */ + NULL, /* epp_write_addr */ + NULL, /* epp_read_addr */ + NULL, /* epp_check_timeout */ + + NULL, /* epp_write_block */ + NULL, /* epp_read_block */ + + NULL, /* ecp_write_block */ + NULL, /* ecp_read_block */ + + amiga_init_state, + amiga_save_state, + amiga_restore_state, + + amiga_enable_irq, + amiga_disable_irq, + amiga_interrupt, + + amiga_inc_use_count, + amiga_dec_use_count, + amiga_fill_inode +}; + +/* ----------- Initialisation code --------------------------------- */ + +__initfunc(int parport_amiga_init(void)) +{ + struct parport *p; + + if (MACH_IS_AMIGA && AMIGAHW_PRESENT(AMI_PARALLEL)) { + ciaa.ddrb = 0xff; + ciab.ddra &= 0xf8; + if (!(p = parport_register_port((unsigned long)&ciaa.prb, + IRQ_AMIGA_CIAA_FLG, PARPORT_DMA_NONE, + &pp_amiga_ops))) + return 0; + this_port = p; + printk(KERN_INFO "%s: Amiga built-in port using irq\n", p->name); + /* XXX: set operating mode */ + parport_proc_register(p); + p->flags |= PARPORT_FLAG_COMA; + + if (parport_probe_hook) + (*parport_probe_hook)(p); + return 1; + + } + return 0; +} + +#ifdef MODULE + +MODULE_AUTHOR("Joerg Dorchain"); +MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port"); +MODULE_SUPPORTED_DEVICE("Amiga builtin Parallel Port"); + +int init_module(void) +{ + return ! parport_amiga_init(); +} + +void cleanup_module(void) +{ + if (!(this_port->flags & PARPORT_FLAG_COMA)) + parport_quiesce(this_port); + parport_proc_unregister(this_port); + parport_unregister_port(this_port); +} +#endif + + --- ./include/linux/parport.h.oldpp Thu Jan 21 19:40:41 1999 +++ ./include/linux/parport.h Fri Jan 22 11:19:11 1999 @@ -78,11 +78,21 @@ unsigned int ecr; }; +/* used by both parport_amiga and parport_mfc3 */ +struct amiga_parport_state { + unsigned char data; /* ciaa.prb */ + unsigned char datadir; /* ciaa.ddrb */ + unsigned char status; /* ciab.pra & 7 */ + unsigned char statusdir;/* ciab.ddrb & 7 */ +}; + + struct parport_state { union { struct pc_parport_state pc; /* ARC has no state. */ /* AX uses same state information as PC */ + struct amiga_parport_state amiga; void *misc; } u; }; @@ -306,9 +316,15 @@ goto out_unlock; if (port->cad->irq_func) port->cad->irq_func(irq, port->cad->private, regs); +/* + * JD: This assumption is simply wrong: This function could be called + * without the higher level having a registered irq function. + */ +#if 0 else printk(KERN_ERR "%s: irq%d happened with irq_func NULL " "with %s as cad!\n", port->name, irq, port->cad->name); +#endif out_unlock: read_unlock(&port->cad_lock); }