1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * WMI methods for use with dell-smbios 4 * 5 * Copyright (c) 2017 Dell Inc. 6 */ 7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9 #include <linux/dmi.h> 10 #include <linux/list.h> 11 #include <linux/module.h> 12 #include <linux/mutex.h> 13 #include <linux/uaccess.h> 14 #include <linux/wmi.h> 15 #include "dell-smbios.h" 16 #include "dell-wmi-descriptor.h" 17 18 static DEFINE_MUTEX(call_mutex); 19 static DEFINE_MUTEX(list_mutex); 20 static int wmi_supported; 21 22 struct misc_bios_flags_structure { 23 struct dmi_header header; 24 u16 flags0; 25 } __packed; 26 #define FLAG_HAS_ACPI_WMI 0x02 27 28 #define DELL_WMI_SMBIOS_GUID "A80593CE-A997-11DA-B012-B622A1EF5492" 29 30 struct wmi_smbios_priv { 31 struct dell_wmi_smbios_buffer *buf; 32 struct list_head list; 33 struct wmi_device *wdev; 34 struct device *child; 35 u32 req_buf_size; 36 }; 37 static LIST_HEAD(wmi_list); 38 39 static inline struct wmi_smbios_priv *get_first_smbios_priv(void) 40 { 41 return list_first_entry_or_null(&wmi_list, 42 struct wmi_smbios_priv, 43 list); 44 } 45 46 static int run_smbios_call(struct wmi_device *wdev) 47 { 48 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; 49 struct wmi_smbios_priv *priv; 50 struct acpi_buffer input; 51 union acpi_object *obj; 52 acpi_status status; 53 54 priv = dev_get_drvdata(&wdev->dev); 55 input.length = priv->req_buf_size - sizeof(u64); 56 input.pointer = &priv->buf->std; 57 58 dev_dbg(&wdev->dev, "evaluating: %u/%u [%x,%x,%x,%x]\n", 59 priv->buf->std.cmd_class, priv->buf->std.cmd_select, 60 priv->buf->std.input[0], priv->buf->std.input[1], 61 priv->buf->std.input[2], priv->buf->std.input[3]); 62 63 status = wmidev_evaluate_method(wdev, 0, 1, &input, &output); 64 if (ACPI_FAILURE(status)) 65 return -EIO; 66 obj = (union acpi_object *)output.pointer; 67 if (obj->type != ACPI_TYPE_BUFFER) { 68 dev_dbg(&wdev->dev, "received type: %d\n", obj->type); 69 if (obj->type == ACPI_TYPE_INTEGER) 70 dev_dbg(&wdev->dev, "SMBIOS call failed: %llu\n", 71 obj->integer.value); 72 kfree(output.pointer); 73 return -EIO; 74 } 75 memcpy(input.pointer, obj->buffer.pointer, obj->buffer.length); 76 dev_dbg(&wdev->dev, "result: [%08x,%08x,%08x,%08x]\n", 77 priv->buf->std.output[0], priv->buf->std.output[1], 78 priv->buf->std.output[2], priv->buf->std.output[3]); 79 kfree(output.pointer); 80 81 return 0; 82 } 83 84 static int dell_smbios_wmi_call(struct calling_interface_buffer *buffer) 85 { 86 struct wmi_smbios_priv *priv; 87 size_t difference; 88 size_t size; 89 int ret; 90 91 mutex_lock(&call_mutex); 92 priv = get_first_smbios_priv(); 93 if (!priv) { 94 ret = -ENODEV; 95 goto out_wmi_call; 96 } 97 98 size = sizeof(struct calling_interface_buffer); 99 difference = priv->req_buf_size - sizeof(u64) - size; 100 101 memset(&priv->buf->ext, 0, difference); 102 memcpy(&priv->buf->std, buffer, size); 103 ret = run_smbios_call(priv->wdev); 104 memcpy(buffer, &priv->buf->std, size); 105 out_wmi_call: 106 mutex_unlock(&call_mutex); 107 108 return ret; 109 } 110 111 static long dell_smbios_wmi_filter(struct wmi_device *wdev, unsigned int cmd, 112 struct wmi_ioctl_buffer *arg) 113 { 114 struct wmi_smbios_priv *priv; 115 int ret = 0; 116 117 switch (cmd) { 118 case DELL_WMI_SMBIOS_CMD: 119 mutex_lock(&call_mutex); 120 priv = dev_get_drvdata(&wdev->dev); 121 if (!priv) { 122 ret = -ENODEV; 123 goto fail_smbios_cmd; 124 } 125 memcpy(priv->buf, arg, priv->req_buf_size); 126 if (dell_smbios_call_filter(&wdev->dev, &priv->buf->std)) { 127 dev_err(&wdev->dev, "Invalid call %d/%d:%8x\n", 128 priv->buf->std.cmd_class, 129 priv->buf->std.cmd_select, 130 priv->buf->std.input[0]); 131 ret = -EFAULT; 132 goto fail_smbios_cmd; 133 } 134 ret = run_smbios_call(priv->wdev); 135 if (ret) 136 goto fail_smbios_cmd; 137 memcpy(arg, priv->buf, priv->req_buf_size); 138 fail_smbios_cmd: 139 mutex_unlock(&call_mutex); 140 break; 141 default: 142 ret = -ENOIOCTLCMD; 143 } 144 return ret; 145 } 146 147 static int dell_smbios_wmi_probe(struct wmi_device *wdev, const void *context) 148 { 149 struct wmi_driver *wdriver = 150 container_of(wdev->dev.driver, struct wmi_driver, driver); 151 struct wmi_smbios_priv *priv; 152 u32 hotfix; 153 int count; 154 int ret; 155 156 ret = dell_wmi_get_descriptor_valid(); 157 if (ret) 158 return ret; 159 160 priv = devm_kzalloc(&wdev->dev, sizeof(struct wmi_smbios_priv), 161 GFP_KERNEL); 162 if (!priv) 163 return -ENOMEM; 164 165 /* WMI buffer size will be either 4k or 32k depending on machine */ 166 if (!dell_wmi_get_size(&priv->req_buf_size)) 167 return -EPROBE_DEFER; 168 169 /* some SMBIOS calls fail unless BIOS contains hotfix */ 170 if (!dell_wmi_get_hotfix(&hotfix)) 171 return -EPROBE_DEFER; 172 if (!hotfix) { 173 dev_warn(&wdev->dev, 174 "WMI SMBIOS userspace interface not supported(%u), try upgrading to a newer BIOS\n", 175 hotfix); 176 wdriver->filter_callback = NULL; 177 } 178 179 /* add in the length object we will use internally with ioctl */ 180 priv->req_buf_size += sizeof(u64); 181 ret = set_required_buffer_size(wdev, priv->req_buf_size); 182 if (ret) 183 return ret; 184 185 count = get_order(priv->req_buf_size); 186 priv->buf = (void *)__get_free_pages(GFP_KERNEL, count); 187 if (!priv->buf) 188 return -ENOMEM; 189 190 /* ID is used by dell-smbios to set priority of drivers */ 191 wdev->dev.id = 1; 192 ret = dell_smbios_register_device(&wdev->dev, &dell_smbios_wmi_call); 193 if (ret) 194 goto fail_register; 195 196 priv->wdev = wdev; 197 dev_set_drvdata(&wdev->dev, priv); 198 mutex_lock(&list_mutex); 199 list_add_tail(&priv->list, &wmi_list); 200 mutex_unlock(&list_mutex); 201 202 return 0; 203 204 fail_register: 205 free_pages((unsigned long)priv->buf, count); 206 return ret; 207 } 208 209 static void dell_smbios_wmi_remove(struct wmi_device *wdev) 210 { 211 struct wmi_smbios_priv *priv = dev_get_drvdata(&wdev->dev); 212 int count; 213 214 mutex_lock(&call_mutex); 215 mutex_lock(&list_mutex); 216 list_del(&priv->list); 217 mutex_unlock(&list_mutex); 218 dell_smbios_unregister_device(&wdev->dev); 219 count = get_order(priv->req_buf_size); 220 free_pages((unsigned long)priv->buf, count); 221 mutex_unlock(&call_mutex); 222 } 223 224 static const struct wmi_device_id dell_smbios_wmi_id_table[] = { 225 { .guid_string = DELL_WMI_SMBIOS_GUID }, 226 { }, 227 }; 228 229 static void parse_b1_table(const struct dmi_header *dm) 230 { 231 struct misc_bios_flags_structure *flags = 232 container_of(dm, struct misc_bios_flags_structure, header); 233 234 /* 4 bytes header, 8 bytes flags */ 235 if (dm->length < 12) 236 return; 237 if (dm->handle != 0xb100) 238 return; 239 if ((flags->flags0 & FLAG_HAS_ACPI_WMI)) 240 wmi_supported = 1; 241 } 242 243 static void find_b1(const struct dmi_header *dm, void *dummy) 244 { 245 switch (dm->type) { 246 case 0xb1: /* misc bios flags */ 247 parse_b1_table(dm); 248 break; 249 } 250 } 251 252 static struct wmi_driver dell_smbios_wmi_driver = { 253 .driver = { 254 .name = "dell-smbios", 255 }, 256 .probe = dell_smbios_wmi_probe, 257 .remove = dell_smbios_wmi_remove, 258 .id_table = dell_smbios_wmi_id_table, 259 .filter_callback = dell_smbios_wmi_filter, 260 }; 261 262 int init_dell_smbios_wmi(void) 263 { 264 dmi_walk(find_b1, NULL); 265 266 if (!wmi_supported) 267 return -ENODEV; 268 269 return wmi_driver_register(&dell_smbios_wmi_driver); 270 } 271 272 void exit_dell_smbios_wmi(void) 273 { 274 if (wmi_supported) 275 wmi_driver_unregister(&dell_smbios_wmi_driver); 276 } 277 278 MODULE_DEVICE_TABLE(wmi, dell_smbios_wmi_id_table); 279