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
,
110 /* local prototypes */
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);
123 static ssize_t
dtlk_read(struct file
*file
, char __user
*buf
,
124 size_t count
, loff_t
* ppos
)
126 unsigned int minor
= iminor(file
->f_path
.dentry
->d_inode
);
130 TRACE_TEXT("(dtlk_read");
131 /* printk("DoubleTalk PC - dtlk_read()\n"); */
133 if (minor
!= DTLK_MINOR
|| !dtlk_has_indexing
)
136 for (retries
= 0; retries
< loops_per_jiffy
; retries
++) {
137 while (i
< count
&& dtlk_readable()) {
138 ch
= dtlk_read_lpc();
139 /* printk("dtlk_read() reads 0x%02x\n", ch); */
140 if (put_user(ch
, buf
++))
146 if (file
->f_flags
& O_NONBLOCK
)
148 msleep_interruptible(100);
150 if (retries
== loops_per_jiffy
)
151 printk(KERN_ERR
"dtlk_read times out\n");
156 static ssize_t
dtlk_write(struct file
*file
, const char __user
*buf
,
157 size_t count
, loff_t
* ppos
)
159 int i
= 0, retries
= 0, ch
;
161 TRACE_TEXT("(dtlk_write");
166 for (i
= 0; i
< count
; i
++) {
167 if (get_user(ch
, buf
+ i
))
169 if (' ' <= ch
&& ch
<= '~')
172 printk("\\%03o", ch
);
178 if (iminor(file
->f_path
.dentry
->d_inode
) != DTLK_MINOR
)
182 while (i
< count
&& !get_user(ch
, buf
) &&
183 (ch
== DTLK_CLEAR
|| dtlk_writeable())) {
188 /* We yield our time until scheduled
189 again. This reduces the transfer
190 rate to 500 bytes/sec, but that's
191 still enough to keep up with the
192 speech synthesizer. */
193 msleep_interruptible(1);
195 /* the RDY bit goes zero 2-3 usec
196 after writing, and goes 1 again
197 180-190 usec later. Here, we wait
198 up to 250 usec for the RDY bit to
201 retries
< loops_per_jiffy
/ (4000/HZ
);
203 if (inb_p(dtlk_port_tts
) &
211 if (file
->f_flags
& O_NONBLOCK
)
214 msleep_interruptible(1);
216 if (++retries
> 10 * HZ
) { /* wait no more than 10 sec
218 printk("dtlk: write timeout. "
219 "inb_p(dtlk_port_tts) = 0x%02x\n",
220 inb_p(dtlk_port_tts
));
229 static unsigned int dtlk_poll(struct file
*file
, poll_table
* wait
)
232 unsigned long expires
;
234 TRACE_TEXT(" dtlk_poll");
238 printk("<%ld>", jiffies-j);
241 poll_wait(file
, &dtlk_process_list
, wait
);
243 if (dtlk_has_indexing
&& dtlk_readable()) {
244 del_timer(&dtlk_timer
);
245 mask
= POLLIN
| POLLRDNORM
;
247 if (dtlk_writeable()) {
248 del_timer(&dtlk_timer
);
249 mask
|= POLLOUT
| POLLWRNORM
;
251 /* there are no exception conditions */
253 /* There won't be any interrupts, so we set a timer instead. */
254 expires
= jiffies
+ 3*HZ
/ 100;
255 mod_timer(&dtlk_timer
, expires
);
260 static void dtlk_timer_tick(unsigned long data
)
262 TRACE_TEXT(" dtlk_timer_tick");
263 wake_up_interruptible(&dtlk_process_list
);
266 static long dtlk_ioctl(struct file
*file
,
270 char __user
*argp
= (char __user
*)arg
;
271 struct dtlk_settings
*sp
;
273 TRACE_TEXT(" dtlk_ioctl");
277 case DTLK_INTERROGATE
:
279 sp
= dtlk_interrogate();
281 if (copy_to_user(argp
, sp
, sizeof(struct dtlk_settings
)))
286 portval
= inb_p(dtlk_port_tts
);
287 return put_user(portval
, argp
);
294 /* Note that nobody ever sets dtlk_busy... */
295 static int dtlk_open(struct inode
*inode
, struct file
*file
)
297 TRACE_TEXT("(dtlk_open");
300 nonseekable_open(inode
, file
);
301 switch (iminor(inode
)) {
305 return nonseekable_open(inode
, file
);
312 static int dtlk_release(struct inode
*inode
, struct file
*file
)
314 TRACE_TEXT("(dtlk_release");
316 switch (iminor(inode
)) {
325 del_timer_sync(&dtlk_timer
);
330 static int __init
dtlk_init(void)
337 dtlk_major
= register_chrdev(0, "dtlk", &dtlk_fops
);
338 if (dtlk_major
< 0) {
339 printk(KERN_ERR
"DoubleTalk PC - cannot register device\n");
342 err
= dtlk_dev_probe();
344 unregister_chrdev(dtlk_major
, "dtlk");
347 printk(", MAJOR %d\n", dtlk_major
);
349 init_waitqueue_head(&dtlk_process_list
);
354 static void __exit
dtlk_cleanup (void)
356 dtlk_write_bytes("goodbye", 8);
357 msleep_interruptible(500); /* nap 0.50 sec but
362 dtlk_write_tts(DTLK_CLEAR
);
363 unregister_chrdev(dtlk_major
, "dtlk");
364 release_region(dtlk_port_lpc
, DTLK_IO_EXTENT
);
367 module_init(dtlk_init
);
368 module_exit(dtlk_cleanup
);
370 /* ------------------------------------------------------------------------ */
372 static int dtlk_readable(void)
375 printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc
) != 0x7f, jiffies
);
377 return inb_p(dtlk_port_lpc
) != 0x7f;
380 static int dtlk_writeable(void)
382 /* TRACE_TEXT(" dtlk_writeable"); */
384 printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts
) & TTS_WRITABLE
)!=0);
386 return inb_p(dtlk_port_tts
) & TTS_WRITABLE
;
389 static int __init
dtlk_dev_probe(void)
391 unsigned int testval
= 0;
393 struct dtlk_settings
*sp
;
395 if (dtlk_port_lpc
| dtlk_port_tts
)
398 for (i
= 0; dtlk_portlist
[i
]; i
++) {
400 if (!request_region(dtlk_portlist
[i
], DTLK_IO_EXTENT
,
403 testval
= inw_p(dtlk_portlist
[i
]);
404 if ((testval
&= 0xfbff) == 0x107f) {
405 dtlk_port_lpc
= dtlk_portlist
[i
];
406 dtlk_port_tts
= dtlk_port_lpc
+ 1;
408 sp
= dtlk_interrogate();
409 printk("DoubleTalk PC at %03x-%03x, "
410 "ROM version %s, serial number %u",
411 dtlk_portlist
[i
], dtlk_portlist
[i
] +
413 sp
->rom_version
, sp
->serial_number
);
415 /* put LPC port into known state, so
416 dtlk_readable() gives valid result */
417 outb_p(0xff, dtlk_port_lpc
);
419 /* INIT string and index marker */
420 dtlk_write_bytes("\036\1@\0\0012I\r", 8);
421 /* posting an index takes 18 msec. Here, we
422 wait up to 100 msec to see whether it
424 msleep_interruptible(100);
425 dtlk_has_indexing
= dtlk_readable();
427 printk(", indexing %d\n", dtlk_has_indexing
);
431 /* This macro records ten samples read from the LPC port, for later display */
433 for (i = 0; i < 10; i++) \
435 buffer[b++] = inb_p(dtlk_port_lpc); \
436 __delay(loops_per_jiffy/(1000000/HZ)); \
442 outb_p(0xff, dtlk_port_lpc
);
445 dtlk_write_bytes("\0012I\r", 4);
447 __delay(50 * loops_per_jiffy
/ (1000/HZ
));
448 outb_p(0xff, dtlk_port_lpc
);
453 for (j
= 0; j
< b
; j
++)
454 printk(" %02x", buffer
[j
]);
461 /* This macro records ten samples read from the TTS port, for later display */
463 for (i = 0; i < 10; i++) \
465 buffer[b++] = inb_p(dtlk_port_tts); \
466 __delay(loops_per_jiffy/(1000000/HZ)); /* 1 us */ \
471 mdelay(10); /* 10 ms */
473 outb_p(0x03, dtlk_port_tts
);
479 for (j
= 0; j
< b
; j
++)
480 printk(" %02x", buffer
[j
]);
483 #endif /* OUTSCOPE */
485 dtlk_write_bytes("Double Talk found", 18);
489 release_region(dtlk_portlist
[i
], DTLK_IO_EXTENT
);
492 printk(KERN_INFO
"DoubleTalk PC - not found\n");
497 static void dtlk_handle_error(char op, char rc, unsigned int minor)
499 printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n",
505 /* interrogate the DoubleTalk PC and return its settings */
506 static struct dtlk_settings
*dtlk_interrogate(void)
509 static char buf
[sizeof(struct dtlk_settings
) + 1];
511 static struct dtlk_settings status
;
512 TRACE_TEXT("(dtlk_interrogate");
513 dtlk_write_bytes("\030\001?", 3);
514 for (total
= 0, i
= 0; i
< 50; i
++) {
515 buf
[total
] = dtlk_read_tts();
516 if (total
> 2 && buf
[total
] == 0x7f)
518 if (total
< sizeof(struct dtlk_settings
))
522 if (i==50) printk("interrogate() read overrun\n");
523 for (i=0; i<sizeof(buf); i++)
524 printk(" %02x", buf[i]);
528 status
.serial_number
= t
[0] + t
[1] * 256; /* serial number is
534 status
.rom_version
[i
] = *t
;
535 if (i
< sizeof(status
.rom_version
) - 1)
539 status
.rom_version
[i
] = 0;
543 status
.punc_level
= *t
++;
544 status
.formant_freq
= *t
++;
547 status
.volume
= *t
++;
549 status
.expression
= *t
++;
550 status
.ext_dict_loaded
= *t
++;
551 status
.ext_dict_status
= *t
++;
552 status
.free_ram
= *t
++;
553 status
.articulation
= *t
++;
554 status
.reverb
= *t
++;
556 status
.has_indexing
= dtlk_has_indexing
;
561 static char dtlk_read_tts(void)
563 int portval
, retries
= 0;
565 TRACE_TEXT("(dtlk_read_tts");
567 /* verify DT is ready, read char, wait for ACK */
569 portval
= inb_p(dtlk_port_tts
);
570 } while ((portval
& TTS_READABLE
) == 0 &&
571 retries
++ < DTLK_MAX_RETRIES
);
572 if (retries
> DTLK_MAX_RETRIES
)
573 printk(KERN_ERR
"dtlk_read_tts() timeout\n");
575 ch
= inb_p(dtlk_port_tts
); /* input from TTS port */
577 outb_p(ch
, dtlk_port_tts
);
581 portval
= inb_p(dtlk_port_tts
);
582 } while ((portval
& TTS_READABLE
) != 0 &&
583 retries
++ < DTLK_MAX_RETRIES
);
584 if (retries
> DTLK_MAX_RETRIES
)
585 printk(KERN_ERR
"dtlk_read_tts() timeout\n");
591 static char dtlk_read_lpc(void)
595 TRACE_TEXT("(dtlk_read_lpc");
597 /* no need to test -- this is only called when the port is readable */
599 ch
= inb_p(dtlk_port_lpc
); /* input from LPC port */
601 outb_p(0xff, dtlk_port_lpc
);
603 /* acknowledging a read takes 3-4
604 usec. Here, we wait up to 20 usec
605 for the acknowledgement */
606 retries
= (loops_per_jiffy
* 20) / (1000000/HZ
);
607 while (inb_p(dtlk_port_lpc
) != 0x7f && --retries
> 0);
609 printk(KERN_ERR
"dtlk_read_lpc() timeout\n");
615 /* write n bytes to tts port */
616 static char dtlk_write_bytes(const char *buf
, int n
)
619 /* printk("dtlk_write_bytes(\"%-*s\", %d)\n", n, buf, n); */
620 TRACE_TEXT("(dtlk_write_bytes");
622 val
= dtlk_write_tts(*buf
++);
627 static char dtlk_write_tts(char ch
)
631 printk(" dtlk_write_tts(");
632 if (' ' <= ch
&& ch
<= '~')
635 printk("0x%02x", ch
);
637 if (ch
!= DTLK_CLEAR
) /* no flow control for CLEAR command */
638 while ((inb_p(dtlk_port_tts
) & TTS_WRITABLE
) == 0 &&
639 retries
++ < DTLK_MAX_RETRIES
) /* DT ready? */
641 if (retries
> DTLK_MAX_RETRIES
)
642 printk(KERN_ERR
"dtlk_write_tts() timeout\n");
644 outb_p(ch
, dtlk_port_tts
); /* output to TTS port */
645 /* the RDY bit goes zero 2-3 usec after writing, and goes
646 1 again 180-190 usec later. Here, we wait up to 10
647 usec for the RDY bit to go zero. */
648 for (retries
= 0; retries
< loops_per_jiffy
/ (100000/HZ
); retries
++)
649 if ((inb_p(dtlk_port_tts
) & TTS_WRITABLE
) == 0)
658 MODULE_LICENSE("GPL");