drivers/platform/x86/dell-smbios.c

   1 /*
   2  *  Common functions for kernel modules using Dell SMBIOS
   3  *
   4  *  Copyright (c) Red Hat <mjg@redhat.com>
   5  *  Copyright (c) 2014 Gabriele Mazzotta <gabriele.mzt@gmail.com>
   6  *  Copyright (c) 2014 Pali Rohár <pali.rohar@gmail.com>
   7  *
   8  *  Based on documentation in the libsmbios package:
   9  *  Copyright (C) 2005-2014 Dell Inc.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License version 2 as
  13  *  published by the Free Software Foundation.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/dmi.h>
  19 #include <linux/gfp.h>
  20 #include <linux/mutex.h>
  21 #include <linux/slab.h>
  22 #include <linux/io.h>
  23 #include "../../firmware/dcdbas.h"
  24 #include "dell-smbios.h"
  25
  26 struct calling_interface_structure {
  27         struct dmi_header header;
  28         u16 cmdIOAddress;
  29         u8 cmdIOCode;
  30         u32 supportedCmds;
  31         struct calling_interface_token tokens[];
  32 } __packed;
  33
  34 struct calling_interface_buffer *buffer;
  35 EXPORT_SYMBOL_GPL(buffer);
  36 static DEFINE_MUTEX(buffer_mutex);
  37
  38 static int da_command_address;
  39 static int da_command_code;
  40 static int da_num_tokens;
  41 struct calling_interface_token *da_tokens;
  42 EXPORT_SYMBOL_GPL(da_tokens);
  43
  44 void dell_smbios_get_buffer(void)
  45 {
  46         mutex_lock(&buffer_mutex);
  47         dell_smbios_clear_buffer();
  48 }
  49 EXPORT_SYMBOL_GPL(dell_smbios_get_buffer);
  50
  51 void dell_smbios_clear_buffer(void)
  52 {
  53         memset(buffer, 0, sizeof(struct calling_interface_buffer));
  54 }
  55 EXPORT_SYMBOL_GPL(dell_smbios_clear_buffer);
  56
  57 void release_buffer(void)
  58 {
  59         mutex_unlock(&buffer_mutex);
  60 }
  61 EXPORT_SYMBOL_GPL(release_buffer);
  62
  63 struct calling_interface_buffer *
  64 dell_send_request(struct calling_interface_buffer *buffer,
  65                   int class, int select)
  66 {
  67         struct smi_cmd command;
  68
  69         command.magic = SMI_CMD_MAGIC;
  70         command.command_address = da_command_address;
  71         command.command_code = da_command_code;
  72         command.ebx = virt_to_phys(buffer);
  73         command.ecx = 0x42534931;
  74
  75         buffer->class = class;
  76         buffer->select = select;
  77
  78         dcdbas_smi_request(&command);
  79
  80         return buffer;
  81 }
  82 EXPORT_SYMBOL_GPL(dell_send_request);
  83
  84 int find_token_id(int tokenid)
  85 {
  86         int i;
  87
  88         for (i = 0; i < da_num_tokens; i++) {
  89                 if (da_tokens[i].tokenID == tokenid)
  90                         return i;
  91         }
  92
  93         return -1;
  94 }
  95 EXPORT_SYMBOL_GPL(find_token_id);
  96
  97 int find_token_location(int tokenid)
  98 {
  99         int id;
 100
 101         id = find_token_id(tokenid);
 102         if (id == -1)
 103                 return -1;
 104
 105         return da_tokens[id].location;
 106 }
 107 EXPORT_SYMBOL_GPL(find_token_location);
 108
 109 static void __init parse_da_table(const struct dmi_header *dm)
 110 {
 111         /* Final token is a terminator, so we don't want to copy it */
 112         int tokens = (dm->length-11)/sizeof(struct calling_interface_token)-1;
 113         struct calling_interface_token *new_da_tokens;
 114         struct calling_interface_structure *table =
 115                 container_of(dm, struct calling_interface_structure, header);
 116
 117         /* 4 bytes of table header, plus 7 bytes of Dell header, plus at least
 118            6 bytes of entry */
 119
 120         if (dm->length < 17)
 121                 return;
 122
 123         da_command_address = table->cmdIOAddress;
 124         da_command_code = table->cmdIOCode;
 125
 126         new_da_tokens = krealloc(da_tokens, (da_num_tokens + tokens) *
 127                                  sizeof(struct calling_interface_token),
 128                                  GFP_KERNEL);
 129
 130         if (!new_da_tokens)
 131                 return;
 132         da_tokens = new_da_tokens;
 133
 134         memcpy(da_tokens+da_num_tokens, table->tokens,
 135                sizeof(struct calling_interface_token) * tokens);
 136
 137         da_num_tokens += tokens;
 138 }
 139
 140 static void __init find_tokens(const struct dmi_header *dm, void *dummy)
 141 {
 142         switch (dm->type) {
 143         case 0xd4: /* Indexed IO */
 144         case 0xd5: /* Protected Area Type 1 */
 145         case 0xd6: /* Protected Area Type 2 */
 146                 break;
 147         case 0xda: /* Calling interface */
 148                 parse_da_table(dm);
 149                 break;
 150         }
 151 }
 152
 153 static int __init dell_smbios_init(void)
 154 {
 155         int ret;
 156
 157         dmi_walk(find_tokens, NULL);
 158
 159         if (!da_tokens)  {
 160                 pr_info("Unable to find dmi tokens\n");
 161                 return -ENODEV;
 162         }
 163
 164         /*
 165          * Allocate buffer below 4GB for SMI data--only 32-bit physical addr
 166          * is passed to SMI handler.
 167          */
 168         buffer = (void *)__get_free_page(GFP_KERNEL | GFP_DMA32);
 169         if (!buffer) {
 170                 ret = -ENOMEM;
 171                 goto fail_buffer;
 172         }
 173
 174         return 0;
 175
 176 fail_buffer:
 177         kfree(da_tokens);
 178         return ret;
 179 }
 180
 181 static void __exit dell_smbios_exit(void)
 182 {
 183         kfree(da_tokens);
 184         free_page((unsigned long)buffer);
 185 }
 186
 187 subsys_initcall(dell_smbios_init);
 188 module_exit(dell_smbios_exit);
 189
 190 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
 191 MODULE_AUTHOR("Gabriele Mazzotta <gabriele.mzt@gmail.com>");
 192 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
 193 MODULE_DESCRIPTION("Common functions for kernel modules using Dell SMBIOS");
 194 MODULE_LICENSE("GPL");