drivers/acpi/arm64/gtdt.c

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