blob: 5389f9f2e2ffdca44ece2502147a231bcf8c3dec [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>
34#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/interrupt.h>
36#include <linux/kmod.h>
37#include <linux/delay.h>
38#include <linux/workqueue.h>
39#include <linux/nmi.h>
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +030040#include <linux/acpi.h>
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +010041#include <linux/acpi_io.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/efi.h>
Thomas Renningerdf92e692008-02-04 23:31:22 -080043#include <linux/ioport.h>
44#include <linux/list.h>
Matthew Wilcoxf1241c82008-03-14 13:43:13 -040045#include <linux/jiffies.h>
46#include <linux/semaphore.h>
47
48#include <asm/io.h>
49#include <asm/uaccess.h>
50
51#include <acpi/acpi.h>
52#include <acpi/acpi_bus.h>
53#include <acpi/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#define _COMPONENT ACPI_OS_SERVICES
Len Brownf52fd662007-02-12 22:42:12 -050056ACPI_MODULE_NAME("osl");
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#define PREFIX "ACPI: "
Len Brown4be44fc2005-08-05 00:44:28 -040058struct acpi_os_dpc {
59 acpi_osd_exec_callback function;
60 void *context;
David Howells65f27f32006-11-22 14:55:48 +000061 struct work_struct work;
Bjorn Helgaas9ac61852009-08-31 22:32:10 +000062 int wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063};
64
65#ifdef CONFIG_ACPI_CUSTOM_DSDT
66#include CONFIG_ACPI_CUSTOM_DSDT_FILE
67#endif
68
69#ifdef ENABLE_DEBUGGER
70#include <linux/kdb.h>
71
72/* stuff for debugger support */
73int acpi_in_debugger;
74EXPORT_SYMBOL(acpi_in_debugger);
75
76extern char line_buf[80];
Len Brown4be44fc2005-08-05 00:44:28 -040077#endif /*ENABLE_DEBUGGER */
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79static unsigned int acpi_irq_irq;
80static acpi_osd_handler acpi_irq_handler;
81static void *acpi_irq_context;
82static struct workqueue_struct *kacpid_wq;
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -040083static struct workqueue_struct *kacpi_notify_wq;
Zhang Ruic02256b2009-06-23 10:20:29 +080084static struct workqueue_struct *kacpi_hotplug_wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Thomas Renningerdf92e692008-02-04 23:31:22 -080086struct acpi_res_list {
87 resource_size_t start;
88 resource_size_t end;
89 acpi_adr_space_type resource_type; /* IO port, System memory, ...*/
90 char name[5]; /* only can have a length of 4 chars, make use of this
91 one instead of res->name, no need to kalloc then */
92 struct list_head resource_list;
Lin Minga5fe1a02009-08-13 10:43:27 +080093 int count;
Thomas Renningerdf92e692008-02-04 23:31:22 -080094};
95
96static LIST_HEAD(resource_list_head);
97static DEFINE_SPINLOCK(acpi_res_lock);
98
Myron Stowe620242a2010-10-21 14:23:53 -060099/*
100 * This list of permanent mappings is for memory that may be accessed from
101 * interrupt context, where we can't do the ioremap().
102 */
103struct acpi_ioremap {
104 struct list_head list;
105 void __iomem *virt;
106 acpi_physical_address phys;
107 acpi_size size;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100108 unsigned long refcount;
Myron Stowe620242a2010-10-21 14:23:53 -0600109};
110
111static LIST_HEAD(acpi_ioremaps);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100112static DEFINE_MUTEX(acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600113
Lin Mingb0ed7a92010-08-06 09:35:51 +0800114static void __init acpi_osi_setup_late(void);
Len Brownae00d812007-05-29 18:43:33 -0400115
Len Brownd4b7dc42008-01-23 20:50:56 -0500116/*
Len Browna6e08872008-11-08 01:21:10 -0500117 * The story of _OSI(Linux)
Len Brownd4b7dc42008-01-23 20:50:56 -0500118 *
Len Browna6e08872008-11-08 01:21:10 -0500119 * From pre-history through Linux-2.6.22,
120 * Linux responded TRUE upon a BIOS OSI(Linux) query.
Len Brownd4b7dc42008-01-23 20:50:56 -0500121 *
Len Browna6e08872008-11-08 01:21:10 -0500122 * Unfortunately, reference BIOS writers got wind of this
123 * and put OSI(Linux) in their example code, quickly exposing
124 * this string as ill-conceived and opening the door to
125 * an un-bounded number of BIOS incompatibilities.
Len Brownd4b7dc42008-01-23 20:50:56 -0500126 *
Len Browna6e08872008-11-08 01:21:10 -0500127 * For example, OSI(Linux) was used on resume to re-POST a
128 * video card on one system, because Linux at that time
129 * could not do a speedy restore in its native driver.
130 * But then upon gaining quick native restore capability,
131 * Linux has no way to tell the BIOS to skip the time-consuming
132 * POST -- putting Linux at a permanent performance disadvantage.
133 * On another system, the BIOS writer used OSI(Linux)
134 * to infer native OS support for IPMI! On other systems,
135 * OSI(Linux) simply got in the way of Linux claiming to
136 * be compatible with other operating systems, exposing
137 * BIOS issues such as skipped device initialization.
Len Brownd4b7dc42008-01-23 20:50:56 -0500138 *
Len Browna6e08872008-11-08 01:21:10 -0500139 * So "Linux" turned out to be a really poor chose of
140 * OSI string, and from Linux-2.6.23 onward we respond FALSE.
Len Brownd4b7dc42008-01-23 20:50:56 -0500141 *
142 * BIOS writers should NOT query _OSI(Linux) on future systems.
Len Browna6e08872008-11-08 01:21:10 -0500143 * Linux will complain on the console when it sees it, and return FALSE.
144 * To get Linux to return TRUE for your system will require
145 * a kernel source update to add a DMI entry,
146 * or boot with "acpi_osi=Linux"
Len Brownd4b7dc42008-01-23 20:50:56 -0500147 */
Len Brownd4b7dc42008-01-23 20:50:56 -0500148
Adrian Bunk1d15d842008-01-29 00:10:15 +0200149static struct osi_linux {
Len Brownd4b7dc42008-01-23 20:50:56 -0500150 unsigned int enable:1;
151 unsigned int dmi:1;
152 unsigned int cmdline:1;
Lin Mingd90aa922010-12-09 16:50:52 +0800153} osi_linux = {0, 0, 0};
Len Brownf5076542007-05-30 00:10:38 -0400154
Lin Mingb0ed7a92010-08-06 09:35:51 +0800155static u32 acpi_osi_handler(acpi_string interface, u32 supported)
156{
157 if (!strcmp("Linux", interface)) {
158
Len Brown3af283e2010-10-15 21:38:57 -0400159 printk(KERN_NOTICE FW_BUG PREFIX
Lin Mingb0ed7a92010-08-06 09:35:51 +0800160 "BIOS _OSI(Linux) query %s%s\n",
161 osi_linux.enable ? "honored" : "ignored",
162 osi_linux.cmdline ? " via cmdline" :
163 osi_linux.dmi ? " via DMI" : "");
164 }
165
166 return supported;
167}
168
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700169static void __init acpi_request_region (struct acpi_generic_address *addr,
170 unsigned int length, char *desc)
171{
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700172 if (!addr->address || !length)
173 return;
174
Andi Kleencfa806f2010-07-20 15:18:36 -0700175 /* Resources are never freed */
Len Browneee3c852007-02-03 01:38:16 -0500176 if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
Andi Kleencfa806f2010-07-20 15:18:36 -0700177 request_region(addr->address, length, desc);
Len Browneee3c852007-02-03 01:38:16 -0500178 else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
Andi Kleencfa806f2010-07-20 15:18:36 -0700179 request_mem_region(addr->address, length, desc);
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700180}
181
182static int __init acpi_reserve_resources(void)
183{
Len Browneee3c852007-02-03 01:38:16 -0500184 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700185 "ACPI PM1a_EVT_BLK");
186
Len Browneee3c852007-02-03 01:38:16 -0500187 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700188 "ACPI PM1b_EVT_BLK");
189
Len Browneee3c852007-02-03 01:38:16 -0500190 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700191 "ACPI PM1a_CNT_BLK");
192
Len Browneee3c852007-02-03 01:38:16 -0500193 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700194 "ACPI PM1b_CNT_BLK");
195
Len Browneee3c852007-02-03 01:38:16 -0500196 if (acpi_gbl_FADT.pm_timer_length == 4)
197 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700198
Len Browneee3c852007-02-03 01:38:16 -0500199 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700200 "ACPI PM2_CNT_BLK");
201
202 /* Length of GPE blocks must be a non-negative multiple of 2 */
203
Len Browneee3c852007-02-03 01:38:16 -0500204 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
205 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
206 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700207
Len Browneee3c852007-02-03 01:38:16 -0500208 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
209 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
210 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700211
212 return 0;
213}
214device_initcall(acpi_reserve_resources);
215
Len Brown4be44fc2005-08-05 00:44:28 -0400216void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
218 va_list args;
219 va_start(args, fmt);
220 acpi_os_vprintf(fmt, args);
221 va_end(args);
222}
Len Brown4be44fc2005-08-05 00:44:28 -0400223
Len Brown4be44fc2005-08-05 00:44:28 -0400224void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225{
226 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400227
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 vsprintf(buffer, fmt, args);
229
230#ifdef ENABLE_DEBUGGER
231 if (acpi_in_debugger) {
232 kdb_printf("%s", buffer);
233 } else {
Frank Seidel4d939152009-02-04 17:03:07 +0100234 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 }
236#else
Frank Seidel4d939152009-02-04 17:03:07 +0100237 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238#endif
239}
240
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300241acpi_physical_address __init acpi_os_get_root_pointer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242{
243 if (efi_enabled) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800244 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300245 return efi.acpi20;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800246 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300247 return efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400249 printk(KERN_ERR PREFIX
250 "System description tables not found\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300251 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
Len Brown239665a2007-11-23 20:08:02 -0500253 } else {
254 acpi_physical_address pa = 0;
255
256 acpi_find_root_pointer(&pa);
257 return pa;
258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259}
260
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600261/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe4a3cba52010-10-21 14:24:14 -0600262static struct acpi_ioremap *
263acpi_map_lookup(acpi_physical_address phys, acpi_size size)
Myron Stowe620242a2010-10-21 14:23:53 -0600264{
265 struct acpi_ioremap *map;
266
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600267 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe620242a2010-10-21 14:23:53 -0600268 if (map->phys <= phys &&
269 phys + size <= map->phys + map->size)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600270 return map;
271
272 return NULL;
273}
274
275/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
276static void __iomem *
277acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
278{
279 struct acpi_ioremap *map;
280
281 map = acpi_map_lookup(phys, size);
282 if (map)
283 return map->virt + (phys - map->phys);
Myron Stowe620242a2010-10-21 14:23:53 -0600284
285 return NULL;
286}
287
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600288/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe620242a2010-10-21 14:23:53 -0600289static struct acpi_ioremap *
290acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
291{
292 struct acpi_ioremap *map;
293
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600294 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600295 if (map->virt <= virt &&
296 virt + size <= map->virt + map->size)
Myron Stowe620242a2010-10-21 14:23:53 -0600297 return map;
298
299 return NULL;
300}
301
Jan Beulich2fdf0742007-12-13 08:33:59 +0000302void __iomem *__init_refok
303acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100305 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600306 void __iomem *virt;
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100307 acpi_physical_address pg_off;
308 acpi_size pg_sz;
Myron Stowe620242a2010-10-21 14:23:53 -0600309
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800310 if (phys > ULONG_MAX) {
311 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
Randy Dunlap70c08462007-02-13 16:11:36 -0800312 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 }
Myron Stowe620242a2010-10-21 14:23:53 -0600314
315 if (!acpi_gbl_permanent_mmap)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300316 return __acpi_map_table((unsigned long)phys, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600317
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100318 mutex_lock(&acpi_ioremap_lock);
319 /* Check if there's a suitable mapping already. */
320 map = acpi_map_lookup(phys, size);
321 if (map) {
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100322 map->refcount++;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100323 goto out;
324 }
325
Myron Stowe620242a2010-10-21 14:23:53 -0600326 map = kzalloc(sizeof(*map), GFP_KERNEL);
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100327 if (!map) {
328 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600329 return NULL;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100330 }
Myron Stowe620242a2010-10-21 14:23:53 -0600331
Myron Stowe4a3cba52010-10-21 14:24:14 -0600332 pg_off = round_down(phys, PAGE_SIZE);
333 pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100334 virt = acpi_os_ioremap(pg_off, pg_sz);
Myron Stowe620242a2010-10-21 14:23:53 -0600335 if (!virt) {
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100336 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600337 kfree(map);
338 return NULL;
339 }
340
341 INIT_LIST_HEAD(&map->list);
342 map->virt = virt;
Myron Stowe4a3cba52010-10-21 14:24:14 -0600343 map->phys = pg_off;
344 map->size = pg_sz;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100345 map->refcount = 1;
Myron Stowe620242a2010-10-21 14:23:53 -0600346
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600347 list_add_tail_rcu(&map->list, &acpi_ioremaps);
Myron Stowe620242a2010-10-21 14:23:53 -0600348
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100349 out:
350 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600351 return map->virt + (phys - map->phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800353EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100355static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600356{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100357 if (!--map->refcount)
358 list_del_rcu(&map->list);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600359}
360
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100361static void acpi_os_map_cleanup(struct acpi_ioremap *map)
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100362{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100363 if (!map->refcount) {
364 synchronize_rcu();
365 iounmap(map->virt);
366 kfree(map);
367 }
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100368}
369
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800370void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
Myron Stowe620242a2010-10-21 14:23:53 -0600372 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600373
374 if (!acpi_gbl_permanent_mmap) {
Yinghai Lu7d972772009-02-07 15:39:41 -0800375 __acpi_unmap_table(virt, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600376 return;
377 }
378
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100379 mutex_lock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600380 map = acpi_map_lookup_virt(virt, size);
381 if (!map) {
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100382 mutex_unlock(&acpi_ioremap_lock);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100383 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
Myron Stowe620242a2010-10-21 14:23:53 -0600384 return;
385 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100386 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100387 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600388
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100389 acpi_os_map_cleanup(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800391EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800393void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Yinghai Lu7d972772009-02-07 15:39:41 -0800394{
395 if (!acpi_gbl_permanent_mmap)
396 __acpi_unmap_table(virt, size);
397}
398
Rafael J. Wysocki073b4962011-02-08 23:37:31 +0100399static int acpi_os_map_generic_address(struct acpi_generic_address *addr)
Myron Stowe29718522010-10-21 14:23:59 -0600400{
401 void __iomem *virt;
402
403 if (addr->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
404 return 0;
405
406 if (!addr->address || !addr->bit_width)
407 return -EINVAL;
408
409 virt = acpi_os_map_memory(addr->address, addr->bit_width / 8);
410 if (!virt)
411 return -EIO;
412
413 return 0;
414}
Myron Stowe29718522010-10-21 14:23:59 -0600415
Rafael J. Wysocki073b4962011-02-08 23:37:31 +0100416static void acpi_os_unmap_generic_address(struct acpi_generic_address *addr)
Myron Stowe29718522010-10-21 14:23:59 -0600417{
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100418 struct acpi_ioremap *map;
Myron Stowe29718522010-10-21 14:23:59 -0600419
420 if (addr->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
421 return;
422
423 if (!addr->address || !addr->bit_width)
424 return;
425
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100426 mutex_lock(&acpi_ioremap_lock);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100427 map = acpi_map_lookup(addr->address, addr->bit_width / 8);
428 if (!map) {
429 mutex_unlock(&acpi_ioremap_lock);
430 return;
431 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100432 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100433 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe29718522010-10-21 14:23:59 -0600434
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100435 acpi_os_map_cleanup(map);
Myron Stowe29718522010-10-21 14:23:59 -0600436}
Myron Stowe29718522010-10-21 14:23:59 -0600437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438#ifdef ACPI_FUTURE_USAGE
439acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400440acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441{
Len Brown4be44fc2005-08-05 00:44:28 -0400442 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 return AE_BAD_PARAMETER;
444
445 *phys = virt_to_phys(virt);
446
447 return AE_OK;
448}
449#endif
450
451#define ACPI_MAX_OVERRIDE_LEN 100
452
453static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
454
455acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400456acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
457 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458{
459 if (!init_val || !new_val)
460 return AE_BAD_PARAMETER;
461
462 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400463 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400465 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 *new_val = acpi_os_name;
467 }
468
469 return AE_OK;
470}
471
472acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400473acpi_os_table_override(struct acpi_table_header * existing_table,
474 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
476 if (!existing_table || !new_table)
477 return AE_BAD_PARAMETER;
478
Markus Gaugusch71fc47a2008-02-05 00:04:06 +0100479 *new_table = NULL;
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481#ifdef CONFIG_ACPI_CUSTOM_DSDT
482 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400483 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484#endif
Éric Piel6ed31e92008-02-05 00:04:50 +0100485 if (*new_table != NULL) {
486 printk(KERN_WARNING PREFIX "Override [%4.4s-%8.8s], "
487 "this is unsafe: tainting kernel\n",
488 existing_table->signature,
489 existing_table->oem_table_id);
490 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
491 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 return AE_OK;
493}
494
David Howells7d12e782006-10-05 14:55:46 +0100495static irqreturn_t acpi_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496{
Len Brown5229e872008-02-06 01:26:55 -0500497 u32 handled;
498
499 handled = (*acpi_irq_handler) (acpi_irq_context);
500
501 if (handled) {
502 acpi_irq_handled++;
503 return IRQ_HANDLED;
Len Brown88bea182009-04-21 00:35:47 -0400504 } else {
505 acpi_irq_not_handled++;
Len Brown5229e872008-02-06 01:26:55 -0500506 return IRQ_NONE;
Len Brown88bea182009-04-21 00:35:47 -0400507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508}
509
510acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400511acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
512 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513{
514 unsigned int irq;
515
Len Brown5229e872008-02-06 01:26:55 -0500516 acpi_irq_stats_init();
517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 /*
519 * Ignore the GSI from the core, and use the value in our copy of the
520 * FADT. It may not be the same if an interrupt source override exists
521 * for the SCI.
522 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300523 gsi = acpi_gbl_FADT.sci_interrupt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
525 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
526 gsi);
527 return AE_OK;
528 }
529
530 acpi_irq_handler = handler;
531 acpi_irq_context = context;
Thomas Gleixnerdace1452006-07-01 19:29:38 -0700532 if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
534 return AE_NOT_ACQUIRED;
535 }
536 acpi_irq_irq = irq;
537
538 return AE_OK;
539}
540
Len Brown4be44fc2005-08-05 00:44:28 -0400541acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
543 if (irq) {
544 free_irq(irq, acpi_irq);
545 acpi_irq_handler = NULL;
546 acpi_irq_irq = 0;
547 }
548
549 return AE_OK;
550}
551
552/*
553 * Running in interpreter thread context, safe to sleep
554 */
555
Lin Ming439913f2010-01-28 10:53:19 +0800556void acpi_os_sleep(u64 ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800558 schedule_timeout_interruptible(msecs_to_jiffies(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559}
Len Brown4be44fc2005-08-05 00:44:28 -0400560
Len Brown4be44fc2005-08-05 00:44:28 -0400561void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562{
563 while (us) {
564 u32 delay = 1000;
565
566 if (delay > us)
567 delay = us;
568 udelay(delay);
569 touch_nmi_watchdog();
570 us -= delay;
571 }
572}
Len Brown4be44fc2005-08-05 00:44:28 -0400573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574/*
575 * Support ACPI 3.0 AML Timer operand
576 * Returns 64-bit free-running, monotonically increasing timer
577 * with 100ns granularity
578 */
Len Brown4be44fc2005-08-05 00:44:28 -0400579u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580{
581 static u64 t;
582
583#ifdef CONFIG_HPET
584 /* TBD: use HPET if available */
585#endif
586
587#ifdef CONFIG_X86_PM_TIMER
588 /* TBD: default to PM timer if HPET was not available */
589#endif
590 if (!t)
591 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
592
593 return ++t;
594}
595
Len Brown4be44fc2005-08-05 00:44:28 -0400596acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597{
598 u32 dummy;
599
600 if (!value)
601 value = &dummy;
602
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800603 *value = 0;
604 if (width <= 8) {
Len Brown4be44fc2005-08-05 00:44:28 -0400605 *(u8 *) value = inb(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800606 } else if (width <= 16) {
Len Brown4be44fc2005-08-05 00:44:28 -0400607 *(u16 *) value = inw(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800608 } else if (width <= 32) {
Len Brown4be44fc2005-08-05 00:44:28 -0400609 *(u32 *) value = inl(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800610 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 BUG();
612 }
613
614 return AE_OK;
615}
Len Brown4be44fc2005-08-05 00:44:28 -0400616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617EXPORT_SYMBOL(acpi_os_read_port);
618
Len Brown4be44fc2005-08-05 00:44:28 -0400619acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800621 if (width <= 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 outb(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800623 } else if (width <= 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 outw(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800625 } else if (width <= 32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 outl(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800627 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 BUG();
629 }
630
631 return AE_OK;
632}
Len Brown4be44fc2005-08-05 00:44:28 -0400633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634EXPORT_SYMBOL(acpi_os_write_port);
635
636acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400637acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
Len Brown4be44fc2005-08-05 00:44:28 -0400639 void __iomem *virt_addr;
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100640 unsigned int size = width / 8;
641 bool unmap = false;
642 u32 dummy;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600644 rcu_read_lock();
Myron Stowe620242a2010-10-21 14:23:53 -0600645 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600646 if (!virt_addr) {
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100647 rcu_read_unlock();
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100648 virt_addr = acpi_os_ioremap(phys_addr, size);
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100649 if (!virt_addr)
650 return AE_BAD_ADDRESS;
651 unmap = true;
Myron Stowe620242a2010-10-21 14:23:53 -0600652 }
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 if (!value)
655 value = &dummy;
656
657 switch (width) {
658 case 8:
Len Brown4be44fc2005-08-05 00:44:28 -0400659 *(u8 *) value = readb(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 break;
661 case 16:
Len Brown4be44fc2005-08-05 00:44:28 -0400662 *(u16 *) value = readw(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 break;
664 case 32:
Len Brown4be44fc2005-08-05 00:44:28 -0400665 *(u32 *) value = readl(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 break;
667 default:
668 BUG();
669 }
670
Myron Stowe620242a2010-10-21 14:23:53 -0600671 if (unmap)
672 iounmap(virt_addr);
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100673 else
674 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
676 return AE_OK;
677}
678
679acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400680acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681{
Len Brown4be44fc2005-08-05 00:44:28 -0400682 void __iomem *virt_addr;
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100683 unsigned int size = width / 8;
684 bool unmap = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600686 rcu_read_lock();
Myron Stowe620242a2010-10-21 14:23:53 -0600687 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600688 if (!virt_addr) {
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100689 rcu_read_unlock();
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100690 virt_addr = acpi_os_ioremap(phys_addr, size);
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100691 if (!virt_addr)
692 return AE_BAD_ADDRESS;
693 unmap = true;
Myron Stowe620242a2010-10-21 14:23:53 -0600694 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 switch (width) {
697 case 8:
698 writeb(value, virt_addr);
699 break;
700 case 16:
701 writew(value, virt_addr);
702 break;
703 case 32:
704 writel(value, virt_addr);
705 break;
706 default:
707 BUG();
708 }
709
Myron Stowe620242a2010-10-21 14:23:53 -0600710 if (unmap)
711 iounmap(virt_addr);
Rafael J. Wysocki884b8212011-02-08 23:37:16 +0100712 else
713 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
715 return AE_OK;
716}
717
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400719acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Bob Moorec5f02312010-08-06 08:57:53 +0800720 u64 *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
722 int result, size;
Bob Moorec5f02312010-08-06 08:57:53 +0800723 u32 value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
725 if (!value)
726 return AE_BAD_PARAMETER;
727
728 switch (width) {
729 case 8:
730 size = 1;
731 break;
732 case 16:
733 size = 2;
734 break;
735 case 32:
736 size = 4;
737 break;
738 default:
739 return AE_ERROR;
740 }
741
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500742 result = raw_pci_read(pci_id->segment, pci_id->bus,
743 PCI_DEVFN(pci_id->device, pci_id->function),
Bob Moorec5f02312010-08-06 08:57:53 +0800744 reg, size, &value32);
745 *value = value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
747 return (result ? AE_ERROR : AE_OK);
748}
Len Brown4be44fc2005-08-05 00:44:28 -0400749
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400751acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Lin Ming439913f2010-01-28 10:53:19 +0800752 u64 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
754 int result, size;
755
756 switch (width) {
757 case 8:
758 size = 1;
759 break;
760 case 16:
761 size = 2;
762 break;
763 case 32:
764 size = 4;
765 break;
766 default:
767 return AE_ERROR;
768 }
769
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500770 result = raw_pci_write(pci_id->segment, pci_id->bus,
771 PCI_DEVFN(pci_id->device, pci_id->function),
772 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 return (result ? AE_ERROR : AE_OK);
775}
776
David Howells65f27f32006-11-22 14:55:48 +0000777static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778{
David Howells65f27f32006-11-22 14:55:48 +0000779 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -0400780
Bjorn Helgaas9ac61852009-08-31 22:32:10 +0000781 if (dpc->wait)
782 acpi_os_wait_events_complete(NULL);
Zhang Rui19cd8472008-08-28 10:05:06 +0800783
784 dpc->function(dpc->context);
785 kfree(dpc);
Zhang Rui19cd8472008-08-28 10:05:06 +0800786}
787
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400788/*******************************************************************************
789 *
790 * FUNCTION: acpi_os_execute
791 *
792 * PARAMETERS: Type - Type of the callback
793 * Function - Function to be executed
794 * Context - Function parameters
795 *
796 * RETURN: Status
797 *
798 * DESCRIPTION: Depending on type, either queues function for deferred execution or
799 * immediately executes function on a separate thread.
800 *
801 ******************************************************************************/
802
Zhang Rui19cd8472008-08-28 10:05:06 +0800803static acpi_status __acpi_os_execute(acpi_execute_type type,
804 acpi_osd_exec_callback function, void *context, int hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805{
Len Brown4be44fc2005-08-05 00:44:28 -0400806 acpi_status status = AE_OK;
807 struct acpi_os_dpc *dpc;
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300808 struct workqueue_struct *queue;
Zhang Rui19cd8472008-08-28 10:05:06 +0800809 int ret;
Len Brown72945b22006-07-12 22:46:42 -0400810 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
811 "Scheduling function [%p(%p)] for deferred execution.\n",
812 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 /*
815 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +0000816 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 * way that allows us to also free its memory inside the callee.
818 * Because we may want to schedule several tasks with different
819 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +0000820 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 */
Len Brown72945b22006-07-12 22:46:42 -0400822
David Howells65f27f32006-11-22 14:55:48 +0000823 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 if (!dpc)
Lin Ming889c78b2008-12-31 09:23:57 +0800825 return AE_NO_MEMORY;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 dpc->function = function;
828 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800829
Zhang Ruic02256b2009-06-23 10:20:29 +0800830 /*
831 * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
832 * because the hotplug code may call driver .remove() functions,
833 * which invoke flush_scheduled_work/acpi_os_wait_events_complete
834 * to flush these workqueues.
835 */
836 queue = hp ? kacpi_hotplug_wq :
837 (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
Bjorn Helgaas9ac61852009-08-31 22:32:10 +0000838 dpc->wait = hp ? 1 : 0;
Zhang Ruibc736752010-03-22 15:48:54 +0800839
840 if (queue == kacpi_hotplug_wq)
841 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
842 else if (queue == kacpi_notify_wq)
843 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
844 else
845 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
846
Tejun Heo8fec62b2010-06-29 10:07:09 +0200847 /*
848 * On some machines, a software-initiated SMI causes corruption unless
849 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
850 * typically it's done in GPE-related methods that are run via
851 * workqueues, so we can avoid the known corruption cases by always
852 * queueing on CPU 0.
853 */
854 ret = queue_work_on(0, queue, &dpc->work);
Zhang Rui19cd8472008-08-28 10:05:06 +0800855
856 if (!ret) {
Lin Ming55ac9a02008-09-28 14:51:56 +0800857 printk(KERN_ERR PREFIX
858 "Call to queue_work() failed.\n");
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300859 status = AE_ERROR;
860 kfree(dpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 }
Lin Ming889c78b2008-12-31 09:23:57 +0800862 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863}
Len Brown4be44fc2005-08-05 00:44:28 -0400864
Zhang Rui19cd8472008-08-28 10:05:06 +0800865acpi_status acpi_os_execute(acpi_execute_type type,
866 acpi_osd_exec_callback function, void *context)
867{
868 return __acpi_os_execute(type, function, context, 0);
869}
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400870EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Zhang Rui19cd8472008-08-28 10:05:06 +0800872acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
873 void *context)
874{
875 return __acpi_os_execute(0, function, context, 1);
876}
877
Len Brown4be44fc2005-08-05 00:44:28 -0400878void acpi_os_wait_events_complete(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879{
880 flush_workqueue(kacpid_wq);
Zhang Rui2f67a062008-04-29 02:34:42 -0400881 flush_workqueue(kacpi_notify_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882}
Len Brown4be44fc2005-08-05 00:44:28 -0400883
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884EXPORT_SYMBOL(acpi_os_wait_events_complete);
885
886/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 * Deallocate the memory for a spinlock.
888 */
Bob Moore967440e32006-06-23 17:04:00 -0400889void acpi_os_delete_lock(acpi_spinlock handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
Patrick Mocheld550d982006-06-27 00:41:40 -0400891 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892}
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400895acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896{
Len Brown4be44fc2005-08-05 00:44:28 -0400897 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 sem = acpi_os_allocate(sizeof(struct semaphore));
900 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -0400901 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 memset(sem, 0, sizeof(struct semaphore));
903
904 sema_init(sem, initial_units);
905
Len Brown4be44fc2005-08-05 00:44:28 -0400906 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
Len Brown4be44fc2005-08-05 00:44:28 -0400908 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
909 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Patrick Mocheld550d982006-06-27 00:41:40 -0400911 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914/*
915 * TODO: A better way to delete semaphores? Linux doesn't have a
916 * 'delete_semaphore()' function -- may result in an invalid
917 * pointer dereference for non-synchronized consumers. Should
918 * we at least check for blocked threads and signal/cancel them?
919 */
920
Len Brown4be44fc2005-08-05 00:44:28 -0400921acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922{
Len Brown4be44fc2005-08-05 00:44:28 -0400923 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -0400926 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
Len Brown4be44fc2005-08-05 00:44:28 -0400928 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Matthew Wilcoxf1241c82008-03-14 13:43:13 -0400930 BUG_ON(!list_empty(&sem->wait_list));
Len Brown02438d82006-06-30 03:19:10 -0400931 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -0400932 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Patrick Mocheld550d982006-06-27 00:41:40 -0400934 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 * TODO: Support for units > 1?
939 */
Len Brown4be44fc2005-08-05 00:44:28 -0400940acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941{
Len Brown4be44fc2005-08-05 00:44:28 -0400942 acpi_status status = AE_OK;
943 struct semaphore *sem = (struct semaphore *)handle;
Matthew Wilcoxf1241c82008-03-14 13:43:13 -0400944 long jiffies;
Len Brown4be44fc2005-08-05 00:44:28 -0400945 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400948 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949
950 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -0400951 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
Len Brown4be44fc2005-08-05 00:44:28 -0400953 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
954 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
Matthew Wilcoxf1241c82008-03-14 13:43:13 -0400956 if (timeout == ACPI_WAIT_FOREVER)
957 jiffies = MAX_SCHEDULE_TIMEOUT;
958 else
959 jiffies = msecs_to_jiffies(timeout);
960
961 ret = down_timeout(sem, jiffies);
962 if (ret)
963 status = AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964
965 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -0400966 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -0400967 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -0400968 handle, units, timeout,
969 acpi_format_exception(status)));
970 } else {
971 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -0400972 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -0400973 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975
Patrick Mocheld550d982006-06-27 00:41:40 -0400976 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979/*
980 * TODO: Support for units > 1?
981 */
Len Brown4be44fc2005-08-05 00:44:28 -0400982acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
Len Brown4be44fc2005-08-05 00:44:28 -0400984 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400987 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
989 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -0400990 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991
Len Brown4be44fc2005-08-05 00:44:28 -0400992 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
993 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
995 up(sem);
996
Patrick Mocheld550d982006-06-27 00:41:40 -0400997 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998}
Len Brown4be44fc2005-08-05 00:44:28 -0400999
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -04001001u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002{
1003
1004#ifdef ENABLE_DEBUGGER
1005 if (acpi_in_debugger) {
1006 u32 chars;
1007
1008 kdb_read(buffer, sizeof(line_buf));
1009
1010 /* remove the CR kdb includes */
1011 chars = strlen(buffer) - 1;
1012 buffer[chars] = '\0';
1013 }
1014#endif
1015
1016 return 0;
1017}
Len Brown4be44fc2005-08-05 00:44:28 -04001018#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019
Len Brown4be44fc2005-08-05 00:44:28 -04001020acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021{
Len Brown4be44fc2005-08-05 00:44:28 -04001022 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 case ACPI_SIGNAL_FATAL:
1024 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1025 break;
1026 case ACPI_SIGNAL_BREAKPOINT:
1027 /*
1028 * AML Breakpoint
1029 * ACPI spec. says to treat it as a NOP unless
1030 * you are debugging. So if/when we integrate
1031 * AML debugger into the kernel debugger its
1032 * hook will go here. But until then it is
1033 * not useful to print anything on breakpoints.
1034 */
1035 break;
1036 default:
1037 break;
1038 }
1039
1040 return AE_OK;
1041}
Len Brown4be44fc2005-08-05 00:44:28 -04001042
Len Brown4be44fc2005-08-05 00:44:28 -04001043static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044{
1045 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -04001046 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048 if (!str || !*str)
1049 return 0;
1050
1051 for (; count-- && str && *str; str++) {
1052 if (isalnum(*str) || *str == ' ' || *str == ':')
1053 *p++ = *str;
1054 else if (*str == '\'' || *str == '"')
1055 continue;
1056 else
1057 break;
1058 }
1059 *p = 0;
1060
1061 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -04001062
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063}
1064
1065__setup("acpi_os_name=", acpi_os_name_setup);
1066
Lin Ming12d32062010-12-09 16:51:06 +08001067#define OSI_STRING_LENGTH_MAX 64 /* arbitrary */
1068#define OSI_STRING_ENTRIES_MAX 16 /* arbitrary */
1069
1070struct osi_setup_entry {
1071 char string[OSI_STRING_LENGTH_MAX];
1072 bool enable;
1073};
1074
1075static struct osi_setup_entry __initdata osi_setup_entries[OSI_STRING_ENTRIES_MAX];
1076
Lin Mingd90aa922010-12-09 16:50:52 +08001077void __init acpi_osi_setup(char *str)
1078{
Lin Ming12d32062010-12-09 16:51:06 +08001079 struct osi_setup_entry *osi;
1080 bool enable = true;
1081 int i;
1082
Lin Mingd90aa922010-12-09 16:50:52 +08001083 if (!acpi_gbl_create_osi_method)
1084 return;
1085
1086 if (str == NULL || *str == '\0') {
1087 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1088 acpi_gbl_create_osi_method = FALSE;
Lin Ming12d32062010-12-09 16:51:06 +08001089 return;
1090 }
1091
1092 if (*str == '!') {
1093 str++;
1094 enable = false;
1095 }
1096
1097 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1098 osi = &osi_setup_entries[i];
1099 if (!strcmp(osi->string, str)) {
1100 osi->enable = enable;
1101 break;
1102 } else if (osi->string[0] == '\0') {
1103 osi->enable = enable;
1104 strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1105 break;
1106 }
1107 }
Lin Mingd90aa922010-12-09 16:50:52 +08001108}
1109
Len Brownd4b7dc42008-01-23 20:50:56 -05001110static void __init set_osi_linux(unsigned int enable)
1111{
Lin Mingd90aa922010-12-09 16:50:52 +08001112 if (osi_linux.enable != enable)
Len Brownd4b7dc42008-01-23 20:50:56 -05001113 osi_linux.enable = enable;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001114
1115 if (osi_linux.enable)
1116 acpi_osi_setup("Linux");
1117 else
1118 acpi_osi_setup("!Linux");
1119
Len Brownd4b7dc42008-01-23 20:50:56 -05001120 return;
1121}
Len Brownf5076542007-05-30 00:10:38 -04001122
Len Brownd4b7dc42008-01-23 20:50:56 -05001123static void __init acpi_cmdline_osi_linux(unsigned int enable)
1124{
Lin Mingd90aa922010-12-09 16:50:52 +08001125 osi_linux.cmdline = 1; /* cmdline set the default and override DMI */
1126 osi_linux.dmi = 0;
Len Brownd4b7dc42008-01-23 20:50:56 -05001127 set_osi_linux(enable);
Len Brownf5076542007-05-30 00:10:38 -04001128
Len Brownd4b7dc42008-01-23 20:50:56 -05001129 return;
1130}
1131
1132void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1133{
Len Brownd4b7dc42008-01-23 20:50:56 -05001134 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1135
1136 if (enable == -1)
1137 return;
1138
Lin Mingd90aa922010-12-09 16:50:52 +08001139 osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) */
Len Brownd4b7dc42008-01-23 20:50:56 -05001140 set_osi_linux(enable);
1141
Len Brownf5076542007-05-30 00:10:38 -04001142 return;
1143}
1144
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145/*
Len Brownae00d812007-05-29 18:43:33 -04001146 * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1147 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 * empty string disables _OSI
Len Brownae00d812007-05-29 18:43:33 -04001149 * string starting with '!' disables that string
1150 * otherwise string is added to list, augmenting built-in strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 */
Lin Mingb0ed7a92010-08-06 09:35:51 +08001152static void __init acpi_osi_setup_late(void)
1153{
Lin Ming12d32062010-12-09 16:51:06 +08001154 struct osi_setup_entry *osi;
1155 char *str;
1156 int i;
Lin Mingd90aa922010-12-09 16:50:52 +08001157 acpi_status status;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001158
Lin Ming12d32062010-12-09 16:51:06 +08001159 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1160 osi = &osi_setup_entries[i];
1161 str = osi->string;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001162
Lin Ming12d32062010-12-09 16:51:06 +08001163 if (*str == '\0')
1164 break;
1165 if (osi->enable) {
1166 status = acpi_install_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001167
Lin Ming12d32062010-12-09 16:51:06 +08001168 if (ACPI_SUCCESS(status))
1169 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1170 } else {
1171 status = acpi_remove_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001172
Lin Ming12d32062010-12-09 16:51:06 +08001173 if (ACPI_SUCCESS(status))
1174 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1175 }
Lin Mingb0ed7a92010-08-06 09:35:51 +08001176 }
1177}
1178
Lin Mingd90aa922010-12-09 16:50:52 +08001179static int __init osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
Lin Mingd90aa922010-12-09 16:50:52 +08001181 if (str && !strcmp("Linux", str))
1182 acpi_cmdline_osi_linux(1);
1183 else if (str && !strcmp("!Linux", str))
1184 acpi_cmdline_osi_linux(0);
1185 else
1186 acpi_osi_setup(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187
1188 return 1;
1189}
1190
Lin Mingd90aa922010-12-09 16:50:52 +08001191__setup("acpi_osi=", osi_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -04001194static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195{
1196 printk(KERN_INFO PREFIX "serialize enabled\n");
1197
1198 acpi_gbl_all_methods_serialized = TRUE;
1199
1200 return 1;
1201}
1202
1203__setup("acpi_serialize", acpi_serialize_setup);
1204
Thomas Renningerdf92e692008-02-04 23:31:22 -08001205/* Check of resource interference between native drivers and ACPI
1206 * OperationRegions (SystemIO and System Memory only).
1207 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1208 * in arbitrary AML code and can interfere with legacy drivers.
1209 * acpi_enforce_resources= can be set to:
1210 *
Luca Tettamanti7e905602009-03-30 00:01:27 +02001211 * - strict (default) (2)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001212 * -> further driver trying to access the resources will not load
Luca Tettamanti7e905602009-03-30 00:01:27 +02001213 * - lax (1)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001214 * -> further driver trying to access the resources will load, but you
1215 * get a system message that something might go wrong...
1216 *
1217 * - no (0)
1218 * -> ACPI Operation Region resources will not be registered
1219 *
1220 */
1221#define ENFORCE_RESOURCES_STRICT 2
1222#define ENFORCE_RESOURCES_LAX 1
1223#define ENFORCE_RESOURCES_NO 0
1224
Luca Tettamanti7e905602009-03-30 00:01:27 +02001225static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001226
1227static int __init acpi_enforce_resources_setup(char *str)
1228{
1229 if (str == NULL || *str == '\0')
1230 return 0;
1231
1232 if (!strcmp("strict", str))
1233 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1234 else if (!strcmp("lax", str))
1235 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1236 else if (!strcmp("no", str))
1237 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1238
1239 return 1;
1240}
1241
1242__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1243
1244/* Check for resource conflicts between ACPI OperationRegions and native
1245 * drivers */
Jean Delvare876fba42009-11-11 15:22:15 +01001246int acpi_check_resource_conflict(const struct resource *res)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001247{
1248 struct acpi_res_list *res_list_elem;
Thomas Renninger106d1a02010-12-20 12:11:45 +01001249 int ioport = 0, clash = 0;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001250
1251 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1252 return 0;
1253 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1254 return 0;
1255
1256 ioport = res->flags & IORESOURCE_IO;
1257
1258 spin_lock(&acpi_res_lock);
1259 list_for_each_entry(res_list_elem, &resource_list_head,
1260 resource_list) {
1261 if (ioport && (res_list_elem->resource_type
1262 != ACPI_ADR_SPACE_SYSTEM_IO))
1263 continue;
1264 if (!ioport && (res_list_elem->resource_type
1265 != ACPI_ADR_SPACE_SYSTEM_MEMORY))
1266 continue;
1267
1268 if (res->end < res_list_elem->start
1269 || res_list_elem->end < res->start)
1270 continue;
1271 clash = 1;
1272 break;
1273 }
1274 spin_unlock(&acpi_res_lock);
1275
1276 if (clash) {
1277 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
Chase Douglas1638bca2010-03-22 15:08:09 -04001278 printk(KERN_WARNING "ACPI: resource %s %pR"
Thomas Renninger106d1a02010-12-20 12:11:45 +01001279 " conflicts with ACPI region %s "
1280 "[%s 0x%zx-0x%zx]\n",
Chase Douglas1638bca2010-03-22 15:08:09 -04001281 res->name, res, res_list_elem->name,
Thomas Renninger106d1a02010-12-20 12:11:45 +01001282 (res_list_elem->resource_type ==
1283 ACPI_ADR_SPACE_SYSTEM_IO) ? "io" : "mem",
1284 (size_t) res_list_elem->start,
1285 (size_t) res_list_elem->end);
Jean Delvare14f03342009-09-08 15:31:46 +02001286 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1287 printk(KERN_NOTICE "ACPI: This conflict may"
1288 " cause random problems and system"
1289 " instability\n");
1290 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1291 " for this device, you should use it instead of"
1292 " the native driver\n");
Thomas Renningerdf92e692008-02-04 23:31:22 -08001293 }
1294 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1295 return -EBUSY;
1296 }
1297 return 0;
1298}
Thomas Renninger443dea72008-02-04 23:31:23 -08001299EXPORT_SYMBOL(acpi_check_resource_conflict);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001300
1301int acpi_check_region(resource_size_t start, resource_size_t n,
1302 const char *name)
1303{
1304 struct resource res = {
1305 .start = start,
1306 .end = start + n - 1,
1307 .name = name,
1308 .flags = IORESOURCE_IO,
1309 };
1310
1311 return acpi_check_resource_conflict(&res);
1312}
1313EXPORT_SYMBOL(acpi_check_region);
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315/*
Jean Delvare70dd6be2010-05-27 19:58:37 +02001316 * Let drivers know whether the resource checks are effective
1317 */
1318int acpi_resources_are_enforced(void)
1319{
1320 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1321}
1322EXPORT_SYMBOL(acpi_resources_are_enforced);
1323
1324/*
Robert Moore73459f72005-06-24 00:00:00 -04001325 * Acquire a spinlock.
1326 *
1327 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001328 */
1329
Bob Moore967440e32006-06-23 17:04:00 -04001330acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001331{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001332 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001333 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001334 return flags;
1335}
1336
1337/*
1338 * Release a spinlock. See above.
1339 */
1340
Bob Moore967440e32006-06-23 17:04:00 -04001341void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001342{
Bob Moore967440e32006-06-23 17:04:00 -04001343 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001344}
1345
Robert Moore73459f72005-06-24 00:00:00 -04001346#ifndef ACPI_USE_LOCAL_CACHE
1347
1348/*******************************************************************************
1349 *
1350 * FUNCTION: acpi_os_create_cache
1351 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001352 * PARAMETERS: name - Ascii name for the cache
1353 * size - Size of each cached object
1354 * depth - Maximum depth of the cache (in objects) <ignored>
1355 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001356 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001357 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001358 *
1359 * DESCRIPTION: Create a cache object
1360 *
1361 ******************************************************************************/
1362
1363acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001364acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001365{
Paul Mundt20c2df82007-07-20 10:11:58 +09001366 *cache = kmem_cache_create(name, size, 0, 0, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001367 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001368 return AE_ERROR;
1369 else
1370 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001371}
1372
1373/*******************************************************************************
1374 *
1375 * FUNCTION: acpi_os_purge_cache
1376 *
1377 * PARAMETERS: Cache - Handle to cache object
1378 *
1379 * RETURN: Status
1380 *
1381 * DESCRIPTION: Free all objects within the requested cache.
1382 *
1383 ******************************************************************************/
1384
Len Brown4be44fc2005-08-05 00:44:28 -04001385acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001386{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001387 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001388 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001389}
1390
1391/*******************************************************************************
1392 *
1393 * FUNCTION: acpi_os_delete_cache
1394 *
1395 * PARAMETERS: Cache - Handle to cache object
1396 *
1397 * RETURN: Status
1398 *
1399 * DESCRIPTION: Free all objects within the requested cache and delete the
1400 * cache object.
1401 *
1402 ******************************************************************************/
1403
Len Brown4be44fc2005-08-05 00:44:28 -04001404acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001405{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001406 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001407 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001408}
1409
1410/*******************************************************************************
1411 *
1412 * FUNCTION: acpi_os_release_object
1413 *
1414 * PARAMETERS: Cache - Handle to cache object
1415 * Object - The object to be released
1416 *
1417 * RETURN: None
1418 *
1419 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1420 * the object is deleted.
1421 *
1422 ******************************************************************************/
1423
Len Brown4be44fc2005-08-05 00:44:28 -04001424acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001425{
Len Brown4be44fc2005-08-05 00:44:28 -04001426 kmem_cache_free(cache, object);
1427 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001428}
1429
Lin Minga5fe1a02009-08-13 10:43:27 +08001430static inline int acpi_res_list_add(struct acpi_res_list *res)
1431{
1432 struct acpi_res_list *res_list_elem;
1433
1434 list_for_each_entry(res_list_elem, &resource_list_head,
1435 resource_list) {
1436
1437 if (res->resource_type == res_list_elem->resource_type &&
1438 res->start == res_list_elem->start &&
1439 res->end == res_list_elem->end) {
1440
1441 /*
1442 * The Region(addr,len) already exist in the list,
1443 * just increase the count
1444 */
1445
1446 res_list_elem->count++;
1447 return 0;
1448 }
1449 }
1450
1451 res->count = 1;
1452 list_add(&res->resource_list, &resource_list_head);
1453 return 1;
1454}
1455
1456static inline void acpi_res_list_del(struct acpi_res_list *res)
1457{
1458 struct acpi_res_list *res_list_elem;
1459
1460 list_for_each_entry(res_list_elem, &resource_list_head,
1461 resource_list) {
1462
1463 if (res->resource_type == res_list_elem->resource_type &&
1464 res->start == res_list_elem->start &&
1465 res->end == res_list_elem->end) {
1466
1467 /*
1468 * If the res count is decreased to 0,
1469 * remove and free it
1470 */
1471
1472 if (--res_list_elem->count == 0) {
1473 list_del(&res_list_elem->resource_list);
1474 kfree(res_list_elem);
1475 }
1476 return;
1477 }
1478 }
1479}
1480
1481acpi_status
1482acpi_os_invalidate_address(
1483 u8 space_id,
1484 acpi_physical_address address,
1485 acpi_size length)
1486{
1487 struct acpi_res_list res;
1488
1489 switch (space_id) {
1490 case ACPI_ADR_SPACE_SYSTEM_IO:
1491 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
Thomas Weber88393162010-03-16 11:47:56 +01001492 /* Only interference checks against SystemIO and SystemMemory
Lin Minga5fe1a02009-08-13 10:43:27 +08001493 are needed */
1494 res.start = address;
1495 res.end = address + length - 1;
1496 res.resource_type = space_id;
1497 spin_lock(&acpi_res_lock);
1498 acpi_res_list_del(&res);
1499 spin_unlock(&acpi_res_lock);
1500 break;
1501 case ACPI_ADR_SPACE_PCI_CONFIG:
1502 case ACPI_ADR_SPACE_EC:
1503 case ACPI_ADR_SPACE_SMBUS:
1504 case ACPI_ADR_SPACE_CMOS:
1505 case ACPI_ADR_SPACE_PCI_BAR_TARGET:
1506 case ACPI_ADR_SPACE_DATA_TABLE:
1507 case ACPI_ADR_SPACE_FIXED_HARDWARE:
1508 break;
1509 }
1510 return AE_OK;
1511}
1512
Bob Mooreb229cf92006-04-21 17:15:00 -04001513/******************************************************************************
1514 *
1515 * FUNCTION: acpi_os_validate_address
1516 *
1517 * PARAMETERS: space_id - ACPI space ID
1518 * address - Physical address
1519 * length - Address length
1520 *
1521 * RETURN: AE_OK if address/length is valid for the space_id. Otherwise,
1522 * should return AE_AML_ILLEGAL_ADDRESS.
1523 *
1524 * DESCRIPTION: Validate a system address via the host OS. Used to validate
1525 * the addresses accessed by AML operation regions.
1526 *
1527 *****************************************************************************/
1528
1529acpi_status
1530acpi_os_validate_address (
1531 u8 space_id,
1532 acpi_physical_address address,
Thomas Renningerdf92e692008-02-04 23:31:22 -08001533 acpi_size length,
1534 char *name)
Bob Mooreb229cf92006-04-21 17:15:00 -04001535{
Thomas Renningerdf92e692008-02-04 23:31:22 -08001536 struct acpi_res_list *res;
Lin Minga5fe1a02009-08-13 10:43:27 +08001537 int added;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001538 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1539 return AE_OK;
Bob Mooreb229cf92006-04-21 17:15:00 -04001540
Thomas Renningerdf92e692008-02-04 23:31:22 -08001541 switch (space_id) {
1542 case ACPI_ADR_SPACE_SYSTEM_IO:
1543 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
Thomas Weber88393162010-03-16 11:47:56 +01001544 /* Only interference checks against SystemIO and SystemMemory
Thomas Renningerdf92e692008-02-04 23:31:22 -08001545 are needed */
1546 res = kzalloc(sizeof(struct acpi_res_list), GFP_KERNEL);
1547 if (!res)
1548 return AE_OK;
1549 /* ACPI names are fixed to 4 bytes, still better use strlcpy */
1550 strlcpy(res->name, name, 5);
1551 res->start = address;
1552 res->end = address + length - 1;
1553 res->resource_type = space_id;
1554 spin_lock(&acpi_res_lock);
Lin Minga5fe1a02009-08-13 10:43:27 +08001555 added = acpi_res_list_add(res);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001556 spin_unlock(&acpi_res_lock);
Lin Minga5fe1a02009-08-13 10:43:27 +08001557 pr_debug("%s %s resource: start: 0x%llx, end: 0x%llx, "
1558 "name: %s\n", added ? "Added" : "Already exist",
1559 (space_id == ACPI_ADR_SPACE_SYSTEM_IO)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001560 ? "SystemIO" : "System Memory",
1561 (unsigned long long)res->start,
1562 (unsigned long long)res->end,
1563 res->name);
Lin Minga5fe1a02009-08-13 10:43:27 +08001564 if (!added)
1565 kfree(res);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001566 break;
1567 case ACPI_ADR_SPACE_PCI_CONFIG:
1568 case ACPI_ADR_SPACE_EC:
1569 case ACPI_ADR_SPACE_SMBUS:
1570 case ACPI_ADR_SPACE_CMOS:
1571 case ACPI_ADR_SPACE_PCI_BAR_TARGET:
1572 case ACPI_ADR_SPACE_DATA_TABLE:
1573 case ACPI_ADR_SPACE_FIXED_HARDWARE:
1574 break;
1575 }
1576 return AE_OK;
Bob Mooreb229cf92006-04-21 17:15:00 -04001577}
Robert Moore73459f72005-06-24 00:00:00 -04001578#endif
Myron Stowed362eda2010-10-21 14:24:04 -06001579
1580acpi_status __init acpi_os_initialize(void)
1581{
1582 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1583 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1584 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1585 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1586
1587 return AE_OK;
1588}
1589
Zhang Rui32d47ee2010-12-08 10:40:36 +08001590acpi_status __init acpi_os_initialize1(void)
Myron Stowed362eda2010-10-21 14:24:04 -06001591{
1592 kacpid_wq = create_workqueue("kacpid");
1593 kacpi_notify_wq = create_workqueue("kacpi_notify");
1594 kacpi_hotplug_wq = create_workqueue("kacpi_hotplug");
1595 BUG_ON(!kacpid_wq);
1596 BUG_ON(!kacpi_notify_wq);
1597 BUG_ON(!kacpi_hotplug_wq);
Len Brown1bd64d42010-10-26 14:50:56 -04001598 acpi_install_interface_handler(acpi_osi_handler);
1599 acpi_osi_setup_late();
Myron Stowed362eda2010-10-21 14:24:04 -06001600 return AE_OK;
1601}
1602
1603acpi_status acpi_os_terminate(void)
1604{
1605 if (acpi_irq_handler) {
1606 acpi_os_remove_interrupt_handler(acpi_irq_irq,
1607 acpi_irq_handler);
1608 }
1609
1610 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1611 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1612 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1613 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1614
1615 destroy_workqueue(kacpid_wq);
1616 destroy_workqueue(kacpi_notify_wq);
1617 destroy_workqueue(kacpi_hotplug_wq);
1618
1619 return AE_OK;
1620}