[linux.git] / drivers / parport / parport_ax88796.c

/* linux/drivers/parport/parport_ax88796.c
 *
 * (c) 2005,2006 Simtec Electronics
 *	Ben Dooks <[email protected]>
 *
 * 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 <linux/slab.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 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;
	struct resource *res;
	unsigned long size;
	int spacing;
	int irq;
	int ret;

	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
	if (!dd)
		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 = resource_size(res);
	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_irq_handler,
				  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_mem_region(dd->io->start, size);
 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_mem_region(dd->io->start, resource_size(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

MODULE_ALIAS("platform:ax88796-pp");

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

module_platform_driver(axdrv);

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