2 * dtlk.c - DoubleTalk PC driver for Linux
4 * Original author: Chris Pallotta <chris@allmedia.com>
5 * Current maintainer: Jim Van Zandt <jrv@vanzandt.mv.com>
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.
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
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
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.
32 The DoubleTalk PC generates no interrupts.
34 These characteristics are mapped into the Unix stream I/O model as
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.
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.
46 Status information is available using the DTLK_INTERROGATE ioctl.
50 #include <linux/module.h>
53 #include <linux/types.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 <linux/sched.h>
60 #include <linux/smp_lock.h> /* cycle_kernel_lock() */
61 #include <asm/io.h> /* for inb_p, outb_p, inb, outb, etc. */
62 #include <asm/uaccess.h> /* for get_user, etc. */
63 #include <linux/wait.h> /* for wait_queue */
64 #include <linux/init.h> /* for __init, module_{init,exit} */
65 #include <linux/poll.h> /* for POLLIN, etc. */
66 #include <linux/dtlk.h> /* local header file for DoubleTalk values */
69 #define TRACE_TEXT(str) printk(str);
70 #define TRACE_RET printk(")")
72 #define TRACE_TEXT(str) ((void) 0)
73 #define TRACE_RET ((void) 0)
76 static void dtlk_timer_tick(unsigned long data);
78 static int dtlk_major;
79 static int dtlk_port_lpc;
80 static int dtlk_port_tts;
82 static int dtlk_has_indexing;
83 static unsigned int dtlk_portlist[] =
84 {0x25e, 0x29e, 0x2de, 0x31e, 0x35e, 0x39e, 0};
85 static wait_queue_head_t dtlk_process_list;
86 static DEFINE_TIMER(dtlk_timer, dtlk_timer_tick, 0, 0);
88 /* prototypes for file_operations struct */
89 static ssize_t dtlk_read(struct file *, char __user *,
90 size_t nbytes, loff_t * ppos);
91 static ssize_t dtlk_write(struct file *, const char __user *,
92 size_t nbytes, loff_t * ppos);
93 static unsigned int dtlk_poll(struct file *, poll_table *);
94 static int dtlk_open(struct inode *, struct file *);
95 static int dtlk_release(struct inode *, struct file *);
96 static long dtlk_ioctl(struct file *file,
97 unsigned int cmd, unsigned long arg);
99 static const struct file_operations dtlk_fops =
101 .owner = THIS_MODULE,
105 .unlocked_ioctl = dtlk_ioctl,
107 .release = dtlk_release,
111 /* local prototypes */
112 static int dtlk_dev_probe(void);
113 static struct dtlk_settings *dtlk_interrogate(void);
114 static int dtlk_readable(void);
115 static char dtlk_read_lpc(void);
116 static char dtlk_read_tts(void);
117 static int dtlk_writeable(void);
118 static char dtlk_write_bytes(const char *buf, int n);
119 static char dtlk_write_tts(char);
121 static void dtlk_handle_error(char, char, unsigned int);
124 static ssize_t dtlk_read(struct file *file, char __user *buf,
125 size_t count, loff_t * ppos)
127 unsigned int minor = iminor(file->f_path.dentry->d_inode);
131 TRACE_TEXT("(dtlk_read");
132 /* printk("DoubleTalk PC - dtlk_read()\n"); */
134 if (minor != DTLK_MINOR || !dtlk_has_indexing)
137 for (retries = 0; retries < loops_per_jiffy; retries++) {
138 while (i < count && dtlk_readable()) {
139 ch = dtlk_read_lpc();
140 /* printk("dtlk_read() reads 0x%02x\n", ch); */
141 if (put_user(ch, buf++))
147 if (file->f_flags & O_NONBLOCK)
149 msleep_interruptible(100);
151 if (retries == loops_per_jiffy)
152 printk(KERN_ERR "dtlk_read times out\n");
157 static ssize_t dtlk_write(struct file *file, const char __user *buf,
158 size_t count, loff_t * ppos)
160 int i = 0, retries = 0, ch;
162 TRACE_TEXT("(dtlk_write");
167 for (i = 0; i < count; i++) {
168 if (get_user(ch, buf + i))
170 if (' ' <= ch && ch <= '~')
173 printk("\\%03o", ch);
179 if (iminor(file->f_path.dentry->d_inode) != DTLK_MINOR)
183 while (i < count && !get_user(ch, buf) &&
184 (ch == DTLK_CLEAR || dtlk_writeable())) {
189 /* We yield our time until scheduled
190 again. This reduces the transfer
191 rate to 500 bytes/sec, but that's
192 still enough to keep up with the
193 speech synthesizer. */
194 msleep_interruptible(1);
196 /* the RDY bit goes zero 2-3 usec
197 after writing, and goes 1 again
198 180-190 usec later. Here, we wait
199 up to 250 usec for the RDY bit to
202 retries < loops_per_jiffy / (4000/HZ);
204 if (inb_p(dtlk_port_tts) &
212 if (file->f_flags & O_NONBLOCK)
215 msleep_interruptible(1);
217 if (++retries > 10 * HZ) { /* wait no more than 10 sec
219 printk("dtlk: write timeout. "
220 "inb_p(dtlk_port_tts) = 0x%02x\n",
221 inb_p(dtlk_port_tts));
230 static unsigned int dtlk_poll(struct file *file, poll_table * wait)
233 unsigned long expires;
235 TRACE_TEXT(" dtlk_poll");
239 printk("<%ld>", jiffies-j);
242 poll_wait(file, &dtlk_process_list, wait);
244 if (dtlk_has_indexing && dtlk_readable()) {
245 del_timer(&dtlk_timer);
246 mask = POLLIN | POLLRDNORM;
248 if (dtlk_writeable()) {
249 del_timer(&dtlk_timer);
250 mask |= POLLOUT | POLLWRNORM;
252 /* there are no exception conditions */
254 /* There won't be any interrupts, so we set a timer instead. */
255 expires = jiffies + 3*HZ / 100;
256 mod_timer(&dtlk_timer, expires);
261 static void dtlk_timer_tick(unsigned long data)
263 TRACE_TEXT(" dtlk_timer_tick");
264 wake_up_interruptible(&dtlk_process_list);
267 static long dtlk_ioctl(struct file *file,
271 char __user *argp = (char __user *)arg;
272 struct dtlk_settings *sp;
274 TRACE_TEXT(" dtlk_ioctl");
278 case DTLK_INTERROGATE:
280 sp = dtlk_interrogate();
282 if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
287 portval = inb_p(dtlk_port_tts);
288 return put_user(portval, argp);
295 /* Note that nobody ever sets dtlk_busy... */
296 static int dtlk_open(struct inode *inode, struct file *file)
298 TRACE_TEXT("(dtlk_open");
301 nonseekable_open(inode, file);
302 switch (iminor(inode)) {
306 return nonseekable_open(inode, file);
313 static int dtlk_release(struct inode *inode, struct file *file)
315 TRACE_TEXT("(dtlk_release");
317 switch (iminor(inode)) {
326 del_timer_sync(&dtlk_timer);
331 static int __init dtlk_init(void)
338 dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
339 if (dtlk_major < 0) {
340 printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
343 err = dtlk_dev_probe();
345 unregister_chrdev(dtlk_major, "dtlk");
348 printk(", MAJOR %d\n", dtlk_major);
350 init_waitqueue_head(&dtlk_process_list);
355 static void __exit dtlk_cleanup (void)
357 dtlk_write_bytes("goodbye", 8);
358 msleep_interruptible(500); /* nap 0.50 sec but
363 dtlk_write_tts(DTLK_CLEAR);
364 unregister_chrdev(dtlk_major, "dtlk");
365 release_region(dtlk_port_lpc, DTLK_IO_EXTENT);
368 module_init(dtlk_init);
369 module_exit(dtlk_cleanup);
371 /* ------------------------------------------------------------------------ */
373 static int dtlk_readable(void)
376 printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc) != 0x7f, jiffies);
378 return inb_p(dtlk_port_lpc) != 0x7f;
381 static int dtlk_writeable(void)
383 /* TRACE_TEXT(" dtlk_writeable"); */
385 printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts) & TTS_WRITABLE)!=0);
387 return inb_p(dtlk_port_tts) & TTS_WRITABLE;
390 static int __init dtlk_dev_probe(void)
392 unsigned int testval = 0;
394 struct dtlk_settings *sp;
396 if (dtlk_port_lpc | dtlk_port_tts)
399 for (i = 0; dtlk_portlist[i]; i++) {
401 printk("DoubleTalk PC - Port %03x = %04x\n",
402 dtlk_portlist[i], (testval = inw_p(dtlk_portlist[i])));
405 if (!request_region(dtlk_portlist[i], DTLK_IO_EXTENT,
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;
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] +
418 sp->rom_version, sp->serial_number);
420 /* put LPC port into known state, so
421 dtlk_readable() gives valid result */
422 outb_p(0xff, dtlk_port_lpc);
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
429 msleep_interruptible(100);
430 dtlk_has_indexing = dtlk_readable();
432 printk(", indexing %d\n", dtlk_has_indexing);
436 /* This macro records ten samples read from the LPC port, for later display */
438 for (i = 0; i < 10; i++) \
440 buffer[b++] = inb_p(dtlk_port_lpc); \
441 __delay(loops_per_jiffy/(1000000/HZ)); \
447 outb_p(0xff, dtlk_port_lpc);
450 dtlk_write_bytes("\0012I\r", 4);
452 __delay(50 * loops_per_jiffy / (1000/HZ));
453 outb_p(0xff, dtlk_port_lpc);
458 for (j = 0; j < b; j++)
459 printk(" %02x", buffer[j]);
466 /* This macro records ten samples read from the TTS port, for later display */
468 for (i = 0; i < 10; i++) \
470 buffer[b++] = inb_p(dtlk_port_tts); \
471 __delay(loops_per_jiffy/(1000000/HZ)); /* 1 us */ \
476 mdelay(10); /* 10 ms */
478 outb_p(0x03, dtlk_port_tts);
484 for (j = 0; j < b; j++)
485 printk(" %02x", buffer[j]);
488 #endif /* OUTSCOPE */
490 dtlk_write_bytes("Double Talk found", 18);
494 release_region(dtlk_portlist[i], DTLK_IO_EXTENT);
497 printk(KERN_INFO "DoubleTalk PC - not found\n");
502 static void dtlk_handle_error(char op, char rc, unsigned int minor)
504 printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n",
510 /* interrogate the DoubleTalk PC and return its settings */
511 static struct dtlk_settings *dtlk_interrogate(void)
514 static char buf[sizeof(struct dtlk_settings) + 1];
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)
523 if (total < sizeof(struct dtlk_settings))
527 if (i==50) printk("interrogate() read overrun\n");
528 for (i=0; i<sizeof(buf); i++)
529 printk(" %02x", buf[i]);
533 status.serial_number = t[0] + t[1] * 256; /* serial number is
539 status.rom_version[i] = *t;
540 if (i < sizeof(status.rom_version) - 1)
544 status.rom_version[i] = 0;
548 status.punc_level = *t++;
549 status.formant_freq = *t++;
552 status.volume = *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++;
561 status.has_indexing = dtlk_has_indexing;
566 static char dtlk_read_tts(void)
568 int portval, retries = 0;
570 TRACE_TEXT("(dtlk_read_tts");
572 /* verify DT is ready, read char, wait for ACK */
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");
580 ch = inb_p(dtlk_port_tts); /* input from TTS port */
582 outb_p(ch, dtlk_port_tts);
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");
596 static char dtlk_read_lpc(void)
600 TRACE_TEXT("(dtlk_read_lpc");
602 /* no need to test -- this is only called when the port is readable */
604 ch = inb_p(dtlk_port_lpc); /* input from LPC port */
606 outb_p(0xff, dtlk_port_lpc);
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);
614 printk(KERN_ERR "dtlk_read_lpc() timeout\n");
620 /* write n bytes to tts port */
621 static char dtlk_write_bytes(const char *buf, int n)
624 /* printk("dtlk_write_bytes(\"%-*s\", %d)\n", n, buf, n); */
625 TRACE_TEXT("(dtlk_write_bytes");
627 val = dtlk_write_tts(*buf++);
632 static char dtlk_write_tts(char ch)
636 printk(" dtlk_write_tts(");
637 if (' ' <= ch && ch <= '~')
640 printk("0x%02x", ch);
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? */
646 if (retries > DTLK_MAX_RETRIES)
647 printk(KERN_ERR "dtlk_write_tts() timeout\n");
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)
663 MODULE_LICENSE("GPL");