2 * FireWire Serial driver
4 * Copyright (C) 2012 Peter Hurley <peter@hurleysoftware.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 #include <linux/device.h>
24 #include <linux/mod_devicetable.h>
25 #include <linux/rculist.h>
26 #include <linux/workqueue.h>
27 #include <linux/ratelimit.h>
28 #include <linux/bug.h>
29 #include <linux/uaccess.h>
33 #define be32_to_u64(hi, lo) ((u64)be32_to_cpu(hi) << 32 | be32_to_cpu(lo))
35 #define LINUX_VENDOR_ID 0xd00d1eU /* same id used in card root directory */
36 #define FWSERIAL_VERSION 0x00e81cU /* must be unique within LINUX_VENDOR_ID */
38 /* configurable options */
39 static int num_ttys
= 4; /* # of std ttys to create per fw_card */
40 /* - doubles as loopback port index */
41 static bool auto_connect
= true; /* try to VIRT_CABLE to every peer */
42 static bool create_loop_dev
= true; /* create a loopback device for each card */
43 bool limit_bw
; /* limit async bandwidth to 20% of max */
45 module_param_named(ttys
, num_ttys
, int, S_IRUGO
| S_IWUSR
);
46 module_param_named(auto, auto_connect
, bool, S_IRUGO
| S_IWUSR
);
47 module_param_named(loop
, create_loop_dev
, bool, S_IRUGO
| S_IWUSR
);
48 module_param(limit_bw
, bool, S_IRUGO
| S_IWUSR
);
51 * Threshold below which the tty is woken for writing
52 * - should be equal to WAKEUP_CHARS in drivers/tty/n_tty.c because
53 * even if the writer is woken, n_tty_poll() won't set POLLOUT until
54 * our fifo is below this level
56 #define WAKEUP_CHARS 256
59 * fwserial_list: list of every fw_serial created for each fw_card
60 * See discussion in fwserial_probe.
62 static LIST_HEAD(fwserial_list
);
63 static DEFINE_MUTEX(fwserial_list_mutex
);
66 * port_table: array of tty ports allocated to each fw_card
68 * tty ports are allocated during probe when an fw_serial is first
69 * created for a given fw_card. Ports are allocated in a contiguous block,
70 * each block consisting of 'num_ports' ports.
72 static struct fwtty_port
*port_table
[MAX_TOTAL_PORTS
];
73 static DEFINE_MUTEX(port_table_lock
);
74 static bool port_table_corrupt
;
75 #define FWTTY_INVALID_INDEX MAX_TOTAL_PORTS
77 /* total # of tty ports created per fw_card */
80 /* slab used as pool for struct fwtty_transactions */
81 static struct kmem_cache
*fwtty_txn_cache
;
83 struct fwtty_transaction
;
84 typedef void (*fwtty_transaction_cb
)(struct fw_card
*card
, int rcode
,
85 void *data
, size_t length
,
86 struct fwtty_transaction
*txn
);
88 struct fwtty_transaction
{
89 struct fw_transaction fw_txn
;
90 fwtty_transaction_cb callback
;
91 struct fwtty_port
*port
;
93 struct dma_pending dma_pended
;
97 #define to_device(a, b) (a->b)
98 #define fwtty_err(p, s, v...) dev_err(to_device(p, device), s, ##v)
99 #define fwtty_info(p, s, v...) dev_info(to_device(p, device), s, ##v)
100 #define fwtty_notice(p, s, v...) dev_notice(to_device(p, device), s, ##v)
101 #define fwtty_dbg(p, s, v...) \
102 dev_dbg(to_device(p, device), "%s: " s, __func__, ##v)
103 #define fwtty_err_ratelimited(p, s, v...) \
104 dev_err_ratelimited(to_device(p, device), s, ##v)
107 static inline void debug_short_write(struct fwtty_port
*port
, int c
, int n
)
112 spin_lock_bh(&port
->lock
);
113 avail
= dma_fifo_avail(&port
->tx_fifo
);
114 spin_unlock_bh(&port
->lock
);
115 fwtty_dbg(port
, "short write: avail:%d req:%d wrote:%d",
120 #define debug_short_write(port, c, n)
123 static struct fwtty_peer
*__fwserial_peer_by_node_id(struct fw_card
*card
,
124 int generation
, int id
);
126 #ifdef FWTTY_PROFILING
128 static void profile_fifo_avail(struct fwtty_port
*port
, unsigned *stat
)
130 spin_lock_bh(&port
->lock
);
131 profile_size_distrib(stat
, dma_fifo_avail(&port
->tx_fifo
));
132 spin_unlock_bh(&port
->lock
);
135 static void dump_profile(struct seq_file
*m
, struct stats
*stats
)
137 /* for each stat, print sum of 0 to 2^k, then individually */
143 snprintf(t
, 10, "< %d", 1 << k
);
144 seq_printf(m
, "\n%14s %6s", " ", t
);
145 for (j
= k
+ 1; j
< DISTRIBUTION_MAX_INDEX
; ++j
)
146 seq_printf(m
, "%6d", 1 << j
);
149 for (j
= 0, sum
= 0; j
<= k
; ++j
)
150 sum
+= stats
->reads
[j
];
151 seq_printf(m
, "\n%14s: %6d", "reads", sum
);
152 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
153 seq_printf(m
, "%6d", stats
->reads
[j
]);
155 for (j
= 0, sum
= 0; j
<= k
; ++j
)
156 sum
+= stats
->writes
[j
];
157 seq_printf(m
, "\n%14s: %6d", "writes", sum
);
158 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
159 seq_printf(m
, "%6d", stats
->writes
[j
]);
161 for (j
= 0, sum
= 0; j
<= k
; ++j
)
162 sum
+= stats
->txns
[j
];
163 seq_printf(m
, "\n%14s: %6d", "txns", sum
);
164 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
165 seq_printf(m
, "%6d", stats
->txns
[j
]);
167 for (j
= 0, sum
= 0; j
<= k
; ++j
)
168 sum
+= stats
->unthrottle
[j
];
169 seq_printf(m
, "\n%14s: %6d", "avail @ unthr", sum
);
170 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
171 seq_printf(m
, "%6d", stats
->unthrottle
[j
]);
175 #define profile_fifo_avail(port, stat)
176 #define dump_profile(m, stats)
179 /* Returns the max receive packet size for the given card */
180 static inline int device_max_receive(struct fw_device
*fw_device
)
182 return 1 << (clamp_t(int, fw_device
->max_rec
, 8U, 11U) + 1);
185 static void fwtty_log_tx_error(struct fwtty_port
*port
, int rcode
)
188 case RCODE_SEND_ERROR
:
189 fwtty_err_ratelimited(port
, "card busy");
191 case RCODE_ADDRESS_ERROR
:
192 fwtty_err_ratelimited(port
, "bad unit addr or write length");
194 case RCODE_DATA_ERROR
:
195 fwtty_err_ratelimited(port
, "failed rx");
198 fwtty_err_ratelimited(port
, "missing ack");
201 fwtty_err_ratelimited(port
, "remote busy");
204 fwtty_err_ratelimited(port
, "failed tx: %d", rcode
);
208 static void fwtty_txn_constructor(void *this)
210 struct fwtty_transaction
*txn
= this;
212 init_timer(&txn
->fw_txn
.split_timeout_timer
);
215 static void fwtty_common_callback(struct fw_card
*card
, int rcode
,
216 void *payload
, size_t len
, void *cb_data
)
218 struct fwtty_transaction
*txn
= cb_data
;
219 struct fwtty_port
*port
= txn
->port
;
221 if (port
&& rcode
!= RCODE_COMPLETE
)
222 fwtty_log_tx_error(port
, rcode
);
224 txn
->callback(card
, rcode
, payload
, len
, txn
);
225 kmem_cache_free(fwtty_txn_cache
, txn
);
228 static int fwtty_send_data_async(struct fwtty_peer
*peer
, int tcode
,
229 unsigned long long addr
, void *payload
,
230 size_t len
, fwtty_transaction_cb callback
,
231 struct fwtty_port
*port
)
233 struct fwtty_transaction
*txn
;
236 txn
= kmem_cache_alloc(fwtty_txn_cache
, GFP_ATOMIC
);
240 txn
->callback
= callback
;
243 generation
= peer
->generation
;
245 fw_send_request(peer
->serial
->card
, &txn
->fw_txn
, tcode
,
246 peer
->node_id
, generation
, peer
->speed
, addr
, payload
,
247 len
, fwtty_common_callback
, txn
);
251 static void fwtty_send_txn_async(struct fwtty_peer
*peer
,
252 struct fwtty_transaction
*txn
, int tcode
,
253 unsigned long long addr
, void *payload
,
254 size_t len
, fwtty_transaction_cb callback
,
255 struct fwtty_port
*port
)
259 txn
->callback
= callback
;
262 generation
= peer
->generation
;
264 fw_send_request(peer
->serial
->card
, &txn
->fw_txn
, tcode
,
265 peer
->node_id
, generation
, peer
->speed
, addr
, payload
,
266 len
, fwtty_common_callback
, txn
);
270 static void __fwtty_restart_tx(struct fwtty_port
*port
)
274 len
= dma_fifo_out_level(&port
->tx_fifo
);
276 schedule_delayed_work(&port
->drain
, 0);
277 avail
= dma_fifo_avail(&port
->tx_fifo
);
279 fwtty_dbg(port
, "fifo len: %d avail: %d", len
, avail
);
282 static void fwtty_restart_tx(struct fwtty_port
*port
)
284 spin_lock_bh(&port
->lock
);
285 __fwtty_restart_tx(port
);
286 spin_unlock_bh(&port
->lock
);
290 * fwtty_update_port_status - decodes & dispatches line status changes
292 * Note: in loopback, the port->lock is being held. Only use functions that
293 * don't attempt to reclaim the port->lock.
295 static void fwtty_update_port_status(struct fwtty_port
*port
, unsigned status
)
298 struct tty_struct
*tty
;
300 /* simulated LSR/MSR status from remote */
301 status
&= ~MCTRL_MASK
;
302 delta
= (port
->mstatus
^ status
) & ~MCTRL_MASK
;
303 delta
&= ~(status
& TIOCM_RNG
);
304 port
->mstatus
= status
;
306 if (delta
& TIOCM_RNG
)
308 if (delta
& TIOCM_DSR
)
310 if (delta
& TIOCM_CAR
)
312 if (delta
& TIOCM_CTS
)
315 fwtty_dbg(port
, "status: %x delta: %x", status
, delta
);
317 if (delta
& TIOCM_CAR
) {
318 tty
= tty_port_tty_get(&port
->port
);
319 if (tty
&& !C_CLOCAL(tty
)) {
320 if (status
& TIOCM_CAR
)
321 wake_up_interruptible(&port
->port
.open_wait
);
323 schedule_work(&port
->hangup
);
328 if (delta
& TIOCM_CTS
) {
329 tty
= tty_port_tty_get(&port
->port
);
330 if (tty
&& C_CRTSCTS(tty
)) {
331 if (tty
->hw_stopped
) {
332 if (status
& TIOCM_CTS
) {
335 __fwtty_restart_tx(port
);
337 fwtty_restart_tx(port
);
340 if (~status
& TIOCM_CTS
)
346 } else if (delta
& OOB_TX_THROTTLE
) {
347 tty
= tty_port_tty_get(&port
->port
);
349 if (tty
->hw_stopped
) {
350 if (~status
& OOB_TX_THROTTLE
) {
353 __fwtty_restart_tx(port
);
355 fwtty_restart_tx(port
);
358 if (status
& OOB_TX_THROTTLE
)
365 if (delta
& (UART_LSR_BI
<< 24)) {
366 if (status
& (UART_LSR_BI
<< 24)) {
367 port
->break_last
= jiffies
;
368 schedule_delayed_work(&port
->emit_breaks
, 0);
370 /* run emit_breaks one last time (if pending) */
371 mod_delayed_work(system_wq
, &port
->emit_breaks
, 0);
375 if (delta
& (TIOCM_DSR
| TIOCM_CAR
| TIOCM_CTS
| TIOCM_RNG
))
376 wake_up_interruptible(&port
->port
.delta_msr_wait
);
380 * __fwtty_port_line_status - generate 'line status' for indicated port
382 * This function returns a remote 'MSR' state based on the local 'MCR' state,
383 * as if a null modem cable was attached. The actual status is a mangling
384 * of TIOCM_* bits suitable for sending to a peer's status_addr.
386 * Note: caller must be holding port lock
388 static unsigned __fwtty_port_line_status(struct fwtty_port
*port
)
392 /* TODO: add module param to tie RNG to DTR as well */
394 if (port
->mctrl
& TIOCM_DTR
)
395 status
|= TIOCM_DSR
| TIOCM_CAR
;
396 if (port
->mctrl
& TIOCM_RTS
)
398 if (port
->mctrl
& OOB_RX_THROTTLE
)
399 status
|= OOB_TX_THROTTLE
;
400 /* emulate BRK as add'l line status */
402 status
|= UART_LSR_BI
<< 24;
408 * __fwtty_write_port_status - send the port line status to peer
410 * Note: caller must be holding the port lock.
412 static int __fwtty_write_port_status(struct fwtty_port
*port
)
414 struct fwtty_peer
*peer
;
416 unsigned status
= __fwtty_port_line_status(port
);
419 peer
= rcu_dereference(port
->peer
);
421 err
= fwtty_send_data_async(peer
, TCODE_WRITE_QUADLET_REQUEST
,
422 peer
->status_addr
, &status
,
423 sizeof(status
), NULL
, port
);
431 * fwtty_write_port_status - same as above but locked by port lock
433 static int fwtty_write_port_status(struct fwtty_port
*port
)
437 spin_lock_bh(&port
->lock
);
438 err
= __fwtty_write_port_status(port
);
439 spin_unlock_bh(&port
->lock
);
443 static void __fwtty_throttle(struct fwtty_port
*port
, struct tty_struct
*tty
)
448 port
->mctrl
|= OOB_RX_THROTTLE
;
450 port
->mctrl
&= ~TIOCM_RTS
;
451 if (~old
& OOB_RX_THROTTLE
)
452 __fwtty_write_port_status(port
);
456 * fwtty_do_hangup - wait for ldisc to deliver all pending rx; only then hangup
458 * When the remote has finished tx, and all in-flight rx has been received and
459 * and pushed to the flip buffer, the remote may close its device. This will
460 * drop DTR on the remote which will drop carrier here. Typically, the tty is
461 * hung up when carrier is dropped or lost.
463 * However, there is a race between the hang up and the line discipline
464 * delivering its data to the reader. A hangup will cause the ldisc to flush
465 * (ie., clear) the read buffer and flip buffer. Because of firewire's
466 * relatively high throughput, the ldisc frequently lags well behind the driver,
467 * resulting in lost data (which has already been received and written to
468 * the flip buffer) when the remote closes its end.
470 * Unfortunately, since the flip buffer offers no direct method for determining
471 * if it holds data, ensuring the ldisc has delivered all data is problematic.
474 /* FIXME: drop this workaround when __tty_hangup waits for ldisc completion */
475 static void fwtty_do_hangup(struct work_struct
*work
)
477 struct fwtty_port
*port
= to_port(work
, hangup
);
478 struct tty_struct
*tty
;
480 schedule_timeout_uninterruptible(msecs_to_jiffies(50));
482 tty
= tty_port_tty_get(&port
->port
);
489 static void fwtty_emit_breaks(struct work_struct
*work
)
491 struct fwtty_port
*port
= to_port(to_delayed_work(work
), emit_breaks
);
492 struct tty_struct
*tty
;
493 static const char buf
[16];
494 unsigned long now
= jiffies
;
495 unsigned long elapsed
= now
- port
->break_last
;
496 int n
, t
, c
, brk
= 0;
498 tty
= tty_port_tty_get(&port
->port
);
502 /* generate breaks at the line rate (but at least 1) */
503 n
= (elapsed
* port
->cps
) / HZ
+ 1;
504 port
->break_last
= now
;
506 fwtty_dbg(port
, "sending %d brks", n
);
510 c
= tty_insert_flip_string_fixed_flag(tty
, buf
, TTY_BREAK
, t
);
516 tty_flip_buffer_push(tty
);
520 if (port
->mstatus
& (UART_LSR_BI
<< 24))
521 schedule_delayed_work(&port
->emit_breaks
, FREQ_BREAKS
);
522 port
->icount
.brk
+= brk
;
525 static void fwtty_pushrx(struct work_struct
*work
)
527 struct fwtty_port
*port
= to_port(work
, push
);
528 struct tty_struct
*tty
;
529 struct buffered_rx
*buf
, *next
;
532 tty
= tty_port_tty_get(&port
->port
);
536 spin_lock_bh(&port
->lock
);
537 list_for_each_entry_safe(buf
, next
, &port
->buf_list
, list
) {
538 n
= tty_insert_flip_string_fixed_flag(tty
, buf
->data
,
544 memmove(buf
->data
, buf
->data
+ n
, buf
->n
- n
);
547 __fwtty_throttle(port
, tty
);
550 list_del(&buf
->list
);
555 tty_flip_buffer_push(tty
);
557 if (list_empty(&port
->buf_list
))
558 clear_bit(BUFFERING_RX
, &port
->flags
);
559 spin_unlock_bh(&port
->lock
);
564 static int fwtty_buffer_rx(struct fwtty_port
*port
, unsigned char *d
, size_t n
)
566 struct buffered_rx
*buf
;
567 size_t size
= (n
+ sizeof(struct buffered_rx
) + 0xFF) & ~0xFF;
569 if (port
->buffered
+ n
> HIGH_WATERMARK
)
571 buf
= kmalloc(size
, GFP_ATOMIC
);
574 INIT_LIST_HEAD(&buf
->list
);
576 memcpy(buf
->data
, d
, n
);
578 spin_lock_bh(&port
->lock
);
579 list_add_tail(&buf
->list
, &port
->buf_list
);
581 if (port
->buffered
> port
->stats
.watermark
)
582 port
->stats
.watermark
= port
->buffered
;
583 set_bit(BUFFERING_RX
, &port
->flags
);
584 spin_unlock_bh(&port
->lock
);
589 static int fwtty_rx(struct fwtty_port
*port
, unsigned char *data
, size_t len
)
591 struct tty_struct
*tty
;
596 tty
= tty_port_tty_get(&port
->port
);
600 fwtty_dbg(port
, "%d", n
);
601 profile_size_distrib(port
->stats
.reads
, n
);
603 if (port
->write_only
) {
608 /* disregard break status; breaks are generated by emit_breaks work */
609 lsr
= (port
->mstatus
>> 24) & ~UART_LSR_BI
;
614 if (lsr
& UART_LSR_OE
)
615 ++port
->icount
.overrun
;
617 lsr
&= port
->status_mask
;
618 if (lsr
& ~port
->ignore_mask
& UART_LSR_OE
) {
619 if (!tty_insert_flip_char(tty
, 0, TTY_OVERRUN
)) {
624 port
->overrun
= false;
626 if (lsr
& port
->ignore_mask
& ~UART_LSR_OE
) {
627 /* TODO: don't drop SAK and Magic SysRq here */
632 if (!test_bit(BUFFERING_RX
, &port
->flags
)) {
633 c
= tty_insert_flip_string_fixed_flag(tty
, data
, TTY_NORMAL
, n
);
635 tty_flip_buffer_push(tty
);
639 /* start buffering and throttling */
640 n
-= fwtty_buffer_rx(port
, &data
[c
], n
);
642 spin_lock_bh(&port
->lock
);
643 __fwtty_throttle(port
, tty
);
644 spin_unlock_bh(&port
->lock
);
647 n
-= fwtty_buffer_rx(port
, data
, n
);
650 port
->overrun
= true;
657 port
->icount
.rx
+= len
;
658 port
->stats
.lost
+= n
;
663 * fwtty_port_handler - bus address handler for port reads/writes
664 * @parameters: fw_address_callback_t as specified by firewire core interface
666 * This handler is responsible for handling inbound read/write dma from remotes.
668 static void fwtty_port_handler(struct fw_card
*card
,
669 struct fw_request
*request
,
670 int tcode
, int destination
, int source
,
672 unsigned long long addr
,
673 void *data
, size_t len
,
676 struct fwtty_port
*port
= callback_data
;
677 struct fwtty_peer
*peer
;
681 /* Only accept rx from the peer virtual-cabled to this port */
683 peer
= __fwserial_peer_by_node_id(card
, generation
, source
);
685 if (!peer
|| peer
!= rcu_access_pointer(port
->peer
)) {
686 rcode
= RCODE_ADDRESS_ERROR
;
687 fwtty_err_ratelimited(port
, "ignoring unauthenticated data");
692 case TCODE_WRITE_QUADLET_REQUEST
:
693 if (addr
!= port
->rx_handler
.offset
|| len
!= 4)
694 rcode
= RCODE_ADDRESS_ERROR
;
696 fwtty_update_port_status(port
, *(unsigned *)data
);
697 rcode
= RCODE_COMPLETE
;
701 case TCODE_WRITE_BLOCK_REQUEST
:
702 if (addr
!= port
->rx_handler
.offset
+ 4 ||
703 len
> port
->rx_handler
.length
- 4) {
704 rcode
= RCODE_ADDRESS_ERROR
;
706 err
= fwtty_rx(port
, data
, len
);
709 rcode
= RCODE_COMPLETE
;
712 rcode
= RCODE_DATA_ERROR
;
715 rcode
= RCODE_CONFLICT_ERROR
;
722 rcode
= RCODE_TYPE_ERROR
;
726 fw_send_response(card
, request
, rcode
);
730 * fwtty_tx_complete - callback for tx dma
731 * @data: ignored, has no meaning for write txns
732 * @length: ignored, has no meaning for write txns
734 * The writer must be woken here if the fifo has been emptied because it
735 * may have slept if chars_in_buffer was != 0
737 static void fwtty_tx_complete(struct fw_card
*card
, int rcode
,
738 void *data
, size_t length
,
739 struct fwtty_transaction
*txn
)
741 struct fwtty_port
*port
= txn
->port
;
742 struct tty_struct
*tty
;
745 fwtty_dbg(port
, "rcode: %d", rcode
);
749 spin_lock_bh(&port
->lock
);
750 dma_fifo_out_complete(&port
->tx_fifo
, &txn
->dma_pended
);
751 len
= dma_fifo_level(&port
->tx_fifo
);
752 spin_unlock_bh(&port
->lock
);
754 port
->icount
.tx
+= txn
->dma_pended
.len
;
758 /* TODO: implement retries */
759 spin_lock_bh(&port
->lock
);
760 dma_fifo_out_complete(&port
->tx_fifo
, &txn
->dma_pended
);
761 len
= dma_fifo_level(&port
->tx_fifo
);
762 spin_unlock_bh(&port
->lock
);
764 port
->stats
.dropped
+= txn
->dma_pended
.len
;
767 if (len
< WAKEUP_CHARS
) {
768 tty
= tty_port_tty_get(&port
->port
);
776 static int fwtty_tx(struct fwtty_port
*port
, bool drain
)
778 struct fwtty_peer
*peer
;
779 struct fwtty_transaction
*txn
;
780 struct tty_struct
*tty
;
783 tty
= tty_port_tty_get(&port
->port
);
788 peer
= rcu_dereference(port
->peer
);
794 if (test_and_set_bit(IN_TX
, &port
->flags
)) {
799 /* try to write as many dma transactions out as possible */
801 while (!tty
->stopped
&& !tty
->hw_stopped
&&
802 !test_bit(STOP_TX
, &port
->flags
)) {
803 txn
= kmem_cache_alloc(fwtty_txn_cache
, GFP_ATOMIC
);
809 spin_lock_bh(&port
->lock
);
810 n
= dma_fifo_out_pend(&port
->tx_fifo
, &txn
->dma_pended
);
811 spin_unlock_bh(&port
->lock
);
813 fwtty_dbg(port
, "out: %u rem: %d", txn
->dma_pended
.len
, n
);
816 kmem_cache_free(fwtty_txn_cache
, txn
);
818 ++port
->stats
.tx_stall
;
819 else if (n
== -ENODATA
)
820 profile_size_distrib(port
->stats
.txns
, 0);
822 ++port
->stats
.fifo_errs
;
823 fwtty_err_ratelimited(port
, "fifo err: %d", n
);
828 profile_size_distrib(port
->stats
.txns
, txn
->dma_pended
.len
);
830 fwtty_send_txn_async(peer
, txn
, TCODE_WRITE_BLOCK_REQUEST
,
831 peer
->fifo_addr
, txn
->dma_pended
.data
,
832 txn
->dma_pended
.len
, fwtty_tx_complete
,
837 * Stop tx if the 'last view' of the fifo is empty or if
838 * this is the writer and there's not enough data to bother
840 if (n
== 0 || (!drain
&& n
< WRITER_MINIMUM
))
844 if (n
>= 0 || n
== -EAGAIN
|| n
== -ENOMEM
|| n
== -ENODATA
) {
845 spin_lock_bh(&port
->lock
);
846 len
= dma_fifo_out_level(&port
->tx_fifo
);
848 unsigned long delay
= (n
== -ENOMEM
) ? HZ
: 1;
849 schedule_delayed_work(&port
->drain
, delay
);
851 len
= dma_fifo_level(&port
->tx_fifo
);
852 spin_unlock_bh(&port
->lock
);
854 /* wakeup the writer */
855 if (drain
&& len
< WAKEUP_CHARS
)
859 clear_bit(IN_TX
, &port
->flags
);
860 wake_up_interruptible(&port
->wait_tx
);
868 static void fwtty_drain_tx(struct work_struct
*work
)
870 struct fwtty_port
*port
= to_port(to_delayed_work(work
), drain
);
872 fwtty_tx(port
, true);
875 static void fwtty_write_xchar(struct fwtty_port
*port
, char ch
)
877 struct fwtty_peer
*peer
;
879 ++port
->stats
.xchars
;
881 fwtty_dbg(port
, "%02x", ch
);
884 peer
= rcu_dereference(port
->peer
);
886 fwtty_send_data_async(peer
, TCODE_WRITE_BLOCK_REQUEST
,
887 peer
->fifo_addr
, &ch
, sizeof(ch
),
893 struct fwtty_port
*fwtty_port_get(unsigned index
)
895 struct fwtty_port
*port
;
897 if (index
>= MAX_TOTAL_PORTS
)
900 mutex_lock(&port_table_lock
);
901 port
= port_table
[index
];
903 kref_get(&port
->serial
->kref
);
904 mutex_unlock(&port_table_lock
);
907 EXPORT_SYMBOL(fwtty_port_get
);
909 static int fwtty_ports_add(struct fw_serial
*serial
)
914 if (port_table_corrupt
)
917 mutex_lock(&port_table_lock
);
918 for (i
= 0; i
+ num_ports
<= MAX_TOTAL_PORTS
; i
+= num_ports
) {
919 if (!port_table
[i
]) {
920 for (j
= 0; j
< num_ports
; ++i
, ++j
) {
921 serial
->ports
[j
]->index
= i
;
922 port_table
[i
] = serial
->ports
[j
];
928 mutex_unlock(&port_table_lock
);
932 static void fwserial_destroy(struct kref
*kref
)
934 struct fw_serial
*serial
= to_serial(kref
, kref
);
935 struct fwtty_port
**ports
= serial
->ports
;
936 int j
, i
= ports
[0]->index
;
940 mutex_lock(&port_table_lock
);
941 for (j
= 0; j
< num_ports
; ++i
, ++j
) {
942 port_table_corrupt
|= port_table
[i
] != ports
[j
];
943 WARN_ONCE(port_table_corrupt
, "port_table[%d]: %p != ports[%d]: %p",
944 i
, port_table
[i
], j
, ports
[j
]);
946 port_table
[i
] = NULL
;
948 mutex_unlock(&port_table_lock
);
950 for (j
= 0; j
< num_ports
; ++j
) {
951 fw_core_remove_address_handler(&ports
[j
]->rx_handler
);
952 tty_port_destroy(&ports
[j
]->port
);
958 void fwtty_port_put(struct fwtty_port
*port
)
960 kref_put(&port
->serial
->kref
, fwserial_destroy
);
962 EXPORT_SYMBOL(fwtty_port_put
);
964 static void fwtty_port_dtr_rts(struct tty_port
*tty_port
, int on
)
966 struct fwtty_port
*port
= to_port(tty_port
, port
);
968 fwtty_dbg(port
, "on/off: %d", on
);
970 spin_lock_bh(&port
->lock
);
971 /* Don't change carrier state if this is a console */
972 if (!port
->port
.console
) {
974 port
->mctrl
|= TIOCM_DTR
| TIOCM_RTS
;
976 port
->mctrl
&= ~(TIOCM_DTR
| TIOCM_RTS
);
979 __fwtty_write_port_status(port
);
980 spin_unlock_bh(&port
->lock
);
984 * fwtty_port_carrier_raised: required tty_port operation
986 * This port operation is polled after a tty has been opened and is waiting for
987 * carrier detect -- see drivers/tty/tty_port:tty_port_block_til_ready().
989 static int fwtty_port_carrier_raised(struct tty_port
*tty_port
)
991 struct fwtty_port
*port
= to_port(tty_port
, port
);
994 rc
= (port
->mstatus
& TIOCM_CAR
);
996 fwtty_dbg(port
, "%d", rc
);
1001 static unsigned set_termios(struct fwtty_port
*port
, struct tty_struct
*tty
)
1003 unsigned baud
, frame
;
1005 baud
= tty_termios_baud_rate(&tty
->termios
);
1006 tty_termios_encode_baud_rate(&tty
->termios
, baud
, baud
);
1008 /* compute bit count of 2 frames */
1009 frame
= 12 + ((C_CSTOPB(tty
)) ? 4 : 2) + ((C_PARENB(tty
)) ? 2 : 0);
1011 switch (C_CSIZE(tty
)) {
1013 frame
-= (C_CSTOPB(tty
)) ? 1 : 0;
1026 port
->cps
= (baud
<< 1) / frame
;
1028 port
->status_mask
= UART_LSR_OE
;
1029 if (_I_FLAG(tty
, BRKINT
| PARMRK
))
1030 port
->status_mask
|= UART_LSR_BI
;
1032 port
->ignore_mask
= 0;
1033 if (I_IGNBRK(tty
)) {
1034 port
->ignore_mask
|= UART_LSR_BI
;
1036 port
->ignore_mask
|= UART_LSR_OE
;
1039 port
->write_only
= !C_CREAD(tty
);
1041 /* turn off echo and newline xlat if loopback */
1042 if (port
->loopback
) {
1043 tty
->termios
.c_lflag
&= ~(ECHO
| ECHOE
| ECHOK
| ECHOKE
|
1044 ECHONL
| ECHOPRT
| ECHOCTL
);
1045 tty
->termios
.c_oflag
&= ~ONLCR
;
1051 static int fwtty_port_activate(struct tty_port
*tty_port
,
1052 struct tty_struct
*tty
)
1054 struct fwtty_port
*port
= to_port(tty_port
, port
);
1058 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1060 err
= dma_fifo_alloc(&port
->tx_fifo
, FWTTY_PORT_TXFIFO_LEN
,
1063 FWTTY_PORT_MAX_PEND_DMA
,
1068 spin_lock_bh(&port
->lock
);
1070 baud
= set_termios(port
, tty
);
1072 /* if console, don't change carrier state */
1073 if (!port
->port
.console
) {
1076 port
->mctrl
= TIOCM_DTR
| TIOCM_RTS
;
1079 if (C_CRTSCTS(tty
) && ~port
->mstatus
& TIOCM_CTS
)
1080 tty
->hw_stopped
= 1;
1082 __fwtty_write_port_status(port
);
1083 spin_unlock_bh(&port
->lock
);
1085 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
1091 * fwtty_port_shutdown
1093 * Note: the tty port core ensures this is not the console and
1094 * manages TTY_IO_ERROR properly
1096 static void fwtty_port_shutdown(struct tty_port
*tty_port
)
1098 struct fwtty_port
*port
= to_port(tty_port
, port
);
1099 struct buffered_rx
*buf
, *next
;
1101 /* TODO: cancel outstanding transactions */
1103 cancel_delayed_work_sync(&port
->emit_breaks
);
1104 cancel_delayed_work_sync(&port
->drain
);
1105 cancel_work_sync(&port
->push
);
1107 spin_lock_bh(&port
->lock
);
1108 list_for_each_entry_safe(buf
, next
, &port
->buf_list
, list
) {
1109 list_del(&buf
->list
);
1114 port
->break_ctl
= 0;
1116 __fwtty_write_port_status(port
);
1117 dma_fifo_free(&port
->tx_fifo
);
1118 spin_unlock_bh(&port
->lock
);
1121 static int fwtty_open(struct tty_struct
*tty
, struct file
*fp
)
1123 struct fwtty_port
*port
= tty
->driver_data
;
1125 return tty_port_open(&port
->port
, tty
, fp
);
1128 static void fwtty_close(struct tty_struct
*tty
, struct file
*fp
)
1130 struct fwtty_port
*port
= tty
->driver_data
;
1132 tty_port_close(&port
->port
, tty
, fp
);
1135 static void fwtty_hangup(struct tty_struct
*tty
)
1137 struct fwtty_port
*port
= tty
->driver_data
;
1139 tty_port_hangup(&port
->port
);
1142 static void fwtty_cleanup(struct tty_struct
*tty
)
1144 struct fwtty_port
*port
= tty
->driver_data
;
1146 tty
->driver_data
= NULL
;
1147 fwtty_port_put(port
);
1150 static int fwtty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1152 struct fwtty_port
*port
= fwtty_port_get(tty
->index
);
1155 err
= tty_standard_install(driver
, tty
);
1157 tty
->driver_data
= port
;
1159 fwtty_port_put(port
);
1163 static int fwtty_write(struct tty_struct
*tty
, const unsigned char *buf
, int c
)
1165 struct fwtty_port
*port
= tty
->driver_data
;
1168 fwtty_dbg(port
, "%d", c
);
1169 profile_size_distrib(port
->stats
.writes
, c
);
1171 spin_lock_bh(&port
->lock
);
1172 n
= dma_fifo_in(&port
->tx_fifo
, buf
, c
);
1173 len
= dma_fifo_out_level(&port
->tx_fifo
);
1174 if (len
< DRAIN_THRESHOLD
)
1175 schedule_delayed_work(&port
->drain
, 1);
1176 spin_unlock_bh(&port
->lock
);
1178 if (len
>= DRAIN_THRESHOLD
)
1179 fwtty_tx(port
, false);
1181 debug_short_write(port
, c
, n
);
1183 return (n
< 0) ? 0 : n
;
1186 static int fwtty_write_room(struct tty_struct
*tty
)
1188 struct fwtty_port
*port
= tty
->driver_data
;
1191 spin_lock_bh(&port
->lock
);
1192 n
= dma_fifo_avail(&port
->tx_fifo
);
1193 spin_unlock_bh(&port
->lock
);
1195 fwtty_dbg(port
, "%d", n
);
1200 static int fwtty_chars_in_buffer(struct tty_struct
*tty
)
1202 struct fwtty_port
*port
= tty
->driver_data
;
1205 spin_lock_bh(&port
->lock
);
1206 n
= dma_fifo_level(&port
->tx_fifo
);
1207 spin_unlock_bh(&port
->lock
);
1209 fwtty_dbg(port
, "%d", n
);
1214 static void fwtty_send_xchar(struct tty_struct
*tty
, char ch
)
1216 struct fwtty_port
*port
= tty
->driver_data
;
1218 fwtty_dbg(port
, "%02x", ch
);
1220 fwtty_write_xchar(port
, ch
);
1223 static void fwtty_throttle(struct tty_struct
*tty
)
1225 struct fwtty_port
*port
= tty
->driver_data
;
1228 * Ignore throttling (but not unthrottling).
1229 * It only makes sense to throttle when data will no longer be
1230 * accepted by the tty flip buffer. For example, it is
1231 * possible for received data to overflow the tty buffer long
1232 * before the line discipline ever has a chance to throttle the driver.
1233 * Additionally, the driver may have already completed the I/O
1234 * but the tty buffer is still emptying, so the line discipline is
1235 * throttling and unthrottling nothing.
1238 ++port
->stats
.throttled
;
1241 static void fwtty_unthrottle(struct tty_struct
*tty
)
1243 struct fwtty_port
*port
= tty
->driver_data
;
1245 fwtty_dbg(port
, "CRTSCTS: %d", (C_CRTSCTS(tty
) != 0));
1247 profile_fifo_avail(port
, port
->stats
.unthrottle
);
1249 schedule_work(&port
->push
);
1251 spin_lock_bh(&port
->lock
);
1252 port
->mctrl
&= ~OOB_RX_THROTTLE
;
1254 port
->mctrl
|= TIOCM_RTS
;
1255 __fwtty_write_port_status(port
);
1256 spin_unlock_bh(&port
->lock
);
1259 static int check_msr_delta(struct fwtty_port
*port
, unsigned long mask
,
1260 struct async_icount
*prev
)
1262 struct async_icount now
;
1267 delta
= ((mask
& TIOCM_RNG
&& prev
->rng
!= now
.rng
) ||
1268 (mask
& TIOCM_DSR
&& prev
->dsr
!= now
.dsr
) ||
1269 (mask
& TIOCM_CAR
&& prev
->dcd
!= now
.dcd
) ||
1270 (mask
& TIOCM_CTS
&& prev
->cts
!= now
.cts
));
1277 static int wait_msr_change(struct fwtty_port
*port
, unsigned long mask
)
1279 struct async_icount prev
;
1281 prev
= port
->icount
;
1283 return wait_event_interruptible(port
->port
.delta_msr_wait
,
1284 check_msr_delta(port
, mask
, &prev
));
1287 static int get_serial_info(struct fwtty_port
*port
,
1288 struct serial_struct __user
*info
)
1290 struct serial_struct tmp
;
1292 memset(&tmp
, 0, sizeof(tmp
));
1294 tmp
.type
= PORT_UNKNOWN
;
1295 tmp
.line
= port
->port
.tty
->index
;
1296 tmp
.flags
= port
->port
.flags
;
1297 tmp
.xmit_fifo_size
= FWTTY_PORT_TXFIFO_LEN
;
1298 tmp
.baud_base
= 400000000;
1299 tmp
.close_delay
= port
->port
.close_delay
;
1301 return (copy_to_user(info
, &tmp
, sizeof(*info
))) ? -EFAULT
: 0;
1304 static int set_serial_info(struct fwtty_port
*port
,
1305 struct serial_struct __user
*info
)
1307 struct serial_struct tmp
;
1309 if (copy_from_user(&tmp
, info
, sizeof(tmp
)))
1312 if (tmp
.irq
!= 0 || tmp
.port
!= 0 || tmp
.custom_divisor
!= 0 ||
1313 tmp
.baud_base
!= 400000000)
1316 if (!capable(CAP_SYS_ADMIN
)) {
1317 if (((tmp
.flags
& ~ASYNC_USR_MASK
) !=
1318 (port
->port
.flags
& ~ASYNC_USR_MASK
)))
1321 port
->port
.close_delay
= tmp
.close_delay
* HZ
/ 100;
1326 static int fwtty_ioctl(struct tty_struct
*tty
, unsigned cmd
,
1329 struct fwtty_port
*port
= tty
->driver_data
;
1334 mutex_lock(&port
->port
.mutex
);
1335 err
= get_serial_info(port
, (void __user
*)arg
);
1336 mutex_unlock(&port
->port
.mutex
);
1340 mutex_lock(&port
->port
.mutex
);
1341 err
= set_serial_info(port
, (void __user
*)arg
);
1342 mutex_unlock(&port
->port
.mutex
);
1346 err
= wait_msr_change(port
, arg
);
1356 static void fwtty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1358 struct fwtty_port
*port
= tty
->driver_data
;
1361 spin_lock_bh(&port
->lock
);
1362 baud
= set_termios(port
, tty
);
1364 if ((baud
== 0) && (old
->c_cflag
& CBAUD
))
1365 port
->mctrl
&= ~(TIOCM_DTR
| TIOCM_RTS
);
1366 else if ((baud
!= 0) && !(old
->c_cflag
& CBAUD
)) {
1367 if (C_CRTSCTS(tty
) || !test_bit(TTY_THROTTLED
, &tty
->flags
))
1368 port
->mctrl
|= TIOCM_DTR
| TIOCM_RTS
;
1370 port
->mctrl
|= TIOCM_DTR
;
1372 __fwtty_write_port_status(port
);
1373 spin_unlock_bh(&port
->lock
);
1375 if (old
->c_cflag
& CRTSCTS
) {
1376 if (!C_CRTSCTS(tty
)) {
1377 tty
->hw_stopped
= 0;
1378 fwtty_restart_tx(port
);
1380 } else if (C_CRTSCTS(tty
) && ~port
->mstatus
& TIOCM_CTS
) {
1381 tty
->hw_stopped
= 1;
1386 * fwtty_break_ctl - start/stop sending breaks
1388 * Signals the remote to start or stop generating simulated breaks.
1389 * First, stop dequeueing from the fifo and wait for writer/drain to leave tx
1390 * before signalling the break line status. This guarantees any pending rx will
1391 * be queued to the line discipline before break is simulated on the remote.
1392 * Conversely, turning off break_ctl requires signalling the line status change,
1395 static int fwtty_break_ctl(struct tty_struct
*tty
, int state
)
1397 struct fwtty_port
*port
= tty
->driver_data
;
1400 fwtty_dbg(port
, "%d", state
);
1403 set_bit(STOP_TX
, &port
->flags
);
1404 ret
= wait_event_interruptible_timeout(port
->wait_tx
,
1405 !test_bit(IN_TX
, &port
->flags
),
1407 if (ret
== 0 || ret
== -ERESTARTSYS
) {
1408 clear_bit(STOP_TX
, &port
->flags
);
1409 fwtty_restart_tx(port
);
1414 spin_lock_bh(&port
->lock
);
1415 port
->break_ctl
= (state
== -1);
1416 __fwtty_write_port_status(port
);
1417 spin_unlock_bh(&port
->lock
);
1420 spin_lock_bh(&port
->lock
);
1421 dma_fifo_reset(&port
->tx_fifo
);
1422 clear_bit(STOP_TX
, &port
->flags
);
1423 spin_unlock_bh(&port
->lock
);
1428 static int fwtty_tiocmget(struct tty_struct
*tty
)
1430 struct fwtty_port
*port
= tty
->driver_data
;
1433 spin_lock_bh(&port
->lock
);
1434 tiocm
= (port
->mctrl
& MCTRL_MASK
) | (port
->mstatus
& ~MCTRL_MASK
);
1435 spin_unlock_bh(&port
->lock
);
1437 fwtty_dbg(port
, "%x", tiocm
);
1442 static int fwtty_tiocmset(struct tty_struct
*tty
, unsigned set
, unsigned clear
)
1444 struct fwtty_port
*port
= tty
->driver_data
;
1446 fwtty_dbg(port
, "set: %x clear: %x", set
, clear
);
1448 /* TODO: simulate loopback if TIOCM_LOOP set */
1450 spin_lock_bh(&port
->lock
);
1451 port
->mctrl
&= ~(clear
& MCTRL_MASK
& 0xffff);
1452 port
->mctrl
|= set
& MCTRL_MASK
& 0xffff;
1453 __fwtty_write_port_status(port
);
1454 spin_unlock_bh(&port
->lock
);
1458 static int fwtty_get_icount(struct tty_struct
*tty
,
1459 struct serial_icounter_struct
*icount
)
1461 struct fwtty_port
*port
= tty
->driver_data
;
1464 memcpy(&stats
, &port
->stats
, sizeof(stats
));
1465 if (port
->port
.console
)
1466 (*port
->fwcon_ops
->stats
)(&stats
, port
->con_data
);
1468 icount
->cts
= port
->icount
.cts
;
1469 icount
->dsr
= port
->icount
.dsr
;
1470 icount
->rng
= port
->icount
.rng
;
1471 icount
->dcd
= port
->icount
.dcd
;
1472 icount
->rx
= port
->icount
.rx
;
1473 icount
->tx
= port
->icount
.tx
+ stats
.xchars
;
1474 icount
->frame
= port
->icount
.frame
;
1475 icount
->overrun
= port
->icount
.overrun
;
1476 icount
->parity
= port
->icount
.parity
;
1477 icount
->brk
= port
->icount
.brk
;
1478 icount
->buf_overrun
= port
->icount
.overrun
;
1482 static void fwtty_proc_show_port(struct seq_file
*m
, struct fwtty_port
*port
)
1486 memcpy(&stats
, &port
->stats
, sizeof(stats
));
1487 if (port
->port
.console
)
1488 (*port
->fwcon_ops
->stats
)(&stats
, port
->con_data
);
1490 seq_printf(m
, " tx:%d rx:%d", port
->icount
.tx
+ stats
.xchars
,
1492 seq_printf(m
, " cts:%d dsr:%d rng:%d dcd:%d", port
->icount
.cts
,
1493 port
->icount
.dsr
, port
->icount
.rng
, port
->icount
.dcd
);
1494 seq_printf(m
, " fe:%d oe:%d pe:%d brk:%d", port
->icount
.frame
,
1495 port
->icount
.overrun
, port
->icount
.parity
, port
->icount
.brk
);
1496 seq_printf(m
, " dr:%d st:%d err:%d lost:%d", stats
.dropped
,
1497 stats
.tx_stall
, stats
.fifo_errs
, stats
.lost
);
1498 seq_printf(m
, " pkts:%d thr:%d wtrmk:%d", stats
.sent
, stats
.throttled
,
1500 seq_printf(m
, " addr:%012llx", port
->rx_handler
.offset
);
1502 if (port
->port
.console
) {
1503 seq_printf(m
, "\n ");
1504 (*port
->fwcon_ops
->proc_show
)(m
, port
->con_data
);
1507 dump_profile(m
, &port
->stats
);
1510 static void fwtty_proc_show_peer(struct seq_file
*m
, struct fwtty_peer
*peer
)
1512 int generation
= peer
->generation
;
1515 seq_printf(m
, " %s:", dev_name(&peer
->unit
->device
));
1516 seq_printf(m
, " node:%04x gen:%d", peer
->node_id
, generation
);
1517 seq_printf(m
, " sp:%d max:%d guid:%016llx", peer
->speed
,
1518 peer
->max_payload
, (unsigned long long) peer
->guid
);
1520 if (capable(CAP_SYS_ADMIN
)) {
1521 seq_printf(m
, " mgmt:%012llx",
1522 (unsigned long long) peer
->mgmt_addr
);
1523 seq_printf(m
, " addr:%012llx",
1524 (unsigned long long) peer
->status_addr
);
1529 static int fwtty_proc_show(struct seq_file
*m
, void *v
)
1531 struct fwtty_port
*port
;
1532 struct fw_serial
*serial
;
1533 struct fwtty_peer
*peer
;
1536 seq_puts(m
, "fwserinfo: 1.0 driver: 1.0\n");
1537 for (i
= 0; i
< MAX_TOTAL_PORTS
&& (port
= fwtty_port_get(i
)); ++i
) {
1538 seq_printf(m
, "%2d:", i
);
1539 if (capable(CAP_SYS_ADMIN
))
1540 fwtty_proc_show_port(m
, port
);
1541 fwtty_port_put(port
);
1542 seq_printf(m
, "\n");
1547 list_for_each_entry_rcu(serial
, &fwserial_list
, list
) {
1548 seq_printf(m
, "card: %s guid: %016llx\n",
1549 dev_name(serial
->card
->device
),
1550 (unsigned long long) serial
->card
->guid
);
1551 list_for_each_entry_rcu(peer
, &serial
->peer_list
, list
)
1552 fwtty_proc_show_peer(m
, peer
);
1558 static int fwtty_proc_open(struct inode
*inode
, struct file
*fp
)
1560 return single_open(fp
, fwtty_proc_show
, NULL
);
1563 static const struct file_operations fwtty_proc_fops
= {
1564 .owner
= THIS_MODULE
,
1565 .open
= fwtty_proc_open
,
1567 .llseek
= seq_lseek
,
1568 .release
= single_release
,
1571 static const struct tty_port_operations fwtty_port_ops
= {
1572 .dtr_rts
= fwtty_port_dtr_rts
,
1573 .carrier_raised
= fwtty_port_carrier_raised
,
1574 .shutdown
= fwtty_port_shutdown
,
1575 .activate
= fwtty_port_activate
,
1578 static const struct tty_operations fwtty_ops
= {
1580 .close
= fwtty_close
,
1581 .hangup
= fwtty_hangup
,
1582 .cleanup
= fwtty_cleanup
,
1583 .install
= fwtty_install
,
1584 .write
= fwtty_write
,
1585 .write_room
= fwtty_write_room
,
1586 .chars_in_buffer
= fwtty_chars_in_buffer
,
1587 .send_xchar
= fwtty_send_xchar
,
1588 .throttle
= fwtty_throttle
,
1589 .unthrottle
= fwtty_unthrottle
,
1590 .ioctl
= fwtty_ioctl
,
1591 .set_termios
= fwtty_set_termios
,
1592 .break_ctl
= fwtty_break_ctl
,
1593 .tiocmget
= fwtty_tiocmget
,
1594 .tiocmset
= fwtty_tiocmset
,
1595 .get_icount
= fwtty_get_icount
,
1596 .proc_fops
= &fwtty_proc_fops
,
1599 static inline int mgmt_pkt_expected_len(__be16 code
)
1601 static const struct fwserial_mgmt_pkt pkt
;
1603 switch (be16_to_cpu(code
)) {
1604 case FWSC_VIRT_CABLE_PLUG
:
1605 return sizeof(pkt
.hdr
) + sizeof(pkt
.plug_req
);
1607 case FWSC_VIRT_CABLE_PLUG_RSP
: /* | FWSC_RSP_OK */
1608 return sizeof(pkt
.hdr
) + sizeof(pkt
.plug_rsp
);
1611 case FWSC_VIRT_CABLE_UNPLUG
:
1612 case FWSC_VIRT_CABLE_UNPLUG_RSP
:
1613 case FWSC_VIRT_CABLE_PLUG_RSP
| FWSC_RSP_NACK
:
1614 case FWSC_VIRT_CABLE_UNPLUG_RSP
| FWSC_RSP_NACK
:
1615 return sizeof(pkt
.hdr
);
1622 static inline void fill_plug_params(struct virt_plug_params
*params
,
1623 struct fwtty_port
*port
)
1625 u64 status_addr
= port
->rx_handler
.offset
;
1626 u64 fifo_addr
= port
->rx_handler
.offset
+ 4;
1627 size_t fifo_len
= port
->rx_handler
.length
- 4;
1629 params
->status_hi
= cpu_to_be32(status_addr
>> 32);
1630 params
->status_lo
= cpu_to_be32(status_addr
);
1631 params
->fifo_hi
= cpu_to_be32(fifo_addr
>> 32);
1632 params
->fifo_lo
= cpu_to_be32(fifo_addr
);
1633 params
->fifo_len
= cpu_to_be32(fifo_len
);
1636 static inline void fill_plug_req(struct fwserial_mgmt_pkt
*pkt
,
1637 struct fwtty_port
*port
)
1639 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_PLUG
);
1640 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1641 fill_plug_params(&pkt
->plug_req
, port
);
1644 static inline void fill_plug_rsp_ok(struct fwserial_mgmt_pkt
*pkt
,
1645 struct fwtty_port
*port
)
1647 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_PLUG_RSP
);
1648 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1649 fill_plug_params(&pkt
->plug_rsp
, port
);
1652 static inline void fill_plug_rsp_nack(struct fwserial_mgmt_pkt
*pkt
)
1654 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_PLUG_RSP
| FWSC_RSP_NACK
);
1655 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1658 static inline void fill_unplug_req(struct fwserial_mgmt_pkt
*pkt
)
1660 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG
);
1661 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1664 static inline void fill_unplug_rsp_nack(struct fwserial_mgmt_pkt
*pkt
)
1666 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG_RSP
| FWSC_RSP_NACK
);
1667 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1670 static inline void fill_unplug_rsp_ok(struct fwserial_mgmt_pkt
*pkt
)
1672 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG_RSP
);
1673 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1676 static void fwserial_virt_plug_complete(struct fwtty_peer
*peer
,
1677 struct virt_plug_params
*params
)
1679 struct fwtty_port
*port
= peer
->port
;
1681 peer
->status_addr
= be32_to_u64(params
->status_hi
, params
->status_lo
);
1682 peer
->fifo_addr
= be32_to_u64(params
->fifo_hi
, params
->fifo_lo
);
1683 peer
->fifo_len
= be32_to_cpu(params
->fifo_len
);
1684 peer_set_state(peer
, FWPS_ATTACHED
);
1686 /* reconfigure tx_fifo optimally for this peer */
1687 spin_lock_bh(&port
->lock
);
1688 port
->max_payload
= min3(peer
->max_payload
, peer
->fifo_len
,
1690 dma_fifo_change_tx_limit(&port
->tx_fifo
, port
->max_payload
);
1691 spin_unlock_bh(&peer
->port
->lock
);
1693 if (port
->port
.console
&& port
->fwcon_ops
->notify
!= NULL
)
1694 (*port
->fwcon_ops
->notify
)(FWCON_NOTIFY_ATTACH
, port
->con_data
);
1696 fwtty_info(&peer
->unit
, "peer (guid:%016llx) connected on %s",
1697 (unsigned long long)peer
->guid
, dev_name(port
->device
));
1700 static inline int fwserial_send_mgmt_sync(struct fwtty_peer
*peer
,
1701 struct fwserial_mgmt_pkt
*pkt
)
1704 int rcode
, tries
= 5;
1707 generation
= peer
->generation
;
1710 rcode
= fw_run_transaction(peer
->serial
->card
,
1711 TCODE_WRITE_BLOCK_REQUEST
,
1713 generation
, peer
->speed
,
1715 pkt
, be16_to_cpu(pkt
->hdr
.len
));
1716 if (rcode
== RCODE_BUSY
|| rcode
== RCODE_SEND_ERROR
||
1717 rcode
== RCODE_GENERATION
) {
1718 fwtty_dbg(&peer
->unit
, "mgmt write error: %d", rcode
);
1722 } while (--tries
> 0);
1727 * fwserial_claim_port - attempt to claim port @ index for peer
1729 * Returns ptr to claimed port or error code (as ERR_PTR())
1730 * Can sleep - must be called from process context
1732 static struct fwtty_port
*fwserial_claim_port(struct fwtty_peer
*peer
,
1735 struct fwtty_port
*port
;
1737 if (index
< 0 || index
>= num_ports
)
1738 return ERR_PTR(-EINVAL
);
1740 /* must guarantee that previous port releases have completed */
1743 port
= peer
->serial
->ports
[index
];
1744 spin_lock_bh(&port
->lock
);
1745 if (!rcu_access_pointer(port
->peer
))
1746 rcu_assign_pointer(port
->peer
, peer
);
1748 port
= ERR_PTR(-EBUSY
);
1749 spin_unlock_bh(&port
->lock
);
1755 * fwserial_find_port - find avail port and claim for peer
1757 * Returns ptr to claimed port or NULL if none avail
1758 * Can sleep - must be called from process context
1760 static struct fwtty_port
*fwserial_find_port(struct fwtty_peer
*peer
)
1762 struct fwtty_port
**ports
= peer
->serial
->ports
;
1765 /* must guarantee that previous port releases have completed */
1768 /* TODO: implement optional GUID-to-specific port # matching */
1770 /* find an unattached port (but not the loopback port, if present) */
1771 for (i
= 0; i
< num_ttys
; ++i
) {
1772 spin_lock_bh(&ports
[i
]->lock
);
1773 if (!ports
[i
]->peer
) {
1775 rcu_assign_pointer(ports
[i
]->peer
, peer
);
1776 spin_unlock_bh(&ports
[i
]->lock
);
1779 spin_unlock_bh(&ports
[i
]->lock
);
1784 static void fwserial_release_port(struct fwtty_port
*port
)
1786 /* drop carrier (and all other line status) */
1787 fwtty_update_port_status(port
, 0);
1789 spin_lock_bh(&port
->lock
);
1791 /* reset dma fifo max transmission size back to S100 */
1792 port
->max_payload
= link_speed_to_max_payload(SCODE_100
);
1793 dma_fifo_change_tx_limit(&port
->tx_fifo
, port
->max_payload
);
1795 rcu_assign_pointer(port
->peer
, NULL
);
1796 spin_unlock_bh(&port
->lock
);
1798 if (port
->port
.console
&& port
->fwcon_ops
->notify
!= NULL
)
1799 (*port
->fwcon_ops
->notify
)(FWCON_NOTIFY_DETACH
, port
->con_data
);
1802 static void fwserial_plug_timeout(unsigned long data
)
1804 struct fwtty_peer
*peer
= (struct fwtty_peer
*) data
;
1805 struct fwtty_port
*port
;
1807 spin_lock_bh(&peer
->lock
);
1808 if (peer
->state
!= FWPS_PLUG_PENDING
) {
1809 spin_unlock_bh(&peer
->lock
);
1813 port
= peer_revert_state(peer
);
1814 spin_unlock_bh(&peer
->lock
);
1817 fwserial_release_port(port
);
1821 * fwserial_connect_peer - initiate virtual cable with peer
1823 * Returns 0 if VIRT_CABLE_PLUG request was successfully sent,
1824 * otherwise error code. Must be called from process context.
1826 static int fwserial_connect_peer(struct fwtty_peer
*peer
)
1828 struct fwtty_port
*port
;
1829 struct fwserial_mgmt_pkt
*pkt
;
1832 pkt
= kmalloc(sizeof(*pkt
), GFP_KERNEL
);
1836 port
= fwserial_find_port(peer
);
1838 fwtty_err(&peer
->unit
, "avail ports in use");
1843 spin_lock_bh(&peer
->lock
);
1845 /* only initiate VIRT_CABLE_PLUG if peer is currently not attached */
1846 if (peer
->state
!= FWPS_NOT_ATTACHED
) {
1852 peer_set_state(peer
, FWPS_PLUG_PENDING
);
1854 fill_plug_req(pkt
, peer
->port
);
1856 setup_timer(&peer
->timer
, fwserial_plug_timeout
, (unsigned long)peer
);
1857 mod_timer(&peer
->timer
, jiffies
+ VIRT_CABLE_PLUG_TIMEOUT
);
1858 spin_unlock_bh(&peer
->lock
);
1860 rcode
= fwserial_send_mgmt_sync(peer
, pkt
);
1862 spin_lock_bh(&peer
->lock
);
1863 if (peer
->state
== FWPS_PLUG_PENDING
&& rcode
!= RCODE_COMPLETE
) {
1864 if (rcode
== RCODE_CONFLICT_ERROR
)
1870 spin_unlock_bh(&peer
->lock
);
1876 del_timer(&peer
->timer
);
1877 peer_revert_state(peer
);
1879 spin_unlock_bh(&peer
->lock
);
1880 fwserial_release_port(port
);
1887 * fwserial_close_port -
1888 * HUP the tty (if the tty exists) and unregister the tty device.
1889 * Only used by the unit driver upon unit removal to disconnect and
1890 * cleanup all attached ports
1892 * The port reference is put by fwtty_cleanup (if a reference was
1895 static void fwserial_close_port(struct fwtty_port
*port
)
1897 struct tty_struct
*tty
;
1899 mutex_lock(&port
->port
.mutex
);
1900 tty
= tty_port_tty_get(&port
->port
);
1905 mutex_unlock(&port
->port
.mutex
);
1907 tty_unregister_device(fwtty_driver
, port
->index
);
1911 * fwserial_lookup - finds first fw_serial associated with card
1912 * @card: fw_card to match
1914 * NB: caller must be holding fwserial_list_mutex
1916 static struct fw_serial
*fwserial_lookup(struct fw_card
*card
)
1918 struct fw_serial
*serial
;
1920 list_for_each_entry(serial
, &fwserial_list
, list
) {
1921 if (card
== serial
->card
)
1929 * __fwserial_lookup_rcu - finds first fw_serial associated with card
1930 * @card: fw_card to match
1932 * NB: caller must be inside rcu_read_lock() section
1934 static struct fw_serial
*__fwserial_lookup_rcu(struct fw_card
*card
)
1936 struct fw_serial
*serial
;
1938 list_for_each_entry_rcu(serial
, &fwserial_list
, list
) {
1939 if (card
== serial
->card
)
1947 * __fwserial_peer_by_node_id - finds a peer matching the given generation + id
1949 * If a matching peer could not be found for the specified generation/node id,
1950 * this could be because:
1951 * a) the generation has changed and one of the nodes hasn't updated yet
1952 * b) the remote node has created its remote unit device before this
1953 * local node has created its corresponding remote unit device
1954 * In either case, the remote node should retry
1956 * Note: caller must be in rcu_read_lock() section
1958 static struct fwtty_peer
*__fwserial_peer_by_node_id(struct fw_card
*card
,
1959 int generation
, int id
)
1961 struct fw_serial
*serial
;
1962 struct fwtty_peer
*peer
;
1964 serial
= __fwserial_lookup_rcu(card
);
1967 * Something is very wrong - there should be a matching
1968 * fw_serial structure for every fw_card. Maybe the remote node
1969 * has created its remote unit device before this driver has
1970 * been probed for any unit devices...
1972 fwtty_err(card
, "unknown card (guid %016llx)",
1973 (unsigned long long) card
->guid
);
1977 list_for_each_entry_rcu(peer
, &serial
->peer_list
, list
) {
1978 int g
= peer
->generation
;
1980 if (generation
== g
&& id
== peer
->node_id
)
1988 static void __dump_peer_list(struct fw_card
*card
)
1990 struct fw_serial
*serial
;
1991 struct fwtty_peer
*peer
;
1993 serial
= __fwserial_lookup_rcu(card
);
1997 list_for_each_entry_rcu(peer
, &serial
->peer_list
, list
) {
1998 int g
= peer
->generation
;
2000 fwtty_dbg(card
, "peer(%d:%x) guid: %016llx\n", g
,
2001 peer
->node_id
, (unsigned long long) peer
->guid
);
2005 #define __dump_peer_list(s)
2008 static void fwserial_auto_connect(struct work_struct
*work
)
2010 struct fwtty_peer
*peer
= to_peer(to_delayed_work(work
), connect
);
2013 err
= fwserial_connect_peer(peer
);
2014 if (err
== -EAGAIN
&& ++peer
->connect_retries
< MAX_CONNECT_RETRIES
)
2015 schedule_delayed_work(&peer
->connect
, CONNECT_RETRY_DELAY
);
2019 * fwserial_add_peer - add a newly probed 'serial' unit device as a 'peer'
2020 * @serial: aggregate representing the specific fw_card to add the peer to
2021 * @unit: 'peer' to create and add to peer_list of serial
2023 * Adds a 'peer' (ie, a local or remote 'serial' unit device) to the list of
2024 * peers for a specific fw_card. Optionally, auto-attach this peer to an
2025 * available tty port. This function is called either directly or indirectly
2026 * as a result of a 'serial' unit device being created & probed.
2028 * Note: this function is serialized with fwserial_remove_peer() by the
2029 * fwserial_list_mutex held in fwserial_probe().
2031 * A 1:1 correspondence between an fw_unit and an fwtty_peer is maintained
2032 * via the dev_set_drvdata() for the device of the fw_unit.
2034 static int fwserial_add_peer(struct fw_serial
*serial
, struct fw_unit
*unit
)
2036 struct device
*dev
= &unit
->device
;
2037 struct fw_device
*parent
= fw_parent_device(unit
);
2038 struct fwtty_peer
*peer
;
2039 struct fw_csr_iterator ci
;
2043 peer
= kzalloc(sizeof(*peer
), GFP_KERNEL
);
2047 peer_set_state(peer
, FWPS_NOT_ATTACHED
);
2049 dev_set_drvdata(dev
, peer
);
2051 peer
->guid
= (u64
)parent
->config_rom
[3] << 32 | parent
->config_rom
[4];
2052 peer
->speed
= parent
->max_speed
;
2053 peer
->max_payload
= min(device_max_receive(parent
),
2054 link_speed_to_max_payload(peer
->speed
));
2056 generation
= parent
->generation
;
2058 peer
->node_id
= parent
->node_id
;
2060 peer
->generation
= generation
;
2062 /* retrieve the mgmt bus addr from the unit directory */
2063 fw_csr_iterator_init(&ci
, unit
->directory
);
2064 while (fw_csr_iterator_next(&ci
, &key
, &val
)) {
2065 if (key
== (CSR_OFFSET
| CSR_DEPENDENT_INFO
)) {
2066 peer
->mgmt_addr
= CSR_REGISTER_BASE
+ 4 * val
;
2070 if (peer
->mgmt_addr
== 0ULL) {
2072 * No mgmt address effectively disables VIRT_CABLE_PLUG -
2073 * this peer will not be able to attach to a remote
2075 peer_set_state(peer
, FWPS_NO_MGMT_ADDR
);
2078 spin_lock_init(&peer
->lock
);
2081 init_timer(&peer
->timer
);
2082 INIT_WORK(&peer
->work
, NULL
);
2083 INIT_DELAYED_WORK(&peer
->connect
, fwserial_auto_connect
);
2085 /* associate peer with specific fw_card */
2086 peer
->serial
= serial
;
2087 list_add_rcu(&peer
->list
, &serial
->peer_list
);
2089 fwtty_info(&peer
->unit
, "peer added (guid:%016llx)",
2090 (unsigned long long)peer
->guid
);
2092 /* identify the local unit & virt cable to loopback port */
2093 if (parent
->is_local
) {
2094 serial
->self
= peer
;
2095 if (create_loop_dev
) {
2096 struct fwtty_port
*port
;
2097 port
= fwserial_claim_port(peer
, num_ttys
);
2098 if (!IS_ERR(port
)) {
2099 struct virt_plug_params params
;
2101 spin_lock_bh(&peer
->lock
);
2103 fill_plug_params(¶ms
, port
);
2104 fwserial_virt_plug_complete(peer
, ¶ms
);
2105 spin_unlock_bh(&peer
->lock
);
2107 fwtty_write_port_status(port
);
2111 } else if (auto_connect
) {
2112 /* auto-attach to remote units only (if policy allows) */
2113 schedule_delayed_work(&peer
->connect
, 1);
2120 * fwserial_remove_peer - remove a 'serial' unit device as a 'peer'
2122 * Remove a 'peer' from its list of peers. This function is only
2123 * called by fwserial_remove() on bus removal of the unit device.
2125 * Note: this function is serialized with fwserial_add_peer() by the
2126 * fwserial_list_mutex held in fwserial_remove().
2128 static void fwserial_remove_peer(struct fwtty_peer
*peer
)
2130 struct fwtty_port
*port
;
2132 spin_lock_bh(&peer
->lock
);
2133 peer_set_state(peer
, FWPS_GONE
);
2134 spin_unlock_bh(&peer
->lock
);
2136 cancel_delayed_work_sync(&peer
->connect
);
2137 cancel_work_sync(&peer
->work
);
2139 spin_lock_bh(&peer
->lock
);
2140 /* if this unit is the local unit, clear link */
2141 if (peer
== peer
->serial
->self
)
2142 peer
->serial
->self
= NULL
;
2144 /* cancel the request timeout timer (if running) */
2145 del_timer(&peer
->timer
);
2150 list_del_rcu(&peer
->list
);
2152 fwtty_info(&peer
->unit
, "peer removed (guid:%016llx)",
2153 (unsigned long long)peer
->guid
);
2155 spin_unlock_bh(&peer
->lock
);
2158 fwserial_release_port(port
);
2165 * create_loop_device - create a loopback tty device
2166 * @tty_driver: tty_driver to own loopback device
2167 * @prototype: ptr to already-assigned 'prototype' tty port
2168 * @index: index to associate this device with the tty port
2169 * @parent: device to child to
2171 * HACK - this is basically tty_port_register_device() with an
2172 * alternate naming scheme. Suggest tty_port_register_named_device()
2175 * Creates a loopback tty device named 'fwloop<n>' which is attached to
2176 * the local unit in fwserial_add_peer(). Note that <n> in the device
2177 * name advances in increments of port allocation blocks, ie., for port
2178 * indices 0..3, the device name will be 'fwloop0'; for 4..7, 'fwloop1',
2181 * Only one loopback device should be created per fw_card.
2183 static void release_loop_device(struct device
*dev
)
2188 static struct device
*create_loop_device(struct tty_driver
*driver
,
2189 struct fwtty_port
*prototype
,
2190 struct fwtty_port
*port
,
2191 struct device
*parent
)
2194 int index
= port
->index
;
2195 dev_t devt
= MKDEV(driver
->major
, driver
->minor_start
) + index
;
2196 struct device
*dev
= NULL
;
2199 if (index
>= fwtty_driver
->num
)
2200 return ERR_PTR(-EINVAL
);
2202 snprintf(name
, 64, "%s%d", loop_dev_name
, index
/ num_ports
);
2204 tty_port_link_device(&port
->port
, driver
, index
);
2206 cdev_init(&driver
->cdevs
[index
], driver
->cdevs
[prototype
->index
].ops
);
2207 driver
->cdevs
[index
].owner
= driver
->owner
;
2208 err
= cdev_add(&driver
->cdevs
[index
], devt
, 1);
2210 return ERR_PTR(err
);
2212 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
2214 cdev_del(&driver
->cdevs
[index
]);
2215 return ERR_PTR(-ENOMEM
);
2219 dev
->class = prototype
->device
->class;
2220 dev
->parent
= parent
;
2221 dev
->release
= release_loop_device
;
2222 dev_set_name(dev
, "%s", name
);
2224 dev_set_drvdata(dev
, NULL
);
2226 err
= device_register(dev
);
2229 cdev_del(&driver
->cdevs
[index
]);
2230 return ERR_PTR(err
);
2237 * fwserial_create - init everything to create TTYs for a specific fw_card
2238 * @unit: fw_unit for first 'serial' unit device probed for this fw_card
2240 * This function inits the aggregate structure (an fw_serial instance)
2241 * used to manage the TTY ports registered by a specific fw_card. Also, the
2242 * unit device is added as the first 'peer'.
2244 * This unit device may represent a local unit device (as specified by the
2245 * config ROM unit directory) or it may represent a remote unit device
2246 * (as specified by the reading of the remote node's config ROM).
2248 * Returns 0 to indicate "ownership" of the unit device, or a negative errno
2249 * value to indicate which error.
2251 static int fwserial_create(struct fw_unit
*unit
)
2253 struct fw_device
*parent
= fw_parent_device(unit
);
2254 struct fw_card
*card
= parent
->card
;
2255 struct fw_serial
*serial
;
2256 struct fwtty_port
*port
;
2257 struct device
*tty_dev
;
2261 serial
= kzalloc(sizeof(*serial
), GFP_KERNEL
);
2265 kref_init(&serial
->kref
);
2266 serial
->card
= card
;
2267 INIT_LIST_HEAD(&serial
->peer_list
);
2269 for (i
= 0; i
< num_ports
; ++i
) {
2270 port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
2275 tty_port_init(&port
->port
);
2276 port
->index
= FWTTY_INVALID_INDEX
;
2277 port
->port
.ops
= &fwtty_port_ops
;
2278 port
->serial
= serial
;
2280 spin_lock_init(&port
->lock
);
2281 INIT_DELAYED_WORK(&port
->drain
, fwtty_drain_tx
);
2282 INIT_DELAYED_WORK(&port
->emit_breaks
, fwtty_emit_breaks
);
2283 INIT_WORK(&port
->hangup
, fwtty_do_hangup
);
2284 INIT_WORK(&port
->push
, fwtty_pushrx
);
2285 INIT_LIST_HEAD(&port
->buf_list
);
2286 init_waitqueue_head(&port
->wait_tx
);
2287 port
->max_payload
= link_speed_to_max_payload(SCODE_100
);
2288 dma_fifo_init(&port
->tx_fifo
);
2290 rcu_assign_pointer(port
->peer
, NULL
);
2291 serial
->ports
[i
] = port
;
2293 /* get unique bus addr region for port's status & recv fifo */
2294 port
->rx_handler
.length
= FWTTY_PORT_RXFIFO_LEN
+ 4;
2295 port
->rx_handler
.address_callback
= fwtty_port_handler
;
2296 port
->rx_handler
.callback_data
= port
;
2298 * XXX: use custom memory region above cpu physical memory addrs
2299 * this will ease porting to 64-bit firewire adapters
2301 err
= fw_core_add_address_handler(&port
->rx_handler
,
2302 &fw_high_memory_region
);
2308 /* preserve i for error cleanup */
2310 err
= fwtty_ports_add(serial
);
2312 fwtty_err(&unit
, "no space in port table");
2316 for (j
= 0; j
< num_ttys
; ++j
) {
2317 tty_dev
= tty_port_register_device(&serial
->ports
[j
]->port
,
2319 serial
->ports
[j
]->index
,
2321 if (IS_ERR(tty_dev
)) {
2322 err
= PTR_ERR(tty_dev
);
2323 fwtty_err(&unit
, "register tty device error (%d)", err
);
2324 goto unregister_ttys
;
2327 serial
->ports
[j
]->device
= tty_dev
;
2329 /* preserve j for error cleanup */
2331 if (create_loop_dev
) {
2332 struct device
*loop_dev
;
2334 loop_dev
= create_loop_device(fwtty_driver
,
2336 serial
->ports
[num_ttys
],
2338 if (IS_ERR(loop_dev
)) {
2339 err
= PTR_ERR(loop_dev
);
2340 fwtty_err(&unit
, "create loop device failed (%d)", err
);
2341 goto unregister_ttys
;
2343 serial
->ports
[num_ttys
]->device
= loop_dev
;
2344 serial
->ports
[num_ttys
]->loopback
= true;
2347 list_add_rcu(&serial
->list
, &fwserial_list
);
2349 fwtty_notice(&unit
, "TTY over FireWire on device %s (guid %016llx)",
2350 dev_name(card
->device
), (unsigned long long) card
->guid
);
2352 err
= fwserial_add_peer(serial
, unit
);
2356 fwtty_err(&unit
, "unable to add peer unit device (%d)", err
);
2358 /* fall-through to error processing */
2359 list_del_rcu(&serial
->list
);
2361 for (--j
; j
>= 0; --j
)
2362 tty_unregister_device(fwtty_driver
, serial
->ports
[j
]->index
);
2363 kref_put(&serial
->kref
, fwserial_destroy
);
2367 for (--i
; i
>= 0; --i
) {
2368 tty_port_destroy(&serial
->ports
[i
]->port
);
2369 kfree(serial
->ports
[i
]);
2376 * fwserial_probe: bus probe function for firewire 'serial' unit devices
2378 * A 'serial' unit device is created and probed as a result of:
2379 * - declaring a ieee1394 bus id table for 'devices' matching a fabricated
2380 * 'serial' unit specifier id
2381 * - adding a unit directory to the config ROM(s) for a 'serial' unit
2383 * The firewire core registers unit devices by enumerating unit directories
2384 * of a node's config ROM after reading the config ROM when a new node is
2385 * added to the bus topology after a bus reset.
2387 * The practical implications of this are:
2388 * - this probe is called for both local and remote nodes that have a 'serial'
2389 * unit directory in their config ROM (that matches the specifiers in
2390 * fwserial_id_table).
2391 * - no specific order is enforced for local vs. remote unit devices
2393 * This unit driver copes with the lack of specific order in the same way the
2394 * firewire net driver does -- each probe, for either a local or remote unit
2395 * device, is treated as a 'peer' (has a struct fwtty_peer instance) and the
2396 * first peer created for a given fw_card (tracked by the global fwserial_list)
2397 * creates the underlying TTYs (aggregated in a fw_serial instance).
2399 * NB: an early attempt to differentiate local & remote unit devices by creating
2400 * peers only for remote units and fw_serial instances (with their
2401 * associated TTY devices) only for local units was discarded. Managing
2402 * the peer lifetimes on device removal proved too complicated.
2404 * fwserial_probe/fwserial_remove are effectively serialized by the
2405 * fwserial_list_mutex. This is necessary because the addition of the first peer
2406 * for a given fw_card will trigger the creation of the fw_serial for that
2407 * fw_card, which must not simultaneously contend with the removal of the
2408 * last peer for a given fw_card triggering the destruction of the same
2409 * fw_serial for the same fw_card.
2411 static int fwserial_probe(struct device
*dev
)
2413 struct fw_unit
*unit
= fw_unit(dev
);
2414 struct fw_serial
*serial
;
2417 mutex_lock(&fwserial_list_mutex
);
2418 serial
= fwserial_lookup(fw_parent_device(unit
)->card
);
2420 err
= fwserial_create(unit
);
2422 err
= fwserial_add_peer(serial
, unit
);
2423 mutex_unlock(&fwserial_list_mutex
);
2428 * fwserial_remove: bus removal function for firewire 'serial' unit devices
2430 * The corresponding 'peer' for this unit device is removed from the list of
2431 * peers for the associated fw_serial (which has a 1:1 correspondence with a
2432 * specific fw_card). If this is the last peer being removed, then trigger
2433 * the destruction of the underlying TTYs.
2435 static int fwserial_remove(struct device
*dev
)
2437 struct fwtty_peer
*peer
= dev_get_drvdata(dev
);
2438 struct fw_serial
*serial
= peer
->serial
;
2441 mutex_lock(&fwserial_list_mutex
);
2442 fwserial_remove_peer(peer
);
2444 if (list_empty(&serial
->peer_list
)) {
2445 /* unlink from the fwserial_list here */
2446 list_del_rcu(&serial
->list
);
2448 for (i
= 0; i
< num_ports
; ++i
)
2449 fwserial_close_port(serial
->ports
[i
]);
2450 kref_put(&serial
->kref
, fwserial_destroy
);
2452 mutex_unlock(&fwserial_list_mutex
);
2458 * fwserial_update: bus update function for 'firewire' serial unit devices
2460 * Updates the new node_id and bus generation for this peer. Note that locking
2461 * is unnecessary; but careful memory barrier usage is important to enforce the
2462 * load and store order of generation & node_id.
2464 * The fw-core orders the write of node_id before generation in the parent
2465 * fw_device to ensure that a stale node_id cannot be used with a current
2466 * bus generation. So the generation value must be read before the node_id.
2468 * In turn, this orders the write of node_id before generation in the peer to
2469 * also ensure a stale node_id cannot be used with a current bus generation.
2471 static void fwserial_update(struct fw_unit
*unit
)
2473 struct fw_device
*parent
= fw_parent_device(unit
);
2474 struct fwtty_peer
*peer
= dev_get_drvdata(&unit
->device
);
2477 generation
= parent
->generation
;
2479 peer
->node_id
= parent
->node_id
;
2481 peer
->generation
= generation
;
2484 static const struct ieee1394_device_id fwserial_id_table
[] = {
2486 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
|
2487 IEEE1394_MATCH_VERSION
,
2488 .specifier_id
= LINUX_VENDOR_ID
,
2489 .version
= FWSERIAL_VERSION
,
2494 static struct fw_driver fwserial_driver
= {
2496 .owner
= THIS_MODULE
,
2497 .name
= KBUILD_MODNAME
,
2498 .bus
= &fw_bus_type
,
2499 .probe
= fwserial_probe
,
2500 .remove
= fwserial_remove
,
2502 .update
= fwserial_update
,
2503 .id_table
= fwserial_id_table
,
2506 #define FW_UNIT_SPECIFIER(id) ((CSR_SPECIFIER_ID << 24) | (id))
2507 #define FW_UNIT_VERSION(ver) ((CSR_VERSION << 24) | (ver))
2508 #define FW_UNIT_ADDRESS(ofs) (((CSR_OFFSET | CSR_DEPENDENT_INFO) << 24) \
2509 | (((ofs) - CSR_REGISTER_BASE) >> 2))
2510 /* XXX: config ROM definitons could be improved with semi-automated offset
2511 * and length calculation
2513 #define FW_ROM_DESCRIPTOR(ofs) (((CSR_LEAF | CSR_DESCRIPTOR) << 24) | (ofs))
2515 struct fwserial_unit_directory_data
{
2519 u32 unit_sw_version
;
2520 u32 unit_addr_offset
;
2527 static struct fwserial_unit_directory_data fwserial_unit_directory_data
= {
2529 .unit_specifier
= FW_UNIT_SPECIFIER(LINUX_VENDOR_ID
),
2530 .unit_sw_version
= FW_UNIT_VERSION(FWSERIAL_VERSION
),
2531 .desc1_ofs
= FW_ROM_DESCRIPTOR(1),
2534 0x00000000, /* type = text */
2535 0x00000000, /* enc = ASCII, lang EN */
2536 0x4c696e75, /* 'Linux TTY' */
2542 static struct fw_descriptor fwserial_unit_directory
= {
2543 .length
= sizeof(fwserial_unit_directory_data
) / sizeof(u32
),
2544 .key
= (CSR_DIRECTORY
| CSR_UNIT
) << 24,
2545 .data
= (u32
*)&fwserial_unit_directory_data
,
2549 * The management address is in the unit space region but above other known
2550 * address users (to keep wild writes from causing havoc)
2552 const struct fw_address_region fwserial_mgmt_addr_region
= {
2553 .start
= CSR_REGISTER_BASE
+ 0x1e0000ULL
,
2554 .end
= 0x1000000000000ULL
,
2557 static struct fw_address_handler fwserial_mgmt_addr_handler
;
2560 * fwserial_handle_plug_req - handle VIRT_CABLE_PLUG request work
2561 * @work: ptr to peer->work
2563 * Attempts to complete the VIRT_CABLE_PLUG handshake sequence for this peer.
2565 * This checks for a collided request-- ie, that a VIRT_CABLE_PLUG request was
2566 * already sent to this peer. If so, the collision is resolved by comparing
2567 * guid values; the loser sends the plug response.
2569 * Note: if an error prevents a response, don't do anything -- the
2570 * remote will timeout its request.
2572 static void fwserial_handle_plug_req(struct work_struct
*work
)
2574 struct fwtty_peer
*peer
= to_peer(work
, work
);
2575 struct virt_plug_params
*plug_req
= &peer
->work_params
.plug_req
;
2576 struct fwtty_port
*port
;
2577 struct fwserial_mgmt_pkt
*pkt
;
2580 pkt
= kmalloc(sizeof(*pkt
), GFP_KERNEL
);
2584 port
= fwserial_find_port(peer
);
2586 spin_lock_bh(&peer
->lock
);
2588 switch (peer
->state
) {
2589 case FWPS_NOT_ATTACHED
:
2591 fwtty_err(&peer
->unit
, "no more ports avail");
2592 fill_plug_rsp_nack(pkt
);
2595 fill_plug_rsp_ok(pkt
, peer
->port
);
2596 peer_set_state(peer
, FWPS_PLUG_RESPONDING
);
2597 /* don't release claimed port */
2602 case FWPS_PLUG_PENDING
:
2603 if (peer
->serial
->card
->guid
> peer
->guid
)
2606 /* We lost - hijack the already-claimed port and send ok */
2607 del_timer(&peer
->timer
);
2608 fill_plug_rsp_ok(pkt
, peer
->port
);
2609 peer_set_state(peer
, FWPS_PLUG_RESPONDING
);
2613 fill_plug_rsp_nack(pkt
);
2616 spin_unlock_bh(&peer
->lock
);
2618 fwserial_release_port(port
);
2620 rcode
= fwserial_send_mgmt_sync(peer
, pkt
);
2622 spin_lock_bh(&peer
->lock
);
2623 if (peer
->state
== FWPS_PLUG_RESPONDING
) {
2624 if (rcode
== RCODE_COMPLETE
) {
2625 struct fwtty_port
*tmp
= peer
->port
;
2627 fwserial_virt_plug_complete(peer
, plug_req
);
2628 spin_unlock_bh(&peer
->lock
);
2630 fwtty_write_port_status(tmp
);
2631 spin_lock_bh(&peer
->lock
);
2633 fwtty_err(&peer
->unit
, "PLUG_RSP error (%d)", rcode
);
2634 port
= peer_revert_state(peer
);
2638 spin_unlock_bh(&peer
->lock
);
2640 fwserial_release_port(port
);
2645 static void fwserial_handle_unplug_req(struct work_struct
*work
)
2647 struct fwtty_peer
*peer
= to_peer(work
, work
);
2648 struct fwtty_port
*port
= NULL
;
2649 struct fwserial_mgmt_pkt
*pkt
;
2652 pkt
= kmalloc(sizeof(*pkt
), GFP_KERNEL
);
2656 spin_lock_bh(&peer
->lock
);
2658 switch (peer
->state
) {
2660 fill_unplug_rsp_ok(pkt
);
2661 peer_set_state(peer
, FWPS_UNPLUG_RESPONDING
);
2664 case FWPS_UNPLUG_PENDING
:
2665 if (peer
->serial
->card
->guid
> peer
->guid
)
2668 /* We lost - send unplug rsp */
2669 del_timer(&peer
->timer
);
2670 fill_unplug_rsp_ok(pkt
);
2671 peer_set_state(peer
, FWPS_UNPLUG_RESPONDING
);
2675 fill_unplug_rsp_nack(pkt
);
2678 spin_unlock_bh(&peer
->lock
);
2680 rcode
= fwserial_send_mgmt_sync(peer
, pkt
);
2682 spin_lock_bh(&peer
->lock
);
2683 if (peer
->state
== FWPS_UNPLUG_RESPONDING
) {
2684 if (rcode
== RCODE_COMPLETE
)
2685 port
= peer_revert_state(peer
);
2687 fwtty_err(&peer
->unit
, "UNPLUG_RSP error (%d)", rcode
);
2690 spin_unlock_bh(&peer
->lock
);
2692 fwserial_release_port(port
);
2697 static int fwserial_parse_mgmt_write(struct fwtty_peer
*peer
,
2698 struct fwserial_mgmt_pkt
*pkt
,
2699 unsigned long long addr
,
2702 struct fwtty_port
*port
= NULL
;
2705 if (addr
!= fwserial_mgmt_addr_handler
.offset
|| len
< sizeof(pkt
->hdr
))
2706 return RCODE_ADDRESS_ERROR
;
2708 if (len
!= be16_to_cpu(pkt
->hdr
.len
) ||
2709 len
!= mgmt_pkt_expected_len(pkt
->hdr
.code
))
2710 return RCODE_DATA_ERROR
;
2712 spin_lock_bh(&peer
->lock
);
2713 if (peer
->state
== FWPS_GONE
) {
2715 * This should never happen - it would mean that the
2716 * remote unit that just wrote this transaction was
2717 * already removed from the bus -- and the removal was
2718 * processed before we rec'd this transaction
2720 fwtty_err(&peer
->unit
, "peer already removed");
2721 spin_unlock_bh(&peer
->lock
);
2722 return RCODE_ADDRESS_ERROR
;
2725 rcode
= RCODE_COMPLETE
;
2727 fwtty_dbg(&peer
->unit
, "mgmt: hdr.code: %04hx", pkt
->hdr
.code
);
2729 switch (be16_to_cpu(pkt
->hdr
.code
) & FWSC_CODE_MASK
) {
2730 case FWSC_VIRT_CABLE_PLUG
:
2731 if (work_pending(&peer
->work
)) {
2732 fwtty_err(&peer
->unit
, "plug req: busy");
2733 rcode
= RCODE_CONFLICT_ERROR
;
2736 peer
->work_params
.plug_req
= pkt
->plug_req
;
2737 PREPARE_WORK(&peer
->work
, fwserial_handle_plug_req
);
2738 queue_work(system_unbound_wq
, &peer
->work
);
2742 case FWSC_VIRT_CABLE_PLUG_RSP
:
2743 if (peer
->state
!= FWPS_PLUG_PENDING
) {
2744 rcode
= RCODE_CONFLICT_ERROR
;
2746 } else if (be16_to_cpu(pkt
->hdr
.code
) & FWSC_RSP_NACK
) {
2747 fwtty_notice(&peer
->unit
, "NACK plug rsp");
2748 port
= peer_revert_state(peer
);
2751 struct fwtty_port
*tmp
= peer
->port
;
2753 fwserial_virt_plug_complete(peer
, &pkt
->plug_rsp
);
2754 spin_unlock_bh(&peer
->lock
);
2756 fwtty_write_port_status(tmp
);
2757 spin_lock_bh(&peer
->lock
);
2761 case FWSC_VIRT_CABLE_UNPLUG
:
2762 if (work_pending(&peer
->work
)) {
2763 fwtty_err(&peer
->unit
, "unplug req: busy");
2764 rcode
= RCODE_CONFLICT_ERROR
;
2766 PREPARE_WORK(&peer
->work
, fwserial_handle_unplug_req
);
2767 queue_work(system_unbound_wq
, &peer
->work
);
2771 case FWSC_VIRT_CABLE_UNPLUG_RSP
:
2772 if (peer
->state
!= FWPS_UNPLUG_PENDING
)
2773 rcode
= RCODE_CONFLICT_ERROR
;
2775 if (be16_to_cpu(pkt
->hdr
.code
) & FWSC_RSP_NACK
)
2776 fwtty_notice(&peer
->unit
, "NACK unplug?");
2777 port
= peer_revert_state(peer
);
2782 fwtty_err(&peer
->unit
, "unknown mgmt code %d",
2783 be16_to_cpu(pkt
->hdr
.code
));
2784 rcode
= RCODE_DATA_ERROR
;
2786 spin_unlock_bh(&peer
->lock
);
2789 fwserial_release_port(port
);
2795 * fwserial_mgmt_handler: bus address handler for mgmt requests
2796 * @parameters: fw_address_callback_t as specified by firewire core interface
2798 * This handler is responsible for handling virtual cable requests from remotes
2801 static void fwserial_mgmt_handler(struct fw_card
*card
,
2802 struct fw_request
*request
,
2803 int tcode
, int destination
, int source
,
2805 unsigned long long addr
,
2806 void *data
, size_t len
,
2807 void *callback_data
)
2809 struct fwserial_mgmt_pkt
*pkt
= data
;
2810 struct fwtty_peer
*peer
;
2814 peer
= __fwserial_peer_by_node_id(card
, generation
, source
);
2816 fwtty_dbg(card
, "peer(%d:%x) not found", generation
, source
);
2817 __dump_peer_list(card
);
2818 rcode
= RCODE_CONFLICT_ERROR
;
2822 case TCODE_WRITE_BLOCK_REQUEST
:
2823 rcode
= fwserial_parse_mgmt_write(peer
, pkt
, addr
, len
);
2827 rcode
= RCODE_TYPE_ERROR
;
2832 fw_send_response(card
, request
, rcode
);
2835 static int __init
fwserial_init(void)
2837 int err
, num_loops
= !!(create_loop_dev
);
2839 /* num_ttys/num_ports must not be set above the static alloc avail */
2840 if (num_ttys
+ num_loops
> MAX_CARD_PORTS
)
2841 num_ttys
= MAX_CARD_PORTS
- num_loops
;
2842 num_ports
= num_ttys
+ num_loops
;
2844 fwtty_driver
= alloc_tty_driver(MAX_TOTAL_PORTS
);
2845 if (!fwtty_driver
) {
2850 fwtty_driver
->driver_name
= KBUILD_MODNAME
;
2851 fwtty_driver
->name
= tty_dev_name
;
2852 fwtty_driver
->major
= 0;
2853 fwtty_driver
->minor_start
= 0;
2854 fwtty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
2855 fwtty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
2856 fwtty_driver
->flags
= TTY_DRIVER_REAL_RAW
|
2857 TTY_DRIVER_DYNAMIC_DEV
;
2859 fwtty_driver
->init_termios
= tty_std_termios
;
2860 fwtty_driver
->init_termios
.c_cflag
|= CLOCAL
;
2861 tty_set_operations(fwtty_driver
, &fwtty_ops
);
2863 err
= tty_register_driver(fwtty_driver
);
2865 driver_err("register tty driver failed (%d)", err
);
2869 fwtty_txn_cache
= kmem_cache_create("fwtty_txn_cache",
2870 sizeof(struct fwtty_transaction
),
2871 0, 0, fwtty_txn_constructor
);
2872 if (!fwtty_txn_cache
) {
2874 goto unregister_driver
;
2878 * Ideally, this address handler would be registered per local node
2879 * (rather than the same handler for all local nodes). However,
2880 * since the firewire core requires the config rom descriptor *before*
2881 * the local unit device(s) are created, a single management handler
2882 * must suffice for all local serial units.
2884 fwserial_mgmt_addr_handler
.length
= sizeof(struct fwserial_mgmt_pkt
);
2885 fwserial_mgmt_addr_handler
.address_callback
= fwserial_mgmt_handler
;
2887 err
= fw_core_add_address_handler(&fwserial_mgmt_addr_handler
,
2888 &fwserial_mgmt_addr_region
);
2890 driver_err("add management handler failed (%d)", err
);
2894 fwserial_unit_directory_data
.unit_addr_offset
=
2895 FW_UNIT_ADDRESS(fwserial_mgmt_addr_handler
.offset
);
2896 err
= fw_core_add_descriptor(&fwserial_unit_directory
);
2898 driver_err("add unit descriptor failed (%d)", err
);
2899 goto remove_handler
;
2902 err
= driver_register(&fwserial_driver
.driver
);
2904 driver_err("register fwserial driver failed (%d)", err
);
2905 goto remove_descriptor
;
2911 fw_core_remove_descriptor(&fwserial_unit_directory
);
2913 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler
);
2915 kmem_cache_destroy(fwtty_txn_cache
);
2917 tty_unregister_driver(fwtty_driver
);
2919 put_tty_driver(fwtty_driver
);
2923 static void __exit
fwserial_exit(void)
2925 driver_unregister(&fwserial_driver
.driver
);
2926 fw_core_remove_descriptor(&fwserial_unit_directory
);
2927 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler
);
2928 kmem_cache_destroy(fwtty_txn_cache
);
2929 tty_unregister_driver(fwtty_driver
);
2930 put_tty_driver(fwtty_driver
);
2933 module_init(fwserial_init
);
2934 module_exit(fwserial_exit
);
2936 MODULE_AUTHOR("Peter Hurley (peter@hurleysoftware.com)");
2937 MODULE_DESCRIPTION("FireWire Serial TTY Driver");
2938 MODULE_LICENSE("GPL");
2939 MODULE_DEVICE_TABLE(ieee1394
, fwserial_id_table
);
2940 MODULE_PARM_DESC(ttys
, "Number of ttys to create for each local firewire node");
2941 MODULE_PARM_DESC(auto, "Auto-connect a tty to each firewire node discovered");
2942 MODULE_PARM_DESC(loop
, "Create a loopback device, fwloop<n>, with ttys");
2943 MODULE_PARM_DESC(limit_bw
, "Limit bandwidth utilization to 20%.");