[deliverable/linux.git] / drivers / staging / fwserial / fwserial.h

#ifndef _FIREWIRE_FWSERIAL_H
#define _FIREWIRE_FWSERIAL_H

#include <linux/kernel.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/list.h>
#include <linux/firewire.h>
#include <linux/firewire-constants.h>
#include <linux/spinlock.h>
#include <linux/rcupdate.h>
#include <linux/mutex.h>
#include <linux/serial.h>
#include <linux/serial_reg.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/debugfs.h>

#include "dma_fifo.h"

#ifdef FWTTY_PROFILING
#define DISTRIBUTION_MAX_SIZE     8192
#define DISTRIBUTION_MAX_INDEX    (ilog2(DISTRIBUTION_MAX_SIZE) + 1)
static inline void fwtty_profile_data(unsigned stat[], unsigned val)
{
	int n = (val) ? min(ilog2(val) + 1, DISTRIBUTION_MAX_INDEX) : 0;
	++stat[n];
}
#else
#define DISTRIBUTION_MAX_INDEX    0
#define fwtty_profile_data(st, n)
#endif

/* Parameters for both VIRT_CABLE_PLUG & VIRT_CABLE_PLUG_RSP mgmt codes */
struct virt_plug_params {
	__be32  status_hi;
	__be32  status_lo;
	__be32	fifo_hi;
	__be32	fifo_lo;
	__be32	fifo_len;
};

struct peer_work_params {
	union {
		struct virt_plug_params plug_req;
	};
};

/**
 * fwtty_peer: structure representing local & remote unit devices
 * @unit: unit child device of fw_device node
 * @serial: back pointer to associated fw_serial aggregate
 * @guid: unique 64-bit guid for this unit device
 * @generation: most recent bus generation
 * @node_id: most recent node_id
 * @speed: link speed of peer (0 = S100, 2 = S400, ... 5 = S3200)
 * @mgmt_addr: bus addr region to write mgmt packets to
 * @status_addr: bus addr register to write line status to
 * @fifo_addr: bus addr region to write serial output to
 * @fifo_len:  max length for single write to fifo_addr
 * @list: link for insertion into fw_serial's peer_list
 * @rcu: for deferring peer reclamation
 * @lock: spinlock to synchonize changes to state & port fields
 * @work: only one work item can be queued at any one time
 *        Note: pending work is canceled prior to removal, so this
 *        peer is valid for at least the lifetime of the work function
 * @work_params: parameter block for work functions
 * @timer: timer for resetting peer state if remote request times out
 * @state: current state
 * @connect: work item for auto-connecting
 * @connect_retries: # of connections already attempted
 * @port: associated tty_port (usable if state == FWSC_ATTACHED)
 */
struct fwtty_peer {
	struct fw_unit		*unit;
	struct fw_serial	*serial;
	u64			guid;
	int			generation;
	int			node_id;
	unsigned		speed;
	int			max_payload;
	u64			mgmt_addr;

	/* these are usable only if state == FWSC_ATTACHED */
	u64			status_addr;
	u64			fifo_addr;
	int			fifo_len;

	struct list_head	list;
	struct rcu_head		rcu;

	spinlock_t		lock;
	struct work_struct	work;
	struct peer_work_params work_params;
	struct timer_list	timer;
	int			state;
	struct delayed_work	connect;
	int			connect_retries;

	struct fwtty_port	*port;
};

#define to_peer(ptr, field)	(container_of(ptr, struct fwtty_peer, field))

/* state values for fwtty_peer.state field */
enum fwtty_peer_state {
	FWPS_GONE,
	FWPS_NOT_ATTACHED,
	FWPS_ATTACHED,
	FWPS_PLUG_PENDING,
	FWPS_PLUG_RESPONDING,
	FWPS_UNPLUG_PENDING,
	FWPS_UNPLUG_RESPONDING,

	FWPS_NO_MGMT_ADDR = -1,
};

#define CONNECT_RETRY_DELAY	HZ
#define MAX_CONNECT_RETRIES	10

/* must be holding peer lock for these state funclets */
static inline void peer_set_state(struct fwtty_peer *peer, int new)
{
	peer->state = new;
}

static inline struct fwtty_port *peer_revert_state(struct fwtty_peer *peer)
{
	struct fwtty_port *port = peer->port;

	peer->port = NULL;
	peer_set_state(peer, FWPS_NOT_ATTACHED);
	return port;
}

struct fwserial_mgmt_pkt {
	struct {
		__be16		len;
		__be16		code;
	} hdr;
	union {
		struct virt_plug_params plug_req;
		struct virt_plug_params plug_rsp;
	};
} __packed;

/* fwserial_mgmt_packet codes */
#define FWSC_RSP_OK			0x0000
#define FWSC_RSP_NACK			0x8000
#define FWSC_CODE_MASK			0x0fff

#define FWSC_VIRT_CABLE_PLUG		1
#define FWSC_VIRT_CABLE_UNPLUG		2
#define FWSC_VIRT_CABLE_PLUG_RSP	3
#define FWSC_VIRT_CABLE_UNPLUG_RSP	4

/* 1 min. plug timeout -- suitable for userland authorization */
#define VIRT_CABLE_PLUG_TIMEOUT		(60 * HZ)

struct stats {
	unsigned	xchars;
	unsigned	dropped;
	unsigned	tx_stall;
	unsigned	fifo_errs;
	unsigned	sent;
	unsigned	lost;
	unsigned	throttled;
	unsigned	reads[DISTRIBUTION_MAX_INDEX + 1];
	unsigned	writes[DISTRIBUTION_MAX_INDEX + 1];
	unsigned	txns[DISTRIBUTION_MAX_INDEX + 1];
	unsigned	unthrottle[DISTRIBUTION_MAX_INDEX + 1];
};

struct fwconsole_ops {
	void (*notify)(int code, void *data);
	void (*stats)(struct stats *stats, void *data);
	void (*proc_show)(struct seq_file *m, void *data);
};

/* codes for console ops notify */
#define FWCON_NOTIFY_ATTACH		1
#define FWCON_NOTIFY_DETACH		2

/**
 * fwtty_port: structure used to track/represent underlying tty_port
 * @port: underlying tty_port
 * @device: tty device
 * @index: index into port_table for this particular port
 *    note: minor = index + minor_start assigned by tty_alloc_driver()
 * @serial: back pointer to the containing fw_serial
 * @rx_handler: bus address handler for unique addr region used by remotes
 *              to communicate with this port. Every port uses
 *		fwtty_port_handler() for per port transactions.
 * @fwcon_ops: ops for attached fw_console (if any)
 * @con_data: private data for fw_console
 * @wait_tx: waitqueue for sleeping until writer/drain completes tx
 * @emit_breaks: delayed work responsible for generating breaks when the
 *               break line status is active
 * @cps : characters per second computed from the termios settings
 * @break_last: timestamp in jiffies from last emit_breaks
 * @hangup: work responsible for HUPing when carrier is dropped/lost
 * @mstatus: loose virtualization of LSR/MSR
 *         bits 15..0  correspond to TIOCM_* bits
 *         bits 19..16 reserved for mctrl
 *         bit 20      OOB_TX_THROTTLE
 *	   bits 23..21 reserved
 *         bits 31..24 correspond to UART_LSR_* bits
 * @lock: spinlock for protecting concurrent access to fields below it
 * @mctrl: loose virtualization of MCR
 *         bits 15..0  correspond to TIOCM_* bits
 *         bit 16      OOB_RX_THROTTLE
 *         bits 19..17 reserved
 *	   bits 31..20 reserved for mstatus
 * @drain: delayed work scheduled to ensure that writes are flushed.
 *         The work can race with the writer but concurrent sending is
 *         prevented with the IN_TX flag. Scheduled under lock to
 *         limit scheduling when fifo has just been drained.
 * @tx_fifo: fifo used to store & block-up writes for dma to remote
 * @max_payload: max bytes transmissable per dma (based on peer's max_payload)
 * @status_mask: UART_LSR_* bitmask significant to rx (based on termios)
 * @ignore_mask: UART_LSR_* bitmask of states to ignore (also based on termios)
 * @break_ctl: if set, port is 'sending break' to remote
 * @write_only: self-explanatory
 * @overrun: previous rx was lost (partially or completely)
 * @loopback: if set, port is in loopback mode
 * @flags: atomic bit flags
 *         bit 0: IN_TX - gate to allow only one cpu to send from the dma fifo
 *                        at a time.
 *         bit 1: STOP_TX - force tx to exit while sending
 * @peer: rcu-pointer to associated fwtty_peer (if attached)
 *        NULL if no peer attached
 * @icount: predefined statistics reported by the TIOCGICOUNT ioctl
 * @stats: additional statistics reported in /proc/tty/driver/firewire_serial
 */
struct fwtty_port {
	struct tty_port		   port;
	struct device		   *device;
	unsigned		   index;
	struct fw_serial	   *serial;
	struct fw_address_handler  rx_handler;

	struct fwconsole_ops	   *fwcon_ops;
	void			   *con_data;

	wait_queue_head_t	   wait_tx;
	struct delayed_work	   emit_breaks;
	unsigned		   cps;
	unsigned long		   break_last;

	struct work_struct	   hangup;

	unsigned		   mstatus;

	spinlock_t		   lock;
	unsigned		   mctrl;
	struct delayed_work	   drain;
	struct dma_fifo		   tx_fifo;
	int			   max_payload;
	unsigned		   status_mask;
	unsigned		   ignore_mask;
	unsigned		   break_ctl:1,
				   write_only:1,
				   overrun:1,
				   loopback:1;
	unsigned long		   flags;

	struct fwtty_peer __rcu	   *peer;

	struct async_icount	   icount;
	struct stats		   stats;
};

#define to_port(ptr, field)	(container_of(ptr, struct fwtty_port, field))

/* bit #s for flags field */
#define IN_TX                      0
#define STOP_TX                    1

/* bitmasks for special mctrl/mstatus bits */
#define OOB_RX_THROTTLE   0x00010000
#define MCTRL_RSRVD       0x000e0000
#define OOB_TX_THROTTLE   0x00100000
#define MSTATUS_RSRVD     0x00e00000

#define MCTRL_MASK        (TIOCM_DTR | TIOCM_RTS | TIOCM_OUT1 | TIOCM_OUT2 | \
			   TIOCM_LOOP | OOB_RX_THROTTLE | MCTRL_RSRVD)

/* XXX even every 1/50th secs. may be unnecessarily accurate */
/* delay in jiffies between brk emits */
#define FREQ_BREAKS        (HZ / 50)

/* Ports are allocated in blocks of num_ports for each fw_card */
#define MAX_CARD_PORTS           32	/* max # of ports per card */
#define MAX_TOTAL_PORTS          64	/* max # of ports total    */

/* tuning parameters */
#define FWTTY_PORT_TXFIFO_LEN	4096
#define FWTTY_PORT_MAX_PEND_DMA    8    /* costs a cache line per pend */
#define DRAIN_THRESHOLD         1024
#define MAX_ASYNC_PAYLOAD       4096    /* ohci-defined limit          */
#define WRITER_MINIMUM           128
/* TODO: how to set watermark to AR context size? see fwtty_rx() */
#define HIGH_WATERMARK         32768	/* AR context is 32K	       */

/*
 * Size of bus addr region above 4GB used per port as the recv addr
 * - must be at least as big as the MAX_ASYNC_PAYLOAD
 */
#define FWTTY_PORT_RXFIFO_LEN	MAX_ASYNC_PAYLOAD

/**
 * fw_serial: aggregate used to associate tty ports with specific fw_card
 * @card: fw_card associated with this fw_serial device (1:1 association)
 * @kref: reference-counted multi-port management allows delayed destroy
 * @self: local unit device as 'peer'. Not valid until local unit device
 *         is enumerated.
 * @list: link for insertion into fwserial_list
 * @peer_list: list of local & remote unit devices attached to this card
 * @ports: fixed array of tty_ports provided by this serial device
 */
struct fw_serial {
	struct fw_card	  *card;
	struct kref	  kref;

	struct dentry	  *debugfs;
	struct fwtty_peer *self;

	struct list_head  list;
	struct list_head  peer_list;

	struct fwtty_port *ports[MAX_CARD_PORTS];
};

#define to_serial(ptr, field)	(container_of(ptr, struct fw_serial, field))

#define TTY_DEV_NAME		    "fwtty"	/* ttyFW was taken           */
static const char tty_dev_name[] =  TTY_DEV_NAME;
static const char loop_dev_name[] = "fwloop";

extern struct tty_driver *fwtty_driver;

struct fwtty_port *fwtty_port_get(unsigned index);
void fwtty_port_put(struct fwtty_port *port);

static inline void fwtty_bind_console(struct fwtty_port *port,
				      struct fwconsole_ops *fwcon_ops,
				      void *data)
{
	port->con_data = data;
	port->fwcon_ops = fwcon_ops;
}

/*
 * Returns the max send async payload size in bytes based on the unit device
 * link speed. Self-limiting asynchronous bandwidth (via reducing the payload)
 * is not necessary and does not work, because
 *   1) asynchronous traffic will absorb all available bandwidth (less that
 *	being used for isochronous traffic)
 *   2) isochronous arbitration always wins.
 */
static inline int link_speed_to_max_payload(unsigned speed)
{
	/* Max async payload is 4096 - see IEEE 1394-2008 tables 6-4, 16-18 */
	return min(512 << speed, 4096);
}

#endif /* _FIREWIRE_FWSERIAL_H */
Commit	Line	Data
e5711071 PH	1	#ifndef _FIREWIRE_FWSERIAL_H
	2	#define _FIREWIRE_FWSERIAL_H
	3
	4	#include <linux/kernel.h>
	5	#include <linux/tty.h>
	6	#include <linux/tty_driver.h>
	7	#include <linux/tty_flip.h>
	8	#include <linux/list.h>
	9	#include <linux/firewire.h>
	10	#include <linux/firewire-constants.h>
	11	#include <linux/spinlock.h>
	12	#include <linux/rcupdate.h>
	13	#include <linux/mutex.h>
	14	#include <linux/serial.h>
	15	#include <linux/serial_reg.h>
	16	#include <linux/module.h>
	17	#include <linux/seq_file.h>
4df5bb04	18	#include <linux/debugfs.h>
e5711071 PH	19
	20	#include "dma_fifo.h"
	21
	22	#ifdef FWTTY_PROFILING
	23	#define DISTRIBUTION_MAX_SIZE 8192
	24	#define DISTRIBUTION_MAX_INDEX (ilog2(DISTRIBUTION_MAX_SIZE) + 1)
49bb8405	25	static inline void fwtty_profile_data(unsigned stat[], unsigned val)
e5711071 PH	26	{
	27	int n = (val) ? min(ilog2(val) + 1, DISTRIBUTION_MAX_INDEX) : 0;
	28	++stat[n];
	29	}
	30	#else
	31	#define DISTRIBUTION_MAX_INDEX 0
49bb8405	32	#define fwtty_profile_data(st, n)
e5711071 PH	33	#endif
	34
	35	/* Parameters for both VIRT_CABLE_PLUG & VIRT_CABLE_PLUG_RSP mgmt codes */
	36	struct virt_plug_params {
	37	__be32 status_hi;
	38	__be32 status_lo;
	39	__be32 fifo_hi;
	40	__be32 fifo_lo;
	41	__be32 fifo_len;
	42	};
	43
	44	struct peer_work_params {
	45	union {
	46	struct virt_plug_params plug_req;
	47	};
	48	};
	49
	50	/**
	51	* fwtty_peer: structure representing local & remote unit devices
	52	* @unit: unit child device of fw_device node
	53	* @serial: back pointer to associated fw_serial aggregate
	54	* @guid: unique 64-bit guid for this unit device
	55	* @generation: most recent bus generation
	56	* @node_id: most recent node_id
	57	* @speed: link speed of peer (0 = S100, 2 = S400, ... 5 = S3200)
	58	* @mgmt_addr: bus addr region to write mgmt packets to
	59	* @status_addr: bus addr register to write line status to
	60	* @fifo_addr: bus addr region to write serial output to
	61	* @fifo_len: max length for single write to fifo_addr
	62	* @list: link for insertion into fw_serial's peer_list
	63	* @rcu: for deferring peer reclamation
	64	* @lock: spinlock to synchonize changes to state & port fields
	65	* @work: only one work item can be queued at any one time
	66	* Note: pending work is canceled prior to removal, so this
	67	* peer is valid for at least the lifetime of the work function
	68	* @work_params: parameter block for work functions
	69	* @timer: timer for resetting peer state if remote request times out
	70	* @state: current state
	71	* @connect: work item for auto-connecting
	72	* @connect_retries: # of connections already attempted
	73	* @port: associated tty_port (usable if state == FWSC_ATTACHED)
	74	*/
	75	struct fwtty_peer {
	76	struct fw_unit *unit;
	77	struct fw_serial *serial;
	78	u64 guid;
	79	int generation;
	80	int node_id;
	81	unsigned speed;
	82	int max_payload;
	83	u64 mgmt_addr;
	84
	85	/* these are usable only if state == FWSC_ATTACHED */
	86	u64 status_addr;
	87	u64 fifo_addr;
	88	int fifo_len;
	89
	90	struct list_head list;
	91	struct rcu_head rcu;
	92
	93	spinlock_t lock;
	94	struct work_struct work;
	95	struct peer_work_params work_params;
	96	struct timer_list timer;
97	int state;
98	struct delayed_work connect;
99	int connect_retries;
100
101	struct fwtty_port *port;
102	};
103
104	#define to_peer(ptr, field) (container_of(ptr, struct fwtty_peer, field))
105
106	/* state values for fwtty_peer.state field */
107	enum fwtty_peer_state {
108	FWPS_GONE,
109	FWPS_NOT_ATTACHED,
110	FWPS_ATTACHED,
111	FWPS_PLUG_PENDING,
112	FWPS_PLUG_RESPONDING,
113	FWPS_UNPLUG_PENDING,
114	FWPS_UNPLUG_RESPONDING,
115
116	FWPS_NO_MGMT_ADDR = -1,
117	};
118
119	#define CONNECT_RETRY_DELAY HZ
120	#define MAX_CONNECT_RETRIES 10
121
122	/* must be holding peer lock for these state funclets */
123	static inline void peer_set_state(struct fwtty_peer *peer, int new)
124	{
125	peer->state = new;
126	}
127
128	static inline struct fwtty_port peer_revert_state(struct fwtty_peer peer)
129	{
130	struct fwtty_port *port = peer->port;
131
132	peer->port = NULL;
133	peer_set_state(peer, FWPS_NOT_ATTACHED);
134	return port;
135	}
136
137	struct fwserial_mgmt_pkt {
138	struct {
139	__be16 len;
140	__be16 code;
141	} hdr;
142	union {
143	struct virt_plug_params plug_req;
144	struct virt_plug_params plug_rsp;
145	};
146	} __packed;
147
148	/* fwserial_mgmt_packet codes */
149	#define FWSC_RSP_OK 0x0000
150	#define FWSC_RSP_NACK 0x8000
151	#define FWSC_CODE_MASK 0x0fff
152
153	#define FWSC_VIRT_CABLE_PLUG 1
154	#define FWSC_VIRT_CABLE_UNPLUG 2
155	#define FWSC_VIRT_CABLE_PLUG_RSP 3
156	#define FWSC_VIRT_CABLE_UNPLUG_RSP 4
157
158	/* 1 min. plug timeout -- suitable for userland authorization */
159	#define VIRT_CABLE_PLUG_TIMEOUT (60 * HZ)
160
161	struct stats {
162	unsigned xchars;
163	unsigned dropped;
164	unsigned tx_stall;
165	unsigned fifo_errs;
166	unsigned sent;
167	unsigned lost;
168	unsigned throttled;
e5711071 PH	169	unsigned reads[DISTRIBUTION_MAX_INDEX + 1];
	170	unsigned writes[DISTRIBUTION_MAX_INDEX + 1];
	171	unsigned txns[DISTRIBUTION_MAX_INDEX + 1];
	172	unsigned unthrottle[DISTRIBUTION_MAX_INDEX + 1];
	173	};
	174
	175	struct fwconsole_ops {
	176	void (notify)(int code, void data);
	177	void (stats)(struct stats stats, void *data);
	178	void (proc_show)(struct seq_file m, void *data);
	179	};
	180
	181	/* codes for console ops notify */
	182	#define FWCON_NOTIFY_ATTACH 1
	183	#define FWCON_NOTIFY_DETACH 2
	184
e5711071 PH	185	/**
	186	* fwtty_port: structure used to track/represent underlying tty_port
	187	* @port: underlying tty_port
	188	* @device: tty device
	189	* @index: index into port_table for this particular port
2257d122	190	* note: minor = index + minor_start assigned by tty_alloc_driver()
e5711071 PH	191	* @serial: back pointer to the containing fw_serial
	192	* @rx_handler: bus address handler for unique addr region used by remotes
	193	* to communicate with this port. Every port uses
	194	* fwtty_port_handler() for per port transactions.
	195	* @fwcon_ops: ops for attached fw_console (if any)
	196	* @con_data: private data for fw_console
	197	* @wait_tx: waitqueue for sleeping until writer/drain completes tx
	198	* @emit_breaks: delayed work responsible for generating breaks when the
	199	* break line status is active
	200	* @cps : characters per second computed from the termios settings
	201	* @break_last: timestamp in jiffies from last emit_breaks
	202	* @hangup: work responsible for HUPing when carrier is dropped/lost
	203	* @mstatus: loose virtualization of LSR/MSR
	204	* bits 15..0 correspond to TIOCM_* bits
	205	* bits 19..16 reserved for mctrl
	206	* bit 20 OOB_TX_THROTTLE
	207	* bits 23..21 reserved
	208	* bits 31..24 correspond to UART_LSR_* bits
	209	* @lock: spinlock for protecting concurrent access to fields below it
	210	* @mctrl: loose virtualization of MCR
	211	* bits 15..0 correspond to TIOCM_* bits
	212	* bit 16 OOB_RX_THROTTLE
	213	* bits 19..17 reserved
	214	* bits 31..20 reserved for mstatus
	215	* @drain: delayed work scheduled to ensure that writes are flushed.
	216	* The work can race with the writer but concurrent sending is
	217	* prevented with the IN_TX flag. Scheduled under lock to
	218	* limit scheduling when fifo has just been drained.
e5711071 PH	219	* @tx_fifo: fifo used to store & block-up writes for dma to remote
	220	* @max_payload: max bytes transmissable per dma (based on peer's max_payload)
	221	* @status_mask: UART_LSR_* bitmask significant to rx (based on termios)
	222	* @ignore_mask: UART_LSR_* bitmask of states to ignore (also based on termios)
	223	* @break_ctl: if set, port is 'sending break' to remote
	224	* @write_only: self-explanatory
	225	* @overrun: previous rx was lost (partially or completely)
	226	* @loopback: if set, port is in loopback mode
	227	* @flags: atomic bit flags
	228	* bit 0: IN_TX - gate to allow only one cpu to send from the dma fifo
	229	* at a time.
	230	* bit 1: STOP_TX - force tx to exit while sending
	231	* @peer: rcu-pointer to associated fwtty_peer (if attached)
	232	* NULL if no peer attached
	233	* @icount: predefined statistics reported by the TIOCGICOUNT ioctl
	234	* @stats: additional statistics reported in /proc/tty/driver/firewire_serial
	235	*/
	236	struct fwtty_port {
	237	struct tty_port port;
	238	struct device *device;
	239	unsigned index;
	240	struct fw_serial *serial;
	241	struct fw_address_handler rx_handler;
	242
	243	struct fwconsole_ops *fwcon_ops;
	244	void *con_data;
	245
	246	wait_queue_head_t wait_tx;
	247	struct delayed_work emit_breaks;
	248	unsigned cps;
	249	unsigned long break_last;
	250
	251	struct work_struct hangup;
	252
	253	unsigned mstatus;
	254
	255	spinlock_t lock;
	256	unsigned mctrl;
	257	struct delayed_work drain;
e5711071 PH	258	struct dma_fifo tx_fifo;
	259	int max_payload;
	260	unsigned status_mask;
	261	unsigned ignore_mask;
	262	unsigned break_ctl:1,
	263	write_only:1,
	264	overrun:1,
	265	loopback:1;
	266	unsigned long flags;
	267
1aedfa8f	268	struct fwtty_peer __rcu *peer;
e5711071 PH	269
	270	struct async_icount icount;
	271	struct stats stats;
	272	};
	273
	274	#define to_port(ptr, field) (container_of(ptr, struct fwtty_port, field))
	275
	276	/* bit #s for flags field */
	277	#define IN_TX 0
	278	#define STOP_TX 1
e5711071 PH	279
	280	/* bitmasks for special mctrl/mstatus bits */
	281	#define OOB_RX_THROTTLE 0x00010000
	282	#define MCTRL_RSRVD 0x000e0000
	283	#define OOB_TX_THROTTLE 0x00100000
	284	#define MSTATUS_RSRVD 0x00e00000
	285
	286	#define MCTRL_MASK (TIOCM_DTR \| TIOCM_RTS \| TIOCM_OUT1 \| TIOCM_OUT2 \| \
	287	TIOCM_LOOP \| OOB_RX_THROTTLE \| MCTRL_RSRVD)
	288
	289	/* XXX even every 1/50th secs. may be unnecessarily accurate */
	290	/* delay in jiffies between brk emits */
	291	#define FREQ_BREAKS (HZ / 50)
	292
	293	/* Ports are allocated in blocks of num_ports for each fw_card */
	294	#define MAX_CARD_PORTS 32 /* max # of ports per card */
	295	#define MAX_TOTAL_PORTS 64 /* max # of ports total */
	296
	297	/* tuning parameters */
	298	#define FWTTY_PORT_TXFIFO_LEN 4096
	299	#define FWTTY_PORT_MAX_PEND_DMA 8 /* costs a cache line per pend */
	300	#define DRAIN_THRESHOLD 1024
	301	#define MAX_ASYNC_PAYLOAD 4096 /* ohci-defined limit */
	302	#define WRITER_MINIMUM 128
	303	/* TODO: how to set watermark to AR context size? see fwtty_rx() */
	304	#define HIGH_WATERMARK 32768 /* AR context is 32K */
	305
	306	/*
	307	* Size of bus addr region above 4GB used per port as the recv addr
	308	* - must be at least as big as the MAX_ASYNC_PAYLOAD
	309	*/
	310	#define FWTTY_PORT_RXFIFO_LEN MAX_ASYNC_PAYLOAD
	311
	312	/**
	313	* fw_serial: aggregate used to associate tty ports with specific fw_card
	314	* @card: fw_card associated with this fw_serial device (1:1 association)
	315	* @kref: reference-counted multi-port management allows delayed destroy
	316	* @self: local unit device as 'peer'. Not valid until local unit device
	317	* is enumerated.
	318	* @list: link for insertion into fwserial_list
	319	* @peer_list: list of local & remote unit devices attached to this card
	320	* @ports: fixed array of tty_ports provided by this serial device
	321	*/
	322	struct fw_serial {
	323	struct fw_card *card;
	324	struct kref kref;
	325
4df5bb04	326	struct dentry *debugfs;
e5711071 PH	327	struct fwtty_peer *self;
	328
	329	struct list_head list;
	330	struct list_head peer_list;
	331
	332	struct fwtty_port *ports[MAX_CARD_PORTS];
	333	};
	334
	335	#define to_serial(ptr, field) (container_of(ptr, struct fw_serial, field))
	336
	337	#define TTY_DEV_NAME "fwtty" /* ttyFW was taken */
	338	static const char tty_dev_name[] = TTY_DEV_NAME;
	339	static const char loop_dev_name[] = "fwloop";
e5711071	340
a3d9ad47	341	extern struct tty_driver *fwtty_driver;
e5711071	342
e5711071 PH	343	struct fwtty_port *fwtty_port_get(unsigned index);
	344	void fwtty_port_put(struct fwtty_port *port);
	345
	346	static inline void fwtty_bind_console(struct fwtty_port *port,
	347	struct fwconsole_ops *fwcon_ops,
	348	void *data)
	349	{
	350	port->con_data = data;
	351	port->fwcon_ops = fwcon_ops;
	352	}
	353
	354	/*
	355	* Returns the max send async payload size in bytes based on the unit device
06b8f14d PH	356	* link speed. Self-limiting asynchronous bandwidth (via reducing the payload)
	357	* is not necessary and does not work, because
	358	* 1) asynchronous traffic will absorb all available bandwidth (less that
	359	* being used for isochronous traffic)
	360	* 2) isochronous arbitration always wins.
e5711071 PH	361	*/
	362	static inline int link_speed_to_max_payload(unsigned speed)
	363	{
d8356189 PH	364	/* Max async payload is 4096 - see IEEE 1394-2008 tables 6-4, 16-18 */
d8356189 PH	365	return min(512 << speed, 4096);
e5711071 PH	366	}
	367
	368	#endif /* _FIREWIRE_FWSERIAL_H */