blob: ba14fb93c92946097bafc866e316c79234ab02f3 [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;
Prarit Bhargava6af8bef2011-09-28 19:40:53 -040087struct workqueue_struct *kacpi_hotplug_wq;
88EXPORT_SYMBOL(kacpi_hotplug_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
Myron Stowe620242a2010-10-21 14:23:53 -060090/*
91 * This list of permanent mappings is for memory that may be accessed from
92 * interrupt context, where we can't do the ioremap().
93 */
94struct acpi_ioremap {
95 struct list_head list;
96 void __iomem *virt;
97 acpi_physical_address phys;
98 acpi_size size;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +010099 unsigned long refcount;
Myron Stowe620242a2010-10-21 14:23:53 -0600100};
101
102static LIST_HEAD(acpi_ioremaps);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100103static DEFINE_MUTEX(acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600104
Lin Mingb0ed7a92010-08-06 09:35:51 +0800105static void __init acpi_osi_setup_late(void);
Len Brownae00d812007-05-29 18:43:33 -0400106
Len Brownd4b7dc42008-01-23 20:50:56 -0500107/*
Len Browna6e08872008-11-08 01:21:10 -0500108 * The story of _OSI(Linux)
Len Brownd4b7dc42008-01-23 20:50:56 -0500109 *
Len Browna6e08872008-11-08 01:21:10 -0500110 * From pre-history through Linux-2.6.22,
111 * Linux responded TRUE upon a BIOS OSI(Linux) query.
Len Brownd4b7dc42008-01-23 20:50:56 -0500112 *
Len Browna6e08872008-11-08 01:21:10 -0500113 * Unfortunately, reference BIOS writers got wind of this
114 * and put OSI(Linux) in their example code, quickly exposing
115 * this string as ill-conceived and opening the door to
116 * an un-bounded number of BIOS incompatibilities.
Len Brownd4b7dc42008-01-23 20:50:56 -0500117 *
Len Browna6e08872008-11-08 01:21:10 -0500118 * For example, OSI(Linux) was used on resume to re-POST a
119 * video card on one system, because Linux at that time
120 * could not do a speedy restore in its native driver.
121 * But then upon gaining quick native restore capability,
122 * Linux has no way to tell the BIOS to skip the time-consuming
123 * POST -- putting Linux at a permanent performance disadvantage.
124 * On another system, the BIOS writer used OSI(Linux)
125 * to infer native OS support for IPMI! On other systems,
126 * OSI(Linux) simply got in the way of Linux claiming to
127 * be compatible with other operating systems, exposing
128 * BIOS issues such as skipped device initialization.
Len Brownd4b7dc42008-01-23 20:50:56 -0500129 *
Len Browna6e08872008-11-08 01:21:10 -0500130 * So "Linux" turned out to be a really poor chose of
131 * OSI string, and from Linux-2.6.23 onward we respond FALSE.
Len Brownd4b7dc42008-01-23 20:50:56 -0500132 *
133 * BIOS writers should NOT query _OSI(Linux) on future systems.
Len Browna6e08872008-11-08 01:21:10 -0500134 * Linux will complain on the console when it sees it, and return FALSE.
135 * To get Linux to return TRUE for your system will require
136 * a kernel source update to add a DMI entry,
137 * or boot with "acpi_osi=Linux"
Len Brownd4b7dc42008-01-23 20:50:56 -0500138 */
Len Brownd4b7dc42008-01-23 20:50:56 -0500139
Adrian Bunk1d15d842008-01-29 00:10:15 +0200140static struct osi_linux {
Len Brownd4b7dc42008-01-23 20:50:56 -0500141 unsigned int enable:1;
142 unsigned int dmi:1;
143 unsigned int cmdline:1;
Lin Mingd90aa922010-12-09 16:50:52 +0800144} osi_linux = {0, 0, 0};
Len Brownf5076542007-05-30 00:10:38 -0400145
Lin Mingb0ed7a92010-08-06 09:35:51 +0800146static u32 acpi_osi_handler(acpi_string interface, u32 supported)
147{
148 if (!strcmp("Linux", interface)) {
149
Len Brown89976212011-08-02 00:45:48 -0400150 printk_once(KERN_NOTICE FW_BUG PREFIX
Lin Mingb0ed7a92010-08-06 09:35:51 +0800151 "BIOS _OSI(Linux) query %s%s\n",
152 osi_linux.enable ? "honored" : "ignored",
153 osi_linux.cmdline ? " via cmdline" :
154 osi_linux.dmi ? " via DMI" : "");
155 }
156
157 return supported;
158}
159
Myron Stowebc9ffce2011-11-07 16:23:27 -0700160static void __init acpi_request_region (struct acpi_generic_address *gas,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700161 unsigned int length, char *desc)
162{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700163 u64 addr;
164
165 /* Handle possible alignment issues */
166 memcpy(&addr, &gas->address, sizeof(addr));
167 if (!addr || !length)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700168 return;
169
Andi Kleencfa806f2010-07-20 15:18:36 -0700170 /* Resources are never freed */
Myron Stowebc9ffce2011-11-07 16:23:27 -0700171 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
172 request_region(addr, length, desc);
173 else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
174 request_mem_region(addr, length, desc);
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700175}
176
177static int __init acpi_reserve_resources(void)
178{
Len Browneee3c852007-02-03 01:38:16 -0500179 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700180 "ACPI PM1a_EVT_BLK");
181
Len Browneee3c852007-02-03 01:38:16 -0500182 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700183 "ACPI PM1b_EVT_BLK");
184
Len Browneee3c852007-02-03 01:38:16 -0500185 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700186 "ACPI PM1a_CNT_BLK");
187
Len Browneee3c852007-02-03 01:38:16 -0500188 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700189 "ACPI PM1b_CNT_BLK");
190
Len Browneee3c852007-02-03 01:38:16 -0500191 if (acpi_gbl_FADT.pm_timer_length == 4)
192 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700193
Len Browneee3c852007-02-03 01:38:16 -0500194 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700195 "ACPI PM2_CNT_BLK");
196
197 /* Length of GPE blocks must be a non-negative multiple of 2 */
198
Len Browneee3c852007-02-03 01:38:16 -0500199 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
200 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
201 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700202
Len Browneee3c852007-02-03 01:38:16 -0500203 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
204 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
205 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700206
207 return 0;
208}
209device_initcall(acpi_reserve_resources);
210
Len Brown4be44fc2005-08-05 00:44:28 -0400211void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
213 va_list args;
214 va_start(args, fmt);
215 acpi_os_vprintf(fmt, args);
216 va_end(args);
217}
Len Brown4be44fc2005-08-05 00:44:28 -0400218
Len Brown4be44fc2005-08-05 00:44:28 -0400219void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220{
221 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 vsprintf(buffer, fmt, args);
224
225#ifdef ENABLE_DEBUGGER
226 if (acpi_in_debugger) {
227 kdb_printf("%s", buffer);
228 } else {
Frank Seidel4d939152009-02-04 17:03:07 +0100229 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 }
231#else
Frank Seidel4d939152009-02-04 17:03:07 +0100232 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233#endif
234}
235
Takao Indoh4996c022011-07-14 18:05:21 -0400236#ifdef CONFIG_KEXEC
237static unsigned long acpi_rsdp;
238static int __init setup_acpi_rsdp(char *arg)
239{
240 acpi_rsdp = simple_strtoul(arg, NULL, 16);
241 return 0;
242}
243early_param("acpi_rsdp", setup_acpi_rsdp);
244#endif
245
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300246acpi_physical_address __init acpi_os_get_root_pointer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
Takao Indoh4996c022011-07-14 18:05:21 -0400248#ifdef CONFIG_KEXEC
249 if (acpi_rsdp)
250 return acpi_rsdp;
251#endif
252
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 if (efi_enabled) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800254 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300255 return efi.acpi20;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800256 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300257 return efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400259 printk(KERN_ERR PREFIX
260 "System description tables not found\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300261 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
Len Brown239665a2007-11-23 20:08:02 -0500263 } else {
264 acpi_physical_address pa = 0;
265
266 acpi_find_root_pointer(&pa);
267 return pa;
268 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269}
270
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600271/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe4a3cba52010-10-21 14:24:14 -0600272static struct acpi_ioremap *
273acpi_map_lookup(acpi_physical_address phys, acpi_size size)
Myron Stowe620242a2010-10-21 14:23:53 -0600274{
275 struct acpi_ioremap *map;
276
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600277 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe620242a2010-10-21 14:23:53 -0600278 if (map->phys <= phys &&
279 phys + size <= map->phys + map->size)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600280 return map;
281
282 return NULL;
283}
284
285/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
286static void __iomem *
287acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
288{
289 struct acpi_ioremap *map;
290
291 map = acpi_map_lookup(phys, size);
292 if (map)
293 return map->virt + (phys - map->phys);
Myron Stowe620242a2010-10-21 14:23:53 -0600294
295 return NULL;
296}
297
Rafael J. Wysocki13606a22011-02-08 23:38:25 +0100298void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
299{
300 struct acpi_ioremap *map;
301 void __iomem *virt = NULL;
302
303 mutex_lock(&acpi_ioremap_lock);
304 map = acpi_map_lookup(phys, size);
305 if (map) {
306 virt = map->virt + (phys - map->phys);
307 map->refcount++;
308 }
309 mutex_unlock(&acpi_ioremap_lock);
310 return virt;
311}
312EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
313
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600314/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe620242a2010-10-21 14:23:53 -0600315static struct acpi_ioremap *
316acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
317{
318 struct acpi_ioremap *map;
319
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600320 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600321 if (map->virt <= virt &&
322 virt + size <= map->virt + map->size)
Myron Stowe620242a2010-10-21 14:23:53 -0600323 return map;
324
325 return NULL;
326}
327
Myron Stoweba242d52012-01-20 19:13:30 -0700328#ifndef CONFIG_IA64
329#define should_use_kmap(pfn) page_is_ram(pfn)
330#else
331/* ioremap will take care of cache attributes */
332#define should_use_kmap(pfn) 0
333#endif
334
335static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
336{
337 unsigned long pfn;
338
339 pfn = pg_off >> PAGE_SHIFT;
340 if (should_use_kmap(pfn)) {
341 if (pg_sz > PAGE_SIZE)
342 return NULL;
343 return (void __iomem __force *)kmap(pfn_to_page(pfn));
344 } else
345 return acpi_os_ioremap(pg_off, pg_sz);
346}
347
348static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
349{
350 unsigned long pfn;
351
352 pfn = pg_off >> PAGE_SHIFT;
Jan Beuliche2526752012-02-24 11:41:53 +0000353 if (should_use_kmap(pfn))
Myron Stoweba242d52012-01-20 19:13:30 -0700354 kunmap(pfn_to_page(pfn));
355 else
356 iounmap(vaddr);
357}
358
Jan Beulich2fdf0742007-12-13 08:33:59 +0000359void __iomem *__init_refok
360acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361{
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100362 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600363 void __iomem *virt;
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100364 acpi_physical_address pg_off;
365 acpi_size pg_sz;
Myron Stowe620242a2010-10-21 14:23:53 -0600366
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800367 if (phys > ULONG_MAX) {
368 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
Randy Dunlap70c08462007-02-13 16:11:36 -0800369 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 }
Myron Stowe620242a2010-10-21 14:23:53 -0600371
372 if (!acpi_gbl_permanent_mmap)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300373 return __acpi_map_table((unsigned long)phys, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600374
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100375 mutex_lock(&acpi_ioremap_lock);
376 /* Check if there's a suitable mapping already. */
377 map = acpi_map_lookup(phys, size);
378 if (map) {
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100379 map->refcount++;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100380 goto out;
381 }
382
Myron Stowe620242a2010-10-21 14:23:53 -0600383 map = kzalloc(sizeof(*map), GFP_KERNEL);
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100384 if (!map) {
385 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600386 return NULL;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100387 }
Myron Stowe620242a2010-10-21 14:23:53 -0600388
Myron Stowe4a3cba52010-10-21 14:24:14 -0600389 pg_off = round_down(phys, PAGE_SIZE);
390 pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
Myron Stoweba242d52012-01-20 19:13:30 -0700391 virt = acpi_map(pg_off, pg_sz);
Myron Stowe620242a2010-10-21 14:23:53 -0600392 if (!virt) {
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100393 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600394 kfree(map);
395 return NULL;
396 }
397
398 INIT_LIST_HEAD(&map->list);
399 map->virt = virt;
Myron Stowe4a3cba52010-10-21 14:24:14 -0600400 map->phys = pg_off;
401 map->size = pg_sz;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100402 map->refcount = 1;
Myron Stowe620242a2010-10-21 14:23:53 -0600403
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600404 list_add_tail_rcu(&map->list, &acpi_ioremaps);
Myron Stowe620242a2010-10-21 14:23:53 -0600405
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100406 out:
407 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600408 return map->virt + (phys - map->phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800410EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100412static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600413{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100414 if (!--map->refcount)
415 list_del_rcu(&map->list);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600416}
Myron Stowe4a3cba52010-10-21 14:24:14 -0600417
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100418static void acpi_os_map_cleanup(struct acpi_ioremap *map)
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100419{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100420 if (!map->refcount) {
421 synchronize_rcu();
Myron Stoweba242d52012-01-20 19:13:30 -0700422 acpi_unmap(map->phys, map->virt);
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100423 kfree(map);
424 }
Myron Stowe4a3cba52010-10-21 14:24:14 -0600425}
426
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800427void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
Myron Stowe620242a2010-10-21 14:23:53 -0600429 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600430
431 if (!acpi_gbl_permanent_mmap) {
Yinghai Lu7d972772009-02-07 15:39:41 -0800432 __acpi_unmap_table(virt, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600433 return;
434 }
435
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100436 mutex_lock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600437 map = acpi_map_lookup_virt(virt, size);
438 if (!map) {
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100439 mutex_unlock(&acpi_ioremap_lock);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100440 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
Myron Stowe620242a2010-10-21 14:23:53 -0600441 return;
442 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100443 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100444 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600445
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100446 acpi_os_map_cleanup(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800448EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800450void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Yinghai Lu7d972772009-02-07 15:39:41 -0800451{
452 if (!acpi_gbl_permanent_mmap)
453 __acpi_unmap_table(virt, size);
454}
455
Myron Stowe6f68c912011-11-07 16:23:34 -0700456int acpi_os_map_generic_address(struct acpi_generic_address *gas)
Myron Stowe29718522010-10-21 14:23:59 -0600457{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700458 u64 addr;
Myron Stowe29718522010-10-21 14:23:59 -0600459 void __iomem *virt;
460
Myron Stowebc9ffce2011-11-07 16:23:27 -0700461 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
Myron Stowe29718522010-10-21 14:23:59 -0600462 return 0;
463
Myron Stowebc9ffce2011-11-07 16:23:27 -0700464 /* Handle possible alignment issues */
465 memcpy(&addr, &gas->address, sizeof(addr));
466 if (!addr || !gas->bit_width)
Myron Stowe29718522010-10-21 14:23:59 -0600467 return -EINVAL;
468
Myron Stowebc9ffce2011-11-07 16:23:27 -0700469 virt = acpi_os_map_memory(addr, gas->bit_width / 8);
Myron Stowe29718522010-10-21 14:23:59 -0600470 if (!virt)
471 return -EIO;
472
473 return 0;
474}
Myron Stowe6f68c912011-11-07 16:23:34 -0700475EXPORT_SYMBOL(acpi_os_map_generic_address);
Myron Stowe29718522010-10-21 14:23:59 -0600476
Myron Stowe6f68c912011-11-07 16:23:34 -0700477void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
Myron Stowe29718522010-10-21 14:23:59 -0600478{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700479 u64 addr;
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100480 struct acpi_ioremap *map;
Myron Stowe29718522010-10-21 14:23:59 -0600481
Myron Stowebc9ffce2011-11-07 16:23:27 -0700482 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
Myron Stowe29718522010-10-21 14:23:59 -0600483 return;
484
Myron Stowebc9ffce2011-11-07 16:23:27 -0700485 /* Handle possible alignment issues */
486 memcpy(&addr, &gas->address, sizeof(addr));
487 if (!addr || !gas->bit_width)
Myron Stowe29718522010-10-21 14:23:59 -0600488 return;
489
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100490 mutex_lock(&acpi_ioremap_lock);
Myron Stowebc9ffce2011-11-07 16:23:27 -0700491 map = acpi_map_lookup(addr, gas->bit_width / 8);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100492 if (!map) {
493 mutex_unlock(&acpi_ioremap_lock);
494 return;
495 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100496 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100497 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe29718522010-10-21 14:23:59 -0600498
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100499 acpi_os_map_cleanup(map);
Myron Stowe29718522010-10-21 14:23:59 -0600500}
Myron Stowe6f68c912011-11-07 16:23:34 -0700501EXPORT_SYMBOL(acpi_os_unmap_generic_address);
Myron Stowe29718522010-10-21 14:23:59 -0600502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503#ifdef ACPI_FUTURE_USAGE
504acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400505acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506{
Len Brown4be44fc2005-08-05 00:44:28 -0400507 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 return AE_BAD_PARAMETER;
509
510 *phys = virt_to_phys(virt);
511
512 return AE_OK;
513}
514#endif
515
516#define ACPI_MAX_OVERRIDE_LEN 100
517
518static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
519
520acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400521acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
522 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523{
524 if (!init_val || !new_val)
525 return AE_BAD_PARAMETER;
526
527 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400528 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400530 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 *new_val = acpi_os_name;
532 }
533
534 return AE_OK;
535}
536
537acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400538acpi_os_table_override(struct acpi_table_header * existing_table,
539 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540{
541 if (!existing_table || !new_table)
542 return AE_BAD_PARAMETER;
543
Markus Gaugusch71fc47a2008-02-05 00:04:06 +0100544 *new_table = NULL;
545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546#ifdef CONFIG_ACPI_CUSTOM_DSDT
547 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400548 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549#endif
Éric Piel6ed31e92008-02-05 00:04:50 +0100550 if (*new_table != NULL) {
551 printk(KERN_WARNING PREFIX "Override [%4.4s-%8.8s], "
552 "this is unsafe: tainting kernel\n",
553 existing_table->signature,
554 existing_table->oem_table_id);
555 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
556 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return AE_OK;
558}
559
Bob Mooref7b004a2012-02-14 18:31:56 +0800560acpi_status
561acpi_os_physical_table_override(struct acpi_table_header *existing_table,
562 acpi_physical_address * new_address,
563 u32 *new_table_length)
564{
565 return AE_SUPPORT;
566}
567
568
David Howells7d12e782006-10-05 14:55:46 +0100569static irqreturn_t acpi_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
Len Brown5229e872008-02-06 01:26:55 -0500571 u32 handled;
572
573 handled = (*acpi_irq_handler) (acpi_irq_context);
574
575 if (handled) {
576 acpi_irq_handled++;
577 return IRQ_HANDLED;
Len Brown88bea182009-04-21 00:35:47 -0400578 } else {
579 acpi_irq_not_handled++;
Len Brown5229e872008-02-06 01:26:55 -0500580 return IRQ_NONE;
Len Brown88bea182009-04-21 00:35:47 -0400581 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
584acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400585acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
586 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 unsigned int irq;
589
Len Brown5229e872008-02-06 01:26:55 -0500590 acpi_irq_stats_init();
591
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 /*
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100593 * ACPI interrupts different from the SCI in our copy of the FADT are
594 * not supported.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 */
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100596 if (gsi != acpi_gbl_FADT.sci_interrupt)
597 return AE_BAD_PARAMETER;
598
599 if (acpi_irq_handler)
600 return AE_ALREADY_ACQUIRED;
601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
603 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
604 gsi);
605 return AE_OK;
606 }
607
608 acpi_irq_handler = handler;
609 acpi_irq_context = context;
Andi Kleen6fe0d062012-02-06 08:17:09 -0800610 if (request_threaded_irq(irq, NULL, acpi_irq, IRQF_SHARED, "acpi",
611 acpi_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100613 acpi_irq_handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return AE_NOT_ACQUIRED;
615 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617 return AE_OK;
618}
619
Len Brown4be44fc2005-08-05 00:44:28 -0400620acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621{
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100622 if (irq != acpi_gbl_FADT.sci_interrupt)
623 return AE_BAD_PARAMETER;
624
625 free_irq(irq, acpi_irq);
626 acpi_irq_handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 return AE_OK;
629}
630
631/*
632 * Running in interpreter thread context, safe to sleep
633 */
634
Lin Ming439913f2010-01-28 10:53:19 +0800635void acpi_os_sleep(u64 ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636{
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800637 schedule_timeout_interruptible(msecs_to_jiffies(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638}
Len Brown4be44fc2005-08-05 00:44:28 -0400639
Len Brown4be44fc2005-08-05 00:44:28 -0400640void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641{
642 while (us) {
643 u32 delay = 1000;
644
645 if (delay > us)
646 delay = us;
647 udelay(delay);
648 touch_nmi_watchdog();
649 us -= delay;
650 }
651}
Len Brown4be44fc2005-08-05 00:44:28 -0400652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653/*
654 * Support ACPI 3.0 AML Timer operand
655 * Returns 64-bit free-running, monotonically increasing timer
656 * with 100ns granularity
657 */
Len Brown4be44fc2005-08-05 00:44:28 -0400658u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
660 static u64 t;
661
662#ifdef CONFIG_HPET
663 /* TBD: use HPET if available */
664#endif
665
666#ifdef CONFIG_X86_PM_TIMER
667 /* TBD: default to PM timer if HPET was not available */
668#endif
669 if (!t)
670 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
671
672 return ++t;
673}
674
Len Brown4be44fc2005-08-05 00:44:28 -0400675acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
677 u32 dummy;
678
679 if (!value)
680 value = &dummy;
681
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800682 *value = 0;
683 if (width <= 8) {
Len Brown4be44fc2005-08-05 00:44:28 -0400684 *(u8 *) value = inb(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800685 } else if (width <= 16) {
Len Brown4be44fc2005-08-05 00:44:28 -0400686 *(u16 *) value = inw(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800687 } else if (width <= 32) {
Len Brown4be44fc2005-08-05 00:44:28 -0400688 *(u32 *) value = inl(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800689 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 BUG();
691 }
692
693 return AE_OK;
694}
Len Brown4be44fc2005-08-05 00:44:28 -0400695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696EXPORT_SYMBOL(acpi_os_read_port);
697
Len Brown4be44fc2005-08-05 00:44:28 -0400698acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699{
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800700 if (width <= 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 outb(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800702 } else if (width <= 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 outw(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800704 } else if (width <= 32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 outl(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800706 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 BUG();
708 }
709
710 return AE_OK;
711}
Len Brown4be44fc2005-08-05 00:44:28 -0400712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713EXPORT_SYMBOL(acpi_os_write_port);
714
Myron Stowee615bf52012-01-20 19:13:24 -0700715#ifdef readq
716static inline u64 read64(const volatile void __iomem *addr)
717{
718 return readq(addr);
719}
720#else
721static inline u64 read64(const volatile void __iomem *addr)
722{
723 u64 l, h;
724 l = readl(addr);
725 h = readl(addr+4);
726 return l | (h << 32);
727}
728#endif
729
730acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800731acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700732{
733 void __iomem *virt_addr;
734 unsigned int size = width / 8;
735 bool unmap = false;
736 u64 dummy;
737
738 rcu_read_lock();
739 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
740 if (!virt_addr) {
741 rcu_read_unlock();
742 virt_addr = acpi_os_ioremap(phys_addr, size);
743 if (!virt_addr)
744 return AE_BAD_ADDRESS;
745 unmap = true;
746 }
747
748 if (!value)
749 value = &dummy;
750
751 switch (width) {
752 case 8:
753 *(u8 *) value = readb(virt_addr);
754 break;
755 case 16:
756 *(u16 *) value = readw(virt_addr);
757 break;
758 case 32:
759 *(u32 *) value = readl(virt_addr);
760 break;
761 case 64:
762 *(u64 *) value = read64(virt_addr);
763 break;
764 default:
765 BUG();
766 }
767
768 if (unmap)
769 iounmap(virt_addr);
770 else
771 rcu_read_unlock();
772
773 return AE_OK;
774}
775
Myron Stowee615bf52012-01-20 19:13:24 -0700776#ifdef writeq
777static inline void write64(u64 val, volatile void __iomem *addr)
778{
779 writeq(val, addr);
780}
781#else
782static inline void write64(u64 val, volatile void __iomem *addr)
783{
784 writel(val, addr);
785 writel(val>>32, addr+4);
786}
787#endif
788
789acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800790acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700791{
792 void __iomem *virt_addr;
793 unsigned int size = width / 8;
794 bool unmap = false;
795
796 rcu_read_lock();
797 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
798 if (!virt_addr) {
799 rcu_read_unlock();
800 virt_addr = acpi_os_ioremap(phys_addr, size);
801 if (!virt_addr)
802 return AE_BAD_ADDRESS;
803 unmap = true;
804 }
805
806 switch (width) {
807 case 8:
808 writeb(value, virt_addr);
809 break;
810 case 16:
811 writew(value, virt_addr);
812 break;
813 case 32:
814 writel(value, virt_addr);
815 break;
816 case 64:
817 write64(value, virt_addr);
818 break;
819 default:
820 BUG();
821 }
822
823 if (unmap)
824 iounmap(virt_addr);
825 else
826 rcu_read_unlock();
827
828 return AE_OK;
829}
830
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400832acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Bob Moorec5f02312010-08-06 08:57:53 +0800833 u64 *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
835 int result, size;
Bob Moorec5f02312010-08-06 08:57:53 +0800836 u32 value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 if (!value)
839 return AE_BAD_PARAMETER;
840
841 switch (width) {
842 case 8:
843 size = 1;
844 break;
845 case 16:
846 size = 2;
847 break;
848 case 32:
849 size = 4;
850 break;
851 default:
852 return AE_ERROR;
853 }
854
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500855 result = raw_pci_read(pci_id->segment, pci_id->bus,
856 PCI_DEVFN(pci_id->device, pci_id->function),
Bob Moorec5f02312010-08-06 08:57:53 +0800857 reg, size, &value32);
858 *value = value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 return (result ? AE_ERROR : AE_OK);
861}
Len Brown4be44fc2005-08-05 00:44:28 -0400862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400864acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Lin Ming439913f2010-01-28 10:53:19 +0800865 u64 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866{
867 int result, size;
868
869 switch (width) {
870 case 8:
871 size = 1;
872 break;
873 case 16:
874 size = 2;
875 break;
876 case 32:
877 size = 4;
878 break;
879 default:
880 return AE_ERROR;
881 }
882
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500883 result = raw_pci_write(pci_id->segment, pci_id->bus,
884 PCI_DEVFN(pci_id->device, pci_id->function),
885 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 return (result ? AE_ERROR : AE_OK);
888}
889
David Howells65f27f32006-11-22 14:55:48 +0000890static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891{
David Howells65f27f32006-11-22 14:55:48 +0000892 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -0400893
Bjorn Helgaas9ac61852009-08-31 22:32:10 +0000894 if (dpc->wait)
895 acpi_os_wait_events_complete(NULL);
Zhang Rui19cd8472008-08-28 10:05:06 +0800896
897 dpc->function(dpc->context);
898 kfree(dpc);
Zhang Rui19cd8472008-08-28 10:05:06 +0800899}
900
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400901/*******************************************************************************
902 *
903 * FUNCTION: acpi_os_execute
904 *
905 * PARAMETERS: Type - Type of the callback
906 * Function - Function to be executed
907 * Context - Function parameters
908 *
909 * RETURN: Status
910 *
911 * DESCRIPTION: Depending on type, either queues function for deferred execution or
912 * immediately executes function on a separate thread.
913 *
914 ******************************************************************************/
915
Zhang Rui19cd8472008-08-28 10:05:06 +0800916static acpi_status __acpi_os_execute(acpi_execute_type type,
917 acpi_osd_exec_callback function, void *context, int hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918{
Len Brown4be44fc2005-08-05 00:44:28 -0400919 acpi_status status = AE_OK;
920 struct acpi_os_dpc *dpc;
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300921 struct workqueue_struct *queue;
Zhang Rui19cd8472008-08-28 10:05:06 +0800922 int ret;
Len Brown72945b22006-07-12 22:46:42 -0400923 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
924 "Scheduling function [%p(%p)] for deferred execution.\n",
925 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 /*
928 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +0000929 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 * way that allows us to also free its memory inside the callee.
931 * Because we may want to schedule several tasks with different
932 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +0000933 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 */
Len Brown72945b22006-07-12 22:46:42 -0400935
David Howells65f27f32006-11-22 14:55:48 +0000936 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (!dpc)
Lin Ming889c78b2008-12-31 09:23:57 +0800938 return AE_NO_MEMORY;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800939
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 dpc->function = function;
941 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800942
Zhang Ruic02256b2009-06-23 10:20:29 +0800943 /*
944 * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
945 * because the hotplug code may call driver .remove() functions,
946 * which invoke flush_scheduled_work/acpi_os_wait_events_complete
947 * to flush these workqueues.
948 */
949 queue = hp ? kacpi_hotplug_wq :
950 (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
Bjorn Helgaas9ac61852009-08-31 22:32:10 +0000951 dpc->wait = hp ? 1 : 0;
Zhang Ruibc736752010-03-22 15:48:54 +0800952
953 if (queue == kacpi_hotplug_wq)
954 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
955 else if (queue == kacpi_notify_wq)
956 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
957 else
958 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
959
Tejun Heo8fec62b2010-06-29 10:07:09 +0200960 /*
961 * On some machines, a software-initiated SMI causes corruption unless
962 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
963 * typically it's done in GPE-related methods that are run via
964 * workqueues, so we can avoid the known corruption cases by always
965 * queueing on CPU 0.
966 */
967 ret = queue_work_on(0, queue, &dpc->work);
Zhang Rui19cd8472008-08-28 10:05:06 +0800968
969 if (!ret) {
Lin Ming55ac9a02008-09-28 14:51:56 +0800970 printk(KERN_ERR PREFIX
971 "Call to queue_work() failed.\n");
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300972 status = AE_ERROR;
973 kfree(dpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
Lin Ming889c78b2008-12-31 09:23:57 +0800975 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976}
Len Brown4be44fc2005-08-05 00:44:28 -0400977
Zhang Rui19cd8472008-08-28 10:05:06 +0800978acpi_status acpi_os_execute(acpi_execute_type type,
979 acpi_osd_exec_callback function, void *context)
980{
981 return __acpi_os_execute(type, function, context, 0);
982}
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400983EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Zhang Rui19cd8472008-08-28 10:05:06 +0800985acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
986 void *context)
987{
988 return __acpi_os_execute(0, function, context, 1);
989}
990
Len Brown4be44fc2005-08-05 00:44:28 -0400991void acpi_os_wait_events_complete(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992{
993 flush_workqueue(kacpid_wq);
Zhang Rui2f67a062008-04-29 02:34:42 -0400994 flush_workqueue(kacpi_notify_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995}
Len Brown4be44fc2005-08-05 00:44:28 -0400996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997EXPORT_SYMBOL(acpi_os_wait_events_complete);
998
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001000acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
Len Brown4be44fc2005-08-05 00:44:28 -04001002 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 sem = acpi_os_allocate(sizeof(struct semaphore));
1005 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001006 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 memset(sem, 0, sizeof(struct semaphore));
1008
1009 sema_init(sem, initial_units);
1010
Len Brown4be44fc2005-08-05 00:44:28 -04001011 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
Len Brown4be44fc2005-08-05 00:44:28 -04001013 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1014 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
Patrick Mocheld550d982006-06-27 00:41:40 -04001016 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019/*
1020 * TODO: A better way to delete semaphores? Linux doesn't have a
1021 * 'delete_semaphore()' function -- may result in an invalid
1022 * pointer dereference for non-synchronized consumers. Should
1023 * we at least check for blocked threads and signal/cancel them?
1024 */
1025
Len Brown4be44fc2005-08-05 00:44:28 -04001026acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027{
Len Brown4be44fc2005-08-05 00:44:28 -04001028 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001031 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032
Len Brown4be44fc2005-08-05 00:44:28 -04001033 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001035 BUG_ON(!list_empty(&sem->wait_list));
Len Brown02438d82006-06-30 03:19:10 -04001036 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -04001037 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
Patrick Mocheld550d982006-06-27 00:41:40 -04001039 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 * TODO: Support for units > 1?
1044 */
Len Brown4be44fc2005-08-05 00:44:28 -04001045acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046{
Len Brown4be44fc2005-08-05 00:44:28 -04001047 acpi_status status = AE_OK;
1048 struct semaphore *sem = (struct semaphore *)handle;
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001049 long jiffies;
Len Brown4be44fc2005-08-05 00:44:28 -04001050 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001053 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054
1055 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001056 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Len Brown4be44fc2005-08-05 00:44:28 -04001058 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1059 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001061 if (timeout == ACPI_WAIT_FOREVER)
1062 jiffies = MAX_SCHEDULE_TIMEOUT;
1063 else
1064 jiffies = msecs_to_jiffies(timeout);
1065
1066 ret = down_timeout(sem, jiffies);
1067 if (ret)
1068 status = AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069
1070 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -04001071 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001072 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -04001073 handle, units, timeout,
1074 acpi_format_exception(status)));
1075 } else {
1076 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001077 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001078 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
1080
Patrick Mocheld550d982006-06-27 00:41:40 -04001081 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084/*
1085 * TODO: Support for units > 1?
1086 */
Len Brown4be44fc2005-08-05 00:44:28 -04001087acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088{
Len Brown4be44fc2005-08-05 00:44:28 -04001089 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001092 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
1094 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001095 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096
Len Brown4be44fc2005-08-05 00:44:28 -04001097 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1098 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
1100 up(sem);
1101
Patrick Mocheld550d982006-06-27 00:41:40 -04001102 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103}
Len Brown4be44fc2005-08-05 00:44:28 -04001104
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -04001106u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107{
1108
1109#ifdef ENABLE_DEBUGGER
1110 if (acpi_in_debugger) {
1111 u32 chars;
1112
1113 kdb_read(buffer, sizeof(line_buf));
1114
1115 /* remove the CR kdb includes */
1116 chars = strlen(buffer) - 1;
1117 buffer[chars] = '\0';
1118 }
1119#endif
1120
1121 return 0;
1122}
Len Brown4be44fc2005-08-05 00:44:28 -04001123#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
Len Brown4be44fc2005-08-05 00:44:28 -04001125acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126{
Len Brown4be44fc2005-08-05 00:44:28 -04001127 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 case ACPI_SIGNAL_FATAL:
1129 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1130 break;
1131 case ACPI_SIGNAL_BREAKPOINT:
1132 /*
1133 * AML Breakpoint
1134 * ACPI spec. says to treat it as a NOP unless
1135 * you are debugging. So if/when we integrate
1136 * AML debugger into the kernel debugger its
1137 * hook will go here. But until then it is
1138 * not useful to print anything on breakpoints.
1139 */
1140 break;
1141 default:
1142 break;
1143 }
1144
1145 return AE_OK;
1146}
Len Brown4be44fc2005-08-05 00:44:28 -04001147
Len Brown4be44fc2005-08-05 00:44:28 -04001148static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149{
1150 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -04001151 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
1153 if (!str || !*str)
1154 return 0;
1155
1156 for (; count-- && str && *str; str++) {
1157 if (isalnum(*str) || *str == ' ' || *str == ':')
1158 *p++ = *str;
1159 else if (*str == '\'' || *str == '"')
1160 continue;
1161 else
1162 break;
1163 }
1164 *p = 0;
1165
1166 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -04001167
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168}
1169
1170__setup("acpi_os_name=", acpi_os_name_setup);
1171
Lin Ming12d32062010-12-09 16:51:06 +08001172#define OSI_STRING_LENGTH_MAX 64 /* arbitrary */
1173#define OSI_STRING_ENTRIES_MAX 16 /* arbitrary */
1174
1175struct osi_setup_entry {
1176 char string[OSI_STRING_LENGTH_MAX];
1177 bool enable;
1178};
1179
Shaohua Liaa165972011-07-28 13:48:43 -07001180static struct osi_setup_entry __initdata
1181 osi_setup_entries[OSI_STRING_ENTRIES_MAX] = {
1182 {"Module Device", true},
1183 {"Processor Device", true},
1184 {"3.0 _SCP Extensions", true},
1185 {"Processor Aggregator Device", true},
1186};
Lin Ming12d32062010-12-09 16:51:06 +08001187
Lin Mingd90aa922010-12-09 16:50:52 +08001188void __init acpi_osi_setup(char *str)
1189{
Lin Ming12d32062010-12-09 16:51:06 +08001190 struct osi_setup_entry *osi;
1191 bool enable = true;
1192 int i;
1193
Lin Mingd90aa922010-12-09 16:50:52 +08001194 if (!acpi_gbl_create_osi_method)
1195 return;
1196
1197 if (str == NULL || *str == '\0') {
1198 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1199 acpi_gbl_create_osi_method = FALSE;
Lin Ming12d32062010-12-09 16:51:06 +08001200 return;
1201 }
1202
1203 if (*str == '!') {
1204 str++;
1205 enable = false;
1206 }
1207
1208 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1209 osi = &osi_setup_entries[i];
1210 if (!strcmp(osi->string, str)) {
1211 osi->enable = enable;
1212 break;
1213 } else if (osi->string[0] == '\0') {
1214 osi->enable = enable;
1215 strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1216 break;
1217 }
1218 }
Lin Mingd90aa922010-12-09 16:50:52 +08001219}
1220
Len Brownd4b7dc42008-01-23 20:50:56 -05001221static void __init set_osi_linux(unsigned int enable)
1222{
Lin Mingd90aa922010-12-09 16:50:52 +08001223 if (osi_linux.enable != enable)
Len Brownd4b7dc42008-01-23 20:50:56 -05001224 osi_linux.enable = enable;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001225
1226 if (osi_linux.enable)
1227 acpi_osi_setup("Linux");
1228 else
1229 acpi_osi_setup("!Linux");
1230
Len Brownd4b7dc42008-01-23 20:50:56 -05001231 return;
1232}
Len Brownf5076542007-05-30 00:10:38 -04001233
Len Brownd4b7dc42008-01-23 20:50:56 -05001234static void __init acpi_cmdline_osi_linux(unsigned int enable)
1235{
Lin Mingd90aa922010-12-09 16:50:52 +08001236 osi_linux.cmdline = 1; /* cmdline set the default and override DMI */
1237 osi_linux.dmi = 0;
Len Brownd4b7dc42008-01-23 20:50:56 -05001238 set_osi_linux(enable);
Len Brownf5076542007-05-30 00:10:38 -04001239
Len Brownd4b7dc42008-01-23 20:50:56 -05001240 return;
1241}
1242
1243void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1244{
Len Brownd4b7dc42008-01-23 20:50:56 -05001245 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1246
1247 if (enable == -1)
1248 return;
1249
Lin Mingd90aa922010-12-09 16:50:52 +08001250 osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) */
Len Brownd4b7dc42008-01-23 20:50:56 -05001251 set_osi_linux(enable);
1252
Len Brownf5076542007-05-30 00:10:38 -04001253 return;
1254}
1255
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256/*
Len Brownae00d812007-05-29 18:43:33 -04001257 * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1258 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 * empty string disables _OSI
Len Brownae00d812007-05-29 18:43:33 -04001260 * string starting with '!' disables that string
1261 * otherwise string is added to list, augmenting built-in strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 */
Lin Mingb0ed7a92010-08-06 09:35:51 +08001263static void __init acpi_osi_setup_late(void)
1264{
Lin Ming12d32062010-12-09 16:51:06 +08001265 struct osi_setup_entry *osi;
1266 char *str;
1267 int i;
Lin Mingd90aa922010-12-09 16:50:52 +08001268 acpi_status status;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001269
Lin Ming12d32062010-12-09 16:51:06 +08001270 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1271 osi = &osi_setup_entries[i];
1272 str = osi->string;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001273
Lin Ming12d32062010-12-09 16:51:06 +08001274 if (*str == '\0')
1275 break;
1276 if (osi->enable) {
1277 status = acpi_install_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001278
Lin Ming12d32062010-12-09 16:51:06 +08001279 if (ACPI_SUCCESS(status))
1280 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1281 } else {
1282 status = acpi_remove_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001283
Lin Ming12d32062010-12-09 16:51:06 +08001284 if (ACPI_SUCCESS(status))
1285 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1286 }
Lin Mingb0ed7a92010-08-06 09:35:51 +08001287 }
1288}
1289
Lin Mingd90aa922010-12-09 16:50:52 +08001290static int __init osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291{
Lin Mingd90aa922010-12-09 16:50:52 +08001292 if (str && !strcmp("Linux", str))
1293 acpi_cmdline_osi_linux(1);
1294 else if (str && !strcmp("!Linux", str))
1295 acpi_cmdline_osi_linux(0);
1296 else
1297 acpi_osi_setup(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298
1299 return 1;
1300}
1301
Lin Mingd90aa922010-12-09 16:50:52 +08001302__setup("acpi_osi=", osi_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
1304/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -04001305static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306{
1307 printk(KERN_INFO PREFIX "serialize enabled\n");
1308
1309 acpi_gbl_all_methods_serialized = TRUE;
1310
1311 return 1;
1312}
1313
1314__setup("acpi_serialize", acpi_serialize_setup);
1315
Thomas Renningerdf92e692008-02-04 23:31:22 -08001316/* Check of resource interference between native drivers and ACPI
1317 * OperationRegions (SystemIO and System Memory only).
1318 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1319 * in arbitrary AML code and can interfere with legacy drivers.
1320 * acpi_enforce_resources= can be set to:
1321 *
Luca Tettamanti7e905602009-03-30 00:01:27 +02001322 * - strict (default) (2)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001323 * -> further driver trying to access the resources will not load
Luca Tettamanti7e905602009-03-30 00:01:27 +02001324 * - lax (1)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001325 * -> further driver trying to access the resources will load, but you
1326 * get a system message that something might go wrong...
1327 *
1328 * - no (0)
1329 * -> ACPI Operation Region resources will not be registered
1330 *
1331 */
1332#define ENFORCE_RESOURCES_STRICT 2
1333#define ENFORCE_RESOURCES_LAX 1
1334#define ENFORCE_RESOURCES_NO 0
1335
Luca Tettamanti7e905602009-03-30 00:01:27 +02001336static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001337
1338static int __init acpi_enforce_resources_setup(char *str)
1339{
1340 if (str == NULL || *str == '\0')
1341 return 0;
1342
1343 if (!strcmp("strict", str))
1344 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1345 else if (!strcmp("lax", str))
1346 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1347 else if (!strcmp("no", str))
1348 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1349
1350 return 1;
1351}
1352
1353__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1354
1355/* Check for resource conflicts between ACPI OperationRegions and native
1356 * drivers */
Jean Delvare876fba42009-11-11 15:22:15 +01001357int acpi_check_resource_conflict(const struct resource *res)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001358{
Lin Mingf654c0f2012-01-12 13:10:32 +08001359 acpi_adr_space_type space_id;
1360 acpi_size length;
1361 u8 warn = 0;
1362 int clash = 0;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001363
1364 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1365 return 0;
1366 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1367 return 0;
1368
Lin Mingf654c0f2012-01-12 13:10:32 +08001369 if (res->flags & IORESOURCE_IO)
1370 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1371 else
1372 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001373
Lin Mingf654c0f2012-01-12 13:10:32 +08001374 length = res->end - res->start + 1;
1375 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1376 warn = 1;
1377 clash = acpi_check_address_range(space_id, res->start, length, warn);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001378
1379 if (clash) {
1380 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
Jean Delvare14f03342009-09-08 15:31:46 +02001381 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1382 printk(KERN_NOTICE "ACPI: This conflict may"
1383 " cause random problems and system"
1384 " instability\n");
1385 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1386 " for this device, you should use it instead of"
1387 " the native driver\n");
Thomas Renningerdf92e692008-02-04 23:31:22 -08001388 }
1389 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1390 return -EBUSY;
1391 }
1392 return 0;
1393}
Thomas Renninger443dea72008-02-04 23:31:23 -08001394EXPORT_SYMBOL(acpi_check_resource_conflict);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001395
1396int acpi_check_region(resource_size_t start, resource_size_t n,
1397 const char *name)
1398{
1399 struct resource res = {
1400 .start = start,
1401 .end = start + n - 1,
1402 .name = name,
1403 .flags = IORESOURCE_IO,
1404 };
1405
1406 return acpi_check_resource_conflict(&res);
1407}
1408EXPORT_SYMBOL(acpi_check_region);
1409
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410/*
Jean Delvare70dd6be2010-05-27 19:58:37 +02001411 * Let drivers know whether the resource checks are effective
1412 */
1413int acpi_resources_are_enforced(void)
1414{
1415 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1416}
1417EXPORT_SYMBOL(acpi_resources_are_enforced);
1418
1419/*
Lin Ming9f63b882011-03-23 17:26:34 +08001420 * Deallocate the memory for a spinlock.
1421 */
1422void acpi_os_delete_lock(acpi_spinlock handle)
1423{
1424 ACPI_FREE(handle);
1425}
1426
1427/*
Robert Moore73459f72005-06-24 00:00:00 -04001428 * Acquire a spinlock.
1429 *
1430 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001431 */
1432
Bob Moore967440e32006-06-23 17:04:00 -04001433acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001434{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001435 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001436 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001437 return flags;
1438}
1439
1440/*
1441 * Release a spinlock. See above.
1442 */
1443
Bob Moore967440e32006-06-23 17:04:00 -04001444void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001445{
Bob Moore967440e32006-06-23 17:04:00 -04001446 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001447}
1448
Robert Moore73459f72005-06-24 00:00:00 -04001449#ifndef ACPI_USE_LOCAL_CACHE
1450
1451/*******************************************************************************
1452 *
1453 * FUNCTION: acpi_os_create_cache
1454 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001455 * PARAMETERS: name - Ascii name for the cache
1456 * size - Size of each cached object
1457 * depth - Maximum depth of the cache (in objects) <ignored>
1458 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001459 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001460 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001461 *
1462 * DESCRIPTION: Create a cache object
1463 *
1464 ******************************************************************************/
1465
1466acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001467acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001468{
Paul Mundt20c2df82007-07-20 10:11:58 +09001469 *cache = kmem_cache_create(name, size, 0, 0, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001470 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001471 return AE_ERROR;
1472 else
1473 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001474}
1475
1476/*******************************************************************************
1477 *
1478 * FUNCTION: acpi_os_purge_cache
1479 *
1480 * PARAMETERS: Cache - Handle to cache object
1481 *
1482 * RETURN: Status
1483 *
1484 * DESCRIPTION: Free all objects within the requested cache.
1485 *
1486 ******************************************************************************/
1487
Len Brown4be44fc2005-08-05 00:44:28 -04001488acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001489{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001490 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001491 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001492}
1493
1494/*******************************************************************************
1495 *
1496 * FUNCTION: acpi_os_delete_cache
1497 *
1498 * PARAMETERS: Cache - Handle to cache object
1499 *
1500 * RETURN: Status
1501 *
1502 * DESCRIPTION: Free all objects within the requested cache and delete the
1503 * cache object.
1504 *
1505 ******************************************************************************/
1506
Len Brown4be44fc2005-08-05 00:44:28 -04001507acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001508{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001509 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001510 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001511}
1512
1513/*******************************************************************************
1514 *
1515 * FUNCTION: acpi_os_release_object
1516 *
1517 * PARAMETERS: Cache - Handle to cache object
1518 * Object - The object to be released
1519 *
1520 * RETURN: None
1521 *
1522 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1523 * the object is deleted.
1524 *
1525 ******************************************************************************/
1526
Len Brown4be44fc2005-08-05 00:44:28 -04001527acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001528{
Len Brown4be44fc2005-08-05 00:44:28 -04001529 kmem_cache_free(cache, object);
1530 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001531}
Robert Moore73459f72005-06-24 00:00:00 -04001532#endif
Myron Stowed362eda2010-10-21 14:24:04 -06001533
1534acpi_status __init acpi_os_initialize(void)
1535{
1536 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1537 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1538 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1539 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1540
1541 return AE_OK;
1542}
1543
Zhang Rui32d47ee2010-12-08 10:40:36 +08001544acpi_status __init acpi_os_initialize1(void)
Myron Stowed362eda2010-10-21 14:24:04 -06001545{
Tejun Heo44d25882011-02-01 11:42:42 +01001546 kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1547 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
1548 kacpi_hotplug_wq = alloc_workqueue("kacpi_hotplug", 0, 1);
Myron Stowed362eda2010-10-21 14:24:04 -06001549 BUG_ON(!kacpid_wq);
1550 BUG_ON(!kacpi_notify_wq);
1551 BUG_ON(!kacpi_hotplug_wq);
Len Brown1bd64d42010-10-26 14:50:56 -04001552 acpi_install_interface_handler(acpi_osi_handler);
1553 acpi_osi_setup_late();
Myron Stowed362eda2010-10-21 14:24:04 -06001554 return AE_OK;
1555}
1556
1557acpi_status acpi_os_terminate(void)
1558{
1559 if (acpi_irq_handler) {
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +01001560 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
Myron Stowed362eda2010-10-21 14:24:04 -06001561 acpi_irq_handler);
1562 }
1563
1564 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1565 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1566 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1567 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1568
1569 destroy_workqueue(kacpid_wq);
1570 destroy_workqueue(kacpi_notify_wq);
1571 destroy_workqueue(kacpi_hotplug_wq);
1572
1573 return AE_OK;
1574}
Tang Liang09f98a82011-12-09 10:05:54 +08001575
1576acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1577 u32 pm1b_control)
1578{
1579 int rc = 0;
1580 if (__acpi_os_prepare_sleep)
1581 rc = __acpi_os_prepare_sleep(sleep_state,
1582 pm1a_control, pm1b_control);
1583 if (rc < 0)
1584 return AE_ERROR;
1585 else if (rc > 0)
1586 return AE_CTRL_SKIP;
1587
1588 return AE_OK;
1589}
1590
1591void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1592 u32 pm1a_ctrl, u32 pm1b_ctrl))
1593{
1594 __acpi_os_prepare_sleep = func;
1595}