1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * ARM Specific GTDT table Support
4 *
5 * Copyright (C) 2016, Linaro Ltd.
6 * Author: Daniel Lezcano <daniel.lezcano@linaro.org>
7 * Fu Wei <fu.wei@linaro.org>
8 * Hanjun Guo <hanjun.guo@linaro.org>
9 */
10
11 #include <linux/acpi.h>
12 #include <linux/init.h>
13 #include <linux/irqdomain.h>
14 #include <linux/kernel.h>
15 #include <linux/platform_device.h>
16
17 #include <clocksource/arm_arch_timer.h>
18
19 #undef pr_fmt
20 #define pr_fmt(fmt) "ACPI GTDT: " fmt
21
22 /**
23 * struct acpi_gtdt_descriptor - Store the key info of GTDT for all functions
24 * @gtdt: The pointer to the struct acpi_table_gtdt of GTDT table.
25 * @gtdt_end: The pointer to the end of GTDT table.
26 * @platform_timer: The pointer to the start of Platform Timer Structure
27 *
28 * The struct store the key info of GTDT table, it should be initialized by
29 * acpi_gtdt_init.
30 */
31 struct acpi_gtdt_descriptor {
32 struct acpi_table_gtdt *gtdt;
33 void *gtdt_end;
34 void *platform_timer;
35 };
36
37 static struct acpi_gtdt_descriptor acpi_gtdt_desc __initdata;
38
next_platform_timer(void * platform_timer)39 static inline void *next_platform_timer(void *platform_timer)
40 {
41 struct acpi_gtdt_header *gh = platform_timer;
42
43 platform_timer += gh->length;
44 if (platform_timer < acpi_gtdt_desc.gtdt_end)
45 return platform_timer;
46
47 return NULL;
48 }
49
50 #define for_each_platform_timer(_g) \
51 for (_g = acpi_gtdt_desc.platform_timer; _g; \
52 _g = next_platform_timer(_g))
53
is_timer_block(void * platform_timer)54 static inline bool is_timer_block(void *platform_timer)
55 {
56 struct acpi_gtdt_header *gh = platform_timer;
57
58 return gh->type == ACPI_GTDT_TYPE_TIMER_BLOCK;
59 }
60
is_non_secure_watchdog(void * platform_timer)61 static inline bool is_non_secure_watchdog(void *platform_timer)
62 {
63 struct acpi_gtdt_header *gh = platform_timer;
64 struct acpi_gtdt_watchdog *wd = platform_timer;
65
66 if (gh->type != ACPI_GTDT_TYPE_WATCHDOG)
67 return false;
68
69 return !(wd->timer_flags & ACPI_GTDT_WATCHDOG_SECURE);
70 }
71
map_gt_gsi(u32 interrupt,u32 flags)72 static int __init map_gt_gsi(u32 interrupt, u32 flags)
73 {
74 int trigger, polarity;
75
76 trigger = (flags & ACPI_GTDT_INTERRUPT_MODE) ? ACPI_EDGE_SENSITIVE
77 : ACPI_LEVEL_SENSITIVE;
78
79 polarity = (flags & ACPI_GTDT_INTERRUPT_POLARITY) ? ACPI_ACTIVE_LOW
80 : ACPI_ACTIVE_HIGH;
81
82 return acpi_register_gsi(NULL, interrupt, trigger, polarity);
83 }
84
85 /**
86 * acpi_gtdt_map_ppi() - Map the PPIs of per-cpu arch_timer.
87 * @type: the type of PPI.
88 *
89 * Note: Secure state is not managed by the kernel on ARM64 systems.
90 * So we only handle the non-secure timer PPIs,
91 * ARCH_TIMER_PHYS_SECURE_PPI is treated as invalid type.
92 *
93 * Return: the mapped PPI value, 0 if error.
94 */
acpi_gtdt_map_ppi(int type)95 int __init acpi_gtdt_map_ppi(int type)
96 {
97 struct acpi_table_gtdt *gtdt = acpi_gtdt_desc.gtdt;
98
99 switch (type) {
100 case ARCH_TIMER_PHYS_NONSECURE_PPI:
101 return map_gt_gsi(gtdt->non_secure_el1_interrupt,
102 gtdt->non_secure_el1_flags);
103 case ARCH_TIMER_VIRT_PPI:
104 return map_gt_gsi(gtdt->virtual_timer_interrupt,
105 gtdt->virtual_timer_flags);
106
107 case ARCH_TIMER_HYP_PPI:
108 return map_gt_gsi(gtdt->non_secure_el2_interrupt,
109 gtdt->non_secure_el2_flags);
110 default:
111 pr_err("Failed to map timer interrupt: invalid type.\n");
112 }
113
114 return 0;
115 }
116
117 /**
118 * acpi_gtdt_c3stop() - Got c3stop info from GTDT according to the type of PPI.
119 * @type: the type of PPI.
120 *
121 * Return: true if the timer HW state is lost when a CPU enters an idle state,
122 * false otherwise
123 */
acpi_gtdt_c3stop(int type)124 bool __init acpi_gtdt_c3stop(int type)
125 {
126 struct acpi_table_gtdt *gtdt = acpi_gtdt_desc.gtdt;
127
128 switch (type) {
129 case ARCH_TIMER_PHYS_NONSECURE_PPI:
130 return !(gtdt->non_secure_el1_flags & ACPI_GTDT_ALWAYS_ON);
131
132 case ARCH_TIMER_VIRT_PPI:
133 return !(gtdt->virtual_timer_flags & ACPI_GTDT_ALWAYS_ON);
134
135 case ARCH_TIMER_HYP_PPI:
136 return !(gtdt->non_secure_el2_flags & ACPI_GTDT_ALWAYS_ON);
137
138 default:
139 pr_err("Failed to get c3stop info: invalid type.\n");
140 }
141
142 return false;
143 }
144
145 /**
146 * acpi_gtdt_init() - Get the info of GTDT table to prepare for further init.
147 * @table: The pointer to GTDT table.
148 * @platform_timer_count: It points to a integer variable which is used
149 * for storing the number of platform timers.
150 * This pointer could be NULL, if the caller
151 * doesn't need this info.
152 *
153 * Return: 0 if success, -EINVAL if error.
154 */
acpi_gtdt_init(struct acpi_table_header * table,int * platform_timer_count)155 int __init acpi_gtdt_init(struct acpi_table_header *table,
156 int *platform_timer_count)
157 {
158 void *platform_timer;
159 struct acpi_table_gtdt *gtdt;
160
161 gtdt = container_of(table, struct acpi_table_gtdt, header);
162 acpi_gtdt_desc.gtdt = gtdt;
163 acpi_gtdt_desc.gtdt_end = (void *)table + table->length;
164 acpi_gtdt_desc.platform_timer = NULL;
165 if (platform_timer_count)
166 *platform_timer_count = 0;
167
168 if (table->revision < 2) {
169 pr_warn("Revision:%d doesn't support Platform Timers.\n",
170 table->revision);
171 return 0;
172 }
173
174 if (!gtdt->platform_timer_count) {
175 pr_debug("No Platform Timer.\n");
176 return 0;
177 }
178
179 platform_timer = (void *)gtdt + gtdt->platform_timer_offset;
180 if (platform_timer < (void *)table + sizeof(struct acpi_table_gtdt)) {
181 pr_err(FW_BUG "invalid timer data.\n");
182 return -EINVAL;
183 }
184 acpi_gtdt_desc.platform_timer = platform_timer;
185 if (platform_timer_count)
186 *platform_timer_count = gtdt->platform_timer_count;
187
188 return 0;
189 }
190
gtdt_parse_timer_block(struct acpi_gtdt_timer_block * block,struct arch_timer_mem * timer_mem)191 static int __init gtdt_parse_timer_block(struct acpi_gtdt_timer_block *block,
192 struct arch_timer_mem *timer_mem)
193 {
194 int i;
195 struct arch_timer_mem_frame *frame;
196 struct acpi_gtdt_timer_entry *gtdt_frame;
197
198 if (!block->timer_count) {
199 pr_err(FW_BUG "GT block present, but frame count is zero.\n");
200 return -ENODEV;
201 }
202
203 if (block->timer_count > ARCH_TIMER_MEM_MAX_FRAMES) {
204 pr_err(FW_BUG "GT block lists %d frames, ACPI spec only allows 8\n",
205 block->timer_count);
206 return -EINVAL;
207 }
208
209 timer_mem->cntctlbase = (phys_addr_t)block->block_address;
210 /*
211 * The CNTCTLBase frame is 4KB (register offsets 0x000 - 0xFFC).
212 * See ARM DDI 0487A.k_iss10775, page I1-5129, Table I1-3
213 * "CNTCTLBase memory map".
214 */
215 timer_mem->size = SZ_4K;
216
217 gtdt_frame = (void *)block + block->timer_offset;
218 if (gtdt_frame + block->timer_count != (void *)block + block->header.length)
219 return -EINVAL;
220
221 /*
222 * Get the GT timer Frame data for every GT Block Timer
223 */
224 for (i = 0; i < block->timer_count; i++, gtdt_frame++) {
225 if (gtdt_frame->common_flags & ACPI_GTDT_GT_IS_SECURE_TIMER)
226 continue;
227 if (gtdt_frame->frame_number >= ARCH_TIMER_MEM_MAX_FRAMES ||
228 !gtdt_frame->base_address || !gtdt_frame->timer_interrupt)
229 goto error;
230
231 frame = &timer_mem->frame[gtdt_frame->frame_number];
232
233 /* duplicate frame */
234 if (frame->valid)
235 goto error;
236
237 frame->phys_irq = map_gt_gsi(gtdt_frame->timer_interrupt,
238 gtdt_frame->timer_flags);
239 if (frame->phys_irq <= 0) {
240 pr_warn("failed to map physical timer irq in frame %d.\n",
241 gtdt_frame->frame_number);
242 goto error;
243 }
244
245 if (gtdt_frame->virtual_timer_interrupt) {
246 frame->virt_irq =
247 map_gt_gsi(gtdt_frame->virtual_timer_interrupt,
248 gtdt_frame->virtual_timer_flags);
249 if (frame->virt_irq <= 0) {
250 pr_warn("failed to map virtual timer irq in frame %d.\n",
251 gtdt_frame->frame_number);
252 goto error;
253 }
254 } else {
255 pr_debug("virtual timer in frame %d not implemented.\n",
256 gtdt_frame->frame_number);
257 }
258
259 frame->cntbase = gtdt_frame->base_address;
260 /*
261 * The CNTBaseN frame is 4KB (register offsets 0x000 - 0xFFC).
262 * See ARM DDI 0487A.k_iss10775, page I1-5130, Table I1-4
263 * "CNTBaseN memory map".
264 */
265 frame->size = SZ_4K;
266 frame->valid = true;
267 }
268
269 return 0;
270
271 error:
272 do {
273 if (gtdt_frame->common_flags & ACPI_GTDT_GT_IS_SECURE_TIMER ||
274 gtdt_frame->frame_number >= ARCH_TIMER_MEM_MAX_FRAMES)
275 continue;
276
277 frame = &timer_mem->frame[gtdt_frame->frame_number];
278
279 if (frame->phys_irq > 0)
280 acpi_unregister_gsi(gtdt_frame->timer_interrupt);
281 frame->phys_irq = 0;
282
283 if (frame->virt_irq > 0)
284 acpi_unregister_gsi(gtdt_frame->virtual_timer_interrupt);
285 frame->virt_irq = 0;
286 } while (i-- >= 0 && gtdt_frame--);
287
288 return -EINVAL;
289 }
290
291 /**
292 * acpi_arch_timer_mem_init() - Get the info of all GT blocks in GTDT table.
293 * @timer_mem: The pointer to the array of struct arch_timer_mem for returning
294 * the result of parsing. The element number of this array should
295 * be platform_timer_count(the total number of platform timers).
296 * @timer_count: It points to a integer variable which is used for storing the
297 * number of GT blocks we have parsed.
298 *
299 * Return: 0 if success, -EINVAL/-ENODEV if error.
300 */
acpi_arch_timer_mem_init(struct arch_timer_mem * timer_mem,int * timer_count)301 int __init acpi_arch_timer_mem_init(struct arch_timer_mem *timer_mem,
302 int *timer_count)
303 {
304 int ret;
305 void *platform_timer;
306
307 *timer_count = 0;
308 for_each_platform_timer(platform_timer) {
309 if (is_timer_block(platform_timer)) {
310 ret = gtdt_parse_timer_block(platform_timer, timer_mem);
311 if (ret)
312 return ret;
313 timer_mem++;
314 (*timer_count)++;
315 }
316 }
317
318 if (*timer_count)
319 pr_info("found %d memory-mapped timer block(s).\n",
320 *timer_count);
321
322 return 0;
323 }
324
325 /*
326 * Initialize a SBSA generic Watchdog platform device info from GTDT
327 */
gtdt_import_sbsa_gwdt(struct acpi_gtdt_watchdog * wd,int index)328 static int __init gtdt_import_sbsa_gwdt(struct acpi_gtdt_watchdog *wd,
329 int index)
330 {
331 struct platform_device *pdev;
332 int irq = map_gt_gsi(wd->timer_interrupt, wd->timer_flags);
333
334 /*
335 * According to SBSA specification the size of refresh and control
336 * frames of SBSA Generic Watchdog is SZ_4K(Offset 0x000 – 0xFFF).
337 */
338 struct resource res[] = {
339 DEFINE_RES_MEM(wd->control_frame_address, SZ_4K),
340 DEFINE_RES_MEM(wd->refresh_frame_address, SZ_4K),
341 DEFINE_RES_IRQ(irq),
342 };
343 int nr_res = ARRAY_SIZE(res);
344
345 pr_debug("found a Watchdog (0x%llx/0x%llx gsi:%u flags:0x%x).\n",
346 wd->refresh_frame_address, wd->control_frame_address,
347 wd->timer_interrupt, wd->timer_flags);
348
349 if (!(wd->refresh_frame_address && wd->control_frame_address)) {
350 pr_err(FW_BUG "failed to get the Watchdog base address.\n");
351 acpi_unregister_gsi(wd->timer_interrupt);
352 return -EINVAL;
353 }
354
355 if (irq <= 0) {
356 pr_warn("failed to map the Watchdog interrupt.\n");
357 nr_res--;
358 }
359
360 /*
361 * Add a platform device named "sbsa-gwdt" to match the platform driver.
362 * "sbsa-gwdt": SBSA(Server Base System Architecture) Generic Watchdog
363 * The platform driver can get device info below by matching this name.
364 */
365 pdev = platform_device_register_simple("sbsa-gwdt", index, res, nr_res);
366 if (IS_ERR(pdev)) {
367 acpi_unregister_gsi(wd->timer_interrupt);
368 return PTR_ERR(pdev);
369 }
370
371 return 0;
372 }
373
gtdt_sbsa_gwdt_init(void)374 static int __init gtdt_sbsa_gwdt_init(void)
375 {
376 void *platform_timer;
377 struct acpi_table_header *table;
378 int ret, timer_count, gwdt_count = 0;
379
380 if (acpi_disabled)
381 return 0;
382
383 if (ACPI_FAILURE(acpi_get_table(ACPI_SIG_GTDT, 0, &table)))
384 return -EINVAL;
385
386 /*
387 * Note: Even though the global variable acpi_gtdt_desc has been
388 * initialized by acpi_gtdt_init() while initializing the arch timers,
389 * when we call this function to get SBSA watchdogs info from GTDT, the
390 * pointers stashed in it are stale (since they are early temporary
391 * mappings carried out before acpi_permanent_mmap is set) and we need
392 * to re-initialize them with permanent mapped pointer values to let the
393 * GTDT parsing possible.
394 */
395 ret = acpi_gtdt_init(table, &timer_count);
396 if (ret || !timer_count)
397 return ret;
398
399 for_each_platform_timer(platform_timer) {
400 if (is_non_secure_watchdog(platform_timer)) {
401 ret = gtdt_import_sbsa_gwdt(platform_timer, gwdt_count);
402 if (ret)
403 break;
404 gwdt_count++;
405 }
406 }
407
408 if (gwdt_count)
409 pr_info("found %d SBSA generic Watchdog(s).\n", gwdt_count);
410
411 return ret;
412 }
413
414 device_initcall(gtdt_sbsa_gwdt_init);
415
