dmi-id.c 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Export SMBIOS/DMI info via sysfs to userspace
  4. *
  5. * Copyright 2007, Lennart Poettering
  6. */
  7. #include <linux/module.h>
  8. #include <linux/kernel.h>
  9. #include <linux/init.h>
  10. #include <linux/dmi.h>
  11. #include <linux/device.h>
  12. #include <linux/slab.h>
  13. struct dmi_device_attribute{
  14. struct device_attribute dev_attr;
  15. int field;
  16. };
  17. #define to_dmi_dev_attr(_dev_attr) \
  18. container_of(_dev_attr, struct dmi_device_attribute, dev_attr)
  19. static ssize_t sys_dmi_field_show(struct device *dev,
  20. struct device_attribute *attr,
  21. char *page)
  22. {
  23. int field = to_dmi_dev_attr(attr)->field;
  24. ssize_t len;
  25. len = scnprintf(page, PAGE_SIZE, "%s\n", dmi_get_system_info(field));
  26. page[len-1] = '\n';
  27. return len;
  28. }
  29. #define DMI_ATTR(_name, _mode, _show, _field) \
  30. { .dev_attr = __ATTR(_name, _mode, _show, NULL), \
  31. .field = _field }
  32. #define DEFINE_DMI_ATTR_WITH_SHOW(_name, _mode, _field) \
  33. static struct dmi_device_attribute sys_dmi_##_name##_attr = \
  34. DMI_ATTR(_name, _mode, sys_dmi_field_show, _field);
  35. DEFINE_DMI_ATTR_WITH_SHOW(bios_vendor, 0444, DMI_BIOS_VENDOR);
  36. DEFINE_DMI_ATTR_WITH_SHOW(bios_version, 0444, DMI_BIOS_VERSION);
  37. DEFINE_DMI_ATTR_WITH_SHOW(bios_date, 0444, DMI_BIOS_DATE);
  38. DEFINE_DMI_ATTR_WITH_SHOW(sys_vendor, 0444, DMI_SYS_VENDOR);
  39. DEFINE_DMI_ATTR_WITH_SHOW(bios_release, 0444, DMI_BIOS_RELEASE);
  40. DEFINE_DMI_ATTR_WITH_SHOW(ec_firmware_release, 0444, DMI_EC_FIRMWARE_RELEASE);
  41. DEFINE_DMI_ATTR_WITH_SHOW(product_name, 0444, DMI_PRODUCT_NAME);
  42. DEFINE_DMI_ATTR_WITH_SHOW(product_version, 0444, DMI_PRODUCT_VERSION);
  43. DEFINE_DMI_ATTR_WITH_SHOW(product_serial, 0400, DMI_PRODUCT_SERIAL);
  44. DEFINE_DMI_ATTR_WITH_SHOW(product_uuid, 0400, DMI_PRODUCT_UUID);
  45. DEFINE_DMI_ATTR_WITH_SHOW(product_sku, 0444, DMI_PRODUCT_SKU);
  46. DEFINE_DMI_ATTR_WITH_SHOW(product_family, 0444, DMI_PRODUCT_FAMILY);
  47. DEFINE_DMI_ATTR_WITH_SHOW(board_vendor, 0444, DMI_BOARD_VENDOR);
  48. DEFINE_DMI_ATTR_WITH_SHOW(board_name, 0444, DMI_BOARD_NAME);
  49. DEFINE_DMI_ATTR_WITH_SHOW(board_version, 0444, DMI_BOARD_VERSION);
  50. DEFINE_DMI_ATTR_WITH_SHOW(board_serial, 0400, DMI_BOARD_SERIAL);
  51. DEFINE_DMI_ATTR_WITH_SHOW(board_asset_tag, 0444, DMI_BOARD_ASSET_TAG);
  52. DEFINE_DMI_ATTR_WITH_SHOW(chassis_vendor, 0444, DMI_CHASSIS_VENDOR);
  53. DEFINE_DMI_ATTR_WITH_SHOW(chassis_type, 0444, DMI_CHASSIS_TYPE);
  54. DEFINE_DMI_ATTR_WITH_SHOW(chassis_version, 0444, DMI_CHASSIS_VERSION);
  55. DEFINE_DMI_ATTR_WITH_SHOW(chassis_serial, 0400, DMI_CHASSIS_SERIAL);
  56. DEFINE_DMI_ATTR_WITH_SHOW(chassis_asset_tag, 0444, DMI_CHASSIS_ASSET_TAG);
  57. static void ascii_filter(char *d, const char *s)
  58. {
  59. /* Filter out characters we don't want to see in the modalias string */
  60. for (; *s; s++)
  61. if (*s > ' ' && *s < 127 && *s != ':')
  62. *(d++) = *s;
  63. *d = 0;
  64. }
  65. static ssize_t get_modalias(char *buffer, size_t buffer_size)
  66. {
  67. static const struct mafield {
  68. const char *prefix;
  69. int field;
  70. } fields[] = {
  71. { "bvn", DMI_BIOS_VENDOR },
  72. { "bvr", DMI_BIOS_VERSION },
  73. { "bd", DMI_BIOS_DATE },
  74. { "br", DMI_BIOS_RELEASE },
  75. { "efr", DMI_EC_FIRMWARE_RELEASE },
  76. { "svn", DMI_SYS_VENDOR },
  77. { "pn", DMI_PRODUCT_NAME },
  78. { "pvr", DMI_PRODUCT_VERSION },
  79. { "rvn", DMI_BOARD_VENDOR },
  80. { "rn", DMI_BOARD_NAME },
  81. { "rvr", DMI_BOARD_VERSION },
  82. { "cvn", DMI_CHASSIS_VENDOR },
  83. { "ct", DMI_CHASSIS_TYPE },
  84. { "cvr", DMI_CHASSIS_VERSION },
  85. { NULL, DMI_NONE }
  86. };
  87. ssize_t l, left;
  88. char *p;
  89. const struct mafield *f;
  90. strcpy(buffer, "dmi");
  91. p = buffer + 3; left = buffer_size - 4;
  92. for (f = fields; f->prefix && left > 0; f++) {
  93. const char *c;
  94. char *t;
  95. c = dmi_get_system_info(f->field);
  96. if (!c)
  97. continue;
  98. t = kmalloc(strlen(c) + 1, GFP_KERNEL);
  99. if (!t)
  100. break;
  101. ascii_filter(t, c);
  102. l = scnprintf(p, left, ":%s%s", f->prefix, t);
  103. kfree(t);
  104. p += l;
  105. left -= l;
  106. }
  107. p[0] = ':';
  108. p[1] = 0;
  109. return p - buffer + 1;
  110. }
  111. static ssize_t sys_dmi_modalias_show(struct device *dev,
  112. struct device_attribute *attr, char *page)
  113. {
  114. ssize_t r;
  115. r = get_modalias(page, PAGE_SIZE-1);
  116. page[r] = '\n';
  117. page[r+1] = 0;
  118. return r+1;
  119. }
  120. static struct device_attribute sys_dmi_modalias_attr =
  121. __ATTR(modalias, 0444, sys_dmi_modalias_show, NULL);
  122. static struct attribute *sys_dmi_attributes[DMI_STRING_MAX+2];
  123. static struct attribute_group sys_dmi_attribute_group = {
  124. .attrs = sys_dmi_attributes,
  125. };
  126. static const struct attribute_group* sys_dmi_attribute_groups[] = {
  127. &sys_dmi_attribute_group,
  128. NULL
  129. };
  130. static int dmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
  131. {
  132. ssize_t len;
  133. if (add_uevent_var(env, "MODALIAS="))
  134. return -ENOMEM;
  135. len = get_modalias(&env->buf[env->buflen - 1],
  136. sizeof(env->buf) - env->buflen);
  137. if (len >= (sizeof(env->buf) - env->buflen))
  138. return -ENOMEM;
  139. env->buflen += len;
  140. return 0;
  141. }
  142. static struct class dmi_class = {
  143. .name = "dmi",
  144. .dev_release = (void(*)(struct device *)) kfree,
  145. .dev_uevent = dmi_dev_uevent,
  146. };
  147. static struct device *dmi_dev;
  148. /* Initialization */
  149. #define ADD_DMI_ATTR(_name, _field) \
  150. if (dmi_get_system_info(_field)) \
  151. sys_dmi_attributes[i++] = &sys_dmi_##_name##_attr.dev_attr.attr;
  152. /* In a separate function to keep gcc 3.2 happy - do NOT merge this in
  153. dmi_id_init! */
  154. static void __init dmi_id_init_attr_table(void)
  155. {
  156. int i;
  157. /* Not necessarily all DMI fields are available on all
  158. * systems, hence let's built an attribute table of just
  159. * what's available */
  160. i = 0;
  161. ADD_DMI_ATTR(bios_vendor, DMI_BIOS_VENDOR);
  162. ADD_DMI_ATTR(bios_version, DMI_BIOS_VERSION);
  163. ADD_DMI_ATTR(bios_date, DMI_BIOS_DATE);
  164. ADD_DMI_ATTR(bios_release, DMI_BIOS_RELEASE);
  165. ADD_DMI_ATTR(ec_firmware_release, DMI_EC_FIRMWARE_RELEASE);
  166. ADD_DMI_ATTR(sys_vendor, DMI_SYS_VENDOR);
  167. ADD_DMI_ATTR(product_name, DMI_PRODUCT_NAME);
  168. ADD_DMI_ATTR(product_version, DMI_PRODUCT_VERSION);
  169. ADD_DMI_ATTR(product_serial, DMI_PRODUCT_SERIAL);
  170. ADD_DMI_ATTR(product_uuid, DMI_PRODUCT_UUID);
  171. ADD_DMI_ATTR(product_family, DMI_PRODUCT_FAMILY);
  172. ADD_DMI_ATTR(product_sku, DMI_PRODUCT_SKU);
  173. ADD_DMI_ATTR(board_vendor, DMI_BOARD_VENDOR);
  174. ADD_DMI_ATTR(board_name, DMI_BOARD_NAME);
  175. ADD_DMI_ATTR(board_version, DMI_BOARD_VERSION);
  176. ADD_DMI_ATTR(board_serial, DMI_BOARD_SERIAL);
  177. ADD_DMI_ATTR(board_asset_tag, DMI_BOARD_ASSET_TAG);
  178. ADD_DMI_ATTR(chassis_vendor, DMI_CHASSIS_VENDOR);
  179. ADD_DMI_ATTR(chassis_type, DMI_CHASSIS_TYPE);
  180. ADD_DMI_ATTR(chassis_version, DMI_CHASSIS_VERSION);
  181. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL);
  182. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG);
  183. sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr;
  184. }
  185. static int __init dmi_id_init(void)
  186. {
  187. int ret;
  188. if (!dmi_available)
  189. return -ENODEV;
  190. dmi_id_init_attr_table();
  191. ret = class_register(&dmi_class);
  192. if (ret)
  193. return ret;
  194. dmi_dev = kzalloc(sizeof(*dmi_dev), GFP_KERNEL);
  195. if (!dmi_dev) {
  196. ret = -ENOMEM;
  197. goto fail_class_unregister;
  198. }
  199. dmi_dev->class = &dmi_class;
  200. dev_set_name(dmi_dev, "id");
  201. dmi_dev->groups = sys_dmi_attribute_groups;
  202. ret = device_register(dmi_dev);
  203. if (ret)
  204. goto fail_put_dmi_dev;
  205. return 0;
  206. fail_put_dmi_dev:
  207. put_device(dmi_dev);
  208. fail_class_unregister:
  209. class_unregister(&dmi_class);
  210. return ret;
  211. }
  212. arch_initcall(dmi_id_init);