238 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * apple-properties.c - EFI device properties on Macs4 * 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() or8 * booleans which can be queried with device_property_present().9 */10 11#define pr_fmt(fmt) "apple-properties: " fmt12 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 22static bool dump_properties __initdata;23 24static 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 32struct 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 42struct properties_header {43 u32 len;44 u32 version;45 u32 dev_count;46 struct dev_header dev_header[];47};48 49static 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 else96 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 118static 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 167skip_device:168 kfree(entry);169 put_device(dev);170 offset += dev_header->len;171 }172 173 return 0;174}175 176static 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 } else222 ret = unmarshal_devices(properties);223 224 /*225 * Can only free the setup_data payload but not its header226 * 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 237fs_initcall(map_properties);238