[mirror_ubuntu-zesty-kernel.git] / arch / arm / mach-bcm / bcm63xx_pmb.c

/*
 * Broadcom BCM63138 PMB initialization for secondary CPU(s)
 *
 * Copyright (C) 2015 Broadcom Corporation
 * Author: Florian Fainelli <f.fainelli@gmail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */
#include <linux/kernel.h>
#include <linux/io.h>
#include <linux/spinlock.h>
#include <linux/reset/bcm63xx_pmb.h>
#include <linux/of.h>
#include <linux/of_address.h>

#include "bcm63xx_smp.h"

/* ARM Control register definitions */
#define CORE_PWR_CTRL_SHIFT	0
#define CORE_PWR_CTRL_MASK	0x3
#define PLL_PWR_ON		BIT(8)
#define PLL_LDO_PWR_ON		BIT(9)
#define PLL_CLAMP_ON		BIT(10)
#define CPU_RESET_N(x)		BIT(13 + (x))
#define NEON_RESET_N		BIT(15)
#define PWR_CTRL_STATUS_SHIFT	28
#define PWR_CTRL_STATUS_MASK	0x3
#define PWR_DOWN_SHIFT		30
#define PWR_DOWN_MASK		0x3

/* CPU Power control register definitions */
#define MEM_PWR_OK		BIT(0)
#define MEM_PWR_ON		BIT(1)
#define MEM_CLAMP_ON		BIT(2)
#define MEM_PWR_OK_STATUS	BIT(4)
#define MEM_PWR_ON_STATUS	BIT(5)
#define MEM_PDA_SHIFT		8
#define MEM_PDA_MASK		0xf
#define  MEM_PDA_CPU_MASK	0x1
#define  MEM_PDA_NEON_MASK	0xf
#define CLAMP_ON		BIT(15)
#define PWR_OK_SHIFT		16
#define PWR_OK_MASK		0xf
#define PWR_ON_SHIFT		20
#define  PWR_CPU_MASK		0x03
#define  PWR_NEON_MASK		0x01
#define PWR_ON_MASK		0xf
#define PWR_OK_STATUS_SHIFT	24
#define PWR_OK_STATUS_MASK	0xf
#define PWR_ON_STATUS_SHIFT	28
#define PWR_ON_STATUS_MASK	0xf

#define ARM_CONTROL		0x30
#define ARM_PWR_CONTROL_BASE	0x34
#define ARM_PWR_CONTROL(x)	(ARM_PWR_CONTROL_BASE + (x) * 0x4)
#define ARM_NEON_L2		0x3c

/* Perform a value write, then spin until the value shifted by
 * shift is seen, masked with mask and is different from cond.
 */
static int bpcm_wr_rd_mask(void __iomem *master,
			   unsigned int addr, u32 off, u32 *val,
			   u32 shift, u32 mask, u32 cond)
{
	int ret;

	ret = bpcm_wr(master, addr, off, *val);
	if (ret)
		return ret;

	do {
		ret = bpcm_rd(master, addr, off, val);
		if (ret)
			return ret;

		cpu_relax();
	} while (((*val >> shift) & mask) != cond);

	return ret;
}

/* Global lock to serialize accesses to the PMB registers while we
 * are bringing up the secondary CPU
 */
static DEFINE_SPINLOCK(pmb_lock);

static int bcm63xx_pmb_get_resources(struct device_node *dn,
				     void __iomem **base,
				     unsigned int *cpu,
				     unsigned int *addr)
{
	struct device_node *pmb_dn;
	struct of_phandle_args args;
	int ret;

	ret = of_property_read_u32(dn, "reg", cpu);
	if (ret) {
		pr_err("CPU is missing a reg node\n");
		return ret;
	}

	ret = of_parse_phandle_with_args(dn, "resets", "#reset-cells",
					 0, &args);
	if (ret) {
		pr_err("CPU is missing a resets phandle\n");
		return ret;
	}

	pmb_dn = args.np;
	if (args.args_count != 2) {
		pr_err("reset-controller does not conform to reset-cells\n");
		return -EINVAL;
	}

	*base = of_iomap(args.np, 0);
	if (!*base) {
		pr_err("failed remapping PMB register\n");
		return -ENOMEM;
	}

	/* We do not need the number of zones */
	*addr = args.args[0];

	return 0;
}

int bcm63xx_pmb_power_on_cpu(struct device_node *dn)
{
	void __iomem *base;
	unsigned int cpu, addr;
	unsigned long flags;
	u32 val, ctrl;
	int ret;

	ret = bcm63xx_pmb_get_resources(dn, &base, &cpu, &addr);
	if (ret)
		return ret;

	/* We would not know how to enable a third and greater CPU */
	WARN_ON(cpu > 1);

	spin_lock_irqsave(&pmb_lock, flags);

	/* Check if the CPU is already on and save the ARM_CONTROL register
	 * value since we will use it later for CPU de-assert once done with
	 * the CPU-specific power sequence
	 */
	ret = bpcm_rd(base, addr, ARM_CONTROL, &ctrl);
	if (ret)
		goto out;

	if (ctrl & CPU_RESET_N(cpu)) {
		pr_info("PMB: CPU%d is already powered on\n", cpu);
		ret = 0;
		goto out;
	}

	/* Power on PLL */
	ret = bpcm_rd(base, addr, ARM_PWR_CONTROL(cpu), &val);
	if (ret)
		goto out;

	val |= (PWR_CPU_MASK << PWR_ON_SHIFT);

	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
			PWR_ON_STATUS_SHIFT, PWR_CPU_MASK, PWR_CPU_MASK);
	if (ret)
		goto out;

	val |= (PWR_CPU_MASK << PWR_OK_SHIFT);

	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
			PWR_OK_STATUS_SHIFT, PWR_CPU_MASK, PWR_CPU_MASK);
	if (ret)
		goto out;

	val &= ~CLAMP_ON;

	ret = bpcm_wr(base, addr, ARM_PWR_CONTROL(cpu), val);
	if (ret)
		goto out;

	/* Power on CPU<N> RAM */
	val &= ~(MEM_PDA_MASK << MEM_PDA_SHIFT);

	ret = bpcm_wr(base, addr, ARM_PWR_CONTROL(cpu), val);
	if (ret)
		goto out;

	val |= MEM_PWR_ON;

	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
			0, MEM_PWR_ON_STATUS, MEM_PWR_ON_STATUS);
	if (ret)
		goto out;

	val |= MEM_PWR_OK;

	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
			0, MEM_PWR_OK_STATUS, MEM_PWR_OK_STATUS);
	if (ret)
		goto out;

	val &= ~MEM_CLAMP_ON;

	ret = bpcm_wr(base, addr, ARM_PWR_CONTROL(cpu), val);
	if (ret)
		goto out;

	/* De-assert CPU reset */
	ctrl |= CPU_RESET_N(cpu);

	ret = bpcm_wr(base, addr, ARM_CONTROL, ctrl);
out:
	spin_unlock_irqrestore(&pmb_lock, flags);
	iounmap(base);
	return ret;
}
Commit	Line	Data
3f2a43c9 FF	1	/*
	2	* Broadcom BCM63138 PMB initialization for secondary CPU(s)
	3	*
	4	* Copyright (C) 2015 Broadcom Corporation
	5	* Author: Florian Fainelli <f.fainelli@gmail.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*/
	12	#include <linux/kernel.h>
	13	#include <linux/io.h>
	14	#include <linux/spinlock.h>
	15	#include <linux/reset/bcm63xx_pmb.h>
	16	#include <linux/of.h>
	17	#include <linux/of_address.h>
	18
	19	#include "bcm63xx_smp.h"
	20
	21	/* ARM Control register definitions */
	22	#define CORE_PWR_CTRL_SHIFT 0
	23	#define CORE_PWR_CTRL_MASK 0x3
	24	#define PLL_PWR_ON BIT(8)
	25	#define PLL_LDO_PWR_ON BIT(9)
	26	#define PLL_CLAMP_ON BIT(10)
	27	#define CPU_RESET_N(x) BIT(13 + (x))
	28	#define NEON_RESET_N BIT(15)
	29	#define PWR_CTRL_STATUS_SHIFT 28
	30	#define PWR_CTRL_STATUS_MASK 0x3
	31	#define PWR_DOWN_SHIFT 30
	32	#define PWR_DOWN_MASK 0x3
	33
	34	/* CPU Power control register definitions */
	35	#define MEM_PWR_OK BIT(0)
	36	#define MEM_PWR_ON BIT(1)
	37	#define MEM_CLAMP_ON BIT(2)
	38	#define MEM_PWR_OK_STATUS BIT(4)
	39	#define MEM_PWR_ON_STATUS BIT(5)
	40	#define MEM_PDA_SHIFT 8
	41	#define MEM_PDA_MASK 0xf
	42	#define MEM_PDA_CPU_MASK 0x1
	43	#define MEM_PDA_NEON_MASK 0xf
	44	#define CLAMP_ON BIT(15)
	45	#define PWR_OK_SHIFT 16
	46	#define PWR_OK_MASK 0xf
	47	#define PWR_ON_SHIFT 20
	48	#define PWR_CPU_MASK 0x03
	49	#define PWR_NEON_MASK 0x01
	50	#define PWR_ON_MASK 0xf
	51	#define PWR_OK_STATUS_SHIFT 24
	52	#define PWR_OK_STATUS_MASK 0xf
	53	#define PWR_ON_STATUS_SHIFT 28
	54	#define PWR_ON_STATUS_MASK 0xf
	55
	56	#define ARM_CONTROL 0x30
	57	#define ARM_PWR_CONTROL_BASE 0x34
	58	#define ARM_PWR_CONTROL(x) (ARM_PWR_CONTROL_BASE + (x) * 0x4)
	59	#define ARM_NEON_L2 0x3c
	60
	61	/* Perform a value write, then spin until the value shifted by
	62	* shift is seen, masked with mask and is different from cond.
	63	*/
	64	static int bpcm_wr_rd_mask(void __iomem *master,
65	unsigned int addr, u32 off, u32 *val,
66	u32 shift, u32 mask, u32 cond)
67	{
68	int ret;
69
70	ret = bpcm_wr(master, addr, off, *val);
71	if (ret)
72	return ret;
73
74	do {
75	ret = bpcm_rd(master, addr, off, val);
76	if (ret)
77	return ret;
78
79	cpu_relax();
80	} while (((*val >> shift) & mask) != cond);
81
82	return ret;
83	}
84
85	/* Global lock to serialize accesses to the PMB registers while we
86	* are bringing up the secondary CPU
87	*/
88	static DEFINE_SPINLOCK(pmb_lock);
89
90	static int bcm63xx_pmb_get_resources(struct device_node *dn,
91	void __iomem **base,
92	unsigned int *cpu,
93	unsigned int *addr)
94	{
95	struct device_node *pmb_dn;
96	struct of_phandle_args args;
97	int ret;
98
99	ret = of_property_read_u32(dn, "reg", cpu);
100	if (ret) {
101	pr_err("CPU is missing a reg node\n");
102	return ret;
103	}
104
105	ret = of_parse_phandle_with_args(dn, "resets", "#reset-cells",
106	0, &args);
107	if (ret) {
108	pr_err("CPU is missing a resets phandle\n");
109	return ret;
110	}
111
112	pmb_dn = args.np;
113	if (args.args_count != 2) {
114	pr_err("reset-controller does not conform to reset-cells\n");
115	return -EINVAL;
116	}
117
118	*base = of_iomap(args.np, 0);
119	if (!*base) {
120	pr_err("failed remapping PMB register\n");
121	return -ENOMEM;
122	}
123
124	/* We do not need the number of zones */
125	*addr = args.args[0];
126
127	return 0;
128	}
129
130	int bcm63xx_pmb_power_on_cpu(struct device_node *dn)
131	{
132	void __iomem *base;
133	unsigned int cpu, addr;
134	unsigned long flags;
135	u32 val, ctrl;
136	int ret;
137
138	ret = bcm63xx_pmb_get_resources(dn, &base, &cpu, &addr);
139	if (ret)
140	return ret;
141
142	/* We would not know how to enable a third and greater CPU */
143	WARN_ON(cpu > 1);
144
145	spin_lock_irqsave(&pmb_lock, flags);
146
147	/* Check if the CPU is already on and save the ARM_CONTROL register
148	* value since we will use it later for CPU de-assert once done with
149	* the CPU-specific power sequence
150	*/
151	ret = bpcm_rd(base, addr, ARM_CONTROL, &ctrl);
152	if (ret)
3cc63056	153	goto out;
3f2a43c9 FF	154
	155	if (ctrl & CPU_RESET_N(cpu)) {
	156	pr_info("PMB: CPU%d is already powered on\n", cpu);
	157	ret = 0;
	158	goto out;
	159	}
	160
	161	/* Power on PLL */
	162	ret = bpcm_rd(base, addr, ARM_PWR_CONTROL(cpu), &val);
	163	if (ret)
	164	goto out;
	165
	166	val \|= (PWR_CPU_MASK << PWR_ON_SHIFT);
	167
	168	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
	169	PWR_ON_STATUS_SHIFT, PWR_CPU_MASK, PWR_CPU_MASK);
	170	if (ret)
	171	goto out;
	172
	173	val \|= (PWR_CPU_MASK << PWR_OK_SHIFT);
	174
	175	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
	176	PWR_OK_STATUS_SHIFT, PWR_CPU_MASK, PWR_CPU_MASK);
	177	if (ret)
	178	goto out;
	179
	180	val &= ~CLAMP_ON;
	181
	182	ret = bpcm_wr(base, addr, ARM_PWR_CONTROL(cpu), val);
	183	if (ret)
	184	goto out;
	185
	186	/* Power on CPU<N> RAM */
	187	val &= ~(MEM_PDA_MASK << MEM_PDA_SHIFT);
	188
	189	ret = bpcm_wr(base, addr, ARM_PWR_CONTROL(cpu), val);
	190	if (ret)
	191	goto out;
	192
	193	val \|= MEM_PWR_ON;
	194
	195	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
	196	0, MEM_PWR_ON_STATUS, MEM_PWR_ON_STATUS);
	197	if (ret)
	198	goto out;
	199
	200	val \|= MEM_PWR_OK;
	201
	202	ret = bpcm_wr_rd_mask(base, addr, ARM_PWR_CONTROL(cpu), &val,
	203	0, MEM_PWR_OK_STATUS, MEM_PWR_OK_STATUS);
	204	if (ret)
	205	goto out;
	206
	207	val &= ~MEM_CLAMP_ON;
	208
	209	ret = bpcm_wr(base, addr, ARM_PWR_CONTROL(cpu), val);
	210	if (ret)
	211	goto out;
	212
	213	/* De-assert CPU reset */
	214	ctrl \|= CPU_RESET_N(cpu);
	215
	216	ret = bpcm_wr(base, addr, ARM_CONTROL, ctrl);
	217	out:
218	spin_unlock_irqrestore(&pmb_lock, flags);
219	iounmap(base);
220	return ret;
221	}