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); 235