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> 18#include <linux/debugfs.h> 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) 25static inline void fwtty_profile_data(unsigned stat[], unsigned val) 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 32#define fwtty_profile_data(st, n) 33#endif 34 35/* Parameters for both VIRT_CABLE_PLUG & VIRT_CABLE_PLUG_RSP mgmt codes */ 36struct 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 44struct 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 */ 75struct 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 work_func_t workfn; 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 */ 108enum 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 */ 124static inline void peer_set_state(struct fwtty_peer *peer, int new) 125{ 126 peer->state = new; 127} 128 129static 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 138struct 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 162struct stats { 163 unsigned xchars; 164 unsigned dropped; 165 unsigned tx_stall; 166 unsigned fifo_errs; 167 unsigned sent; 168 unsigned lost; 169 unsigned throttled; 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 176struct 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 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 191 * note: minor = index + minor_start assigned by tty_alloc_driver() 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. 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 */ 237struct 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; 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 269 struct fwtty_peer __rcu *peer; 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 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 */ 295#define MAX_CARD_PORTS CONFIG_FWTTY_MAX_CARD_PORTS 296#define MAX_TOTAL_PORTS CONFIG_FWTTY_MAX_TOTAL_PORTS 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 */ 323struct fw_serial { 324 struct fw_card *card; 325 struct kref kref; 326 327 struct dentry *debugfs; 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 */ 339static const char tty_dev_name[] = TTY_DEV_NAME; 340static const char loop_dev_name[] = "fwloop"; 341 342extern struct tty_driver *fwtty_driver; 343 344struct fwtty_port *fwtty_port_get(unsigned index); 345void fwtty_port_put(struct fwtty_port *port); 346 347static 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 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. 362 */ 363static inline int link_speed_to_max_payload(unsigned speed) 364{ 365 /* Max async payload is 4096 - see IEEE 1394-2008 tables 6-4, 16-18 */ 366 return min(512 << speed, 4096); 367} 368 369#endif /* _FIREWIRE_FWSERIAL_H */ 370