drivers/firmware/efivars.c

   1 /*
   2  * EFI Variables - efivars.c
   3  *
   4  * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
   5  * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
   6  *
   7  * This code takes all variables accessible from EFI runtime and
   8  *  exports them via sysfs
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  *
  24  * Changelog:
  25  *
  26  *  26 Apr 2004 - Matt Domsch <Matt_Domsch@dell.com>
  27  *   minor bug fixes
  28  *
  29  *  21 Apr 2004 - Matt Tolentino <matthew.e.tolentino@intel.com)
  30  *   converted driver to export variable information via sysfs
  31  *   and moved to drivers/firmware directory
  32  *   bumped revision number to v0.07 to reflect conversion & move
  33  *
  34  *  10 Dec 2002 - Matt Domsch <Matt_Domsch@dell.com>
  35  *   fix locking per Peter Chubb's findings
  36  *
  37  *  25 Mar 2002 - Matt Domsch <Matt_Domsch@dell.com>
  38  *   move uuid_unparse() to include/asm-ia64/efi.h:efi_guid_unparse()
  39  *
  40  *  12 Feb 2002 - Matt Domsch <Matt_Domsch@dell.com>
  41  *   use list_for_each_safe when deleting vars.
  42  *   remove ifdef CONFIG_SMP around include <linux/smp.h>
  43  *   v0.04 release to linux-ia64@linuxia64.org
  44  *
  45  *  20 April 2001 - Matt Domsch <Matt_Domsch@dell.com>
  46  *   Moved vars from /proc/efi to /proc/efi/vars, and made
  47  *   efi.c own the /proc/efi directory.
  48  *   v0.03 release to linux-ia64@linuxia64.org
  49  *
  50  *  26 March 2001 - Matt Domsch <Matt_Domsch@dell.com>
  51  *   At the request of Stephane, moved ownership of /proc/efi
  52  *   to efi.c, and now efivars lives under /proc/efi/vars.
  53  *
  54  *  12 March 2001 - Matt Domsch <Matt_Domsch@dell.com>
  55  *   Feedback received from Stephane Eranian incorporated.
  56  *   efivar_write() checks copy_from_user() return value.
  57  *   efivar_read/write() returns proper errno.
  58  *   v0.02 release to linux-ia64@linuxia64.org
  59  *
  60  *  26 February 2001 - Matt Domsch <Matt_Domsch@dell.com>
  61  *   v0.01 release to linux-ia64@linuxia64.org
  62  */
  63
  64 #include <linux/config.h>
  65 #include <linux/types.h>
  66 #include <linux/errno.h>
  67 #include <linux/init.h>
  68 #include <linux/sched.h>                /* for capable() */
  69 #include <linux/mm.h>
  70 #include <linux/module.h>
  71 #include <linux/string.h>
  72 #include <linux/smp.h>
  73 #include <linux/efi.h>
  74 #include <linux/sysfs.h>
  75 #include <linux/kobject.h>
  76 #include <linux/device.h>
  77
  78 #include <asm/uaccess.h>
  79
  80 MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
  81 MODULE_DESCRIPTION("sysfs interface to EFI Variables");
  82 MODULE_LICENSE("GPL");
  83
  84 #define EFIVARS_VERSION "0.07 2004-Apr-26"
  85
  86 /*
  87  * efivars_lock protects two things:
  88  * 1) efivar_list - adds, removals, reads, writes
  89  * 2) efi.[gs]et_variable() calls.
  90  * It must not be held when creating sysfs entries or calling kmalloc.
  91  * efi.get_next_variable() is only called from efivars_init(),
  92  * which is protected by the BKL, so that path is safe.
  93  */
  94 static spinlock_t efivars_lock = SPIN_LOCK_UNLOCKED;
  95 static LIST_HEAD(efivar_list);
  96
  97 /*
  98  * The maximum size of VariableName + Data = 1024
  99  * Therefore, it's reasonable to save that much
 100  * space in each part of the structure,
 101  * and we use a page for reading/writing.
 102  */
 103
 104 struct efi_variable {
 105         efi_char16_t  VariableName[1024/sizeof(efi_char16_t)];
 106         efi_guid_t    VendorGuid;
 107         unsigned long DataSize;
 108         __u8          Data[1024];
 109         efi_status_t  Status;
 110         __u32         Attributes;
 111 } __attribute__((packed));
 112
 113
 114 struct efivar_entry {
 115         struct efi_variable var;
 116         struct list_head list;
 117         struct kobject kobj;
 118 };
 119
 120 #define get_efivar_entry(n) list_entry(n, struct efivar_entry, list)
 121
 122 struct efivar_attribute {
 123         struct attribute attr;
 124         ssize_t (*show) (struct efivar_entry *entry, char *buf);
 125         ssize_t (*store)(struct efivar_entry *entry, const char *buf, size_t count);
 126 };
 127
 128
 129 #define EFI_ATTR(_name, _mode, _show, _store) \
 130 struct subsys_attribute efi_attr_##_name = { \
 131         .attr {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
 132         .show = _show, \
 133         .store = _store, \
 134 };
 135
 136 #define EFIVAR_ATTR(_name, _mode, _show, _store) \
 137 struct efivar_attribute efivar_attr_##_name = { \
 138         .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
 139         .show = _show, \
 140         .store = _store, \
 141 };
 142
 143 #define VAR_SUBSYS_ATTR(_name, _mode, _show, _store) \
 144 struct subsys_attribute var_subsys_attr_##_name = { \
 145         .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
 146         .show = _show, \
 147         .store = _store, \
 148 };
 149
 150 #define to_efivar_attr(_attr) container_of(_attr, struct efivar_attribute, attr)
 151 #define to_efivar_entry(obj)  container_of(obj, struct efivar_entry, kobj)
 152
 153 /*
 154  * Prototype for sysfs creation function
 155  */
 156 static int
 157 efivar_create_sysfs_entry(unsigned long variable_name_size,
 158                                 efi_char16_t *variable_name,
 159                                 efi_guid_t *vendor_guid);
 160
 161 /* Return the number of unicode characters in data */
 162 static unsigned long
 163 utf8_strlen(efi_char16_t *data, unsigned long maxlength)
 164 {
 165         unsigned long length = 0;
 166
 167         while (*data++ != 0 && length < maxlength)
 168                 length++;
 169         return length;
 170 }
 171
 172 /*
 173  * Return the number of bytes is the length of this string
 174  * Note: this is NOT the same as the number of unicode characters
 175  */
 176 static inline unsigned long
 177 utf8_strsize(efi_char16_t *data, unsigned long maxlength)
 178 {
 179         return utf8_strlen(data, maxlength/sizeof(efi_char16_t)) * sizeof(efi_char16_t);
 180 }
 181
 182 static efi_status_t
 183 get_var_data(struct efi_variable *var)
 184 {
 185         efi_status_t status;
 186
 187         spin_lock(&efivars_lock);
 188         var->DataSize = 1024;
 189         status = efi.get_variable(var->VariableName,
 190                                 &var->VendorGuid,
 191                                 &var->Attributes,
 192                                 &var->DataSize,
 193                                 var->Data);
 194         spin_unlock(&efivars_lock);
 195         if (status != EFI_SUCCESS) {
 196                 printk(KERN_WARNING "efivars: get_variable() failed 0x%lx!\n",
 197                         status);
 198         }
 199         return status;
 200 }
 201
 202 static ssize_t
 203 efivar_guid_read(struct efivar_entry *entry, char *buf)
 204 {
 205         struct efi_variable *var = &entry->var;
 206         char *str = buf;
 207
 208         if (!entry || !buf)
 209                 return 0;
 210
 211         efi_guid_unparse(&var->VendorGuid, str);
 212         str += strlen(str);
 213         str += sprintf(str, "\n");
 214
 215         return str - buf;
 216 }
 217
 218 static ssize_t
 219 efivar_attr_read(struct efivar_entry *entry, char *buf)
 220 {
 221         struct efi_variable *var = &entry->var;
 222         char *str = buf;
 223         efi_status_t status;
 224
 225         if (!entry || !buf)
 226                 return -EINVAL;
 227
 228         status = get_var_data(var);
 229         if (status != EFI_SUCCESS)
 230                 return -EIO;
 231
 232         if (var->Attributes & 0x1)
 233                 str += sprintf(str, "EFI_VARIABLE_NON_VOLATILE\n");
 234         if (var->Attributes & 0x2)
 235                 str += sprintf(str, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
 236         if (var->Attributes & 0x4)
 237                 str += sprintf(str, "EFI_VARIABLE_RUNTIME_ACCESS\n");
 238         return str - buf;
 239 }
 240
 241 static ssize_t
 242 efivar_size_read(struct efivar_entry *entry, char *buf)
 243 {
 244         struct efi_variable *var = &entry->var;
 245         char *str = buf;
 246         efi_status_t status;
 247
 248         if (!entry || !buf)
 249                 return -EINVAL;
 250
 251         status = get_var_data(var);
 252         if (status != EFI_SUCCESS)
 253                 return -EIO;
 254
 255         str += sprintf(str, "0x%lx\n", var->DataSize);
 256         return str - buf;
 257 }
 258
 259 static ssize_t
 260 efivar_data_read(struct efivar_entry *entry, char *buf)
 261 {
 262         struct efi_variable *var = &entry->var;
 263         efi_status_t status;
 264
 265         if (!entry || !buf)
 266                 return -EINVAL;
 267
 268         status = get_var_data(var);
 269         if (status != EFI_SUCCESS)
 270                 return -EIO;
 271
 272         memcpy(buf, var->Data, var->DataSize);
 273         return var->DataSize;
 274 }
 275 /*
 276  * We allow each variable to be edited via rewriting the
 277  * entire efi variable structure.
 278  */
 279 static ssize_t
 280 efivar_store_raw(struct efivar_entry *entry, const char *buf, size_t count)
 281 {
 282         struct efi_variable *new_var, *var = &entry->var;
 283         efi_status_t status = EFI_NOT_FOUND;
 284
 285         if (count != sizeof(struct efi_variable))
 286                 return -EINVAL;
 287
 288         new_var = (struct efi_variable *)buf;
 289         /*
 290          * If only updating the variable data, then the name
 291          * and guid should remain the same
 292          */
 293         if (memcmp(new_var->VariableName, var->VariableName, sizeof(var->VariableName)) ||
 294                 efi_guidcmp(new_var->VendorGuid, var->VendorGuid)) {
 295                 printk(KERN_ERR "efivars: Cannot edit the wrong variable!\n");
 296                 return -EINVAL;
 297         }
 298
 299         if ((new_var->DataSize <= 0) || (new_var->Attributes == 0)){
 300                 printk(KERN_ERR "efivars: DataSize & Attributes must be valid!\n");
 301                 return -EINVAL;
 302         }
 303
 304         spin_lock(&efivars_lock);
 305         status = efi.set_variable(new_var->VariableName,
 306                                         &new_var->VendorGuid,
 307                                         new_var->Attributes,
 308                                         new_var->DataSize,
 309                                         new_var->Data);
 310
 311         spin_unlock(&efivars_lock);
 312
 313         if (status != EFI_SUCCESS) {
 314                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
 315                         status);
 316                 return -EIO;
 317         }
 318
 319         memcpy(&entry->var, new_var, count);
 320         return count;
 321 }
 322
 323 static ssize_t
 324 efivar_show_raw(struct efivar_entry *entry, char *buf)
 325 {
 326         struct efi_variable *var = &entry->var;
 327         efi_status_t status;
 328
 329         if (!entry || !buf)
 330                 return 0;
 331
 332         status = get_var_data(var);
 333         if (status != EFI_SUCCESS)
 334                 return -EIO;
 335
 336         memcpy(buf, var, sizeof(*var));
 337         return sizeof(*var);
 338 }
 339
 340 /*
 341  * Generic read/write functions that call the specific functions of
 342  * the atttributes...
 343  */
 344 static ssize_t efivar_attr_show(struct kobject *kobj, struct attribute *attr,
 345                                 char *buf)
 346 {
 347         struct efivar_entry *var = to_efivar_entry(kobj);
 348         struct efivar_attribute *efivar_attr = to_efivar_attr(attr);
 349         ssize_t ret = 0;
 350
 351         if (!capable(CAP_SYS_ADMIN))
 352                 return -EACCES;
 353
 354         if (efivar_attr->show) {
 355                 ret = efivar_attr->show(var, buf);
 356         }
 357         return ret;
 358 }
 359
 360 static ssize_t efivar_attr_store(struct kobject *kobj, struct attribute *attr,
 361                                 const char *buf, size_t count)
 362 {
 363         struct efivar_entry *var = to_efivar_entry(kobj);
 364         struct efivar_attribute *efivar_attr = to_efivar_attr(attr);
 365         ssize_t ret = 0;
 366
 367         if (!capable(CAP_SYS_ADMIN))
 368                 return -EACCES;
 369
 370         if (efivar_attr->store)
 371                 ret = efivar_attr->store(var, buf, count);
 372
 373         return ret;
 374 }
 375
 376 static struct sysfs_ops efivar_attr_ops = {
 377         .show = efivar_attr_show,
 378         .store = efivar_attr_store,
 379 };
 380
 381 static void efivar_release(struct kobject *kobj)
 382 {
 383         struct efivar_entry *var = container_of(kobj, struct efivar_entry, kobj);
 384         spin_lock(&efivars_lock);
 385         list_del(&var->list);
 386         spin_unlock(&efivars_lock);
 387         kfree(var);
 388 }
 389
 390 static EFIVAR_ATTR(guid, 0400, efivar_guid_read, NULL);
 391 static EFIVAR_ATTR(attributes, 0400, efivar_attr_read, NULL);
 392 static EFIVAR_ATTR(size, 0400, efivar_size_read, NULL);
 393 static EFIVAR_ATTR(data, 0400, efivar_data_read, NULL);
 394 static EFIVAR_ATTR(raw_var, 0600, efivar_show_raw, efivar_store_raw);
 395
 396 static struct attribute *def_attrs[] = {
 397         &efivar_attr_guid.attr,
 398         &efivar_attr_size.attr,
 399         &efivar_attr_attributes.attr,
 400         &efivar_attr_data.attr,
 401         &efivar_attr_raw_var.attr,
 402         NULL,
 403 };
 404
 405 static struct kobj_type ktype_efivar = {
 406         .release = efivar_release,
 407         .sysfs_ops = &efivar_attr_ops,
 408         .default_attrs = def_attrs,
 409 };
 410
 411 static ssize_t
 412 dummy(struct subsystem *sub, char *buf)
 413 {
 414         return -ENODEV;
 415 }
 416
 417 static inline void
 418 efivar_unregister(struct efivar_entry *var)
 419 {
 420         kobject_unregister(&var->kobj);
 421 }
 422
 423
 424 static ssize_t
 425 efivar_create(struct subsystem *sub, const char *buf, size_t count)
 426 {
 427         struct efi_variable *new_var = (struct efi_variable *)buf;
 428         struct efivar_entry *search_efivar = NULL;
 429         unsigned long strsize1, strsize2;
 430         struct list_head *pos, *n;
 431         efi_status_t status = EFI_NOT_FOUND;
 432         int found = 0;
 433
 434         if (!capable(CAP_SYS_ADMIN))
 435                 return -EACCES;
 436
 437         spin_lock(&efivars_lock);
 438
 439         /*
 440          * Does this variable already exist?
 441          */
 442         list_for_each_safe(pos, n, &efivar_list) {
 443                 search_efivar = get_efivar_entry(pos);
 444                 strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
 445                 strsize2 = utf8_strsize(new_var->VariableName, 1024);
 446                 if (strsize1 == strsize2 &&
 447                         !memcmp(&(search_efivar->var.VariableName),
 448                                 new_var->VariableName, strsize1) &&
 449                         !efi_guidcmp(search_efivar->var.VendorGuid,
 450                                 new_var->VendorGuid)) {
 451                         found = 1;
 452                         break;
 453                 }
 454         }
 455         if (found) {
 456                 spin_unlock(&efivars_lock);
 457                 return -EINVAL;
 458         }
 459
 460         /* now *really* create the variable via EFI */
 461         status = efi.set_variable(new_var->VariableName,
 462                         &new_var->VendorGuid,
 463                         new_var->Attributes,
 464                         new_var->DataSize,
 465                         new_var->Data);
 466
 467         if (status != EFI_SUCCESS) {
 468                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
 469                         status);
 470                 spin_unlock(&efivars_lock);
 471                 return -EIO;
 472         }
 473         spin_unlock(&efivars_lock);
 474
 475         /* Create the entry in sysfs.  Locking is not required here */
 476         status = efivar_create_sysfs_entry(utf8_strsize(new_var->VariableName,
 477                         1024), new_var->VariableName, &new_var->VendorGuid);
 478         if (status) {
 479                 printk(KERN_WARNING "efivars: variable created, but sysfs entry wasn't.\n");
 480         }
 481         return count;
 482 }
 483
 484 static ssize_t
 485 efivar_delete(struct subsystem *sub, const char *buf, size_t count)
 486 {
 487         struct efi_variable *del_var = (struct efi_variable *)buf;
 488         struct efivar_entry *search_efivar = NULL;
 489         unsigned long strsize1, strsize2;
 490         struct list_head *pos, *n;
 491         efi_status_t status = EFI_NOT_FOUND;
 492         int found = 0;
 493
 494         if (!capable(CAP_SYS_ADMIN))
 495                 return -EACCES;
 496
 497         spin_lock(&efivars_lock);
 498
 499         /*
 500          * Does this variable already exist?
 501          */
 502         list_for_each_safe(pos, n, &efivar_list) {
 503                 search_efivar = get_efivar_entry(pos);
 504                 strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
 505                 strsize2 = utf8_strsize(del_var->VariableName, 1024);
 506                 if (strsize1 == strsize2 &&
 507                         !memcmp(&(search_efivar->var.VariableName),
 508                                 del_var->VariableName, strsize1) &&
 509                         !efi_guidcmp(search_efivar->var.VendorGuid,
 510                                 del_var->VendorGuid)) {
 511                         found = 1;
 512                         break;
 513                 }
 514         }
 515         if (!found) {
 516                 spin_unlock(&efivars_lock);
 517                 return -EINVAL;
 518         }
 519         /* force the Attributes/DataSize to 0 to ensure deletion */
 520         del_var->Attributes = 0;
 521         del_var->DataSize = 0;
 522
 523         status = efi.set_variable(del_var->VariableName,
 524                         &del_var->VendorGuid,
 525                         del_var->Attributes,
 526                         del_var->DataSize,
 527                         del_var->Data);
 528
 529         if (status != EFI_SUCCESS) {
 530                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
 531                         status);
 532                 spin_unlock(&efivars_lock);
 533                 return -EIO;
 534         }
 535         /* We need to release this lock before unregistering. */
 536         spin_unlock(&efivars_lock);
 537
 538         efivar_unregister(search_efivar);
 539
 540         /* It's dead Jim.... */
 541         return count;
 542 }
 543
 544 static VAR_SUBSYS_ATTR(new_var, 0200, dummy, efivar_create);
 545 static VAR_SUBSYS_ATTR(del_var, 0200, dummy, efivar_delete);
 546
 547 static struct subsys_attribute *var_subsys_attrs[] = {
 548         &var_subsys_attr_new_var,
 549         &var_subsys_attr_del_var,
 550         NULL,
 551 };
 552
 553 /*
 554  * Let's not leave out systab information that snuck into
 555  * the efivars driver
 556  */
 557 static ssize_t
 558 systab_read(struct subsystem *entry, char *buf)
 559 {
 560         char *str = buf;
 561
 562         if (!entry || !buf)
 563                 return -EINVAL;
 564
 565         if (efi.mps)
 566                 str += sprintf(str, "MPS=0x%lx\n", __pa(efi.mps));
 567         if (efi.acpi20)
 568                 str += sprintf(str, "ACPI20=0x%lx\n", __pa(efi.acpi20));
 569         if (efi.acpi)
 570                 str += sprintf(str, "ACPI=0x%lx\n", __pa(efi.acpi));
 571         if (efi.smbios)
 572                 str += sprintf(str, "SMBIOS=0x%lx\n", __pa(efi.smbios));
 573         if (efi.hcdp)
 574                 str += sprintf(str, "HCDP=0x%lx\n", __pa(efi.hcdp));
 575         if (efi.boot_info)
 576                 str += sprintf(str, "BOOTINFO=0x%lx\n", __pa(efi.boot_info));
 577         if (efi.uga)
 578                 str += sprintf(str, "UGA=0x%lx\n", __pa(efi.uga));
 579
 580         return str - buf;
 581 }
 582
 583 static EFI_ATTR(systab, 0400, systab_read, NULL);
 584
 585 static struct subsys_attribute *efi_subsys_attrs[] = {
 586         &efi_attr_systab,
 587         NULL,   /* maybe more in the future? */
 588 };
 589
 590 static decl_subsys(vars, &ktype_efivar, NULL);
 591 static decl_subsys(efi, NULL, NULL);
 592
 593 /*
 594  * efivar_create_sysfs_entry()
 595  * Requires:
 596  *    variable_name_size = number of bytes required to hold
 597  *                         variable_name (not counting the NULL
 598  *                         character at the end.
 599  *    efivars_lock is not held on entry or exit.
 600  * Returns 1 on failure, 0 on success
 601  */
 602 static int
 603 efivar_create_sysfs_entry(unsigned long variable_name_size,
 604                         efi_char16_t *variable_name,
 605                         efi_guid_t *vendor_guid)
 606 {
 607         int i, short_name_size = variable_name_size / sizeof(efi_char16_t) + 38;
 608         char *short_name;
 609         struct efivar_entry *new_efivar;
 610
 611         short_name = kmalloc(short_name_size + 1, GFP_KERNEL);
 612         new_efivar = kmalloc(sizeof(struct efivar_entry), GFP_KERNEL);
 613
 614         if (!short_name || !new_efivar)  {
 615                 if (short_name)        kfree(short_name);
 616                 if (new_efivar)        kfree(new_efivar);
 617                 return 1;
 618         }
 619         memset(short_name, 0, short_name_size+1);
 620         memset(new_efivar, 0, sizeof(struct efivar_entry));
 621
 622         memcpy(new_efivar->var.VariableName, variable_name,
 623                 variable_name_size);
 624         memcpy(&(new_efivar->var.VendorGuid), vendor_guid, sizeof(efi_guid_t));
 625
 626         /* Convert Unicode to normal chars (assume top bits are 0),
 627            ala UTF-8 */
 628         for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) {
 629                 short_name[i] = variable_name[i] & 0xFF;
 630         }
 631         /* This is ugly, but necessary to separate one vendor's
 632            private variables from another's.         */
 633
 634         *(short_name + strlen(short_name)) = '-';
 635         efi_guid_unparse(vendor_guid, short_name + strlen(short_name));
 636
 637         kobject_set_name(&new_efivar->kobj, short_name);
 638         kobj_set_kset_s(new_efivar, vars_subsys);
 639         kobject_register(&new_efivar->kobj);
 640
 641         kfree(short_name); short_name = NULL;
 642
 643         spin_lock(&efivars_lock);
 644         list_add(&new_efivar->list, &efivar_list);
 645         spin_unlock(&efivars_lock);
 646
 647         return 0;
 648 }
 649 /*
 650  * For now we register the efi subsystem with the firmware subsystem
 651  * and the vars subsystem with the efi subsystem.  In the future, it
 652  * might make sense to split off the efi subsystem into its own
 653  * driver, but for now only efivars will register with it, so just
 654  * include it here.
 655  */
 656
 657 static int __init
 658 efivars_init(void)
 659 {
 660         efi_status_t status = EFI_NOT_FOUND;
 661         efi_guid_t vendor_guid;
 662         efi_char16_t *variable_name = kmalloc(1024, GFP_KERNEL);
 663         struct subsys_attribute *attr;
 664         unsigned long variable_name_size = 1024;
 665         int i, rc = 0, error = 0;
 666
 667         printk(KERN_INFO "EFI Variables Facility v%s\n", EFIVARS_VERSION);
 668
 669         /*
 670          * For now we'll register the efi subsys within this driver
 671          */
 672
 673         rc = firmware_register(&efi_subsys);
 674
 675         if (rc)
 676                 return rc;
 677
 678         kset_set_kset_s(&vars_subsys, efi_subsys);
 679         subsystem_register(&vars_subsys);
 680
 681         /*
 682          * Per EFI spec, the maximum storage allocated for both
 683          * the variable name and variable data is 1024 bytes.
 684          */
 685
 686         memset(variable_name, 0, 1024);
 687
 688         do {
 689                 variable_name_size = 1024;
 690
 691                 status = efi.get_next_variable(&variable_name_size,
 692                                                 variable_name,
 693                                                 &vendor_guid);
 694                 switch (status) {
 695                 case EFI_SUCCESS:
 696                         efivar_create_sysfs_entry(variable_name_size,
 697                                                         variable_name,
 698                                                         &vendor_guid);
 699                         break;
 700                 case EFI_NOT_FOUND:
 701                         break;
 702                 default:
 703                         printk(KERN_WARNING "efivars: get_next_variable: status=%lx\n",
 704                                 status);
 705                         status = EFI_NOT_FOUND;
 706                         break;
 707                 }
 708         } while (status != EFI_NOT_FOUND);
 709
 710         /*
 711          * Now add attributes to allow creation of new vars
 712          * and deletion of existing ones...
 713          */
 714
 715         for (i = 0; (attr = var_subsys_attrs[i]) && !error; i++) {
 716                 if (attr->show && attr->store)
 717                         error = subsys_create_file(&vars_subsys, attr);
 718         }
 719
 720         /* Don't forget the systab entry */
 721
 722         for (i = 0; (attr = efi_subsys_attrs[i]) && !error; i++) {
 723                 if (attr->show)
 724                         error = subsys_create_file(&efi_subsys, attr);
 725         }
 726
 727         kfree(variable_name);
 728         return 0;
 729 }
 730
 731 static void __exit
 732 efivars_exit(void)
 733 {
 734         struct list_head *pos, *n;
 735
 736         list_for_each_safe(pos, n, &efivar_list)
 737                 efivar_unregister(get_efivar_entry(pos));
 738
 739         subsystem_unregister(&vars_subsys);
 740         firmware_unregister(&efi_subsys);
 741 }
 742
 743 module_init(efivars_init);
 744 module_exit(efivars_exit);
 745