release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/parport/parport_sunbpp.c

   1 /* 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 #include <linux/of.h>
  30 #include <linux/of_device.h>
  31
  32 #include <linux/parport.h>
  33
  34 #include <asm/ptrace.h>
  35 #include <linux/interrupt.h>
  36
  37 #include <asm/io.h>
  38 #include <asm/oplib.h>           /* OpenProm Library */
  39 #include <asm/dma.h>             /* BPP uses LSI 64854 for DMA */
  40 #include <asm/irq.h>
  41 #include <asm/sunbpp.h>
  42
  43 #undef __SUNBPP_DEBUG
  44 #ifdef __SUNBPP_DEBUG
  45 #define dprintk(x) printk x
  46 #else
  47 #define dprintk(x)
  48 #endif
  49
  50 static void parport_sunbpp_disable_irq(struct parport *p)
  51 {
  52         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
  53         u32 tmp;
  54
  55         tmp = sbus_readl(&regs->p_csr);
  56         tmp &= ~DMA_INT_ENAB;
  57         sbus_writel(tmp, &regs->p_csr);
  58 }
  59
  60 static void parport_sunbpp_enable_irq(struct parport *p)
  61 {
  62         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
  63         u32 tmp;
  64
  65         tmp = sbus_readl(&regs->p_csr);
  66         tmp |= DMA_INT_ENAB;
  67         sbus_writel(tmp, &regs->p_csr);
  68 }
  69
  70 static void parport_sunbpp_write_data(struct parport *p, unsigned char d)
  71 {
  72         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
  73
  74         sbus_writeb(d, &regs->p_dr);
  75         dprintk((KERN_DEBUG "wrote 0x%x\n", d));
  76 }
  77
  78 static unsigned char parport_sunbpp_read_data(struct parport *p)
  79 {
  80         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
  81
  82         return sbus_readb(&regs->p_dr);
  83 }
  84
  85
  86 static unsigned char status_sunbpp_to_pc(struct parport *p)
  87 {
  88         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
  89         unsigned char bits = 0;
  90         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
  91         unsigned char value_ir = sbus_readb(&regs->p_ir);
  92
  93         if (!(value_ir & P_IR_ERR))
  94                 bits |= PARPORT_STATUS_ERROR;
  95         if (!(value_ir & P_IR_SLCT))
  96                 bits |= PARPORT_STATUS_SELECT;
  97         if (!(value_ir & P_IR_PE))
  98                 bits |= PARPORT_STATUS_PAPEROUT;
  99         if (value_tcr & P_TCR_ACK)
 100                 bits |= PARPORT_STATUS_ACK;
 101         if (!(value_tcr & P_TCR_BUSY))
 102                 bits |= PARPORT_STATUS_BUSY;
 103
 104         dprintk((KERN_DEBUG "tcr 0x%x ir 0x%x\n", value_tcr, value_ir));
 105         dprintk((KERN_DEBUG "read status 0x%x\n", bits));
 106         return bits;
 107 }
 108
 109 static unsigned char control_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_or = sbus_readb(&regs->p_or);
 115
 116         if (!(value_tcr & P_TCR_DS))
 117                 bits |= PARPORT_CONTROL_STROBE;
 118         if (!(value_or & P_OR_AFXN))
 119                 bits |= PARPORT_CONTROL_AUTOFD;
 120         if (!(value_or & P_OR_INIT))
 121                 bits |= PARPORT_CONTROL_INIT;
 122         if (value_or & P_OR_SLCT_IN)
 123                 bits |= PARPORT_CONTROL_SELECT;
 124
 125         dprintk((KERN_DEBUG "tcr 0x%x or 0x%x\n", value_tcr, value_or));
 126         dprintk((KERN_DEBUG "read control 0x%x\n", bits));
 127         return bits;
 128 }
 129
 130 static unsigned char parport_sunbpp_read_control(struct parport *p)
 131 {
 132         return control_sunbpp_to_pc(p);
 133 }
 134
 135 static unsigned char parport_sunbpp_frob_control(struct parport *p,
 136                                                  unsigned char mask,
 137                                                  unsigned char val)
 138 {
 139         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 140         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
 141         unsigned char value_or = sbus_readb(&regs->p_or);
 142
 143         dprintk((KERN_DEBUG "frob1: tcr 0x%x or 0x%x\n",
 144                  value_tcr, value_or));
 145         if (mask & PARPORT_CONTROL_STROBE) {
 146                 if (val & PARPORT_CONTROL_STROBE) {
 147                         value_tcr &= ~P_TCR_DS;
 148                 } else {
 149                         value_tcr |= P_TCR_DS;
 150                 }
 151         }
 152         if (mask & PARPORT_CONTROL_AUTOFD) {
 153                 if (val & PARPORT_CONTROL_AUTOFD) {
 154                         value_or &= ~P_OR_AFXN;
 155                 } else {
 156                         value_or |= P_OR_AFXN;
 157                 }
 158         }
 159         if (mask & PARPORT_CONTROL_INIT) {
 160                 if (val & PARPORT_CONTROL_INIT) {
 161                         value_or &= ~P_OR_INIT;
 162                 } else {
 163                         value_or |= P_OR_INIT;
 164                 }
 165         }
 166         if (mask & PARPORT_CONTROL_SELECT) {
 167                 if (val & PARPORT_CONTROL_SELECT) {
 168                         value_or |= P_OR_SLCT_IN;
 169                 } else {
 170                         value_or &= ~P_OR_SLCT_IN;
 171                 }
 172         }
 173
 174         sbus_writeb(value_or, &regs->p_or);
 175         sbus_writeb(value_tcr, &regs->p_tcr);
 176         dprintk((KERN_DEBUG "frob2: tcr 0x%x or 0x%x\n",
 177                  value_tcr, value_or));
 178         return parport_sunbpp_read_control(p);
 179 }
 180
 181 static void parport_sunbpp_write_control(struct parport *p, unsigned char d)
 182 {
 183         const unsigned char wm = (PARPORT_CONTROL_STROBE |
 184                                   PARPORT_CONTROL_AUTOFD |
 185                                   PARPORT_CONTROL_INIT |
 186                                   PARPORT_CONTROL_SELECT);
 187
 188         parport_sunbpp_frob_control (p, wm, d & wm);
 189 }
 190
 191 static unsigned char parport_sunbpp_read_status(struct parport *p)
 192 {
 193         return status_sunbpp_to_pc(p);
 194 }
 195
 196 static void parport_sunbpp_data_forward (struct parport *p)
 197 {
 198         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 199         unsigned char value_tcr = sbus_readb(&regs->p_tcr);
 200
 201         dprintk((KERN_DEBUG "forward\n"));
 202         value_tcr &= ~P_TCR_DIR;
 203         sbus_writeb(value_tcr, &regs->p_tcr);
 204 }
 205
 206 static void parport_sunbpp_data_reverse (struct parport *p)
 207 {
 208         struct bpp_regs __iomem *regs = (struct bpp_regs __iomem *)p->base;
 209         u8 val = sbus_readb(&regs->p_tcr);
 210
 211         dprintk((KERN_DEBUG "reverse\n"));
 212         val |= P_TCR_DIR;
 213         sbus_writeb(val, &regs->p_tcr);
 214 }
 215
 216 static void parport_sunbpp_init_state(struct pardevice *dev, struct parport_state *s)
 217 {
 218         s->u.pc.ctr = 0xc;
 219         s->u.pc.ecr = 0x0;
 220 }
 221
 222 static void parport_sunbpp_save_state(struct parport *p, struct parport_state *s)
 223 {
 224         s->u.pc.ctr = parport_sunbpp_read_control(p);
 225 }
 226
 227 static void parport_sunbpp_restore_state(struct parport *p, struct parport_state *s)
 228 {
 229         parport_sunbpp_write_control(p, s->u.pc.ctr);
 230 }
 231
 232 static struct parport_operations parport_sunbpp_ops =
 233 {
 234         .write_data     = parport_sunbpp_write_data,
 235         .read_data      = parport_sunbpp_read_data,
 236
 237         .write_control  = parport_sunbpp_write_control,
 238         .read_control   = parport_sunbpp_read_control,
 239         .frob_control   = parport_sunbpp_frob_control,
 240
 241         .read_status    = parport_sunbpp_read_status,
 242
 243         .enable_irq     = parport_sunbpp_enable_irq,
 244         .disable_irq    = parport_sunbpp_disable_irq,
 245
 246         .data_forward   = parport_sunbpp_data_forward,
 247         .data_reverse   = parport_sunbpp_data_reverse,
 248
 249         .init_state     = parport_sunbpp_init_state,
 250         .save_state     = parport_sunbpp_save_state,
 251         .restore_state  = parport_sunbpp_restore_state,
 252
 253         .epp_write_data = parport_ieee1284_epp_write_data,
 254         .epp_read_data  = parport_ieee1284_epp_read_data,
 255         .epp_write_addr = parport_ieee1284_epp_write_addr,
 256         .epp_read_addr  = parport_ieee1284_epp_read_addr,
 257
 258         .ecp_write_data = parport_ieee1284_ecp_write_data,
 259         .ecp_read_data  = parport_ieee1284_ecp_read_data,
 260         .ecp_write_addr = parport_ieee1284_ecp_write_addr,
 261
 262         .compat_write_data      = parport_ieee1284_write_compat,
 263         .nibble_read_data       = parport_ieee1284_read_nibble,
 264         .byte_read_data         = parport_ieee1284_read_byte,
 265
 266         .owner          = THIS_MODULE,
 267 };
 268
 269 static int __devinit bpp_probe(struct platform_device *op, const struct of_device_id *match)
 270 {
 271         struct parport_operations *ops;
 272         struct bpp_regs __iomem *regs;
 273         int irq, dma, err = 0, size;
 274         unsigned char value_tcr;
 275         void __iomem *base;
 276         struct parport *p;
 277
 278         irq = op->archdata.irqs[0];
 279         base = of_ioremap(&op->resource[0], 0,
 280                           resource_size(&op->resource[0]),
 281                           "sunbpp");
 282         if (!base)
 283                 return -ENODEV;
 284
 285         size = resource_size(&op->resource[0]);
 286         dma = PARPORT_DMA_NONE;
 287
 288         ops = kmalloc(sizeof(struct parport_operations), GFP_KERNEL);
 289         if (!ops)
 290                 goto out_unmap;
 291
 292         memcpy (ops, &parport_sunbpp_ops, sizeof(struct parport_operations));
 293
 294         dprintk(("register_port\n"));
 295         if (!(p = parport_register_port((unsigned long)base, irq, dma, ops)))
 296                 goto out_free_ops;
 297
 298         p->size = size;
 299         p->dev = &op->dev;
 300
 301         if ((err = request_irq(p->irq, parport_irq_handler,
 302                                IRQF_SHARED, p->name, p)) != 0) {
 303                 goto out_put_port;
 304         }
 305
 306         parport_sunbpp_enable_irq(p);
 307
 308         regs = (struct bpp_regs __iomem *)p->base;
 309
 310         value_tcr = sbus_readb(&regs->p_tcr);
 311         value_tcr &= ~P_TCR_DIR;
 312         sbus_writeb(value_tcr, &regs->p_tcr);
 313
 314         printk(KERN_INFO "%s: sunbpp at 0x%lx\n", p->name, p->base);
 315
 316         dev_set_drvdata(&op->dev, p);
 317
 318         parport_announce_port(p);
 319
 320         return 0;
 321
 322 out_put_port:
 323         parport_put_port(p);
 324
 325 out_free_ops:
 326         kfree(ops);
 327
 328 out_unmap:
 329         of_iounmap(&op->resource[0], base, size);
 330
 331         return err;
 332 }
 333
 334 static int __devexit bpp_remove(struct platform_device *op)
 335 {
 336         struct parport *p = dev_get_drvdata(&op->dev);
 337         struct parport_operations *ops = p->ops;
 338
 339         parport_remove_port(p);
 340
 341         if (p->irq != PARPORT_IRQ_NONE) {
 342                 parport_sunbpp_disable_irq(p);
 343                 free_irq(p->irq, p);
 344         }
 345
 346         of_iounmap(&op->resource[0], (void __iomem *) p->base, p->size);
 347         parport_put_port(p);
 348         kfree(ops);
 349
 350         dev_set_drvdata(&op->dev, NULL);
 351
 352         return 0;
 353 }
 354
 355 static const struct of_device_id bpp_match[] = {
 356         {
 357                 .name = "SUNW,bpp",
 358         },
 359         {},
 360 };
 361
 362 MODULE_DEVICE_TABLE(of, bpp_match);
 363
 364 static struct of_platform_driver bpp_sbus_driver = {
 365         .driver = {
 366                 .name = "bpp",
 367                 .owner = THIS_MODULE,
 368                 .of_match_table = bpp_match,
 369         },
 370         .probe          = bpp_probe,
 371         .remove         = __devexit_p(bpp_remove),
 372 };
 373
 374 static int __init parport_sunbpp_init(void)
 375 {
 376         return of_register_platform_driver(&bpp_sbus_driver);
 377 }
 378
 379 static void __exit parport_sunbpp_exit(void)
 380 {
 381         of_unregister_platform_driver(&bpp_sbus_driver);
 382 }
 383
 384 MODULE_AUTHOR("Derrick J Brashear");
 385 MODULE_DESCRIPTION("Parport Driver for Sparc bidirectional Port");
 386 MODULE_SUPPORTED_DEVICE("Sparc Bidirectional Parallel Port");
 387 MODULE_VERSION("2.0");
 388 MODULE_LICENSE("GPL");
 389
 390 module_init(parport_sunbpp_init)
 391 module_exit(parport_sunbpp_exit)