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>
55 #include <linux/mm.h> /* for verify_area */
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 #include <linux/devfs_fs_kernel.h>
66 #include <linux/smp_lock.h>
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)
77 static int dtlk_major;
78 static int dtlk_port_lpc;
79 static int dtlk_port_tts;
81 static int dtlk_has_indexing;
82 static unsigned int dtlk_portlist[] =
83 {0x25e, 0x29e, 0x2de, 0x31e, 0x35e, 0x39e, 0};
84 static wait_queue_head_t dtlk_process_list;
85 static struct timer_list dtlk_timer;
87 /* prototypes for file_operations struct */
88 static ssize_t dtlk_read(struct file *, char __user *,
89 size_t nbytes, loff_t * ppos);
90 static ssize_t dtlk_write(struct file *, const char __user *,
91 size_t nbytes, loff_t * ppos);
92 static unsigned int dtlk_poll(struct file *, poll_table *);
93 static int dtlk_open(struct inode *, struct file *);
94 static int dtlk_release(struct inode *, struct file *);
95 static int dtlk_ioctl(struct inode *inode, struct file *file,
96 unsigned int cmd, unsigned long arg);
98 static struct file_operations dtlk_fops =
100 .owner = THIS_MODULE,
106 .release = dtlk_release,
109 /* local prototypes */
110 static void dtlk_delay(int ms);
111 static int dtlk_dev_probe(void);
112 static struct dtlk_settings *dtlk_interrogate(void);
113 static int dtlk_readable(void);
114 static char dtlk_read_lpc(void);
115 static char dtlk_read_tts(void);
116 static int dtlk_writeable(void);
117 static char dtlk_write_bytes(const char *buf, int n);
118 static char dtlk_write_tts(char);
120 static void dtlk_handle_error(char, char, unsigned int);
122 static void dtlk_timer_tick(unsigned long data);
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_dentry->d_inode);
131 /* Can't seek (pread) on the DoubleTalk. */
132 if (ppos != &file->f_pos)
135 TRACE_TEXT("(dtlk_read");
136 /* printk("DoubleTalk PC - dtlk_read()\n"); */
138 if (minor != DTLK_MINOR || !dtlk_has_indexing)
141 for (retries = 0; retries < loops_per_jiffy; retries++) {
142 while (i < count && dtlk_readable()) {
143 ch = dtlk_read_lpc();
144 /* printk("dtlk_read() reads 0x%02x\n", ch); */
145 if (put_user(ch, buf++))
151 if (file->f_flags & O_NONBLOCK)
155 if (retries == loops_per_jiffy)
156 printk(KERN_ERR "dtlk_read times out\n");
161 static ssize_t dtlk_write(struct file *file, const char __user *buf,
162 size_t count, loff_t * ppos)
164 int i = 0, retries = 0, ch;
166 TRACE_TEXT("(dtlk_write");
171 for (i = 0; i < count; i++) {
172 if (get_user(ch, buf + i))
174 if (' ' <= ch && ch <= '~')
177 printk("\\%03o", ch);
183 /* Can't seek (pwrite) on the DoubleTalk. */
184 if (ppos != &file->f_pos)
187 if (iminor(file->f_dentry->d_inode) != DTLK_MINOR)
191 while (i < count && !get_user(ch, buf) &&
192 (ch == DTLK_CLEAR || dtlk_writeable())) {
197 /* We yield our time until scheduled
198 again. This reduces the transfer
199 rate to 500 bytes/sec, but that's
200 still enough to keep up with the
201 speech synthesizer. */
204 /* the RDY bit goes zero 2-3 usec
205 after writing, and goes 1 again
206 180-190 usec later. Here, we wait
207 up to 250 usec for the RDY bit to
210 retries < loops_per_jiffy / (4000/HZ);
212 if (inb_p(dtlk_port_tts) &
220 if (file->f_flags & O_NONBLOCK)
225 if (++retries > 10 * HZ) { /* wait no more than 10 sec
227 printk("dtlk: write timeout. "
228 "inb_p(dtlk_port_tts) = 0x%02x\n",
229 inb_p(dtlk_port_tts));
238 static unsigned int dtlk_poll(struct file *file, poll_table * wait)
241 unsigned long expires;
243 TRACE_TEXT(" dtlk_poll");
247 printk("<%ld>", jiffies-j);
250 poll_wait(file, &dtlk_process_list, wait);
252 if (dtlk_has_indexing && dtlk_readable()) {
253 del_timer(&dtlk_timer);
254 mask = POLLIN | POLLRDNORM;
256 if (dtlk_writeable()) {
257 del_timer(&dtlk_timer);
258 mask |= POLLOUT | POLLWRNORM;
260 /* there are no exception conditions */
262 /* There won't be any interrupts, so we set a timer instead. */
263 expires = jiffies + 3*HZ / 100;
264 mod_timer(&dtlk_timer, expires);
269 static void dtlk_timer_tick(unsigned long data)
271 TRACE_TEXT(" dtlk_timer_tick");
272 wake_up_interruptible(&dtlk_process_list);
275 static int dtlk_ioctl(struct inode *inode,
280 char __user *argp = (char __user *)arg;
281 struct dtlk_settings *sp;
283 TRACE_TEXT(" dtlk_ioctl");
287 case DTLK_INTERROGATE:
288 sp = dtlk_interrogate();
289 if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
294 portval = inb_p(dtlk_port_tts);
295 return put_user(portval, argp);
302 static int dtlk_open(struct inode *inode, struct file *file)
304 TRACE_TEXT("(dtlk_open");
306 switch (iminor(inode)) {
317 static int dtlk_release(struct inode *inode, struct file *file)
319 TRACE_TEXT("(dtlk_release");
321 switch (iminor(inode)) {
330 del_timer(&dtlk_timer);
335 static int __init dtlk_init(void)
340 dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
341 if (dtlk_major == 0) {
342 printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
345 if (dtlk_dev_probe() == 0)
346 printk(", MAJOR %d\n", dtlk_major);
348 devfs_mk_cdev(MKDEV(dtlk_major, DTLK_MINOR),
349 S_IFCHR | S_IRUSR | S_IWUSR, "dtlk");
351 init_timer(&dtlk_timer);
352 dtlk_timer.function = dtlk_timer_tick;
353 init_waitqueue_head(&dtlk_process_list);
358 static void __exit dtlk_cleanup (void)
360 dtlk_write_bytes("goodbye", 8);
361 current->state = TASK_INTERRUPTIBLE;
362 schedule_timeout(5 * HZ / 10); /* nap 0.50 sec but
367 dtlk_write_tts(DTLK_CLEAR);
368 unregister_chrdev(dtlk_major, "dtlk");
369 devfs_remove("dtlk");
370 release_region(dtlk_port_lpc, DTLK_IO_EXTENT);
373 module_init(dtlk_init);
374 module_exit(dtlk_cleanup);
376 /* ------------------------------------------------------------------------ */
378 /* sleep for ms milliseconds */
379 static void dtlk_delay(int ms)
381 current->state = TASK_INTERRUPTIBLE;
382 schedule_timeout((ms * HZ + 1000 - HZ) / 1000);
385 static int dtlk_readable(void)
388 printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc) != 0x7f, jiffies);
390 return inb_p(dtlk_port_lpc) != 0x7f;
393 static int dtlk_writeable(void)
395 /* TRACE_TEXT(" dtlk_writeable"); */
397 printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts) & TTS_WRITABLE)!=0);
399 return inb_p(dtlk_port_tts) & TTS_WRITABLE;
402 static int __init dtlk_dev_probe(void)
404 unsigned int testval = 0;
406 struct dtlk_settings *sp;
408 if (dtlk_port_lpc | dtlk_port_tts)
411 for (i = 0; dtlk_portlist[i]; i++) {
413 printk("DoubleTalk PC - Port %03x = %04x\n",
414 dtlk_portlist[i], (testval = inw_p(dtlk_portlist[i])));
417 if (!request_region(dtlk_portlist[i], DTLK_IO_EXTENT,
420 testval = inw_p(dtlk_portlist[i]);
421 if ((testval &= 0xfbff) == 0x107f) {
422 dtlk_port_lpc = dtlk_portlist[i];
423 dtlk_port_tts = dtlk_port_lpc + 1;
425 sp = dtlk_interrogate();
426 printk("DoubleTalk PC at %03x-%03x, "
427 "ROM version %s, serial number %u",
428 dtlk_portlist[i], dtlk_portlist[i] +
430 sp->rom_version, sp->serial_number);
432 /* put LPC port into known state, so
433 dtlk_readable() gives valid result */
434 outb_p(0xff, dtlk_port_lpc);
436 /* INIT string and index marker */
437 dtlk_write_bytes("\036\1@\0\0012I\r", 8);
438 /* posting an index takes 18 msec. Here, we
439 wait up to 100 msec to see whether it
442 dtlk_has_indexing = dtlk_readable();
444 printk(", indexing %d\n", dtlk_has_indexing);
448 /* This macro records ten samples read from the LPC port, for later display */
450 for (i = 0; i < 10; i++) \
452 buffer[b++] = inb_p(dtlk_port_lpc); \
453 __delay(loops_per_jiffy/(1000000/HZ)); \
459 outb_p(0xff, dtlk_port_lpc);
462 dtlk_write_bytes("\0012I\r", 4);
464 __delay(50 * loops_per_jiffy / (1000/HZ));
465 outb_p(0xff, dtlk_port_lpc);
470 for (j = 0; j < b; j++)
471 printk(" %02x", buffer[j]);
478 /* This macro records ten samples read from the TTS port, for later display */
480 for (i = 0; i < 10; i++) \
482 buffer[b++] = inb_p(dtlk_port_tts); \
483 __delay(loops_per_jiffy/(1000000/HZ)); /* 1 us */ \
488 mdelay(10); /* 10 ms */
490 outb_p(0x03, dtlk_port_tts);
496 for (j = 0; j < b; j++)
497 printk(" %02x", buffer[j]);
500 #endif /* OUTSCOPE */
502 dtlk_write_bytes("Double Talk found", 18);
506 release_region(dtlk_portlist[i], DTLK_IO_EXTENT);
509 printk(KERN_INFO "\nDoubleTalk PC - not found\n");
514 static void dtlk_handle_error(char op, char rc, unsigned int minor)
516 printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n",
522 /* interrogate the DoubleTalk PC and return its settings */
523 static struct dtlk_settings *dtlk_interrogate(void)
526 static char buf[sizeof(struct dtlk_settings) + 1];
528 static struct dtlk_settings status;
529 TRACE_TEXT("(dtlk_interrogate");
530 dtlk_write_bytes("\030\001?", 3);
531 for (total = 0, i = 0; i < 50; i++) {
532 buf[total] = dtlk_read_tts();
533 if (total > 2 && buf[total] == 0x7f)
535 if (total < sizeof(struct dtlk_settings))
539 if (i==50) printk("interrogate() read overrun\n");
540 for (i=0; i<sizeof(buf); i++)
541 printk(" %02x", buf[i]);
545 status.serial_number = t[0] + t[1] * 256; /* serial number is
551 status.rom_version[i] = *t;
552 if (i < sizeof(status.rom_version) - 1)
556 status.rom_version[i] = 0;
560 status.punc_level = *t++;
561 status.formant_freq = *t++;
564 status.volume = *t++;
566 status.expression = *t++;
567 status.ext_dict_loaded = *t++;
568 status.ext_dict_status = *t++;
569 status.free_ram = *t++;
570 status.articulation = *t++;
571 status.reverb = *t++;
573 status.has_indexing = dtlk_has_indexing;
578 static char dtlk_read_tts(void)
580 int portval, retries = 0;
582 TRACE_TEXT("(dtlk_read_tts");
584 /* verify DT is ready, read char, wait for ACK */
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");
592 ch = inb_p(dtlk_port_tts); /* input from TTS port */
594 outb_p(ch, dtlk_port_tts);
598 portval = inb_p(dtlk_port_tts);
599 } while ((portval & TTS_READABLE) != 0 &&
600 retries++ < DTLK_MAX_RETRIES);
601 if (retries == DTLK_MAX_RETRIES)
602 printk(KERN_ERR "dtlk_read_tts() timeout\n");
608 static char dtlk_read_lpc(void)
612 TRACE_TEXT("(dtlk_read_lpc");
614 /* no need to test -- this is only called when the port is readable */
616 ch = inb_p(dtlk_port_lpc); /* input from LPC port */
618 outb_p(0xff, dtlk_port_lpc);
620 /* acknowledging a read takes 3-4
621 usec. Here, we wait up to 20 usec
622 for the acknowledgement */
623 retries = (loops_per_jiffy * 20) / (1000000/HZ);
624 while (inb_p(dtlk_port_lpc) != 0x7f && --retries > 0);
626 printk(KERN_ERR "dtlk_read_lpc() timeout\n");
632 /* write n bytes to tts port */
633 static char dtlk_write_bytes(const char *buf, int n)
636 /* printk("dtlk_write_bytes(\"%-*s\", %d)\n", n, buf, n); */
637 TRACE_TEXT("(dtlk_write_bytes");
639 val = dtlk_write_tts(*buf++);
644 static char dtlk_write_tts(char ch)
648 printk(" dtlk_write_tts(");
649 if (' ' <= ch && ch <= '~')
652 printk("0x%02x", ch);
654 if (ch != DTLK_CLEAR) /* no flow control for CLEAR command */
655 while ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0 &&
656 retries++ < DTLK_MAX_RETRIES) /* DT ready? */
658 if (retries == DTLK_MAX_RETRIES)
659 printk(KERN_ERR "dtlk_write_tts() timeout\n");
661 outb_p(ch, dtlk_port_tts); /* output to TTS port */
662 /* the RDY bit goes zero 2-3 usec after writing, and goes
663 1 again 180-190 usec later. Here, we wait up to 10
664 usec for the RDY bit to go zero. */
665 for (retries = 0; retries < loops_per_jiffy / (100000/HZ); retries++)
666 if ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0)
675 MODULE_LICENSE("GPL");