drivers/char/dtlk.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*                                              -*- linux-c -*-
   3  * dtlk.c - DoubleTalk PC driver for Linux
   4  *
   5  * Original author: Chris Pallotta <chris@allmedia.com>
   6  * Current maintainer: Jim Van Zandt <jrv@vanzandt.mv.com>
   7  *
   8  * 2000-03-18 Jim Van Zandt: Fix polling.
   9  *  Eliminate dtlk_timer_active flag and separate dtlk_stop_timer
  10  *  function.  Don't restart timer in dtlk_timer_tick.  Restart timer
  11  *  in dtlk_poll after every poll.  dtlk_poll returns mask (duh).
  12  *  Eliminate unused function dtlk_write_byte.  Misc. code cleanups.
  13  */
  14
  15 /* This driver is for the DoubleTalk PC, a speech synthesizer
  16    manufactured by RC Systems (http://www.rcsys.com/).  It was written
  17    based on documentation in their User's Manual file and Developer's
  18    Tools disk.
  19
  20    The DoubleTalk PC contains four voice synthesizers: text-to-speech
  21    (TTS), linear predictive coding (LPC), PCM/ADPCM, and CVSD.  It
  22    also has a tone generator.  Output data for LPC are written to the
  23    LPC port, and output data for the other modes are written to the
  24    TTS port.
  25
  26    Two kinds of data can be read from the DoubleTalk: status
  27    information (in response to the "\001?" interrogation command) is
  28    read from the TTS port, and index markers (which mark the progress
  29    of the speech) are read from the LPC port.  Not all models of the
  30    DoubleTalk PC implement index markers.  Both the TTS and LPC ports
  31    can also display status flags.
  32
  33    The DoubleTalk PC generates no interrupts.
  34
  35    These characteristics are mapped into the Unix stream I/O model as
  36    follows:
  37
  38    "write" sends bytes to the TTS port.  It is the responsibility of
  39    the user program to switch modes among TTS, PCM/ADPCM, and CVSD.
  40    This driver was written for use with the text-to-speech
  41    synthesizer.  If LPC output is needed some day, other minor device
  42    numbers can be used to select among output modes.
  43
  44    "read" gets index markers from the LPC port.  If the device does
  45    not implement index markers, the read will fail with error EINVAL.
  46
  47    Status information is available using the DTLK_INTERROGATE ioctl.
  48
  49  */
  50
  51 #include <linux/module.h>
  52
  53 #define KERNEL
  54 #include <linux/types.h>
  55 #include <linux/fs.h>
  56 #include <linux/mm.h>
  57 #include <linux/errno.h>        /* for -EBUSY */
  58 #include <linux/ioport.h>       /* for request_region */
  59 #include <linux/delay.h>        /* for loops_per_jiffy */
  60 #include <linux/sched.h>
  61 #include <linux/mutex.h>
  62 #include <asm/io.h>             /* for inb_p, outb_p, inb, outb, etc. */
  63 #include <linux/uaccess.h>      /* for get_user, etc. */
  64 #include <linux/wait.h>         /* for wait_queue */
  65 #include <linux/init.h>         /* for __init, module_{init,exit} */
  66 #include <linux/poll.h>         /* for EPOLLIN, etc. */
  67 #include <linux/dtlk.h>         /* local header file for DoubleTalk values */
  68
  69 #ifdef TRACING
  70 #define TRACE_TEXT(str) printk(str);
  71 #define TRACE_RET printk(")")
  72 #else                           /* !TRACING */
  73 #define TRACE_TEXT(str) ((void) 0)
  74 #define TRACE_RET ((void) 0)
  75 #endif                          /* TRACING */
  76
  77 static DEFINE_MUTEX(dtlk_mutex);
  78 static void dtlk_timer_tick(struct timer_list *unused);
  79
  80 static int dtlk_major;
  81 static int dtlk_port_lpc;
  82 static int dtlk_port_tts;
  83 static int dtlk_busy;
  84 static int dtlk_has_indexing;
  85 static unsigned int dtlk_portlist[] =
  86 {0x25e, 0x29e, 0x2de, 0x31e, 0x35e, 0x39e, 0};
  87 static wait_queue_head_t dtlk_process_list;
  88 static DEFINE_TIMER(dtlk_timer, dtlk_timer_tick);
  89
  90 /* prototypes for file_operations struct */
  91 static ssize_t dtlk_read(struct file *, char __user *,
  92                          size_t nbytes, loff_t * ppos);
  93 static ssize_t dtlk_write(struct file *, const char __user *,
  94                           size_t nbytes, loff_t * ppos);
  95 static __poll_t dtlk_poll(struct file *, poll_table *);
  96 static int dtlk_open(struct inode *, struct file *);
  97 static int dtlk_release(struct inode *, struct file *);
  98 static long dtlk_ioctl(struct file *file,
  99                        unsigned int cmd, unsigned long arg);
 100
 101 static const struct file_operations dtlk_fops =
 102 {
 103         .owner          = THIS_MODULE,
 104         .read           = dtlk_read,
 105         .write          = dtlk_write,
 106         .poll           = dtlk_poll,
 107         .unlocked_ioctl = dtlk_ioctl,
 108         .open           = dtlk_open,
 109         .release        = dtlk_release,
 110         .llseek         = no_llseek,
 111 };
 112
 113 /* local prototypes */
 114 static int dtlk_dev_probe(void);
 115 static struct dtlk_settings *dtlk_interrogate(void);
 116 static int dtlk_readable(void);
 117 static char dtlk_read_lpc(void);
 118 static char dtlk_read_tts(void);
 119 static int dtlk_writeable(void);
 120 static char dtlk_write_bytes(const char *buf, int n);
 121 static char dtlk_write_tts(char);
 122 /*
 123    static void dtlk_handle_error(char, char, unsigned int);
 124  */
 125
 126 static ssize_t dtlk_read(struct file *file, char __user *buf,
 127                          size_t count, loff_t * ppos)
 128 {
 129         unsigned int minor = iminor(file_inode(file));
 130         char ch;
 131         int i = 0, retries;
 132
 133         TRACE_TEXT("(dtlk_read");
 134         /*  printk("DoubleTalk PC - dtlk_read()\n"); */
 135
 136         if (minor != DTLK_MINOR || !dtlk_has_indexing)
 137                 return -EINVAL;
 138
 139         for (retries = 0; retries < loops_per_jiffy; retries++) {
 140                 while (i < count && dtlk_readable()) {
 141                         ch = dtlk_read_lpc();
 142                         /*        printk("dtlk_read() reads 0x%02x\n", ch); */
 143                         if (put_user(ch, buf++))
 144                                 return -EFAULT;
 145                         i++;
 146                 }
 147                 if (i)
 148                         return i;
 149                 if (file->f_flags & O_NONBLOCK)
 150                         break;
 151                 msleep_interruptible(100);
 152         }
 153         if (retries == loops_per_jiffy)
 154                 printk(KERN_ERR "dtlk_read times out\n");
 155         TRACE_RET;
 156         return -EAGAIN;
 157 }
 158
 159 static ssize_t dtlk_write(struct file *file, const char __user *buf,
 160                           size_t count, loff_t * ppos)
 161 {
 162         int i = 0, retries = 0, ch;
 163
 164         TRACE_TEXT("(dtlk_write");
 165 #ifdef TRACING
 166         printk(" \"");
 167         {
 168                 int i, ch;
 169                 for (i = 0; i < count; i++) {
 170                         if (get_user(ch, buf + i))
 171                                 return -EFAULT;
 172                         if (' ' <= ch && ch <= '~')
 173                                 printk("%c", ch);
 174                         else
 175                                 printk("\\%03o", ch);
 176                 }
 177                 printk("\"");
 178         }
 179 #endif
 180
 181         if (iminor(file_inode(file)) != DTLK_MINOR)
 182                 return -EINVAL;
 183
 184         while (1) {
 185                 while (i < count && !get_user(ch, buf) &&
 186                        (ch == DTLK_CLEAR || dtlk_writeable())) {
 187                         dtlk_write_tts(ch);
 188                         buf++;
 189                         i++;
 190                         if (i % 5 == 0)
 191                                 /* We yield our time until scheduled
 192                                    again.  This reduces the transfer
 193                                    rate to 500 bytes/sec, but that's
 194                                    still enough to keep up with the
 195                                    speech synthesizer. */
 196                                 msleep_interruptible(1);
 197                         else {
 198                                 /* the RDY bit goes zero 2-3 usec
 199                                    after writing, and goes 1 again
 200                                    180-190 usec later.  Here, we wait
 201                                    up to 250 usec for the RDY bit to
 202                                    go nonzero. */
 203                                 for (retries = 0;
 204                                      retries < loops_per_jiffy / (4000/HZ);
 205                                      retries++)
 206                                         if (inb_p(dtlk_port_tts) &
 207                                             TTS_WRITABLE)
 208                                                 break;
 209                         }
 210                         retries = 0;
 211                 }
 212                 if (i == count)
 213                         return i;
 214                 if (file->f_flags & O_NONBLOCK)
 215                         break;
 216
 217                 msleep_interruptible(1);
 218
 219                 if (++retries > 10 * HZ) { /* wait no more than 10 sec
 220                                               from last write */
 221                         printk("dtlk: write timeout.  "
 222                                "inb_p(dtlk_port_tts) = 0x%02x\n",
 223                                inb_p(dtlk_port_tts));
 224                         TRACE_RET;
 225                         return -EBUSY;
 226                 }
 227         }
 228         TRACE_RET;
 229         return -EAGAIN;
 230 }
 231
 232 static __poll_t dtlk_poll(struct file *file, poll_table * wait)
 233 {
 234         __poll_t mask = 0;
 235         unsigned long expires;
 236
 237         TRACE_TEXT(" dtlk_poll");
 238         /*
 239            static long int j;
 240            printk(".");
 241            printk("<%ld>", jiffies-j);
 242            j=jiffies;
 243          */
 244         poll_wait(file, &dtlk_process_list, wait);
 245
 246         if (dtlk_has_indexing && dtlk_readable()) {
 247                 del_timer(&dtlk_timer);
 248                 mask = EPOLLIN | EPOLLRDNORM;
 249         }
 250         if (dtlk_writeable()) {
 251                 del_timer(&dtlk_timer);
 252                 mask |= EPOLLOUT | EPOLLWRNORM;
 253         }
 254         /* there are no exception conditions */
 255
 256         /* There won't be any interrupts, so we set a timer instead. */
 257         expires = jiffies + 3*HZ / 100;
 258         mod_timer(&dtlk_timer, expires);
 259
 260         return mask;
 261 }
 262
 263 static void dtlk_timer_tick(struct timer_list *unused)
 264 {
 265         TRACE_TEXT(" dtlk_timer_tick");
 266         wake_up_interruptible(&dtlk_process_list);
 267 }
 268
 269 static long dtlk_ioctl(struct file *file,
 270                        unsigned int cmd,
 271                        unsigned long arg)
 272 {
 273         char __user *argp = (char __user *)arg;
 274         struct dtlk_settings *sp;
 275         char portval;
 276         TRACE_TEXT(" dtlk_ioctl");
 277
 278         switch (cmd) {
 279
 280         case DTLK_INTERROGATE:
 281                 mutex_lock(&dtlk_mutex);
 282                 sp = dtlk_interrogate();
 283                 mutex_unlock(&dtlk_mutex);
 284                 if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
 285                         return -EINVAL;
 286                 return 0;
 287
 288         case DTLK_STATUS:
 289                 portval = inb_p(dtlk_port_tts);
 290                 return put_user(portval, argp);
 291
 292         default:
 293                 return -EINVAL;
 294         }
 295 }
 296
 297 /* Note that nobody ever sets dtlk_busy... */
 298 static int dtlk_open(struct inode *inode, struct file *file)
 299 {
 300         TRACE_TEXT("(dtlk_open");
 301
 302         switch (iminor(inode)) {
 303         case DTLK_MINOR:
 304                 if (dtlk_busy)
 305                         return -EBUSY;
 306                 return stream_open(inode, file);
 307
 308         default:
 309                 return -ENXIO;
 310         }
 311 }
 312
 313 static int dtlk_release(struct inode *inode, struct file *file)
 314 {
 315         TRACE_TEXT("(dtlk_release");
 316
 317         switch (iminor(inode)) {
 318         case DTLK_MINOR:
 319                 break;
 320
 321         default:
 322                 break;
 323         }
 324         TRACE_RET;
 325
 326         del_timer_sync(&dtlk_timer);
 327
 328         return 0;
 329 }
 330
 331 static int __init dtlk_init(void)
 332 {
 333         int err;
 334
 335         dtlk_port_lpc = 0;
 336         dtlk_port_tts = 0;
 337         dtlk_busy = 0;
 338         dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
 339         if (dtlk_major < 0) {
 340                 printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
 341                 return dtlk_major;
 342         }
 343         err = dtlk_dev_probe();
 344         if (err) {
 345                 unregister_chrdev(dtlk_major, "dtlk");
 346                 return err;
 347         }
 348         printk(", MAJOR %d\n", dtlk_major);
 349
 350         init_waitqueue_head(&dtlk_process_list);
 351
 352         return 0;
 353 }
 354
 355 static void __exit dtlk_cleanup (void)
 356 {
 357         dtlk_write_bytes("goodbye", 8);
 358         msleep_interruptible(500);              /* nap 0.50 sec but
 359                                                    could be awakened
 360                                                    earlier by
 361                                                    signals... */
 362
 363         dtlk_write_tts(DTLK_CLEAR);
 364         unregister_chrdev(dtlk_major, "dtlk");
 365         release_region(dtlk_port_lpc, DTLK_IO_EXTENT);
 366 }
 367
 368 module_init(dtlk_init);
 369 module_exit(dtlk_cleanup);
 370
 371 /* ------------------------------------------------------------------------ */
 372
 373 static int dtlk_readable(void)
 374 {
 375 #ifdef TRACING
 376         printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc) != 0x7f, jiffies);
 377 #endif
 378         return inb_p(dtlk_port_lpc) != 0x7f;
 379 }
 380
 381 static int dtlk_writeable(void)
 382 {
 383         /* TRACE_TEXT(" dtlk_writeable"); */
 384 #ifdef TRACINGMORE
 385         printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts) & TTS_WRITABLE)!=0);
 386 #endif
 387         return inb_p(dtlk_port_tts) & TTS_WRITABLE;
 388 }
 389
 390 static int __init dtlk_dev_probe(void)
 391 {
 392         unsigned int testval = 0;
 393         int i = 0;
 394         struct dtlk_settings *sp;
 395
 396         if (dtlk_port_lpc | dtlk_port_tts)
 397                 return -EBUSY;
 398
 399         for (i = 0; dtlk_portlist[i]; i++) {
 400 #if 0
 401                 printk("DoubleTalk PC - Port %03x = %04x\n",
 402                        dtlk_portlist[i], (testval = inw_p(dtlk_portlist[i])));
 403 #endif
 404
 405                 if (!request_region(dtlk_portlist[i], DTLK_IO_EXTENT,
 406                                "dtlk"))
 407                         continue;
 408                 testval = inw_p(dtlk_portlist[i]);
 409                 if ((testval &= 0xfbff) == 0x107f) {
 410                         dtlk_port_lpc = dtlk_portlist[i];
 411                         dtlk_port_tts = dtlk_port_lpc + 1;
 412
 413                         sp = dtlk_interrogate();
 414                         printk("DoubleTalk PC at %03x-%03x, "
 415                                "ROM version %s, serial number %u",
 416                                dtlk_portlist[i], dtlk_portlist[i] +
 417                                DTLK_IO_EXTENT - 1,
 418                                sp->rom_version, sp->serial_number);
 419
 420                         /* put LPC port into known state, so
 421                            dtlk_readable() gives valid result */
 422                         outb_p(0xff, dtlk_port_lpc);
 423
 424                         /* INIT string and index marker */
 425                         dtlk_write_bytes("\036\1@\0\0012I\r", 8);
 426                         /* posting an index takes 18 msec.  Here, we
 427                            wait up to 100 msec to see whether it
 428                            appears. */
 429                         msleep_interruptible(100);
 430                         dtlk_has_indexing = dtlk_readable();
 431 #ifdef TRACING
 432                         printk(", indexing %d\n", dtlk_has_indexing);
 433 #endif
 434 #ifdef INSCOPE
 435                         {
 436 /* This macro records ten samples read from the LPC port, for later display */
 437 #define LOOK                                    \
 438 for (i = 0; i < 10; i++)                        \
 439   {                                             \
 440     buffer[b++] = inb_p(dtlk_port_lpc);         \
 441     __delay(loops_per_jiffy/(1000000/HZ));             \
 442   }
 443                                 char buffer[1000];
 444                                 int b = 0, i, j;
 445
 446                                 LOOK
 447                                 outb_p(0xff, dtlk_port_lpc);
 448                                 buffer[b++] = 0;
 449                                 LOOK
 450                                 dtlk_write_bytes("\0012I\r", 4);
 451                                 buffer[b++] = 0;
 452                                 __delay(50 * loops_per_jiffy / (1000/HZ));
 453                                 outb_p(0xff, dtlk_port_lpc);
 454                                 buffer[b++] = 0;
 455                                 LOOK
 456
 457                                 printk("\n");
 458                                 for (j = 0; j < b; j++)
 459                                         printk(" %02x", buffer[j]);
 460                                 printk("\n");
 461                         }
 462 #endif                          /* INSCOPE */
 463
 464 #ifdef OUTSCOPE
 465                         {
 466 /* This macro records ten samples read from the TTS port, for later display */
 467 #define LOOK                                    \
 468 for (i = 0; i < 10; i++)                        \
 469   {                                             \
 470     buffer[b++] = inb_p(dtlk_port_tts);         \
 471     __delay(loops_per_jiffy/(1000000/HZ));  /* 1 us */ \
 472   }
 473                                 char buffer[1000];
 474                                 int b = 0, i, j;
 475
 476                                 mdelay(10);     /* 10 ms */
 477                                 LOOK
 478                                 outb_p(0x03, dtlk_port_tts);
 479                                 buffer[b++] = 0;
 480                                 LOOK
 481                                 LOOK
 482
 483                                 printk("\n");
 484                                 for (j = 0; j < b; j++)
 485                                         printk(" %02x", buffer[j]);
 486                                 printk("\n");
 487                         }
 488 #endif                          /* OUTSCOPE */
 489
 490                         dtlk_write_bytes("Double Talk found", 18);
 491
 492                         return 0;
 493                 }
 494                 release_region(dtlk_portlist[i], DTLK_IO_EXTENT);
 495         }
 496
 497         printk(KERN_INFO "DoubleTalk PC - not found\n");
 498         return -ENODEV;
 499 }
 500
 501 /*
 502    static void dtlk_handle_error(char op, char rc, unsigned int minor)
 503    {
 504    printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n",
 505    minor, op, rc);
 506    return;
 507    }
 508  */
 509
 510 /* interrogate the DoubleTalk PC and return its settings */
 511 static struct dtlk_settings *dtlk_interrogate(void)
 512 {
 513         unsigned char *t;
 514         static char buf[sizeof(struct dtlk_settings) + 1];
 515         int total, i;
 516         static struct dtlk_settings status;
 517         TRACE_TEXT("(dtlk_interrogate");
 518         dtlk_write_bytes("\030\001?", 3);
 519         for (total = 0, i = 0; i < 50; i++) {
 520                 buf[total] = dtlk_read_tts();
 521                 if (total > 2 && buf[total] == 0x7f)
 522                         break;
 523                 if (total < sizeof(struct dtlk_settings))
 524                         total++;
 525         }
 526         /*
 527            if (i==50) printk("interrogate() read overrun\n");
 528            for (i=0; i<sizeof(buf); i++)
 529            printk(" %02x", buf[i]);
 530            printk("\n");
 531          */
 532         t = buf;
 533         status.serial_number = t[0] + t[1] * 256; /* serial number is
 534                                                      little endian */
 535         t += 2;
 536
 537         i = 0;
 538         while (*t != '\r') {
 539                 status.rom_version[i] = *t;
 540                 if (i < sizeof(status.rom_version) - 1)
 541                         i++;
 542                 t++;
 543         }
 544         status.rom_version[i] = 0;
 545         t++;
 546
 547         status.mode = *t++;
 548         status.punc_level = *t++;
 549         status.formant_freq = *t++;
 550         status.pitch = *t++;
 551         status.speed = *t++;
 552         status.volume = *t++;
 553         status.tone = *t++;
 554         status.expression = *t++;
 555         status.ext_dict_loaded = *t++;
 556         status.ext_dict_status = *t++;
 557         status.free_ram = *t++;
 558         status.articulation = *t++;
 559         status.reverb = *t++;
 560         status.eob = *t++;
 561         status.has_indexing = dtlk_has_indexing;
 562         TRACE_RET;
 563         return &status;
 564 }
 565
 566 static char dtlk_read_tts(void)
 567 {
 568         int portval, retries = 0;
 569         char ch;
 570         TRACE_TEXT("(dtlk_read_tts");
 571
 572         /* verify DT is ready, read char, wait for ACK */
 573         do {
 574                 portval = inb_p(dtlk_port_tts);
 575         } while ((portval & TTS_READABLE) == 0 &&
 576                  retries++ < DTLK_MAX_RETRIES);
 577         if (retries > DTLK_MAX_RETRIES)
 578                 printk(KERN_ERR "dtlk_read_tts() timeout\n");
 579
 580         ch = inb_p(dtlk_port_tts);      /* input from TTS port */
 581         ch &= 0x7f;
 582         outb_p(ch, dtlk_port_tts);
 583
 584         retries = 0;
 585         do {
 586                 portval = inb_p(dtlk_port_tts);
 587         } while ((portval & TTS_READABLE) != 0 &&
 588                  retries++ < DTLK_MAX_RETRIES);
 589         if (retries > DTLK_MAX_RETRIES)
 590                 printk(KERN_ERR "dtlk_read_tts() timeout\n");
 591
 592         TRACE_RET;
 593         return ch;
 594 }
 595
 596 static char dtlk_read_lpc(void)
 597 {
 598         int retries = 0;
 599         char ch;
 600         TRACE_TEXT("(dtlk_read_lpc");
 601
 602         /* no need to test -- this is only called when the port is readable */
 603
 604         ch = inb_p(dtlk_port_lpc);      /* input from LPC port */
 605
 606         outb_p(0xff, dtlk_port_lpc);
 607
 608         /* acknowledging a read takes 3-4
 609            usec.  Here, we wait up to 20 usec
 610            for the acknowledgement */
 611         retries = (loops_per_jiffy * 20) / (1000000/HZ);
 612         while (inb_p(dtlk_port_lpc) != 0x7f && --retries > 0);
 613         if (retries == 0)
 614                 printk(KERN_ERR "dtlk_read_lpc() timeout\n");
 615
 616         TRACE_RET;
 617         return ch;
 618 }
 619
 620 /* write n bytes to tts port */
 621 static char dtlk_write_bytes(const char *buf, int n)
 622 {
 623         char val = 0;
 624         /*  printk("dtlk_write_bytes(\"%-*s\", %d)\n", n, buf, n); */
 625         TRACE_TEXT("(dtlk_write_bytes");
 626         while (n-- > 0)
 627                 val = dtlk_write_tts(*buf++);
 628         TRACE_RET;
 629         return val;
 630 }
 631
 632 static char dtlk_write_tts(char ch)
 633 {
 634         int retries = 0;
 635 #ifdef TRACINGMORE
 636         printk("  dtlk_write_tts(");
 637         if (' ' <= ch && ch <= '~')
 638                 printk("'%c'", ch);
 639         else
 640                 printk("0x%02x", ch);
 641 #endif
 642         if (ch != DTLK_CLEAR)   /* no flow control for CLEAR command */
 643                 while ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0 &&
 644                        retries++ < DTLK_MAX_RETRIES)    /* DT ready? */
 645                         ;
 646         if (retries > DTLK_MAX_RETRIES)
 647                 printk(KERN_ERR "dtlk_write_tts() timeout\n");
 648
 649         outb_p(ch, dtlk_port_tts);      /* output to TTS port */
 650         /* the RDY bit goes zero 2-3 usec after writing, and goes
 651            1 again 180-190 usec later.  Here, we wait up to 10
 652            usec for the RDY bit to go zero. */
 653         for (retries = 0; retries < loops_per_jiffy / (100000/HZ); retries++)
 654                 if ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0)
 655                         break;
 656
 657 #ifdef TRACINGMORE
 658         printk(")\n");
 659 #endif
 660         return 0;
 661 }
 662
 663 MODULE_LICENSE("GPL");