hc
2023-03-21 4b55d97acc464242bcd6a8ae77b8ff37c22dec58
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
/*
 *  pvpanic.c - pvpanic Device Support
 *
 *  Copyright (C) 2013 Fujitsu.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/acpi.h>
 
MODULE_AUTHOR("Hu Tao <hutao@cn.fujitsu.com>");
MODULE_DESCRIPTION("pvpanic device driver");
MODULE_LICENSE("GPL");
 
static int pvpanic_add(struct acpi_device *device);
static int pvpanic_remove(struct acpi_device *device);
 
static const struct acpi_device_id pvpanic_device_ids[] = {
   { "QEMU0001", 0 },
   { "", 0 },
};
MODULE_DEVICE_TABLE(acpi, pvpanic_device_ids);
 
#define PVPANIC_PANICKED    (1 << 0)
 
static u16 port;
 
static struct acpi_driver pvpanic_driver = {
   .name =        "pvpanic",
   .class =    "QEMU",
   .ids =        pvpanic_device_ids,
   .ops =        {
               .add =        pvpanic_add,
               .remove =    pvpanic_remove,
           },
   .owner =    THIS_MODULE,
};
 
static void
pvpanic_send_event(unsigned int event)
{
   outb(event, port);
}
 
static int
pvpanic_panic_notify(struct notifier_block *nb, unsigned long code,
            void *unused)
{
   pvpanic_send_event(PVPANIC_PANICKED);
   return NOTIFY_DONE;
}
 
static struct notifier_block pvpanic_panic_nb = {
   .notifier_call = pvpanic_panic_notify,
   .priority = 1, /* let this called before broken drm_fb_helper */
};
 
 
static acpi_status
pvpanic_walk_resources(struct acpi_resource *res, void *context)
{
   switch (res->type) {
   case ACPI_RESOURCE_TYPE_END_TAG:
       return AE_OK;
 
   case ACPI_RESOURCE_TYPE_IO:
       port = res->data.io.minimum;
       return AE_OK;
 
   default:
       return AE_ERROR;
   }
}
 
static int pvpanic_add(struct acpi_device *device)
{
   int ret;
 
   ret = acpi_bus_get_status(device);
   if (ret < 0)
       return ret;
 
   if (!device->status.enabled || !device->status.functional)
       return -ENODEV;
 
   acpi_walk_resources(device->handle, METHOD_NAME__CRS,
               pvpanic_walk_resources, NULL);
 
   if (!port)
       return -ENODEV;
 
   atomic_notifier_chain_register(&panic_notifier_list,
                      &pvpanic_panic_nb);
 
   return 0;
}
 
static int pvpanic_remove(struct acpi_device *device)
{
 
   atomic_notifier_chain_unregister(&panic_notifier_list,
                    &pvpanic_panic_nb);
   return 0;
}
 
module_acpi_driver(pvpanic_driver);