drivers/core/acpi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Core driver model support for ACPI table generation
   4  *
   5  * Copyright 2019 Google LLC
   6  * Written by Simon Glass <sjg@chromium.org>
   7  */
   8
   9 #define LOG_CATEOGRY    LOGC_ACPI
  10
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <log.h>
  14 #include <malloc.h>
  15 #include <mapmem.h>
  16 #include <acpi/acpi_device.h>
  17 #include <dm/acpi.h>
  18 #include <dm/device-internal.h>
  19 #include <dm/root.h>
  20
  21 #define MAX_ACPI_ITEMS  100
  22
  23 /**
  24  * Type of table that we collected
  25  *
  26  * @TYPE_NONE: Not yet known
  27  * @TYPE_SSDT: Items in the Secondary System Description Table
  28  * @TYPE_DSDT: Items in the Differentiated System Description Table
  29  * @TYPE_OTHER: Other (whole)
  30  */
  31 enum gen_type_t {
  32         TYPE_NONE,
  33         TYPE_SSDT,
  34         TYPE_DSDT,
  35         TYPE_OTHER,
  36 };
  37
  38 const char *gen_type_str[] = {
  39         "-",
  40         "ssdt",
  41         "dsdt",
  42         "other",
  43 };
  44
  45 /* Type of method to call */
  46 enum method_t {
  47         METHOD_WRITE_TABLES,
  48         METHOD_FILL_SSDT,
  49         METHOD_INJECT_DSDT,
  50         METHOD_SETUP_NHLT,
  51 };
  52
  53 /* Prototype for all methods */
  54 typedef int (*acpi_method)(const struct udevice *dev, struct acpi_ctx *ctx);
  55
  56 /**
  57  * struct acpi_item - Holds info about ACPI data generated by a driver method
  58  *
  59  * @dev: Device that generated this data
  60  * @type: Table type it refers to
  61  * @writer: Writer that wrote this table
  62  * @base: Pointer to base of table in its original location
  63  * @buf: Buffer allocated to contain the data (NULL if not allocated)
  64  * @size: Size of the data in bytes
  65  */
  66 struct acpi_item {
  67         struct udevice *dev;
  68         const struct acpi_writer *writer;
  69         enum gen_type_t type;
  70         const char *base;
  71         char *buf;
  72         int size;
  73 };
  74
  75 /* List of ACPI items collected */
  76 static struct acpi_item acpi_item[MAX_ACPI_ITEMS];
  77 static int item_count;
  78
  79 int acpi_copy_name(char *out_name, const char *name)
  80 {
  81         strncpy(out_name, name, ACPI_NAME_LEN);
  82         out_name[ACPI_NAME_LEN] = '\0';
  83
  84         return 0;
  85 }
  86
  87 int acpi_get_name(const struct udevice *dev, char *out_name)
  88 {
  89         struct acpi_ops *aops;
  90         const char *name;
  91         int ret;
  92
  93         aops = device_get_acpi_ops(dev);
  94         if (aops && aops->get_name)
  95                 return aops->get_name(dev, out_name);
  96         name = dev_read_string(dev, "acpi,name");
  97         if (name)
  98                 return acpi_copy_name(out_name, name);
  99         ret = acpi_device_infer_name(dev, out_name);
 100         if (ret)
 101                 return log_msg_ret("dev", ret);
 102
 103         return 0;
 104 }
 105
 106 int acpi_get_path(const struct udevice *dev, char *out_path, int maxlen)
 107 {
 108         const char *path;
 109         int ret;
 110
 111         path = dev_read_string(dev, "acpi,path");
 112         if (path) {
 113                 if (strlen(path) >= maxlen)
 114                         return -ENOSPC;
 115                 strcpy(out_path, path);
 116                 return 0;
 117         }
 118         ret = acpi_device_path(dev, out_path, maxlen);
 119         if (ret)
 120                 return log_msg_ret("dev", ret);
 121
 122         return 0;
 123 }
 124
 125 /**
 126  * add_item() - Add a new item to the list of data collected
 127  *
 128  * @ctx: ACPI context
 129  * @dev: Device that generated the data, if type != TYPE_OTHER
 130  * @writer: Writer entry that generated the data, if type == TYPE_OTHER
 131  * @type: Table type it refers to
 132  * @start: The start of the data (the end is obtained from ctx->current)
 133  * Return: 0 if OK, -ENOSPC if too many items, -ENOMEM if out of memory
 134  */
 135 static int add_item(struct acpi_ctx *ctx, struct udevice *dev,
 136                     const struct acpi_writer *writer, enum gen_type_t type,
 137                     void *start)
 138 {
 139         struct acpi_item *item;
 140         void *end = ctx->current;
 141
 142         if (item_count == MAX_ACPI_ITEMS) {
 143                 log_err("Too many items\n");
 144                 return log_msg_ret("mem", -ENOSPC);
 145         }
 146
 147         item = &acpi_item[item_count];
 148         item->dev = dev;
 149         item->writer = writer;
 150         item->type = type;
 151         item->size = end - start;
 152         item->base = start;
 153         if (!item->size)
 154                 return 0;
 155         if (type != TYPE_OTHER) {
 156                 item->buf = malloc(item->size);
 157                 if (!item->buf)
 158                         return log_msg_ret("mem", -ENOMEM);
 159                 memcpy(item->buf, start, item->size);
 160         }
 161         item_count++;
 162         log_debug("* %s: Added type %d, %p, size %x\n", dev->name, type, start,
 163                   item->size);
 164
 165         return 0;
 166 }
 167
 168 int acpi_add_other_item(struct acpi_ctx *ctx, const struct acpi_writer *writer,
 169                         void *start)
 170 {
 171         return add_item(ctx, NULL, writer, TYPE_OTHER, start);
 172 }
 173
 174 void acpi_dump_items(enum acpi_dump_option option)
 175 {
 176         int i;
 177
 178         printf("Seq  Type       Base   Size  Device/Writer\n");
 179         printf("---  -----  --------   ----  -------------\n");
 180         for (i = 0; i < item_count; i++) {
 181                 struct acpi_item *item = &acpi_item[i];
 182
 183                 printf("%3x  %-5s  %8lx  %5x  %s\n", i,
 184                        gen_type_str[item->type],
 185                        (ulong)map_to_sysmem(item->base), item->size,
 186                        item->dev ? item->dev->name : item->writer->name);
 187                 if (option == ACPI_DUMP_CONTENTS) {
 188                         print_buffer(0, item->buf ? item->buf : item->base, 1,
 189                                      item->size, 0);
 190                         printf("\n");
 191                 }
 192         }
 193 }
 194
 195 static struct acpi_item *find_acpi_item(const char *devname)
 196 {
 197         int i;
 198
 199         for (i = 0; i < item_count; i++) {
 200                 struct acpi_item *item = &acpi_item[i];
 201
 202                 if (item->dev && !strcmp(devname, item->dev->name))
 203                         return item;
 204         }
 205
 206         return NULL;
 207 }
 208
 209 /**
 210  * sort_acpi_item_type - Sort the ACPI items into the desired order
 211  *
 212  * This looks up the ordering in the device tree and then adds each item one by
 213  * one into the supplied buffer
 214  *
 215  * @ctx: ACPI context
 216  * @start: Start position to put the sorted items. The items will follow each
 217  *      other in sorted order
 218  * @type: Type of items to sort
 219  * Return: 0 if OK, -ve on error
 220  */
 221 static int sort_acpi_item_type(struct acpi_ctx *ctx, void *start,
 222                                enum gen_type_t type)
 223 {
 224         const u32 *order;
 225         int size;
 226         int count;
 227         void *ptr;
 228         void *end = ctx->current;
 229
 230         ptr = start;
 231         order = ofnode_read_chosen_prop(type == TYPE_DSDT ?
 232                                         "u-boot,acpi-dsdt-order" :
 233                                         "u-boot,acpi-ssdt-order", &size);
 234         if (!order) {
 235                 log_debug("Failed to find ordering, leaving as is\n");
 236                 return 0;
 237         }
 238
 239         /*
 240          * This algorithm rewrites the context buffer without changing its
 241          * length. So there is no need to update ctx-current
 242          */
 243         count = size / sizeof(u32);
 244         while (count--) {
 245                 struct acpi_item *item;
 246                 const char *name;
 247                 ofnode node;
 248
 249                 node = ofnode_get_by_phandle(fdt32_to_cpu(*order++));
 250                 name = ofnode_get_name(node);
 251                 item = find_acpi_item(name);
 252                 if (!item) {
 253                         log_err("Failed to find item '%s'\n", name);
 254                         return log_msg_ret("find", -ENOENT);
 255                 }
 256                 if (item->type == type) {
 257                         log_debug("   - add %s\n", item->dev->name);
 258                         memcpy(ptr, item->buf, item->size);
 259                         ptr += item->size;
 260                 }
 261         }
 262
 263         /*
 264          * If the sort order is missing an item then the output will be too
 265          * small. Report this error since the item needs to be added to the
 266          * ordering for the ACPI tables to be complete.
 267          */
 268         if (ptr != end) {
 269                 log_warning("*** Missing bytes: ptr=%p, end=%p\n", ptr, end);
 270                 return -ENXIO;
 271         }
 272
 273         return 0;
 274 }
 275
 276 acpi_method acpi_get_method(struct udevice *dev, enum method_t method)
 277 {
 278         struct acpi_ops *aops;
 279
 280         aops = device_get_acpi_ops(dev);
 281         if (aops) {
 282                 switch (method) {
 283                 case METHOD_WRITE_TABLES:
 284                         return aops->write_tables;
 285                 case METHOD_FILL_SSDT:
 286                         return aops->fill_ssdt;
 287                 case METHOD_INJECT_DSDT:
 288                         return aops->inject_dsdt;
 289                 case METHOD_SETUP_NHLT:
 290                         return aops->setup_nhlt;
 291                 }
 292         }
 293
 294         return NULL;
 295 }
 296
 297 int acpi_recurse_method(struct acpi_ctx *ctx, struct udevice *parent,
 298                         enum method_t method, enum gen_type_t type)
 299 {
 300         struct udevice *dev;
 301         acpi_method func;
 302         int ret;
 303
 304         func = acpi_get_method(parent, method);
 305         if (func) {
 306                 log_debug("- method %d, %s %p\n", method, parent->name, func);
 307                 ret = device_of_to_plat(parent);
 308                 if (ret)
 309                         return log_msg_ret("ofdata", ret);
 310                 ctx->tab_start = ctx->current;
 311                 ret = func(parent, ctx);
 312                 if (ret)
 313                         return log_msg_ret("func", ret);
 314
 315                 /* Add the item to the internal list */
 316                 if (type != TYPE_NONE) {
 317                         ret = add_item(ctx, parent, NULL, type, ctx->tab_start);
 318                         if (ret)
 319                                 return log_msg_ret("add", ret);
 320                 }
 321         }
 322         device_foreach_child(dev, parent) {
 323                 ret = acpi_recurse_method(ctx, dev, method, type);
 324                 if (ret)
 325                         return log_msg_ret("recurse", ret);
 326         }
 327
 328         return 0;
 329 }
 330
 331 int acpi_fill_ssdt(struct acpi_ctx *ctx)
 332 {
 333         void *start = ctx->current;
 334         int ret;
 335
 336         log_debug("Writing SSDT tables\n");
 337         ret = acpi_recurse_method(ctx, dm_root(), METHOD_FILL_SSDT, TYPE_SSDT);
 338         log_debug("Writing SSDT finished, err=%d\n", ret);
 339         ret = sort_acpi_item_type(ctx, start, TYPE_SSDT);
 340         if (ret)
 341                 return log_msg_ret("build", ret);
 342
 343         return ret;
 344 }
 345
 346 int acpi_inject_dsdt(struct acpi_ctx *ctx)
 347 {
 348         void *start = ctx->current;
 349         int ret;
 350
 351         log_debug("Writing DSDT tables\n");
 352         ret = acpi_recurse_method(ctx, dm_root(), METHOD_INJECT_DSDT,
 353                                   TYPE_DSDT);
 354         log_debug("Writing DSDT finished, err=%d\n", ret);
 355         ret = sort_acpi_item_type(ctx, start, TYPE_DSDT);
 356         if (ret)
 357                 return log_msg_ret("build", ret);
 358
 359         return ret;
 360 }
 361
 362 void acpi_reset_items(void)
 363 {
 364         item_count = 0;
 365 }
 366
 367 int acpi_write_dev_tables(struct acpi_ctx *ctx)
 368 {
 369         int ret;
 370
 371         log_debug("Writing device tables\n");
 372         ret = acpi_recurse_method(ctx, dm_root(), METHOD_WRITE_TABLES,
 373                                   TYPE_NONE);
 374         log_debug("Writing finished, err=%d\n", ret);
 375
 376         return ret;
 377 }
 378
 379 int acpi_setup_nhlt(struct acpi_ctx *ctx, struct nhlt *nhlt)
 380 {
 381         int ret;
 382
 383         log_debug("Setup NHLT\n");
 384         ctx->nhlt = nhlt;
 385         ret = acpi_recurse_method(ctx, dm_root(), METHOD_SETUP_NHLT, TYPE_NONE);
 386         log_debug("Setup finished, err=%d\n", ret);
 387
 388         return ret;
 389 }