drivers/staging/fwserial/fwserial.c

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