[linux.git] / drivers / char / dsp56k.c

/*
 * The DSP56001 Device Driver, saviour of the Free World(tm)
 *
 * Authors: Fredrik Noring   <[email protected]>
 *          lars brinkhoff   <[email protected]>
 *          Tomas Berndtsson <[email protected]>
 *
 * First version May 1996
 *
 * History:
 *  97-01-29   Tomas Berndtsson,
 *               Integrated with Linux 2.1.21 kernel sources.
 *  97-02-15   Tomas Berndtsson,
 *               Fixed for kernel 2.1.26
 *
 * BUGS:
 *  Hmm... there must be something here :)
 *
 * Copyright (C) 1996,1997 Fredrik Noring, lars brinkhoff & Tomas Berndtsson
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file COPYING in the main directory of this archive
 * for more details.
 */

#include <linux/module.h>
#include <linux/slab.h>	/* for kmalloc() and kfree() */
#include <linux/major.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/delay.h>	/* guess what */
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/init.h>
#include <linux/device.h>

#include <asm/atarihw.h>
#include <asm/traps.h>
#include <asm/uaccess.h>	/* For put_user and get_user */

#include <asm/dsp56k.h>

/* minor devices */
#define DSP56K_DEV_56001        0    /* The only device so far */

#define TIMEOUT    10   /* Host port timeout in number of tries */
#define MAXIO    2048   /* Maximum number of words before sleep */
#define DSP56K_MAX_BINARY_LENGTH (3*64*1024)

#define DSP56K_TX_INT_ON	dsp56k_host_interface.icr |=  DSP56K_ICR_TREQ
#define DSP56K_RX_INT_ON	dsp56k_host_interface.icr |=  DSP56K_ICR_RREQ
#define DSP56K_TX_INT_OFF	dsp56k_host_interface.icr &= ~DSP56K_ICR_TREQ
#define DSP56K_RX_INT_OFF	dsp56k_host_interface.icr &= ~DSP56K_ICR_RREQ

#define DSP56K_TRANSMIT		(dsp56k_host_interface.isr & DSP56K_ISR_TXDE)
#define DSP56K_RECEIVE		(dsp56k_host_interface.isr & DSP56K_ISR_RXDF)

#define handshake(count, maxio, timeout, ENABLE, f) \
{ \
	long i, t, m; \
	while (count > 0) { \
		m = min_t(unsigned long, count, maxio); \
		for (i = 0; i < m; i++) { \
			for (t = 0; t < timeout && !ENABLE; t++) \
				msleep(20); \
			if(!ENABLE) \
				return -EIO; \
			f; \
		} \
		count -= m; \
		if (m == maxio) msleep(20); \
	} \
}

#define tx_wait(n) \
{ \
	int t; \
	for(t = 0; t < n && !DSP56K_TRANSMIT; t++) \
		msleep(10); \
	if(!DSP56K_TRANSMIT) { \
		return -EIO; \
	} \
}

#define rx_wait(n) \
{ \
	int t; \
	for(t = 0; t < n && !DSP56K_RECEIVE; t++) \
		msleep(10); \
	if(!DSP56K_RECEIVE) { \
		return -EIO; \
	} \
}

/* DSP56001 bootstrap code */
static char bootstrap[] = {
	0x0c, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x60, 0xf4, 0x00, 0x00, 0x00, 0x4f, 0x61, 0xf4,
	0x00, 0x00, 0x7e, 0xa9, 0x06, 0x2e, 0x80, 0x00, 0x00, 0x47,
	0x07, 0xd8, 0x84, 0x07, 0x59, 0x84, 0x08, 0xf4, 0xa8, 0x00,
	0x00, 0x04, 0x08, 0xf4, 0xbf, 0x00, 0x0c, 0x00, 0x00, 0xfe,
	0xb8, 0x0a, 0xf0, 0x80, 0x00, 0x7e, 0xa9, 0x08, 0xf4, 0xa0,
	0x00, 0x00, 0x01, 0x08, 0xf4, 0xbe, 0x00, 0x00, 0x00, 0x0a,
	0xa9, 0x80, 0x00, 0x7e, 0xad, 0x08, 0x4e, 0x2b, 0x44, 0xf4,
	0x00, 0x00, 0x00, 0x03, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x01,
	0x0e, 0xa0, 0x00, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb5, 0x08,
	0x50, 0x2b, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb8, 0x08, 0x46,
	0x2b, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x02, 0x0a, 0xf0, 0xaa,
	0x00, 0x7e, 0xc9, 0x20, 0x00, 0x45, 0x0a, 0xf0, 0xaa, 0x00,
	0x7e, 0xd0, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xc6, 0x0a, 0xa9,
	0x80, 0x00, 0x7e, 0xc4, 0x08, 0x58, 0x6b, 0x0a, 0xf0, 0x80,
	0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xcd, 0x0a,
	0xa9, 0x80, 0x00, 0x7e, 0xcb, 0x08, 0x58, 0xab, 0x0a, 0xf0,
	0x80, 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xd4,
	0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xd2, 0x08, 0x58, 0xeb, 0x0a,
	0xf0, 0x80, 0x00, 0x7e, 0xad};
static int sizeof_bootstrap = 375;


static struct dsp56k_device {
	long in_use;
	long maxio, timeout;
	int tx_wsize, rx_wsize;
} dsp56k;

static struct class *dsp56k_class;

static int dsp56k_reset(void)
{
	u_char status;
	
	/* Power down the DSP */
	sound_ym.rd_data_reg_sel = 14;
	status = sound_ym.rd_data_reg_sel & 0xef;
	sound_ym.wd_data = status;
	sound_ym.wd_data = status | 0x10;
  
	udelay(10);
  
	/* Power up the DSP */
	sound_ym.rd_data_reg_sel = 14;
	sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;

	return 0;
}

static int dsp56k_upload(u_char __user *bin, int len)
{
	int i;
	u_char *p;
	
	dsp56k_reset();
  
	p = bootstrap;
	for (i = 0; i < sizeof_bootstrap/3; i++) {
		/* tx_wait(10); */
		dsp56k_host_interface.data.b[1] = *p++;
		dsp56k_host_interface.data.b[2] = *p++;
		dsp56k_host_interface.data.b[3] = *p++;
	}
	for (; i < 512; i++) {
		/* tx_wait(10); */
		dsp56k_host_interface.data.b[1] = 0;
		dsp56k_host_interface.data.b[2] = 0;
		dsp56k_host_interface.data.b[3] = 0;
	}
  
	for (i = 0; i < len; i++) {
		tx_wait(10);
		get_user(dsp56k_host_interface.data.b[1], bin++);
		get_user(dsp56k_host_interface.data.b[2], bin++);
		get_user(dsp56k_host_interface.data.b[3], bin++);
	}

	tx_wait(10);
	dsp56k_host_interface.data.l = 3;    /* Magic execute */

	return 0;
}

static ssize_t dsp56k_read(struct file *file, char __user *buf, size_t count,
			   loff_t *ppos)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	int dev = iminor(inode) & 0x0f;

	switch(dev)
	{
	case DSP56K_DEV_56001:
	{

		long n;

		/* Don't do anything if nothing is to be done */
		if (!count) return 0;

		n = 0;
		switch (dsp56k.rx_wsize) {
		case 1:  /* 8 bit */
		{
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
				  put_user(dsp56k_host_interface.data.b[3], buf+n++));
			return n;
		}
		case 2:  /* 16 bit */
		{
			short __user *data;

			count /= 2;
			data = (short __user *) buf;
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
				  put_user(dsp56k_host_interface.data.w[1], data+n++));
			return 2*n;
		}
		case 3:  /* 24 bit */
		{
			count /= 3;
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
				  put_user(dsp56k_host_interface.data.b[1], buf+n++);
				  put_user(dsp56k_host_interface.data.b[2], buf+n++);
				  put_user(dsp56k_host_interface.data.b[3], buf+n++));
			return 3*n;
		}
		case 4:  /* 32 bit */
		{
			long __user *data;

			count /= 4;
			data = (long __user *) buf;
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
				  put_user(dsp56k_host_interface.data.l, data+n++));
			return 4*n;
		}
		}
		return -EFAULT;
	}

	default:
		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
		return -ENXIO;
	}
}

static ssize_t dsp56k_write(struct file *file, const char __user *buf, size_t count,
			    loff_t *ppos)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	int dev = iminor(inode) & 0x0f;

	switch(dev)
	{
	case DSP56K_DEV_56001:
	{
		long n;

		/* Don't do anything if nothing is to be done */
		if (!count) return 0;

		n = 0;
		switch (dsp56k.tx_wsize) {
		case 1:  /* 8 bit */
		{
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
				  get_user(dsp56k_host_interface.data.b[3], buf+n++));
			return n;
		}
		case 2:  /* 16 bit */
		{
			const short __user *data;

			count /= 2;
			data = (const short __user *)buf;
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
				  get_user(dsp56k_host_interface.data.w[1], data+n++));
			return 2*n;
		}
		case 3:  /* 24 bit */
		{
			count /= 3;
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
				  get_user(dsp56k_host_interface.data.b[1], buf+n++);
				  get_user(dsp56k_host_interface.data.b[2], buf+n++);
				  get_user(dsp56k_host_interface.data.b[3], buf+n++));
			return 3*n;
		}
		case 4:  /* 32 bit */
		{
			const long __user *data;

			count /= 4;
			data = (const long __user *)buf;
			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
				  get_user(dsp56k_host_interface.data.l, data+n++));
			return 4*n;
		}
		}

		return -EFAULT;
	}
	default:
		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
		return -ENXIO;
	}
}

static int dsp56k_ioctl(struct inode *inode, struct file *file,
			unsigned int cmd, unsigned long arg)
{
	int dev = iminor(inode) & 0x0f;
	void __user *argp = (void __user *)arg;

	switch(dev)
	{
	case DSP56K_DEV_56001:

		switch(cmd) {
		case DSP56K_UPLOAD:
		{
			char __user *bin;
			int r, len;
			struct dsp56k_upload __user *binary = argp;
    
			if(get_user(len, &binary->len) < 0)
				return -EFAULT;
			if(get_user(bin, &binary->bin) < 0)
				return -EFAULT;
		
			if (len == 0) {
				return -EINVAL;      /* nothing to upload?!? */
			}
			if (len > DSP56K_MAX_BINARY_LENGTH) {
				return -EINVAL;
			}
    
			r = dsp56k_upload(bin, len);
			if (r < 0) {
				return r;
			}
    
			break;
		}
		case DSP56K_SET_TX_WSIZE:
			if (arg > 4 || arg < 1)
				return -EINVAL;
			dsp56k.tx_wsize = (int) arg;
			break;
		case DSP56K_SET_RX_WSIZE:
			if (arg > 4 || arg < 1)
				return -EINVAL;
			dsp56k.rx_wsize = (int) arg;
			break;
		case DSP56K_HOST_FLAGS:
		{
			int dir, out, status;
			struct dsp56k_host_flags __user *hf = argp;
    
			if(get_user(dir, &hf->dir) < 0)
				return -EFAULT;
			if(get_user(out, &hf->out) < 0)
				return -EFAULT;

			if ((dir & 0x1) && (out & 0x1))
				dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
			else if (dir & 0x1)
				dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
			if ((dir & 0x2) && (out & 0x2))
				dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
			else if (dir & 0x2)
				dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;

			status = 0;
			if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
			if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
			if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
			if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;

			return put_user(status, &hf->status);
		}
		case DSP56K_HOST_CMD:
			if (arg > 31 || arg < 0)
				return -EINVAL;
			dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
							     DSP56K_CVR_HC);
			break;
		default:
			return -EINVAL;
		}
		return 0;

	default:
		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
		return -ENXIO;
	}
}

/* As of 2.1.26 this should be dsp56k_poll,
 * but how do I then check device minor number?
 * Do I need this function at all???
 */
#if 0
static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
{
	int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;

	switch(dev)
	{
	case DSP56K_DEV_56001:
		/* poll_wait(file, ???, wait); */
		return POLLIN | POLLRDNORM | POLLOUT;

	default:
		printk("DSP56k driver: Unknown minor device: %d\n", dev);
		return 0;
	}
}
#endif

static int dsp56k_open(struct inode *inode, struct file *file)
{
	int dev = iminor(inode) & 0x0f;

	switch(dev)
	{
	case DSP56K_DEV_56001:

		if (test_and_set_bit(0, &dsp56k.in_use))
			return -EBUSY;

		dsp56k.timeout = TIMEOUT;
		dsp56k.maxio = MAXIO;
		dsp56k.rx_wsize = dsp56k.tx_wsize = 4; 

		DSP56K_TX_INT_OFF;
		DSP56K_RX_INT_OFF;

		/* Zero host flags */
		dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
		dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;

		break;

	default:
		return -ENODEV;
	}

	return 0;
}

static int dsp56k_release(struct inode *inode, struct file *file)
{
	int dev = iminor(inode) & 0x0f;

	switch(dev)
	{
	case DSP56K_DEV_56001:
		clear_bit(0, &dsp56k.in_use);
		break;
	default:
		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
		return -ENXIO;
	}

	return 0;
}

static const struct file_operations dsp56k_fops = {
	.owner		= THIS_MODULE,
	.read		= dsp56k_read,
	.write		= dsp56k_write,
	.ioctl		= dsp56k_ioctl,
	.open		= dsp56k_open,
	.release	= dsp56k_release,
};


/****** Init and module functions ******/

static char banner[] __initdata = KERN_INFO "DSP56k driver installed\n";

static int __init dsp56k_init_driver(void)
{
	int err = 0;

	if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
		printk("DSP56k driver: Hardware not present\n");
		return -ENODEV;
	}

	if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
		printk("DSP56k driver: Unable to register driver\n");
		return -ENODEV;
	}
	dsp56k_class = class_create(THIS_MODULE, "dsp56k");
	if (IS_ERR(dsp56k_class)) {
		err = PTR_ERR(dsp56k_class);
		goto out_chrdev;
	}
	class_device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");

	printk(banner);
	goto out;

out_chrdev:
	unregister_chrdev(DSP56K_MAJOR, "dsp56k");
out:
	return err;
}
module_init(dsp56k_init_driver);

static void __exit dsp56k_cleanup_driver(void)
{
	class_device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
	class_destroy(dsp56k_class);
	unregister_chrdev(DSP56K_MAJOR, "dsp56k");
}
module_exit(dsp56k_cleanup_driver);

MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* The DSP56001 Device Driver, saviour of the Free World(tm)
	3	*
	4	* Authors: Fredrik Noring <[email protected]>
	5	* lars brinkhoff <[email protected]>
	6	* Tomas Berndtsson <[email protected]>
	7	*
	8	* First version May 1996
	9	*
	10	* History:
	11	* 97-01-29 Tomas Berndtsson,
	12	* Integrated with Linux 2.1.21 kernel sources.
	13	* 97-02-15 Tomas Berndtsson,
	14	* Fixed for kernel 2.1.26
	15	*
	16	* BUGS:
	17	* Hmm... there must be something here :)
	18	*
	19	* Copyright (C) 1996,1997 Fredrik Noring, lars brinkhoff & Tomas Berndtsson
	20	*
	21	* This file is subject to the terms and conditions of the GNU General Public
	22	* License. See the file COPYING in the main directory of this archive
	23	* for more details.
	24	*/
	25
	26	#include <linux/module.h>
	27	#include <linux/slab.h> /* for kmalloc() and kfree() */
1da177e4 LT	28	#include <linux/major.h>
	29	#include <linux/types.h>
	30	#include <linux/errno.h>
	31	#include <linux/delay.h> /* guess what */
	32	#include <linux/fs.h>
	33	#include <linux/mm.h>
	34	#include <linux/init.h>
1da177e4 LT	35	#include <linux/device.h>
	36
	37	#include <asm/atarihw.h>
	38	#include <asm/traps.h>
	39	#include <asm/uaccess.h> /* For put_user and get_user */
	40
	41	#include <asm/dsp56k.h>
	42
	43	/* minor devices */
	44	#define DSP56K_DEV_56001 0 /* The only device so far */
	45
	46	#define TIMEOUT 10 /* Host port timeout in number of tries */
	47	#define MAXIO 2048 /* Maximum number of words before sleep */
	48	#define DSP56K_MAX_BINARY_LENGTH (3641024)
	49
	50	#define DSP56K_TX_INT_ON dsp56k_host_interface.icr \|= DSP56K_ICR_TREQ
	51	#define DSP56K_RX_INT_ON dsp56k_host_interface.icr \|= DSP56K_ICR_RREQ
	52	#define DSP56K_TX_INT_OFF dsp56k_host_interface.icr &= ~DSP56K_ICR_TREQ
	53	#define DSP56K_RX_INT_OFF dsp56k_host_interface.icr &= ~DSP56K_ICR_RREQ
	54
	55	#define DSP56K_TRANSMIT (dsp56k_host_interface.isr & DSP56K_ISR_TXDE)
	56	#define DSP56K_RECEIVE (dsp56k_host_interface.isr & DSP56K_ISR_RXDF)
	57
	58	#define handshake(count, maxio, timeout, ENABLE, f) \
	59	{ \
	60	long i, t, m; \
	61	while (count > 0) { \
	62	m = min_t(unsigned long, count, maxio); \
	63	for (i = 0; i < m; i++) { \
	64	for (t = 0; t < timeout && !ENABLE; t++) \
	65	msleep(20); \
	66	if(!ENABLE) \
	67	return -EIO; \
	68	f; \
	69	} \
	70	count -= m; \
	71	if (m == maxio) msleep(20); \
	72	} \
	73	}
	74
	75	#define tx_wait(n) \
	76	{ \
	77	int t; \
	78	for(t = 0; t < n && !DSP56K_TRANSMIT; t++) \
	79	msleep(10); \
	80	if(!DSP56K_TRANSMIT) { \
	81	return -EIO; \
	82	} \
	83	}
	84
	85	#define rx_wait(n) \
	86	{ \
	87	int t; \
	88	for(t = 0; t < n && !DSP56K_RECEIVE; t++) \
	89	msleep(10); \
	90	if(!DSP56K_RECEIVE) { \
	91	return -EIO; \
	92	} \
	93	}
	94
	95	/* DSP56001 bootstrap code */
	96	static char bootstrap[] = {
	97	0x0c, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	98	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
99	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
100	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
101	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
102	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
103	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
104	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
105	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
108	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
109	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
110	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
111	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
112	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
113	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
114	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
115	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
116	0x00, 0x00, 0x60, 0xf4, 0x00, 0x00, 0x00, 0x4f, 0x61, 0xf4,
117	0x00, 0x00, 0x7e, 0xa9, 0x06, 0x2e, 0x80, 0x00, 0x00, 0x47,
118	0x07, 0xd8, 0x84, 0x07, 0x59, 0x84, 0x08, 0xf4, 0xa8, 0x00,
119	0x00, 0x04, 0x08, 0xf4, 0xbf, 0x00, 0x0c, 0x00, 0x00, 0xfe,
120	0xb8, 0x0a, 0xf0, 0x80, 0x00, 0x7e, 0xa9, 0x08, 0xf4, 0xa0,
121	0x00, 0x00, 0x01, 0x08, 0xf4, 0xbe, 0x00, 0x00, 0x00, 0x0a,
122	0xa9, 0x80, 0x00, 0x7e, 0xad, 0x08, 0x4e, 0x2b, 0x44, 0xf4,
123	0x00, 0x00, 0x00, 0x03, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x01,
124	0x0e, 0xa0, 0x00, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb5, 0x08,
125	0x50, 0x2b, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb8, 0x08, 0x46,
126	0x2b, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x02, 0x0a, 0xf0, 0xaa,
127	0x00, 0x7e, 0xc9, 0x20, 0x00, 0x45, 0x0a, 0xf0, 0xaa, 0x00,
128	0x7e, 0xd0, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xc6, 0x0a, 0xa9,
129	0x80, 0x00, 0x7e, 0xc4, 0x08, 0x58, 0x6b, 0x0a, 0xf0, 0x80,
130	0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xcd, 0x0a,
131	0xa9, 0x80, 0x00, 0x7e, 0xcb, 0x08, 0x58, 0xab, 0x0a, 0xf0,
132	0x80, 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xd4,
133	0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xd2, 0x08, 0x58, 0xeb, 0x0a,
134	0xf0, 0x80, 0x00, 0x7e, 0xad};
135	static int sizeof_bootstrap = 375;
136
137
138	static struct dsp56k_device {
139	long in_use;
140	long maxio, timeout;
141	int tx_wsize, rx_wsize;
142	} dsp56k;
143
ca8eca68	144	static struct class *dsp56k_class;
1da177e4 LT	145
	146	static int dsp56k_reset(void)
	147	{
	148	u_char status;
	149
	150	/* Power down the DSP */
	151	sound_ym.rd_data_reg_sel = 14;
	152	status = sound_ym.rd_data_reg_sel & 0xef;
	153	sound_ym.wd_data = status;
	154	sound_ym.wd_data = status \| 0x10;
	155
	156	udelay(10);
	157
	158	/* Power up the DSP */
	159	sound_ym.rd_data_reg_sel = 14;
	160	sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;
	161
	162	return 0;
	163	}
	164
d85f6891	165	static int dsp56k_upload(u_char __user *bin, int len)
1da177e4 LT	166	{
	167	int i;
	168	u_char *p;
	169
	170	dsp56k_reset();
	171
	172	p = bootstrap;
	173	for (i = 0; i < sizeof_bootstrap/3; i++) {
	174	/* tx_wait(10); */
	175	dsp56k_host_interface.data.b[1] = *p++;
	176	dsp56k_host_interface.data.b[2] = *p++;
	177	dsp56k_host_interface.data.b[3] = *p++;
	178	}
	179	for (; i < 512; i++) {
	180	/* tx_wait(10); */
	181	dsp56k_host_interface.data.b[1] = 0;
	182	dsp56k_host_interface.data.b[2] = 0;
	183	dsp56k_host_interface.data.b[3] = 0;
	184	}
	185
	186	for (i = 0; i < len; i++) {
	187	tx_wait(10);
	188	get_user(dsp56k_host_interface.data.b[1], bin++);
	189	get_user(dsp56k_host_interface.data.b[2], bin++);
	190	get_user(dsp56k_host_interface.data.b[3], bin++);
	191	}
	192
	193	tx_wait(10);
	194	dsp56k_host_interface.data.l = 3; /* Magic execute */
	195
	196	return 0;
	197	}
	198
d85f6891	199	static ssize_t dsp56k_read(struct file file, char __user buf, size_t count,
1da177e4 LT	200	loff_t *ppos)
1da177e4 LT	201	{
a7113a96	202	struct inode *inode = file->f_path.dentry->d_inode;
1da177e4 LT	203	int dev = iminor(inode) & 0x0f;
	204
	205	switch(dev)
	206	{
	207	case DSP56K_DEV_56001:
	208	{
	209
	210	long n;
	211
	212	/* Don't do anything if nothing is to be done */
	213	if (!count) return 0;
	214
	215	n = 0;
	216	switch (dsp56k.rx_wsize) {
	217	case 1: /* 8 bit */
	218	{
	219	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
	220	put_user(dsp56k_host_interface.data.b[3], buf+n++));
	221	return n;
	222	}
	223	case 2: /* 16 bit */
	224	{
d85f6891	225	short __user *data;
1da177e4 LT	226
1da177e4 LT	227	count /= 2;
d85f6891	228	data = (short __user *) buf;
1da177e4 LT	229	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
	230	put_user(dsp56k_host_interface.data.w[1], data+n++));
	231	return 2*n;
	232	}
	233	case 3: /* 24 bit */
	234	{
	235	count /= 3;
	236	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
	237	put_user(dsp56k_host_interface.data.b[1], buf+n++);
	238	put_user(dsp56k_host_interface.data.b[2], buf+n++);
	239	put_user(dsp56k_host_interface.data.b[3], buf+n++));
	240	return 3*n;
	241	}
	242	case 4: /* 32 bit */
	243	{
d85f6891	244	long __user *data;
1da177e4 LT	245
1da177e4 LT	246	count /= 4;
d85f6891	247	data = (long __user *) buf;
1da177e4 LT	248	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
	249	put_user(dsp56k_host_interface.data.l, data+n++));
	250	return 4*n;
	251	}
	252	}
	253	return -EFAULT;
	254	}
	255
	256	default:
	257	printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
	258	return -ENXIO;
	259	}
	260	}
	261
d85f6891	262	static ssize_t dsp56k_write(struct file file, const char __user buf, size_t count,
1da177e4 LT	263	loff_t *ppos)
1da177e4 LT	264	{
a7113a96	265	struct inode *inode = file->f_path.dentry->d_inode;
1da177e4 LT	266	int dev = iminor(inode) & 0x0f;
	267
	268	switch(dev)
	269	{
	270	case DSP56K_DEV_56001:
	271	{
	272	long n;
	273
	274	/* Don't do anything if nothing is to be done */
	275	if (!count) return 0;
	276
	277	n = 0;
	278	switch (dsp56k.tx_wsize) {
	279	case 1: /* 8 bit */
	280	{
	281	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
	282	get_user(dsp56k_host_interface.data.b[3], buf+n++));
	283	return n;
	284	}
	285	case 2: /* 16 bit */
	286	{
d85f6891	287	const short __user *data;
1da177e4 LT	288
1da177e4 LT	289	count /= 2;
d85f6891	290	data = (const short __user *)buf;
1da177e4 LT	291	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
	292	get_user(dsp56k_host_interface.data.w[1], data+n++));
	293	return 2*n;
	294	}
	295	case 3: /* 24 bit */
	296	{
	297	count /= 3;
	298	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
	299	get_user(dsp56k_host_interface.data.b[1], buf+n++);
	300	get_user(dsp56k_host_interface.data.b[2], buf+n++);
	301	get_user(dsp56k_host_interface.data.b[3], buf+n++));
	302	return 3*n;
	303	}
	304	case 4: /* 32 bit */
	305	{
d85f6891	306	const long __user *data;
1da177e4 LT	307
1da177e4 LT	308	count /= 4;
d85f6891	309	data = (const long __user *)buf;
1da177e4 LT	310	handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
	311	get_user(dsp56k_host_interface.data.l, data+n++));
	312	return 4*n;
	313	}
	314	}
	315
	316	return -EFAULT;
	317	}
	318	default:
	319	printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
	320	return -ENXIO;
	321	}
	322	}
	323
	324	static int dsp56k_ioctl(struct inode inode, struct file file,
	325	unsigned int cmd, unsigned long arg)
	326	{
	327	int dev = iminor(inode) & 0x0f;
d85f6891	328	void __user argp = (void __user )arg;
1da177e4 LT	329
	330	switch(dev)
	331	{
	332	case DSP56K_DEV_56001:
	333
	334	switch(cmd) {
	335	case DSP56K_UPLOAD:
	336	{
d85f6891	337	char __user *bin;
1da177e4	338	int r, len;
d85f6891	339	struct dsp56k_upload __user *binary = argp;
1da177e4 LT	340
	341	if(get_user(len, &binary->len) < 0)
	342	return -EFAULT;
	343	if(get_user(bin, &binary->bin) < 0)
	344	return -EFAULT;
	345
	346	if (len == 0) {
	347	return -EINVAL; /* nothing to upload?!? */
	348	}
	349	if (len > DSP56K_MAX_BINARY_LENGTH) {
	350	return -EINVAL;
	351	}
	352
	353	r = dsp56k_upload(bin, len);
	354	if (r < 0) {
	355	return r;
	356	}
	357
	358	break;
	359	}
	360	case DSP56K_SET_TX_WSIZE:
	361	if (arg > 4 \|\| arg < 1)
	362	return -EINVAL;
	363	dsp56k.tx_wsize = (int) arg;
	364	break;
	365	case DSP56K_SET_RX_WSIZE:
	366	if (arg > 4 \|\| arg < 1)
	367	return -EINVAL;
	368	dsp56k.rx_wsize = (int) arg;
	369	break;
	370	case DSP56K_HOST_FLAGS:
	371	{
	372	int dir, out, status;
d85f6891	373	struct dsp56k_host_flags __user *hf = argp;
1da177e4 LT	374
	375	if(get_user(dir, &hf->dir) < 0)
	376	return -EFAULT;
	377	if(get_user(out, &hf->out) < 0)
	378	return -EFAULT;
	379
	380	if ((dir & 0x1) && (out & 0x1))
	381	dsp56k_host_interface.icr \|= DSP56K_ICR_HF0;
	382	else if (dir & 0x1)
	383	dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
	384	if ((dir & 0x2) && (out & 0x2))
	385	dsp56k_host_interface.icr \|= DSP56K_ICR_HF1;
	386	else if (dir & 0x2)
	387	dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
	388
	389	status = 0;
	390	if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status \|= 0x1;
	391	if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status \|= 0x2;
	392	if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status \|= 0x4;
	393	if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status \|= 0x8;
	394
	395	return put_user(status, &hf->status);
	396	}
	397	case DSP56K_HOST_CMD:
	398	if (arg > 31 \|\| arg < 0)
	399	return -EINVAL;
	400	dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) \|
	401	DSP56K_CVR_HC);
	402	break;
	403	default:
	404	return -EINVAL;
	405	}
	406	return 0;
	407
	408	default:
	409	printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
	410	return -ENXIO;
	411	}
	412	}
	413
	414	/* As of 2.1.26 this should be dsp56k_poll,
	415	* but how do I then check device minor number?
	416	* Do I need this function at all???
	417	*/
	418	#if 0
	419	static unsigned int dsp56k_poll(struct file file, poll_table wait)
	420	{
a7113a96	421	int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
1da177e4 LT	422
	423	switch(dev)
	424	{
	425	case DSP56K_DEV_56001:
	426	/* poll_wait(file, ???, wait); */
	427	return POLLIN \| POLLRDNORM \| POLLOUT;
	428
	429	default:
	430	printk("DSP56k driver: Unknown minor device: %d\n", dev);
	431	return 0;
	432	}
	433	}
	434	#endif
	435
	436	static int dsp56k_open(struct inode inode, struct file file)
	437	{
	438	int dev = iminor(inode) & 0x0f;
	439
	440	switch(dev)
	441	{
	442	case DSP56K_DEV_56001:
	443
	444	if (test_and_set_bit(0, &dsp56k.in_use))
	445	return -EBUSY;
	446
	447	dsp56k.timeout = TIMEOUT;
	448	dsp56k.maxio = MAXIO;
	449	dsp56k.rx_wsize = dsp56k.tx_wsize = 4;
	450
	451	DSP56K_TX_INT_OFF;
	452	DSP56K_RX_INT_OFF;
	453
	454	/* Zero host flags */
	455	dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
	456	dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
	457
	458	break;
	459
	460	default:
	461	return -ENODEV;
	462	}
	463
	464	return 0;
	465	}
	466
	467	static int dsp56k_release(struct inode inode, struct file file)
	468	{
	469	int dev = iminor(inode) & 0x0f;
	470
	471	switch(dev)
	472	{
	473	case DSP56K_DEV_56001:
	474	clear_bit(0, &dsp56k.in_use);
	475	break;
	476	default:
	477	printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
	478	return -ENXIO;
	479	}
	480
	481	return 0;
	482	}
	483
62322d25	484	static const struct file_operations dsp56k_fops = {
1da177e4 LT	485	.owner = THIS_MODULE,
	486	.read = dsp56k_read,
	487	.write = dsp56k_write,
	488	.ioctl = dsp56k_ioctl,
	489	.open = dsp56k_open,
	490	.release = dsp56k_release,
	491	};
	492
	493
	494	/**** Init and module functions ****/
	495
	496	static char banner[] __initdata = KERN_INFO "DSP56k driver installed\n";
	497
	498	static int __init dsp56k_init_driver(void)
	499	{
	500	int err = 0;
	501
	502	if(!MACH_IS_ATARI \|\| !ATARIHW_PRESENT(DSP56K)) {
	503	printk("DSP56k driver: Hardware not present\n");
	504	return -ENODEV;
	505	}
	506
	507	if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
	508	printk("DSP56k driver: Unable to register driver\n");
	509	return -ENODEV;
	510	}
ca8eca68	511	dsp56k_class = class_create(THIS_MODULE, "dsp56k");
1da177e4 LT	512	if (IS_ERR(dsp56k_class)) {
	513	err = PTR_ERR(dsp56k_class);
	514	goto out_chrdev;
	515	}
53f46542	516	class_device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL, "dsp56k");
1da177e4	517
1da177e4 LT	518	printk(banner);
	519	goto out;
	520
1da177e4 LT	521	out_chrdev:
	522	unregister_chrdev(DSP56K_MAJOR, "dsp56k");
	523	out:
	524	return err;
	525	}
	526	module_init(dsp56k_init_driver);
	527
	528	static void __exit dsp56k_cleanup_driver(void)
	529	{
ca8eca68 GKH	530	class_device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
ca8eca68 GKH	531	class_destroy(dsp56k_class);
1da177e4	532	unregister_chrdev(DSP56K_MAJOR, "dsp56k");
1da177e4 LT	533	}
	534	module_exit(dsp56k_cleanup_driver);
	535
	536	MODULE_LICENSE("GPL");