blob: 4ec220b2eae7dba0bf61481931209fbc08f8d2fc [file] [log] [blame]
Ben Dooksad4063b2006-06-25 05:48:03 -07001/* 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
34struct 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
49static inline struct ax_drvdata *pp_to_drv(struct parport *p)
50{
51 return p->private_data;
52}
53
54static unsigned char
55parport_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
62static void
63parport_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
70static unsigned char
71parport_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
92static void
93parport_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
121static unsigned char
122parport_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
146static unsigned char
147parport_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
160static void
161parport_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
174static void
175parport_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
188static void
189parport_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
197static void
198parport_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
206static void
207parport_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
217static void
218parport_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
226static void
227parport_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
Ben Dooksad4063b2006-06-25 05:48:03 -0700235static struct parport_operations parport_ax88796_ops = {
236 .write_data = parport_ax88796_write_data,
237 .read_data = parport_ax88796_read_data,
238
239 .write_control = parport_ax88796_write_control,
240 .read_control = parport_ax88796_read_control,
241 .frob_control = parport_ax88796_frob_control,
242
243 .read_status = parport_ax88796_read_status,
244
245 .enable_irq = parport_ax88796_enable_irq,
246 .disable_irq = parport_ax88796_disable_irq,
247
248 .data_forward = parport_ax88796_data_forward,
249 .data_reverse = parport_ax88796_data_reverse,
250
251 .init_state = parport_ax88796_init_state,
252 .save_state = parport_ax88796_save_state,
253 .restore_state = parport_ax88796_restore_state,
254
255 .epp_write_data = parport_ieee1284_epp_write_data,
256 .epp_read_data = parport_ieee1284_epp_read_data,
257 .epp_write_addr = parport_ieee1284_epp_write_addr,
258 .epp_read_addr = parport_ieee1284_epp_read_addr,
259
260 .ecp_write_data = parport_ieee1284_ecp_write_data,
261 .ecp_read_data = parport_ieee1284_ecp_read_data,
262 .ecp_write_addr = parport_ieee1284_ecp_write_addr,
263
264 .compat_write_data = parport_ieee1284_write_compat,
265 .nibble_read_data = parport_ieee1284_read_nibble,
266 .byte_read_data = parport_ieee1284_read_byte,
267
268 .owner = THIS_MODULE,
269};
270
271static int parport_ax88796_probe(struct platform_device *pdev)
272{
273 struct device *_dev = &pdev->dev;
274 struct ax_drvdata *dd;
275 struct parport *pp = NULL;
276 struct resource *res;
277 unsigned long size;
278 int spacing;
279 int irq;
280 int ret;
281
282 dd = kzalloc(sizeof(struct ax_drvdata), GFP_KERNEL);
283 if (dd == NULL) {
284 dev_err(_dev, "no memory for private data\n");
285 return -ENOMEM;
286 }
287
288 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
289 if (res == NULL) {
290 dev_err(_dev, "no MEM specified\n");
291 ret = -ENXIO;
292 goto exit_mem;
293 }
294
295 size = (res->end - res->start) + 1;
296 spacing = size / 3;
297
298 dd->io = request_mem_region(res->start, size, pdev->name);
299 if (dd->io == NULL) {
300 dev_err(_dev, "cannot reserve memory\n");
301 ret = -ENXIO;
302 goto exit_mem;
303 }
304
305 dd->base = ioremap(res->start, size);
306 if (dd->base == NULL) {
307 dev_err(_dev, "cannot ioremap region\n");
308 ret = -ENXIO;
309 goto exit_res;
310 }
311
312 irq = platform_get_irq(pdev, 0);
313 if (irq <= 0)
314 irq = PARPORT_IRQ_NONE;
315
316 pp = parport_register_port((unsigned long)dd->base, irq,
317 PARPORT_DMA_NONE,
318 &parport_ax88796_ops);
319
320 if (pp == NULL) {
321 dev_err(_dev, "failed to register parallel port\n");
322 ret = -ENOMEM;
323 goto exit_unmap;
324 }
325
326 pp->private_data = dd;
327 dd->parport = pp;
328 dd->dev = _dev;
329
330 dd->spp_data = dd->base;
331 dd->spp_spr = dd->base + (spacing * 1);
332 dd->spp_cpr = dd->base + (spacing * 2);
333
334 /* initialise the port controls */
335 writeb(AX_CPR_STRB, dd->spp_cpr);
336
337 if (irq >= 0) {
338 /* request irq */
Jeff Garzik3f2e40d2007-10-19 01:42:14 -0400339 ret = request_irq(irq, parport_irq_handler,
Thomas Gleixnerdace1452006-07-01 19:29:38 -0700340 IRQF_TRIGGER_FALLING, pdev->name, pp);
Ben Dooksad4063b2006-06-25 05:48:03 -0700341
342 if (ret < 0)
343 goto exit_port;
344
345 dd->irq_enabled = 1;
346 }
347
348 platform_set_drvdata(pdev, pp);
349
350 dev_info(_dev, "attached parallel port driver\n");
351 parport_announce_port(pp);
352
353 return 0;
354
355 exit_port:
356 parport_remove_port(pp);
357 exit_unmap:
358 iounmap(dd->base);
359 exit_res:
360 release_resource(dd->io);
361 kfree(dd->io);
362 exit_mem:
363 kfree(dd);
364 return ret;
365}
366
367static int parport_ax88796_remove(struct platform_device *pdev)
368{
369 struct parport *p = platform_get_drvdata(pdev);
370 struct ax_drvdata *dd = pp_to_drv(p);
371
372 free_irq(p->irq, p);
373 parport_remove_port(p);
374 iounmap(dd->base);
375 release_resource(dd->io);
376 kfree(dd->io);
377 kfree(dd);
378
379 return 0;
380}
381
382#ifdef CONFIG_PM
383
384static int parport_ax88796_suspend(struct platform_device *dev,
385 pm_message_t state)
386{
387 struct parport *p = platform_get_drvdata(dev);
388 struct ax_drvdata *dd = pp_to_drv(p);
389
390 parport_ax88796_save_state(p, &dd->suspend);
391 writeb(AX_CPR_nDOE | AX_CPR_STRB, dd->spp_cpr);
392 return 0;
393}
394
395static int parport_ax88796_resume(struct platform_device *dev)
396{
397 struct parport *p = platform_get_drvdata(dev);
398 struct ax_drvdata *dd = pp_to_drv(p);
399
400 parport_ax88796_restore_state(p, &dd->suspend);
401 return 0;
402}
403
404#else
405#define parport_ax88796_suspend NULL
406#define parport_ax88796_resume NULL
407#endif
408
409static struct platform_driver axdrv = {
410 .driver = {
411 .name = "ax88796-pp",
412 .owner = THIS_MODULE,
413 },
414 .probe = parport_ax88796_probe,
415 .remove = parport_ax88796_remove,
416 .suspend = parport_ax88796_suspend,
417 .resume = parport_ax88796_resume,
418};
419
420static int __init parport_ax88796_init(void)
421{
422 return platform_driver_register(&axdrv);
423}
424
425static void __exit parport_ax88796_exit(void)
426{
427 platform_driver_unregister(&axdrv);
428}
429
430module_init(parport_ax88796_init)
431module_exit(parport_ax88796_exit)
432
433MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
434MODULE_DESCRIPTION("AX88796 Parport parallel port driver");
435MODULE_LICENSE("GPL");