/* SPDX-License-Identifier: GPL-2.0 */
|
#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 int stat[], unsigned int 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 int 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 int xchars;
|
unsigned int dropped;
|
unsigned int tx_stall;
|
unsigned int fifo_errs;
|
unsigned int sent;
|
unsigned int lost;
|
unsigned int throttled;
|
unsigned int reads[DISTRIBUTION_MAX_INDEX + 1];
|
unsigned int writes[DISTRIBUTION_MAX_INDEX + 1];
|
unsigned int txns[DISTRIBUTION_MAX_INDEX + 1];
|
unsigned int 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 transmissible 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 int 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 int cps;
|
unsigned long break_last;
|
|
struct work_struct hangup;
|
|
unsigned int mstatus;
|
|
spinlock_t lock;
|
unsigned int mctrl;
|
struct delayed_work drain;
|
struct dma_fifo tx_fifo;
|
int max_payload;
|
unsigned int status_mask;
|
unsigned int ignore_mask;
|
unsigned int 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;
|
|
/*
|
* 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 int speed)
|
{
|
/* Max async payload is 4096 - see IEEE 1394-2008 tables 6-4, 16-18 */
|
return min(512 << speed, 4096);
|
}
|
|
#endif /* _FIREWIRE_FWSERIAL_H */
|
