mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 20:02:17 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
Here is the big set of char/misc and other driver subsystem updates for 6.5-rc1. Lots of different, tiny, stuff in here, from a range of smaller driver subsystems, including pulls from some substems directly: - IIO driver updates and additions - W1 driver updates and fixes (and a new maintainer!) - FPGA driver updates and fixes - Counter driver updates - Extcon driver updates - Interconnect driver updates - Coresight driver updates - mfd tree tag merge needed for other updates on top of that, lots of small driver updates as patches, including: - static const updates for class structures - nvmem driver updates - pcmcia driver fix - lots of other small driver updates and fixes All of these have been in linux-next for a while with no reported problems. Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> -----BEGIN PGP SIGNATURE----- iG0EABECAC0WIQT0tgzFv3jCIUoxPcsxR9QN2y37KQUCZKKNMw8cZ3JlZ0Brcm9h aC5jb20ACgkQMUfUDdst+ylhlQCfZrtz8RIbau8zbzh/CKpKBOmvHp4An3V64hbz recBPLH0ZACKl0wPl4iZ =A83A -----END PGP SIGNATURE----- Merge tag 'char-misc-6.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc Pull Char/Misc updates from Greg KH: "Here is the big set of char/misc and other driver subsystem updates for 6.5-rc1. Lots of different, tiny, stuff in here, from a range of smaller driver subsystems, including pulls from some substems directly: - IIO driver updates and additions - W1 driver updates and fixes (and a new maintainer!) - FPGA driver updates and fixes - Counter driver updates - Extcon driver updates - Interconnect driver updates - Coresight driver updates - mfd tree tag merge needed for other updates on top of that, lots of small driver updates as patches, including: - static const updates for class structures - nvmem driver updates - pcmcia driver fix - lots of other small driver updates and fixes All of these have been in linux-next for a while with no reported problems" * tag 'char-misc-6.5-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (243 commits) bsr: fix build problem with bsr_class static cleanup comedi: make all 'class' structures const char: xillybus: make xillybus_class a static const structure xilinx_hwicap: make icap_class a static const structure virtio_console: make port class a static const structure ppdev: make ppdev_class a static const structure char: misc: make misc_class a static const structure /dev/mem: make mem_class a static const structure char: lp: make lp_class a static const structure dsp56k: make dsp56k_class a static const structure bsr: make bsr_class a static const structure oradax: make 'cl' a static const structure hwtracing: hisi_ptt: Fix potential sleep in atomic context hwtracing: hisi_ptt: Advertise PERF_PMU_CAP_NO_EXCLUDE for PTT PMU hwtracing: hisi_ptt: Export available filters through sysfs hwtracing: hisi_ptt: Add support for dynamically updating the filter list hwtracing: hisi_ptt: Factor out filter allocation and release operation samples: pfsm: add CC_CAN_LINK dependency misc: fastrpc: check return value of devm_kasprintf() coresight: dummy: Update type of mode parameter in dummy_{sink,source}_enable() ...
552 lines
19 KiB
C
552 lines
19 KiB
C
/*
|
|
* Any part of this program may be used in documents licensed under
|
|
* the GNU Free Documentation License, Version 1.1 or any later version
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
#ifndef _PARPORT_H_
|
|
#define _PARPORT_H_
|
|
|
|
|
|
#include <linux/jiffies.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/irqreturn.h>
|
|
#include <linux/semaphore.h>
|
|
#include <linux/device.h>
|
|
#include <asm/ptrace.h>
|
|
#include <uapi/linux/parport.h>
|
|
|
|
/* Define this later. */
|
|
struct parport;
|
|
struct pardevice;
|
|
|
|
struct pc_parport_state {
|
|
unsigned int ctr;
|
|
unsigned int ecr;
|
|
};
|
|
|
|
struct ax_parport_state {
|
|
unsigned int ctr;
|
|
unsigned int ecr;
|
|
unsigned int dcsr;
|
|
};
|
|
|
|
/* used by both parport_amiga and parport_mfc3 */
|
|
struct amiga_parport_state {
|
|
unsigned char data; /* ciaa.prb */
|
|
unsigned char datadir; /* ciaa.ddrb */
|
|
unsigned char status; /* ciab.pra & 7 */
|
|
unsigned char statusdir;/* ciab.ddrb & 7 */
|
|
};
|
|
|
|
struct ip32_parport_state {
|
|
unsigned int dcr;
|
|
unsigned int ecr;
|
|
};
|
|
|
|
struct parport_state {
|
|
union {
|
|
struct pc_parport_state pc;
|
|
/* ARC has no state. */
|
|
struct ax_parport_state ax;
|
|
struct amiga_parport_state amiga;
|
|
/* Atari has not state. */
|
|
struct ip32_parport_state ip32;
|
|
void *misc;
|
|
} u;
|
|
};
|
|
|
|
struct parport_operations {
|
|
/* IBM PC-style virtual registers. */
|
|
void (*write_data)(struct parport *, unsigned char);
|
|
unsigned char (*read_data)(struct parport *);
|
|
|
|
void (*write_control)(struct parport *, unsigned char);
|
|
unsigned char (*read_control)(struct parport *);
|
|
unsigned char (*frob_control)(struct parport *, unsigned char mask,
|
|
unsigned char val);
|
|
|
|
unsigned char (*read_status)(struct parport *);
|
|
|
|
/* IRQs. */
|
|
void (*enable_irq)(struct parport *);
|
|
void (*disable_irq)(struct parport *);
|
|
|
|
/* Data direction. */
|
|
void (*data_forward) (struct parport *);
|
|
void (*data_reverse) (struct parport *);
|
|
|
|
/* For core parport code. */
|
|
void (*init_state)(struct pardevice *, struct parport_state *);
|
|
void (*save_state)(struct parport *, struct parport_state *);
|
|
void (*restore_state)(struct parport *, struct parport_state *);
|
|
|
|
/* Block read/write */
|
|
size_t (*epp_write_data) (struct parport *port, const void *buf,
|
|
size_t len, int flags);
|
|
size_t (*epp_read_data) (struct parport *port, void *buf, size_t len,
|
|
int flags);
|
|
size_t (*epp_write_addr) (struct parport *port, const void *buf,
|
|
size_t len, int flags);
|
|
size_t (*epp_read_addr) (struct parport *port, void *buf, size_t len,
|
|
int flags);
|
|
|
|
size_t (*ecp_write_data) (struct parport *port, const void *buf,
|
|
size_t len, int flags);
|
|
size_t (*ecp_read_data) (struct parport *port, void *buf, size_t len,
|
|
int flags);
|
|
size_t (*ecp_write_addr) (struct parport *port, const void *buf,
|
|
size_t len, int flags);
|
|
|
|
size_t (*compat_write_data) (struct parport *port, const void *buf,
|
|
size_t len, int flags);
|
|
size_t (*nibble_read_data) (struct parport *port, void *buf,
|
|
size_t len, int flags);
|
|
size_t (*byte_read_data) (struct parport *port, void *buf,
|
|
size_t len, int flags);
|
|
struct module *owner;
|
|
};
|
|
|
|
struct parport_device_info {
|
|
parport_device_class class;
|
|
const char *class_name;
|
|
const char *mfr;
|
|
const char *model;
|
|
const char *cmdset;
|
|
const char *description;
|
|
};
|
|
|
|
/* Each device can have two callback functions:
|
|
* 1) a preemption function, called by the resource manager to request
|
|
* that the driver relinquish control of the port. The driver should
|
|
* return zero if it agrees to release the port, and nonzero if it
|
|
* refuses. Do not call parport_release() - the kernel will do this
|
|
* implicitly.
|
|
*
|
|
* 2) a wake-up function, called by the resource manager to tell drivers
|
|
* that the port is available to be claimed. If a driver wants to use
|
|
* the port, it should call parport_claim() here.
|
|
*/
|
|
|
|
/* A parallel port device */
|
|
struct pardevice {
|
|
const char *name;
|
|
struct parport *port;
|
|
int daisy;
|
|
int (*preempt)(void *);
|
|
void (*wakeup)(void *);
|
|
void *private;
|
|
void (*irq_func)(void *);
|
|
unsigned int flags;
|
|
struct pardevice *next;
|
|
struct pardevice *prev;
|
|
struct device dev;
|
|
bool devmodel;
|
|
struct parport_state *state; /* saved status over preemption */
|
|
wait_queue_head_t wait_q;
|
|
unsigned long int time;
|
|
unsigned long int timeslice;
|
|
volatile long int timeout;
|
|
unsigned long waiting; /* long req'd for set_bit --RR */
|
|
struct pardevice *waitprev;
|
|
struct pardevice *waitnext;
|
|
void * sysctl_table;
|
|
};
|
|
|
|
#define to_pardevice(n) container_of(n, struct pardevice, dev)
|
|
|
|
/* IEEE1284 information */
|
|
|
|
/* IEEE1284 phases. These are exposed to userland through ppdev IOCTL
|
|
* PP[GS]ETPHASE, so do not change existing values. */
|
|
enum ieee1284_phase {
|
|
IEEE1284_PH_FWD_DATA,
|
|
IEEE1284_PH_FWD_IDLE,
|
|
IEEE1284_PH_TERMINATE,
|
|
IEEE1284_PH_NEGOTIATION,
|
|
IEEE1284_PH_HBUSY_DNA,
|
|
IEEE1284_PH_REV_IDLE,
|
|
IEEE1284_PH_HBUSY_DAVAIL,
|
|
IEEE1284_PH_REV_DATA,
|
|
IEEE1284_PH_ECP_SETUP,
|
|
IEEE1284_PH_ECP_FWD_TO_REV,
|
|
IEEE1284_PH_ECP_REV_TO_FWD,
|
|
IEEE1284_PH_ECP_DIR_UNKNOWN,
|
|
};
|
|
struct ieee1284_info {
|
|
int mode;
|
|
volatile enum ieee1284_phase phase;
|
|
struct semaphore irq;
|
|
};
|
|
|
|
#define PARPORT_NAME_MAX_LEN 15
|
|
|
|
/* A parallel port */
|
|
struct parport {
|
|
unsigned long base; /* base address */
|
|
unsigned long base_hi; /* base address (hi - ECR) */
|
|
unsigned int size; /* IO extent */
|
|
const char *name;
|
|
unsigned int modes;
|
|
int irq; /* interrupt (or -1 for none) */
|
|
int dma;
|
|
int muxport; /* which muxport (if any) this is */
|
|
int portnum; /* which physical parallel port (not mux) */
|
|
struct device *dev; /* Physical device associated with IO/DMA.
|
|
* This may unfortulately be null if the
|
|
* port has a legacy driver.
|
|
*/
|
|
struct device bus_dev; /* to link with the bus */
|
|
struct parport *physport;
|
|
/* If this is a non-default mux
|
|
parport, i.e. we're a clone of a real
|
|
physical port, this is a pointer to that
|
|
port. The locking is only done in the
|
|
real port. For a clone port, the
|
|
following structure members are
|
|
meaningless: devices, cad, muxsel,
|
|
waithead, waittail, flags, pdir,
|
|
dev, ieee1284, *_lock.
|
|
|
|
It this is a default mux parport, or
|
|
there is no mux involved, this points to
|
|
ourself. */
|
|
|
|
struct pardevice *devices;
|
|
struct pardevice *cad; /* port owner */
|
|
int daisy; /* currently selected daisy addr */
|
|
int muxsel; /* currently selected mux port */
|
|
|
|
struct pardevice *waithead;
|
|
struct pardevice *waittail;
|
|
|
|
struct list_head list;
|
|
struct timer_list timer;
|
|
unsigned int flags;
|
|
|
|
void *sysctl_table;
|
|
struct parport_device_info probe_info[5]; /* 0-3 + non-IEEE1284.3 */
|
|
struct ieee1284_info ieee1284;
|
|
|
|
struct parport_operations *ops;
|
|
void *private_data; /* for lowlevel driver */
|
|
|
|
int number; /* port index - the `n' in `parportn' */
|
|
spinlock_t pardevice_lock;
|
|
spinlock_t waitlist_lock;
|
|
rwlock_t cad_lock;
|
|
|
|
int spintime;
|
|
atomic_t ref_count;
|
|
|
|
unsigned long devflags;
|
|
#define PARPORT_DEVPROC_REGISTERED 0
|
|
struct pardevice *proc_device; /* Currently register proc device */
|
|
|
|
struct list_head full_list;
|
|
struct parport *slaves[3];
|
|
};
|
|
|
|
#define to_parport_dev(n) container_of(n, struct parport, bus_dev)
|
|
|
|
#define DEFAULT_SPIN_TIME 500 /* us */
|
|
|
|
struct parport_driver {
|
|
const char *name;
|
|
void (*attach) (struct parport *);
|
|
void (*detach) (struct parport *);
|
|
void (*match_port)(struct parport *);
|
|
int (*probe)(struct pardevice *);
|
|
struct device_driver driver;
|
|
bool devmodel;
|
|
struct list_head list;
|
|
};
|
|
|
|
#define to_parport_driver(n) container_of(n, struct parport_driver, driver)
|
|
|
|
int parport_bus_init(void);
|
|
void parport_bus_exit(void);
|
|
|
|
/* parport_register_port registers a new parallel port at the given
|
|
address (if one does not already exist) and returns a pointer to it.
|
|
This entails claiming the I/O region, IRQ and DMA. NULL is returned
|
|
if initialisation fails. */
|
|
struct parport *parport_register_port(unsigned long base, int irq, int dma,
|
|
struct parport_operations *ops);
|
|
|
|
/* Once a registered port is ready for high-level drivers to use, the
|
|
low-level driver that registered it should announce it. This will
|
|
call the high-level drivers' attach() functions (after things like
|
|
determining the IEEE 1284.3 topology of the port and collecting
|
|
DeviceIDs). */
|
|
void parport_announce_port (struct parport *port);
|
|
|
|
/* Unregister a port. */
|
|
extern void parport_remove_port(struct parport *port);
|
|
|
|
/* Register a new high-level driver. */
|
|
|
|
int __must_check __parport_register_driver(struct parport_driver *,
|
|
struct module *,
|
|
const char *mod_name);
|
|
/*
|
|
* parport_register_driver must be a macro so that KBUILD_MODNAME can
|
|
* be expanded
|
|
*/
|
|
|
|
/**
|
|
* parport_register_driver - register a parallel port device driver
|
|
* @driver: structure describing the driver
|
|
*
|
|
* This can be called by a parallel port device driver in order
|
|
* to receive notifications about ports being found in the
|
|
* system, as well as ports no longer available.
|
|
*
|
|
* If devmodel is true then the new device model is used
|
|
* for registration.
|
|
*
|
|
* The @driver structure is allocated by the caller and must not be
|
|
* deallocated until after calling parport_unregister_driver().
|
|
*
|
|
* If using the non device model:
|
|
* The driver's attach() function may block. The port that
|
|
* attach() is given will be valid for the duration of the
|
|
* callback, but if the driver wants to take a copy of the
|
|
* pointer it must call parport_get_port() to do so. Calling
|
|
* parport_register_device() on that port will do this for you.
|
|
*
|
|
* The driver's detach() function may block. The port that
|
|
* detach() is given will be valid for the duration of the
|
|
* callback, but if the driver wants to take a copy of the
|
|
* pointer it must call parport_get_port() to do so.
|
|
*
|
|
*
|
|
* Returns 0 on success. The non device model will always succeeds.
|
|
* but the new device model can fail and will return the error code.
|
|
**/
|
|
#define parport_register_driver(driver) \
|
|
__parport_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
|
|
|
|
/* Unregister a high-level driver. */
|
|
void parport_unregister_driver(struct parport_driver *);
|
|
|
|
/**
|
|
* module_parport_driver() - Helper macro for registering a modular parport driver
|
|
* @__parport_driver: struct parport_driver to be used
|
|
*
|
|
* Helper macro for parport drivers which do not do anything special in module
|
|
* init and exit. This eliminates a lot of boilerplate. Each module may only
|
|
* use this macro once, and calling it replaces module_init() and module_exit().
|
|
*/
|
|
#define module_parport_driver(__parport_driver) \
|
|
module_driver(__parport_driver, parport_register_driver, parport_unregister_driver)
|
|
|
|
/* If parport_register_driver doesn't fit your needs, perhaps
|
|
* parport_find_xxx does. */
|
|
extern struct parport *parport_find_number (int);
|
|
extern struct parport *parport_find_base (unsigned long);
|
|
|
|
/* generic irq handler, if it suits your needs */
|
|
extern irqreturn_t parport_irq_handler(int irq, void *dev_id);
|
|
|
|
/* Reference counting for ports. */
|
|
extern struct parport *parport_get_port (struct parport *);
|
|
extern void parport_put_port (struct parport *);
|
|
void parport_del_port(struct parport *);
|
|
|
|
struct pardev_cb {
|
|
int (*preempt)(void *);
|
|
void (*wakeup)(void *);
|
|
void *private;
|
|
void (*irq_func)(void *);
|
|
unsigned int flags;
|
|
};
|
|
|
|
/*
|
|
* parport_register_dev_model declares that a device is connected to a
|
|
* port, and tells the kernel all it needs to know.
|
|
*/
|
|
struct pardevice *
|
|
parport_register_dev_model(struct parport *port, const char *name,
|
|
const struct pardev_cb *par_dev_cb, int cnt);
|
|
|
|
/* parport_unregister unlinks a device from the chain. */
|
|
extern void parport_unregister_device(struct pardevice *dev);
|
|
|
|
/* parport_claim tries to gain ownership of the port for a particular
|
|
driver. This may fail (return non-zero) if another driver is busy.
|
|
If this driver has registered an interrupt handler, it will be
|
|
enabled. */
|
|
extern int parport_claim(struct pardevice *dev);
|
|
|
|
/* parport_claim_or_block is the same, but sleeps if the port cannot
|
|
be claimed. Return value is 1 if it slept, 0 normally and -errno
|
|
on error. */
|
|
extern int parport_claim_or_block(struct pardevice *dev);
|
|
|
|
/* parport_release reverses a previous parport_claim. This can never
|
|
fail, though the effects are undefined (except that they are bad)
|
|
if you didn't previously own the port. Once you have released the
|
|
port you should make sure that neither your code nor the hardware
|
|
on the port tries to initiate any communication without first
|
|
re-claiming the port. If you mess with the port state (enabling
|
|
ECP for example) you should clean up before releasing the port. */
|
|
|
|
extern void parport_release(struct pardevice *dev);
|
|
|
|
/**
|
|
* parport_yield - relinquish a parallel port temporarily
|
|
* @dev: a device on the parallel port
|
|
*
|
|
* This function relinquishes the port if it would be helpful to other
|
|
* drivers to do so. Afterwards it tries to reclaim the port using
|
|
* parport_claim(), and the return value is the same as for
|
|
* parport_claim(). If it fails, the port is left unclaimed and it is
|
|
* the driver's responsibility to reclaim the port.
|
|
*
|
|
* The parport_yield() and parport_yield_blocking() functions are for
|
|
* marking points in the driver at which other drivers may claim the
|
|
* port and use their devices. Yielding the port is similar to
|
|
* releasing it and reclaiming it, but is more efficient because no
|
|
* action is taken if there are no other devices needing the port. In
|
|
* fact, nothing is done even if there are other devices waiting but
|
|
* the current device is still within its "timeslice". The default
|
|
* timeslice is half a second, but it can be adjusted via the /proc
|
|
* interface.
|
|
**/
|
|
static __inline__ int parport_yield(struct pardevice *dev)
|
|
{
|
|
unsigned long int timeslip = (jiffies - dev->time);
|
|
if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice))
|
|
return 0;
|
|
parport_release(dev);
|
|
return parport_claim(dev);
|
|
}
|
|
|
|
/**
|
|
* parport_yield_blocking - relinquish a parallel port temporarily
|
|
* @dev: a device on the parallel port
|
|
*
|
|
* This function relinquishes the port if it would be helpful to other
|
|
* drivers to do so. Afterwards it tries to reclaim the port using
|
|
* parport_claim_or_block(), and the return value is the same as for
|
|
* parport_claim_or_block().
|
|
**/
|
|
static __inline__ int parport_yield_blocking(struct pardevice *dev)
|
|
{
|
|
unsigned long int timeslip = (jiffies - dev->time);
|
|
if ((dev->port->waithead == NULL) || (timeslip < dev->timeslice))
|
|
return 0;
|
|
parport_release(dev);
|
|
return parport_claim_or_block(dev);
|
|
}
|
|
|
|
/* Flags used to identify what a device does. */
|
|
#define PARPORT_DEV_TRAN 0 /* WARNING !! DEPRECATED !! */
|
|
#define PARPORT_DEV_LURK (1<<0) /* WARNING !! DEPRECATED !! */
|
|
#define PARPORT_DEV_EXCL (1<<1) /* Need exclusive access. */
|
|
|
|
#define PARPORT_FLAG_EXCL (1<<1) /* EXCL driver registered. */
|
|
|
|
/* IEEE1284 functions */
|
|
extern void parport_ieee1284_interrupt (void *);
|
|
extern int parport_negotiate (struct parport *, int mode);
|
|
extern ssize_t parport_write (struct parport *, const void *buf, size_t len);
|
|
extern ssize_t parport_read (struct parport *, void *buf, size_t len);
|
|
|
|
#define PARPORT_INACTIVITY_O_NONBLOCK 1
|
|
extern long parport_set_timeout (struct pardevice *, long inactivity);
|
|
|
|
extern int parport_wait_event (struct parport *, long timeout);
|
|
extern int parport_wait_peripheral (struct parport *port,
|
|
unsigned char mask,
|
|
unsigned char val);
|
|
extern int parport_poll_peripheral (struct parport *port,
|
|
unsigned char mask,
|
|
unsigned char val,
|
|
int usec);
|
|
|
|
/* For architectural drivers */
|
|
extern size_t parport_ieee1284_write_compat (struct parport *,
|
|
const void *, size_t, int);
|
|
extern size_t parport_ieee1284_read_nibble (struct parport *,
|
|
void *, size_t, int);
|
|
extern size_t parport_ieee1284_read_byte (struct parport *,
|
|
void *, size_t, int);
|
|
extern size_t parport_ieee1284_ecp_read_data (struct parport *,
|
|
void *, size_t, int);
|
|
extern size_t parport_ieee1284_ecp_write_data (struct parport *,
|
|
const void *, size_t, int);
|
|
extern size_t parport_ieee1284_ecp_write_addr (struct parport *,
|
|
const void *, size_t, int);
|
|
extern size_t parport_ieee1284_epp_write_data (struct parport *,
|
|
const void *, size_t, int);
|
|
extern size_t parport_ieee1284_epp_read_data (struct parport *,
|
|
void *, size_t, int);
|
|
extern size_t parport_ieee1284_epp_write_addr (struct parport *,
|
|
const void *, size_t, int);
|
|
extern size_t parport_ieee1284_epp_read_addr (struct parport *,
|
|
void *, size_t, int);
|
|
|
|
/* IEEE1284.3 functions */
|
|
#define daisy_dev_name "Device ID probe"
|
|
extern int parport_daisy_init (struct parport *port);
|
|
extern void parport_daisy_fini (struct parport *port);
|
|
extern struct pardevice *parport_open (int devnum, const char *name);
|
|
extern void parport_close (struct pardevice *dev);
|
|
extern ssize_t parport_device_id (int devnum, char *buffer, size_t len);
|
|
extern void parport_daisy_deselect_all (struct parport *port);
|
|
extern int parport_daisy_select (struct parport *port, int daisy, int mode);
|
|
|
|
/* Lowlevel drivers _can_ call this support function to handle irqs. */
|
|
static inline void parport_generic_irq(struct parport *port)
|
|
{
|
|
parport_ieee1284_interrupt (port);
|
|
read_lock(&port->cad_lock);
|
|
if (port->cad && port->cad->irq_func)
|
|
port->cad->irq_func(port->cad->private);
|
|
read_unlock(&port->cad_lock);
|
|
}
|
|
|
|
/* Prototypes from parport_procfs */
|
|
extern int parport_proc_register(struct parport *pp);
|
|
extern int parport_proc_unregister(struct parport *pp);
|
|
extern int parport_device_proc_register(struct pardevice *device);
|
|
extern int parport_device_proc_unregister(struct pardevice *device);
|
|
|
|
/* If PC hardware is the only type supported, we can optimise a bit. */
|
|
#if !defined(CONFIG_PARPORT_NOT_PC) && defined(CONFIG_PARPORT_PC)
|
|
|
|
#include <linux/parport_pc.h>
|
|
#define parport_write_data(p,x) parport_pc_write_data(p,x)
|
|
#define parport_read_data(p) parport_pc_read_data(p)
|
|
#define parport_write_control(p,x) parport_pc_write_control(p,x)
|
|
#define parport_read_control(p) parport_pc_read_control(p)
|
|
#define parport_frob_control(p,m,v) parport_pc_frob_control(p,m,v)
|
|
#define parport_read_status(p) parport_pc_read_status(p)
|
|
#define parport_enable_irq(p) parport_pc_enable_irq(p)
|
|
#define parport_disable_irq(p) parport_pc_disable_irq(p)
|
|
#define parport_data_forward(p) parport_pc_data_forward(p)
|
|
#define parport_data_reverse(p) parport_pc_data_reverse(p)
|
|
|
|
#else /* !CONFIG_PARPORT_NOT_PC */
|
|
|
|
/* Generic operations vector through the dispatch table. */
|
|
#define parport_write_data(p,x) (p)->ops->write_data(p,x)
|
|
#define parport_read_data(p) (p)->ops->read_data(p)
|
|
#define parport_write_control(p,x) (p)->ops->write_control(p,x)
|
|
#define parport_read_control(p) (p)->ops->read_control(p)
|
|
#define parport_frob_control(p,m,v) (p)->ops->frob_control(p,m,v)
|
|
#define parport_read_status(p) (p)->ops->read_status(p)
|
|
#define parport_enable_irq(p) (p)->ops->enable_irq(p)
|
|
#define parport_disable_irq(p) (p)->ops->disable_irq(p)
|
|
#define parport_data_forward(p) (p)->ops->data_forward(p)
|
|
#define parport_data_reverse(p) (p)->ops->data_reverse(p)
|
|
|
|
#endif /* !CONFIG_PARPORT_NOT_PC */
|
|
|
|
extern unsigned long parport_default_timeslice;
|
|
extern int parport_default_spintime;
|
|
|
|
#endif /* _PARPORT_H_ */
|