drivers/firmware/efi/apple-properties.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * apple-properties.c - EFI device properties on Macs
   4  * Copyright (C) 2016 Lukas Wunner <lukas@wunner.de>
   5  *
   6  * Properties are stored either as:
   7  * u8 arrays which can be retrieved with device_property_read_u8_array() or
   8  * booleans which can be queried with device_property_present().
   9  */
  10
  11 #define pr_fmt(fmt) "apple-properties: " fmt
  12
  13 #include <linux/memblock.h>
  14 #include <linux/efi.h>
  15 #include <linux/io.h>
  16 #include <linux/platform_data/x86/apple.h>
  17 #include <linux/property.h>
  18 #include <linux/slab.h>
  19 #include <linux/ucs2_string.h>
  20 #include <asm/setup.h>
  21
  22 static bool dump_properties __initdata;
  23
  24 static int __init dump_properties_enable(char *arg)
  25 {
  26         dump_properties = true;
  27         return 1;
  28 }
  29
  30 __setup("dump_apple_properties", dump_properties_enable);
  31
  32 struct dev_header {
  33         u32 len;
  34         u32 prop_count;
  35         struct efi_dev_path path[];
  36         /*
  37          * followed by key/value pairs, each key and value preceded by u32 len,
  38          * len includes itself, value may be empty (in which case its len is 4)
  39          */
  40 };
  41
  42 struct properties_header {
  43         u32 len;
  44         u32 version;
  45         u32 dev_count;
  46         struct dev_header dev_header[];
  47 };
  48
  49 static void __init unmarshal_key_value_pairs(struct dev_header *dev_header,
  50                                              struct device *dev, const void *ptr,
  51                                              struct property_entry entry[])
  52 {
  53         int i;
  54
  55         for (i = 0; i < dev_header->prop_count; i++) {
  56                 int remaining = dev_header->len - (ptr - (void *)dev_header);
  57                 u32 key_len, val_len, entry_len;
  58                 const u8 *entry_data;
  59                 char *key;
  60
  61                 if (sizeof(key_len) > remaining)
  62                         break;
  63
  64                 key_len = *(typeof(key_len) *)ptr;
  65                 if (key_len + sizeof(val_len) > remaining ||
  66                     key_len < sizeof(key_len) + sizeof(efi_char16_t) ||
  67                     *(efi_char16_t *)(ptr + sizeof(key_len)) == 0) {
  68                         dev_err(dev, "invalid property name len at %#zx\n",
  69                                 ptr - (void *)dev_header);
  70                         break;
  71                 }
  72
  73                 val_len = *(typeof(val_len) *)(ptr + key_len);
  74                 if (key_len + val_len > remaining ||
  75                     val_len < sizeof(val_len)) {
  76                         dev_err(dev, "invalid property val len at %#zx\n",
  77                                 ptr - (void *)dev_header + key_len);
  78                         break;
  79                 }
  80
  81                 /* 4 bytes to accommodate UTF-8 code points + null byte */
  82                 key = kzalloc((key_len - sizeof(key_len)) * 4 + 1, GFP_KERNEL);
  83                 if (!key) {
  84                         dev_err(dev, "cannot allocate property name\n");
  85                         break;
  86                 }
  87                 ucs2_as_utf8(key, ptr + sizeof(key_len),
  88                              key_len - sizeof(key_len));
  89
  90                 entry_data = ptr + key_len + sizeof(val_len);
  91                 entry_len = val_len - sizeof(val_len);
  92                 if (entry_len)
  93                         entry[i] = PROPERTY_ENTRY_U8_ARRAY_LEN(key, entry_data,
  94                                                                entry_len);
  95                 else
  96                         entry[i] = PROPERTY_ENTRY_BOOL(key);
  97
  98                 if (dump_properties) {
  99                         dev_info(dev, "property: %s\n", key);
 100                         print_hex_dump(KERN_INFO, pr_fmt(), DUMP_PREFIX_OFFSET,
 101                                 16, 1, entry_data, entry_len, true);
 102                 }
 103
 104                 ptr += key_len + val_len;
 105         }
 106
 107         if (i != dev_header->prop_count) {
 108                 dev_err(dev, "got %d device properties, expected %u\n", i,
 109                         dev_header->prop_count);
 110                 print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
 111                         16, 1, dev_header, dev_header->len, true);
 112                 return;
 113         }
 114
 115         dev_info(dev, "assigning %d device properties\n", i);
 116 }
 117
 118 static int __init unmarshal_devices(struct properties_header *properties)
 119 {
 120         size_t offset = offsetof(struct properties_header, dev_header[0]);
 121
 122         while (offset + sizeof(struct dev_header) < properties->len) {
 123                 struct dev_header *dev_header = (void *)properties + offset;
 124                 struct property_entry *entry = NULL;
 125                 const struct efi_dev_path *ptr;
 126                 struct device *dev;
 127                 size_t len;
 128                 int ret, i;
 129
 130                 if (offset + dev_header->len > properties->len ||
 131                     dev_header->len <= sizeof(*dev_header)) {
 132                         pr_err("invalid len in dev_header at %#zx\n", offset);
 133                         return -EINVAL;
 134                 }
 135
 136                 ptr = dev_header->path;
 137                 len = dev_header->len - sizeof(*dev_header);
 138
 139                 dev = efi_get_device_by_path(&ptr, &len);
 140                 if (IS_ERR(dev)) {
 141                         pr_err("device path parse error %ld at %#zx:\n",
 142                                PTR_ERR(dev), (void *)ptr - (void *)dev_header);
 143                         print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
 144                                16, 1, dev_header, dev_header->len, true);
 145                         dev = NULL;
 146                         goto skip_device;
 147                 }
 148
 149                 entry = kcalloc(dev_header->prop_count + 1, sizeof(*entry),
 150                                 GFP_KERNEL);
 151                 if (!entry) {
 152                         dev_err(dev, "cannot allocate properties\n");
 153                         goto skip_device;
 154                 }
 155
 156                 unmarshal_key_value_pairs(dev_header, dev, ptr, entry);
 157                 if (!entry[0].name)
 158                         goto skip_device;
 159
 160                 ret = device_create_managed_software_node(dev, entry, NULL);
 161                 if (ret)
 162                         dev_err(dev, "error %d assigning properties\n", ret);
 163
 164                 for (i = 0; entry[i].name; i++)
 165                         kfree(entry[i].name);
 166
 167 skip_device:
 168                 kfree(entry);
 169                 put_device(dev);
 170                 offset += dev_header->len;
 171         }
 172
 173         return 0;
 174 }
 175
 176 static int __init map_properties(void)
 177 {
 178         struct properties_header *properties;
 179         struct setup_data *data;
 180         u32 data_len;
 181         u64 pa_data;
 182         int ret;
 183
 184         if (!x86_apple_machine)
 185                 return 0;
 186
 187         pa_data = boot_params.hdr.setup_data;
 188         while (pa_data) {
 189                 data = memremap(pa_data, sizeof(*data), MEMREMAP_WB);
 190                 if (!data) {
 191                         pr_err("cannot map setup_data header\n");
 192                         return -ENOMEM;
 193                 }
 194
 195                 if (data->type != SETUP_APPLE_PROPERTIES) {
 196                         pa_data = data->next;
 197                         memunmap(data);
 198                         continue;
 199                 }
 200
 201                 data_len = data->len;
 202                 memunmap(data);
 203
 204                 data = memremap(pa_data, sizeof(*data) + data_len, MEMREMAP_WB);
 205                 if (!data) {
 206                         pr_err("cannot map setup_data payload\n");
 207                         return -ENOMEM;
 208                 }
 209
 210                 properties = (struct properties_header *)data->data;
 211                 if (properties->version != 1) {
 212                         pr_err("unsupported version:\n");
 213                         print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
 214                                16, 1, properties, data_len, true);
 215                         ret = -ENOTSUPP;
 216                 } else if (properties->len != data_len) {
 217                         pr_err("length mismatch, expected %u\n", data_len);
 218                         print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
 219                                16, 1, properties, data_len, true);
 220                         ret = -EINVAL;
 221                 } else
 222                         ret = unmarshal_devices(properties);
 223
 224                 /*
 225                  * Can only free the setup_data payload but not its header
 226                  * to avoid breaking the chain of ->next pointers.
 227                  */
 228                 data->len = 0;
 229                 memunmap(data);
 230                 memblock_free_late(pa_data + sizeof(*data), data_len);
 231
 232                 return ret;
 233         }
 234         return 0;
 235 }
 236
 237 fs_initcall(map_properties);