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