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) 241