apple-properties.c 6.0 KB

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