[PATCH] irq-flags: misc drivers: Use the new IRQF_ constants
[linux-2.6.git] / drivers / parport / parport_ax88796.c
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
236 parport_ax88796_interrupt(int irq, void *dev_id, struct pt_regs *regs)
237 {
238         parport_generic_irq(irq, dev_id, regs);
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,
348                                   IRQF_TRIGGER_FALLING, pdev->name, pp);
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");