drivers/staging/dgnc/dgnc_tty.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2003 Digi International (www.digi.com)
   4  *      Scott H Kilau <Scott_Kilau at digi dot com>
   5  */
   6
   7 /*
   8  * This file implements the tty driver functionality for the
   9  * Neo and ClassicBoard PCI based product lines.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/sched/signal.h> /* For jiffies, task states, etc. */
  14 #include <linux/interrupt.h>    /* For tasklet and interrupt structs/defines */
  15 #include <linux/module.h>
  16 #include <linux/ctype.h>
  17 #include <linux/tty.h>
  18 #include <linux/tty_flip.h>
  19 #include <linux/types.h>
  20 #include <linux/serial_reg.h>
  21 #include <linux/slab.h>
  22 #include <linux/delay.h>        /* For udelay */
  23 #include <linux/uaccess.h>      /* For copy_from_user/copy_to_user */
  24 #include <linux/pci.h>
  25 #include "dgnc_driver.h"
  26 #include "dgnc_tty.h"
  27 #include "dgnc_cls.h"
  28
  29 /* Default transparent print information. */
  30
  31 static const struct digi_t dgnc_digi_init = {
  32         .digi_flags =   DIGI_COOK,      /* Flags */
  33         .digi_maxcps =  100,            /* Max CPS */
  34         .digi_maxchar = 50,             /* Max chars in print queue */
  35         .digi_bufsize = 100,            /* Printer buffer size */
  36         .digi_onlen =   4,              /* size of printer on string */
  37         .digi_offlen =  4,              /* size of printer off string */
  38         .digi_onstr =   "\033[5i",      /* ANSI printer on string ] */
  39         .digi_offstr =  "\033[4i",      /* ANSI printer off string ] */
  40         .digi_term =    "ansi"          /* default terminal type */
  41 };
  42
  43 static int dgnc_tty_open(struct tty_struct *tty, struct file *file);
  44 static void dgnc_tty_close(struct tty_struct *tty, struct file *file);
  45 static int dgnc_block_til_ready(struct tty_struct *tty, struct file *file,
  46                                 struct channel_t *ch);
  47 static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
  48                           unsigned long arg);
  49 static int dgnc_tty_digigeta(struct tty_struct *tty,
  50                              struct digi_t __user *retinfo);
  51 static int dgnc_tty_digiseta(struct tty_struct *tty,
  52                              struct digi_t __user *new_info);
  53 static int dgnc_tty_write_room(struct tty_struct *tty);
  54 static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c);
  55 static int dgnc_tty_chars_in_buffer(struct tty_struct *tty);
  56 static void dgnc_tty_start(struct tty_struct *tty);
  57 static void dgnc_tty_stop(struct tty_struct *tty);
  58 static void dgnc_tty_throttle(struct tty_struct *tty);
  59 static void dgnc_tty_unthrottle(struct tty_struct *tty);
  60 static void dgnc_tty_flush_chars(struct tty_struct *tty);
  61 static void dgnc_tty_flush_buffer(struct tty_struct *tty);
  62 static void dgnc_tty_hangup(struct tty_struct *tty);
  63 static int dgnc_set_modem_info(struct channel_t *ch, unsigned int command,
  64                                unsigned int __user *value);
  65 static int dgnc_get_modem_info(struct channel_t *ch,
  66                                unsigned int __user *value);
  67 static int dgnc_tty_tiocmget(struct tty_struct *tty);
  68 static int dgnc_tty_tiocmset(struct tty_struct *tty, unsigned int set,
  69                              unsigned int clear);
  70 static int dgnc_tty_send_break(struct tty_struct *tty, int msec);
  71 static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout);
  72 static int dgnc_tty_write(struct tty_struct *tty, const unsigned char *buf,
  73                           int count);
  74 static void dgnc_tty_set_termios(struct tty_struct *tty,
  75                                  struct ktermios *old_termios);
  76 static void dgnc_tty_send_xchar(struct tty_struct *tty, char ch);
  77 static void dgnc_set_signal_low(struct channel_t *ch, const unsigned char line);
  78 static void dgnc_wake_up_unit(struct un_t *unit);
  79
  80 static const struct tty_operations dgnc_tty_ops = {
  81         .open = dgnc_tty_open,
  82         .close = dgnc_tty_close,
  83         .write = dgnc_tty_write,
  84         .write_room = dgnc_tty_write_room,
  85         .flush_buffer = dgnc_tty_flush_buffer,
  86         .chars_in_buffer = dgnc_tty_chars_in_buffer,
  87         .flush_chars = dgnc_tty_flush_chars,
  88         .ioctl = dgnc_tty_ioctl,
  89         .set_termios = dgnc_tty_set_termios,
  90         .stop = dgnc_tty_stop,
  91         .start = dgnc_tty_start,
  92         .throttle = dgnc_tty_throttle,
  93         .unthrottle = dgnc_tty_unthrottle,
  94         .hangup = dgnc_tty_hangup,
  95         .put_char = dgnc_tty_put_char,
  96         .tiocmget = dgnc_tty_tiocmget,
  97         .tiocmset = dgnc_tty_tiocmset,
  98         .break_ctl = dgnc_tty_send_break,
  99         .wait_until_sent = dgnc_tty_wait_until_sent,
 100         .send_xchar = dgnc_tty_send_xchar
 101 };
 102
 103 /* TTY Initialization/Cleanup Functions */
 104
 105 static struct tty_driver *dgnc_tty_create(char *serial_name, uint maxports,
 106                                           int major, int minor)
 107 {
 108         int rc;
 109         struct tty_driver *drv;
 110
 111         drv = tty_alloc_driver(maxports,
 112                                TTY_DRIVER_REAL_RAW |
 113                                TTY_DRIVER_DYNAMIC_DEV |
 114                                TTY_DRIVER_HARDWARE_BREAK);
 115         if (IS_ERR(drv))
 116                 return drv;
 117
 118         drv->name = serial_name;
 119         drv->name_base = 0;
 120         drv->major = major;
 121         drv->minor_start = minor;
 122         drv->type = TTY_DRIVER_TYPE_SERIAL;
 123         drv->subtype = SERIAL_TYPE_NORMAL;
 124         drv->init_termios = tty_std_termios;
 125         drv->init_termios.c_cflag = (B9600 | CS8 | CREAD | HUPCL | CLOCAL);
 126         drv->init_termios.c_ispeed = 9600;
 127         drv->init_termios.c_ospeed = 9600;
 128         drv->driver_name = DRVSTR;
 129         /*
 130          * Entry points for driver.  Called by the kernel from
 131          * tty_io.c and n_tty.c.
 132          */
 133         tty_set_operations(drv, &dgnc_tty_ops);
 134         rc = tty_register_driver(drv);
 135         if (rc < 0) {
 136                 put_tty_driver(drv);
 137                 return ERR_PTR(rc);
 138         }
 139         return drv;
 140 }
 141
 142 static void dgnc_tty_free(struct tty_driver *drv)
 143 {
 144         tty_unregister_driver(drv);
 145         put_tty_driver(drv);
 146 }
 147
 148 /**
 149  * dgnc_tty_register() - Init the tty subsystem for this board.
 150  */
 151 int dgnc_tty_register(struct dgnc_board *brd)
 152 {
 153         int rc;
 154
 155         snprintf(brd->serial_name, MAXTTYNAMELEN, "tty_dgnc_%d_",
 156                  brd->boardnum);
 157
 158         brd->serial_driver = dgnc_tty_create(brd->serial_name,
 159                                              brd->maxports, 0, 0);
 160         if (IS_ERR(brd->serial_driver)) {
 161                 rc = PTR_ERR(brd->serial_driver);
 162                 dev_dbg(&brd->pdev->dev, "Can't register tty device (%d)\n",
 163                         rc);
 164                 return rc;
 165         }
 166
 167         snprintf(brd->print_name, MAXTTYNAMELEN, "pr_dgnc_%d_", brd->boardnum);
 168         brd->print_driver = dgnc_tty_create(brd->print_name, brd->maxports,
 169                                             0x80,
 170                                             brd->serial_driver->major);
 171         if (IS_ERR(brd->print_driver)) {
 172                 rc = PTR_ERR(brd->print_driver);
 173                 dev_dbg(&brd->pdev->dev,
 174                         "Can't register Transparent Print device(%d)\n", rc);
 175                 dgnc_tty_free(brd->serial_driver);
 176                 return rc;
 177         }
 178         return 0;
 179 }
 180
 181 void dgnc_tty_unregister(struct dgnc_board *brd)
 182 {
 183         dgnc_tty_free(brd->print_driver);
 184         dgnc_tty_free(brd->serial_driver);
 185 }
 186
 187 /**
 188  * dgnc_tty_init() - Initialize the tty subsystem.
 189  *
 190  * Called once per board after board has been downloaded and initialized.
 191  */
 192 int dgnc_tty_init(struct dgnc_board *brd)
 193 {
 194         int i;
 195         int rc;
 196         void __iomem *vaddr;
 197         struct channel_t *ch;
 198
 199         if (!brd)
 200                 return -ENXIO;
 201
 202         /* Initialize board structure elements. */
 203
 204         vaddr = brd->re_map_membase;
 205
 206         brd->nasync = brd->maxports;
 207
 208         for (i = 0; i < brd->nasync; i++) {
 209                 brd->channels[i] = kzalloc(sizeof(*brd->channels[i]),
 210                                            GFP_KERNEL);
 211                 if (!brd->channels[i]) {
 212                         rc = -ENOMEM;
 213                         goto err_free_channels;
 214                 }
 215         }
 216
 217         ch = brd->channels[0];
 218         vaddr = brd->re_map_membase;
 219
 220         /* Set up channel variables */
 221         for (i = 0; i < brd->nasync; i++, ch = brd->channels[i]) {
 222                 spin_lock_init(&ch->ch_lock);
 223
 224                 ch->ch_tun.un_ch = ch;
 225                 ch->ch_tun.un_type = DGNC_SERIAL;
 226                 ch->ch_tun.un_dev = i;
 227
 228                 ch->ch_pun.un_ch = ch;
 229                 ch->ch_pun.un_type = DGNC_PRINT;
 230                 ch->ch_pun.un_dev = i + 128;
 231
 232                 ch->ch_cls_uart = vaddr + (brd->bd_uart_offset * i);
 233
 234                 ch->ch_bd = brd;
 235                 ch->ch_portnum = i;
 236                 ch->ch_digi = dgnc_digi_init;
 237
 238                 /* .25 second delay */
 239                 ch->ch_close_delay = 250;
 240
 241                 init_waitqueue_head(&ch->ch_flags_wait);
 242                 init_waitqueue_head(&ch->ch_tun.un_flags_wait);
 243                 init_waitqueue_head(&ch->ch_pun.un_flags_wait);
 244
 245                 {
 246                         struct device *classp;
 247
 248                         classp = tty_register_device(brd->serial_driver, i,
 249                                                      &ch->ch_bd->pdev->dev);
 250                         ch->ch_tun.un_sysfs = classp;
 251
 252                         classp = tty_register_device(brd->print_driver, i,
 253                                                      &ch->ch_bd->pdev->dev);
 254                         ch->ch_pun.un_sysfs = classp;
 255                 }
 256         }
 257
 258         return 0;
 259
 260 err_free_channels:
 261         for (i = i - 1; i >= 0; --i) {
 262                 kfree(brd->channels[i]);
 263                 brd->channels[i] = NULL;
 264         }
 265
 266         return rc;
 267 }
 268
 269 /**
 270  * dgnc_cleanup_tty() - Cleanup driver.
 271  *
 272  * Uninitialize the TTY portion of this driver.  Free all memory and
 273  * resources.
 274  */
 275 void dgnc_cleanup_tty(struct dgnc_board *brd)
 276 {
 277         int i = 0;
 278
 279         for (i = 0; i < brd->nasync; i++)
 280                 tty_unregister_device(brd->serial_driver, i);
 281
 282         tty_unregister_driver(brd->serial_driver);
 283
 284         for (i = 0; i < brd->nasync; i++)
 285                 tty_unregister_device(brd->print_driver, i);
 286
 287         tty_unregister_driver(brd->print_driver);
 288
 289         put_tty_driver(brd->serial_driver);
 290         put_tty_driver(brd->print_driver);
 291 }
 292
 293 /**
 294  * dgnc_wmove() - Write data to transmit queue.
 295  * @ch: Pointer to channel structure.
 296  * @buf: Pointer to characters to be moved.
 297  * @n: Number of characters to move.
 298  */
 299 static void dgnc_wmove(struct channel_t *ch, char *buf, uint n)
 300 {
 301         int     remain;
 302         uint    head;
 303
 304         if (!ch)
 305                 return;
 306
 307         head = ch->ch_w_head & WQUEUEMASK;
 308
 309         /*
 310          * If the write wraps over the top of the circular buffer,
 311          * move the portion up to the wrap point, and reset the
 312          * pointers to the bottom.
 313          */
 314         remain = WQUEUESIZE - head;
 315
 316         if (n >= remain) {
 317                 n -= remain;
 318                 memcpy(ch->ch_wqueue + head, buf, remain);
 319                 head = 0;
 320                 buf += remain;
 321         }
 322
 323         if (n > 0) {
 324                 /* Move rest of data. */
 325                 remain = n;
 326                 memcpy(ch->ch_wqueue + head, buf, remain);
 327                 head += remain;
 328         }
 329
 330         head &= WQUEUEMASK;
 331         ch->ch_w_head = head;
 332 }
 333
 334 /**
 335  * dgnc_input() - Process received data.
 336  * @ch: Pointer to channel structure.
 337  */
 338 void dgnc_input(struct channel_t *ch)
 339 {
 340         struct dgnc_board *bd;
 341         struct tty_struct *tp;
 342         struct tty_ldisc *ld = NULL;
 343         uint    rmask;
 344         ushort  head;
 345         ushort  tail;
 346         int     data_len;
 347         unsigned long flags;
 348         int flip_len;
 349         int len = 0;
 350         int n = 0;
 351         int s = 0;
 352         int i = 0;
 353
 354         if (!ch)
 355                 return;
 356
 357         tp = ch->ch_tun.un_tty;
 358
 359         bd = ch->ch_bd;
 360         if (!bd)
 361                 return;
 362
 363         spin_lock_irqsave(&ch->ch_lock, flags);
 364
 365         rmask = RQUEUEMASK;
 366         head = ch->ch_r_head & rmask;
 367         tail = ch->ch_r_tail & rmask;
 368         data_len = (head - tail) & rmask;
 369
 370         if (data_len == 0)
 371                 goto exit_unlock;
 372
 373         /*
 374          * If the device is not open, or CREAD is off,
 375          * flush input data and return immediately.
 376          */
 377         if (!tp ||
 378             !(ch->ch_tun.un_flags & UN_ISOPEN) ||
 379             !C_CREAD(tp) ||
 380             (ch->ch_tun.un_flags & UN_CLOSING)) {
 381                 ch->ch_r_head = tail;
 382
 383                 /* Force queue flow control to be released, if needed */
 384                 dgnc_check_queue_flow_control(ch);
 385
 386                 goto exit_unlock;
 387         }
 388
 389         if (ch->ch_flags & CH_FORCED_STOPI)
 390                 goto exit_unlock;
 391
 392         flip_len = TTY_FLIPBUF_SIZE;
 393
 394         len = min(data_len, flip_len);
 395         len = min(len, (N_TTY_BUF_SIZE - 1));
 396
 397         ld = tty_ldisc_ref(tp);
 398         if (!ld) {
 399                 len = 0;
 400         } else {
 401                 if (!ld->ops->receive_buf) {
 402                         ch->ch_r_head = ch->ch_r_tail;
 403                         len = 0;
 404                 }
 405         }
 406
 407         if (len <= 0)
 408                 goto exit_unlock;
 409
 410         /*
 411          * The tty layer in the kernel has changed in 2.6.16+.
 412          *
 413          * The flip buffers in the tty structure are no longer exposed,
 414          * and probably will be going away eventually.
 415          *
 416          * If we are completely raw, we don't need to go through a lot
 417          * of the tty layers that exist.
 418          * In this case, we take the shortest and fastest route we
 419          * can to relay the data to the user.
 420          *
 421          * On the other hand, if we are not raw, we need to go through
 422          * the new 2.6.16+ tty layer, which has its API more well defined.
 423          */
 424         len = tty_buffer_request_room(tp->port, len);
 425         n = len;
 426
 427         /*
 428          * n now contains the most amount of data we can copy,
 429          * bounded either by how much the Linux tty layer can handle,
 430          * or the amount of data the card actually has pending...
 431          */
 432         while (n) {
 433                 unsigned char *ch_pos = ch->ch_equeue + tail;
 434
 435                 s = ((head >= tail) ? head : RQUEUESIZE) - tail;
 436                 s = min(s, n);
 437
 438                 if (s <= 0)
 439                         break;
 440
 441                 /*
 442                  * If conditions are such that ld needs to see all
 443                  * UART errors, we will have to walk each character
 444                  * and error byte and send them to the buffer one at
 445                  * a time.
 446                  */
 447                 if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
 448                         for (i = 0; i < s; i++) {
 449                                 unsigned char ch = *(ch_pos + i);
 450                                 char flag = TTY_NORMAL;
 451
 452                                 if (ch & UART_LSR_BI)
 453                                         flag = TTY_BREAK;
 454                                 else if (ch & UART_LSR_PE)
 455                                         flag = TTY_PARITY;
 456                                 else if (ch & UART_LSR_FE)
 457                                         flag = TTY_FRAME;
 458
 459                                 tty_insert_flip_char(tp->port, ch, flag);
 460                         }
 461                 } else {
 462                         tty_insert_flip_string(tp->port, ch_pos, s);
 463                 }
 464
 465                 tail += s;
 466                 n -= s;
 467                 /* Flip queue if needed */
 468                 tail &= rmask;
 469         }
 470
 471         ch->ch_r_tail = tail & rmask;
 472         ch->ch_e_tail = tail & rmask;
 473         dgnc_check_queue_flow_control(ch);
 474         spin_unlock_irqrestore(&ch->ch_lock, flags);
 475
 476         /* Tell the tty layer its okay to "eat" the data now */
 477         tty_flip_buffer_push(tp->port);
 478
 479         if (ld)
 480                 tty_ldisc_deref(ld);
 481         return;
 482
 483 exit_unlock:
 484         spin_unlock_irqrestore(&ch->ch_lock, flags);
 485         if (ld)
 486                 tty_ldisc_deref(ld);
 487 }
 488
 489 /**
 490  * dgnc_carrier()
 491  *
 492  * Determines when CARRIER changes state and takes appropriate
 493  * action.
 494  */
 495 void dgnc_carrier(struct channel_t *ch)
 496 {
 497         int virt_carrier = 0;
 498         int phys_carrier = 0;
 499
 500         if (!ch)
 501                 return;
 502
 503         if (ch->ch_mistat & UART_MSR_DCD)
 504                 phys_carrier = 1;
 505
 506         if (ch->ch_digi.digi_flags & DIGI_FORCEDCD)
 507                 virt_carrier = 1;
 508
 509         if (ch->ch_c_cflag & CLOCAL)
 510                 virt_carrier = 1;
 511
 512         /* Test for a VIRTUAL carrier transition to HIGH. */
 513
 514         if (((ch->ch_flags & CH_FCAR) == 0) && (virt_carrier == 1)) {
 515                 /*
 516                  * When carrier rises, wake any threads waiting
 517                  * for carrier in the open routine.
 518                  */
 519                 if (waitqueue_active(&ch->ch_flags_wait))
 520                         wake_up_interruptible(&ch->ch_flags_wait);
 521         }
 522
 523         /* Test for a PHYSICAL carrier transition to HIGH. */
 524
 525         if (((ch->ch_flags & CH_CD) == 0) && (phys_carrier == 1)) {
 526                 /*
 527                  * When carrier rises, wake any threads waiting
 528                  * for carrier in the open routine.
 529                  */
 530                 if (waitqueue_active(&ch->ch_flags_wait))
 531                         wake_up_interruptible(&ch->ch_flags_wait);
 532         }
 533
 534         /*
 535          *  Test for a PHYSICAL transition to low, so long as we aren't
 536          *  currently ignoring physical transitions (which is what "virtual
 537          *  carrier" indicates).
 538          *
 539          *  The transition of the virtual carrier to low really doesn't
 540          *  matter... it really only means "ignore carrier state", not
 541          *  "make pretend that carrier is there".
 542          */
 543         if ((virt_carrier == 0) && ((ch->ch_flags & CH_CD) != 0) &&
 544             (phys_carrier == 0)) {
 545                 /*
 546                  *   When carrier drops:
 547                  *
 548                  *   Drop carrier on all open units.
 549                  *
 550                  *   Flush queues, waking up any task waiting in the
 551                  *   line discipline.
 552                  *
 553                  *   Send a hangup to the control terminal.
 554                  *
 555                  *   Enable all select calls.
 556                  */
 557                 if (waitqueue_active(&ch->ch_flags_wait))
 558                         wake_up_interruptible(&ch->ch_flags_wait);
 559
 560                 if (ch->ch_tun.un_open_count > 0)
 561                         tty_hangup(ch->ch_tun.un_tty);
 562
 563                 if (ch->ch_pun.un_open_count > 0)
 564                         tty_hangup(ch->ch_pun.un_tty);
 565         }
 566
 567         /*  Make sure that our cached values reflect the current reality. */
 568
 569         if (virt_carrier == 1)
 570                 ch->ch_flags |= CH_FCAR;
 571         else
 572                 ch->ch_flags &= ~CH_FCAR;
 573
 574         if (phys_carrier == 1)
 575                 ch->ch_flags |= CH_CD;
 576         else
 577                 ch->ch_flags &= ~CH_CD;
 578 }
 579
 580 /*  Assign the custom baud rate to the channel structure */
 581 static void dgnc_set_custom_speed(struct channel_t *ch, uint newrate)
 582 {
 583         int testdiv;
 584         int testrate_high;
 585         int testrate_low;
 586         int deltahigh;
 587         int deltalow;
 588
 589         if (newrate <= 0) {
 590                 ch->ch_custom_speed = 0;
 591                 return;
 592         }
 593
 594         /*
 595          *  Since the divisor is stored in a 16-bit integer, we make sure
 596          *  we don't allow any rates smaller than a 16-bit integer would allow.
 597          *  And of course, rates above the dividend won't fly.
 598          */
 599         if (newrate && newrate < ((ch->ch_bd->bd_dividend / 0xFFFF) + 1))
 600                 newrate = (ch->ch_bd->bd_dividend / 0xFFFF) + 1;
 601
 602         if (newrate && newrate > ch->ch_bd->bd_dividend)
 603                 newrate = ch->ch_bd->bd_dividend;
 604
 605         if (newrate > 0) {
 606                 testdiv = ch->ch_bd->bd_dividend / newrate;
 607
 608                 /*
 609                  *  If we try to figure out what rate the board would use
 610                  *  with the test divisor, it will be either equal or higher
 611                  *  than the requested baud rate.  If we then determine the
 612                  *  rate with a divisor one higher, we will get the next lower
 613                  *  supported rate below the requested.
 614                  */
 615                 testrate_high = ch->ch_bd->bd_dividend / testdiv;
 616                 testrate_low  = ch->ch_bd->bd_dividend / (testdiv + 1);
 617
 618                 /*
 619                  *  If the rate for the requested divisor is correct, just
 620                  *  use it and be done.
 621                  */
 622                 if (testrate_high != newrate) {
 623                         /*
 624                          *  Otherwise, pick the rate that is closer
 625                          *  (i.e. whichever rate has a smaller delta).
 626                          */
 627                         deltahigh = testrate_high - newrate;
 628                         deltalow = newrate - testrate_low;
 629
 630                         if (deltahigh < deltalow)
 631                                 newrate = testrate_high;
 632                         else
 633                                 newrate = testrate_low;
 634                 }
 635         }
 636
 637         ch->ch_custom_speed = newrate;
 638 }
 639
 640 void dgnc_check_queue_flow_control(struct channel_t *ch)
 641 {
 642         int qleft;
 643
 644         qleft = ch->ch_r_tail - ch->ch_r_head - 1;
 645         if (qleft < 0)
 646                 qleft += RQUEUEMASK + 1;
 647
 648         /*
 649          * Check to see if we should enforce flow control on our queue because
 650          * the ld (or user) isn't reading data out of our queue fast enuf.
 651          *
 652          * NOTE: This is done based on what the current flow control of the
 653          * port is set for.
 654          *
 655          * 1) HWFLOW (RTS) - Turn off the UART's Receive interrupt.
 656          *      This will cause the UART's FIFO to back up, and force
 657          *      the RTS signal to be dropped.
 658          * 2) SWFLOW (IXOFF) - Keep trying to send a stop character to
 659          *      the other side, in hopes it will stop sending data to us.
 660          * 3) NONE - Nothing we can do.  We will simply drop any extra data
 661          *      that gets sent into us when the queue fills up.
 662          */
 663         if (qleft < 256) {
 664                 /* HWFLOW */
 665                 if (ch->ch_digi.digi_flags & CTSPACE ||
 666                     ch->ch_c_cflag & CRTSCTS) {
 667                         if (!(ch->ch_flags & CH_RECEIVER_OFF)) {
 668                                 ch->ch_bd->bd_ops->disable_receiver(ch);
 669                                 ch->ch_flags |= (CH_RECEIVER_OFF);
 670                         }
 671                 }
 672                 /* SWFLOW */
 673                 else if (ch->ch_c_iflag & IXOFF) {
 674                         if (ch->ch_stops_sent <= MAX_STOPS_SENT) {
 675                                 ch->ch_bd->bd_ops->send_stop_character(ch);
 676                                 ch->ch_stops_sent++;
 677                         }
 678                 }
 679         }
 680
 681         /*
 682          * Check to see if we should unenforce flow control because
 683          * ld (or user) finally read enuf data out of our queue.
 684          *
 685          * NOTE: This is done based on what the current flow control of the
 686          * port is set for.
 687          *
 688          * 1) HWFLOW (RTS) - Turn back on the UART's Receive interrupt.
 689          *      This will cause the UART's FIFO to raise RTS back up,
 690          *      which will allow the other side to start sending data again.
 691          * 2) SWFLOW (IXOFF) - Send a start character to
 692          *      the other side, so it will start sending data to us again.
 693          * 3) NONE - Do nothing. Since we didn't do anything to turn off the
 694          *      other side, we don't need to do anything now.
 695          */
 696         if (qleft > (RQUEUESIZE / 2)) {
 697                 /* HWFLOW */
 698                 if (ch->ch_digi.digi_flags & RTSPACE ||
 699                     ch->ch_c_cflag & CRTSCTS) {
 700                         if (ch->ch_flags & CH_RECEIVER_OFF) {
 701                                 ch->ch_bd->bd_ops->enable_receiver(ch);
 702                                 ch->ch_flags &= ~(CH_RECEIVER_OFF);
 703                         }
 704                 }
 705                 /* SWFLOW */
 706                 else if (ch->ch_c_iflag & IXOFF && ch->ch_stops_sent) {
 707                         ch->ch_stops_sent = 0;
 708                         ch->ch_bd->bd_ops->send_start_character(ch);
 709                 }
 710         }
 711 }
 712
 713 static void dgnc_set_signal_low(struct channel_t *ch, const unsigned char sig)
 714 {
 715         ch->ch_mostat &= ~(sig);
 716         ch->ch_bd->bd_ops->assert_modem_signals(ch);
 717 }
 718
 719 void dgnc_wakeup_writes(struct channel_t *ch)
 720 {
 721         int qlen = 0;
 722         unsigned long flags;
 723
 724         if (!ch)
 725                 return;
 726
 727         spin_lock_irqsave(&ch->ch_lock, flags);
 728
 729         /* If channel now has space, wake up anyone waiting on the condition. */
 730
 731         qlen = ch->ch_w_head - ch->ch_w_tail;
 732         if (qlen < 0)
 733                 qlen += WQUEUESIZE;
 734
 735         if (qlen >= (WQUEUESIZE - 256)) {
 736                 spin_unlock_irqrestore(&ch->ch_lock, flags);
 737                 return;
 738         }
 739
 740         if (ch->ch_tun.un_flags & UN_ISOPEN) {
 741                 tty_wakeup(ch->ch_tun.un_tty);
 742
 743                 /*
 744                  * If unit is set to wait until empty, check to make sure
 745                  * the queue AND FIFO are both empty.
 746                  */
 747                 if (ch->ch_tun.un_flags & UN_EMPTY) {
 748                         if ((qlen == 0) &&
 749                             (ch->ch_bd->bd_ops->get_uart_bytes_left(ch) == 0)) {
 750                                 ch->ch_tun.un_flags &= ~(UN_EMPTY);
 751
 752                                 /*
 753                                  * If RTS Toggle mode is on, whenever
 754                                  * the queue and UART is empty, keep RTS low.
 755                                  */
 756                                 if (ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE)
 757                                         dgnc_set_signal_low(ch, UART_MCR_RTS);
 758
 759                                 /*
 760                                  * If DTR Toggle mode is on, whenever
 761                                  * the queue and UART is empty, keep DTR low.
 762                                  */
 763                                 if (ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE)
 764                                         dgnc_set_signal_low(ch, UART_MCR_DTR);
 765                         }
 766                 }
 767
 768                 wake_up_interruptible(&ch->ch_tun.un_flags_wait);
 769         }
 770
 771         if (ch->ch_pun.un_flags & UN_ISOPEN) {
 772                 tty_wakeup(ch->ch_pun.un_tty);
 773
 774                 /*
 775                  * If unit is set to wait until empty, check to make sure
 776                  * the queue AND FIFO are both empty.
 777                  */
 778                 if (ch->ch_pun.un_flags & UN_EMPTY) {
 779                         if ((qlen == 0) &&
 780                             (ch->ch_bd->bd_ops->get_uart_bytes_left(ch) == 0))
 781                                 ch->ch_pun.un_flags &= ~(UN_EMPTY);
 782                 }
 783
 784                 wake_up_interruptible(&ch->ch_pun.un_flags_wait);
 785         }
 786
 787         spin_unlock_irqrestore(&ch->ch_lock, flags);
 788 }
 789
 790 static struct dgnc_board *find_board_by_major(unsigned int major)
 791 {
 792         int i;
 793
 794         for (i = 0; i < MAXBOARDS; i++) {
 795                 struct dgnc_board *brd = dgnc_board[i];
 796
 797                 if (!brd)
 798                         return NULL;
 799
 800                 if (major == brd->serial_driver->major ||
 801                     major == brd->print_driver->major)
 802                         return brd;
 803         }
 804
 805         return NULL;
 806 }
 807
 808 /* TTY Entry points and helper functions */
 809
 810 static int dgnc_tty_open(struct tty_struct *tty, struct file *file)
 811 {
 812         struct dgnc_board       *brd;
 813         struct channel_t *ch;
 814         struct un_t     *un;
 815         uint            major = 0;
 816         uint            minor = 0;
 817         int             rc = 0;
 818         unsigned long flags;
 819
 820         rc = 0;
 821
 822         major = MAJOR(tty_devnum(tty));
 823         minor = MINOR(tty_devnum(tty));
 824
 825         if (major > 255)
 826                 return -ENXIO;
 827
 828         brd = find_board_by_major(major);
 829         if (!brd)
 830                 return -ENXIO;
 831
 832         rc = wait_event_interruptible(brd->state_wait,
 833                                       (brd->state & BOARD_READY));
 834         if (rc)
 835                 return rc;
 836
 837         spin_lock_irqsave(&brd->bd_lock, flags);
 838
 839         if (PORT_NUM(minor) >= brd->nasync) {
 840                 rc = -ENXIO;
 841                 goto err_brd_unlock;
 842         }
 843
 844         ch = brd->channels[PORT_NUM(minor)];
 845         if (!ch) {
 846                 rc = -ENXIO;
 847                 goto err_brd_unlock;
 848         }
 849
 850         spin_unlock_irqrestore(&brd->bd_lock, flags);
 851
 852         spin_lock_irqsave(&ch->ch_lock, flags);
 853
 854         /* Figure out our type */
 855         if (!IS_PRINT(minor)) {
 856                 un = &brd->channels[PORT_NUM(minor)]->ch_tun;
 857                 un->un_type = DGNC_SERIAL;
 858         } else if (IS_PRINT(minor)) {
 859                 un = &brd->channels[PORT_NUM(minor)]->ch_pun;
 860                 un->un_type = DGNC_PRINT;
 861         } else {
 862                 rc = -ENXIO;
 863                 goto err_ch_unlock;
 864         }
 865
 866         /*
 867          * If the port is still in a previous open, and in a state
 868          * where we simply cannot safely keep going, wait until the
 869          * state clears.
 870          */
 871         spin_unlock_irqrestore(&ch->ch_lock, flags);
 872
 873         rc = wait_event_interruptible(ch->ch_flags_wait,
 874                                       ((ch->ch_flags & CH_OPENING) == 0));
 875         /* If ret is non-zero, user ctrl-c'ed us */
 876         if (rc)
 877                 return -EINTR;
 878
 879         /*
 880          * If either unit is in the middle of the fragile part of close,
 881          * we just cannot touch the channel safely.
 882          * Go to sleep, knowing that when the channel can be
 883          * touched safely, the close routine will signal the
 884          * ch_flags_wait to wake us back up.
 885          */
 886         rc = wait_event_interruptible(ch->ch_flags_wait,
 887                                       !((ch->ch_tun.un_flags |
 888                                       ch->ch_pun.un_flags) & UN_CLOSING));
 889         /* If ret is non-zero, user ctrl-c'ed us */
 890         if (rc)
 891                 return -EINTR;
 892
 893         spin_lock_irqsave(&ch->ch_lock, flags);
 894
 895         tty->driver_data = un;
 896
 897         /* Initialize tty's */
 898
 899         if (!(un->un_flags & UN_ISOPEN)) {
 900                 un->un_tty = tty;
 901
 902                 /* Maybe do something here to the TTY struct as well? */
 903         }
 904
 905         /*
 906          * Allocate channel buffers for read/write/error.
 907          * Set flag, so we don't get trounced on.
 908          */
 909         ch->ch_flags |= (CH_OPENING);
 910
 911         spin_unlock_irqrestore(&ch->ch_lock, flags);
 912
 913         if (!ch->ch_rqueue)
 914                 ch->ch_rqueue = kzalloc(RQUEUESIZE, GFP_KERNEL);
 915         if (!ch->ch_equeue)
 916                 ch->ch_equeue = kzalloc(EQUEUESIZE, GFP_KERNEL);
 917         if (!ch->ch_wqueue)
 918                 ch->ch_wqueue = kzalloc(WQUEUESIZE, GFP_KERNEL);
 919
 920         if (!ch->ch_rqueue || !ch->ch_equeue || !ch->ch_wqueue) {
 921                 kfree(ch->ch_rqueue);
 922                 kfree(ch->ch_equeue);
 923                 kfree(ch->ch_wqueue);
 924                 return -ENOMEM;
 925         }
 926
 927         spin_lock_irqsave(&ch->ch_lock, flags);
 928
 929         ch->ch_flags &= ~(CH_OPENING);
 930         wake_up_interruptible(&ch->ch_flags_wait);
 931
 932         /* Initialize if neither terminal or printer is open. */
 933
 934         if (!((ch->ch_tun.un_flags | ch->ch_pun.un_flags) & UN_ISOPEN)) {
 935                 /* Flush input queues. */
 936                 ch->ch_r_head = 0;
 937                 ch->ch_r_tail = 0;
 938                 ch->ch_e_head = 0;
 939                 ch->ch_e_tail = 0;
 940                 ch->ch_w_head = 0;
 941                 ch->ch_w_tail = 0;
 942
 943                 brd->bd_ops->flush_uart_write(ch);
 944                 brd->bd_ops->flush_uart_read(ch);
 945
 946                 ch->ch_flags = 0;
 947                 ch->ch_cached_lsr = 0;
 948                 ch->ch_stop_sending_break = 0;
 949                 ch->ch_stops_sent = 0;
 950
 951                 ch->ch_c_cflag   = tty->termios.c_cflag;
 952                 ch->ch_c_iflag   = tty->termios.c_iflag;
 953                 ch->ch_c_oflag   = tty->termios.c_oflag;
 954                 ch->ch_c_lflag   = tty->termios.c_lflag;
 955                 ch->ch_startc = tty->termios.c_cc[VSTART];
 956                 ch->ch_stopc  = tty->termios.c_cc[VSTOP];
 957
 958                 /*
 959                  * Bring up RTS and DTR...
 960                  * Also handle RTS or DTR toggle if set.
 961                  */
 962                 if (!(ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE))
 963                         ch->ch_mostat |= (UART_MCR_RTS);
 964                 if (!(ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE))
 965                         ch->ch_mostat |= (UART_MCR_DTR);
 966
 967                 /* Tell UART to init itself */
 968                 brd->bd_ops->uart_init(ch);
 969         }
 970
 971         brd->bd_ops->param(tty);
 972
 973         dgnc_carrier(ch);
 974
 975         spin_unlock_irqrestore(&ch->ch_lock, flags);
 976
 977         rc = dgnc_block_til_ready(tty, file, ch);
 978
 979         spin_lock_irqsave(&ch->ch_lock, flags);
 980         ch->ch_open_count++;
 981         un->un_open_count++;
 982         un->un_flags |= (UN_ISOPEN);
 983         spin_unlock_irqrestore(&ch->ch_lock, flags);
 984
 985         return rc;
 986
 987 err_brd_unlock:
 988         spin_unlock_irqrestore(&brd->bd_lock, flags);
 989
 990         return rc;
 991 err_ch_unlock:
 992         spin_unlock_irqrestore(&ch->ch_lock, flags);
 993
 994         return rc;
 995 }
 996
 997 /* Wait for DCD, if needed. */
 998 static int dgnc_block_til_ready(struct tty_struct *tty,
 999                                 struct file *file,
1000                                 struct channel_t *ch)
1001 {
1002         int rc = 0;
1003         struct un_t *un = tty->driver_data;
1004         unsigned long flags;
1005         uint    old_flags = 0;
1006         int     sleep_on_un_flags = 0;
1007
1008         if (!file)
1009                 return -ENXIO;
1010
1011         spin_lock_irqsave(&ch->ch_lock, flags);
1012
1013         ch->ch_wopen++;
1014
1015         while (1) {
1016                 sleep_on_un_flags = 0;
1017
1018                 if (ch->ch_bd->state == BOARD_FAILED) {
1019                         rc = -ENXIO;
1020                         break;
1021                 }
1022
1023                 if (tty_hung_up_p(file)) {
1024                         rc = -EAGAIN;
1025                         break;
1026                 }
1027
1028                 /*
1029                  * If either unit is in the middle of the fragile part of close,
1030                  * we just cannot touch the channel safely.
1031                  * Go back to sleep, knowing that when the channel can be
1032                  * touched safely, the close routine will signal the
1033                  * ch_wait_flags to wake us back up.
1034                  */
1035                 if (!((ch->ch_tun.un_flags |
1036                     ch->ch_pun.un_flags) &
1037                     UN_CLOSING)) {
1038                         /*
1039                          * Our conditions to leave cleanly and happily:
1040                          * 1) NONBLOCKING on the tty is set.
1041                          * 2) CLOCAL is set.
1042                          * 3) DCD (fake or real) is active.
1043                          */
1044
1045                         if (file->f_flags & O_NONBLOCK)
1046                                 break;
1047
1048                         if (tty_io_error(tty)) {
1049                                 rc = -EIO;
1050                                 break;
1051                         }
1052
1053                         if (ch->ch_flags & CH_CD)
1054                                 break;
1055
1056                         if (ch->ch_flags & CH_FCAR)
1057                                 break;
1058                 } else {
1059                         sleep_on_un_flags = 1;
1060                 }
1061
1062                 /*
1063                  * If there is a signal pending, the user probably
1064                  * interrupted (ctrl-c) us.
1065                  */
1066                 if (signal_pending(current)) {
1067                         rc = -ERESTARTSYS;
1068                         break;
1069                 }
1070
1071                 if (sleep_on_un_flags)
1072                         old_flags = ch->ch_tun.un_flags | ch->ch_pun.un_flags;
1073                 else
1074                         old_flags = ch->ch_flags;
1075
1076                 /*
1077                  * Let go of channel lock before calling schedule.
1078                  * Our poller will get any FEP events and wake us up when DCD
1079                  * eventually goes active.
1080                  */
1081
1082                 spin_unlock_irqrestore(&ch->ch_lock, flags);
1083
1084                 /*
1085                  * Wait for something in the flags to change
1086                  * from the current value.
1087                  */
1088                 if (sleep_on_un_flags)
1089                         rc = wait_event_interruptible
1090                                 (un->un_flags_wait,
1091                                  (old_flags != (ch->ch_tun.un_flags |
1092                                                 ch->ch_pun.un_flags)));
1093                 else
1094                         rc = wait_event_interruptible(
1095                                         ch->ch_flags_wait,
1096                                         (old_flags != ch->ch_flags));
1097
1098                 /*
1099                  * We got woken up for some reason.
1100                  * Before looping around, grab our channel lock.
1101                  */
1102                 spin_lock_irqsave(&ch->ch_lock, flags);
1103         }
1104
1105         ch->ch_wopen--;
1106
1107         spin_unlock_irqrestore(&ch->ch_lock, flags);
1108
1109         return rc;
1110 }
1111
1112 /* Hangup the port.  Like a close, but don't wait for output to drain. */
1113 static void dgnc_tty_hangup(struct tty_struct *tty)
1114 {
1115         if (!tty)
1116                 return;
1117
1118         /* flush the transmit queues */
1119         dgnc_tty_flush_buffer(tty);
1120 }
1121
1122 static void dgnc_tty_close(struct tty_struct *tty, struct file *file)
1123 {
1124         struct dgnc_board *bd;
1125         struct channel_t *ch;
1126         struct un_t *un;
1127         unsigned long flags;
1128
1129         if (!tty)
1130                 return;
1131
1132         un = tty->driver_data;
1133         if (!un)
1134                 return;
1135
1136         ch = un->un_ch;
1137         if (!ch)
1138                 return;
1139
1140         bd = ch->ch_bd;
1141         if (!bd)
1142                 return;
1143
1144         spin_lock_irqsave(&ch->ch_lock, flags);
1145
1146         /*
1147          * Determine if this is the last close or not - and if we agree about
1148          * which type of close it is with the Line Discipline
1149          */
1150         if ((tty->count == 1) && (un->un_open_count != 1)) {
1151                 /*
1152                  * Uh, oh.  tty->count is 1, which means that the tty
1153                  * structure will be freed.  un_open_count should always
1154                  * be one in these conditions.  If it's greater than
1155                  * one, we've got real problems, since it means the
1156                  * serial port won't be shutdown.
1157                  */
1158                 dev_dbg(tty->dev,
1159                         "tty->count is 1, un open count is %d\n",
1160                         un->un_open_count);
1161                 un->un_open_count = 1;
1162         }
1163
1164         if (un->un_open_count)
1165                 un->un_open_count--;
1166         else
1167                 dev_dbg(tty->dev,
1168                         "bad serial port open count of %d\n",
1169                         un->un_open_count);
1170
1171         ch->ch_open_count--;
1172
1173         if (ch->ch_open_count && un->un_open_count) {
1174                 spin_unlock_irqrestore(&ch->ch_lock, flags);
1175                 return;
1176         }
1177
1178         /* OK, its the last close on the unit */
1179         un->un_flags |= UN_CLOSING;
1180
1181         tty->closing = 1;
1182
1183         /*
1184          * Only officially close channel if count is 0 and
1185          * DIGI_PRINTER bit is not set.
1186          */
1187         if ((ch->ch_open_count == 0) &&
1188             !(ch->ch_digi.digi_flags & DIGI_PRINTER)) {
1189                 ch->ch_flags &= ~(CH_STOPI | CH_FORCED_STOPI);
1190
1191                 /* turn off print device when closing print device. */
1192
1193                 if ((un->un_type == DGNC_PRINT) && (ch->ch_flags & CH_PRON)) {
1194                         dgnc_wmove(ch, ch->ch_digi.digi_offstr,
1195                                    (int)ch->ch_digi.digi_offlen);
1196                         ch->ch_flags &= ~CH_PRON;
1197                 }
1198
1199                 spin_unlock_irqrestore(&ch->ch_lock, flags);
1200                 /* wait for output to drain */
1201                 /* This will also return if we take an interrupt */
1202
1203                 bd->bd_ops->drain(tty, 0);
1204
1205                 dgnc_tty_flush_buffer(tty);
1206                 tty_ldisc_flush(tty);
1207
1208                 spin_lock_irqsave(&ch->ch_lock, flags);
1209
1210                 tty->closing = 0;
1211
1212                 /* If we have HUPCL set, lower DTR and RTS */
1213
1214                 if (ch->ch_c_cflag & HUPCL) {
1215                         /* Drop RTS/DTR */
1216                         ch->ch_mostat &= ~(UART_MCR_DTR | UART_MCR_RTS);
1217                         bd->bd_ops->assert_modem_signals(ch);
1218
1219                         /*
1220                          * Go to sleep to ensure RTS/DTR
1221                          * have been dropped for modems to see it.
1222                          */
1223                         if (ch->ch_close_delay) {
1224                                 spin_unlock_irqrestore(&ch->ch_lock,
1225                                                        flags);
1226                                 msleep_interruptible(ch->ch_close_delay);
1227                                 spin_lock_irqsave(&ch->ch_lock, flags);
1228                         }
1229                 }
1230
1231                 ch->ch_old_baud = 0;
1232
1233                 /* Turn off UART interrupts for this port */
1234                 ch->ch_bd->bd_ops->uart_off(ch);
1235         } else {
1236                 /* turn off print device when closing print device. */
1237
1238                 if ((un->un_type == DGNC_PRINT) && (ch->ch_flags & CH_PRON)) {
1239                         dgnc_wmove(ch, ch->ch_digi.digi_offstr,
1240                                    (int)ch->ch_digi.digi_offlen);
1241                         ch->ch_flags &= ~CH_PRON;
1242                 }
1243         }
1244
1245         un->un_tty = NULL;
1246         un->un_flags &= ~(UN_ISOPEN | UN_CLOSING);
1247
1248         wake_up_interruptible(&ch->ch_flags_wait);
1249         wake_up_interruptible(&un->un_flags_wait);
1250
1251         spin_unlock_irqrestore(&ch->ch_lock, flags);
1252 }
1253
1254 /*
1255  * Return number of characters that have not been transmitted yet.
1256  *
1257  * This routine is used by the line discipline to determine if there
1258  * is data waiting to be transmitted/drained/flushed or not.
1259  */
1260 static int dgnc_tty_chars_in_buffer(struct tty_struct *tty)
1261 {
1262         struct channel_t *ch = NULL;
1263         struct un_t *un = NULL;
1264         ushort thead;
1265         ushort ttail;
1266         uint tmask;
1267         uint chars;
1268         unsigned long flags;
1269
1270         if (!tty)
1271                 return 0;
1272
1273         un = tty->driver_data;
1274         if (!un)
1275                 return 0;
1276
1277         ch = un->un_ch;
1278         if (!ch)
1279                 return 0;
1280
1281         spin_lock_irqsave(&ch->ch_lock, flags);
1282
1283         tmask = WQUEUEMASK;
1284         thead = ch->ch_w_head & tmask;
1285         ttail = ch->ch_w_tail & tmask;
1286
1287         spin_unlock_irqrestore(&ch->ch_lock, flags);
1288
1289         if (ttail == thead)
1290                 chars = 0;
1291         else if (thead > ttail)
1292                 chars = thead - ttail;
1293         else
1294                 chars = thead - ttail + WQUEUESIZE;
1295
1296         return chars;
1297 }
1298
1299 /*
1300  * Reduces bytes_available to the max number of characters
1301  * that can be sent currently given the maxcps value, and
1302  * returns the new bytes_available.  This only affects printer
1303  * output.
1304  */
1305 static int dgnc_maxcps_room(struct channel_t *ch, int bytes_available)
1306 {
1307         int rc = bytes_available;
1308
1309         if (ch->ch_digi.digi_maxcps > 0 && ch->ch_digi.digi_bufsize > 0) {
1310                 int cps_limit = 0;
1311                 unsigned long current_time = jiffies;
1312                 unsigned long buffer_time = current_time +
1313                         (HZ * ch->ch_digi.digi_bufsize) /
1314                         ch->ch_digi.digi_maxcps;
1315
1316                 if (ch->ch_cpstime < current_time) {
1317                         /* buffer is empty */
1318                         ch->ch_cpstime = current_time;  /* reset ch_cpstime */
1319                         cps_limit = ch->ch_digi.digi_bufsize;
1320                 } else if (ch->ch_cpstime < buffer_time) {
1321                         /* still room in the buffer */
1322                         cps_limit = ((buffer_time - ch->ch_cpstime) *
1323                                         ch->ch_digi.digi_maxcps) / HZ;
1324                 } else {
1325                         /* no room in the buffer */
1326                         cps_limit = 0;
1327                 }
1328
1329                 rc = min(cps_limit, bytes_available);
1330         }
1331
1332         return rc;
1333 }
1334
1335 /* Return room available in Tx buffer */
1336 static int dgnc_tty_write_room(struct tty_struct *tty)
1337 {
1338         struct channel_t *ch = NULL;
1339         struct un_t *un = NULL;
1340         ushort head;
1341         ushort tail;
1342         ushort tmask;
1343         int room = 0;
1344         unsigned long flags;
1345
1346         if (!tty)
1347                 return 0;
1348
1349         un = tty->driver_data;
1350         if (!un)
1351                 return 0;
1352
1353         ch = un->un_ch;
1354         if (!ch)
1355                 return 0;
1356
1357         spin_lock_irqsave(&ch->ch_lock, flags);
1358
1359         tmask = WQUEUEMASK;
1360         head = (ch->ch_w_head) & tmask;
1361         tail = (ch->ch_w_tail) & tmask;
1362
1363         room = tail - head - 1;
1364         if (room < 0)
1365                 room += WQUEUESIZE;
1366
1367         /* Limit printer to maxcps */
1368         if (un->un_type != DGNC_PRINT)
1369                 room = dgnc_maxcps_room(ch, room);
1370
1371         /*
1372          * If we are printer device, leave room for
1373          * possibly both the on and off strings.
1374          */
1375         if (un->un_type == DGNC_PRINT) {
1376                 if (!(ch->ch_flags & CH_PRON))
1377                         room -= ch->ch_digi.digi_onlen;
1378                 room -= ch->ch_digi.digi_offlen;
1379         } else {
1380                 if (ch->ch_flags & CH_PRON)
1381                         room -= ch->ch_digi.digi_offlen;
1382         }
1383
1384         if (room < 0)
1385                 room = 0;
1386
1387         spin_unlock_irqrestore(&ch->ch_lock, flags);
1388         return room;
1389 }
1390
1391 /*
1392  * Put a character into ch->ch_buf
1393  * Used by the line discipline for OPOST processing
1394  */
1395 static int dgnc_tty_put_char(struct tty_struct *tty, unsigned char c)
1396 {
1397         dgnc_tty_write(tty, &c, 1);
1398         return 1;
1399 }
1400
1401 /*
1402  * Take data from the user or kernel and send it out to the FEP.
1403  * In here exists all the Transparent Print magic as well.
1404  */
1405 static int dgnc_tty_write(struct tty_struct *tty,
1406                           const unsigned char *buf, int count)
1407 {
1408         struct channel_t *ch = NULL;
1409         struct un_t *un = NULL;
1410         int bufcount = 0, n = 0;
1411         unsigned long flags;
1412         ushort head;
1413         ushort tail;
1414         ushort tmask;
1415         uint remain;
1416
1417         if (!tty)
1418                 return 0;
1419
1420         un = tty->driver_data;
1421         if (!un)
1422                 return 0;
1423
1424         ch = un->un_ch;
1425         if (!ch)
1426                 return 0;
1427
1428         if (!count)
1429                 return 0;
1430
1431         /*
1432          * Store original amount of characters passed in.
1433          * This helps to figure out if we should ask the FEP
1434          * to send us an event when it has more space available.
1435          */
1436
1437         spin_lock_irqsave(&ch->ch_lock, flags);
1438
1439         tmask = WQUEUEMASK;
1440         head = (ch->ch_w_head) & tmask;
1441         tail = (ch->ch_w_tail) & tmask;
1442
1443         bufcount = tail - head - 1;
1444         if (bufcount < 0)
1445                 bufcount += WQUEUESIZE;
1446
1447         /*
1448          * Limit printer output to maxcps overall, with bursts allowed
1449          * up to bufsize characters.
1450          */
1451         if (un->un_type != DGNC_PRINT)
1452                 bufcount = dgnc_maxcps_room(ch, bufcount);
1453
1454         count = min(count, bufcount);
1455         if (count <= 0)
1456                 goto exit_retry;
1457
1458         /*
1459          * Output the printer ON string, if we are in terminal mode, but
1460          * need to be in printer mode.
1461          */
1462         if ((un->un_type == DGNC_PRINT) && !(ch->ch_flags & CH_PRON)) {
1463                 dgnc_wmove(ch, ch->ch_digi.digi_onstr,
1464                            (int)ch->ch_digi.digi_onlen);
1465                 head = (ch->ch_w_head) & tmask;
1466                 ch->ch_flags |= CH_PRON;
1467         }
1468
1469         /*
1470          * On the other hand, output the printer OFF string, if we are
1471          * currently in printer mode, but need to output to the terminal.
1472          */
1473         if ((un->un_type != DGNC_PRINT) && (ch->ch_flags & CH_PRON)) {
1474                 dgnc_wmove(ch, ch->ch_digi.digi_offstr,
1475                            (int)ch->ch_digi.digi_offlen);
1476                 head = (ch->ch_w_head) & tmask;
1477                 ch->ch_flags &= ~CH_PRON;
1478         }
1479
1480         n = count;
1481
1482         /*
1483          * If the write wraps over the top of the circular buffer,
1484          * move the portion up to the wrap point, and reset the
1485          * pointers to the bottom.
1486          */
1487         remain = WQUEUESIZE - head;
1488
1489         if (n >= remain) {
1490                 n -= remain;
1491                 memcpy(ch->ch_wqueue + head, buf, remain);
1492                 head = 0;
1493                 buf += remain;
1494         }
1495
1496         if (n > 0) {
1497                 /* Move rest of data. */
1498                 remain = n;
1499                 memcpy(ch->ch_wqueue + head, buf, remain);
1500                 head += remain;
1501         }
1502
1503         if (count) {
1504                 head &= tmask;
1505                 ch->ch_w_head = head;
1506         }
1507
1508         /* Update printer buffer empty time. */
1509         if ((un->un_type == DGNC_PRINT) && (ch->ch_digi.digi_maxcps > 0) &&
1510             (ch->ch_digi.digi_bufsize > 0)) {
1511                 ch->ch_cpstime += (HZ * count) / ch->ch_digi.digi_maxcps;
1512         }
1513
1514         spin_unlock_irqrestore(&ch->ch_lock, flags);
1515
1516         if (count)
1517                 ch->ch_bd->bd_ops->copy_data_from_queue_to_uart(ch);
1518
1519         return count;
1520
1521 exit_retry:
1522         spin_unlock_irqrestore(&ch->ch_lock, flags);
1523
1524         return 0;
1525 }
1526
1527 /* Return modem signals to ld. */
1528 static int dgnc_tty_tiocmget(struct tty_struct *tty)
1529 {
1530         struct channel_t *ch;
1531         struct un_t *un;
1532         int rc;
1533         unsigned char mstat = 0;
1534         unsigned long flags;
1535
1536         if (!tty)
1537                 return -EIO;
1538
1539         un = tty->driver_data;
1540         if (!un)
1541                 return -EIO;
1542
1543         ch = un->un_ch;
1544         if (!ch)
1545                 return -EIO;
1546
1547         spin_lock_irqsave(&ch->ch_lock, flags);
1548
1549         mstat = ch->ch_mostat | ch->ch_mistat;
1550
1551         spin_unlock_irqrestore(&ch->ch_lock, flags);
1552
1553         rc = 0;
1554
1555         if (mstat & UART_MCR_DTR)
1556                 rc |= TIOCM_DTR;
1557         if (mstat & UART_MCR_RTS)
1558                 rc |= TIOCM_RTS;
1559         if (mstat & UART_MSR_CTS)
1560                 rc |= TIOCM_CTS;
1561         if (mstat & UART_MSR_DSR)
1562                 rc |= TIOCM_DSR;
1563         if (mstat & UART_MSR_RI)
1564                 rc |= TIOCM_RI;
1565         if (mstat & UART_MSR_DCD)
1566                 rc |= TIOCM_CD;
1567
1568         return rc;
1569 }
1570
1571 /* Set modem signals, called by ld. */
1572 static int dgnc_tty_tiocmset(struct tty_struct *tty,
1573                              unsigned int set, unsigned int clear)
1574 {
1575         struct dgnc_board *bd;
1576         struct channel_t *ch;
1577         struct un_t *un;
1578         unsigned long flags;
1579
1580         if (!tty)
1581                 return -EIO;
1582
1583         un = tty->driver_data;
1584         if (!un)
1585                 return -EIO;
1586
1587         ch = un->un_ch;
1588         if (!ch)
1589                 return -EIO;
1590
1591         bd = ch->ch_bd;
1592         if (!bd)
1593                 return -EIO;
1594
1595         spin_lock_irqsave(&ch->ch_lock, flags);
1596
1597         if (set & TIOCM_RTS)
1598                 ch->ch_mostat |= UART_MCR_RTS;
1599
1600         if (set & TIOCM_DTR)
1601                 ch->ch_mostat |= UART_MCR_DTR;
1602
1603         if (clear & TIOCM_RTS)
1604                 ch->ch_mostat &= ~(UART_MCR_RTS);
1605
1606         if (clear & TIOCM_DTR)
1607                 ch->ch_mostat &= ~(UART_MCR_DTR);
1608
1609         bd->bd_ops->assert_modem_signals(ch);
1610
1611         spin_unlock_irqrestore(&ch->ch_lock, flags);
1612
1613         return 0;
1614 }
1615
1616 /* Send a Break, called by ld. */
1617 static int dgnc_tty_send_break(struct tty_struct *tty, int msec)
1618 {
1619         struct dgnc_board *bd;
1620         struct channel_t *ch;
1621         struct un_t *un;
1622         unsigned long flags;
1623
1624         if (!tty)
1625                 return -EIO;
1626
1627         un = tty->driver_data;
1628         if (!un)
1629                 return -EIO;
1630
1631         ch = un->un_ch;
1632         if (!ch)
1633                 return -EIO;
1634
1635         bd = ch->ch_bd;
1636         if (!bd)
1637                 return -EIO;
1638
1639         if (msec < 0)
1640                 msec = 0xFFFF;
1641
1642         spin_lock_irqsave(&ch->ch_lock, flags);
1643
1644         bd->bd_ops->send_break(ch, msec);
1645
1646         spin_unlock_irqrestore(&ch->ch_lock, flags);
1647
1648         return 0;
1649 }
1650
1651 /* wait until data has been transmitted, called by ld. */
1652 static void dgnc_tty_wait_until_sent(struct tty_struct *tty, int timeout)
1653 {
1654         struct dgnc_board *bd;
1655         struct channel_t *ch;
1656         struct un_t *un;
1657
1658         if (!tty)
1659                 return;
1660
1661         un = tty->driver_data;
1662         if (!un)
1663                 return;
1664
1665         ch = un->un_ch;
1666         if (!ch)
1667                 return;
1668
1669         bd = ch->ch_bd;
1670         if (!bd)
1671                 return;
1672
1673         bd->bd_ops->drain(tty, 0);
1674 }
1675
1676 /* send a high priority character, called by ld. */
1677 static void dgnc_tty_send_xchar(struct tty_struct *tty, char c)
1678 {
1679         struct dgnc_board *bd;
1680         struct channel_t *ch;
1681         struct un_t *un;
1682         unsigned long flags;
1683
1684         if (!tty)
1685                 return;
1686
1687         un = tty->driver_data;
1688         if (!un)
1689                 return;
1690
1691         ch = un->un_ch;
1692         if (!ch)
1693                 return;
1694
1695         bd = ch->ch_bd;
1696         if (!bd)
1697                 return;
1698
1699         spin_lock_irqsave(&ch->ch_lock, flags);
1700         bd->bd_ops->send_immediate_char(ch, c);
1701         spin_unlock_irqrestore(&ch->ch_lock, flags);
1702 }
1703
1704 /* Return modem signals to ld. */
1705 static inline int dgnc_get_mstat(struct channel_t *ch)
1706 {
1707         unsigned char mstat;
1708         unsigned long flags;
1709         int rc;
1710
1711         if (!ch)
1712                 return -ENXIO;
1713
1714         spin_lock_irqsave(&ch->ch_lock, flags);
1715
1716         mstat = ch->ch_mostat | ch->ch_mistat;
1717
1718         spin_unlock_irqrestore(&ch->ch_lock, flags);
1719
1720         rc = 0;
1721
1722         if (mstat & UART_MCR_DTR)
1723                 rc |= TIOCM_DTR;
1724         if (mstat & UART_MCR_RTS)
1725                 rc |= TIOCM_RTS;
1726         if (mstat & UART_MSR_CTS)
1727                 rc |= TIOCM_CTS;
1728         if (mstat & UART_MSR_DSR)
1729                 rc |= TIOCM_DSR;
1730         if (mstat & UART_MSR_RI)
1731                 rc |= TIOCM_RI;
1732         if (mstat & UART_MSR_DCD)
1733                 rc |= TIOCM_CD;
1734
1735         return rc;
1736 }
1737
1738 /* Return modem signals to ld. */
1739 static int dgnc_get_modem_info(struct channel_t *ch,
1740                                unsigned int  __user *value)
1741 {
1742         return put_user(dgnc_get_mstat(ch), value);
1743 }
1744
1745 /* Set modem signals, called by ld. */
1746 static int dgnc_set_modem_info(struct channel_t *ch,
1747                                unsigned int command,
1748                                unsigned int __user *value)
1749 {
1750         int rc;
1751         unsigned int arg = 0;
1752         unsigned long flags;
1753
1754         rc = get_user(arg, value);
1755         if (rc)
1756                 return rc;
1757
1758         switch (command) {
1759         case TIOCMBIS:
1760                 if (arg & TIOCM_RTS)
1761                         ch->ch_mostat |= UART_MCR_RTS;
1762
1763                 if (arg & TIOCM_DTR)
1764                         ch->ch_mostat |= UART_MCR_DTR;
1765
1766                 break;
1767
1768         case TIOCMBIC:
1769                 if (arg & TIOCM_RTS)
1770                         ch->ch_mostat &= ~(UART_MCR_RTS);
1771
1772                 if (arg & TIOCM_DTR)
1773                         ch->ch_mostat &= ~(UART_MCR_DTR);
1774
1775                 break;
1776
1777         case TIOCMSET:
1778
1779                 if (arg & TIOCM_RTS)
1780                         ch->ch_mostat |= UART_MCR_RTS;
1781                 else
1782                         ch->ch_mostat &= ~(UART_MCR_RTS);
1783
1784                 if (arg & TIOCM_DTR)
1785                         ch->ch_mostat |= UART_MCR_DTR;
1786                 else
1787                         ch->ch_mostat &= ~(UART_MCR_DTR);
1788
1789                 break;
1790
1791         default:
1792                 return -EINVAL;
1793         }
1794
1795         spin_lock_irqsave(&ch->ch_lock, flags);
1796
1797         ch->ch_bd->bd_ops->assert_modem_signals(ch);
1798
1799         spin_unlock_irqrestore(&ch->ch_lock, flags);
1800
1801         return 0;
1802 }
1803
1804 /* Ioctl to get the information for ditty. */
1805 static int dgnc_tty_digigeta(struct tty_struct *tty,
1806                              struct digi_t __user *retinfo)
1807 {
1808         struct channel_t *ch;
1809         struct un_t *un;
1810         struct digi_t tmp;
1811         unsigned long flags;
1812
1813         if (!retinfo)
1814                 return -EFAULT;
1815
1816         if (!tty)
1817                 return -EFAULT;
1818
1819         un = tty->driver_data;
1820         if (!un)
1821                 return -EFAULT;
1822
1823         ch = un->un_ch;
1824         if (!ch)
1825                 return -EFAULT;
1826
1827         memset(&tmp, 0, sizeof(tmp));
1828
1829         spin_lock_irqsave(&ch->ch_lock, flags);
1830         memcpy(&tmp, &ch->ch_digi, sizeof(tmp));
1831         spin_unlock_irqrestore(&ch->ch_lock, flags);
1832
1833         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1834                 return -EFAULT;
1835
1836         return 0;
1837 }
1838
1839 /* Ioctl to set the information for ditty. */
1840 static int dgnc_tty_digiseta(struct tty_struct *tty,
1841                              struct digi_t __user *new_info)
1842 {
1843         struct dgnc_board *bd;
1844         struct channel_t *ch;
1845         struct un_t *un;
1846         struct digi_t new_digi;
1847         unsigned long flags;
1848
1849         if (!tty)
1850                 return -EFAULT;
1851
1852         un = tty->driver_data;
1853         if (!un)
1854                 return -EFAULT;
1855
1856         ch = un->un_ch;
1857         if (!ch)
1858                 return -EFAULT;
1859
1860         bd = ch->ch_bd;
1861         if (!bd)
1862                 return -EFAULT;
1863
1864         if (copy_from_user(&new_digi, new_info, sizeof(new_digi)))
1865                 return -EFAULT;
1866
1867         spin_lock_irqsave(&ch->ch_lock, flags);
1868
1869         /* Handle transitions to and from RTS Toggle. */
1870
1871         if (!(ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) &&
1872             (new_digi.digi_flags & DIGI_RTS_TOGGLE))
1873                 ch->ch_mostat &= ~(UART_MCR_RTS);
1874         if ((ch->ch_digi.digi_flags & DIGI_RTS_TOGGLE) &&
1875             !(new_digi.digi_flags & DIGI_RTS_TOGGLE))
1876                 ch->ch_mostat |= (UART_MCR_RTS);
1877
1878         /* Handle transitions to and from DTR Toggle. */
1879
1880         if (!(ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) &&
1881             (new_digi.digi_flags & DIGI_DTR_TOGGLE))
1882                 ch->ch_mostat &= ~(UART_MCR_DTR);
1883         if ((ch->ch_digi.digi_flags & DIGI_DTR_TOGGLE) &&
1884             !(new_digi.digi_flags & DIGI_DTR_TOGGLE))
1885                 ch->ch_mostat |= (UART_MCR_DTR);
1886
1887         memcpy(&ch->ch_digi, &new_digi, sizeof(new_digi));
1888
1889         if (ch->ch_digi.digi_maxcps < 1)
1890                 ch->ch_digi.digi_maxcps = 1;
1891
1892         if (ch->ch_digi.digi_maxcps > 10000)
1893                 ch->ch_digi.digi_maxcps = 10000;
1894
1895         if (ch->ch_digi.digi_bufsize < 10)
1896                 ch->ch_digi.digi_bufsize = 10;
1897
1898         if (ch->ch_digi.digi_maxchar < 1)
1899                 ch->ch_digi.digi_maxchar = 1;
1900
1901         if (ch->ch_digi.digi_maxchar > ch->ch_digi.digi_bufsize)
1902                 ch->ch_digi.digi_maxchar = ch->ch_digi.digi_bufsize;
1903
1904         if (ch->ch_digi.digi_onlen > DIGI_PLEN)
1905                 ch->ch_digi.digi_onlen = DIGI_PLEN;
1906
1907         if (ch->ch_digi.digi_offlen > DIGI_PLEN)
1908                 ch->ch_digi.digi_offlen = DIGI_PLEN;
1909
1910         bd->bd_ops->param(tty);
1911
1912         spin_unlock_irqrestore(&ch->ch_lock, flags);
1913
1914         return 0;
1915 }
1916
1917 static void dgnc_tty_set_termios(struct tty_struct *tty,
1918                                  struct ktermios *old_termios)
1919 {
1920         struct dgnc_board *bd;
1921         struct channel_t *ch;
1922         struct un_t *un;
1923         unsigned long flags;
1924
1925         if (!tty)
1926                 return;
1927
1928         un = tty->driver_data;
1929         if (!un)
1930                 return;
1931
1932         ch = un->un_ch;
1933         if (!ch)
1934                 return;
1935
1936         bd = ch->ch_bd;
1937         if (!bd)
1938                 return;
1939
1940         spin_lock_irqsave(&ch->ch_lock, flags);
1941
1942         ch->ch_c_cflag   = tty->termios.c_cflag;
1943         ch->ch_c_iflag   = tty->termios.c_iflag;
1944         ch->ch_c_oflag   = tty->termios.c_oflag;
1945         ch->ch_c_lflag   = tty->termios.c_lflag;
1946         ch->ch_startc = tty->termios.c_cc[VSTART];
1947         ch->ch_stopc  = tty->termios.c_cc[VSTOP];
1948
1949         bd->bd_ops->param(tty);
1950         dgnc_carrier(ch);
1951
1952         spin_unlock_irqrestore(&ch->ch_lock, flags);
1953 }
1954
1955 static void dgnc_tty_throttle(struct tty_struct *tty)
1956 {
1957         struct channel_t *ch;
1958         struct un_t *un;
1959         unsigned long flags;
1960
1961         if (!tty)
1962                 return;
1963
1964         un = tty->driver_data;
1965         if (!un)
1966                 return;
1967
1968         ch = un->un_ch;
1969         if (!ch)
1970                 return;
1971
1972         spin_lock_irqsave(&ch->ch_lock, flags);
1973
1974         ch->ch_flags |= (CH_FORCED_STOPI);
1975
1976         spin_unlock_irqrestore(&ch->ch_lock, flags);
1977 }
1978
1979 static void dgnc_tty_unthrottle(struct tty_struct *tty)
1980 {
1981         struct channel_t *ch;
1982         struct un_t *un;
1983         unsigned long flags;
1984
1985         if (!tty)
1986                 return;
1987
1988         un = tty->driver_data;
1989         if (!un)
1990                 return;
1991
1992         ch = un->un_ch;
1993         if (!ch)
1994                 return;
1995
1996         spin_lock_irqsave(&ch->ch_lock, flags);
1997
1998         ch->ch_flags &= ~(CH_FORCED_STOPI);
1999
2000         spin_unlock_irqrestore(&ch->ch_lock, flags);
2001 }
2002
2003 static void dgnc_tty_start(struct tty_struct *tty)
2004 {
2005         struct dgnc_board *bd;
2006         struct channel_t *ch;
2007         struct un_t *un;
2008         unsigned long flags;
2009
2010         if (!tty)
2011                 return;
2012
2013         un = tty->driver_data;
2014         if (!un)
2015                 return;
2016
2017         ch = un->un_ch;
2018         if (!ch)
2019                 return;
2020
2021         bd = ch->ch_bd;
2022         if (!bd)
2023                 return;
2024
2025         spin_lock_irqsave(&ch->ch_lock, flags);
2026
2027         ch->ch_flags &= ~(CH_FORCED_STOP);
2028
2029         spin_unlock_irqrestore(&ch->ch_lock, flags);
2030 }
2031
2032 static void dgnc_tty_stop(struct tty_struct *tty)
2033 {
2034         struct dgnc_board *bd;
2035         struct channel_t *ch;
2036         struct un_t *un;
2037         unsigned long flags;
2038
2039         if (!tty)
2040                 return;
2041
2042         un = tty->driver_data;
2043         if (!un)
2044                 return;
2045
2046         ch = un->un_ch;
2047         if (!ch)
2048                 return;
2049
2050         bd = ch->ch_bd;
2051         if (!bd)
2052                 return;
2053
2054         spin_lock_irqsave(&ch->ch_lock, flags);
2055
2056         ch->ch_flags |= (CH_FORCED_STOP);
2057
2058         spin_unlock_irqrestore(&ch->ch_lock, flags);
2059 }
2060
2061 /*
2062  * Flush the cook buffer
2063  *
2064  * Note to self, and any other poor souls who venture here:
2065  *
2066  * flush in this case DOES NOT mean dispose of the data.
2067  * instead, it means "stop buffering and send it if you
2068  * haven't already."  Just guess how I figured that out...   SRW 2-Jun-98
2069  *
2070  * It is also always called in interrupt context - JAR 8-Sept-99
2071  */
2072 static void dgnc_tty_flush_chars(struct tty_struct *tty)
2073 {
2074         struct dgnc_board *bd;
2075         struct channel_t *ch;
2076         struct un_t *un;
2077         unsigned long flags;
2078
2079         if (!tty)
2080                 return;
2081
2082         un = tty->driver_data;
2083         if (!un)
2084                 return;
2085
2086         ch = un->un_ch;
2087         if (!ch)
2088                 return;
2089
2090         bd = ch->ch_bd;
2091         if (!bd)
2092                 return;
2093
2094         spin_lock_irqsave(&ch->ch_lock, flags);
2095
2096         /* Do something maybe here */
2097
2098         spin_unlock_irqrestore(&ch->ch_lock, flags);
2099 }
2100
2101 /* Flush Tx buffer (make in == out) */
2102 static void dgnc_tty_flush_buffer(struct tty_struct *tty)
2103 {
2104         struct channel_t *ch;
2105         struct un_t *un;
2106         unsigned long flags;
2107
2108         if (!tty)
2109                 return;
2110
2111         un = tty->driver_data;
2112         if (!un)
2113                 return;
2114
2115         ch = un->un_ch;
2116         if (!ch)
2117                 return;
2118
2119         spin_lock_irqsave(&ch->ch_lock, flags);
2120
2121         ch->ch_flags &= ~CH_STOP;
2122
2123         /* Flush our write queue */
2124         ch->ch_w_head = ch->ch_w_tail;
2125
2126         /* Flush UARTs transmit FIFO */
2127         ch->ch_bd->bd_ops->flush_uart_write(ch);
2128
2129         if (ch->ch_tun.un_flags & (UN_LOW | UN_EMPTY)) {
2130                 ch->ch_tun.un_flags &= ~(UN_LOW | UN_EMPTY);
2131                 wake_up_interruptible(&ch->ch_tun.un_flags_wait);
2132         }
2133         if (ch->ch_pun.un_flags & (UN_LOW | UN_EMPTY)) {
2134                 ch->ch_pun.un_flags &= ~(UN_LOW | UN_EMPTY);
2135                 wake_up_interruptible(&ch->ch_pun.un_flags_wait);
2136         }
2137
2138         spin_unlock_irqrestore(&ch->ch_lock, flags);
2139 }
2140
2141 /* Wakes up processes waiting in the unit's (teminal/printer) wait queue */
2142 static void dgnc_wake_up_unit(struct un_t *unit)
2143 {
2144         unit->un_flags &= ~(UN_LOW | UN_EMPTY);
2145         wake_up_interruptible(&unit->un_flags_wait);
2146 }
2147
2148 /* The IOCTL function and all of its helpers */
2149
2150 /* The usual assortment of ioctl's */
2151 static int dgnc_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
2152                           unsigned long arg)
2153 {
2154         struct dgnc_board *bd;
2155         struct board_ops *ch_bd_ops;
2156         struct channel_t *ch;
2157         struct un_t *un;
2158         int rc;
2159         unsigned long flags;
2160         void __user *uarg = (void __user *)arg;
2161
2162         if (!tty)
2163                 return -ENODEV;
2164
2165         un = tty->driver_data;
2166         if (!un)
2167                 return -ENODEV;
2168
2169         ch = un->un_ch;
2170         if (!ch)
2171                 return -ENODEV;
2172
2173         bd = ch->ch_bd;
2174         if (!bd)
2175                 return -ENODEV;
2176
2177         ch_bd_ops = bd->bd_ops;
2178
2179         spin_lock_irqsave(&ch->ch_lock, flags);
2180
2181         if (un->un_open_count <= 0) {
2182                 rc = -EIO;
2183                 goto err_unlock;
2184         }
2185
2186         switch (cmd) {
2187         /* Here are all the standard ioctl's that we MUST implement */
2188
2189         case TCSBRK:
2190                 /*
2191                  * TCSBRK is SVID version: non-zero arg --> no break
2192                  * this behaviour is exploited by tcdrain().
2193                  *
2194                  * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2195                  * between 0.25 and 0.5 seconds so we'll ask for something
2196                  * in the middle: 0.375 seconds.
2197                  */
2198                 rc = tty_check_change(tty);
2199                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2200                 if (rc)
2201                         return rc;
2202
2203                 rc = ch_bd_ops->drain(tty, 0);
2204                 if (rc)
2205                         return -EINTR;
2206
2207                 spin_lock_irqsave(&ch->ch_lock, flags);
2208
2209                 if (((cmd == TCSBRK) && (!arg)) || (cmd == TCSBRKP))
2210                         ch_bd_ops->send_break(ch, 250);
2211
2212                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2213
2214                 return 0;
2215
2216         case TCSBRKP:
2217                 /*
2218                  * support for POSIX tcsendbreak()
2219                  * According to POSIX.1 spec (7.2.2.1.2) breaks should be
2220                  * between 0.25 and 0.5 seconds so we'll ask for something
2221                  * in the middle: 0.375 seconds.
2222                  */
2223                 rc = tty_check_change(tty);
2224                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2225                 if (rc)
2226                         return rc;
2227
2228                 rc = ch_bd_ops->drain(tty, 0);
2229                 if (rc)
2230                         return -EINTR;
2231
2232                 spin_lock_irqsave(&ch->ch_lock, flags);
2233
2234                 ch_bd_ops->send_break(ch, 250);
2235
2236                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2237
2238                 return 0;
2239
2240         case TIOCSBRK:
2241                 rc = tty_check_change(tty);
2242                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2243                 if (rc)
2244                         return rc;
2245
2246                 rc = ch_bd_ops->drain(tty, 0);
2247                 if (rc)
2248                         return -EINTR;
2249
2250                 spin_lock_irqsave(&ch->ch_lock, flags);
2251
2252                 ch_bd_ops->send_break(ch, 250);
2253
2254                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2255
2256                 return 0;
2257
2258         case TIOCCBRK:
2259                 /* Do Nothing */
2260                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2261                 return 0;
2262
2263         case TIOCGSOFTCAR:
2264
2265                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2266
2267                 return put_user(C_CLOCAL(tty) ? 1 : 0,
2268                                 (unsigned long __user *)arg);
2269
2270         case TIOCSSOFTCAR:
2271
2272                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2273                 rc = get_user(arg, (unsigned long __user *)arg);
2274                 if (rc)
2275                         return rc;
2276
2277                 spin_lock_irqsave(&ch->ch_lock, flags);
2278                 tty->termios.c_cflag = ((tty->termios.c_cflag & ~CLOCAL) |
2279                                        (arg ? CLOCAL : 0));
2280                 ch_bd_ops->param(tty);
2281                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2282
2283                 return 0;
2284
2285         case TIOCMGET:
2286                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2287                 return dgnc_get_modem_info(ch, uarg);
2288
2289         case TIOCMBIS:
2290         case TIOCMBIC:
2291         case TIOCMSET:
2292                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2293                 return dgnc_set_modem_info(ch, cmd, uarg);
2294
2295                 /* Here are any additional ioctl's that we want to implement */
2296
2297         case TCFLSH:
2298                 /*
2299                  * The linux tty driver doesn't have a flush
2300                  * input routine for the driver, assuming all backed
2301                  * up data is in the line disc. buffers.  However,
2302                  * we all know that's not the case.  Here, we
2303                  * act on the ioctl, but then lie and say we didn't
2304                  * so the line discipline will process the flush
2305                  * also.
2306                  */
2307                 rc = tty_check_change(tty);
2308                 if (rc)
2309                         goto err_unlock;
2310
2311                 if ((arg == TCIFLUSH) || (arg == TCIOFLUSH)) {
2312                         ch->ch_r_head = ch->ch_r_tail;
2313                         ch_bd_ops->flush_uart_read(ch);
2314                         /* Force queue flow control to be released, if needed */
2315                         dgnc_check_queue_flow_control(ch);
2316                 }
2317
2318                 if ((arg == TCOFLUSH) || (arg == TCIOFLUSH)) {
2319                         if (!(un->un_type == DGNC_PRINT)) {
2320                                 ch->ch_w_head = ch->ch_w_tail;
2321                                 ch_bd_ops->flush_uart_write(ch);
2322
2323                                 if (ch->ch_tun.un_flags & (UN_LOW | UN_EMPTY))
2324                                         dgnc_wake_up_unit(&ch->ch_tun);
2325
2326                                 if (ch->ch_pun.un_flags & (UN_LOW | UN_EMPTY))
2327                                         dgnc_wake_up_unit(&ch->ch_pun);
2328                         }
2329                 }
2330
2331                 /* pretend we didn't recognize this IOCTL */
2332                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2333                 return -ENOIOCTLCMD;
2334         case TCSETSF:
2335         case TCSETSW:
2336                 /*
2337                  * The linux tty driver doesn't have a flush
2338                  * input routine for the driver, assuming all backed
2339                  * up data is in the line disc. buffers.  However,
2340                  * we all know that's not the case.  Here, we
2341                  * act on the ioctl, but then lie and say we didn't
2342                  * so the line discipline will process the flush
2343                  * also.
2344                  */
2345                 if (cmd == TCSETSF) {
2346                         /* flush rx */
2347                         ch->ch_flags &= ~CH_STOP;
2348                         ch->ch_r_head = ch->ch_r_tail;
2349                         ch_bd_ops->flush_uart_read(ch);
2350                         /* Force queue flow control to be released, if needed */
2351                         dgnc_check_queue_flow_control(ch);
2352                 }
2353
2354                 /* now wait for all the output to drain */
2355                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2356                 rc = ch_bd_ops->drain(tty, 0);
2357                 if (rc)
2358                         return -EINTR;
2359
2360                 /* pretend we didn't recognize this */
2361                 return -ENOIOCTLCMD;
2362
2363         case TCSETAW:
2364
2365                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2366                 rc = ch_bd_ops->drain(tty, 0);
2367                 if (rc)
2368                         return -EINTR;
2369
2370                 /* pretend we didn't recognize this */
2371                 return -ENOIOCTLCMD;
2372
2373         case TCXONC:
2374                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2375                 /* Make the ld do it */
2376                 return -ENOIOCTLCMD;
2377
2378         case DIGI_GETA:
2379                 /* get information for ditty */
2380                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2381                 return dgnc_tty_digigeta(tty, uarg);
2382
2383         case DIGI_SETAW:
2384         case DIGI_SETAF:
2385
2386                 /* set information for ditty */
2387                 if (cmd == (DIGI_SETAW)) {
2388                         spin_unlock_irqrestore(&ch->ch_lock, flags);
2389                         rc = ch_bd_ops->drain(tty, 0);
2390                         if (rc)
2391                                 return -EINTR;
2392
2393                         spin_lock_irqsave(&ch->ch_lock, flags);
2394                 } else {
2395                         tty_ldisc_flush(tty);
2396                 }
2397                 /* fall thru */
2398
2399         case DIGI_SETA:
2400                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2401                 return dgnc_tty_digiseta(tty, uarg);
2402
2403         case DIGI_LOOPBACK:
2404                 {
2405                         uint loopback = 0;
2406                         /*
2407                          * Let go of locks when accessing user space,
2408                          * could sleep
2409                          */
2410                         spin_unlock_irqrestore(&ch->ch_lock, flags);
2411                         rc = get_user(loopback, (unsigned int __user *)arg);
2412                         if (rc)
2413                                 return rc;
2414                         spin_lock_irqsave(&ch->ch_lock, flags);
2415
2416                         /* Enable/disable internal loopback for this port */
2417                         if (loopback)
2418                                 ch->ch_flags |= CH_LOOPBACK;
2419                         else
2420                                 ch->ch_flags &= ~(CH_LOOPBACK);
2421
2422                         ch_bd_ops->param(tty);
2423                         spin_unlock_irqrestore(&ch->ch_lock, flags);
2424                         return 0;
2425                 }
2426
2427         case DIGI_GETCUSTOMBAUD:
2428                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2429                 return put_user(ch->ch_custom_speed,
2430                                 (unsigned int __user *)arg);
2431
2432         case DIGI_SETCUSTOMBAUD:
2433         {
2434                 int new_rate;
2435
2436                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2437                 rc = get_user(new_rate, (int __user *)arg);
2438                 if (rc)
2439                         return rc;
2440                 spin_lock_irqsave(&ch->ch_lock, flags);
2441                 dgnc_set_custom_speed(ch, new_rate);
2442                 ch_bd_ops->param(tty);
2443                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2444                 return 0;
2445         }
2446
2447         /*
2448          * This ioctl allows insertion of a character into the front
2449          * of any pending data to be transmitted.
2450          *
2451          * This ioctl is to satisfy the "Send Character Immediate"
2452          * call that the RealPort protocol spec requires.
2453          */
2454         case DIGI_REALPORT_SENDIMMEDIATE:
2455         {
2456                 unsigned char c;
2457
2458                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2459                 rc = get_user(c, (unsigned char __user *)arg);
2460                 if (rc)
2461                         return rc;
2462                 spin_lock_irqsave(&ch->ch_lock, flags);
2463                 ch_bd_ops->send_immediate_char(ch, c);
2464                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2465                 return 0;
2466         }
2467
2468         /*
2469          * This ioctl returns all the current counts for the port.
2470          *
2471          * This ioctl is to satisfy the "Line Error Counters"
2472          * call that the RealPort protocol spec requires.
2473          */
2474         case DIGI_REALPORT_GETCOUNTERS:
2475         {
2476                 struct digi_getcounter buf;
2477
2478                 buf.norun = ch->ch_err_overrun;
2479                 buf.noflow = 0;         /* The driver doesn't keep this stat */
2480                 buf.nframe = ch->ch_err_frame;
2481                 buf.nparity = ch->ch_err_parity;
2482                 buf.nbreak = ch->ch_err_break;
2483                 buf.rbytes = ch->ch_rxcount;
2484                 buf.tbytes = ch->ch_txcount;
2485
2486                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2487
2488                 if (copy_to_user(uarg, &buf, sizeof(buf)))
2489                         return -EFAULT;
2490
2491                 return 0;
2492         }
2493
2494         /*
2495          * This ioctl returns all current events.
2496          *
2497          * This ioctl is to satisfy the "Event Reporting"
2498          * call that the RealPort protocol spec requires.
2499          */
2500         case DIGI_REALPORT_GETEVENTS:
2501         {
2502                 unsigned int events = 0;
2503
2504                 /* NOTE: MORE EVENTS NEEDS TO BE ADDED HERE */
2505                 if (ch->ch_flags & CH_BREAK_SENDING)
2506                         events |= EV_TXB;
2507                 if ((ch->ch_flags & CH_STOP) ||
2508                     (ch->ch_flags & CH_FORCED_STOP))
2509                         events |= (EV_OPU | EV_OPS);
2510
2511                 if ((ch->ch_flags & CH_STOPI) ||
2512                     (ch->ch_flags & CH_FORCED_STOPI))
2513                         events |= (EV_IPU | EV_IPS);
2514
2515                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2516                 return put_user(events, (unsigned int __user *)arg);
2517         }
2518
2519         /*
2520          * This ioctl returns TOUT and TIN counters based
2521          * upon the values passed in by the RealPort Server.
2522          * It also passes back whether the UART Transmitter is
2523          * empty as well.
2524          */
2525         case DIGI_REALPORT_GETBUFFERS:
2526         {
2527                 struct digi_getbuffer buf;
2528                 int tdist;
2529                 int count;
2530
2531                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2532
2533                 if (copy_from_user(&buf, uarg, sizeof(buf)))
2534                         return -EFAULT;
2535
2536                 spin_lock_irqsave(&ch->ch_lock, flags);
2537
2538                 /* Figure out how much data is in our RX and TX queues. */
2539
2540                 buf.rxbuf = (ch->ch_r_head - ch->ch_r_tail) & RQUEUEMASK;
2541                 buf.txbuf = (ch->ch_w_head - ch->ch_w_tail) & WQUEUEMASK;
2542
2543                 /*
2544                  * Is the UART empty?
2545                  * Add that value to whats in our TX queue.
2546                  */
2547
2548                 count = buf.txbuf + ch_bd_ops->get_uart_bytes_left(ch);
2549
2550                 /*
2551                  * Figure out how much data the RealPort Server believes should
2552                  * be in our TX queue.
2553                  */
2554                 tdist = (buf.tx_in - buf.tx_out) & 0xffff;
2555
2556                 /*
2557                  * If we have more data than the RealPort Server believes we
2558                  * should have, reduce our count to its amount.
2559                  *
2560                  * This count difference CAN happen because the Linux LD can
2561                  * insert more characters into our queue for OPOST processing
2562                  * that the RealPort Server doesn't know about.
2563                  */
2564                 if (buf.txbuf > tdist)
2565                         buf.txbuf = tdist;
2566
2567                 /* Report whether our queue and UART TX are completely empty. */
2568
2569                 if (count)
2570                         buf.txdone = 0;
2571                 else
2572                         buf.txdone = 1;
2573
2574                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2575
2576                 if (copy_to_user(uarg, &buf, sizeof(buf)))
2577                         return -EFAULT;
2578
2579                 return 0;
2580         }
2581         default:
2582                 spin_unlock_irqrestore(&ch->ch_lock, flags);
2583
2584                 return -ENOIOCTLCMD;
2585         }
2586 err_unlock:
2587         spin_unlock_irqrestore(&ch->ch_lock, flags);
2588
2589         return rc;
2590 }