1
2
3
4
5
6
7
8
9
10
11#include <linux/kernel.h>
12#include <linux/init.h>
13#include <linux/types.h>
14#include <linux/device.h>
15#include <linux/platform_device.h>
16#include <linux/errno.h>
17#include <linux/string.h>
18#include <linux/spinlock.h>
19#include <linux/dma-mapping.h>
20#include <linux/fs.h>
21#include <linux/slab.h>
22#include <linux/panic_notifier.h>
23#include <linux/ioctl.h>
24#include <linux/acpi.h>
25#include <linux/io.h>
26#include <linux/uaccess.h>
27#include <linux/dmi.h>
28#include <linux/kdebug.h>
29#include <linux/reboot.h>
30#include <linux/efi.h>
31#include <linux/module.h>
32#include <linux/ucs2_string.h>
33#include <linux/suspend.h>
34
35#define GSMI_SHUTDOWN_CLEAN 0
36
37#define GSMI_SHUTDOWN_NMIWDT 1
38#define GSMI_SHUTDOWN_PANIC 2
39#define GSMI_SHUTDOWN_OOPS 3
40#define GSMI_SHUTDOWN_DIE 4
41#define GSMI_SHUTDOWN_MCE 5
42#define GSMI_SHUTDOWN_SOFTWDT 6
43#define GSMI_SHUTDOWN_MBE 7
44#define GSMI_SHUTDOWN_TRIPLE 8
45
46#define DRIVER_VERSION "1.0"
47#define GSMI_GUID_SIZE 16
48#define GSMI_BUF_SIZE 1024
49#define GSMI_BUF_ALIGN sizeof(u64)
50#define GSMI_CALLBACK 0xef
51
52
53#define GSMI_SUCCESS 0x00
54#define GSMI_UNSUPPORTED2 0x03
55#define GSMI_LOG_FULL 0x0b
56#define GSMI_VAR_NOT_FOUND 0x0e
57#define GSMI_HANDSHAKE_SPIN 0x7d
58#define GSMI_HANDSHAKE_CF 0x7e
59#define GSMI_HANDSHAKE_NONE 0x7f
60#define GSMI_INVALID_PARAMETER 0x82
61#define GSMI_UNSUPPORTED 0x83
62#define GSMI_BUFFER_TOO_SMALL 0x85
63#define GSMI_NOT_READY 0x86
64#define GSMI_DEVICE_ERROR 0x87
65#define GSMI_NOT_FOUND 0x8e
66
67#define QUIRKY_BOARD_HASH 0x78a30a50
68
69
70#define GSMI_CMD_GET_NVRAM_VAR 0x01
71#define GSMI_CMD_GET_NEXT_VAR 0x02
72#define GSMI_CMD_SET_NVRAM_VAR 0x03
73#define GSMI_CMD_SET_EVENT_LOG 0x08
74#define GSMI_CMD_CLEAR_EVENT_LOG 0x09
75#define GSMI_CMD_LOG_S0IX_SUSPEND 0x0a
76#define GSMI_CMD_LOG_S0IX_RESUME 0x0b
77#define GSMI_CMD_CLEAR_CONFIG 0x20
78#define GSMI_CMD_HANDSHAKE_TYPE 0xC1
79#define GSMI_CMD_RESERVED 0xff
80
81
82#define GSMI_LOG_ENTRY_TYPE_KERNEL 0xDEAD
83
84
85struct gsmi_buf {
86 u8 *start;
87 size_t length;
88 u32 address;
89};
90
91static struct gsmi_device {
92 struct platform_device *pdev;
93 struct gsmi_buf *name_buf;
94 struct gsmi_buf *data_buf;
95 struct gsmi_buf *param_buf;
96 spinlock_t lock;
97 u16 smi_cmd;
98 int handshake_type;
99 struct kmem_cache *mem_pool;
100} gsmi_dev;
101
102
103struct gsmi_nvram_var_param {
104 efi_guid_t guid;
105 u32 name_ptr;
106 u32 attributes;
107 u32 data_len;
108 u32 data_ptr;
109} __packed;
110
111struct gsmi_get_next_var_param {
112 u8 guid[GSMI_GUID_SIZE];
113 u32 name_ptr;
114 u32 name_len;
115} __packed;
116
117struct gsmi_set_eventlog_param {
118 u32 data_ptr;
119 u32 data_len;
120 u32 type;
121} __packed;
122
123
124struct gsmi_log_entry_type_1 {
125 u16 type;
126 u32 instance;
127} __packed;
128
129
130
131
132
133#define GSMI_DEFAULT_SPINCOUNT 0x10000
134static unsigned int spincount = GSMI_DEFAULT_SPINCOUNT;
135module_param(spincount, uint, 0600);
136MODULE_PARM_DESC(spincount,
137 "The number of loop iterations to use when using the spin handshake.");
138
139
140
141
142
143
144
145
146
147
148
149static bool s0ix_logging_enable = true;
150module_param(s0ix_logging_enable, bool, 0600);
151
152static struct gsmi_buf *gsmi_buf_alloc(void)
153{
154 struct gsmi_buf *smibuf;
155
156 smibuf = kzalloc(sizeof(*smibuf), GFP_KERNEL);
157 if (!smibuf) {
158 printk(KERN_ERR "gsmi: out of memory\n");
159 return NULL;
160 }
161
162
163 smibuf->start = kmem_cache_alloc(gsmi_dev.mem_pool, GFP_KERNEL);
164 if (!smibuf->start) {
165 printk(KERN_ERR "gsmi: failed to allocate name buffer\n");
166 kfree(smibuf);
167 return NULL;
168 }
169
170
171 smibuf->length = GSMI_BUF_SIZE;
172 smibuf->address = (u32)virt_to_phys(smibuf->start);
173
174 return smibuf;
175}
176
177static void gsmi_buf_free(struct gsmi_buf *smibuf)
178{
179 if (smibuf) {
180 if (smibuf->start)
181 kmem_cache_free(gsmi_dev.mem_pool, smibuf->start);
182 kfree(smibuf);
183 }
184}
185
186
187
188
189
190static int gsmi_exec(u8 func, u8 sub)
191{
192 u16 cmd = (sub << 8) | func;
193 u16 result = 0;
194 int rc = 0;
195
196
197
198
199
200
201
202
203
204 if (gsmi_dev.handshake_type == GSMI_HANDSHAKE_CF) {
205
206
207
208
209
210
211
212 asm volatile (
213 "stc\n"
214 "outb %%al, %%dx\n"
215 "1: jc 1b\n"
216 : "=a" (result)
217 : "0" (cmd),
218 "d" (gsmi_dev.smi_cmd),
219 "b" (gsmi_dev.param_buf->address)
220 : "memory", "cc"
221 );
222 } else if (gsmi_dev.handshake_type == GSMI_HANDSHAKE_SPIN) {
223
224
225
226
227 asm volatile (
228 "outb %%al, %%dx\n"
229 "1: loop 1b\n"
230 : "=a" (result)
231 : "0" (cmd),
232 "d" (gsmi_dev.smi_cmd),
233 "b" (gsmi_dev.param_buf->address),
234 "c" (spincount)
235 : "memory", "cc"
236 );
237 } else {
238
239
240
241
242
243 asm volatile (
244 "outb %%al, %%dx\n\t"
245 : "=a" (result)
246 : "0" (cmd),
247 "d" (gsmi_dev.smi_cmd),
248 "b" (gsmi_dev.param_buf->address)
249 : "memory", "cc"
250 );
251 }
252
253
254 switch (result) {
255 case GSMI_SUCCESS:
256 break;
257 case GSMI_VAR_NOT_FOUND:
258
259 rc = 1;
260 break;
261 case GSMI_INVALID_PARAMETER:
262 printk(KERN_ERR "gsmi: exec 0x%04x: Invalid parameter\n", cmd);
263 rc = -EINVAL;
264 break;
265 case GSMI_BUFFER_TOO_SMALL:
266 printk(KERN_ERR "gsmi: exec 0x%04x: Buffer too small\n", cmd);
267 rc = -ENOMEM;
268 break;
269 case GSMI_UNSUPPORTED:
270 case GSMI_UNSUPPORTED2:
271 if (sub != GSMI_CMD_HANDSHAKE_TYPE)
272 printk(KERN_ERR "gsmi: exec 0x%04x: Not supported\n",
273 cmd);
274 rc = -ENOSYS;
275 break;
276 case GSMI_NOT_READY:
277 printk(KERN_ERR "gsmi: exec 0x%04x: Not ready\n", cmd);
278 rc = -EBUSY;
279 break;
280 case GSMI_DEVICE_ERROR:
281 printk(KERN_ERR "gsmi: exec 0x%04x: Device error\n", cmd);
282 rc = -EFAULT;
283 break;
284 case GSMI_NOT_FOUND:
285 printk(KERN_ERR "gsmi: exec 0x%04x: Data not found\n", cmd);
286 rc = -ENOENT;
287 break;
288 case GSMI_LOG_FULL:
289 printk(KERN_ERR "gsmi: exec 0x%04x: Log full\n", cmd);
290 rc = -ENOSPC;
291 break;
292 case GSMI_HANDSHAKE_CF:
293 case GSMI_HANDSHAKE_SPIN:
294 case GSMI_HANDSHAKE_NONE:
295 rc = result;
296 break;
297 default:
298 printk(KERN_ERR "gsmi: exec 0x%04x: Unknown error 0x%04x\n",
299 cmd, result);
300 rc = -ENXIO;
301 }
302
303 return rc;
304}
305
306#ifdef CONFIG_EFI
307
308static struct efivars efivars;
309
310static efi_status_t gsmi_get_variable(efi_char16_t *name,
311 efi_guid_t *vendor, u32 *attr,
312 unsigned long *data_size,
313 void *data)
314{
315 struct gsmi_nvram_var_param param = {
316 .name_ptr = gsmi_dev.name_buf->address,
317 .data_ptr = gsmi_dev.data_buf->address,
318 .data_len = (u32)*data_size,
319 };
320 efi_status_t ret = EFI_SUCCESS;
321 unsigned long flags;
322 size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2);
323 int rc;
324
325 if (name_len >= GSMI_BUF_SIZE / 2)
326 return EFI_BAD_BUFFER_SIZE;
327
328 spin_lock_irqsave(&gsmi_dev.lock, flags);
329
330
331 memcpy(¶m.guid, vendor, sizeof(param.guid));
332
333
334 memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length);
335 memcpy(gsmi_dev.name_buf->start, name, name_len * 2);
336
337
338 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
339
340
341 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
342 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
343
344 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NVRAM_VAR);
345 if (rc < 0) {
346 printk(KERN_ERR "gsmi: Get Variable failed\n");
347 ret = EFI_LOAD_ERROR;
348 } else if (rc == 1) {
349
350 ret = EFI_NOT_FOUND;
351 } else {
352
353 memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param));
354
355
356 *data_size = min_t(unsigned long, *data_size,
357 gsmi_dev.data_buf->length);
358 *data_size = min_t(unsigned long, *data_size, param.data_len);
359
360
361 memcpy(data, gsmi_dev.data_buf->start, *data_size);
362
363
364 *attr = EFI_VARIABLE_NON_VOLATILE |
365 EFI_VARIABLE_BOOTSERVICE_ACCESS |
366 EFI_VARIABLE_RUNTIME_ACCESS;
367 }
368
369 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
370
371 return ret;
372}
373
374static efi_status_t gsmi_get_next_variable(unsigned long *name_size,
375 efi_char16_t *name,
376 efi_guid_t *vendor)
377{
378 struct gsmi_get_next_var_param param = {
379 .name_ptr = gsmi_dev.name_buf->address,
380 .name_len = gsmi_dev.name_buf->length,
381 };
382 efi_status_t ret = EFI_SUCCESS;
383 int rc;
384 unsigned long flags;
385
386
387 if (*name_size != GSMI_BUF_SIZE)
388 return EFI_BAD_BUFFER_SIZE;
389
390
391 if (ucs2_strnlen(name, GSMI_BUF_SIZE / 2) == GSMI_BUF_SIZE / 2)
392 return EFI_INVALID_PARAMETER;
393
394 spin_lock_irqsave(&gsmi_dev.lock, flags);
395
396
397 memcpy(¶m.guid, vendor, sizeof(param.guid));
398
399
400 memcpy(gsmi_dev.name_buf->start, name, *name_size);
401
402
403 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
404 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
405
406 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_GET_NEXT_VAR);
407 if (rc < 0) {
408 printk(KERN_ERR "gsmi: Get Next Variable Name failed\n");
409 ret = EFI_LOAD_ERROR;
410 } else if (rc == 1) {
411
412 ret = EFI_NOT_FOUND;
413 } else {
414
415 memcpy(¶m, gsmi_dev.param_buf->start, sizeof(param));
416
417
418 memcpy(name, gsmi_dev.name_buf->start, GSMI_BUF_SIZE);
419 *name_size = ucs2_strnlen(name, GSMI_BUF_SIZE / 2) * 2;
420
421
422 memcpy(vendor, ¶m.guid, sizeof(param.guid));
423 ret = EFI_SUCCESS;
424 }
425
426 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
427
428 return ret;
429}
430
431static efi_status_t gsmi_set_variable(efi_char16_t *name,
432 efi_guid_t *vendor,
433 u32 attr,
434 unsigned long data_size,
435 void *data)
436{
437 struct gsmi_nvram_var_param param = {
438 .name_ptr = gsmi_dev.name_buf->address,
439 .data_ptr = gsmi_dev.data_buf->address,
440 .data_len = (u32)data_size,
441 .attributes = EFI_VARIABLE_NON_VOLATILE |
442 EFI_VARIABLE_BOOTSERVICE_ACCESS |
443 EFI_VARIABLE_RUNTIME_ACCESS,
444 };
445 size_t name_len = ucs2_strnlen(name, GSMI_BUF_SIZE / 2);
446 efi_status_t ret = EFI_SUCCESS;
447 int rc;
448 unsigned long flags;
449
450 if (name_len >= GSMI_BUF_SIZE / 2)
451 return EFI_BAD_BUFFER_SIZE;
452
453 spin_lock_irqsave(&gsmi_dev.lock, flags);
454
455
456 memcpy(¶m.guid, vendor, sizeof(param.guid));
457
458
459 memset(gsmi_dev.name_buf->start, 0, gsmi_dev.name_buf->length);
460 memcpy(gsmi_dev.name_buf->start, name, name_len * 2);
461
462
463 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
464 memcpy(gsmi_dev.data_buf->start, data, data_size);
465
466
467 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
468 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
469
470 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_NVRAM_VAR);
471 if (rc < 0) {
472 printk(KERN_ERR "gsmi: Set Variable failed\n");
473 ret = EFI_INVALID_PARAMETER;
474 }
475
476 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
477
478 return ret;
479}
480
481static const struct efivar_operations efivar_ops = {
482 .get_variable = gsmi_get_variable,
483 .set_variable = gsmi_set_variable,
484 .get_next_variable = gsmi_get_next_variable,
485};
486
487#endif
488
489static ssize_t eventlog_write(struct file *filp, struct kobject *kobj,
490 struct bin_attribute *bin_attr,
491 char *buf, loff_t pos, size_t count)
492{
493 struct gsmi_set_eventlog_param param = {
494 .data_ptr = gsmi_dev.data_buf->address,
495 };
496 int rc = 0;
497 unsigned long flags;
498
499
500 if (count < sizeof(u32))
501 return -EINVAL;
502 param.type = *(u32 *)buf;
503 buf += sizeof(u32);
504
505
506 if ((count - sizeof(u32)) > gsmi_dev.data_buf->length)
507 return -EINVAL;
508 param.data_len = count - sizeof(u32);
509
510 spin_lock_irqsave(&gsmi_dev.lock, flags);
511
512
513 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
514 memcpy(gsmi_dev.data_buf->start, buf, param.data_len);
515
516
517 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
518 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
519
520 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);
521 if (rc < 0)
522 printk(KERN_ERR "gsmi: Set Event Log failed\n");
523
524 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
525
526 return (rc == 0) ? count : rc;
527
528}
529
530static struct bin_attribute eventlog_bin_attr = {
531 .attr = {.name = "append_to_eventlog", .mode = 0200},
532 .write = eventlog_write,
533};
534
535static ssize_t gsmi_clear_eventlog_store(struct kobject *kobj,
536 struct kobj_attribute *attr,
537 const char *buf, size_t count)
538{
539 int rc;
540 unsigned long flags;
541 unsigned long val;
542 struct {
543 u32 percentage;
544 u32 data_type;
545 } param;
546
547 rc = kstrtoul(buf, 0, &val);
548 if (rc)
549 return rc;
550
551
552
553
554
555 if (val > 100)
556 return -EINVAL;
557
558
559 param.percentage = val;
560 param.data_type = 0;
561
562 spin_lock_irqsave(&gsmi_dev.lock, flags);
563
564
565 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
566 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
567
568 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_EVENT_LOG);
569
570 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
571
572 if (rc)
573 return rc;
574 return count;
575}
576
577static struct kobj_attribute gsmi_clear_eventlog_attr = {
578 .attr = {.name = "clear_eventlog", .mode = 0200},
579 .store = gsmi_clear_eventlog_store,
580};
581
582static ssize_t gsmi_clear_config_store(struct kobject *kobj,
583 struct kobj_attribute *attr,
584 const char *buf, size_t count)
585{
586 int rc;
587 unsigned long flags;
588
589 spin_lock_irqsave(&gsmi_dev.lock, flags);
590
591
592 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
593
594 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_CLEAR_CONFIG);
595
596 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
597
598 if (rc)
599 return rc;
600 return count;
601}
602
603static struct kobj_attribute gsmi_clear_config_attr = {
604 .attr = {.name = "clear_config", .mode = 0200},
605 .store = gsmi_clear_config_store,
606};
607
608static const struct attribute *gsmi_attrs[] = {
609 &gsmi_clear_config_attr.attr,
610 &gsmi_clear_eventlog_attr.attr,
611 NULL,
612};
613
614static int gsmi_shutdown_reason(int reason)
615{
616 struct gsmi_log_entry_type_1 entry = {
617 .type = GSMI_LOG_ENTRY_TYPE_KERNEL,
618 .instance = reason,
619 };
620 struct gsmi_set_eventlog_param param = {
621 .data_len = sizeof(entry),
622 .type = 1,
623 };
624 static int saved_reason;
625 int rc = 0;
626 unsigned long flags;
627
628
629 if (saved_reason & (1 << reason))
630 return 0;
631
632 spin_lock_irqsave(&gsmi_dev.lock, flags);
633
634 saved_reason |= (1 << reason);
635
636
637 memset(gsmi_dev.data_buf->start, 0, gsmi_dev.data_buf->length);
638 memcpy(gsmi_dev.data_buf->start, &entry, sizeof(entry));
639
640
641 param.data_ptr = gsmi_dev.data_buf->address;
642 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
643 memcpy(gsmi_dev.param_buf->start, ¶m, sizeof(param));
644
645 rc = gsmi_exec(GSMI_CALLBACK, GSMI_CMD_SET_EVENT_LOG);
646
647 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
648
649 if (rc < 0)
650 printk(KERN_ERR "gsmi: Log Shutdown Reason failed\n");
651 else
652 printk(KERN_EMERG "gsmi: Log Shutdown Reason 0x%02x\n",
653 reason);
654
655 return rc;
656}
657
658static int gsmi_reboot_callback(struct notifier_block *nb,
659 unsigned long reason, void *arg)
660{
661 gsmi_shutdown_reason(GSMI_SHUTDOWN_CLEAN);
662 return NOTIFY_DONE;
663}
664
665static struct notifier_block gsmi_reboot_notifier = {
666 .notifier_call = gsmi_reboot_callback
667};
668
669static int gsmi_die_callback(struct notifier_block *nb,
670 unsigned long reason, void *arg)
671{
672 if (reason == DIE_OOPS)
673 gsmi_shutdown_reason(GSMI_SHUTDOWN_OOPS);
674 return NOTIFY_DONE;
675}
676
677static struct notifier_block gsmi_die_notifier = {
678 .notifier_call = gsmi_die_callback
679};
680
681static int gsmi_panic_callback(struct notifier_block *nb,
682 unsigned long reason, void *arg)
683{
684 gsmi_shutdown_reason(GSMI_SHUTDOWN_PANIC);
685 return NOTIFY_DONE;
686}
687
688static struct notifier_block gsmi_panic_notifier = {
689 .notifier_call = gsmi_panic_callback,
690};
691
692
693
694
695
696
697
698
699
700
701static u64 __init local_hash_64(u64 val, unsigned bits)
702{
703 u64 hash = val;
704
705
706 u64 n = hash;
707 n <<= 18;
708 hash -= n;
709 n <<= 33;
710 hash -= n;
711 n <<= 3;
712 hash += n;
713 n <<= 3;
714 hash -= n;
715 n <<= 4;
716 hash += n;
717 n <<= 2;
718 hash += n;
719
720
721 return hash >> (64 - bits);
722}
723
724static u32 __init hash_oem_table_id(char s[8])
725{
726 u64 input;
727 memcpy(&input, s, 8);
728 return local_hash_64(input, 32);
729}
730
731static const struct dmi_system_id gsmi_dmi_table[] __initconst = {
732 {
733 .ident = "Google Board",
734 .matches = {
735 DMI_MATCH(DMI_BOARD_VENDOR, "Google, Inc."),
736 },
737 },
738 {
739 .ident = "Coreboot Firmware",
740 .matches = {
741 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
742 },
743 },
744 {}
745};
746MODULE_DEVICE_TABLE(dmi, gsmi_dmi_table);
747
748static __init int gsmi_system_valid(void)
749{
750 u32 hash;
751 u16 cmd, result;
752
753 if (!dmi_check_system(gsmi_dmi_table))
754 return -ENODEV;
755
756
757
758
759
760
761
762
763
764 if (!strncmp(acpi_gbl_FADT.header.oem_table_id, "FACP", 4)) {
765 printk(KERN_INFO "gsmi: Board is too old\n");
766 return -ENODEV;
767 }
768
769
770 hash = hash_oem_table_id(acpi_gbl_FADT.header.oem_table_id);
771 if (hash == QUIRKY_BOARD_HASH) {
772 const char *bios_ver = dmi_get_system_info(DMI_BIOS_VERSION);
773 if (strncmp(bios_ver, "1.0", 3) == 0) {
774 pr_info("gsmi: disabled on this board's BIOS %s\n",
775 bios_ver);
776 return -ENODEV;
777 }
778 }
779
780
781 if (acpi_gbl_FADT.smi_command == 0) {
782 pr_info("gsmi: missing smi_command\n");
783 return -ENODEV;
784 }
785
786
787
788
789
790 cmd = GSMI_CALLBACK | GSMI_CMD_RESERVED << 8;
791 asm volatile (
792 "outb %%al, %%dx\n\t"
793 : "=a" (result)
794 : "0" (cmd),
795 "d" (acpi_gbl_FADT.smi_command)
796 : "memory", "cc"
797 );
798 if (cmd == result) {
799 pr_info("gsmi: no gsmi handler in firmware\n");
800 return -ENODEV;
801 }
802
803
804 return 0;
805}
806
807static struct kobject *gsmi_kobj;
808
809static const struct platform_device_info gsmi_dev_info = {
810 .name = "gsmi",
811 .id = -1,
812
813 .dma_mask = DMA_BIT_MASK(32),
814};
815
816#ifdef CONFIG_PM
817static void gsmi_log_s0ix_info(u8 cmd)
818{
819 unsigned long flags;
820
821
822
823
824
825 if (!s0ix_logging_enable)
826 return;
827
828 spin_lock_irqsave(&gsmi_dev.lock, flags);
829
830 memset(gsmi_dev.param_buf->start, 0, gsmi_dev.param_buf->length);
831
832 gsmi_exec(GSMI_CALLBACK, cmd);
833
834 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
835}
836
837static int gsmi_log_s0ix_suspend(struct device *dev)
838{
839
840
841
842
843 if (!pm_suspend_via_firmware())
844 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_SUSPEND);
845
846
847
848
849
850 return 0;
851}
852
853static int gsmi_log_s0ix_resume(struct device *dev)
854{
855
856
857
858
859 if (!pm_resume_via_firmware())
860 gsmi_log_s0ix_info(GSMI_CMD_LOG_S0IX_RESUME);
861
862
863
864
865
866 return 0;
867}
868
869static const struct dev_pm_ops gsmi_pm_ops = {
870 .suspend_noirq = gsmi_log_s0ix_suspend,
871 .resume_noirq = gsmi_log_s0ix_resume,
872};
873
874static int gsmi_platform_driver_probe(struct platform_device *dev)
875{
876 return 0;
877}
878
879static struct platform_driver gsmi_driver_info = {
880 .driver = {
881 .name = "gsmi",
882 .pm = &gsmi_pm_ops,
883 },
884 .probe = gsmi_platform_driver_probe,
885};
886#endif
887
888static __init int gsmi_init(void)
889{
890 unsigned long flags;
891 int ret;
892
893 ret = gsmi_system_valid();
894 if (ret)
895 return ret;
896
897 gsmi_dev.smi_cmd = acpi_gbl_FADT.smi_command;
898
899#ifdef CONFIG_PM
900 ret = platform_driver_register(&gsmi_driver_info);
901 if (unlikely(ret)) {
902 printk(KERN_ERR "gsmi: unable to register platform driver\n");
903 return ret;
904 }
905#endif
906
907
908 gsmi_dev.pdev = platform_device_register_full(&gsmi_dev_info);
909 if (IS_ERR(gsmi_dev.pdev)) {
910 printk(KERN_ERR "gsmi: unable to register platform device\n");
911 return PTR_ERR(gsmi_dev.pdev);
912 }
913
914
915 spin_lock_init(&gsmi_dev.lock);
916
917 ret = -ENOMEM;
918
919
920
921
922
923
924
925
926
927
928 gsmi_dev.mem_pool = kmem_cache_create("gsmi", GSMI_BUF_SIZE,
929 GSMI_BUF_ALIGN,
930 SLAB_CACHE_DMA32, NULL);
931 if (!gsmi_dev.mem_pool)
932 goto out_err;
933
934
935
936
937
938 gsmi_dev.name_buf = gsmi_buf_alloc();
939 if (!gsmi_dev.name_buf) {
940 printk(KERN_ERR "gsmi: failed to allocate name buffer\n");
941 goto out_err;
942 }
943
944 gsmi_dev.data_buf = gsmi_buf_alloc();
945 if (!gsmi_dev.data_buf) {
946 printk(KERN_ERR "gsmi: failed to allocate data buffer\n");
947 goto out_err;
948 }
949
950 gsmi_dev.param_buf = gsmi_buf_alloc();
951 if (!gsmi_dev.param_buf) {
952 printk(KERN_ERR "gsmi: failed to allocate param buffer\n");
953 goto out_err;
954 }
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984 spin_lock_irqsave(&gsmi_dev.lock, flags);
985 gsmi_dev.handshake_type = GSMI_HANDSHAKE_SPIN;
986 gsmi_dev.handshake_type =
987 gsmi_exec(GSMI_CALLBACK, GSMI_CMD_HANDSHAKE_TYPE);
988 if (gsmi_dev.handshake_type == -ENOSYS)
989 gsmi_dev.handshake_type = GSMI_HANDSHAKE_NONE;
990 spin_unlock_irqrestore(&gsmi_dev.lock, flags);
991
992
993 if (gsmi_dev.handshake_type == -ENXIO) {
994 printk(KERN_INFO "gsmi version " DRIVER_VERSION
995 " failed to load\n");
996 ret = -ENODEV;
997 goto out_err;
998 }
999
1000
1001 ret = -ENOMEM;
1002 gsmi_kobj = kobject_create_and_add("gsmi", firmware_kobj);
1003 if (!gsmi_kobj) {
1004 printk(KERN_INFO "gsmi: Failed to create firmware kobj\n");
1005 goto out_err;
1006 }
1007
1008
1009 ret = sysfs_create_bin_file(gsmi_kobj, &eventlog_bin_attr);
1010 if (ret) {
1011 printk(KERN_INFO "gsmi: Failed to setup eventlog");
1012 goto out_err;
1013 }
1014
1015
1016 ret = sysfs_create_files(gsmi_kobj, gsmi_attrs);
1017 if (ret) {
1018 printk(KERN_INFO "gsmi: Failed to add attrs");
1019 goto out_remove_bin_file;
1020 }
1021
1022#ifdef CONFIG_EFI
1023 ret = efivars_register(&efivars, &efivar_ops, gsmi_kobj);
1024 if (ret) {
1025 printk(KERN_INFO "gsmi: Failed to register efivars\n");
1026 sysfs_remove_files(gsmi_kobj, gsmi_attrs);
1027 goto out_remove_bin_file;
1028 }
1029#endif
1030
1031 register_reboot_notifier(&gsmi_reboot_notifier);
1032 register_die_notifier(&gsmi_die_notifier);
1033 atomic_notifier_chain_register(&panic_notifier_list,
1034 &gsmi_panic_notifier);
1035
1036 printk(KERN_INFO "gsmi version " DRIVER_VERSION " loaded\n");
1037
1038 return 0;
1039
1040out_remove_bin_file:
1041 sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);
1042out_err:
1043 kobject_put(gsmi_kobj);
1044 gsmi_buf_free(gsmi_dev.param_buf);
1045 gsmi_buf_free(gsmi_dev.data_buf);
1046 gsmi_buf_free(gsmi_dev.name_buf);
1047 kmem_cache_destroy(gsmi_dev.mem_pool);
1048 platform_device_unregister(gsmi_dev.pdev);
1049 pr_info("gsmi: failed to load: %d\n", ret);
1050#ifdef CONFIG_PM
1051 platform_driver_unregister(&gsmi_driver_info);
1052#endif
1053 return ret;
1054}
1055
1056static void __exit gsmi_exit(void)
1057{
1058 unregister_reboot_notifier(&gsmi_reboot_notifier);
1059 unregister_die_notifier(&gsmi_die_notifier);
1060 atomic_notifier_chain_unregister(&panic_notifier_list,
1061 &gsmi_panic_notifier);
1062#ifdef CONFIG_EFI
1063 efivars_unregister(&efivars);
1064#endif
1065
1066 sysfs_remove_files(gsmi_kobj, gsmi_attrs);
1067 sysfs_remove_bin_file(gsmi_kobj, &eventlog_bin_attr);
1068 kobject_put(gsmi_kobj);
1069 gsmi_buf_free(gsmi_dev.param_buf);
1070 gsmi_buf_free(gsmi_dev.data_buf);
1071 gsmi_buf_free(gsmi_dev.name_buf);
1072 kmem_cache_destroy(gsmi_dev.mem_pool);
1073 platform_device_unregister(gsmi_dev.pdev);
1074#ifdef CONFIG_PM
1075 platform_driver_unregister(&gsmi_driver_info);
1076#endif
1077}
1078
1079module_init(gsmi_init);
1080module_exit(gsmi_exit);
1081
1082MODULE_AUTHOR("Google, Inc.");
1083MODULE_LICENSE("GPL");
1084