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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
23 #include <linux/sched.h>
24 #include <linux/slab.h>
25 #include <linux/device.h>
26 #include <linux/mod_devicetable.h>
27 #include <linux/rculist.h>
28 #include <linux/workqueue.h>
29 #include <linux/ratelimit.h>
30 #include <linux/bug.h>
31 #include <linux/uaccess.h>
35 #define be32_to_u64(hi, lo) ((u64)be32_to_cpu(hi) << 32 | be32_to_cpu(lo))
37 #define LINUX_VENDOR_ID 0xd00d1eU /* same id used in card root directory */
38 #define FWSERIAL_VERSION 0x00e81cU /* must be unique within LINUX_VENDOR_ID */
40 /* configurable options */
41 static int num_ttys
= 4; /* # of std ttys to create per fw_card */
42 /* - doubles as loopback port index */
43 static bool auto_connect
= true; /* try to VIRT_CABLE to every peer */
44 static bool create_loop_dev
= true; /* create a loopback device for each card */
46 module_param_named(ttys
, num_ttys
, int, S_IRUGO
| S_IWUSR
);
47 module_param_named(auto, auto_connect
, bool, S_IRUGO
| S_IWUSR
);
48 module_param_named(loop
, create_loop_dev
, 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 #define loop_idx(port) (((port)->index) / num_ports)
78 #define table_idx(loop) ((loop) * num_ports + num_ttys)
80 /* total # of tty ports created per fw_card */
83 /* slab used as pool for struct fwtty_transactions */
84 static struct kmem_cache
*fwtty_txn_cache
;
86 struct tty_driver
*fwtty_driver
;
87 static struct tty_driver
*fwloop_driver
;
89 static struct dentry
*fwserial_debugfs
;
91 struct fwtty_transaction
;
92 typedef void (*fwtty_transaction_cb
)(struct fw_card
*card
, int rcode
,
93 void *data
, size_t length
,
94 struct fwtty_transaction
*txn
);
96 struct fwtty_transaction
{
97 struct fw_transaction fw_txn
;
98 fwtty_transaction_cb callback
;
99 struct fwtty_port
*port
;
101 struct dma_pending dma_pended
;
105 #define to_device(a, b) (a->b)
106 #define fwtty_err(p, fmt, ...) \
107 dev_err(to_device(p, device), fmt, ##__VA_ARGS__)
108 #define fwtty_info(p, fmt, ...) \
109 dev_info(to_device(p, device), fmt, ##__VA_ARGS__)
110 #define fwtty_notice(p, fmt, ...) \
111 dev_notice(to_device(p, device), fmt, ##__VA_ARGS__)
112 #define fwtty_dbg(p, fmt, ...) \
113 dev_dbg(to_device(p, device), "%s: " fmt, __func__, ##__VA_ARGS__)
114 #define fwtty_err_ratelimited(p, fmt, ...) \
115 dev_err_ratelimited(to_device(p, device), fmt, ##__VA_ARGS__)
118 static inline void debug_short_write(struct fwtty_port
*port
, int c
, int n
)
123 spin_lock_bh(&port
->lock
);
124 avail
= dma_fifo_avail(&port
->tx_fifo
);
125 spin_unlock_bh(&port
->lock
);
126 fwtty_dbg(port
, "short write: avail:%d req:%d wrote:%d\n",
131 #define debug_short_write(port, c, n)
134 static struct fwtty_peer
*__fwserial_peer_by_node_id(struct fw_card
*card
,
135 int generation
, int id
);
137 #ifdef FWTTY_PROFILING
139 static void profile_fifo_avail(struct fwtty_port
*port
, unsigned *stat
)
141 spin_lock_bh(&port
->lock
);
142 profile_size_distrib(stat
, dma_fifo_avail(&port
->tx_fifo
));
143 spin_unlock_bh(&port
->lock
);
146 static void dump_profile(struct seq_file
*m
, struct stats
*stats
)
148 /* for each stat, print sum of 0 to 2^k, then individually */
154 snprintf(t
, 10, "< %d", 1 << k
);
155 seq_printf(m
, "\n%14s %6s", " ", t
);
156 for (j
= k
+ 1; j
< DISTRIBUTION_MAX_INDEX
; ++j
)
157 seq_printf(m
, "%6d", 1 << j
);
160 for (j
= 0, sum
= 0; j
<= k
; ++j
)
161 sum
+= stats
->reads
[j
];
162 seq_printf(m
, "\n%14s: %6d", "reads", sum
);
163 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
164 seq_printf(m
, "%6d", stats
->reads
[j
]);
166 for (j
= 0, sum
= 0; j
<= k
; ++j
)
167 sum
+= stats
->writes
[j
];
168 seq_printf(m
, "\n%14s: %6d", "writes", sum
);
169 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
170 seq_printf(m
, "%6d", stats
->writes
[j
]);
172 for (j
= 0, sum
= 0; j
<= k
; ++j
)
173 sum
+= stats
->txns
[j
];
174 seq_printf(m
, "\n%14s: %6d", "txns", sum
);
175 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
176 seq_printf(m
, "%6d", stats
->txns
[j
]);
178 for (j
= 0, sum
= 0; j
<= k
; ++j
)
179 sum
+= stats
->unthrottle
[j
];
180 seq_printf(m
, "\n%14s: %6d", "avail @ unthr", sum
);
181 for (j
= k
+ 1; j
<= DISTRIBUTION_MAX_INDEX
; ++j
)
182 seq_printf(m
, "%6d", stats
->unthrottle
[j
]);
186 #define profile_fifo_avail(port, stat)
187 #define dump_profile(m, stats)
191 * Returns the max receive packet size for the given node
192 * Devices which are OHCI v1.0/ v1.1/ v1.2-draft or RFC 2734 compliant
193 * are required by specification to support max_rec of 8 (512 bytes) or more.
195 static inline int device_max_receive(struct fw_device
*fw_device
)
197 /* see IEEE 1394-2008 table 8-8 */
198 return min(2 << fw_device
->max_rec
, 4096);
201 static void fwtty_log_tx_error(struct fwtty_port
*port
, int rcode
)
204 case RCODE_SEND_ERROR
:
205 fwtty_err_ratelimited(port
, "card busy\n");
207 case RCODE_ADDRESS_ERROR
:
208 fwtty_err_ratelimited(port
, "bad unit addr or write length\n");
210 case RCODE_DATA_ERROR
:
211 fwtty_err_ratelimited(port
, "failed rx\n");
214 fwtty_err_ratelimited(port
, "missing ack\n");
217 fwtty_err_ratelimited(port
, "remote busy\n");
220 fwtty_err_ratelimited(port
, "failed tx: %d\n", rcode
);
224 static void fwtty_txn_constructor(void *this)
226 struct fwtty_transaction
*txn
= this;
228 init_timer(&txn
->fw_txn
.split_timeout_timer
);
231 static void fwtty_common_callback(struct fw_card
*card
, int rcode
,
232 void *payload
, size_t len
, void *cb_data
)
234 struct fwtty_transaction
*txn
= cb_data
;
235 struct fwtty_port
*port
= txn
->port
;
237 if (port
&& rcode
!= RCODE_COMPLETE
)
238 fwtty_log_tx_error(port
, rcode
);
240 txn
->callback(card
, rcode
, payload
, len
, txn
);
241 kmem_cache_free(fwtty_txn_cache
, txn
);
244 static int fwtty_send_data_async(struct fwtty_peer
*peer
, int tcode
,
245 unsigned long long addr
, void *payload
,
246 size_t len
, fwtty_transaction_cb callback
,
247 struct fwtty_port
*port
)
249 struct fwtty_transaction
*txn
;
252 txn
= kmem_cache_alloc(fwtty_txn_cache
, GFP_ATOMIC
);
256 txn
->callback
= callback
;
259 generation
= peer
->generation
;
261 fw_send_request(peer
->serial
->card
, &txn
->fw_txn
, tcode
,
262 peer
->node_id
, generation
, peer
->speed
, addr
, payload
,
263 len
, fwtty_common_callback
, txn
);
267 static void fwtty_send_txn_async(struct fwtty_peer
*peer
,
268 struct fwtty_transaction
*txn
, int tcode
,
269 unsigned long long addr
, void *payload
,
270 size_t len
, fwtty_transaction_cb callback
,
271 struct fwtty_port
*port
)
275 txn
->callback
= callback
;
278 generation
= peer
->generation
;
280 fw_send_request(peer
->serial
->card
, &txn
->fw_txn
, tcode
,
281 peer
->node_id
, generation
, peer
->speed
, addr
, payload
,
282 len
, fwtty_common_callback
, txn
);
286 static void __fwtty_restart_tx(struct fwtty_port
*port
)
290 len
= dma_fifo_out_level(&port
->tx_fifo
);
292 schedule_delayed_work(&port
->drain
, 0);
293 avail
= dma_fifo_avail(&port
->tx_fifo
);
295 fwtty_dbg(port
, "fifo len: %d avail: %d\n", len
, avail
);
298 static void fwtty_restart_tx(struct fwtty_port
*port
)
300 spin_lock_bh(&port
->lock
);
301 __fwtty_restart_tx(port
);
302 spin_unlock_bh(&port
->lock
);
306 * fwtty_update_port_status - decodes & dispatches line status changes
308 * Note: in loopback, the port->lock is being held. Only use functions that
309 * don't attempt to reclaim the port->lock.
311 static void fwtty_update_port_status(struct fwtty_port
*port
, unsigned status
)
314 struct tty_struct
*tty
;
316 /* simulated LSR/MSR status from remote */
317 status
&= ~MCTRL_MASK
;
318 delta
= (port
->mstatus
^ status
) & ~MCTRL_MASK
;
319 delta
&= ~(status
& TIOCM_RNG
);
320 port
->mstatus
= status
;
322 if (delta
& TIOCM_RNG
)
324 if (delta
& TIOCM_DSR
)
326 if (delta
& TIOCM_CAR
)
328 if (delta
& TIOCM_CTS
)
331 fwtty_dbg(port
, "status: %x delta: %x\n", status
, delta
);
333 if (delta
& TIOCM_CAR
) {
334 tty
= tty_port_tty_get(&port
->port
);
335 if (tty
&& !C_CLOCAL(tty
)) {
336 if (status
& TIOCM_CAR
)
337 wake_up_interruptible(&port
->port
.open_wait
);
339 schedule_work(&port
->hangup
);
344 if (delta
& TIOCM_CTS
) {
345 tty
= tty_port_tty_get(&port
->port
);
346 if (tty
&& C_CRTSCTS(tty
)) {
347 if (tty
->hw_stopped
) {
348 if (status
& TIOCM_CTS
) {
351 __fwtty_restart_tx(port
);
353 fwtty_restart_tx(port
);
356 if (~status
& TIOCM_CTS
)
362 } else if (delta
& OOB_TX_THROTTLE
) {
363 tty
= tty_port_tty_get(&port
->port
);
365 if (tty
->hw_stopped
) {
366 if (~status
& OOB_TX_THROTTLE
) {
369 __fwtty_restart_tx(port
);
371 fwtty_restart_tx(port
);
374 if (status
& OOB_TX_THROTTLE
)
381 if (delta
& (UART_LSR_BI
<< 24)) {
382 if (status
& (UART_LSR_BI
<< 24)) {
383 port
->break_last
= jiffies
;
384 schedule_delayed_work(&port
->emit_breaks
, 0);
386 /* run emit_breaks one last time (if pending) */
387 mod_delayed_work(system_wq
, &port
->emit_breaks
, 0);
391 if (delta
& (TIOCM_DSR
| TIOCM_CAR
| TIOCM_CTS
| TIOCM_RNG
))
392 wake_up_interruptible(&port
->port
.delta_msr_wait
);
396 * __fwtty_port_line_status - generate 'line status' for indicated port
398 * This function returns a remote 'MSR' state based on the local 'MCR' state,
399 * as if a null modem cable was attached. The actual status is a mangling
400 * of TIOCM_* bits suitable for sending to a peer's status_addr.
402 * Note: caller must be holding port lock
404 static unsigned __fwtty_port_line_status(struct fwtty_port
*port
)
408 /* TODO: add module param to tie RNG to DTR as well */
410 if (port
->mctrl
& TIOCM_DTR
)
411 status
|= TIOCM_DSR
| TIOCM_CAR
;
412 if (port
->mctrl
& TIOCM_RTS
)
414 if (port
->mctrl
& OOB_RX_THROTTLE
)
415 status
|= OOB_TX_THROTTLE
;
416 /* emulate BRK as add'l line status */
418 status
|= UART_LSR_BI
<< 24;
424 * __fwtty_write_port_status - send the port line status to peer
426 * Note: caller must be holding the port lock.
428 static int __fwtty_write_port_status(struct fwtty_port
*port
)
430 struct fwtty_peer
*peer
;
432 unsigned status
= __fwtty_port_line_status(port
);
435 peer
= rcu_dereference(port
->peer
);
437 err
= fwtty_send_data_async(peer
, TCODE_WRITE_QUADLET_REQUEST
,
438 peer
->status_addr
, &status
,
439 sizeof(status
), NULL
, port
);
447 * fwtty_write_port_status - same as above but locked by port lock
449 static int fwtty_write_port_status(struct fwtty_port
*port
)
453 spin_lock_bh(&port
->lock
);
454 err
= __fwtty_write_port_status(port
);
455 spin_unlock_bh(&port
->lock
);
459 static void __fwtty_throttle(struct fwtty_port
*port
, struct tty_struct
*tty
)
464 port
->mctrl
|= OOB_RX_THROTTLE
;
466 port
->mctrl
&= ~TIOCM_RTS
;
467 if (~old
& OOB_RX_THROTTLE
)
468 __fwtty_write_port_status(port
);
472 * fwtty_do_hangup - wait for ldisc to deliver all pending rx; only then hangup
474 * When the remote has finished tx, and all in-flight rx has been received and
475 * and pushed to the flip buffer, the remote may close its device. This will
476 * drop DTR on the remote which will drop carrier here. Typically, the tty is
477 * hung up when carrier is dropped or lost.
479 * However, there is a race between the hang up and the line discipline
480 * delivering its data to the reader. A hangup will cause the ldisc to flush
481 * (ie., clear) the read buffer and flip buffer. Because of firewire's
482 * relatively high throughput, the ldisc frequently lags well behind the driver,
483 * resulting in lost data (which has already been received and written to
484 * the flip buffer) when the remote closes its end.
486 * Unfortunately, since the flip buffer offers no direct method for determining
487 * if it holds data, ensuring the ldisc has delivered all data is problematic.
490 /* FIXME: drop this workaround when __tty_hangup waits for ldisc completion */
491 static void fwtty_do_hangup(struct work_struct
*work
)
493 struct fwtty_port
*port
= to_port(work
, hangup
);
494 struct tty_struct
*tty
;
496 schedule_timeout_uninterruptible(msecs_to_jiffies(50));
498 tty
= tty_port_tty_get(&port
->port
);
505 static void fwtty_emit_breaks(struct work_struct
*work
)
507 struct fwtty_port
*port
= to_port(to_delayed_work(work
), emit_breaks
);
508 static const char buf
[16];
509 unsigned long now
= jiffies
;
510 unsigned long elapsed
= now
- port
->break_last
;
511 int n
, t
, c
, brk
= 0;
513 /* generate breaks at the line rate (but at least 1) */
514 n
= (elapsed
* port
->cps
) / HZ
+ 1;
515 port
->break_last
= now
;
517 fwtty_dbg(port
, "sending %d brks\n", n
);
521 c
= tty_insert_flip_string_fixed_flag(&port
->port
, buf
,
528 tty_flip_buffer_push(&port
->port
);
530 if (port
->mstatus
& (UART_LSR_BI
<< 24))
531 schedule_delayed_work(&port
->emit_breaks
, FREQ_BREAKS
);
532 port
->icount
.brk
+= brk
;
535 static void fwtty_pushrx(struct work_struct
*work
)
537 struct fwtty_port
*port
= to_port(work
, push
);
538 struct tty_struct
*tty
;
539 struct buffered_rx
*buf
, *next
;
542 spin_lock_bh(&port
->lock
);
543 list_for_each_entry_safe(buf
, next
, &port
->buf_list
, list
) {
544 n
= tty_insert_flip_string_fixed_flag(&port
->port
, buf
->data
,
550 memmove(buf
->data
, buf
->data
+ n
, buf
->n
- n
);
553 tty
= tty_port_tty_get(&port
->port
);
555 __fwtty_throttle(port
, tty
);
560 list_del(&buf
->list
);
565 tty_flip_buffer_push(&port
->port
);
567 if (list_empty(&port
->buf_list
))
568 clear_bit(BUFFERING_RX
, &port
->flags
);
569 spin_unlock_bh(&port
->lock
);
572 static int fwtty_buffer_rx(struct fwtty_port
*port
, unsigned char *d
, size_t n
)
574 struct buffered_rx
*buf
;
575 size_t size
= (n
+ sizeof(struct buffered_rx
) + 0xFF) & ~0xFF;
577 if (port
->buffered
+ n
> HIGH_WATERMARK
) {
578 fwtty_err_ratelimited(port
, "overflowed rx buffer: buffered: %d new: %zu wtrmk: %d\n",
579 port
->buffered
, n
, HIGH_WATERMARK
);
582 buf
= kmalloc(size
, GFP_ATOMIC
);
585 INIT_LIST_HEAD(&buf
->list
);
587 memcpy(buf
->data
, d
, n
);
589 spin_lock_bh(&port
->lock
);
590 list_add_tail(&buf
->list
, &port
->buf_list
);
592 if (port
->buffered
> port
->stats
.watermark
)
593 port
->stats
.watermark
= port
->buffered
;
594 set_bit(BUFFERING_RX
, &port
->flags
);
595 spin_unlock_bh(&port
->lock
);
600 static int fwtty_rx(struct fwtty_port
*port
, unsigned char *data
, size_t len
)
602 struct tty_struct
*tty
;
607 fwtty_dbg(port
, "%d\n", n
);
608 profile_size_distrib(port
->stats
.reads
, n
);
610 if (port
->write_only
) {
615 /* disregard break status; breaks are generated by emit_breaks work */
616 lsr
= (port
->mstatus
>> 24) & ~UART_LSR_BI
;
621 if (lsr
& UART_LSR_OE
)
622 ++port
->icount
.overrun
;
624 lsr
&= port
->status_mask
;
625 if (lsr
& ~port
->ignore_mask
& UART_LSR_OE
) {
626 if (!tty_insert_flip_char(&port
->port
, 0, TTY_OVERRUN
)) {
631 port
->overrun
= false;
633 if (lsr
& port
->ignore_mask
& ~UART_LSR_OE
) {
634 /* TODO: don't drop SAK and Magic SysRq here */
639 if (!test_bit(BUFFERING_RX
, &port
->flags
)) {
640 c
= tty_insert_flip_string_fixed_flag(&port
->port
, data
,
643 tty_flip_buffer_push(&port
->port
);
647 /* start buffering and throttling */
648 n
-= fwtty_buffer_rx(port
, &data
[c
], n
);
650 tty
= tty_port_tty_get(&port
->port
);
652 spin_lock_bh(&port
->lock
);
653 __fwtty_throttle(port
, tty
);
654 spin_unlock_bh(&port
->lock
);
659 n
-= fwtty_buffer_rx(port
, data
, n
);
662 port
->overrun
= true;
667 port
->icount
.rx
+= len
;
668 port
->stats
.lost
+= n
;
673 * fwtty_port_handler - bus address handler for port reads/writes
674 * @parameters: fw_address_callback_t as specified by firewire core interface
676 * This handler is responsible for handling inbound read/write dma from remotes.
678 static void fwtty_port_handler(struct fw_card
*card
,
679 struct fw_request
*request
,
680 int tcode
, int destination
, int source
,
682 unsigned long long addr
,
683 void *data
, size_t len
,
686 struct fwtty_port
*port
= callback_data
;
687 struct fwtty_peer
*peer
;
691 /* Only accept rx from the peer virtual-cabled to this port */
693 peer
= __fwserial_peer_by_node_id(card
, generation
, source
);
695 if (!peer
|| peer
!= rcu_access_pointer(port
->peer
)) {
696 rcode
= RCODE_ADDRESS_ERROR
;
697 fwtty_err_ratelimited(port
, "ignoring unauthenticated data\n");
702 case TCODE_WRITE_QUADLET_REQUEST
:
703 if (addr
!= port
->rx_handler
.offset
|| len
!= 4)
704 rcode
= RCODE_ADDRESS_ERROR
;
706 fwtty_update_port_status(port
, *(unsigned *)data
);
707 rcode
= RCODE_COMPLETE
;
711 case TCODE_WRITE_BLOCK_REQUEST
:
712 if (addr
!= port
->rx_handler
.offset
+ 4 ||
713 len
> port
->rx_handler
.length
- 4) {
714 rcode
= RCODE_ADDRESS_ERROR
;
716 err
= fwtty_rx(port
, data
, len
);
719 rcode
= RCODE_COMPLETE
;
722 rcode
= RCODE_DATA_ERROR
;
725 rcode
= RCODE_CONFLICT_ERROR
;
732 rcode
= RCODE_TYPE_ERROR
;
736 fw_send_response(card
, request
, rcode
);
740 * fwtty_tx_complete - callback for tx dma
741 * @data: ignored, has no meaning for write txns
742 * @length: ignored, has no meaning for write txns
744 * The writer must be woken here if the fifo has been emptied because it
745 * may have slept if chars_in_buffer was != 0
747 static void fwtty_tx_complete(struct fw_card
*card
, int rcode
,
748 void *data
, size_t length
,
749 struct fwtty_transaction
*txn
)
751 struct fwtty_port
*port
= txn
->port
;
754 fwtty_dbg(port
, "rcode: %d\n", rcode
);
758 spin_lock_bh(&port
->lock
);
759 dma_fifo_out_complete(&port
->tx_fifo
, &txn
->dma_pended
);
760 len
= dma_fifo_level(&port
->tx_fifo
);
761 spin_unlock_bh(&port
->lock
);
763 port
->icount
.tx
+= txn
->dma_pended
.len
;
767 /* TODO: implement retries */
768 spin_lock_bh(&port
->lock
);
769 dma_fifo_out_complete(&port
->tx_fifo
, &txn
->dma_pended
);
770 len
= dma_fifo_level(&port
->tx_fifo
);
771 spin_unlock_bh(&port
->lock
);
773 port
->stats
.dropped
+= txn
->dma_pended
.len
;
776 if (len
< WAKEUP_CHARS
)
777 tty_port_tty_wakeup(&port
->port
);
780 static int fwtty_tx(struct fwtty_port
*port
, bool drain
)
782 struct fwtty_peer
*peer
;
783 struct fwtty_transaction
*txn
;
784 struct tty_struct
*tty
;
787 tty
= tty_port_tty_get(&port
->port
);
792 peer
= rcu_dereference(port
->peer
);
798 if (test_and_set_bit(IN_TX
, &port
->flags
)) {
803 /* try to write as many dma transactions out as possible */
805 while (!tty
->stopped
&& !tty
->hw_stopped
&&
806 !test_bit(STOP_TX
, &port
->flags
)) {
807 txn
= kmem_cache_alloc(fwtty_txn_cache
, GFP_ATOMIC
);
813 spin_lock_bh(&port
->lock
);
814 n
= dma_fifo_out_pend(&port
->tx_fifo
, &txn
->dma_pended
);
815 spin_unlock_bh(&port
->lock
);
817 fwtty_dbg(port
, "out: %u rem: %d\n", txn
->dma_pended
.len
, n
);
820 kmem_cache_free(fwtty_txn_cache
, txn
);
822 ++port
->stats
.tx_stall
;
823 else if (n
== -ENODATA
)
824 profile_size_distrib(port
->stats
.txns
, 0);
826 ++port
->stats
.fifo_errs
;
827 fwtty_err_ratelimited(port
, "fifo err: %d\n",
833 profile_size_distrib(port
->stats
.txns
, txn
->dma_pended
.len
);
835 fwtty_send_txn_async(peer
, txn
, TCODE_WRITE_BLOCK_REQUEST
,
836 peer
->fifo_addr
, txn
->dma_pended
.data
,
837 txn
->dma_pended
.len
, fwtty_tx_complete
,
842 * Stop tx if the 'last view' of the fifo is empty or if
843 * this is the writer and there's not enough data to bother
845 if (n
== 0 || (!drain
&& n
< WRITER_MINIMUM
))
849 if (n
>= 0 || n
== -EAGAIN
|| n
== -ENOMEM
|| n
== -ENODATA
) {
850 spin_lock_bh(&port
->lock
);
851 len
= dma_fifo_out_level(&port
->tx_fifo
);
853 unsigned long delay
= (n
== -ENOMEM
) ? HZ
: 1;
854 schedule_delayed_work(&port
->drain
, delay
);
856 len
= dma_fifo_level(&port
->tx_fifo
);
857 spin_unlock_bh(&port
->lock
);
859 /* wakeup the writer */
860 if (drain
&& len
< WAKEUP_CHARS
)
864 clear_bit(IN_TX
, &port
->flags
);
865 wake_up_interruptible(&port
->wait_tx
);
873 static void fwtty_drain_tx(struct work_struct
*work
)
875 struct fwtty_port
*port
= to_port(to_delayed_work(work
), drain
);
877 fwtty_tx(port
, true);
880 static void fwtty_write_xchar(struct fwtty_port
*port
, char ch
)
882 struct fwtty_peer
*peer
;
884 ++port
->stats
.xchars
;
886 fwtty_dbg(port
, "%02x\n", ch
);
889 peer
= rcu_dereference(port
->peer
);
891 fwtty_send_data_async(peer
, TCODE_WRITE_BLOCK_REQUEST
,
892 peer
->fifo_addr
, &ch
, sizeof(ch
),
898 struct fwtty_port
*fwtty_port_get(unsigned index
)
900 struct fwtty_port
*port
;
902 if (index
>= MAX_TOTAL_PORTS
)
905 mutex_lock(&port_table_lock
);
906 port
= port_table
[index
];
908 kref_get(&port
->serial
->kref
);
909 mutex_unlock(&port_table_lock
);
912 EXPORT_SYMBOL(fwtty_port_get
);
914 static int fwtty_ports_add(struct fw_serial
*serial
)
919 if (port_table_corrupt
)
922 mutex_lock(&port_table_lock
);
923 for (i
= 0; i
+ num_ports
<= MAX_TOTAL_PORTS
; i
+= num_ports
) {
924 if (!port_table
[i
]) {
925 for (j
= 0; j
< num_ports
; ++i
, ++j
) {
926 serial
->ports
[j
]->index
= i
;
927 port_table
[i
] = serial
->ports
[j
];
933 mutex_unlock(&port_table_lock
);
937 static void fwserial_destroy(struct kref
*kref
)
939 struct fw_serial
*serial
= to_serial(kref
, kref
);
940 struct fwtty_port
**ports
= serial
->ports
;
941 int j
, i
= ports
[0]->index
;
945 mutex_lock(&port_table_lock
);
946 for (j
= 0; j
< num_ports
; ++i
, ++j
) {
947 port_table_corrupt
|= port_table
[i
] != ports
[j
];
948 WARN_ONCE(port_table_corrupt
, "port_table[%d]: %p != ports[%d]: %p",
949 i
, port_table
[i
], j
, ports
[j
]);
951 port_table
[i
] = NULL
;
953 mutex_unlock(&port_table_lock
);
955 for (j
= 0; j
< num_ports
; ++j
) {
956 fw_core_remove_address_handler(&ports
[j
]->rx_handler
);
957 tty_port_destroy(&ports
[j
]->port
);
963 void fwtty_port_put(struct fwtty_port
*port
)
965 kref_put(&port
->serial
->kref
, fwserial_destroy
);
967 EXPORT_SYMBOL(fwtty_port_put
);
969 static void fwtty_port_dtr_rts(struct tty_port
*tty_port
, int on
)
971 struct fwtty_port
*port
= to_port(tty_port
, port
);
973 fwtty_dbg(port
, "on/off: %d\n", on
);
975 spin_lock_bh(&port
->lock
);
976 /* Don't change carrier state if this is a console */
977 if (!port
->port
.console
) {
979 port
->mctrl
|= TIOCM_DTR
| TIOCM_RTS
;
981 port
->mctrl
&= ~(TIOCM_DTR
| TIOCM_RTS
);
984 __fwtty_write_port_status(port
);
985 spin_unlock_bh(&port
->lock
);
989 * fwtty_port_carrier_raised: required tty_port operation
991 * This port operation is polled after a tty has been opened and is waiting for
992 * carrier detect -- see drivers/tty/tty_port:tty_port_block_til_ready().
994 static int fwtty_port_carrier_raised(struct tty_port
*tty_port
)
996 struct fwtty_port
*port
= to_port(tty_port
, port
);
999 rc
= (port
->mstatus
& TIOCM_CAR
);
1001 fwtty_dbg(port
, "%d\n", rc
);
1006 static unsigned set_termios(struct fwtty_port
*port
, struct tty_struct
*tty
)
1008 unsigned baud
, frame
;
1010 baud
= tty_termios_baud_rate(&tty
->termios
);
1011 tty_termios_encode_baud_rate(&tty
->termios
, baud
, baud
);
1013 /* compute bit count of 2 frames */
1014 frame
= 12 + ((C_CSTOPB(tty
)) ? 4 : 2) + ((C_PARENB(tty
)) ? 2 : 0);
1016 switch (C_CSIZE(tty
)) {
1018 frame
-= (C_CSTOPB(tty
)) ? 1 : 0;
1031 port
->cps
= (baud
<< 1) / frame
;
1033 port
->status_mask
= UART_LSR_OE
;
1034 if (_I_FLAG(tty
, BRKINT
| PARMRK
))
1035 port
->status_mask
|= UART_LSR_BI
;
1037 port
->ignore_mask
= 0;
1038 if (I_IGNBRK(tty
)) {
1039 port
->ignore_mask
|= UART_LSR_BI
;
1041 port
->ignore_mask
|= UART_LSR_OE
;
1044 port
->write_only
= !C_CREAD(tty
);
1046 /* turn off echo and newline xlat if loopback */
1047 if (port
->loopback
) {
1048 tty
->termios
.c_lflag
&= ~(ECHO
| ECHOE
| ECHOK
| ECHOKE
|
1049 ECHONL
| ECHOPRT
| ECHOCTL
);
1050 tty
->termios
.c_oflag
&= ~ONLCR
;
1056 static int fwtty_port_activate(struct tty_port
*tty_port
,
1057 struct tty_struct
*tty
)
1059 struct fwtty_port
*port
= to_port(tty_port
, port
);
1063 set_bit(TTY_IO_ERROR
, &tty
->flags
);
1065 err
= dma_fifo_alloc(&port
->tx_fifo
, FWTTY_PORT_TXFIFO_LEN
,
1068 FWTTY_PORT_MAX_PEND_DMA
,
1073 spin_lock_bh(&port
->lock
);
1075 baud
= set_termios(port
, tty
);
1077 /* if console, don't change carrier state */
1078 if (!port
->port
.console
) {
1081 port
->mctrl
= TIOCM_DTR
| TIOCM_RTS
;
1084 if (C_CRTSCTS(tty
) && ~port
->mstatus
& TIOCM_CTS
)
1085 tty
->hw_stopped
= 1;
1087 __fwtty_write_port_status(port
);
1088 spin_unlock_bh(&port
->lock
);
1090 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
1096 * fwtty_port_shutdown
1098 * Note: the tty port core ensures this is not the console and
1099 * manages TTY_IO_ERROR properly
1101 static void fwtty_port_shutdown(struct tty_port
*tty_port
)
1103 struct fwtty_port
*port
= to_port(tty_port
, port
);
1104 struct buffered_rx
*buf
, *next
;
1106 /* TODO: cancel outstanding transactions */
1108 cancel_delayed_work_sync(&port
->emit_breaks
);
1109 cancel_delayed_work_sync(&port
->drain
);
1110 cancel_work_sync(&port
->push
);
1112 spin_lock_bh(&port
->lock
);
1113 list_for_each_entry_safe(buf
, next
, &port
->buf_list
, list
) {
1114 list_del(&buf
->list
);
1119 port
->break_ctl
= 0;
1121 __fwtty_write_port_status(port
);
1122 dma_fifo_free(&port
->tx_fifo
);
1123 spin_unlock_bh(&port
->lock
);
1126 static int fwtty_open(struct tty_struct
*tty
, struct file
*fp
)
1128 struct fwtty_port
*port
= tty
->driver_data
;
1130 return tty_port_open(&port
->port
, tty
, fp
);
1133 static void fwtty_close(struct tty_struct
*tty
, struct file
*fp
)
1135 struct fwtty_port
*port
= tty
->driver_data
;
1137 tty_port_close(&port
->port
, tty
, fp
);
1140 static void fwtty_hangup(struct tty_struct
*tty
)
1142 struct fwtty_port
*port
= tty
->driver_data
;
1144 tty_port_hangup(&port
->port
);
1147 static void fwtty_cleanup(struct tty_struct
*tty
)
1149 struct fwtty_port
*port
= tty
->driver_data
;
1151 tty
->driver_data
= NULL
;
1152 fwtty_port_put(port
);
1155 static int fwtty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1157 struct fwtty_port
*port
= fwtty_port_get(tty
->index
);
1160 err
= tty_standard_install(driver
, tty
);
1162 tty
->driver_data
= port
;
1164 fwtty_port_put(port
);
1168 static int fwloop_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1170 struct fwtty_port
*port
= fwtty_port_get(table_idx(tty
->index
));
1173 err
= tty_standard_install(driver
, tty
);
1175 tty
->driver_data
= port
;
1177 fwtty_port_put(port
);
1181 static int fwtty_write(struct tty_struct
*tty
, const unsigned char *buf
, int c
)
1183 struct fwtty_port
*port
= tty
->driver_data
;
1186 fwtty_dbg(port
, "%d\n", c
);
1187 profile_size_distrib(port
->stats
.writes
, c
);
1189 spin_lock_bh(&port
->lock
);
1190 n
= dma_fifo_in(&port
->tx_fifo
, buf
, c
);
1191 len
= dma_fifo_out_level(&port
->tx_fifo
);
1192 if (len
< DRAIN_THRESHOLD
)
1193 schedule_delayed_work(&port
->drain
, 1);
1194 spin_unlock_bh(&port
->lock
);
1196 if (len
>= DRAIN_THRESHOLD
)
1197 fwtty_tx(port
, false);
1199 debug_short_write(port
, c
, n
);
1201 return (n
< 0) ? 0 : n
;
1204 static int fwtty_write_room(struct tty_struct
*tty
)
1206 struct fwtty_port
*port
= tty
->driver_data
;
1209 spin_lock_bh(&port
->lock
);
1210 n
= dma_fifo_avail(&port
->tx_fifo
);
1211 spin_unlock_bh(&port
->lock
);
1213 fwtty_dbg(port
, "%d\n", n
);
1218 static int fwtty_chars_in_buffer(struct tty_struct
*tty
)
1220 struct fwtty_port
*port
= tty
->driver_data
;
1223 spin_lock_bh(&port
->lock
);
1224 n
= dma_fifo_level(&port
->tx_fifo
);
1225 spin_unlock_bh(&port
->lock
);
1227 fwtty_dbg(port
, "%d\n", n
);
1232 static void fwtty_send_xchar(struct tty_struct
*tty
, char ch
)
1234 struct fwtty_port
*port
= tty
->driver_data
;
1236 fwtty_dbg(port
, "%02x\n", ch
);
1238 fwtty_write_xchar(port
, ch
);
1241 static void fwtty_throttle(struct tty_struct
*tty
)
1243 struct fwtty_port
*port
= tty
->driver_data
;
1246 * Ignore throttling (but not unthrottling).
1247 * It only makes sense to throttle when data will no longer be
1248 * accepted by the tty flip buffer. For example, it is
1249 * possible for received data to overflow the tty buffer long
1250 * before the line discipline ever has a chance to throttle the driver.
1251 * Additionally, the driver may have already completed the I/O
1252 * but the tty buffer is still emptying, so the line discipline is
1253 * throttling and unthrottling nothing.
1256 ++port
->stats
.throttled
;
1259 static void fwtty_unthrottle(struct tty_struct
*tty
)
1261 struct fwtty_port
*port
= tty
->driver_data
;
1263 fwtty_dbg(port
, "CRTSCTS: %d\n", (C_CRTSCTS(tty
) != 0));
1265 profile_fifo_avail(port
, port
->stats
.unthrottle
);
1267 schedule_work(&port
->push
);
1269 spin_lock_bh(&port
->lock
);
1270 port
->mctrl
&= ~OOB_RX_THROTTLE
;
1272 port
->mctrl
|= TIOCM_RTS
;
1273 __fwtty_write_port_status(port
);
1274 spin_unlock_bh(&port
->lock
);
1277 static int check_msr_delta(struct fwtty_port
*port
, unsigned long mask
,
1278 struct async_icount
*prev
)
1280 struct async_icount now
;
1285 delta
= ((mask
& TIOCM_RNG
&& prev
->rng
!= now
.rng
) ||
1286 (mask
& TIOCM_DSR
&& prev
->dsr
!= now
.dsr
) ||
1287 (mask
& TIOCM_CAR
&& prev
->dcd
!= now
.dcd
) ||
1288 (mask
& TIOCM_CTS
&& prev
->cts
!= now
.cts
));
1295 static int wait_msr_change(struct fwtty_port
*port
, unsigned long mask
)
1297 struct async_icount prev
;
1299 prev
= port
->icount
;
1301 return wait_event_interruptible(port
->port
.delta_msr_wait
,
1302 check_msr_delta(port
, mask
, &prev
));
1305 static int get_serial_info(struct fwtty_port
*port
,
1306 struct serial_struct __user
*info
)
1308 struct serial_struct tmp
;
1310 memset(&tmp
, 0, sizeof(tmp
));
1312 tmp
.type
= PORT_UNKNOWN
;
1313 tmp
.line
= port
->port
.tty
->index
;
1314 tmp
.flags
= port
->port
.flags
;
1315 tmp
.xmit_fifo_size
= FWTTY_PORT_TXFIFO_LEN
;
1316 tmp
.baud_base
= 400000000;
1317 tmp
.close_delay
= port
->port
.close_delay
;
1319 return (copy_to_user(info
, &tmp
, sizeof(*info
))) ? -EFAULT
: 0;
1322 static int set_serial_info(struct fwtty_port
*port
,
1323 struct serial_struct __user
*info
)
1325 struct serial_struct tmp
;
1327 if (copy_from_user(&tmp
, info
, sizeof(tmp
)))
1330 if (tmp
.irq
!= 0 || tmp
.port
!= 0 || tmp
.custom_divisor
!= 0 ||
1331 tmp
.baud_base
!= 400000000)
1334 if (!capable(CAP_SYS_ADMIN
)) {
1335 if (((tmp
.flags
& ~ASYNC_USR_MASK
) !=
1336 (port
->port
.flags
& ~ASYNC_USR_MASK
)))
1339 port
->port
.close_delay
= tmp
.close_delay
* HZ
/ 100;
1344 static int fwtty_ioctl(struct tty_struct
*tty
, unsigned cmd
,
1347 struct fwtty_port
*port
= tty
->driver_data
;
1352 mutex_lock(&port
->port
.mutex
);
1353 err
= get_serial_info(port
, (void __user
*)arg
);
1354 mutex_unlock(&port
->port
.mutex
);
1358 mutex_lock(&port
->port
.mutex
);
1359 err
= set_serial_info(port
, (void __user
*)arg
);
1360 mutex_unlock(&port
->port
.mutex
);
1364 err
= wait_msr_change(port
, arg
);
1374 static void fwtty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1376 struct fwtty_port
*port
= tty
->driver_data
;
1379 spin_lock_bh(&port
->lock
);
1380 baud
= set_termios(port
, tty
);
1382 if ((baud
== 0) && (old
->c_cflag
& CBAUD
))
1383 port
->mctrl
&= ~(TIOCM_DTR
| TIOCM_RTS
);
1384 else if ((baud
!= 0) && !(old
->c_cflag
& CBAUD
)) {
1385 if (C_CRTSCTS(tty
) || !test_bit(TTY_THROTTLED
, &tty
->flags
))
1386 port
->mctrl
|= TIOCM_DTR
| TIOCM_RTS
;
1388 port
->mctrl
|= TIOCM_DTR
;
1390 __fwtty_write_port_status(port
);
1391 spin_unlock_bh(&port
->lock
);
1393 if (old
->c_cflag
& CRTSCTS
) {
1394 if (!C_CRTSCTS(tty
)) {
1395 tty
->hw_stopped
= 0;
1396 fwtty_restart_tx(port
);
1398 } else if (C_CRTSCTS(tty
) && ~port
->mstatus
& TIOCM_CTS
) {
1399 tty
->hw_stopped
= 1;
1404 * fwtty_break_ctl - start/stop sending breaks
1406 * Signals the remote to start or stop generating simulated breaks.
1407 * First, stop dequeueing from the fifo and wait for writer/drain to leave tx
1408 * before signalling the break line status. This guarantees any pending rx will
1409 * be queued to the line discipline before break is simulated on the remote.
1410 * Conversely, turning off break_ctl requires signalling the line status change,
1413 static int fwtty_break_ctl(struct tty_struct
*tty
, int state
)
1415 struct fwtty_port
*port
= tty
->driver_data
;
1418 fwtty_dbg(port
, "%d\n", state
);
1421 set_bit(STOP_TX
, &port
->flags
);
1422 ret
= wait_event_interruptible_timeout(port
->wait_tx
,
1423 !test_bit(IN_TX
, &port
->flags
),
1425 if (ret
== 0 || ret
== -ERESTARTSYS
) {
1426 clear_bit(STOP_TX
, &port
->flags
);
1427 fwtty_restart_tx(port
);
1432 spin_lock_bh(&port
->lock
);
1433 port
->break_ctl
= (state
== -1);
1434 __fwtty_write_port_status(port
);
1435 spin_unlock_bh(&port
->lock
);
1438 spin_lock_bh(&port
->lock
);
1439 dma_fifo_reset(&port
->tx_fifo
);
1440 clear_bit(STOP_TX
, &port
->flags
);
1441 spin_unlock_bh(&port
->lock
);
1446 static int fwtty_tiocmget(struct tty_struct
*tty
)
1448 struct fwtty_port
*port
= tty
->driver_data
;
1451 spin_lock_bh(&port
->lock
);
1452 tiocm
= (port
->mctrl
& MCTRL_MASK
) | (port
->mstatus
& ~MCTRL_MASK
);
1453 spin_unlock_bh(&port
->lock
);
1455 fwtty_dbg(port
, "%x\n", tiocm
);
1460 static int fwtty_tiocmset(struct tty_struct
*tty
, unsigned set
, unsigned clear
)
1462 struct fwtty_port
*port
= tty
->driver_data
;
1464 fwtty_dbg(port
, "set: %x clear: %x\n", set
, clear
);
1466 /* TODO: simulate loopback if TIOCM_LOOP set */
1468 spin_lock_bh(&port
->lock
);
1469 port
->mctrl
&= ~(clear
& MCTRL_MASK
& 0xffff);
1470 port
->mctrl
|= set
& MCTRL_MASK
& 0xffff;
1471 __fwtty_write_port_status(port
);
1472 spin_unlock_bh(&port
->lock
);
1476 static int fwtty_get_icount(struct tty_struct
*tty
,
1477 struct serial_icounter_struct
*icount
)
1479 struct fwtty_port
*port
= tty
->driver_data
;
1482 memcpy(&stats
, &port
->stats
, sizeof(stats
));
1483 if (port
->port
.console
)
1484 (*port
->fwcon_ops
->stats
)(&stats
, port
->con_data
);
1486 icount
->cts
= port
->icount
.cts
;
1487 icount
->dsr
= port
->icount
.dsr
;
1488 icount
->rng
= port
->icount
.rng
;
1489 icount
->dcd
= port
->icount
.dcd
;
1490 icount
->rx
= port
->icount
.rx
;
1491 icount
->tx
= port
->icount
.tx
+ stats
.xchars
;
1492 icount
->frame
= port
->icount
.frame
;
1493 icount
->overrun
= port
->icount
.overrun
;
1494 icount
->parity
= port
->icount
.parity
;
1495 icount
->brk
= port
->icount
.brk
;
1496 icount
->buf_overrun
= port
->icount
.overrun
;
1500 static void fwtty_proc_show_port(struct seq_file
*m
, struct fwtty_port
*port
)
1504 memcpy(&stats
, &port
->stats
, sizeof(stats
));
1505 if (port
->port
.console
)
1506 (*port
->fwcon_ops
->stats
)(&stats
, port
->con_data
);
1508 seq_printf(m
, " addr:%012llx tx:%d rx:%d", port
->rx_handler
.offset
,
1509 port
->icount
.tx
+ stats
.xchars
, port
->icount
.rx
);
1510 seq_printf(m
, " cts:%d dsr:%d rng:%d dcd:%d", port
->icount
.cts
,
1511 port
->icount
.dsr
, port
->icount
.rng
, port
->icount
.dcd
);
1512 seq_printf(m
, " fe:%d oe:%d pe:%d brk:%d", port
->icount
.frame
,
1513 port
->icount
.overrun
, port
->icount
.parity
, port
->icount
.brk
);
1516 static void fwtty_debugfs_show_port(struct seq_file
*m
, struct fwtty_port
*port
)
1520 memcpy(&stats
, &port
->stats
, sizeof(stats
));
1521 if (port
->port
.console
)
1522 (*port
->fwcon_ops
->stats
)(&stats
, port
->con_data
);
1524 seq_printf(m
, " dr:%d st:%d err:%d lost:%d", stats
.dropped
,
1525 stats
.tx_stall
, stats
.fifo_errs
, stats
.lost
);
1526 seq_printf(m
, " pkts:%d thr:%d wtrmk:%d", stats
.sent
, stats
.throttled
,
1529 if (port
->port
.console
) {
1531 (*port
->fwcon_ops
->proc_show
)(m
, port
->con_data
);
1534 dump_profile(m
, &port
->stats
);
1537 static void fwtty_debugfs_show_peer(struct seq_file
*m
, struct fwtty_peer
*peer
)
1539 int generation
= peer
->generation
;
1542 seq_printf(m
, " %s:", dev_name(&peer
->unit
->device
));
1543 seq_printf(m
, " node:%04x gen:%d", peer
->node_id
, generation
);
1544 seq_printf(m
, " sp:%d max:%d guid:%016llx", peer
->speed
,
1545 peer
->max_payload
, (unsigned long long) peer
->guid
);
1546 seq_printf(m
, " mgmt:%012llx", (unsigned long long) peer
->mgmt_addr
);
1547 seq_printf(m
, " addr:%012llx", (unsigned long long) peer
->status_addr
);
1551 static int fwtty_proc_show(struct seq_file
*m
, void *v
)
1553 struct fwtty_port
*port
;
1556 seq_puts(m
, "fwserinfo: 1.0 driver: 1.0\n");
1557 for (i
= 0; i
< MAX_TOTAL_PORTS
&& (port
= fwtty_port_get(i
)); ++i
) {
1558 seq_printf(m
, "%2d:", i
);
1559 if (capable(CAP_SYS_ADMIN
))
1560 fwtty_proc_show_port(m
, port
);
1561 fwtty_port_put(port
);
1567 static int fwtty_debugfs_stats_show(struct seq_file
*m
, void *v
)
1569 struct fw_serial
*serial
= m
->private;
1570 struct fwtty_port
*port
;
1573 for (i
= 0; i
< num_ports
; ++i
) {
1574 port
= fwtty_port_get(serial
->ports
[i
]->index
);
1576 seq_printf(m
, "%2d:", port
->index
);
1577 fwtty_proc_show_port(m
, port
);
1578 fwtty_debugfs_show_port(m
, port
);
1579 fwtty_port_put(port
);
1586 static int fwtty_debugfs_peers_show(struct seq_file
*m
, void *v
)
1588 struct fw_serial
*serial
= m
->private;
1589 struct fwtty_peer
*peer
;
1592 seq_printf(m
, "card: %s guid: %016llx\n",
1593 dev_name(serial
->card
->device
),
1594 (unsigned long long) serial
->card
->guid
);
1595 list_for_each_entry_rcu(peer
, &serial
->peer_list
, list
)
1596 fwtty_debugfs_show_peer(m
, peer
);
1601 static int fwtty_proc_open(struct inode
*inode
, struct file
*fp
)
1603 return single_open(fp
, fwtty_proc_show
, NULL
);
1606 static int fwtty_stats_open(struct inode
*inode
, struct file
*fp
)
1608 return single_open(fp
, fwtty_debugfs_stats_show
, inode
->i_private
);
1611 static int fwtty_peers_open(struct inode
*inode
, struct file
*fp
)
1613 return single_open(fp
, fwtty_debugfs_peers_show
, inode
->i_private
);
1616 static const struct file_operations fwtty_stats_fops
= {
1617 .owner
= THIS_MODULE
,
1618 .open
= fwtty_stats_open
,
1620 .llseek
= seq_lseek
,
1621 .release
= single_release
,
1624 static const struct file_operations fwtty_peers_fops
= {
1625 .owner
= THIS_MODULE
,
1626 .open
= fwtty_peers_open
,
1628 .llseek
= seq_lseek
,
1629 .release
= single_release
,
1632 static const struct file_operations fwtty_proc_fops
= {
1633 .owner
= THIS_MODULE
,
1634 .open
= fwtty_proc_open
,
1636 .llseek
= seq_lseek
,
1637 .release
= single_release
,
1640 static const struct tty_port_operations fwtty_port_ops
= {
1641 .dtr_rts
= fwtty_port_dtr_rts
,
1642 .carrier_raised
= fwtty_port_carrier_raised
,
1643 .shutdown
= fwtty_port_shutdown
,
1644 .activate
= fwtty_port_activate
,
1647 static const struct tty_operations fwtty_ops
= {
1649 .close
= fwtty_close
,
1650 .hangup
= fwtty_hangup
,
1651 .cleanup
= fwtty_cleanup
,
1652 .install
= fwtty_install
,
1653 .write
= fwtty_write
,
1654 .write_room
= fwtty_write_room
,
1655 .chars_in_buffer
= fwtty_chars_in_buffer
,
1656 .send_xchar
= fwtty_send_xchar
,
1657 .throttle
= fwtty_throttle
,
1658 .unthrottle
= fwtty_unthrottle
,
1659 .ioctl
= fwtty_ioctl
,
1660 .set_termios
= fwtty_set_termios
,
1661 .break_ctl
= fwtty_break_ctl
,
1662 .tiocmget
= fwtty_tiocmget
,
1663 .tiocmset
= fwtty_tiocmset
,
1664 .get_icount
= fwtty_get_icount
,
1665 .proc_fops
= &fwtty_proc_fops
,
1668 static const struct tty_operations fwloop_ops
= {
1670 .close
= fwtty_close
,
1671 .hangup
= fwtty_hangup
,
1672 .cleanup
= fwtty_cleanup
,
1673 .install
= fwloop_install
,
1674 .write
= fwtty_write
,
1675 .write_room
= fwtty_write_room
,
1676 .chars_in_buffer
= fwtty_chars_in_buffer
,
1677 .send_xchar
= fwtty_send_xchar
,
1678 .throttle
= fwtty_throttle
,
1679 .unthrottle
= fwtty_unthrottle
,
1680 .ioctl
= fwtty_ioctl
,
1681 .set_termios
= fwtty_set_termios
,
1682 .break_ctl
= fwtty_break_ctl
,
1683 .tiocmget
= fwtty_tiocmget
,
1684 .tiocmset
= fwtty_tiocmset
,
1685 .get_icount
= fwtty_get_icount
,
1688 static inline int mgmt_pkt_expected_len(__be16 code
)
1690 static const struct fwserial_mgmt_pkt pkt
;
1692 switch (be16_to_cpu(code
)) {
1693 case FWSC_VIRT_CABLE_PLUG
:
1694 return sizeof(pkt
.hdr
) + sizeof(pkt
.plug_req
);
1696 case FWSC_VIRT_CABLE_PLUG_RSP
: /* | FWSC_RSP_OK */
1697 return sizeof(pkt
.hdr
) + sizeof(pkt
.plug_rsp
);
1700 case FWSC_VIRT_CABLE_UNPLUG
:
1701 case FWSC_VIRT_CABLE_UNPLUG_RSP
:
1702 case FWSC_VIRT_CABLE_PLUG_RSP
| FWSC_RSP_NACK
:
1703 case FWSC_VIRT_CABLE_UNPLUG_RSP
| FWSC_RSP_NACK
:
1704 return sizeof(pkt
.hdr
);
1711 static inline void fill_plug_params(struct virt_plug_params
*params
,
1712 struct fwtty_port
*port
)
1714 u64 status_addr
= port
->rx_handler
.offset
;
1715 u64 fifo_addr
= port
->rx_handler
.offset
+ 4;
1716 size_t fifo_len
= port
->rx_handler
.length
- 4;
1718 params
->status_hi
= cpu_to_be32(status_addr
>> 32);
1719 params
->status_lo
= cpu_to_be32(status_addr
);
1720 params
->fifo_hi
= cpu_to_be32(fifo_addr
>> 32);
1721 params
->fifo_lo
= cpu_to_be32(fifo_addr
);
1722 params
->fifo_len
= cpu_to_be32(fifo_len
);
1725 static inline void fill_plug_req(struct fwserial_mgmt_pkt
*pkt
,
1726 struct fwtty_port
*port
)
1728 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_PLUG
);
1729 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1730 fill_plug_params(&pkt
->plug_req
, port
);
1733 static inline void fill_plug_rsp_ok(struct fwserial_mgmt_pkt
*pkt
,
1734 struct fwtty_port
*port
)
1736 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_PLUG_RSP
);
1737 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1738 fill_plug_params(&pkt
->plug_rsp
, port
);
1741 static inline void fill_plug_rsp_nack(struct fwserial_mgmt_pkt
*pkt
)
1743 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_PLUG_RSP
| FWSC_RSP_NACK
);
1744 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1747 static inline void fill_unplug_req(struct fwserial_mgmt_pkt
*pkt
)
1749 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG
);
1750 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1753 static inline void fill_unplug_rsp_nack(struct fwserial_mgmt_pkt
*pkt
)
1755 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG_RSP
| FWSC_RSP_NACK
);
1756 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1759 static inline void fill_unplug_rsp_ok(struct fwserial_mgmt_pkt
*pkt
)
1761 pkt
->hdr
.code
= cpu_to_be16(FWSC_VIRT_CABLE_UNPLUG_RSP
);
1762 pkt
->hdr
.len
= cpu_to_be16(mgmt_pkt_expected_len(pkt
->hdr
.code
));
1765 static void fwserial_virt_plug_complete(struct fwtty_peer
*peer
,
1766 struct virt_plug_params
*params
)
1768 struct fwtty_port
*port
= peer
->port
;
1770 peer
->status_addr
= be32_to_u64(params
->status_hi
, params
->status_lo
);
1771 peer
->fifo_addr
= be32_to_u64(params
->fifo_hi
, params
->fifo_lo
);
1772 peer
->fifo_len
= be32_to_cpu(params
->fifo_len
);
1773 peer_set_state(peer
, FWPS_ATTACHED
);
1775 /* reconfigure tx_fifo optimally for this peer */
1776 spin_lock_bh(&port
->lock
);
1777 port
->max_payload
= min(peer
->max_payload
, peer
->fifo_len
);
1778 dma_fifo_change_tx_limit(&port
->tx_fifo
, port
->max_payload
);
1779 spin_unlock_bh(&peer
->port
->lock
);
1781 if (port
->port
.console
&& port
->fwcon_ops
->notify
!= NULL
)
1782 (*port
->fwcon_ops
->notify
)(FWCON_NOTIFY_ATTACH
, port
->con_data
);
1784 fwtty_info(&peer
->unit
, "peer (guid:%016llx) connected on %s\n",
1785 (unsigned long long)peer
->guid
, dev_name(port
->device
));
1788 static inline int fwserial_send_mgmt_sync(struct fwtty_peer
*peer
,
1789 struct fwserial_mgmt_pkt
*pkt
)
1792 int rcode
, tries
= 5;
1795 generation
= peer
->generation
;
1798 rcode
= fw_run_transaction(peer
->serial
->card
,
1799 TCODE_WRITE_BLOCK_REQUEST
,
1801 generation
, peer
->speed
,
1803 pkt
, be16_to_cpu(pkt
->hdr
.len
));
1804 if (rcode
== RCODE_BUSY
|| rcode
== RCODE_SEND_ERROR
||
1805 rcode
== RCODE_GENERATION
) {
1806 fwtty_dbg(&peer
->unit
, "mgmt write error: %d\n", rcode
);
1810 } while (--tries
> 0);
1815 * fwserial_claim_port - attempt to claim port @ index for peer
1817 * Returns ptr to claimed port or error code (as ERR_PTR())
1818 * Can sleep - must be called from process context
1820 static struct fwtty_port
*fwserial_claim_port(struct fwtty_peer
*peer
,
1823 struct fwtty_port
*port
;
1825 if (index
< 0 || index
>= num_ports
)
1826 return ERR_PTR(-EINVAL
);
1828 /* must guarantee that previous port releases have completed */
1831 port
= peer
->serial
->ports
[index
];
1832 spin_lock_bh(&port
->lock
);
1833 if (!rcu_access_pointer(port
->peer
))
1834 rcu_assign_pointer(port
->peer
, peer
);
1836 port
= ERR_PTR(-EBUSY
);
1837 spin_unlock_bh(&port
->lock
);
1843 * fwserial_find_port - find avail port and claim for peer
1845 * Returns ptr to claimed port or NULL if none avail
1846 * Can sleep - must be called from process context
1848 static struct fwtty_port
*fwserial_find_port(struct fwtty_peer
*peer
)
1850 struct fwtty_port
**ports
= peer
->serial
->ports
;
1853 /* must guarantee that previous port releases have completed */
1856 /* TODO: implement optional GUID-to-specific port # matching */
1858 /* find an unattached port (but not the loopback port, if present) */
1859 for (i
= 0; i
< num_ttys
; ++i
) {
1860 spin_lock_bh(&ports
[i
]->lock
);
1861 if (!ports
[i
]->peer
) {
1863 rcu_assign_pointer(ports
[i
]->peer
, peer
);
1864 spin_unlock_bh(&ports
[i
]->lock
);
1867 spin_unlock_bh(&ports
[i
]->lock
);
1872 static void fwserial_release_port(struct fwtty_port
*port
, bool reset
)
1874 /* drop carrier (and all other line status) */
1876 fwtty_update_port_status(port
, 0);
1878 spin_lock_bh(&port
->lock
);
1880 /* reset dma fifo max transmission size back to S100 */
1881 port
->max_payload
= link_speed_to_max_payload(SCODE_100
);
1882 dma_fifo_change_tx_limit(&port
->tx_fifo
, port
->max_payload
);
1884 rcu_assign_pointer(port
->peer
, NULL
);
1885 spin_unlock_bh(&port
->lock
);
1887 if (port
->port
.console
&& port
->fwcon_ops
->notify
!= NULL
)
1888 (*port
->fwcon_ops
->notify
)(FWCON_NOTIFY_DETACH
, port
->con_data
);
1891 static void fwserial_plug_timeout(unsigned long data
)
1893 struct fwtty_peer
*peer
= (struct fwtty_peer
*) data
;
1894 struct fwtty_port
*port
;
1896 spin_lock_bh(&peer
->lock
);
1897 if (peer
->state
!= FWPS_PLUG_PENDING
) {
1898 spin_unlock_bh(&peer
->lock
);
1902 port
= peer_revert_state(peer
);
1903 spin_unlock_bh(&peer
->lock
);
1906 fwserial_release_port(port
, false);
1910 * fwserial_connect_peer - initiate virtual cable with peer
1912 * Returns 0 if VIRT_CABLE_PLUG request was successfully sent,
1913 * otherwise error code. Must be called from process context.
1915 static int fwserial_connect_peer(struct fwtty_peer
*peer
)
1917 struct fwtty_port
*port
;
1918 struct fwserial_mgmt_pkt
*pkt
;
1921 pkt
= kmalloc(sizeof(*pkt
), GFP_KERNEL
);
1925 port
= fwserial_find_port(peer
);
1927 fwtty_err(&peer
->unit
, "avail ports in use\n");
1932 spin_lock_bh(&peer
->lock
);
1934 /* only initiate VIRT_CABLE_PLUG if peer is currently not attached */
1935 if (peer
->state
!= FWPS_NOT_ATTACHED
) {
1941 peer_set_state(peer
, FWPS_PLUG_PENDING
);
1943 fill_plug_req(pkt
, peer
->port
);
1945 setup_timer(&peer
->timer
, fwserial_plug_timeout
, (unsigned long)peer
);
1946 mod_timer(&peer
->timer
, jiffies
+ VIRT_CABLE_PLUG_TIMEOUT
);
1947 spin_unlock_bh(&peer
->lock
);
1949 rcode
= fwserial_send_mgmt_sync(peer
, pkt
);
1951 spin_lock_bh(&peer
->lock
);
1952 if (peer
->state
== FWPS_PLUG_PENDING
&& rcode
!= RCODE_COMPLETE
) {
1953 if (rcode
== RCODE_CONFLICT_ERROR
)
1959 spin_unlock_bh(&peer
->lock
);
1965 del_timer(&peer
->timer
);
1966 peer_revert_state(peer
);
1968 spin_unlock_bh(&peer
->lock
);
1969 fwserial_release_port(port
, false);
1976 * fwserial_close_port -
1977 * HUP the tty (if the tty exists) and unregister the tty device.
1978 * Only used by the unit driver upon unit removal to disconnect and
1979 * cleanup all attached ports
1981 * The port reference is put by fwtty_cleanup (if a reference was
1984 static void fwserial_close_port(struct tty_driver
*driver
,
1985 struct fwtty_port
*port
)
1987 struct tty_struct
*tty
;
1989 mutex_lock(&port
->port
.mutex
);
1990 tty
= tty_port_tty_get(&port
->port
);
1995 mutex_unlock(&port
->port
.mutex
);
1997 if (driver
== fwloop_driver
)
1998 tty_unregister_device(driver
, loop_idx(port
));
2000 tty_unregister_device(driver
, port
->index
);
2004 * fwserial_lookup - finds first fw_serial associated with card
2005 * @card: fw_card to match
2007 * NB: caller must be holding fwserial_list_mutex
2009 static struct fw_serial
*fwserial_lookup(struct fw_card
*card
)
2011 struct fw_serial
*serial
;
2013 list_for_each_entry(serial
, &fwserial_list
, list
) {
2014 if (card
== serial
->card
)
2022 * __fwserial_lookup_rcu - finds first fw_serial associated with card
2023 * @card: fw_card to match
2025 * NB: caller must be inside rcu_read_lock() section
2027 static struct fw_serial
*__fwserial_lookup_rcu(struct fw_card
*card
)
2029 struct fw_serial
*serial
;
2031 list_for_each_entry_rcu(serial
, &fwserial_list
, list
) {
2032 if (card
== serial
->card
)
2040 * __fwserial_peer_by_node_id - finds a peer matching the given generation + id
2042 * If a matching peer could not be found for the specified generation/node id,
2043 * this could be because:
2044 * a) the generation has changed and one of the nodes hasn't updated yet
2045 * b) the remote node has created its remote unit device before this
2046 * local node has created its corresponding remote unit device
2047 * In either case, the remote node should retry
2049 * Note: caller must be in rcu_read_lock() section
2051 static struct fwtty_peer
*__fwserial_peer_by_node_id(struct fw_card
*card
,
2052 int generation
, int id
)
2054 struct fw_serial
*serial
;
2055 struct fwtty_peer
*peer
;
2057 serial
= __fwserial_lookup_rcu(card
);
2060 * Something is very wrong - there should be a matching
2061 * fw_serial structure for every fw_card. Maybe the remote node
2062 * has created its remote unit device before this driver has
2063 * been probed for any unit devices...
2065 fwtty_err(card
, "unknown card (guid %016llx)\n",
2066 (unsigned long long) card
->guid
);
2070 list_for_each_entry_rcu(peer
, &serial
->peer_list
, list
) {
2071 int g
= peer
->generation
;
2073 if (generation
== g
&& id
== peer
->node_id
)
2081 static void __dump_peer_list(struct fw_card
*card
)
2083 struct fw_serial
*serial
;
2084 struct fwtty_peer
*peer
;
2086 serial
= __fwserial_lookup_rcu(card
);
2090 list_for_each_entry_rcu(peer
, &serial
->peer_list
, list
) {
2091 int g
= peer
->generation
;
2093 fwtty_dbg(card
, "peer(%d:%x) guid: %016llx\n",
2094 g
, peer
->node_id
, (unsigned long long) peer
->guid
);
2098 #define __dump_peer_list(s)
2101 static void fwserial_auto_connect(struct work_struct
*work
)
2103 struct fwtty_peer
*peer
= to_peer(to_delayed_work(work
), connect
);
2106 err
= fwserial_connect_peer(peer
);
2107 if (err
== -EAGAIN
&& ++peer
->connect_retries
< MAX_CONNECT_RETRIES
)
2108 schedule_delayed_work(&peer
->connect
, CONNECT_RETRY_DELAY
);
2112 * fwserial_add_peer - add a newly probed 'serial' unit device as a 'peer'
2113 * @serial: aggregate representing the specific fw_card to add the peer to
2114 * @unit: 'peer' to create and add to peer_list of serial
2116 * Adds a 'peer' (ie, a local or remote 'serial' unit device) to the list of
2117 * peers for a specific fw_card. Optionally, auto-attach this peer to an
2118 * available tty port. This function is called either directly or indirectly
2119 * as a result of a 'serial' unit device being created & probed.
2121 * Note: this function is serialized with fwserial_remove_peer() by the
2122 * fwserial_list_mutex held in fwserial_probe().
2124 * A 1:1 correspondence between an fw_unit and an fwtty_peer is maintained
2125 * via the dev_set_drvdata() for the device of the fw_unit.
2127 static int fwserial_add_peer(struct fw_serial
*serial
, struct fw_unit
*unit
)
2129 struct device
*dev
= &unit
->device
;
2130 struct fw_device
*parent
= fw_parent_device(unit
);
2131 struct fwtty_peer
*peer
;
2132 struct fw_csr_iterator ci
;
2136 peer
= kzalloc(sizeof(*peer
), GFP_KERNEL
);
2140 peer_set_state(peer
, FWPS_NOT_ATTACHED
);
2142 dev_set_drvdata(dev
, peer
);
2144 peer
->guid
= (u64
)parent
->config_rom
[3] << 32 | parent
->config_rom
[4];
2145 peer
->speed
= parent
->max_speed
;
2146 peer
->max_payload
= min(device_max_receive(parent
),
2147 link_speed_to_max_payload(peer
->speed
));
2149 generation
= parent
->generation
;
2151 peer
->node_id
= parent
->node_id
;
2153 peer
->generation
= generation
;
2155 /* retrieve the mgmt bus addr from the unit directory */
2156 fw_csr_iterator_init(&ci
, unit
->directory
);
2157 while (fw_csr_iterator_next(&ci
, &key
, &val
)) {
2158 if (key
== (CSR_OFFSET
| CSR_DEPENDENT_INFO
)) {
2159 peer
->mgmt_addr
= CSR_REGISTER_BASE
+ 4 * val
;
2163 if (peer
->mgmt_addr
== 0ULL) {
2165 * No mgmt address effectively disables VIRT_CABLE_PLUG -
2166 * this peer will not be able to attach to a remote
2168 peer_set_state(peer
, FWPS_NO_MGMT_ADDR
);
2171 spin_lock_init(&peer
->lock
);
2174 init_timer(&peer
->timer
);
2175 INIT_WORK(&peer
->work
, NULL
);
2176 INIT_DELAYED_WORK(&peer
->connect
, fwserial_auto_connect
);
2178 /* associate peer with specific fw_card */
2179 peer
->serial
= serial
;
2180 list_add_rcu(&peer
->list
, &serial
->peer_list
);
2182 fwtty_info(&peer
->unit
, "peer added (guid:%016llx)\n",
2183 (unsigned long long)peer
->guid
);
2185 /* identify the local unit & virt cable to loopback port */
2186 if (parent
->is_local
) {
2187 serial
->self
= peer
;
2188 if (create_loop_dev
) {
2189 struct fwtty_port
*port
;
2190 port
= fwserial_claim_port(peer
, num_ttys
);
2191 if (!IS_ERR(port
)) {
2192 struct virt_plug_params params
;
2194 spin_lock_bh(&peer
->lock
);
2196 fill_plug_params(¶ms
, port
);
2197 fwserial_virt_plug_complete(peer
, ¶ms
);
2198 spin_unlock_bh(&peer
->lock
);
2200 fwtty_write_port_status(port
);
2204 } else if (auto_connect
) {
2205 /* auto-attach to remote units only (if policy allows) */
2206 schedule_delayed_work(&peer
->connect
, 1);
2213 * fwserial_remove_peer - remove a 'serial' unit device as a 'peer'
2215 * Remove a 'peer' from its list of peers. This function is only
2216 * called by fwserial_remove() on bus removal of the unit device.
2218 * Note: this function is serialized with fwserial_add_peer() by the
2219 * fwserial_list_mutex held in fwserial_remove().
2221 static void fwserial_remove_peer(struct fwtty_peer
*peer
)
2223 struct fwtty_port
*port
;
2225 spin_lock_bh(&peer
->lock
);
2226 peer_set_state(peer
, FWPS_GONE
);
2227 spin_unlock_bh(&peer
->lock
);
2229 cancel_delayed_work_sync(&peer
->connect
);
2230 cancel_work_sync(&peer
->work
);
2232 spin_lock_bh(&peer
->lock
);
2233 /* if this unit is the local unit, clear link */
2234 if (peer
== peer
->serial
->self
)
2235 peer
->serial
->self
= NULL
;
2237 /* cancel the request timeout timer (if running) */
2238 del_timer(&peer
->timer
);
2243 list_del_rcu(&peer
->list
);
2245 fwtty_info(&peer
->unit
, "peer removed (guid:%016llx)\n",
2246 (unsigned long long)peer
->guid
);
2248 spin_unlock_bh(&peer
->lock
);
2251 fwserial_release_port(port
, true);
2258 * fwserial_create - init everything to create TTYs for a specific fw_card
2259 * @unit: fw_unit for first 'serial' unit device probed for this fw_card
2261 * This function inits the aggregate structure (an fw_serial instance)
2262 * used to manage the TTY ports registered by a specific fw_card. Also, the
2263 * unit device is added as the first 'peer'.
2265 * This unit device may represent a local unit device (as specified by the
2266 * config ROM unit directory) or it may represent a remote unit device
2267 * (as specified by the reading of the remote node's config ROM).
2269 * Returns 0 to indicate "ownership" of the unit device, or a negative errno
2270 * value to indicate which error.
2272 static int fwserial_create(struct fw_unit
*unit
)
2274 struct fw_device
*parent
= fw_parent_device(unit
);
2275 struct fw_card
*card
= parent
->card
;
2276 struct fw_serial
*serial
;
2277 struct fwtty_port
*port
;
2278 struct device
*tty_dev
;
2282 serial
= kzalloc(sizeof(*serial
), GFP_KERNEL
);
2286 kref_init(&serial
->kref
);
2287 serial
->card
= card
;
2288 INIT_LIST_HEAD(&serial
->peer_list
);
2290 for (i
= 0; i
< num_ports
; ++i
) {
2291 port
= kzalloc(sizeof(*port
), GFP_KERNEL
);
2296 tty_port_init(&port
->port
);
2297 port
->index
= FWTTY_INVALID_INDEX
;
2298 port
->port
.ops
= &fwtty_port_ops
;
2299 port
->serial
= serial
;
2301 spin_lock_init(&port
->lock
);
2302 INIT_DELAYED_WORK(&port
->drain
, fwtty_drain_tx
);
2303 INIT_DELAYED_WORK(&port
->emit_breaks
, fwtty_emit_breaks
);
2304 INIT_WORK(&port
->hangup
, fwtty_do_hangup
);
2305 INIT_WORK(&port
->push
, fwtty_pushrx
);
2306 INIT_LIST_HEAD(&port
->buf_list
);
2307 init_waitqueue_head(&port
->wait_tx
);
2308 port
->max_payload
= link_speed_to_max_payload(SCODE_100
);
2309 dma_fifo_init(&port
->tx_fifo
);
2311 rcu_assign_pointer(port
->peer
, NULL
);
2312 serial
->ports
[i
] = port
;
2314 /* get unique bus addr region for port's status & recv fifo */
2315 port
->rx_handler
.length
= FWTTY_PORT_RXFIFO_LEN
+ 4;
2316 port
->rx_handler
.address_callback
= fwtty_port_handler
;
2317 port
->rx_handler
.callback_data
= port
;
2319 * XXX: use custom memory region above cpu physical memory addrs
2320 * this will ease porting to 64-bit firewire adapters
2322 err
= fw_core_add_address_handler(&port
->rx_handler
,
2323 &fw_high_memory_region
);
2329 /* preserve i for error cleanup */
2331 err
= fwtty_ports_add(serial
);
2333 fwtty_err(&unit
, "no space in port table\n");
2337 for (j
= 0; j
< num_ttys
; ++j
) {
2338 tty_dev
= tty_port_register_device(&serial
->ports
[j
]->port
,
2340 serial
->ports
[j
]->index
,
2342 if (IS_ERR(tty_dev
)) {
2343 err
= PTR_ERR(tty_dev
);
2344 fwtty_err(&unit
, "register tty device error (%d)\n",
2346 goto unregister_ttys
;
2349 serial
->ports
[j
]->device
= tty_dev
;
2351 /* preserve j for error cleanup */
2353 if (create_loop_dev
) {
2354 struct device
*loop_dev
;
2356 loop_dev
= tty_port_register_device(&serial
->ports
[j
]->port
,
2358 loop_idx(serial
->ports
[j
]),
2360 if (IS_ERR(loop_dev
)) {
2361 err
= PTR_ERR(loop_dev
);
2362 fwtty_err(&unit
, "create loop device failed (%d)\n",
2364 goto unregister_ttys
;
2366 serial
->ports
[j
]->device
= loop_dev
;
2367 serial
->ports
[j
]->loopback
= true;
2370 if (!IS_ERR_OR_NULL(fwserial_debugfs
)) {
2371 serial
->debugfs
= debugfs_create_dir(dev_name(&unit
->device
),
2373 if (!IS_ERR_OR_NULL(serial
->debugfs
)) {
2374 debugfs_create_file("peers", 0444, serial
->debugfs
,
2375 serial
, &fwtty_peers_fops
);
2376 debugfs_create_file("stats", 0444, serial
->debugfs
,
2377 serial
, &fwtty_stats_fops
);
2381 list_add_rcu(&serial
->list
, &fwserial_list
);
2383 fwtty_notice(&unit
, "TTY over FireWire on device %s (guid %016llx)\n",
2384 dev_name(card
->device
), (unsigned long long) card
->guid
);
2386 err
= fwserial_add_peer(serial
, unit
);
2390 fwtty_err(&unit
, "unable to add peer unit device (%d)\n", err
);
2392 /* fall-through to error processing */
2393 debugfs_remove_recursive(serial
->debugfs
);
2395 list_del_rcu(&serial
->list
);
2396 if (create_loop_dev
)
2397 tty_unregister_device(fwloop_driver
, loop_idx(serial
->ports
[j
]));
2399 for (--j
; j
>= 0; --j
)
2400 tty_unregister_device(fwtty_driver
, serial
->ports
[j
]->index
);
2401 kref_put(&serial
->kref
, fwserial_destroy
);
2405 for (--i
; i
>= 0; --i
) {
2406 tty_port_destroy(&serial
->ports
[i
]->port
);
2407 kfree(serial
->ports
[i
]);
2414 * fwserial_probe: bus probe function for firewire 'serial' unit devices
2416 * A 'serial' unit device is created and probed as a result of:
2417 * - declaring a ieee1394 bus id table for 'devices' matching a fabricated
2418 * 'serial' unit specifier id
2419 * - adding a unit directory to the config ROM(s) for a 'serial' unit
2421 * The firewire core registers unit devices by enumerating unit directories
2422 * of a node's config ROM after reading the config ROM when a new node is
2423 * added to the bus topology after a bus reset.
2425 * The practical implications of this are:
2426 * - this probe is called for both local and remote nodes that have a 'serial'
2427 * unit directory in their config ROM (that matches the specifiers in
2428 * fwserial_id_table).
2429 * - no specific order is enforced for local vs. remote unit devices
2431 * This unit driver copes with the lack of specific order in the same way the
2432 * firewire net driver does -- each probe, for either a local or remote unit
2433 * device, is treated as a 'peer' (has a struct fwtty_peer instance) and the
2434 * first peer created for a given fw_card (tracked by the global fwserial_list)
2435 * creates the underlying TTYs (aggregated in a fw_serial instance).
2437 * NB: an early attempt to differentiate local & remote unit devices by creating
2438 * peers only for remote units and fw_serial instances (with their
2439 * associated TTY devices) only for local units was discarded. Managing
2440 * the peer lifetimes on device removal proved too complicated.
2442 * fwserial_probe/fwserial_remove are effectively serialized by the
2443 * fwserial_list_mutex. This is necessary because the addition of the first peer
2444 * for a given fw_card will trigger the creation of the fw_serial for that
2445 * fw_card, which must not simultaneously contend with the removal of the
2446 * last peer for a given fw_card triggering the destruction of the same
2447 * fw_serial for the same fw_card.
2449 static int fwserial_probe(struct fw_unit
*unit
,
2450 const struct ieee1394_device_id
*id
)
2452 struct fw_serial
*serial
;
2455 mutex_lock(&fwserial_list_mutex
);
2456 serial
= fwserial_lookup(fw_parent_device(unit
)->card
);
2458 err
= fwserial_create(unit
);
2460 err
= fwserial_add_peer(serial
, unit
);
2461 mutex_unlock(&fwserial_list_mutex
);
2466 * fwserial_remove: bus removal function for firewire 'serial' unit devices
2468 * The corresponding 'peer' for this unit device is removed from the list of
2469 * peers for the associated fw_serial (which has a 1:1 correspondence with a
2470 * specific fw_card). If this is the last peer being removed, then trigger
2471 * the destruction of the underlying TTYs.
2473 static void fwserial_remove(struct fw_unit
*unit
)
2475 struct fwtty_peer
*peer
= dev_get_drvdata(&unit
->device
);
2476 struct fw_serial
*serial
= peer
->serial
;
2479 mutex_lock(&fwserial_list_mutex
);
2480 fwserial_remove_peer(peer
);
2482 if (list_empty(&serial
->peer_list
)) {
2483 /* unlink from the fwserial_list here */
2484 list_del_rcu(&serial
->list
);
2486 debugfs_remove_recursive(serial
->debugfs
);
2488 for (i
= 0; i
< num_ttys
; ++i
)
2489 fwserial_close_port(fwtty_driver
, serial
->ports
[i
]);
2490 if (create_loop_dev
)
2491 fwserial_close_port(fwloop_driver
, serial
->ports
[i
]);
2492 kref_put(&serial
->kref
, fwserial_destroy
);
2494 mutex_unlock(&fwserial_list_mutex
);
2498 * fwserial_update: bus update function for 'firewire' serial unit devices
2500 * Updates the new node_id and bus generation for this peer. Note that locking
2501 * is unnecessary; but careful memory barrier usage is important to enforce the
2502 * load and store order of generation & node_id.
2504 * The fw-core orders the write of node_id before generation in the parent
2505 * fw_device to ensure that a stale node_id cannot be used with a current
2506 * bus generation. So the generation value must be read before the node_id.
2508 * In turn, this orders the write of node_id before generation in the peer to
2509 * also ensure a stale node_id cannot be used with a current bus generation.
2511 static void fwserial_update(struct fw_unit
*unit
)
2513 struct fw_device
*parent
= fw_parent_device(unit
);
2514 struct fwtty_peer
*peer
= dev_get_drvdata(&unit
->device
);
2517 generation
= parent
->generation
;
2519 peer
->node_id
= parent
->node_id
;
2521 peer
->generation
= generation
;
2524 static const struct ieee1394_device_id fwserial_id_table
[] = {
2526 .match_flags
= IEEE1394_MATCH_SPECIFIER_ID
|
2527 IEEE1394_MATCH_VERSION
,
2528 .specifier_id
= LINUX_VENDOR_ID
,
2529 .version
= FWSERIAL_VERSION
,
2534 static struct fw_driver fwserial_driver
= {
2536 .owner
= THIS_MODULE
,
2537 .name
= KBUILD_MODNAME
,
2538 .bus
= &fw_bus_type
,
2540 .probe
= fwserial_probe
,
2541 .update
= fwserial_update
,
2542 .remove
= fwserial_remove
,
2543 .id_table
= fwserial_id_table
,
2546 #define FW_UNIT_SPECIFIER(id) ((CSR_SPECIFIER_ID << 24) | (id))
2547 #define FW_UNIT_VERSION(ver) ((CSR_VERSION << 24) | (ver))
2548 #define FW_UNIT_ADDRESS(ofs) (((CSR_OFFSET | CSR_DEPENDENT_INFO) << 24) \
2549 | (((ofs) - CSR_REGISTER_BASE) >> 2))
2550 /* XXX: config ROM definitons could be improved with semi-automated offset
2551 * and length calculation
2553 #define FW_ROM_LEN(quads) ((quads) << 16)
2554 #define FW_ROM_DESCRIPTOR(ofs) (((CSR_LEAF | CSR_DESCRIPTOR) << 24) | (ofs))
2556 struct fwserial_unit_directory_data
{
2559 u32 unit_sw_version
;
2560 u32 unit_addr_offset
;
2566 static struct fwserial_unit_directory_data fwserial_unit_directory_data
= {
2567 .len_crc
= FW_ROM_LEN(4),
2568 .unit_specifier
= FW_UNIT_SPECIFIER(LINUX_VENDOR_ID
),
2569 .unit_sw_version
= FW_UNIT_VERSION(FWSERIAL_VERSION
),
2570 .desc1_ofs
= FW_ROM_DESCRIPTOR(1),
2571 .desc1_len_crc
= FW_ROM_LEN(5),
2573 0x00000000, /* type = text */
2574 0x00000000, /* enc = ASCII, lang EN */
2575 0x4c696e75, /* 'Linux TTY' */
2581 static struct fw_descriptor fwserial_unit_directory
= {
2582 .length
= sizeof(fwserial_unit_directory_data
) / sizeof(u32
),
2583 .key
= (CSR_DIRECTORY
| CSR_UNIT
) << 24,
2584 .data
= (u32
*)&fwserial_unit_directory_data
,
2588 * The management address is in the unit space region but above other known
2589 * address users (to keep wild writes from causing havoc)
2591 static const struct fw_address_region fwserial_mgmt_addr_region
= {
2592 .start
= CSR_REGISTER_BASE
+ 0x1e0000ULL
,
2593 .end
= 0x1000000000000ULL
,
2596 static struct fw_address_handler fwserial_mgmt_addr_handler
;
2599 * fwserial_handle_plug_req - handle VIRT_CABLE_PLUG request work
2600 * @work: ptr to peer->work
2602 * Attempts to complete the VIRT_CABLE_PLUG handshake sequence for this peer.
2604 * This checks for a collided request-- ie, that a VIRT_CABLE_PLUG request was
2605 * already sent to this peer. If so, the collision is resolved by comparing
2606 * guid values; the loser sends the plug response.
2608 * Note: if an error prevents a response, don't do anything -- the
2609 * remote will timeout its request.
2611 static void fwserial_handle_plug_req(struct work_struct
*work
)
2613 struct fwtty_peer
*peer
= to_peer(work
, work
);
2614 struct virt_plug_params
*plug_req
= &peer
->work_params
.plug_req
;
2615 struct fwtty_port
*port
;
2616 struct fwserial_mgmt_pkt
*pkt
;
2619 pkt
= kmalloc(sizeof(*pkt
), GFP_KERNEL
);
2623 port
= fwserial_find_port(peer
);
2625 spin_lock_bh(&peer
->lock
);
2627 switch (peer
->state
) {
2628 case FWPS_NOT_ATTACHED
:
2630 fwtty_err(&peer
->unit
, "no more ports avail\n");
2631 fill_plug_rsp_nack(pkt
);
2634 fill_plug_rsp_ok(pkt
, peer
->port
);
2635 peer_set_state(peer
, FWPS_PLUG_RESPONDING
);
2636 /* don't release claimed port */
2641 case FWPS_PLUG_PENDING
:
2642 if (peer
->serial
->card
->guid
> peer
->guid
)
2645 /* We lost - hijack the already-claimed port and send ok */
2646 del_timer(&peer
->timer
);
2647 fill_plug_rsp_ok(pkt
, peer
->port
);
2648 peer_set_state(peer
, FWPS_PLUG_RESPONDING
);
2652 fill_plug_rsp_nack(pkt
);
2655 spin_unlock_bh(&peer
->lock
);
2657 fwserial_release_port(port
, false);
2659 rcode
= fwserial_send_mgmt_sync(peer
, pkt
);
2661 spin_lock_bh(&peer
->lock
);
2662 if (peer
->state
== FWPS_PLUG_RESPONDING
) {
2663 if (rcode
== RCODE_COMPLETE
) {
2664 struct fwtty_port
*tmp
= peer
->port
;
2666 fwserial_virt_plug_complete(peer
, plug_req
);
2667 spin_unlock_bh(&peer
->lock
);
2669 fwtty_write_port_status(tmp
);
2670 spin_lock_bh(&peer
->lock
);
2672 fwtty_err(&peer
->unit
, "PLUG_RSP error (%d)\n", rcode
);
2673 port
= peer_revert_state(peer
);
2677 spin_unlock_bh(&peer
->lock
);
2679 fwserial_release_port(port
, false);
2684 static void fwserial_handle_unplug_req(struct work_struct
*work
)
2686 struct fwtty_peer
*peer
= to_peer(work
, work
);
2687 struct fwtty_port
*port
= NULL
;
2688 struct fwserial_mgmt_pkt
*pkt
;
2691 pkt
= kmalloc(sizeof(*pkt
), GFP_KERNEL
);
2695 spin_lock_bh(&peer
->lock
);
2697 switch (peer
->state
) {
2699 fill_unplug_rsp_ok(pkt
);
2700 peer_set_state(peer
, FWPS_UNPLUG_RESPONDING
);
2703 case FWPS_UNPLUG_PENDING
:
2704 if (peer
->serial
->card
->guid
> peer
->guid
)
2707 /* We lost - send unplug rsp */
2708 del_timer(&peer
->timer
);
2709 fill_unplug_rsp_ok(pkt
);
2710 peer_set_state(peer
, FWPS_UNPLUG_RESPONDING
);
2714 fill_unplug_rsp_nack(pkt
);
2717 spin_unlock_bh(&peer
->lock
);
2719 rcode
= fwserial_send_mgmt_sync(peer
, pkt
);
2721 spin_lock_bh(&peer
->lock
);
2722 if (peer
->state
== FWPS_UNPLUG_RESPONDING
) {
2723 if (rcode
!= RCODE_COMPLETE
)
2724 fwtty_err(&peer
->unit
, "UNPLUG_RSP error (%d)\n",
2726 port
= peer_revert_state(peer
);
2729 spin_unlock_bh(&peer
->lock
);
2731 fwserial_release_port(port
, true);
2736 static int fwserial_parse_mgmt_write(struct fwtty_peer
*peer
,
2737 struct fwserial_mgmt_pkt
*pkt
,
2738 unsigned long long addr
,
2741 struct fwtty_port
*port
= NULL
;
2745 if (addr
!= fwserial_mgmt_addr_handler
.offset
|| len
< sizeof(pkt
->hdr
))
2746 return RCODE_ADDRESS_ERROR
;
2748 if (len
!= be16_to_cpu(pkt
->hdr
.len
) ||
2749 len
!= mgmt_pkt_expected_len(pkt
->hdr
.code
))
2750 return RCODE_DATA_ERROR
;
2752 spin_lock_bh(&peer
->lock
);
2753 if (peer
->state
== FWPS_GONE
) {
2755 * This should never happen - it would mean that the
2756 * remote unit that just wrote this transaction was
2757 * already removed from the bus -- and the removal was
2758 * processed before we rec'd this transaction
2760 fwtty_err(&peer
->unit
, "peer already removed\n");
2761 spin_unlock_bh(&peer
->lock
);
2762 return RCODE_ADDRESS_ERROR
;
2765 rcode
= RCODE_COMPLETE
;
2767 fwtty_dbg(&peer
->unit
, "mgmt: hdr.code: %04hx\n", pkt
->hdr
.code
);
2769 switch (be16_to_cpu(pkt
->hdr
.code
) & FWSC_CODE_MASK
) {
2770 case FWSC_VIRT_CABLE_PLUG
:
2771 if (work_pending(&peer
->work
)) {
2772 fwtty_err(&peer
->unit
, "plug req: busy\n");
2773 rcode
= RCODE_CONFLICT_ERROR
;
2776 peer
->work_params
.plug_req
= pkt
->plug_req
;
2777 PREPARE_WORK(&peer
->work
, fwserial_handle_plug_req
);
2778 queue_work(system_unbound_wq
, &peer
->work
);
2782 case FWSC_VIRT_CABLE_PLUG_RSP
:
2783 if (peer
->state
!= FWPS_PLUG_PENDING
) {
2784 rcode
= RCODE_CONFLICT_ERROR
;
2786 } else if (be16_to_cpu(pkt
->hdr
.code
) & FWSC_RSP_NACK
) {
2787 fwtty_notice(&peer
->unit
, "NACK plug rsp\n");
2788 port
= peer_revert_state(peer
);
2791 struct fwtty_port
*tmp
= peer
->port
;
2793 fwserial_virt_plug_complete(peer
, &pkt
->plug_rsp
);
2794 spin_unlock_bh(&peer
->lock
);
2796 fwtty_write_port_status(tmp
);
2797 spin_lock_bh(&peer
->lock
);
2801 case FWSC_VIRT_CABLE_UNPLUG
:
2802 if (work_pending(&peer
->work
)) {
2803 fwtty_err(&peer
->unit
, "unplug req: busy\n");
2804 rcode
= RCODE_CONFLICT_ERROR
;
2806 PREPARE_WORK(&peer
->work
, fwserial_handle_unplug_req
);
2807 queue_work(system_unbound_wq
, &peer
->work
);
2811 case FWSC_VIRT_CABLE_UNPLUG_RSP
:
2812 if (peer
->state
!= FWPS_UNPLUG_PENDING
)
2813 rcode
= RCODE_CONFLICT_ERROR
;
2815 if (be16_to_cpu(pkt
->hdr
.code
) & FWSC_RSP_NACK
)
2816 fwtty_notice(&peer
->unit
, "NACK unplug?\n");
2817 port
= peer_revert_state(peer
);
2823 fwtty_err(&peer
->unit
, "unknown mgmt code %d\n",
2824 be16_to_cpu(pkt
->hdr
.code
));
2825 rcode
= RCODE_DATA_ERROR
;
2827 spin_unlock_bh(&peer
->lock
);
2830 fwserial_release_port(port
, reset
);
2836 * fwserial_mgmt_handler: bus address handler for mgmt requests
2837 * @parameters: fw_address_callback_t as specified by firewire core interface
2839 * This handler is responsible for handling virtual cable requests from remotes
2842 static void fwserial_mgmt_handler(struct fw_card
*card
,
2843 struct fw_request
*request
,
2844 int tcode
, int destination
, int source
,
2846 unsigned long long addr
,
2847 void *data
, size_t len
,
2848 void *callback_data
)
2850 struct fwserial_mgmt_pkt
*pkt
= data
;
2851 struct fwtty_peer
*peer
;
2855 peer
= __fwserial_peer_by_node_id(card
, generation
, source
);
2857 fwtty_dbg(card
, "peer(%d:%x) not found\n", generation
, source
);
2858 __dump_peer_list(card
);
2859 rcode
= RCODE_CONFLICT_ERROR
;
2863 case TCODE_WRITE_BLOCK_REQUEST
:
2864 rcode
= fwserial_parse_mgmt_write(peer
, pkt
, addr
, len
);
2868 rcode
= RCODE_TYPE_ERROR
;
2873 fw_send_response(card
, request
, rcode
);
2876 static int __init
fwserial_init(void)
2878 int err
, num_loops
= !!(create_loop_dev
);
2880 /* XXX: placeholder for a "firewire" debugfs node */
2881 fwserial_debugfs
= debugfs_create_dir(KBUILD_MODNAME
, NULL
);
2883 /* num_ttys/num_ports must not be set above the static alloc avail */
2884 if (num_ttys
+ num_loops
> MAX_CARD_PORTS
)
2885 num_ttys
= MAX_CARD_PORTS
- num_loops
;
2886 num_ports
= num_ttys
+ num_loops
;
2888 fwtty_driver
= tty_alloc_driver(MAX_TOTAL_PORTS
, TTY_DRIVER_REAL_RAW
2889 | TTY_DRIVER_DYNAMIC_DEV
);
2890 if (IS_ERR(fwtty_driver
)) {
2891 err
= PTR_ERR(fwtty_driver
);
2895 fwtty_driver
->driver_name
= KBUILD_MODNAME
;
2896 fwtty_driver
->name
= tty_dev_name
;
2897 fwtty_driver
->major
= 0;
2898 fwtty_driver
->minor_start
= 0;
2899 fwtty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
2900 fwtty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
2901 fwtty_driver
->init_termios
= tty_std_termios
;
2902 fwtty_driver
->init_termios
.c_cflag
|= CLOCAL
;
2903 tty_set_operations(fwtty_driver
, &fwtty_ops
);
2905 err
= tty_register_driver(fwtty_driver
);
2907 pr_err("register tty driver failed (%d)\n", err
);
2911 if (create_loop_dev
) {
2912 fwloop_driver
= tty_alloc_driver(MAX_TOTAL_PORTS
/ num_ports
,
2914 | TTY_DRIVER_DYNAMIC_DEV
);
2915 if (IS_ERR(fwloop_driver
)) {
2916 err
= PTR_ERR(fwloop_driver
);
2917 goto unregister_driver
;
2920 fwloop_driver
->driver_name
= KBUILD_MODNAME
"_loop";
2921 fwloop_driver
->name
= loop_dev_name
;
2922 fwloop_driver
->major
= 0;
2923 fwloop_driver
->minor_start
= 0;
2924 fwloop_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
2925 fwloop_driver
->subtype
= SERIAL_TYPE_NORMAL
;
2926 fwloop_driver
->init_termios
= tty_std_termios
;
2927 fwloop_driver
->init_termios
.c_cflag
|= CLOCAL
;
2928 tty_set_operations(fwloop_driver
, &fwloop_ops
);
2930 err
= tty_register_driver(fwloop_driver
);
2932 pr_err("register loop driver failed (%d)\n", err
);
2937 fwtty_txn_cache
= kmem_cache_create("fwtty_txn_cache",
2938 sizeof(struct fwtty_transaction
),
2939 0, 0, fwtty_txn_constructor
);
2940 if (!fwtty_txn_cache
) {
2942 goto unregister_loop
;
2946 * Ideally, this address handler would be registered per local node
2947 * (rather than the same handler for all local nodes). However,
2948 * since the firewire core requires the config rom descriptor *before*
2949 * the local unit device(s) are created, a single management handler
2950 * must suffice for all local serial units.
2952 fwserial_mgmt_addr_handler
.length
= sizeof(struct fwserial_mgmt_pkt
);
2953 fwserial_mgmt_addr_handler
.address_callback
= fwserial_mgmt_handler
;
2955 err
= fw_core_add_address_handler(&fwserial_mgmt_addr_handler
,
2956 &fwserial_mgmt_addr_region
);
2958 pr_err("add management handler failed (%d)\n", err
);
2962 fwserial_unit_directory_data
.unit_addr_offset
=
2963 FW_UNIT_ADDRESS(fwserial_mgmt_addr_handler
.offset
);
2964 err
= fw_core_add_descriptor(&fwserial_unit_directory
);
2966 pr_err("add unit descriptor failed (%d)\n", err
);
2967 goto remove_handler
;
2970 err
= driver_register(&fwserial_driver
.driver
);
2972 pr_err("register fwserial driver failed (%d)\n", err
);
2973 goto remove_descriptor
;
2979 fw_core_remove_descriptor(&fwserial_unit_directory
);
2981 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler
);
2983 kmem_cache_destroy(fwtty_txn_cache
);
2985 if (create_loop_dev
)
2986 tty_unregister_driver(fwloop_driver
);
2988 if (create_loop_dev
)
2989 put_tty_driver(fwloop_driver
);
2991 tty_unregister_driver(fwtty_driver
);
2993 put_tty_driver(fwtty_driver
);
2994 debugfs_remove_recursive(fwserial_debugfs
);
2998 static void __exit
fwserial_exit(void)
3000 driver_unregister(&fwserial_driver
.driver
);
3001 fw_core_remove_descriptor(&fwserial_unit_directory
);
3002 fw_core_remove_address_handler(&fwserial_mgmt_addr_handler
);
3003 kmem_cache_destroy(fwtty_txn_cache
);
3004 if (create_loop_dev
) {
3005 tty_unregister_driver(fwloop_driver
);
3006 put_tty_driver(fwloop_driver
);
3008 tty_unregister_driver(fwtty_driver
);
3009 put_tty_driver(fwtty_driver
);
3010 debugfs_remove_recursive(fwserial_debugfs
);
3013 module_init(fwserial_init
);
3014 module_exit(fwserial_exit
);
3016 MODULE_AUTHOR("Peter Hurley (peter@hurleysoftware.com)");
3017 MODULE_DESCRIPTION("FireWire Serial TTY Driver");
3018 MODULE_LICENSE("GPL");
3019 MODULE_DEVICE_TABLE(ieee1394
, fwserial_id_table
);
3020 MODULE_PARM_DESC(ttys
, "Number of ttys to create for each local firewire node");
3021 MODULE_PARM_DESC(auto, "Auto-connect a tty to each firewire node discovered");
3022 MODULE_PARM_DESC(loop
, "Create a loopback device, fwloop<n>, with ttys");