[linux-2.6-block.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;
	work_func_t		workfn;
	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           CONFIG_FWTTY_MAX_CARD_PORTS
#define MAX_TOTAL_PORTS          CONFIG_FWTTY_MAX_TOTAL_PORTS

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