satip-axe/kernel/drivers/stm/stm-coprocessor.c

/*
 * Copyright (C) 2003-2004 Giuseppe Cavallaro (peppe.cavallaro@st.com)
 *
 * May be copied or modified under the terms of the GNU General Public
 * License.  See linux/COPYING for more information.
 *
 * Interfaces (where required) the co-processors on ST platforms based
 * on multiprocessor architecture, for embedded products like Set-top-Box
 * DVD, etc...
 *
*/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/bootmem.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/vmalloc.h>

#include <linux/delay.h>
#include <linux/mm.h>
#include <linux/stm/coprocessor.h>
#include <linux/platform_device.h>
#include <asm/types.h>
#include <asm/uaccess.h>
#include <asm/sections.h>
#include <asm/io.h>
#include <asm/irq.h>

#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
#include <linux/seq_file.h>

static int __init proc_st_coproc_init(void);
#endif

/* ---------------------------------------------------------------------------
 *     Local (declared out of order) functions
 * ------------------------------------------------------------------------ */

static int __init parse_coproc_mem(char *from);

/* ---------------------------------------------------------------------------
 * 		Co-processor: Hardware dependent support
 * This includes:
 *    - per platform device and memory addresses
 *    - platform dependent macros
 *    - HW dependent actions required by the generic APIs: Init,
 *      Open, Release, Ioctl (to reset, trigger the start (grant),
 *      peek and poke, etc...) functions
 * ------------------------------------------------------------------------ */

extern struct coproc_board_info coproc_info;

/* ---------------------------------------------------------------------------
 *    Local data structure
 * ------------------------------------------------------------------------ */

extern coproc_t coproc[];	/* The maximum number of copro-  */
					   /* cessors depends on platform   */
					   /* type                          */

#ifdef CONFIG_DEVFS_FS
static devfs_handle_t devfs_reset_hdl;
#endif

#if defined(CONFIG_COPROCESSOR_DEBUG) && defined(RPC_DEBUG)
/* -------------------------------------------------------------------------
 * 			Co-processor DEBUG Suppor26t
 *
 *  Currently we do not expect to receive asynchronous events from the
 *  slave processor. This routine as well as the IRQ definition has been
 *  foreseen and used for debug purposes.
 *  Once a slave is started the standard and supported way of communicating
 *  with the host processor is to rely on the RPC service.
 */

static int irq_count = 0;
static void mbx_irq_handle(int irq, void *cop, struct pt_regs *regs)
{
	/* avoid a noisy loop if possible! */
	irq_count++;
	if ((irq_count % 100) == 0)
		printk("st-coprocessor: unexpected interrupt %d from %s.%u\n",
		       irq, ((coproc_t *) cop)->pdev.name,((coproc_t *) cop)->pdev.id);

	(void)&mbx_irq_handle;	/* warning suppression */
}

#endif				/* CONFIG_COPROCESSOR_DEBUG */

static void __debug(coproc_t * cop, const char *fnc)
{

	/* Print the coprocessor control structure */
	printk("%s.%u Coprocessor -------------------------------------------\n",
	       cop->pdev.name,cop->pdev.id);
	if (cop->control == 0 || cop->ram_size == 0) {
		printk("    not configured!\n");
		goto skip_debug;
	} else {
		printk
		    ("    flags %04x RAM start at 0x%08lx  size      0x%08x\n",
		     cop->control, HOST_ADDR(cop, 0), cop->ram_size);
		printk("                  cop. addr 0x%08lx\n",
		       COPR_ADDR(cop, 0));
	}

#ifdef CONFIG_COPROCESSOR_DEBUG
	if (cop->h2c_port)
		printk
		    ("    Channels : h->c 0x%08x (%08lx)    c->h 0x%08x (%08lx)\n",
					cop->h2c_port, (long unsigned int)readl(cop->h2c_port), cop->c2h_port,
					(long unsigned int)readl(cop->c2h_port));
	else
#endif
		printk("    Channels : Not defined\n");

	if (cop->irq)
		printk("    IRQ      : %d\n", cop->irq);
	else
		printk("    IRQ      : not used\n");

      skip_debug:
	printk
	    ("---------------------------------------------------------------\n");

}

/* ---------------------------------------------------------------------------
 * 			Co-processor driver APIs
 * ------------------------------------------------------------------------ */

static int st_coproc_open(struct inode *inode, struct file *file)
{
	/*
	 ** use minor number (ID) to access the current coproc. descriptor
	 */
	coproc_t *cop = FILE_2_COP(coproc, file);

	DPRINTK(">>> %s: %s-%u, cop->control = %d, cop->ram_size = %d\n",
		__FUNCTION__, cop->pdev.name,cop->pdev.id, cop->control, cop->ram_size);

	if (((cop - coproc) / sizeof(coproc_t)) >= coproc_info.max_coprs)
		return (-ENODEV);
	if (cop->ram_size == 0)
		return (-ENOSPC);
	if (cop->control & COPROC_IN_USE)
		return (-EBUSY);
	cop->control |= COPROC_IN_USE;

	/* Now call the platform dependent open stage */
	coproc_cpu_open(cop);
#ifdef CONFIG_COPROCESSOR_DEBUG
	__debug(cop, __FUNCTION__);
#endif
	return 0;
}

static int st_coproc_release(struct inode *inode, struct file *file)
{
	coproc_t *cop = FILE_2_COP(coproc, file);

	coproc_cpu_release(cop);
	cop->control &= ~COPROC_IN_USE;

	return 0;
}

static int st_coproc_ioctl(struct inode *inode, struct file *file,
			   unsigned int cmd, unsigned long arg)
{
	coproc_t *cop = FILE_2_COP(coproc, file);
	int res = 0;

	switch (cmd) {
	case STCOP_RESET:
		res = coproc_cpu_reset(cop);
		break;
	case STCOP_GRANT:
		/* Release the Slave CPU from reset (do not wait) */
		res = coproc_cpu_grant(cop, arg);
		break;

/* Peek and poke 32 bit cell:  for debug only
 * ------------------------------------------
 * Not generally available, not documented and not supported.
 * Simple and perhaps not reliable way for writing and reading a 32 bit
 * value using the <stslave> application.
 * PAY ATTENTION: the code doesn't make any validity check hence the use
 *                of a wrong address may have undesired effects!
 */
#define PAIRS(p) (p)[0]		/* Number of couple:  addr./value */
#define PORT(p)  (p)[1]		/* the address (port)             */
#define VALUE(p) (p)[2]		/* the 32 bit value               */

	case STCOP_PEEK:
		{
			u_long peek[3];
			res = -EINVAL;

			/* so far we need to peek only a single 32 bit cell */
			res = copy_from_user(peek, (void __user *)arg,
					     sizeof(peek));
			if (res < 0)
				break;
			if (PAIRS(peek) != 1)
				break;

			/* make the addr 32 bit aligned  and peek the value */
			PORT(peek) &= ~0x3;
			VALUE(peek) = peek_l(PORT(peek));

			DPRINTK(">>> %s: %s.%u;  peek[%ld] @0x%08lx = 0x%08lx\n",
				__FUNCTION__, cop->pdev.name,cop->pdev.id,
				PAIRS(peek), PORT(peek), VALUE(peek));

			/* don't mind wich data, make it availbale to the user */
			res = copy_to_user((void *)arg, peek, sizeof(peek));
			break;
		}

	case STCOP_POKE:
		{
			u_long poke[3];
			res = -EINVAL;

			/* so far we need to peek only a single 32 bit cell */
			res = copy_from_user(poke, (void __user *)arg,
					     sizeof(poke));
			if (res < 0)
				break;
			if (PAIRS(poke) != 1)
				break;

			/* make the addr 32 bit aligned  and poke the value */
			PORT(poke) &= ~0x3;
			poke_l(VALUE(poke), PORT(poke));

			DPRINTK(">>> %s: %s.%u;  poke[%ld] @0x%08lx = 0x%08lx\n",
				__FUNCTION__, cop->pdev.name,cop->pdev.id,
				PAIRS(poke), PORT(poke), VALUE(poke));
			res = 0;
			break;
		}

	case STCOP_GET_PROPERTIES:
		{
			cop_properties_t clayout;

//			strncpy(clayout.name, cop->pdev.name,
//				sizeof(clayout.name));
			sprintf(clayout.name,"%s-%u",cop->pdev.name,cop->pdev.id);
			clayout.flags = cop->control;

			clayout.ram_start = HOST_ADDR(cop, 0);
			clayout.ram_size = cop->ram_size;
			clayout.cp_ram_start = COPR_ADDR(cop, 0);

			res =
			    copy_to_user((void *)arg, &clayout,
					 sizeof(cop_properties_t));
			break;
		}

	case STCOP_SET_PROPERTIES:
		{
			/* Not yet supported! */
			printk(KERN_INFO
			       "%s.%u: setting properties not yet available\n",
			       cop->pdev.name,cop->pdev.id);
			res = -ENOSYS;
			break;
		}

	default:
		res = -EINVAL;
	}
	return (res);
}

static ssize_t st_coproc_read(struct file *file, char *buf,
			      size_t count, loff_t * ppos)
{
	coproc_t *cop;
	u_long from;
	ssize_t bytes;
	u_int offset = *ppos;

	cop = FILE_2_COP(coproc, file);

	/*
	 * File position assumes the Coprocessor RAM base addr.
	 * normalaized to 0
	 */
	if (offset >= cop->ram_size)
		return (0);

	from = (u_long) HOST_ADDR(cop, offset);
	bytes = min(count, (cop->ram_size - offset));

	DPRINTK(">>> %s: from 0x%08lx to 0x%08x len 0x%x(%d)\n",
		__FUNCTION__, from, (u_int) buf, bytes, bytes);

	if (copy_to_user(buf, (void *)from, bytes))
		return (-EFAULT);

	*ppos += bytes;

	return (bytes);
}

static ssize_t st_coproc_write(struct file *file, const char *buf,
			       size_t count, loff_t * ppos)
{
	coproc_t *cop;
	u_long to;
	ssize_t bytes;
	u_int offset = (u_int) * ppos;

	cop = FILE_2_COP(coproc, file);

	/* File position assumes the RAM base addr. normalaized to 0 */
	if (offset >= (u_long) cop->ram_size)
		return (-EFBIG);

	to = (u_long) HOST_ADDR(cop, offset);
	bytes = min(count, (cop->ram_size - offset));

	DPRINTK(">>> %s: from 0x%08x to 0x%08lx len 0x%x(%d)\n",
		__FUNCTION__, (u_int) buf, to, bytes, bytes);

	if (copy_from_user((void *)to, buf, bytes))
		return (-EFAULT);

	*ppos += bytes;
	return (bytes);
}

static loff_t st_coproc_llseek(struct file *file, loff_t fpos, int orig)
{
	coproc_t *cop;
	u_long offset = fpos;
	u_long base;

	cop = FILE_2_COP(coproc, file);

	/*
	 * fpos  can be a real offset within the coprocessor region or a
	 * direct host address in the region (coming from application in
	 * case of mmap).  This code assumes to be an address if it abs.
	 * value > COPR_ADDR, a normal offset otherwyse.
	 */
	base = HOST_ADDR(cop, 0);

	DPRINTK
	    (">>> %s: seek to: 0x%08lx ->  fpos = offset 0x%lx + base 0x%lx\n",
	     __FUNCTION__, (u_long) fpos, offset, HOST_ADDR(cop, 0));

	switch (orig) {
	case 0:
		file->f_pos = offset;
		break;		/* SEEK_SET */
	case 1:
		file->f_pos += offset;
		break;		/* SEEK_CUR */
	case 2:
		file->f_pos = cop->ram_size + offset;
		break;		/* SEEK_END */
	default:
		return -EINVAL;
	}

	if (file->f_pos >= cop->ram_size)
		file->f_pos = cop->ram_size - 1;

	return (file->f_pos);

}

static int st_coproc_mmap(struct file *file, struct vm_area_struct *vma)
{
	coproc_t *cop = FILE_2_COP(coproc, file);

	unsigned int offset = vma->vm_pgoff << PAGE_SHIFT;
	unsigned int vsize = vma->vm_end - vma->vm_start;
	unsigned int psize = cop->ram_size - offset;

	DPRINTK(">>> %s: vm_start=0x%lx, vm_end=0x%lx, vm_pgoff=0x%lx\n",
		__FUNCTION__, vma->vm_start, vma->vm_end, vma->vm_pgoff);

	if (vsize > psize)
		return (-ENOSPC);

	/*
	 * Call the remap_pfn_range(...) function to map in user space the
	 * coprocessor memory region. Uses ST40 no cache region
	 */
	vma->vm_flags |= VM_IO;
	/* TODO: double check this. was a call
	 *       to remap_page_range but without the >> PAGE_SHIFT
	 */
	if (remap_pfn_range(vma, vma->vm_start, cop->ram_offset
			    >> PAGE_SHIFT, vsize, vma->vm_page_prot)) {
		DPRINTK(">>> %s: remap_page_range(...) failed\n", __FUNCTION__);
		return (-EAGAIN);
	}

	DPRINTK(">>> %s: ... done: 0x%08lx len 0x%x --> 0x%08lx\n",
		__FUNCTION__, (unsigned long)HOST_ADDR(cop, 0), vsize,
		vma->vm_start);
	return (0);
}

static struct file_operations coproc_fops = {
      llseek:st_coproc_llseek,
      read:st_coproc_read,
      write:st_coproc_write,
      ioctl:st_coproc_ioctl,
      mmap:st_coproc_mmap,
      open:st_coproc_open,
      release:st_coproc_release
};

/* Start: ST-Coprocessor Device Attribute on SysFs*/
static ssize_t st_copro_show_running(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	coproc_t *cop = container_of(dev, coproc_t, pdev.dev);
	return sprintf(buf, "%d", cop->control & COPROC_IN_USE);
}

static DEVICE_ATTR(running, S_IRUGO, st_copro_show_running, NULL);

static ssize_t st_copro_show_mem_size(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	coproc_t *cop = container_of(dev, coproc_t, pdev.dev);
	return sprintf(buf, "0x%x", cop->ram_size);
}

static DEVICE_ATTR(mem_size, S_IRUGO, st_copro_show_mem_size, NULL);

static ssize_t st_copro_show_mem_base(struct device *dev,
				      struct device_attribute *attr, char *buf)
{
	coproc_t *cop = container_of(dev, coproc_t, pdev.dev);
	return sprintf(buf, "0x%x", (int)cop->ram_offset);
}

static DEVICE_ATTR(mem_base, S_IRUGO, st_copro_show_mem_base, NULL);
/* End: ST-Coprocessor Device Attribute SysFs*/

static int st_coproc_driver_probe(struct platform_device *dev)
{
	if (!strncmp("st2", dev->name, 3))
		return 1;
	return 0;
}

#if defined(CONFIG_PM)
static int st_coproc_suspend(struct platform_device * dev, pm_message_t state)
{
	printk("st_coproc_suspend: %s.%u down\n",dev->name,dev->id);
	return 0;
}
static int st_coproc_resume(struct platform_device * dev)
{
	printk("st_coproc_resume: %s.%u up\n",dev->name,dev->id);
	return 0;
}
#endif

static struct platform_driver st_coproc_driver = {
	.driver.name = "st-copro",
	.driver.owner = THIS_MODULE,
	.probe = st_coproc_driver_probe,
#if defined(CONFIG_PM)
	.suspend =st_coproc_suspend,
	.resume = st_coproc_resume,
#endif
};

static struct class *coproc_dev_class;
static int __init st_coproc_init(void)
{
	int i;
	coproc_t *cop;
	struct platform_device *pdev;

	printk("STMicroelectronics - Coprocessors %s Init\n", coproc_info.name);

	if (platform_driver_register(&st_coproc_driver)){
		printk(KERN_ERR
		       "Error on ST-Coprocessor device driver registration\n");
		return (-EAGAIN);
	}

	if (register_chrdev(COPROCESSOR_MAJOR, coproc_info.name, &coproc_fops)) {
		printk("Can't allocate major %d for ST Coprocessor Devices\n",
		       COPROCESSOR_MAJOR);
		return (-EAGAIN);
	}

	coproc_dev_class = class_create(THIS_MODULE, "coproc-dev");

	for (cop = &coproc[0], i = 0; i < coproc_info.max_coprs; i++, cop++) {
		if (!cop->ram_offset) {
			printk("st-coprocessor-%d: No RAM reserved\n", i);
			cop->control &= ~COPROC_SPACE_ALLOCATE;
		} else {
			cop->control |= COPROC_SPACE_ALLOCATE;
			cop->vma_address =
				(int)ioremap_nocache((unsigned long)cop->ram_offset, cop->ram_size);
		}
		/*
		 ** Nodes:
		 **    STb7100         : /dev/st231-0    c   63   0
		 **                    : /dev/st231-1    c   63   1
		 ** if the device file system support is configured the above
		 ** devices are autonatically generated
		 */
		pdev = &(cop->pdev);
		memset(pdev, 0, sizeof(struct platform_device));
		pdev->name = coproc_info.name;
		pdev->id   = i;
		pdev->dev.driver = &st_coproc_driver.driver;
		/* Now complete with the platform dependent init stage */
		if (coproc_cpu_init(cop)){
			printk(KERN_ERR
				"CPU %d : HW dep. initialization failed!\n", i);
			continue;
		}
		if (platform_device_register(pdev)<0)
			printk(KERN_ERR
			       "Error on ST-Coprocessor device registration\n");
		else {
			/* Add the attributes on the device */
			if(device_create_file(&pdev->dev, &dev_attr_mem_base) |
					device_create_file(&pdev->dev, &dev_attr_mem_size) |
					device_create_file(&pdev->dev, &dev_attr_running))
				printk(KERN_ERR "Error to add attribute to the coprocessor device\n");
			/* Create the device file via Discovery System */
			cop->dev = device_create(coproc_dev_class, NULL,
						MKDEV(COPROCESSOR_MAJOR,pdev->id),
						NULL,"st231-%d", pdev->id);
		}

		/* Now complete with the platform dependent init stage */
#if defined(CONFIG_COPROCESSOR_DEBUG) && defined(RPC_DEBUG)
		{
			/* just to debug on STi5528 application using the RPC 2.1,
			 * install a fake interrupt hadler
			 */
			int res;

			cop->irq = EMBX_IRQ + i;
			if ((res = request_irq(cop->irq, &mbx_irq_handle, 0,
					       coproc_info.name, cop)) != 0) {
				printk
				    ("st-coprocessor: Error %d booking IRQ %d for %s\n",
				     res, cop->irq, cop->name);
				cop->irq = 0;
			}
		}
#endif
		__debug(cop, __FUNCTION__);
	}

#ifdef CONFIG_PROC_FS
	proc_st_coproc_init();
#endif

	return (0);
}

static void __exit st_coproc_exit(void)
{
	DPRINTK("Release coprocessor module...\n");
}

/*
 * Parse the optional kernel argument:
 *
 * ... coprocessor_mem=size_0@phis_address_0, size_1@phis_address_1
 *
 * It seems to be reasonable to assume that in a "staically partitioned
 * RAM layout", the regions of RAM assigned to each slave processor are
 * not scattered in memory!
 */
static int __init parse_coproc_mem(char *from)
{
	char *cmdl = (from);	/* start scan from '=' char */
	u_long size, addr;
	int i = 0;
	char *error_msg;
	static char size_error[] __initdata =
		KERN_ERR "st-coprocessor: Error parsing size\n";
	static char addr_error[] __initdata =
		KERN_ERR "st-coprocessor: Error parsing address\n";
	static char too_many_warn[] __initdata =
		KERN_WARNING "st-coprocessor: More regions than coprocessors\n";
	static char alloc_error[] __initdata =
		KERN_ERR "st-coprocessor: Failed to reserve memory at 0x%08x\n";

	while (*cmdl && (i < coproc_info.max_coprs)) {
		size = memparse(cmdl, &cmdl);
		if (*cmdl != '@') {
			error_msg = size_error;
			goto args_error;
		}
		addr = memparse(cmdl+1, &cmdl);
		if (*cmdl) {
			if (*cmdl++ != ',') {
				error_msg = addr_error;
				goto args_error;
			}
		}
		coproc[i].ram_offset = addr;
		coproc[i].ram_size = size;
		++i;
	}

	if (*cmdl) {
		printk(too_many_warn);
	}

	for (i = 0; i < coproc_info.max_coprs; ++i) {
		if (coproc[i].ram_size) {
			void* mem;
			addr = coproc[i].ram_offset;
			size = coproc[i].ram_size;
			mem = __alloc_bootmem_nopanic(size, PAGE_SIZE, addr);
			if (mem != __va(addr)) {
				if (mem) {
					free_bootmem(virt_to_phys(mem), size);
				}
				/* At this point, if addr overlaps kernel
				 * memory, coprocessor won't be allocated.
				 */
				if (coproc_check_area(addr, size, i, coproc))
					printk(alloc_error, addr);
			}
		}
	}

	return 1;

args_error:
	printk(error_msg);
	return 1;
}

__setup("coprocessor_mem=", parse_coproc_mem);

MODULE_DESCRIPTION("Co-processor manager for multi-core devices");
MODULE_AUTHOR("STMicroelectronics Limited");
MODULE_VERSION("0.3");
MODULE_LICENSE("GPL");

module_init(st_coproc_init);
module_exit(st_coproc_exit);

#ifdef CONFIG_PROC_FS

static int show_st_coproc(struct seq_file *m, void *v)
{
	int i;
	coproc_t *cop;
	seq_printf(m, "Coprocessors: %d  %s\n",
		   coproc_info.max_coprs, coproc_info.name);
	seq_printf(m,
		   "  CPU (dev)        Host addr.     Copr. addr.     Size\n");
	seq_printf(m,
		   "  -------------------------------------------------------------------\n");
	for (i = 0, cop = &coproc[0]; i < coproc_info.max_coprs; i++, cop++) {
		seq_printf(m, "  /dev/%s-%u    ", cop->pdev.name,cop->pdev.id);
		if (cop->ram_size == 0)
			seq_printf(m, "not allocated!\n");
		else
			seq_printf(m,
				   "0x%08lx     0x%08lx      0x%08x (%2d Mb)\n",
				   HOST_ADDR(cop, 0), COPR_ADDR(cop, 0),
				   cop->ram_size, (cop->ram_size / MEGA));
	}
	seq_printf(m, "\n");

	coproc_proc_other_info(cop, m);
	return (0);
}

static void *st_coproc_seq_start(struct seq_file *m, loff_t * pos)
{
	return (void *)(*pos == 0);
}

static void *st_coproc_seq_next(struct seq_file *m, void *v, loff_t * pos)
{
	return NULL;
}

static void st_coproc_seq_stop(struct seq_file *m, void *v)
{
}

static struct seq_operations proc_st_coproc_op = {
      start:st_coproc_seq_start,
      next:st_coproc_seq_next,
      stop:st_coproc_seq_stop,
      show:show_st_coproc,
};

static int proc_st_coproc_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &proc_st_coproc_op);
}

static struct file_operations proc_st_coproc_operations = {
      open:proc_st_coproc_open,
      read:seq_read,
      llseek:seq_lseek,
      release:seq_release,
};

static int __init proc_st_coproc_init(void)
{
	struct proc_dir_entry *entry;
	entry = create_proc_entry("coprocessor", 0, NULL);
	if (entry != NULL) {
		entry->proc_fops = &proc_st_coproc_operations;
	}

	return 0;
}

#endif				/* CONFIG_PROC_FS */