drivers/parport/parport_atari.c

   1 /* Low-level parallel port routines for the Atari builtin port
   2  *
   3  * Author: Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
   4  *
   5  * Based on parport_amiga.c.
   6  *
   7  * The built-in Atari parallel port provides one port at a fixed address
   8  * with 8 output data lines (D0 - D7), 1 output control line (STROBE)
   9  * and 1 input status line (BUSY) able to cause an interrupt.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/parport.h>
  15 #include <linux/interrupt.h>
  16 #include <asm/setup.h>
  17 #include <asm/atarihw.h>
  18 #include <asm/irq.h>
  19 #include <asm/atariints.h>
  20
  21 static struct parport *this_port = NULL;
  22
  23 static unsigned char
  24 parport_atari_read_data(struct parport *p)
  25 {
  26         unsigned long flags;
  27         unsigned char data;
  28
  29         local_irq_save(flags);
  30         sound_ym.rd_data_reg_sel = 15;
  31         data = sound_ym.rd_data_reg_sel;
  32         local_irq_restore(flags);
  33         return data;
  34 }
  35
  36 static void
  37 parport_atari_write_data(struct parport *p, unsigned char data)
  38 {
  39         unsigned long flags;
  40
  41         local_irq_save(flags);
  42         sound_ym.rd_data_reg_sel = 15;
  43         sound_ym.wd_data = data;
  44         local_irq_restore(flags);
  45 }
  46
  47 static unsigned char
  48 parport_atari_read_control(struct parport *p)
  49 {
  50         unsigned long flags;
  51         unsigned char control = 0;
  52
  53         local_irq_save(flags);
  54         sound_ym.rd_data_reg_sel = 14;
  55         if (!(sound_ym.rd_data_reg_sel & (1 << 5)))
  56                 control = PARPORT_CONTROL_STROBE;
  57         local_irq_restore(flags);
  58         return control;
  59 }
  60
  61 static void
  62 parport_atari_write_control(struct parport *p, unsigned char control)
  63 {
  64         unsigned long flags;
  65
  66         local_irq_save(flags);
  67         sound_ym.rd_data_reg_sel = 14;
  68         if (control & PARPORT_CONTROL_STROBE)
  69                 sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~(1 << 5);
  70         else
  71                 sound_ym.wd_data = sound_ym.rd_data_reg_sel | (1 << 5);
  72         local_irq_restore(flags);
  73 }
  74
  75 static unsigned char
  76 parport_atari_frob_control(struct parport *p, unsigned char mask,
  77                            unsigned char val)
  78 {
  79         unsigned char old = parport_atari_read_control(p);
  80         parport_atari_write_control(p, (old & ~mask) ^ val);
  81         return old;
  82 }
  83
  84 static unsigned char
  85 parport_atari_read_status(struct parport *p)
  86 {
  87         return ((mfp.par_dt_reg & 1 ? 0 : PARPORT_STATUS_BUSY) |
  88                 PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR);
  89 }
  90
  91 static void
  92 parport_atari_init_state(struct pardevice *d, struct parport_state *s)
  93 {
  94 }
  95
  96 static void
  97 parport_atari_save_state(struct parport *p, struct parport_state *s)
  98 {
  99 }
 100
 101 static void
 102 parport_atari_restore_state(struct parport *p, struct parport_state *s)
 103 {
 104 }
 105
 106 static irqreturn_t
 107 parport_atari_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 108 {
 109         parport_generic_irq(irq, (struct parport *) dev_id, regs);
 110         return IRQ_HANDLED;
 111 }
 112
 113 static void
 114 parport_atari_enable_irq(struct parport *p)
 115 {
 116         enable_irq(IRQ_MFP_BUSY);
 117 }
 118
 119 static void
 120 parport_atari_disable_irq(struct parport *p)
 121 {
 122         disable_irq(IRQ_MFP_BUSY);
 123 }
 124
 125 static void
 126 parport_atari_data_forward(struct parport *p)
 127 {
 128         unsigned long flags;
 129
 130         local_irq_save(flags);
 131         /* Soundchip port B as output. */
 132         sound_ym.rd_data_reg_sel = 7;
 133         sound_ym.wd_data = sound_ym.rd_data_reg_sel | 0x40;
 134         local_irq_restore(flags);
 135 }
 136
 137 static void
 138 parport_atari_data_reverse(struct parport *p)
 139 {
 140 #if 0 /* too dangerous, can kill sound chip */
 141         unsigned long flags;
 142
 143         local_irq_save(flags);
 144         /* Soundchip port B as input. */
 145         sound_ym.rd_data_reg_sel = 7;
 146         sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~0x40;
 147         local_irq_restore(flags);
 148 #endif
 149 }
 150
 151 static struct parport_operations parport_atari_ops = {
 152         .write_data     = parport_atari_write_data,
 153         .read_data      = parport_atari_read_data,
 154
 155         .write_control  = parport_atari_write_control,
 156         .read_control   = parport_atari_read_control,
 157         .frob_control   = parport_atari_frob_control,
 158
 159         .read_status    = parport_atari_read_status,
 160
 161         .enable_irq     = parport_atari_enable_irq,
 162         .disable_irq    = parport_atari_disable_irq,
 163
 164         .data_forward   = parport_atari_data_forward,
 165         .data_reverse   = parport_atari_data_reverse,
 166
 167         .init_state     = parport_atari_init_state,
 168         .save_state     = parport_atari_save_state,
 169         .restore_state  = parport_atari_restore_state,
 170
 171         .epp_write_data = parport_ieee1284_epp_write_data,
 172         .epp_read_data  = parport_ieee1284_epp_read_data,
 173         .epp_write_addr = parport_ieee1284_epp_write_addr,
 174         .epp_read_addr  = parport_ieee1284_epp_read_addr,
 175
 176         .ecp_write_data = parport_ieee1284_ecp_write_data,
 177         .ecp_read_data  = parport_ieee1284_ecp_read_data,
 178         .ecp_write_addr = parport_ieee1284_ecp_write_addr,
 179
 180         .compat_write_data      = parport_ieee1284_write_compat,
 181         .nibble_read_data       = parport_ieee1284_read_nibble,
 182         .byte_read_data         = parport_ieee1284_read_byte,
 183
 184         .owner          = THIS_MODULE,
 185 };
 186
 187
 188 static int __init parport_atari_init(void)
 189 {
 190         struct parport *p;
 191         unsigned long flags;
 192
 193         if (MACH_IS_ATARI) {
 194                 local_irq_save(flags);
 195                 /* Soundchip port A/B as output. */
 196                 sound_ym.rd_data_reg_sel = 7;
 197                 sound_ym.wd_data = (sound_ym.rd_data_reg_sel & 0x3f) | 0xc0;
 198                 /* STROBE high. */
 199                 sound_ym.rd_data_reg_sel = 14;
 200                 sound_ym.wd_data = sound_ym.rd_data_reg_sel | (1 << 5);
 201                 local_irq_restore(flags);
 202                 /* MFP port I0 as input. */
 203                 mfp.data_dir &= ~1;
 204                 /* MFP port I0 interrupt on high->low edge. */
 205                 mfp.active_edge &= ~1;
 206                 p = parport_register_port((unsigned long)&sound_ym.wd_data,
 207                                           IRQ_MFP_BUSY, PARPORT_DMA_NONE,
 208                                           &parport_atari_ops);
 209                 if (!p)
 210                         return -ENODEV;
 211                 if (request_irq(IRQ_MFP_BUSY, parport_atari_interrupt,
 212                                 IRQ_TYPE_SLOW, p->name, p)) {
 213                         parport_put_port (p);
 214                         return -ENODEV;
 215                 }
 216
 217                 this_port = p;
 218                 printk(KERN_INFO "%s: Atari built-in port using irq\n", p->name);
 219                 parport_announce_port (p);
 220
 221                 return 0;
 222         }
 223         return -ENODEV;
 224 }
 225
 226 static void __exit parport_atari_exit(void)
 227 {
 228         parport_remove_port(this_port);
 229         if (this_port->irq != PARPORT_IRQ_NONE)
 230                 free_irq(IRQ_MFP_BUSY, this_port);
 231         parport_put_port(this_port);
 232 }
 233
 234 MODULE_AUTHOR("Andreas Schwab");
 235 MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");
 236 MODULE_SUPPORTED_DEVICE("Atari builtin Parallel Port");
 237 MODULE_LICENSE("GPL");
 238
 239 module_init(parport_atari_init)
 240 module_exit(parport_atari_exit)