include/linux/parport_pc.h

   1 #ifndef __LINUX_PARPORT_PC_H
   2 #define __LINUX_PARPORT_PC_H
   3
   4 #include <asm/io.h>
   5
   6 /* --- register definitions ------------------------------- */
   7
   8 #define ECONTROL(p) ((p)->base_hi + 0x2)
   9 #define CONFIGB(p)  ((p)->base_hi + 0x1)
  10 #define CONFIGA(p)  ((p)->base_hi + 0x0)
  11 #define FIFO(p)     ((p)->base_hi + 0x0)
  12 #define EPPDATA(p)  ((p)->base    + 0x4)
  13 #define EPPADDR(p)  ((p)->base    + 0x3)
  14 #define CONTROL(p)  ((p)->base    + 0x2)
  15 #define STATUS(p)   ((p)->base    + 0x1)
  16 #define DATA(p)     ((p)->base    + 0x0)
  17
  18 struct parport_pc_private {
  19         /* Contents of CTR. */
  20         unsigned char ctr;
  21
  22         /* Bitmask of writable CTR bits. */
  23         unsigned char ctr_writable;
  24
  25         /* Whether or not there's an ECR. */
  26         int ecr;
  27
  28         /* Number of PWords that FIFO will hold. */
  29         int fifo_depth;
  30
  31         /* Number of bytes per portword. */
  32         int pword;
  33
  34         /* Not used yet. */
  35         int readIntrThreshold;
  36         int writeIntrThreshold;
  37
  38         /* buffer suitable for DMA, if DMA enabled */
  39         char *dma_buf;
  40         dma_addr_t dma_handle;
  41         struct pci_dev *dev;
  42 };
  43
  44 extern __inline__ void parport_pc_write_data(struct parport *p, unsigned char d)
  45 {
  46 #ifdef DEBUG_PARPORT
  47         printk (KERN_DEBUG "parport_pc_write_data(%p,0x%02x)\n", p, d);
  48 #endif
  49         outb(d, DATA(p));
  50 }
  51
  52 extern __inline__ unsigned char parport_pc_read_data(struct parport *p)
  53 {
  54         unsigned char val = inb (DATA (p));
  55 #ifdef DEBUG_PARPORT
  56         printk (KERN_DEBUG "parport_pc_read_data(%p) = 0x%02x\n",
  57                 p, val);
  58 #endif
  59         return val;
  60 }
  61
  62 /* __parport_pc_frob_control differs from parport_pc_frob_control in that
  63  * it doesn't do any extra masking. */
  64 static __inline__ unsigned char __parport_pc_frob_control (struct parport *p,
  65                                                            unsigned char mask,
  66                                                            unsigned char val)
  67 {
  68         struct parport_pc_private *priv = p->physport->private_data;
  69         unsigned char ctr = priv->ctr;
  70 #ifdef DEBUG_PARPORT
  71         printk (KERN_DEBUG
  72                 "__parport_pc_frob_control(%02x,%02x): %02x -> %02x\n",
  73                 mask, val, ctr, ((ctr & ~mask) ^ val) & priv->ctr_writable);
  74 #endif
  75         ctr = (ctr & ~mask) ^ val;
  76         ctr &= priv->ctr_writable; /* only write writable bits. */
  77         outb (ctr, CONTROL (p));
  78         priv->ctr = ctr;        /* Update soft copy */
  79         return ctr;
  80 }
  81
  82 extern __inline__ void parport_pc_data_reverse (struct parport *p)
  83 {
  84         __parport_pc_frob_control (p, 0x20, 0x20);
  85 }
  86
  87 extern __inline__ void parport_pc_data_forward (struct parport *p)
  88 {
  89         __parport_pc_frob_control (p, 0x20, 0x00);
  90 }
  91
  92 extern __inline__ void parport_pc_write_control (struct parport *p,
  93                                                  unsigned char d)
  94 {
  95         const unsigned char wm = (PARPORT_CONTROL_STROBE |
  96                                   PARPORT_CONTROL_AUTOFD |
  97                                   PARPORT_CONTROL_INIT |
  98                                   PARPORT_CONTROL_SELECT);
  99
 100         /* Take this out when drivers have adapted to newer interface. */
 101         if (d & 0x20) {
 102                 printk (KERN_DEBUG "%s (%s): use data_reverse for this!\n",
 103                         p->name, p->cad->name);
 104                 parport_pc_data_reverse (p);
 105         }
 106
 107         __parport_pc_frob_control (p, wm, d & wm);
 108 }
 109
 110 extern __inline__ unsigned char parport_pc_read_control(struct parport *p)
 111 {
 112         const unsigned char rm = (PARPORT_CONTROL_STROBE |
 113                                   PARPORT_CONTROL_AUTOFD |
 114                                   PARPORT_CONTROL_INIT |
 115                                   PARPORT_CONTROL_SELECT);
 116         const struct parport_pc_private *priv = p->physport->private_data;
 117         return priv->ctr & rm; /* Use soft copy */
 118 }
 119
 120 extern __inline__ unsigned char parport_pc_frob_control (struct parport *p,
 121                                                          unsigned char mask,
 122                                                          unsigned char val)
 123 {
 124         const unsigned char wm = (PARPORT_CONTROL_STROBE |
 125                                   PARPORT_CONTROL_AUTOFD |
 126                                   PARPORT_CONTROL_INIT |
 127                                   PARPORT_CONTROL_SELECT);
 128
 129         /* Take this out when drivers have adapted to newer interface. */
 130         if (mask & 0x20) {
 131                 printk (KERN_DEBUG "%s (%s): use data_%s for this!\n",
 132                         p->name, p->cad->name,
 133                         (val & 0x20) ? "reverse" : "forward");
 134                 if (val & 0x20)
 135                         parport_pc_data_reverse (p);
 136                 else
 137                         parport_pc_data_forward (p);
 138         }
 139
 140         /* Restrict mask and val to control lines. */
 141         mask &= wm;
 142         val &= wm;
 143
 144         return __parport_pc_frob_control (p, mask, val);
 145 }
 146
 147 extern __inline__ unsigned char parport_pc_read_status(struct parport *p)
 148 {
 149         return inb(STATUS(p));
 150 }
 151
 152
 153 extern __inline__ void parport_pc_disable_irq(struct parport *p)
 154 {
 155         __parport_pc_frob_control (p, 0x10, 0x00);
 156 }
 157
 158 extern __inline__ void parport_pc_enable_irq(struct parport *p)
 159 {
 160         __parport_pc_frob_control (p, 0x10, 0x10);
 161 }
 162
 163 extern void parport_pc_release_resources(struct parport *p);
 164
 165 extern int parport_pc_claim_resources(struct parport *p);
 166
 167 extern void parport_pc_init_state(struct pardevice *, struct parport_state *s);
 168
 169 extern void parport_pc_save_state(struct parport *p, struct parport_state *s);
 170
 171 extern void parport_pc_restore_state(struct parport *p, struct parport_state *s);
 172
 173 extern void parport_pc_inc_use_count(void);
 174
 175 extern void parport_pc_dec_use_count(void);
 176
 177 /* PCMCIA code will want to get us to look at a port.  Provide a mechanism. */
 178 extern struct parport *parport_pc_probe_port (unsigned long base,
 179                                               unsigned long base_hi,
 180                                               int irq, int dma,
 181                                               struct pci_dev *dev);
 182
 183 #endif