firmware/efi/apple-properties.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * apple-properties.c - EFI device properties on Macs
0004  * Copyright (C) 2016 Lukas Wunner <lukas@wunner.de>
0005  *
0006  * Properties are stored either as:
0007  * u8 arrays which can be retrieved with device_property_read_u8_array() or
0008  * booleans which can be queried with device_property_present().
0009  */
0010
0011 #define pr_fmt(fmt) "apple-properties: " fmt
0012
0013 #include <linux/memblock.h>
0014 #include <linux/efi.h>
0015 #include <linux/io.h>
0016 #include <linux/platform_data/x86/apple.h>
0017 #include <linux/property.h>
0018 #include <linux/slab.h>
0019 #include <linux/ucs2_string.h>
0020 #include <asm/setup.h>
0021
0022 static bool dump_properties __initdata;
0023
0024 static int __init dump_properties_enable(char *arg)
0025 {
0026     dump_properties = true;
0027     return 1;
0028 }
0029
0030 __setup("dump_apple_properties", dump_properties_enable);
0031
0032 struct dev_header {
0033     u32 len;
0034     u32 prop_count;
0035     struct efi_dev_path path[];
0036     /*
0037      * followed by key/value pairs, each key and value preceded by u32 len,
0038      * len includes itself, value may be empty (in which case its len is 4)
0039      */
0040 };
0041
0042 struct properties_header {
0043     u32 len;
0044     u32 version;
0045     u32 dev_count;
0046     struct dev_header dev_header[];
0047 };
0048
0049 static void __init unmarshal_key_value_pairs(struct dev_header *dev_header,
0050                          struct device *dev, const void *ptr,
0051                          struct property_entry entry[])
0052 {
0053     int i;
0054
0055     for (i = 0; i < dev_header->prop_count; i++) {
0056         int remaining = dev_header->len - (ptr - (void *)dev_header);
0057         u32 key_len, val_len, entry_len;
0058         const u8 *entry_data;
0059         char *key;
0060
0061         if (sizeof(key_len) > remaining)
0062             break;
0063
0064         key_len = *(typeof(key_len) *)ptr;
0065         if (key_len + sizeof(val_len) > remaining ||
0066             key_len < sizeof(key_len) + sizeof(efi_char16_t) ||
0067             *(efi_char16_t *)(ptr + sizeof(key_len)) == 0) {
0068             dev_err(dev, "invalid property name len at %#zx\n",
0069                 ptr - (void *)dev_header);
0070             break;
0071         }
0072
0073         val_len = *(typeof(val_len) *)(ptr + key_len);
0074         if (key_len + val_len > remaining ||
0075             val_len < sizeof(val_len)) {
0076             dev_err(dev, "invalid property val len at %#zx\n",
0077                 ptr - (void *)dev_header + key_len);
0078             break;
0079         }
0080
0081         /* 4 bytes to accommodate UTF-8 code points + null byte */
0082         key = kzalloc((key_len - sizeof(key_len)) * 4 + 1, GFP_KERNEL);
0083         if (!key) {
0084             dev_err(dev, "cannot allocate property name\n");
0085             break;
0086         }
0087         ucs2_as_utf8(key, ptr + sizeof(key_len),
0088                  key_len - sizeof(key_len));
0089
0090         entry_data = ptr + key_len + sizeof(val_len);
0091         entry_len = val_len - sizeof(val_len);
0092         if (entry_len)
0093             entry[i] = PROPERTY_ENTRY_U8_ARRAY_LEN(key, entry_data,
0094                                    entry_len);
0095         else
0096             entry[i] = PROPERTY_ENTRY_BOOL(key);
0097
0098         if (dump_properties) {
0099             dev_info(dev, "property: %s\n", key);
0100             print_hex_dump(KERN_INFO, pr_fmt(), DUMP_PREFIX_OFFSET,
0101                 16, 1, entry_data, entry_len, true);
0102         }
0103
0104         ptr += key_len + val_len;
0105     }
0106
0107     if (i != dev_header->prop_count) {
0108         dev_err(dev, "got %d device properties, expected %u\n", i,
0109             dev_header->prop_count);
0110         print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
0111             16, 1, dev_header, dev_header->len, true);
0112         return;
0113     }
0114
0115     dev_info(dev, "assigning %d device properties\n", i);
0116 }
0117
0118 static int __init unmarshal_devices(struct properties_header *properties)
0119 {
0120     size_t offset = offsetof(struct properties_header, dev_header[0]);
0121
0122     while (offset + sizeof(struct dev_header) < properties->len) {
0123         struct dev_header *dev_header = (void *)properties + offset;
0124         struct property_entry *entry = NULL;
0125         const struct efi_dev_path *ptr;
0126         struct device *dev;
0127         size_t len;
0128         int ret, i;
0129
0130         if (offset + dev_header->len > properties->len ||
0131             dev_header->len <= sizeof(*dev_header)) {
0132             pr_err("invalid len in dev_header at %#zx\n", offset);
0133             return -EINVAL;
0134         }
0135
0136         ptr = dev_header->path;
0137         len = dev_header->len - sizeof(*dev_header);
0138
0139         dev = efi_get_device_by_path(&ptr, &len);
0140         if (IS_ERR(dev)) {
0141             pr_err("device path parse error %ld at %#zx:\n",
0142                    PTR_ERR(dev), (void *)ptr - (void *)dev_header);
0143             print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
0144                    16, 1, dev_header, dev_header->len, true);
0145             dev = NULL;
0146             goto skip_device;
0147         }
0148
0149         entry = kcalloc(dev_header->prop_count + 1, sizeof(*entry),
0150                 GFP_KERNEL);
0151         if (!entry) {
0152             dev_err(dev, "cannot allocate properties\n");
0153             goto skip_device;
0154         }
0155
0156         unmarshal_key_value_pairs(dev_header, dev, ptr, entry);
0157         if (!entry[0].name)
0158             goto skip_device;
0159
0160         ret = device_create_managed_software_node(dev, entry, NULL);
0161         if (ret)
0162             dev_err(dev, "error %d assigning properties\n", ret);
0163
0164         for (i = 0; entry[i].name; i++)
0165             kfree(entry[i].name);
0166
0167 skip_device:
0168         kfree(entry);
0169         put_device(dev);
0170         offset += dev_header->len;
0171     }
0172
0173     return 0;
0174 }
0175
0176 static int __init map_properties(void)
0177 {
0178     struct properties_header *properties;
0179     struct setup_data *data;
0180     u32 data_len;
0181     u64 pa_data;
0182     int ret;
0183
0184     if (!x86_apple_machine)
0185         return 0;
0186
0187     pa_data = boot_params.hdr.setup_data;
0188     while (pa_data) {
0189         data = memremap(pa_data, sizeof(*data), MEMREMAP_WB);
0190         if (!data) {
0191             pr_err("cannot map setup_data header\n");
0192             return -ENOMEM;
0193         }
0194
0195         if (data->type != SETUP_APPLE_PROPERTIES) {
0196             pa_data = data->next;
0197             memunmap(data);
0198             continue;
0199         }
0200
0201         data_len = data->len;
0202         memunmap(data);
0203
0204         data = memremap(pa_data, sizeof(*data) + data_len, MEMREMAP_WB);
0205         if (!data) {
0206             pr_err("cannot map setup_data payload\n");
0207             return -ENOMEM;
0208         }
0209
0210         properties = (struct properties_header *)data->data;
0211         if (properties->version != 1) {
0212             pr_err("unsupported version:\n");
0213             print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
0214                    16, 1, properties, data_len, true);
0215             ret = -ENOTSUPP;
0216         } else if (properties->len != data_len) {
0217             pr_err("length mismatch, expected %u\n", data_len);
0218             print_hex_dump(KERN_ERR, pr_fmt(), DUMP_PREFIX_OFFSET,
0219                    16, 1, properties, data_len, true);
0220             ret = -EINVAL;
0221         } else
0222             ret = unmarshal_devices(properties);
0223
0224         /*
0225          * Can only free the setup_data payload but not its header
0226          * to avoid breaking the chain of ->next pointers.
0227          */
0228         data->len = 0;
0229         memunmap(data);
0230         memblock_free_late(pa_data + sizeof(*data), data_len);
0231
0232         return ret;
0233     }
0234     return 0;
0235 }
0236
0237 fs_initcall(map_properties);