drivers/acpi/acpi_configfs.c

   1 /*
   2  * ACPI configfs support
   3  *
   4  * Copyright (c) 2016 Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  */
  10
  11 #define pr_fmt(fmt) "ACPI configfs: " fmt
  12
  13 #include <linux/init.h>
  14 #include <linux/module.h>
  15 #include <linux/configfs.h>
  16 #include <linux/acpi.h>
  17
  18 #include "acpica/accommon.h"
  19 #include "acpica/actables.h"
  20
  21 static struct config_group *acpi_table_group;
  22
  23 struct acpi_table {
  24         struct config_item cfg;
  25         struct acpi_table_header *header;
  26         u32 index;
  27 };
  28
  29 static ssize_t acpi_table_aml_write(struct config_item *cfg,
  30                                     const void *data, size_t size)
  31 {
  32         const struct acpi_table_header *header = data;
  33         struct acpi_table *table;
  34         int ret;
  35
  36         table = container_of(cfg, struct acpi_table, cfg);
  37
  38         if (table->header) {
  39                 pr_err("table already loaded\n");
  40                 return -EBUSY;
  41         }
  42
  43         if (header->length != size) {
  44                 pr_err("invalid table length\n");
  45                 return -EINVAL;
  46         }
  47
  48         if (memcmp(header->signature, ACPI_SIG_SSDT, 4)) {
  49                 pr_err("invalid table signature\n");
  50                 return -EINVAL;
  51         }
  52
  53         table = container_of(cfg, struct acpi_table, cfg);
  54
  55         table->header = kmemdup(header, header->length, GFP_KERNEL);
  56         if (!table->header)
  57                 return -ENOMEM;
  58
  59         ACPI_INFO(("Host-directed Dynamic ACPI Table Load:"));
  60         ret = acpi_tb_install_and_load_table(
  61                         ACPI_PTR_TO_PHYSADDR(table->header),
  62                         ACPI_TABLE_ORIGIN_EXTERNAL_VIRTUAL, FALSE,
  63                         &table->index);
  64         if (ret) {
  65                 kfree(table->header);
  66                 table->header = NULL;
  67         }
  68
  69         return ret;
  70 }
  71
  72 static inline struct acpi_table_header *get_header(struct config_item *cfg)
  73 {
  74         struct acpi_table *table = container_of(cfg, struct acpi_table, cfg);
  75
  76         if (!table->header)
  77                 pr_err("table not loaded\n");
  78
  79         return table->header;
  80 }
  81
  82 static ssize_t acpi_table_aml_read(struct config_item *cfg,
  83                                    void *data, size_t size)
  84 {
  85         struct acpi_table_header *h = get_header(cfg);
  86
  87         if (!h)
  88                 return -EINVAL;
  89
  90         if (data)
  91                 memcpy(data, h, h->length);
  92
  93         return h->length;
  94 }
  95
  96 #define MAX_ACPI_TABLE_SIZE (128 * 1024)
  97
  98 CONFIGFS_BIN_ATTR(acpi_table_, aml, NULL, MAX_ACPI_TABLE_SIZE);
  99
 100 static struct configfs_bin_attribute *acpi_table_bin_attrs[] = {
 101         &acpi_table_attr_aml,
 102         NULL,
 103 };
 104
 105 static ssize_t acpi_table_signature_show(struct config_item *cfg, char *str)
 106 {
 107         struct acpi_table_header *h = get_header(cfg);
 108
 109         if (!h)
 110                 return -EINVAL;
 111
 112         return sprintf(str, "%.*s\n", ACPI_NAMESEG_SIZE, h->signature);
 113 }
 114
 115 static ssize_t acpi_table_length_show(struct config_item *cfg, char *str)
 116 {
 117         struct acpi_table_header *h = get_header(cfg);
 118
 119         if (!h)
 120                 return -EINVAL;
 121
 122         return sprintf(str, "%d\n", h->length);
 123 }
 124
 125 static ssize_t acpi_table_revision_show(struct config_item *cfg, char *str)
 126 {
 127         struct acpi_table_header *h = get_header(cfg);
 128
 129         if (!h)
 130                 return -EINVAL;
 131
 132         return sprintf(str, "%d\n", h->revision);
 133 }
 134
 135 static ssize_t acpi_table_oem_id_show(struct config_item *cfg, char *str)
 136 {
 137         struct acpi_table_header *h = get_header(cfg);
 138
 139         if (!h)
 140                 return -EINVAL;
 141
 142         return sprintf(str, "%.*s\n", ACPI_OEM_ID_SIZE, h->oem_id);
 143 }
 144
 145 static ssize_t acpi_table_oem_table_id_show(struct config_item *cfg, char *str)
 146 {
 147         struct acpi_table_header *h = get_header(cfg);
 148
 149         if (!h)
 150                 return -EINVAL;
 151
 152         return sprintf(str, "%.*s\n", ACPI_OEM_TABLE_ID_SIZE, h->oem_table_id);
 153 }
 154
 155 static ssize_t acpi_table_oem_revision_show(struct config_item *cfg, char *str)
 156 {
 157         struct acpi_table_header *h = get_header(cfg);
 158
 159         if (!h)
 160                 return -EINVAL;
 161
 162         return sprintf(str, "%d\n", h->oem_revision);
 163 }
 164
 165 static ssize_t acpi_table_asl_compiler_id_show(struct config_item *cfg,
 166                                                char *str)
 167 {
 168         struct acpi_table_header *h = get_header(cfg);
 169
 170         if (!h)
 171                 return -EINVAL;
 172
 173         return sprintf(str, "%.*s\n", ACPI_NAMESEG_SIZE, h->asl_compiler_id);
 174 }
 175
 176 static ssize_t acpi_table_asl_compiler_revision_show(struct config_item *cfg,
 177                                                      char *str)
 178 {
 179         struct acpi_table_header *h = get_header(cfg);
 180
 181         if (!h)
 182                 return -EINVAL;
 183
 184         return sprintf(str, "%d\n", h->asl_compiler_revision);
 185 }
 186
 187 CONFIGFS_ATTR_RO(acpi_table_, signature);
 188 CONFIGFS_ATTR_RO(acpi_table_, length);
 189 CONFIGFS_ATTR_RO(acpi_table_, revision);
 190 CONFIGFS_ATTR_RO(acpi_table_, oem_id);
 191 CONFIGFS_ATTR_RO(acpi_table_, oem_table_id);
 192 CONFIGFS_ATTR_RO(acpi_table_, oem_revision);
 193 CONFIGFS_ATTR_RO(acpi_table_, asl_compiler_id);
 194 CONFIGFS_ATTR_RO(acpi_table_, asl_compiler_revision);
 195
 196 static struct configfs_attribute *acpi_table_attrs[] = {
 197         &acpi_table_attr_signature,
 198         &acpi_table_attr_length,
 199         &acpi_table_attr_revision,
 200         &acpi_table_attr_oem_id,
 201         &acpi_table_attr_oem_table_id,
 202         &acpi_table_attr_oem_revision,
 203         &acpi_table_attr_asl_compiler_id,
 204         &acpi_table_attr_asl_compiler_revision,
 205         NULL,
 206 };
 207
 208 static const struct config_item_type acpi_table_type = {
 209         .ct_owner = THIS_MODULE,
 210         .ct_bin_attrs = acpi_table_bin_attrs,
 211         .ct_attrs = acpi_table_attrs,
 212 };
 213
 214 static struct config_item *acpi_table_make_item(struct config_group *group,
 215                                                 const char *name)
 216 {
 217         struct acpi_table *table;
 218
 219         table = kzalloc(sizeof(*table), GFP_KERNEL);
 220         if (!table)
 221                 return ERR_PTR(-ENOMEM);
 222
 223         config_item_init_type_name(&table->cfg, name, &acpi_table_type);
 224         return &table->cfg;
 225 }
 226
 227 static void acpi_table_drop_item(struct config_group *group,
 228                                  struct config_item *cfg)
 229 {
 230         struct acpi_table *table = container_of(cfg, struct acpi_table, cfg);
 231
 232         ACPI_INFO(("Host-directed Dynamic ACPI Table Unload"));
 233         acpi_tb_unload_table(table->index);
 234 }
 235
 236 static struct configfs_group_operations acpi_table_group_ops = {
 237         .make_item = acpi_table_make_item,
 238         .drop_item = acpi_table_drop_item,
 239 };
 240
 241 static const struct config_item_type acpi_tables_type = {
 242         .ct_owner = THIS_MODULE,
 243         .ct_group_ops = &acpi_table_group_ops,
 244 };
 245
 246 static const struct config_item_type acpi_root_group_type = {
 247         .ct_owner = THIS_MODULE,
 248 };
 249
 250 static struct configfs_subsystem acpi_configfs = {
 251         .su_group = {
 252                 .cg_item = {
 253                         .ci_namebuf = "acpi",
 254                         .ci_type = &acpi_root_group_type,
 255                 },
 256         },
 257         .su_mutex = __MUTEX_INITIALIZER(acpi_configfs.su_mutex),
 258 };
 259
 260 static int __init acpi_configfs_init(void)
 261 {
 262         int ret;
 263         struct config_group *root = &acpi_configfs.su_group;
 264
 265         config_group_init(root);
 266
 267         ret = configfs_register_subsystem(&acpi_configfs);
 268         if (ret)
 269                 return ret;
 270
 271         acpi_table_group = configfs_register_default_group(root, "table",
 272                                                            &acpi_tables_type);
 273         return PTR_ERR_OR_ZERO(acpi_table_group);
 274 }
 275 module_init(acpi_configfs_init);
 276
 277 static void __exit acpi_configfs_exit(void)
 278 {
 279         configfs_unregister_default_group(acpi_table_group);
 280         configfs_unregister_subsystem(&acpi_configfs);
 281 }
 282 module_exit(acpi_configfs_exit);
 283
 284 MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
 285 MODULE_DESCRIPTION("ACPI configfs support");
 286 MODULE_LICENSE("GPL v2");