blob: ee11657b3339ef8a4e2968709cd7e9fb2b13633c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * acpi_osl.c - OS-dependent functions ($Revision: 83 $)
3 *
4 * Copyright (C) 2000 Andrew Henroid
5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04007 * Copyright (c) 2008 Intel Corporation
8 * Author: Matthew Wilcox <willy@linux.intel.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
27 *
28 */
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/slab.h>
33#include <linux/mm.h>
Myron Stoweba242d52012-01-20 19:13:30 -070034#include <linux/highmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/pci.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/interrupt.h>
37#include <linux/kmod.h>
38#include <linux/delay.h>
39#include <linux/workqueue.h>
40#include <linux/nmi.h>
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +030041#include <linux/acpi.h>
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
Lv Zheng1129c922013-07-23 16:11:55 +080051#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#define _COMPONENT ACPI_OS_SERVICES
Len Brownf52fd662007-02-12 22:42:12 -050054ACPI_MODULE_NAME("osl");
Hanjun Guo07070e12014-03-13 12:47:39 +080055
Len Brown4be44fc2005-08-05 00:44:28 -040056struct acpi_os_dpc {
57 acpi_osd_exec_callback function;
58 void *context;
David Howells65f27f32006-11-22 14:55:48 +000059 struct work_struct work;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060};
61
62#ifdef CONFIG_ACPI_CUSTOM_DSDT
63#include CONFIG_ACPI_CUSTOM_DSDT_FILE
64#endif
65
66#ifdef ENABLE_DEBUGGER
67#include <linux/kdb.h>
68
69/* stuff for debugger support */
70int acpi_in_debugger;
71EXPORT_SYMBOL(acpi_in_debugger);
72
73extern char line_buf[80];
Len Brown4be44fc2005-08-05 00:44:28 -040074#endif /*ENABLE_DEBUGGER */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Tang Liang09f98a82011-12-09 10:05:54 +080076static int (*__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl,
77 u32 pm1b_ctrl);
Ben Guthrod6b47b12013-07-30 08:24:52 -040078static int (*__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a,
79 u32 val_b);
Tang Liang09f98a82011-12-09 10:05:54 +080080
Linus Torvalds1da177e2005-04-16 15:20:36 -070081static acpi_osd_handler acpi_irq_handler;
82static void *acpi_irq_context;
83static struct workqueue_struct *kacpid_wq;
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -040084static struct workqueue_struct *kacpi_notify_wq;
Yinghai Lu92d8aff2013-01-21 13:20:47 -080085static struct workqueue_struct *kacpi_hotplug_wq;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Myron Stowe620242a2010-10-21 14:23:53 -060087/*
88 * This list of permanent mappings is for memory that may be accessed from
89 * interrupt context, where we can't do the ioremap().
90 */
91struct acpi_ioremap {
92 struct list_head list;
93 void __iomem *virt;
94 acpi_physical_address phys;
95 acpi_size size;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +010096 unsigned long refcount;
Myron Stowe620242a2010-10-21 14:23:53 -060097};
98
99static LIST_HEAD(acpi_ioremaps);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100100static DEFINE_MUTEX(acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600101
Lin Mingb0ed7a92010-08-06 09:35:51 +0800102static void __init acpi_osi_setup_late(void);
Len Brownae00d812007-05-29 18:43:33 -0400103
Len Brownd4b7dc42008-01-23 20:50:56 -0500104/*
Len Browna6e08872008-11-08 01:21:10 -0500105 * The story of _OSI(Linux)
Len Brownd4b7dc42008-01-23 20:50:56 -0500106 *
Len Browna6e08872008-11-08 01:21:10 -0500107 * From pre-history through Linux-2.6.22,
108 * Linux responded TRUE upon a BIOS OSI(Linux) query.
Len Brownd4b7dc42008-01-23 20:50:56 -0500109 *
Len Browna6e08872008-11-08 01:21:10 -0500110 * Unfortunately, reference BIOS writers got wind of this
111 * and put OSI(Linux) in their example code, quickly exposing
112 * this string as ill-conceived and opening the door to
113 * an un-bounded number of BIOS incompatibilities.
Len Brownd4b7dc42008-01-23 20:50:56 -0500114 *
Len Browna6e08872008-11-08 01:21:10 -0500115 * For example, OSI(Linux) was used on resume to re-POST a
116 * video card on one system, because Linux at that time
117 * could not do a speedy restore in its native driver.
118 * But then upon gaining quick native restore capability,
119 * Linux has no way to tell the BIOS to skip the time-consuming
120 * POST -- putting Linux at a permanent performance disadvantage.
121 * On another system, the BIOS writer used OSI(Linux)
122 * to infer native OS support for IPMI! On other systems,
123 * OSI(Linux) simply got in the way of Linux claiming to
124 * be compatible with other operating systems, exposing
125 * BIOS issues such as skipped device initialization.
Len Brownd4b7dc42008-01-23 20:50:56 -0500126 *
Len Browna6e08872008-11-08 01:21:10 -0500127 * So "Linux" turned out to be a really poor chose of
128 * OSI string, and from Linux-2.6.23 onward we respond FALSE.
Len Brownd4b7dc42008-01-23 20:50:56 -0500129 *
130 * BIOS writers should NOT query _OSI(Linux) on future systems.
Len Browna6e08872008-11-08 01:21:10 -0500131 * Linux will complain on the console when it sees it, and return FALSE.
132 * To get Linux to return TRUE for your system will require
133 * a kernel source update to add a DMI entry,
134 * or boot with "acpi_osi=Linux"
Len Brownd4b7dc42008-01-23 20:50:56 -0500135 */
Len Brownd4b7dc42008-01-23 20:50:56 -0500136
Adrian Bunk1d15d842008-01-29 00:10:15 +0200137static struct osi_linux {
Len Brownd4b7dc42008-01-23 20:50:56 -0500138 unsigned int enable:1;
139 unsigned int dmi:1;
140 unsigned int cmdline:1;
Lv Zheng5dc17982013-07-22 16:08:25 +0800141 unsigned int default_disabling:1;
142} osi_linux = {0, 0, 0, 0};
Len Brownf5076542007-05-30 00:10:38 -0400143
Lin Mingb0ed7a92010-08-06 09:35:51 +0800144static u32 acpi_osi_handler(acpi_string interface, u32 supported)
145{
146 if (!strcmp("Linux", interface)) {
147
Len Brown89976212011-08-02 00:45:48 -0400148 printk_once(KERN_NOTICE FW_BUG PREFIX
Lin Mingb0ed7a92010-08-06 09:35:51 +0800149 "BIOS _OSI(Linux) query %s%s\n",
150 osi_linux.enable ? "honored" : "ignored",
151 osi_linux.cmdline ? " via cmdline" :
152 osi_linux.dmi ? " via DMI" : "");
153 }
154
155 return supported;
156}
157
Myron Stowebc9ffce2011-11-07 16:23:27 -0700158static void __init acpi_request_region (struct acpi_generic_address *gas,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700159 unsigned int length, char *desc)
160{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700161 u64 addr;
162
163 /* Handle possible alignment issues */
164 memcpy(&addr, &gas->address, sizeof(addr));
165 if (!addr || !length)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700166 return;
167
Andi Kleencfa806f2010-07-20 15:18:36 -0700168 /* Resources are never freed */
Myron Stowebc9ffce2011-11-07 16:23:27 -0700169 if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
170 request_region(addr, length, desc);
171 else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
172 request_mem_region(addr, length, desc);
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700173}
174
175static int __init acpi_reserve_resources(void)
176{
Len Browneee3c852007-02-03 01:38:16 -0500177 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700178 "ACPI PM1a_EVT_BLK");
179
Len Browneee3c852007-02-03 01:38:16 -0500180 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700181 "ACPI PM1b_EVT_BLK");
182
Len Browneee3c852007-02-03 01:38:16 -0500183 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700184 "ACPI PM1a_CNT_BLK");
185
Len Browneee3c852007-02-03 01:38:16 -0500186 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700187 "ACPI PM1b_CNT_BLK");
188
Len Browneee3c852007-02-03 01:38:16 -0500189 if (acpi_gbl_FADT.pm_timer_length == 4)
190 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700191
Len Browneee3c852007-02-03 01:38:16 -0500192 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700193 "ACPI PM2_CNT_BLK");
194
195 /* Length of GPE blocks must be a non-negative multiple of 2 */
196
Len Browneee3c852007-02-03 01:38:16 -0500197 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
198 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
199 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700200
Len Browneee3c852007-02-03 01:38:16 -0500201 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
202 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
203 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700204
205 return 0;
206}
207device_initcall(acpi_reserve_resources);
208
Len Brown4be44fc2005-08-05 00:44:28 -0400209void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
211 va_list args;
212 va_start(args, fmt);
213 acpi_os_vprintf(fmt, args);
214 va_end(args);
215}
Len Brown4be44fc2005-08-05 00:44:28 -0400216
Len Brown4be44fc2005-08-05 00:44:28 -0400217void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 vsprintf(buffer, fmt, args);
222
223#ifdef ENABLE_DEBUGGER
224 if (acpi_in_debugger) {
225 kdb_printf("%s", buffer);
226 } else {
Frank Seidel4d939152009-02-04 17:03:07 +0100227 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
229#else
Frank Seidel4d939152009-02-04 17:03:07 +0100230 printk(KERN_CONT "%s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231#endif
232}
233
Takao Indoh4996c022011-07-14 18:05:21 -0400234#ifdef CONFIG_KEXEC
235static unsigned long acpi_rsdp;
236static int __init setup_acpi_rsdp(char *arg)
237{
238 acpi_rsdp = simple_strtoul(arg, NULL, 16);
239 return 0;
240}
241early_param("acpi_rsdp", setup_acpi_rsdp);
242#endif
243
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300244acpi_physical_address __init acpi_os_get_root_pointer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
Takao Indoh4996c022011-07-14 18:05:21 -0400246#ifdef CONFIG_KEXEC
247 if (acpi_rsdp)
248 return acpi_rsdp;
249#endif
250
Matt Fleming83e68182012-11-14 09:42:35 +0000251 if (efi_enabled(EFI_CONFIG_TABLES)) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800252 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300253 return efi.acpi20;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800254 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300255 return efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400257 printk(KERN_ERR PREFIX
258 "System description tables not found\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300259 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
Len Brown239665a2007-11-23 20:08:02 -0500261 } else {
262 acpi_physical_address pa = 0;
263
264 acpi_find_root_pointer(&pa);
265 return pa;
266 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267}
268
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600269/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe4a3cba52010-10-21 14:24:14 -0600270static struct acpi_ioremap *
271acpi_map_lookup(acpi_physical_address phys, acpi_size size)
Myron Stowe620242a2010-10-21 14:23:53 -0600272{
273 struct acpi_ioremap *map;
274
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600275 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe620242a2010-10-21 14:23:53 -0600276 if (map->phys <= phys &&
277 phys + size <= map->phys + map->size)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600278 return map;
279
280 return NULL;
281}
282
283/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
284static void __iomem *
285acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size)
286{
287 struct acpi_ioremap *map;
288
289 map = acpi_map_lookup(phys, size);
290 if (map)
291 return map->virt + (phys - map->phys);
Myron Stowe620242a2010-10-21 14:23:53 -0600292
293 return NULL;
294}
295
Rafael J. Wysocki13606a22011-02-08 23:38:25 +0100296void __iomem *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size)
297{
298 struct acpi_ioremap *map;
299 void __iomem *virt = NULL;
300
301 mutex_lock(&acpi_ioremap_lock);
302 map = acpi_map_lookup(phys, size);
303 if (map) {
304 virt = map->virt + (phys - map->phys);
305 map->refcount++;
306 }
307 mutex_unlock(&acpi_ioremap_lock);
308 return virt;
309}
310EXPORT_SYMBOL_GPL(acpi_os_get_iomem);
311
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600312/* Must be called with 'acpi_ioremap_lock' or RCU read lock held. */
Myron Stowe620242a2010-10-21 14:23:53 -0600313static struct acpi_ioremap *
314acpi_map_lookup_virt(void __iomem *virt, acpi_size size)
315{
316 struct acpi_ioremap *map;
317
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600318 list_for_each_entry_rcu(map, &acpi_ioremaps, list)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600319 if (map->virt <= virt &&
320 virt + size <= map->virt + map->size)
Myron Stowe620242a2010-10-21 14:23:53 -0600321 return map;
322
323 return NULL;
324}
325
Myron Stoweba242d52012-01-20 19:13:30 -0700326#ifndef CONFIG_IA64
327#define should_use_kmap(pfn) page_is_ram(pfn)
328#else
329/* ioremap will take care of cache attributes */
330#define should_use_kmap(pfn) 0
331#endif
332
333static void __iomem *acpi_map(acpi_physical_address pg_off, unsigned long pg_sz)
334{
335 unsigned long pfn;
336
337 pfn = pg_off >> PAGE_SHIFT;
338 if (should_use_kmap(pfn)) {
339 if (pg_sz > PAGE_SIZE)
340 return NULL;
341 return (void __iomem __force *)kmap(pfn_to_page(pfn));
342 } else
343 return acpi_os_ioremap(pg_off, pg_sz);
344}
345
346static void acpi_unmap(acpi_physical_address pg_off, void __iomem *vaddr)
347{
348 unsigned long pfn;
349
350 pfn = pg_off >> PAGE_SHIFT;
Jan Beuliche2526752012-02-24 11:41:53 +0000351 if (should_use_kmap(pfn))
Myron Stoweba242d52012-01-20 19:13:30 -0700352 kunmap(pfn_to_page(pfn));
353 else
354 iounmap(vaddr);
355}
356
Jan Beulich2fdf0742007-12-13 08:33:59 +0000357void __iomem *__init_refok
358acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100360 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600361 void __iomem *virt;
Rafael J. Wysocki2d6d9fd2011-01-19 22:27:14 +0100362 acpi_physical_address pg_off;
363 acpi_size pg_sz;
Myron Stowe620242a2010-10-21 14:23:53 -0600364
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800365 if (phys > ULONG_MAX) {
366 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
Randy Dunlap70c08462007-02-13 16:11:36 -0800367 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 }
Myron Stowe620242a2010-10-21 14:23:53 -0600369
370 if (!acpi_gbl_permanent_mmap)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300371 return __acpi_map_table((unsigned long)phys, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600372
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100373 mutex_lock(&acpi_ioremap_lock);
374 /* Check if there's a suitable mapping already. */
375 map = acpi_map_lookup(phys, size);
376 if (map) {
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100377 map->refcount++;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100378 goto out;
379 }
380
Myron Stowe620242a2010-10-21 14:23:53 -0600381 map = kzalloc(sizeof(*map), GFP_KERNEL);
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100382 if (!map) {
383 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600384 return NULL;
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100385 }
Myron Stowe620242a2010-10-21 14:23:53 -0600386
Myron Stowe4a3cba52010-10-21 14:24:14 -0600387 pg_off = round_down(phys, PAGE_SIZE);
388 pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off;
Myron Stoweba242d52012-01-20 19:13:30 -0700389 virt = acpi_map(pg_off, pg_sz);
Myron Stowe620242a2010-10-21 14:23:53 -0600390 if (!virt) {
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100391 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600392 kfree(map);
393 return NULL;
394 }
395
396 INIT_LIST_HEAD(&map->list);
397 map->virt = virt;
Myron Stowe4a3cba52010-10-21 14:24:14 -0600398 map->phys = pg_off;
399 map->size = pg_sz;
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100400 map->refcount = 1;
Myron Stowe620242a2010-10-21 14:23:53 -0600401
Myron Stowe78cdb3e2010-10-21 14:24:09 -0600402 list_add_tail_rcu(&map->list, &acpi_ioremaps);
Myron Stowe620242a2010-10-21 14:23:53 -0600403
Rafael J. Wysocki7ffd0442011-02-08 23:38:05 +0100404 out:
405 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600406 return map->virt + (phys - map->phys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800408EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100410static void acpi_os_drop_map_ref(struct acpi_ioremap *map)
Myron Stowe4a3cba52010-10-21 14:24:14 -0600411{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100412 if (!--map->refcount)
413 list_del_rcu(&map->list);
Myron Stowe4a3cba52010-10-21 14:24:14 -0600414}
Myron Stowe4a3cba52010-10-21 14:24:14 -0600415
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100416static void acpi_os_map_cleanup(struct acpi_ioremap *map)
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100417{
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100418 if (!map->refcount) {
419 synchronize_rcu();
Myron Stoweba242d52012-01-20 19:13:30 -0700420 acpi_unmap(map->phys, map->virt);
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100421 kfree(map);
422 }
Myron Stowe4a3cba52010-10-21 14:24:14 -0600423}
424
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800425void __ref acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
Myron Stowe620242a2010-10-21 14:23:53 -0600427 struct acpi_ioremap *map;
Myron Stowe620242a2010-10-21 14:23:53 -0600428
429 if (!acpi_gbl_permanent_mmap) {
Yinghai Lu7d972772009-02-07 15:39:41 -0800430 __acpi_unmap_table(virt, size);
Myron Stowe620242a2010-10-21 14:23:53 -0600431 return;
432 }
433
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100434 mutex_lock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600435 map = acpi_map_lookup_virt(virt, size);
436 if (!map) {
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100437 mutex_unlock(&acpi_ioremap_lock);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100438 WARN(true, PREFIX "%s: bad address %p\n", __func__, virt);
Myron Stowe620242a2010-10-21 14:23:53 -0600439 return;
440 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100441 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100442 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe620242a2010-10-21 14:23:53 -0600443
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100444 acpi_os_map_cleanup(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800446EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Jeremy Fitzhardinge0d3a9cf2009-02-22 14:58:56 -0800448void __init early_acpi_os_unmap_memory(void __iomem *virt, acpi_size size)
Yinghai Lu7d972772009-02-07 15:39:41 -0800449{
450 if (!acpi_gbl_permanent_mmap)
451 __acpi_unmap_table(virt, size);
452}
453
Myron Stowe6f68c912011-11-07 16:23:34 -0700454int acpi_os_map_generic_address(struct acpi_generic_address *gas)
Myron Stowe29718522010-10-21 14:23:59 -0600455{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700456 u64 addr;
Myron Stowe29718522010-10-21 14:23:59 -0600457 void __iomem *virt;
458
Myron Stowebc9ffce2011-11-07 16:23:27 -0700459 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
Myron Stowe29718522010-10-21 14:23:59 -0600460 return 0;
461
Myron Stowebc9ffce2011-11-07 16:23:27 -0700462 /* Handle possible alignment issues */
463 memcpy(&addr, &gas->address, sizeof(addr));
464 if (!addr || !gas->bit_width)
Myron Stowe29718522010-10-21 14:23:59 -0600465 return -EINVAL;
466
Myron Stowebc9ffce2011-11-07 16:23:27 -0700467 virt = acpi_os_map_memory(addr, gas->bit_width / 8);
Myron Stowe29718522010-10-21 14:23:59 -0600468 if (!virt)
469 return -EIO;
470
471 return 0;
472}
Myron Stowe6f68c912011-11-07 16:23:34 -0700473EXPORT_SYMBOL(acpi_os_map_generic_address);
Myron Stowe29718522010-10-21 14:23:59 -0600474
Myron Stowe6f68c912011-11-07 16:23:34 -0700475void acpi_os_unmap_generic_address(struct acpi_generic_address *gas)
Myron Stowe29718522010-10-21 14:23:59 -0600476{
Myron Stowebc9ffce2011-11-07 16:23:27 -0700477 u64 addr;
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100478 struct acpi_ioremap *map;
Myron Stowe29718522010-10-21 14:23:59 -0600479
Myron Stowebc9ffce2011-11-07 16:23:27 -0700480 if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY)
Myron Stowe29718522010-10-21 14:23:59 -0600481 return;
482
Myron Stowebc9ffce2011-11-07 16:23:27 -0700483 /* Handle possible alignment issues */
484 memcpy(&addr, &gas->address, sizeof(addr));
485 if (!addr || !gas->bit_width)
Myron Stowe29718522010-10-21 14:23:59 -0600486 return;
487
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100488 mutex_lock(&acpi_ioremap_lock);
Myron Stowebc9ffce2011-11-07 16:23:27 -0700489 map = acpi_map_lookup(addr, gas->bit_width / 8);
Rafael J. Wysocki7fe135d2011-02-08 23:37:53 +0100490 if (!map) {
491 mutex_unlock(&acpi_ioremap_lock);
492 return;
493 }
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100494 acpi_os_drop_map_ref(map);
Rafael J. Wysocki7bbb8902011-02-08 23:37:42 +0100495 mutex_unlock(&acpi_ioremap_lock);
Myron Stowe29718522010-10-21 14:23:59 -0600496
Rafael J. Wysockib7c1fad2011-02-08 23:38:15 +0100497 acpi_os_map_cleanup(map);
Myron Stowe29718522010-10-21 14:23:59 -0600498}
Myron Stowe6f68c912011-11-07 16:23:34 -0700499EXPORT_SYMBOL(acpi_os_unmap_generic_address);
Myron Stowe29718522010-10-21 14:23:59 -0600500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501#ifdef ACPI_FUTURE_USAGE
502acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400503acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504{
Len Brown4be44fc2005-08-05 00:44:28 -0400505 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return AE_BAD_PARAMETER;
507
508 *phys = virt_to_phys(virt);
509
510 return AE_OK;
511}
512#endif
513
514#define ACPI_MAX_OVERRIDE_LEN 100
515
516static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
517
518acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400519acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
520 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
522 if (!init_val || !new_val)
523 return AE_BAD_PARAMETER;
524
525 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400526 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400528 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 *new_val = acpi_os_name;
530 }
531
532 return AE_OK;
533}
534
Thomas Renninger53aac442012-10-01 00:23:54 +0200535#ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
536#include <linux/earlycpio.h>
537#include <linux/memblock.h>
538
539static u64 acpi_tables_addr;
540static int all_tables_size;
541
542/* Copied from acpica/tbutils.c:acpi_tb_checksum() */
Rashika66e162b2013-12-17 14:43:05 +0530543static u8 __init acpi_table_checksum(u8 *buffer, u32 length)
Thomas Renninger53aac442012-10-01 00:23:54 +0200544{
545 u8 sum = 0;
546 u8 *end = buffer + length;
547
548 while (buffer < end)
549 sum = (u8) (sum + *(buffer++));
550 return sum;
551}
552
553/* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: */
554static const char * const table_sigs[] = {
555 ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ,
556 ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT,
557 ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF,
558 ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET,
559 ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI,
560 ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA,
561 ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT,
562 ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT,
563 ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL };
564
Thomas Renninger53aac442012-10-01 00:23:54 +0200565#define ACPI_HEADER_SIZE sizeof(struct acpi_table_header)
566
Yinghai Lubee7f9c2013-09-06 19:08:00 -0700567#define ACPI_OVERRIDE_TABLES 64
568static struct cpio_data __initdata acpi_initrd_files[ACPI_OVERRIDE_TABLES];
569
570#define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT)
Thomas Renninger53aac442012-10-01 00:23:54 +0200571
572void __init acpi_initrd_override(void *data, size_t size)
573{
574 int sig, no, table_nr = 0, total_offset = 0;
575 long offset = 0;
576 struct acpi_table_header *table;
577 char cpio_path[32] = "kernel/firmware/acpi/";
578 struct cpio_data file;
Thomas Renninger53aac442012-10-01 00:23:54 +0200579
580 if (data == NULL || size == 0)
581 return;
582
583 for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) {
584 file = find_cpio_data(cpio_path, data, size, &offset);
585 if (!file.data)
586 break;
587
588 data += offset;
589 size -= offset;
590
Tang Chen7702ae02013-08-14 17:37:08 +0800591 if (file.size < sizeof(struct acpi_table_header)) {
592 pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n",
593 cpio_path, file.name);
594 continue;
595 }
Thomas Renninger53aac442012-10-01 00:23:54 +0200596
597 table = file.data;
598
599 for (sig = 0; table_sigs[sig]; sig++)
600 if (!memcmp(table->signature, table_sigs[sig], 4))
601 break;
602
Tang Chen7702ae02013-08-14 17:37:08 +0800603 if (!table_sigs[sig]) {
604 pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n",
605 cpio_path, file.name);
606 continue;
607 }
608 if (file.size != table->length) {
609 pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n",
610 cpio_path, file.name);
611 continue;
612 }
613 if (acpi_table_checksum(file.data, table->length)) {
614 pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n",
615 cpio_path, file.name);
616 continue;
617 }
Thomas Renninger53aac442012-10-01 00:23:54 +0200618
619 pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n",
620 table->signature, cpio_path, file.name, table->length);
621
622 all_tables_size += table->length;
Yinghai Lubee7f9c2013-09-06 19:08:00 -0700623 acpi_initrd_files[table_nr].data = file.data;
624 acpi_initrd_files[table_nr].size = file.size;
Thomas Renninger53aac442012-10-01 00:23:54 +0200625 table_nr++;
626 }
627 if (table_nr == 0)
628 return;
629
630 acpi_tables_addr =
631 memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT,
632 all_tables_size, PAGE_SIZE);
633 if (!acpi_tables_addr) {
634 WARN_ON(1);
635 return;
636 }
637 /*
638 * Only calling e820_add_reserve does not work and the
639 * tables are invalid (memory got used) later.
640 * memblock_reserve works as expected and the tables won't get modified.
641 * But it's not enough on X86 because ioremap will
642 * complain later (used by acpi_os_map_memory) that the pages
643 * that should get mapped are not marked "reserved".
644 * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area)
645 * works fine.
646 */
Wang YanQinga6432de2013-04-23 01:19:19 +0200647 memblock_reserve(acpi_tables_addr, all_tables_size);
Thomas Renninger53aac442012-10-01 00:23:54 +0200648 arch_reserve_mem_area(acpi_tables_addr, all_tables_size);
649
Yinghai Lubee7f9c2013-09-06 19:08:00 -0700650 /*
651 * early_ioremap only can remap 256k one time. If we map all
652 * tables one time, we will hit the limit. Need to map chunks
653 * one by one during copying the same as that in relocate_initrd().
654 */
Thomas Renninger53aac442012-10-01 00:23:54 +0200655 for (no = 0; no < table_nr; no++) {
Yinghai Lubee7f9c2013-09-06 19:08:00 -0700656 unsigned char *src_p = acpi_initrd_files[no].data;
657 phys_addr_t size = acpi_initrd_files[no].size;
658 phys_addr_t dest_addr = acpi_tables_addr + total_offset;
659 phys_addr_t slop, clen;
660 char *dest_p;
661
662 total_offset += size;
663
664 while (size) {
665 slop = dest_addr & ~PAGE_MASK;
666 clen = size;
667 if (clen > MAP_CHUNK_SIZE - slop)
668 clen = MAP_CHUNK_SIZE - slop;
669 dest_p = early_ioremap(dest_addr & PAGE_MASK,
670 clen + slop);
671 memcpy(dest_p + slop, src_p, clen);
672 early_iounmap(dest_p, clen + slop);
673 src_p += clen;
674 dest_addr += clen;
675 size -= clen;
676 }
Thomas Renninger53aac442012-10-01 00:23:54 +0200677 }
Thomas Renninger53aac442012-10-01 00:23:54 +0200678}
679#endif /* CONFIG_ACPI_INITRD_TABLE_OVERRIDE */
680
Thomas Renninger325a8d362012-10-01 00:23:56 +0200681static void acpi_table_taint(struct acpi_table_header *table)
682{
683 pr_warn(PREFIX
684 "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n",
685 table->signature, table->oem_table_id);
Rusty Russell373d4d02013-01-21 17:17:39 +1030686 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE);
Thomas Renninger325a8d362012-10-01 00:23:56 +0200687}
688
689
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400691acpi_os_table_override(struct acpi_table_header * existing_table,
692 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
694 if (!existing_table || !new_table)
695 return AE_BAD_PARAMETER;
696
Markus Gaugusch71fc47a2008-02-05 00:04:06 +0100697 *new_table = NULL;
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699#ifdef CONFIG_ACPI_CUSTOM_DSDT
700 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400701 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702#endif
Thomas Renninger325a8d362012-10-01 00:23:56 +0200703 if (*new_table != NULL)
704 acpi_table_taint(existing_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 return AE_OK;
706}
707
Bob Mooref7b004a2012-02-14 18:31:56 +0800708acpi_status
709acpi_os_physical_table_override(struct acpi_table_header *existing_table,
Thomas Renningerb2a35002012-10-01 00:23:55 +0200710 acpi_physical_address *address,
711 u32 *table_length)
Bob Mooref7b004a2012-02-14 18:31:56 +0800712{
Thomas Renningerb2a35002012-10-01 00:23:55 +0200713#ifndef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
714 *table_length = 0;
715 *address = 0;
716 return AE_OK;
717#else
718 int table_offset = 0;
719 struct acpi_table_header *table;
Bob Mooref7b004a2012-02-14 18:31:56 +0800720
Thomas Renningerb2a35002012-10-01 00:23:55 +0200721 *table_length = 0;
722 *address = 0;
723
724 if (!acpi_tables_addr)
725 return AE_OK;
726
727 do {
728 if (table_offset + ACPI_HEADER_SIZE > all_tables_size) {
729 WARN_ON(1);
730 return AE_OK;
731 }
732
733 table = acpi_os_map_memory(acpi_tables_addr + table_offset,
734 ACPI_HEADER_SIZE);
735
736 if (table_offset + table->length > all_tables_size) {
737 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
738 WARN_ON(1);
739 return AE_OK;
740 }
741
742 table_offset += table->length;
743
744 if (memcmp(existing_table->signature, table->signature, 4)) {
745 acpi_os_unmap_memory(table,
746 ACPI_HEADER_SIZE);
747 continue;
748 }
749
750 /* Only override tables with matching oem id */
751 if (memcmp(table->oem_table_id, existing_table->oem_table_id,
752 ACPI_OEM_TABLE_ID_SIZE)) {
753 acpi_os_unmap_memory(table,
754 ACPI_HEADER_SIZE);
755 continue;
756 }
757
758 table_offset -= table->length;
759 *table_length = table->length;
760 acpi_os_unmap_memory(table, ACPI_HEADER_SIZE);
761 *address = acpi_tables_addr + table_offset;
762 break;
763 } while (table_offset + ACPI_HEADER_SIZE < all_tables_size);
764
Thomas Renninger325a8d362012-10-01 00:23:56 +0200765 if (*address != 0)
766 acpi_table_taint(existing_table);
Thomas Renningerb2a35002012-10-01 00:23:55 +0200767 return AE_OK;
768#endif
769}
Bob Mooref7b004a2012-02-14 18:31:56 +0800770
David Howells7d12e782006-10-05 14:55:46 +0100771static irqreturn_t acpi_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
Len Brown5229e872008-02-06 01:26:55 -0500773 u32 handled;
774
775 handled = (*acpi_irq_handler) (acpi_irq_context);
776
777 if (handled) {
778 acpi_irq_handled++;
779 return IRQ_HANDLED;
Len Brown88bea182009-04-21 00:35:47 -0400780 } else {
781 acpi_irq_not_handled++;
Len Brown5229e872008-02-06 01:26:55 -0500782 return IRQ_NONE;
Len Brown88bea182009-04-21 00:35:47 -0400783 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784}
785
786acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400787acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
788 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
790 unsigned int irq;
791
Len Brown5229e872008-02-06 01:26:55 -0500792 acpi_irq_stats_init();
793
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 /*
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100795 * ACPI interrupts different from the SCI in our copy of the FADT are
796 * not supported.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 */
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100798 if (gsi != acpi_gbl_FADT.sci_interrupt)
799 return AE_BAD_PARAMETER;
800
801 if (acpi_irq_handler)
802 return AE_ALREADY_ACQUIRED;
803
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
805 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
806 gsi);
807 return AE_OK;
808 }
809
810 acpi_irq_handler = handler;
811 acpi_irq_context = context;
Zhang Rui89a22da2013-02-04 07:10:10 +0000812 if (request_irq(irq, acpi_irq, IRQF_SHARED | IRQF_NO_SUSPEND, "acpi", acpi_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100814 acpi_irq_handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 return AE_NOT_ACQUIRED;
816 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
818 return AE_OK;
819}
820
Len Brown4be44fc2005-08-05 00:44:28 -0400821acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +0100823 if (irq != acpi_gbl_FADT.sci_interrupt)
824 return AE_BAD_PARAMETER;
825
826 free_irq(irq, acpi_irq);
827 acpi_irq_handler = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
829 return AE_OK;
830}
831
832/*
833 * Running in interpreter thread context, safe to sleep
834 */
835
Lin Ming439913f2010-01-28 10:53:19 +0800836void acpi_os_sleep(u64 ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
Liu Chuansheng30282292013-09-12 01:42:57 +0800838 msleep(ms);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839}
Len Brown4be44fc2005-08-05 00:44:28 -0400840
Len Brown4be44fc2005-08-05 00:44:28 -0400841void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842{
843 while (us) {
844 u32 delay = 1000;
845
846 if (delay > us)
847 delay = us;
848 udelay(delay);
849 touch_nmi_watchdog();
850 us -= delay;
851 }
852}
Len Brown4be44fc2005-08-05 00:44:28 -0400853
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854/*
855 * Support ACPI 3.0 AML Timer operand
856 * Returns 64-bit free-running, monotonically increasing timer
857 * with 100ns granularity
858 */
Len Brown4be44fc2005-08-05 00:44:28 -0400859u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Mika Westerberg10619062013-05-23 10:27:46 +0300861 u64 time_ns = ktime_to_ns(ktime_get());
862 do_div(time_ns, 100);
863 return time_ns;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864}
865
Len Brown4be44fc2005-08-05 00:44:28 -0400866acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867{
868 u32 dummy;
869
870 if (!value)
871 value = &dummy;
872
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800873 *value = 0;
874 if (width <= 8) {
Len Brown4be44fc2005-08-05 00:44:28 -0400875 *(u8 *) value = inb(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800876 } else if (width <= 16) {
Len Brown4be44fc2005-08-05 00:44:28 -0400877 *(u16 *) value = inw(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800878 } else if (width <= 32) {
Len Brown4be44fc2005-08-05 00:44:28 -0400879 *(u32 *) value = inl(port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800880 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 BUG();
882 }
883
884 return AE_OK;
885}
Len Brown4be44fc2005-08-05 00:44:28 -0400886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887EXPORT_SYMBOL(acpi_os_read_port);
888
Len Brown4be44fc2005-08-05 00:44:28 -0400889acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890{
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800891 if (width <= 8) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 outb(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800893 } else if (width <= 16) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 outw(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800895 } else if (width <= 32) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 outl(value, port);
Zhao Yakui49fbabf2007-11-15 17:01:06 +0800897 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 BUG();
899 }
900
901 return AE_OK;
902}
Len Brown4be44fc2005-08-05 00:44:28 -0400903
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904EXPORT_SYMBOL(acpi_os_write_port);
905
Myron Stowee615bf52012-01-20 19:13:24 -0700906#ifdef readq
907static inline u64 read64(const volatile void __iomem *addr)
908{
909 return readq(addr);
910}
911#else
912static inline u64 read64(const volatile void __iomem *addr)
913{
914 u64 l, h;
915 l = readl(addr);
916 h = readl(addr+4);
917 return l | (h << 32);
918}
919#endif
920
921acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800922acpi_os_read_memory(acpi_physical_address phys_addr, u64 *value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700923{
924 void __iomem *virt_addr;
925 unsigned int size = width / 8;
926 bool unmap = false;
927 u64 dummy;
928
929 rcu_read_lock();
930 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
931 if (!virt_addr) {
932 rcu_read_unlock();
933 virt_addr = acpi_os_ioremap(phys_addr, size);
934 if (!virt_addr)
935 return AE_BAD_ADDRESS;
936 unmap = true;
937 }
938
939 if (!value)
940 value = &dummy;
941
942 switch (width) {
943 case 8:
944 *(u8 *) value = readb(virt_addr);
945 break;
946 case 16:
947 *(u16 *) value = readw(virt_addr);
948 break;
949 case 32:
950 *(u32 *) value = readl(virt_addr);
951 break;
952 case 64:
953 *(u64 *) value = read64(virt_addr);
954 break;
955 default:
956 BUG();
957 }
958
959 if (unmap)
960 iounmap(virt_addr);
961 else
962 rcu_read_unlock();
963
964 return AE_OK;
965}
966
Myron Stowee615bf52012-01-20 19:13:24 -0700967#ifdef writeq
968static inline void write64(u64 val, volatile void __iomem *addr)
969{
970 writeq(val, addr);
971}
972#else
973static inline void write64(u64 val, volatile void __iomem *addr)
974{
975 writel(val, addr);
976 writel(val>>32, addr+4);
977}
978#endif
979
980acpi_status
Bob Moore653f4b52012-02-14 18:29:55 +0800981acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width)
Myron Stowee615bf52012-01-20 19:13:24 -0700982{
983 void __iomem *virt_addr;
984 unsigned int size = width / 8;
985 bool unmap = false;
986
987 rcu_read_lock();
988 virt_addr = acpi_map_vaddr_lookup(phys_addr, size);
989 if (!virt_addr) {
990 rcu_read_unlock();
991 virt_addr = acpi_os_ioremap(phys_addr, size);
992 if (!virt_addr)
993 return AE_BAD_ADDRESS;
994 unmap = true;
995 }
996
997 switch (width) {
998 case 8:
999 writeb(value, virt_addr);
1000 break;
1001 case 16:
1002 writew(value, virt_addr);
1003 break;
1004 case 32:
1005 writel(value, virt_addr);
1006 break;
1007 case 64:
1008 write64(value, virt_addr);
1009 break;
1010 default:
1011 BUG();
1012 }
1013
1014 if (unmap)
1015 iounmap(virt_addr);
1016 else
1017 rcu_read_unlock();
1018
1019 return AE_OK;
1020}
1021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001023acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Bob Moorec5f02312010-08-06 08:57:53 +08001024 u64 *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025{
1026 int result, size;
Bob Moorec5f02312010-08-06 08:57:53 +08001027 u32 value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
1029 if (!value)
1030 return AE_BAD_PARAMETER;
1031
1032 switch (width) {
1033 case 8:
1034 size = 1;
1035 break;
1036 case 16:
1037 size = 2;
1038 break;
1039 case 32:
1040 size = 4;
1041 break;
1042 default:
1043 return AE_ERROR;
1044 }
1045
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -05001046 result = raw_pci_read(pci_id->segment, pci_id->bus,
1047 PCI_DEVFN(pci_id->device, pci_id->function),
Bob Moorec5f02312010-08-06 08:57:53 +08001048 reg, size, &value32);
1049 *value = value32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050
1051 return (result ? AE_ERROR : AE_OK);
1052}
Len Brown4be44fc2005-08-05 00:44:28 -04001053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001055acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
Lin Ming439913f2010-01-28 10:53:19 +08001056 u64 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057{
1058 int result, size;
1059
1060 switch (width) {
1061 case 8:
1062 size = 1;
1063 break;
1064 case 16:
1065 size = 2;
1066 break;
1067 case 32:
1068 size = 4;
1069 break;
1070 default:
1071 return AE_ERROR;
1072 }
1073
Matthew Wilcoxb6ce0682008-02-10 09:45:28 -05001074 result = raw_pci_write(pci_id->segment, pci_id->bus,
1075 PCI_DEVFN(pci_id->device, pci_id->function),
1076 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
1078 return (result ? AE_ERROR : AE_OK);
1079}
1080
David Howells65f27f32006-11-22 14:55:48 +00001081static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082{
David Howells65f27f32006-11-22 14:55:48 +00001083 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Alexey Starikovskiy88db5e12007-05-09 23:31:03 -04001084
Zhang Rui19cd8472008-08-28 10:05:06 +08001085 dpc->function(dpc->context);
1086 kfree(dpc);
Zhang Rui19cd8472008-08-28 10:05:06 +08001087}
1088
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -04001089/*******************************************************************************
1090 *
1091 * FUNCTION: acpi_os_execute
1092 *
1093 * PARAMETERS: Type - Type of the callback
1094 * Function - Function to be executed
1095 * Context - Function parameters
1096 *
1097 * RETURN: Status
1098 *
1099 * DESCRIPTION: Depending on type, either queues function for deferred execution or
1100 * immediately executes function on a separate thread.
1101 *
1102 ******************************************************************************/
1103
Rafael J. Wysocki7b981182013-11-07 01:45:40 +01001104acpi_status acpi_os_execute(acpi_execute_type type,
1105 acpi_osd_exec_callback function, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106{
Len Brown4be44fc2005-08-05 00:44:28 -04001107 acpi_status status = AE_OK;
1108 struct acpi_os_dpc *dpc;
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +03001109 struct workqueue_struct *queue;
Zhang Rui19cd8472008-08-28 10:05:06 +08001110 int ret;
Len Brown72945b22006-07-12 22:46:42 -04001111 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1112 "Scheduling function [%p(%p)] for deferred execution.\n",
1113 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 /*
1116 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +00001117 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 * way that allows us to also free its memory inside the callee.
1119 * Because we may want to schedule several tasks with different
1120 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +00001121 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 */
Len Brown72945b22006-07-12 22:46:42 -04001123
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001124 dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 if (!dpc)
Lin Ming889c78b2008-12-31 09:23:57 +08001126 return AE_NO_MEMORY;
Linus Torvaldsb976fe12006-11-17 19:31:09 -08001127
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 dpc->function = function;
1129 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -08001130
Zhang Ruic02256b2009-06-23 10:20:29 +08001131 /*
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001132 * To prevent lockdep from complaining unnecessarily, make sure that
1133 * there is a different static lockdep key for each workqueue by using
1134 * INIT_WORK() for each of them separately.
Zhang Ruic02256b2009-06-23 10:20:29 +08001135 */
Rafael J. Wysocki7b981182013-11-07 01:45:40 +01001136 if (type == OSL_NOTIFY_HANDLER) {
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001137 queue = kacpi_notify_wq;
Zhang Ruibc736752010-03-22 15:48:54 +08001138 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001139 } else {
1140 queue = kacpid_wq;
Zhang Ruibc736752010-03-22 15:48:54 +08001141 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
Rafael J. Wysocki3ae45a22012-11-02 13:09:08 +01001142 }
Zhang Ruibc736752010-03-22 15:48:54 +08001143
Tejun Heo8fec62b2010-06-29 10:07:09 +02001144 /*
1145 * On some machines, a software-initiated SMI causes corruption unless
1146 * the SMI runs on CPU 0. An SMI can be initiated by any AML, but
1147 * typically it's done in GPE-related methods that are run via
1148 * workqueues, so we can avoid the known corruption cases by always
1149 * queueing on CPU 0.
1150 */
1151 ret = queue_work_on(0, queue, &dpc->work);
Zhang Rui19cd8472008-08-28 10:05:06 +08001152
1153 if (!ret) {
Lin Ming55ac9a02008-09-28 14:51:56 +08001154 printk(KERN_ERR PREFIX
1155 "Call to queue_work() failed.\n");
Alexey Starikovskiy17bc54e2007-11-13 13:05:45 +03001156 status = AE_ERROR;
1157 kfree(dpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 }
Lin Ming889c78b2008-12-31 09:23:57 +08001159 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160}
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -04001161EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162
Lin Mingbd6f10a2012-05-22 16:43:49 +08001163void acpi_os_wait_events_complete(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
1165 flush_workqueue(kacpid_wq);
Zhang Rui2f67a062008-04-29 02:34:42 -04001166 flush_workqueue(kacpi_notify_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167}
Len Brown4be44fc2005-08-05 00:44:28 -04001168
Rafael J. Wysocki7b981182013-11-07 01:45:40 +01001169struct acpi_hp_work {
1170 struct work_struct work;
1171 acpi_hp_callback func;
1172 void *data;
1173 u32 src;
1174};
1175
1176static void acpi_hotplug_work_fn(struct work_struct *work)
1177{
1178 struct acpi_hp_work *hpw = container_of(work, struct acpi_hp_work, work);
1179
1180 acpi_os_wait_events_complete();
1181 hpw->func(hpw->data, hpw->src);
1182 kfree(hpw);
1183}
1184
1185acpi_status acpi_hotplug_execute(acpi_hp_callback func, void *data, u32 src)
1186{
1187 struct acpi_hp_work *hpw;
1188
1189 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
1190 "Scheduling function [%p(%p, %u)] for deferred execution.\n",
1191 func, data, src));
1192
1193 hpw = kmalloc(sizeof(*hpw), GFP_KERNEL);
1194 if (!hpw)
1195 return AE_NO_MEMORY;
1196
1197 INIT_WORK(&hpw->work, acpi_hotplug_work_fn);
1198 hpw->func = func;
1199 hpw->data = data;
1200 hpw->src = src;
1201 /*
1202 * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because
1203 * the hotplug code may call driver .remove() functions, which may
1204 * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush
1205 * these workqueues.
1206 */
1207 if (!queue_work(kacpi_hotplug_wq, &hpw->work)) {
1208 kfree(hpw);
1209 return AE_ERROR;
1210 }
1211 return AE_OK;
1212}
1213
Rafael J. Wysockid7831562013-11-22 21:52:12 +01001214bool acpi_queue_hotplug_work(struct work_struct *work)
1215{
1216 return queue_work(kacpi_hotplug_wq, work);
1217}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001220acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221{
Len Brown4be44fc2005-08-05 00:44:28 -04001222 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 sem = acpi_os_allocate(sizeof(struct semaphore));
1225 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001226 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 memset(sem, 0, sizeof(struct semaphore));
1228
1229 sema_init(sem, initial_units);
1230
Len Brown4be44fc2005-08-05 00:44:28 -04001231 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232
Len Brown4be44fc2005-08-05 00:44:28 -04001233 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
1234 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235
Patrick Mocheld550d982006-06-27 00:41:40 -04001236 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239/*
1240 * TODO: A better way to delete semaphores? Linux doesn't have a
1241 * 'delete_semaphore()' function -- may result in an invalid
1242 * pointer dereference for non-synchronized consumers. Should
1243 * we at least check for blocked threads and signal/cancel them?
1244 */
1245
Len Brown4be44fc2005-08-05 00:44:28 -04001246acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247{
Len Brown4be44fc2005-08-05 00:44:28 -04001248 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -04001251 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252
Len Brown4be44fc2005-08-05 00:44:28 -04001253 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001255 BUG_ON(!list_empty(&sem->wait_list));
Len Brown02438d82006-06-30 03:19:10 -04001256 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -04001257 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258
Patrick Mocheld550d982006-06-27 00:41:40 -04001259 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 * TODO: Support for units > 1?
1264 */
Len Brown4be44fc2005-08-05 00:44:28 -04001265acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266{
Len Brown4be44fc2005-08-05 00:44:28 -04001267 acpi_status status = AE_OK;
1268 struct semaphore *sem = (struct semaphore *)handle;
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001269 long jiffies;
Len Brown4be44fc2005-08-05 00:44:28 -04001270 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001273 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001276 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Len Brown4be44fc2005-08-05 00:44:28 -04001278 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
1279 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001281 if (timeout == ACPI_WAIT_FOREVER)
1282 jiffies = MAX_SCHEDULE_TIMEOUT;
1283 else
1284 jiffies = msecs_to_jiffies(timeout);
Al Stonecad15252013-12-04 12:59:11 -07001285
Matthew Wilcoxf1241c82008-03-14 13:43:13 -04001286 ret = down_timeout(sem, jiffies);
1287 if (ret)
1288 status = AE_TIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
1290 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -04001291 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001292 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -04001293 handle, units, timeout,
1294 acpi_format_exception(status)));
1295 } else {
1296 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -04001297 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -04001298 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 }
1300
Patrick Mocheld550d982006-06-27 00:41:40 -04001301 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304/*
1305 * TODO: Support for units > 1?
1306 */
Len Brown4be44fc2005-08-05 00:44:28 -04001307acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308{
Len Brown4be44fc2005-08-05 00:44:28 -04001309 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -04001312 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313
1314 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -04001315 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Len Brown4be44fc2005-08-05 00:44:28 -04001317 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
1318 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
1320 up(sem);
1321
Patrick Mocheld550d982006-06-27 00:41:40 -04001322 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323}
Len Brown4be44fc2005-08-05 00:44:28 -04001324
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -04001326u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327{
1328
1329#ifdef ENABLE_DEBUGGER
1330 if (acpi_in_debugger) {
1331 u32 chars;
1332
1333 kdb_read(buffer, sizeof(line_buf));
1334
1335 /* remove the CR kdb includes */
1336 chars = strlen(buffer) - 1;
1337 buffer[chars] = '\0';
1338 }
1339#endif
1340
1341 return 0;
1342}
Len Brown4be44fc2005-08-05 00:44:28 -04001343#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Len Brown4be44fc2005-08-05 00:44:28 -04001345acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346{
Len Brown4be44fc2005-08-05 00:44:28 -04001347 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 case ACPI_SIGNAL_FATAL:
1349 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
1350 break;
1351 case ACPI_SIGNAL_BREAKPOINT:
1352 /*
1353 * AML Breakpoint
1354 * ACPI spec. says to treat it as a NOP unless
1355 * you are debugging. So if/when we integrate
1356 * AML debugger into the kernel debugger its
1357 * hook will go here. But until then it is
1358 * not useful to print anything on breakpoints.
1359 */
1360 break;
1361 default:
1362 break;
1363 }
1364
1365 return AE_OK;
1366}
Len Brown4be44fc2005-08-05 00:44:28 -04001367
Len Brown4be44fc2005-08-05 00:44:28 -04001368static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369{
1370 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -04001371 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
1373 if (!str || !*str)
1374 return 0;
1375
Dan Carpenter5e2be4e2013-10-18 12:01:43 +03001376 for (; count-- && *str; str++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 if (isalnum(*str) || *str == ' ' || *str == ':')
1378 *p++ = *str;
1379 else if (*str == '\'' || *str == '"')
1380 continue;
1381 else
1382 break;
1383 }
1384 *p = 0;
1385
1386 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -04001387
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388}
1389
1390__setup("acpi_os_name=", acpi_os_name_setup);
1391
Lin Ming12d32062010-12-09 16:51:06 +08001392#define OSI_STRING_LENGTH_MAX 64 /* arbitrary */
1393#define OSI_STRING_ENTRIES_MAX 16 /* arbitrary */
1394
1395struct osi_setup_entry {
1396 char string[OSI_STRING_LENGTH_MAX];
1397 bool enable;
1398};
1399
Hanjun Guoe73d3132013-08-13 18:31:15 +08001400static struct osi_setup_entry
1401 osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = {
Shaohua Liaa165972011-07-28 13:48:43 -07001402 {"Module Device", true},
1403 {"Processor Device", true},
1404 {"3.0 _SCP Extensions", true},
1405 {"Processor Aggregator Device", true},
1406};
Lin Ming12d32062010-12-09 16:51:06 +08001407
Lin Mingd90aa922010-12-09 16:50:52 +08001408void __init acpi_osi_setup(char *str)
1409{
Lin Ming12d32062010-12-09 16:51:06 +08001410 struct osi_setup_entry *osi;
1411 bool enable = true;
1412 int i;
1413
Lin Mingd90aa922010-12-09 16:50:52 +08001414 if (!acpi_gbl_create_osi_method)
1415 return;
1416
1417 if (str == NULL || *str == '\0') {
1418 printk(KERN_INFO PREFIX "_OSI method disabled\n");
1419 acpi_gbl_create_osi_method = FALSE;
Lin Ming12d32062010-12-09 16:51:06 +08001420 return;
1421 }
1422
1423 if (*str == '!') {
1424 str++;
Lv Zheng5dc17982013-07-22 16:08:25 +08001425 if (*str == '\0') {
1426 osi_linux.default_disabling = 1;
1427 return;
Lv Zheng741d8122013-07-22 16:08:36 +08001428 } else if (*str == '*') {
1429 acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS);
1430 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1431 osi = &osi_setup_entries[i];
1432 osi->enable = false;
1433 }
1434 return;
Lv Zheng5dc17982013-07-22 16:08:25 +08001435 }
Lin Ming12d32062010-12-09 16:51:06 +08001436 enable = false;
1437 }
1438
1439 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1440 osi = &osi_setup_entries[i];
1441 if (!strcmp(osi->string, str)) {
1442 osi->enable = enable;
1443 break;
1444 } else if (osi->string[0] == '\0') {
1445 osi->enable = enable;
1446 strncpy(osi->string, str, OSI_STRING_LENGTH_MAX);
1447 break;
1448 }
1449 }
Lin Mingd90aa922010-12-09 16:50:52 +08001450}
1451
Len Brownd4b7dc42008-01-23 20:50:56 -05001452static void __init set_osi_linux(unsigned int enable)
1453{
Lin Mingd90aa922010-12-09 16:50:52 +08001454 if (osi_linux.enable != enable)
Len Brownd4b7dc42008-01-23 20:50:56 -05001455 osi_linux.enable = enable;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001456
1457 if (osi_linux.enable)
1458 acpi_osi_setup("Linux");
1459 else
1460 acpi_osi_setup("!Linux");
1461
Len Brownd4b7dc42008-01-23 20:50:56 -05001462 return;
1463}
Len Brownf5076542007-05-30 00:10:38 -04001464
Len Brownd4b7dc42008-01-23 20:50:56 -05001465static void __init acpi_cmdline_osi_linux(unsigned int enable)
1466{
Lin Mingd90aa922010-12-09 16:50:52 +08001467 osi_linux.cmdline = 1; /* cmdline set the default and override DMI */
1468 osi_linux.dmi = 0;
Len Brownd4b7dc42008-01-23 20:50:56 -05001469 set_osi_linux(enable);
Len Brownf5076542007-05-30 00:10:38 -04001470
Len Brownd4b7dc42008-01-23 20:50:56 -05001471 return;
1472}
1473
1474void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id *d)
1475{
Len Brownd4b7dc42008-01-23 20:50:56 -05001476 printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident);
1477
1478 if (enable == -1)
1479 return;
1480
Lin Mingd90aa922010-12-09 16:50:52 +08001481 osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) */
Len Brownd4b7dc42008-01-23 20:50:56 -05001482 set_osi_linux(enable);
1483
Len Brownf5076542007-05-30 00:10:38 -04001484 return;
1485}
1486
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487/*
Len Brownae00d812007-05-29 18:43:33 -04001488 * Modify the list of "OS Interfaces" reported to BIOS via _OSI
1489 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 * empty string disables _OSI
Len Brownae00d812007-05-29 18:43:33 -04001491 * string starting with '!' disables that string
1492 * otherwise string is added to list, augmenting built-in strings
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 */
Lin Mingb0ed7a92010-08-06 09:35:51 +08001494static void __init acpi_osi_setup_late(void)
1495{
Lin Ming12d32062010-12-09 16:51:06 +08001496 struct osi_setup_entry *osi;
1497 char *str;
1498 int i;
Lin Mingd90aa922010-12-09 16:50:52 +08001499 acpi_status status;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001500
Lv Zheng5dc17982013-07-22 16:08:25 +08001501 if (osi_linux.default_disabling) {
1502 status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS);
1503
1504 if (ACPI_SUCCESS(status))
1505 printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n");
1506 }
1507
Lin Ming12d32062010-12-09 16:51:06 +08001508 for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) {
1509 osi = &osi_setup_entries[i];
1510 str = osi->string;
Lin Mingb0ed7a92010-08-06 09:35:51 +08001511
Lin Ming12d32062010-12-09 16:51:06 +08001512 if (*str == '\0')
1513 break;
1514 if (osi->enable) {
1515 status = acpi_install_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001516
Lin Ming12d32062010-12-09 16:51:06 +08001517 if (ACPI_SUCCESS(status))
1518 printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str);
1519 } else {
1520 status = acpi_remove_interface(str);
Lin Mingd90aa922010-12-09 16:50:52 +08001521
Lin Ming12d32062010-12-09 16:51:06 +08001522 if (ACPI_SUCCESS(status))
1523 printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str);
1524 }
Lin Mingb0ed7a92010-08-06 09:35:51 +08001525 }
1526}
1527
Lin Mingd90aa922010-12-09 16:50:52 +08001528static int __init osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529{
Lin Mingd90aa922010-12-09 16:50:52 +08001530 if (str && !strcmp("Linux", str))
1531 acpi_cmdline_osi_linux(1);
1532 else if (str && !strcmp("!Linux", str))
1533 acpi_cmdline_osi_linux(0);
1534 else
1535 acpi_osi_setup(str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
1537 return 1;
1538}
1539
Lin Mingd90aa922010-12-09 16:50:52 +08001540__setup("acpi_osi=", osi_setup);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541
1542/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -04001543static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544{
1545 printk(KERN_INFO PREFIX "serialize enabled\n");
1546
1547 acpi_gbl_all_methods_serialized = TRUE;
1548
1549 return 1;
1550}
1551
1552__setup("acpi_serialize", acpi_serialize_setup);
1553
Thomas Renningerdf92e692008-02-04 23:31:22 -08001554/* Check of resource interference between native drivers and ACPI
1555 * OperationRegions (SystemIO and System Memory only).
1556 * IO ports and memory declared in ACPI might be used by the ACPI subsystem
1557 * in arbitrary AML code and can interfere with legacy drivers.
1558 * acpi_enforce_resources= can be set to:
1559 *
Luca Tettamanti7e905602009-03-30 00:01:27 +02001560 * - strict (default) (2)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001561 * -> further driver trying to access the resources will not load
Luca Tettamanti7e905602009-03-30 00:01:27 +02001562 * - lax (1)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001563 * -> further driver trying to access the resources will load, but you
1564 * get a system message that something might go wrong...
1565 *
1566 * - no (0)
1567 * -> ACPI Operation Region resources will not be registered
1568 *
1569 */
1570#define ENFORCE_RESOURCES_STRICT 2
1571#define ENFORCE_RESOURCES_LAX 1
1572#define ENFORCE_RESOURCES_NO 0
1573
Luca Tettamanti7e905602009-03-30 00:01:27 +02001574static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001575
1576static int __init acpi_enforce_resources_setup(char *str)
1577{
1578 if (str == NULL || *str == '\0')
1579 return 0;
1580
1581 if (!strcmp("strict", str))
1582 acpi_enforce_resources = ENFORCE_RESOURCES_STRICT;
1583 else if (!strcmp("lax", str))
1584 acpi_enforce_resources = ENFORCE_RESOURCES_LAX;
1585 else if (!strcmp("no", str))
1586 acpi_enforce_resources = ENFORCE_RESOURCES_NO;
1587
1588 return 1;
1589}
1590
1591__setup("acpi_enforce_resources=", acpi_enforce_resources_setup);
1592
1593/* Check for resource conflicts between ACPI OperationRegions and native
1594 * drivers */
Jean Delvare876fba42009-11-11 15:22:15 +01001595int acpi_check_resource_conflict(const struct resource *res)
Thomas Renningerdf92e692008-02-04 23:31:22 -08001596{
Lin Mingf654c0f2012-01-12 13:10:32 +08001597 acpi_adr_space_type space_id;
1598 acpi_size length;
1599 u8 warn = 0;
1600 int clash = 0;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001601
1602 if (acpi_enforce_resources == ENFORCE_RESOURCES_NO)
1603 return 0;
1604 if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM))
1605 return 0;
1606
Lin Mingf654c0f2012-01-12 13:10:32 +08001607 if (res->flags & IORESOURCE_IO)
1608 space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1609 else
1610 space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY;
Thomas Renningerdf92e692008-02-04 23:31:22 -08001611
Alexandru Gheorghiue4f52242013-03-12 08:53:02 +00001612 length = resource_size(res);
Lin Mingf654c0f2012-01-12 13:10:32 +08001613 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO)
1614 warn = 1;
1615 clash = acpi_check_address_range(space_id, res->start, length, warn);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001616
1617 if (clash) {
1618 if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) {
Jean Delvare14f03342009-09-08 15:31:46 +02001619 if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX)
1620 printk(KERN_NOTICE "ACPI: This conflict may"
1621 " cause random problems and system"
1622 " instability\n");
1623 printk(KERN_INFO "ACPI: If an ACPI driver is available"
1624 " for this device, you should use it instead of"
1625 " the native driver\n");
Thomas Renningerdf92e692008-02-04 23:31:22 -08001626 }
1627 if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT)
1628 return -EBUSY;
1629 }
1630 return 0;
1631}
Thomas Renninger443dea72008-02-04 23:31:23 -08001632EXPORT_SYMBOL(acpi_check_resource_conflict);
Thomas Renningerdf92e692008-02-04 23:31:22 -08001633
1634int acpi_check_region(resource_size_t start, resource_size_t n,
1635 const char *name)
1636{
1637 struct resource res = {
1638 .start = start,
1639 .end = start + n - 1,
1640 .name = name,
1641 .flags = IORESOURCE_IO,
1642 };
1643
1644 return acpi_check_resource_conflict(&res);
1645}
1646EXPORT_SYMBOL(acpi_check_region);
1647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648/*
Jean Delvare70dd6be2010-05-27 19:58:37 +02001649 * Let drivers know whether the resource checks are effective
1650 */
1651int acpi_resources_are_enforced(void)
1652{
1653 return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT;
1654}
1655EXPORT_SYMBOL(acpi_resources_are_enforced);
1656
1657/*
Lin Ming9f63b882011-03-23 17:26:34 +08001658 * Deallocate the memory for a spinlock.
1659 */
1660void acpi_os_delete_lock(acpi_spinlock handle)
1661{
1662 ACPI_FREE(handle);
1663}
1664
1665/*
Robert Moore73459f72005-06-24 00:00:00 -04001666 * Acquire a spinlock.
1667 *
1668 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001669 */
1670
Bob Moore967440e32006-06-23 17:04:00 -04001671acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001672{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001673 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001674 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001675 return flags;
1676}
1677
1678/*
1679 * Release a spinlock. See above.
1680 */
1681
Bob Moore967440e32006-06-23 17:04:00 -04001682void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001683{
Bob Moore967440e32006-06-23 17:04:00 -04001684 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001685}
1686
Robert Moore73459f72005-06-24 00:00:00 -04001687#ifndef ACPI_USE_LOCAL_CACHE
1688
1689/*******************************************************************************
1690 *
1691 * FUNCTION: acpi_os_create_cache
1692 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001693 * PARAMETERS: name - Ascii name for the cache
1694 * size - Size of each cached object
1695 * depth - Maximum depth of the cache (in objects) <ignored>
1696 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001697 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001698 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001699 *
1700 * DESCRIPTION: Create a cache object
1701 *
1702 ******************************************************************************/
1703
1704acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001705acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001706{
Paul Mundt20c2df82007-07-20 10:11:58 +09001707 *cache = kmem_cache_create(name, size, 0, 0, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001708 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001709 return AE_ERROR;
1710 else
1711 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001712}
1713
1714/*******************************************************************************
1715 *
1716 * FUNCTION: acpi_os_purge_cache
1717 *
1718 * PARAMETERS: Cache - Handle to cache object
1719 *
1720 * RETURN: Status
1721 *
1722 * DESCRIPTION: Free all objects within the requested cache.
1723 *
1724 ******************************************************************************/
1725
Len Brown4be44fc2005-08-05 00:44:28 -04001726acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001727{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001728 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001729 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001730}
1731
1732/*******************************************************************************
1733 *
1734 * FUNCTION: acpi_os_delete_cache
1735 *
1736 * PARAMETERS: Cache - Handle to cache object
1737 *
1738 * RETURN: Status
1739 *
1740 * DESCRIPTION: Free all objects within the requested cache and delete the
1741 * cache object.
1742 *
1743 ******************************************************************************/
1744
Len Brown4be44fc2005-08-05 00:44:28 -04001745acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001746{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001747 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001748 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001749}
1750
1751/*******************************************************************************
1752 *
1753 * FUNCTION: acpi_os_release_object
1754 *
1755 * PARAMETERS: Cache - Handle to cache object
1756 * Object - The object to be released
1757 *
1758 * RETURN: None
1759 *
1760 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1761 * the object is deleted.
1762 *
1763 ******************************************************************************/
1764
Len Brown4be44fc2005-08-05 00:44:28 -04001765acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001766{
Len Brown4be44fc2005-08-05 00:44:28 -04001767 kmem_cache_free(cache, object);
1768 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001769}
Robert Moore73459f72005-06-24 00:00:00 -04001770#endif
Myron Stowed362eda2010-10-21 14:24:04 -06001771
Lv Zhengb75dd292013-06-08 00:58:48 +00001772static int __init acpi_no_auto_ssdt_setup(char *s)
1773{
1774 printk(KERN_NOTICE PREFIX "SSDT auto-load disabled\n");
1775
1776 acpi_gbl_disable_ssdt_table_load = TRUE;
1777
1778 return 1;
1779}
1780
1781__setup("acpi_no_auto_ssdt", acpi_no_auto_ssdt_setup);
1782
Myron Stowed362eda2010-10-21 14:24:04 -06001783acpi_status __init acpi_os_initialize(void)
1784{
1785 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1786 acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1787 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block);
1788 acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block);
1789
1790 return AE_OK;
1791}
1792
Zhang Rui32d47ee2010-12-08 10:40:36 +08001793acpi_status __init acpi_os_initialize1(void)
Myron Stowed362eda2010-10-21 14:24:04 -06001794{
Tejun Heo44d25882011-02-01 11:42:42 +01001795 kacpid_wq = alloc_workqueue("kacpid", 0, 1);
1796 kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1);
Rafael J. Wysockid7831562013-11-22 21:52:12 +01001797 kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0);
Myron Stowed362eda2010-10-21 14:24:04 -06001798 BUG_ON(!kacpid_wq);
1799 BUG_ON(!kacpi_notify_wq);
1800 BUG_ON(!kacpi_hotplug_wq);
Len Brown1bd64d42010-10-26 14:50:56 -04001801 acpi_install_interface_handler(acpi_osi_handler);
1802 acpi_osi_setup_late();
Myron Stowed362eda2010-10-21 14:24:04 -06001803 return AE_OK;
1804}
1805
1806acpi_status acpi_os_terminate(void)
1807{
1808 if (acpi_irq_handler) {
Rafael J. Wysocki23fe3632011-02-08 23:48:16 +01001809 acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt,
Myron Stowed362eda2010-10-21 14:24:04 -06001810 acpi_irq_handler);
1811 }
1812
1813 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block);
1814 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block);
1815 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block);
1816 acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block);
1817
1818 destroy_workqueue(kacpid_wq);
1819 destroy_workqueue(kacpi_notify_wq);
1820 destroy_workqueue(kacpi_hotplug_wq);
1821
1822 return AE_OK;
1823}
Tang Liang09f98a82011-12-09 10:05:54 +08001824
1825acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control,
1826 u32 pm1b_control)
1827{
1828 int rc = 0;
1829 if (__acpi_os_prepare_sleep)
1830 rc = __acpi_os_prepare_sleep(sleep_state,
1831 pm1a_control, pm1b_control);
1832 if (rc < 0)
1833 return AE_ERROR;
1834 else if (rc > 0)
1835 return AE_CTRL_SKIP;
1836
1837 return AE_OK;
1838}
1839
1840void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
1841 u32 pm1a_ctrl, u32 pm1b_ctrl))
1842{
1843 __acpi_os_prepare_sleep = func;
1844}
Yinghai Lu92d8aff2013-01-21 13:20:47 -08001845
Ben Guthrod6b47b12013-07-30 08:24:52 -04001846acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a,
1847 u32 val_b)
1848{
1849 int rc = 0;
1850 if (__acpi_os_prepare_extended_sleep)
1851 rc = __acpi_os_prepare_extended_sleep(sleep_state,
1852 val_a, val_b);
1853 if (rc < 0)
1854 return AE_ERROR;
1855 else if (rc > 0)
1856 return AE_CTRL_SKIP;
1857
1858 return AE_OK;
1859}
1860
1861void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
1862 u32 val_a, u32 val_b))
1863{
1864 __acpi_os_prepare_extended_sleep = func;
1865}