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