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