1 |
1275 |
phoenix |
/* $Id: parport.h,v 1.1.1.1 2004-04-15 02:35:10 phoenix Exp $ */
|
2 |
|
|
|
3 |
|
|
/*
|
4 |
|
|
* Any part of this program may be used in documents licensed under
|
5 |
|
|
* the GNU Free Documentation License, Version 1.1 or any later version
|
6 |
|
|
* published by the Free Software Foundation.
|
7 |
|
|
*/
|
8 |
|
|
|
9 |
|
|
#ifndef _PARPORT_H_
|
10 |
|
|
#define _PARPORT_H_
|
11 |
|
|
|
12 |
|
|
/* Start off with user-visible constants */
|
13 |
|
|
|
14 |
|
|
/* Maximum of 16 ports per machine */
|
15 |
|
|
#define PARPORT_MAX 16
|
16 |
|
|
|
17 |
|
|
/* Magic numbers */
|
18 |
|
|
#define PARPORT_IRQ_NONE -1
|
19 |
|
|
#define PARPORT_DMA_NONE -1
|
20 |
|
|
#define PARPORT_IRQ_AUTO -2
|
21 |
|
|
#define PARPORT_DMA_AUTO -2
|
22 |
|
|
#define PARPORT_DMA_NOFIFO -3
|
23 |
|
|
#define PARPORT_DISABLE -2
|
24 |
|
|
#define PARPORT_IRQ_PROBEONLY -3
|
25 |
|
|
#define PARPORT_IOHI_AUTO -1
|
26 |
|
|
|
27 |
|
|
#define PARPORT_CONTROL_STROBE 0x1
|
28 |
|
|
#define PARPORT_CONTROL_AUTOFD 0x2
|
29 |
|
|
#define PARPORT_CONTROL_INIT 0x4
|
30 |
|
|
#define PARPORT_CONTROL_SELECT 0x8
|
31 |
|
|
|
32 |
|
|
#define PARPORT_STATUS_ERROR 0x8
|
33 |
|
|
#define PARPORT_STATUS_SELECT 0x10
|
34 |
|
|
#define PARPORT_STATUS_PAPEROUT 0x20
|
35 |
|
|
#define PARPORT_STATUS_ACK 0x40
|
36 |
|
|
#define PARPORT_STATUS_BUSY 0x80
|
37 |
|
|
|
38 |
|
|
/* Type classes for Plug-and-Play probe. */
|
39 |
|
|
typedef enum {
|
40 |
|
|
PARPORT_CLASS_LEGACY = 0, /* Non-IEEE1284 device */
|
41 |
|
|
PARPORT_CLASS_PRINTER,
|
42 |
|
|
PARPORT_CLASS_MODEM,
|
43 |
|
|
PARPORT_CLASS_NET,
|
44 |
|
|
PARPORT_CLASS_HDC, /* Hard disk controller */
|
45 |
|
|
PARPORT_CLASS_PCMCIA,
|
46 |
|
|
PARPORT_CLASS_MEDIA, /* Multimedia device */
|
47 |
|
|
PARPORT_CLASS_FDC, /* Floppy disk controller */
|
48 |
|
|
PARPORT_CLASS_PORTS,
|
49 |
|
|
PARPORT_CLASS_SCANNER,
|
50 |
|
|
PARPORT_CLASS_DIGCAM,
|
51 |
|
|
PARPORT_CLASS_OTHER, /* Anything else */
|
52 |
|
|
PARPORT_CLASS_UNSPEC, /* No CLS field in ID */
|
53 |
|
|
PARPORT_CLASS_SCSIADAPTER
|
54 |
|
|
} parport_device_class;
|
55 |
|
|
|
56 |
|
|
/* The "modes" entry in parport is a bit field representing the
|
57 |
|
|
capabilities of the hardware. */
|
58 |
|
|
#define PARPORT_MODE_PCSPP (1<<0) /* IBM PC registers available. */
|
59 |
|
|
#define PARPORT_MODE_TRISTATE (1<<1) /* Can tristate. */
|
60 |
|
|
#define PARPORT_MODE_EPP (1<<2) /* Hardware EPP. */
|
61 |
|
|
#define PARPORT_MODE_ECP (1<<3) /* Hardware ECP. */
|
62 |
|
|
#define PARPORT_MODE_COMPAT (1<<4) /* Hardware 'printer protocol'. */
|
63 |
|
|
#define PARPORT_MODE_DMA (1<<5) /* Hardware can DMA. */
|
64 |
|
|
#define PARPORT_MODE_SAFEININT (1<<6) /* SPP registers accessible in IRQ. */
|
65 |
|
|
|
66 |
|
|
/* IEEE1284 modes:
|
67 |
|
|
Nibble mode, byte mode, ECP, ECPRLE and EPP are their own
|
68 |
|
|
'extensibility request' values. Others are special.
|
69 |
|
|
'Real' ECP modes must have the IEEE1284_MODE_ECP bit set. */
|
70 |
|
|
#define IEEE1284_MODE_NIBBLE 0
|
71 |
|
|
#define IEEE1284_MODE_BYTE (1<<0)
|
72 |
|
|
#define IEEE1284_MODE_COMPAT (1<<8)
|
73 |
|
|
#define IEEE1284_MODE_BECP (1<<9) /* Bounded ECP mode */
|
74 |
|
|
#define IEEE1284_MODE_ECP (1<<4)
|
75 |
|
|
#define IEEE1284_MODE_ECPRLE (IEEE1284_MODE_ECP | (1<<5))
|
76 |
|
|
#define IEEE1284_MODE_ECPSWE (1<<10) /* Software-emulated */
|
77 |
|
|
#define IEEE1284_MODE_EPP (1<<6)
|
78 |
|
|
#define IEEE1284_MODE_EPPSL (1<<11) /* EPP 1.7 */
|
79 |
|
|
#define IEEE1284_MODE_EPPSWE (1<<12) /* Software-emulated */
|
80 |
|
|
#define IEEE1284_DEVICEID (1<<2) /* This is a flag */
|
81 |
|
|
#define IEEE1284_EXT_LINK (1<<14) /* This flag causes the
|
82 |
|
|
* extensibility link to
|
83 |
|
|
* be requested, using
|
84 |
|
|
* bits 0-6. */
|
85 |
|
|
|
86 |
|
|
/* For the benefit of parport_read/write, you can use these with
|
87 |
|
|
* parport_negotiate to use address operations. They have no effect
|
88 |
|
|
* other than to make parport_read/write use address transfers. */
|
89 |
|
|
#define IEEE1284_ADDR (1<<13) /* This is a flag */
|
90 |
|
|
#define IEEE1284_DATA 0 /* So is this */
|
91 |
|
|
|
92 |
|
|
/* Flags for block transfer operations. */
|
93 |
|
|
#define PARPORT_EPP_FAST (1<<0) /* Unreliable counts. */
|
94 |
|
|
#define PARPORT_W91284PIC (1<<1) /* have a Warp9 w91284pic in the device */
|
95 |
|
|
|
96 |
|
|
/* The rest is for the kernel only */
|
97 |
|
|
#ifdef __KERNEL__
|
98 |
|
|
|
99 |
|
|
#include <linux/wait.h>
|
100 |
|
|
#include <linux/spinlock.h>
|
101 |
|
|
#include <asm/system.h>
|
102 |
|
|
#include <asm/ptrace.h>
|
103 |
|
|
#include <asm/semaphore.h>
|
104 |
|
|
#include <linux/proc_fs.h>
|
105 |
|
|
#include <linux/config.h>
|
106 |
|
|
|
107 |
|
|
#define PARPORT_NEED_GENERIC_OPS
|
108 |
|
|
|
109 |
|
|
/* Define this later. */
|
110 |
|
|
struct parport;
|
111 |
|
|
struct pardevice;
|
112 |
|
|
|
113 |
|
|
struct pc_parport_state {
|
114 |
|
|
unsigned int ctr;
|
115 |
|
|
unsigned int ecr;
|
116 |
|
|
};
|
117 |
|
|
|
118 |
|
|
struct ax_parport_state {
|
119 |
|
|
unsigned int ctr;
|
120 |
|
|
unsigned int ecr;
|
121 |
|
|
unsigned int dcsr;
|
122 |
|
|
};
|
123 |
|
|
|
124 |
|
|
/* used by both parport_amiga and parport_mfc3 */
|
125 |
|
|
struct amiga_parport_state {
|
126 |
|
|
unsigned char data; /* ciaa.prb */
|
127 |
|
|
unsigned char datadir; /* ciaa.ddrb */
|
128 |
|
|
unsigned char status; /* ciab.pra & 7 */
|
129 |
|
|
unsigned char statusdir;/* ciab.ddrb & 7 */
|
130 |
|
|
};
|
131 |
|
|
|
132 |
|
|
struct parport_state {
|
133 |
|
|
union {
|
134 |
|
|
struct pc_parport_state pc;
|
135 |
|
|
/* ARC has no state. */
|
136 |
|
|
struct ax_parport_state ax;
|
137 |
|
|
struct amiga_parport_state amiga;
|
138 |
|
|
/* Atari has not state. */
|
139 |
|
|
void *misc;
|
140 |
|
|
} u;
|
141 |
|
|
};
|
142 |
|
|
|
143 |
|
|
struct parport_operations {
|
144 |
|
|
/* IBM PC-style virtual registers. */
|
145 |
|
|
void (*write_data)(struct parport *, unsigned char);
|
146 |
|
|
unsigned char (*read_data)(struct parport *);
|
147 |
|
|
|
148 |
|
|
void (*write_control)(struct parport *, unsigned char);
|
149 |
|
|
unsigned char (*read_control)(struct parport *);
|
150 |
|
|
unsigned char (*frob_control)(struct parport *, unsigned char mask,
|
151 |
|
|
unsigned char val);
|
152 |
|
|
|
153 |
|
|
unsigned char (*read_status)(struct parport *);
|
154 |
|
|
|
155 |
|
|
/* IRQs. */
|
156 |
|
|
void (*enable_irq)(struct parport *);
|
157 |
|
|
void (*disable_irq)(struct parport *);
|
158 |
|
|
|
159 |
|
|
/* Data direction. */
|
160 |
|
|
void (*data_forward) (struct parport *);
|
161 |
|
|
void (*data_reverse) (struct parport *);
|
162 |
|
|
|
163 |
|
|
/* For core parport code. */
|
164 |
|
|
void (*init_state)(struct pardevice *, struct parport_state *);
|
165 |
|
|
void (*save_state)(struct parport *, struct parport_state *);
|
166 |
|
|
void (*restore_state)(struct parport *, struct parport_state *);
|
167 |
|
|
|
168 |
|
|
void (*inc_use_count)(void);
|
169 |
|
|
void (*dec_use_count)(void);
|
170 |
|
|
|
171 |
|
|
/* Block read/write */
|
172 |
|
|
size_t (*epp_write_data) (struct parport *port, const void *buf,
|
173 |
|
|
size_t len, int flags);
|
174 |
|
|
size_t (*epp_read_data) (struct parport *port, void *buf, size_t len,
|
175 |
|
|
int flags);
|
176 |
|
|
size_t (*epp_write_addr) (struct parport *port, const void *buf,
|
177 |
|
|
size_t len, int flags);
|
178 |
|
|
size_t (*epp_read_addr) (struct parport *port, void *buf, size_t len,
|
179 |
|
|
int flags);
|
180 |
|
|
|
181 |
|
|
size_t (*ecp_write_data) (struct parport *port, const void *buf,
|
182 |
|
|
size_t len, int flags);
|
183 |
|
|
size_t (*ecp_read_data) (struct parport *port, void *buf, size_t len,
|
184 |
|
|
int flags);
|
185 |
|
|
size_t (*ecp_write_addr) (struct parport *port, const void *buf,
|
186 |
|
|
size_t len, int flags);
|
187 |
|
|
|
188 |
|
|
size_t (*compat_write_data) (struct parport *port, const void *buf,
|
189 |
|
|
size_t len, int flags);
|
190 |
|
|
size_t (*nibble_read_data) (struct parport *port, void *buf,
|
191 |
|
|
size_t len, int flags);
|
192 |
|
|
size_t (*byte_read_data) (struct parport *port, void *buf,
|
193 |
|
|
size_t len, int flags);
|
194 |
|
|
};
|
195 |
|
|
|
196 |
|
|
struct parport_device_info {
|
197 |
|
|
parport_device_class class;
|
198 |
|
|
const char *class_name;
|
199 |
|
|
const char *mfr;
|
200 |
|
|
const char *model;
|
201 |
|
|
const char *cmdset;
|
202 |
|
|
const char *description;
|
203 |
|
|
};
|
204 |
|
|
|
205 |
|
|
/* Each device can have two callback functions:
|
206 |
|
|
* 1) a preemption function, called by the resource manager to request
|
207 |
|
|
* that the driver relinquish control of the port. The driver should
|
208 |
|
|
* return zero if it agrees to release the port, and nonzero if it
|
209 |
|
|
* refuses. Do not call parport_release() - the kernel will do this
|
210 |
|
|
* implicitly.
|
211 |
|
|
*
|
212 |
|
|
* 2) a wake-up function, called by the resource manager to tell drivers
|
213 |
|
|
* that the port is available to be claimed. If a driver wants to use
|
214 |
|
|
* the port, it should call parport_claim() here.
|
215 |
|
|
*/
|
216 |
|
|
|
217 |
|
|
/* A parallel port device */
|
218 |
|
|
struct pardevice {
|
219 |
|
|
const char *name;
|
220 |
|
|
struct parport *port;
|
221 |
|
|
int daisy;
|
222 |
|
|
int (*preempt)(void *);
|
223 |
|
|
void (*wakeup)(void *);
|
224 |
|
|
void *private;
|
225 |
|
|
void (*irq_func)(int, void *, struct pt_regs *);
|
226 |
|
|
unsigned int flags;
|
227 |
|
|
struct pardevice *next;
|
228 |
|
|
struct pardevice *prev;
|
229 |
|
|
struct parport_state *state; /* saved status over preemption */
|
230 |
|
|
wait_queue_head_t wait_q;
|
231 |
|
|
unsigned long int time;
|
232 |
|
|
unsigned long int timeslice;
|
233 |
|
|
volatile long int timeout;
|
234 |
|
|
unsigned long waiting; /* long req'd for set_bit --RR */
|
235 |
|
|
struct pardevice *waitprev;
|
236 |
|
|
struct pardevice *waitnext;
|
237 |
|
|
void * sysctl_table;
|
238 |
|
|
};
|
239 |
|
|
|
240 |
|
|
/* IEEE1284 information */
|
241 |
|
|
|
242 |
|
|
/* IEEE1284 phases */
|
243 |
|
|
enum ieee1284_phase {
|
244 |
|
|
IEEE1284_PH_FWD_DATA,
|
245 |
|
|
IEEE1284_PH_FWD_IDLE,
|
246 |
|
|
IEEE1284_PH_TERMINATE,
|
247 |
|
|
IEEE1284_PH_NEGOTIATION,
|
248 |
|
|
IEEE1284_PH_HBUSY_DNA,
|
249 |
|
|
IEEE1284_PH_REV_IDLE,
|
250 |
|
|
IEEE1284_PH_HBUSY_DAVAIL,
|
251 |
|
|
IEEE1284_PH_REV_DATA,
|
252 |
|
|
IEEE1284_PH_ECP_SETUP,
|
253 |
|
|
IEEE1284_PH_ECP_FWD_TO_REV,
|
254 |
|
|
IEEE1284_PH_ECP_REV_TO_FWD,
|
255 |
|
|
IEEE1284_PH_ECP_DIR_UNKNOWN,
|
256 |
|
|
};
|
257 |
|
|
struct ieee1284_info {
|
258 |
|
|
int mode;
|
259 |
|
|
volatile enum ieee1284_phase phase;
|
260 |
|
|
struct semaphore irq;
|
261 |
|
|
};
|
262 |
|
|
|
263 |
|
|
/* A parallel port */
|
264 |
|
|
struct parport {
|
265 |
|
|
unsigned long base; /* base address */
|
266 |
|
|
unsigned long base_hi; /* base address (hi - ECR) */
|
267 |
|
|
unsigned int size; /* IO extent */
|
268 |
|
|
const char *name;
|
269 |
|
|
unsigned int modes;
|
270 |
|
|
int irq; /* interrupt (or -1 for none) */
|
271 |
|
|
int dma;
|
272 |
|
|
int muxport; /* which muxport (if any) this is */
|
273 |
|
|
int portnum; /* which physical parallel port (not mux) */
|
274 |
|
|
|
275 |
|
|
struct parport *physport;
|
276 |
|
|
/* If this is a non-default mux
|
277 |
|
|
parport, i.e. we're a clone of a real
|
278 |
|
|
physical port, this is a pointer to that
|
279 |
|
|
port. The locking is only done in the
|
280 |
|
|
real port. For a clone port, the
|
281 |
|
|
following structure members are
|
282 |
|
|
meaningless: devices, cad, muxsel,
|
283 |
|
|
waithead, waittail, flags, pdir,
|
284 |
|
|
ieee1284, *_lock.
|
285 |
|
|
|
286 |
|
|
It this is a default mux parport, or
|
287 |
|
|
there is no mux involved, this points to
|
288 |
|
|
ourself. */
|
289 |
|
|
|
290 |
|
|
struct pardevice *devices;
|
291 |
|
|
struct pardevice *cad; /* port owner */
|
292 |
|
|
int daisy; /* currently selected daisy addr */
|
293 |
|
|
int muxsel; /* currently selected mux port */
|
294 |
|
|
|
295 |
|
|
struct pardevice *waithead;
|
296 |
|
|
struct pardevice *waittail;
|
297 |
|
|
|
298 |
|
|
struct parport *next;
|
299 |
|
|
unsigned int flags;
|
300 |
|
|
|
301 |
|
|
void *sysctl_table;
|
302 |
|
|
struct parport_device_info probe_info[5]; /* 0-3 + non-IEEE1284.3 */
|
303 |
|
|
struct ieee1284_info ieee1284;
|
304 |
|
|
|
305 |
|
|
struct parport_operations *ops;
|
306 |
|
|
void *private_data; /* for lowlevel driver */
|
307 |
|
|
|
308 |
|
|
int number; /* port index - the `n' in `parportn' */
|
309 |
|
|
spinlock_t pardevice_lock;
|
310 |
|
|
spinlock_t waitlist_lock;
|
311 |
|
|
rwlock_t cad_lock;
|
312 |
|
|
|
313 |
|
|
int spintime;
|
314 |
|
|
atomic_t ref_count;
|
315 |
|
|
};
|
316 |
|
|
|
317 |
|
|
#define DEFAULT_SPIN_TIME 500 /* us */
|
318 |
|
|
|
319 |
|
|
struct parport_driver {
|
320 |
|
|
const char *name;
|
321 |
|
|
void (*attach) (struct parport *);
|
322 |
|
|
void (*detach) (struct parport *);
|
323 |
|
|
struct parport_driver *next;
|
324 |
|
|
};
|
325 |
|
|
|
326 |
|
|
/* parport_register_port registers a new parallel port at the given
|
327 |
|
|
address (if one does not already exist) and returns a pointer to it.
|
328 |
|
|
This entails claiming the I/O region, IRQ and DMA. NULL is returned
|
329 |
|
|
if initialisation fails. */
|
330 |
|
|
struct parport *parport_register_port(unsigned long base, int irq, int dma,
|
331 |
|
|
struct parport_operations *ops);
|
332 |
|
|
|
333 |
|
|
/* Once a registered port is ready for high-level drivers to use, the
|
334 |
|
|
low-level driver that registered it should announce it. This will
|
335 |
|
|
call the high-level drivers' attach() functions (after things like
|
336 |
|
|
determining the IEEE 1284.3 topology of the port and collecting
|
337 |
|
|
DeviceIDs). */
|
338 |
|
|
void parport_announce_port (struct parport *port);
|
339 |
|
|
|
340 |
|
|
/* Unregister a port. */
|
341 |
|
|
extern void parport_unregister_port(struct parport *port);
|
342 |
|
|
|
343 |
|
|
/* parport_enumerate returns a pointer to the linked list of all the
|
344 |
|
|
ports in this machine. DON'T USE THIS. Use
|
345 |
|
|
parport_register_driver instead. */
|
346 |
|
|
struct parport *parport_enumerate(void);
|
347 |
|
|
|
348 |
|
|
/* Register a new high-level driver. */
|
349 |
|
|
extern int parport_register_driver (struct parport_driver *);
|
350 |
|
|
|
351 |
|
|
/* Unregister a high-level driver. */
|
352 |
|
|
extern void parport_unregister_driver (struct parport_driver *);
|
353 |
|
|
|
354 |
|
|
/* If parport_register_driver doesn't fit your needs, perhaps
|
355 |
|
|
* parport_find_xxx does. */
|
356 |
|
|
extern struct parport *parport_find_number (int);
|
357 |
|
|
extern struct parport *parport_find_base (unsigned long);
|
358 |
|
|
|
359 |
|
|
/* Reference counting for ports. */
|
360 |
|
|
extern struct parport *parport_get_port (struct parport *);
|
361 |
|
|
extern void parport_put_port (struct parport *);
|
362 |
|
|
|
363 |
|
|
/* parport_register_device declares that a device is connected to a
|
364 |
|
|
port, and tells the kernel all it needs to know.
|
365 |
|
|
- pf is the preemption function (may be NULL for no callback)
|
366 |
|
|
- kf is the wake-up function (may be NULL for no callback)
|
367 |
|
|
- irq_func is the interrupt handler (may be NULL for no interrupts)
|
368 |
|
|
- handle is a user pointer that gets handed to callback functions. */
|
369 |
|
|
struct pardevice *parport_register_device(struct parport *port,
|
370 |
|
|
const char *name,
|
371 |
|
|
int (*pf)(void *), void (*kf)(void *),
|
372 |
|
|
void (*irq_func)(int, void *, struct pt_regs *),
|
373 |
|
|
int flags, void *handle);
|
374 |
|
|
|
375 |
|
|
/* parport_unregister unlinks a device from the chain. */
|
376 |
|
|
extern void parport_unregister_device(struct pardevice *dev);
|
377 |
|
|
|
378 |
|
|
/* parport_claim tries to gain ownership of the port for a particular
|
379 |
|
|
driver. This may fail (return non-zero) if another driver is busy.
|
380 |
|
|
If this driver has registered an interrupt handler, it will be
|
381 |
|
|
enabled. */
|
382 |
|
|
extern int parport_claim(struct pardevice *dev);
|
383 |
|
|
|
384 |
|
|
/* parport_claim_or_block is the same, but sleeps if the port cannot
|
385 |
|
|
be claimed. Return value is 1 if it slept, 0 normally and -errno
|
386 |
|
|
on error. */
|
387 |
|
|
extern int parport_claim_or_block(struct pardevice *dev);
|
388 |
|
|
|
389 |
|
|
/* parport_release reverses a previous parport_claim. This can never
|
390 |
|
|
fail, though the effects are undefined (except that they are bad)
|
391 |
|
|
if you didn't previously own the port. Once you have released the
|
392 |
|
|
port you should make sure that neither your code nor the hardware
|
393 |
|
|
on the port tries to initiate any communication without first
|
394 |
|
|
re-claiming the port. If you mess with the port state (enabling
|
395 |
|
|
ECP for example) you should clean up before releasing the port. */
|
396 |
|
|
|
397 |
|
|
extern void parport_release(struct pardevice *dev);
|
398 |
|
|
|
399 |
|
|
/**
|
400 |
|
|
* parport_yield - relinquish a parallel port temporarily
|
401 |
|
|
* @dev: a device on the parallel port
|
402 |
|
|
*
|
403 |
|
|
* This function relinquishes the port if it would be helpful to other
|
404 |
|
|
* drivers to do so. Afterwards it tries to reclaim the port using
|
405 |
|
|
* parport_claim(), and the return value is the same as for
|
406 |
|
|
* parport_claim(). If it fails, the port is left unclaimed and it is
|
407 |
|
|
* the driver's responsibility to reclaim the port.
|
408 |
|
|
*
|
409 |
|
|
* The parport_yield() and parport_yield_blocking() functions are for
|
410 |
|
|
* marking points in the driver at which other drivers may claim the
|
411 |
|
|
* port and use their devices. Yielding the port is similar to
|
412 |
|
|
* releasing it and reclaiming it, but is more efficient because no
|
413 |
|
|
* action is taken if there are no other devices needing the port. In
|
414 |
|
|
* fact, nothing is done even if there are other devices waiting but
|
415 |
|
|
* the current device is still within its "timeslice". The default
|
416 |
|
|
* timeslice is half a second, but it can be adjusted via the /proc
|
417 |
|
|
* interface.
|
418 |
|
|
**/
|
419 |
|
|
static __inline__ int parport_yield(struct pardevice *dev)
|
420 |
|
|
{
|
421 |
|
|
unsigned long int timeslip = (jiffies - dev->time);
|
422 |
|
|
if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice))
|
423 |
|
|
return 0;
|
424 |
|
|
parport_release(dev);
|
425 |
|
|
return parport_claim(dev);
|
426 |
|
|
}
|
427 |
|
|
|
428 |
|
|
/**
|
429 |
|
|
* parport_yield_blocking - relinquish a parallel port temporarily
|
430 |
|
|
* @dev: a device on the parallel port
|
431 |
|
|
*
|
432 |
|
|
* This function relinquishes the port if it would be helpful to other
|
433 |
|
|
* drivers to do so. Afterwards it tries to reclaim the port using
|
434 |
|
|
* parport_claim_or_block(), and the return value is the same as for
|
435 |
|
|
* parport_claim_or_block().
|
436 |
|
|
**/
|
437 |
|
|
static __inline__ int parport_yield_blocking(struct pardevice *dev)
|
438 |
|
|
{
|
439 |
|
|
unsigned long int timeslip = (jiffies - dev->time);
|
440 |
|
|
if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice))
|
441 |
|
|
return 0;
|
442 |
|
|
parport_release(dev);
|
443 |
|
|
return parport_claim_or_block(dev);
|
444 |
|
|
}
|
445 |
|
|
|
446 |
|
|
/* Flags used to identify what a device does. */
|
447 |
|
|
#define PARPORT_DEV_TRAN 0 /* WARNING !! DEPRECATED !! */
|
448 |
|
|
#define PARPORT_DEV_LURK (1<<0) /* WARNING !! DEPRECATED !! */
|
449 |
|
|
#define PARPORT_DEV_EXCL (1<<1) /* Need exclusive access. */
|
450 |
|
|
|
451 |
|
|
#define PARPORT_FLAG_EXCL (1<<1) /* EXCL driver registered. */
|
452 |
|
|
|
453 |
|
|
extern int parport_parse_irqs(int, const char *[], int irqval[]);
|
454 |
|
|
extern int parport_parse_dmas(int, const char *[], int dmaval[]);
|
455 |
|
|
|
456 |
|
|
/* IEEE1284 functions */
|
457 |
|
|
extern void parport_ieee1284_interrupt (int, void *, struct pt_regs *);
|
458 |
|
|
extern int parport_negotiate (struct parport *, int mode);
|
459 |
|
|
extern ssize_t parport_write (struct parport *, const void *buf, size_t len);
|
460 |
|
|
extern ssize_t parport_read (struct parport *, void *buf, size_t len);
|
461 |
|
|
|
462 |
|
|
#define PARPORT_INACTIVITY_O_NONBLOCK 1
|
463 |
|
|
extern long parport_set_timeout (struct pardevice *, long inactivity);
|
464 |
|
|
|
465 |
|
|
extern int parport_wait_event (struct parport *, long timeout);
|
466 |
|
|
extern int parport_wait_peripheral (struct parport *port,
|
467 |
|
|
unsigned char mask,
|
468 |
|
|
unsigned char val);
|
469 |
|
|
extern int parport_poll_peripheral (struct parport *port,
|
470 |
|
|
unsigned char mask,
|
471 |
|
|
unsigned char val,
|
472 |
|
|
int usec);
|
473 |
|
|
|
474 |
|
|
/* For architectural drivers */
|
475 |
|
|
extern void parport_ieee1284_wakeup (struct parport *port);
|
476 |
|
|
extern size_t parport_ieee1284_write_compat (struct parport *,
|
477 |
|
|
const void *, size_t, int);
|
478 |
|
|
extern size_t parport_ieee1284_read_nibble (struct parport *,
|
479 |
|
|
void *, size_t, int);
|
480 |
|
|
extern size_t parport_ieee1284_read_byte (struct parport *,
|
481 |
|
|
void *, size_t, int);
|
482 |
|
|
extern size_t parport_ieee1284_ecp_read_data (struct parport *,
|
483 |
|
|
void *, size_t, int);
|
484 |
|
|
extern size_t parport_ieee1284_ecp_write_data (struct parport *,
|
485 |
|
|
const void *, size_t, int);
|
486 |
|
|
extern size_t parport_ieee1284_ecp_write_addr (struct parport *,
|
487 |
|
|
const void *, size_t, int);
|
488 |
|
|
extern size_t parport_ieee1284_epp_write_data (struct parport *,
|
489 |
|
|
const void *, size_t, int);
|
490 |
|
|
extern size_t parport_ieee1284_epp_read_data (struct parport *,
|
491 |
|
|
void *, size_t, int);
|
492 |
|
|
extern size_t parport_ieee1284_epp_write_addr (struct parport *,
|
493 |
|
|
const void *, size_t, int);
|
494 |
|
|
extern size_t parport_ieee1284_epp_read_addr (struct parport *,
|
495 |
|
|
void *, size_t, int);
|
496 |
|
|
|
497 |
|
|
/* IEEE1284.3 functions */
|
498 |
|
|
extern int parport_daisy_init (struct parport *port);
|
499 |
|
|
extern void parport_daisy_fini (struct parport *port);
|
500 |
|
|
extern struct pardevice *parport_open (int devnum, const char *name,
|
501 |
|
|
int (*pf) (void *),
|
502 |
|
|
void (*kf) (void *),
|
503 |
|
|
void (*irqf) (int, void *,
|
504 |
|
|
struct pt_regs *),
|
505 |
|
|
int flags, void *handle);
|
506 |
|
|
extern void parport_close (struct pardevice *dev);
|
507 |
|
|
extern ssize_t parport_device_id (int devnum, char *buffer, size_t len);
|
508 |
|
|
extern int parport_device_num (int parport, int mux, int daisy);
|
509 |
|
|
extern int parport_device_coords (int devnum, int *parport, int *mux,
|
510 |
|
|
int *daisy);
|
511 |
|
|
extern void parport_daisy_deselect_all (struct parport *port);
|
512 |
|
|
extern int parport_daisy_select (struct parport *port, int daisy, int mode);
|
513 |
|
|
|
514 |
|
|
/* For finding devices based on their device ID. Example usage:
|
515 |
|
|
int devnum = -1;
|
516 |
|
|
while ((devnum = parport_find_class (PARPORT_CLASS_DIGCAM, devnum)) != -1) {
|
517 |
|
|
struct pardevice *dev = parport_open (devnum, ...);
|
518 |
|
|
...
|
519 |
|
|
}
|
520 |
|
|
*/
|
521 |
|
|
extern int parport_find_device (const char *mfg, const char *mdl, int from);
|
522 |
|
|
extern int parport_find_class (parport_device_class cls, int from);
|
523 |
|
|
|
524 |
|
|
/* Lowlevel drivers _can_ call this support function to handle irqs. */
|
525 |
|
|
static __inline__ void parport_generic_irq(int irq, struct parport *port,
|
526 |
|
|
struct pt_regs *regs)
|
527 |
|
|
{
|
528 |
|
|
parport_ieee1284_interrupt (irq, port, regs);
|
529 |
|
|
read_lock(&port->cad_lock);
|
530 |
|
|
if (port->cad && port->cad->irq_func)
|
531 |
|
|
port->cad->irq_func(irq, port->cad->private, regs);
|
532 |
|
|
read_unlock(&port->cad_lock);
|
533 |
|
|
}
|
534 |
|
|
|
535 |
|
|
/* Prototypes from parport_procfs */
|
536 |
|
|
extern int parport_proc_register(struct parport *pp);
|
537 |
|
|
extern int parport_proc_unregister(struct parport *pp);
|
538 |
|
|
extern int parport_device_proc_register(struct pardevice *device);
|
539 |
|
|
extern int parport_device_proc_unregister(struct pardevice *device);
|
540 |
|
|
extern int parport_default_proc_register(void);
|
541 |
|
|
extern int parport_default_proc_unregister(void);
|
542 |
|
|
|
543 |
|
|
extern void dec_parport_count(void);
|
544 |
|
|
extern void inc_parport_count(void);
|
545 |
|
|
|
546 |
|
|
/* If PC hardware is the only type supported, we can optimise a bit. */
|
547 |
|
|
#if (defined(CONFIG_PARPORT_PC) || defined(CONFIG_PARPORT_PC_MODULE)) && !(defined(CONFIG_PARPORT_ARC) || defined(CONFIG_PARPORT_ARC_MODULE)) && !(defined(CONFIG_PARPORT_AMIGA) || defined(CONFIG_PARPORT_AMIGA_MODULE)) && !(defined(CONFIG_PARPORT_MFC3) || defined(CONFIG_PARPORT_MFC3_MODULE)) && !(defined(CONFIG_PARPORT_ATARI) || defined(CONFIG_PARPORT_ATARI_MODULE)) && !(defined(CONFIG_USB_USS720) || defined(CONFIG_USB_USS720_MODULE)) && !(defined(CONFIG_PARPORT_SUNBPP) || defined(CONFIG_PARPORT_SUNBPP_MODULE)) && !(defined(CONFIG_PARPORT_GSC) || defined(CONFIG_PARPORT_GSC_MODULE)) && !defined(CONFIG_PARPORT_OTHER)
|
548 |
|
|
|
549 |
|
|
#undef PARPORT_NEED_GENERIC_OPS
|
550 |
|
|
#include <linux/parport_pc.h>
|
551 |
|
|
#define parport_write_data(p,x) parport_pc_write_data(p,x)
|
552 |
|
|
#define parport_read_data(p) parport_pc_read_data(p)
|
553 |
|
|
#define parport_write_control(p,x) parport_pc_write_control(p,x)
|
554 |
|
|
#define parport_read_control(p) parport_pc_read_control(p)
|
555 |
|
|
#define parport_frob_control(p,m,v) parport_pc_frob_control(p,m,v)
|
556 |
|
|
#define parport_read_status(p) parport_pc_read_status(p)
|
557 |
|
|
#define parport_enable_irq(p) parport_pc_enable_irq(p)
|
558 |
|
|
#define parport_disable_irq(p) parport_pc_disable_irq(p)
|
559 |
|
|
#define parport_data_forward(p) parport_pc_data_forward(p)
|
560 |
|
|
#define parport_data_reverse(p) parport_pc_data_reverse(p)
|
561 |
|
|
#endif
|
562 |
|
|
|
563 |
|
|
#ifdef PARPORT_NEED_GENERIC_OPS
|
564 |
|
|
/* Generic operations vector through the dispatch table. */
|
565 |
|
|
#define parport_write_data(p,x) (p)->ops->write_data(p,x)
|
566 |
|
|
#define parport_read_data(p) (p)->ops->read_data(p)
|
567 |
|
|
#define parport_write_control(p,x) (p)->ops->write_control(p,x)
|
568 |
|
|
#define parport_read_control(p) (p)->ops->read_control(p)
|
569 |
|
|
#define parport_frob_control(p,m,v) (p)->ops->frob_control(p,m,v)
|
570 |
|
|
#define parport_read_status(p) (p)->ops->read_status(p)
|
571 |
|
|
#define parport_enable_irq(p) (p)->ops->enable_irq(p)
|
572 |
|
|
#define parport_disable_irq(p) (p)->ops->disable_irq(p)
|
573 |
|
|
#define parport_data_forward(p) (p)->ops->data_forward(p)
|
574 |
|
|
#define parport_data_reverse(p) (p)->ops->data_reverse(p)
|
575 |
|
|
#endif
|
576 |
|
|
|
577 |
|
|
#endif /* __KERNEL__ */
|
578 |
|
|
#endif /* _PARPORT_H_ */
|