SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/char/dtlk.c

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