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