[SERIAL] PARPORT_SERIAL should depend on SERIAL_8250_PCI
[linux-2.6.git] / drivers / parport / parport_sunbpp.c
1 /* $Id: parport_sunbpp.c,v 1.12 2001/05/26 03:01:42 davem Exp $
2  * Parallel-port routines for Sun architecture
3  * 
4  * Author: Derrick J. Brashear <shadow@dementia.org>
5  *
6  * based on work by:
7  *          Phil Blundell <philb@gnu.org>
8  *          Tim Waugh <tim@cyberelk.demon.co.uk>
9  *          Jose Renau <renau@acm.org>
10  *          David Campbell <campbell@tirian.che.curtin.edu.au>
11  *          Grant Guenther <grant@torque.net>
12  *          Eddie C. Dost <ecd@skynet.be>
13  *          Stephen Williams (steve@icarus.com)
14  *          Gus Baldauf (gbaldauf@ix.netcom.com)
15  *          Peter Zaitcev
16  *          Tom Dyas
17  */
18
19 #include <linux/string.h>
20 #include <linux/module.h>
21 #include <linux/delay.h>
22 #include <linux/errno.h>
23 #include <linux/ioport.h>
24 #include <linux/kernel.h>
25 #include <linux/slab.h>
26 #include <linux/init.h>
27
28 #include <linux/parport.h>
29
30 #include <asm/ptrace.h>
31 #include <linux/interrupt.h>
32
33 #include <asm/io.h>
34 #include <asm/oplib.h>           /* OpenProm Library */
35 #include <asm/sbus.h>
36 #include <asm/dma.h>             /* BPP uses LSI 64854 for DMA */
37 #include <asm/irq.h>
38 #include <asm/sunbpp.h>
39
40 #undef __SUNBPP_DEBUG
41 #ifdef __SUNBPP_DEBUG
42 #define dprintk(x) printk x
43 #else
44 #define dprintk(x)
45 #endif
46
47 static irqreturn_t parport_sunbpp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
48 {
49         parport_generic_irq(irq, (struct parport *) dev_id, regs);
50         return IRQ_HANDLED;
51 }
52
53 static void parport_sunbpp_disable_irq(struct parport *p)
54 {
55         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
56         u32 tmp;
57
58         tmp = sbus_readl(&regs->p_csr);
59         tmp &= ~DMA_INT_ENAB;
60         sbus_writel(tmp, &regs->p_csr);
61 }
62
63 static void parport_sunbpp_enable_irq(struct parport *p)
64 {
65         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
66         u32 tmp;
67
68         tmp = sbus_readl(&regs->p_csr);
69         tmp |= DMA_INT_ENAB;
70         sbus_writel(tmp, &regs->p_csr);
71 }
72
73 static void parport_sunbpp_write_data(struct parport *p, unsigned char d)
74 {
75         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
76
77         sbus_writeb(d, &regs->p_dr);
78         dprintk((KERN_DEBUG "wrote 0x%x\n", d));
79 }
80
81 static unsigned char parport_sunbpp_read_data(struct parport *p)
82 {
83         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
84
85         return sbus_readb(&regs->p_dr);
86 }
87
88 #if 0
89 static void control_pc_to_sunbpp(struct parport *p, unsigned char status)
90 {
91         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
92         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
93         unsigned char value_or = sbus_readb(&regs->p_or);
94
95         if (status & PARPORT_CONTROL_STROBE) 
96                 value_tcr |= P_TCR_DS;
97         if (status & PARPORT_CONTROL_AUTOFD) 
98                 value_or |= P_OR_AFXN;
99         if (status & PARPORT_CONTROL_INIT) 
100                 value_or |= P_OR_INIT;
101         if (status & PARPORT_CONTROL_SELECT) 
102                 value_or |= P_OR_SLCT_IN;
103
104         sbus_writeb(value_or, &regs->p_or);
105         sbus_writeb(value_tcr, &regs->p_tcr);
106 }
107 #endif
108
109 static unsigned char status_sunbpp_to_pc(struct parport *p)
110 {
111         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
112         unsigned char bits = 0;
113         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
114         unsigned char value_ir = sbus_readb(&regs->p_ir);
115
116         if (!(value_ir & P_IR_ERR))
117                 bits |= PARPORT_STATUS_ERROR;
118         if (!(value_ir & P_IR_SLCT))
119                 bits |= PARPORT_STATUS_SELECT;
120         if (!(value_ir & P_IR_PE))
121                 bits |= PARPORT_STATUS_PAPEROUT;
122         if (value_tcr & P_TCR_ACK)
123                 bits |= PARPORT_STATUS_ACK;
124         if (!(value_tcr & P_TCR_BUSY))
125                 bits |= PARPORT_STATUS_BUSY;
126
127         dprintk((KERN_DEBUG "tcr 0x%x ir 0x%x\n", regs->p_tcr, regs->p_ir));
128         dprintk((KERN_DEBUG "read status 0x%x\n", bits));
129         return bits;
130 }
131
132 static unsigned char control_sunbpp_to_pc(struct parport *p)
133 {
134         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
135         unsigned char bits = 0;
136         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
137         unsigned char value_or = sbus_readb(&regs->p_or);
138
139         if (!(value_tcr & P_TCR_DS))
140                 bits |= PARPORT_CONTROL_STROBE;
141         if (!(value_or & P_OR_AFXN))
142                 bits |= PARPORT_CONTROL_AUTOFD;
143         if (!(value_or & P_OR_INIT))
144                 bits |= PARPORT_CONTROL_INIT;
145         if (value_or & P_OR_SLCT_IN)
146                 bits |= PARPORT_CONTROL_SELECT;
147
148         dprintk((KERN_DEBUG "tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
149         dprintk((KERN_DEBUG "read control 0x%x\n", bits));
150         return bits;
151 }
152
153 static unsigned char parport_sunbpp_read_control(struct parport *p)
154 {
155         return control_sunbpp_to_pc(p);
156 }
157
158 static unsigned char parport_sunbpp_frob_control(struct parport *p,
159                                                  unsigned char mask,
160                                                  unsigned char val)
161 {
162         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
163         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
164         unsigned char value_or = sbus_readb(&regs->p_or);
165
166         dprintk((KERN_DEBUG "frob1: tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
167         if (mask & PARPORT_CONTROL_STROBE) {
168                 if (val & PARPORT_CONTROL_STROBE) {
169                         value_tcr &= ~P_TCR_DS;
170                 } else {
171                         value_tcr |= P_TCR_DS;
172                 }
173         }
174         if (mask & PARPORT_CONTROL_AUTOFD) {
175                 if (val & PARPORT_CONTROL_AUTOFD) {
176                         value_or &= ~P_OR_AFXN;
177                 } else {
178                         value_or |= P_OR_AFXN;
179                 }
180         }
181         if (mask & PARPORT_CONTROL_INIT) {
182                 if (val & PARPORT_CONTROL_INIT) {
183                         value_or &= ~P_OR_INIT;
184                 } else {
185                         value_or |= P_OR_INIT;
186                 }
187         }
188         if (mask & PARPORT_CONTROL_SELECT) {
189                 if (val & PARPORT_CONTROL_SELECT) {
190                         value_or |= P_OR_SLCT_IN;
191                 } else {
192                         value_or &= ~P_OR_SLCT_IN;
193                 }
194         }
195
196         sbus_writeb(value_or, &regs->p_or);
197         sbus_writeb(value_tcr, &regs->p_tcr);
198         dprintk((KERN_DEBUG "frob2: tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
199         return parport_sunbpp_read_control(p);
200 }
201
202 static void parport_sunbpp_write_control(struct parport *p, unsigned char d)
203 {
204         const unsigned char wm = (PARPORT_CONTROL_STROBE |
205                                   PARPORT_CONTROL_AUTOFD |
206                                   PARPORT_CONTROL_INIT |
207                                   PARPORT_CONTROL_SELECT);
208
209         parport_sunbpp_frob_control (p, wm, d & wm);
210 }
211
212 static unsigned char parport_sunbpp_read_status(struct parport *p)
213 {
214         return status_sunbpp_to_pc(p);
215 }
216
217 static void parport_sunbpp_data_forward (struct parport *p)
218 {
219         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
220         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
221
222         dprintk((KERN_DEBUG "forward\n"));
223         value_tcr &= ~P_TCR_DIR;
224         sbus_writeb(value_tcr, &regs->p_tcr);
225 }
226
227 static void parport_sunbpp_data_reverse (struct parport *p)
228 {
229         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
230         u8 val = sbus_readb(&regs->p_tcr);
231
232         dprintk((KERN_DEBUG "reverse\n"));
233         val |= P_TCR_DIR;
234         sbus_writeb(val, &regs->p_tcr);
235 }
236
237 static void parport_sunbpp_init_state(struct pardevice *dev, struct parport_state *s)
238 {
239         s->u.pc.ctr = 0xc;
240         s->u.pc.ecr = 0x0;
241 }
242
243 static void parport_sunbpp_save_state(struct parport *p, struct parport_state *s)
244 {
245         s->u.pc.ctr = parport_sunbpp_read_control(p);
246 }
247
248 static void parport_sunbpp_restore_state(struct parport *p, struct parport_state *s)
249 {
250         parport_sunbpp_write_control(p, s->u.pc.ctr);
251 }
252
253 static struct parport_operations parport_sunbpp_ops = 
254 {
255         .write_data     = parport_sunbpp_write_data,
256         .read_data      = parport_sunbpp_read_data,
257
258         .write_control  = parport_sunbpp_write_control,
259         .read_control   = parport_sunbpp_read_control,
260         .frob_control   = parport_sunbpp_frob_control,
261
262         .read_status    = parport_sunbpp_read_status,
263
264         .enable_irq     = parport_sunbpp_enable_irq,
265         .disable_irq    = parport_sunbpp_disable_irq,
266
267         .data_forward   = parport_sunbpp_data_forward,
268         .data_reverse   = parport_sunbpp_data_reverse,
269
270         .init_state     = parport_sunbpp_init_state,
271         .save_state     = parport_sunbpp_save_state,
272         .restore_state  = parport_sunbpp_restore_state,
273
274         .epp_write_data = parport_ieee1284_epp_write_data,
275         .epp_read_data  = parport_ieee1284_epp_read_data,
276         .epp_write_addr = parport_ieee1284_epp_write_addr,
277         .epp_read_addr  = parport_ieee1284_epp_read_addr,
278
279         .ecp_write_data = parport_ieee1284_ecp_write_data,
280         .ecp_read_data  = parport_ieee1284_ecp_read_data,
281         .ecp_write_addr = parport_ieee1284_ecp_write_addr,
282
283         .compat_write_data      = parport_ieee1284_write_compat,
284         .nibble_read_data       = parport_ieee1284_read_nibble,
285         .byte_read_data         = parport_ieee1284_read_byte,
286
287         .owner          = THIS_MODULE,
288 };
289
290 typedef struct {
291         struct list_head list;
292         struct parport *port;
293 } Node;
294 /* no locks, everything's serialized */
295 static LIST_HEAD(port_list);
296
297 static int __init init_one_port(struct sbus_dev *sdev)
298 {
299         struct parport *p;
300         /* at least in theory there may be a "we don't dma" case */
301         struct parport_operations *ops;
302         void __iomem *base;
303         int irq, dma, err = 0, size;
304         struct bpp_regs __iomem *regs;
305         unsigned char value_tcr;
306         Node *node;
307
308         dprintk((KERN_DEBUG "init_one_port(%p): ranges, alloc_io, ", sdev));
309         node = kmalloc(sizeof(Node), GFP_KERNEL);
310         if (!node)
311                 goto out0;
312
313         irq = sdev->irqs[0];
314         base = sbus_ioremap(&sdev->resource[0], 0,
315                             sdev->reg_addrs[0].reg_size, 
316                             "sunbpp");
317         if (!base)
318                 goto out1;
319
320         size = sdev->reg_addrs[0].reg_size;
321         dma = PARPORT_DMA_NONE;
322
323         dprintk(("alloc(ppops), "));
324         ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
325         if (!ops)
326                 goto out2;
327
328         memcpy (ops, &parport_sunbpp_ops, sizeof (struct parport_operations));
329
330         dprintk(("register_port\n"));
331         if (!(p = parport_register_port((unsigned long)base, irq, dma, ops)))
332                 goto out3;
333
334         p->size = size;
335
336         dprintk((KERN_DEBUG "init_one_port: request_irq(%08x:%p:%x:%s:%p) ",
337                 p->irq, parport_sunbpp_interrupt, SA_SHIRQ, p->name, p));
338         if ((err = request_irq(p->irq, parport_sunbpp_interrupt,
339                                SA_SHIRQ, p->name, p)) != 0) {
340                 dprintk(("ERROR %d\n", err));
341                 goto out4;
342         }
343         dprintk(("OK\n"));
344         parport_sunbpp_enable_irq(p);
345
346         regs = (struct bpp_regs __iomem *)p->base;
347         dprintk((KERN_DEBUG "forward\n"));
348         value_tcr = sbus_readb(&regs->p_tcr);
349         value_tcr &= ~P_TCR_DIR;
350         sbus_writeb(value_tcr, &regs->p_tcr);
351
352         printk(KERN_INFO "%s: sunbpp at 0x%lx\n", p->name, p->base);
353         node->port = p;
354         list_add(&node->list, &port_list);
355         parport_announce_port (p);
356
357         return 1;
358
359 out4:
360         parport_put_port(p);
361 out3:
362         kfree(ops);
363 out2:
364         sbus_iounmap(base, size);
365 out1:
366         kfree(node);
367 out0:
368         return err;
369 }
370
371 static int __init parport_sunbpp_init(void)
372 {
373         struct sbus_bus *sbus;
374         struct sbus_dev *sdev;
375         int count = 0;
376
377         for_each_sbus(sbus) {
378                 for_each_sbusdev(sdev, sbus) {
379                         if (!strcmp(sdev->prom_name, "SUNW,bpp"))
380                                 count += init_one_port(sdev);
381                 }
382         }
383         return count ? 0 : -ENODEV;
384 }
385
386 static void __exit parport_sunbpp_exit(void)
387 {
388         while (!list_empty(&port_list)) {
389                 Node *node = list_entry(port_list.next, Node, list);
390                 struct parport *p = node->port;
391                 struct parport_operations *ops = p->ops;
392                 parport_remove_port(p);
393
394                 if (p->irq != PARPORT_IRQ_NONE) {
395                         parport_sunbpp_disable_irq(p);
396                         free_irq(p->irq, p);
397                 }
398                 sbus_iounmap((void __iomem *)p->base, p->size);
399                 parport_put_port(p);
400                 kfree (ops);
401                 list_del(&node->list);
402                 kfree (node);
403         }
404 }
405
406 MODULE_AUTHOR("Derrick J Brashear");
407 MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
408 MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
409 MODULE_LICENSE("GPL");
410
411 module_init(parport_sunbpp_init)
412 module_exit(parport_sunbpp_exit)