[net-next-2.6.git] / drivers / parport / parport_atari.c

/* Low-level parallel port routines for the Atari builtin port
 *
 * Author: Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
 *
 * Based on parport_amiga.c.
 *
 * The built-in Atari parallel port provides one port at a fixed address
 * with 8 output data lines (D0 - D7), 1 output control line (STROBE)
 * and 1 input status line (BUSY) able to cause an interrupt.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/parport.h>
#include <linux/interrupt.h>
#include <asm/setup.h>
#include <asm/atarihw.h>
#include <asm/irq.h>
#include <asm/atariints.h>

static struct parport *this_port = NULL;

static unsigned char
parport_atari_read_data(struct parport *p)
{
	unsigned long flags;
	unsigned char data;

	local_irq_save(flags);
	sound_ym.rd_data_reg_sel = 15;
	data = sound_ym.rd_data_reg_sel;
	local_irq_restore(flags);
	return data;
}

static void
parport_atari_write_data(struct parport *p, unsigned char data)
{
	unsigned long flags;

	local_irq_save(flags);
	sound_ym.rd_data_reg_sel = 15;
	sound_ym.wd_data = data;
	local_irq_restore(flags);
}

static unsigned char
parport_atari_read_control(struct parport *p)
{
	unsigned long flags;
	unsigned char control = 0;

	local_irq_save(flags);
	sound_ym.rd_data_reg_sel = 14;
	if (!(sound_ym.rd_data_reg_sel & (1 << 5)))
		control = PARPORT_CONTROL_STROBE;
	local_irq_restore(flags);
	return control;
}

static void
parport_atari_write_control(struct parport *p, unsigned char control)
{
	unsigned long flags;

	local_irq_save(flags);
	sound_ym.rd_data_reg_sel = 14;
	if (control & PARPORT_CONTROL_STROBE)
		sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~(1 << 5);
	else
		sound_ym.wd_data = sound_ym.rd_data_reg_sel | (1 << 5);
	local_irq_restore(flags);
}

static unsigned char
parport_atari_frob_control(struct parport *p, unsigned char mask,
			   unsigned char val)
{
	unsigned char old = parport_atari_read_control(p);
	parport_atari_write_control(p, (old & ~mask) ^ val);
	return old;
}

static unsigned char
parport_atari_read_status(struct parport *p)
{
	return ((st_mfp.par_dt_reg & 1 ? 0 : PARPORT_STATUS_BUSY) |
		PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR);
}

static void
parport_atari_init_state(struct pardevice *d, struct parport_state *s)
{
}

static void
parport_atari_save_state(struct parport *p, struct parport_state *s)
{
}

static void
parport_atari_restore_state(struct parport *p, struct parport_state *s)
{
}

static void
parport_atari_enable_irq(struct parport *p)
{
	enable_irq(IRQ_MFP_BUSY);
}

static void
parport_atari_disable_irq(struct parport *p)
{
	disable_irq(IRQ_MFP_BUSY);
}

static void
parport_atari_data_forward(struct parport *p)
{
	unsigned long flags;

	local_irq_save(flags);
	/* Soundchip port B as output. */
	sound_ym.rd_data_reg_sel = 7;
	sound_ym.wd_data = sound_ym.rd_data_reg_sel | 0x40;
	local_irq_restore(flags);
}

static void
parport_atari_data_reverse(struct parport *p)
{
#if 0 /* too dangerous, can kill sound chip */
	unsigned long flags;

	local_irq_save(flags);
	/* Soundchip port B as input. */
	sound_ym.rd_data_reg_sel = 7;
	sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~0x40;
	local_irq_restore(flags);
#endif
}

static struct parport_operations parport_atari_ops = {
	.write_data	= parport_atari_write_data,
	.read_data	= parport_atari_read_data,

	.write_control	= parport_atari_write_control,
	.read_control	= parport_atari_read_control,
	.frob_control	= parport_atari_frob_control,

	.read_status	= parport_atari_read_status,

	.enable_irq	= parport_atari_enable_irq,
	.disable_irq	= parport_atari_disable_irq,

	.data_forward	= parport_atari_data_forward,
	.data_reverse	= parport_atari_data_reverse,

	.init_state	= parport_atari_init_state,
	.save_state	= parport_atari_save_state,
	.restore_state	= parport_atari_restore_state,

	.epp_write_data	= parport_ieee1284_epp_write_data,
	.epp_read_data	= parport_ieee1284_epp_read_data,
	.epp_write_addr	= parport_ieee1284_epp_write_addr,
	.epp_read_addr	= parport_ieee1284_epp_read_addr,

	.ecp_write_data	= parport_ieee1284_ecp_write_data,
	.ecp_read_data	= parport_ieee1284_ecp_read_data,
	.ecp_write_addr	= parport_ieee1284_ecp_write_addr,

	.compat_write_data	= parport_ieee1284_write_compat,
	.nibble_read_data	= parport_ieee1284_read_nibble,
	.byte_read_data		= parport_ieee1284_read_byte,

	.owner		= THIS_MODULE,
};


static int __init parport_atari_init(void)
{
	struct parport *p;
	unsigned long flags;

	if (MACH_IS_ATARI) {
		local_irq_save(flags);
		/* Soundchip port A/B as output. */
		sound_ym.rd_data_reg_sel = 7;
		sound_ym.wd_data = (sound_ym.rd_data_reg_sel & 0x3f) | 0xc0;
		/* STROBE high. */
		sound_ym.rd_data_reg_sel = 14;
		sound_ym.wd_data = sound_ym.rd_data_reg_sel | (1 << 5);
		local_irq_restore(flags);
		/* MFP port I0 as input. */
		st_mfp.data_dir &= ~1;
		/* MFP port I0 interrupt on high->low edge. */
		st_mfp.active_edge &= ~1;
		p = parport_register_port((unsigned long)&sound_ym.wd_data,
					  IRQ_MFP_BUSY, PARPORT_DMA_NONE,
					  &parport_atari_ops);
		if (!p)
			return -ENODEV;
		if (request_irq(IRQ_MFP_BUSY, parport_irq_handler,
				IRQ_TYPE_SLOW, p->name, p)) {
			parport_put_port (p);
			return -ENODEV;
		}

		this_port = p;
		printk(KERN_INFO "%s: Atari built-in port using irq\n", p->name);
		parport_announce_port (p);

		return 0;
	}
	return -ENODEV;
}

static void __exit parport_atari_exit(void)
{
	parport_remove_port(this_port);
	if (this_port->irq != PARPORT_IRQ_NONE)
		free_irq(IRQ_MFP_BUSY, this_port);
	parport_put_port(this_port);
}

MODULE_AUTHOR("Andreas Schwab");
MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");
MODULE_SUPPORTED_DEVICE("Atari builtin Parallel Port");
MODULE_LICENSE("GPL");

module_init(parport_atari_init)
module_exit(parport_atari_exit)
Commit	Line	Data
1da177e4 LT	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	{
3d92e8f3	87	return ((st_mfp.par_dt_reg & 1 ? 0 : PARPORT_STATUS_BUSY) \|
1da177e4 LT	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
1da177e4 LT	106	static void
	107	parport_atari_enable_irq(struct parport *p)
	108	{
	109	enable_irq(IRQ_MFP_BUSY);
	110	}
	111
	112	static void
	113	parport_atari_disable_irq(struct parport *p)
	114	{
	115	disable_irq(IRQ_MFP_BUSY);
	116	}
	117
	118	static void
	119	parport_atari_data_forward(struct parport *p)
	120	{
	121	unsigned long flags;
	122
	123	local_irq_save(flags);
	124	/* Soundchip port B as output. */
	125	sound_ym.rd_data_reg_sel = 7;
	126	sound_ym.wd_data = sound_ym.rd_data_reg_sel \| 0x40;
	127	local_irq_restore(flags);
	128	}
	129
	130	static void
	131	parport_atari_data_reverse(struct parport *p)
	132	{
	133	#if 0 /* too dangerous, can kill sound chip */
	134	unsigned long flags;
	135
	136	local_irq_save(flags);
	137	/* Soundchip port B as input. */
	138	sound_ym.rd_data_reg_sel = 7;
	139	sound_ym.wd_data = sound_ym.rd_data_reg_sel & ~0x40;
	140	local_irq_restore(flags);
	141	#endif
	142	}
	143
	144	static struct parport_operations parport_atari_ops = {
	145	.write_data = parport_atari_write_data,
	146	.read_data = parport_atari_read_data,
	147
	148	.write_control = parport_atari_write_control,
	149	.read_control = parport_atari_read_control,
	150	.frob_control = parport_atari_frob_control,
	151
	152	.read_status = parport_atari_read_status,
	153
	154	.enable_irq = parport_atari_enable_irq,
	155	.disable_irq = parport_atari_disable_irq,
	156
	157	.data_forward = parport_atari_data_forward,
	158	.data_reverse = parport_atari_data_reverse,
	159
	160	.init_state = parport_atari_init_state,
	161	.save_state = parport_atari_save_state,
	162	.restore_state = parport_atari_restore_state,
	163
	164	.epp_write_data = parport_ieee1284_epp_write_data,
	165	.epp_read_data = parport_ieee1284_epp_read_data,
	166	.epp_write_addr = parport_ieee1284_epp_write_addr,
	167	.epp_read_addr = parport_ieee1284_epp_read_addr,
	168
	169	.ecp_write_data = parport_ieee1284_ecp_write_data,
170	.ecp_read_data = parport_ieee1284_ecp_read_data,
171	.ecp_write_addr = parport_ieee1284_ecp_write_addr,
172
173	.compat_write_data = parport_ieee1284_write_compat,
174	.nibble_read_data = parport_ieee1284_read_nibble,
175	.byte_read_data = parport_ieee1284_read_byte,
176
177	.owner = THIS_MODULE,
178	};
179
180
181	static int __init parport_atari_init(void)
182	{
183	struct parport *p;
184	unsigned long flags;
185
186	if (MACH_IS_ATARI) {
187	local_irq_save(flags);
188	/* Soundchip port A/B as output. */
189	sound_ym.rd_data_reg_sel = 7;
190	sound_ym.wd_data = (sound_ym.rd_data_reg_sel & 0x3f) \| 0xc0;
191	/* STROBE high. */
192	sound_ym.rd_data_reg_sel = 14;
193	sound_ym.wd_data = sound_ym.rd_data_reg_sel \| (1 << 5);
194	local_irq_restore(flags);
195	/* MFP port I0 as input. */
3d92e8f3	196	st_mfp.data_dir &= ~1;
1da177e4	197	/* MFP port I0 interrupt on high->low edge. */
3d92e8f3	198	st_mfp.active_edge &= ~1;
1da177e4 LT	199	p = parport_register_port((unsigned long)&sound_ym.wd_data,
	200	IRQ_MFP_BUSY, PARPORT_DMA_NONE,
	201	&parport_atari_ops);
	202	if (!p)
	203	return -ENODEV;
3f2e40df	204	if (request_irq(IRQ_MFP_BUSY, parport_irq_handler,
1da177e4 LT	205	IRQ_TYPE_SLOW, p->name, p)) {
	206	parport_put_port (p);
	207	return -ENODEV;
	208	}
	209
	210	this_port = p;
	211	printk(KERN_INFO "%s: Atari built-in port using irq\n", p->name);
	212	parport_announce_port (p);
	213
	214	return 0;
	215	}
	216	return -ENODEV;
	217	}
	218
	219	static void __exit parport_atari_exit(void)
	220	{
	221	parport_remove_port(this_port);
	222	if (this_port->irq != PARPORT_IRQ_NONE)
	223	free_irq(IRQ_MFP_BUSY, this_port);
	224	parport_put_port(this_port);
	225	}
	226
	227	MODULE_AUTHOR("Andreas Schwab");
	228	MODULE_DESCRIPTION("Parport Driver for Atari builtin Port");
	229	MODULE_SUPPORTED_DEVICE("Atari builtin Parallel Port");
	230	MODULE_LICENSE("GPL");
	231
	232	module_init(parport_atari_init)
	233	module_exit(parport_atari_exit)