blob: 4d31748faca3d9f05014a4c662d76e11abc6bd7a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * acpi_osl.c - OS-dependent functions ($Revision: 83 $)
3 *
4 * Copyright (C) 2000 Andrew Henroid
5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04007 * Copyright (c) 2008 Intel Corporation
8 * Author: Matthew Wilcox <willy@linux.intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27 *
28 */
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/slab.h>
33#include <linux/mm.h>
Myron Stoweba242d52012-01-20 19:13:30 -070034#include <linux/highmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/interrupt.h>
37#include <linux/kmod.h>
38#include <linux/delay.h>
39#include <linux/workqueue.h>
40#include <linux/nmi.h>
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +030041#include <linux/acpi.h>
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +010042#include <linux/acpi_io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/efi.h>
Thomas Renningerdf92e692008-02-04 23:31:22 -080044#include <linux/ioport.h>
45#include <linux/list.h>
Matthew Wilcoxf1241c82008-03-14 13:43:13 -040046#include <linux/jiffies.h>
47#include <linux/semaphore.h>
48
49#include <asm/io.h>
50#include <asm/uaccess.h>
51
52#include <acpi/acpi.h>
53#include <acpi/acpi_bus.h>
54#include <acpi/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#define _COMPONENT ACPI_OS_SERVICES
Len Brownf52fd662007-02-12 22:42:12 -050057ACPI_MODULE_NAME("osl");
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#define PREFIX "ACPI: "
Len Brown4be44fc2005-08-05 00:44:28 -040059struct acpi_os_dpc {
60 acpi_osd_exec_callback function;
61 void *context;
David Howells65f27f32006-11-22 14:55:48 +000062 struct work_struct work;
Bjorn Helgaas9ac61852009-08-31 22:32:10 +000063 int wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064};
65
66#ifdef CONFIG_ACPI_CUSTOM_DSDT
67#include CONFIG_ACPI_CUSTOM_DSDT_FILE
68#endif
69
70#ifdef ENABLE_DEBUGGER
71#include <linux/kdb.h>
72
73/* stuff for debugger support */
74int acpi_in_debugger;
75EXPORT_SYMBOL(acpi_in_debugger);
76
77extern char line_buf[80];
Len Brown4be44fc2005-08-05 00:44:28 -040078#endif /*ENABLE_DEBUGGER */
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Tang Liang09f98a82011-12-09 10:05:54 +080080static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
81 u32 pm1b_ctrl);
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083static acpi_osd_handler acpi_irq_handler;
84static void *acpi_irq_context;
85static struct workqueue_struct *kacpid_wq;
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -040086static struct workqueue_struct *kacpi_notify_wq;
Yinghai Lu92d8aff2013-01-21 13:20:47 -080087static struct workqueue_struct *kacpi_hotplug_wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
Myron Stowe620242a2010-10-21 14:23:53 -060089/*
90 * This list of permanent mappings is for memory that may be accessed from
91 * interrupt context, where we can't do the ioremap().
92 */
93struct acpi_ioremap {
94 struct list_head list;
95 void __iomem *virt;
96 acpi_physical_address phys;
97 acpi_size size;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +010098 unsigned long refcount;
Myron Stowe620242a2010-10-21 14:23:53 -060099};
100
101static LIST_HEAD(acpi_ioremaps);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100102static DEFINE_MUTEX(acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600103
Lin Mingb0ed7a92010-08-06 09:35:51 +0800104static void __init acpi_osi_setup_late(void);
Len Brownae00d812007-05-29 18:43:33 -0400105
Len Brownd4b7dc42008-01-23 20:50:56 -0500106/*
Len Browna6e08872008-11-08 01:21:10 -0500107 * The story of _OSI(Linux)
Len Brownd4b7dc42008-01-23 20:50:56 -0500108 *
Len Browna6e08872008-11-08 01:21:10 -0500109 * From pre-history through Linux-2.6.22,
110 * Linux responded TRUE upon a BIOS OSI(Linux) query.
Len Brownd4b7dc42008-01-23 20:50:56 -0500111 *
Len Browna6e08872008-11-08 01:21:10 -0500112 * Unfortunately, reference BIOS writers got wind of this
113 * and put OSI(Linux) in their example code, quickly exposing
114 * this string as ill-conceived and opening the door to
115 * an un-bounded number of BIOS incompatibilities.
Len Brownd4b7dc42008-01-23 20:50:56 -0500116 *
Len Browna6e08872008-11-08 01:21:10 -0500117 * For example, OSI(Linux) was used on resume to re-POST a
118 * video card on one system, because Linux at that time
119 * could not do a speedy restore in its native driver.
120 * But then upon gaining quick native restore capability,
121 * Linux has no way to tell the BIOS to skip the time-consuming
122 * POST -- putting Linux at a permanent performance disadvantage.
123 * On another system, the BIOS writer used OSI(Linux)
124 * to infer native OS support for IPMI! On other systems,
125 * OSI(Linux) simply got in the way of Linux claiming to
126 * be compatible with other operating systems, exposing
127 * BIOS issues such as skipped device initialization.
Len Brownd4b7dc42008-01-23 20:50:56 -0500128 *
Len Browna6e08872008-11-08 01:21:10 -0500129 * So "Linux" turned out to be a really poor chose of
130 * OSI string, and from Linux-2.6.23 onward we respond FALSE.
Len Brownd4b7dc42008-01-23 20:50:56 -0500131 *
132 * BIOS writers should NOT query _OSI(Linux) on future systems.
Len Browna6e08872008-11-08 01:21:10 -0500133 * Linux will complain on the console when it sees it, and return FALSE.
134 * To get Linux to return TRUE for your system will require
135 * a kernel source update to add a DMI entry,
136 * or boot with "acpi_osi=Linux"
Len Brownd4b7dc42008-01-23 20:50:56 -0500137 */
Len Brownd4b7dc42008-01-23 20:50:56 -0500138
Adrian Bunk1d15d842008-01-29 00:10:15 +0200139static struct osi_linux {
Len Brownd4b7dc42008-01-23 20:50:56 -0500140 unsigned int enable:1;
141 unsigned int dmi:1;
142 unsigned int cmdline:1;
Lin Mingd90aa922010-12-09 16:50:52 +0800143} osi_linux = {0, 0, 0};
Len Brownf5076542007-05-30 00:10:38 -0400144
Lin Mingb0ed7a92010-08-06 09:35:51 +0800145static u32 acpi_osi_handler(acpi_string interface, u32 supported)
146{
147 if (!strcmp("Linux", interface)) {
148
Len Brown89976212011-08-02 00:45:48 -0400149 printk_once(KERN_NOTICE FW_BUG PREFIX
Lin Mingb0ed7a92010-08-06 09:35:51 +0800150 "BIOS _OSI(Linux) query %s%s\n",
151 osi_linux.enable ? "honored" : "ignored",
152 osi_linux.cmdline ? " via cmdline" :
153 osi_linux.dmi ? " via DMI" : "");
154 }
155
156 return supported;
157}
158
Myron Stowebc9ffce2011-11-07 16:23:27 -0700159static void __init acpi_request_region (struct acpi_generic_address *gas,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700160 unsigned int length, char *desc)
161{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700162 u64 addr;
163
164 /* Handle possible alignment issues */
165 memcpy(&addr, &gas->address, sizeof(addr));
166 if (!addr || !length)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700167 return;
168
Andi Kleencfa806f2010-07-20 15:18:36 -0700169 /* Resources are never freed */
Myron Stowebc9ffce2011-11-07 16:23:27 -0700170 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
171 request_region(addr, length, desc);
172 else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
173 request_mem_region(addr, length, desc);
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700174}
175
176static int __init acpi_reserve_resources(void)
177{
Len Browneee3c852007-02-03 01:38:16 -0500178 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700179 "ACPI PM1a_EVT_BLK");
180
Len Browneee3c852007-02-03 01:38:16 -0500181 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700182 "ACPI PM1b_EVT_BLK");
183
Len Browneee3c852007-02-03 01:38:16 -0500184 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700185 "ACPI PM1a_CNT_BLK");
186
Len Browneee3c852007-02-03 01:38:16 -0500187 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700188 "ACPI PM1b_CNT_BLK");
189
Len Browneee3c852007-02-03 01:38:16 -0500190 if (acpi_gbl_FADT.pm_timer_length == 4)
191 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700192
Len Browneee3c852007-02-03 01:38:16 -0500193 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700194 "ACPI PM2_CNT_BLK");
195
196 /* Length of GPE blocks must be a non-negative multiple of 2 */
197
Len Browneee3c852007-02-03 01:38:16 -0500198 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
199 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
200 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700201
Len Browneee3c852007-02-03 01:38:16 -0500202 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
203 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
204 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700205
206 return 0;
207}
208device_initcall(acpi_reserve_resources);
209
Len Brown4be44fc2005-08-05 00:44:28 -0400210void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
212 va_list args;
213 va_start(args, fmt);
214 acpi_os_vprintf(fmt, args);
215 va_end(args);
216}
Len Brown4be44fc2005-08-05 00:44:28 -0400217
Len Brown4be44fc2005-08-05 00:44:28 -0400218void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219{
220 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 vsprintf(buffer, fmt, args);
223
224#ifdef ENABLE_DEBUGGER
225 if (acpi_in_debugger) {
226 kdb_printf("%s", buffer);
227 } else {
Frank Seidel4d939152009-02-04 17:03:07 +0100228 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 }
230#else
Frank Seidel4d939152009-02-04 17:03:07 +0100231 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232#endif
233}
234
Takao Indoh4996c022011-07-14 18:05:21 -0400235#ifdef CONFIG_KEXEC
236static unsigned long acpi_rsdp;
237static int __init setup_acpi_rsdp(char *arg)
238{
239 acpi_rsdp = simple_strtoul(arg, NULL, 16);
240 return 0;
241}
242early_param("acpi_rsdp", setup_acpi_rsdp);
243#endif
244
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300245acpi_physical_address __init acpi_os_get_root_pointer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246{
Takao Indoh4996c022011-07-14 18:05:21 -0400247#ifdef CONFIG_KEXEC
248 if (acpi_rsdp)
249 return acpi_rsdp;
250#endif
251
Matt Fleming83e68182012-11-14 09:42:35 +0000252 if (efi_enabled(EFI_CONFIG_TABLES)) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800253 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300254 return efi.acpi20;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800255 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300256 return efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400258 printk(KERN_ERR PREFIX
259 "System description tables not found\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300260 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 }
Len Brown239665a2007-11-23 20:08:02 -0500262 } else {
263 acpi_physical_address pa = 0;
264
265 acpi_find_root_pointer(&pa);
266 return pa;
267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600270/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe4a3cba52010-10-21 14:24:14 -0600271static struct acpi_ioremap *
272acpi_map_lookup(acpi_physical_address phys, acpi_size size)
Myron Stowe620242a2010-10-21 14:23:53 -0600273{
274 struct acpi_ioremap *map;
275
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600276 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe620242a2010-10-21 14:23:53 -0600277 if (map->phys <= phys &&
278 phys + size <= map->phys + map->size)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600279 return map;
280
281 return NULL;
282}
283
284/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
285static void __iomem *
286acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
287{
288 struct acpi_ioremap *map;
289
290 map = acpi_map_lookup(phys, size);
291 if (map)
292 return map->virt + (phys - map->phys);
Myron Stowe620242a2010-10-21 14:23:53 -0600293
294 return NULL;
295}
296
Rafael J. Wysocki13606a22011-02-08 23:38:25 +0100297void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
298{
299 struct acpi_ioremap *map;
300 void __iomem *virt = NULL;
301
302 mutex_lock(&acpi_ioremap_lock);
303 map = acpi_map_lookup(phys, size);
304 if (map) {
305 virt = map->virt + (phys - map->phys);
306 map->refcount++;
307 }
308 mutex_unlock(&acpi_ioremap_lock);
309 return virt;
310}
311EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
312
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600313/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe620242a2010-10-21 14:23:53 -0600314static struct acpi_ioremap *
315acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
316{
317 struct acpi_ioremap *map;
318
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600319 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600320 if (map->virt <= virt &&
321 virt + size <= map->virt + map->size)
Myron Stowe620242a2010-10-21 14:23:53 -0600322 return map;
323
324 return NULL;
325}
326
Myron Stoweba242d52012-01-20 19:13:30 -0700327#ifndef CONFIG_IA64
328#define should_use_kmap(pfn) page_is_ram(pfn)
329#else
330/* ioremap will take care of cache attributes */
331#define should_use_kmap(pfn) 0
332#endif
333
334static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
335{
336 unsigned long pfn;
337
338 pfn = pg_off >> PAGE_SHIFT;
339 if (should_use_kmap(pfn)) {
340 if (pg_sz > PAGE_SIZE)
341 return NULL;
342 return (void __iomem __force *)kmap(pfn_to_page(pfn));
343 } else
344 return acpi_os_ioremap(pg_off, pg_sz);
345}
346
347static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
348{
349 unsigned long pfn;
350
351 pfn = pg_off >> PAGE_SHIFT;
Jan Beuliche2526752012-02-24 11:41:53 +0000352 if (should_use_kmap(pfn))
Myron Stoweba242d52012-01-20 19:13:30 -0700353 kunmap(pfn_to_page(pfn));
354 else
355 iounmap(vaddr);
356}
357
Jan Beulich2fdf0742007-12-13 08:33:59 +0000358void __iomem *__init_refok
359acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100361 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600362 void __iomem *virt;
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100363 acpi_physical_address pg_off;
364 acpi_size pg_sz;
Myron Stowe620242a2010-10-21 14:23:53 -0600365
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800366 if (phys > ULONG_MAX) {
367 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
Randy Dunlap70c08462007-02-13 16:11:36 -0800368 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 }
Myron Stowe620242a2010-10-21 14:23:53 -0600370
371 if (!acpi_gbl_permanent_mmap)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300372 return __acpi_map_table((unsigned long)phys, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600373
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100374 mutex_lock(&acpi_ioremap_lock);
375 /* Check if there's a suitable mapping already. */
376 map = acpi_map_lookup(phys, size);
377 if (map) {
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100378 map->refcount++;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100379 goto out;
380 }
381
Myron Stowe620242a2010-10-21 14:23:53 -0600382 map = kzalloc(sizeof(*map), GFP_KERNEL);
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100383 if (!map) {
384 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600385 return NULL;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100386 }
Myron Stowe620242a2010-10-21 14:23:53 -0600387
Myron Stowe4a3cba52010-10-21 14:24:14 -0600388 pg_off = round_down(phys, PAGE_SIZE);
389 pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
Myron Stoweba242d52012-01-20 19:13:30 -0700390 virt = acpi_map(pg_off, pg_sz);
Myron Stowe620242a2010-10-21 14:23:53 -0600391 if (!virt) {
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100392 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600393 kfree(map);
394 return NULL;
395 }
396
397 INIT_LIST_HEAD(&map->list);
398 map->virt = virt;
Myron Stowe4a3cba52010-10-21 14:24:14 -0600399 map->phys = pg_off;
400 map->size = pg_sz;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100401 map->refcount = 1;
Myron Stowe620242a2010-10-21 14:23:53 -0600402
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600403 list_add_tail_rcu(&map->list, &acpi_ioremaps);
Myron Stowe620242a2010-10-21 14:23:53 -0600404
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100405 out:
406 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600407 return map->virt + (phys - map->phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800409EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100411static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600412{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100413 if (!--map->refcount)
414 list_del_rcu(&map->list);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600415}
Myron Stowe4a3cba52010-10-21 14:24:14 -0600416
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100417static void acpi_os_map_cleanup(struct acpi_ioremap *map)
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100418{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100419 if (!map->refcount) {
420 synchronize_rcu();
Myron Stoweba242d52012-01-20 19:13:30 -0700421 acpi_unmap(map->phys, map->virt);
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100422 kfree(map);
423 }
Myron Stowe4a3cba52010-10-21 14:24:14 -0600424}
425
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800426void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427{
Myron Stowe620242a2010-10-21 14:23:53 -0600428 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600429
430 if (!acpi_gbl_permanent_mmap) {
Yinghai Lu7d972772009-02-07 15:39:41 -0800431 __acpi_unmap_table(virt, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600432 return;
433 }
434
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100435 mutex_lock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600436 map = acpi_map_lookup_virt(virt, size);
437 if (!map) {
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100438 mutex_unlock(&acpi_ioremap_lock);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100439 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
Myron Stowe620242a2010-10-21 14:23:53 -0600440 return;
441 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100442 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100443 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600444
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100445 acpi_os_map_cleanup(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800447EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800449void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Yinghai Lu7d972772009-02-07 15:39:41 -0800450{
451 if (!acpi_gbl_permanent_mmap)
452 __acpi_unmap_table(virt, size);
453}
454
Myron Stowe6f68c912011-11-07 16:23:34 -0700455int acpi_os_map_generic_address(struct acpi_generic_address *gas)
Myron Stowe29718522010-10-21 14:23:59 -0600456{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700457 u64 addr;
Myron Stowe29718522010-10-21 14:23:59 -0600458 void __iomem *virt;
459
Myron Stowebc9ffce2011-11-07 16:23:27 -0700460 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
Myron Stowe29718522010-10-21 14:23:59 -0600461 return 0;
462
Myron Stowebc9ffce2011-11-07 16:23:27 -0700463 /* Handle possible alignment issues */
464 memcpy(&addr, &gas->address, sizeof(addr));
465 if (!addr || !gas->bit_width)
Myron Stowe29718522010-10-21 14:23:59 -0600466 return -EINVAL;
467
Myron Stowebc9ffce2011-11-07 16:23:27 -0700468 virt = acpi_os_map_memory(addr, gas->bit_width / 8);
Myron Stowe29718522010-10-21 14:23:59 -0600469 if (!virt)
470 return -EIO;
471
472 return 0;
473}
Myron Stowe6f68c912011-11-07 16:23:34 -0700474EXPORT_SYMBOL(acpi_os_map_generic_address);
Myron Stowe29718522010-10-21 14:23:59 -0600475
Myron Stowe6f68c912011-11-07 16:23:34 -0700476void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
Myron Stowe29718522010-10-21 14:23:59 -0600477{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700478 u64 addr;
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100479 struct acpi_ioremap *map;
Myron Stowe29718522010-10-21 14:23:59 -0600480
Myron Stowebc9ffce2011-11-07 16:23:27 -0700481 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
Myron Stowe29718522010-10-21 14:23:59 -0600482 return;
483
Myron Stowebc9ffce2011-11-07 16:23:27 -0700484 /* Handle possible alignment issues */
485 memcpy(&addr, &gas->address, sizeof(addr));
486 if (!addr || !gas->bit_width)
Myron Stowe29718522010-10-21 14:23:59 -0600487 return;
488
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100489 mutex_lock(&acpi_ioremap_lock);
Myron Stowebc9ffce2011-11-07 16:23:27 -0700490 map = acpi_map_lookup(addr, gas->bit_width / 8);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100491 if (!map) {
492 mutex_unlock(&acpi_ioremap_lock);
493 return;
494 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100495 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100496 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe29718522010-10-21 14:23:59 -0600497
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100498 acpi_os_map_cleanup(map);
Myron Stowe29718522010-10-21 14:23:59 -0600499}
Myron Stowe6f68c912011-11-07 16:23:34 -0700500EXPORT_SYMBOL(acpi_os_unmap_generic_address);
Myron Stowe29718522010-10-21 14:23:59 -0600501
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502#ifdef ACPI_FUTURE_USAGE
503acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400504acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505{
Len Brown4be44fc2005-08-05 00:44:28 -0400506 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 return AE_BAD_PARAMETER;
508
509 *phys = virt_to_phys(virt);
510
511 return AE_OK;
512}
513#endif
514
515#define ACPI_MAX_OVERRIDE_LEN 100
516
517static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
518
519acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400520acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
521 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522{
523 if (!init_val || !new_val)
524 return AE_BAD_PARAMETER;
525
526 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400527 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400529 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 *new_val = acpi_os_name;
531 }
532
533 return AE_OK;
534}
535
Thomas Renninger53aac442012-10-01 00:23:54 +0200536#ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
537#include <linux/earlycpio.h>
538#include <linux/memblock.h>
539
540static u64 acpi_tables_addr;
541static int all_tables_size;
542
543/* Copied from acpica/tbutils.c:acpi_tb_checksum() */
544u8 __init acpi_table_checksum(u8 *buffer, u32 length)
545{
546 u8 sum = 0;
547 u8 *end = buffer + length;
548
549 while (buffer < end)
550 sum = (u8) (sum + *(buffer++));
551 return sum;
552}
553
554/* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */
555static const char * const table_sigs[] = {
556 ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
557 ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
558 ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
559 ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
560 ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
561 ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
562 ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
563 ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
564 ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
565
566/* Non-fatal errors: Affected tables/files are ignored */
567#define INVALID_TABLE(x, path, name) \
568 { pr_err("ACPI OVERRIDE: " x " [%s%s]\n", path, name); continue; }
569
570#define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
571
572/* Must not increase 10 or needs code modification below */
573#define ACPI_OVERRIDE_TABLES 10
574
575void __init acpi_initrd_override(void *data, size_t size)
576{
577 int sig, no, table_nr = 0, total_offset = 0;
578 long offset = 0;
579 struct acpi_table_header *table;
580 char cpio_path[32] = "kernel/firmware/acpi/";
581 struct cpio_data file;
582 struct cpio_data early_initrd_files[ACPI_OVERRIDE_TABLES];
583 char *p;
584
585 if (data == NULL || size == 0)
586 return;
587
588 for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) {
589 file = find_cpio_data(cpio_path, data, size, &offset);
590 if (!file.data)
591 break;
592
593 data += offset;
594 size -= offset;
595
596 if (file.size < sizeof(struct acpi_table_header))
597 INVALID_TABLE("Table smaller than ACPI header",
598 cpio_path, file.name);
599
600 table = file.data;
601
602 for (sig = 0; table_sigs[sig]; sig++)
603 if (!memcmp(table->signature, table_sigs[sig], 4))
604 break;
605
606 if (!table_sigs[sig])
607 INVALID_TABLE("Unknown signature",
608 cpio_path, file.name);
609 if (file.size != table->length)
610 INVALID_TABLE("File length does not match table length",
611 cpio_path, file.name);
612 if (acpi_table_checksum(file.data, table->length))
613 INVALID_TABLE("Bad table checksum",
614 cpio_path, file.name);
615
616 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
617 table->signature, cpio_path, file.name, table->length);
618
619 all_tables_size += table->length;
620 early_initrd_files[table_nr].data = file.data;
621 early_initrd_files[table_nr].size = file.size;
622 table_nr++;
623 }
624 if (table_nr == 0)
625 return;
626
627 acpi_tables_addr =
628 memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
629 all_tables_size, PAGE_SIZE);
630 if (!acpi_tables_addr) {
631 WARN_ON(1);
632 return;
633 }
634 /*
635 * Only calling e820_add_reserve does not work and the
636 * tables are invalid (memory got used) later.
637 * memblock_reserve works as expected and the tables won't get modified.
638 * But it's not enough on X86 because ioremap will
639 * complain later (used by acpi_os_map_memory) that the pages
640 * that should get mapped are not marked "reserved".
641 * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area)
642 * works fine.
643 */
644 memblock_reserve(acpi_tables_addr, acpi_tables_addr + all_tables_size);
645 arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
646
647 p = early_ioremap(acpi_tables_addr, all_tables_size);
648
649 for (no = 0; no < table_nr; no++) {
650 memcpy(p + total_offset, early_initrd_files[no].data,
651 early_initrd_files[no].size);
652 total_offset += early_initrd_files[no].size;
653 }
654 early_iounmap(p, all_tables_size);
655}
656#endif /* CONFIG_ACPI_INITRD_TABLE_OVERRIDE */
657
Thomas Renninger325a8d362012-10-01 00:23:56 +0200658static void acpi_table_taint(struct acpi_table_header *table)
659{
660 pr_warn(PREFIX
661 "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
662 table->signature, table->oem_table_id);
Rusty Russell373d4d02013-01-21 17:17:39 +1030663 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
Thomas Renninger325a8d362012-10-01 00:23:56 +0200664}
665
666
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400668acpi_os_table_override(struct acpi_table_header * existing_table,
669 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 if (!existing_table || !new_table)
672 return AE_BAD_PARAMETER;
673
Markus Gaugusch71fc47a2008-02-05 00:04:06 +0100674 *new_table = NULL;
675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676#ifdef CONFIG_ACPI_CUSTOM_DSDT
677 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400678 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679#endif
Thomas Renninger325a8d362012-10-01 00:23:56 +0200680 if (*new_table != NULL)
681 acpi_table_taint(existing_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 return AE_OK;
683}
684
Bob Mooref7b004a2012-02-14 18:31:56 +0800685acpi_status
686acpi_os_physical_table_override(struct acpi_table_header *existing_table,
Thomas Renningerb2a35002012-10-01 00:23:55 +0200687 acpi_physical_address *address,
688 u32 *table_length)
Bob Mooref7b004a2012-02-14 18:31:56 +0800689{
Thomas Renningerb2a35002012-10-01 00:23:55 +0200690#ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
691 *table_length = 0;
692 *address = 0;
693 return AE_OK;
694#else
695 int table_offset = 0;
696 struct acpi_table_header *table;
Bob Mooref7b004a2012-02-14 18:31:56 +0800697
Thomas Renningerb2a35002012-10-01 00:23:55 +0200698 *table_length = 0;
699 *address = 0;
700
701 if (!acpi_tables_addr)
702 return AE_OK;
703
704 do {
705 if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {
706 WARN_ON(1);
707 return AE_OK;
708 }
709
710 table = acpi_os_map_memory(acpi_tables_addr + table_offset,
711 ACPI_HEADER_SIZE);
712
713 if (table_offset + table->length > all_tables_size) {
714 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
715 WARN_ON(1);
716 return AE_OK;
717 }
718
719 table_offset += table->length;
720
721 if (memcmp(existing_table->signature, table->signature, 4)) {
722 acpi_os_unmap_memory(table,
723 ACPI_HEADER_SIZE);
724 continue;
725 }
726
727 /* Only override tables with matching oem id */
728 if (memcmp(table->oem_table_id, existing_table->oem_table_id,
729 ACPI_OEM_TABLE_ID_SIZE)) {
730 acpi_os_unmap_memory(table,
731 ACPI_HEADER_SIZE);
732 continue;
733 }
734
735 table_offset -= table->length;
736 *table_length = table->length;
737 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
738 *address = acpi_tables_addr + table_offset;
739 break;
740 } while (table_offset + ACPI_HEADER_SIZE < all_tables_size);
741
Thomas Renninger325a8d362012-10-01 00:23:56 +0200742 if (*address != 0)
743 acpi_table_taint(existing_table);
Thomas Renningerb2a35002012-10-01 00:23:55 +0200744 return AE_OK;
745#endif
746}
Bob Mooref7b004a2012-02-14 18:31:56 +0800747
David Howells7d12e782006-10-05 14:55:46 +0100748static irqreturn_t acpi_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
Len Brown5229e872008-02-06 01:26:55 -0500750 u32 handled;
751
752 handled = (*acpi_irq_handler) (acpi_irq_context);
753
754 if (handled) {
755 acpi_irq_handled++;
756 return IRQ_HANDLED;
Len Brown88bea182009-04-21 00:35:47 -0400757 } else {
758 acpi_irq_not_handled++;
Len Brown5229e872008-02-06 01:26:55 -0500759 return IRQ_NONE;
Len Brown88bea182009-04-21 00:35:47 -0400760 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761}
762
763acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400764acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
765 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766{
767 unsigned int irq;
768
Len Brown5229e872008-02-06 01:26:55 -0500769 acpi_irq_stats_init();
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 /*
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100772 * ACPI interrupts different from the SCI in our copy of the FADT are
773 * not supported.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 */
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100775 if (gsi != acpi_gbl_FADT.sci_interrupt)
776 return AE_BAD_PARAMETER;
777
778 if (acpi_irq_handler)
779 return AE_ALREADY_ACQUIRED;
780
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
782 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
783 gsi);
784 return AE_OK;
785 }
786
787 acpi_irq_handler = handler;
788 acpi_irq_context = context;
Zhang Rui89a22da2013-02-04 07:10:10 +0000789 if (request_irq(irq, acpi_irq, IRQF_SHARED | IRQF_NO_SUSPEND, "acpi", acpi_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100791 acpi_irq_handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 return AE_NOT_ACQUIRED;
793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 return AE_OK;
796}
797
Len Brown4be44fc2005-08-05 00:44:28 -0400798acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799{
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100800 if (irq != acpi_gbl_FADT.sci_interrupt)
801 return AE_BAD_PARAMETER;
802
803 free_irq(irq, acpi_irq);
804 acpi_irq_handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
806 return AE_OK;
807}
808
809/*
810 * Running in interpreter thread context, safe to sleep
811 */
812
Lin Ming439913f2010-01-28 10:53:19 +0800813void acpi_os_sleep(u64 ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800815 schedule_timeout_interruptible(msecs_to_jiffies(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816}
Len Brown4be44fc2005-08-05 00:44:28 -0400817
Len Brown4be44fc2005-08-05 00:44:28 -0400818void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 while (us) {
821 u32 delay = 1000;
822
823 if (delay > us)
824 delay = us;
825 udelay(delay);
826 touch_nmi_watchdog();
827 us -= delay;
828 }
829}
Len Brown4be44fc2005-08-05 00:44:28 -0400830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831/*
832 * Support ACPI 3.0 AML Timer operand
833 * Returns 64-bit free-running, monotonically increasing timer
834 * with 100ns granularity
835 */
Len Brown4be44fc2005-08-05 00:44:28 -0400836u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
838 static u64 t;
839
840#ifdef CONFIG_HPET
841 /* TBD: use HPET if available */
842#endif
843
844#ifdef CONFIG_X86_PM_TIMER
845 /* TBD: default to PM timer if HPET was not available */
846#endif
847 if (!t)
848 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
849
850 return ++t;
851}
852
Len Brown4be44fc2005-08-05 00:44:28 -0400853acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854{
855 u32 dummy;
856
857 if (!value)
858 value = &dummy;
859
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800860 *value = 0;
861 if (width <= 8) {
Len Brown4be44fc2005-08-05 00:44:28 -0400862 *(u8 *) value = inb(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800863 } else if (width <= 16) {
Len Brown4be44fc2005-08-05 00:44:28 -0400864 *(u16 *) value = inw(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800865 } else if (width <= 32) {
Len Brown4be44fc2005-08-05 00:44:28 -0400866 *(u32 *) value = inl(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800867 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 BUG();
869 }
870
871 return AE_OK;
872}
Len Brown4be44fc2005-08-05 00:44:28 -0400873
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874EXPORT_SYMBOL(acpi_os_read_port);
875
Len Brown4be44fc2005-08-05 00:44:28 -0400876acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800878 if (width <= 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 outb(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800880 } else if (width <= 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 outw(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800882 } else if (width <= 32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 outl(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800884 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 BUG();
886 }
887
888 return AE_OK;
889}
Len Brown4be44fc2005-08-05 00:44:28 -0400890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891EXPORT_SYMBOL(acpi_os_write_port);
892
Myron Stowee615bf52012-01-20 19:13:24 -0700893#ifdef readq
894static inline u64 read64(const volatile void __iomem *addr)
895{
896 return readq(addr);
897}
898#else
899static inline u64 read64(const volatile void __iomem *addr)
900{
901 u64 l, h;
902 l = readl(addr);
903 h = readl(addr+4);
904 return l | (h << 32);
905}
906#endif
907
908acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800909acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700910{
911 void __iomem *virt_addr;
912 unsigned int size = width / 8;
913 bool unmap = false;
914 u64 dummy;
915
916 rcu_read_lock();
917 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
918 if (!virt_addr) {
919 rcu_read_unlock();
920 virt_addr = acpi_os_ioremap(phys_addr, size);
921 if (!virt_addr)
922 return AE_BAD_ADDRESS;
923 unmap = true;
924 }
925
926 if (!value)
927 value = &dummy;
928
929 switch (width) {
930 case 8:
931 *(u8 *) value = readb(virt_addr);
932 break;
933 case 16:
934 *(u16 *) value = readw(virt_addr);
935 break;
936 case 32:
937 *(u32 *) value = readl(virt_addr);
938 break;
939 case 64:
940 *(u64 *) value = read64(virt_addr);
941 break;
942 default:
943 BUG();
944 }
945
946 if (unmap)
947 iounmap(virt_addr);
948 else
949 rcu_read_unlock();
950
951 return AE_OK;
952}
953
Myron Stowee615bf52012-01-20 19:13:24 -0700954#ifdef writeq
955static inline void write64(u64 val, volatile void __iomem *addr)
956{
957 writeq(val, addr);
958}
959#else
960static inline void write64(u64 val, volatile void __iomem *addr)
961{
962 writel(val, addr);
963 writel(val>>32, addr+4);
964}
965#endif
966
967acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800968acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700969{
970 void __iomem *virt_addr;
971 unsigned int size = width / 8;
972 bool unmap = false;
973
974 rcu_read_lock();
975 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
976 if (!virt_addr) {
977 rcu_read_unlock();
978 virt_addr = acpi_os_ioremap(phys_addr, size);
979 if (!virt_addr)
980 return AE_BAD_ADDRESS;
981 unmap = true;
982 }
983
984 switch (width) {
985 case 8:
986 writeb(value, virt_addr);
987 break;
988 case 16:
989 writew(value, virt_addr);
990 break;
991 case 32:
992 writel(value, virt_addr);
993 break;
994 case 64:
995 write64(value, virt_addr);
996 break;
997 default:
998 BUG();
999 }
1000
1001 if (unmap)
1002 iounmap(virt_addr);
1003 else
1004 rcu_read_unlock();
1005
1006 return AE_OK;
1007}
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001010acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Bob Moorec5f02312010-08-06 08:57:53 +08001011 u64 *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012{
1013 int result, size;
Bob Moorec5f02312010-08-06 08:57:53 +08001014 u32 value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 if (!value)
1017 return AE_BAD_PARAMETER;
1018
1019 switch (width) {
1020 case 8:
1021 size = 1;
1022 break;
1023 case 16:
1024 size = 2;
1025 break;
1026 case 32:
1027 size = 4;
1028 break;
1029 default:
1030 return AE_ERROR;
1031 }
1032
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -05001033 result = raw_pci_read(pci_id->segment, pci_id->bus,
1034 PCI_DEVFN(pci_id->device, pci_id->function),
Bob Moorec5f02312010-08-06 08:57:53 +08001035 reg, size, &value32);
1036 *value = value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037
1038 return (result ? AE_ERROR : AE_OK);
1039}
Len Brown4be44fc2005-08-05 00:44:28 -04001040
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001042acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Lin Ming439913f2010-01-28 10:53:19 +08001043 u64 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044{
1045 int result, size;
1046
1047 switch (width) {
1048 case 8:
1049 size = 1;
1050 break;
1051 case 16:
1052 size = 2;
1053 break;
1054 case 32:
1055 size = 4;
1056 break;
1057 default:
1058 return AE_ERROR;
1059 }
1060
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -05001061 result = raw_pci_write(pci_id->segment, pci_id->bus,
1062 PCI_DEVFN(pci_id->device, pci_id->function),
1063 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
1065 return (result ? AE_ERROR : AE_OK);
1066}
1067
David Howells65f27f32006-11-22 14:55:48 +00001068static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069{
David Howells65f27f32006-11-22 14:55:48 +00001070 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -04001071
Bjorn Helgaas9ac61852009-08-31 22:32:10 +00001072 if (dpc->wait)
Lin Mingbd6f10a2012-05-22 16:43:49 +08001073 acpi_os_wait_events_complete();
Zhang Rui19cd8472008-08-28 10:05:06 +08001074
1075 dpc->function(dpc->context);
1076 kfree(dpc);
Zhang Rui19cd8472008-08-28 10:05:06 +08001077}
1078
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -04001079/*******************************************************************************
1080 *
1081 * FUNCTION: acpi_os_execute
1082 *
1083 * PARAMETERS: Type - Type of the callback
1084 * Function - Function to be executed
1085 * Context - Function parameters
1086 *
1087 * RETURN: Status
1088 *
1089 * DESCRIPTION: Depending on type, either queues function for deferred execution or
1090 * immediately executes function on a separate thread.
1091 *
1092 ******************************************************************************/
1093
Zhang Rui19cd8472008-08-28 10:05:06 +08001094static acpi_status __acpi_os_execute(acpi_execute_type type,
1095 acpi_osd_exec_callback function, void *context, int hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096{
Len Brown4be44fc2005-08-05 00:44:28 -04001097 acpi_status status = AE_OK;
1098 struct acpi_os_dpc *dpc;
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +03001099 struct workqueue_struct *queue;
Zhang Rui19cd8472008-08-28 10:05:06 +08001100 int ret;
Len Brown72945b22006-07-12 22:46:42 -04001101 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1102 "Scheduling function [%p(%p)] for deferred execution.\n",
1103 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 /*
1106 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +00001107 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 * way that allows us to also free its memory inside the callee.
1109 * Because we may want to schedule several tasks with different
1110 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +00001111 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 */
Len Brown72945b22006-07-12 22:46:42 -04001113
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001114 dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 if (!dpc)
Lin Ming889c78b2008-12-31 09:23:57 +08001116 return AE_NO_MEMORY;
Linus Torvaldsb976fe12006-11-17 19:31:09 -08001117
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 dpc->function = function;
1119 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -08001120
Zhang Ruic02256b2009-06-23 10:20:29 +08001121 /*
1122 * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
1123 * because the hotplug code may call driver .remove() functions,
1124 * which invoke flush_scheduled_work/acpi_os_wait_events_complete
1125 * to flush these workqueues.
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001126 *
1127 * To prevent lockdep from complaining unnecessarily, make sure that
1128 * there is a different static lockdep key for each workqueue by using
1129 * INIT_WORK() for each of them separately.
Zhang Ruic02256b2009-06-23 10:20:29 +08001130 */
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001131 if (hp) {
1132 queue = kacpi_hotplug_wq;
1133 dpc->wait = 1;
Zhang Ruibc736752010-03-22 15:48:54 +08001134 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001135 } else if (type == OSL_NOTIFY_HANDLER) {
1136 queue = kacpi_notify_wq;
Zhang Ruibc736752010-03-22 15:48:54 +08001137 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001138 } else {
1139 queue = kacpid_wq;
Zhang Ruibc736752010-03-22 15:48:54 +08001140 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001141 }
Zhang Ruibc736752010-03-22 15:48:54 +08001142
Tejun Heo8fec62b2010-06-29 10:07:09 +02001143 /*
1144 * On some machines, a software-initiated SMI causes corruption unless
1145 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
1146 * typically it's done in GPE-related methods that are run via
1147 * workqueues, so we can avoid the known corruption cases by always
1148 * queueing on CPU 0.
1149 */
1150 ret = queue_work_on(0, queue, &dpc->work);
Zhang Rui19cd8472008-08-28 10:05:06 +08001151
1152 if (!ret) {
Lin Ming55ac9a02008-09-28 14:51:56 +08001153 printk(KERN_ERR PREFIX
1154 "Call to queue_work() failed.\n");
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +03001155 status = AE_ERROR;
1156 kfree(dpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
Lin Ming889c78b2008-12-31 09:23:57 +08001158 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159}
Len Brown4be44fc2005-08-05 00:44:28 -04001160
Zhang Rui19cd8472008-08-28 10:05:06 +08001161acpi_status acpi_os_execute(acpi_execute_type type,
1162 acpi_osd_exec_callback function, void *context)
1163{
1164 return __acpi_os_execute(type, function, context, 0);
1165}
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -04001166EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
Zhang Rui19cd8472008-08-28 10:05:06 +08001168acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
1169 void *context)
1170{
1171 return __acpi_os_execute(0, function, context, 1);
1172}
Toshi Kani61622ac2012-11-01 14:42:12 +00001173EXPORT_SYMBOL(acpi_os_hotplug_execute);
Zhang Rui19cd8472008-08-28 10:05:06 +08001174
Lin Mingbd6f10a2012-05-22 16:43:49 +08001175void acpi_os_wait_events_complete(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176{
1177 flush_workqueue(kacpid_wq);
Zhang Rui2f67a062008-04-29 02:34:42 -04001178 flush_workqueue(kacpi_notify_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179}
Len Brown4be44fc2005-08-05 00:44:28 -04001180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181EXPORT_SYMBOL(acpi_os_wait_events_complete);
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001184acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185{
Len Brown4be44fc2005-08-05 00:44:28 -04001186 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 sem = acpi_os_allocate(sizeof(struct semaphore));
1189 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001190 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 memset(sem, 0, sizeof(struct semaphore));
1192
1193 sema_init(sem, initial_units);
1194
Len Brown4be44fc2005-08-05 00:44:28 -04001195 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196
Len Brown4be44fc2005-08-05 00:44:28 -04001197 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1198 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
Patrick Mocheld550d982006-06-27 00:41:40 -04001200 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203/*
1204 * TODO: A better way to delete semaphores? Linux doesn't have a
1205 * 'delete_semaphore()' function -- may result in an invalid
1206 * pointer dereference for non-synchronized consumers. Should
1207 * we at least check for blocked threads and signal/cancel them?
1208 */
1209
Len Brown4be44fc2005-08-05 00:44:28 -04001210acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211{
Len Brown4be44fc2005-08-05 00:44:28 -04001212 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001215 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216
Len Brown4be44fc2005-08-05 00:44:28 -04001217 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001219 BUG_ON(!list_empty(&sem->wait_list));
Len Brown02438d82006-06-30 03:19:10 -04001220 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -04001221 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222
Patrick Mocheld550d982006-06-27 00:41:40 -04001223 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 * TODO: Support for units > 1?
1228 */
Len Brown4be44fc2005-08-05 00:44:28 -04001229acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
Len Brown4be44fc2005-08-05 00:44:28 -04001231 acpi_status status = AE_OK;
1232 struct semaphore *sem = (struct semaphore *)handle;
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001233 long jiffies;
Len Brown4be44fc2005-08-05 00:44:28 -04001234 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001237 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
1239 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001240 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
Len Brown4be44fc2005-08-05 00:44:28 -04001242 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1243 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001245 if (timeout == ACPI_WAIT_FOREVER)
1246 jiffies = MAX_SCHEDULE_TIMEOUT;
1247 else
1248 jiffies = msecs_to_jiffies(timeout);
1249
1250 ret = down_timeout(sem, jiffies);
1251 if (ret)
1252 status = AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253
1254 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -04001255 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001256 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -04001257 handle, units, timeout,
1258 acpi_format_exception(status)));
1259 } else {
1260 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001261 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001262 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 }
1264
Patrick Mocheld550d982006-06-27 00:41:40 -04001265 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268/*
1269 * TODO: Support for units > 1?
1270 */
Len Brown4be44fc2005-08-05 00:44:28 -04001271acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272{
Len Brown4be44fc2005-08-05 00:44:28 -04001273 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001276 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
1278 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001279 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
Len Brown4be44fc2005-08-05 00:44:28 -04001281 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1282 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283
1284 up(sem);
1285
Patrick Mocheld550d982006-06-27 00:41:40 -04001286 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287}
Len Brown4be44fc2005-08-05 00:44:28 -04001288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -04001290u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291{
1292
1293#ifdef ENABLE_DEBUGGER
1294 if (acpi_in_debugger) {
1295 u32 chars;
1296
1297 kdb_read(buffer, sizeof(line_buf));
1298
1299 /* remove the CR kdb includes */
1300 chars = strlen(buffer) - 1;
1301 buffer[chars] = '\0';
1302 }
1303#endif
1304
1305 return 0;
1306}
Len Brown4be44fc2005-08-05 00:44:28 -04001307#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
Len Brown4be44fc2005-08-05 00:44:28 -04001309acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310{
Len Brown4be44fc2005-08-05 00:44:28 -04001311 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 case ACPI_SIGNAL_FATAL:
1313 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1314 break;
1315 case ACPI_SIGNAL_BREAKPOINT:
1316 /*
1317 * AML Breakpoint
1318 * ACPI spec. says to treat it as a NOP unless
1319 * you are debugging. So if/when we integrate
1320 * AML debugger into the kernel debugger its
1321 * hook will go here. But until then it is
1322 * not useful to print anything on breakpoints.
1323 */
1324 break;
1325 default:
1326 break;
1327 }
1328
1329 return AE_OK;
1330}
Len Brown4be44fc2005-08-05 00:44:28 -04001331
Len Brown4be44fc2005-08-05 00:44:28 -04001332static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333{
1334 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -04001335 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
1337 if (!str || !*str)
1338 return 0;
1339
1340 for (; count-- && str && *str; str++) {
1341 if (isalnum(*str) || *str == ' ' || *str == ':')
1342 *p++ = *str;
1343 else if (*str == '\'' || *str == '"')
1344 continue;
1345 else
1346 break;
1347 }
1348 *p = 0;
1349
1350 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -04001351
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352}
1353
1354__setup("acpi_os_name=", acpi_os_name_setup);
1355
Lin Ming12d32062010-12-09 16:51:06 +08001356#define OSI_STRING_LENGTH_MAX 64 /* arbitrary */
1357#define OSI_STRING_ENTRIES_MAX 16 /* arbitrary */
1358
1359struct osi_setup_entry {
1360 char string[OSI_STRING_LENGTH_MAX];
1361 bool enable;
1362};
1363
Shaohua Liaa165972011-07-28 13:48:43 -07001364static struct osi_setup_entry __initdata
1365 osi_setup_entries[OSI_STRING_ENTRIES_MAX] = {
1366 {"Module Device", true},
1367 {"Processor Device", true},
1368 {"3.0 _SCP Extensions", true},
1369 {"Processor Aggregator Device", true},
1370};
Lin Ming12d32062010-12-09 16:51:06 +08001371
Lin Mingd90aa922010-12-09 16:50:52 +08001372void __init acpi_osi_setup(char *str)
1373{
Lin Ming12d32062010-12-09 16:51:06 +08001374 struct osi_setup_entry *osi;
1375 bool enable = true;
1376 int i;
1377
Lin Mingd90aa922010-12-09 16:50:52 +08001378 if (!acpi_gbl_create_osi_method)
1379 return;
1380
1381 if (str == NULL || *str == '\0') {
1382 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1383 acpi_gbl_create_osi_method = FALSE;
Lin Ming12d32062010-12-09 16:51:06 +08001384 return;
1385 }
1386
1387 if (*str == '!') {
1388 str++;
1389 enable = false;
1390 }
1391
1392 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1393 osi = &osi_setup_entries[i];
1394 if (!strcmp(osi->string, str)) {
1395 osi->enable = enable;
1396 break;
1397 } else if (osi->string[0] == '\0') {
1398 osi->enable = enable;
1399 strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1400 break;
1401 }
1402 }
Lin Mingd90aa922010-12-09 16:50:52 +08001403}
1404
Len Brownd4b7dc42008-01-23 20:50:56 -05001405static void __init set_osi_linux(unsigned int enable)
1406{
Lin Mingd90aa922010-12-09 16:50:52 +08001407 if (osi_linux.enable != enable)
Len Brownd4b7dc42008-01-23 20:50:56 -05001408 osi_linux.enable = enable;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001409
1410 if (osi_linux.enable)
1411 acpi_osi_setup("Linux");
1412 else
1413 acpi_osi_setup("!Linux");
1414
Len Brownd4b7dc42008-01-23 20:50:56 -05001415 return;
1416}
Len Brownf5076542007-05-30 00:10:38 -04001417
Len Brownd4b7dc42008-01-23 20:50:56 -05001418static void __init acpi_cmdline_osi_linux(unsigned int enable)
1419{
Lin Mingd90aa922010-12-09 16:50:52 +08001420 osi_linux.cmdline = 1; /* cmdline set the default and override DMI */
1421 osi_linux.dmi = 0;
Len Brownd4b7dc42008-01-23 20:50:56 -05001422 set_osi_linux(enable);
Len Brownf5076542007-05-30 00:10:38 -04001423
Len Brownd4b7dc42008-01-23 20:50:56 -05001424 return;
1425}
1426
1427void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1428{
Len Brownd4b7dc42008-01-23 20:50:56 -05001429 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1430
1431 if (enable == -1)
1432 return;
1433
Lin Mingd90aa922010-12-09 16:50:52 +08001434 osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) */
Len Brownd4b7dc42008-01-23 20:50:56 -05001435 set_osi_linux(enable);
1436
Len Brownf5076542007-05-30 00:10:38 -04001437 return;
1438}
1439
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440/*
Len Brownae00d812007-05-29 18:43:33 -04001441 * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1442 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 * empty string disables _OSI
Len Brownae00d812007-05-29 18:43:33 -04001444 * string starting with '!' disables that string
1445 * otherwise string is added to list, augmenting built-in strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 */
Lin Mingb0ed7a92010-08-06 09:35:51 +08001447static void __init acpi_osi_setup_late(void)
1448{
Lin Ming12d32062010-12-09 16:51:06 +08001449 struct osi_setup_entry *osi;
1450 char *str;
1451 int i;
Lin Mingd90aa922010-12-09 16:50:52 +08001452 acpi_status status;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001453
Lin Ming12d32062010-12-09 16:51:06 +08001454 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1455 osi = &osi_setup_entries[i];
1456 str = osi->string;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001457
Lin Ming12d32062010-12-09 16:51:06 +08001458 if (*str == '\0')
1459 break;
1460 if (osi->enable) {
1461 status = acpi_install_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001462
Lin Ming12d32062010-12-09 16:51:06 +08001463 if (ACPI_SUCCESS(status))
1464 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1465 } else {
1466 status = acpi_remove_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001467
Lin Ming12d32062010-12-09 16:51:06 +08001468 if (ACPI_SUCCESS(status))
1469 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1470 }
Lin Mingb0ed7a92010-08-06 09:35:51 +08001471 }
1472}
1473
Lin Mingd90aa922010-12-09 16:50:52 +08001474static int __init osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475{
Lin Mingd90aa922010-12-09 16:50:52 +08001476 if (str && !strcmp("Linux", str))
1477 acpi_cmdline_osi_linux(1);
1478 else if (str && !strcmp("!Linux", str))
1479 acpi_cmdline_osi_linux(0);
1480 else
1481 acpi_osi_setup(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
1483 return 1;
1484}
1485
Lin Mingd90aa922010-12-09 16:50:52 +08001486__setup("acpi_osi=", osi_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487
1488/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -04001489static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490{
1491 printk(KERN_INFO PREFIX "serialize enabled\n");
1492
1493 acpi_gbl_all_methods_serialized = TRUE;
1494
1495 return 1;
1496}
1497
1498__setup("acpi_serialize", acpi_serialize_setup);
1499
Thomas Renningerdf92e692008-02-04 23:31:22 -08001500/* Check of resource interference between native drivers and ACPI
1501 * OperationRegions (SystemIO and System Memory only).
1502 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1503 * in arbitrary AML code and can interfere with legacy drivers.
1504 * acpi_enforce_resources= can be set to:
1505 *
Luca Tettamanti7e905602009-03-30 00:01:27 +02001506 * - strict (default) (2)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001507 * -> further driver trying to access the resources will not load
Luca Tettamanti7e905602009-03-30 00:01:27 +02001508 * - lax (1)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001509 * -> further driver trying to access the resources will load, but you
1510 * get a system message that something might go wrong...
1511 *
1512 * - no (0)
1513 * -> ACPI Operation Region resources will not be registered
1514 *
1515 */
1516#define ENFORCE_RESOURCES_STRICT 2
1517#define ENFORCE_RESOURCES_LAX 1
1518#define ENFORCE_RESOURCES_NO 0
1519
Luca Tettamanti7e905602009-03-30 00:01:27 +02001520static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001521
1522static int __init acpi_enforce_resources_setup(char *str)
1523{
1524 if (str == NULL || *str == '\0')
1525 return 0;
1526
1527 if (!strcmp("strict", str))
1528 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1529 else if (!strcmp("lax", str))
1530 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1531 else if (!strcmp("no", str))
1532 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1533
1534 return 1;
1535}
1536
1537__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1538
1539/* Check for resource conflicts between ACPI OperationRegions and native
1540 * drivers */
Jean Delvare876fba42009-11-11 15:22:15 +01001541int acpi_check_resource_conflict(const struct resource *res)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001542{
Lin Mingf654c0f2012-01-12 13:10:32 +08001543 acpi_adr_space_type space_id;
1544 acpi_size length;
1545 u8 warn = 0;
1546 int clash = 0;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001547
1548 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1549 return 0;
1550 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1551 return 0;
1552
Lin Mingf654c0f2012-01-12 13:10:32 +08001553 if (res->flags & IORESOURCE_IO)
1554 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1555 else
1556 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001557
Alexandru Gheorghiue4f52242013-03-12 08:53:02 +00001558 length = resource_size(res);
Lin Mingf654c0f2012-01-12 13:10:32 +08001559 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1560 warn = 1;
1561 clash = acpi_check_address_range(space_id, res->start, length, warn);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001562
1563 if (clash) {
1564 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
Jean Delvare14f03342009-09-08 15:31:46 +02001565 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1566 printk(KERN_NOTICE "ACPI: This conflict may"
1567 " cause random problems and system"
1568 " instability\n");
1569 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1570 " for this device, you should use it instead of"
1571 " the native driver\n");
Thomas Renningerdf92e692008-02-04 23:31:22 -08001572 }
1573 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1574 return -EBUSY;
1575 }
1576 return 0;
1577}
Thomas Renninger443dea72008-02-04 23:31:23 -08001578EXPORT_SYMBOL(acpi_check_resource_conflict);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001579
1580int acpi_check_region(resource_size_t start, resource_size_t n,
1581 const char *name)
1582{
1583 struct resource res = {
1584 .start = start,
1585 .end = start + n - 1,
1586 .name = name,
1587 .flags = IORESOURCE_IO,
1588 };
1589
1590 return acpi_check_resource_conflict(&res);
1591}
1592EXPORT_SYMBOL(acpi_check_region);
1593
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594/*
Jean Delvare70dd6be2010-05-27 19:58:37 +02001595 * Let drivers know whether the resource checks are effective
1596 */
1597int acpi_resources_are_enforced(void)
1598{
1599 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1600}
1601EXPORT_SYMBOL(acpi_resources_are_enforced);
1602
1603/*
Lin Ming9f63b882011-03-23 17:26:34 +08001604 * Deallocate the memory for a spinlock.
1605 */
1606void acpi_os_delete_lock(acpi_spinlock handle)
1607{
1608 ACPI_FREE(handle);
1609}
1610
1611/*
Robert Moore73459f72005-06-24 00:00:00 -04001612 * Acquire a spinlock.
1613 *
1614 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001615 */
1616
Bob Moore967440e32006-06-23 17:04:00 -04001617acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001618{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001619 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001620 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001621 return flags;
1622}
1623
1624/*
1625 * Release a spinlock. See above.
1626 */
1627
Bob Moore967440e32006-06-23 17:04:00 -04001628void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001629{
Bob Moore967440e32006-06-23 17:04:00 -04001630 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001631}
1632
Robert Moore73459f72005-06-24 00:00:00 -04001633#ifndef ACPI_USE_LOCAL_CACHE
1634
1635/*******************************************************************************
1636 *
1637 * FUNCTION: acpi_os_create_cache
1638 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001639 * PARAMETERS: name - Ascii name for the cache
1640 * size - Size of each cached object
1641 * depth - Maximum depth of the cache (in objects) <ignored>
1642 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001643 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001644 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001645 *
1646 * DESCRIPTION: Create a cache object
1647 *
1648 ******************************************************************************/
1649
1650acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001651acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001652{
Paul Mundt20c2df82007-07-20 10:11:58 +09001653 *cache = kmem_cache_create(name, size, 0, 0, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001654 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001655 return AE_ERROR;
1656 else
1657 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001658}
1659
1660/*******************************************************************************
1661 *
1662 * FUNCTION: acpi_os_purge_cache
1663 *
1664 * PARAMETERS: Cache - Handle to cache object
1665 *
1666 * RETURN: Status
1667 *
1668 * DESCRIPTION: Free all objects within the requested cache.
1669 *
1670 ******************************************************************************/
1671
Len Brown4be44fc2005-08-05 00:44:28 -04001672acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001673{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001674 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001675 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001676}
1677
1678/*******************************************************************************
1679 *
1680 * FUNCTION: acpi_os_delete_cache
1681 *
1682 * PARAMETERS: Cache - Handle to cache object
1683 *
1684 * RETURN: Status
1685 *
1686 * DESCRIPTION: Free all objects within the requested cache and delete the
1687 * cache object.
1688 *
1689 ******************************************************************************/
1690
Len Brown4be44fc2005-08-05 00:44:28 -04001691acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001692{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001693 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001694 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001695}
1696
1697/*******************************************************************************
1698 *
1699 * FUNCTION: acpi_os_release_object
1700 *
1701 * PARAMETERS: Cache - Handle to cache object
1702 * Object - The object to be released
1703 *
1704 * RETURN: None
1705 *
1706 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1707 * the object is deleted.
1708 *
1709 ******************************************************************************/
1710
Len Brown4be44fc2005-08-05 00:44:28 -04001711acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001712{
Len Brown4be44fc2005-08-05 00:44:28 -04001713 kmem_cache_free(cache, object);
1714 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001715}
Robert Moore73459f72005-06-24 00:00:00 -04001716#endif
Myron Stowed362eda2010-10-21 14:24:04 -06001717
1718acpi_status __init acpi_os_initialize(void)
1719{
1720 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1721 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1722 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1723 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1724
1725 return AE_OK;
1726}
1727
Zhang Rui32d47ee2010-12-08 10:40:36 +08001728acpi_status __init acpi_os_initialize1(void)
Myron Stowed362eda2010-10-21 14:24:04 -06001729{
Tejun Heo44d25882011-02-01 11:42:42 +01001730 kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1731 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1732 kacpi_hotplug_wq = alloc_workqueue("kacpi_hotplug", 0, 1);
Myron Stowed362eda2010-10-21 14:24:04 -06001733 BUG_ON(!kacpid_wq);
1734 BUG_ON(!kacpi_notify_wq);
1735 BUG_ON(!kacpi_hotplug_wq);
Len Brown1bd64d42010-10-26 14:50:56 -04001736 acpi_install_interface_handler(acpi_osi_handler);
1737 acpi_osi_setup_late();
Myron Stowed362eda2010-10-21 14:24:04 -06001738 return AE_OK;
1739}
1740
1741acpi_status acpi_os_terminate(void)
1742{
1743 if (acpi_irq_handler) {
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +01001744 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
Myron Stowed362eda2010-10-21 14:24:04 -06001745 acpi_irq_handler);
1746 }
1747
1748 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1749 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1750 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1751 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1752
1753 destroy_workqueue(kacpid_wq);
1754 destroy_workqueue(kacpi_notify_wq);
1755 destroy_workqueue(kacpi_hotplug_wq);
1756
1757 return AE_OK;
1758}
Tang Liang09f98a82011-12-09 10:05:54 +08001759
1760acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1761 u32 pm1b_control)
1762{
1763 int rc = 0;
1764 if (__acpi_os_prepare_sleep)
1765 rc = __acpi_os_prepare_sleep(sleep_state,
1766 pm1a_control, pm1b_control);
1767 if (rc < 0)
1768 return AE_ERROR;
1769 else if (rc > 0)
1770 return AE_CTRL_SKIP;
1771
1772 return AE_OK;
1773}
1774
1775void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1776 u32 pm1a_ctrl, u32 pm1b_ctrl))
1777{
1778 __acpi_os_prepare_sleep = func;
1779}
Yinghai Lu92d8aff2013-01-21 13:20:47 -08001780
1781void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
1782 void (*func)(struct work_struct *work))
1783{
1784 struct acpi_hp_work *hp_work;
1785 int ret;
1786
1787 hp_work = kmalloc(sizeof(*hp_work), GFP_KERNEL);
1788 if (!hp_work)
1789 return;
1790
1791 hp_work->handle = handle;
1792 hp_work->type = type;
1793 hp_work->context = context;
1794
1795 INIT_WORK(&hp_work->work, func);
1796 ret = queue_work(kacpi_hotplug_wq, &hp_work->work);
1797 if (!ret)
1798 kfree(hp_work);
1799}
1800EXPORT_SYMBOL_GPL(alloc_acpi_hp_work);