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