blob: 6ab2c350552061893ded7355d376406de5d98ed8 [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 */
Wang YanQinga6432de2013-04-23 01:19:19 +0200644 memblock_reserve(acpi_tables_addr, all_tables_size);
Thomas Renninger53aac442012-10-01 00:23:54 +0200645 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{
Mika Westerberg10619062013-05-23 10:27:46 +0300838 u64 time_ns = ktime_to_ns(ktime_get());
839 do_div(time_ns, 100);
840 return time_ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
842
Len Brown4be44fc2005-08-05 00:44:28 -0400843acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844{
845 u32 dummy;
846
847 if (!value)
848 value = &dummy;
849
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800850 *value = 0;
851 if (width <= 8) {
Len Brown4be44fc2005-08-05 00:44:28 -0400852 *(u8 *) value = inb(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800853 } else if (width <= 16) {
Len Brown4be44fc2005-08-05 00:44:28 -0400854 *(u16 *) value = inw(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800855 } else if (width <= 32) {
Len Brown4be44fc2005-08-05 00:44:28 -0400856 *(u32 *) value = inl(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800857 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 BUG();
859 }
860
861 return AE_OK;
862}
Len Brown4be44fc2005-08-05 00:44:28 -0400863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864EXPORT_SYMBOL(acpi_os_read_port);
865
Len Brown4be44fc2005-08-05 00:44:28 -0400866acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800868 if (width <= 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 outb(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800870 } else if (width <= 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 outw(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800872 } else if (width <= 32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 outl(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800874 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 BUG();
876 }
877
878 return AE_OK;
879}
Len Brown4be44fc2005-08-05 00:44:28 -0400880
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881EXPORT_SYMBOL(acpi_os_write_port);
882
Myron Stowee615bf52012-01-20 19:13:24 -0700883#ifdef readq
884static inline u64 read64(const volatile void __iomem *addr)
885{
886 return readq(addr);
887}
888#else
889static inline u64 read64(const volatile void __iomem *addr)
890{
891 u64 l, h;
892 l = readl(addr);
893 h = readl(addr+4);
894 return l | (h << 32);
895}
896#endif
897
898acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800899acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700900{
901 void __iomem *virt_addr;
902 unsigned int size = width / 8;
903 bool unmap = false;
904 u64 dummy;
905
906 rcu_read_lock();
907 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
908 if (!virt_addr) {
909 rcu_read_unlock();
910 virt_addr = acpi_os_ioremap(phys_addr, size);
911 if (!virt_addr)
912 return AE_BAD_ADDRESS;
913 unmap = true;
914 }
915
916 if (!value)
917 value = &dummy;
918
919 switch (width) {
920 case 8:
921 *(u8 *) value = readb(virt_addr);
922 break;
923 case 16:
924 *(u16 *) value = readw(virt_addr);
925 break;
926 case 32:
927 *(u32 *) value = readl(virt_addr);
928 break;
929 case 64:
930 *(u64 *) value = read64(virt_addr);
931 break;
932 default:
933 BUG();
934 }
935
936 if (unmap)
937 iounmap(virt_addr);
938 else
939 rcu_read_unlock();
940
941 return AE_OK;
942}
943
Myron Stowee615bf52012-01-20 19:13:24 -0700944#ifdef writeq
945static inline void write64(u64 val, volatile void __iomem *addr)
946{
947 writeq(val, addr);
948}
949#else
950static inline void write64(u64 val, volatile void __iomem *addr)
951{
952 writel(val, addr);
953 writel(val>>32, addr+4);
954}
955#endif
956
957acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800958acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700959{
960 void __iomem *virt_addr;
961 unsigned int size = width / 8;
962 bool unmap = false;
963
964 rcu_read_lock();
965 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
966 if (!virt_addr) {
967 rcu_read_unlock();
968 virt_addr = acpi_os_ioremap(phys_addr, size);
969 if (!virt_addr)
970 return AE_BAD_ADDRESS;
971 unmap = true;
972 }
973
974 switch (width) {
975 case 8:
976 writeb(value, virt_addr);
977 break;
978 case 16:
979 writew(value, virt_addr);
980 break;
981 case 32:
982 writel(value, virt_addr);
983 break;
984 case 64:
985 write64(value, virt_addr);
986 break;
987 default:
988 BUG();
989 }
990
991 if (unmap)
992 iounmap(virt_addr);
993 else
994 rcu_read_unlock();
995
996 return AE_OK;
997}
998
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001000acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Bob Moorec5f02312010-08-06 08:57:53 +08001001 u64 *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002{
1003 int result, size;
Bob Moorec5f02312010-08-06 08:57:53 +08001004 u32 value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 if (!value)
1007 return AE_BAD_PARAMETER;
1008
1009 switch (width) {
1010 case 8:
1011 size = 1;
1012 break;
1013 case 16:
1014 size = 2;
1015 break;
1016 case 32:
1017 size = 4;
1018 break;
1019 default:
1020 return AE_ERROR;
1021 }
1022
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -05001023 result = raw_pci_read(pci_id->segment, pci_id->bus,
1024 PCI_DEVFN(pci_id->device, pci_id->function),
Bob Moorec5f02312010-08-06 08:57:53 +08001025 reg, size, &value32);
1026 *value = value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
1028 return (result ? AE_ERROR : AE_OK);
1029}
Len Brown4be44fc2005-08-05 00:44:28 -04001030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001032acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Lin Ming439913f2010-01-28 10:53:19 +08001033 u64 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034{
1035 int result, size;
1036
1037 switch (width) {
1038 case 8:
1039 size = 1;
1040 break;
1041 case 16:
1042 size = 2;
1043 break;
1044 case 32:
1045 size = 4;
1046 break;
1047 default:
1048 return AE_ERROR;
1049 }
1050
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -05001051 result = raw_pci_write(pci_id->segment, pci_id->bus,
1052 PCI_DEVFN(pci_id->device, pci_id->function),
1053 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
1055 return (result ? AE_ERROR : AE_OK);
1056}
1057
David Howells65f27f32006-11-22 14:55:48 +00001058static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059{
David Howells65f27f32006-11-22 14:55:48 +00001060 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -04001061
Bjorn Helgaas9ac61852009-08-31 22:32:10 +00001062 if (dpc->wait)
Lin Mingbd6f10a2012-05-22 16:43:49 +08001063 acpi_os_wait_events_complete();
Zhang Rui19cd8472008-08-28 10:05:06 +08001064
1065 dpc->function(dpc->context);
1066 kfree(dpc);
Zhang Rui19cd8472008-08-28 10:05:06 +08001067}
1068
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -04001069/*******************************************************************************
1070 *
1071 * FUNCTION: acpi_os_execute
1072 *
1073 * PARAMETERS: Type - Type of the callback
1074 * Function - Function to be executed
1075 * Context - Function parameters
1076 *
1077 * RETURN: Status
1078 *
1079 * DESCRIPTION: Depending on type, either queues function for deferred execution or
1080 * immediately executes function on a separate thread.
1081 *
1082 ******************************************************************************/
1083
Zhang Rui19cd8472008-08-28 10:05:06 +08001084static acpi_status __acpi_os_execute(acpi_execute_type type,
1085 acpi_osd_exec_callback function, void *context, int hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086{
Len Brown4be44fc2005-08-05 00:44:28 -04001087 acpi_status status = AE_OK;
1088 struct acpi_os_dpc *dpc;
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +03001089 struct workqueue_struct *queue;
Zhang Rui19cd8472008-08-28 10:05:06 +08001090 int ret;
Len Brown72945b22006-07-12 22:46:42 -04001091 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1092 "Scheduling function [%p(%p)] for deferred execution.\n",
1093 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 /*
1096 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +00001097 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 * way that allows us to also free its memory inside the callee.
1099 * Because we may want to schedule several tasks with different
1100 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +00001101 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 */
Len Brown72945b22006-07-12 22:46:42 -04001103
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001104 dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 if (!dpc)
Lin Ming889c78b2008-12-31 09:23:57 +08001106 return AE_NO_MEMORY;
Linus Torvaldsb976fe12006-11-17 19:31:09 -08001107
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 dpc->function = function;
1109 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -08001110
Zhang Ruic02256b2009-06-23 10:20:29 +08001111 /*
1112 * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
1113 * because the hotplug code may call driver .remove() functions,
1114 * which invoke flush_scheduled_work/acpi_os_wait_events_complete
1115 * to flush these workqueues.
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001116 *
1117 * To prevent lockdep from complaining unnecessarily, make sure that
1118 * there is a different static lockdep key for each workqueue by using
1119 * INIT_WORK() for each of them separately.
Zhang Ruic02256b2009-06-23 10:20:29 +08001120 */
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001121 if (hp) {
1122 queue = kacpi_hotplug_wq;
1123 dpc->wait = 1;
Zhang Ruibc736752010-03-22 15:48:54 +08001124 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001125 } else if (type == OSL_NOTIFY_HANDLER) {
1126 queue = kacpi_notify_wq;
Zhang Ruibc736752010-03-22 15:48:54 +08001127 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001128 } else {
1129 queue = kacpid_wq;
Zhang Ruibc736752010-03-22 15:48:54 +08001130 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001131 }
Zhang Ruibc736752010-03-22 15:48:54 +08001132
Tejun Heo8fec62b2010-06-29 10:07:09 +02001133 /*
1134 * On some machines, a software-initiated SMI causes corruption unless
1135 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
1136 * typically it's done in GPE-related methods that are run via
1137 * workqueues, so we can avoid the known corruption cases by always
1138 * queueing on CPU 0.
1139 */
1140 ret = queue_work_on(0, queue, &dpc->work);
Zhang Rui19cd8472008-08-28 10:05:06 +08001141
1142 if (!ret) {
Lin Ming55ac9a02008-09-28 14:51:56 +08001143 printk(KERN_ERR PREFIX
1144 "Call to queue_work() failed.\n");
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +03001145 status = AE_ERROR;
1146 kfree(dpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 }
Lin Ming889c78b2008-12-31 09:23:57 +08001148 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149}
Len Brown4be44fc2005-08-05 00:44:28 -04001150
Zhang Rui19cd8472008-08-28 10:05:06 +08001151acpi_status acpi_os_execute(acpi_execute_type type,
1152 acpi_osd_exec_callback function, void *context)
1153{
1154 return __acpi_os_execute(type, function, context, 0);
1155}
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -04001156EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157
Zhang Rui19cd8472008-08-28 10:05:06 +08001158acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
1159 void *context)
1160{
1161 return __acpi_os_execute(0, function, context, 1);
1162}
Toshi Kani61622ac2012-11-01 14:42:12 +00001163EXPORT_SYMBOL(acpi_os_hotplug_execute);
Zhang Rui19cd8472008-08-28 10:05:06 +08001164
Lin Mingbd6f10a2012-05-22 16:43:49 +08001165void acpi_os_wait_events_complete(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166{
1167 flush_workqueue(kacpid_wq);
Zhang Rui2f67a062008-04-29 02:34:42 -04001168 flush_workqueue(kacpi_notify_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169}
Len Brown4be44fc2005-08-05 00:44:28 -04001170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171EXPORT_SYMBOL(acpi_os_wait_events_complete);
1172
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001174acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175{
Len Brown4be44fc2005-08-05 00:44:28 -04001176 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 sem = acpi_os_allocate(sizeof(struct semaphore));
1179 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001180 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 memset(sem, 0, sizeof(struct semaphore));
1182
1183 sema_init(sem, initial_units);
1184
Len Brown4be44fc2005-08-05 00:44:28 -04001185 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
Len Brown4be44fc2005-08-05 00:44:28 -04001187 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1188 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Patrick Mocheld550d982006-06-27 00:41:40 -04001190 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193/*
1194 * TODO: A better way to delete semaphores? Linux doesn't have a
1195 * 'delete_semaphore()' function -- may result in an invalid
1196 * pointer dereference for non-synchronized consumers. Should
1197 * we at least check for blocked threads and signal/cancel them?
1198 */
1199
Len Brown4be44fc2005-08-05 00:44:28 -04001200acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201{
Len Brown4be44fc2005-08-05 00:44:28 -04001202 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001205 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206
Len Brown4be44fc2005-08-05 00:44:28 -04001207 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001209 BUG_ON(!list_empty(&sem->wait_list));
Len Brown02438d82006-06-30 03:19:10 -04001210 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -04001211 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212
Patrick Mocheld550d982006-06-27 00:41:40 -04001213 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 * TODO: Support for units > 1?
1218 */
Len Brown4be44fc2005-08-05 00:44:28 -04001219acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220{
Len Brown4be44fc2005-08-05 00:44:28 -04001221 acpi_status status = AE_OK;
1222 struct semaphore *sem = (struct semaphore *)handle;
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001223 long jiffies;
Len Brown4be44fc2005-08-05 00:44:28 -04001224 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001227 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
1229 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001230 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
Len Brown4be44fc2005-08-05 00:44:28 -04001232 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1233 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001235 if (timeout == ACPI_WAIT_FOREVER)
1236 jiffies = MAX_SCHEDULE_TIMEOUT;
1237 else
1238 jiffies = msecs_to_jiffies(timeout);
1239
1240 ret = down_timeout(sem, jiffies);
1241 if (ret)
1242 status = AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243
1244 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -04001245 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001246 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -04001247 handle, units, timeout,
1248 acpi_format_exception(status)));
1249 } else {
1250 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001251 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001252 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 }
1254
Patrick Mocheld550d982006-06-27 00:41:40 -04001255 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258/*
1259 * TODO: Support for units > 1?
1260 */
Len Brown4be44fc2005-08-05 00:44:28 -04001261acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262{
Len Brown4be44fc2005-08-05 00:44:28 -04001263 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001266 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
1268 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001269 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
Len Brown4be44fc2005-08-05 00:44:28 -04001271 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1272 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
1274 up(sem);
1275
Patrick Mocheld550d982006-06-27 00:41:40 -04001276 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277}
Len Brown4be44fc2005-08-05 00:44:28 -04001278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -04001280u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281{
1282
1283#ifdef ENABLE_DEBUGGER
1284 if (acpi_in_debugger) {
1285 u32 chars;
1286
1287 kdb_read(buffer, sizeof(line_buf));
1288
1289 /* remove the CR kdb includes */
1290 chars = strlen(buffer) - 1;
1291 buffer[chars] = '\0';
1292 }
1293#endif
1294
1295 return 0;
1296}
Len Brown4be44fc2005-08-05 00:44:28 -04001297#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
Len Brown4be44fc2005-08-05 00:44:28 -04001299acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300{
Len Brown4be44fc2005-08-05 00:44:28 -04001301 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 case ACPI_SIGNAL_FATAL:
1303 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1304 break;
1305 case ACPI_SIGNAL_BREAKPOINT:
1306 /*
1307 * AML Breakpoint
1308 * ACPI spec. says to treat it as a NOP unless
1309 * you are debugging. So if/when we integrate
1310 * AML debugger into the kernel debugger its
1311 * hook will go here. But until then it is
1312 * not useful to print anything on breakpoints.
1313 */
1314 break;
1315 default:
1316 break;
1317 }
1318
1319 return AE_OK;
1320}
Len Brown4be44fc2005-08-05 00:44:28 -04001321
Len Brown4be44fc2005-08-05 00:44:28 -04001322static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323{
1324 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -04001325 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
1327 if (!str || !*str)
1328 return 0;
1329
1330 for (; count-- && str && *str; str++) {
1331 if (isalnum(*str) || *str == ' ' || *str == ':')
1332 *p++ = *str;
1333 else if (*str == '\'' || *str == '"')
1334 continue;
1335 else
1336 break;
1337 }
1338 *p = 0;
1339
1340 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -04001341
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342}
1343
1344__setup("acpi_os_name=", acpi_os_name_setup);
1345
Lin Ming12d32062010-12-09 16:51:06 +08001346#define OSI_STRING_LENGTH_MAX 64 /* arbitrary */
1347#define OSI_STRING_ENTRIES_MAX 16 /* arbitrary */
1348
1349struct osi_setup_entry {
1350 char string[OSI_STRING_LENGTH_MAX];
1351 bool enable;
1352};
1353
Shaohua Liaa165972011-07-28 13:48:43 -07001354static struct osi_setup_entry __initdata
1355 osi_setup_entries[OSI_STRING_ENTRIES_MAX] = {
1356 {"Module Device", true},
1357 {"Processor Device", true},
1358 {"3.0 _SCP Extensions", true},
1359 {"Processor Aggregator Device", true},
1360};
Lin Ming12d32062010-12-09 16:51:06 +08001361
Lin Mingd90aa922010-12-09 16:50:52 +08001362void __init acpi_osi_setup(char *str)
1363{
Lin Ming12d32062010-12-09 16:51:06 +08001364 struct osi_setup_entry *osi;
1365 bool enable = true;
1366 int i;
1367
Lin Mingd90aa922010-12-09 16:50:52 +08001368 if (!acpi_gbl_create_osi_method)
1369 return;
1370
1371 if (str == NULL || *str == '\0') {
1372 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1373 acpi_gbl_create_osi_method = FALSE;
Lin Ming12d32062010-12-09 16:51:06 +08001374 return;
1375 }
1376
1377 if (*str == '!') {
1378 str++;
1379 enable = false;
1380 }
1381
1382 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1383 osi = &osi_setup_entries[i];
1384 if (!strcmp(osi->string, str)) {
1385 osi->enable = enable;
1386 break;
1387 } else if (osi->string[0] == '\0') {
1388 osi->enable = enable;
1389 strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1390 break;
1391 }
1392 }
Lin Mingd90aa922010-12-09 16:50:52 +08001393}
1394
Len Brownd4b7dc42008-01-23 20:50:56 -05001395static void __init set_osi_linux(unsigned int enable)
1396{
Lin Mingd90aa922010-12-09 16:50:52 +08001397 if (osi_linux.enable != enable)
Len Brownd4b7dc42008-01-23 20:50:56 -05001398 osi_linux.enable = enable;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001399
1400 if (osi_linux.enable)
1401 acpi_osi_setup("Linux");
1402 else
1403 acpi_osi_setup("!Linux");
1404
Len Brownd4b7dc42008-01-23 20:50:56 -05001405 return;
1406}
Len Brownf5076542007-05-30 00:10:38 -04001407
Len Brownd4b7dc42008-01-23 20:50:56 -05001408static void __init acpi_cmdline_osi_linux(unsigned int enable)
1409{
Lin Mingd90aa922010-12-09 16:50:52 +08001410 osi_linux.cmdline = 1; /* cmdline set the default and override DMI */
1411 osi_linux.dmi = 0;
Len Brownd4b7dc42008-01-23 20:50:56 -05001412 set_osi_linux(enable);
Len Brownf5076542007-05-30 00:10:38 -04001413
Len Brownd4b7dc42008-01-23 20:50:56 -05001414 return;
1415}
1416
1417void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1418{
Len Brownd4b7dc42008-01-23 20:50:56 -05001419 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1420
1421 if (enable == -1)
1422 return;
1423
Lin Mingd90aa922010-12-09 16:50:52 +08001424 osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) */
Len Brownd4b7dc42008-01-23 20:50:56 -05001425 set_osi_linux(enable);
1426
Len Brownf5076542007-05-30 00:10:38 -04001427 return;
1428}
1429
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430/*
Len Brownae00d812007-05-29 18:43:33 -04001431 * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1432 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 * empty string disables _OSI
Len Brownae00d812007-05-29 18:43:33 -04001434 * string starting with '!' disables that string
1435 * otherwise string is added to list, augmenting built-in strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 */
Lin Mingb0ed7a92010-08-06 09:35:51 +08001437static void __init acpi_osi_setup_late(void)
1438{
Lin Ming12d32062010-12-09 16:51:06 +08001439 struct osi_setup_entry *osi;
1440 char *str;
1441 int i;
Lin Mingd90aa922010-12-09 16:50:52 +08001442 acpi_status status;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001443
Lin Ming12d32062010-12-09 16:51:06 +08001444 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1445 osi = &osi_setup_entries[i];
1446 str = osi->string;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001447
Lin Ming12d32062010-12-09 16:51:06 +08001448 if (*str == '\0')
1449 break;
1450 if (osi->enable) {
1451 status = acpi_install_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001452
Lin Ming12d32062010-12-09 16:51:06 +08001453 if (ACPI_SUCCESS(status))
1454 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1455 } else {
1456 status = acpi_remove_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001457
Lin Ming12d32062010-12-09 16:51:06 +08001458 if (ACPI_SUCCESS(status))
1459 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1460 }
Lin Mingb0ed7a92010-08-06 09:35:51 +08001461 }
1462}
1463
Lin Mingd90aa922010-12-09 16:50:52 +08001464static int __init osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465{
Lin Mingd90aa922010-12-09 16:50:52 +08001466 if (str && !strcmp("Linux", str))
1467 acpi_cmdline_osi_linux(1);
1468 else if (str && !strcmp("!Linux", str))
1469 acpi_cmdline_osi_linux(0);
1470 else
1471 acpi_osi_setup(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
1473 return 1;
1474}
1475
Lin Mingd90aa922010-12-09 16:50:52 +08001476__setup("acpi_osi=", osi_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
1478/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -04001479static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480{
1481 printk(KERN_INFO PREFIX "serialize enabled\n");
1482
1483 acpi_gbl_all_methods_serialized = TRUE;
1484
1485 return 1;
1486}
1487
1488__setup("acpi_serialize", acpi_serialize_setup);
1489
Thomas Renningerdf92e692008-02-04 23:31:22 -08001490/* Check of resource interference between native drivers and ACPI
1491 * OperationRegions (SystemIO and System Memory only).
1492 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1493 * in arbitrary AML code and can interfere with legacy drivers.
1494 * acpi_enforce_resources= can be set to:
1495 *
Luca Tettamanti7e905602009-03-30 00:01:27 +02001496 * - strict (default) (2)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001497 * -> further driver trying to access the resources will not load
Luca Tettamanti7e905602009-03-30 00:01:27 +02001498 * - lax (1)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001499 * -> further driver trying to access the resources will load, but you
1500 * get a system message that something might go wrong...
1501 *
1502 * - no (0)
1503 * -> ACPI Operation Region resources will not be registered
1504 *
1505 */
1506#define ENFORCE_RESOURCES_STRICT 2
1507#define ENFORCE_RESOURCES_LAX 1
1508#define ENFORCE_RESOURCES_NO 0
1509
Luca Tettamanti7e905602009-03-30 00:01:27 +02001510static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001511
1512static int __init acpi_enforce_resources_setup(char *str)
1513{
1514 if (str == NULL || *str == '\0')
1515 return 0;
1516
1517 if (!strcmp("strict", str))
1518 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1519 else if (!strcmp("lax", str))
1520 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1521 else if (!strcmp("no", str))
1522 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1523
1524 return 1;
1525}
1526
1527__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1528
1529/* Check for resource conflicts between ACPI OperationRegions and native
1530 * drivers */
Jean Delvare876fba42009-11-11 15:22:15 +01001531int acpi_check_resource_conflict(const struct resource *res)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001532{
Lin Mingf654c0f2012-01-12 13:10:32 +08001533 acpi_adr_space_type space_id;
1534 acpi_size length;
1535 u8 warn = 0;
1536 int clash = 0;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001537
1538 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1539 return 0;
1540 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1541 return 0;
1542
Lin Mingf654c0f2012-01-12 13:10:32 +08001543 if (res->flags & IORESOURCE_IO)
1544 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1545 else
1546 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001547
Alexandru Gheorghiue4f52242013-03-12 08:53:02 +00001548 length = resource_size(res);
Lin Mingf654c0f2012-01-12 13:10:32 +08001549 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1550 warn = 1;
1551 clash = acpi_check_address_range(space_id, res->start, length, warn);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001552
1553 if (clash) {
1554 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
Jean Delvare14f03342009-09-08 15:31:46 +02001555 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1556 printk(KERN_NOTICE "ACPI: This conflict may"
1557 " cause random problems and system"
1558 " instability\n");
1559 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1560 " for this device, you should use it instead of"
1561 " the native driver\n");
Thomas Renningerdf92e692008-02-04 23:31:22 -08001562 }
1563 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1564 return -EBUSY;
1565 }
1566 return 0;
1567}
Thomas Renninger443dea72008-02-04 23:31:23 -08001568EXPORT_SYMBOL(acpi_check_resource_conflict);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001569
1570int acpi_check_region(resource_size_t start, resource_size_t n,
1571 const char *name)
1572{
1573 struct resource res = {
1574 .start = start,
1575 .end = start + n - 1,
1576 .name = name,
1577 .flags = IORESOURCE_IO,
1578 };
1579
1580 return acpi_check_resource_conflict(&res);
1581}
1582EXPORT_SYMBOL(acpi_check_region);
1583
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584/*
Jean Delvare70dd6be2010-05-27 19:58:37 +02001585 * Let drivers know whether the resource checks are effective
1586 */
1587int acpi_resources_are_enforced(void)
1588{
1589 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1590}
1591EXPORT_SYMBOL(acpi_resources_are_enforced);
1592
1593/*
Lin Ming9f63b882011-03-23 17:26:34 +08001594 * Deallocate the memory for a spinlock.
1595 */
1596void acpi_os_delete_lock(acpi_spinlock handle)
1597{
1598 ACPI_FREE(handle);
1599}
1600
1601/*
Robert Moore73459f72005-06-24 00:00:00 -04001602 * Acquire a spinlock.
1603 *
1604 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001605 */
1606
Bob Moore967440e32006-06-23 17:04:00 -04001607acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001608{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001609 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001610 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001611 return flags;
1612}
1613
1614/*
1615 * Release a spinlock. See above.
1616 */
1617
Bob Moore967440e32006-06-23 17:04:00 -04001618void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001619{
Bob Moore967440e32006-06-23 17:04:00 -04001620 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001621}
1622
Robert Moore73459f72005-06-24 00:00:00 -04001623#ifndef ACPI_USE_LOCAL_CACHE
1624
1625/*******************************************************************************
1626 *
1627 * FUNCTION: acpi_os_create_cache
1628 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001629 * PARAMETERS: name - Ascii name for the cache
1630 * size - Size of each cached object
1631 * depth - Maximum depth of the cache (in objects) <ignored>
1632 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001633 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001634 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001635 *
1636 * DESCRIPTION: Create a cache object
1637 *
1638 ******************************************************************************/
1639
1640acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001641acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001642{
Paul Mundt20c2df82007-07-20 10:11:58 +09001643 *cache = kmem_cache_create(name, size, 0, 0, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001644 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001645 return AE_ERROR;
1646 else
1647 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001648}
1649
1650/*******************************************************************************
1651 *
1652 * FUNCTION: acpi_os_purge_cache
1653 *
1654 * PARAMETERS: Cache - Handle to cache object
1655 *
1656 * RETURN: Status
1657 *
1658 * DESCRIPTION: Free all objects within the requested cache.
1659 *
1660 ******************************************************************************/
1661
Len Brown4be44fc2005-08-05 00:44:28 -04001662acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001663{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001664 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001665 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001666}
1667
1668/*******************************************************************************
1669 *
1670 * FUNCTION: acpi_os_delete_cache
1671 *
1672 * PARAMETERS: Cache - Handle to cache object
1673 *
1674 * RETURN: Status
1675 *
1676 * DESCRIPTION: Free all objects within the requested cache and delete the
1677 * cache object.
1678 *
1679 ******************************************************************************/
1680
Len Brown4be44fc2005-08-05 00:44:28 -04001681acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001682{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001683 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001684 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001685}
1686
1687/*******************************************************************************
1688 *
1689 * FUNCTION: acpi_os_release_object
1690 *
1691 * PARAMETERS: Cache - Handle to cache object
1692 * Object - The object to be released
1693 *
1694 * RETURN: None
1695 *
1696 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1697 * the object is deleted.
1698 *
1699 ******************************************************************************/
1700
Len Brown4be44fc2005-08-05 00:44:28 -04001701acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001702{
Len Brown4be44fc2005-08-05 00:44:28 -04001703 kmem_cache_free(cache, object);
1704 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001705}
Robert Moore73459f72005-06-24 00:00:00 -04001706#endif
Myron Stowed362eda2010-10-21 14:24:04 -06001707
Lv Zhengb75dd292013-06-08 00:58:48 +00001708static int __init acpi_no_auto_ssdt_setup(char *s)
1709{
1710 printk(KERN_NOTICE PREFIX "SSDT auto-load disabled\n");
1711
1712 acpi_gbl_disable_ssdt_table_load = TRUE;
1713
1714 return 1;
1715}
1716
1717__setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup);
1718
Myron Stowed362eda2010-10-21 14:24:04 -06001719acpi_status __init acpi_os_initialize(void)
1720{
1721 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1722 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1723 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1724 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1725
1726 return AE_OK;
1727}
1728
Zhang Rui32d47ee2010-12-08 10:40:36 +08001729acpi_status __init acpi_os_initialize1(void)
Myron Stowed362eda2010-10-21 14:24:04 -06001730{
Tejun Heo44d25882011-02-01 11:42:42 +01001731 kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1732 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1733 kacpi_hotplug_wq = alloc_workqueue("kacpi_hotplug", 0, 1);
Myron Stowed362eda2010-10-21 14:24:04 -06001734 BUG_ON(!kacpid_wq);
1735 BUG_ON(!kacpi_notify_wq);
1736 BUG_ON(!kacpi_hotplug_wq);
Len Brown1bd64d42010-10-26 14:50:56 -04001737 acpi_install_interface_handler(acpi_osi_handler);
1738 acpi_osi_setup_late();
Myron Stowed362eda2010-10-21 14:24:04 -06001739 return AE_OK;
1740}
1741
1742acpi_status acpi_os_terminate(void)
1743{
1744 if (acpi_irq_handler) {
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +01001745 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
Myron Stowed362eda2010-10-21 14:24:04 -06001746 acpi_irq_handler);
1747 }
1748
1749 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1750 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1751 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1752 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1753
1754 destroy_workqueue(kacpid_wq);
1755 destroy_workqueue(kacpi_notify_wq);
1756 destroy_workqueue(kacpi_hotplug_wq);
1757
1758 return AE_OK;
1759}
Tang Liang09f98a82011-12-09 10:05:54 +08001760
1761acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1762 u32 pm1b_control)
1763{
1764 int rc = 0;
1765 if (__acpi_os_prepare_sleep)
1766 rc = __acpi_os_prepare_sleep(sleep_state,
1767 pm1a_control, pm1b_control);
1768 if (rc < 0)
1769 return AE_ERROR;
1770 else if (rc > 0)
1771 return AE_CTRL_SKIP;
1772
1773 return AE_OK;
1774}
1775
1776void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1777 u32 pm1a_ctrl, u32 pm1b_ctrl))
1778{
1779 __acpi_os_prepare_sleep = func;
1780}
Yinghai Lu92d8aff2013-01-21 13:20:47 -08001781
1782void alloc_acpi_hp_work(acpi_handle handle, u32 type, void *context,
1783 void (*func)(struct work_struct *work))
1784{
1785 struct acpi_hp_work *hp_work;
1786 int ret;
1787
1788 hp_work = kmalloc(sizeof(*hp_work), GFP_KERNEL);
1789 if (!hp_work)
1790 return;
1791
1792 hp_work->handle = handle;
1793 hp_work->type = type;
1794 hp_work->context = context;
1795
1796 INIT_WORK(&hp_work->work, func);
1797 ret = queue_work(kacpi_hotplug_wq, &hp_work->work);
1798 if (!ret)
1799 kfree(hp_work);
1800}
1801EXPORT_SYMBOL_GPL(alloc_acpi_hp_work);