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/device.h> 10#include <linux/dmi.h> 11#include <linux/fs.h> 12#include <linux/list.h> 13#include <linux/miscdevice.h> 14#include <linux/module.h> 15#include <linux/mutex.h> 16#include <linux/uaccess.h> 17#include <linux/wmi.h> 18#include <uapi/linux/wmi.h> 19#include "dell-smbios.h" 20#include "dell-wmi-descriptor.h" 21 22static DEFINE_MUTEX(call_mutex); 23static DEFINE_MUTEX(list_mutex); 24static int wmi_supported; 25 26struct misc_bios_flags_structure { 27 struct dmi_header header; 28 u16 flags0; 29} __packed; 30#define FLAG_HAS_ACPI_WMI 0x02 31 32#define DELL_WMI_SMBIOS_GUID "A80593CE-A997-11DA-B012-B622A1EF5492" 33 34struct wmi_smbios_priv { 35 struct dell_wmi_smbios_buffer *buf; 36 struct list_head list; 37 struct wmi_device *wdev; 38 struct device *child; 39 u64 req_buf_size; 40 struct miscdevice char_dev; 41}; 42static LIST_HEAD(wmi_list); 43 44static inline struct wmi_smbios_priv *get_first_smbios_priv(void) 45{ 46 return list_first_entry_or_null(&wmi_list, 47 struct wmi_smbios_priv, 48 list); 49} 50 51static int run_smbios_call(struct wmi_device *wdev) 52{ 53 struct acpi_buffer output = {ACPI_ALLOCATE_BUFFER, NULL}; 54 struct wmi_smbios_priv *priv; 55 struct acpi_buffer input; 56 union acpi_object *obj; 57 acpi_status status; 58 59 priv = dev_get_drvdata(&wdev->dev); 60 input.length = priv->req_buf_size - sizeof(u64); 61 input.pointer = &priv->buf->std; 62 63 dev_dbg(&wdev->dev, "evaluating: %u/%u [%x,%x,%x,%x]\n", 64 priv->buf->std.cmd_class, priv->buf->std.cmd_select, 65 priv->buf->std.input[0], priv->buf->std.input[1], 66 priv->buf->std.input[2], priv->buf->std.input[3]); 67 68 status = wmidev_evaluate_method(wdev, 0, 1, &input, &output); 69 if (ACPI_FAILURE(status)) 70 return -EIO; 71 obj = (union acpi_object *)output.pointer; 72 if (obj->type != ACPI_TYPE_BUFFER) { 73 dev_dbg(&wdev->dev, "received type: %d\n", obj->type); 74 if (obj->type == ACPI_TYPE_INTEGER) 75 dev_dbg(&wdev->dev, "SMBIOS call failed: %llu\n", 76 obj->integer.value); 77 kfree(output.pointer); 78 return -EIO; 79 } 80 memcpy(input.pointer, obj->buffer.pointer, obj->buffer.length); 81 dev_dbg(&wdev->dev, "result: [%08x,%08x,%08x,%08x]\n", 82 priv->buf->std.output[0], priv->buf->std.output[1], 83 priv->buf->std.output[2], priv->buf->std.output[3]); 84 kfree(output.pointer); 85 86 return 0; 87} 88 89static int dell_smbios_wmi_call(struct calling_interface_buffer *buffer) 90{ 91 struct wmi_smbios_priv *priv; 92 size_t difference; 93 size_t size; 94 int ret; 95 96 mutex_lock(&call_mutex); 97 priv = get_first_smbios_priv(); 98 if (!priv) { 99 ret = -ENODEV; 100 goto out_wmi_call; 101 } 102 103 size = sizeof(struct calling_interface_buffer); 104 difference = priv->req_buf_size - sizeof(u64) - size; 105 106 memset(&priv->buf->ext, 0, difference); 107 memcpy(&priv->buf->std, buffer, size); 108 ret = run_smbios_call(priv->wdev); 109 memcpy(buffer, &priv->buf->std, size); 110out_wmi_call: 111 mutex_unlock(&call_mutex); 112 113 return ret; 114} 115 116static int dell_smbios_wmi_open(struct inode *inode, struct file *filp) 117{ 118 struct wmi_smbios_priv *priv; 119 120 priv = container_of(filp->private_data, struct wmi_smbios_priv, char_dev); 121 filp->private_data = priv; 122 123 return nonseekable_open(inode, filp); 124} 125 126static ssize_t dell_smbios_wmi_read(struct file *filp, char __user *buffer, size_t length, 127 loff_t *offset) 128{ 129 struct wmi_smbios_priv *priv = filp->private_data; 130 131 return simple_read_from_buffer(buffer, length, offset, &priv->req_buf_size, 132 sizeof(priv->req_buf_size)); 133} 134 135static long dell_smbios_wmi_do_ioctl(struct wmi_smbios_priv *priv, 136 struct dell_wmi_smbios_buffer __user *arg) 137{ 138 long ret; 139 140 if (get_user(priv->buf->length, &arg->length)) 141 return -EFAULT; 142 143 if (priv->buf->length < priv->req_buf_size) 144 return -EINVAL; 145 146 /* if it's too big, warn, driver will only use what is needed */ 147 if (priv->buf->length > priv->req_buf_size) 148 dev_err(&priv->wdev->dev, "Buffer %llu is bigger than required %llu\n", 149 priv->buf->length, priv->req_buf_size); 150 151 if (copy_from_user(priv->buf, arg, priv->req_buf_size)) 152 return -EFAULT; 153 154 if (dell_smbios_call_filter(&priv->wdev->dev, &priv->buf->std)) { 155 dev_err(&priv->wdev->dev, "Invalid call %d/%d:%8x\n", 156 priv->buf->std.cmd_class, 157 priv->buf->std.cmd_select, 158 priv->buf->std.input[0]); 159 160 return -EINVAL; 161 } 162 163 ret = run_smbios_call(priv->wdev); 164 if (ret) 165 return ret; 166 167 if (copy_to_user(arg, priv->buf, priv->req_buf_size)) 168 return -EFAULT; 169 170 return 0; 171} 172 173static long dell_smbios_wmi_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 174{ 175 struct dell_wmi_smbios_buffer __user *input = (struct dell_wmi_smbios_buffer __user *)arg; 176 struct wmi_smbios_priv *priv = filp->private_data; 177 long ret; 178 179 if (cmd != DELL_WMI_SMBIOS_CMD) 180 return -ENOIOCTLCMD; 181 182 mutex_lock(&call_mutex); 183 ret = dell_smbios_wmi_do_ioctl(priv, input); 184 mutex_unlock(&call_mutex); 185 186 return ret; 187} 188 189static const struct file_operations dell_smbios_wmi_fops = { 190 .owner = THIS_MODULE, 191 .open = dell_smbios_wmi_open, 192 .read = dell_smbios_wmi_read, 193 .unlocked_ioctl = dell_smbios_wmi_ioctl, 194 .compat_ioctl = compat_ptr_ioctl, 195}; 196 197static void dell_smbios_wmi_unregister_chardev(void *data) 198{ 199 struct miscdevice *char_dev = data; 200 201 misc_deregister(char_dev); 202} 203 204static int dell_smbios_wmi_register_chardev(struct wmi_smbios_priv *priv) 205{ 206 int ret; 207 208 priv->char_dev.minor = MISC_DYNAMIC_MINOR; 209 priv->char_dev.name = "wmi/dell-smbios"; 210 priv->char_dev.fops = &dell_smbios_wmi_fops; 211 priv->char_dev.mode = 0444; 212 213 ret = misc_register(&priv->char_dev); 214 if (ret < 0) 215 return ret; 216 217 return devm_add_action_or_reset(&priv->wdev->dev, dell_smbios_wmi_unregister_chardev, 218 &priv->char_dev); 219} 220 221static int dell_smbios_wmi_probe(struct wmi_device *wdev, const void *context) 222{ 223 struct wmi_smbios_priv *priv; 224 u32 buffer_size, hotfix; 225 int count; 226 int ret; 227 228 ret = dell_wmi_get_descriptor_valid(); 229 if (ret) 230 return ret; 231 232 priv = devm_kzalloc(&wdev->dev, sizeof(struct wmi_smbios_priv), 233 GFP_KERNEL); 234 if (!priv) 235 return -ENOMEM; 236 237 priv->wdev = wdev; 238 dev_set_drvdata(&wdev->dev, priv); 239 240 /* WMI buffer size will be either 4k or 32k depending on machine */ 241 if (!dell_wmi_get_size(&buffer_size)) 242 return -EPROBE_DEFER; 243 244 priv->req_buf_size = buffer_size; 245 246 /* some SMBIOS calls fail unless BIOS contains hotfix */ 247 if (!dell_wmi_get_hotfix(&hotfix)) 248 return -EPROBE_DEFER; 249 250 if (!hotfix) 251 dev_warn(&wdev->dev, 252 "WMI SMBIOS userspace interface not supported(%u), try upgrading to a newer BIOS\n", 253 hotfix); 254 255 /* add in the length object we will use internally with ioctl */ 256 priv->req_buf_size += sizeof(u64); 257 258 count = get_order(priv->req_buf_size); 259 priv->buf = (void *)devm_get_free_pages(&wdev->dev, GFP_KERNEL, count); 260 if (!priv->buf) 261 return -ENOMEM; 262 263 ret = dell_smbios_wmi_register_chardev(priv); 264 if (ret) 265 return ret; 266 267 /* ID is used by dell-smbios to set priority of drivers */ 268 wdev->dev.id = 1; 269 ret = dell_smbios_register_device(&wdev->dev, &dell_smbios_wmi_call); 270 if (ret) 271 return ret; 272 273 mutex_lock(&list_mutex); 274 list_add_tail(&priv->list, &wmi_list); 275 mutex_unlock(&list_mutex); 276 277 return 0; 278} 279 280static void dell_smbios_wmi_remove(struct wmi_device *wdev) 281{ 282 struct wmi_smbios_priv *priv = dev_get_drvdata(&wdev->dev); 283 284 mutex_lock(&call_mutex); 285 mutex_lock(&list_mutex); 286 list_del(&priv->list); 287 mutex_unlock(&list_mutex); 288 dell_smbios_unregister_device(&wdev->dev); 289 mutex_unlock(&call_mutex); 290} 291 292static const struct wmi_device_id dell_smbios_wmi_id_table[] = { 293 { .guid_string = DELL_WMI_SMBIOS_GUID }, 294 { }, 295}; 296 297static void parse_b1_table(const struct dmi_header *dm) 298{ 299 struct misc_bios_flags_structure *flags = 300 container_of(dm, struct misc_bios_flags_structure, header); 301 302 /* 4 bytes header, 8 bytes flags */ 303 if (dm->length < 12) 304 return; 305 if (dm->handle != 0xb100) 306 return; 307 if ((flags->flags0 & FLAG_HAS_ACPI_WMI)) 308 wmi_supported = 1; 309} 310 311static void find_b1(const struct dmi_header *dm, void *dummy) 312{ 313 switch (dm->type) { 314 case 0xb1: /* misc bios flags */ 315 parse_b1_table(dm); 316 break; 317 } 318} 319 320static struct wmi_driver dell_smbios_wmi_driver = { 321 .driver = { 322 .name = "dell-smbios", 323 }, 324 .probe = dell_smbios_wmi_probe, 325 .remove = dell_smbios_wmi_remove, 326 .id_table = dell_smbios_wmi_id_table, 327}; 328 329int init_dell_smbios_wmi(void) 330{ 331 dmi_walk(find_b1, NULL); 332 333 if (!wmi_supported) 334 return -ENODEV; 335 336 return wmi_driver_register(&dell_smbios_wmi_driver); 337} 338 339void exit_dell_smbios_wmi(void) 340{ 341 if (wmi_supported) 342 wmi_driver_unregister(&dell_smbios_wmi_driver); 343} 344 345MODULE_DEVICE_TABLE(wmi, dell_smbios_wmi_id_table); 346