LXR linux-bk/include/asm-parisc/parport

   1#ifndef __LINUX_PARPORT_GSC_H
   2#define __LINUX_PARPORT_GSC_H
   3
   4#include <asm/io.h>
   5#include <linux/delay.h>
   6
   7#undef  DEBUG_PARPORT   /* undefine for production */
   8#define DELAY_TIME      0
   9
  10#if DELAY_TIME == 0
  11#define parport_readb   gsc_readb
  12#define parport_writeb  gsc_writeb
  13#else
  14static __inline__ unsigned char parport_readb( unsigned long port )
  15{
  16    udelay(DELAY_TIME);
  17    return gsc_readb(port);
  18}
  19
  20static __inline__ void parport_writeb( unsigned char value, unsigned long port )
  21{
  22    gsc_writeb(value,port);
  23    udelay(DELAY_TIME);
  24}
  25#endif
  26
  27/* --- register definitions ------------------------------- */
  28
  29#define EPPDATA(p)  ((p)->base    + 0x4)
  30#define EPPADDR(p)  ((p)->base    + 0x3)
  31#define CONTROL(p)  ((p)->base    + 0x2)
  32#define STATUS(p)   ((p)->base    + 0x1)
  33#define DATA(p)     ((p)->base    + 0x0)
  34
  35struct parport_gsc_private {
  36        /* Contents of CTR. */
  37        unsigned char ctr;
  38
  39        /* Bitmask of writable CTR bits. */
  40        unsigned char ctr_writable;
  41
  42        /* Number of bytes per portword. */
  43        int pword;
  44
  45        /* Not used yet. */
  46        int readIntrThreshold;
  47        int writeIntrThreshold;
  48
  49        /* buffer suitable for DMA, if DMA enabled */
  50        char *dma_buf;
  51        dma_addr_t dma_handle;
  52        struct pci_dev *dev;
  53};
  54
  55extern __inline__ void parport_gsc_write_data(struct parport *p, unsigned char d)
  56{
  57#ifdef DEBUG_PARPORT
  58        printk (KERN_DEBUG "parport_gsc_write_data(%p,0x%02x)\n", p, d);
  59#endif
  60        parport_writeb(d, DATA(p));
  61}
  62
  63extern __inline__ unsigned char parport_gsc_read_data(struct parport *p)
  64{
  65        unsigned char val = parport_readb (DATA (p));
  66#ifdef DEBUG_PARPORT
  67        printk (KERN_DEBUG "parport_gsc_read_data(%p) = 0x%02x\n",
  68                p, val);
  69#endif
  70        return val;
  71}
  72
  73/* __parport_gsc_frob_control differs from parport_gsc_frob_control in that
  74 * it doesn't do any extra masking. */
  75static __inline__ unsigned char __parport_gsc_frob_control (struct parport *p,
  76                                                           unsigned char mask,
  77                                                           unsigned char val)
  78{
  79        struct parport_gsc_private *priv = p->physport->private_data;
  80        unsigned char ctr = priv->ctr;
  81#ifdef DEBUG_PARPORT
  82        printk (KERN_DEBUG
  83                "__parport_gsc_frob_control(%02x,%02x): %02x -> %02x\n",
  84                mask, val, ctr, ((ctr & ~mask) ^ val) & priv->ctr_writable);
  85#endif
  86        ctr = (ctr & ~mask) ^ val;
  87        ctr &= priv->ctr_writable; /* only write writable bits. */
  88        parport_writeb (ctr, CONTROL (p));
  89        priv->ctr = ctr;        /* Update soft copy */
  90        return ctr;
  91}
  92
  93extern __inline__ void parport_gsc_data_reverse (struct parport *p)
  94{
  95        __parport_gsc_frob_control (p, 0x20, 0x20);
  96}
  97
  98extern __inline__ void parport_gsc_data_forward (struct parport *p)
  99{
 100        __parport_gsc_frob_control (p, 0x20, 0x00);
 101}
 102
 103extern __inline__ void parport_gsc_write_control (struct parport *p,
 104                                                 unsigned char d)
 105{
 106        const unsigned char wm = (PARPORT_CONTROL_STROBE |
 107                                  PARPORT_CONTROL_AUTOFD |
 108                                  PARPORT_CONTROL_INIT |
 109                                  PARPORT_CONTROL_SELECT);
 110
 111        /* Take this out when drivers have adapted to newer interface. */
 112        if (d & 0x20) {
 113                printk (KERN_DEBUG "%s (%s): use data_reverse for this!\n",
 114                        p->name, p->cad->name);
 115                parport_gsc_data_reverse (p);
 116        }
 117
 118        __parport_gsc_frob_control (p, wm, d & wm);
 119}
 120
 121extern __inline__ unsigned char parport_gsc_read_control(struct parport *p)
 122{
 123        const unsigned char rm = (PARPORT_CONTROL_STROBE |
 124                                  PARPORT_CONTROL_AUTOFD |
 125                                  PARPORT_CONTROL_INIT |
 126                                  PARPORT_CONTROL_SELECT);
 127        const struct parport_gsc_private *priv = p->physport->private_data;
 128        return priv->ctr & rm; /* Use soft copy */
 129}
 130
 131extern __inline__ unsigned char parport_gsc_frob_control (struct parport *p,
 132                                                         unsigned char mask,
 133                                                         unsigned char val)
 134{
 135        const unsigned char wm = (PARPORT_CONTROL_STROBE |
 136                                  PARPORT_CONTROL_AUTOFD |
 137                                  PARPORT_CONTROL_INIT |
 138                                  PARPORT_CONTROL_SELECT);
 139
 140        /* Take this out when drivers have adapted to newer interface. */
 141        if (mask & 0x20) {
 142                printk (KERN_DEBUG "%s (%s): use data_%s for this!\n",
 143                        p->name, p->cad->name,
 144                        (val & 0x20) ? "reverse" : "forward");
 145                if (val & 0x20)
 146                        parport_gsc_data_reverse (p);
 147                else
 148                        parport_gsc_data_forward (p);
 149        }
 150
 151        /* Restrict mask and val to control lines. */
 152        mask &= wm;
 153        val &= wm;
 154
 155        return __parport_gsc_frob_control (p, mask, val);
 156}
 157
 158extern __inline__ unsigned char parport_gsc_read_status(struct parport *p)
 159{
 160        return parport_readb (STATUS(p));
 161}
 162
 163
 164extern __inline__ void parport_gsc_disable_irq(struct parport *p)
 165{
 166        __parport_gsc_frob_control (p, 0x10, 0x00);
 167}
 168
 169extern __inline__ void parport_gsc_enable_irq(struct parport *p)
 170{
 171        __parport_gsc_frob_control (p, 0x10, 0x10);
 172}
 173
 174extern void parport_gsc_release_resources(struct parport *p);
 175
 176extern int parport_gsc_claim_resources(struct parport *p);
 177
 178extern void parport_gsc_init_state(struct pardevice *, struct parport_state *s);
 179
 180extern void parport_gsc_save_state(struct parport *p, struct parport_state *s);
 181
 182extern void parport_gsc_restore_state(struct parport *p, struct parport_state *s);
 183
 184extern void parport_gsc_inc_use_count(void);
 185
 186extern void parport_gsc_dec_use_count(void);
 187
 188extern struct parport *parport_gsc_probe_port (unsigned long base,
 189                                              unsigned long base_hi,
 190                                              int irq, int dma,
 191                                              struct pci_dev *dev);
 192
 193#endif
 194