drivers/misc/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 <asm/setup.h>
  16 #include <asm/atarihw.h>
  17 #include <asm/irq.h>
  18 #include <asm/atariints.h>
  19
  20 static struct parport *this_port = NULL;
  21
  22 static unsigned char
  23 parport_atari_read_data(struct parport *p)
  24 {
  25         unsigned long flags;
  26         unsigned char data;
  27
  28         save_flags(flags);
  29         cli();
  30         sound_ym.rd_data_reg_sel = 15;
  31         data = sound_ym.rd_data_reg_sel;
  32         restore_flags(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         save_flags(flags);
  42         cli();
  43         sound_ym.rd_data_reg_sel = 15;
  44         sound_ym.wd_data = data;
  45         restore_flags(flags);
  46 }
  47
  48 static unsigned char
  49 parport_atari_read_control(struct parport *p)
  50 {
  51         unsigned long flags;
  52         unsigned char control = 0;
  53
  54         save_flags(flags);
  55         cli();
  56         sound_ym.rd_data_reg_sel = 14;
  57         if (!(sound_ym.rd_data_reg_sel & (1 << 5)))
  58                 control = PARPORT_CONTROL_STROBE;
  59         restore_flags(flags);
  60         return control;
  61 }
  62
  63 static void
  64 parport_atari_write_control(struct parport *p, unsigned char control)
  65 {
  66         unsigned long flags;
  67
  68         save_flags(flags);
  69         cli();
  70         sound_ym.rd_data_reg_sel = 14;
  71         if (control & PARPORT_CONTROL_STROBE)
  72                 sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~(1 << 5);
  73         else
  74                 sound_ym.wd_data = sound_ym.rd_data_reg_sel | (1 << 5);
  75         restore_flags(flags);
  76 }
  77
  78 static unsigned char
  79 parport_atari_frob_control(struct parport *p, unsigned char mask,
  80                            unsigned char val)
  81 {
  82         unsigned char old = parport_atari_read_control(p);
  83         parport_atari_write_control(p, (old & ~mask) ^ val);
  84         return old;
  85 }
  86
  87 static unsigned char
  88 parport_atari_read_status(struct parport *p)
  89 {
  90         return ((mfp.par_dt_reg & 1 ? 0 : PARPORT_STATUS_BUSY) |
  91                 PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR);
  92 }
  93
  94 static void
  95 parport_atari_write_status(struct parport *p, unsigned char status)
  96 {
  97 }
  98
  99 static void
 100 parport_atari_init_state(struct parport_state *s)
 101 {
 102 }
 103
 104 static void
 105 parport_atari_save_state(struct parport *p, struct parport_state *s)
 106 {
 107 }
 108
 109 static void
 110 parport_atari_restore_state(struct parport *p, struct parport_state *s)
 111 {
 112 }
 113
 114 static void
 115 parport_atari_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 116 {
 117         parport_generic_irq(irq, (struct parport *) dev_id, regs);
 118 }
 119
 120 static void
 121 parport_atari_inc_use_count(void)
 122 {
 123         MOD_INC_USE_COUNT;
 124 }
 125
 126 static void
 127 parport_atari_dec_use_count(void)
 128 {
 129         MOD_DEC_USE_COUNT;
 130 }
 131
 132 static void
 133 parport_atari_fill_inode(struct inode *inode, int fill)
 134 {
 135 #ifdef MODULE
 136         if (fill)
 137                 MOD_INC_USE_COUNT;
 138         else
 139                 MOD_DEC_USE_COUNT;
 140 #endif
 141 }
 142
 143 static struct parport_operations parport_atari_ops = {
 144         parport_atari_write_data,
 145         parport_atari_read_data,
 146
 147         parport_atari_write_control,
 148         parport_atari_read_control,
 149         parport_atari_frob_control,
 150
 151         NULL, /* write_econtrol */
 152         NULL, /* read_econtrol */
 153         NULL, /* frob_econtrol */
 154
 155         parport_atari_write_status,
 156         parport_atari_read_status,
 157
 158         NULL, /* write fifo */
 159         NULL, /* read fifo */
 160
 161         NULL, /* change_mode */
 162
 163         NULL, /* epp_write_data */
 164         NULL, /* epp_read_data */
 165         NULL, /* epp_write_addr */
 166         NULL, /* epp_read_addr */
 167         NULL, /* epp_check_timeout */
 168
 169         NULL, /* epp_write_block */
 170         NULL, /* epp_read_block */
 171
 172         NULL, /* ecp_write_block */
 173         NULL, /* ecp_read_block */
 174
 175         parport_atari_init_state,
 176         parport_atari_save_state,
 177         parport_atari_restore_state,
 178
 179         NULL, /* enable_irq */
 180         NULL, /* disable_irq */
 181         parport_atari_interrupt,
 182
 183         parport_atari_inc_use_count,
 184         parport_atari_dec_use_count,
 185         parport_atari_fill_inode
 186 };
 187
 188
 189 int __init
 190 parport_atari_init(void)
 191 {
 192         struct parport *p;
 193         unsigned long flags;
 194
 195         if (MACH_IS_ATARI) {
 196                 save_flags(flags);
 197                 cli();
 198                 /* Soundchip port A/B as output. */
 199                 sound_ym.rd_data_reg_sel = 7;
 200                 sound_ym.wd_data = (sound_ym.rd_data_reg_sel & 0x3f) | 0xc0;
 201                 /* STROBE high. */
 202                 sound_ym.rd_data_reg_sel = 14;
 203                 sound_ym.wd_data = sound_ym.rd_data_reg_sel | (1 << 5);
 204                 restore_flags(flags);
 205                 /* MFP port I0 as input. */
 206                 mfp.data_dir &= ~1;
 207                 /* MFP port I0 interrupt on high->low edge. */
 208                 mfp.active_edge &= ~1;
 209                 p = parport_register_port((unsigned long)&sound_ym.wd_data,
 210                                           IRQ_MFP_BUSY, PARPORT_DMA_NONE,
 211                                           &parport_atari_ops);
 212                 if (!p)
 213                         return 0;
 214                 if (request_irq(IRQ_MFP_BUSY, parport_atari_interrupt,
 215                                 IRQ_TYPE_SLOW, p->name, p)) {
 216                         parport_unregister_port (p);
 217                         return 0;
 218                 }
 219
 220                 this_port = p;
 221                 printk(KERN_INFO "%s: Atari built-in port using irq\n", p->name);
 222                 parport_proc_register(p);
 223
 224                 parport_announce_port (p);
 225
 226                 return 1;
 227         }
 228         return 0;
 229 }
 230
 231 #ifdef MODULE
 232
 233 MODULE_AUTHOR("Andreas Schwab");
 234 MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");
 235 MODULE_SUPPORTED_DEVICE("Atari builtin Parallel Port");
 236
 237 int
 238 init_module(void)
 239 {
 240         return parport_atari_init() ? 0 : -ENODEV;
 241 }
 242
 243 void
 244 cleanup_module(void)
 245 {
 246         if (p->irq != PARPORT_IRQ_NONE)
 247                 free_irq(IRQ_MFP_BUSY, p);
 248         parport_proc_unregister(this_port);
 249         parport_unregister_port(this_port);
 250 }
 251 #endif