Subversion Repositories shark

Rev

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_ */