drivers/platform/x86/dell-smbios-wmi.c

   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(&priv->buf->std, 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 int 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         return 0;
 223 }
 224
 225 static const struct wmi_device_id dell_smbios_wmi_id_table[] = {
 226         { .guid_string = DELL_WMI_SMBIOS_GUID },
 227         { },
 228 };
 229
 230 static void parse_b1_table(const struct dmi_header *dm)
 231 {
 232         struct misc_bios_flags_structure *flags =
 233         container_of(dm, struct misc_bios_flags_structure, header);
 234
 235         /* 4 bytes header, 8 bytes flags */
 236         if (dm->length < 12)
 237                 return;
 238         if (dm->handle != 0xb100)
 239                 return;
 240         if ((flags->flags0 & FLAG_HAS_ACPI_WMI))
 241                 wmi_supported = 1;
 242 }
 243
 244 static void find_b1(const struct dmi_header *dm, void *dummy)
 245 {
 246         switch (dm->type) {
 247         case 0xb1: /* misc bios flags */
 248                 parse_b1_table(dm);
 249                 break;
 250         }
 251 }
 252
 253 static struct wmi_driver dell_smbios_wmi_driver = {
 254         .driver = {
 255                 .name = "dell-smbios",
 256         },
 257         .probe = dell_smbios_wmi_probe,
 258         .remove = dell_smbios_wmi_remove,
 259         .id_table = dell_smbios_wmi_id_table,
 260         .filter_callback = dell_smbios_wmi_filter,
 261 };
 262
 263 int init_dell_smbios_wmi(void)
 264 {
 265         dmi_walk(find_b1, NULL);
 266
 267         if (!wmi_supported)
 268                 return -ENODEV;
 269
 270         return wmi_driver_register(&dell_smbios_wmi_driver);
 271 }
 272
 273 void exit_dell_smbios_wmi(void)
 274 {
 275         if (wmi_supported)
 276                 wmi_driver_unregister(&dell_smbios_wmi_driver);
 277 }
 278
 279 MODULE_DEVICE_TABLE(wmi, dell_smbios_wmi_id_table);