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

/* linux/drivers/parport/parport_ax88796.c
 *
 * (c) 2005,2006 Simtec Electronics
 *	Ben Dooks <ben@simtec.co.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
*/

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/parport.h>
#include <linux/interrupt.h>
#include <linux/errno.h>
#include <linux/platform_device.h>

#include <asm/io.h>
#include <asm/irq.h>

#define AX_SPR_BUSY		(1<<7)
#define AX_SPR_ACK		(1<<6)
#define AX_SPR_PE		(1<<5)
#define AX_SPR_SLCT		(1<<4)
#define AX_SPR_ERR		(1<<3)

#define AX_CPR_nDOE		(1<<5)
#define AX_CPR_SLCTIN		(1<<3)
#define AX_CPR_nINIT		(1<<2)
#define AX_CPR_ATFD		(1<<1)
#define AX_CPR_STRB		(1<<0)

struct ax_drvdata {
	struct parport		*parport;
	struct parport_state	 suspend;

	struct device		*dev;
	struct resource		*io;

	unsigned char		 irq_enabled;

	void __iomem		*base;
	void __iomem		*spp_data;
	void __iomem		*spp_spr;
	void __iomem		*spp_cpr;
};

static inline struct ax_drvdata *pp_to_drv(struct parport *p)
{
	return p->private_data;
}

static unsigned char
parport_ax88796_read_data(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);

	return readb(dd->spp_data);
}

static void
parport_ax88796_write_data(struct parport *p, unsigned char data)
{
	struct ax_drvdata *dd = pp_to_drv(p);

	writeb(data, dd->spp_data);
}

static unsigned char
parport_ax88796_read_control(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	unsigned int cpr = readb(dd->spp_cpr);
	unsigned int ret = 0;

	if (!(cpr & AX_CPR_STRB))
		ret |= PARPORT_CONTROL_STROBE;

	if (!(cpr & AX_CPR_ATFD))
		ret |= PARPORT_CONTROL_AUTOFD;

	if (cpr & AX_CPR_nINIT)
		ret |= PARPORT_CONTROL_INIT;

	if (!(cpr & AX_CPR_SLCTIN))
		ret |= PARPORT_CONTROL_SELECT;

	return ret;
}

static void
parport_ax88796_write_control(struct parport *p, unsigned char control)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	unsigned int cpr = readb(dd->spp_cpr);

	cpr &= AX_CPR_nDOE;

	if (!(control & PARPORT_CONTROL_STROBE))
		cpr |= AX_CPR_STRB;

	if (!(control & PARPORT_CONTROL_AUTOFD))
		cpr |= AX_CPR_ATFD;

	if (control & PARPORT_CONTROL_INIT)
		cpr |= AX_CPR_nINIT;

	if (!(control & PARPORT_CONTROL_SELECT))
		cpr |= AX_CPR_SLCTIN;

	dev_dbg(dd->dev, "write_control: ctrl=%02x, cpr=%02x\n", control, cpr);
	writeb(cpr, dd->spp_cpr);

	if (parport_ax88796_read_control(p) != control) {
		dev_err(dd->dev, "write_control: read != set (%02x, %02x)\n",
			parport_ax88796_read_control(p), control);
	}
}

static unsigned char
parport_ax88796_read_status(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	unsigned int status = readb(dd->spp_spr);
	unsigned int ret = 0;

	if (status & AX_SPR_BUSY)
		ret |= PARPORT_STATUS_BUSY;

	if (status & AX_SPR_ACK)
		ret |= PARPORT_STATUS_ACK;

	if (status & AX_SPR_ERR)
		ret |= PARPORT_STATUS_ERROR;

	if (status & AX_SPR_SLCT)
		ret |= PARPORT_STATUS_SELECT;

	if (status & AX_SPR_PE)
		ret |= PARPORT_STATUS_PAPEROUT;

	return ret;
}

static unsigned char
parport_ax88796_frob_control(struct parport *p, unsigned char mask,
			     unsigned char val)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	unsigned char old = parport_ax88796_read_control(p);

	dev_dbg(dd->dev, "frob: mask=%02x, val=%02x, old=%02x\n",
		mask, val, old);

	parport_ax88796_write_control(p, (old & ~mask) | val);
	return old;
}

static void
parport_ax88796_enable_irq(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	unsigned long flags;

	local_irq_save(flags);
	if (!dd->irq_enabled) {
		enable_irq(p->irq);
		dd->irq_enabled = 1;
	}
	local_irq_restore(flags);
}

static void
parport_ax88796_disable_irq(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	unsigned long flags;

	local_irq_save(flags);
	if (dd->irq_enabled) {
		disable_irq(p->irq);
		dd->irq_enabled = 0;
	}
	local_irq_restore(flags);
}

static void
parport_ax88796_data_forward(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	void __iomem *cpr = dd->spp_cpr;

	writeb((readb(cpr) & ~AX_CPR_nDOE), cpr);
}

static void
parport_ax88796_data_reverse(struct parport *p)
{
	struct ax_drvdata *dd = pp_to_drv(p);
	void __iomem *cpr = dd->spp_cpr;

	writeb(readb(cpr) | AX_CPR_nDOE, cpr);
}

static void
parport_ax88796_init_state(struct pardevice *d, struct parport_state *s)
{
	struct ax_drvdata *dd = pp_to_drv(d->port);

	memset(s, 0, sizeof(struct parport_state));

	dev_dbg(dd->dev, "init_state: %p: state=%p\n", d, s);
	s->u.ax88796.cpr = readb(dd->spp_cpr);
}

static void
parport_ax88796_save_state(struct parport *p, struct parport_state *s)
{
	struct ax_drvdata *dd = pp_to_drv(p);

	dev_dbg(dd->dev, "save_state: %p: state=%p\n", p, s);
	s->u.ax88796.cpr = readb(dd->spp_cpr);
}

static void
parport_ax88796_restore_state(struct parport *p, struct parport_state *s)
{
	struct ax_drvdata *dd = pp_to_drv(p);

	dev_dbg(dd->dev, "restore_state: %p: state=%p\n", p, s);
	writeb(s->u.ax88796.cpr, dd->spp_cpr);
}

static irqreturn_t
parport_ax88796_interrupt(int irq, void *dev_id)
{
        parport_generic_irq(irq, dev_id);
        return IRQ_HANDLED;
}


static struct parport_operations parport_ax88796_ops = {
	.write_data	= parport_ax88796_write_data,
	.read_data	= parport_ax88796_read_data,

	.write_control	= parport_ax88796_write_control,
	.read_control	= parport_ax88796_read_control,
	.frob_control	= parport_ax88796_frob_control,

	.read_status	= parport_ax88796_read_status,

	.enable_irq	= parport_ax88796_enable_irq,
	.disable_irq	= parport_ax88796_disable_irq,

	.data_forward	= parport_ax88796_data_forward,
	.data_reverse	= parport_ax88796_data_reverse,

	.init_state	= parport_ax88796_init_state,
	.save_state	= parport_ax88796_save_state,
	.restore_state	= parport_ax88796_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 parport_ax88796_probe(struct platform_device *pdev)
{
	struct device *_dev = &pdev->dev;
	struct ax_drvdata *dd;
	struct parport *pp = NULL;
	struct resource *res;
	unsigned long size;
	int spacing;
	int irq;
	int ret;

	dd = kzalloc(sizeof(struct ax_drvdata), GFP_KERNEL);
	if (dd == NULL) {
		dev_err(_dev, "no memory for private data\n");
		return -ENOMEM;
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(_dev, "no MEM specified\n");
		ret = -ENXIO;
		goto exit_mem;
	}

	size = (res->end - res->start) + 1;
	spacing = size / 3;

	dd->io = request_mem_region(res->start, size, pdev->name);
	if (dd->io == NULL) {
		dev_err(_dev, "cannot reserve memory\n");
		ret = -ENXIO;
		goto exit_mem;
	}

	dd->base = ioremap(res->start, size);
	if (dd->base == NULL) {
		dev_err(_dev, "cannot ioremap region\n");
		ret = -ENXIO;
		goto exit_res;
	}

	irq = platform_get_irq(pdev, 0);
	if (irq <= 0)
		irq = PARPORT_IRQ_NONE;

	pp = parport_register_port((unsigned long)dd->base, irq,
				   PARPORT_DMA_NONE,
				   &parport_ax88796_ops);

	if (pp == NULL) {
		dev_err(_dev, "failed to register parallel port\n");
		ret = -ENOMEM;
		goto exit_unmap;
	}

	pp->private_data = dd;
	dd->parport = pp;
	dd->dev = _dev;

	dd->spp_data = dd->base;
	dd->spp_spr  = dd->base + (spacing * 1);
	dd->spp_cpr  = dd->base + (spacing * 2);

	/* initialise the port controls */
	writeb(AX_CPR_STRB, dd->spp_cpr);

	if (irq >= 0) {
		/* request irq */
		ret = request_irq(irq, parport_ax88796_interrupt,
				  IRQF_TRIGGER_FALLING, pdev->name, pp);

		if (ret < 0)
			goto exit_port;

		dd->irq_enabled = 1;
	}

	platform_set_drvdata(pdev, pp);

	dev_info(_dev, "attached parallel port driver\n");
	parport_announce_port(pp);

	return 0;

 exit_port:
	parport_remove_port(pp);
 exit_unmap:
	iounmap(dd->base);
 exit_res:
	release_resource(dd->io);
	kfree(dd->io);
 exit_mem:
	kfree(dd);
	return ret;
}

static int parport_ax88796_remove(struct platform_device *pdev)
{
	struct parport *p = platform_get_drvdata(pdev);
	struct ax_drvdata *dd = pp_to_drv(p);

	free_irq(p->irq, p);
	parport_remove_port(p);
	iounmap(dd->base);
	release_resource(dd->io);
	kfree(dd->io);
	kfree(dd);

	return 0;
}

#ifdef CONFIG_PM

static int parport_ax88796_suspend(struct platform_device *dev,
				   pm_message_t state)
{
	struct parport *p = platform_get_drvdata(dev);
	struct ax_drvdata *dd = pp_to_drv(p);

	parport_ax88796_save_state(p, &dd->suspend);
	writeb(AX_CPR_nDOE | AX_CPR_STRB, dd->spp_cpr);
	return 0;
}

static int parport_ax88796_resume(struct platform_device *dev)
{
	struct parport *p = platform_get_drvdata(dev);
	struct ax_drvdata *dd = pp_to_drv(p);

	parport_ax88796_restore_state(p, &dd->suspend);
	return 0;
}

#else
#define parport_ax88796_suspend NULL
#define parport_ax88796_resume  NULL
#endif

static struct platform_driver axdrv = {
	.driver		= {
		.name	= "ax88796-pp",
		.owner	= THIS_MODULE,
	},
	.probe		= parport_ax88796_probe,
	.remove		= parport_ax88796_remove,
	.suspend	= parport_ax88796_suspend,
	.resume		= parport_ax88796_resume,
};

static int __init parport_ax88796_init(void)
{
	return platform_driver_register(&axdrv);
}

static void __exit parport_ax88796_exit(void)
{
	platform_driver_unregister(&axdrv);
}

module_init(parport_ax88796_init)
module_exit(parport_ax88796_exit)

MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
MODULE_DESCRIPTION("AX88796 Parport parallel port driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
ad4063b0 BD	1	/* linux/drivers/parport/parport_ax88796.c
	2	*
	3	* (c) 2005,2006 Simtec Electronics
	4	* Ben Dooks <ben@simtec.co.uk>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/kernel.h>
	14	#include <linux/parport.h>
	15	#include <linux/interrupt.h>
	16	#include <linux/errno.h>
	17	#include <linux/platform_device.h>
	18
	19	#include <asm/io.h>
	20	#include <asm/irq.h>
	21
	22	#define AX_SPR_BUSY (1<<7)
	23	#define AX_SPR_ACK (1<<6)
	24	#define AX_SPR_PE (1<<5)
	25	#define AX_SPR_SLCT (1<<4)
	26	#define AX_SPR_ERR (1<<3)
	27
	28	#define AX_CPR_nDOE (1<<5)
	29	#define AX_CPR_SLCTIN (1<<3)
	30	#define AX_CPR_nINIT (1<<2)
	31	#define AX_CPR_ATFD (1<<1)
	32	#define AX_CPR_STRB (1<<0)
	33
	34	struct ax_drvdata {
	35	struct parport *parport;
	36	struct parport_state suspend;
	37
	38	struct device *dev;
	39	struct resource *io;
	40
	41	unsigned char irq_enabled;
	42
	43	void __iomem *base;
	44	void __iomem *spp_data;
	45	void __iomem *spp_spr;
	46	void __iomem *spp_cpr;
	47	};
	48
	49	static inline struct ax_drvdata pp_to_drv(struct parport p)
	50	{
	51	return p->private_data;
	52	}
	53
	54	static unsigned char
	55	parport_ax88796_read_data(struct parport *p)
	56	{
	57	struct ax_drvdata *dd = pp_to_drv(p);
	58
	59	return readb(dd->spp_data);
	60	}
	61
	62	static void
	63	parport_ax88796_write_data(struct parport *p, unsigned char data)
	64	{
65	struct ax_drvdata *dd = pp_to_drv(p);
66
67	writeb(data, dd->spp_data);
68	}
69
70	static unsigned char
71	parport_ax88796_read_control(struct parport *p)
72	{
73	struct ax_drvdata *dd = pp_to_drv(p);
74	unsigned int cpr = readb(dd->spp_cpr);
75	unsigned int ret = 0;
76
77	if (!(cpr & AX_CPR_STRB))
78	ret \|= PARPORT_CONTROL_STROBE;
79
80	if (!(cpr & AX_CPR_ATFD))
81	ret \|= PARPORT_CONTROL_AUTOFD;
82
83	if (cpr & AX_CPR_nINIT)
84	ret \|= PARPORT_CONTROL_INIT;
85
86	if (!(cpr & AX_CPR_SLCTIN))
87	ret \|= PARPORT_CONTROL_SELECT;
88
89	return ret;
90	}
91
92	static void
93	parport_ax88796_write_control(struct parport *p, unsigned char control)
94	{
95	struct ax_drvdata *dd = pp_to_drv(p);
96	unsigned int cpr = readb(dd->spp_cpr);
97
98	cpr &= AX_CPR_nDOE;
99
100	if (!(control & PARPORT_CONTROL_STROBE))
101	cpr \|= AX_CPR_STRB;
102
103	if (!(control & PARPORT_CONTROL_AUTOFD))
104	cpr \|= AX_CPR_ATFD;
105
106	if (control & PARPORT_CONTROL_INIT)
107	cpr \|= AX_CPR_nINIT;
108
109	if (!(control & PARPORT_CONTROL_SELECT))
110	cpr \|= AX_CPR_SLCTIN;
111
112	dev_dbg(dd->dev, "write_control: ctrl=%02x, cpr=%02x\n", control, cpr);
113	writeb(cpr, dd->spp_cpr);
114
115	if (parport_ax88796_read_control(p) != control) {
116	dev_err(dd->dev, "write_control: read != set (%02x, %02x)\n",
117	parport_ax88796_read_control(p), control);
118	}
119	}
120
121	static unsigned char
122	parport_ax88796_read_status(struct parport *p)
123	{
124	struct ax_drvdata *dd = pp_to_drv(p);
125	unsigned int status = readb(dd->spp_spr);
126	unsigned int ret = 0;
127
128	if (status & AX_SPR_BUSY)
129	ret \|= PARPORT_STATUS_BUSY;
130
131	if (status & AX_SPR_ACK)
132	ret \|= PARPORT_STATUS_ACK;
133
134	if (status & AX_SPR_ERR)
135	ret \|= PARPORT_STATUS_ERROR;
136
137	if (status & AX_SPR_SLCT)
138	ret \|= PARPORT_STATUS_SELECT;
139
140	if (status & AX_SPR_PE)
141	ret \|= PARPORT_STATUS_PAPEROUT;
142
143	return ret;
144	}
145
146	static unsigned char
147	parport_ax88796_frob_control(struct parport *p, unsigned char mask,
148	unsigned char val)
149	{
150	struct ax_drvdata *dd = pp_to_drv(p);
151	unsigned char old = parport_ax88796_read_control(p);
152
153	dev_dbg(dd->dev, "frob: mask=%02x, val=%02x, old=%02x\n",
154	mask, val, old);
155
156	parport_ax88796_write_control(p, (old & ~mask) \| val);
157	return old;
158	}
159
160	static void
161	parport_ax88796_enable_irq(struct parport *p)
162	{
163	struct ax_drvdata *dd = pp_to_drv(p);
164	unsigned long flags;
165
166	local_irq_save(flags);
167	if (!dd->irq_enabled) {
168	enable_irq(p->irq);
169	dd->irq_enabled = 1;
170	}
171	local_irq_restore(flags);
172	}
173
174	static void
175	parport_ax88796_disable_irq(struct parport *p)
176	{
177	struct ax_drvdata *dd = pp_to_drv(p);
178	unsigned long flags;
179
180	local_irq_save(flags);
181	if (dd->irq_enabled) {
182	disable_irq(p->irq);
183	dd->irq_enabled = 0;
184	}
185	local_irq_restore(flags);
186	}
187
188	static void
189	parport_ax88796_data_forward(struct parport *p)
190	{
191	struct ax_drvdata *dd = pp_to_drv(p);
192	void __iomem *cpr = dd->spp_cpr;
193
194	writeb((readb(cpr) & ~AX_CPR_nDOE), cpr);
195	}
196
197	static void
198	parport_ax88796_data_reverse(struct parport *p)
199	{
200	struct ax_drvdata *dd = pp_to_drv(p);
201	void __iomem *cpr = dd->spp_cpr;
202
203	writeb(readb(cpr) \| AX_CPR_nDOE, cpr);
204	}
205
206	static void
207	parport_ax88796_init_state(struct pardevice d, struct parport_state s)
208	{
209	struct ax_drvdata *dd = pp_to_drv(d->port);
210
211	memset(s, 0, sizeof(struct parport_state));
212
213	dev_dbg(dd->dev, "init_state: %p: state=%p\n", d, s);
214	s->u.ax88796.cpr = readb(dd->spp_cpr);
215	}
216
217	static void
218	parport_ax88796_save_state(struct parport p, struct parport_state s)
219	{
220	struct ax_drvdata *dd = pp_to_drv(p);
221
222	dev_dbg(dd->dev, "save_state: %p: state=%p\n", p, s);
223	s->u.ax88796.cpr = readb(dd->spp_cpr);
224	}
225
226	static void
227	parport_ax88796_restore_state(struct parport p, struct parport_state s)
228	{
229	struct ax_drvdata *dd = pp_to_drv(p);
230
231	dev_dbg(dd->dev, "restore_state: %p: state=%p\n", p, s);
232	writeb(s->u.ax88796.cpr, dd->spp_cpr);
233	}
234
235	static irqreturn_t
7d12e780	236	parport_ax88796_interrupt(int irq, void *dev_id)
ad4063b0	237	{
7d12e780	238	parport_generic_irq(irq, dev_id);
ad4063b0 BD	239	return IRQ_HANDLED;
	240	}
	241
	242
	243	static struct parport_operations parport_ax88796_ops = {
	244	.write_data = parport_ax88796_write_data,
	245	.read_data = parport_ax88796_read_data,
	246
	247	.write_control = parport_ax88796_write_control,
	248	.read_control = parport_ax88796_read_control,
	249	.frob_control = parport_ax88796_frob_control,
	250
	251	.read_status = parport_ax88796_read_status,
	252
	253	.enable_irq = parport_ax88796_enable_irq,
	254	.disable_irq = parport_ax88796_disable_irq,
	255
	256	.data_forward = parport_ax88796_data_forward,
	257	.data_reverse = parport_ax88796_data_reverse,
	258
	259	.init_state = parport_ax88796_init_state,
	260	.save_state = parport_ax88796_save_state,
	261	.restore_state = parport_ax88796_restore_state,
	262
	263	.epp_write_data = parport_ieee1284_epp_write_data,
	264	.epp_read_data = parport_ieee1284_epp_read_data,
	265	.epp_write_addr = parport_ieee1284_epp_write_addr,
	266	.epp_read_addr = parport_ieee1284_epp_read_addr,
	267
	268	.ecp_write_data = parport_ieee1284_ecp_write_data,
	269	.ecp_read_data = parport_ieee1284_ecp_read_data,
	270	.ecp_write_addr = parport_ieee1284_ecp_write_addr,
	271
	272	.compat_write_data = parport_ieee1284_write_compat,
	273	.nibble_read_data = parport_ieee1284_read_nibble,
	274	.byte_read_data = parport_ieee1284_read_byte,
	275
	276	.owner = THIS_MODULE,
	277	};
	278
	279	static int parport_ax88796_probe(struct platform_device *pdev)
	280	{
	281	struct device *_dev = &pdev->dev;
	282	struct ax_drvdata *dd;
	283	struct parport *pp = NULL;
	284	struct resource *res;
	285	unsigned long size;
	286	int spacing;
	287	int irq;
	288	int ret;
	289
	290	dd = kzalloc(sizeof(struct ax_drvdata), GFP_KERNEL);
	291	if (dd == NULL) {
	292	dev_err(_dev, "no memory for private data\n");
	293	return -ENOMEM;
	294	}
	295
	296	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	297	if (res == NULL) {
	298	dev_err(_dev, "no MEM specified\n");
	299	ret = -ENXIO;
	300	goto exit_mem;
	301	}
	302
303	size = (res->end - res->start) + 1;
304	spacing = size / 3;
305
306	dd->io = request_mem_region(res->start, size, pdev->name);
307	if (dd->io == NULL) {
308	dev_err(_dev, "cannot reserve memory\n");
309	ret = -ENXIO;
310	goto exit_mem;
311	}
312
313	dd->base = ioremap(res->start, size);
314	if (dd->base == NULL) {
315	dev_err(_dev, "cannot ioremap region\n");
316	ret = -ENXIO;
317	goto exit_res;
318	}
319
320	irq = platform_get_irq(pdev, 0);
321	if (irq <= 0)
322	irq = PARPORT_IRQ_NONE;
323
324	pp = parport_register_port((unsigned long)dd->base, irq,
325	PARPORT_DMA_NONE,
326	&parport_ax88796_ops);
327
328	if (pp == NULL) {
329	dev_err(_dev, "failed to register parallel port\n");
330	ret = -ENOMEM;
331	goto exit_unmap;
332	}
333
334	pp->private_data = dd;
335	dd->parport = pp;
336	dd->dev = _dev;
337
338	dd->spp_data = dd->base;
339	dd->spp_spr = dd->base + (spacing * 1);
340	dd->spp_cpr = dd->base + (spacing * 2);
341
342	/* initialise the port controls */
343	writeb(AX_CPR_STRB, dd->spp_cpr);
344
345	if (irq >= 0) {
346	/* request irq */
347	ret = request_irq(irq, parport_ax88796_interrupt,
dace1453	348	IRQF_TRIGGER_FALLING, pdev->name, pp);
ad4063b0 BD	349
	350	if (ret < 0)
	351	goto exit_port;
	352
	353	dd->irq_enabled = 1;
	354	}
	355
	356	platform_set_drvdata(pdev, pp);
	357
	358	dev_info(_dev, "attached parallel port driver\n");
	359	parport_announce_port(pp);
	360
	361	return 0;
	362
	363	exit_port:
	364	parport_remove_port(pp);
	365	exit_unmap:
	366	iounmap(dd->base);
	367	exit_res:
	368	release_resource(dd->io);
	369	kfree(dd->io);
	370	exit_mem:
	371	kfree(dd);
	372	return ret;
	373	}
	374
	375	static int parport_ax88796_remove(struct platform_device *pdev)
	376	{
	377	struct parport *p = platform_get_drvdata(pdev);
	378	struct ax_drvdata *dd = pp_to_drv(p);
	379
	380	free_irq(p->irq, p);
	381	parport_remove_port(p);
	382	iounmap(dd->base);
	383	release_resource(dd->io);
	384	kfree(dd->io);
	385	kfree(dd);
	386
	387	return 0;
	388	}
	389
	390	#ifdef CONFIG_PM
	391
	392	static int parport_ax88796_suspend(struct platform_device *dev,
	393	pm_message_t state)
	394	{
	395	struct parport *p = platform_get_drvdata(dev);
	396	struct ax_drvdata *dd = pp_to_drv(p);
	397
	398	parport_ax88796_save_state(p, &dd->suspend);
	399	writeb(AX_CPR_nDOE \| AX_CPR_STRB, dd->spp_cpr);
	400	return 0;
	401	}
	402
	403	static int parport_ax88796_resume(struct platform_device *dev)
	404	{
	405	struct parport *p = platform_get_drvdata(dev);
	406	struct ax_drvdata *dd = pp_to_drv(p);
	407
	408	parport_ax88796_restore_state(p, &dd->suspend);
	409	return 0;
	410	}
	411
	412	#else
413	#define parport_ax88796_suspend NULL
414	#define parport_ax88796_resume NULL
415	#endif
416
417	static struct platform_driver axdrv = {
418	.driver = {
419	.name = "ax88796-pp",
420	.owner = THIS_MODULE,
421	},
422	.probe = parport_ax88796_probe,
423	.remove = parport_ax88796_remove,
424	.suspend = parport_ax88796_suspend,
425	.resume = parport_ax88796_resume,
426	};
427
428	static int __init parport_ax88796_init(void)
429	{
430	return platform_driver_register(&axdrv);
431	}
432
433	static void __exit parport_ax88796_exit(void)
434	{
435	platform_driver_unregister(&axdrv);
436	}
437
438	module_init(parport_ax88796_init)
439	module_exit(parport_ax88796_exit)
440
441	MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
442	MODULE_DESCRIPTION("AX88796 Parport parallel port driver");
443	MODULE_LICENSE("GPL");