Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
422 | giacomo | 1 | /* $Id: parport.h,v 1.1 2004-01-28 15:26:14 giacomo 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/config.h> |
||
100 | #include <linux/jiffies.h> |
||
101 | #include <linux/proc_fs.h> |
||
102 | #include <linux/spinlock.h> |
||
103 | #include <linux/wait.h> |
||
104 | #include <asm/system.h> |
||
105 | #include <asm/ptrace.h> |
||
106 | #include <asm/semaphore.h> |
||
107 | |||
108 | #define PARPORT_NEED_GENERIC_OPS |
||
109 | |||
110 | /* Define this later. */ |
||
111 | struct parport; |
||
112 | struct pardevice; |
||
113 | |||
114 | struct pc_parport_state { |
||
115 | unsigned int ctr; |
||
116 | unsigned int ecr; |
||
117 | }; |
||
118 | |||
119 | struct ax_parport_state { |
||
120 | unsigned int ctr; |
||
121 | unsigned int ecr; |
||
122 | unsigned int dcsr; |
||
123 | }; |
||
124 | |||
125 | /* used by both parport_amiga and parport_mfc3 */ |
||
126 | struct amiga_parport_state { |
||
127 | unsigned char data; /* ciaa.prb */ |
||
128 | unsigned char datadir; /* ciaa.ddrb */ |
||
129 | unsigned char status; /* ciab.pra & 7 */ |
||
130 | unsigned char statusdir;/* ciab.ddrb & 7 */ |
||
131 | }; |
||
132 | |||
133 | struct parport_state { |
||
134 | union { |
||
135 | struct pc_parport_state pc; |
||
136 | /* ARC has no state. */ |
||
137 | struct ax_parport_state ax; |
||
138 | struct amiga_parport_state amiga; |
||
139 | /* Atari has not state. */ |
||
140 | void *misc; |
||
141 | } u; |
||
142 | }; |
||
143 | |||
144 | struct parport_operations { |
||
145 | /* IBM PC-style virtual registers. */ |
||
146 | void (*write_data)(struct parport *, unsigned char); |
||
147 | unsigned char (*read_data)(struct parport *); |
||
148 | |||
149 | void (*write_control)(struct parport *, unsigned char); |
||
150 | unsigned char (*read_control)(struct parport *); |
||
151 | unsigned char (*frob_control)(struct parport *, unsigned char mask, |
||
152 | unsigned char val); |
||
153 | |||
154 | unsigned char (*read_status)(struct parport *); |
||
155 | |||
156 | /* IRQs. */ |
||
157 | void (*enable_irq)(struct parport *); |
||
158 | void (*disable_irq)(struct parport *); |
||
159 | |||
160 | /* Data direction. */ |
||
161 | void (*data_forward) (struct parport *); |
||
162 | void (*data_reverse) (struct parport *); |
||
163 | |||
164 | /* For core parport code. */ |
||
165 | void (*init_state)(struct pardevice *, struct parport_state *); |
||
166 | void (*save_state)(struct parport *, struct parport_state *); |
||
167 | void (*restore_state)(struct parport *, struct parport_state *); |
||
168 | |||
169 | /* Block read/write */ |
||
170 | size_t (*epp_write_data) (struct parport *port, const void *buf, |
||
171 | size_t len, int flags); |
||
172 | size_t (*epp_read_data) (struct parport *port, void *buf, size_t len, |
||
173 | int flags); |
||
174 | size_t (*epp_write_addr) (struct parport *port, const void *buf, |
||
175 | size_t len, int flags); |
||
176 | size_t (*epp_read_addr) (struct parport *port, void *buf, size_t len, |
||
177 | int flags); |
||
178 | |||
179 | size_t (*ecp_write_data) (struct parport *port, const void *buf, |
||
180 | size_t len, int flags); |
||
181 | size_t (*ecp_read_data) (struct parport *port, void *buf, size_t len, |
||
182 | int flags); |
||
183 | size_t (*ecp_write_addr) (struct parport *port, const void *buf, |
||
184 | size_t len, int flags); |
||
185 | |||
186 | size_t (*compat_write_data) (struct parport *port, const void *buf, |
||
187 | size_t len, int flags); |
||
188 | size_t (*nibble_read_data) (struct parport *port, void *buf, |
||
189 | size_t len, int flags); |
||
190 | size_t (*byte_read_data) (struct parport *port, void *buf, |
||
191 | size_t len, int flags); |
||
192 | struct module *owner; |
||
193 | }; |
||
194 | |||
195 | struct parport_device_info { |
||
196 | parport_device_class class; |
||
197 | const char *class_name; |
||
198 | const char *mfr; |
||
199 | const char *model; |
||
200 | const char *cmdset; |
||
201 | const char *description; |
||
202 | }; |
||
203 | |||
204 | /* Each device can have two callback functions: |
||
205 | * 1) a preemption function, called by the resource manager to request |
||
206 | * that the driver relinquish control of the port. The driver should |
||
207 | * return zero if it agrees to release the port, and nonzero if it |
||
208 | * refuses. Do not call parport_release() - the kernel will do this |
||
209 | * implicitly. |
||
210 | * |
||
211 | * 2) a wake-up function, called by the resource manager to tell drivers |
||
212 | * that the port is available to be claimed. If a driver wants to use |
||
213 | * the port, it should call parport_claim() here. |
||
214 | */ |
||
215 | |||
216 | /* A parallel port device */ |
||
217 | struct pardevice { |
||
218 | const char *name; |
||
219 | struct parport *port; |
||
220 | int daisy; |
||
221 | int (*preempt)(void *); |
||
222 | void (*wakeup)(void *); |
||
223 | void *private; |
||
224 | void (*irq_func)(int, void *, struct pt_regs *); |
||
225 | unsigned int flags; |
||
226 | struct pardevice *next; |
||
227 | struct pardevice *prev; |
||
228 | struct parport_state *state; /* saved status over preemption */ |
||
229 | wait_queue_head_t wait_q; |
||
230 | unsigned long int time; |
||
231 | unsigned long int timeslice; |
||
232 | volatile long int timeout; |
||
233 | unsigned long waiting; /* long req'd for set_bit --RR */ |
||
234 | struct pardevice *waitprev; |
||
235 | struct pardevice *waitnext; |
||
236 | void * sysctl_table; |
||
237 | }; |
||
238 | |||
239 | /* IEEE1284 information */ |
||
240 | |||
241 | /* IEEE1284 phases */ |
||
242 | enum ieee1284_phase { |
||
243 | IEEE1284_PH_FWD_DATA, |
||
244 | IEEE1284_PH_FWD_IDLE, |
||
245 | IEEE1284_PH_TERMINATE, |
||
246 | IEEE1284_PH_NEGOTIATION, |
||
247 | IEEE1284_PH_HBUSY_DNA, |
||
248 | IEEE1284_PH_REV_IDLE, |
||
249 | IEEE1284_PH_HBUSY_DAVAIL, |
||
250 | IEEE1284_PH_REV_DATA, |
||
251 | IEEE1284_PH_ECP_SETUP, |
||
252 | IEEE1284_PH_ECP_FWD_TO_REV, |
||
253 | IEEE1284_PH_ECP_REV_TO_FWD, |
||
254 | IEEE1284_PH_ECP_DIR_UNKNOWN, |
||
255 | }; |
||
256 | struct ieee1284_info { |
||
257 | int mode; |
||
258 | volatile enum ieee1284_phase phase; |
||
259 | struct semaphore irq; |
||
260 | }; |
||
261 | |||
262 | /* A parallel port */ |
||
263 | struct parport { |
||
264 | unsigned long base; /* base address */ |
||
265 | unsigned long base_hi; /* base address (hi - ECR) */ |
||
266 | unsigned int size; /* IO extent */ |
||
267 | const char *name; |
||
268 | unsigned int modes; |
||
269 | int irq; /* interrupt (or -1 for none) */ |
||
270 | int dma; |
||
271 | int muxport; /* which muxport (if any) this is */ |
||
272 | int portnum; /* which physical parallel port (not mux) */ |
||
273 | |||
274 | struct parport *physport; |
||
275 | /* If this is a non-default mux |
||
276 | parport, i.e. we're a clone of a real |
||
277 | physical port, this is a pointer to that |
||
278 | port. The locking is only done in the |
||
279 | real port. For a clone port, the |
||
280 | following structure members are |
||
281 | meaningless: devices, cad, muxsel, |
||
282 | waithead, waittail, flags, pdir, |
||
283 | ieee1284, *_lock. |
||
284 | |||
285 | It this is a default mux parport, or |
||
286 | there is no mux involved, this points to |
||
287 | ourself. */ |
||
288 | |||
289 | struct pardevice *devices; |
||
290 | struct pardevice *cad; /* port owner */ |
||
291 | int daisy; /* currently selected daisy addr */ |
||
292 | int muxsel; /* currently selected mux port */ |
||
293 | |||
294 | struct pardevice *waithead; |
||
295 | struct pardevice *waittail; |
||
296 | |||
297 | struct parport *next; |
||
298 | unsigned int flags; |
||
299 | |||
300 | void *sysctl_table; |
||
301 | struct parport_device_info probe_info[5]; /* 0-3 + non-IEEE1284.3 */ |
||
302 | struct ieee1284_info ieee1284; |
||
303 | |||
304 | struct parport_operations *ops; |
||
305 | void *private_data; /* for lowlevel driver */ |
||
306 | |||
307 | int number; /* port index - the `n' in `parportn' */ |
||
308 | spinlock_t pardevice_lock; |
||
309 | spinlock_t waitlist_lock; |
||
310 | rwlock_t cad_lock; |
||
311 | |||
312 | int spintime; |
||
313 | atomic_t ref_count; |
||
314 | }; |
||
315 | |||
316 | #define DEFAULT_SPIN_TIME 500 /* us */ |
||
317 | |||
318 | struct parport_driver { |
||
319 | const char *name; |
||
320 | void (*attach) (struct parport *); |
||
321 | void (*detach) (struct parport *); |
||
322 | struct parport_driver *next; |
||
323 | }; |
||
324 | |||
325 | /* parport_register_port registers a new parallel port at the given |
||
326 | address (if one does not already exist) and returns a pointer to it. |
||
327 | This entails claiming the I/O region, IRQ and DMA. NULL is returned |
||
328 | if initialisation fails. */ |
||
329 | struct parport *parport_register_port(unsigned long base, int irq, int dma, |
||
330 | struct parport_operations *ops); |
||
331 | |||
332 | /* Once a registered port is ready for high-level drivers to use, the |
||
333 | low-level driver that registered it should announce it. This will |
||
334 | call the high-level drivers' attach() functions (after things like |
||
335 | determining the IEEE 1284.3 topology of the port and collecting |
||
336 | DeviceIDs). */ |
||
337 | void parport_announce_port (struct parport *port); |
||
338 | |||
339 | /* Unregister a port. */ |
||
340 | extern void parport_unregister_port(struct parport *port); |
||
341 | |||
342 | /* parport_enumerate returns a pointer to the linked list of all the |
||
343 | ports in this machine. DON'T USE THIS. Use |
||
344 | parport_register_driver instead. */ |
||
345 | struct parport *parport_enumerate(void); |
||
346 | |||
347 | /* Register a new high-level driver. */ |
||
348 | extern int parport_register_driver (struct parport_driver *); |
||
349 | |||
350 | /* Unregister a high-level driver. */ |
||
351 | extern void parport_unregister_driver (struct parport_driver *); |
||
352 | |||
353 | /* If parport_register_driver doesn't fit your needs, perhaps |
||
354 | * parport_find_xxx does. */ |
||
355 | extern struct parport *parport_find_number (int); |
||
356 | extern struct parport *parport_find_base (unsigned long); |
||
357 | |||
358 | /* Reference counting for ports. */ |
||
359 | extern struct parport *parport_get_port (struct parport *); |
||
360 | extern void parport_put_port (struct parport *); |
||
361 | |||
362 | /* parport_register_device declares that a device is connected to a |
||
363 | port, and tells the kernel all it needs to know. |
||
364 | - pf is the preemption function (may be NULL for no callback) |
||
365 | - kf is the wake-up function (may be NULL for no callback) |
||
366 | - irq_func is the interrupt handler (may be NULL for no interrupts) |
||
367 | - handle is a user pointer that gets handed to callback functions. */ |
||
368 | struct pardevice *parport_register_device(struct parport *port, |
||
369 | const char *name, |
||
370 | int (*pf)(void *), void (*kf)(void *), |
||
371 | void (*irq_func)(int, void *, struct pt_regs *), |
||
372 | int flags, void *handle); |
||
373 | |||
374 | /* parport_unregister unlinks a device from the chain. */ |
||
375 | extern void parport_unregister_device(struct pardevice *dev); |
||
376 | |||
377 | /* parport_claim tries to gain ownership of the port for a particular |
||
378 | driver. This may fail (return non-zero) if another driver is busy. |
||
379 | If this driver has registered an interrupt handler, it will be |
||
380 | enabled. */ |
||
381 | extern int parport_claim(struct pardevice *dev); |
||
382 | |||
383 | /* parport_claim_or_block is the same, but sleeps if the port cannot |
||
384 | be claimed. Return value is 1 if it slept, 0 normally and -errno |
||
385 | on error. */ |
||
386 | extern int parport_claim_or_block(struct pardevice *dev); |
||
387 | |||
388 | /* parport_release reverses a previous parport_claim. This can never |
||
389 | fail, though the effects are undefined (except that they are bad) |
||
390 | if you didn't previously own the port. Once you have released the |
||
391 | port you should make sure that neither your code nor the hardware |
||
392 | on the port tries to initiate any communication without first |
||
393 | re-claiming the port. If you mess with the port state (enabling |
||
394 | ECP for example) you should clean up before releasing the port. */ |
||
395 | |||
396 | extern void parport_release(struct pardevice *dev); |
||
397 | |||
398 | /** |
||
399 | * parport_yield - relinquish a parallel port temporarily |
||
400 | * @dev: a device on the parallel port |
||
401 | * |
||
402 | * This function relinquishes the port if it would be helpful to other |
||
403 | * drivers to do so. Afterwards it tries to reclaim the port using |
||
404 | * parport_claim(), and the return value is the same as for |
||
405 | * parport_claim(). If it fails, the port is left unclaimed and it is |
||
406 | * the driver's responsibility to reclaim the port. |
||
407 | * |
||
408 | * The parport_yield() and parport_yield_blocking() functions are for |
||
409 | * marking points in the driver at which other drivers may claim the |
||
410 | * port and use their devices. Yielding the port is similar to |
||
411 | * releasing it and reclaiming it, but is more efficient because no |
||
412 | * action is taken if there are no other devices needing the port. In |
||
413 | * fact, nothing is done even if there are other devices waiting but |
||
414 | * the current device is still within its "timeslice". The default |
||
415 | * timeslice is half a second, but it can be adjusted via the /proc |
||
416 | * interface. |
||
417 | **/ |
||
418 | static __inline__ int parport_yield(struct pardevice *dev) |
||
419 | { |
||
420 | unsigned long int timeslip = (jiffies - dev->time); |
||
421 | if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice)) |
||
422 | return 0; |
||
423 | parport_release(dev); |
||
424 | return parport_claim(dev); |
||
425 | } |
||
426 | |||
427 | /** |
||
428 | * parport_yield_blocking - relinquish a parallel port temporarily |
||
429 | * @dev: a device on the parallel port |
||
430 | * |
||
431 | * This function relinquishes the port if it would be helpful to other |
||
432 | * drivers to do so. Afterwards it tries to reclaim the port using |
||
433 | * parport_claim_or_block(), and the return value is the same as for |
||
434 | * parport_claim_or_block(). |
||
435 | **/ |
||
436 | static __inline__ int parport_yield_blocking(struct pardevice *dev) |
||
437 | { |
||
438 | unsigned long int timeslip = (jiffies - dev->time); |
||
439 | if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice)) |
||
440 | return 0; |
||
441 | parport_release(dev); |
||
442 | return parport_claim_or_block(dev); |
||
443 | } |
||
444 | |||
445 | /* Flags used to identify what a device does. */ |
||
446 | #define PARPORT_DEV_TRAN 0 /* WARNING !! DEPRECATED !! */ |
||
447 | #define PARPORT_DEV_LURK (1<<0) /* WARNING !! DEPRECATED !! */ |
||
448 | #define PARPORT_DEV_EXCL (1<<1) /* Need exclusive access. */ |
||
449 | |||
450 | #define PARPORT_FLAG_EXCL (1<<1) /* EXCL driver registered. */ |
||
451 | |||
452 | extern int parport_parse_irqs(int, const char *[], int irqval[]); |
||
453 | extern int parport_parse_dmas(int, const char *[], int dmaval[]); |
||
454 | |||
455 | /* IEEE1284 functions */ |
||
456 | extern void parport_ieee1284_interrupt (int, void *, struct pt_regs *); |
||
457 | extern int parport_negotiate (struct parport *, int mode); |
||
458 | extern ssize_t parport_write (struct parport *, const void *buf, size_t len); |
||
459 | extern ssize_t parport_read (struct parport *, void *buf, size_t len); |
||
460 | |||
461 | #define PARPORT_INACTIVITY_O_NONBLOCK 1 |
||
462 | extern long parport_set_timeout (struct pardevice *, long inactivity); |
||
463 | |||
464 | extern int parport_wait_event (struct parport *, long timeout); |
||
465 | extern int parport_wait_peripheral (struct parport *port, |
||
466 | unsigned char mask, |
||
467 | unsigned char val); |
||
468 | extern int parport_poll_peripheral (struct parport *port, |
||
469 | unsigned char mask, |
||
470 | unsigned char val, |
||
471 | int usec); |
||
472 | |||
473 | /* For architectural drivers */ |
||
474 | extern void parport_ieee1284_wakeup (struct parport *port); |
||
475 | extern size_t parport_ieee1284_write_compat (struct parport *, |
||
476 | const void *, size_t, int); |
||
477 | extern size_t parport_ieee1284_read_nibble (struct parport *, |
||
478 | void *, size_t, int); |
||
479 | extern size_t parport_ieee1284_read_byte (struct parport *, |
||
480 | void *, size_t, int); |
||
481 | extern size_t parport_ieee1284_ecp_read_data (struct parport *, |
||
482 | void *, size_t, int); |
||
483 | extern size_t parport_ieee1284_ecp_write_data (struct parport *, |
||
484 | const void *, size_t, int); |
||
485 | extern size_t parport_ieee1284_ecp_write_addr (struct parport *, |
||
486 | const void *, size_t, int); |
||
487 | extern size_t parport_ieee1284_epp_write_data (struct parport *, |
||
488 | const void *, size_t, int); |
||
489 | extern size_t parport_ieee1284_epp_read_data (struct parport *, |
||
490 | void *, size_t, int); |
||
491 | extern size_t parport_ieee1284_epp_write_addr (struct parport *, |
||
492 | const void *, size_t, int); |
||
493 | extern size_t parport_ieee1284_epp_read_addr (struct parport *, |
||
494 | void *, size_t, int); |
||
495 | |||
496 | /* IEEE1284.3 functions */ |
||
497 | extern int parport_daisy_init (struct parport *port); |
||
498 | extern void parport_daisy_fini (struct parport *port); |
||
499 | extern struct pardevice *parport_open (int devnum, const char *name, |
||
500 | int (*pf) (void *), |
||
501 | void (*kf) (void *), |
||
502 | void (*irqf) (int, void *, |
||
503 | struct pt_regs *), |
||
504 | int flags, void *handle); |
||
505 | extern void parport_close (struct pardevice *dev); |
||
506 | extern ssize_t parport_device_id (int devnum, char *buffer, size_t len); |
||
507 | extern int parport_device_num (int parport, int mux, int daisy); |
||
508 | extern int parport_device_coords (int devnum, int *parport, int *mux, |
||
509 | int *daisy); |
||
510 | extern void parport_daisy_deselect_all (struct parport *port); |
||
511 | extern int parport_daisy_select (struct parport *port, int daisy, int mode); |
||
512 | |||
513 | /* For finding devices based on their device ID. Example usage: |
||
514 | int devnum = -1; |
||
515 | while ((devnum = parport_find_class (PARPORT_CLASS_DIGCAM, devnum)) != -1) { |
||
516 | struct pardevice *dev = parport_open (devnum, ...); |
||
517 | ... |
||
518 | } |
||
519 | */ |
||
520 | extern int parport_find_device (const char *mfg, const char *mdl, int from); |
||
521 | extern int parport_find_class (parport_device_class cls, int from); |
||
522 | |||
523 | /* Lowlevel drivers _can_ call this support function to handle irqs. */ |
||
524 | static __inline__ void parport_generic_irq(int irq, struct parport *port, |
||
525 | struct pt_regs *regs) |
||
526 | { |
||
527 | parport_ieee1284_interrupt (irq, port, regs); |
||
528 | read_lock(&port->cad_lock); |
||
529 | if (port->cad && port->cad->irq_func) |
||
530 | port->cad->irq_func(irq, port->cad->private, regs); |
||
531 | read_unlock(&port->cad_lock); |
||
532 | } |
||
533 | |||
534 | /* Prototypes from parport_procfs */ |
||
535 | extern int parport_proc_register(struct parport *pp); |
||
536 | extern int parport_proc_unregister(struct parport *pp); |
||
537 | extern int parport_device_proc_register(struct pardevice *device); |
||
538 | extern int parport_device_proc_unregister(struct pardevice *device); |
||
539 | extern int parport_default_proc_register(void); |
||
540 | extern int parport_default_proc_unregister(void); |
||
541 | |||
542 | /* If PC hardware is the only type supported, we can optimise a bit. */ |
||
543 | #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_OTHER) |
||
544 | |||
545 | #undef PARPORT_NEED_GENERIC_OPS |
||
546 | #include <linux/parport_pc.h> |
||
547 | #define parport_write_data(p,x) parport_pc_write_data(p,x) |
||
548 | #define parport_read_data(p) parport_pc_read_data(p) |
||
549 | #define parport_write_control(p,x) parport_pc_write_control(p,x) |
||
550 | #define parport_read_control(p) parport_pc_read_control(p) |
||
551 | #define parport_frob_control(p,m,v) parport_pc_frob_control(p,m,v) |
||
552 | #define parport_read_status(p) parport_pc_read_status(p) |
||
553 | #define parport_enable_irq(p) parport_pc_enable_irq(p) |
||
554 | #define parport_disable_irq(p) parport_pc_disable_irq(p) |
||
555 | #define parport_data_forward(p) parport_pc_data_forward(p) |
||
556 | #define parport_data_reverse(p) parport_pc_data_reverse(p) |
||
557 | #endif |
||
558 | |||
559 | #ifdef PARPORT_NEED_GENERIC_OPS |
||
560 | /* Generic operations vector through the dispatch table. */ |
||
561 | #define parport_write_data(p,x) (p)->ops->write_data(p,x) |
||
562 | #define parport_read_data(p) (p)->ops->read_data(p) |
||
563 | #define parport_write_control(p,x) (p)->ops->write_control(p,x) |
||
564 | #define parport_read_control(p) (p)->ops->read_control(p) |
||
565 | #define parport_frob_control(p,m,v) (p)->ops->frob_control(p,m,v) |
||
566 | #define parport_read_status(p) (p)->ops->read_status(p) |
||
567 | #define parport_enable_irq(p) (p)->ops->enable_irq(p) |
||
568 | #define parport_disable_irq(p) (p)->ops->disable_irq(p) |
||
569 | #define parport_data_forward(p) (p)->ops->data_forward(p) |
||
570 | #define parport_data_reverse(p) (p)->ops->data_reverse(p) |
||
571 | #endif |
||
572 | |||
573 | #endif /* __KERNEL__ */ |
||
574 | #endif /* _PARPORT_H_ */ |