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