drivers/staging/fwserial/fwserial.c

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