John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 1 | /* |
| 2 | * This file contains common code that is intended to be used across |
| 3 | * boards so that it's not replicated. |
| 4 | * |
| 5 | * Copyright (C) 2011 Xilinx |
| 6 | * |
| 7 | * This software is licensed under the terms of the GNU General Public |
| 8 | * License version 2, as published by the Free Software Foundation, and |
| 9 | * may be copied, distributed, and modified under those terms. |
| 10 | * |
| 11 | * This program is distributed in the hope that it will be useful, |
| 12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | * GNU General Public License for more details. |
| 15 | */ |
| 16 | |
| 17 | #include <linux/init.h> |
| 18 | #include <linux/kernel.h> |
| 19 | #include <linux/cpumask.h> |
| 20 | #include <linux/platform_device.h> |
| 21 | #include <linux/clk.h> |
Michal Simek | 4a32c74 | 2014-02-05 15:41:51 +0100 | [diff] [blame] | 22 | #include <linux/clk-provider.h> |
Josh Cartwright | 0f586fb | 2012-11-08 12:04:26 -0600 | [diff] [blame] | 23 | #include <linux/clk/zynq.h> |
Michal Simek | e932900 | 2013-03-20 10:15:28 +0100 | [diff] [blame] | 24 | #include <linux/clocksource.h> |
Josh Cartwright | 0f586fb | 2012-11-08 12:04:26 -0600 | [diff] [blame] | 25 | #include <linux/of_address.h> |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 26 | #include <linux/of_irq.h> |
| 27 | #include <linux/of_platform.h> |
Arnd Bergmann | 3d64b44 | 2011-07-07 11:35:20 +0000 | [diff] [blame] | 28 | #include <linux/of.h> |
Michal Simek | 46f5b96 | 2014-01-31 12:55:06 +0100 | [diff] [blame] | 29 | #include <linux/memblock.h> |
Soren Brinkmann | 9f4f5d2 | 2013-10-31 09:10:18 -0700 | [diff] [blame] | 30 | #include <linux/irqchip.h> |
| 31 | #include <linux/irqchip/arm-gic.h> |
Michal Simek | 00f7dc6 | 2013-07-31 09:19:59 +0200 | [diff] [blame] | 32 | #include <linux/slab.h> |
| 33 | #include <linux/sys_soc.h> |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 34 | |
Arnd Bergmann | 3d64b44 | 2011-07-07 11:35:20 +0000 | [diff] [blame] | 35 | #include <asm/mach/arch.h> |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 36 | #include <asm/mach/map.h> |
Josh Cartwright | 03e0759 | 2012-10-31 11:11:59 -0600 | [diff] [blame] | 37 | #include <asm/mach/time.h> |
Arnd Bergmann | 3d64b44 | 2011-07-07 11:35:20 +0000 | [diff] [blame] | 38 | #include <asm/mach-types.h> |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 39 | #include <asm/page.h> |
Josh Cartwright | 9a45eb6 | 2012-11-19 11:38:29 -0600 | [diff] [blame] | 40 | #include <asm/pgtable.h> |
Michal Simek | 732078c | 2013-03-20 11:11:43 +0100 | [diff] [blame] | 41 | #include <asm/smp_scu.h> |
Michal Simek | 00f7dc6 | 2013-07-31 09:19:59 +0200 | [diff] [blame] | 42 | #include <asm/system_info.h> |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 43 | #include <asm/hardware/cache-l2x0.h> |
| 44 | |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 45 | #include "common.h" |
| 46 | |
Michal Simek | 00f7dc6 | 2013-07-31 09:19:59 +0200 | [diff] [blame] | 47 | #define ZYNQ_DEVCFG_MCTRL 0x80 |
| 48 | #define ZYNQ_DEVCFG_PS_VERSION_SHIFT 28 |
| 49 | #define ZYNQ_DEVCFG_PS_VERSION_MASK 0xF |
| 50 | |
Michal Simek | 732078c | 2013-03-20 11:11:43 +0100 | [diff] [blame] | 51 | void __iomem *zynq_scu_base; |
| 52 | |
Michal Simek | 46f5b96 | 2014-01-31 12:55:06 +0100 | [diff] [blame] | 53 | /** |
| 54 | * zynq_memory_init - Initialize special memory |
| 55 | * |
| 56 | * We need to stop things allocating the low memory as DMA can't work in |
| 57 | * the 1st 512K of memory. |
| 58 | */ |
| 59 | static void __init zynq_memory_init(void) |
| 60 | { |
| 61 | if (!__pa(PAGE_OFFSET)) |
| 62 | memblock_reserve(__pa(PAGE_OFFSET), __pa(swapper_pg_dir)); |
| 63 | } |
| 64 | |
Daniel Lezcano | 3e8ceca | 2013-09-21 18:41:02 +0200 | [diff] [blame] | 65 | static struct platform_device zynq_cpuidle_device = { |
| 66 | .name = "cpuidle-zynq", |
| 67 | }; |
| 68 | |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 69 | /** |
Michal Simek | 00f7dc6 | 2013-07-31 09:19:59 +0200 | [diff] [blame] | 70 | * zynq_get_revision - Get Zynq silicon revision |
| 71 | * |
| 72 | * Return: Silicon version or -1 otherwise |
| 73 | */ |
| 74 | static int __init zynq_get_revision(void) |
| 75 | { |
| 76 | struct device_node *np; |
| 77 | void __iomem *zynq_devcfg_base; |
| 78 | u32 revision; |
| 79 | |
| 80 | np = of_find_compatible_node(NULL, NULL, "xlnx,zynq-devcfg-1.0"); |
| 81 | if (!np) { |
| 82 | pr_err("%s: no devcfg node found\n", __func__); |
| 83 | return -1; |
| 84 | } |
| 85 | |
| 86 | zynq_devcfg_base = of_iomap(np, 0); |
| 87 | if (!zynq_devcfg_base) { |
| 88 | pr_err("%s: Unable to map I/O memory\n", __func__); |
| 89 | return -1; |
| 90 | } |
| 91 | |
| 92 | revision = readl(zynq_devcfg_base + ZYNQ_DEVCFG_MCTRL); |
| 93 | revision >>= ZYNQ_DEVCFG_PS_VERSION_SHIFT; |
| 94 | revision &= ZYNQ_DEVCFG_PS_VERSION_MASK; |
| 95 | |
| 96 | iounmap(zynq_devcfg_base); |
| 97 | |
| 98 | return revision; |
| 99 | } |
| 100 | |
| 101 | /** |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 102 | * zynq_init_machine - System specific initialization, intended to be |
| 103 | * called from board specific initialization. |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 104 | */ |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 105 | static void __init zynq_init_machine(void) |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 106 | { |
Soren Brinkmann | cd32529 | 2014-02-19 15:14:44 -0800 | [diff] [blame] | 107 | struct platform_device_info devinfo = { .name = "cpufreq-cpu0", }; |
Michal Simek | 00f7dc6 | 2013-07-31 09:19:59 +0200 | [diff] [blame] | 108 | struct soc_device_attribute *soc_dev_attr; |
| 109 | struct soc_device *soc_dev; |
| 110 | struct device *parent = NULL; |
Soren Brinkmann | cd32529 | 2014-02-19 15:14:44 -0800 | [diff] [blame] | 111 | |
Michal Simek | 00f7dc6 | 2013-07-31 09:19:59 +0200 | [diff] [blame] | 112 | soc_dev_attr = kzalloc(sizeof(*soc_dev_attr), GFP_KERNEL); |
| 113 | if (!soc_dev_attr) |
| 114 | goto out; |
| 115 | |
| 116 | system_rev = zynq_get_revision(); |
| 117 | |
| 118 | soc_dev_attr->family = kasprintf(GFP_KERNEL, "Xilinx Zynq"); |
| 119 | soc_dev_attr->revision = kasprintf(GFP_KERNEL, "0x%x", system_rev); |
| 120 | soc_dev_attr->soc_id = kasprintf(GFP_KERNEL, "0x%x", |
| 121 | zynq_slcr_get_device_id()); |
| 122 | |
| 123 | soc_dev = soc_device_register(soc_dev_attr); |
| 124 | if (IS_ERR(soc_dev)) { |
| 125 | kfree(soc_dev_attr->family); |
| 126 | kfree(soc_dev_attr->revision); |
| 127 | kfree(soc_dev_attr->soc_id); |
| 128 | kfree(soc_dev_attr); |
| 129 | goto out; |
| 130 | } |
| 131 | |
| 132 | parent = soc_device_to_device(soc_dev); |
| 133 | |
| 134 | out: |
| 135 | /* |
| 136 | * Finished with the static registrations now; fill in the missing |
| 137 | * devices |
| 138 | */ |
| 139 | of_platform_populate(NULL, of_default_bus_match_table, NULL, parent); |
Daniel Lezcano | 3e8ceca | 2013-09-21 18:41:02 +0200 | [diff] [blame] | 140 | |
| 141 | platform_device_register(&zynq_cpuidle_device); |
Soren Brinkmann | cd32529 | 2014-02-19 15:14:44 -0800 | [diff] [blame] | 142 | platform_device_register_full(&devinfo); |
Michal Simek | 016f4dc | 2013-11-26 15:41:31 +0100 | [diff] [blame] | 143 | |
| 144 | zynq_slcr_init(); |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 145 | } |
| 146 | |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 147 | static void __init zynq_timer_init(void) |
Josh Cartwright | 03e0759 | 2012-10-31 11:11:59 -0600 | [diff] [blame] | 148 | { |
Michal Simek | 016f4dc | 2013-11-26 15:41:31 +0100 | [diff] [blame] | 149 | zynq_early_slcr_init(); |
Steffen Trumtrar | 6f69c7f | 2013-06-25 22:05:24 +0200 | [diff] [blame] | 150 | |
Michal Simek | b0504e3 | 2013-11-18 16:48:19 +0100 | [diff] [blame] | 151 | zynq_clock_init(); |
Michal Simek | 4a32c74 | 2014-02-05 15:41:51 +0100 | [diff] [blame] | 152 | of_clk_init(NULL); |
Michal Simek | c5263bb | 2013-03-20 10:24:59 +0100 | [diff] [blame] | 153 | clocksource_of_init(); |
Josh Cartwright | 03e0759 | 2012-10-31 11:11:59 -0600 | [diff] [blame] | 154 | } |
| 155 | |
Michal Simek | 732078c | 2013-03-20 11:11:43 +0100 | [diff] [blame] | 156 | static struct map_desc zynq_cortex_a9_scu_map __initdata = { |
| 157 | .length = SZ_256, |
| 158 | .type = MT_DEVICE, |
| 159 | }; |
| 160 | |
| 161 | static void __init zynq_scu_map_io(void) |
| 162 | { |
| 163 | unsigned long base; |
| 164 | |
| 165 | base = scu_a9_get_base(); |
| 166 | zynq_cortex_a9_scu_map.pfn = __phys_to_pfn(base); |
| 167 | /* Expected address is in vmalloc area that's why simple assign here */ |
| 168 | zynq_cortex_a9_scu_map.virtual = base; |
| 169 | iotable_init(&zynq_cortex_a9_scu_map, 1); |
| 170 | zynq_scu_base = (void __iomem *)base; |
| 171 | BUG_ON(!zynq_scu_base); |
| 172 | } |
| 173 | |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 174 | /** |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 175 | * zynq_map_io - Create memory mappings needed for early I/O. |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 176 | */ |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 177 | static void __init zynq_map_io(void) |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 178 | { |
Josh Cartwright | 385f02b | 2012-11-19 10:16:01 -0600 | [diff] [blame] | 179 | debug_ll_io_init(); |
Michal Simek | 732078c | 2013-03-20 11:11:43 +0100 | [diff] [blame] | 180 | zynq_scu_map_io(); |
John Linn | b85a3ef | 2011-06-20 11:47:27 -0600 | [diff] [blame] | 181 | } |
Arnd Bergmann | 3d64b44 | 2011-07-07 11:35:20 +0000 | [diff] [blame] | 182 | |
Soren Brinkmann | 9f4f5d2 | 2013-10-31 09:10:18 -0700 | [diff] [blame] | 183 | static void __init zynq_irq_init(void) |
| 184 | { |
| 185 | gic_arch_extn.flags = IRQCHIP_SKIP_SET_WAKE | IRQCHIP_MASK_ON_SUSPEND; |
| 186 | irqchip_init(); |
| 187 | } |
| 188 | |
Vincent Stehlé | fe08bf9 | 2013-06-27 14:42:41 +0200 | [diff] [blame] | 189 | static void zynq_system_reset(enum reboot_mode mode, const char *cmd) |
Michal Simek | 96790f0 | 2013-03-20 11:42:15 +0100 | [diff] [blame] | 190 | { |
| 191 | zynq_slcr_system_reset(); |
| 192 | } |
| 193 | |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 194 | static const char * const zynq_dt_match[] = { |
Josh Cartwright | e06f1a9 | 2012-10-31 12:24:48 -0600 | [diff] [blame] | 195 | "xlnx,zynq-7000", |
Arnd Bergmann | 3d64b44 | 2011-07-07 11:35:20 +0000 | [diff] [blame] | 196 | NULL |
| 197 | }; |
| 198 | |
Arnd Bergmann | 514a590 | 2013-06-13 14:13:37 +0200 | [diff] [blame] | 199 | DT_MACHINE_START(XILINX_EP107, "Xilinx Zynq Platform") |
Russell King | dcf9c7f | 2014-04-28 15:31:11 +0100 | [diff] [blame] | 200 | /* 64KB way size, 8-way associativity, parity disabled */ |
| 201 | .l2c_aux_val = 0x02000000, |
| 202 | .l2c_aux_mask = 0xf0ffffff, |
Michal Simek | aa7eb2b | 2013-03-20 13:50:12 +0100 | [diff] [blame] | 203 | .smp = smp_ops(zynq_smp_ops), |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 204 | .map_io = zynq_map_io, |
Soren Brinkmann | 9f4f5d2 | 2013-10-31 09:10:18 -0700 | [diff] [blame] | 205 | .init_irq = zynq_irq_init, |
Michal Simek | 889faa8 | 2013-03-27 13:07:00 +0100 | [diff] [blame] | 206 | .init_machine = zynq_init_machine, |
| 207 | .init_time = zynq_timer_init, |
| 208 | .dt_compat = zynq_dt_match, |
Michal Simek | 46f5b96 | 2014-01-31 12:55:06 +0100 | [diff] [blame] | 209 | .reserve = zynq_memory_init, |
Michal Simek | 96790f0 | 2013-03-20 11:42:15 +0100 | [diff] [blame] | 210 | .restart = zynq_system_reset, |
Arnd Bergmann | 3d64b44 | 2011-07-07 11:35:20 +0000 | [diff] [blame] | 211 | MACHINE_END |