[deliverable/linux.git] / arch / arm / mach-ux500 / cpu.c

/*
 * Copyright (C) ST-Ericsson SA 2010
 *
 * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
 * Author: Lee Jones <lee.jones@linaro.org> for ST-Ericsson
 * License terms: GNU General Public License (GPL) version 2
 */

#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/mfd/dbx500-prcmu.h>
#include <linux/clksrc-dbx500-prcmu.h>
#include <linux/sys_soc.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/stat.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>
#include <linux/irq.h>
#include <linux/irqchip.h>
#include <linux/irqchip/arm-gic.h>
#include <linux/platform_data/clk-ux500.h>
#include <linux/platform_data/arm-ux500-pm.h>

#include <asm/mach/map.h>

#include "setup.h"

#include "board-mop500.h"
#include "db8500-regs.h"
#include "id.h"

void ux500_restart(enum reboot_mode mode, const char *cmd)
{
	local_irq_disable();
	local_fiq_disable();

	prcmu_system_reset(0);
}

/*
 * FIXME: Should we set up the GPIO domain here?
 *
 * The problem is that we cannot put the interrupt resources into the platform
 * device until the irqdomain has been added. Right now, we set the GIC interrupt
 * domain from init_irq(), then load the gpio driver from
 * core_initcall(nmk_gpio_init) and add the platform devices from
 * arch_initcall(customize_machine).
 *
 * This feels fragile because it depends on the gpio device getting probed
 * _before_ any device uses the gpio interrupts.
*/
void __init ux500_init_irq(void)
{
	struct device_node *np;
	struct resource r;

	gic_set_irqchip_flags(IRQCHIP_SKIP_SET_WAKE | IRQCHIP_MASK_ON_SUSPEND);
	irqchip_init();
	np = of_find_compatible_node(NULL, NULL, "stericsson,db8500-prcmu");
	of_address_to_resource(np, 0, &r);
	of_node_put(np);
	if (!r.start) {
		pr_err("could not find PRCMU base resource\n");
		return;
	}
	prcmu_early_init(r.start, r.end-r.start);
	ux500_pm_init(r.start, r.end-r.start);

	/*
	 * Init clocks here so that they are available for system timer
	 * initialization.
	 */
	if (cpu_is_u8500_family()) {
		u8500_of_clk_init(U8500_CLKRST1_BASE,
				  U8500_CLKRST2_BASE,
				  U8500_CLKRST3_BASE,
				  U8500_CLKRST5_BASE,
				  U8500_CLKRST6_BASE);
	} else if (cpu_is_u9540()) {
		u9540_clk_init(U8500_CLKRST1_BASE, U8500_CLKRST2_BASE,
			       U8500_CLKRST3_BASE, U8500_CLKRST5_BASE,
			       U8500_CLKRST6_BASE);
	} else if (cpu_is_u8540()) {
		u8540_clk_init(U8500_CLKRST1_BASE, U8500_CLKRST2_BASE,
			       U8500_CLKRST3_BASE, U8500_CLKRST5_BASE,
			       U8500_CLKRST6_BASE);
	}
}

static const char * __init ux500_get_machine(void)
{
	return kasprintf(GFP_KERNEL, "DB%4x", dbx500_partnumber());
}

static const char * __init ux500_get_family(void)
{
	return kasprintf(GFP_KERNEL, "ux500");
}

static const char * __init ux500_get_revision(void)
{
	unsigned int rev = dbx500_revision();

	if (rev == 0x01)
		return kasprintf(GFP_KERNEL, "%s", "ED");
	else if (rev >= 0xA0)
		return kasprintf(GFP_KERNEL, "%d.%d",
				 (rev >> 4) - 0xA + 1, rev & 0xf);

	return kasprintf(GFP_KERNEL, "%s", "Unknown");
}

static ssize_t ux500_get_process(struct device *dev,
					struct device_attribute *attr,
					char *buf)
{
	if (dbx500_id.process == 0x00)
		return sprintf(buf, "Standard\n");

	return sprintf(buf, "%02xnm\n", dbx500_id.process);
}

static void __init soc_info_populate(struct soc_device_attribute *soc_dev_attr,
				     const char *soc_id)
{
	soc_dev_attr->soc_id   = soc_id;
	soc_dev_attr->machine  = ux500_get_machine();
	soc_dev_attr->family   = ux500_get_family();
	soc_dev_attr->revision = ux500_get_revision();
}

static const struct device_attribute ux500_soc_attr =
	__ATTR(process,  S_IRUGO, ux500_get_process,  NULL);

struct device * __init ux500_soc_device_init(const char *soc_id)
{
	struct device *parent;
	struct soc_device *soc_dev;
	struct soc_device_attribute *soc_dev_attr;

	soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
	if (!soc_dev_attr)
		return ERR_PTR(-ENOMEM);

	soc_info_populate(soc_dev_attr, soc_id);

	soc_dev = soc_device_register(soc_dev_attr);
	if (IS_ERR(soc_dev)) {
	        kfree(soc_dev_attr);
		return NULL;
	}

	parent = soc_device_to_device(soc_dev);
	device_create_file(parent, &ux500_soc_attr);

	return parent;
}
Commit	Line	Data
178980f9 RV	1	/*
	2	* Copyright (C) ST-Ericsson SA 2010
	3	*
	4	* Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
eda413c2	5	* Author: Lee Jones <lee.jones@linaro.org> for ST-Ericsson
178980f9 RV	6	* License terms: GNU General Public License (GPL) version 2
	7	*/
	8
	9	#include <linux/platform_device.h>
178980f9	10	#include <linux/io.h>
9a47a8dc	11	#include <linux/mfd/dbx500-prcmu.h>
7ed00af7	12	#include <linux/clksrc-dbx500-prcmu.h>
eda413c2 LJ	13	#include <linux/sys_soc.h>
	14	#include <linux/err.h>
	15	#include <linux/slab.h>
	16	#include <linux/stat.h>
dab6487e LJ	17	#include <linux/of.h>
dab6487e LJ	18	#include <linux/of_irq.h>
6252bd35	19	#include <linux/of_address.h>
1ae32557	20	#include <linux/irq.h>
0529e315	21	#include <linux/irqchip.h>
520f7bd7	22	#include <linux/irqchip/arm-gic.h>
ebc96db7	23	#include <linux/platform_data/clk-ux500.h>
1e22a8c6	24	#include <linux/platform_data/arm-ux500-pm.h>
178980f9	25
178980f9 RV	26	#include <asm/mach/map.h>
178980f9 RV	27
e657bcf6	28	#include "setup.h"
178980f9	29
0ddf855a	30	#include "board-mop500.h"
174e7796	31	#include "db8500-regs.h"
7a4f2609	32	#include "id.h"
0ddf855a	33
bd93ec50 FB	34	void ux500_restart(enum reboot_mode mode, const char *cmd)
	35	{
	36	local_irq_disable();
	37	local_fiq_disable();
	38
	39	prcmu_system_reset(0);
	40	}
	41
a60b57ed LJ	42	/*
	43	* FIXME: Should we set up the GPIO domain here?
	44	*
	45	* The problem is that we cannot put the interrupt resources into the platform
	46	* device until the irqdomain has been added. Right now, we set the GIC interrupt
	47	* domain from init_irq(), then load the gpio driver from
	48	* core_initcall(nmk_gpio_init) and add the platform devices from
	49	* arch_initcall(customize_machine).
	50	*
	51	* This feels fragile because it depends on the gpio device getting probed
	52	* _before_ any device uses the gpio interrupts.
	53	*/
178980f9 RV	54	void __init ux500_init_irq(void)
178980f9 RV	55	{
6252bd35 LW	56	struct device_node *np;
	57	struct resource r;
	58
23324204	59	gic_set_irqchip_flags(IRQCHIP_SKIP_SET_WAKE \| IRQCHIP_MASK_ON_SUSPEND);
e937274f	60	irqchip_init();
6252bd35 LW	61	np = of_find_compatible_node(NULL, NULL, "stericsson,db8500-prcmu");
	62	of_address_to_resource(np, 0, &r);
	63	of_node_put(np);
	64	if (!r.start) {
	65	pr_err("could not find PRCMU base resource\n");
	66	return;
	67	}
	68	prcmu_early_init(r.start, r.end-r.start);
	69	ux500_pm_init(r.start, r.end-r.start);
ba327b1e LW	70
	71	/*
	72	* Init clocks here so that they are available for system timer
	73	* initialization.
	74	*/
9a47a8dc	75	if (cpu_is_u8500_family()) {
e937274f LJ	76	u8500_of_clk_init(U8500_CLKRST1_BASE,
	77	U8500_CLKRST2_BASE,
	78	U8500_CLKRST3_BASE,
	79	U8500_CLKRST5_BASE,
	80	U8500_CLKRST6_BASE);
9a47a8dc	81	} else if (cpu_is_u9540()) {
1237e598	82	u9540_clk_init(U8500_CLKRST1_BASE, U8500_CLKRST2_BASE,
9b819060 LW	83	U8500_CLKRST3_BASE, U8500_CLKRST5_BASE,
9b819060 LW	84	U8500_CLKRST6_BASE);
9a47a8dc	85	} else if (cpu_is_u8540()) {
1237e598 PB	86	u8540_clk_init(U8500_CLKRST1_BASE, U8500_CLKRST2_BASE,
	87	U8500_CLKRST3_BASE, U8500_CLKRST5_BASE,
	88	U8500_CLKRST6_BASE);
9a47a8dc	89	}
178980f9	90	}
eda413c2 LJ	91
	92	static const char * __init ux500_get_machine(void)
	93	{
	94	return kasprintf(GFP_KERNEL, "DB%4x", dbx500_partnumber());
	95	}
	96
	97	static const char * __init ux500_get_family(void)
	98	{
	99	return kasprintf(GFP_KERNEL, "ux500");
	100	}
	101
	102	static const char * __init ux500_get_revision(void)
	103	{
	104	unsigned int rev = dbx500_revision();
	105
	106	if (rev == 0x01)
	107	return kasprintf(GFP_KERNEL, "%s", "ED");
	108	else if (rev >= 0xA0)
	109	return kasprintf(GFP_KERNEL, "%d.%d",
	110	(rev >> 4) - 0xA + 1, rev & 0xf);
	111
	112	return kasprintf(GFP_KERNEL, "%s", "Unknown");
	113	}
	114
	115	static ssize_t ux500_get_process(struct device *dev,
	116	struct device_attribute *attr,
	117	char *buf)
	118	{
	119	if (dbx500_id.process == 0x00)
	120	return sprintf(buf, "Standard\n");
	121
	122	return sprintf(buf, "%02xnm\n", dbx500_id.process);
	123	}
	124
	125	static void __init soc_info_populate(struct soc_device_attribute *soc_dev_attr,
	126	const char *soc_id)
	127	{
	128	soc_dev_attr->soc_id = soc_id;
	129	soc_dev_attr->machine = ux500_get_machine();
	130	soc_dev_attr->family = ux500_get_family();
	131	soc_dev_attr->revision = ux500_get_revision();
	132	}
	133
51fe0057	134	static const struct device_attribute ux500_soc_attr =
eda413c2 LJ	135	__ATTR(process, S_IRUGO, ux500_get_process, NULL);
	136
	137	struct device * __init ux500_soc_device_init(const char *soc_id)
	138	{
	139	struct device *parent;
	140	struct soc_device *soc_dev;
	141	struct soc_device_attribute *soc_dev_attr;
	142
	143	soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL);
	144	if (!soc_dev_attr)
	145	return ERR_PTR(-ENOMEM);
	146
	147	soc_info_populate(soc_dev_attr, soc_id);
	148
	149	soc_dev = soc_device_register(soc_dev_attr);
b269b170	150	if (IS_ERR(soc_dev)) {
eda413c2 LJ	151	kfree(soc_dev_attr);
	152	return NULL;
	153	}
	154
	155	parent = soc_device_to_device(soc_dev);
b269b170	156	device_create_file(parent, &ux500_soc_attr);
eda413c2 LJ	157
	158	return parent;
	159	}