Loading...
Note: File does not exist in v4.6.
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Think LMI BIOS configuration driver
4 *
5 * Copyright(C) 2019-2021 Lenovo
6 *
7 * Original code from Thinkpad-wmi project https://github.com/iksaif/thinkpad-wmi
8 * Copyright(C) 2017 Corentin Chary <corentin.chary@gmail.com>
9 * Distributed under the GPL-2.0 license
10 */
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/acpi.h>
15#include <linux/errno.h>
16#include <linux/fs.h>
17#include <linux/string.h>
18#include <linux/types.h>
19#include <linux/wmi.h>
20#include "firmware_attributes_class.h"
21#include "think-lmi.h"
22
23/*
24 * Name:
25 * Lenovo_BiosSetting
26 * Description:
27 * Get item name and settings for current LMI instance.
28 * Type:
29 * Query
30 * Returns:
31 * "Item,Value"
32 * Example:
33 * "WakeOnLAN,Enable"
34 */
35#define LENOVO_BIOS_SETTING_GUID "51F5230E-9677-46CD-A1CF-C0B23EE34DB7"
36
37/*
38 * Name:
39 * Lenovo_SetBiosSetting
40 * Description:
41 * Change the BIOS setting to the desired value using the Lenovo_SetBiosSetting
42 * class. To save the settings, use the Lenovo_SaveBiosSetting class.
43 * BIOS settings and values are case sensitive.
44 * After making changes to the BIOS settings, you must reboot the computer
45 * before the changes will take effect.
46 * Type:
47 * Method
48 * Arguments:
49 * "Item,Value,Password,Encoding,KbdLang;"
50 * Example:
51 * "WakeOnLAN,Disable,pa55w0rd,ascii,us;"
52 */
53#define LENOVO_SET_BIOS_SETTINGS_GUID "98479A64-33F5-4E33-A707-8E251EBBC3A1"
54
55/*
56 * Name:
57 * Lenovo_SaveBiosSettings
58 * Description:
59 * Save any pending changes in settings.
60 * Type:
61 * Method
62 * Arguments:
63 * "Password,Encoding,KbdLang;"
64 * Example:
65 * "pa55w0rd,ascii,us;"
66 */
67#define LENOVO_SAVE_BIOS_SETTINGS_GUID "6A4B54EF-A5ED-4D33-9455-B0D9B48DF4B3"
68
69/*
70 * Name:
71 * Lenovo_BiosPasswordSettings
72 * Description:
73 * Return BIOS Password settings
74 * Type:
75 * Query
76 * Returns:
77 * PasswordMode, PasswordState, MinLength, MaxLength,
78 * SupportedEncoding, SupportedKeyboard
79 */
80#define LENOVO_BIOS_PASSWORD_SETTINGS_GUID "8ADB159E-1E32-455C-BC93-308A7ED98246"
81
82/*
83 * Name:
84 * Lenovo_SetBiosPassword
85 * Description:
86 * Change a specific password.
87 * - BIOS settings cannot be changed at the same boot as power-on
88 * passwords (POP) and hard disk passwords (HDP). If you want to change
89 * BIOS settings and POP or HDP, you must reboot the system after changing
90 * one of them.
91 * - A password cannot be set using this method when one does not already
92 * exist. Passwords can only be updated or cleared.
93 * Type:
94 * Method
95 * Arguments:
96 * "PasswordType,CurrentPassword,NewPassword,Encoding,KbdLang;"
97 * Example:
98 * "pop,pa55w0rd,newpa55w0rd,ascii,us;”
99 */
100#define LENOVO_SET_BIOS_PASSWORD_GUID "2651D9FD-911C-4B69-B94E-D0DED5963BD7"
101
102/*
103 * Name:
104 * Lenovo_GetBiosSelections
105 * Description:
106 * Return a list of valid settings for a given item.
107 * Type:
108 * Method
109 * Arguments:
110 * "Item"
111 * Returns:
112 * "Value1,Value2,Value3,..."
113 * Example:
114 * -> "FlashOverLAN"
115 * <- "Enabled,Disabled"
116 */
117#define LENOVO_GET_BIOS_SELECTIONS_GUID "7364651A-132F-4FE7-ADAA-40C6C7EE2E3B"
118
119#define TLMI_POP_PWD (1 << 0)
120#define TLMI_PAP_PWD (1 << 1)
121#define to_tlmi_pwd_setting(kobj) container_of(kobj, struct tlmi_pwd_setting, kobj)
122#define to_tlmi_attr_setting(kobj) container_of(kobj, struct tlmi_attr_setting, kobj)
123
124static const struct tlmi_err_codes tlmi_errs[] = {
125 {"Success", 0},
126 {"Not Supported", -EOPNOTSUPP},
127 {"Invalid Parameter", -EINVAL},
128 {"Access Denied", -EACCES},
129 {"System Busy", -EBUSY},
130};
131
132static const char * const encoding_options[] = {
133 [TLMI_ENCODING_ASCII] = "ascii",
134 [TLMI_ENCODING_SCANCODE] = "scancode",
135};
136static struct think_lmi tlmi_priv;
137static struct class *fw_attr_class;
138
139/* ------ Utility functions ------------*/
140/* Convert BIOS WMI error string to suitable error code */
141static int tlmi_errstr_to_err(const char *errstr)
142{
143 int i;
144
145 for (i = 0; i < sizeof(tlmi_errs)/sizeof(struct tlmi_err_codes); i++) {
146 if (!strcmp(tlmi_errs[i].err_str, errstr))
147 return tlmi_errs[i].err_code;
148 }
149 return -EPERM;
150}
151
152/* Extract error string from WMI return buffer */
153static int tlmi_extract_error(const struct acpi_buffer *output)
154{
155 const union acpi_object *obj;
156
157 obj = output->pointer;
158 if (!obj)
159 return -ENOMEM;
160 if (obj->type != ACPI_TYPE_STRING || !obj->string.pointer)
161 return -EIO;
162
163 return tlmi_errstr_to_err(obj->string.pointer);
164}
165
166/* Utility function to execute WMI call to BIOS */
167static int tlmi_simple_call(const char *guid, const char *arg)
168{
169 const struct acpi_buffer input = { strlen(arg), (char *)arg };
170 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
171 acpi_status status;
172 int i, err;
173
174 /*
175 * Duplicated call required to match BIOS workaround for behavior
176 * seen when WMI accessed via scripting on other OS.
177 */
178 for (i = 0; i < 2; i++) {
179 /* (re)initialize output buffer to default state */
180 output.length = ACPI_ALLOCATE_BUFFER;
181 output.pointer = NULL;
182
183 status = wmi_evaluate_method(guid, 0, 0, &input, &output);
184 if (ACPI_FAILURE(status)) {
185 kfree(output.pointer);
186 return -EIO;
187 }
188 err = tlmi_extract_error(&output);
189 kfree(output.pointer);
190 if (err)
191 return err;
192 }
193 return 0;
194}
195
196/* Extract output string from WMI return buffer */
197static int tlmi_extract_output_string(const struct acpi_buffer *output,
198 char **string)
199{
200 const union acpi_object *obj;
201 char *s;
202
203 obj = output->pointer;
204 if (!obj)
205 return -ENOMEM;
206 if (obj->type != ACPI_TYPE_STRING || !obj->string.pointer)
207 return -EIO;
208
209 s = kstrdup(obj->string.pointer, GFP_KERNEL);
210 if (!s)
211 return -ENOMEM;
212 *string = s;
213 return 0;
214}
215
216/* ------ Core interface functions ------------*/
217
218/* Get password settings from BIOS */
219static int tlmi_get_pwd_settings(struct tlmi_pwdcfg *pwdcfg)
220{
221 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
222 const union acpi_object *obj;
223 acpi_status status;
224
225 if (!tlmi_priv.can_get_password_settings)
226 return -EOPNOTSUPP;
227
228 status = wmi_query_block(LENOVO_BIOS_PASSWORD_SETTINGS_GUID, 0,
229 &output);
230 if (ACPI_FAILURE(status))
231 return -EIO;
232
233 obj = output.pointer;
234 if (!obj)
235 return -ENOMEM;
236 if (obj->type != ACPI_TYPE_BUFFER || !obj->buffer.pointer) {
237 kfree(obj);
238 return -EIO;
239 }
240 /*
241 * The size of thinkpad_wmi_pcfg on ThinkStation is larger than ThinkPad.
242 * To make the driver compatible on different brands, we permit it to get
243 * the data in below case.
244 */
245 if (obj->buffer.length < sizeof(struct tlmi_pwdcfg)) {
246 pr_warn("Unknown pwdcfg buffer length %d\n", obj->buffer.length);
247 kfree(obj);
248 return -EIO;
249 }
250 memcpy(pwdcfg, obj->buffer.pointer, sizeof(struct tlmi_pwdcfg));
251 kfree(obj);
252 return 0;
253}
254
255static int tlmi_save_bios_settings(const char *password)
256{
257 return tlmi_simple_call(LENOVO_SAVE_BIOS_SETTINGS_GUID,
258 password);
259}
260
261static int tlmi_setting(int item, char **value, const char *guid_string)
262{
263 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
264 acpi_status status;
265 int ret;
266
267 status = wmi_query_block(guid_string, item, &output);
268 if (ACPI_FAILURE(status)) {
269 kfree(output.pointer);
270 return -EIO;
271 }
272
273 ret = tlmi_extract_output_string(&output, value);
274 kfree(output.pointer);
275 return ret;
276}
277
278static int tlmi_get_bios_selections(const char *item, char **value)
279{
280 const struct acpi_buffer input = { strlen(item), (char *)item };
281 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
282 acpi_status status;
283 int ret;
284
285 status = wmi_evaluate_method(LENOVO_GET_BIOS_SELECTIONS_GUID,
286 0, 0, &input, &output);
287
288 if (ACPI_FAILURE(status)) {
289 kfree(output.pointer);
290 return -EIO;
291 }
292
293 ret = tlmi_extract_output_string(&output, value);
294 kfree(output.pointer);
295 return ret;
296}
297
298/* ---- Authentication sysfs --------------------------------------------------------- */
299static ssize_t is_enabled_show(struct kobject *kobj, struct kobj_attribute *attr,
300 char *buf)
301{
302 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
303
304 return sysfs_emit(buf, "%d\n", setting->valid);
305}
306
307static struct kobj_attribute auth_is_pass_set = __ATTR_RO(is_enabled);
308
309static ssize_t current_password_store(struct kobject *kobj,
310 struct kobj_attribute *attr,
311 const char *buf, size_t count)
312{
313 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
314 size_t pwdlen;
315 char *p;
316
317 pwdlen = strlen(buf);
318 /* pwdlen == 0 is allowed to clear the password */
319 if (pwdlen && ((pwdlen < setting->minlen) || (pwdlen > setting->maxlen)))
320 return -EINVAL;
321
322 strscpy(setting->password, buf, setting->maxlen);
323 /* Strip out CR if one is present, setting password won't work if it is present */
324 p = strchrnul(setting->password, '\n');
325 *p = '\0';
326 return count;
327}
328
329static struct kobj_attribute auth_current_password = __ATTR_WO(current_password);
330
331static ssize_t new_password_store(struct kobject *kobj,
332 struct kobj_attribute *attr,
333 const char *buf, size_t count)
334{
335 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
336 char *auth_str, *new_pwd, *p;
337 size_t pwdlen;
338 int ret;
339
340 if (!capable(CAP_SYS_ADMIN))
341 return -EPERM;
342
343 if (!tlmi_priv.can_set_bios_password)
344 return -EOPNOTSUPP;
345
346 new_pwd = kstrdup(buf, GFP_KERNEL);
347 if (!new_pwd)
348 return -ENOMEM;
349
350 /* Strip out CR if one is present, setting password won't work if it is present */
351 p = strchrnul(new_pwd, '\n');
352 *p = '\0';
353
354 pwdlen = strlen(new_pwd);
355 /* pwdlen == 0 is allowed to clear the password */
356 if (pwdlen && ((pwdlen < setting->minlen) || (pwdlen > setting->maxlen))) {
357 ret = -EINVAL;
358 goto out;
359 }
360
361 /* Format: 'PasswordType,CurrentPw,NewPw,Encoding,KbdLang;' */
362 auth_str = kasprintf(GFP_KERNEL, "%s,%s,%s,%s,%s;",
363 setting->pwd_type, setting->password, new_pwd,
364 encoding_options[setting->encoding], setting->kbdlang);
365 if (!auth_str) {
366 ret = -ENOMEM;
367 goto out;
368 }
369 ret = tlmi_simple_call(LENOVO_SET_BIOS_PASSWORD_GUID, auth_str);
370 kfree(auth_str);
371out:
372 kfree(new_pwd);
373 return ret ?: count;
374}
375
376static struct kobj_attribute auth_new_password = __ATTR_WO(new_password);
377
378static ssize_t min_password_length_show(struct kobject *kobj, struct kobj_attribute *attr,
379 char *buf)
380{
381 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
382
383 return sysfs_emit(buf, "%d\n", setting->minlen);
384}
385
386static struct kobj_attribute auth_min_pass_length = __ATTR_RO(min_password_length);
387
388static ssize_t max_password_length_show(struct kobject *kobj, struct kobj_attribute *attr,
389 char *buf)
390{
391 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
392
393 return sysfs_emit(buf, "%d\n", setting->maxlen);
394}
395static struct kobj_attribute auth_max_pass_length = __ATTR_RO(max_password_length);
396
397static ssize_t mechanism_show(struct kobject *kobj, struct kobj_attribute *attr,
398 char *buf)
399{
400 return sysfs_emit(buf, "password\n");
401}
402static struct kobj_attribute auth_mechanism = __ATTR_RO(mechanism);
403
404static ssize_t encoding_show(struct kobject *kobj, struct kobj_attribute *attr,
405 char *buf)
406{
407 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
408
409 return sysfs_emit(buf, "%s\n", encoding_options[setting->encoding]);
410}
411
412static ssize_t encoding_store(struct kobject *kobj,
413 struct kobj_attribute *attr,
414 const char *buf, size_t count)
415{
416 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
417 int i;
418
419 /* Scan for a matching profile */
420 i = sysfs_match_string(encoding_options, buf);
421 if (i < 0)
422 return -EINVAL;
423
424 setting->encoding = i;
425 return count;
426}
427
428static struct kobj_attribute auth_encoding = __ATTR_RW(encoding);
429
430static ssize_t kbdlang_show(struct kobject *kobj, struct kobj_attribute *attr,
431 char *buf)
432{
433 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
434
435 return sysfs_emit(buf, "%s\n", setting->kbdlang);
436}
437
438static ssize_t kbdlang_store(struct kobject *kobj,
439 struct kobj_attribute *attr,
440 const char *buf, size_t count)
441{
442 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
443 int length;
444
445 /* Calculate length till '\n' or terminating 0 */
446 length = strchrnul(buf, '\n') - buf;
447 if (!length || length >= TLMI_LANG_MAXLEN)
448 return -EINVAL;
449
450 memcpy(setting->kbdlang, buf, length);
451 setting->kbdlang[length] = '\0';
452 return count;
453}
454
455static struct kobj_attribute auth_kbdlang = __ATTR_RW(kbdlang);
456
457static ssize_t role_show(struct kobject *kobj, struct kobj_attribute *attr,
458 char *buf)
459{
460 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
461
462 return sysfs_emit(buf, "%s\n", setting->role);
463}
464static struct kobj_attribute auth_role = __ATTR_RO(role);
465
466static struct attribute *auth_attrs[] = {
467 &auth_is_pass_set.attr,
468 &auth_min_pass_length.attr,
469 &auth_max_pass_length.attr,
470 &auth_current_password.attr,
471 &auth_new_password.attr,
472 &auth_role.attr,
473 &auth_mechanism.attr,
474 &auth_encoding.attr,
475 &auth_kbdlang.attr,
476 NULL
477};
478
479static const struct attribute_group auth_attr_group = {
480 .attrs = auth_attrs,
481};
482
483/* ---- Attributes sysfs --------------------------------------------------------- */
484static ssize_t display_name_show(struct kobject *kobj, struct kobj_attribute *attr,
485 char *buf)
486{
487 struct tlmi_attr_setting *setting = to_tlmi_attr_setting(kobj);
488
489 return sysfs_emit(buf, "%s\n", setting->display_name);
490}
491
492static ssize_t current_value_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
493{
494 struct tlmi_attr_setting *setting = to_tlmi_attr_setting(kobj);
495 char *item, *value;
496 int ret;
497
498 ret = tlmi_setting(setting->index, &item, LENOVO_BIOS_SETTING_GUID);
499 if (ret)
500 return ret;
501
502 /* validate and split from `item,value` -> `value` */
503 value = strpbrk(item, ",");
504 if (!value || value == item || !strlen(value + 1))
505 return -EINVAL;
506
507 ret = sysfs_emit(buf, "%s\n", value + 1);
508 kfree(item);
509 return ret;
510}
511
512static ssize_t possible_values_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
513{
514 struct tlmi_attr_setting *setting = to_tlmi_attr_setting(kobj);
515
516 if (!tlmi_priv.can_get_bios_selections)
517 return -EOPNOTSUPP;
518
519 return sysfs_emit(buf, "%s\n", setting->possible_values);
520}
521
522static ssize_t current_value_store(struct kobject *kobj,
523 struct kobj_attribute *attr,
524 const char *buf, size_t count)
525{
526 struct tlmi_attr_setting *setting = to_tlmi_attr_setting(kobj);
527 char *set_str = NULL, *new_setting = NULL;
528 char *auth_str = NULL;
529 char *p;
530 int ret;
531
532 if (!tlmi_priv.can_set_bios_settings)
533 return -EOPNOTSUPP;
534
535 new_setting = kstrdup(buf, GFP_KERNEL);
536 if (!new_setting)
537 return -ENOMEM;
538
539 /* Strip out CR if one is present */
540 p = strchrnul(new_setting, '\n');
541 *p = '\0';
542
543 if (tlmi_priv.pwd_admin->valid && tlmi_priv.pwd_admin->password[0]) {
544 auth_str = kasprintf(GFP_KERNEL, "%s,%s,%s;",
545 tlmi_priv.pwd_admin->password,
546 encoding_options[tlmi_priv.pwd_admin->encoding],
547 tlmi_priv.pwd_admin->kbdlang);
548 if (!auth_str) {
549 ret = -ENOMEM;
550 goto out;
551 }
552 }
553
554 if (auth_str)
555 set_str = kasprintf(GFP_KERNEL, "%s,%s,%s", setting->display_name,
556 new_setting, auth_str);
557 else
558 set_str = kasprintf(GFP_KERNEL, "%s,%s;", setting->display_name,
559 new_setting);
560 if (!set_str) {
561 ret = -ENOMEM;
562 goto out;
563 }
564
565 ret = tlmi_simple_call(LENOVO_SET_BIOS_SETTINGS_GUID, set_str);
566 if (ret)
567 goto out;
568
569 if (auth_str)
570 ret = tlmi_save_bios_settings(auth_str);
571 else
572 ret = tlmi_save_bios_settings("");
573
574 if (!ret && !tlmi_priv.pending_changes) {
575 tlmi_priv.pending_changes = true;
576 /* let userland know it may need to check reboot pending again */
577 kobject_uevent(&tlmi_priv.class_dev->kobj, KOBJ_CHANGE);
578 }
579out:
580 kfree(auth_str);
581 kfree(set_str);
582 kfree(new_setting);
583 return ret ?: count;
584}
585
586static struct kobj_attribute attr_displ_name = __ATTR_RO(display_name);
587
588static struct kobj_attribute attr_possible_values = __ATTR_RO(possible_values);
589
590static struct kobj_attribute attr_current_val = __ATTR_RW_MODE(current_value, 0600);
591
592static struct attribute *tlmi_attrs[] = {
593 &attr_displ_name.attr,
594 &attr_current_val.attr,
595 &attr_possible_values.attr,
596 NULL
597};
598
599static const struct attribute_group tlmi_attr_group = {
600 .attrs = tlmi_attrs,
601};
602
603static ssize_t tlmi_attr_show(struct kobject *kobj, struct attribute *attr,
604 char *buf)
605{
606 struct kobj_attribute *kattr;
607
608 kattr = container_of(attr, struct kobj_attribute, attr);
609 if (kattr->show)
610 return kattr->show(kobj, kattr, buf);
611 return -EIO;
612}
613
614static ssize_t tlmi_attr_store(struct kobject *kobj, struct attribute *attr,
615 const char *buf, size_t count)
616{
617 struct kobj_attribute *kattr;
618
619 kattr = container_of(attr, struct kobj_attribute, attr);
620 if (kattr->store)
621 return kattr->store(kobj, kattr, buf, count);
622 return -EIO;
623}
624
625static const struct sysfs_ops tlmi_kobj_sysfs_ops = {
626 .show = tlmi_attr_show,
627 .store = tlmi_attr_store,
628};
629
630static void tlmi_attr_setting_release(struct kobject *kobj)
631{
632 struct tlmi_attr_setting *setting = to_tlmi_attr_setting(kobj);
633
634 kfree(setting->possible_values);
635 kfree(setting);
636}
637
638static void tlmi_pwd_setting_release(struct kobject *kobj)
639{
640 struct tlmi_pwd_setting *setting = to_tlmi_pwd_setting(kobj);
641
642 kfree(setting);
643}
644
645static struct kobj_type tlmi_attr_setting_ktype = {
646 .release = &tlmi_attr_setting_release,
647 .sysfs_ops = &tlmi_kobj_sysfs_ops,
648};
649
650static struct kobj_type tlmi_pwd_setting_ktype = {
651 .release = &tlmi_pwd_setting_release,
652 .sysfs_ops = &tlmi_kobj_sysfs_ops,
653};
654
655static ssize_t pending_reboot_show(struct kobject *kobj, struct kobj_attribute *attr,
656 char *buf)
657{
658 return sprintf(buf, "%d\n", tlmi_priv.pending_changes);
659}
660
661static struct kobj_attribute pending_reboot = __ATTR_RO(pending_reboot);
662
663/* ---- Initialisation --------------------------------------------------------- */
664static void tlmi_release_attr(void)
665{
666 int i;
667
668 /* Attribute structures */
669 for (i = 0; i < TLMI_SETTINGS_COUNT; i++) {
670 if (tlmi_priv.setting[i]) {
671 sysfs_remove_group(&tlmi_priv.setting[i]->kobj, &tlmi_attr_group);
672 kobject_put(&tlmi_priv.setting[i]->kobj);
673 }
674 }
675 sysfs_remove_file(&tlmi_priv.attribute_kset->kobj, &pending_reboot.attr);
676 kset_unregister(tlmi_priv.attribute_kset);
677
678 /* Authentication structures */
679 sysfs_remove_group(&tlmi_priv.pwd_admin->kobj, &auth_attr_group);
680 kobject_put(&tlmi_priv.pwd_admin->kobj);
681 sysfs_remove_group(&tlmi_priv.pwd_power->kobj, &auth_attr_group);
682 kobject_put(&tlmi_priv.pwd_power->kobj);
683 kset_unregister(tlmi_priv.authentication_kset);
684}
685
686static int tlmi_sysfs_init(void)
687{
688 int i, ret;
689
690 ret = fw_attributes_class_get(&fw_attr_class);
691 if (ret)
692 return ret;
693
694 tlmi_priv.class_dev = device_create(fw_attr_class, NULL, MKDEV(0, 0),
695 NULL, "%s", "thinklmi");
696 if (IS_ERR(tlmi_priv.class_dev)) {
697 ret = PTR_ERR(tlmi_priv.class_dev);
698 goto fail_class_created;
699 }
700
701 tlmi_priv.attribute_kset = kset_create_and_add("attributes", NULL,
702 &tlmi_priv.class_dev->kobj);
703 if (!tlmi_priv.attribute_kset) {
704 ret = -ENOMEM;
705 goto fail_device_created;
706 }
707
708 for (i = 0; i < TLMI_SETTINGS_COUNT; i++) {
709 /* Check if index is a valid setting - skip if it isn't */
710 if (!tlmi_priv.setting[i])
711 continue;
712
713 /* check for duplicate or reserved values */
714 if (kset_find_obj(tlmi_priv.attribute_kset, tlmi_priv.setting[i]->display_name) ||
715 !strcmp(tlmi_priv.setting[i]->display_name, "Reserved")) {
716 pr_debug("duplicate or reserved attribute name found - %s\n",
717 tlmi_priv.setting[i]->display_name);
718 kfree(tlmi_priv.setting[i]->possible_values);
719 kfree(tlmi_priv.setting[i]);
720 tlmi_priv.setting[i] = NULL;
721 continue;
722 }
723
724 /* Build attribute */
725 tlmi_priv.setting[i]->kobj.kset = tlmi_priv.attribute_kset;
726 ret = kobject_add(&tlmi_priv.setting[i]->kobj, NULL,
727 "%s", tlmi_priv.setting[i]->display_name);
728 if (ret)
729 goto fail_create_attr;
730
731 ret = sysfs_create_group(&tlmi_priv.setting[i]->kobj, &tlmi_attr_group);
732 if (ret)
733 goto fail_create_attr;
734 }
735
736 ret = sysfs_create_file(&tlmi_priv.attribute_kset->kobj, &pending_reboot.attr);
737 if (ret)
738 goto fail_create_attr;
739
740 /* Create authentication entries */
741 tlmi_priv.authentication_kset = kset_create_and_add("authentication", NULL,
742 &tlmi_priv.class_dev->kobj);
743 if (!tlmi_priv.authentication_kset) {
744 ret = -ENOMEM;
745 goto fail_create_attr;
746 }
747 tlmi_priv.pwd_admin->kobj.kset = tlmi_priv.authentication_kset;
748 ret = kobject_add(&tlmi_priv.pwd_admin->kobj, NULL, "%s", "Admin");
749 if (ret)
750 goto fail_create_attr;
751
752 ret = sysfs_create_group(&tlmi_priv.pwd_admin->kobj, &auth_attr_group);
753 if (ret)
754 goto fail_create_attr;
755
756 tlmi_priv.pwd_power->kobj.kset = tlmi_priv.authentication_kset;
757 ret = kobject_add(&tlmi_priv.pwd_power->kobj, NULL, "%s", "System");
758 if (ret)
759 goto fail_create_attr;
760
761 ret = sysfs_create_group(&tlmi_priv.pwd_power->kobj, &auth_attr_group);
762 if (ret)
763 goto fail_create_attr;
764
765 return ret;
766
767fail_create_attr:
768 tlmi_release_attr();
769fail_device_created:
770 device_destroy(fw_attr_class, MKDEV(0, 0));
771fail_class_created:
772 fw_attributes_class_put();
773 return ret;
774}
775
776/* ---- Base Driver -------------------------------------------------------- */
777static int tlmi_analyze(void)
778{
779 struct tlmi_pwdcfg pwdcfg;
780 acpi_status status;
781 int i, ret;
782
783 if (wmi_has_guid(LENOVO_SET_BIOS_SETTINGS_GUID) &&
784 wmi_has_guid(LENOVO_SAVE_BIOS_SETTINGS_GUID))
785 tlmi_priv.can_set_bios_settings = true;
786
787 if (wmi_has_guid(LENOVO_GET_BIOS_SELECTIONS_GUID))
788 tlmi_priv.can_get_bios_selections = true;
789
790 if (wmi_has_guid(LENOVO_SET_BIOS_PASSWORD_GUID))
791 tlmi_priv.can_set_bios_password = true;
792
793 if (wmi_has_guid(LENOVO_BIOS_PASSWORD_SETTINGS_GUID))
794 tlmi_priv.can_get_password_settings = true;
795
796 /*
797 * Try to find the number of valid settings of this machine
798 * and use it to create sysfs attributes.
799 */
800 for (i = 0; i < TLMI_SETTINGS_COUNT; ++i) {
801 struct tlmi_attr_setting *setting;
802 char *item = NULL;
803 char *p;
804
805 tlmi_priv.setting[i] = NULL;
806 status = tlmi_setting(i, &item, LENOVO_BIOS_SETTING_GUID);
807 if (ACPI_FAILURE(status))
808 break;
809 if (!item)
810 break;
811 if (!*item)
812 continue;
813
814 /* It is not allowed to have '/' for file name. Convert it into '\'. */
815 strreplace(item, '/', '\\');
816
817 /* Remove the value part */
818 p = strchrnul(item, ',');
819 *p = '\0';
820
821 /* Create a setting entry */
822 setting = kzalloc(sizeof(*setting), GFP_KERNEL);
823 if (!setting) {
824 ret = -ENOMEM;
825 goto fail_clear_attr;
826 }
827 setting->index = i;
828 strscpy(setting->display_name, item, TLMI_SETTINGS_MAXLEN);
829 /* If BIOS selections supported, load those */
830 if (tlmi_priv.can_get_bios_selections) {
831 ret = tlmi_get_bios_selections(setting->display_name,
832 &setting->possible_values);
833 if (ret || !setting->possible_values)
834 pr_info("Error retrieving possible values for %d : %s\n",
835 i, setting->display_name);
836 }
837 kobject_init(&setting->kobj, &tlmi_attr_setting_ktype);
838 tlmi_priv.setting[i] = setting;
839 tlmi_priv.settings_count++;
840 kfree(item);
841 }
842
843 /* Create password setting structure */
844 ret = tlmi_get_pwd_settings(&pwdcfg);
845 if (ret)
846 goto fail_clear_attr;
847
848 tlmi_priv.pwd_admin = kzalloc(sizeof(struct tlmi_pwd_setting), GFP_KERNEL);
849 if (!tlmi_priv.pwd_admin) {
850 ret = -ENOMEM;
851 goto fail_clear_attr;
852 }
853 strscpy(tlmi_priv.pwd_admin->kbdlang, "us", TLMI_LANG_MAXLEN);
854 tlmi_priv.pwd_admin->encoding = TLMI_ENCODING_ASCII;
855 tlmi_priv.pwd_admin->pwd_type = "pap";
856 tlmi_priv.pwd_admin->role = "bios-admin";
857 tlmi_priv.pwd_admin->minlen = pwdcfg.min_length;
858 if (WARN_ON(pwdcfg.max_length >= TLMI_PWD_BUFSIZE))
859 pwdcfg.max_length = TLMI_PWD_BUFSIZE - 1;
860 tlmi_priv.pwd_admin->maxlen = pwdcfg.max_length;
861 if (pwdcfg.password_state & TLMI_PAP_PWD)
862 tlmi_priv.pwd_admin->valid = true;
863
864 kobject_init(&tlmi_priv.pwd_admin->kobj, &tlmi_pwd_setting_ktype);
865
866 tlmi_priv.pwd_power = kzalloc(sizeof(struct tlmi_pwd_setting), GFP_KERNEL);
867 if (!tlmi_priv.pwd_power) {
868 ret = -ENOMEM;
869 goto fail_free_pwd_admin;
870 }
871 strscpy(tlmi_priv.pwd_power->kbdlang, "us", TLMI_LANG_MAXLEN);
872 tlmi_priv.pwd_power->encoding = TLMI_ENCODING_ASCII;
873 tlmi_priv.pwd_power->pwd_type = "pop";
874 tlmi_priv.pwd_power->role = "power-on";
875 tlmi_priv.pwd_power->minlen = pwdcfg.min_length;
876 tlmi_priv.pwd_power->maxlen = pwdcfg.max_length;
877
878 if (pwdcfg.password_state & TLMI_POP_PWD)
879 tlmi_priv.pwd_power->valid = true;
880
881 kobject_init(&tlmi_priv.pwd_power->kobj, &tlmi_pwd_setting_ktype);
882
883 return 0;
884
885fail_free_pwd_admin:
886 kfree(tlmi_priv.pwd_admin);
887fail_clear_attr:
888 for (i = 0; i < TLMI_SETTINGS_COUNT; ++i) {
889 if (tlmi_priv.setting[i]) {
890 kfree(tlmi_priv.setting[i]->possible_values);
891 kfree(tlmi_priv.setting[i]);
892 }
893 }
894 return ret;
895}
896
897static void tlmi_remove(struct wmi_device *wdev)
898{
899 tlmi_release_attr();
900 device_destroy(fw_attr_class, MKDEV(0, 0));
901 fw_attributes_class_put();
902}
903
904static int tlmi_probe(struct wmi_device *wdev, const void *context)
905{
906 tlmi_analyze();
907 return tlmi_sysfs_init();
908}
909
910static const struct wmi_device_id tlmi_id_table[] = {
911 { .guid_string = LENOVO_BIOS_SETTING_GUID },
912 { }
913};
914MODULE_DEVICE_TABLE(wmi, tlmi_id_table);
915
916static struct wmi_driver tlmi_driver = {
917 .driver = {
918 .name = "think-lmi",
919 },
920 .id_table = tlmi_id_table,
921 .probe = tlmi_probe,
922 .remove = tlmi_remove,
923};
924
925MODULE_AUTHOR("Sugumaran L <slacshiminar@lenovo.com>");
926MODULE_AUTHOR("Mark Pearson <markpearson@lenovo.com>");
927MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>");
928MODULE_DESCRIPTION("ThinkLMI Driver");
929MODULE_LICENSE("GPL");
930
931module_wmi_driver(tlmi_driver);