projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'regmap-v3.9-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[deliverable/linux.git] / drivers / staging / fwserial / fwserial.c
CommitLineData
7355ba34
PH		 1/*
2 * FireWire Serial driver
3 *
4 * Copyright (C) 2012 Peter Hurley <peter@hurleysoftware.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 */
20
21#include <linux/sched.h>
22#include <linux/slab.h>
23#include <linux/device.h>
24#include <linux/mod_devicetable.h>
25#include <linux/rculist.h>
26#include <linux/workqueue.h>
27#include <linux/ratelimit.h>
28#include <linux/bug.h>
29#include <linux/uaccess.h>
30
31#include "fwserial.h"
32
33#define be32_to_u64(hi, lo) ((u64)be32_to_cpu(hi) << 32 | be32_to_cpu(lo))
34
35#define LINUX_VENDOR_ID 0xd00d1eU /* same id used in card root directory */
36#define FWSERIAL_VERSION 0x00e81cU /* must be unique within LINUX_VENDOR_ID */
37
38/* configurable options */
39static int num_ttys = 4; /* # of std ttys to create per fw_card */
40 /* - doubles as loopback port index */
41static bool auto_connect = true; /* try to VIRT_CABLE to every peer */
42static bool create_loop_dev = true; /* create a loopback device for each card */
7355ba34
PH		 43
44module_param_named(ttys, num_ttys, int, S_IRUGO | S_IWUSR);
45module_param_named(auto, auto_connect, bool, S_IRUGO | S_IWUSR);
46module_param_named(loop, create_loop_dev, bool, S_IRUGO | S_IWUSR);
7355ba34
PH		 47
48/*
49 * Threshold below which the tty is woken for writing
50 * - should be equal to WAKEUP_CHARS in drivers/tty/n_tty.c because
51 * even if the writer is woken, n_tty_poll() won't set POLLOUT until
52 * our fifo is below this level
53 */
54#define WAKEUP_CHARS 256
55
56/**
57 * fwserial_list: list of every fw_serial created for each fw_card
58 * See discussion in fwserial_probe.
59 */
60static LIST_HEAD(fwserial_list);
61static DEFINE_MUTEX(fwserial_list_mutex);
62
63/**
64 * port_table: array of tty ports allocated to each fw_card
65 *
66 * tty ports are allocated during probe when an fw_serial is first
67 * created for a given fw_card. Ports are allocated in a contiguous block,
68 * each block consisting of 'num_ports' ports.
69 */
70static struct fwtty_port *port_table[MAX_TOTAL_PORTS];
71static DEFINE_MUTEX(port_table_lock);
72static bool port_table_corrupt;
73#define FWTTY_INVALID_INDEX MAX_TOTAL_PORTS
74
fa1da242
PH		 75#define loop_idx(port) (((port)->index) / num_ports)
76#define table_idx(loop) ((loop) * num_ports + num_ttys)
77
7355ba34
PH		 78/* total # of tty ports created per fw_card */
79static int num_ports;
80
81/* slab used as pool for struct fwtty_transactions */
82static struct kmem_cache *fwtty_txn_cache;
83
a3d9ad47 84struct tty_driver *fwtty_driver;
fa1da242 85static struct tty_driver *fwloop_driver;
a3d9ad47 86
4df5bb04
PH		 87static struct dentry *fwserial_debugfs;
88
7355ba34
PH		 89struct fwtty_transaction;
90typedef void (*fwtty_transaction_cb)(struct fw_card *card, int rcode,
91 void *data, size_t length,
92 struct fwtty_transaction *txn);
93
94struct fwtty_transaction {
95 struct fw_transaction fw_txn;
96 fwtty_transaction_cb callback;
97 struct fwtty_port *port;
98 union {
99 struct dma_pending dma_pended;
100 };
101};
102
103#define to_device(a, b) (a->b)
104#define fwtty_err(p, s, v...) dev_err(to_device(p, device), s, ##v)
105#define fwtty_info(p, s, v...) dev_info(to_device(p, device), s, ##v)
106#define fwtty_notice(p, s, v...) dev_notice(to_device(p, device), s, ##v)
107#define fwtty_dbg(p, s, v...) \
108 dev_dbg(to_device(p, device), "%s: " s, __func__, ##v)
109#define fwtty_err_ratelimited(p, s, v...) \
110 dev_err_ratelimited(to_device(p, device), s, ##v)
111
112#ifdef DEBUG
113static inline void debug_short_write(struct fwtty_port *port, int c, int n)
114{
115 int avail;
116
117 if (n < c) {
118 spin_lock_bh(&port->lock);
119 avail = dma_fifo_avail(&port->tx_fifo);
120 spin_unlock_bh(&port->lock);
121 fwtty_dbg(port, "short write: avail:%d req:%d wrote:%d",
122 avail, c, n);
123 }
124}
125#else
126#define debug_short_write(port, c, n)
127#endif
128
129static struct fwtty_peer *__fwserial_peer_by_node_id(struct fw_card *card,
130 int generation, int id);
131
132#ifdef FWTTY_PROFILING
133
134static void profile_fifo_avail(struct fwtty_port *port, unsigned *stat)
135{
136 spin_lock_bh(&port->lock);
137 profile_size_distrib(stat, dma_fifo_avail(&port->tx_fifo));
138 spin_unlock_bh(&port->lock);
139}
140
141static void dump_profile(struct seq_file *m, struct stats *stats)
142{
143 /* for each stat, print sum of 0 to 2^k, then individually */
144 int k = 4;
145 unsigned sum;
146 int j;
147 char t[10];
148
149 snprintf(t, 10, "< %d", 1 << k);
150 seq_printf(m, "\n%14s %6s", " ", t);
151 for (j = k + 1; j < DISTRIBUTION_MAX_INDEX; ++j)
152 seq_printf(m, "%6d", 1 << j);
153
154 ++k;
155 for (j = 0, sum = 0; j <= k; ++j)
156 sum += stats->reads[j];
157 seq_printf(m, "\n%14s: %6d", "reads", sum);
158 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
159 seq_printf(m, "%6d", stats->reads[j]);
160
161 for (j = 0, sum = 0; j <= k; ++j)
162 sum += stats->writes[j];
163 seq_printf(m, "\n%14s: %6d", "writes", sum);
164 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
165 seq_printf(m, "%6d", stats->writes[j]);
166
167 for (j = 0, sum = 0; j <= k; ++j)
168 sum += stats->txns[j];
169 seq_printf(m, "\n%14s: %6d", "txns", sum);
170 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
171 seq_printf(m, "%6d", stats->txns[j]);
172
173 for (j = 0, sum = 0; j <= k; ++j)
174 sum += stats->unthrottle[j];
175 seq_printf(m, "\n%14s: %6d", "avail @ unthr", sum);
176 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
177 seq_printf(m, "%6d", stats->unthrottle[j]);
178}
179
180#else
181#define profile_fifo_avail(port, stat)
182#define dump_profile(m, stats)
183#endif
184
9883a739
PH		 185/*
186 * Returns the max receive packet size for the given node
187 * Devices which are OHCI v1.0/ v1.1/ v1.2-draft or RFC 2734 compliant
188 * are required by specification to support max_rec of 8 (512 bytes) or more.
189 */
7355ba34
PH		 190static inline int device_max_receive(struct fw_device *fw_device)
191{
9883a739
PH		 192 /* see IEEE 1394-2008 table 8-8 */
193 return min(2 << fw_device->max_rec, 4096);
7355ba34
PH		 194}
195
196static void fwtty_log_tx_error(struct fwtty_port *port, int rcode)
197{
198 switch (rcode) {
199 case RCODE_SEND_ERROR:
200 fwtty_err_ratelimited(port, "card busy");
201 break;
202 case RCODE_ADDRESS_ERROR:
203 fwtty_err_ratelimited(port, "bad unit addr or write length");
204 break;
205 case RCODE_DATA_ERROR:
206 fwtty_err_ratelimited(port, "failed rx");
207 break;
208 case RCODE_NO_ACK:
209 fwtty_err_ratelimited(port, "missing ack");
210 break;
211 case RCODE_BUSY:
212 fwtty_err_ratelimited(port, "remote busy");
213 break;
214 default:
215 fwtty_err_ratelimited(port, "failed tx: %d", rcode);
216 }
217}
218
219static void fwtty_txn_constructor(void *this)
220{
221 struct fwtty_transaction *txn = this;
222
223 init_timer(&txn->fw_txn.split_timeout_timer);
224}
225
226static void fwtty_common_callback(struct fw_card *card, int rcode,
227 void *payload, size_t len, void *cb_data)
228{
229 struct fwtty_transaction *txn = cb_data;
230 struct fwtty_port *port = txn->port;
231
232 if (port && rcode != RCODE_COMPLETE)
233 fwtty_log_tx_error(port, rcode);
234 if (txn->callback)
235 txn->callback(card, rcode, payload, len, txn);
236 kmem_cache_free(fwtty_txn_cache, txn);
237}
238
239static int fwtty_send_data_async(struct fwtty_peer *peer, int tcode,
240 unsigned long long addr, void *payload,
241 size_t len, fwtty_transaction_cb callback,
242 struct fwtty_port *port)
243{
244 struct fwtty_transaction *txn;
245 int generation;
246
247 txn = kmem_cache_alloc(fwtty_txn_cache, GFP_ATOMIC);
248 if (!txn)
249 return -ENOMEM;
250
251 txn->callback = callback;
252 txn->port = port;
253
254 generation = peer->generation;
255 smp_rmb();
256 fw_send_request(peer->serial->card, &txn->fw_txn, tcode,
257 peer->node_id, generation, peer->speed, addr, payload,
258 len, fwtty_common_callback, txn);
259 return 0;
260}
261
262static void fwtty_send_txn_async(struct fwtty_peer *peer,
263 struct fwtty_transaction *txn, int tcode,
264 unsigned long long addr, void *payload,
265 size_t len, fwtty_transaction_cb callback,
266 struct fwtty_port *port)
267{
268 int generation;
269
270 txn->callback = callback;
271 txn->port = port;
272
273 generation = peer->generation;
274 smp_rmb();
275 fw_send_request(peer->serial->card, &txn->fw_txn, tcode,
276 peer->node_id, generation, peer->speed, addr, payload,
277 len, fwtty_common_callback, txn);
278}
279
280
281static void __fwtty_restart_tx(struct fwtty_port *port)
282{
283 int len, avail;
284
285 len = dma_fifo_out_level(&port->tx_fifo);
286 if (len)
287 schedule_delayed_work(&port->drain, 0);
288 avail = dma_fifo_avail(&port->tx_fifo);
289
290 fwtty_dbg(port, "fifo len: %d avail: %d", len, avail);
291}
292
293static void fwtty_restart_tx(struct fwtty_port *port)
294{
295 spin_lock_bh(&port->lock);
296 __fwtty_restart_tx(port);
297 spin_unlock_bh(&port->lock);
298}
299
300/**
301 * fwtty_update_port_status - decodes & dispatches line status changes
302 *
303 * Note: in loopback, the port->lock is being held. Only use functions that
304 * don't attempt to reclaim the port->lock.
305 */
306static void fwtty_update_port_status(struct fwtty_port *port, unsigned status)
307{
308 unsigned delta;
309 struct tty_struct *tty;
310
311 /* simulated LSR/MSR status from remote */
312 status &= ~MCTRL_MASK;
313 delta = (port->mstatus ^ status) & ~MCTRL_MASK;
314 delta &= ~(status & TIOCM_RNG);
315 port->mstatus = status;
316
317 if (delta & TIOCM_RNG)
318 ++port->icount.rng;
319 if (delta & TIOCM_DSR)
320 ++port->icount.dsr;
321 if (delta & TIOCM_CAR)
322 ++port->icount.dcd;
323 if (delta & TIOCM_CTS)
324 ++port->icount.cts;
325
326 fwtty_dbg(port, "status: %x delta: %x", status, delta);
327
328 if (delta & TIOCM_CAR) {
329 tty = tty_port_tty_get(&port->port);
330 if (tty && !C_CLOCAL(tty)) {
331 if (status & TIOCM_CAR)
332 wake_up_interruptible(&port->port.open_wait);
333 else
334 schedule_work(&port->hangup);
335 }
336 tty_kref_put(tty);
337 }
338
339 if (delta & TIOCM_CTS) {
340 tty = tty_port_tty_get(&port->port);
341 if (tty && C_CRTSCTS(tty)) {
342 if (tty->hw_stopped) {
343 if (status & TIOCM_CTS) {
344 tty->hw_stopped = 0;
345 if (port->loopback)
346 __fwtty_restart_tx(port);
347 else
348 fwtty_restart_tx(port);
349 }
350 } else {
351 if (~status & TIOCM_CTS)
352 tty->hw_stopped = 1;
353 }
354 }
355 tty_kref_put(tty);
356
357 } else if (delta & OOB_TX_THROTTLE) {
358 tty = tty_port_tty_get(&port->port);
359 if (tty) {
360 if (tty->hw_stopped) {
361 if (~status & OOB_TX_THROTTLE) {
362 tty->hw_stopped = 0;
363 if (port->loopback)
364 __fwtty_restart_tx(port);
365 else
366 fwtty_restart_tx(port);
367 }
368 } else {
369 if (status & OOB_TX_THROTTLE)
370 tty->hw_stopped = 1;
371 }
372 }
373 tty_kref_put(tty);
374 }
375
376 if (delta & (UART_LSR_BI << 24)) {
377 if (status & (UART_LSR_BI << 24)) {
378 port->break_last = jiffies;
379 schedule_delayed_work(&port->emit_breaks, 0);
380 } else {
381 /* run emit_breaks one last time (if pending) */
382 mod_delayed_work(system_wq, &port->emit_breaks, 0);
383 }
384 }
385
386 if (delta & (TIOCM_DSR | TIOCM_CAR | TIOCM_CTS | TIOCM_RNG))
387 wake_up_interruptible(&port->port.delta_msr_wait);
388}
389
390/**
391 * __fwtty_port_line_status - generate 'line status' for indicated port
392 *
393 * This function returns a remote 'MSR' state based on the local 'MCR' state,
394 * as if a null modem cable was attached. The actual status is a mangling
395 * of TIOCM_* bits suitable for sending to a peer's status_addr.
396 *
397 * Note: caller must be holding port lock
398 */
399static unsigned __fwtty_port_line_status(struct fwtty_port *port)
400{
401 unsigned status = 0;
402
403 /* TODO: add module param to tie RNG to DTR as well */
404
405 if (port->mctrl & TIOCM_DTR)
406 status |= TIOCM_DSR | TIOCM_CAR;
407 if (port->mctrl & TIOCM_RTS)
408 status |= TIOCM_CTS;
409 if (port->mctrl & OOB_RX_THROTTLE)
410 status |= OOB_TX_THROTTLE;
411 /* emulate BRK as add'l line status */
412 if (port->break_ctl)
413 status |= UART_LSR_BI << 24;
414
415 return status;
416}
417
418/**
419 * __fwtty_write_port_status - send the port line status to peer
420 *
421 * Note: caller must be holding the port lock.
422 */
423static int __fwtty_write_port_status(struct fwtty_port *port)
424{
425 struct fwtty_peer *peer;
426 int err = -ENOENT;
427 unsigned status = __fwtty_port_line_status(port);
428
429 rcu_read_lock();
430 peer = rcu_dereference(port->peer);
431 if (peer) {
432 err = fwtty_send_data_async(peer, TCODE_WRITE_QUADLET_REQUEST,
433 peer->status_addr, &status,
434 sizeof(status), NULL, port);
435 }
436 rcu_read_unlock();
437
438 return err;
439}
440
441/**
442 * fwtty_write_port_status - same as above but locked by port lock
443 */
444static int fwtty_write_port_status(struct fwtty_port *port)
445{
446 int err;
447
448 spin_lock_bh(&port->lock);
449 err = __fwtty_write_port_status(port);
450 spin_unlock_bh(&port->lock);
451 return err;
452}
453
454static void __fwtty_throttle(struct fwtty_port *port, struct tty_struct *tty)
455{
456 unsigned old;
457
458 old = port->mctrl;
459 port->mctrl |= OOB_RX_THROTTLE;
460 if (C_CRTSCTS(tty))
461 port->mctrl &= ~TIOCM_RTS;
462 if (~old & OOB_RX_THROTTLE)
463 __fwtty_write_port_status(port);
464}
465
466/**
467 * fwtty_do_hangup - wait for ldisc to deliver all pending rx; only then hangup
468 *
469 * When the remote has finished tx, and all in-flight rx has been received and
470 * and pushed to the flip buffer, the remote may close its device. This will
471 * drop DTR on the remote which will drop carrier here. Typically, the tty is
472 * hung up when carrier is dropped or lost.
473 *
474 * However, there is a race between the hang up and the line discipline
475 * delivering its data to the reader. A hangup will cause the ldisc to flush
476 * (ie., clear) the read buffer and flip buffer. Because of firewire's
477 * relatively high throughput, the ldisc frequently lags well behind the driver,
478 * resulting in lost data (which has already been received and written to
479 * the flip buffer) when the remote closes its end.
480 *
481 * Unfortunately, since the flip buffer offers no direct method for determining
482 * if it holds data, ensuring the ldisc has delivered all data is problematic.
483 */
484
485/* FIXME: drop this workaround when __tty_hangup waits for ldisc completion */
486static void fwtty_do_hangup(struct work_struct *work)
487{
488 struct fwtty_port *port = to_port(work, hangup);
489 struct tty_struct *tty;
490
491 schedule_timeout_uninterruptible(msecs_to_jiffies(50));
492
493 tty = tty_port_tty_get(&port->port);
494 if (tty)
495 tty_vhangup(tty);
496 tty_kref_put(tty);
497}
498
499
500static void fwtty_emit_breaks(struct work_struct *work)
501{
502 struct fwtty_port *port = to_port(to_delayed_work(work), emit_breaks);
7355ba34
PH		 503 static const char buf[16];
504 unsigned long now = jiffies;
505 unsigned long elapsed = now - port->break_last;
506 int n, t, c, brk = 0;
507
7355ba34
PH		 508 /* generate breaks at the line rate (but at least 1) */
509 n = (elapsed * port->cps) / HZ + 1;
510 port->break_last = now;
511
512 fwtty_dbg(port, "sending %d brks", n);
513
514 while (n) {
515 t = min(n, 16);
2f693357
JS		 516 c = tty_insert_flip_string_fixed_flag(&port->port, buf,
517 TTY_BREAK, t);
7355ba34
PH		 518 n -= c;
519 brk += c;
520 if (c < t)
521 break;
522 }
2e124b4a 523 tty_flip_buffer_push(&port->port);
7355ba34
PH		 524
525 if (port->mstatus & (UART_LSR_BI << 24))
526 schedule_delayed_work(&port->emit_breaks, FREQ_BREAKS);
527 port->icount.brk += brk;
528}
529
530static void fwtty_pushrx(struct work_struct *work)
531{
532 struct fwtty_port *port = to_port(work, push);
533 struct tty_struct *tty;
534 struct buffered_rx *buf, *next;
535 int n, c = 0;
536
7355ba34
PH		 537 spin_lock_bh(&port->lock);
538 list_for_each_entry_safe(buf, next, &port->buf_list, list) {
2f693357 539 n = tty_insert_flip_string_fixed_flag(&port->port, buf->data,
7355ba34
PH		 540 TTY_NORMAL, buf->n);
541 c += n;
542 port->buffered -= n;
543 if (n < buf->n) {
544 if (n > 0) {
545 memmove(buf->data, buf->data + n, buf->n - n);
546 buf->n -= n;
547 }
2e124b4a
JS		 548 tty = tty_port_tty_get(&port->port);
549 if (tty) {
550 __fwtty_throttle(port, tty);
551 tty_kref_put(tty);
552 }
7355ba34
PH		 553 break;
554 } else {
555 list_del(&buf->list);
556 kfree(buf);
557 }
558 }
559 if (c > 0)
2e124b4a 560 tty_flip_buffer_push(&port->port);
7355ba34
PH		 561
562 if (list_empty(&port->buf_list))
563 clear_bit(BUFFERING_RX, &port->flags);
564 spin_unlock_bh(&port->lock);
7355ba34
PH		 565}
566
567static int fwtty_buffer_rx(struct fwtty_port *port, unsigned char *d, size_t n)
568{
569 struct buffered_rx *buf;
570 size_t size = (n + sizeof(struct buffered_rx) + 0xFF) & ~0xFF;
571
ef34dd18 572 if (port->buffered + n > HIGH_WATERMARK) {
d13b0b6d 573 fwtty_err_ratelimited(port, "overflowed rx buffer: buffered: %d new: %zu wtrmk: %d",
ef34dd18 574 port->buffered, n, HIGH_WATERMARK);
7355ba34 575 return 0;
ef34dd18 576 }
7355ba34
PH		 577 buf = kmalloc(size, GFP_ATOMIC);
578 if (!buf)
579 return 0;
580 INIT_LIST_HEAD(&buf->list);
581 buf->n = n;
582 memcpy(buf->data, d, n);
583
584 spin_lock_bh(&port->lock);
585 list_add_tail(&buf->list, &port->buf_list);
586 port->buffered += n;
587 if (port->buffered > port->stats.watermark)
588 port->stats.watermark = port->buffered;
589 set_bit(BUFFERING_RX, &port->flags);
590 spin_unlock_bh(&port->lock);
591
592 return n;
593}
594
595static int fwtty_rx(struct fwtty_port *port, unsigned char *data, size_t len)
596{
597 struct tty_struct *tty;
598 int c, n = len;
599 unsigned lsr;
600 int err = 0;
601
7355ba34
PH		 602 fwtty_dbg(port, "%d", n);
603 profile_size_distrib(port->stats.reads, n);
604
605 if (port->write_only) {
606 n = 0;
607 goto out;
608 }
609
610 /* disregard break status; breaks are generated by emit_breaks work */
611 lsr = (port->mstatus >> 24) & ~UART_LSR_BI;
612
613 if (port->overrun)
614 lsr |= UART_LSR_OE;
615
616 if (lsr & UART_LSR_OE)
617 ++port->icount.overrun;
618
619 lsr &= port->status_mask;
620 if (lsr & ~port->ignore_mask & UART_LSR_OE) {
92a19f9c 621 if (!tty_insert_flip_char(&port->port, 0, TTY_OVERRUN)) {
7355ba34
PH		 622 err = -EIO;
623 goto out;
624 }
625 }
626 port->overrun = false;
627
628 if (lsr & port->ignore_mask & ~UART_LSR_OE) {
629 /* TODO: don't drop SAK and Magic SysRq here */
630 n = 0;
631 goto out;
632 }
633
634 if (!test_bit(BUFFERING_RX, &port->flags)) {
2f693357
JS		 635 c = tty_insert_flip_string_fixed_flag(&port->port, data,
636 TTY_NORMAL, n);
7355ba34 637 if (c > 0)
2e124b4a 638 tty_flip_buffer_push(&port->port);
7355ba34
PH		 639 n -= c;
640
641 if (n) {
642 /* start buffering and throttling */
643 n -= fwtty_buffer_rx(port, &data[c], n);
644
2e124b4a
JS		 645 tty = tty_port_tty_get(&port->port);
646 if (tty) {
647 spin_lock_bh(&port->lock);
648 __fwtty_throttle(port, tty);
649 spin_unlock_bh(&port->lock);
650 tty_kref_put(tty);
651 }
7355ba34
PH		 652 }
653 } else
654 n -= fwtty_buffer_rx(port, data, n);
655
656 if (n) {
657 port->overrun = true;
658 err = -EIO;
659 }
660
661out:
7355ba34
PH		 662 port->icount.rx += len;
663 port->stats.lost += n;
664 return err;
665}
666
667/**
668 * fwtty_port_handler - bus address handler for port reads/writes
669 * @parameters: fw_address_callback_t as specified by firewire core interface
670 *
671 * This handler is responsible for handling inbound read/write dma from remotes.
672 */
673static void fwtty_port_handler(struct fw_card *card,
674 struct fw_request *request,
675 int tcode, int destination, int source,
676 int generation,
677 unsigned long long addr,
678 void *data, size_t len,
679 void *callback_data)
680{
681 struct fwtty_port *port = callback_data;
682 struct fwtty_peer *peer;
683 int err;
684 int rcode;
685
686 /* Only accept rx from the peer virtual-cabled to this port */
687 rcu_read_lock();
688 peer = __fwserial_peer_by_node_id(card, generation, source);
689 rcu_read_unlock();
690 if (!peer || peer != rcu_access_pointer(port->peer)) {
691 rcode = RCODE_ADDRESS_ERROR;
692 fwtty_err_ratelimited(port, "ignoring unauthenticated data");
693 goto respond;
694 }
695
696 switch (tcode) {
697 case TCODE_WRITE_QUADLET_REQUEST:
698 if (addr != port->rx_handler.offset || len != 4)
699 rcode = RCODE_ADDRESS_ERROR;
700 else {
701 fwtty_update_port_status(port, *(unsigned *)data);
702 rcode = RCODE_COMPLETE;
703 }
704 break;
705
706 case TCODE_WRITE_BLOCK_REQUEST:
707 if (addr != port->rx_handler.offset + 4 ||
708 len > port->rx_handler.length - 4) {
709 rcode = RCODE_ADDRESS_ERROR;
710 } else {
711 err = fwtty_rx(port, data, len);
712 switch (err) {
713 case 0:
714 rcode = RCODE_COMPLETE;
715 break;
716 case -EIO:
717 rcode = RCODE_DATA_ERROR;
718 break;
719 default:
720 rcode = RCODE_CONFLICT_ERROR;
721 break;
722 }
723 }
724 break;
725
726 default:
727 rcode = RCODE_TYPE_ERROR;
728 }
729
730respond:
731 fw_send_response(card, request, rcode);
732}
733
734/**
735 * fwtty_tx_complete - callback for tx dma
736 * @data: ignored, has no meaning for write txns
737 * @length: ignored, has no meaning for write txns
738 *
739 * The writer must be woken here if the fifo has been emptied because it
740 * may have slept if chars_in_buffer was != 0
741 */
742static void fwtty_tx_complete(struct fw_card *card, int rcode,
743 void *data, size_t length,
744 struct fwtty_transaction *txn)
745{
746 struct fwtty_port *port = txn->port;
747 struct tty_struct *tty;
748 int len;
749
750 fwtty_dbg(port, "rcode: %d", rcode);
751
752 switch (rcode) {
753 case RCODE_COMPLETE:
754 spin_lock_bh(&port->lock);
755 dma_fifo_out_complete(&port->tx_fifo, &txn->dma_pended);
756 len = dma_fifo_level(&port->tx_fifo);
757 spin_unlock_bh(&port->lock);
758
759 port->icount.tx += txn->dma_pended.len;
760 break;
761
762 default:
763 /* TODO: implement retries */
764 spin_lock_bh(&port->lock);
765 dma_fifo_out_complete(&port->tx_fifo, &txn->dma_pended);
766 len = dma_fifo_level(&port->tx_fifo);
767 spin_unlock_bh(&port->lock);
768
769 port->stats.dropped += txn->dma_pended.len;
770 }
771
772 if (len < WAKEUP_CHARS) {
773 tty = tty_port_tty_get(&port->port);
774 if (tty) {
775 tty_wakeup(tty);
776 tty_kref_put(tty);
777 }
778 }
779}
780
781static int fwtty_tx(struct fwtty_port *port, bool drain)
782{
783 struct fwtty_peer *peer;
784 struct fwtty_transaction *txn;
785 struct tty_struct *tty;
786 int n, len;
787
788 tty = tty_port_tty_get(&port->port);
789 if (!tty)
790 return -ENOENT;
791
792 rcu_read_lock();
793 peer = rcu_dereference(port->peer);
794 if (!peer) {
795 n = -EIO;
796 goto out;
797 }
798
799 if (test_and_set_bit(IN_TX, &port->flags)) {
800 n = -EALREADY;
801 goto out;
802 }
803
804 /* try to write as many dma transactions out as possible */
805 n = -EAGAIN;
806 while (!tty->stopped && !tty->hw_stopped &&
807 !test_bit(STOP_TX, &port->flags)) {
808 txn = kmem_cache_alloc(fwtty_txn_cache, GFP_ATOMIC);
809 if (!txn) {
810 n = -ENOMEM;
811 break;
812 }
813
814 spin_lock_bh(&port->lock);
815 n = dma_fifo_out_pend(&port->tx_fifo, &txn->dma_pended);
816 spin_unlock_bh(&port->lock);
817
818 fwtty_dbg(port, "out: %u rem: %d", txn->dma_pended.len, n);
819
820 if (n < 0) {
821 kmem_cache_free(fwtty_txn_cache, txn);
822 if (n == -EAGAIN)
823 ++port->stats.tx_stall;
824 else if (n == -ENODATA)
825 profile_size_distrib(port->stats.txns, 0);
826 else {
827 ++port->stats.fifo_errs;
828 fwtty_err_ratelimited(port, "fifo err: %d", n);
829 }
830 break;
831 }
832
833 profile_size_distrib(port->stats.txns, txn->dma_pended.len);
834
835 fwtty_send_txn_async(peer, txn, TCODE_WRITE_BLOCK_REQUEST,
836 peer->fifo_addr, txn->dma_pended.data,
837 txn->dma_pended.len, fwtty_tx_complete,
838 port);
839 ++port->stats.sent;
840
841 /*
842 * Stop tx if the 'last view' of the fifo is empty or if
843 * this is the writer and there's not enough data to bother
844 */
845 if (n == 0 || (!drain && n < WRITER_MINIMUM))
846 break;
847 }
848
849 if (n >= 0 || n == -EAGAIN || n == -ENOMEM || n == -ENODATA) {
850 spin_lock_bh(&port->lock);
851 len = dma_fifo_out_level(&port->tx_fifo);
852 if (len) {
853 unsigned long delay = (n == -ENOMEM) ? HZ : 1;
854 schedule_delayed_work(&port->drain, delay);
855 }
856 len = dma_fifo_level(&port->tx_fifo);
857 spin_unlock_bh(&port->lock);
858
859 /* wakeup the writer */
860 if (drain && len < WAKEUP_CHARS)
861 tty_wakeup(tty);
862 }
863
864 clear_bit(IN_TX, &port->flags);
865 wake_up_interruptible(&port->wait_tx);
866
867out:
868 rcu_read_unlock();
869 tty_kref_put(tty);
870 return n;
871}
872
873static void fwtty_drain_tx(struct work_struct *work)
874{
875 struct fwtty_port *port = to_port(to_delayed_work(work), drain);
876
877 fwtty_tx(port, true);
878}
879
880static void fwtty_write_xchar(struct fwtty_port *port, char ch)
881{
882 struct fwtty_peer *peer;
883
884 ++port->stats.xchars;
885
886 fwtty_dbg(port, "%02x", ch);
887
888 rcu_read_lock();
889 peer = rcu_dereference(port->peer);
890 if (peer) {
891 fwtty_send_data_async(peer, TCODE_WRITE_BLOCK_REQUEST,
892 peer->fifo_addr, &ch, sizeof(ch),
893 NULL, port);
894 }
895 rcu_read_unlock();
896}
897
898struct fwtty_port *fwtty_port_get(unsigned index)
899{
900 struct fwtty_port *port;
901
902 if (index >= MAX_TOTAL_PORTS)
903 return NULL;
904
905 mutex_lock(&port_table_lock);
906 port = port_table[index];
907 if (port)
908 kref_get(&port->serial->kref);
909 mutex_unlock(&port_table_lock);
910 return port;
911}
912EXPORT_SYMBOL(fwtty_port_get);
913
914static int fwtty_ports_add(struct fw_serial *serial)
915{
916 int err = -EBUSY;
917 int i, j;
918
919 if (port_table_corrupt)
920 return err;
921
922 mutex_lock(&port_table_lock);
923 for (i = 0; i + num_ports <= MAX_TOTAL_PORTS; i += num_ports) {
924 if (!port_table[i]) {
925 for (j = 0; j < num_ports; ++i, ++j) {
926 serial->ports[j]->index = i;
927 port_table[i] = serial->ports[j];
928 }
929 err = 0;
930 break;
931 }
932 }
933 mutex_unlock(&port_table_lock);
934 return err;
935}
936
937static void fwserial_destroy(struct kref *kref)
938{
939 struct fw_serial *serial = to_serial(kref, kref);
940 struct fwtty_port **ports = serial->ports;
941 int j, i = ports[0]->index;
942
943 synchronize_rcu();
944
945 mutex_lock(&port_table_lock);
946 for (j = 0; j < num_ports; ++i, ++j) {
49b2746e
PH		 947 port_table_corrupt |= port_table[i] != ports[j];
948 WARN_ONCE(port_table_corrupt, "port_table[%d]: %p != ports[%d]: %p",
949 i, port_table[i], j, ports[j]);
7355ba34
PH		 950
951 port_table[i] = NULL;
952 }
953 mutex_unlock(&port_table_lock);
954
955 for (j = 0; j < num_ports; ++j) {
956 fw_core_remove_address_handler(&ports[j]->rx_handler);
a3218464 957 tty_port_destroy(&ports[j]->port);
7355ba34
PH		 958 kfree(ports[j]);
959 }
960 kfree(serial);
961}
962
963void fwtty_port_put(struct fwtty_port *port)
964{
965 kref_put(&port->serial->kref, fwserial_destroy);
966}
967EXPORT_SYMBOL(fwtty_port_put);
968
969static void fwtty_port_dtr_rts(struct tty_port *tty_port, int on)
970{
971 struct fwtty_port *port = to_port(tty_port, port);
972
973 fwtty_dbg(port, "on/off: %d", on);
974
975 spin_lock_bh(&port->lock);
976 /* Don't change carrier state if this is a console */
977 if (!port->port.console) {
978 if (on)
979 port->mctrl |= TIOCM_DTR | TIOCM_RTS;
980 else
981 port->mctrl &= ~(TIOCM_DTR | TIOCM_RTS);
982 }
983
984 __fwtty_write_port_status(port);
985 spin_unlock_bh(&port->lock);
986}
987
988/**
989 * fwtty_port_carrier_raised: required tty_port operation
990 *
991 * This port operation is polled after a tty has been opened and is waiting for
992 * carrier detect -- see drivers/tty/tty_port:tty_port_block_til_ready().
993 */
994static int fwtty_port_carrier_raised(struct tty_port *tty_port)
995{
996 struct fwtty_port *port = to_port(tty_port, port);
997 int rc;
998
999 rc = (port->mstatus & TIOCM_CAR);
1000
1001 fwtty_dbg(port, "%d", rc);
1002
1003 return rc;
1004}
1005
1006static unsigned set_termios(struct fwtty_port *port, struct tty_struct *tty)
1007{
1008 unsigned baud, frame;
1009
1010 baud = tty_termios_baud_rate(&tty->termios);
1011 tty_termios_encode_baud_rate(&tty->termios, baud, baud);
1012
1013 /* compute bit count of 2 frames */
1014 frame = 12 + ((C_CSTOPB(tty)) ? 4 : 2) + ((C_PARENB(tty)) ? 2 : 0);
1015
1016 switch (C_CSIZE(tty)) {
1017 case CS5:
1018 frame -= (C_CSTOPB(tty)) ? 1 : 0;
1019 break;
1020 case CS6:
1021 frame += 2;
1022 break;
1023 case CS7:
1024 frame += 4;
1025 break;
1026 case CS8:
1027 frame += 6;
1028 break;
1029 }
1030
1031 port->cps = (baud << 1) / frame;
1032
1033 port->status_mask = UART_LSR_OE;
1034 if (_I_FLAG(tty, BRKINT | PARMRK))
1035 port->status_mask |= UART_LSR_BI;
1036
1037 port->ignore_mask = 0;
1038 if (I_IGNBRK(tty)) {
1039 port->ignore_mask |= UART_LSR_BI;
1040 if (I_IGNPAR(tty))
1041 port->ignore_mask |= UART_LSR_OE;
1042 }
1043
1044 port->write_only = !C_CREAD(tty);
1045
1046 /* turn off echo and newline xlat if loopback */
1047 if (port->loopback) {
1048 tty->termios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHOKE |
1049 ECHONL | ECHOPRT | ECHOCTL);
1050 tty->termios.c_oflag &= ~ONLCR;
1051 }
1052
1053 return baud;
1054}
1055
1056static int fwtty_port_activate(struct tty_port *tty_port,
1057 struct tty_struct *tty)
1058{
1059 struct fwtty_port *port = to_port(tty_port, port);
1060 unsigned baud;
1061 int err;
1062
1063 set_bit(TTY_IO_ERROR, &tty->flags);
1064
1065 err = dma_fifo_alloc(&port->tx_fifo, FWTTY_PORT_TXFIFO_LEN,
1066 cache_line_size(),
1067 port->max_payload,
1068 FWTTY_PORT_MAX_PEND_DMA,
1069 GFP_KERNEL);
1070 if (err)
1071 return err;
1072
1073 spin_lock_bh(&port->lock);
1074
1075 baud = set_termios(port, tty);
1076
1077 /* if console, don't change carrier state */
1078 if (!port->port.console) {
1079 port->mctrl = 0;
1080 if (baud != 0)
1081 port->mctrl = TIOCM_DTR | TIOCM_RTS;
1082 }
1083
1084 if (C_CRTSCTS(tty) && ~port->mstatus & TIOCM_CTS)
1085 tty->hw_stopped = 1;
1086
1087 __fwtty_write_port_status(port);
1088 spin_unlock_bh(&port->lock);
1089
1090 clear_bit(TTY_IO_ERROR, &tty->flags);
1091
1092 return 0;
1093}
1094
1095/**
1096 * fwtty_port_shutdown
1097 *
1098 * Note: the tty port core ensures this is not the console and
1099 * manages TTY_IO_ERROR properly
1100 */
1101static void fwtty_port_shutdown(struct tty_port *tty_port)
1102{
1103 struct fwtty_port *port = to_port(tty_port, port);
1104 struct buffered_rx *buf, *next;
1105
1106 /* TODO: cancel outstanding transactions */
1107
1108 cancel_delayed_work_sync(&port->emit_breaks);
1109 cancel_delayed_work_sync(&port->drain);
1110 cancel_work_sync(&port->push);
1111
1112 spin_lock_bh(&port->lock);
1113 list_for_each_entry_safe(buf, next, &port->buf_list, list) {
1114 list_del(&buf->list);
1115 kfree(buf);
1116 }
1117 port->buffered = 0;
1118 port->flags = 0;
1119 port->break_ctl = 0;
1120 port->overrun = 0;
1121 __fwtty_write_port_status(port);
1122 dma_fifo_free(&port->tx_fifo);
1123 spin_unlock_bh(&port->lock);
1124}
1125
1126static int fwtty_open(struct tty_struct *tty, struct file *fp)
1127{
1128 struct fwtty_port *port = tty->driver_data;
1129
1130 return tty_port_open(&port->port, tty, fp);
1131}
1132
1133static void fwtty_close(struct tty_struct *tty, struct file *fp)
1134{
1135 struct fwtty_port *port = tty->driver_data;
1136
1137 tty_port_close(&port->port, tty, fp);
1138}
1139
1140static void fwtty_hangup(struct tty_struct *tty)
1141{
1142 struct fwtty_port *port = tty->driver_data;
1143
1144 tty_port_hangup(&port->port);
1145}
1146
1147static void fwtty_cleanup(struct tty_struct *tty)
1148{
1149 struct fwtty_port *port = tty->driver_data;
1150
1151 tty->driver_data = NULL;
1152 fwtty_port_put(port);
1153}
1154
1155static int fwtty_install(struct tty_driver *driver, struct tty_struct *tty)
1156{
1157 struct fwtty_port *port = fwtty_port_get(tty->index);
1158 int err;
1159
1160 err = tty_standard_install(driver, tty);
1161 if (!err)
1162 tty->driver_data = port;
1163 else
1164 fwtty_port_put(port);
1165 return err;
1166}
1167
fa1da242
PH		 1168static int fwloop_install(struct tty_driver *driver, struct tty_struct *tty)
1169{
1170 struct fwtty_port *port = fwtty_port_get(table_idx(tty->index));
1171 int err;
1172
1173 err = tty_standard_install(driver, tty);
1174 if (!err)
1175 tty->driver_data = port;
1176 else
1177 fwtty_port_put(port);
1178 return err;
1179}
1180
7355ba34
PH		 1181static int fwtty_write(struct tty_struct *tty, const unsigned char *buf, int c)
1182{
1183 struct fwtty_port *port = tty->driver_data;
1184 int n, len;
1185
1186 fwtty_dbg(port, "%d", c);
1187 profile_size_distrib(port->stats.writes, c);
1188
1189 spin_lock_bh(&port->lock);
1190 n = dma_fifo_in(&port->tx_fifo, buf, c);
1191 len = dma_fifo_out_level(&port->tx_fifo);
1192 if (len < DRAIN_THRESHOLD)
1193 schedule_delayed_work(&port->drain, 1);
1194 spin_unlock_bh(&port->lock);
1195
1196 if (len >= DRAIN_THRESHOLD)
1197 fwtty_tx(port, false);
1198
1199 debug_short_write(port, c, n);
1200
1201 return (n < 0) ? 0 : n;
1202}
1203
1204static int fwtty_write_room(struct tty_struct *tty)
1205{
1206 struct fwtty_port *port = tty->driver_data;
1207 int n;
1208
1209 spin_lock_bh(&port->lock);
1210 n = dma_fifo_avail(&port->tx_fifo);
1211 spin_unlock_bh(&port->lock);
1212
1213 fwtty_dbg(port, "%d", n);
1214
1215 return n;
1216}
1217
1218static int fwtty_chars_in_buffer(struct tty_struct *tty)
1219{
1220 struct fwtty_port *port = tty->driver_data;
1221 int n;
1222
1223 spin_lock_bh(&port->lock);
1224 n = dma_fifo_level(&port->tx_fifo);
1225 spin_unlock_bh(&port->lock);
1226
1227 fwtty_dbg(port, "%d", n);
1228
1229 return n;
1230}
1231
1232static void fwtty_send_xchar(struct tty_struct *tty, char ch)
1233{
1234 struct fwtty_port *port = tty->driver_data;
1235
1236 fwtty_dbg(port, "%02x", ch);
1237
1238 fwtty_write_xchar(port, ch);
1239}
1240
1241static void fwtty_throttle(struct tty_struct *tty)
1242{
1243 struct fwtty_port *port = tty->driver_data;
1244
1245 /*
1246 * Ignore throttling (but not unthrottling).
1247 * It only makes sense to throttle when data will no longer be
1248 * accepted by the tty flip buffer. For example, it is
1249 * possible for received data to overflow the tty buffer long
1250 * before the line discipline ever has a chance to throttle the driver.
1251 * Additionally, the driver may have already completed the I/O
1252 * but the tty buffer is still emptying, so the line discipline is
1253 * throttling and unthrottling nothing.
1254 */
1255
1256 ++port->stats.throttled;
1257}
1258
1259static void fwtty_unthrottle(struct tty_struct *tty)
1260{
1261 struct fwtty_port *port = tty->driver_data;
1262
1263 fwtty_dbg(port, "CRTSCTS: %d", (C_CRTSCTS(tty) != 0));
1264
1265 profile_fifo_avail(port, port->stats.unthrottle);
1266
1267 schedule_work(&port->push);
1268
1269 spin_lock_bh(&port->lock);
1270 port->mctrl &= ~OOB_RX_THROTTLE;
1271 if (C_CRTSCTS(tty))
1272 port->mctrl |= TIOCM_RTS;
1273 __fwtty_write_port_status(port);
1274 spin_unlock_bh(&port->lock);
1275}
1276
1277static int check_msr_delta(struct fwtty_port *port, unsigned long mask,
1278 struct async_icount *prev)
1279{
1280 struct async_icount now;
1281 int delta;
1282
1283 now = port->icount;
1284
1285 delta = ((mask & TIOCM_RNG && prev->rng != now.rng) ||
1286 (mask & TIOCM_DSR && prev->dsr != now.dsr) ||
1287 (mask & TIOCM_CAR && prev->dcd != now.dcd) ||
1288 (mask & TIOCM_CTS && prev->cts != now.cts));
1289
1290 *prev = now;
1291
1292 return delta;
1293}
1294
1295static int wait_msr_change(struct fwtty_port *port, unsigned long mask)
1296{
1297 struct async_icount prev;
1298
1299 prev = port->icount;
1300
1301 return wait_event_interruptible(port->port.delta_msr_wait,
1302 check_msr_delta(port, mask, &prev));
1303}
1304
1305static int get_serial_info(struct fwtty_port *port,
1306 struct serial_struct __user *info)
1307{
1308 struct serial_struct tmp;
1309
1310 memset(&tmp, 0, sizeof(tmp));
1311
1312 tmp.type = PORT_UNKNOWN;
1313 tmp.line = port->port.tty->index;
1314 tmp.flags = port->port.flags;
1315 tmp.xmit_fifo_size = FWTTY_PORT_TXFIFO_LEN;
1316 tmp.baud_base = 400000000;
1317 tmp.close_delay = port->port.close_delay;
1318
1319 return (copy_to_user(info, &tmp, sizeof(*info))) ? -EFAULT : 0;
1320}
1321
1322static int set_serial_info(struct fwtty_port *port,
1323 struct serial_struct __user *info)
1324{
1325 struct serial_struct tmp;
1326
1327 if (copy_from_user(&tmp, info, sizeof(tmp)))
1328 return -EFAULT;
1329
1330 if (tmp.irq != 0 || tmp.port != 0 || tmp.custom_divisor != 0 ||
1331 tmp.baud_base != 400000000)
1332 return -EPERM;
1333
1334 if (!capable(CAP_SYS_ADMIN)) {
1335 if (((tmp.flags & ~ASYNC_USR_MASK) !=
1336 (port->port.flags & ~ASYNC_USR_MASK)))
1337 return -EPERM;
1338 } else
1339 port->port.close_delay = tmp.close_delay * HZ / 100;
1340
1341 return 0;
1342}
1343
1344static int fwtty_ioctl(struct tty_struct *tty, unsigned cmd,
1345 unsigned long arg)
1346{
1347 struct fwtty_port *port = tty->driver_data;
1348 int err;
1349
1350 switch (cmd) {
1351 case TIOCGSERIAL:
1352 mutex_lock(&port->port.mutex);
1353 err = get_serial_info(port, (void __user *)arg);
1354 mutex_unlock(&port->port.mutex);
1355 break;
1356
1357 case TIOCSSERIAL:
1358 mutex_lock(&port->port.mutex);
1359 err = set_serial_info(port, (void __user *)arg);
1360 mutex_unlock(&port->port.mutex);
1361 break;
1362
1363 case TIOCMIWAIT:
1364 err = wait_msr_change(port, arg);
1365 break;
1366
1367 default:
1368 err = -ENOIOCTLCMD;
1369 }
1370
1371 return err;
1372}
1373
1374static void fwtty_set_termios(struct tty_struct *tty, struct ktermios *old)
1375{
1376 struct fwtty_port *port = tty->driver_data;
1377 unsigned baud;
1378
1379 spin_lock_bh(&port->lock);
1380 baud = set_termios(port, tty);
1381
1382 if ((baud == 0) && (old->c_cflag & CBAUD))
1383 port->mctrl &= ~(TIOCM_DTR | TIOCM_RTS);
1384 else if ((baud != 0) && !(old->c_cflag & CBAUD)) {
1385 if (C_CRTSCTS(tty) || !test_bit(TTY_THROTTLED, &tty->flags))
1386 port->mctrl |= TIOCM_DTR | TIOCM_RTS;
1387 else
1388 port->mctrl |= TIOCM_DTR;
1389 }
1390 __fwtty_write_port_status(port);
1391 spin_unlock_bh(&port->lock);
1392
1393 if (old->c_cflag & CRTSCTS) {
1394 if (!C_CRTSCTS(tty)) {
1395 tty->hw_stopped = 0;
1396 fwtty_restart_tx(port);
1397 }
1398 } else if (C_CRTSCTS(tty) && ~port->mstatus & TIOCM_CTS) {
1399 tty->hw_stopped = 1;
1400 }
1401}
1402
1403/**
1404 * fwtty_break_ctl - start/stop sending breaks
1405 *
1406 * Signals the remote to start or stop generating simulated breaks.
1407 * First, stop dequeueing from the fifo and wait for writer/drain to leave tx
1408 * before signalling the break line status. This guarantees any pending rx will
1409 * be queued to the line discipline before break is simulated on the remote.
1410 * Conversely, turning off break_ctl requires signalling the line status change,
1411 * then enabling tx.
1412 */
1413static int fwtty_break_ctl(struct tty_struct *tty, int state)
1414{
1415 struct fwtty_port *port = tty->driver_data;
1416 long ret;
1417
1418 fwtty_dbg(port, "%d", state);
1419
1420 if (state == -1) {
1421 set_bit(STOP_TX, &port->flags);
1422 ret = wait_event_interruptible_timeout(port->wait_tx,
1423 !test_bit(IN_TX, &port->flags),
1424 10);
1425 if (ret == 0 || ret == -ERESTARTSYS) {
1426 clear_bit(STOP_TX, &port->flags);
1427 fwtty_restart_tx(port);
1428 return -EINTR;
1429 }
1430 }
1431
1432 spin_lock_bh(&port->lock);
1433 port->break_ctl = (state == -1);
1434 __fwtty_write_port_status(port);
1435 spin_unlock_bh(&port->lock);
1436
1437 if (state == 0) {
1438 spin_lock_bh(&port->lock);
1439 dma_fifo_reset(&port->tx_fifo);
1440 clear_bit(STOP_TX, &port->flags);
1441 spin_unlock_bh(&port->lock);
1442 }
1443 return 0;
1444}
1445
1446static int fwtty_tiocmget(struct tty_struct *tty)
1447{
1448 struct fwtty_port *port = tty->driver_data;
1449 unsigned tiocm;
1450
1451 spin_lock_bh(&port->lock);
1452 tiocm = (port->mctrl & MCTRL_MASK) | (port->mstatus & ~MCTRL_MASK);
1453 spin_unlock_bh(&port->lock);
1454
1455 fwtty_dbg(port, "%x", tiocm);
1456
1457 return tiocm;
1458}
1459
1460static int fwtty_tiocmset(struct tty_struct *tty, unsigned set, unsigned clear)
1461{
1462 struct fwtty_port *port = tty->driver_data;
1463
1464 fwtty_dbg(port, "set: %x clear: %x", set, clear);
1465
1466 /* TODO: simulate loopback if TIOCM_LOOP set */
1467
1468 spin_lock_bh(&port->lock);
1469 port->mctrl &= ~(clear & MCTRL_MASK & 0xffff);
1470 port->mctrl |= set & MCTRL_MASK & 0xffff;
1471 __fwtty_write_port_status(port);
1472 spin_unlock_bh(&port->lock);
1473 return 0;
1474}
1475
1476static int fwtty_get_icount(struct tty_struct *tty,
1477 struct serial_icounter_struct *icount)
1478{
1479 struct fwtty_port *port = tty->driver_data;
1480 struct stats stats;
1481
1482 memcpy(&stats, &port->stats, sizeof(stats));
1483 if (port->port.console)
1484 (*port->fwcon_ops->stats)(&stats, port->con_data);
1485
1486 icount->cts = port->icount.cts;
1487 icount->dsr = port->icount.dsr;
1488 icount->rng = port->icount.rng;
1489 icount->dcd = port->icount.dcd;
1490 icount->rx = port->icount.rx;
1491 icount->tx = port->icount.tx + stats.xchars;
1492 icount->frame = port->icount.frame;
1493 icount->overrun = port->icount.overrun;
1494 icount->parity = port->icount.parity;
1495 icount->brk = port->icount.brk;
1496 icount->buf_overrun = port->icount.overrun;
1497 return 0;
1498}
1499
1500static void fwtty_proc_show_port(struct seq_file *m, struct fwtty_port *port)
1501{
1502 struct stats stats;
1503
1504 memcpy(&stats, &port->stats, sizeof(stats));
1505 if (port->port.console)
1506 (*port->fwcon_ops->stats)(&stats, port->con_data);
1507
e16d1ded
PH		 1508 seq_printf(m, " addr:%012llx tx:%d rx:%d", port->rx_handler.offset,
1509 port->icount.tx + stats.xchars, port->icount.rx);
7355ba34
PH		 1510 seq_printf(m, " cts:%d dsr:%d rng:%d dcd:%d", port->icount.cts,
1511 port->icount.dsr, port->icount.rng, port->icount.dcd);
1512 seq_printf(m, " fe:%d oe:%d pe:%d brk:%d", port->icount.frame,
1513 port->icount.overrun, port->icount.parity, port->icount.brk);
e16d1ded
PH		 1514}
1515
1516static void fwtty_debugfs_show_port(struct seq_file *m, struct fwtty_port *port)
1517{
1518 struct stats stats;
1519
1520 memcpy(&stats, &port->stats, sizeof(stats));
1521 if (port->port.console)
1522 (*port->fwcon_ops->stats)(&stats, port->con_data);
1523
7355ba34
PH		 1524 seq_printf(m, " dr:%d st:%d err:%d lost:%d", stats.dropped,
1525 stats.tx_stall, stats.fifo_errs, stats.lost);
1526 seq_printf(m, " pkts:%d thr:%d wtrmk:%d", stats.sent, stats.throttled,
1527 stats.watermark);
7355ba34
PH		 1528
1529 if (port->port.console) {
1530 seq_printf(m, "\n ");
1531 (*port->fwcon_ops->proc_show)(m, port->con_data);
1532 }
1533
1534 dump_profile(m, &port->stats);
1535}
1536
e16d1ded 1537static void fwtty_debugfs_show_peer(struct seq_file *m, struct fwtty_peer *peer)
7355ba34
PH		 1538{
1539 int generation = peer->generation;
1540
1541 smp_rmb();
1542 seq_printf(m, " %s:", dev_name(&peer->unit->device));
1543 seq_printf(m, " node:%04x gen:%d", peer->node_id, generation);
1544 seq_printf(m, " sp:%d max:%d guid:%016llx", peer->speed,
1545 peer->max_payload, (unsigned long long) peer->guid);
e16d1ded
PH		 1546 seq_printf(m, " mgmt:%012llx", (unsigned long long) peer->mgmt_addr);
1547 seq_printf(m, " addr:%012llx", (unsigned long long) peer->status_addr);
7355ba34
PH		 1548 seq_putc(m, '\n');
1549}
1550
1551static int fwtty_proc_show(struct seq_file *m, void *v)
1552{
1553 struct fwtty_port *port;
7355ba34
PH		 1554 int i;
1555
1556 seq_puts(m, "fwserinfo: 1.0 driver: 1.0\n");
1557 for (i = 0; i < MAX_TOTAL_PORTS && (port = fwtty_port_get(i)); ++i) {
1558 seq_printf(m, "%2d:", i);
1559 if (capable(CAP_SYS_ADMIN))
1560 fwtty_proc_show_port(m, port);
1561 fwtty_port_put(port);
1562 seq_printf(m, "\n");
1563 }
7355ba34
PH		 1564 return 0;
1565}
1566
4df5bb04
PH		 1567static int fwtty_debugfs_stats_show(struct seq_file *m, void *v)
1568{
1569 struct fw_serial *serial = m->private;
1570 struct fwtty_port *port;
1571 int i;
1572
1573 for (i = 0; i < num_ports; ++i) {
1574 port = fwtty_port_get(serial->ports[i]->index);
1575 if (port) {
1576 seq_printf(m, "%2d:", port->index);
1577 fwtty_proc_show_port(m, port);
1578 fwtty_debugfs_show_port(m, port);
1579 fwtty_port_put(port);
1580 seq_printf(m, "\n");
1581 }
1582 }
1583 return 0;
1584}
1585
1586static int fwtty_debugfs_peers_show(struct seq_file *m, void *v)
1587{
1588 struct fw_serial *serial = m->private;
1589 struct fwtty_peer *peer;
1590
1591 rcu_read_lock();
1592 seq_printf(m, "card: %s guid: %016llx\n",
1593 dev_name(serial->card->device),
1594 (unsigned long long) serial->card->guid);
1595 list_for_each_entry_rcu(peer, &serial->peer_list, list)
1596 fwtty_debugfs_show_peer(m, peer);
1597 rcu_read_unlock();
1598 return 0;
1599}
1600
7355ba34
PH		 1601static int fwtty_proc_open(struct inode *inode, struct file *fp)
1602{
1603 return single_open(fp, fwtty_proc_show, NULL);
1604}
1605
4df5bb04
PH		 1606static int fwtty_stats_open(struct inode *inode, struct file *fp)
1607{
1608 return single_open(fp, fwtty_debugfs_stats_show, inode->i_private);
1609}
1610
1611static int fwtty_peers_open(struct inode *inode, struct file *fp)
1612{
1613 return single_open(fp, fwtty_debugfs_peers_show, inode->i_private);
1614}
1615
1616static const struct file_operations fwtty_stats_fops = {
1617 .owner = THIS_MODULE,
1618 .open = fwtty_stats_open,
1619 .read = seq_read,
1620 .llseek = seq_lseek,
1621 .release = single_release,
1622};
1623
1624static const struct file_operations fwtty_peers_fops = {
1625 .owner = THIS_MODULE,
1626 .open = fwtty_peers_open,
1627 .read = seq_read,
1628 .llseek = seq_lseek,
1629 .release = single_release,
1630};
1631
7355ba34
PH		 1632static const struct file_operations fwtty_proc_fops = {
1633 .owner = THIS_MODULE,
1634 .open = fwtty_proc_open,
1635 .read = seq_read,
1636 .llseek = seq_lseek,
1637 .release = single_release,
1638};
1639
1640static const struct tty_port_operations fwtty_port_ops = {
1641 .dtr_rts = fwtty_port_dtr_rts,
1642 .carrier_raised = fwtty_port_carrier_raised,
1643 .shutdown = fwtty_port_shutdown,
1644 .activate = fwtty_port_activate,
1645};
1646
1647static const struct tty_operations fwtty_ops = {
1648 .open = fwtty_open,
1649 .close = fwtty_close,
1650 .hangup = fwtty_hangup,
1651 .cleanup = fwtty_cleanup,
1652 .install = fwtty_install,
1653 .write = fwtty_write,
1654 .write_room = fwtty_write_room,
1655 .chars_in_buffer = fwtty_chars_in_buffer,
1656 .send_xchar = fwtty_send_xchar,
1657 .throttle = fwtty_throttle,
1658 .unthrottle = fwtty_unthrottle,
1659 .ioctl = fwtty_ioctl,
1660 .set_termios = fwtty_set_termios,
1661 .break_ctl = fwtty_break_ctl,
1662 .tiocmget = fwtty_tiocmget,
1663 .tiocmset = fwtty_tiocmset,
1664 .get_icount = fwtty_get_icount,
1665 .proc_fops = &fwtty_proc_fops,
1666};
1667
fa1da242
PH		 1668static const struct tty_operations fwloop_ops = {
1669 .open = fwtty_open,
1670 .close = fwtty_close,
1671 .hangup = fwtty_hangup,
1672 .cleanup = fwtty_cleanup,
1673 .install = fwloop_install,
1674 .write = fwtty_write,
1675 .write_room = fwtty_write_room,
1676 .chars_in_buffer = fwtty_chars_in_buffer,
1677 .send_xchar = fwtty_send_xchar,
1678 .throttle = fwtty_throttle,
1679 .unthrottle = fwtty_unthrottle,
1680 .ioctl = fwtty_ioctl,
1681 .set_termios = fwtty_set_termios,
1682 .break_ctl = fwtty_break_ctl,
1683 .tiocmget = fwtty_tiocmget,
1684 .tiocmset = fwtty_tiocmset,
1685 .get_icount = fwtty_get_icount,
1686};
1687
7355ba34
PH		 1688static inline int mgmt_pkt_expected_len(__be16 code)
1689{
1690 static const struct fwserial_mgmt_pkt pkt;
1691
1692 switch (be16_to_cpu(code)) {
1693 case FWSC_VIRT_CABLE_PLUG:
1694 return sizeof(pkt.hdr) + sizeof(pkt.plug_req);
1695
1696 case FWSC_VIRT_CABLE_PLUG_RSP: /* | FWSC_RSP_OK */
1697 return sizeof(pkt.hdr) + sizeof(pkt.plug_rsp);
1698
1699
1700 case FWSC_VIRT_CABLE_UNPLUG:
1701 case FWSC_VIRT_CABLE_UNPLUG_RSP:
1702 case FWSC_VIRT_CABLE_PLUG_RSP | FWSC_RSP_NACK:
1703 case FWSC_VIRT_CABLE_UNPLUG_RSP | FWSC_RSP_NACK:
1704 return sizeof(pkt.hdr);
1705
1706 default:
1707 return -1;
1708 }
1709}
1710
1711static inline void fill_plug_params(struct virt_plug_params *params,
1712 struct fwtty_port *port)
1713{
1714 u64 status_addr = port->rx_handler.offset;
1715 u64 fifo_addr = port->rx_handler.offset + 4;
1716 size_t fifo_len = port->rx_handler.length - 4;
1717
1718 params->status_hi = cpu_to_be32(status_addr >> 32);
1719 params->status_lo = cpu_to_be32(status_addr);
1720 params->fifo_hi = cpu_to_be32(fifo_addr >> 32);
1721 params->fifo_lo = cpu_to_be32(fifo_addr);
1722 params->fifo_len = cpu_to_be32(fifo_len);
1723}
1724
1725static inline void fill_plug_req(struct fwserial_mgmt_pkt *pkt,
1726 struct fwtty_port *port)
1727{
1728 pkt->hdr.code = cpu_to_be16(FWSC_VIRT_CABLE_PLUG);
1729 pkt->hdr.len = cpu_to_be16(mgmt_pkt_expected_len(pkt->hdr.code));
1730 fill_plug_params(&pkt->plug_req, port);
1731}
1732
1733static inline void fill_plug_rsp_ok(struct fwserial_mgmt_pkt *pkt,
1734 struct fwtty_port *port)
1735{
1736 pkt->hdr.code = cpu_to_be16(FWSC_VIRT_CABLE_PLUG_RSP);
1737 pkt->hdr.len = cpu_to_be16(mgmt_pkt_expected_len(pkt->hdr.code));
1738 fill_plug_params(&pkt->plug_rsp, port);
1739}
1740
1741static inline void fill_plug_rsp_nack(struct fwserial_mgmt_pkt *pkt)
1742{
1743 pkt->hdr.code = cpu_to_be16(FWSC_VIRT_CABLE_PLUG_RSP | FWSC_RSP_NACK);
1744 pkt->hdr.len = cpu_to_be16(mgmt_pkt_expected_len(pkt->hdr.code));
1745}
1746
1747static inline void fill_unplug_req(struct fwserial_mgmt_pkt *pkt)
1748{
1749 pkt->hdr.code = cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG);
1750 pkt->hdr.len = cpu_to_be16(mgmt_pkt_expected_len(pkt->hdr.code));
1751}
1752
1753static inline void fill_unplug_rsp_nack(struct fwserial_mgmt_pkt *pkt)
1754{
1755 pkt->hdr.code = cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG_RSP | FWSC_RSP_NACK);
1756 pkt->hdr.len = cpu_to_be16(mgmt_pkt_expected_len(pkt->hdr.code));
1757}
1758
1759static inline void fill_unplug_rsp_ok(struct fwserial_mgmt_pkt *pkt)
1760{
1761 pkt->hdr.code = cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG_RSP);
1762 pkt->hdr.len = cpu_to_be16(mgmt_pkt_expected_len(pkt->hdr.code));
1763}
1764
1765static void fwserial_virt_plug_complete(struct fwtty_peer *peer,
1766 struct virt_plug_params *params)
1767{
1768 struct fwtty_port *port = peer->port;
1769
1770 peer->status_addr = be32_to_u64(params->status_hi, params->status_lo);
1771 peer->fifo_addr = be32_to_u64(params->fifo_hi, params->fifo_lo);
1772 peer->fifo_len = be32_to_cpu(params->fifo_len);
1773 peer_set_state(peer, FWPS_ATTACHED);
1774
1775 /* reconfigure tx_fifo optimally for this peer */
1776 spin_lock_bh(&port->lock);
3b1f3154 1777 port->max_payload = min(peer->max_payload, peer->fifo_len);
7355ba34
PH		 1778 dma_fifo_change_tx_limit(&port->tx_fifo, port->max_payload);
1779 spin_unlock_bh(&peer->port->lock);
1780
1781 if (port->port.console && port->fwcon_ops->notify != NULL)
1782 (*port->fwcon_ops->notify)(FWCON_NOTIFY_ATTACH, port->con_data);
1783
1784 fwtty_info(&peer->unit, "peer (guid:%016llx) connected on %s",
1785 (unsigned long long)peer->guid, dev_name(port->device));
1786}
1787
1788static inline int fwserial_send_mgmt_sync(struct fwtty_peer *peer,
1789 struct fwserial_mgmt_pkt *pkt)
1790{
1791 int generation;
1792 int rcode, tries = 5;
1793
1794 do {
1795 generation = peer->generation;
1796 smp_rmb();
1797
1798 rcode = fw_run_transaction(peer->serial->card,
1799 TCODE_WRITE_BLOCK_REQUEST,
1800 peer->node_id,
1801 generation, peer->speed,
1802 peer->mgmt_addr,
1803 pkt, be16_to_cpu(pkt->hdr.len));
1804 if (rcode == RCODE_BUSY || rcode == RCODE_SEND_ERROR ||
1805 rcode == RCODE_GENERATION) {
1806 fwtty_dbg(&peer->unit, "mgmt write error: %d", rcode);
1807 continue;
1808 } else
1809 break;
1810 } while (--tries > 0);
1811 return rcode;
1812}
1813
1814/**
1815 * fwserial_claim_port - attempt to claim port @ index for peer
1816 *
1817 * Returns ptr to claimed port or error code (as ERR_PTR())
1818 * Can sleep - must be called from process context
1819 */
1820static struct fwtty_port *fwserial_claim_port(struct fwtty_peer *peer,
1821 int index)
1822{
1823 struct fwtty_port *port;
1824
1825 if (index < 0 || index >= num_ports)
1826 return ERR_PTR(-EINVAL);
1827
1828 /* must guarantee that previous port releases have completed */
1829 synchronize_rcu();
1830
1831 port = peer->serial->ports[index];
1832 spin_lock_bh(&port->lock);
1833 if (!rcu_access_pointer(port->peer))
1834 rcu_assign_pointer(port->peer, peer);
1835 else
1836 port = ERR_PTR(-EBUSY);
1837 spin_unlock_bh(&port->lock);
1838
1839 return port;
1840}
1841
1842/**
1843 * fwserial_find_port - find avail port and claim for peer
1844 *
1845 * Returns ptr to claimed port or NULL if none avail
1846 * Can sleep - must be called from process context
1847 */
1848static struct fwtty_port *fwserial_find_port(struct fwtty_peer *peer)
1849{
1850 struct fwtty_port **ports = peer->serial->ports;
1851 int i;
1852
1853 /* must guarantee that previous port releases have completed */
1854 synchronize_rcu();
1855
1856 /* TODO: implement optional GUID-to-specific port # matching */
1857
1858 /* find an unattached port (but not the loopback port, if present) */
1859 for (i = 0; i < num_ttys; ++i) {
1860 spin_lock_bh(&ports[i]->lock);
1861 if (!ports[i]->peer) {
1862 /* claim port */
1863 rcu_assign_pointer(ports[i]->peer, peer);
1864 spin_unlock_bh(&ports[i]->lock);
1865 return ports[i];
1866 }
1867 spin_unlock_bh(&ports[i]->lock);
1868 }
1869 return NULL;
1870}
1871
de321a14 1872static void fwserial_release_port(struct fwtty_port *port, bool reset)
7355ba34
PH		 1873{
1874 /* drop carrier (and all other line status) */
de321a14
PH		 1875 if (reset)
1876 fwtty_update_port_status(port, 0);
7355ba34
PH		 1877
1878 spin_lock_bh(&port->lock);
1879
1880 /* reset dma fifo max transmission size back to S100 */
1881 port->max_payload = link_speed_to_max_payload(SCODE_100);
1882 dma_fifo_change_tx_limit(&port->tx_fifo, port->max_payload);
1883
1884 rcu_assign_pointer(port->peer, NULL);
1885 spin_unlock_bh(&port->lock);
1886
1887 if (port->port.console && port->fwcon_ops->notify != NULL)
1888 (*port->fwcon_ops->notify)(FWCON_NOTIFY_DETACH, port->con_data);
1889}
1890
1891static void fwserial_plug_timeout(unsigned long data)
1892{
1893 struct fwtty_peer *peer = (struct fwtty_peer *) data;
1894 struct fwtty_port *port;
1895
1896 spin_lock_bh(&peer->lock);
1897 if (peer->state != FWPS_PLUG_PENDING) {
1898 spin_unlock_bh(&peer->lock);
1899 return;
1900 }
1901
1902 port = peer_revert_state(peer);
1903 spin_unlock_bh(&peer->lock);
1904
1905 if (port)
de321a14 1906 fwserial_release_port(port, false);
7355ba34
PH		 1907}
1908
1909/**
1910 * fwserial_connect_peer - initiate virtual cable with peer
1911 *
1912 * Returns 0 if VIRT_CABLE_PLUG request was successfully sent,
1913 * otherwise error code. Must be called from process context.
1914 */
1915static int fwserial_connect_peer(struct fwtty_peer *peer)
1916{
1917 struct fwtty_port *port;
1918 struct fwserial_mgmt_pkt *pkt;
1919 int err, rcode;
1920
1921 pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
1922 if (!pkt)
1923 return -ENOMEM;
1924
1925 port = fwserial_find_port(peer);
1926 if (!port) {
1927 fwtty_err(&peer->unit, "avail ports in use");
1928 err = -EBUSY;
1929 goto free_pkt;
1930 }
1931
1932 spin_lock_bh(&peer->lock);
1933
1934 /* only initiate VIRT_CABLE_PLUG if peer is currently not attached */
1935 if (peer->state != FWPS_NOT_ATTACHED) {
1936 err = -EBUSY;
1937 goto release_port;
1938 }
1939
1940 peer->port = port;
1941 peer_set_state(peer, FWPS_PLUG_PENDING);
1942
1943 fill_plug_req(pkt, peer->port);
1944
1945 setup_timer(&peer->timer, fwserial_plug_timeout, (unsigned long)peer);
1946 mod_timer(&peer->timer, jiffies + VIRT_CABLE_PLUG_TIMEOUT);
1947 spin_unlock_bh(&peer->lock);
1948
1949 rcode = fwserial_send_mgmt_sync(peer, pkt);
1950
1951 spin_lock_bh(&peer->lock);
1952 if (peer->state == FWPS_PLUG_PENDING && rcode != RCODE_COMPLETE) {
1953 if (rcode == RCODE_CONFLICT_ERROR)
1954 err = -EAGAIN;
1955 else
1956 err = -EIO;
1957 goto cancel_timer;
1958 }
1959 spin_unlock_bh(&peer->lock);
1960
1961 kfree(pkt);
1962 return 0;
1963
1964cancel_timer:
1965 del_timer(&peer->timer);
1966 peer_revert_state(peer);
1967release_port:
1968 spin_unlock_bh(&peer->lock);
de321a14 1969 fwserial_release_port(port, false);
7355ba34
PH		 1970free_pkt:
1971 kfree(pkt);
1972 return err;
1973}
1974
1975/**
1976 * fwserial_close_port -
1977 * HUP the tty (if the tty exists) and unregister the tty device.
1978 * Only used by the unit driver upon unit removal to disconnect and
1979 * cleanup all attached ports
1980 *
1981 * The port reference is put by fwtty_cleanup (if a reference was
1982 * ever taken).
1983 */
fa1da242
PH		 1984static void fwserial_close_port(struct tty_driver *driver,
1985 struct fwtty_port *port)
7355ba34
PH		 1986{
1987 struct tty_struct *tty;
1988
1989 mutex_lock(&port->port.mutex);
1990 tty = tty_port_tty_get(&port->port);
1991 if (tty) {
1992 tty_vhangup(tty);
1993 tty_kref_put(tty);
1994 }
1995 mutex_unlock(&port->port.mutex);
1996
fa1da242
PH		 1997 if (driver == fwloop_driver)
1998 tty_unregister_device(driver, loop_idx(port));
1999 else
2000 tty_unregister_device(driver, port->index);
7355ba34
PH		 2001}
2002
2003/**
2004 * fwserial_lookup - finds first fw_serial associated with card
2005 * @card: fw_card to match
2006 *
2007 * NB: caller must be holding fwserial_list_mutex
2008 */
2009static struct fw_serial *fwserial_lookup(struct fw_card *card)
2010{
2011 struct fw_serial *serial;
2012
2013 list_for_each_entry(serial, &fwserial_list, list) {
2014 if (card == serial->card)
2015 return serial;
2016 }
2017
2018 return NULL;
2019}
2020
2021/**
2022 * __fwserial_lookup_rcu - finds first fw_serial associated with card
2023 * @card: fw_card to match
2024 *
2025 * NB: caller must be inside rcu_read_lock() section
2026 */
2027static struct fw_serial *__fwserial_lookup_rcu(struct fw_card *card)
2028{
2029 struct fw_serial *serial;
2030
2031 list_for_each_entry_rcu(serial, &fwserial_list, list) {
2032 if (card == serial->card)
2033 return serial;
2034 }
2035
2036 return NULL;
2037}
2038
2039/**
2040 * __fwserial_peer_by_node_id - finds a peer matching the given generation + id
2041 *
2042 * If a matching peer could not be found for the specified generation/node id,
2043 * this could be because:
2044 * a) the generation has changed and one of the nodes hasn't updated yet
2045 * b) the remote node has created its remote unit device before this
2046 * local node has created its corresponding remote unit device
2047 * In either case, the remote node should retry
2048 *
2049 * Note: caller must be in rcu_read_lock() section
2050 */
2051static struct fwtty_peer *__fwserial_peer_by_node_id(struct fw_card *card,
2052 int generation, int id)
2053{
2054 struct fw_serial *serial;
2055 struct fwtty_peer *peer;
2056
2057 serial = __fwserial_lookup_rcu(card);
2058 if (!serial) {
2059 /*
2060 * Something is very wrong - there should be a matching
2061 * fw_serial structure for every fw_card. Maybe the remote node
2062 * has created its remote unit device before this driver has
2063 * been probed for any unit devices...
2064 */
2065 fwtty_err(card, "unknown card (guid %016llx)",
2066 (unsigned long long) card->guid);
2067 return NULL;
2068 }
2069
2070 list_for_each_entry_rcu(peer, &serial->peer_list, list) {
2071 int g = peer->generation;
2072 smp_rmb();
2073 if (generation == g && id == peer->node_id)
2074 return peer;
2075 }
2076
2077 return NULL;
2078}
2079
2080#ifdef DEBUG
2081static void __dump_peer_list(struct fw_card *card)
2082{
2083 struct fw_serial *serial;
2084 struct fwtty_peer *peer;
2085
2086 serial = __fwserial_lookup_rcu(card);
2087 if (!serial)
2088 return;
2089
2090 list_for_each_entry_rcu(peer, &serial->peer_list, list) {
2091 int g = peer->generation;
2092 smp_rmb();
2093 fwtty_dbg(card, "peer(%d:%x) guid: %016llx\n", g,
2094 peer->node_id, (unsigned long long) peer->guid);
2095 }
2096}
2097#else
2098#define __dump_peer_list(s)
2099#endif
2100
2101static void fwserial_auto_connect(struct work_struct *work)
2102{
2103 struct fwtty_peer *peer = to_peer(to_delayed_work(work), connect);
2104 int err;
2105
2106 err = fwserial_connect_peer(peer);
2107 if (err == -EAGAIN && ++peer->connect_retries < MAX_CONNECT_RETRIES)
2108 schedule_delayed_work(&peer->connect, CONNECT_RETRY_DELAY);
2109}
2110
2111/**
2112 * fwserial_add_peer - add a newly probed 'serial' unit device as a 'peer'
2113 * @serial: aggregate representing the specific fw_card to add the peer to
2114 * @unit: 'peer' to create and add to peer_list of serial
2115 *
2116 * Adds a 'peer' (ie, a local or remote 'serial' unit device) to the list of
2117 * peers for a specific fw_card. Optionally, auto-attach this peer to an
2118 * available tty port. This function is called either directly or indirectly
2119 * as a result of a 'serial' unit device being created & probed.
2120 *
2121 * Note: this function is serialized with fwserial_remove_peer() by the
2122 * fwserial_list_mutex held in fwserial_probe().
2123 *
2124 * A 1:1 correspondence between an fw_unit and an fwtty_peer is maintained
2125 * via the dev_set_drvdata() for the device of the fw_unit.
2126 */
2127static int fwserial_add_peer(struct fw_serial *serial, struct fw_unit *unit)
2128{
2129 struct device *dev = &unit->device;
2130 struct fw_device *parent = fw_parent_device(unit);
2131 struct fwtty_peer *peer;
2132 struct fw_csr_iterator ci;
2133 int key, val;
2134 int generation;
2135
2136 peer = kzalloc(sizeof(*peer), GFP_KERNEL);
2137 if (!peer)
2138 return -ENOMEM;
2139
2140 peer_set_state(peer, FWPS_NOT_ATTACHED);
2141
2142 dev_set_drvdata(dev, peer);
2143 peer->unit = unit;
2144 peer->guid = (u64)parent->config_rom[3] << 32 | parent->config_rom[4];
2145 peer->speed = parent->max_speed;
2146 peer->max_payload = min(device_max_receive(parent),
2147 link_speed_to_max_payload(peer->speed));
2148
2149 generation = parent->generation;
2150 smp_rmb();
2151 peer->node_id = parent->node_id;
2152 smp_wmb();
2153 peer->generation = generation;
2154
2155 /* retrieve the mgmt bus addr from the unit directory */
2156 fw_csr_iterator_init(&ci, unit->directory);
2157 while (fw_csr_iterator_next(&ci, &key, &val)) {
2158 if (key == (CSR_OFFSET | CSR_DEPENDENT_INFO)) {
2159 peer->mgmt_addr = CSR_REGISTER_BASE + 4 * val;
2160 break;
2161 }
2162 }
2163 if (peer->mgmt_addr == 0ULL) {
2164 /*
2165 * No mgmt address effectively disables VIRT_CABLE_PLUG -
2166 * this peer will not be able to attach to a remote
2167 */
2168 peer_set_state(peer, FWPS_NO_MGMT_ADDR);
2169 }
2170
2171 spin_lock_init(&peer->lock);
2172 peer->port = NULL;
2173
2174 init_timer(&peer->timer);
2175 INIT_WORK(&peer->work, NULL);
2176 INIT_DELAYED_WORK(&peer->connect, fwserial_auto_connect);
2177
2178 /* associate peer with specific fw_card */
2179 peer->serial = serial;
2180 list_add_rcu(&peer->list, &serial->peer_list);
2181
2182 fwtty_info(&peer->unit, "peer added (guid:%016llx)",
2183 (unsigned long long)peer->guid);
2184
2185 /* identify the local unit & virt cable to loopback port */
2186 if (parent->is_local) {
2187 serial->self = peer;
2188 if (create_loop_dev) {
2189 struct fwtty_port *port;
2190 port = fwserial_claim_port(peer, num_ttys);
2191 if (!IS_ERR(port)) {
2192 struct virt_plug_params params;
2193
2194 spin_lock_bh(&peer->lock);
2195 peer->port = port;
2196 fill_plug_params(&params, port);
2197 fwserial_virt_plug_complete(peer, &params);
2198 spin_unlock_bh(&peer->lock);
2199
2200 fwtty_write_port_status(port);
2201 }
2202 }
2203
2204 } else if (auto_connect) {
2205 /* auto-attach to remote units only (if policy allows) */
2206 schedule_delayed_work(&peer->connect, 1);
2207 }
2208
2209 return 0;
2210}
2211
2212/**
2213 * fwserial_remove_peer - remove a 'serial' unit device as a 'peer'
2214 *
2215 * Remove a 'peer' from its list of peers. This function is only
2216 * called by fwserial_remove() on bus removal of the unit device.
2217 *
2218 * Note: this function is serialized with fwserial_add_peer() by the
2219 * fwserial_list_mutex held in fwserial_remove().
2220 */
2221static void fwserial_remove_peer(struct fwtty_peer *peer)
2222{
2223 struct fwtty_port *port;
2224
2225 spin_lock_bh(&peer->lock);
2226 peer_set_state(peer, FWPS_GONE);
2227 spin_unlock_bh(&peer->lock);
2228
2229 cancel_delayed_work_sync(&peer->connect);
2230 cancel_work_sync(&peer->work);
2231
2232 spin_lock_bh(&peer->lock);
2233 /* if this unit is the local unit, clear link */
2234 if (peer == peer->serial->self)
2235 peer->serial->self = NULL;
2236
2237 /* cancel the request timeout timer (if running) */
2238 del_timer(&peer->timer);
2239
2240 port = peer->port;
2241 peer->port = NULL;
2242
2243 list_del_rcu(&peer->list);
2244
2245 fwtty_info(&peer->unit, "peer removed (guid:%016llx)",
2246 (unsigned long long)peer->guid);
2247
2248 spin_unlock_bh(&peer->lock);
2249
2250 if (port)
de321a14 2251 fwserial_release_port(port, true);
7355ba34
PH		 2252
2253 synchronize_rcu();
2254 kfree(peer);
2255}
2256
7355ba34
PH		 2257/**
2258 * fwserial_create - init everything to create TTYs for a specific fw_card
2259 * @unit: fw_unit for first 'serial' unit device probed for this fw_card
2260 *
2261 * This function inits the aggregate structure (an fw_serial instance)
2262 * used to manage the TTY ports registered by a specific fw_card. Also, the
2263 * unit device is added as the first 'peer'.
2264 *
2265 * This unit device may represent a local unit device (as specified by the
2266 * config ROM unit directory) or it may represent a remote unit device
2267 * (as specified by the reading of the remote node's config ROM).
2268 *
2269 * Returns 0 to indicate "ownership" of the unit device, or a negative errno
2270 * value to indicate which error.
2271 */
2272static int fwserial_create(struct fw_unit *unit)
2273{
2274 struct fw_device *parent = fw_parent_device(unit);
2275 struct fw_card *card = parent->card;
2276 struct fw_serial *serial;
2277 struct fwtty_port *port;
2278 struct device *tty_dev;
2279 int i, j;
2280 int err;
2281
2282 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
2283 if (!serial)
2284 return -ENOMEM;
2285
2286 kref_init(&serial->kref);
2287 serial->card = card;
2288 INIT_LIST_HEAD(&serial->peer_list);
2289
2290 for (i = 0; i < num_ports; ++i) {
2291 port = kzalloc(sizeof(*port), GFP_KERNEL);
2292 if (!port) {
2293 err = -ENOMEM;
2294 goto free_ports;
2295 }
2296 tty_port_init(&port->port);
2297 port->index = FWTTY_INVALID_INDEX;
2298 port->port.ops = &fwtty_port_ops;
2299 port->serial = serial;
2300
2301 spin_lock_init(&port->lock);
2302 INIT_DELAYED_WORK(&port->drain, fwtty_drain_tx);
2303 INIT_DELAYED_WORK(&port->emit_breaks, fwtty_emit_breaks);
2304 INIT_WORK(&port->hangup, fwtty_do_hangup);
2305 INIT_WORK(&port->push, fwtty_pushrx);
2306 INIT_LIST_HEAD(&port->buf_list);
2307 init_waitqueue_head(&port->wait_tx);
2308 port->max_payload = link_speed_to_max_payload(SCODE_100);
2309 dma_fifo_init(&port->tx_fifo);
2310
2311 rcu_assign_pointer(port->peer, NULL);
2312 serial->ports[i] = port;
2313
2314 /* get unique bus addr region for port's status & recv fifo */
2315 port->rx_handler.length = FWTTY_PORT_RXFIFO_LEN + 4;
2316 port->rx_handler.address_callback = fwtty_port_handler;
2317 port->rx_handler.callback_data = port;
2318 /*
2319 * XXX: use custom memory region above cpu physical memory addrs
2320 * this will ease porting to 64-bit firewire adapters
2321 */
2322 err = fw_core_add_address_handler(&port->rx_handler,
2323 &fw_high_memory_region);
2324 if (err) {
2325 kfree(port);
2326 goto free_ports;
2327 }
2328 }
2329 /* preserve i for error cleanup */
2330
2331 err = fwtty_ports_add(serial);
2332 if (err) {
2333 fwtty_err(&unit, "no space in port table");
2334 goto free_ports;
2335 }
2336
2337 for (j = 0; j < num_ttys; ++j) {
2338 tty_dev = tty_port_register_device(&serial->ports[j]->port,
2339 fwtty_driver,
2340 serial->ports[j]->index,
2341 card->device);
2342 if (IS_ERR(tty_dev)) {
2343 err = PTR_ERR(tty_dev);
2344 fwtty_err(&unit, "register tty device error (%d)", err);
2345 goto unregister_ttys;
2346 }
2347
2348 serial->ports[j]->device = tty_dev;
2349 }
2350 /* preserve j for error cleanup */
2351
2352 if (create_loop_dev) {
2353 struct device *loop_dev;
2354
fa1da242
PH		 2355 loop_dev = tty_port_register_device(&serial->ports[j]->port,
2356 fwloop_driver,
2357 loop_idx(serial->ports[j]),
2358 card->device);
7355ba34
PH		 2359 if (IS_ERR(loop_dev)) {
2360 err = PTR_ERR(loop_dev);
2361 fwtty_err(&unit, "create loop device failed (%d)", err);
2362 goto unregister_ttys;
2363 }
fa1da242
PH		 2364 serial->ports[j]->device = loop_dev;
2365 serial->ports[j]->loopback = true;
7355ba34
PH		 2366 }
2367
4df5bb04
PH		 2368 if (!IS_ERR_OR_NULL(fwserial_debugfs)) {
2369 serial->debugfs = debugfs_create_dir(dev_name(&unit->device),
2370 fwserial_debugfs);
2371 if (!IS_ERR_OR_NULL(serial->debugfs)) {
2372 debugfs_create_file("peers", 0444, serial->debugfs,
2373 serial, &fwtty_peers_fops);
2374 debugfs_create_file("stats", 0444, serial->debugfs,
2375 serial, &fwtty_stats_fops);
2376 }
2377 }
2378
7355ba34
PH		 2379 list_add_rcu(&serial->list, &fwserial_list);
2380
2381 fwtty_notice(&unit, "TTY over FireWire on device %s (guid %016llx)",
2382 dev_name(card->device), (unsigned long long) card->guid);
2383
2384 err = fwserial_add_peer(serial, unit);
2385 if (!err)
2386 return 0;
2387
2388 fwtty_err(&unit, "unable to add peer unit device (%d)", err);
2389
2390 /* fall-through to error processing */
4df5bb04
PH		 2391 debugfs_remove_recursive(serial->debugfs);
2392
7355ba34 2393 list_del_rcu(&serial->list);
fa1da242
PH		 2394 if (create_loop_dev)
2395 tty_unregister_device(fwloop_driver, loop_idx(serial->ports[j]));
7355ba34
PH		 2396unregister_ttys:
2397 for (--j; j >= 0; --j)
2398 tty_unregister_device(fwtty_driver, serial->ports[j]->index);
2399 kref_put(&serial->kref, fwserial_destroy);
2400 return err;
2401
2402free_ports:
a3218464
PH		 2403 for (--i; i >= 0; --i) {
2404 tty_port_destroy(&serial->ports[i]->port);
7355ba34 2405 kfree(serial->ports[i]);
a3218464 2406 }
7355ba34
PH		 2407 kfree(serial);
2408 return err;
2409}
2410
2411/**
2412 * fwserial_probe: bus probe function for firewire 'serial' unit devices
2413 *
2414 * A 'serial' unit device is created and probed as a result of:
2415 * - declaring a ieee1394 bus id table for 'devices' matching a fabricated
2416 * 'serial' unit specifier id
2417 * - adding a unit directory to the config ROM(s) for a 'serial' unit
2418 *
2419 * The firewire core registers unit devices by enumerating unit directories
2420 * of a node's config ROM after reading the config ROM when a new node is
2421 * added to the bus topology after a bus reset.
2422 *
2423 * The practical implications of this are:
2424 * - this probe is called for both local and remote nodes that have a 'serial'
2425 * unit directory in their config ROM (that matches the specifiers in
2426 * fwserial_id_table).
2427 * - no specific order is enforced for local vs. remote unit devices
2428 *
2429 * This unit driver copes with the lack of specific order in the same way the
2430 * firewire net driver does -- each probe, for either a local or remote unit
2431 * device, is treated as a 'peer' (has a struct fwtty_peer instance) and the
2432 * first peer created for a given fw_card (tracked by the global fwserial_list)
2433 * creates the underlying TTYs (aggregated in a fw_serial instance).
2434 *
2435 * NB: an early attempt to differentiate local & remote unit devices by creating
2436 * peers only for remote units and fw_serial instances (with their
2437 * associated TTY devices) only for local units was discarded. Managing
2438 * the peer lifetimes on device removal proved too complicated.
2439 *
2440 * fwserial_probe/fwserial_remove are effectively serialized by the
2441 * fwserial_list_mutex. This is necessary because the addition of the first peer
2442 * for a given fw_card will trigger the creation of the fw_serial for that
2443 * fw_card, which must not simultaneously contend with the removal of the
2444 * last peer for a given fw_card triggering the destruction of the same
2445 * fw_serial for the same fw_card.
2446 */
2447static int fwserial_probe(struct device *dev)
2448{
2449 struct fw_unit *unit = fw_unit(dev);
2450 struct fw_serial *serial;
2451 int err;
2452
2453 mutex_lock(&fwserial_list_mutex);
2454 serial = fwserial_lookup(fw_parent_device(unit)->card);
2455 if (!serial)
2456 err = fwserial_create(unit);
2457 else
2458 err = fwserial_add_peer(serial, unit);
2459 mutex_unlock(&fwserial_list_mutex);
2460 return err;
2461}
2462
2463/**
2464 * fwserial_remove: bus removal function for firewire 'serial' unit devices
2465 *
2466 * The corresponding 'peer' for this unit device is removed from the list of
2467 * peers for the associated fw_serial (which has a 1:1 correspondence with a
2468 * specific fw_card). If this is the last peer being removed, then trigger
2469 * the destruction of the underlying TTYs.
2470 */
2471static int fwserial_remove(struct device *dev)
2472{
2473 struct fwtty_peer *peer = dev_get_drvdata(dev);
2474 struct fw_serial *serial = peer->serial;
2475 int i;
2476
2477 mutex_lock(&fwserial_list_mutex);
2478 fwserial_remove_peer(peer);
2479
2480 if (list_empty(&serial->peer_list)) {
2481 /* unlink from the fwserial_list here */
2482 list_del_rcu(&serial->list);
2483
4df5bb04
PH		 2484 debugfs_remove_recursive(serial->debugfs);
2485
fa1da242
PH		 2486 for (i = 0; i < num_ttys; ++i)
2487 fwserial_close_port(fwtty_driver, serial->ports[i]);
2488 if (create_loop_dev)
2489 fwserial_close_port(fwloop_driver, serial->ports[i]);
7355ba34
PH		 2490 kref_put(&serial->kref, fwserial_destroy);
2491 }
2492 mutex_unlock(&fwserial_list_mutex);
2493
2494 return 0;
2495}
2496
2497/**
2498 * fwserial_update: bus update function for 'firewire' serial unit devices
2499 *
2500 * Updates the new node_id and bus generation for this peer. Note that locking
2501 * is unnecessary; but careful memory barrier usage is important to enforce the
2502 * load and store order of generation & node_id.
2503 *
2504 * The fw-core orders the write of node_id before generation in the parent
2505 * fw_device to ensure that a stale node_id cannot be used with a current
2506 * bus generation. So the generation value must be read before the node_id.
2507 *
2508 * In turn, this orders the write of node_id before generation in the peer to
2509 * also ensure a stale node_id cannot be used with a current bus generation.
2510 */
2511static void fwserial_update(struct fw_unit *unit)
2512{
2513 struct fw_device *parent = fw_parent_device(unit);
2514 struct fwtty_peer *peer = dev_get_drvdata(&unit->device);
2515 int generation;
2516
2517 generation = parent->generation;
2518 smp_rmb();
2519 peer->node_id = parent->node_id;
2520 smp_wmb();
2521 peer->generation = generation;
2522}
2523
2524static const struct ieee1394_device_id fwserial_id_table[] = {
2525 {
2526 .match_flags = IEEE1394_MATCH_SPECIFIER_ID |
2527 IEEE1394_MATCH_VERSION,
2528 .specifier_id = LINUX_VENDOR_ID,
2529 .version = FWSERIAL_VERSION,
2530 },
2531 { }
2532};
2533
2534static struct fw_driver fwserial_driver = {
2535 .driver = {
2536 .owner = THIS_MODULE,
2537 .name = KBUILD_MODNAME,
2538 .bus = &fw_bus_type,
2539 .probe = fwserial_probe,
2540 .remove = fwserial_remove,
2541 },
2542 .update = fwserial_update,
2543 .id_table = fwserial_id_table,
2544};
2545
2546#define FW_UNIT_SPECIFIER(id) ((CSR_SPECIFIER_ID << 24) | (id))
2547#define FW_UNIT_VERSION(ver) ((CSR_VERSION << 24) | (ver))
2548#define FW_UNIT_ADDRESS(ofs) (((CSR_OFFSET | CSR_DEPENDENT_INFO) << 24) \
2549 | (((ofs) - CSR_REGISTER_BASE) >> 2))
2550/* XXX: config ROM definitons could be improved with semi-automated offset
2551 * and length calculation
2552 */
612588a8 2553#define FW_ROM_LEN(quads) ((quads) << 16)
7355ba34
PH		 2554#define FW_ROM_DESCRIPTOR(ofs) (((CSR_LEAF | CSR_DESCRIPTOR) << 24) | (ofs))
2555
2556struct fwserial_unit_directory_data {
612588a8 2557 u32 len_crc;
7355ba34
PH		 2558 u32 unit_specifier;
2559 u32 unit_sw_version;
2560 u32 unit_addr_offset;
2561 u32 desc1_ofs;
612588a8 2562 u32 desc1_len_crc;
7355ba34
PH		 2563 u32 desc1_data[5];
2564} __packed;
2565
2566static struct fwserial_unit_directory_data fwserial_unit_directory_data = {
612588a8 2567 .len_crc = FW_ROM_LEN(4),
7355ba34
PH		 2568 .unit_specifier = FW_UNIT_SPECIFIER(LINUX_VENDOR_ID),
2569 .unit_sw_version = FW_UNIT_VERSION(FWSERIAL_VERSION),
2570 .desc1_ofs = FW_ROM_DESCRIPTOR(1),
612588a8 2571 .desc1_len_crc = FW_ROM_LEN(5),
7355ba34
PH		 2572 .desc1_data = {
2573 0x00000000, /* type = text */
2574 0x00000000, /* enc = ASCII, lang EN */
2575 0x4c696e75, /* 'Linux TTY' */
2576 0x78205454,
2577 0x59000000,
2578 },
2579};
2580
2581static struct fw_descriptor fwserial_unit_directory = {
2582 .length = sizeof(fwserial_unit_directory_data) / sizeof(u32),
2583 .key = (CSR_DIRECTORY | CSR_UNIT) << 24,
2584 .data = (u32 *)&fwserial_unit_directory_data,
2585};
2586
2587/*
2588 * The management address is in the unit space region but above other known
2589 * address users (to keep wild writes from causing havoc)
2590 */
a3d9ad47 2591static const struct fw_address_region fwserial_mgmt_addr_region = {
7355ba34
PH		 2592 .start = CSR_REGISTER_BASE + 0x1e0000ULL,
2593 .end = 0x1000000000000ULL,
2594};
2595
2596static struct fw_address_handler fwserial_mgmt_addr_handler;
2597
2598/**
2599 * fwserial_handle_plug_req - handle VIRT_CABLE_PLUG request work
2600 * @work: ptr to peer->work
2601 *
2602 * Attempts to complete the VIRT_CABLE_PLUG handshake sequence for this peer.
2603 *
2604 * This checks for a collided request-- ie, that a VIRT_CABLE_PLUG request was
2605 * already sent to this peer. If so, the collision is resolved by comparing
2606 * guid values; the loser sends the plug response.
2607 *
2608 * Note: if an error prevents a response, don't do anything -- the
2609 * remote will timeout its request.
2610 */
2611static void fwserial_handle_plug_req(struct work_struct *work)
2612{
2613 struct fwtty_peer *peer = to_peer(work, work);
2614 struct virt_plug_params *plug_req = &peer->work_params.plug_req;
2615 struct fwtty_port *port;
2616 struct fwserial_mgmt_pkt *pkt;
2617 int rcode;
2618
2619 pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
2620 if (!pkt)
2621 return;
2622
2623 port = fwserial_find_port(peer);
2624
2625 spin_lock_bh(&peer->lock);
2626
2627 switch (peer->state) {
2628 case FWPS_NOT_ATTACHED:
2629 if (!port) {
2630 fwtty_err(&peer->unit, "no more ports avail");
2631 fill_plug_rsp_nack(pkt);
2632 } else {
2633 peer->port = port;
2634 fill_plug_rsp_ok(pkt, peer->port);
2635 peer_set_state(peer, FWPS_PLUG_RESPONDING);
2636 /* don't release claimed port */
2637 port = NULL;
2638 }
2639 break;
2640
2641 case FWPS_PLUG_PENDING:
2642 if (peer->serial->card->guid > peer->guid)
2643 goto cleanup;
2644
2645 /* We lost - hijack the already-claimed port and send ok */
2646 del_timer(&peer->timer);
2647 fill_plug_rsp_ok(pkt, peer->port);
2648 peer_set_state(peer, FWPS_PLUG_RESPONDING);
2649 break;
2650
2651 default:
2652 fill_plug_rsp_nack(pkt);
2653 }
2654
2655 spin_unlock_bh(&peer->lock);
2656 if (port)
de321a14 2657 fwserial_release_port(port, false);
7355ba34
PH		 2658
2659 rcode = fwserial_send_mgmt_sync(peer, pkt);
2660
2661 spin_lock_bh(&peer->lock);
2662 if (peer->state == FWPS_PLUG_RESPONDING) {
2663 if (rcode == RCODE_COMPLETE) {
2664 struct fwtty_port *tmp = peer->port;
2665
2666 fwserial_virt_plug_complete(peer, plug_req);
2667 spin_unlock_bh(&peer->lock);
2668
2669 fwtty_write_port_status(tmp);
2670 spin_lock_bh(&peer->lock);
2671 } else {
2672 fwtty_err(&peer->unit, "PLUG_RSP error (%d)", rcode);
2673 port = peer_revert_state(peer);
2674 }
2675 }
2676cleanup:
2677 spin_unlock_bh(&peer->lock);
2678 if (port)
de321a14 2679 fwserial_release_port(port, false);
7355ba34
PH		 2680 kfree(pkt);
2681 return;
2682}
2683
2684static void fwserial_handle_unplug_req(struct work_struct *work)
2685{
2686 struct fwtty_peer *peer = to_peer(work, work);
2687 struct fwtty_port *port = NULL;
2688 struct fwserial_mgmt_pkt *pkt;
2689 int rcode;
2690
2691 pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
2692 if (!pkt)
2693 return;
2694
2695 spin_lock_bh(&peer->lock);
2696
2697 switch (peer->state) {
2698 case FWPS_ATTACHED:
2699 fill_unplug_rsp_ok(pkt);
2700 peer_set_state(peer, FWPS_UNPLUG_RESPONDING);
2701 break;
2702
2703 case FWPS_UNPLUG_PENDING:
2704 if (peer->serial->card->guid > peer->guid)
2705 goto cleanup;
2706
2707 /* We lost - send unplug rsp */
2708 del_timer(&peer->timer);
2709 fill_unplug_rsp_ok(pkt);
2710 peer_set_state(peer, FWPS_UNPLUG_RESPONDING);
2711 break;
2712
2713 default:
2714 fill_unplug_rsp_nack(pkt);
2715 }
2716
2717 spin_unlock_bh(&peer->lock);
2718
2719 rcode = fwserial_send_mgmt_sync(peer, pkt);
2720
2721 spin_lock_bh(&peer->lock);
2722 if (peer->state == FWPS_UNPLUG_RESPONDING) {
c88d40b2 2723 if (rcode != RCODE_COMPLETE)
7355ba34 2724 fwtty_err(&peer->unit, "UNPLUG_RSP error (%d)", rcode);
c88d40b2 2725 port = peer_revert_state(peer);
7355ba34
PH		 2726 }
2727cleanup:
2728 spin_unlock_bh(&peer->lock);
2729 if (port)
de321a14 2730 fwserial_release_port(port, true);
7355ba34
PH		 2731 kfree(pkt);
2732 return;
2733}
2734
2735static int fwserial_parse_mgmt_write(struct fwtty_peer *peer,
2736 struct fwserial_mgmt_pkt *pkt,
2737 unsigned long long addr,
2738 size_t len)
2739{
2740 struct fwtty_port *port = NULL;
de321a14 2741 bool reset = false;
7355ba34
PH		 2742 int rcode;
2743
2744 if (addr != fwserial_mgmt_addr_handler.offset || len < sizeof(pkt->hdr))
2745 return RCODE_ADDRESS_ERROR;
2746
2747 if (len != be16_to_cpu(pkt->hdr.len) ||
2748 len != mgmt_pkt_expected_len(pkt->hdr.code))
2749 return RCODE_DATA_ERROR;
2750
2751 spin_lock_bh(&peer->lock);
2752 if (peer->state == FWPS_GONE) {
2753 /*
2754 * This should never happen - it would mean that the
2755 * remote unit that just wrote this transaction was
2756 * already removed from the bus -- and the removal was
2757 * processed before we rec'd this transaction
2758 */
2759 fwtty_err(&peer->unit, "peer already removed");
2760 spin_unlock_bh(&peer->lock);
2761 return RCODE_ADDRESS_ERROR;
2762 }
2763
2764 rcode = RCODE_COMPLETE;
2765
2766 fwtty_dbg(&peer->unit, "mgmt: hdr.code: %04hx", pkt->hdr.code);
2767
2768 switch (be16_to_cpu(pkt->hdr.code) & FWSC_CODE_MASK) {
2769 case FWSC_VIRT_CABLE_PLUG:
2770 if (work_pending(&peer->work)) {
2771 fwtty_err(&peer->unit, "plug req: busy");
2772 rcode = RCODE_CONFLICT_ERROR;
2773
2774 } else {
2775 peer->work_params.plug_req = pkt->plug_req;
2776 PREPARE_WORK(&peer->work, fwserial_handle_plug_req);
2777 queue_work(system_unbound_wq, &peer->work);
2778 }
2779 break;
2780
2781 case FWSC_VIRT_CABLE_PLUG_RSP:
2782 if (peer->state != FWPS_PLUG_PENDING) {
2783 rcode = RCODE_CONFLICT_ERROR;
2784
2785 } else if (be16_to_cpu(pkt->hdr.code) & FWSC_RSP_NACK) {
2786 fwtty_notice(&peer->unit, "NACK plug rsp");
2787 port = peer_revert_state(peer);
2788
2789 } else {
2790 struct fwtty_port *tmp = peer->port;
2791
2792 fwserial_virt_plug_complete(peer, &pkt->plug_rsp);
2793 spin_unlock_bh(&peer->lock);
2794
2795 fwtty_write_port_status(tmp);
2796 spin_lock_bh(&peer->lock);
2797 }
2798 break;
2799
2800 case FWSC_VIRT_CABLE_UNPLUG:
2801 if (work_pending(&peer->work)) {
2802 fwtty_err(&peer->unit, "unplug req: busy");
2803 rcode = RCODE_CONFLICT_ERROR;
2804 } else {
2805 PREPARE_WORK(&peer->work, fwserial_handle_unplug_req);
2806 queue_work(system_unbound_wq, &peer->work);
2807 }
2808 break;
2809
2810 case FWSC_VIRT_CABLE_UNPLUG_RSP:
2811 if (peer->state != FWPS_UNPLUG_PENDING)
2812 rcode = RCODE_CONFLICT_ERROR;
2813 else {
2814 if (be16_to_cpu(pkt->hdr.code) & FWSC_RSP_NACK)
2815 fwtty_notice(&peer->unit, "NACK unplug?");
2816 port = peer_revert_state(peer);
de321a14 2817 reset = true;
7355ba34
PH		 2818 }
2819 break;
2820
2821 default:
2822 fwtty_err(&peer->unit, "unknown mgmt code %d",
2823 be16_to_cpu(pkt->hdr.code));
2824 rcode = RCODE_DATA_ERROR;
2825 }
2826 spin_unlock_bh(&peer->lock);
2827
2828 if (port)
de321a14 2829 fwserial_release_port(port, reset);
7355ba34
PH		 2830
2831 return rcode;
2832}
2833
2834/**
2835 * fwserial_mgmt_handler: bus address handler for mgmt requests
2836 * @parameters: fw_address_callback_t as specified by firewire core interface
2837 *
2838 * This handler is responsible for handling virtual cable requests from remotes
2839 * for all cards.
2840 */
2841static void fwserial_mgmt_handler(struct fw_card *card,
2842 struct fw_request *request,
2843 int tcode, int destination, int source,
2844 int generation,
2845 unsigned long long addr,
2846 void *data, size_t len,
2847 void *callback_data)
2848{
2849 struct fwserial_mgmt_pkt *pkt = data;
2850 struct fwtty_peer *peer;
2851 int rcode;
2852
2853 rcu_read_lock();
2854 peer = __fwserial_peer_by_node_id(card, generation, source);
2855 if (!peer) {
2856 fwtty_dbg(card, "peer(%d:%x) not found", generation, source);
2857 __dump_peer_list(card);
2858 rcode = RCODE_CONFLICT_ERROR;
2859
2860 } else {
2861 switch (tcode) {
2862 case TCODE_WRITE_BLOCK_REQUEST:
2863 rcode = fwserial_parse_mgmt_write(peer, pkt, addr, len);
2864 break;
2865
2866 default:
2867 rcode = RCODE_TYPE_ERROR;
2868 }
2869 }
2870
2871 rcu_read_unlock();
2872 fw_send_response(card, request, rcode);
2873}
2874
2875static int __init fwserial_init(void)
2876{
2877 int err, num_loops = !!(create_loop_dev);
2878
4df5bb04
PH		 2879 /* XXX: placeholder for a "firewire" debugfs node */
2880 fwserial_debugfs = debugfs_create_dir(KBUILD_MODNAME, NULL);
2881
7355ba34
PH		 2882 /* num_ttys/num_ports must not be set above the static alloc avail */
2883 if (num_ttys + num_loops > MAX_CARD_PORTS)
2884 num_ttys = MAX_CARD_PORTS - num_loops;
2885 num_ports = num_ttys + num_loops;
2886
84472c3b
PH		 2887 fwtty_driver = tty_alloc_driver(MAX_TOTAL_PORTS, TTY_DRIVER_REAL_RAW
2888 | TTY_DRIVER_DYNAMIC_DEV);
2889 if (IS_ERR(fwtty_driver)) {
2890 err = PTR_ERR(fwtty_driver);
7355ba34
PH		 2891 return err;
2892 }
2893
2894 fwtty_driver->driver_name = KBUILD_MODNAME;
2895 fwtty_driver->name = tty_dev_name;
2896 fwtty_driver->major = 0;
2897 fwtty_driver->minor_start = 0;
2898 fwtty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2899 fwtty_driver->subtype = SERIAL_TYPE_NORMAL;
7355ba34
PH		 2900 fwtty_driver->init_termios = tty_std_termios;
2901 fwtty_driver->init_termios.c_cflag |= CLOCAL;
2902 tty_set_operations(fwtty_driver, &fwtty_ops);
2903
2904 err = tty_register_driver(fwtty_driver);
2905 if (err) {
2906 driver_err("register tty driver failed (%d)", err);
2907 goto put_tty;
2908 }
2909
fa1da242 2910 if (create_loop_dev) {
84472c3b
PH		 2911 fwloop_driver = tty_alloc_driver(MAX_TOTAL_PORTS / num_ports,
2912 TTY_DRIVER_REAL_RAW
2913 | TTY_DRIVER_DYNAMIC_DEV);
2914 if (IS_ERR(fwloop_driver)) {
2915 err = PTR_ERR(fwloop_driver);
fa1da242
PH		 2916 goto unregister_driver;
2917 }
2918
2919 fwloop_driver->driver_name = KBUILD_MODNAME "_loop";
2920 fwloop_driver->name = loop_dev_name;
2921 fwloop_driver->major = 0;
2922 fwloop_driver->minor_start = 0;
2923 fwloop_driver->type = TTY_DRIVER_TYPE_SERIAL;
2924 fwloop_driver->subtype = SERIAL_TYPE_NORMAL;
fa1da242
PH		 2925 fwloop_driver->init_termios = tty_std_termios;
2926 fwloop_driver->init_termios.c_cflag |= CLOCAL;
2927 tty_set_operations(fwloop_driver, &fwloop_ops);
2928
2929 err = tty_register_driver(fwloop_driver);
2930 if (err) {
2931 driver_err("register loop driver failed (%d)", err);
2932 goto put_loop;
2933 }
2934 }
2935
7355ba34
PH		 2936 fwtty_txn_cache = kmem_cache_create("fwtty_txn_cache",
2937 sizeof(struct fwtty_transaction),
2938 0, 0, fwtty_txn_constructor);
2939 if (!fwtty_txn_cache) {
2940 err = -ENOMEM;
fa1da242 2941 goto unregister_loop;
7355ba34
PH		 2942 }
2943
2944 /*
2945 * Ideally, this address handler would be registered per local node
2946 * (rather than the same handler for all local nodes). However,
2947 * since the firewire core requires the config rom descriptor *before*
2948 * the local unit device(s) are created, a single management handler
2949 * must suffice for all local serial units.
2950 */
2951 fwserial_mgmt_addr_handler.length = sizeof(struct fwserial_mgmt_pkt);
2952 fwserial_mgmt_addr_handler.address_callback = fwserial_mgmt_handler;
2953
2954 err = fw_core_add_address_handler(&fwserial_mgmt_addr_handler,
2955 &fwserial_mgmt_addr_region);
2956 if (err) {
2957 driver_err("add management handler failed (%d)", err);
2958 goto destroy_cache;
2959 }
2960
2961 fwserial_unit_directory_data.unit_addr_offset =
2962 FW_UNIT_ADDRESS(fwserial_mgmt_addr_handler.offset);
2963 err = fw_core_add_descriptor(&fwserial_unit_directory);
2964 if (err) {
2965 driver_err("add unit descriptor failed (%d)", err);
2966 goto remove_handler;
2967 }
2968
2969 err = driver_register(&fwserial_driver.driver);
2970 if (err) {
2971 driver_err("register fwserial driver failed (%d)", err);
2972 goto remove_descriptor;
2973 }
2974
2975 return 0;
2976
2977remove_descriptor:
2978 fw_core_remove_descriptor(&fwserial_unit_directory);
2979remove_handler:
2980 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler);
2981destroy_cache:
2982 kmem_cache_destroy(fwtty_txn_cache);
fa1da242
PH		 2983unregister_loop:
2984 if (create_loop_dev)
2985 tty_unregister_driver(fwloop_driver);
2986put_loop:
2987 if (create_loop_dev)
2988 put_tty_driver(fwloop_driver);
7355ba34
PH		 2989unregister_driver:
2990 tty_unregister_driver(fwtty_driver);
2991put_tty:
2992 put_tty_driver(fwtty_driver);
4df5bb04 2993 debugfs_remove_recursive(fwserial_debugfs);
7355ba34
PH		 2994 return err;
2995}
2996
2997static void __exit fwserial_exit(void)
2998{
2999 driver_unregister(&fwserial_driver.driver);
3000 fw_core_remove_descriptor(&fwserial_unit_directory);
3001 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler);
3002 kmem_cache_destroy(fwtty_txn_cache);
fa1da242
PH		 3003 if (create_loop_dev) {
3004 tty_unregister_driver(fwloop_driver);
3005 put_tty_driver(fwloop_driver);
3006 }
7355ba34
PH		 3007 tty_unregister_driver(fwtty_driver);
3008 put_tty_driver(fwtty_driver);
4df5bb04 3009 debugfs_remove_recursive(fwserial_debugfs);
7355ba34
PH		 3010}
3011
3012module_init(fwserial_init);
3013module_exit(fwserial_exit);
3014
3015MODULE_AUTHOR("Peter Hurley (peter@hurleysoftware.com)");
3016MODULE_DESCRIPTION("FireWire Serial TTY Driver");
3017MODULE_LICENSE("GPL");
3018MODULE_DEVICE_TABLE(ieee1394, fwserial_id_table);
3019MODULE_PARM_DESC(ttys, "Number of ttys to create for each local firewire node");
3020MODULE_PARM_DESC(auto, "Auto-connect a tty to each firewire node discovered");
3021MODULE_PARM_DESC(loop, "Create a loopback device, fwloop<n>, with ttys");
Linux kernel - Deliverables
This page took 0.174214 seconds and 5 git commands to generate.