[mirror_ubuntu-bionic-kernel.git] / include / linux / parport.h

/*
 * 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 ax88796_parport_state {
	unsigned char cpr;
};

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;
		struct ax88796_parport_state ax88796;
		/* 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;
};

/* 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
 */
#define parport_register_driver(driver)             \
	__parport_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)

/* Unregister a high-level driver. */
extern void parport_unregister_driver (struct parport_driver *);
void parport_unregister_driver(struct parport_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_device declares that a device is connected to a
   port, and tells the kernel all it needs to know.
   - pf is the preemption function (may be NULL for no callback)
   - kf is the wake-up function (may be NULL for no callback)
   - irq_func is the interrupt handler (may be NULL for no interrupts)
   - handle is a user pointer that gets handed to callback functions.  */
struct pardevice *parport_register_device(struct parport *port, 
			  const char *name,
			  int (*pf)(void *), void (*kf)(void *),
			  void (*irq_func)(void *), 
			  int flags, void *handle);

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

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