1 /* $Id: parport_sunbpp.c,v 1.12 2001/05/26 03:01:42 davem Exp $
2 * Parallel-port routines for Sun architecture
4 * Author: Derrick J. Brashear <shadow@dementia.org>
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)
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>
28 #include <linux/parport.h>
30 #include <asm/ptrace.h>
31 #include <linux/interrupt.h>
34 #include <asm/oplib.h> /* OpenProm Library */
36 #include <asm/dma.h> /* BPP uses LSI 64854 for DMA */
38 #include <asm/sunbpp.h>
42 #define dprintk(x) printk x
47 static void parport_sunbpp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
49 parport_generic_irq(irq, (struct parport *) dev_id, regs);
52 static void parport_sunbpp_disable_irq(struct parport *p)
54 struct bpp_regs *regs = (struct bpp_regs *)p->base;
57 tmp = sbus_readl(®s->p_csr);
59 sbus_writel(tmp, ®s->p_csr);
62 static void parport_sunbpp_enable_irq(struct parport *p)
64 struct bpp_regs *regs = (struct bpp_regs *)p->base;
67 tmp = sbus_readl(®s->p_csr);
69 sbus_writel(tmp, ®s->p_csr);
72 static void parport_sunbpp_write_data(struct parport *p, unsigned char d)
74 struct bpp_regs *regs = (struct bpp_regs *)p->base;
76 sbus_writeb(d, ®s->p_dr);
77 dprintk((KERN_DEBUG "wrote 0x%x\n", d));
80 static unsigned char parport_sunbpp_read_data(struct parport *p)
82 struct bpp_regs *regs = (struct bpp_regs *)p->base;
84 return sbus_readb(®s->p_dr);
88 static void control_pc_to_sunbpp(struct parport *p, unsigned char status)
90 struct bpp_regs *regs = (struct bpp_regs *)p->base;
91 unsigned char value_tcr = sbus_readb(®s->p_tcr);
92 unsigned char value_or = sbus_readb(®s->p_or);
94 if (status & PARPORT_CONTROL_STROBE)
95 value_tcr |= P_TCR_DS;
96 if (status & PARPORT_CONTROL_AUTOFD)
97 value_or |= P_OR_AFXN;
98 if (status & PARPORT_CONTROL_INIT)
99 value_or |= P_OR_INIT;
100 if (status & PARPORT_CONTROL_SELECT)
101 value_or |= P_OR_SLCT_IN;
103 sbus_writeb(value_or, ®s->p_or);
104 sbus_writeb(value_tcr, ®s->p_tcr);
108 static unsigned char status_sunbpp_to_pc(struct parport *p)
110 struct bpp_regs *regs = (struct bpp_regs *)p->base;
111 unsigned char bits = 0;
112 unsigned char value_tcr = sbus_readb(®s->p_tcr);
113 unsigned char value_ir = sbus_readb(®s->p_ir);
115 if (!(value_ir & P_IR_ERR))
116 bits |= PARPORT_STATUS_ERROR;
117 if (!(value_ir & P_IR_SLCT))
118 bits |= PARPORT_STATUS_SELECT;
119 if (!(value_ir & P_IR_PE))
120 bits |= PARPORT_STATUS_PAPEROUT;
121 if (value_tcr & P_TCR_ACK)
122 bits |= PARPORT_STATUS_ACK;
123 if (!(value_tcr & P_TCR_BUSY))
124 bits |= PARPORT_STATUS_BUSY;
126 dprintk((KERN_DEBUG "tcr 0x%x ir 0x%x\n", regs->p_tcr, regs->p_ir));
127 dprintk((KERN_DEBUG "read status 0x%x\n", bits));
131 static unsigned char control_sunbpp_to_pc(struct parport *p)
133 struct bpp_regs *regs = (struct bpp_regs *)p->base;
134 unsigned char bits = 0;
135 unsigned char value_tcr = sbus_readb(®s->p_tcr);
136 unsigned char value_or = sbus_readb(®s->p_or);
138 if (!(value_tcr & P_TCR_DS))
139 bits |= PARPORT_CONTROL_STROBE;
140 if (!(value_or & P_OR_AFXN))
141 bits |= PARPORT_CONTROL_AUTOFD;
142 if (!(value_or & P_OR_INIT))
143 bits |= PARPORT_CONTROL_INIT;
144 if (value_or & P_OR_SLCT_IN)
145 bits |= PARPORT_CONTROL_SELECT;
147 dprintk((KERN_DEBUG "tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
148 dprintk((KERN_DEBUG "read control 0x%x\n", bits));
152 static unsigned char parport_sunbpp_read_control(struct parport *p)
154 return control_sunbpp_to_pc(p);
157 static unsigned char parport_sunbpp_frob_control(struct parport *p,
161 struct bpp_regs *regs = (struct bpp_regs *)p->base;
162 unsigned char value_tcr = sbus_readb(®s->p_tcr);
163 unsigned char value_or = sbus_readb(®s->p_or);
165 dprintk((KERN_DEBUG "frob1: tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
166 if (mask & PARPORT_CONTROL_STROBE) {
167 if (val & PARPORT_CONTROL_STROBE) {
168 value_tcr &= ~P_TCR_DS;
170 value_tcr |= P_TCR_DS;
173 if (mask & PARPORT_CONTROL_AUTOFD) {
174 if (val & PARPORT_CONTROL_AUTOFD) {
175 value_or &= ~P_OR_AFXN;
177 value_or |= P_OR_AFXN;
180 if (mask & PARPORT_CONTROL_INIT) {
181 if (val & PARPORT_CONTROL_INIT) {
182 value_or &= ~P_OR_INIT;
184 value_or |= P_OR_INIT;
187 if (mask & PARPORT_CONTROL_SELECT) {
188 if (val & PARPORT_CONTROL_SELECT) {
189 value_or |= P_OR_SLCT_IN;
191 value_or &= ~P_OR_SLCT_IN;
195 sbus_writeb(value_or, ®s->p_or);
196 sbus_writeb(value_tcr, ®s->p_tcr);
197 dprintk((KERN_DEBUG "frob2: tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
198 return parport_sunbpp_read_control(p);
201 static void parport_sunbpp_write_control(struct parport *p, unsigned char d)
203 const unsigned char wm = (PARPORT_CONTROL_STROBE |
204 PARPORT_CONTROL_AUTOFD |
205 PARPORT_CONTROL_INIT |
206 PARPORT_CONTROL_SELECT);
208 parport_sunbpp_frob_control (p, wm, d & wm);
211 static unsigned char parport_sunbpp_read_status(struct parport *p)
213 return status_sunbpp_to_pc(p);
216 static void parport_sunbpp_data_forward (struct parport *p)
218 struct bpp_regs *regs = (struct bpp_regs *)p->base;
219 unsigned char value_tcr = sbus_readb(®s->p_tcr);
221 dprintk((KERN_DEBUG "forward\n"));
222 value_tcr &= ~P_TCR_DIR;
223 sbus_writeb(value_tcr, ®s->p_tcr);
226 static void parport_sunbpp_data_reverse (struct parport *p)
228 struct bpp_regs *regs = (struct bpp_regs *)p->base;
229 u8 val = sbus_readb(®s->p_tcr);
231 dprintk((KERN_DEBUG "reverse\n"));
233 sbus_writeb(val, ®s->p_tcr);
236 static void parport_sunbpp_init_state(struct pardevice *dev, struct parport_state *s)
242 static void parport_sunbpp_save_state(struct parport *p, struct parport_state *s)
244 s->u.pc.ctr = parport_sunbpp_read_control(p);
247 static void parport_sunbpp_restore_state(struct parport *p, struct parport_state *s)
249 parport_sunbpp_write_control(p, s->u.pc.ctr);
252 static void parport_sunbpp_inc_use_count(void)
259 static void parport_sunbpp_dec_use_count(void)
266 static struct parport_operations parport_sunbpp_ops =
268 parport_sunbpp_write_data,
269 parport_sunbpp_read_data,
271 parport_sunbpp_write_control,
272 parport_sunbpp_read_control,
273 parport_sunbpp_frob_control,
275 parport_sunbpp_read_status,
277 parport_sunbpp_enable_irq,
278 parport_sunbpp_disable_irq,
280 parport_sunbpp_data_forward,
281 parport_sunbpp_data_reverse,
283 parport_sunbpp_init_state,
284 parport_sunbpp_save_state,
285 parport_sunbpp_restore_state,
287 parport_sunbpp_inc_use_count,
288 parport_sunbpp_dec_use_count,
290 parport_ieee1284_epp_write_data,
291 parport_ieee1284_epp_read_data,
292 parport_ieee1284_epp_write_addr,
293 parport_ieee1284_epp_read_addr,
295 parport_ieee1284_ecp_write_data,
296 parport_ieee1284_ecp_read_data,
297 parport_ieee1284_ecp_write_addr,
299 parport_ieee1284_write_compat,
300 parport_ieee1284_read_nibble,
301 parport_ieee1284_read_byte,
304 static int __init init_one_port(struct sbus_dev *sdev)
307 /* at least in theory there may be a "we don't dma" case */
308 struct parport_operations *ops;
310 int irq, dma, err, size;
311 struct bpp_regs *regs;
312 unsigned char value_tcr;
314 dprintk((KERN_DEBUG "init_one_port(%p): ranges, alloc_io, ", sdev));
316 base = sbus_ioremap(&sdev->resource[0], 0,
317 sdev->reg_addrs[0].reg_size,
319 size = sdev->reg_addrs[0].reg_size;
320 dma = PARPORT_DMA_NONE;
322 dprintk(("alloc(ppops), "));
323 ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
325 sbus_iounmap(base, size);
329 memcpy (ops, &parport_sunbpp_ops, sizeof (struct parport_operations));
331 dprintk(("register_port\n"));
332 if (!(p = parport_register_port(base, irq, dma, ops))) {
334 sbus_iounmap(base, size);
340 dprintk((KERN_DEBUG "init_one_port: request_irq(%08x:%p:%x:%s:%p) ",
341 p->irq, parport_sunbpp_interrupt, SA_SHIRQ, p->name, p));
342 if ((err = request_irq(p->irq, parport_sunbpp_interrupt,
343 SA_SHIRQ, p->name, p)) != 0) {
344 dprintk(("ERROR %d\n", err));
345 parport_unregister_port(p);
347 sbus_iounmap(base, size);
351 parport_sunbpp_enable_irq(p);
354 regs = (struct bpp_regs *)p->base;
355 dprintk((KERN_DEBUG "forward\n"));
356 value_tcr = sbus_readb(®s->p_tcr);
357 value_tcr &= ~P_TCR_DIR;
358 sbus_writeb(value_tcr, ®s->p_tcr);
360 printk(KERN_INFO "%s: sunbpp at 0x%lx\n", p->name, p->base);
361 parport_proc_register(p);
362 parport_announce_port (p);
370 int init_module(void)
372 int __init parport_sunbpp_init(void)
375 struct sbus_bus *sbus;
376 struct sbus_dev *sdev;
379 for_each_sbus(sbus) {
380 for_each_sbusdev(sdev, sbus) {
381 if (!strcmp(sdev->prom_name, "SUNW,bpp"))
382 count += init_one_port(sdev);
385 return count ? 0 : -ENODEV;
389 MODULE_AUTHOR("Derrick J Brashear");
390 MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
391 MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
396 struct parport *p = parport_enumerate();
399 struct parport *next = p->next;
401 if (1/*p->modes & PARPORT_MODE_PCSPP*/) {
402 struct parport_operations *ops = p->ops;
404 if (p->irq != PARPORT_IRQ_NONE) {
405 parport_sunbpp_disable_irq(p);
408 sbus_iounmap(p->base, p->size);
409 parport_proc_unregister(p);
410 parport_unregister_port(p);