| #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 profile_size_distrib(unsigned stat[], unsigned val) |
| { |
| int n = (val) ? min(ilog2(val) + 1, DISTRIBUTION_MAX_INDEX) : 0; |
| ++stat[n]; |
| } |
| #else |
| #define DISTRIBUTION_MAX_INDEX 0 |
| #define profile_size_distrib(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 watermark; |
| 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 |
| |
| struct buffered_rx { |
| struct list_head list; |
| size_t n; |
| unsigned char data[0]; |
| }; |
| |
| /** |
| * 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. |
| * @push: work responsible for pushing buffered rx to the ldisc. |
| * rx can become buffered if the tty buffer is filled before the |
| * ldisc throttles the sender. |
| * @buf_list: list of buffered rx yet to be sent to ldisc |
| * @buffered: byte count of buffered rx |
| * @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 work_struct push; |
| struct list_head buf_list; |
| int buffered; |
| 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 |
| #define BUFFERING_RX 2 |
| |
| /* 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 */ |