blob: 8e6d8665f0aecd54a6895046c13071b831a250c6 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/efi.h>
Thomas Renningerdf92e692008-02-04 23:31:22 -080042#include <linux/ioport.h>
43#include <linux/list.h>
Matthew Wilcoxf1241c82008-03-14 13:43:13 -040044#include <linux/jiffies.h>
45#include <linux/semaphore.h>
46
47#include <asm/io.h>
48#include <asm/uaccess.h>
49
50#include <acpi/acpi.h>
51#include <acpi/acpi_bus.h>
52#include <acpi/processor.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054#define _COMPONENT ACPI_OS_SERVICES
Len Brownf52fd662007-02-12 22:42:12 -050055ACPI_MODULE_NAME("osl");
Linus Torvalds1da177e2005-04-16 15:20:36 -070056#define PREFIX "ACPI: "
Len Brown4be44fc2005-08-05 00:44:28 -040057struct acpi_os_dpc {
58 acpi_osd_exec_callback function;
59 void *context;
David Howells65f27f32006-11-22 14:55:48 +000060 struct work_struct work;
Bjorn Helgaas9ac61852009-08-31 22:32:10 +000061 int wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062};
63
64#ifdef CONFIG_ACPI_CUSTOM_DSDT
65#include CONFIG_ACPI_CUSTOM_DSDT_FILE
66#endif
67
68#ifdef ENABLE_DEBUGGER
69#include <linux/kdb.h>
70
71/* stuff for debugger support */
72int acpi_in_debugger;
73EXPORT_SYMBOL(acpi_in_debugger);
74
75extern char line_buf[80];
Len Brown4be44fc2005-08-05 00:44:28 -040076#endif /*ENABLE_DEBUGGER */
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static unsigned int acpi_irq_irq;
79static acpi_osd_handler acpi_irq_handler;
80static void *acpi_irq_context;
81static struct workqueue_struct *kacpid_wq;
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -040082static struct workqueue_struct *kacpi_notify_wq;
Zhang Ruic02256b2009-06-23 10:20:29 +080083static struct workqueue_struct *kacpi_hotplug_wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Thomas Renningerdf92e692008-02-04 23:31:22 -080085struct acpi_res_list {
86 resource_size_t start;
87 resource_size_t end;
88 acpi_adr_space_type resource_type; /* IO port, System memory, ...*/
89 char name[5]; /* only can have a length of 4 chars, make use of this
90 one instead of res->name, no need to kalloc then */
91 struct list_head resource_list;
Lin Minga5fe1a02009-08-13 10:43:27 +080092 int count;
Thomas Renningerdf92e692008-02-04 23:31:22 -080093};
94
95static LIST_HEAD(resource_list_head);
96static DEFINE_SPINLOCK(acpi_res_lock);
97
Len Brownae00d812007-05-29 18:43:33 -040098#define OSI_STRING_LENGTH_MAX 64 /* arbitrary */
99static char osi_additional_string[OSI_STRING_LENGTH_MAX];
100
Len Brownd4b7dc42008-01-23 20:50:56 -0500101/*
Len Browna6e08872008-11-08 01:21:10 -0500102 * The story of _OSI(Linux)
Len Brownd4b7dc42008-01-23 20:50:56 -0500103 *
Len Browna6e08872008-11-08 01:21:10 -0500104 * From pre-history through Linux-2.6.22,
105 * Linux responded TRUE upon a BIOS OSI(Linux) query.
Len Brownd4b7dc42008-01-23 20:50:56 -0500106 *
Len Browna6e08872008-11-08 01:21:10 -0500107 * Unfortunately, reference BIOS writers got wind of this
108 * and put OSI(Linux) in their example code, quickly exposing
109 * this string as ill-conceived and opening the door to
110 * an un-bounded number of BIOS incompatibilities.
Len Brownd4b7dc42008-01-23 20:50:56 -0500111 *
Len Browna6e08872008-11-08 01:21:10 -0500112 * For example, OSI(Linux) was used on resume to re-POST a
113 * video card on one system, because Linux at that time
114 * could not do a speedy restore in its native driver.
115 * But then upon gaining quick native restore capability,
116 * Linux has no way to tell the BIOS to skip the time-consuming
117 * POST -- putting Linux at a permanent performance disadvantage.
118 * On another system, the BIOS writer used OSI(Linux)
119 * to infer native OS support for IPMI! On other systems,
120 * OSI(Linux) simply got in the way of Linux claiming to
121 * be compatible with other operating systems, exposing
122 * BIOS issues such as skipped device initialization.
Len Brownd4b7dc42008-01-23 20:50:56 -0500123 *
Len Browna6e08872008-11-08 01:21:10 -0500124 * So "Linux" turned out to be a really poor chose of
125 * OSI string, and from Linux-2.6.23 onward we respond FALSE.
Len Brownd4b7dc42008-01-23 20:50:56 -0500126 *
127 * BIOS writers should NOT query _OSI(Linux) on future systems.
Len Browna6e08872008-11-08 01:21:10 -0500128 * Linux will complain on the console when it sees it, and return FALSE.
129 * To get Linux to return TRUE for your system will require
130 * a kernel source update to add a DMI entry,
131 * or boot with "acpi_osi=Linux"
Len Brownd4b7dc42008-01-23 20:50:56 -0500132 */
Len Brownd4b7dc42008-01-23 20:50:56 -0500133
Adrian Bunk1d15d842008-01-29 00:10:15 +0200134static struct osi_linux {
Len Brownd4b7dc42008-01-23 20:50:56 -0500135 unsigned int enable:1;
136 unsigned int dmi:1;
137 unsigned int cmdline:1;
138 unsigned int known:1;
Len Browna6e08872008-11-08 01:21:10 -0500139} osi_linux = { 0, 0, 0, 0};
Len Brownf5076542007-05-30 00:10:38 -0400140
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700141static void __init acpi_request_region (struct acpi_generic_address *addr,
142 unsigned int length, char *desc)
143{
144 struct resource *res;
145
146 if (!addr->address || !length)
147 return;
148
Len Browneee3c852007-02-03 01:38:16 -0500149 if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700150 res = request_region(addr->address, length, desc);
Len Browneee3c852007-02-03 01:38:16 -0500151 else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700152 res = request_mem_region(addr->address, length, desc);
153}
154
155static int __init acpi_reserve_resources(void)
156{
Len Browneee3c852007-02-03 01:38:16 -0500157 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700158 "ACPI PM1a_EVT_BLK");
159
Len Browneee3c852007-02-03 01:38:16 -0500160 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700161 "ACPI PM1b_EVT_BLK");
162
Len Browneee3c852007-02-03 01:38:16 -0500163 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700164 "ACPI PM1a_CNT_BLK");
165
Len Browneee3c852007-02-03 01:38:16 -0500166 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700167 "ACPI PM1b_CNT_BLK");
168
Len Browneee3c852007-02-03 01:38:16 -0500169 if (acpi_gbl_FADT.pm_timer_length == 4)
170 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700171
Len Browneee3c852007-02-03 01:38:16 -0500172 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700173 "ACPI PM2_CNT_BLK");
174
175 /* Length of GPE blocks must be a non-negative multiple of 2 */
176
Len Browneee3c852007-02-03 01:38:16 -0500177 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
178 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
179 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700180
Len Browneee3c852007-02-03 01:38:16 -0500181 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
182 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
183 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700184
185 return 0;
186}
187device_initcall(acpi_reserve_resources);
188
Len Browndd272b52007-05-30 00:26:11 -0400189acpi_status __init acpi_os_initialize(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
191 return AE_OK;
192}
193
Bjorn Helgaas74b58202009-07-29 15:54:25 -0600194static void bind_to_cpu0(struct work_struct *work)
195{
Bjorn Helgaase68110f2009-09-24 09:34:38 -0600196 set_cpus_allowed_ptr(current, cpumask_of(0));
Bjorn Helgaas74b58202009-07-29 15:54:25 -0600197 kfree(work);
198}
199
200static void bind_workqueue(struct workqueue_struct *wq)
201{
202 struct work_struct *work;
203
204 work = kzalloc(sizeof(struct work_struct), GFP_KERNEL);
205 INIT_WORK(work, bind_to_cpu0);
206 queue_work(wq, work);
207}
208
Len Brown4be44fc2005-08-05 00:44:28 -0400209acpi_status acpi_os_initialize1(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
Bjorn Helgaas74b58202009-07-29 15:54:25 -0600211 /*
212 * On some machines, a software-initiated SMI causes corruption unless
213 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
214 * typically it's done in GPE-related methods that are run via
215 * workqueues, so we can avoid the known corruption cases by binding
216 * the workqueues to CPU 0.
217 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 kacpid_wq = create_singlethread_workqueue("kacpid");
Bjorn Helgaas74b58202009-07-29 15:54:25 -0600219 bind_workqueue(kacpid_wq);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -0400220 kacpi_notify_wq = create_singlethread_workqueue("kacpi_notify");
Bjorn Helgaas74b58202009-07-29 15:54:25 -0600221 bind_workqueue(kacpi_notify_wq);
Zhang Ruic02256b2009-06-23 10:20:29 +0800222 kacpi_hotplug_wq = create_singlethread_workqueue("kacpi_hotplug");
Bjorn Helgaas74b58202009-07-29 15:54:25 -0600223 bind_workqueue(kacpi_hotplug_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 BUG_ON(!kacpid_wq);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -0400225 BUG_ON(!kacpi_notify_wq);
Zhang Ruic02256b2009-06-23 10:20:29 +0800226 BUG_ON(!kacpi_hotplug_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return AE_OK;
228}
229
Len Brown4be44fc2005-08-05 00:44:28 -0400230acpi_status acpi_os_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
232 if (acpi_irq_handler) {
233 acpi_os_remove_interrupt_handler(acpi_irq_irq,
234 acpi_irq_handler);
235 }
236
237 destroy_workqueue(kacpid_wq);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -0400238 destroy_workqueue(kacpi_notify_wq);
Zhang Ruic02256b2009-06-23 10:20:29 +0800239 destroy_workqueue(kacpi_hotplug_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 return AE_OK;
242}
243
Len Brown4be44fc2005-08-05 00:44:28 -0400244void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
246 va_list args;
247 va_start(args, fmt);
248 acpi_os_vprintf(fmt, args);
249 va_end(args);
250}
Len Brown4be44fc2005-08-05 00:44:28 -0400251
Len Brown4be44fc2005-08-05 00:44:28 -0400252void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
254 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 vsprintf(buffer, fmt, args);
257
258#ifdef ENABLE_DEBUGGER
259 if (acpi_in_debugger) {
260 kdb_printf("%s", buffer);
261 } else {
Frank Seidel4d939152009-02-04 17:03:07 +0100262 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 }
264#else
Frank Seidel4d939152009-02-04 17:03:07 +0100265 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266#endif
267}
268
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300269acpi_physical_address __init acpi_os_get_root_pointer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270{
271 if (efi_enabled) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800272 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300273 return efi.acpi20;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800274 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300275 return efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400277 printk(KERN_ERR PREFIX
278 "System description tables not found\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300279 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 }
Len Brown239665a2007-11-23 20:08:02 -0500281 } else {
282 acpi_physical_address pa = 0;
283
284 acpi_find_root_pointer(&pa);
285 return pa;
286 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287}
288
Jan Beulich2fdf0742007-12-13 08:33:59 +0000289void __iomem *__init_refok
290acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291{
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800292 if (phys > ULONG_MAX) {
293 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
Randy Dunlap70c08462007-02-13 16:11:36 -0800294 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 }
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300296 if (acpi_gbl_permanent_mmap)
297 /*
298 * ioremap checks to ensure this is in reserved space
299 */
300 return ioremap((unsigned long)phys, size);
301 else
302 return __acpi_map_table((unsigned long)phys, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800304EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800306void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
Yinghai Lu7d972772009-02-07 15:39:41 -0800308 if (acpi_gbl_permanent_mmap)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300309 iounmap(virt);
Yinghai Lu7d972772009-02-07 15:39:41 -0800310 else
311 __acpi_unmap_table(virt, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800313EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800315void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Yinghai Lu7d972772009-02-07 15:39:41 -0800316{
317 if (!acpi_gbl_permanent_mmap)
318 __acpi_unmap_table(virt, size);
319}
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321#ifdef ACPI_FUTURE_USAGE
322acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400323acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
Len Brown4be44fc2005-08-05 00:44:28 -0400325 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 return AE_BAD_PARAMETER;
327
328 *phys = virt_to_phys(virt);
329
330 return AE_OK;
331}
332#endif
333
334#define ACPI_MAX_OVERRIDE_LEN 100
335
336static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
337
338acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400339acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
340 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
342 if (!init_val || !new_val)
343 return AE_BAD_PARAMETER;
344
345 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400346 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400348 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 *new_val = acpi_os_name;
350 }
351
352 return AE_OK;
353}
354
355acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400356acpi_os_table_override(struct acpi_table_header * existing_table,
357 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358{
359 if (!existing_table || !new_table)
360 return AE_BAD_PARAMETER;
361
Markus Gaugusch71fc47a2008-02-05 00:04:06 +0100362 *new_table = NULL;
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364#ifdef CONFIG_ACPI_CUSTOM_DSDT
365 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400366 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367#endif
Éric Piel6ed31e92008-02-05 00:04:50 +0100368 if (*new_table != NULL) {
369 printk(KERN_WARNING PREFIX "Override [%4.4s-%8.8s], "
370 "this is unsafe: tainting kernel\n",
371 existing_table->signature,
372 existing_table->oem_table_id);
373 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
374 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 return AE_OK;
376}
377
David Howells7d12e782006-10-05 14:55:46 +0100378static irqreturn_t acpi_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Len Brown5229e872008-02-06 01:26:55 -0500380 u32 handled;
381
382 handled = (*acpi_irq_handler) (acpi_irq_context);
383
384 if (handled) {
385 acpi_irq_handled++;
386 return IRQ_HANDLED;
Len Brown88bea182009-04-21 00:35:47 -0400387 } else {
388 acpi_irq_not_handled++;
Len Brown5229e872008-02-06 01:26:55 -0500389 return IRQ_NONE;
Len Brown88bea182009-04-21 00:35:47 -0400390 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391}
392
393acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400394acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
395 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396{
397 unsigned int irq;
398
Len Brown5229e872008-02-06 01:26:55 -0500399 acpi_irq_stats_init();
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 /*
402 * Ignore the GSI from the core, and use the value in our copy of the
403 * FADT. It may not be the same if an interrupt source override exists
404 * for the SCI.
405 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300406 gsi = acpi_gbl_FADT.sci_interrupt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
408 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
409 gsi);
410 return AE_OK;
411 }
412
413 acpi_irq_handler = handler;
414 acpi_irq_context = context;
Thomas Gleixnerdace1452006-07-01 19:29:38 -0700415 if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
417 return AE_NOT_ACQUIRED;
418 }
419 acpi_irq_irq = irq;
420
421 return AE_OK;
422}
423
Len Brown4be44fc2005-08-05 00:44:28 -0400424acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425{
426 if (irq) {
427 free_irq(irq, acpi_irq);
428 acpi_irq_handler = NULL;
429 acpi_irq_irq = 0;
430 }
431
432 return AE_OK;
433}
434
435/*
436 * Running in interpreter thread context, safe to sleep
437 */
438
Lin Ming439913f2010-01-28 10:53:19 +0800439void acpi_os_sleep(u64 ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440{
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800441 schedule_timeout_interruptible(msecs_to_jiffies(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442}
Len Brown4be44fc2005-08-05 00:44:28 -0400443
Len Brown4be44fc2005-08-05 00:44:28 -0400444void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
446 while (us) {
447 u32 delay = 1000;
448
449 if (delay > us)
450 delay = us;
451 udelay(delay);
452 touch_nmi_watchdog();
453 us -= delay;
454 }
455}
Len Brown4be44fc2005-08-05 00:44:28 -0400456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457/*
458 * Support ACPI 3.0 AML Timer operand
459 * Returns 64-bit free-running, monotonically increasing timer
460 * with 100ns granularity
461 */
Len Brown4be44fc2005-08-05 00:44:28 -0400462u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
464 static u64 t;
465
466#ifdef CONFIG_HPET
467 /* TBD: use HPET if available */
468#endif
469
470#ifdef CONFIG_X86_PM_TIMER
471 /* TBD: default to PM timer if HPET was not available */
472#endif
473 if (!t)
474 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
475
476 return ++t;
477}
478
Len Brown4be44fc2005-08-05 00:44:28 -0400479acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480{
481 u32 dummy;
482
483 if (!value)
484 value = &dummy;
485
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800486 *value = 0;
487 if (width <= 8) {
Len Brown4be44fc2005-08-05 00:44:28 -0400488 *(u8 *) value = inb(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800489 } else if (width <= 16) {
Len Brown4be44fc2005-08-05 00:44:28 -0400490 *(u16 *) value = inw(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800491 } else if (width <= 32) {
Len Brown4be44fc2005-08-05 00:44:28 -0400492 *(u32 *) value = inl(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800493 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 BUG();
495 }
496
497 return AE_OK;
498}
Len Brown4be44fc2005-08-05 00:44:28 -0400499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500EXPORT_SYMBOL(acpi_os_read_port);
501
Len Brown4be44fc2005-08-05 00:44:28 -0400502acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503{
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800504 if (width <= 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 outb(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800506 } else if (width <= 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 outw(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800508 } else if (width <= 32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 outl(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800510 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 BUG();
512 }
513
514 return AE_OK;
515}
Len Brown4be44fc2005-08-05 00:44:28 -0400516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517EXPORT_SYMBOL(acpi_os_write_port);
518
519acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400520acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
Len Brown4be44fc2005-08-05 00:44:28 -0400522 u32 dummy;
523 void __iomem *virt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800525 virt_addr = ioremap(phys_addr, width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 if (!value)
527 value = &dummy;
528
529 switch (width) {
530 case 8:
Len Brown4be44fc2005-08-05 00:44:28 -0400531 *(u8 *) value = readb(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 break;
533 case 16:
Len Brown4be44fc2005-08-05 00:44:28 -0400534 *(u16 *) value = readw(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 break;
536 case 32:
Len Brown4be44fc2005-08-05 00:44:28 -0400537 *(u32 *) value = readl(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 break;
539 default:
540 BUG();
541 }
542
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800543 iounmap(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 return AE_OK;
546}
547
548acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400549acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550{
Len Brown4be44fc2005-08-05 00:44:28 -0400551 void __iomem *virt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800553 virt_addr = ioremap(phys_addr, width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 switch (width) {
556 case 8:
557 writeb(value, virt_addr);
558 break;
559 case 16:
560 writew(value, virt_addr);
561 break;
562 case 32:
563 writel(value, virt_addr);
564 break;
565 default:
566 BUG();
567 }
568
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800569 iounmap(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 return AE_OK;
572}
573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400575acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Linus Torvalds10270d42008-02-13 09:56:14 -0800576 u32 *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577{
578 int result, size;
579
580 if (!value)
581 return AE_BAD_PARAMETER;
582
583 switch (width) {
584 case 8:
585 size = 1;
586 break;
587 case 16:
588 size = 2;
589 break;
590 case 32:
591 size = 4;
592 break;
593 default:
594 return AE_ERROR;
595 }
596
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500597 result = raw_pci_read(pci_id->segment, pci_id->bus,
598 PCI_DEVFN(pci_id->device, pci_id->function),
599 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 return (result ? AE_ERROR : AE_OK);
602}
Len Brown4be44fc2005-08-05 00:44:28 -0400603
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400605acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Lin Ming439913f2010-01-28 10:53:19 +0800606 u64 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607{
608 int result, size;
609
610 switch (width) {
611 case 8:
612 size = 1;
613 break;
614 case 16:
615 size = 2;
616 break;
617 case 32:
618 size = 4;
619 break;
620 default:
621 return AE_ERROR;
622 }
623
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -0500624 result = raw_pci_write(pci_id->segment, pci_id->bus,
625 PCI_DEVFN(pci_id->device, pci_id->function),
626 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 return (result ? AE_ERROR : AE_OK);
629}
630
631/* TODO: Change code to take advantage of driver model more */
Len Brown4be44fc2005-08-05 00:44:28 -0400632static void acpi_os_derive_pci_id_2(acpi_handle rhandle, /* upper bound */
633 acpi_handle chandle, /* current node */
634 struct acpi_pci_id **id,
635 int *is_bridge, u8 * bus_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636{
Len Brown4be44fc2005-08-05 00:44:28 -0400637 acpi_handle handle;
638 struct acpi_pci_id *pci_id = *id;
639 acpi_status status;
Matthew Wilcox27663c52008-10-10 02:22:59 -0400640 unsigned long long temp;
Len Brown4be44fc2005-08-05 00:44:28 -0400641 acpi_object_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642
643 acpi_get_parent(chandle, &handle);
644 if (handle != rhandle) {
Len Brown4be44fc2005-08-05 00:44:28 -0400645 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
646 bus_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
648 status = acpi_get_type(handle, &type);
Len Brown4be44fc2005-08-05 00:44:28 -0400649 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return;
651
Matthew Wilcox27663c52008-10-10 02:22:59 -0400652 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
Len Brown4be44fc2005-08-05 00:44:28 -0400653 &temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 if (ACPI_SUCCESS(status)) {
Linus Torvalds10270d42008-02-13 09:56:14 -0800655 u32 val;
Len Brown4be44fc2005-08-05 00:44:28 -0400656 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
657 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
659 if (*is_bridge)
660 pci_id->bus = *bus_number;
661
662 /* any nicer way to get bus number of bridge ? */
Len Brown4be44fc2005-08-05 00:44:28 -0400663 status =
Linus Torvalds10270d42008-02-13 09:56:14 -0800664 acpi_os_read_pci_configuration(pci_id, 0x0e, &val,
Len Brown4be44fc2005-08-05 00:44:28 -0400665 8);
666 if (ACPI_SUCCESS(status)
Linus Torvalds10270d42008-02-13 09:56:14 -0800667 && ((val & 0x7f) == 1 || (val & 0x7f) == 2)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400668 status =
669 acpi_os_read_pci_configuration(pci_id, 0x18,
Linus Torvalds10270d42008-02-13 09:56:14 -0800670 &val, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 if (!ACPI_SUCCESS(status)) {
672 /* Certainly broken... FIX ME */
673 return;
674 }
675 *is_bridge = 1;
Linus Torvalds10270d42008-02-13 09:56:14 -0800676 pci_id->bus = val;
Len Brown4be44fc2005-08-05 00:44:28 -0400677 status =
678 acpi_os_read_pci_configuration(pci_id, 0x19,
Linus Torvalds10270d42008-02-13 09:56:14 -0800679 &val, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 if (ACPI_SUCCESS(status)) {
Linus Torvalds10270d42008-02-13 09:56:14 -0800681 *bus_number = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 }
683 } else
684 *is_bridge = 0;
685 }
686 }
687}
688
Len Brown4be44fc2005-08-05 00:44:28 -0400689void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */
690 acpi_handle chandle, /* current node */
691 struct acpi_pci_id **id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
693 int is_bridge = 1;
694 u8 bus_number = (*id)->bus;
695
696 acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
697}
698
David Howells65f27f32006-11-22 14:55:48 +0000699static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
David Howells65f27f32006-11-22 14:55:48 +0000701 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -0400702
Bjorn Helgaas9ac61852009-08-31 22:32:10 +0000703 if (dpc->wait)
704 acpi_os_wait_events_complete(NULL);
Zhang Rui19cd8472008-08-28 10:05:06 +0800705
706 dpc->function(dpc->context);
707 kfree(dpc);
Zhang Rui19cd8472008-08-28 10:05:06 +0800708}
709
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400710/*******************************************************************************
711 *
712 * FUNCTION: acpi_os_execute
713 *
714 * PARAMETERS: Type - Type of the callback
715 * Function - Function to be executed
716 * Context - Function parameters
717 *
718 * RETURN: Status
719 *
720 * DESCRIPTION: Depending on type, either queues function for deferred execution or
721 * immediately executes function on a separate thread.
722 *
723 ******************************************************************************/
724
Zhang Rui19cd8472008-08-28 10:05:06 +0800725static acpi_status __acpi_os_execute(acpi_execute_type type,
726 acpi_osd_exec_callback function, void *context, int hp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727{
Len Brown4be44fc2005-08-05 00:44:28 -0400728 acpi_status status = AE_OK;
729 struct acpi_os_dpc *dpc;
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300730 struct workqueue_struct *queue;
Zhang Rui19cd8472008-08-28 10:05:06 +0800731 int ret;
Len Brown72945b22006-07-12 22:46:42 -0400732 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
733 "Scheduling function [%p(%p)] for deferred execution.\n",
734 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 /*
737 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +0000738 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 * way that allows us to also free its memory inside the callee.
740 * Because we may want to schedule several tasks with different
741 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +0000742 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 */
Len Brown72945b22006-07-12 22:46:42 -0400744
David Howells65f27f32006-11-22 14:55:48 +0000745 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 if (!dpc)
Lin Ming889c78b2008-12-31 09:23:57 +0800747 return AE_NO_MEMORY;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 dpc->function = function;
750 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800751
Zhang Ruic02256b2009-06-23 10:20:29 +0800752 /*
753 * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
754 * because the hotplug code may call driver .remove() functions,
755 * which invoke flush_scheduled_work/acpi_os_wait_events_complete
756 * to flush these workqueues.
757 */
758 queue = hp ? kacpi_hotplug_wq :
759 (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
Bjorn Helgaas9ac61852009-08-31 22:32:10 +0000760 dpc->wait = hp ? 1 : 0;
761 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Zhang Ruic02256b2009-06-23 10:20:29 +0800762 ret = queue_work(queue, &dpc->work);
Zhang Rui19cd8472008-08-28 10:05:06 +0800763
764 if (!ret) {
Lin Ming55ac9a02008-09-28 14:51:56 +0800765 printk(KERN_ERR PREFIX
766 "Call to queue_work() failed.\n");
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +0300767 status = AE_ERROR;
768 kfree(dpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 }
Lin Ming889c78b2008-12-31 09:23:57 +0800770 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771}
Len Brown4be44fc2005-08-05 00:44:28 -0400772
Zhang Rui19cd8472008-08-28 10:05:06 +0800773acpi_status acpi_os_execute(acpi_execute_type type,
774 acpi_osd_exec_callback function, void *context)
775{
776 return __acpi_os_execute(type, function, context, 0);
777}
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400778EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Zhang Rui19cd8472008-08-28 10:05:06 +0800780acpi_status acpi_os_hotplug_execute(acpi_osd_exec_callback function,
781 void *context)
782{
783 return __acpi_os_execute(0, function, context, 1);
784}
785
Len Brown4be44fc2005-08-05 00:44:28 -0400786void acpi_os_wait_events_complete(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787{
788 flush_workqueue(kacpid_wq);
Zhang Rui2f67a062008-04-29 02:34:42 -0400789 flush_workqueue(kacpi_notify_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790}
Len Brown4be44fc2005-08-05 00:44:28 -0400791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792EXPORT_SYMBOL(acpi_os_wait_events_complete);
793
794/*
795 * Allocate the memory for a spinlock and initialize it.
796 */
Bob Moore967440e32006-06-23 17:04:00 -0400797acpi_status acpi_os_create_lock(acpi_spinlock * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798{
Bob Moore967440e32006-06-23 17:04:00 -0400799 spin_lock_init(*handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Patrick Mocheld550d982006-06-27 00:41:40 -0400801 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802}
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804/*
805 * Deallocate the memory for a spinlock.
806 */
Bob Moore967440e32006-06-23 17:04:00 -0400807void acpi_os_delete_lock(acpi_spinlock handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808{
Patrick Mocheld550d982006-06-27 00:41:40 -0400809 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810}
811
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400813acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
Len Brown4be44fc2005-08-05 00:44:28 -0400815 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 sem = acpi_os_allocate(sizeof(struct semaphore));
818 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -0400819 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 memset(sem, 0, sizeof(struct semaphore));
821
822 sema_init(sem, initial_units);
823
Len Brown4be44fc2005-08-05 00:44:28 -0400824 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Len Brown4be44fc2005-08-05 00:44:28 -0400826 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
827 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
Patrick Mocheld550d982006-06-27 00:41:40 -0400829 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832/*
833 * TODO: A better way to delete semaphores? Linux doesn't have a
834 * 'delete_semaphore()' function -- may result in an invalid
835 * pointer dereference for non-synchronized consumers. Should
836 * we at least check for blocked threads and signal/cancel them?
837 */
838
Len Brown4be44fc2005-08-05 00:44:28 -0400839acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840{
Len Brown4be44fc2005-08-05 00:44:28 -0400841 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -0400844 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845
Len Brown4be44fc2005-08-05 00:44:28 -0400846 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847
Matthew Wilcoxf1241c82008-03-14 13:43:13 -0400848 BUG_ON(!list_empty(&sem->wait_list));
Len Brown02438d82006-06-30 03:19:10 -0400849 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -0400850 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Patrick Mocheld550d982006-06-27 00:41:40 -0400852 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 * TODO: Support for units > 1?
857 */
Len Brown4be44fc2005-08-05 00:44:28 -0400858acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859{
Len Brown4be44fc2005-08-05 00:44:28 -0400860 acpi_status status = AE_OK;
861 struct semaphore *sem = (struct semaphore *)handle;
Matthew Wilcoxf1241c82008-03-14 13:43:13 -0400862 long jiffies;
Len Brown4be44fc2005-08-05 00:44:28 -0400863 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400866 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -0400869 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
Len Brown4be44fc2005-08-05 00:44:28 -0400871 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
872 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Matthew Wilcoxf1241c82008-03-14 13:43:13 -0400874 if (timeout == ACPI_WAIT_FOREVER)
875 jiffies = MAX_SCHEDULE_TIMEOUT;
876 else
877 jiffies = msecs_to_jiffies(timeout);
878
879 ret = down_timeout(sem, jiffies);
880 if (ret)
881 status = AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882
883 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -0400884 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -0400885 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -0400886 handle, units, timeout,
887 acpi_format_exception(status)));
888 } else {
889 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -0400890 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -0400891 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 }
893
Patrick Mocheld550d982006-06-27 00:41:40 -0400894 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897/*
898 * TODO: Support for units > 1?
899 */
Len Brown4be44fc2005-08-05 00:44:28 -0400900acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901{
Len Brown4be44fc2005-08-05 00:44:28 -0400902 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400905 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906
907 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -0400908 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909
Len Brown4be44fc2005-08-05 00:44:28 -0400910 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
911 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
913 up(sem);
914
Patrick Mocheld550d982006-06-27 00:41:40 -0400915 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
Len Brown4be44fc2005-08-05 00:44:28 -0400917
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -0400919u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920{
921
922#ifdef ENABLE_DEBUGGER
923 if (acpi_in_debugger) {
924 u32 chars;
925
926 kdb_read(buffer, sizeof(line_buf));
927
928 /* remove the CR kdb includes */
929 chars = strlen(buffer) - 1;
930 buffer[chars] = '\0';
931 }
932#endif
933
934 return 0;
935}
Len Brown4be44fc2005-08-05 00:44:28 -0400936#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Len Brown4be44fc2005-08-05 00:44:28 -0400938acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
Len Brown4be44fc2005-08-05 00:44:28 -0400940 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 case ACPI_SIGNAL_FATAL:
942 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
943 break;
944 case ACPI_SIGNAL_BREAKPOINT:
945 /*
946 * AML Breakpoint
947 * ACPI spec. says to treat it as a NOP unless
948 * you are debugging. So if/when we integrate
949 * AML debugger into the kernel debugger its
950 * hook will go here. But until then it is
951 * not useful to print anything on breakpoints.
952 */
953 break;
954 default:
955 break;
956 }
957
958 return AE_OK;
959}
Len Brown4be44fc2005-08-05 00:44:28 -0400960
Len Brown4be44fc2005-08-05 00:44:28 -0400961static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962{
963 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -0400964 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966 if (!str || !*str)
967 return 0;
968
969 for (; count-- && str && *str; str++) {
970 if (isalnum(*str) || *str == ' ' || *str == ':')
971 *p++ = *str;
972 else if (*str == '\'' || *str == '"')
973 continue;
974 else
975 break;
976 }
977 *p = 0;
978
979 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -0400980
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981}
982
983__setup("acpi_os_name=", acpi_os_name_setup);
984
Len Brownd4b7dc42008-01-23 20:50:56 -0500985static void __init set_osi_linux(unsigned int enable)
986{
987 if (osi_linux.enable != enable) {
988 osi_linux.enable = enable;
989 printk(KERN_NOTICE PREFIX "%sed _OSI(Linux)\n",
990 enable ? "Add": "Delet");
991 }
992 return;
993}
Len Brownf5076542007-05-30 00:10:38 -0400994
Len Brownd4b7dc42008-01-23 20:50:56 -0500995static void __init acpi_cmdline_osi_linux(unsigned int enable)
996{
997 osi_linux.cmdline = 1; /* cmdline set the default */
998 set_osi_linux(enable);
Len Brownf5076542007-05-30 00:10:38 -0400999
Len Brownd4b7dc42008-01-23 20:50:56 -05001000 return;
1001}
1002
1003void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1004{
1005 osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) */
1006
1007 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1008
1009 if (enable == -1)
1010 return;
1011
1012 osi_linux.known = 1; /* DMI knows which OSI(Linux) default needed */
1013
1014 set_osi_linux(enable);
1015
Len Brownf5076542007-05-30 00:10:38 -04001016 return;
1017}
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019/*
Len Brownae00d812007-05-29 18:43:33 -04001020 * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1021 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 * empty string disables _OSI
Len Brownae00d812007-05-29 18:43:33 -04001023 * string starting with '!' disables that string
1024 * otherwise string is added to list, augmenting built-in strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 */
Len Brown46c1fbd2008-02-13 23:13:25 -05001026int __init acpi_osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027{
1028 if (str == NULL || *str == '\0') {
1029 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1030 acpi_gbl_create_osi_method = FALSE;
Len Brownaa2e09d2007-07-02 23:57:45 -04001031 } else if (!strcmp("!Linux", str)) {
Len Brownd4b7dc42008-01-23 20:50:56 -05001032 acpi_cmdline_osi_linux(0); /* !enable */
Len Brownae00d812007-05-29 18:43:33 -04001033 } else if (*str == '!') {
1034 if (acpi_osi_invalidate(++str) == AE_OK)
1035 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
Len Brownf5076542007-05-30 00:10:38 -04001036 } else if (!strcmp("Linux", str)) {
Len Brownd4b7dc42008-01-23 20:50:56 -05001037 acpi_cmdline_osi_linux(1); /* enable */
Len Brownae00d812007-05-29 18:43:33 -04001038 } else if (*osi_additional_string == '\0') {
1039 strncpy(osi_additional_string, str, OSI_STRING_LENGTH_MAX);
1040 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 }
1042
1043 return 1;
1044}
1045
1046__setup("acpi_osi=", acpi_osi_setup);
1047
1048/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -04001049static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050{
1051 printk(KERN_INFO PREFIX "serialize enabled\n");
1052
1053 acpi_gbl_all_methods_serialized = TRUE;
1054
1055 return 1;
1056}
1057
1058__setup("acpi_serialize", acpi_serialize_setup);
1059
1060/*
1061 * Wake and Run-Time GPES are expected to be separate.
1062 * We disable wake-GPEs at run-time to prevent spurious
1063 * interrupts.
1064 *
1065 * However, if a system exists that shares Wake and
1066 * Run-time events on the same GPE this flag is available
1067 * to tell Linux to keep the wake-time GPEs enabled at run-time.
1068 */
Len Brown4be44fc2005-08-05 00:44:28 -04001069static int __init acpi_wake_gpes_always_on_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070{
1071 printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
1072
1073 acpi_gbl_leave_wake_gpes_disabled = FALSE;
1074
1075 return 1;
1076}
1077
1078__setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
1079
Thomas Renningerdf92e692008-02-04 23:31:22 -08001080/* Check of resource interference between native drivers and ACPI
1081 * OperationRegions (SystemIO and System Memory only).
1082 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1083 * in arbitrary AML code and can interfere with legacy drivers.
1084 * acpi_enforce_resources= can be set to:
1085 *
Luca Tettamanti7e905602009-03-30 00:01:27 +02001086 * - strict (default) (2)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001087 * -> further driver trying to access the resources will not load
Luca Tettamanti7e905602009-03-30 00:01:27 +02001088 * - lax (1)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001089 * -> further driver trying to access the resources will load, but you
1090 * get a system message that something might go wrong...
1091 *
1092 * - no (0)
1093 * -> ACPI Operation Region resources will not be registered
1094 *
1095 */
1096#define ENFORCE_RESOURCES_STRICT 2
1097#define ENFORCE_RESOURCES_LAX 1
1098#define ENFORCE_RESOURCES_NO 0
1099
Luca Tettamanti7e905602009-03-30 00:01:27 +02001100static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001101
1102static int __init acpi_enforce_resources_setup(char *str)
1103{
1104 if (str == NULL || *str == '\0')
1105 return 0;
1106
1107 if (!strcmp("strict", str))
1108 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1109 else if (!strcmp("lax", str))
1110 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1111 else if (!strcmp("no", str))
1112 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1113
1114 return 1;
1115}
1116
1117__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1118
1119/* Check for resource conflicts between ACPI OperationRegions and native
1120 * drivers */
Jean Delvare876fba42009-11-11 15:22:15 +01001121int acpi_check_resource_conflict(const struct resource *res)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001122{
1123 struct acpi_res_list *res_list_elem;
1124 int ioport;
1125 int clash = 0;
1126
1127 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1128 return 0;
1129 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1130 return 0;
1131
1132 ioport = res->flags & IORESOURCE_IO;
1133
1134 spin_lock(&acpi_res_lock);
1135 list_for_each_entry(res_list_elem, &resource_list_head,
1136 resource_list) {
1137 if (ioport && (res_list_elem->resource_type
1138 != ACPI_ADR_SPACE_SYSTEM_IO))
1139 continue;
1140 if (!ioport && (res_list_elem->resource_type
1141 != ACPI_ADR_SPACE_SYSTEM_MEMORY))
1142 continue;
1143
1144 if (res->end < res_list_elem->start
1145 || res_list_elem->end < res->start)
1146 continue;
1147 clash = 1;
1148 break;
1149 }
1150 spin_unlock(&acpi_res_lock);
1151
1152 if (clash) {
1153 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
Jean Delvarebd129352008-02-27 20:56:01 +01001154 printk("%sACPI: %s resource %s [0x%llx-0x%llx]"
Thomas Renningerdf92e692008-02-04 23:31:22 -08001155 " conflicts with ACPI region %s"
1156 " [0x%llx-0x%llx]\n",
1157 acpi_enforce_resources == ENFORCE_RESOURCES_LAX
1158 ? KERN_WARNING : KERN_ERR,
1159 ioport ? "I/O" : "Memory", res->name,
1160 (long long) res->start, (long long) res->end,
1161 res_list_elem->name,
1162 (long long) res_list_elem->start,
1163 (long long) res_list_elem->end);
Jean Delvare14f03342009-09-08 15:31:46 +02001164 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1165 printk(KERN_NOTICE "ACPI: This conflict may"
1166 " cause random problems and system"
1167 " instability\n");
1168 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1169 " for this device, you should use it instead of"
1170 " the native driver\n");
Thomas Renningerdf92e692008-02-04 23:31:22 -08001171 }
1172 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1173 return -EBUSY;
1174 }
1175 return 0;
1176}
Thomas Renninger443dea72008-02-04 23:31:23 -08001177EXPORT_SYMBOL(acpi_check_resource_conflict);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001178
1179int acpi_check_region(resource_size_t start, resource_size_t n,
1180 const char *name)
1181{
1182 struct resource res = {
1183 .start = start,
1184 .end = start + n - 1,
1185 .name = name,
1186 .flags = IORESOURCE_IO,
1187 };
1188
1189 return acpi_check_resource_conflict(&res);
1190}
1191EXPORT_SYMBOL(acpi_check_region);
1192
1193int acpi_check_mem_region(resource_size_t start, resource_size_t n,
1194 const char *name)
1195{
1196 struct resource res = {
1197 .start = start,
1198 .end = start + n - 1,
1199 .name = name,
1200 .flags = IORESOURCE_MEM,
1201 };
1202
1203 return acpi_check_resource_conflict(&res);
1204
1205}
1206EXPORT_SYMBOL(acpi_check_mem_region);
1207
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208/*
Robert Moore73459f72005-06-24 00:00:00 -04001209 * Acquire a spinlock.
1210 *
1211 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001212 */
1213
Bob Moore967440e32006-06-23 17:04:00 -04001214acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001215{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001216 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001217 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001218 return flags;
1219}
1220
1221/*
1222 * Release a spinlock. See above.
1223 */
1224
Bob Moore967440e32006-06-23 17:04:00 -04001225void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001226{
Bob Moore967440e32006-06-23 17:04:00 -04001227 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001228}
1229
Robert Moore73459f72005-06-24 00:00:00 -04001230#ifndef ACPI_USE_LOCAL_CACHE
1231
1232/*******************************************************************************
1233 *
1234 * FUNCTION: acpi_os_create_cache
1235 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001236 * PARAMETERS: name - Ascii name for the cache
1237 * size - Size of each cached object
1238 * depth - Maximum depth of the cache (in objects) <ignored>
1239 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001240 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001241 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001242 *
1243 * DESCRIPTION: Create a cache object
1244 *
1245 ******************************************************************************/
1246
1247acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001248acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001249{
Paul Mundt20c2df82007-07-20 10:11:58 +09001250 *cache = kmem_cache_create(name, size, 0, 0, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001251 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001252 return AE_ERROR;
1253 else
1254 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001255}
1256
1257/*******************************************************************************
1258 *
1259 * FUNCTION: acpi_os_purge_cache
1260 *
1261 * PARAMETERS: Cache - Handle to cache object
1262 *
1263 * RETURN: Status
1264 *
1265 * DESCRIPTION: Free all objects within the requested cache.
1266 *
1267 ******************************************************************************/
1268
Len Brown4be44fc2005-08-05 00:44:28 -04001269acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001270{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001271 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001272 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001273}
1274
1275/*******************************************************************************
1276 *
1277 * FUNCTION: acpi_os_delete_cache
1278 *
1279 * PARAMETERS: Cache - Handle to cache object
1280 *
1281 * RETURN: Status
1282 *
1283 * DESCRIPTION: Free all objects within the requested cache and delete the
1284 * cache object.
1285 *
1286 ******************************************************************************/
1287
Len Brown4be44fc2005-08-05 00:44:28 -04001288acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001289{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001290 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001291 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001292}
1293
1294/*******************************************************************************
1295 *
1296 * FUNCTION: acpi_os_release_object
1297 *
1298 * PARAMETERS: Cache - Handle to cache object
1299 * Object - The object to be released
1300 *
1301 * RETURN: None
1302 *
1303 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1304 * the object is deleted.
1305 *
1306 ******************************************************************************/
1307
Len Brown4be44fc2005-08-05 00:44:28 -04001308acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001309{
Len Brown4be44fc2005-08-05 00:44:28 -04001310 kmem_cache_free(cache, object);
1311 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001312}
1313
Bob Mooreb229cf92006-04-21 17:15:00 -04001314/******************************************************************************
1315 *
1316 * FUNCTION: acpi_os_validate_interface
1317 *
1318 * PARAMETERS: interface - Requested interface to be validated
1319 *
1320 * RETURN: AE_OK if interface is supported, AE_SUPPORT otherwise
1321 *
1322 * DESCRIPTION: Match an interface string to the interfaces supported by the
1323 * host. Strings originate from an AML call to the _OSI method.
1324 *
1325 *****************************************************************************/
1326
1327acpi_status
1328acpi_os_validate_interface (char *interface)
1329{
Len Brownae00d812007-05-29 18:43:33 -04001330 if (!strncmp(osi_additional_string, interface, OSI_STRING_LENGTH_MAX))
1331 return AE_OK;
Len Brownf5076542007-05-30 00:10:38 -04001332 if (!strcmp("Linux", interface)) {
Len Brownd4b7dc42008-01-23 20:50:56 -05001333
1334 printk(KERN_NOTICE PREFIX
1335 "BIOS _OSI(Linux) query %s%s\n",
1336 osi_linux.enable ? "honored" : "ignored",
1337 osi_linux.cmdline ? " via cmdline" :
1338 osi_linux.dmi ? " via DMI" : "");
1339
Len Brownd4b7dc42008-01-23 20:50:56 -05001340 if (osi_linux.enable)
Len Brownf5076542007-05-30 00:10:38 -04001341 return AE_OK;
1342 }
Len Brownae00d812007-05-29 18:43:33 -04001343 return AE_SUPPORT;
Bob Mooreb229cf92006-04-21 17:15:00 -04001344}
1345
Lin Minga5fe1a02009-08-13 10:43:27 +08001346static inline int acpi_res_list_add(struct acpi_res_list *res)
1347{
1348 struct acpi_res_list *res_list_elem;
1349
1350 list_for_each_entry(res_list_elem, &resource_list_head,
1351 resource_list) {
1352
1353 if (res->resource_type == res_list_elem->resource_type &&
1354 res->start == res_list_elem->start &&
1355 res->end == res_list_elem->end) {
1356
1357 /*
1358 * The Region(addr,len) already exist in the list,
1359 * just increase the count
1360 */
1361
1362 res_list_elem->count++;
1363 return 0;
1364 }
1365 }
1366
1367 res->count = 1;
1368 list_add(&res->resource_list, &resource_list_head);
1369 return 1;
1370}
1371
1372static inline void acpi_res_list_del(struct acpi_res_list *res)
1373{
1374 struct acpi_res_list *res_list_elem;
1375
1376 list_for_each_entry(res_list_elem, &resource_list_head,
1377 resource_list) {
1378
1379 if (res->resource_type == res_list_elem->resource_type &&
1380 res->start == res_list_elem->start &&
1381 res->end == res_list_elem->end) {
1382
1383 /*
1384 * If the res count is decreased to 0,
1385 * remove and free it
1386 */
1387
1388 if (--res_list_elem->count == 0) {
1389 list_del(&res_list_elem->resource_list);
1390 kfree(res_list_elem);
1391 }
1392 return;
1393 }
1394 }
1395}
1396
1397acpi_status
1398acpi_os_invalidate_address(
1399 u8 space_id,
1400 acpi_physical_address address,
1401 acpi_size length)
1402{
1403 struct acpi_res_list res;
1404
1405 switch (space_id) {
1406 case ACPI_ADR_SPACE_SYSTEM_IO:
1407 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
1408 /* Only interference checks against SystemIO and SytemMemory
1409 are needed */
1410 res.start = address;
1411 res.end = address + length - 1;
1412 res.resource_type = space_id;
1413 spin_lock(&acpi_res_lock);
1414 acpi_res_list_del(&res);
1415 spin_unlock(&acpi_res_lock);
1416 break;
1417 case ACPI_ADR_SPACE_PCI_CONFIG:
1418 case ACPI_ADR_SPACE_EC:
1419 case ACPI_ADR_SPACE_SMBUS:
1420 case ACPI_ADR_SPACE_CMOS:
1421 case ACPI_ADR_SPACE_PCI_BAR_TARGET:
1422 case ACPI_ADR_SPACE_DATA_TABLE:
1423 case ACPI_ADR_SPACE_FIXED_HARDWARE:
1424 break;
1425 }
1426 return AE_OK;
1427}
1428
Bob Mooreb229cf92006-04-21 17:15:00 -04001429/******************************************************************************
1430 *
1431 * FUNCTION: acpi_os_validate_address
1432 *
1433 * PARAMETERS: space_id - ACPI space ID
1434 * address - Physical address
1435 * length - Address length
1436 *
1437 * RETURN: AE_OK if address/length is valid for the space_id. Otherwise,
1438 * should return AE_AML_ILLEGAL_ADDRESS.
1439 *
1440 * DESCRIPTION: Validate a system address via the host OS. Used to validate
1441 * the addresses accessed by AML operation regions.
1442 *
1443 *****************************************************************************/
1444
1445acpi_status
1446acpi_os_validate_address (
1447 u8 space_id,
1448 acpi_physical_address address,
Thomas Renningerdf92e692008-02-04 23:31:22 -08001449 acpi_size length,
1450 char *name)
Bob Mooreb229cf92006-04-21 17:15:00 -04001451{
Thomas Renningerdf92e692008-02-04 23:31:22 -08001452 struct acpi_res_list *res;
Lin Minga5fe1a02009-08-13 10:43:27 +08001453 int added;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001454 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1455 return AE_OK;
Bob Mooreb229cf92006-04-21 17:15:00 -04001456
Thomas Renningerdf92e692008-02-04 23:31:22 -08001457 switch (space_id) {
1458 case ACPI_ADR_SPACE_SYSTEM_IO:
1459 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
1460 /* Only interference checks against SystemIO and SytemMemory
1461 are needed */
1462 res = kzalloc(sizeof(struct acpi_res_list), GFP_KERNEL);
1463 if (!res)
1464 return AE_OK;
1465 /* ACPI names are fixed to 4 bytes, still better use strlcpy */
1466 strlcpy(res->name, name, 5);
1467 res->start = address;
1468 res->end = address + length - 1;
1469 res->resource_type = space_id;
1470 spin_lock(&acpi_res_lock);
Lin Minga5fe1a02009-08-13 10:43:27 +08001471 added = acpi_res_list_add(res);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001472 spin_unlock(&acpi_res_lock);
Lin Minga5fe1a02009-08-13 10:43:27 +08001473 pr_debug("%s %s resource: start: 0x%llx, end: 0x%llx, "
1474 "name: %s\n", added ? "Added" : "Already exist",
1475 (space_id == ACPI_ADR_SPACE_SYSTEM_IO)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001476 ? "SystemIO" : "System Memory",
1477 (unsigned long long)res->start,
1478 (unsigned long long)res->end,
1479 res->name);
Lin Minga5fe1a02009-08-13 10:43:27 +08001480 if (!added)
1481 kfree(res);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001482 break;
1483 case ACPI_ADR_SPACE_PCI_CONFIG:
1484 case ACPI_ADR_SPACE_EC:
1485 case ACPI_ADR_SPACE_SMBUS:
1486 case ACPI_ADR_SPACE_CMOS:
1487 case ACPI_ADR_SPACE_PCI_BAR_TARGET:
1488 case ACPI_ADR_SPACE_DATA_TABLE:
1489 case ACPI_ADR_SPACE_FIXED_HARDWARE:
1490 break;
1491 }
1492 return AE_OK;
Bob Mooreb229cf92006-04-21 17:15:00 -04001493}
1494
Robert Moore73459f72005-06-24 00:00:00 -04001495#endif