1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23#include <linux/sched.h>
24#include <linux/slab.h>
25#include <linux/device.h>
26#include <linux/mod_devicetable.h>
27#include <linux/rculist.h>
28#include <linux/workqueue.h>
29#include <linux/ratelimit.h>
30#include <linux/bug.h>
31#include <linux/uaccess.h>
32
33#include "fwserial.h"
34
35#define be32_to_u64(hi, lo) ((u64)be32_to_cpu(hi) << 32 | be32_to_cpu(lo))
36
37#define LINUX_VENDOR_ID 0xd00d1eU
38#define FWSERIAL_VERSION 0x00e81cU
39
40
41static int num_ttys = 4;
42
43static bool auto_connect = true;
44static bool create_loop_dev = true;
45
46module_param_named(ttys, num_ttys, int, S_IRUGO | S_IWUSR);
47module_param_named(auto, auto_connect, bool, S_IRUGO | S_IWUSR);
48module_param_named(loop, create_loop_dev, bool, S_IRUGO | S_IWUSR);
49
50
51
52
53
54
55
56#define WAKEUP_CHARS 256
57
58
59
60
61
62static LIST_HEAD(fwserial_list);
63static DEFINE_MUTEX(fwserial_list_mutex);
64
65
66
67
68
69
70
71
72static struct fwtty_port *port_table[MAX_TOTAL_PORTS];
73static DEFINE_MUTEX(port_table_lock);
74static bool port_table_corrupt;
75#define FWTTY_INVALID_INDEX MAX_TOTAL_PORTS
76
77#define loop_idx(port) (((port)->index) / num_ports)
78#define table_idx(loop) ((loop) * num_ports + num_ttys)
79
80
81static int num_ports;
82
83
84static struct kmem_cache *fwtty_txn_cache;
85
86struct tty_driver *fwtty_driver;
87static struct tty_driver *fwloop_driver;
88
89static struct dentry *fwserial_debugfs;
90
91struct fwtty_transaction;
92typedef void (*fwtty_transaction_cb)(struct fw_card *card, int rcode,
93 void *data, size_t length,
94 struct fwtty_transaction *txn);
95
96struct fwtty_transaction {
97 struct fw_transaction fw_txn;
98 fwtty_transaction_cb callback;
99 struct fwtty_port *port;
100 union {
101 struct dma_pending dma_pended;
102 };
103};
104
105#define to_device(a, b) (a->b)
106#define fwtty_err(p, fmt, ...) \
107 dev_err(to_device(p, device), fmt, ##__VA_ARGS__)
108#define fwtty_info(p, fmt, ...) \
109 dev_info(to_device(p, device), fmt, ##__VA_ARGS__)
110#define fwtty_notice(p, fmt, ...) \
111 dev_notice(to_device(p, device), fmt, ##__VA_ARGS__)
112#define fwtty_dbg(p, fmt, ...) \
113 dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__)
114#define fwtty_err_ratelimited(p, fmt, ...) \
115 dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__)
116
117#ifdef DEBUG
118static inline void debug_short_write(struct fwtty_port *port, int c, int n)
119{
120 int avail;
121
122 if (n < c) {
123 spin_lock_bh(&port->lock);
124 avail = dma_fifo_avail(&port->tx_fifo);
125 spin_unlock_bh(&port->lock);
126 fwtty_dbg(port, "short write: avail:%d req:%d wrote:%d\n",
127 avail, c, n);
128 }
129}
130#else
131#define debug_short_write(port, c, n)
132#endif
133
134static struct fwtty_peer *__fwserial_peer_by_node_id(struct fw_card *card,
135 int generation, int id);
136
137#ifdef FWTTY_PROFILING
138
139static void profile_fifo_avail(struct fwtty_port *port, unsigned *stat)
140{
141 spin_lock_bh(&port->lock);
142 profile_size_distrib(stat, dma_fifo_avail(&port->tx_fifo));
143 spin_unlock_bh(&port->lock);
144}
145
146static void dump_profile(struct seq_file *m, struct stats *stats)
147{
148
149 int k = 4;
150 unsigned sum;
151 int j;
152 char t[10];
153
154 snprintf(t, 10, "< %d", 1 << k);
155 seq_printf(m, "\n%14s %6s", " ", t);
156 for (j = k + 1; j < DISTRIBUTION_MAX_INDEX; ++j)
157 seq_printf(m, "%6d", 1 << j);
158
159 ++k;
160 for (j = 0, sum = 0; j <= k; ++j)
161 sum += stats->reads[j];
162 seq_printf(m, "\n%14s: %6d", "reads", sum);
163 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
164 seq_printf(m, "%6d", stats->reads[j]);
165
166 for (j = 0, sum = 0; j <= k; ++j)
167 sum += stats->writes[j];
168 seq_printf(m, "\n%14s: %6d", "writes", sum);
169 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
170 seq_printf(m, "%6d", stats->writes[j]);
171
172 for (j = 0, sum = 0; j <= k; ++j)
173 sum += stats->txns[j];
174 seq_printf(m, "\n%14s: %6d", "txns", sum);
175 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
176 seq_printf(m, "%6d", stats->txns[j]);
177
178 for (j = 0, sum = 0; j <= k; ++j)
179 sum += stats->unthrottle[j];
180 seq_printf(m, "\n%14s: %6d", "avail @ unthr", sum);
181 for (j = k + 1; j <= DISTRIBUTION_MAX_INDEX; ++j)
182 seq_printf(m, "%6d", stats->unthrottle[j]);
183}
184
185#else
186#define profile_fifo_avail(port, stat)
187#define dump_profile(m, stats)
188#endif
189
190
191
192
193
194
195static inline int device_max_receive(struct fw_device *fw_device)
196{
197
198 return min(2 << fw_device->max_rec, 4096);
199}
200
201static void fwtty_log_tx_error(struct fwtty_port *port, int rcode)
202{
203 switch (rcode) {
204 case RCODE_SEND_ERROR:
205 fwtty_err_ratelimited(port, "card busy\n");
206 break;
207 case RCODE_ADDRESS_ERROR:
208 fwtty_err_ratelimited(port, "bad unit addr or write length\n");
209 break;
210 case RCODE_DATA_ERROR:
211 fwtty_err_ratelimited(port, "failed rx\n");
212 break;
213 case RCODE_NO_ACK:
214 fwtty_err_ratelimited(port, "missing ack\n");
215 break;
216 case RCODE_BUSY:
217 fwtty_err_ratelimited(port, "remote busy\n");
218 break;
219 default:
220 fwtty_err_ratelimited(port, "failed tx: %d\n", rcode);
221 }
222}
223
224static void fwtty_txn_constructor(void *this)
225{
226 struct fwtty_transaction *txn = this;
227
228 init_timer(&txn->fw_txn.split_timeout_timer);
229}
230
231static void fwtty_common_callback(struct fw_card *card, int rcode,
232 void *payload, size_t len, void *cb_data)
233{
234 struct fwtty_transaction *txn = cb_data;
235 struct fwtty_port *port = txn->port;
236
237 if (port && rcode != RCODE_COMPLETE)
238 fwtty_log_tx_error(port, rcode);
239 if (txn->callback)
240 txn->callback(card, rcode, payload, len, txn);
241 kmem_cache_free(fwtty_txn_cache, txn);
242}
243
244static int fwtty_send_data_async(struct fwtty_peer *peer, int tcode,
245 unsigned long long addr, void *payload,
246 size_t len, fwtty_transaction_cb callback,
247 struct fwtty_port *port)
248{
249 struct fwtty_transaction *txn;
250 int generation;
251
252 txn = kmem_cache_alloc(fwtty_txn_cache, GFP_ATOMIC);
253 if (!txn)
254 return -ENOMEM;
255
256 txn->callback = callback;
257 txn->port = port;
258
259 generation = peer->generation;
260 smp_rmb();
261 fw_send_request(peer->serial->card, &txn->fw_txn, tcode,
262 peer->node_id, generation, peer->speed, addr, payload,
263 len, fwtty_common_callback, txn);
264 return 0;
265}
266
267static void fwtty_send_txn_async(struct fwtty_peer *peer,
268 struct fwtty_transaction *txn, int tcode,
269 unsigned long long addr, void *payload,
270 size_t len, fwtty_transaction_cb callback,
271 struct fwtty_port *port)
272{
273 int generation;
274
275 txn->callback = callback;
276 txn->port = port;
277
278 generation = peer->generation;
279 smp_rmb();
280 fw_send_request(peer->serial->card, &txn->fw_txn, tcode,
281 peer->node_id, generation, peer->speed, addr, payload,
282 len, fwtty_common_callback, txn);
283}
284
285
286static void __fwtty_restart_tx(struct fwtty_port *port)
287{
288 int len, avail;
289
290 len = dma_fifo_out_level(&port->tx_fifo);
291 if (len)
292 schedule_delayed_work(&port->drain, 0);
293 avail = dma_fifo_avail(&port->tx_fifo);
294
295 fwtty_dbg(port, "fifo len: %d avail: %d\n", len, avail);
296}
297
298static void fwtty_restart_tx(struct fwtty_port *port)
299{
300 spin_lock_bh(&port->lock);
301 __fwtty_restart_tx(port);
302 spin_unlock_bh(&port->lock);
303}
304
305
306
307
308
309
310
311static void fwtty_update_port_status(struct fwtty_port *port, unsigned status)
312{
313 unsigned delta;
314 struct tty_struct *tty;
315
316
317 status &= ~MCTRL_MASK;
318 delta = (port->mstatus ^ status) & ~MCTRL_MASK;
319 delta &= ~(status & TIOCM_RNG);
320 port->mstatus = status;
321
322 if (delta & TIOCM_RNG)
323 ++port->icount.rng;
324 if (delta & TIOCM_DSR)
325 ++port->icount.dsr;
326 if (delta & TIOCM_CAR)
327 ++port->icount.dcd;
328 if (delta & TIOCM_CTS)
329 ++port->icount.cts;
330
331 fwtty_dbg(port, "status: %x delta: %x\n", status, delta);
332
333 if (delta & TIOCM_CAR) {
334 tty = tty_port_tty_get(&port->port);
335 if (tty && !C_CLOCAL(tty)) {
336 if (status & TIOCM_CAR)
337 wake_up_interruptible(&port->port.open_wait);
338 else
339 schedule_work(&port->hangup);
340 }
341 tty_kref_put(tty);
342 }
343
344 if (delta & TIOCM_CTS) {
345 tty = tty_port_tty_get(&port->port);
346 if (tty && C_CRTSCTS(tty)) {
347 if (tty->hw_stopped) {
348 if (status & TIOCM_CTS) {
349 tty->hw_stopped = 0;
350 if (port->loopback)
351 __fwtty_restart_tx(port);
352 else
353 fwtty_restart_tx(port);
354 }
355 } else {
356 if (~status & TIOCM_CTS)
357 tty->hw_stopped = 1;
358 }
359 }
360 tty_kref_put(tty);
361
362 } else if (delta & OOB_TX_THROTTLE) {
363 tty = tty_port_tty_get(&port->port);
364 if (tty) {
365 if (tty->hw_stopped) {
366 if (~status & OOB_TX_THROTTLE) {
367 tty->hw_stopped = 0;
368 if (port->loopback)
369 __fwtty_restart_tx(port);
370 else
371 fwtty_restart_tx(port);
372 }
373 } else {
374 if (status & OOB_TX_THROTTLE)
375 tty->hw_stopped = 1;
376 }
377 }
378 tty_kref_put(tty);
379 }
380
381 if (delta & (UART_LSR_BI << 24)) {
382 if (status & (UART_LSR_BI << 24)) {
383 port->break_last = jiffies;
384 schedule_delayed_work(&port->emit_breaks, 0);
385 } else {
386
387 mod_delayed_work(system_wq, &port->emit_breaks, 0);
388 }
389 }
390
391 if (delta & (TIOCM_DSR | TIOCM_CAR | TIOCM_CTS | TIOCM_RNG))
392 wake_up_interruptible(&port->port.delta_msr_wait);
393}
394
395
396
397
398
399
400
401
402
403
404static unsigned __fwtty_port_line_status(struct fwtty_port *port)
405{
406 unsigned status = 0;
407
408
409
410 if (port->mctrl & TIOCM_DTR)
411 status |= TIOCM_DSR | TIOCM_CAR;
412 if (port->mctrl & TIOCM_RTS)
413 status |= TIOCM_CTS;
414 if (port->mctrl & OOB_RX_THROTTLE)
415 status |= OOB_TX_THROTTLE;
416
417 if (port->break_ctl)
418 status |= UART_LSR_BI << 24;
419
420 return status;
421}
422
423
424
425
426
427
428static int __fwtty_write_port_status(struct fwtty_port *port)
429{
430 struct fwtty_peer *peer;
431 int err = -ENOENT;
432 unsigned status = __fwtty_port_line_status(port);
433
434 rcu_read_lock();
435 peer = rcu_dereference(port->peer);
436 if (peer) {
437 err = fwtty_send_data_async(peer, TCODE_WRITE_QUADLET_REQUEST,
438 peer->status_addr, &status,
439 sizeof(status), NULL, port);
440 }
441 rcu_read_unlock();
442
443 return err;
444}
445
446
447
448
449static int fwtty_write_port_status(struct fwtty_port *port)
450{
451 int err;
452
453 spin_lock_bh(&port->lock);
454 err = __fwtty_write_port_status(port);
455 spin_unlock_bh(&port->lock);
456 return err;
457}
458
459static void __fwtty_throttle(struct fwtty_port *port, struct tty_struct *tty)
460{
461 unsigned old;
462
463 old = port->mctrl;
464 port->mctrl |= OOB_RX_THROTTLE;
465 if (C_CRTSCTS(tty))
466 port->mctrl &= ~TIOCM_RTS;
467 if (~old & OOB_RX_THROTTLE)
468 __fwtty_write_port_status(port);
469}
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491static void fwtty_do_hangup(struct work_struct *work)
492{
493 struct fwtty_port *port = to_port(work, hangup);
494 struct tty_struct *tty;
495
496 schedule_timeout_uninterruptible(msecs_to_jiffies(50));
497
498 tty = tty_port_tty_get(&port->port);
499 if (tty)
500 tty_vhangup(tty);
501 tty_kref_put(tty);
502}
503
504
505static void fwtty_emit_breaks(struct work_struct *work)
506{
507 struct fwtty_port *port = to_port(to_delayed_work(work), emit_breaks);
508 static const char buf[16];
509 unsigned long now = jiffies;
510 unsigned long elapsed = now - port->break_last;
511 int n, t, c, brk = 0;
512
513
514 n = (elapsed * port->cps) / HZ + 1;
515 port->break_last = now;
516
517 fwtty_dbg(port, "sending %d brks\n", n);
518
519 while (n) {
520 t = min(n, 16);
521 c = tty_insert_flip_string_fixed_flag(&port->port, buf,
522 TTY_BREAK, t);
523 n -= c;
524 brk += c;
525 if (c < t)
526 break;
527 }
528 tty_flip_buffer_push(&port->port);
529
530 if (port->mstatus & (UART_LSR_BI << 24))
531 schedule_delayed_work(&port->emit_breaks, FREQ_BREAKS);
532 port->icount.brk += brk;
533}
534
535static void fwtty_pushrx(struct work_struct *work)
536{
537 struct fwtty_port *port = to_port(work, push);
538 struct tty_struct *tty;
539 struct buffered_rx *buf, *next;
540 int n, c = 0;
541
542 spin_lock_bh(&port->lock);
543 list_for_each_entry_safe(buf, next, &port->buf_list, list) {
544 n = tty_insert_flip_string_fixed_flag(&port->port, buf->data,
545 TTY_NORMAL, buf->n);
546 c += n;
547 port->buffered -= n;
548 if (n < buf->n) {
549 if (n > 0) {
550 memmove(buf->data, buf->data + n, buf->n - n);
551 buf->n -= n;
552 }
553 tty = tty_port_tty_get(&port->port);
554 if (tty) {
555 __fwtty_throttle(port, tty);
556 tty_kref_put(tty);
557 }
558 break;
559 } else {
560 list_del(&buf->list);
561 kfree(buf);
562 }
563 }
564 if (c > 0)
565 tty_flip_buffer_push(&port->port);
566
567 if (list_empty(&port->buf_list))
568 clear_bit(BUFFERING_RX, &port->flags);
569 spin_unlock_bh(&port->lock);
570}
571
572static int fwtty_buffer_rx(struct fwtty_port *port, unsigned char *d, size_t n)
573{
574 struct buffered_rx *buf;
575 size_t size = (n + sizeof(struct buffered_rx) + 0xFF) & ~0xFF;
576
577 if (port->buffered + n > HIGH_WATERMARK) {
578 fwtty_err_ratelimited(port, "overflowed rx buffer: buffered: %d new: %zu wtrmk: %d\n",
579 port->buffered, n, HIGH_WATERMARK);
580 return 0;
581 }
582 buf = kmalloc(size, GFP_ATOMIC);
583 if (!buf)
584 return 0;
585 INIT_LIST_HEAD(&buf->list);
586 buf->n = n;
587 memcpy(buf->data, d, n);
588
589 spin_lock_bh(&port->lock);
590 list_add_tail(&buf->list, &port->buf_list);
591 port->buffered += n;
592 if (port->buffered > port->stats.watermark)
593 port->stats.watermark = port->buffered;
594 set_bit(BUFFERING_RX, &port->flags);
595 spin_unlock_bh(&port->lock);
596
597 return n;
598}
599
600static int fwtty_rx(struct fwtty_port *port, unsigned char *data, size_t len)
601{
602 struct tty_struct *tty;
603 int c, n = len;
604 unsigned lsr;
605 int err = 0;
606
607 fwtty_dbg(port, "%d\n", n);
608 profile_size_distrib(port->stats.reads, n);
609
610 if (port->write_only) {
611 n = 0;
612 goto out;
613 }
614
615
616 lsr = (port->mstatus >> 24) & ~UART_LSR_BI;
617
618 if (port->overrun)
619 lsr |= UART_LSR_OE;
620
621 if (lsr & UART_LSR_OE)
622 ++port->icount.overrun;
623
624 lsr &= port->status_mask;
625 if (lsr & ~port->ignore_mask & UART_LSR_OE) {
626 if (!tty_insert_flip_char(&port->port, 0, TTY_OVERRUN)) {
627 err = -EIO;
628 goto out;
629 }
630 }
631 port->overrun = false;
632
633 if (lsr & port->ignore_mask & ~UART_LSR_OE) {
634
635 n = 0;
636 goto out;
637 }
638
639 if (!test_bit(BUFFERING_RX, &port->flags)) {
640 c = tty_insert_flip_string_fixed_flag(&port->port, data,
641 TTY_NORMAL, n);
642 if (c > 0)
643 tty_flip_buffer_push(&port->port);
644 n -= c;
645
646 if (n) {
647
648 n -= fwtty_buffer_rx(port, &data[c], n);
649
650 tty = tty_port_tty_get(&port->port);
651 if (tty) {
652 spin_lock_bh(&port->lock);
653 __fwtty_throttle(port, tty);
654 spin_unlock_bh(&port->lock);
655 tty_kref_put(tty);
656 }
657 }
658 } else
659 n -= fwtty_buffer_rx(port, data, n);
660
661 if (n) {
662 port->overrun = true;
663 err = -EIO;
664 }
665
666out:
667 port->icount.rx += len;
668 port->stats.lost += n;
669 return err;
670}
671
672
673
674
675
676
677
678static void fwtty_port_handler(struct fw_card *card,
679 struct fw_request *request,
680 int tcode, int destination, int source,
681 int generation,
682 unsigned long long addr,
683 void *data, size_t len,
684 void *callback_data)
685{
686 struct fwtty_port *port = callback_data;
687 struct fwtty_peer *peer;
688 int err;
689 int rcode;
690
691
692 rcu_read_lock();
693 peer = __fwserial_peer_by_node_id(card, generation, source);
694 rcu_read_unlock();
695 if (!peer || peer != rcu_access_pointer(port->peer)) {
696 rcode = RCODE_ADDRESS_ERROR;
697 fwtty_err_ratelimited(port, "ignoring unauthenticated data\n");
698 goto respond;
699 }
700
701 switch (tcode) {
702 case TCODE_WRITE_QUADLET_REQUEST:
703 if (addr != port->rx_handler.offset || len != 4)
704 rcode = RCODE_ADDRESS_ERROR;
705 else {
706 fwtty_update_port_status(port, *(unsigned *)data);
707 rcode = RCODE_COMPLETE;
708 }
709 break;
710
711 case TCODE_WRITE_BLOCK_REQUEST:
712 if (addr != port->rx_handler.offset + 4 ||
713 len > port->rx_handler.length - 4) {
714 rcode = RCODE_ADDRESS_ERROR;
715 } else {
716 err = fwtty_rx(port, data, len);
717 switch (err) {
718 case 0:
719 rcode = RCODE_COMPLETE;
720 break;
721 case -EIO:
722 rcode = RCODE_DATA_ERROR;
723 break;
724 default:
725 rcode = RCODE_CONFLICT_ERROR;
726 break;
727 }
728 }
729 break;
730
731 default:
732 rcode = RCODE_TYPE_ERROR;
733 }
734
735respond:
736 fw_send_response(card, request, rcode);
737}
738
739
740
741
742
743
744
745
746
747static void fwtty_tx_complete(struct fw_card *card, int rcode,
748 void *data, size_t length,
749 struct fwtty_transaction *txn)
750{
751 struct fwtty_port *port = txn->port;
752 int len;
753
754 fwtty_dbg(port, "rcode: %d\n", rcode);
755
756 switch (rcode) {
757 case RCODE_COMPLETE:
758 spin_lock_bh(&port->lock);
759 dma_fifo_out_complete(&port->tx_fifo, &txn->dma_pended);
760 len = dma_fifo_level(&port->tx_fifo);
761 spin_unlock_bh(&port->lock);
762
763 port->icount.tx += txn->dma_pended.len;
764 break;
765
766 default:
767
768 spin_lock_bh(&port->lock);
769 dma_fifo_out_complete(&port->tx_fifo, &txn->dma_pended);
770 len = dma_fifo_level(&port->tx_fifo);
771 spin_unlock_bh(&port->lock);
772
773 port->stats.dropped += txn->dma_pended.len;
774 }
775
776 if (len < WAKEUP_CHARS)
777 tty_port_tty_wakeup(&port->port);
778}
779
780static int fwtty_tx(struct fwtty_port *port, bool drain)
781{
782 struct fwtty_peer *peer;
783 struct fwtty_transaction *txn;
784 struct tty_struct *tty;
785 int n, len;
786
787 tty = tty_port_tty_get(&port->port);
788 if (!tty)
789 return -ENOENT;
790
791 rcu_read_lock();
792 peer = rcu_dereference(port->peer);
793 if (!peer) {
794 n = -EIO;
795 goto out;
796 }
797
798 if (test_and_set_bit(IN_TX, &port->flags)) {
799 n = -EALREADY;
800 goto out;
801 }
802
803
804 n = -EAGAIN;
805 while (!tty->stopped && !tty->hw_stopped &&
806 !test_bit(STOP_TX, &port->flags)) {
807 txn = kmem_cache_alloc(fwtty_txn_cache, GFP_ATOMIC);
808 if (!txn) {
809 n = -ENOMEM;
810 break;
811 }
812
813 spin_lock_bh(&port->lock);
814 n = dma_fifo_out_pend(&port->tx_fifo, &txn->dma_pended);
815 spin_unlock_bh(&port->lock);
816
817 fwtty_dbg(port, "out: %u rem: %d\n", txn->dma_pended.len, n);
818
819 if (n < 0) {
820 kmem_cache_free(fwtty_txn_cache, txn);
821 if (n == -EAGAIN)
822 ++port->stats.tx_stall;
823 else if (n == -ENODATA)
824 profile_size_distrib(port->stats.txns, 0);
825 else {
826 ++port->stats.fifo_errs;
827 fwtty_err_ratelimited(port, "fifo err: %d\n",
828 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
843
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
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\n", 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) {
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]);
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);
957 tty_port_destroy(&ports[j]->port);
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\n", on);
974
975 spin_lock_bh(&port->lock);
976
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
990
991
992
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\n", 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
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
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
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
1097
1098
1099
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
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
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
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\n", 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", 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", 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\n", 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
1247
1248
1249
1250
1251
1252
1253
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\n", (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
1405
1406
1407
1408
1409
1410
1411
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\n", 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\n", 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\n", set, clear);
1465
1466
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
1508 seq_printf(m, " addr:%012llx tx:%d rx:%d", port->rx_handler.offset,
1509 port->icount.tx + stats.xchars, port->icount.rx);
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);
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
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);
1528
1529 if (port->port.console) {
1530 seq_puts(m, "\n ");
1531 (*port->fwcon_ops->proc_show)(m, port->con_data);
1532 }
1533
1534 dump_profile(m, &port->stats);
1535}
1536
1537static void fwtty_debugfs_show_peer(struct seq_file *m, struct fwtty_peer *peer)
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);
1546 seq_printf(m, " mgmt:%012llx", (unsigned long long) peer->mgmt_addr);
1547 seq_printf(m, " addr:%012llx", (unsigned long long) peer->status_addr);
1548 seq_putc(m, '\n');
1549}
1550
1551static int fwtty_proc_show(struct seq_file *m, void *v)
1552{
1553 struct fwtty_port *port;
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_puts(m, "\n");
1563 }
1564 return 0;
1565}
1566
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_puts(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
1601static int fwtty_proc_open(struct inode *inode, struct file *fp)
1602{
1603 return single_open(fp, fwtty_proc_show, NULL);
1604}
1605
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
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
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
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:
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
1776 spin_lock_bh(&port->lock);
1777 port->max_payload = min(peer->max_payload, peer->fifo_len);
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\n",
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\n", rcode);
1807 continue;
1808 } else
1809 break;
1810 } while (--tries > 0);
1811 return rcode;
1812}
1813
1814
1815
1816
1817
1818
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
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
1844
1845
1846
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
1854 synchronize_rcu();
1855
1856
1857
1858
1859 for (i = 0; i < num_ttys; ++i) {
1860 spin_lock_bh(&ports[i]->lock);
1861 if (!ports[i]->peer) {
1862
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
1872static void fwserial_release_port(struct fwtty_port *port, bool reset)
1873{
1874
1875 if (reset)
1876 fwtty_update_port_status(port, 0);
1877
1878 spin_lock_bh(&port->lock);
1879
1880
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)
1906 fwserial_release_port(port, false);
1907}
1908
1909
1910
1911
1912
1913
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\n");
1928 err = -EBUSY;
1929 goto free_pkt;
1930 }
1931
1932 spin_lock_bh(&peer->lock);
1933
1934
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);
1969 fwserial_release_port(port, false);
1970free_pkt:
1971 kfree(pkt);
1972 return err;
1973}
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984static void fwserial_close_port(struct tty_driver *driver,
1985 struct fwtty_port *port)
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
1997 if (driver == fwloop_driver)
1998 tty_unregister_device(driver, loop_idx(port));
1999 else
2000 tty_unregister_device(driver, port->index);
2001}
2002
2003
2004
2005
2006
2007
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
2023
2024
2025
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
2041
2042
2043
2044
2045
2046
2047
2048
2049
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
2061
2062
2063
2064
2065 fwtty_err(card, "unknown card (guid %016llx)\n",
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",
2094 g, 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
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
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
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
2166
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
2179 peer->serial = serial;
2180 list_add_rcu(&peer->list, &serial->peer_list);
2181
2182 fwtty_info(&peer->unit, "peer added (guid:%016llx)\n",
2183 (unsigned long long)peer->guid);
2184
2185
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(¶ms, port);
2197 fwserial_virt_plug_complete(peer, ¶ms);
2198 spin_unlock_bh(&peer->lock);
2199
2200 fwtty_write_port_status(port);
2201 }
2202 }
2203
2204 } else if (auto_connect) {
2205
2206 schedule_delayed_work(&peer->connect, 1);
2207 }
2208
2209 return 0;
2210}
2211
2212
2213
2214
2215
2216
2217
2218
2219
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
2234 if (peer == peer->serial->self)
2235 peer->serial->self = NULL;
2236
2237
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)\n",
2246 (unsigned long long)peer->guid);
2247
2248 spin_unlock_bh(&peer->lock);
2249
2250 if (port)
2251 fwserial_release_port(port, true);
2252
2253 synchronize_rcu();
2254 kfree(peer);
2255}
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
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
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
2320
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
2330
2331 err = fwtty_ports_add(serial);
2332 if (err) {
2333 fwtty_err(&unit, "no space in port table\n");
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)\n",
2345 err);
2346 goto unregister_ttys;
2347 }
2348
2349 serial->ports[j]->device = tty_dev;
2350 }
2351
2352
2353 if (create_loop_dev) {
2354 struct device *loop_dev;
2355
2356 loop_dev = tty_port_register_device(&serial->ports[j]->port,
2357 fwloop_driver,
2358 loop_idx(serial->ports[j]),
2359 card->device);
2360 if (IS_ERR(loop_dev)) {
2361 err = PTR_ERR(loop_dev);
2362 fwtty_err(&unit, "create loop device failed (%d)\n",
2363 err);
2364 goto unregister_ttys;
2365 }
2366 serial->ports[j]->device = loop_dev;
2367 serial->ports[j]->loopback = true;
2368 }
2369
2370 if (!IS_ERR_OR_NULL(fwserial_debugfs)) {
2371 serial->debugfs = debugfs_create_dir(dev_name(&unit->device),
2372 fwserial_debugfs);
2373 if (!IS_ERR_OR_NULL(serial->debugfs)) {
2374 debugfs_create_file("peers", 0444, serial->debugfs,
2375 serial, &fwtty_peers_fops);
2376 debugfs_create_file("stats", 0444, serial->debugfs,
2377 serial, &fwtty_stats_fops);
2378 }
2379 }
2380
2381 list_add_rcu(&serial->list, &fwserial_list);
2382
2383 fwtty_notice(&unit, "TTY over FireWire on device %s (guid %016llx)\n",
2384 dev_name(card->device), (unsigned long long) card->guid);
2385
2386 err = fwserial_add_peer(serial, unit);
2387 if (!err)
2388 return 0;
2389
2390 fwtty_err(&unit, "unable to add peer unit device (%d)\n", err);
2391
2392
2393 debugfs_remove_recursive(serial->debugfs);
2394
2395 list_del_rcu(&serial->list);
2396 if (create_loop_dev)
2397 tty_unregister_device(fwloop_driver, loop_idx(serial->ports[j]));
2398unregister_ttys:
2399 for (--j; j >= 0; --j)
2400 tty_unregister_device(fwtty_driver, serial->ports[j]->index);
2401 kref_put(&serial->kref, fwserial_destroy);
2402 return err;
2403
2404free_ports:
2405 for (--i; i >= 0; --i) {
2406 tty_port_destroy(&serial->ports[i]->port);
2407 kfree(serial->ports[i]);
2408 }
2409 kfree(serial);
2410 return err;
2411}
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449static int fwserial_probe(struct fw_unit *unit,
2450 const struct ieee1394_device_id *id)
2451{
2452 struct fw_serial *serial;
2453 int err;
2454
2455 mutex_lock(&fwserial_list_mutex);
2456 serial = fwserial_lookup(fw_parent_device(unit)->card);
2457 if (!serial)
2458 err = fwserial_create(unit);
2459 else
2460 err = fwserial_add_peer(serial, unit);
2461 mutex_unlock(&fwserial_list_mutex);
2462 return err;
2463}
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473static void fwserial_remove(struct fw_unit *unit)
2474{
2475 struct fwtty_peer *peer = dev_get_drvdata(&unit->device);
2476 struct fw_serial *serial = peer->serial;
2477 int i;
2478
2479 mutex_lock(&fwserial_list_mutex);
2480 fwserial_remove_peer(peer);
2481
2482 if (list_empty(&serial->peer_list)) {
2483
2484 list_del_rcu(&serial->list);
2485
2486 debugfs_remove_recursive(serial->debugfs);
2487
2488 for (i = 0; i < num_ttys; ++i)
2489 fwserial_close_port(fwtty_driver, serial->ports[i]);
2490 if (create_loop_dev)
2491 fwserial_close_port(fwloop_driver, serial->ports[i]);
2492 kref_put(&serial->kref, fwserial_destroy);
2493 }
2494 mutex_unlock(&fwserial_list_mutex);
2495}
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
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 },
2540 .probe = fwserial_probe,
2541 .update = fwserial_update,
2542 .remove = fwserial_remove,
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
2551
2552
2553#define FW_ROM_LEN(quads) ((quads) << 16)
2554#define FW_ROM_DESCRIPTOR(ofs) (((CSR_LEAF | CSR_DESCRIPTOR) << 24) | (ofs))
2555
2556struct fwserial_unit_directory_data {
2557 u32 len_crc;
2558 u32 unit_specifier;
2559 u32 unit_sw_version;
2560 u32 unit_addr_offset;
2561 u32 desc1_ofs;
2562 u32 desc1_len_crc;
2563 u32 desc1_data[5];
2564} __packed;
2565
2566static struct fwserial_unit_directory_data fwserial_unit_directory_data = {
2567 .len_crc = FW_ROM_LEN(4),
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),
2571 .desc1_len_crc = FW_ROM_LEN(5),
2572 .desc1_data = {
2573 0x00000000,
2574 0x00000000,
2575 0x4c696e75,
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
2589
2590
2591static const struct fw_address_region fwserial_mgmt_addr_region = {
2592 .start = CSR_REGISTER_BASE + 0x1e0000ULL,
2593 .end = 0x1000000000000ULL,
2594};
2595
2596static struct fw_address_handler fwserial_mgmt_addr_handler;
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
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\n");
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
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
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)
2657 fwserial_release_port(port, false);
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)\n", rcode);
2673 port = peer_revert_state(peer);
2674 }
2675 }
2676cleanup:
2677 spin_unlock_bh(&peer->lock);
2678 if (port)
2679 fwserial_release_port(port, false);
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
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) {
2723 if (rcode != RCODE_COMPLETE)
2724 fwtty_err(&peer->unit, "UNPLUG_RSP error (%d)\n",
2725 rcode);
2726 port = peer_revert_state(peer);
2727 }
2728cleanup:
2729 spin_unlock_bh(&peer->lock);
2730 if (port)
2731 fwserial_release_port(port, true);
2732 kfree(pkt);
2733 return;
2734}
2735
2736static int fwserial_parse_mgmt_write(struct fwtty_peer *peer,
2737 struct fwserial_mgmt_pkt *pkt,
2738 unsigned long long addr,
2739 size_t len)
2740{
2741 struct fwtty_port *port = NULL;
2742 bool reset = false;
2743 int rcode;
2744
2745 if (addr != fwserial_mgmt_addr_handler.offset || len < sizeof(pkt->hdr))
2746 return RCODE_ADDRESS_ERROR;
2747
2748 if (len != be16_to_cpu(pkt->hdr.len) ||
2749 len != mgmt_pkt_expected_len(pkt->hdr.code))
2750 return RCODE_DATA_ERROR;
2751
2752 spin_lock_bh(&peer->lock);
2753 if (peer->state == FWPS_GONE) {
2754
2755
2756
2757
2758
2759
2760 fwtty_err(&peer->unit, "peer already removed\n");
2761 spin_unlock_bh(&peer->lock);
2762 return RCODE_ADDRESS_ERROR;
2763 }
2764
2765 rcode = RCODE_COMPLETE;
2766
2767 fwtty_dbg(&peer->unit, "mgmt: hdr.code: %04hx\n", pkt->hdr.code);
2768
2769 switch (be16_to_cpu(pkt->hdr.code) & FWSC_CODE_MASK) {
2770 case FWSC_VIRT_CABLE_PLUG:
2771 if (work_pending(&peer->work)) {
2772 fwtty_err(&peer->unit, "plug req: busy\n");
2773 rcode = RCODE_CONFLICT_ERROR;
2774
2775 } else {
2776 peer->work_params.plug_req = pkt->plug_req;
2777 PREPARE_WORK(&peer->work, fwserial_handle_plug_req);
2778 queue_work(system_unbound_wq, &peer->work);
2779 }
2780 break;
2781
2782 case FWSC_VIRT_CABLE_PLUG_RSP:
2783 if (peer->state != FWPS_PLUG_PENDING) {
2784 rcode = RCODE_CONFLICT_ERROR;
2785
2786 } else if (be16_to_cpu(pkt->hdr.code) & FWSC_RSP_NACK) {
2787 fwtty_notice(&peer->unit, "NACK plug rsp\n");
2788 port = peer_revert_state(peer);
2789
2790 } else {
2791 struct fwtty_port *tmp = peer->port;
2792
2793 fwserial_virt_plug_complete(peer, &pkt->plug_rsp);
2794 spin_unlock_bh(&peer->lock);
2795
2796 fwtty_write_port_status(tmp);
2797 spin_lock_bh(&peer->lock);
2798 }
2799 break;
2800
2801 case FWSC_VIRT_CABLE_UNPLUG:
2802 if (work_pending(&peer->work)) {
2803 fwtty_err(&peer->unit, "unplug req: busy\n");
2804 rcode = RCODE_CONFLICT_ERROR;
2805 } else {
2806 PREPARE_WORK(&peer->work, fwserial_handle_unplug_req);
2807 queue_work(system_unbound_wq, &peer->work);
2808 }
2809 break;
2810
2811 case FWSC_VIRT_CABLE_UNPLUG_RSP:
2812 if (peer->state != FWPS_UNPLUG_PENDING)
2813 rcode = RCODE_CONFLICT_ERROR;
2814 else {
2815 if (be16_to_cpu(pkt->hdr.code) & FWSC_RSP_NACK)
2816 fwtty_notice(&peer->unit, "NACK unplug?\n");
2817 port = peer_revert_state(peer);
2818 reset = true;
2819 }
2820 break;
2821
2822 default:
2823 fwtty_err(&peer->unit, "unknown mgmt code %d\n",
2824 be16_to_cpu(pkt->hdr.code));
2825 rcode = RCODE_DATA_ERROR;
2826 }
2827 spin_unlock_bh(&peer->lock);
2828
2829 if (port)
2830 fwserial_release_port(port, reset);
2831
2832 return rcode;
2833}
2834
2835
2836
2837
2838
2839
2840
2841
2842static void fwserial_mgmt_handler(struct fw_card *card,
2843 struct fw_request *request,
2844 int tcode, int destination, int source,
2845 int generation,
2846 unsigned long long addr,
2847 void *data, size_t len,
2848 void *callback_data)
2849{
2850 struct fwserial_mgmt_pkt *pkt = data;
2851 struct fwtty_peer *peer;
2852 int rcode;
2853
2854 rcu_read_lock();
2855 peer = __fwserial_peer_by_node_id(card, generation, source);
2856 if (!peer) {
2857 fwtty_dbg(card, "peer(%d:%x) not found\n", generation, source);
2858 __dump_peer_list(card);
2859 rcode = RCODE_CONFLICT_ERROR;
2860
2861 } else {
2862 switch (tcode) {
2863 case TCODE_WRITE_BLOCK_REQUEST:
2864 rcode = fwserial_parse_mgmt_write(peer, pkt, addr, len);
2865 break;
2866
2867 default:
2868 rcode = RCODE_TYPE_ERROR;
2869 }
2870 }
2871
2872 rcu_read_unlock();
2873 fw_send_response(card, request, rcode);
2874}
2875
2876static int __init fwserial_init(void)
2877{
2878 int err, num_loops = !!(create_loop_dev);
2879
2880
2881 fwserial_debugfs = debugfs_create_dir(KBUILD_MODNAME, NULL);
2882
2883
2884 if (num_ttys + num_loops > MAX_CARD_PORTS)
2885 num_ttys = MAX_CARD_PORTS - num_loops;
2886 num_ports = num_ttys + num_loops;
2887
2888 fwtty_driver = tty_alloc_driver(MAX_TOTAL_PORTS, TTY_DRIVER_REAL_RAW
2889 | TTY_DRIVER_DYNAMIC_DEV);
2890 if (IS_ERR(fwtty_driver)) {
2891 err = PTR_ERR(fwtty_driver);
2892 return err;
2893 }
2894
2895 fwtty_driver->driver_name = KBUILD_MODNAME;
2896 fwtty_driver->name = tty_dev_name;
2897 fwtty_driver->major = 0;
2898 fwtty_driver->minor_start = 0;
2899 fwtty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2900 fwtty_driver->subtype = SERIAL_TYPE_NORMAL;
2901 fwtty_driver->init_termios = tty_std_termios;
2902 fwtty_driver->init_termios.c_cflag |= CLOCAL;
2903 tty_set_operations(fwtty_driver, &fwtty_ops);
2904
2905 err = tty_register_driver(fwtty_driver);
2906 if (err) {
2907 pr_err("register tty driver failed (%d)\n", err);
2908 goto put_tty;
2909 }
2910
2911 if (create_loop_dev) {
2912 fwloop_driver = tty_alloc_driver(MAX_TOTAL_PORTS / num_ports,
2913 TTY_DRIVER_REAL_RAW
2914 | TTY_DRIVER_DYNAMIC_DEV);
2915 if (IS_ERR(fwloop_driver)) {
2916 err = PTR_ERR(fwloop_driver);
2917 goto unregister_driver;
2918 }
2919
2920 fwloop_driver->driver_name = KBUILD_MODNAME "_loop";
2921 fwloop_driver->name = loop_dev_name;
2922 fwloop_driver->major = 0;
2923 fwloop_driver->minor_start = 0;
2924 fwloop_driver->type = TTY_DRIVER_TYPE_SERIAL;
2925 fwloop_driver->subtype = SERIAL_TYPE_NORMAL;
2926 fwloop_driver->init_termios = tty_std_termios;
2927 fwloop_driver->init_termios.c_cflag |= CLOCAL;
2928 tty_set_operations(fwloop_driver, &fwloop_ops);
2929
2930 err = tty_register_driver(fwloop_driver);
2931 if (err) {
2932 pr_err("register loop driver failed (%d)\n", err);
2933 goto put_loop;
2934 }
2935 }
2936
2937 fwtty_txn_cache = kmem_cache_create("fwtty_txn_cache",
2938 sizeof(struct fwtty_transaction),
2939 0, 0, fwtty_txn_constructor);
2940 if (!fwtty_txn_cache) {
2941 err = -ENOMEM;
2942 goto unregister_loop;
2943 }
2944
2945
2946
2947
2948
2949
2950
2951
2952 fwserial_mgmt_addr_handler.length = sizeof(struct fwserial_mgmt_pkt);
2953 fwserial_mgmt_addr_handler.address_callback = fwserial_mgmt_handler;
2954
2955 err = fw_core_add_address_handler(&fwserial_mgmt_addr_handler,
2956 &fwserial_mgmt_addr_region);
2957 if (err) {
2958 pr_err("add management handler failed (%d)\n", err);
2959 goto destroy_cache;
2960 }
2961
2962 fwserial_unit_directory_data.unit_addr_offset =
2963 FW_UNIT_ADDRESS(fwserial_mgmt_addr_handler.offset);
2964 err = fw_core_add_descriptor(&fwserial_unit_directory);
2965 if (err) {
2966 pr_err("add unit descriptor failed (%d)\n", err);
2967 goto remove_handler;
2968 }
2969
2970 err = driver_register(&fwserial_driver.driver);
2971 if (err) {
2972 pr_err("register fwserial driver failed (%d)\n", err);
2973 goto remove_descriptor;
2974 }
2975
2976 return 0;
2977
2978remove_descriptor:
2979 fw_core_remove_descriptor(&fwserial_unit_directory);
2980remove_handler:
2981 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler);
2982destroy_cache:
2983 kmem_cache_destroy(fwtty_txn_cache);
2984unregister_loop:
2985 if (create_loop_dev)
2986 tty_unregister_driver(fwloop_driver);
2987put_loop:
2988 if (create_loop_dev)
2989 put_tty_driver(fwloop_driver);
2990unregister_driver:
2991 tty_unregister_driver(fwtty_driver);
2992put_tty:
2993 put_tty_driver(fwtty_driver);
2994 debugfs_remove_recursive(fwserial_debugfs);
2995 return err;
2996}
2997
2998static void __exit fwserial_exit(void)
2999{
3000 driver_unregister(&fwserial_driver.driver);
3001 fw_core_remove_descriptor(&fwserial_unit_directory);
3002 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler);
3003 kmem_cache_destroy(fwtty_txn_cache);
3004 if (create_loop_dev) {
3005 tty_unregister_driver(fwloop_driver);
3006 put_tty_driver(fwloop_driver);
3007 }
3008 tty_unregister_driver(fwtty_driver);
3009 put_tty_driver(fwtty_driver);
3010 debugfs_remove_recursive(fwserial_debugfs);
3011}
3012
3013module_init(fwserial_init);
3014module_exit(fwserial_exit);
3015
3016MODULE_AUTHOR("Peter Hurley (peter@hurleysoftware.com)");
3017MODULE_DESCRIPTION("FireWire Serial TTY Driver");
3018MODULE_LICENSE("GPL");
3019MODULE_DEVICE_TABLE(ieee1394, fwserial_id_table);
3020MODULE_PARM_DESC(ttys, "Number of ttys to create for each local firewire node");
3021MODULE_PARM_DESC(auto, "Auto-connect a tty to each firewire node discovered");
3022MODULE_PARM_DESC(loop, "Create a loopback device, fwloop<n>, with ttys");
3023