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

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