Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2c973ef0 authored by Deng-Cheng Zhu's avatar Deng-Cheng Zhu Committed by Ralf Baechle
Browse files

MIPS: APRP: Split RTLX support into separate files. 



Split the RTLX functionality in preparation for adding support for CMP
platforms. Common functions remain in the original file and a new file
contains code specific to platforms that do not have a CMP.

Signed-off-by: default avatarDeng-Cheng Zhu <dengcheng.zhu@imgtec.com>
Signed-off-by: default avatarSteven J. Hill <Steven.Hill@imgtec.com>
Reviewed-by: default avatarQais Yousef <Qais.Yousef@imgtec.com>
Patchwork: http://patchwork.linux-mips.org/patch/6093/


Reviewed-by: default avatarJohn Crispin <blogic@openwrt.org>
parent 17a1d523

arch/mips/Kconfig

+5 −0
Original line number Diff line number Diff line
@@ -1956,6 +1956,11 @@ config MIPS_VPE_APSP_API 
	depends on MIPS_VPE_LOADER

	help



config MIPS_VPE_APSP_API_MT

	bool

	default "y"

	depends on MIPS_VPE_APSP_API && !MIPS_CMP



config MIPS_CMP

	bool "MIPS CMP support"

	depends on SYS_SUPPORTS_MIPS_CMP && MIPS_MT_SMP

arch/mips/include/asm/rtlx.h

+31 −12
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2004, 2005 MIPS Technologies, Inc.  All rights reserved.

 *

 * Copyright (C) 2013 Imagination Technologies Ltd.

 */



#ifndef __ASM_RTLX_H_
@@ -8,6 +8,8 @@ 


#include <irq.h>



#define RTLX_MODULE_NAME "rtlx"



#define LX_NODE_BASE 10



#define MIPS_CPU_RTLX_IRQ 0
@@ -15,18 +17,31 @@ 
#define RTLX_VERSION 2

#define RTLX_xID 0x12345600

#define RTLX_ID (RTLX_xID | RTLX_VERSION)

#define RTLX_BUFFER_SIZE 2048

#define RTLX_CHANNELS 8



#define RTLX_CHANNEL_STDIO	0

#define RTLX_CHANNEL_DBG	1

#define RTLX_CHANNEL_SYSIO	2



extern int rtlx_open(int index, int can_sleep);

extern int rtlx_release(int index);

extern ssize_t rtlx_read(int index, void __user *buff, size_t count);

extern ssize_t rtlx_write(int index, const void __user *buffer, size_t count);

extern unsigned int rtlx_read_poll(int index, int can_sleep);

extern unsigned int rtlx_write_poll(int index);

void rtlx_starting(int vpe);

void rtlx_stopping(int vpe);



int rtlx_open(int index, int can_sleep);

int rtlx_release(int index);

ssize_t rtlx_read(int index, void __user *buff, size_t count);

ssize_t rtlx_write(int index, const void __user *buffer, size_t count);

unsigned int rtlx_read_poll(int index, int can_sleep);

unsigned int rtlx_write_poll(int index);



int __init rtlx_module_init(void);

void __exit rtlx_module_exit(void);



void _interrupt_sp(void);



extern struct vpe_notifications rtlx_notify;

extern const struct file_operations rtlx_fops;

extern void (*aprp_hook)(void);



enum rtlx_state {

	RTLX_STATE_UNUSED = 0,
@@ -35,7 +50,12 @@ enum rtlx_state { 
	RTLX_STATE_OPENED

};



#define RTLX_BUFFER_SIZE 2048

extern struct chan_waitqueues {

	wait_queue_head_t rt_queue;

	wait_queue_head_t lx_queue;

	atomic_t in_open;

	struct mutex mutex;

} channel_wqs[RTLX_CHANNELS];



/* each channel supports read and write.

   linux (vpe0) reads lx_buffer and writes rt_buffer
@@ -55,11 +75,10 @@ struct rtlx_channel { 
	char *lx_buffer;

};



struct rtlx_info {

extern struct rtlx_info {

	unsigned long id;

	enum rtlx_state state;



	struct rtlx_channel channel[RTLX_CHANNELS];

};



} *rtlx;

#endif /* __ASM_RTLX_H_ */

arch/mips/kernel/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -59,6 +59,7 @@ obj-$(CONFIG_MIPS_VPE_LOADER) += vpe.o 
obj-$(CONFIG_MIPS_VPE_LOADER_CMP) += vpe-cmp.o

obj-$(CONFIG_MIPS_VPE_LOADER_MT) += vpe-mt.o

obj-$(CONFIG_MIPS_VPE_APSP_API) += rtlx.o

obj-$(CONFIG_MIPS_VPE_APSP_API_MT) += rtlx-mt.o



obj-$(CONFIG_I8259)		+= i8259.o

obj-$(CONFIG_IRQ_CPU)		+= irq_cpu.o

arch/mips/kernel/rtlx-mt.c

0 → 100644
+148 −0
Original line number Diff line number Diff line 
/*

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

 *

 * Copyright (C) 2005 MIPS Technologies, Inc.  All rights reserved.

 * Copyright (C) 2013 Imagination Technologies Ltd.

 */

#include <linux/device.h>

#include <linux/fs.h>

#include <linux/err.h>

#include <linux/wait.h>

#include <linux/sched.h>

#include <linux/interrupt.h>

#include <linux/irq.h>



#include <asm/mips_mt.h>

#include <asm/vpe.h>

#include <asm/rtlx.h>



static int major;



static void rtlx_dispatch(void)

{

	if (read_c0_cause() & read_c0_status() & C_SW0)

		do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ);

}



/*

 * Interrupt handler may be called before rtlx_init has otherwise had

 * a chance to run.

 */

static irqreturn_t rtlx_interrupt(int irq, void *dev_id)

{

	unsigned int vpeflags;

	unsigned long flags;

	int i;



	/* Ought not to be strictly necessary for SMTC builds */

	local_irq_save(flags);

	vpeflags = dvpe();

	set_c0_status(0x100 << MIPS_CPU_RTLX_IRQ);

	irq_enable_hazard();

	evpe(vpeflags);

	local_irq_restore(flags);



	for (i = 0; i < RTLX_CHANNELS; i++) {

		wake_up(&channel_wqs[i].lx_queue);

		wake_up(&channel_wqs[i].rt_queue);

	}



	return IRQ_HANDLED;

}



static struct irqaction rtlx_irq = {

	.handler	= rtlx_interrupt,

	.name		= "RTLX",

};



static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;



void _interrupt_sp(void)

{

	unsigned long flags;



	local_irq_save(flags);

	dvpe();

	settc(1);

	write_vpe_c0_cause(read_vpe_c0_cause() | C_SW0);

	evpe(EVPE_ENABLE);

	local_irq_restore(flags);

}



int __init rtlx_module_init(void)

{

	struct device *dev;

	int i, err;



	if (!cpu_has_mipsmt) {

		pr_warn("VPE loader: not a MIPS MT capable processor\n");

		return -ENODEV;

	}



	if (aprp_cpu_index() == 0) {

		pr_warn("No TCs reserved for AP/SP, not initializing RTLX.\n"

			"Pass maxtcs=<n> argument as kernel argument\n");



		return -ENODEV;

	}



	major = register_chrdev(0, RTLX_MODULE_NAME, &rtlx_fops);

	if (major < 0) {

		pr_err("rtlx_module_init: unable to register device\n");

		return major;

	}



	/* initialise the wait queues */

	for (i = 0; i < RTLX_CHANNELS; i++) {

		init_waitqueue_head(&channel_wqs[i].rt_queue);

		init_waitqueue_head(&channel_wqs[i].lx_queue);

		atomic_set(&channel_wqs[i].in_open, 0);

		mutex_init(&channel_wqs[i].mutex);



		dev = device_create(mt_class, NULL, MKDEV(major, i), NULL,

				    "%s%d", RTLX_MODULE_NAME, i);

		if (IS_ERR(dev)) {

			err = PTR_ERR(dev);

			goto out_chrdev;

		}

	}



	/* set up notifiers */

	rtlx_notify.start = rtlx_starting;

	rtlx_notify.stop = rtlx_stopping;

	vpe_notify(aprp_cpu_index(), &rtlx_notify);



	if (cpu_has_vint) {

		aprp_hook = rtlx_dispatch;

	} else {

		pr_err("APRP RTLX init on non-vectored-interrupt processor\n");

		err = -ENODEV;

		goto out_class;

	}



	rtlx_irq.dev_id = rtlx;

	err = setup_irq(rtlx_irq_num, &rtlx_irq);

	if (err)

		goto out_class;



	return 0;



out_class:

	for (i = 0; i < RTLX_CHANNELS; i++)

		device_destroy(mt_class, MKDEV(major, i));

out_chrdev:

	unregister_chrdev(major, RTLX_MODULE_NAME);



	return err;

}



void __exit rtlx_module_exit(void)

{

	int i;



	for (i = 0; i < RTLX_CHANNELS; i++)

		device_destroy(mt_class, MKDEV(major, i));

	unregister_chrdev(major, RTLX_MODULE_NAME);

}

arch/mips/kernel/rtlx.c

+10 −132
Original line number Diff line number Diff line
@@ -42,52 +42,12 @@ 
#include <asm/rtlx.h>

#include <asm/setup.h>



static struct rtlx_info *rtlx;

static int major;

static char module_name[] = "rtlx";



static struct chan_waitqueues {

	wait_queue_head_t rt_queue;

	wait_queue_head_t lx_queue;

	atomic_t in_open;

	struct mutex mutex;

} channel_wqs[RTLX_CHANNELS];



static struct vpe_notifications notify;

static int sp_stopping;



extern void *vpe_get_shared(int index);



static void rtlx_dispatch(void)

{

	do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ);

}





/* Interrupt handler may be called before rtlx_init has otherwise had

   a chance to run.

*/

static irqreturn_t rtlx_interrupt(int irq, void *dev_id)

{

	unsigned int vpeflags;

	unsigned long flags;

	int i;



	/* Ought not to be strictly necessary for SMTC builds */

	local_irq_save(flags);

	vpeflags = dvpe();

	set_c0_status(0x100 << MIPS_CPU_RTLX_IRQ);

	irq_enable_hazard();

	evpe(vpeflags);

	local_irq_restore(flags);



	for (i = 0; i < RTLX_CHANNELS; i++) {

			wake_up(&channel_wqs[i].lx_queue);

			wake_up(&channel_wqs[i].rt_queue);

	}



	return IRQ_HANDLED;

}

struct rtlx_info *rtlx;

struct chan_waitqueues channel_wqs[RTLX_CHANNELS];

struct vpe_notifications rtlx_notify;

void (*aprp_hook)(void) = NULL;

EXPORT_SYMBOL(aprp_hook);



static void __used dump_rtlx(void)

{
@@ -127,7 +87,7 @@ static int rtlx_init(struct rtlx_info *rtlxi) 
}



/* notifications */

static void starting(int vpe)

void rtlx_starting(int vpe)

{

	int i;

	sp_stopping = 0;
@@ -140,7 +100,7 @@ static void starting(int vpe) 
		wake_up_interruptible(&channel_wqs[i].lx_queue);

}



static void stopping(int vpe)

void rtlx_stopping(int vpe)

{

	int i;
@@ -384,6 +344,8 @@ out: 
	smp_wmb();

	mutex_unlock(&channel_wqs[index].mutex);



	_interrupt_sp();



	return count;

}
@@ -454,7 +416,7 @@ static ssize_t file_write(struct file *file, const char __user * buffer, 
	return rtlx_write(minor, buffer, count);

}



static const struct file_operations rtlx_fops = {

const struct file_operations rtlx_fops = {

	.owner =   THIS_MODULE,

	.open =	   file_open,

	.release = file_release,
@@ -464,90 +426,6 @@ static const struct file_operations rtlx_fops = { 
	.llseek =  noop_llseek,

};



static struct irqaction rtlx_irq = {

	.handler	= rtlx_interrupt,

	.name		= "RTLX",

};



static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;



static char register_chrdev_failed[] __initdata =

	KERN_ERR "rtlx_module_init: unable to register device\n";



static int __init rtlx_module_init(void)

{

	struct device *dev;

	int i, err;



	if (!cpu_has_mipsmt) {

		printk("VPE loader: not a MIPS MT capable processor\n");

		return -ENODEV;

	}



	if (tclimit == 0) {

		printk(KERN_WARNING "No TCs reserved for AP/SP, not "

		       "initializing RTLX.\nPass maxtcs=<n> argument as kernel "

		       "argument\n");



		return -ENODEV;

	}



	major = register_chrdev(0, module_name, &rtlx_fops);

	if (major < 0) {

		printk(register_chrdev_failed);

		return major;

	}



	/* initialise the wait queues */

	for (i = 0; i < RTLX_CHANNELS; i++) {

		init_waitqueue_head(&channel_wqs[i].rt_queue);

		init_waitqueue_head(&channel_wqs[i].lx_queue);

		atomic_set(&channel_wqs[i].in_open, 0);

		mutex_init(&channel_wqs[i].mutex);



		dev = device_create(mt_class, NULL, MKDEV(major, i), NULL,

				    "%s%d", module_name, i);

		if (IS_ERR(dev)) {

			err = PTR_ERR(dev);

			goto out_chrdev;

		}

	}



	/* set up notifiers */

	notify.start = starting;

	notify.stop = stopping;

	vpe_notify(tclimit, &notify);



	if (cpu_has_vint)

		set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch);

	else {

		pr_err("APRP RTLX init on non-vectored-interrupt processor\n");

		err = -ENODEV;

		goto out_chrdev;

	}



	rtlx_irq.dev_id = rtlx;

	setup_irq(rtlx_irq_num, &rtlx_irq);



	return 0;



out_chrdev:

	for (i = 0; i < RTLX_CHANNELS; i++)

		device_destroy(mt_class, MKDEV(major, i));



	return err;

}



static void __exit rtlx_module_exit(void)

{

	int i;



	for (i = 0; i < RTLX_CHANNELS; i++)

		device_destroy(mt_class, MKDEV(major, i));



	unregister_chrdev(major, module_name);

}



module_init(rtlx_module_init);

module_exit(rtlx_module_exit);