Loading...
1/*
2 * SH generic board support, using device tree
3 *
4 * Copyright (C) 2015-2016 Smart Energy Instruments, Inc.
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 */
10
11#include <linux/of.h>
12#include <linux/of_fdt.h>
13#include <linux/clocksource.h>
14#include <linux/irqchip.h>
15#include <linux/clk-provider.h>
16#include <asm/machvec.h>
17#include <asm/rtc.h>
18
19#ifdef CONFIG_SMP
20
21static void dummy_smp_setup(void)
22{
23}
24
25static void dummy_prepare_cpus(unsigned int max_cpus)
26{
27}
28
29static void dummy_start_cpu(unsigned int cpu, unsigned long entry_point)
30{
31}
32
33static unsigned int dummy_smp_processor_id(void)
34{
35 return 0;
36}
37
38static void dummy_send_ipi(unsigned int cpu, unsigned int message)
39{
40}
41
42static struct plat_smp_ops dummy_smp_ops = {
43 .smp_setup = dummy_smp_setup,
44 .prepare_cpus = dummy_prepare_cpus,
45 .start_cpu = dummy_start_cpu,
46 .smp_processor_id = dummy_smp_processor_id,
47 .send_ipi = dummy_send_ipi,
48 .cpu_die = native_cpu_die,
49 .cpu_disable = native_cpu_disable,
50 .play_dead = native_play_dead,
51};
52
53extern const struct of_cpu_method __cpu_method_of_table[];
54const struct of_cpu_method __cpu_method_of_table_sentinel
55 __section(__cpu_method_of_table_end);
56
57static void sh_of_smp_probe(void)
58{
59 struct device_node *np = 0;
60 const char *method = 0;
61 const struct of_cpu_method *m = __cpu_method_of_table;
62
63 pr_info("SH generic board support: scanning for cpus\n");
64
65 init_cpu_possible(cpumask_of(0));
66
67 while ((np = of_find_node_by_type(np, "cpu"))) {
68 const __be32 *cell = of_get_property(np, "reg", NULL);
69 u64 id = -1;
70 if (cell) id = of_read_number(cell, of_n_addr_cells(np));
71 if (id < NR_CPUS) {
72 if (!method)
73 of_property_read_string(np, "enable-method", &method);
74 set_cpu_possible(id, true);
75 set_cpu_present(id, true);
76 __cpu_number_map[id] = id;
77 __cpu_logical_map[id] = id;
78 }
79 }
80 if (!method) {
81 np = of_find_node_by_name(NULL, "cpus");
82 of_property_read_string(np, "enable-method", &method);
83 }
84
85 pr_info("CPU enable method: %s\n", method);
86 if (method)
87 for (; m->method; m++)
88 if (!strcmp(m->method, method)) {
89 register_smp_ops(m->ops);
90 return;
91 }
92
93 register_smp_ops(&dummy_smp_ops);
94}
95
96#else
97
98static void sh_of_smp_probe(void)
99{
100}
101
102#endif
103
104static void noop(void)
105{
106}
107
108static int noopi(void)
109{
110 return 0;
111}
112
113static void __init sh_of_mem_reserve(void)
114{
115 early_init_fdt_reserve_self();
116 early_init_fdt_scan_reserved_mem();
117}
118
119static void __init sh_of_time_init(void)
120{
121 pr_info("SH generic board support: scanning for clocksource devices\n");
122 timer_probe();
123}
124
125static void __init sh_of_setup(char **cmdline_p)
126{
127 struct device_node *root;
128
129 board_time_init = sh_of_time_init;
130
131 sh_mv.mv_name = "Unknown SH model";
132 root = of_find_node_by_path("/");
133 if (root) {
134 of_property_read_string(root, "model", &sh_mv.mv_name);
135 of_node_put(root);
136 }
137
138 sh_of_smp_probe();
139}
140
141static int sh_of_irq_demux(int irq)
142{
143 /* FIXME: eventually this should not be used at all;
144 * the interrupt controller should set_handle_irq(). */
145 return irq;
146}
147
148static void __init sh_of_init_irq(void)
149{
150 pr_info("SH generic board support: scanning for interrupt controllers\n");
151 irqchip_init();
152}
153
154static int __init sh_of_clk_init(void)
155{
156#ifdef CONFIG_COMMON_CLK
157 /* Disabled pending move to COMMON_CLK framework. */
158 pr_info("SH generic board support: scanning for clk providers\n");
159 of_clk_init(NULL);
160#endif
161 return 0;
162}
163
164static struct sh_machine_vector __initmv sh_of_generic_mv = {
165 .mv_setup = sh_of_setup,
166 .mv_name = "devicetree", /* replaced by DT root's model */
167 .mv_irq_demux = sh_of_irq_demux,
168 .mv_init_irq = sh_of_init_irq,
169 .mv_clk_init = sh_of_clk_init,
170 .mv_mode_pins = noopi,
171 .mv_mem_init = noop,
172 .mv_mem_reserve = sh_of_mem_reserve,
173};
174
175struct sh_clk_ops;
176
177void __init arch_init_clk_ops(struct sh_clk_ops **ops, int idx)
178{
179}
180
181void __init plat_irq_setup(void)
182{
183}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * SH generic board support, using device tree
4 *
5 * Copyright (C) 2015-2016 Smart Energy Instruments, Inc.
6 */
7
8#include <linux/of.h>
9#include <linux/of_clk.h>
10#include <linux/of_fdt.h>
11#include <linux/clocksource.h>
12#include <linux/irqchip.h>
13#include <asm/machvec.h>
14#include <asm/rtc.h>
15
16#ifdef CONFIG_SMP
17
18static void dummy_smp_setup(void)
19{
20}
21
22static void dummy_prepare_cpus(unsigned int max_cpus)
23{
24}
25
26static void dummy_start_cpu(unsigned int cpu, unsigned long entry_point)
27{
28}
29
30static unsigned int dummy_smp_processor_id(void)
31{
32 return 0;
33}
34
35static void dummy_send_ipi(unsigned int cpu, unsigned int message)
36{
37}
38
39static struct plat_smp_ops dummy_smp_ops = {
40 .smp_setup = dummy_smp_setup,
41 .prepare_cpus = dummy_prepare_cpus,
42 .start_cpu = dummy_start_cpu,
43 .smp_processor_id = dummy_smp_processor_id,
44 .send_ipi = dummy_send_ipi,
45 .cpu_die = native_cpu_die,
46 .cpu_disable = native_cpu_disable,
47 .play_dead = native_play_dead,
48};
49
50extern const struct of_cpu_method __cpu_method_of_table[];
51const struct of_cpu_method __cpu_method_of_table_sentinel
52 __section("__cpu_method_of_table_end");
53
54static void sh_of_smp_probe(void)
55{
56 struct device_node *np;
57 const char *method = NULL;
58 const struct of_cpu_method *m = __cpu_method_of_table;
59
60 pr_info("SH generic board support: scanning for cpus\n");
61
62 init_cpu_possible(cpumask_of(0));
63
64 for_each_of_cpu_node(np) {
65 u64 id = of_get_cpu_hwid(np, 0);
66
67 if (id < NR_CPUS) {
68 if (!method)
69 of_property_read_string(np, "enable-method", &method);
70 set_cpu_possible(id, true);
71 set_cpu_present(id, true);
72 __cpu_number_map[id] = id;
73 __cpu_logical_map[id] = id;
74 }
75 }
76 if (!method) {
77 np = of_find_node_by_name(NULL, "cpus");
78 of_property_read_string(np, "enable-method", &method);
79 of_node_put(np);
80 }
81
82 pr_info("CPU enable method: %s\n", method);
83 if (method)
84 for (; m->method; m++)
85 if (!strcmp(m->method, method)) {
86 register_smp_ops(m->ops);
87 return;
88 }
89
90 register_smp_ops(&dummy_smp_ops);
91}
92
93#else
94
95static void sh_of_smp_probe(void)
96{
97}
98
99#endif
100
101static void noop(void)
102{
103}
104
105static int noopi(void)
106{
107 return 0;
108}
109
110static void __init sh_of_mem_reserve(void)
111{
112 early_init_fdt_reserve_self();
113 early_init_fdt_scan_reserved_mem();
114}
115
116static void __init sh_of_setup(char **cmdline_p)
117{
118 struct device_node *root;
119
120 sh_mv.mv_name = "Unknown SH model";
121 root = of_find_node_by_path("/");
122 if (root) {
123 of_property_read_string(root, "model", &sh_mv.mv_name);
124 of_node_put(root);
125 }
126
127 sh_of_smp_probe();
128}
129
130static int sh_of_irq_demux(int irq)
131{
132 /* FIXME: eventually this should not be used at all;
133 * the interrupt controller should set_handle_irq(). */
134 return irq;
135}
136
137static void __init sh_of_init_irq(void)
138{
139 pr_info("SH generic board support: scanning for interrupt controllers\n");
140 irqchip_init();
141}
142
143static int __init sh_of_clk_init(void)
144{
145#ifdef CONFIG_COMMON_CLK
146 /* Disabled pending move to COMMON_CLK framework. */
147 pr_info("SH generic board support: scanning for clk providers\n");
148 of_clk_init(NULL);
149#endif
150 return 0;
151}
152
153static struct sh_machine_vector __initmv sh_of_generic_mv = {
154 .mv_setup = sh_of_setup,
155 .mv_name = "devicetree", /* replaced by DT root's model */
156 .mv_irq_demux = sh_of_irq_demux,
157 .mv_init_irq = sh_of_init_irq,
158 .mv_clk_init = sh_of_clk_init,
159 .mv_mode_pins = noopi,
160 .mv_mem_init = noop,
161 .mv_mem_reserve = sh_of_mem_reserve,
162};
163
164struct sh_clk_ops;
165
166void __init __weak arch_init_clk_ops(struct sh_clk_ops **ops, int idx)
167{
168}
169
170void __init __weak plat_irq_setup(void)
171{
172}