drivers/misc/parport_amiga.c

   1 /* Low-level parallel port routines for the Amiga buildin port
   2  *
   3  * Author: Joerg Dorchain <dorchain@wirbel.com>
   4  *
   5  * This is a complete rewrite of the code, but based heaviy upon the old
   6  * lp_intern. code.
   7  *
   8  * The built-in Amiga parallel port provides one port at a fixed address
   9  * with 8 bisdirecttional data lines (D0 - D7) and 3 bidirectional status
  10  * lines (BUSY, POUT, SEL), 1 output control line /STROBE (raised automatically in
  11  * hardware when the data register is accessed), and 1 input control line
  12  * /ACK, able to cause an interrupt, but both not directly settable by
  13  * software.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/init.h>
  18 #include <linux/parport.h>
  19 #include <asm/setup.h>
  20 #include <asm/amigahw.h>
  21 #include <asm/irq.h>
  22 #include <asm/amigaints.h>
  23
  24 #undef DEBUG
  25 #ifdef DEBUG
  26 #define DPRINTK printk
  27 #else
  28 static inline int DPRINTK() {return 0;}
  29 #endif
  30
  31 static struct parport *this_port = NULL;
  32
  33 static void amiga_write_data(struct parport *p, unsigned char data)
  34 {
  35 DPRINTK("write_data %c\n",data);
  36         /* Triggers also /STROBE. This behavior cannot be changed */
  37         ciaa.prb = data;
  38 }
  39
  40 static unsigned char amiga_read_data(struct parport *p)
  41 {
  42         /* Triggers also /STROBE. This behavior cannot be changed */
  43         return ciaa.prb;
  44 }
  45
  46 #if 0
  47 static unsigned char control_pc_to_amiga(unsigned char control)
  48 {
  49         unsigned char ret = 0;
  50
  51         if (control & PARPORT_CONTROL_DIRECTION) /* XXX: What is this? */
  52                 ;
  53         if (control & PARPORT_CONTROL_INTEN) /* XXX: What is INTEN? */
  54                 ;
  55         if (control & PARPORT_CONTROL_SELECT) /* XXX: What is SELECP? */
  56                 ;
  57         if (control & PARPORT_CONTROL_INIT) /* INITP */
  58                 /* reset connected to cpu reset pin */;
  59         if (control & PARPORT_CONTROL_AUTOFD) /* AUTOLF */
  60                 /* Not connected */;
  61         if (control & PARPORT_CONTROL_STROBE) /* Strobe */
  62                 /* Handled only directly by hardware */;
  63         return ret;
  64 }
  65 #endif
  66
  67 static unsigned char control_amiga_to_pc(unsigned char control)
  68 {
  69         return PARPORT_CONTROL_INTEN | PARPORT_CONTROL_SELECT |
  70               PARPORT_CONTROL_AUTOFD | PARPORT_CONTROL_STROBE;
  71         /* fake value: interrupt enable, select in, no reset,
  72         no autolf, no strobe - seems to be closest the wiring diagram */
  73 }
  74
  75 static void amiga_write_control(struct parport *p, unsigned char control)
  76 {
  77 DPRINTK("write_control %02x\n",control);
  78         /* No implementation possible */
  79 }
  80
  81 static unsigned char amiga_read_control( struct parport *p)
  82 {
  83 DPRINTK("read_control \n");
  84         return control_amiga_to_pc(0);
  85 }
  86
  87 static unsigned char amiga_frob_control( struct parport *p, unsigned char mask, unsigned char val)
  88 {
  89         unsigned char old;
  90
  91 DPRINTK("frob_control mask %02x, value %02x\n",mask,val);
  92         old = amiga_read_control(p);
  93         amiga_write_control(p, (old & ~mask) ^ val);
  94         return old;
  95 }
  96
  97
  98 static unsigned char status_pc_to_amiga(unsigned char status)
  99 {
 100         unsigned char ret = 1;
 101
 102         if (status & PARPORT_STATUS_BUSY) /* Busy */
 103                 ret &= ~1;
 104         if (status & PARPORT_STATUS_ACK) /* Ack */
 105                 /* handled in hardware */;
 106         if (status & PARPORT_STATUS_PAPEROUT) /* PaperOut */
 107                 ret |= 2;
 108         if (status & PARPORT_STATUS_SELECT) /* select */
 109                 ret |= 4;
 110         if (status & PARPORT_STATUS_ERROR) /* error */
 111                 /* not connected */;
 112         return ret;
 113 }
 114
 115 static unsigned char status_amiga_to_pc(unsigned char status)
 116 {
 117         unsigned char ret = PARPORT_STATUS_BUSY | PARPORT_STATUS_ACK | PARPORT_STATUS_ERROR;
 118
 119         if (status & 1) /* Busy */
 120                 ret &= ~PARPORT_STATUS_BUSY;
 121         if (status & 2) /* PaperOut */
 122                 ret |= PARPORT_STATUS_PAPEROUT;
 123         if (status & 4) /* Selected */
 124                 ret |= PARPORT_STATUS_SELECT;
 125         /* the rest is not connected or handled autonomously in hardware */
 126
 127         return ret;
 128 }
 129
 130 static void amiga_write_status( struct parport *p, unsigned char status)
 131 {
 132 DPRINTK("write_status %02x\n",status);
 133         ciab.pra |= (ciab.pra & 0xf8) | status_pc_to_amiga(status);
 134 }
 135
 136 static unsigned char amiga_read_status(struct parport *p)
 137 {
 138         unsigned char status;
 139
 140         status = status_amiga_to_pc(ciab.pra & 7);
 141 DPRINTK("read_status %02x\n", status);
 142         return status;
 143 }
 144
 145 static void amiga_change_mode( struct parport *p, int m)
 146 {
 147         /* XXX: This port only has one mode, and I am
 148         not sure about the corresponding PC-style mode*/
 149 }
 150
 151 /* as this ports irq handling is already done, we use a generic funktion */
 152 static void amiga_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 153 {
 154         parport_generic_irq(irq, (struct parport *) dev_id, regs);
 155 }
 156
 157
 158 static void amiga_init_state(struct parport_state *s)
 159 {
 160         s->u.amiga.data = 0;
 161         s->u.amiga.datadir = 255;
 162         s->u.amiga.status = 0;
 163         s->u.amiga.statusdir = 0;
 164 }
 165
 166 static void amiga_save_state(struct parport *p, struct parport_state *s)
 167 {
 168         s->u.amiga.data = ciaa.prb;
 169         s->u.amiga.datadir = ciaa.ddrb;
 170         s->u.amiga.status = ciab.pra & 7;
 171         s->u.amiga.statusdir = ciab.ddra & 7;
 172 }
 173
 174 static void amiga_restore_state(struct parport *p, struct parport_state *s)
 175 {
 176         ciaa.prb = s->u.amiga.data;
 177         ciaa.ddrb = s->u.amiga.datadir;
 178         ciab.pra |= (ciab.pra & 0xf8) | s->u.amiga.status;
 179         ciab.ddra |= (ciab.ddra & 0xf8) | s->u.amiga.statusdir;
 180 }
 181
 182 static void amiga_enable_irq(struct parport *p)
 183 {
 184         enable_irq(IRQ_AMIGA_CIAA_FLG);
 185 }
 186
 187 static void amiga_disable_irq(struct parport *p)
 188 {
 189         disable_irq(IRQ_AMIGA_CIAA_FLG);
 190 }
 191
 192 static void amiga_inc_use_count(void)
 193 {
 194         MOD_INC_USE_COUNT;
 195 }
 196
 197 static void amiga_dec_use_count(void)
 198 {
 199         MOD_DEC_USE_COUNT;
 200 }
 201
 202 static void amiga_fill_inode(struct inode *inode, int fill)
 203 {
 204 #ifdef MODULE
 205         if (fill)
 206                 MOD_INC_USE_COUNT;
 207         else
 208                 MOD_DEC_USE_COUNT;
 209 #endif
 210 }
 211
 212 static struct parport_operations pp_amiga_ops = {
 213         amiga_write_data,
 214         amiga_read_data,
 215
 216         amiga_write_control,
 217         amiga_read_control,
 218         amiga_frob_control,
 219
 220         NULL, /* write_econtrol */
 221         NULL, /* read_econtrol */
 222         NULL, /* frob_econtrol */
 223
 224         amiga_write_status,
 225         amiga_read_status,
 226
 227         NULL, /* write fifo */
 228         NULL, /* read fifo */
 229
 230         amiga_change_mode,
 231
 232
 233         NULL, /* epp_write_data */
 234         NULL, /* epp_read_data */
 235         NULL, /* epp_write_addr */
 236         NULL, /* epp_read_addr */
 237         NULL, /* epp_check_timeout */
 238
 239         NULL, /* epp_write_block */
 240         NULL, /* epp_read_block */
 241
 242         NULL, /* ecp_write_block */
 243         NULL, /* ecp_read_block */
 244
 245         amiga_init_state,
 246         amiga_save_state,
 247         amiga_restore_state,
 248
 249         amiga_enable_irq,
 250         amiga_disable_irq,
 251         amiga_interrupt,
 252
 253         amiga_inc_use_count,
 254         amiga_dec_use_count,
 255         amiga_fill_inode
 256 };
 257
 258 /* ----------- Initialisation code --------------------------------- */
 259
 260 __initfunc(int parport_amiga_init(void))
 261 {
 262         struct parport *p;
 263
 264         if (MACH_IS_AMIGA && AMIGAHW_PRESENT(AMI_PARALLEL)) {
 265                 ciaa.ddrb = 0xff;
 266                 ciab.ddra &= 0xf8;
 267                 if (!(p = parport_register_port((unsigned long)&ciaa.prb,
 268                                         IRQ_AMIGA_CIAA_FLG, PARPORT_DMA_NONE,
 269                                         &pp_amiga_ops)))
 270                         return 0;
 271                 this_port = p;
 272                 printk(KERN_INFO "%s: Amiga built-in port using irq\n", p->name);
 273                 /* XXX: set operating mode */
 274                 parport_proc_register(p);
 275                 if (request_irq(IRQ_AMIGA_CIAA_FLG, amiga_interrupt, 0,
 276                                 p->name, p)) {
 277                         parport_unregister_port (p);
 278                         return 0;
 279                 }
 280
 281                 if (parport_probe_hook)
 282                         (*parport_probe_hook)(p);
 283
 284                 parport_announce_port (p);
 285
 286                 return 1;
 287
 288         }
 289         return 0;
 290 }
 291
 292 #ifdef MODULE
 293
 294 MODULE_AUTHOR("Joerg Dorchain");
 295 MODULE_DESCRIPTION("Parport Driver for Amiga builtin Port");
 296 MODULE_SUPPORTED_DEVICE("Amiga builtin Parallel Port");
 297
 298 int init_module(void)
 299 {
 300         return ! parport_amiga_init();
 301 }
 302
 303 void cleanup_module(void)
 304 {
 305         if (p->irq != PARPORT_IRQ_NONE)
 306                 free_irq(IRQ_AMIGA_CIAA_FLG, p);
 307         parport_proc_unregister(this_port);
 308         parport_unregister_port(this_port);
 309 }
 310 #endif
 311
 312