parport_atari.c 5.7 KB

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