dtlk.c

powerpc内核mpc8241linux系统下char驱动程序

/*                                              -*- linux-c -*-
 * dtlk.c - DoubleTalk PC driver for Linux kernel 2.0.29
 * 
 * $Id: dtlk.c,v 1.19 1999/02/28 12:13:13 jrv Exp jrv $
 *
 * Original author: Chris Pallotta <[e-mail]>
 * Current maintainer: Jim Van Zandt <[e-mail]>
 */

/* 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.

 */

#ifdef MODVERSIONS
#include <linux/modversions.h>
#endif

#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#else
#define MOD_INC_USE_COUNT
#define MOD_DEC_USE_COUNT
#endif

#define KERNEL
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>		/* for verify_area */
#include <linux/errno.h>	/* for -EBUSY */
#include <linux/ioport.h>	/* for check_region, request_region */
#include <linux/delay.h>	/* for loops_per_sec */
#include <asm/segment.h>	/* for put_user_byte */
#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 */
#include <linux/poll.h>		/* for POLLIN, etc. */
#include <linux/dtlk.h>		/* local header file for DoubleTalk values */

#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_timer_active;
static int dtlk_has_indexing;
static unsigned int dtlk_portlist[] =
{0x25e, 0x29e, 0x2de, 0x31e, 0x35e, 0x39e, 0};
static struct wait_queue *dtlk_process_list = NULL;
static struct timer_list dtlk_timer;

/* prototypes for file_operations struct */
static ssize_t dtlk_read(struct file *, char *,
			 size_t nbytes, loff_t * ppos);
static ssize_t dtlk_write(struct file *, const char *,
			  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 struct file_operations dtlk_fops =
{
	NULL,			/* lseek */
	dtlk_read,
	dtlk_write,
	NULL,			/* readdir */
	dtlk_poll,
	dtlk_ioctl,
	NULL,			/* mmap */
	dtlk_open,
	NULL,			/* flush */
	dtlk_release,
	NULL,			/* fsync */
	NULL,			/* fasync */
	NULL,			/* check_media_change */
	NULL,			/* revalidate */
	NULL			/* lock */
};

/* local prototypes */
static void dtlk_delay(int ms);
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 void dtlk_stop_timer(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 char dtlk_write_byte(unsigned int, const char*);
 */
static void dtlk_timer_tick(unsigned long data);

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

	/* Can't seek (pread) on the DoubleTalk.  */
	if (ppos != &file->f_pos)
		return -ESPIPE;

	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_sec / 10; retries++) {
		while (i < count && dtlk_readable()) {
			ch = dtlk_read_lpc();
			/*        printk("dtlk_read() reads 0x%02x\n", ch); */
			if ((retval = put_user(ch, buf++)))
				return retval;
			i++;
		}
		if (i)
			return i;
		if (file->f_flags & O_NONBLOCK)
			break;
		dtlk_delay(10);
	}
	if (retries == loops_per_sec)
		printk(KERN_ERR "dtlk_read times out\n");
	TRACE_RET;
	return -EAGAIN;
}

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

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

	/* Can't seek (pwrite) on the DoubleTalk.  */
	if (ppos != &file->f_pos)
		return -ESPIPE;

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

	while (1) {
		while (i < count && (err = get_user(ch, buf)) == 0 &&
		       (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. */
				dtlk_delay(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_sec / 4000;
				     retries++)
					if (inb_p(dtlk_port_tts) &
					    TTS_WRITABLE)
						break;
			}
			retries = 0;
		}
		if (i == count)
			return i;
		if (file->f_flags & O_NONBLOCK)
			break;

		dtlk_delay(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;
	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()) {
		dtlk_stop_timer();
		mask = POLLIN | POLLRDNORM;
	}
	if (dtlk_writeable()) {
		dtlk_stop_timer();
		mask |= POLLOUT | POLLWRNORM;
	}
	/* there are no exception conditions */

	if (mask == 0 && !dtlk_timer_active) {
		/* not ready just yet.  There won't be any interrupts,
		   so we set a timer instead. */
		dtlk_timer_active = 1;
		dtlk_timer.expires = jiffies + HZ / 100;
		add_timer(&dtlk_timer);
	}
	return 0;
}

static void dtlk_stop_timer()
{
	if (dtlk_timer_active) {
		dtlk_timer_active = 0;
		del_timer(&dtlk_timer);
	}
}

static void dtlk_timer_tick(unsigned long data)
{

	wake_up_interruptible(&dtlk_process_list);

	if (dtlk_timer_active) {
		del_timer(&dtlk_timer);
		dtlk_timer.expires = jiffies + HZ / 100;
		add_timer(&dtlk_timer);
	}
}

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

	switch (cmd) {

	case DTLK_INTERROGATE:
		sp = dtlk_interrogate();
		err = copy_to_user((char *) arg, (char *) sp,
				   sizeof(struct dtlk_settings));
		if (err)
			return -EINVAL;
		return 0;

	case DTLK_STATUS:
		portval = inb_p(dtlk_port_tts);
		return put_user(portval, (char *) arg);

	default:
		return -EINVAL;
	}
}

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

	switch (MINOR(inode->i_rdev)) {
	case DTLK_MINOR:
		if (dtlk_busy)
			return -EBUSY;
		return 0;

	default:
		return -ENXIO;
	}
}

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

	switch (MINOR(inode->i_rdev)) {
	case DTLK_MINOR:
		break;

	default:
		break;
	}