patch-2.3.16 linux/drivers/parport/parport_sunbpp.c

• Lines: 399
• Date: Tue Aug 31 11:25:33 1999
• Orig file: v2.3.15/linux/drivers/parport/parport_sunbpp.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -u --recursive --new-file v2.3.15/linux/drivers/parport/parport_sunbpp.c linux/drivers/parport/parport_sunbpp.c
@@ -0,0 +1,398 @@
+/* $Id: parport_sunbpp.c,v 1.6 1999/08/31 06:57:22 davem Exp $
+ * Parallel-port routines for Sun architecture
+ * 
+ * Author: Derrick J. Brashear <shadow@dementia.org>
+ *
+ * based on work by:
+ *          Phil Blundell <Philip.Blundell@pobox.com>
+ *          Tim Waugh <tim@cyberelk.demon.co.uk>
+ *	    Jose Renau <renau@acm.org>
+ *          David Campbell <campbell@tirian.che.curtin.edu.au>
+ *          Grant Guenther <grant@torque.net>
+ *          Eddie C. Dost <ecd@skynet.be>
+ *          Stephen Williams (steve@icarus.com)
+ *          Gus Baldauf (gbaldauf@ix.netcom.com)
+ *          Peter Zaitcev
+ *          Tom Dyas
+ */
+
+#include <linux/string.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/malloc.h>
+#include <linux/init.h>
+
+#include <linux/parport.h>
+
+#include <asm/ptrace.h>
+#include <linux/interrupt.h>
+
+#include <asm/io.h>
+#include <asm/oplib.h>           /* OpenProm Library */
+#include <asm/sbus.h>            /* struct linux_sbus *SBus_chain */
+#include <asm/dma.h>             /* BPP uses LSI 64854 for DMA */
+#include <asm/irq.h>
+#include <asm/sunbpp.h>
+
+#undef __SUNBPP_DEBUG
+#ifdef __SUNBPP_DEBUG
+#define dprintk(x) printk x
+#else
+#define dprintk(x)
+#endif
+
+static void parport_sunbpp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+	parport_generic_irq(irq, (struct parport *) dev_id, regs);
+}
+
+void
+parport_sunbpp_disable_irq(struct parport *p)
+{
+	struct bpp_regs *regs = (struct bpp_regs *)p->base;
+
+	regs->p_csr &= ~(DMA_INT_ENAB);
+}
+
+void
+parport_sunbpp_enable_irq(struct parport *p)
+{
+	struct bpp_regs *regs = (struct bpp_regs *)p->base;
+
+	regs->p_csr |= DMA_INT_ENAB;
+}
+
+void
+parport_sunbpp_write_data(struct parport *p, unsigned char d)
+{
+	struct bpp_regs *regs = (struct bpp_regs *)p->base;
+
+	regs->p_dr = d;
+	dprintk(("wrote 0x%x\n", d));
+}
+
+unsigned char
+parport_sunbpp_read_data(struct parport *p)
+{
+	struct bpp_regs *regs = (struct bpp_regs *)p->base;
+
+	return regs->p_dr;
+}
+
+static void
+control_pc_to_sunbpp(struct parport *p, unsigned char status)
+{
+  struct bpp_regs *regs = (struct bpp_regs *)p->base;
+  unsigned char value_tcr = regs->p_tcr;
+  unsigned char value_or = regs->p_or;
+
+  if (status & PARPORT_CONTROL_STROBE) 
+    value_tcr |= P_TCR_DS;
+  if (status & PARPORT_CONTROL_AUTOFD) 
+    value_or |= P_OR_AFXN;
+  if (status & PARPORT_CONTROL_INIT) 
+    value_or |= P_OR_INIT;
+  if (status & PARPORT_CONTROL_SELECT) 
+    value_or |= P_OR_SLCT_IN;
+
+  regs->p_or = value_or;
+  regs->p_tcr = value_tcr;
+}
+
+static unsigned char 
+status_sunbpp_to_pc(struct parport *p)
+{
+  struct bpp_regs *regs = (struct bpp_regs *)p->base;
+  unsigned char bits = 0;
+  unsigned char value_tcr = regs->p_tcr;
+  unsigned char value_ir = regs->p_ir;
+
+  if (!(value_ir & P_IR_ERR))          bits |= PARPORT_STATUS_ERROR;
+  if (!(value_ir & P_IR_SLCT))      bits |= PARPORT_STATUS_SELECT;
+  if (!(value_ir & P_IR_PE))        bits |= PARPORT_STATUS_PAPEROUT;
+  if (value_tcr & P_TCR_ACK)        bits |= PARPORT_STATUS_ACK;
+  if (!(value_tcr & P_TCR_BUSY))       bits |= PARPORT_STATUS_BUSY;
+
+  dprintk(("tcr 0x%x ir 0x%x\n", regs->p_tcr, regs->p_ir));
+  dprintk(("read status 0x%x\n", bits));
+  return bits;
+}
+
+static unsigned char 
+control_sunbpp_to_pc(struct parport *p)
+{
+  struct bpp_regs *regs = (struct bpp_regs *)p->base;
+  unsigned char bits = 0;
+  unsigned char value_tcr = regs->p_tcr;
+  unsigned char value_or = regs->p_or;
+
+  if (!(value_tcr & P_TCR_DS))      bits |= PARPORT_CONTROL_STROBE;
+  if (!(value_or & P_OR_AFXN))      bits |= PARPORT_CONTROL_AUTOFD;
+  if (!(value_or & P_OR_INIT))      bits |= PARPORT_CONTROL_INIT;
+  if (value_or & P_OR_SLCT_IN)      bits |= PARPORT_CONTROL_SELECT;
+
+  dprintk(("tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
+  dprintk(("read control 0x%x\n", bits));
+  return bits;
+}
+
+unsigned char 
+parport_sunbpp_read_control(struct parport *p)
+{
+  return control_sunbpp_to_pc(p);
+}
+
+unsigned char 
+parport_sunbpp_frob_control(struct parport *p, unsigned char mask,
+			    unsigned char val)
+{
+  struct bpp_regs *regs = (struct bpp_regs *)p->base;
+  unsigned char value_tcr = regs->p_tcr;
+  unsigned char value_or = regs->p_or;
+
+  dprintk(("frob1: tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
+  if (mask & PARPORT_CONTROL_STROBE) {
+    if (val & PARPORT_CONTROL_STROBE)
+      value_tcr &= ~P_TCR_DS;
+    else
+      value_tcr |= P_TCR_DS;
+  }
+  if (mask & PARPORT_CONTROL_AUTOFD) {
+    if (val & PARPORT_CONTROL_AUTOFD)
+      value_or &= ~P_OR_AFXN;
+    else
+      value_or |= P_OR_AFXN;
+  }
+  if (mask & PARPORT_CONTROL_INIT) {
+    if (val & PARPORT_CONTROL_INIT)
+      value_or &= ~P_OR_INIT;
+    else
+      value_or |= P_OR_INIT;
+  }
+  if (mask & PARPORT_CONTROL_SELECT) {
+    if (val & PARPORT_CONTROL_SELECT)
+      value_or |= P_OR_SLCT_IN;
+    else
+      value_or &= ~P_OR_SLCT_IN;
+  }
+  regs->p_or = value_or;
+  regs->p_tcr = value_tcr;
+  dprintk(("frob2: tcr 0x%x or 0x%x\n", regs->p_tcr, regs->p_or));
+  return parport_sunbpp_read_control(p);
+}
+
+void
+parport_sunbpp_write_control(struct parport *p, unsigned char d)
+{
+  const unsigned char wm = (PARPORT_CONTROL_STROBE |
+			    PARPORT_CONTROL_AUTOFD |
+			    PARPORT_CONTROL_INIT |
+			    PARPORT_CONTROL_SELECT);
+
+  parport_sunbpp_frob_control (p, wm, d & wm);
+  return;
+}
+
+unsigned char 
+parport_sunbpp_read_status(struct parport *p)
+{
+  return status_sunbpp_to_pc(p);
+}
+
+void parport_sunbpp_data_forward (struct parport *p)
+{
+  struct bpp_regs *regs = (struct bpp_regs *)p->base;
+  unsigned char value_tcr = regs->p_tcr;
+
+  dprintk(("forward\n"));
+  value_tcr = regs->p_tcr;
+  value_tcr &= ~P_TCR_DIR;
+  regs->p_tcr = value_tcr;
+}
+
+void parport_sunbpp_data_reverse (struct parport *p)
+{
+  struct bpp_regs *regs = (struct bpp_regs *)p->base;
+
+  dprintk(("reverse\n"));
+  regs->p_tcr |= P_TCR_DIR;
+}
+
+void
+parport_sunbpp_init_state(struct pardevice *dev, struct parport_state *s)
+{
+	s->u.pc.ctr = 0xc;
+	s->u.pc.ecr = 0x0;
+}
+
+void
+parport_sunbpp_save_state(struct parport *p, struct parport_state *s)
+{
+	s->u.pc.ctr = parport_sunbpp_read_control(p);
+}
+
+void
+parport_sunbpp_restore_state(struct parport *p, struct parport_state *s)
+{
+	parport_sunbpp_write_control(p, s->u.pc.ctr);
+}
+
+void
+parport_sunbpp_inc_use_count(void)
+{
+#ifdef MODULE
+	MOD_INC_USE_COUNT;
+#endif
+}
+
+void
+parport_sunbpp_dec_use_count(void)
+{
+#ifdef MODULE
+	MOD_DEC_USE_COUNT;
+#endif
+}
+
+static struct parport_operations parport_sunbpp_ops = 
+{
+	parport_sunbpp_write_data,
+	parport_sunbpp_read_data,
+
+	parport_sunbpp_write_control,
+	parport_sunbpp_read_control,
+	parport_sunbpp_frob_control,
+
+	parport_sunbpp_read_status,
+
+	parport_sunbpp_enable_irq,
+        parport_sunbpp_disable_irq,
+
+        parport_sunbpp_data_forward,
+        parport_sunbpp_data_reverse,
+
+        parport_sunbpp_init_state,
+        parport_sunbpp_save_state,
+        parport_sunbpp_restore_state,
+
+        parport_sunbpp_inc_use_count,
+        parport_sunbpp_dec_use_count,
+
+        parport_ieee1284_epp_write_data,
+        parport_ieee1284_epp_read_data,
+        parport_ieee1284_epp_write_addr,
+        parport_ieee1284_epp_read_addr,
+
+        parport_ieee1284_ecp_write_data,
+        parport_ieee1284_ecp_read_data,
+        parport_ieee1284_ecp_write_addr,
+
+        parport_ieee1284_write_compat,
+        parport_ieee1284_read_nibble,
+        parport_ieee1284_read_byte,
+};
+
+
+int
+init_one_port(struct linux_sbus_device *sdev)
+{
+	struct parport *p;
+	/* at least in theory there may be a "we don't dma" case */
+	struct parport_operations *ops;
+	char *base;
+	int irq, dma, err, size;
+	struct bpp_regs *regs;
+	unsigned char value_tcr;
+
+	irq = sdev->irqs[0];
+	prom_apply_sbus_ranges(sdev->my_bus, sdev->reg_addrs, 1, sdev);
+	base = sparc_alloc_io(sdev->reg_addrs[0].phys_addr, 0,
+				 sdev->reg_addrs[0].reg_size, 
+				 "sunbpp", sdev->reg_addrs[0].which_io, 0);
+	size = sdev->reg_addrs[0].reg_size;
+	dma = PARPORT_DMA_NONE;
+
+	ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
+        if (!ops) {
+	  sparc_free_io(base, size);
+	  return 0;
+        }
+        memcpy (ops, &parport_sunbpp_ops, sizeof (struct parport_operations));
+
+	if (!(p = parport_register_port((unsigned long)base, irq, dma, ops))) {
+	  kfree(ops);
+	  sparc_free_io(base, size);
+	  return 0;
+	}
+
+	if ((err = request_irq(p->irq, parport_sunbpp_interrupt,
+			       0, p->name, p)) != 0) {
+	  parport_unregister_port(p);
+	  kfree(ops);
+	  sparc_free_io(base, size);
+	  return err;
+	} else
+	  parport_sunbpp_enable_irq(p);
+
+	regs = (struct bpp_regs *)p->base;
+	dprintk(("forward\n"));
+	value_tcr = regs->p_tcr;
+	value_tcr &= ~P_TCR_DIR;
+	regs->p_tcr = value_tcr;
+
+	printk(KERN_INFO "%s: sunbpp at 0x%lx\n", p->name, p->base);
+	parport_proc_register(p);
+	parport_announce_port (p);
+
+	return 1;
+}
+
+EXPORT_NO_SYMBOLS;
+
+#ifdef MODULE
+int init_module(void)
+#else
+int __init parport_sunbpp_init(void)
+#endif
+{
+        struct linux_sbus *sbus;
+        struct linux_sbus_device *sdev;
+	int count = 0;
+
+	for_each_sbus(sbus) {
+		for_each_sbusdev(sdev, sbus) {
+			if (!strcmp(sdev->prom_name, "SUNW,bpp"))
+				count += init_one_port(sdev);
+		}
+	}
+	return count ? 0 : -ENODEV;
+}
+
+#ifdef MODULE
+MODULE_AUTHOR("Derrick J Brashear");
+MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
+MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
+
+void
+cleanup_module(void)
+{
+	struct parport *p = parport_enumerate(), *tmp;
+	while (p) {
+		tmp = p->next;
+		if (1/*p->modes & PARPORT_MODE_PCSPP*/) { 
+		  struct parport_operations *ops = p->ops;
+		  if (p->irq != PARPORT_IRQ_NONE) {
+		    parport_sunbpp_disable_irq(p);
+		    free_irq(p->irq, p);
+		  }
+		  sparc_free_io((char *)p->base, p->size);
+		  parport_proc_unregister(p);
+		  parport_unregister_port(p);
+		  kfree (ops);
+		}
+		p = tmp;
+	}
+}
+#endif