[linux-block.git] / drivers / char / dtlk.c

/*                                              -*- linux-c -*-
 * dtlk.c - DoubleTalk PC driver for Linux
 *
 * Original author: Chris Pallotta <chris@allmedia.com>
 * Current maintainer: Jim Van Zandt <jrv@vanzandt.mv.com>
 * 
 * 2000-03-18 Jim Van Zandt: Fix polling.
 *  Eliminate dtlk_timer_active flag and separate dtlk_stop_timer
 *  function.  Don't restart timer in dtlk_timer_tick.  Restart timer
 *  in dtlk_poll after every poll.  dtlk_poll returns mask (duh).
 *  Eliminate unused function dtlk_write_byte.  Misc. code cleanups.
 */

/* This driver is for the DoubleTalk PC, a speech synthesizer
   manufactured by RC Systems (http://www.rcsys.com/).  It was written
   based on documentation in their User's Manual file and Developer's
   Tools disk.

   The DoubleTalk PC contains four voice synthesizers: text-to-speech
   (TTS), linear predictive coding (LPC), PCM/ADPCM, and CVSD.  It
   also has a tone generator.  Output data for LPC are written to the
   LPC port, and output data for the other modes are written to the
   TTS port.

   Two kinds of data can be read from the DoubleTalk: status
   information (in response to the "\001?" interrogation command) is
   read from the TTS port, and index markers (which mark the progress
   of the speech) are read from the LPC port.  Not all models of the
   DoubleTalk PC implement index markers.  Both the TTS and LPC ports
   can also display status flags.

   The DoubleTalk PC generates no interrupts.

   These characteristics are mapped into the Unix stream I/O model as
   follows:

   "write" sends bytes to the TTS port.  It is the responsibility of
   the user program to switch modes among TTS, PCM/ADPCM, and CVSD.
   This driver was written for use with the text-to-speech
   synthesizer.  If LPC output is needed some day, other minor device
   numbers can be used to select among output modes.

   "read" gets index markers from the LPC port.  If the device does
   not implement index markers, the read will fail with error EINVAL.

   Status information is available using the DTLK_INTERROGATE ioctl.

 */

#include <linux/module.h>

#define KERNEL
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/errno.h>	/* for -EBUSY */
#include <linux/ioport.h>	/* for request_region */
#include <linux/delay.h>	/* for loops_per_jiffy */
#include <asm/io.h>		/* for inb_p, outb_p, inb, outb, etc. */
#include <asm/uaccess.h>	/* for get_user, etc. */
#include <linux/wait.h>		/* for wait_queue */
#include <linux/init.h>		/* for __init, module_{init,exit} */
#include <linux/poll.h>		/* for POLLIN, etc. */
#include <linux/dtlk.h>		/* local header file for DoubleTalk values */
#include <linux/smp_lock.h>

#ifdef TRACING
#define TRACE_TEXT(str) printk(str);
#define TRACE_RET printk(")")
#else				/* !TRACING */
#define TRACE_TEXT(str) ((void) 0)
#define TRACE_RET ((void) 0)
#endif				/* TRACING */


static int dtlk_major;
static int dtlk_port_lpc;
static int dtlk_port_tts;
static int dtlk_busy;
static int dtlk_has_indexing;
static unsigned int dtlk_portlist[] =
{0x25e, 0x29e, 0x2de, 0x31e, 0x35e, 0x39e, 0};
static wait_queue_head_t dtlk_process_list;
static struct timer_list dtlk_timer;

/* prototypes for file_operations struct */
static ssize_t dtlk_read(struct file *, char __user *,
			 size_t nbytes, loff_t * ppos);
static ssize_t dtlk_write(struct file *, const char __user *,
			  size_t nbytes, loff_t * ppos);
static unsigned int dtlk_poll(struct file *, poll_table *);
static int dtlk_open(struct inode *, struct file *);
static int dtlk_release(struct inode *, struct file *);
static int dtlk_ioctl(struct inode *inode, struct file *file,
		      unsigned int cmd, unsigned long arg);

static const struct file_operations dtlk_fops =
{
	.owner		= THIS_MODULE,
	.read		= dtlk_read,
	.write		= dtlk_write,
	.poll		= dtlk_poll,
	.ioctl		= dtlk_ioctl,
	.open		= dtlk_open,
	.release	= dtlk_release,
};

/* local prototypes */
static int dtlk_dev_probe(void);
static struct dtlk_settings *dtlk_interrogate(void);
static int dtlk_readable(void);
static char dtlk_read_lpc(void);
static char dtlk_read_tts(void);
static int dtlk_writeable(void);
static char dtlk_write_bytes(const char *buf, int n);
static char dtlk_write_tts(char);
/*
   static void dtlk_handle_error(char, char, unsigned int);
 */
static void dtlk_timer_tick(unsigned long data);

static ssize_t dtlk_read(struct file *file, char __user *buf,
			 size_t count, loff_t * ppos)
{
	unsigned int minor = iminor(file->f_dentry->d_inode);
	char ch;
	int i = 0, retries;

	TRACE_TEXT("(dtlk_read");
	/*  printk("DoubleTalk PC - dtlk_read()\n"); */

	if (minor != DTLK_MINOR || !dtlk_has_indexing)
		return -EINVAL;

	for (retries = 0; retries < loops_per_jiffy; retries++) {
		while (i < count && dtlk_readable()) {
			ch = dtlk_read_lpc();
			/*        printk("dtlk_read() reads 0x%02x\n", ch); */
			if (put_user(ch, buf++))
				return -EFAULT;
			i++;
		}
		if (i)
			return i;
		if (file->f_flags & O_NONBLOCK)
			break;
		msleep_interruptible(100);
	}
	if (retries == loops_per_jiffy)
		printk(KERN_ERR "dtlk_read times out\n");
	TRACE_RET;
	return -EAGAIN;
}

static ssize_t dtlk_write(struct file *file, const char __user *buf,
			  size_t count, loff_t * ppos)
{
	int i = 0, retries = 0, ch;

	TRACE_TEXT("(dtlk_write");
#ifdef TRACING
	printk(" \"");
	{
		int i, ch;
		for (i = 0; i < count; i++) {
			if (get_user(ch, buf + i))
				return -EFAULT;
			if (' ' <= ch && ch <= '~')
				printk("%c", ch);
			else
				printk("\\%03o", ch);
		}
		printk("\"");
	}
#endif

	if (iminor(file->f_dentry->d_inode) != DTLK_MINOR)
		return -EINVAL;

	while (1) {
		while (i < count && !get_user(ch, buf) &&
		       (ch == DTLK_CLEAR || dtlk_writeable())) {
			dtlk_write_tts(ch);
			buf++;
			i++;
			if (i % 5 == 0)
				/* We yield our time until scheduled
				   again.  This reduces the transfer
				   rate to 500 bytes/sec, but that's
				   still enough to keep up with the
				   speech synthesizer. */
				msleep_interruptible(1);
			else {
				/* the RDY bit goes zero 2-3 usec
				   after writing, and goes 1 again
				   180-190 usec later.  Here, we wait
				   up to 250 usec for the RDY bit to
				   go nonzero. */
				for (retries = 0;
				     retries < loops_per_jiffy / (4000/HZ);
				     retries++)
					if (inb_p(dtlk_port_tts) &
					    TTS_WRITABLE)
						break;
			}
			retries = 0;
		}
		if (i == count)
			return i;
		if (file->f_flags & O_NONBLOCK)
			break;

		msleep_interruptible(1);

		if (++retries > 10 * HZ) { /* wait no more than 10 sec
					      from last write */
			printk("dtlk: write timeout.  "
			       "inb_p(dtlk_port_tts) = 0x%02x\n",
			       inb_p(dtlk_port_tts));
			TRACE_RET;
			return -EBUSY;
		}
	}
	TRACE_RET;
	return -EAGAIN;
}

static unsigned int dtlk_poll(struct file *file, poll_table * wait)
{
	int mask = 0;
	unsigned long expires;

	TRACE_TEXT(" dtlk_poll");
	/*
	   static long int j;
	   printk(".");
	   printk("<%ld>", jiffies-j);
	   j=jiffies;
	 */
	poll_wait(file, &dtlk_process_list, wait);

	if (dtlk_has_indexing && dtlk_readable()) {
	        del_timer(&dtlk_timer);
		mask = POLLIN | POLLRDNORM;
	}
	if (dtlk_writeable()) {
	        del_timer(&dtlk_timer);
		mask |= POLLOUT | POLLWRNORM;
	}
	/* there are no exception conditions */

	/* There won't be any interrupts, so we set a timer instead. */
	expires = jiffies + 3*HZ / 100;
	mod_timer(&dtlk_timer, expires);

	return mask;
}

static void dtlk_timer_tick(unsigned long data)
{
	TRACE_TEXT(" dtlk_timer_tick");
	wake_up_interruptible(&dtlk_process_list);
}

static int dtlk_ioctl(struct inode *inode,
		      struct file *file,
		      unsigned int cmd,
		      unsigned long arg)
{
	char __user *argp = (char __user *)arg;
	struct dtlk_settings *sp;
	char portval;
	TRACE_TEXT(" dtlk_ioctl");

	switch (cmd) {

	case DTLK_INTERROGATE:
		sp = dtlk_interrogate();
		if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
			return -EINVAL;
		return 0;

	case DTLK_STATUS:
		portval = inb_p(dtlk_port_tts);
		return put_user(portval, argp);

	default:
		return -EINVAL;
	}
}

static int dtlk_open(struct inode *inode, struct file *file)
{
	TRACE_TEXT("(dtlk_open");

	nonseekable_open(inode, file);
	switch (iminor(inode)) {
	case DTLK_MINOR:
		if (dtlk_busy)
			return -EBUSY;
		return nonseekable_open(inode, file);

	default:
		return -ENXIO;
	}
}

static int dtlk_release(struct inode *inode, struct file *file)
{
	TRACE_TEXT("(dtlk_release");

	switch (iminor(inode)) {
	case DTLK_MINOR:
		break;

	default:
		break;
	}
	TRACE_RET;
	
	del_timer(&dtlk_timer);

	return 0;
}

static int __init dtlk_init(void)
{
	dtlk_port_lpc = 0;
	dtlk_port_tts = 0;
	dtlk_busy = 0;
	dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
	if (dtlk_major == 0) {
		printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
		return 0;
	}
	if (dtlk_dev_probe() == 0)
		printk(", MAJOR %d\n", dtlk_major);

	init_timer(&dtlk_timer);
	dtlk_timer.function = dtlk_timer_tick;
	init_waitqueue_head(&dtlk_process_list);

	return 0;
}

static void __exit dtlk_cleanup (void)
{
	dtlk_write_bytes("goodbye", 8);
	msleep_interruptible(500);		/* nap 0.50 sec but
						   could be awakened
						   earlier by
						   signals... */

	dtlk_write_tts(DTLK_CLEAR);
	unregister_chrdev(dtlk_major, "dtlk");
	release_region(dtlk_port_lpc, DTLK_IO_EXTENT);
}

module_init(dtlk_init);
module_exit(dtlk_cleanup);

/* ------------------------------------------------------------------------ */

static int dtlk_readable(void)
{
#ifdef TRACING
	printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc) != 0x7f, jiffies);
#endif
	return inb_p(dtlk_port_lpc) != 0x7f;
}

static int dtlk_writeable(void)
{
	/* TRACE_TEXT(" dtlk_writeable"); */
#ifdef TRACINGMORE
	printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts) & TTS_WRITABLE)!=0);
#endif
	return inb_p(dtlk_port_tts) & TTS_WRITABLE;
}

static int __init dtlk_dev_probe(void)
{
	unsigned int testval = 0;
	int i = 0;
	struct dtlk_settings *sp;

	if (dtlk_port_lpc | dtlk_port_tts)
		return -EBUSY;

	for (i = 0; dtlk_portlist[i]; i++) {
#if 0
		printk("DoubleTalk PC - Port %03x = %04x\n",
		       dtlk_portlist[i], (testval = inw_p(dtlk_portlist[i])));
#endif

		if (!request_region(dtlk_portlist[i], DTLK_IO_EXTENT, 
			       "dtlk"))
			continue;
		testval = inw_p(dtlk_portlist[i]);
		if ((testval &= 0xfbff) == 0x107f) {
			dtlk_port_lpc = dtlk_portlist[i];
			dtlk_port_tts = dtlk_port_lpc + 1;

			sp = dtlk_interrogate();
			printk("DoubleTalk PC at %03x-%03x, "
			       "ROM version %s, serial number %u",
			       dtlk_portlist[i], dtlk_portlist[i] +
			       DTLK_IO_EXTENT - 1,
			       sp->rom_version, sp->serial_number);

                        /* put LPC port into known state, so
			   dtlk_readable() gives valid result */
			outb_p(0xff, dtlk_port_lpc); 

                        /* INIT string and index marker */
			dtlk_write_bytes("\036\1@\0\0012I\r", 8);
			/* posting an index takes 18 msec.  Here, we
			   wait up to 100 msec to see whether it
			   appears. */
			msleep_interruptible(100);
			dtlk_has_indexing = dtlk_readable();
#ifdef TRACING
			printk(", indexing %d\n", dtlk_has_indexing);
#endif
#ifdef INSCOPE
			{
/* This macro records ten samples read from the LPC port, for later display */
#define LOOK					\
for (i = 0; i < 10; i++)			\
  {						\
    buffer[b++] = inb_p(dtlk_port_lpc);		\
    __delay(loops_per_jiffy/(1000000/HZ));             \
  }
				char buffer[1000];
				int b = 0, i, j;

				LOOK
				outb_p(0xff, dtlk_port_lpc);
				buffer[b++] = 0;
				LOOK
				dtlk_write_bytes("\0012I\r", 4);
				buffer[b++] = 0;
				__delay(50 * loops_per_jiffy / (1000/HZ));
				outb_p(0xff, dtlk_port_lpc);
				buffer[b++] = 0;
				LOOK

				printk("\n");
				for (j = 0; j < b; j++)
					printk(" %02x", buffer[j]);
				printk("\n");
			}
#endif				/* INSCOPE */

#ifdef OUTSCOPE
			{
/* This macro records ten samples read from the TTS port, for later display */
#define LOOK					\
for (i = 0; i < 10; i++)			\
  {						\
    buffer[b++] = inb_p(dtlk_port_tts);		\
    __delay(loops_per_jiffy/(1000000/HZ));  /* 1 us */ \
  }
				char buffer[1000];
				int b = 0, i, j;

				mdelay(10);	/* 10 ms */
				LOOK
				outb_p(0x03, dtlk_port_tts);
				buffer[b++] = 0;
				LOOK
				LOOK

				printk("\n");
				for (j = 0; j < b; j++)
					printk(" %02x", buffer[j]);
				printk("\n");
			}
#endif				/* OUTSCOPE */

			dtlk_write_bytes("Double Talk found", 18);

			return 0;
		}
		release_region(dtlk_portlist[i], DTLK_IO_EXTENT);
	}

	printk(KERN_INFO "DoubleTalk PC - not found\n");
	return -ENODEV;
}

/*
   static void dtlk_handle_error(char op, char rc, unsigned int minor)
   {
   printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n", 
   minor, op, rc);
   return;
   }
 */

/* interrogate the DoubleTalk PC and return its settings */
static struct dtlk_settings *dtlk_interrogate(void)
{
	unsigned char *t;
	static char buf[sizeof(struct dtlk_settings) + 1];
	int total, i;
	static struct dtlk_settings status;
	TRACE_TEXT("(dtlk_interrogate");
	dtlk_write_bytes("\030\001?", 3);
	for (total = 0, i = 0; i < 50; i++) {
		buf[total] = dtlk_read_tts();
		if (total > 2 && buf[total] == 0x7f)
			break;
		if (total < sizeof(struct dtlk_settings))
			total++;
	}
	/*
	   if (i==50) printk("interrogate() read overrun\n");
	   for (i=0; i<sizeof(buf); i++)
	   printk(" %02x", buf[i]);
	   printk("\n");
	 */
	t = buf;
	status.serial_number = t[0] + t[1] * 256; /* serial number is
						     little endian */
	t += 2;

	i = 0;
	while (*t != '\r') {
		status.rom_version[i] = *t;
		if (i < sizeof(status.rom_version) - 1)
			i++;
		t++;
	}
	status.rom_version[i] = 0;
	t++;

	status.mode = *t++;
	status.punc_level = *t++;
	status.formant_freq = *t++;
	status.pitch = *t++;
	status.speed = *t++;
	status.volume = *t++;
	status.tone = *t++;
	status.expression = *t++;
	status.ext_dict_loaded = *t++;
	status.ext_dict_status = *t++;
	status.free_ram = *t++;
	status.articulation = *t++;
	status.reverb = *t++;
	status.eob = *t++;
	status.has_indexing = dtlk_has_indexing;
	TRACE_RET;
	return &status;
}

static char dtlk_read_tts(void)
{
	int portval, retries = 0;
	char ch;
	TRACE_TEXT("(dtlk_read_tts");

	/* verify DT is ready, read char, wait for ACK */
	do {
		portval = inb_p(dtlk_port_tts);
	} while ((portval & TTS_READABLE) == 0 &&
		 retries++ < DTLK_MAX_RETRIES);
	if (retries == DTLK_MAX_RETRIES)
		printk(KERN_ERR "dtlk_read_tts() timeout\n");

	ch = inb_p(dtlk_port_tts);	/* input from TTS port */
	ch &= 0x7f;
	outb_p(ch, dtlk_port_tts);

	retries = 0;
	do {
		portval = inb_p(dtlk_port_tts);
	} while ((portval & TTS_READABLE) != 0 &&
		 retries++ < DTLK_MAX_RETRIES);
	if (retries == DTLK_MAX_RETRIES)
		printk(KERN_ERR "dtlk_read_tts() timeout\n");

	TRACE_RET;
	return ch;
}

static char dtlk_read_lpc(void)
{
	int retries = 0;
	char ch;
	TRACE_TEXT("(dtlk_read_lpc");

	/* no need to test -- this is only called when the port is readable */

	ch = inb_p(dtlk_port_lpc);	/* input from LPC port */

	outb_p(0xff, dtlk_port_lpc);

	/* acknowledging a read takes 3-4
	   usec.  Here, we wait up to 20 usec
	   for the acknowledgement */
	retries = (loops_per_jiffy * 20) / (1000000/HZ);
	while (inb_p(dtlk_port_lpc) != 0x7f && --retries > 0);
	if (retries == 0)
		printk(KERN_ERR "dtlk_read_lpc() timeout\n");

	TRACE_RET;
	return ch;
}

/* write n bytes to tts port */
static char dtlk_write_bytes(const char *buf, int n)
{
	char val = 0;
	/*  printk("dtlk_write_bytes(\"%-*s\", %d)\n", n, buf, n); */
	TRACE_TEXT("(dtlk_write_bytes");
	while (n-- > 0)
		val = dtlk_write_tts(*buf++);
	TRACE_RET;
	return val;
}

static char dtlk_write_tts(char ch)
{
	int retries = 0;
#ifdef TRACINGMORE
	printk("  dtlk_write_tts(");
	if (' ' <= ch && ch <= '~')
		printk("'%c'", ch);
	else
		printk("0x%02x", ch);
#endif
	if (ch != DTLK_CLEAR)	/* no flow control for CLEAR command */
		while ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0 &&
		       retries++ < DTLK_MAX_RETRIES)	/* DT ready? */
			;
	if (retries == DTLK_MAX_RETRIES)
		printk(KERN_ERR "dtlk_write_tts() timeout\n");

	outb_p(ch, dtlk_port_tts);	/* output to TTS port */
	/* the RDY bit goes zero 2-3 usec after writing, and goes
	   1 again 180-190 usec later.  Here, we wait up to 10
	   usec for the RDY bit to go zero. */
	for (retries = 0; retries < loops_per_jiffy / (100000/HZ); retries++)
		if ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0)
			break;

#ifdef TRACINGMORE
	printk(")\n");
#endif
	return 0;
}

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	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>
e49332bd	55	#include <linux/mm.h>
1da177e4 LT	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 */
1da177e4 LT	65	#include <linux/smp_lock.h>
	66
	67	#ifdef TRACING
	68	#define TRACE_TEXT(str) printk(str);
	69	#define TRACE_RET printk(")")
	70	#else /* !TRACING */
	71	#define TRACE_TEXT(str) ((void) 0)
	72	#define TRACE_RET ((void) 0)
	73	#endif /* TRACING */
	74
	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 struct timer_list dtlk_timer;
	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
62322d25	97	static const struct file_operations dtlk_fops =
1da177e4 LT	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	static void dtlk_timer_tick(unsigned long data);
	121
	122	static ssize_t dtlk_read(struct file file, char __user buf,
	123	size_t count, loff_t * ppos)
	124	{
	125	unsigned int minor = iminor(file->f_dentry->d_inode);
	126	char ch;
	127	int i = 0, retries;
	128
	129	TRACE_TEXT("(dtlk_read");
	130	/* printk("DoubleTalk PC - dtlk_read()\n"); */
	131
	132	if (minor != DTLK_MINOR \|\| !dtlk_has_indexing)
	133	return -EINVAL;
	134
	135	for (retries = 0; retries < loops_per_jiffy; retries++) {
	136	while (i < count && dtlk_readable()) {
	137	ch = dtlk_read_lpc();
	138	/* printk("dtlk_read() reads 0x%02x\n", ch); */
	139	if (put_user(ch, buf++))
	140	return -EFAULT;
	141	i++;
	142	}
	143	if (i)
	144	return i;
	145	if (file->f_flags & O_NONBLOCK)
	146	break;
	147	msleep_interruptible(100);
	148	}
	149	if (retries == loops_per_jiffy)
	150	printk(KERN_ERR "dtlk_read times out\n");
	151	TRACE_RET;
	152	return -EAGAIN;
	153	}
	154
	155	static ssize_t dtlk_write(struct file file, const char __user buf,
	156	size_t count, loff_t * ppos)
	157	{
	158	int i = 0, retries = 0, ch;
	159
	160	TRACE_TEXT("(dtlk_write");
	161	#ifdef TRACING
162	printk(" \"");
163	{
164	int i, ch;
165	for (i = 0; i < count; i++) {
166	if (get_user(ch, buf + i))
167	return -EFAULT;
168	if (' ' <= ch && ch <= '~')
169	printk("%c", ch);
170	else
171	printk("\\%03o", ch);
172	}
173	printk("\"");
174	}
175	#endif
176
177	if (iminor(file->f_dentry->d_inode) != DTLK_MINOR)
178	return -EINVAL;
179
180	while (1) {
181	while (i < count && !get_user(ch, buf) &&
182	(ch == DTLK_CLEAR \|\| dtlk_writeable())) {
183	dtlk_write_tts(ch);
184	buf++;
185	i++;
186	if (i % 5 == 0)
187	/* We yield our time until scheduled
188	again. This reduces the transfer
189	rate to 500 bytes/sec, but that's
190	still enough to keep up with the
191	speech synthesizer. */
192	msleep_interruptible(1);
193	else {
194	/* the RDY bit goes zero 2-3 usec
195	after writing, and goes 1 again
196	180-190 usec later. Here, we wait
197	up to 250 usec for the RDY bit to
198	go nonzero. */
199	for (retries = 0;
200	retries < loops_per_jiffy / (4000/HZ);
201	retries++)
202	if (inb_p(dtlk_port_tts) &
203	TTS_WRITABLE)
204	break;
205	}
206	retries = 0;
207	}
208	if (i == count)
209	return i;
210	if (file->f_flags & O_NONBLOCK)
211	break;
212
213	msleep_interruptible(1);
214
215	if (++retries > 10 * HZ) { /* wait no more than 10 sec
216	from last write */
217	printk("dtlk: write timeout. "
218	"inb_p(dtlk_port_tts) = 0x%02x\n",
219	inb_p(dtlk_port_tts));
220	TRACE_RET;
221	return -EBUSY;
222	}
223	}
224	TRACE_RET;
225	return -EAGAIN;
226	}
227
228	static unsigned int dtlk_poll(struct file file, poll_table wait)
229	{
230	int mask = 0;
231	unsigned long expires;
232
233	TRACE_TEXT(" dtlk_poll");
234	/*
235	static long int j;
236	printk(".");
237	printk("<%ld>", jiffies-j);
238	j=jiffies;
239	*/
240	poll_wait(file, &dtlk_process_list, wait);
241
242	if (dtlk_has_indexing && dtlk_readable()) {
243	del_timer(&dtlk_timer);
244	mask = POLLIN \| POLLRDNORM;
245	}
246	if (dtlk_writeable()) {
247	del_timer(&dtlk_timer);
248	mask \|= POLLOUT \| POLLWRNORM;
249	}
250	/* there are no exception conditions */
251
252	/* There won't be any interrupts, so we set a timer instead. */
253	expires = jiffies + 3*HZ / 100;
254	mod_timer(&dtlk_timer, expires);
255
256	return mask;
257	}
258
259	static void dtlk_timer_tick(unsigned long data)
260	{
261	TRACE_TEXT(" dtlk_timer_tick");
262	wake_up_interruptible(&dtlk_process_list);
263	}
264
265	static int dtlk_ioctl(struct inode *inode,
266	struct file *file,
267	unsigned int cmd,
268	unsigned long arg)
269	{
270	char __user argp = (char __user )arg;
271	struct dtlk_settings *sp;
272	char portval;
273	TRACE_TEXT(" dtlk_ioctl");
274
275	switch (cmd) {
276
277	case DTLK_INTERROGATE:
278	sp = dtlk_interrogate();
279	if (copy_to_user(argp, sp, sizeof(struct dtlk_settings)))
280	return -EINVAL;
281	return 0;
282
283	case DTLK_STATUS:
284	portval = inb_p(dtlk_port_tts);
285	return put_user(portval, argp);
286
287	default:
288	return -EINVAL;
289	}
290	}
291
292	static int dtlk_open(struct inode inode, struct file file)
293	{
294	TRACE_TEXT("(dtlk_open");
295
296	nonseekable_open(inode, file);
297	switch (iminor(inode)) {
298	case DTLK_MINOR:
299	if (dtlk_busy)
300	return -EBUSY;
301	return nonseekable_open(inode, file);
302
303	default:
304	return -ENXIO;
305	}
306	}
307
308	static int dtlk_release(struct inode inode, struct file file)
309	{
310	TRACE_TEXT("(dtlk_release");
311
312	switch (iminor(inode)) {
313	case DTLK_MINOR:
314	break;
315
316	default:
317	break;
318	}
319	TRACE_RET;
320
321	del_timer(&dtlk_timer);
322
323	return 0;
324	}
325
326	static int __init dtlk_init(void)
327	{
328	dtlk_port_lpc = 0;
329	dtlk_port_tts = 0;
330	dtlk_busy = 0;
331	dtlk_major = register_chrdev(0, "dtlk", &dtlk_fops);
332	if (dtlk_major == 0) {
333	printk(KERN_ERR "DoubleTalk PC - cannot register device\n");
334	return 0;
335	}
336	if (dtlk_dev_probe() == 0)
337	printk(", MAJOR %d\n", dtlk_major);
338
1da177e4 LT	339	init_timer(&dtlk_timer);
	340	dtlk_timer.function = dtlk_timer_tick;
	341	init_waitqueue_head(&dtlk_process_list);
	342
	343	return 0;
	344	}
	345
	346	static void __exit dtlk_cleanup (void)
	347	{
	348	dtlk_write_bytes("goodbye", 8);
	349	msleep_interruptible(500); /* nap 0.50 sec but
	350	could be awakened
	351	earlier by
	352	signals... */
	353
	354	dtlk_write_tts(DTLK_CLEAR);
	355	unregister_chrdev(dtlk_major, "dtlk");
1da177e4 LT	356	release_region(dtlk_port_lpc, DTLK_IO_EXTENT);
	357	}
	358
	359	module_init(dtlk_init);
	360	module_exit(dtlk_cleanup);
	361
	362	/* ------------------------------------------------------------------------ */
	363
	364	static int dtlk_readable(void)
	365	{
	366	#ifdef TRACING
	367	printk(" dtlk_readable=%u@%u", inb_p(dtlk_port_lpc) != 0x7f, jiffies);
	368	#endif
	369	return inb_p(dtlk_port_lpc) != 0x7f;
	370	}
	371
	372	static int dtlk_writeable(void)
	373	{
	374	/* TRACE_TEXT(" dtlk_writeable"); */
	375	#ifdef TRACINGMORE
	376	printk(" dtlk_writeable=%u", (inb_p(dtlk_port_tts) & TTS_WRITABLE)!=0);
	377	#endif
	378	return inb_p(dtlk_port_tts) & TTS_WRITABLE;
	379	}
	380
	381	static int __init dtlk_dev_probe(void)
	382	{
	383	unsigned int testval = 0;
	384	int i = 0;
	385	struct dtlk_settings *sp;
	386
	387	if (dtlk_port_lpc \| dtlk_port_tts)
	388	return -EBUSY;
	389
	390	for (i = 0; dtlk_portlist[i]; i++) {
	391	#if 0
	392	printk("DoubleTalk PC - Port %03x = %04x\n",
	393	dtlk_portlist[i], (testval = inw_p(dtlk_portlist[i])));
	394	#endif
	395
	396	if (!request_region(dtlk_portlist[i], DTLK_IO_EXTENT,
	397	"dtlk"))
	398	continue;
	399	testval = inw_p(dtlk_portlist[i]);
	400	if ((testval &= 0xfbff) == 0x107f) {
	401	dtlk_port_lpc = dtlk_portlist[i];
	402	dtlk_port_tts = dtlk_port_lpc + 1;
	403
	404	sp = dtlk_interrogate();
	405	printk("DoubleTalk PC at %03x-%03x, "
	406	"ROM version %s, serial number %u",
	407	dtlk_portlist[i], dtlk_portlist[i] +
	408	DTLK_IO_EXTENT - 1,
	409	sp->rom_version, sp->serial_number);
	410
	411	/* put LPC port into known state, so
	412	dtlk_readable() gives valid result */
	413	outb_p(0xff, dtlk_port_lpc);
	414
	415	/* INIT string and index marker */
	416	dtlk_write_bytes("\036\1@\0\0012I\r", 8);
	417	/* posting an index takes 18 msec. Here, we
	418	wait up to 100 msec to see whether it
	419	appears. */
420	msleep_interruptible(100);
421	dtlk_has_indexing = dtlk_readable();
422	#ifdef TRACING
423	printk(", indexing %d\n", dtlk_has_indexing);
424	#endif
425	#ifdef INSCOPE
426	{
427	/* This macro records ten samples read from the LPC port, for later display */
428	#define LOOK \
429	for (i = 0; i < 10; i++) \
430	{ \
431	buffer[b++] = inb_p(dtlk_port_lpc); \
432	__delay(loops_per_jiffy/(1000000/HZ)); \
433	}
434	char buffer[1000];
435	int b = 0, i, j;
436
437	LOOK
438	outb_p(0xff, dtlk_port_lpc);
439	buffer[b++] = 0;
440	LOOK
441	dtlk_write_bytes("\0012I\r", 4);
442	buffer[b++] = 0;
443	__delay(50 * loops_per_jiffy / (1000/HZ));
444	outb_p(0xff, dtlk_port_lpc);
445	buffer[b++] = 0;
446	LOOK
447
448	printk("\n");
449	for (j = 0; j < b; j++)
450	printk(" %02x", buffer[j]);
451	printk("\n");
452	}
453	#endif /* INSCOPE */
454
455	#ifdef OUTSCOPE
456	{
457	/* This macro records ten samples read from the TTS port, for later display */
458	#define LOOK \
459	for (i = 0; i < 10; i++) \
460	{ \
461	buffer[b++] = inb_p(dtlk_port_tts); \
462	__delay(loops_per_jiffy/(1000000/HZ)); /* 1 us */ \
463	}
464	char buffer[1000];
465	int b = 0, i, j;
466
467	mdelay(10); /* 10 ms */
468	LOOK
469	outb_p(0x03, dtlk_port_tts);
470	buffer[b++] = 0;
471	LOOK
472	LOOK
473
474	printk("\n");
475	for (j = 0; j < b; j++)
476	printk(" %02x", buffer[j]);
477	printk("\n");
478	}
479	#endif /* OUTSCOPE */
480
481	dtlk_write_bytes("Double Talk found", 18);
482
483	return 0;
484	}
485	release_region(dtlk_portlist[i], DTLK_IO_EXTENT);
486	}
487
49b6e2ad	488	printk(KERN_INFO "DoubleTalk PC - not found\n");
1da177e4 LT	489	return -ENODEV;
	490	}
	491
	492	/*
	493	static void dtlk_handle_error(char op, char rc, unsigned int minor)
	494	{
	495	printk(KERN_INFO"\nDoubleTalk PC - MINOR: %d, OPCODE: %d, ERROR: %d\n",
	496	minor, op, rc);
	497	return;
	498	}
	499	*/
	500
	501	/* interrogate the DoubleTalk PC and return its settings */
	502	static struct dtlk_settings *dtlk_interrogate(void)
	503	{
	504	unsigned char *t;
	505	static char buf[sizeof(struct dtlk_settings) + 1];
	506	int total, i;
	507	static struct dtlk_settings status;
	508	TRACE_TEXT("(dtlk_interrogate");
	509	dtlk_write_bytes("\030\001?", 3);
	510	for (total = 0, i = 0; i < 50; i++) {
	511	buf[total] = dtlk_read_tts();
	512	if (total > 2 && buf[total] == 0x7f)
	513	break;
	514	if (total < sizeof(struct dtlk_settings))
	515	total++;
	516	}
	517	/*
	518	if (i==50) printk("interrogate() read overrun\n");
	519	for (i=0; i<sizeof(buf); i++)
	520	printk(" %02x", buf[i]);
	521	printk("\n");
	522	*/
	523	t = buf;
	524	status.serial_number = t[0] + t[1] * 256; /* serial number is
	525	little endian */
	526	t += 2;
	527
	528	i = 0;
	529	while (*t != '\r') {
	530	status.rom_version[i] = *t;
	531	if (i < sizeof(status.rom_version) - 1)
	532	i++;
	533	t++;
	534	}
	535	status.rom_version[i] = 0;
	536	t++;
	537
	538	status.mode = *t++;
	539	status.punc_level = *t++;
	540	status.formant_freq = *t++;
	541	status.pitch = *t++;
	542	status.speed = *t++;
	543	status.volume = *t++;
	544	status.tone = *t++;
	545	status.expression = *t++;
	546	status.ext_dict_loaded = *t++;
	547	status.ext_dict_status = *t++;
	548	status.free_ram = *t++;
	549	status.articulation = *t++;
	550	status.reverb = *t++;
	551	status.eob = *t++;
	552	status.has_indexing = dtlk_has_indexing;
553	TRACE_RET;
554	return &status;
555	}
556
557	static char dtlk_read_tts(void)
558	{
559	int portval, retries = 0;
560	char ch;
561	TRACE_TEXT("(dtlk_read_tts");
562
563	/* verify DT is ready, read char, wait for ACK */
564	do {
565	portval = inb_p(dtlk_port_tts);
566	} while ((portval & TTS_READABLE) == 0 &&
567	retries++ < DTLK_MAX_RETRIES);
568	if (retries == DTLK_MAX_RETRIES)
569	printk(KERN_ERR "dtlk_read_tts() timeout\n");
570
571	ch = inb_p(dtlk_port_tts); /* input from TTS port */
572	ch &= 0x7f;
573	outb_p(ch, dtlk_port_tts);
574
575	retries = 0;
576	do {
577	portval = inb_p(dtlk_port_tts);
578	} while ((portval & TTS_READABLE) != 0 &&
579	retries++ < DTLK_MAX_RETRIES);
580	if (retries == DTLK_MAX_RETRIES)
581	printk(KERN_ERR "dtlk_read_tts() timeout\n");
582
583	TRACE_RET;
584	return ch;
585	}
586
587	static char dtlk_read_lpc(void)
588	{
589	int retries = 0;
590	char ch;
591	TRACE_TEXT("(dtlk_read_lpc");
592
593	/* no need to test -- this is only called when the port is readable */
594
595	ch = inb_p(dtlk_port_lpc); /* input from LPC port */
596
597	outb_p(0xff, dtlk_port_lpc);
598
599	/* acknowledging a read takes 3-4
600	usec. Here, we wait up to 20 usec
601	for the acknowledgement */
602	retries = (loops_per_jiffy * 20) / (1000000/HZ);
603	while (inb_p(dtlk_port_lpc) != 0x7f && --retries > 0);
604	if (retries == 0)
605	printk(KERN_ERR "dtlk_read_lpc() timeout\n");
606
607	TRACE_RET;
608	return ch;
609	}
610
611	/* write n bytes to tts port */
612	static char dtlk_write_bytes(const char *buf, int n)
613	{
614	char val = 0;
615	/* printk("dtlk_write_bytes(\"%-s\", %d)\n", n, buf, n); /
616	TRACE_TEXT("(dtlk_write_bytes");
617	while (n-- > 0)
618	val = dtlk_write_tts(*buf++);
619	TRACE_RET;
620	return val;
621	}
622
623	static char dtlk_write_tts(char ch)
624	{
625	int retries = 0;
626	#ifdef TRACINGMORE
627	printk(" dtlk_write_tts(");
628	if (' ' <= ch && ch <= '~')
629	printk("'%c'", ch);
630	else
631	printk("0x%02x", ch);
632	#endif
633	if (ch != DTLK_CLEAR) /* no flow control for CLEAR command */
634	while ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0 &&
635	retries++ < DTLK_MAX_RETRIES) /* DT ready? */
636	;
637	if (retries == DTLK_MAX_RETRIES)
638	printk(KERN_ERR "dtlk_write_tts() timeout\n");
639
640	outb_p(ch, dtlk_port_tts); /* output to TTS port */
641	/* the RDY bit goes zero 2-3 usec after writing, and goes
642	1 again 180-190 usec later. Here, we wait up to 10
643	usec for the RDY bit to go zero. */
644	for (retries = 0; retries < loops_per_jiffy / (100000/HZ); retries++)
645	if ((inb_p(dtlk_port_tts) & TTS_WRITABLE) == 0)
646	break;
647
648	#ifdef TRACINGMORE
649	printk(")\n");
650	#endif
651	return 0;
652	}
653
654	MODULE_LICENSE("GPL");