URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [parport/] [parport_sunbpp.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/* parport_sunbpp.c: Parallel-port routines for SBUS
 *
 * Author: Derrick J. Brashear <shadow@dementia.org>
 *
 * based on work by:
 *          Phil Blundell <philb@gnu.org>
 *          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
 *
 * Updated to new SBUS device framework: David S. Miller <davem@davemloft.net>
 *
 */
 
#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/slab.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>
#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_disable_irq(struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        u32 tmp;
 
        tmp = sbus_readl(&regs->p_csr);
        tmp &= ~DMA_INT_ENAB;
        sbus_writel(tmp, &regs->p_csr);
}
 
static void parport_sunbpp_enable_irq(struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        u32 tmp;
 
        tmp = sbus_readl(&regs->p_csr);
        tmp |= DMA_INT_ENAB;
        sbus_writel(tmp, &regs->p_csr);
}
 
static void parport_sunbpp_write_data(struct parport *p, unsigned char d)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 
        sbus_writeb(d, &regs->p_dr);
        dprintk((KERN_DEBUG "wrote 0x%x\n", d));
}
 
static unsigned char parport_sunbpp_read_data(struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 
        return sbus_readb(&regs->p_dr);
}
 
#if 0
static void control_pc_to_sunbpp(struct parport *p, unsigned char status)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        unsigned char value_tcr = sbus_readb(&regs->p_tcr);
        unsigned char value_or = sbus_readb(&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;
 
        sbus_writeb(value_or, &regs->p_or);
        sbus_writeb(value_tcr, &regs->p_tcr);
}
#endif
 
static unsigned char status_sunbpp_to_pc(struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        unsigned char bits = 0;
        unsigned char value_tcr = sbus_readb(&regs->p_tcr);
        unsigned char value_ir = sbus_readb(&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((KERN_DEBUG "tcr 0x%x ir 0x%x\n", value_tcr, value_ir));
        dprintk((KERN_DEBUG "read status 0x%x\n", bits));
        return bits;
}
 
static unsigned char control_sunbpp_to_pc(struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        unsigned char bits = 0;
        unsigned char value_tcr = sbus_readb(&regs->p_tcr);
        unsigned char value_or = sbus_readb(&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((KERN_DEBUG "tcr 0x%x or 0x%x\n", value_tcr, value_or));
        dprintk((KERN_DEBUG "read control 0x%x\n", bits));
        return bits;
}
 
static unsigned char parport_sunbpp_read_control(struct parport *p)
{
        return control_sunbpp_to_pc(p);
}
 
static unsigned char parport_sunbpp_frob_control(struct parport *p,
                                                 unsigned char mask,
                                                 unsigned char val)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        unsigned char value_tcr = sbus_readb(&regs->p_tcr);
        unsigned char value_or = sbus_readb(&regs->p_or);
 
        dprintk((KERN_DEBUG "frob1: tcr 0x%x or 0x%x\n",
                 value_tcr, value_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;
                }
        }
 
        sbus_writeb(value_or, &regs->p_or);
        sbus_writeb(value_tcr, &regs->p_tcr);
        dprintk((KERN_DEBUG "frob2: tcr 0x%x or 0x%x\n",
                 value_tcr, value_or));
        return parport_sunbpp_read_control(p);
}
 
static 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);
}
 
static unsigned char parport_sunbpp_read_status(struct parport *p)
{
        return status_sunbpp_to_pc(p);
}
 
static void parport_sunbpp_data_forward (struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        unsigned char value_tcr = sbus_readb(&regs->p_tcr);
 
        dprintk((KERN_DEBUG "forward\n"));
        value_tcr &= ~P_TCR_DIR;
        sbus_writeb(value_tcr, &regs->p_tcr);
}
 
static void parport_sunbpp_data_reverse (struct parport *p)
{
        struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
        u8 val = sbus_readb(&regs->p_tcr);
 
        dprintk((KERN_DEBUG "reverse\n"));
        val |= P_TCR_DIR;
        sbus_writeb(val, &regs->p_tcr);
}
 
static void parport_sunbpp_init_state(struct pardevice *dev, struct parport_state *s)
{
        s->u.pc.ctr = 0xc;
        s->u.pc.ecr = 0x0;
}
 
static void parport_sunbpp_save_state(struct parport *p, struct parport_state *s)
{
        s->u.pc.ctr = parport_sunbpp_read_control(p);
}
 
static void parport_sunbpp_restore_state(struct parport *p, struct parport_state *s)
{
        parport_sunbpp_write_control(p, s->u.pc.ctr);
}
 
static struct parport_operations parport_sunbpp_ops =
{
        .write_data     = parport_sunbpp_write_data,
        .read_data      = parport_sunbpp_read_data,
 
        .write_control  = parport_sunbpp_write_control,
        .read_control   = parport_sunbpp_read_control,
        .frob_control   = parport_sunbpp_frob_control,
 
        .read_status    = parport_sunbpp_read_status,
 
        .enable_irq     = parport_sunbpp_enable_irq,
        .disable_irq    = parport_sunbpp_disable_irq,
 
        .data_forward   = parport_sunbpp_data_forward,
        .data_reverse   = parport_sunbpp_data_reverse,
 
        .init_state     = parport_sunbpp_init_state,
        .save_state     = parport_sunbpp_save_state,
        .restore_state  = parport_sunbpp_restore_state,
 
        .epp_write_data = parport_ieee1284_epp_write_data,
        .epp_read_data  = parport_ieee1284_epp_read_data,
        .epp_write_addr = parport_ieee1284_epp_write_addr,
        .epp_read_addr  = parport_ieee1284_epp_read_addr,
 
        .ecp_write_data = parport_ieee1284_ecp_write_data,
        .ecp_read_data  = parport_ieee1284_ecp_read_data,
        .ecp_write_addr = parport_ieee1284_ecp_write_addr,
 
        .compat_write_data      = parport_ieee1284_write_compat,
        .nibble_read_data       = parport_ieee1284_read_nibble,
        .byte_read_data         = parport_ieee1284_read_byte,
 
        .owner          = THIS_MODULE,
};
 
static int __devinit init_one_port(struct sbus_dev *sdev)
{
        struct parport *p;
        /* at least in theory there may be a "we don't dma" case */
        struct parport_operations *ops;
        void __iomem *base;
        int irq, dma, err = 0, size;
        struct bpp_regs __iomem *regs;
        unsigned char value_tcr;
 
        irq = sdev->irqs[0];
        base = sbus_ioremap(&sdev->resource[0], 0,
                            sdev->reg_addrs[0].reg_size,
                            "sunbpp");
        if (!base)
                return -ENODEV;
 
        size = sdev->reg_addrs[0].reg_size;
        dma = PARPORT_DMA_NONE;
 
        ops = kmalloc(sizeof(struct parport_operations), GFP_KERNEL);
        if (!ops)
                goto out_unmap;
 
        memcpy (ops, &parport_sunbpp_ops, sizeof (struct parport_operations));
 
        dprintk(("register_port\n"));
        if (!(p = parport_register_port((unsigned long)base, irq, dma, ops)))
                goto out_free_ops;
 
        p->size = size;
        p->dev = &sdev->ofdev.dev;
 
        if ((err = request_irq(p->irq, parport_irq_handler,
                               IRQF_SHARED, p->name, p)) != 0) {
                goto out_put_port;
        }
 
        parport_sunbpp_enable_irq(p);
 
        regs = (struct bpp_regs __iomem *)p->base;
 
        value_tcr = sbus_readb(&regs->p_tcr);
        value_tcr &= ~P_TCR_DIR;
        sbus_writeb(value_tcr, &regs->p_tcr);
 
        printk(KERN_INFO "%s: sunbpp at 0x%lx\n", p->name, p->base);
 
        dev_set_drvdata(&sdev->ofdev.dev, p);
 
        parport_announce_port(p);
 
        return 0;
 
out_put_port:
        parport_put_port(p);
 
out_free_ops:
        kfree(ops);
 
out_unmap:
        sbus_iounmap(base, size);
 
        return err;
}
 
static int __devinit bpp_probe(struct of_device *dev, const struct of_device_id *match)
{
        struct sbus_dev *sdev = to_sbus_device(&dev->dev);
 
        return init_one_port(sdev);
}
 
static int __devexit bpp_remove(struct of_device *dev)
{
        struct parport *p = dev_get_drvdata(&dev->dev);
        struct parport_operations *ops = p->ops;
 
        parport_remove_port(p);
 
        if (p->irq != PARPORT_IRQ_NONE) {
                parport_sunbpp_disable_irq(p);
                free_irq(p->irq, p);
        }
 
        sbus_iounmap((void __iomem *) p->base, p->size);
        parport_put_port(p);
        kfree(ops);
 
        dev_set_drvdata(&dev->dev, NULL);
 
        return 0;
}
 
static struct of_device_id bpp_match[] = {
        {
                .name = "SUNW,bpp",
        },
        {},
};
 
MODULE_DEVICE_TABLE(of, bpp_match);
 
static struct of_platform_driver bpp_sbus_driver = {
        .name           = "bpp",
        .match_table    = bpp_match,
        .probe          = bpp_probe,
        .remove         = __devexit_p(bpp_remove),
};
 
static int __init parport_sunbpp_init(void)
{
        return of_register_driver(&bpp_sbus_driver, &sbus_bus_type);
}
 
static void __exit parport_sunbpp_exit(void)
{
        of_unregister_driver(&bpp_sbus_driver);
}
 
MODULE_AUTHOR("Derrick J Brashear");
MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
MODULE_VERSION("2.0");
MODULE_LICENSE("GPL");
 
module_init(parport_sunbpp_init)
module_exit(parport_sunbpp_exit)

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [parport/] [parport_sunbpp.c] - Blame information for rev 62

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