blob: 0f6f3bcbc8ebc2d4b0c06cb8f1443d1fb5e6e9b6 [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>
7 *
8 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
25 *
26 */
27
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/module.h>
29#include <linux/kernel.h>
30#include <linux/slab.h>
31#include <linux/mm.h>
32#include <linux/pci.h>
33#include <linux/smp_lock.h>
34#include <linux/interrupt.h>
35#include <linux/kmod.h>
36#include <linux/delay.h>
37#include <linux/workqueue.h>
38#include <linux/nmi.h>
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +030039#include <linux/acpi.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <acpi/acpi.h>
41#include <asm/io.h>
42#include <acpi/acpi_bus.h>
43#include <acpi/processor.h>
44#include <asm/uaccess.h>
45
46#include <linux/efi.h>
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#define _COMPONENT ACPI_OS_SERVICES
Len Brown4be44fc2005-08-05 00:44:28 -040049ACPI_MODULE_NAME("osl")
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#define PREFIX "ACPI: "
Len Brown4be44fc2005-08-05 00:44:28 -040051struct acpi_os_dpc {
52 acpi_osd_exec_callback function;
53 void *context;
David Howells65f27f32006-11-22 14:55:48 +000054 struct work_struct work;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055};
56
57#ifdef CONFIG_ACPI_CUSTOM_DSDT
58#include CONFIG_ACPI_CUSTOM_DSDT_FILE
59#endif
60
61#ifdef ENABLE_DEBUGGER
62#include <linux/kdb.h>
63
64/* stuff for debugger support */
65int acpi_in_debugger;
66EXPORT_SYMBOL(acpi_in_debugger);
67
68extern char line_buf[80];
Len Brown4be44fc2005-08-05 00:44:28 -040069#endif /*ENABLE_DEBUGGER */
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Luming Yu30e332f2005-08-12 00:31:00 -040071int acpi_specific_hotkey_enabled = TRUE;
Luming Yufb9802f2005-03-18 18:03:45 -050072EXPORT_SYMBOL(acpi_specific_hotkey_enabled);
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074static unsigned int acpi_irq_irq;
75static acpi_osd_handler acpi_irq_handler;
76static void *acpi_irq_context;
77static struct workqueue_struct *kacpid_wq;
78
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -070079static void __init acpi_request_region (struct acpi_generic_address *addr,
80 unsigned int length, char *desc)
81{
82 struct resource *res;
83
84 if (!addr->address || !length)
85 return;
86
Len Browneee3c852007-02-03 01:38:16 -050087 if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_IO)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -070088 res = request_region(addr->address, length, desc);
Len Browneee3c852007-02-03 01:38:16 -050089 else if (addr->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -070090 res = request_mem_region(addr->address, length, desc);
91}
92
93static int __init acpi_reserve_resources(void)
94{
Len Browneee3c852007-02-03 01:38:16 -050095 acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -070096 "ACPI PM1a_EVT_BLK");
97
Len Browneee3c852007-02-03 01:38:16 -050098 acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -070099 "ACPI PM1b_EVT_BLK");
100
Len Browneee3c852007-02-03 01:38:16 -0500101 acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700102 "ACPI PM1a_CNT_BLK");
103
Len Browneee3c852007-02-03 01:38:16 -0500104 acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700105 "ACPI PM1b_CNT_BLK");
106
Len Browneee3c852007-02-03 01:38:16 -0500107 if (acpi_gbl_FADT.pm_timer_length == 4)
108 acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700109
Len Browneee3c852007-02-03 01:38:16 -0500110 acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length,
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700111 "ACPI PM2_CNT_BLK");
112
113 /* Length of GPE blocks must be a non-negative multiple of 2 */
114
Len Browneee3c852007-02-03 01:38:16 -0500115 if (!(acpi_gbl_FADT.gpe0_block_length & 0x1))
116 acpi_request_region(&acpi_gbl_FADT.xgpe0_block,
117 acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700118
Len Browneee3c852007-02-03 01:38:16 -0500119 if (!(acpi_gbl_FADT.gpe1_block_length & 0x1))
120 acpi_request_region(&acpi_gbl_FADT.xgpe1_block,
121 acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK");
Bjorn Helgaas9a47cdb2007-01-18 16:42:55 -0700122
123 return 0;
124}
125device_initcall(acpi_reserve_resources);
126
Len Brown4be44fc2005-08-05 00:44:28 -0400127acpi_status acpi_os_initialize(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
129 return AE_OK;
130}
131
Len Brown4be44fc2005-08-05 00:44:28 -0400132acpi_status acpi_os_initialize1(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133{
134 /*
135 * Initialize PCI configuration space access, as we'll need to access
136 * it while walking the namespace (bus 0 and root bridges w/ _BBNs).
137 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 if (!raw_pci_ops) {
Len Brown4be44fc2005-08-05 00:44:28 -0400139 printk(KERN_ERR PREFIX
140 "Access to PCI configuration space unavailable\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return AE_NULL_ENTRY;
142 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 kacpid_wq = create_singlethread_workqueue("kacpid");
144 BUG_ON(!kacpid_wq);
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800145
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 return AE_OK;
147}
148
Len Brown4be44fc2005-08-05 00:44:28 -0400149acpi_status acpi_os_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
151 if (acpi_irq_handler) {
152 acpi_os_remove_interrupt_handler(acpi_irq_irq,
153 acpi_irq_handler);
154 }
155
156 destroy_workqueue(kacpid_wq);
157
158 return AE_OK;
159}
160
Len Brown4be44fc2005-08-05 00:44:28 -0400161void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162{
163 va_list args;
164 va_start(args, fmt);
165 acpi_os_vprintf(fmt, args);
166 va_end(args);
167}
Len Brown4be44fc2005-08-05 00:44:28 -0400168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169EXPORT_SYMBOL(acpi_os_printf);
170
Len Brown4be44fc2005-08-05 00:44:28 -0400171void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172{
173 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400174
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 vsprintf(buffer, fmt, args);
176
177#ifdef ENABLE_DEBUGGER
178 if (acpi_in_debugger) {
179 kdb_printf("%s", buffer);
180 } else {
181 printk("%s", buffer);
182 }
183#else
184 printk("%s", buffer);
185#endif
186}
187
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300188acpi_physical_address __init acpi_os_get_root_pointer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
190 if (efi_enabled) {
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800191 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300192 return efi.acpi20;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800193 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300194 return efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400196 printk(KERN_ERR PREFIX
197 "System description tables not found\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300198 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 }
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300200 } else
201 return acpi_find_rsdp();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202}
203
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300204void __iomem *acpi_os_map_memory(acpi_physical_address phys, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800206 if (phys > ULONG_MAX) {
207 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300208 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 }
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300210 if (acpi_gbl_permanent_mmap)
211 /*
212 * ioremap checks to ensure this is in reserved space
213 */
214 return ioremap((unsigned long)phys, size);
215 else
216 return __acpi_map_table((unsigned long)phys, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800218EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Len Brown4be44fc2005-08-05 00:44:28 -0400220void acpi_os_unmap_memory(void __iomem * virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221{
Alexey Starikovskiyad71860a2007-02-02 19:48:19 +0300222 if (acpi_gbl_permanent_mmap) {
223 iounmap(virt);
224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800226EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
228#ifdef ACPI_FUTURE_USAGE
229acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400230acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
Len Brown4be44fc2005-08-05 00:44:28 -0400232 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 return AE_BAD_PARAMETER;
234
235 *phys = virt_to_phys(virt);
236
237 return AE_OK;
238}
239#endif
240
241#define ACPI_MAX_OVERRIDE_LEN 100
242
243static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
244
245acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400246acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
247 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248{
249 if (!init_val || !new_val)
250 return AE_BAD_PARAMETER;
251
252 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400253 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400255 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 *new_val = acpi_os_name;
257 }
258
259 return AE_OK;
260}
261
262acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400263acpi_os_table_override(struct acpi_table_header * existing_table,
264 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
266 if (!existing_table || !new_table)
267 return AE_BAD_PARAMETER;
268
269#ifdef CONFIG_ACPI_CUSTOM_DSDT
270 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400271 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 else
273 *new_table = NULL;
274#else
275 *new_table = NULL;
276#endif
277 return AE_OK;
278}
279
David Howells7d12e782006-10-05 14:55:46 +0100280static irqreturn_t acpi_irq(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
Len Brown4be44fc2005-08-05 00:44:28 -0400282 return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283}
284
285acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400286acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
287 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
289 unsigned int irq;
290
291 /*
292 * Ignore the GSI from the core, and use the value in our copy of the
293 * FADT. It may not be the same if an interrupt source override exists
294 * for the SCI.
295 */
Alexey Starikovskiycee324b2007-02-02 19:48:22 +0300296 gsi = acpi_gbl_FADT.sci_interrupt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
298 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
299 gsi);
300 return AE_OK;
301 }
302
303 acpi_irq_handler = handler;
304 acpi_irq_context = context;
Thomas Gleixnerdace1452006-07-01 19:29:38 -0700305 if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
307 return AE_NOT_ACQUIRED;
308 }
309 acpi_irq_irq = irq;
310
311 return AE_OK;
312}
313
Len Brown4be44fc2005-08-05 00:44:28 -0400314acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 if (irq) {
317 free_irq(irq, acpi_irq);
318 acpi_irq_handler = NULL;
319 acpi_irq_irq = 0;
320 }
321
322 return AE_OK;
323}
324
325/*
326 * Running in interpreter thread context, safe to sleep
327 */
328
Len Brown4be44fc2005-08-05 00:44:28 -0400329void acpi_os_sleep(acpi_integer ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800331 schedule_timeout_interruptible(msecs_to_jiffies(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332}
Len Brown4be44fc2005-08-05 00:44:28 -0400333
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334EXPORT_SYMBOL(acpi_os_sleep);
335
Len Brown4be44fc2005-08-05 00:44:28 -0400336void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
338 while (us) {
339 u32 delay = 1000;
340
341 if (delay > us)
342 delay = us;
343 udelay(delay);
344 touch_nmi_watchdog();
345 us -= delay;
346 }
347}
Len Brown4be44fc2005-08-05 00:44:28 -0400348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349EXPORT_SYMBOL(acpi_os_stall);
350
351/*
352 * Support ACPI 3.0 AML Timer operand
353 * Returns 64-bit free-running, monotonically increasing timer
354 * with 100ns granularity
355 */
Len Brown4be44fc2005-08-05 00:44:28 -0400356u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357{
358 static u64 t;
359
360#ifdef CONFIG_HPET
361 /* TBD: use HPET if available */
362#endif
363
364#ifdef CONFIG_X86_PM_TIMER
365 /* TBD: default to PM timer if HPET was not available */
366#endif
367 if (!t)
368 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
369
370 return ++t;
371}
372
Len Brown4be44fc2005-08-05 00:44:28 -0400373acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374{
375 u32 dummy;
376
377 if (!value)
378 value = &dummy;
379
Len Brown4be44fc2005-08-05 00:44:28 -0400380 switch (width) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 case 8:
Len Brown4be44fc2005-08-05 00:44:28 -0400382 *(u8 *) value = inb(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 break;
384 case 16:
Len Brown4be44fc2005-08-05 00:44:28 -0400385 *(u16 *) value = inw(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 break;
387 case 32:
Len Brown4be44fc2005-08-05 00:44:28 -0400388 *(u32 *) value = inl(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 break;
390 default:
391 BUG();
392 }
393
394 return AE_OK;
395}
Len Brown4be44fc2005-08-05 00:44:28 -0400396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397EXPORT_SYMBOL(acpi_os_read_port);
398
Len Brown4be44fc2005-08-05 00:44:28 -0400399acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Len Brown4be44fc2005-08-05 00:44:28 -0400401 switch (width) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 case 8:
403 outb(value, port);
404 break;
405 case 16:
406 outw(value, port);
407 break;
408 case 32:
409 outl(value, port);
410 break;
411 default:
412 BUG();
413 }
414
415 return AE_OK;
416}
Len Brown4be44fc2005-08-05 00:44:28 -0400417
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418EXPORT_SYMBOL(acpi_os_write_port);
419
420acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400421acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422{
Len Brown4be44fc2005-08-05 00:44:28 -0400423 u32 dummy;
424 void __iomem *virt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800426 virt_addr = ioremap(phys_addr, width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 if (!value)
428 value = &dummy;
429
430 switch (width) {
431 case 8:
Len Brown4be44fc2005-08-05 00:44:28 -0400432 *(u8 *) value = readb(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 break;
434 case 16:
Len Brown4be44fc2005-08-05 00:44:28 -0400435 *(u16 *) value = readw(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 break;
437 case 32:
Len Brown4be44fc2005-08-05 00:44:28 -0400438 *(u32 *) value = readl(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 break;
440 default:
441 BUG();
442 }
443
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800444 iounmap(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
446 return AE_OK;
447}
448
449acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400450acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451{
Len Brown4be44fc2005-08-05 00:44:28 -0400452 void __iomem *virt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800454 virt_addr = ioremap(phys_addr, width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
456 switch (width) {
457 case 8:
458 writeb(value, virt_addr);
459 break;
460 case 16:
461 writew(value, virt_addr);
462 break;
463 case 32:
464 writel(value, virt_addr);
465 break;
466 default:
467 BUG();
468 }
469
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800470 iounmap(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 return AE_OK;
473}
474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400476acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
477 void *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478{
479 int result, size;
480
481 if (!value)
482 return AE_BAD_PARAMETER;
483
484 switch (width) {
485 case 8:
486 size = 1;
487 break;
488 case 16:
489 size = 2;
490 break;
491 case 32:
492 size = 4;
493 break;
494 default:
495 return AE_ERROR;
496 }
497
498 BUG_ON(!raw_pci_ops);
499
500 result = raw_pci_ops->read(pci_id->segment, pci_id->bus,
Len Brown4be44fc2005-08-05 00:44:28 -0400501 PCI_DEVFN(pci_id->device, pci_id->function),
502 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 return (result ? AE_ERROR : AE_OK);
505}
Len Brown4be44fc2005-08-05 00:44:28 -0400506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507EXPORT_SYMBOL(acpi_os_read_pci_configuration);
508
509acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400510acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
511 acpi_integer value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512{
513 int result, size;
514
515 switch (width) {
516 case 8:
517 size = 1;
518 break;
519 case 16:
520 size = 2;
521 break;
522 case 32:
523 size = 4;
524 break;
525 default:
526 return AE_ERROR;
527 }
528
529 BUG_ON(!raw_pci_ops);
530
531 result = raw_pci_ops->write(pci_id->segment, pci_id->bus,
Len Brown4be44fc2005-08-05 00:44:28 -0400532 PCI_DEVFN(pci_id->device, pci_id->function),
533 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 return (result ? AE_ERROR : AE_OK);
536}
537
538/* TODO: Change code to take advantage of driver model more */
Len Brown4be44fc2005-08-05 00:44:28 -0400539static void acpi_os_derive_pci_id_2(acpi_handle rhandle, /* upper bound */
540 acpi_handle chandle, /* current node */
541 struct acpi_pci_id **id,
542 int *is_bridge, u8 * bus_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543{
Len Brown4be44fc2005-08-05 00:44:28 -0400544 acpi_handle handle;
545 struct acpi_pci_id *pci_id = *id;
546 acpi_status status;
547 unsigned long temp;
548 acpi_object_type type;
549 u8 tu8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
551 acpi_get_parent(chandle, &handle);
552 if (handle != rhandle) {
Len Brown4be44fc2005-08-05 00:44:28 -0400553 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
554 bus_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
556 status = acpi_get_type(handle, &type);
Len Brown4be44fc2005-08-05 00:44:28 -0400557 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return;
559
Len Brown4be44fc2005-08-05 00:44:28 -0400560 status =
561 acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
562 &temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 if (ACPI_SUCCESS(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400564 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
565 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 if (*is_bridge)
568 pci_id->bus = *bus_number;
569
570 /* any nicer way to get bus number of bridge ? */
Len Brown4be44fc2005-08-05 00:44:28 -0400571 status =
572 acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8,
573 8);
574 if (ACPI_SUCCESS(status)
575 && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) {
576 status =
577 acpi_os_read_pci_configuration(pci_id, 0x18,
578 &tu8, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 if (!ACPI_SUCCESS(status)) {
580 /* Certainly broken... FIX ME */
581 return;
582 }
583 *is_bridge = 1;
584 pci_id->bus = tu8;
Len Brown4be44fc2005-08-05 00:44:28 -0400585 status =
586 acpi_os_read_pci_configuration(pci_id, 0x19,
587 &tu8, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (ACPI_SUCCESS(status)) {
589 *bus_number = tu8;
590 }
591 } else
592 *is_bridge = 0;
593 }
594 }
595}
596
Len Brown4be44fc2005-08-05 00:44:28 -0400597void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */
598 acpi_handle chandle, /* current node */
599 struct acpi_pci_id **id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
601 int is_bridge = 1;
602 u8 bus_number = (*id)->bus;
603
604 acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
605}
606
David Howells65f27f32006-11-22 14:55:48 +0000607static void acpi_os_execute_deferred(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
David Howells65f27f32006-11-22 14:55:48 +0000609 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if (!dpc) {
Len Brown64684632006-06-26 23:41:38 -0400612 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
Patrick Mocheld550d982006-06-27 00:41:40 -0400613 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 }
615
616 dpc->function(dpc->context);
617
618 kfree(dpc);
619
Patrick Mocheld550d982006-06-27 00:41:40 -0400620 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621}
622
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400623/*******************************************************************************
624 *
625 * FUNCTION: acpi_os_execute
626 *
627 * PARAMETERS: Type - Type of the callback
628 * Function - Function to be executed
629 * Context - Function parameters
630 *
631 * RETURN: Status
632 *
633 * DESCRIPTION: Depending on type, either queues function for deferred execution or
634 * immediately executes function on a separate thread.
635 *
636 ******************************************************************************/
637
638acpi_status acpi_os_execute(acpi_execute_type type,
Len Brown4be44fc2005-08-05 00:44:28 -0400639 acpi_osd_exec_callback function, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640{
Len Brown4be44fc2005-08-05 00:44:28 -0400641 acpi_status status = AE_OK;
642 struct acpi_os_dpc *dpc;
Len Brown72945b22006-07-12 22:46:42 -0400643
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800644 ACPI_FUNCTION_TRACE("os_queue_for_execution");
645
Len Brown72945b22006-07-12 22:46:42 -0400646 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
647 "Scheduling function [%p(%p)] for deferred execution.\n",
648 function, context));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
650 if (!function)
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800651 return_ACPI_STATUS(AE_BAD_PARAMETER);
Len Brown72945b22006-07-12 22:46:42 -0400652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 /*
654 * Allocate/initialize DPC structure. Note that this memory will be
David Howells65f27f32006-11-22 14:55:48 +0000655 * freed by the callee. The kernel handles the work_struct list in a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 * way that allows us to also free its memory inside the callee.
657 * Because we may want to schedule several tasks with different
658 * parameters we can't use the approach some kernel code uses of
David Howells65f27f32006-11-22 14:55:48 +0000659 * having a static work_struct.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 */
Len Brown72945b22006-07-12 22:46:42 -0400661
David Howells65f27f32006-11-22 14:55:48 +0000662 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (!dpc)
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800664 return_ACPI_STATUS(AE_NO_MEMORY);
665
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 dpc->function = function;
667 dpc->context = context;
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800668
David Howells65f27f32006-11-22 14:55:48 +0000669 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
670 if (!queue_work(kacpid_wq, &dpc->work)) {
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800671 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
672 "Call to queue_work() failed.\n"));
Alexey Y. Starikovskiy37605a62006-09-26 04:20:47 -0400673 kfree(dpc);
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800674 status = AE_ERROR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
Linus Torvaldsb976fe12006-11-17 19:31:09 -0800676
677 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678}
Len Brown4be44fc2005-08-05 00:44:28 -0400679
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400680EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Len Brown4be44fc2005-08-05 00:44:28 -0400682void acpi_os_wait_events_complete(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
684 flush_workqueue(kacpid_wq);
685}
Len Brown4be44fc2005-08-05 00:44:28 -0400686
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687EXPORT_SYMBOL(acpi_os_wait_events_complete);
688
689/*
690 * Allocate the memory for a spinlock and initialize it.
691 */
Bob Moore967440e32006-06-23 17:04:00 -0400692acpi_status acpi_os_create_lock(acpi_spinlock * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Bob Moore967440e32006-06-23 17:04:00 -0400694 spin_lock_init(*handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Patrick Mocheld550d982006-06-27 00:41:40 -0400696 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697}
698
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699/*
700 * Deallocate the memory for a spinlock.
701 */
Bob Moore967440e32006-06-23 17:04:00 -0400702void acpi_os_delete_lock(acpi_spinlock handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703{
Patrick Mocheld550d982006-06-27 00:41:40 -0400704 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400708acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709{
Len Brown4be44fc2005-08-05 00:44:28 -0400710 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
713 sem = acpi_os_allocate(sizeof(struct semaphore));
714 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -0400715 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 memset(sem, 0, sizeof(struct semaphore));
717
718 sema_init(sem, initial_units);
719
Len Brown4be44fc2005-08-05 00:44:28 -0400720 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Len Brown4be44fc2005-08-05 00:44:28 -0400722 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
723 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724
Patrick Mocheld550d982006-06-27 00:41:40 -0400725 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Len Brown4be44fc2005-08-05 00:44:28 -0400728EXPORT_SYMBOL(acpi_os_create_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729
730/*
731 * TODO: A better way to delete semaphores? Linux doesn't have a
732 * 'delete_semaphore()' function -- may result in an invalid
733 * pointer dereference for non-synchronized consumers. Should
734 * we at least check for blocked threads and signal/cancel them?
735 */
736
Len Brown4be44fc2005-08-05 00:44:28 -0400737acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Len Brown4be44fc2005-08-05 00:44:28 -0400739 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 if (!sem)
Patrick Mocheld550d982006-06-27 00:41:40 -0400743 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Len Brown4be44fc2005-08-05 00:44:28 -0400745 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Len Brown02438d82006-06-30 03:19:10 -0400747 kfree(sem);
Len Brown4be44fc2005-08-05 00:44:28 -0400748 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749
Patrick Mocheld550d982006-06-27 00:41:40 -0400750 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
Len Brown4be44fc2005-08-05 00:44:28 -0400753EXPORT_SYMBOL(acpi_os_delete_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755/*
756 * TODO: The kernel doesn't have a 'down_timeout' function -- had to
757 * improvise. The process is to sleep for one scheduler quantum
758 * until the semaphore becomes available. Downside is that this
759 * may result in starvation for timeout-based waits when there's
760 * lots of semaphore activity.
761 *
762 * TODO: Support for units > 1?
763 */
Len Brown4be44fc2005-08-05 00:44:28 -0400764acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765{
Len Brown4be44fc2005-08-05 00:44:28 -0400766 acpi_status status = AE_OK;
767 struct semaphore *sem = (struct semaphore *)handle;
768 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
771 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400772 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -0400775 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Len Brown4be44fc2005-08-05 00:44:28 -0400777 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
778 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Len Brownd68909f2006-08-16 19:16:58 -0400780 /*
781 * This can be called during resume with interrupts off.
782 * Like boot-time, we should be single threaded and will
783 * always get the lock if we try -- timeout or not.
784 * If this doesn't succeed, then we will oops courtesy of
785 * might_sleep() in down().
786 */
787 if (!down_trylock(sem))
788 return AE_OK;
789
Len Brown4be44fc2005-08-05 00:44:28 -0400790 switch (timeout) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 /*
792 * No Wait:
793 * --------
794 * A zero timeout value indicates that we shouldn't wait - just
795 * acquire the semaphore if available otherwise return AE_TIME
796 * (a.k.a. 'would block').
797 */
Len Brown4be44fc2005-08-05 00:44:28 -0400798 case 0:
799 if (down_trylock(sem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 status = AE_TIME;
801 break;
802
803 /*
804 * Wait Indefinitely:
805 * ------------------
806 */
Len Brown4be44fc2005-08-05 00:44:28 -0400807 case ACPI_WAIT_FOREVER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 down(sem);
809 break;
810
811 /*
812 * Wait w/ Timeout:
813 * ----------------
814 */
Len Brown4be44fc2005-08-05 00:44:28 -0400815 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 // TODO: A better timeout algorithm?
817 {
818 int i = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400819 static const int quantum_ms = 1000 / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820
821 ret = down_trylock(sem);
Yu Lumingdacd9b82005-12-31 01:45:00 -0500822 for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) {
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800823 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 ret = down_trylock(sem);
825 }
Len Brown4be44fc2005-08-05 00:44:28 -0400826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 if (ret != 0)
828 status = AE_TIME;
829 }
830 break;
831 }
832
833 if (ACPI_FAILURE(status)) {
Bjorn Helgaas9e7e2c02006-04-27 05:25:00 -0400834 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -0400835 "Failed to acquire semaphore[%p|%d|%d], %s",
Len Brown4be44fc2005-08-05 00:44:28 -0400836 handle, units, timeout,
837 acpi_format_exception(status)));
838 } else {
839 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
Thomas Renningera6fc6722006-06-26 23:58:43 -0400840 "Acquired semaphore[%p|%d|%d]", handle,
Len Brown4be44fc2005-08-05 00:44:28 -0400841 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 }
843
Patrick Mocheld550d982006-06-27 00:41:40 -0400844 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
Len Brown4be44fc2005-08-05 00:44:28 -0400847EXPORT_SYMBOL(acpi_os_wait_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
849/*
850 * TODO: Support for units > 1?
851 */
Len Brown4be44fc2005-08-05 00:44:28 -0400852acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853{
Len Brown4be44fc2005-08-05 00:44:28 -0400854 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
857 if (!sem || (units < 1))
Patrick Mocheld550d982006-06-27 00:41:40 -0400858 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860 if (units > 1)
Patrick Mocheld550d982006-06-27 00:41:40 -0400861 return AE_SUPPORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862
Len Brown4be44fc2005-08-05 00:44:28 -0400863 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
864 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866 up(sem);
867
Patrick Mocheld550d982006-06-27 00:41:40 -0400868 return AE_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869}
Len Brown4be44fc2005-08-05 00:44:28 -0400870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871EXPORT_SYMBOL(acpi_os_signal_semaphore);
872
873#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -0400874u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
876
877#ifdef ENABLE_DEBUGGER
878 if (acpi_in_debugger) {
879 u32 chars;
880
881 kdb_read(buffer, sizeof(line_buf));
882
883 /* remove the CR kdb includes */
884 chars = strlen(buffer) - 1;
885 buffer[chars] = '\0';
886 }
887#endif
888
889 return 0;
890}
Len Brown4be44fc2005-08-05 00:44:28 -0400891#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893/* Assumes no unreadable holes inbetween */
Len Brown4be44fc2005-08-05 00:44:28 -0400894u8 acpi_os_readable(void *ptr, acpi_size len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895{
Len Brown4be44fc2005-08-05 00:44:28 -0400896#if defined(__i386__) || defined(__x86_64__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 char tmp;
Len Brown4be44fc2005-08-05 00:44:28 -0400898 return !__get_user(tmp, (char __user *)ptr)
899 && !__get_user(tmp, (char __user *)ptr + len - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900#endif
901 return 1;
902}
903
904#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -0400905u8 acpi_os_writable(void *ptr, acpi_size len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906{
907 /* could do dummy write (racy) or a kernel page table lookup.
908 The later may be difficult at early boot when kmap doesn't work yet. */
909 return 1;
910}
911#endif
912
Len Brown4be44fc2005-08-05 00:44:28 -0400913acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914{
Len Brown4be44fc2005-08-05 00:44:28 -0400915 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 case ACPI_SIGNAL_FATAL:
917 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
918 break;
919 case ACPI_SIGNAL_BREAKPOINT:
920 /*
921 * AML Breakpoint
922 * ACPI spec. says to treat it as a NOP unless
923 * you are debugging. So if/when we integrate
924 * AML debugger into the kernel debugger its
925 * hook will go here. But until then it is
926 * not useful to print anything on breakpoints.
927 */
928 break;
929 default:
930 break;
931 }
932
933 return AE_OK;
934}
Len Brown4be44fc2005-08-05 00:44:28 -0400935
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936EXPORT_SYMBOL(acpi_os_signal);
937
Len Brown4be44fc2005-08-05 00:44:28 -0400938static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939{
940 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -0400941 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
943 if (!str || !*str)
944 return 0;
945
946 for (; count-- && str && *str; str++) {
947 if (isalnum(*str) || *str == ' ' || *str == ':')
948 *p++ = *str;
949 else if (*str == '\'' || *str == '"')
950 continue;
951 else
952 break;
953 }
954 *p = 0;
955
956 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -0400957
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958}
959
960__setup("acpi_os_name=", acpi_os_name_setup);
961
962/*
963 * _OSI control
964 * empty string disables _OSI
965 * TBD additional string adds to _OSI
966 */
Len Brown4be44fc2005-08-05 00:44:28 -0400967static int __init acpi_osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968{
969 if (str == NULL || *str == '\0') {
970 printk(KERN_INFO PREFIX "_OSI method disabled\n");
971 acpi_gbl_create_osi_method = FALSE;
Len Brown4be44fc2005-08-05 00:44:28 -0400972 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973 /* TBD */
Len Brown4be44fc2005-08-05 00:44:28 -0400974 printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n",
975 str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
977
978 return 1;
979}
980
981__setup("acpi_osi=", acpi_osi_setup);
982
983/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -0400984static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985{
986 printk(KERN_INFO PREFIX "serialize enabled\n");
987
988 acpi_gbl_all_methods_serialized = TRUE;
989
990 return 1;
991}
992
993__setup("acpi_serialize", acpi_serialize_setup);
994
995/*
996 * Wake and Run-Time GPES are expected to be separate.
997 * We disable wake-GPEs at run-time to prevent spurious
998 * interrupts.
999 *
1000 * However, if a system exists that shares Wake and
1001 * Run-time events on the same GPE this flag is available
1002 * to tell Linux to keep the wake-time GPEs enabled at run-time.
1003 */
Len Brown4be44fc2005-08-05 00:44:28 -04001004static int __init acpi_wake_gpes_always_on_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005{
1006 printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
1007
1008 acpi_gbl_leave_wake_gpes_disabled = FALSE;
1009
1010 return 1;
1011}
1012
1013__setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
1014
Adrian Bunk8713cbe2005-09-02 17:16:48 -04001015static int __init acpi_hotkey_setup(char *str)
Luming Yufb9802f2005-03-18 18:03:45 -05001016{
Luming Yu30e332f2005-08-12 00:31:00 -04001017 acpi_specific_hotkey_enabled = FALSE;
Luming Yufb9802f2005-03-18 18:03:45 -05001018 return 1;
1019}
1020
Luming Yu30e332f2005-08-12 00:31:00 -04001021__setup("acpi_generic_hotkey", acpi_hotkey_setup);
Luming Yufb9802f2005-03-18 18:03:45 -05001022
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023/*
1024 * max_cstate is defined in the base kernel so modules can
1025 * change it w/o depending on the state of the processor module.
1026 */
1027unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
1028
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029EXPORT_SYMBOL(max_cstate);
Robert Moore73459f72005-06-24 00:00:00 -04001030
1031/*
1032 * Acquire a spinlock.
1033 *
1034 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001035 */
1036
Bob Moore967440e32006-06-23 17:04:00 -04001037acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
Robert Moore73459f72005-06-24 00:00:00 -04001038{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001039 acpi_cpu_flags flags;
Bob Moore967440e32006-06-23 17:04:00 -04001040 spin_lock_irqsave(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001041 return flags;
1042}
1043
1044/*
1045 * Release a spinlock. See above.
1046 */
1047
Bob Moore967440e32006-06-23 17:04:00 -04001048void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001049{
Bob Moore967440e32006-06-23 17:04:00 -04001050 spin_unlock_irqrestore(lockp, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001051}
1052
Robert Moore73459f72005-06-24 00:00:00 -04001053#ifndef ACPI_USE_LOCAL_CACHE
1054
1055/*******************************************************************************
1056 *
1057 * FUNCTION: acpi_os_create_cache
1058 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001059 * PARAMETERS: name - Ascii name for the cache
1060 * size - Size of each cached object
1061 * depth - Maximum depth of the cache (in objects) <ignored>
1062 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001063 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001064 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001065 *
1066 * DESCRIPTION: Create a cache object
1067 *
1068 ******************************************************************************/
1069
1070acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001071acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001072{
Len Brown4be44fc2005-08-05 00:44:28 -04001073 *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
Adrian Bunka6fdbf92006-12-19 12:56:13 -08001074 if (*cache == NULL)
Bob Mooreb229cf92006-04-21 17:15:00 -04001075 return AE_ERROR;
1076 else
1077 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001078}
1079
1080/*******************************************************************************
1081 *
1082 * FUNCTION: acpi_os_purge_cache
1083 *
1084 * PARAMETERS: Cache - Handle to cache object
1085 *
1086 * RETURN: Status
1087 *
1088 * DESCRIPTION: Free all objects within the requested cache.
1089 *
1090 ******************************************************************************/
1091
Len Brown4be44fc2005-08-05 00:44:28 -04001092acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001093{
Jan Engelhardt50dd0962006-10-01 00:28:50 +02001094 kmem_cache_shrink(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001095 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001096}
1097
1098/*******************************************************************************
1099 *
1100 * FUNCTION: acpi_os_delete_cache
1101 *
1102 * PARAMETERS: Cache - Handle to cache object
1103 *
1104 * RETURN: Status
1105 *
1106 * DESCRIPTION: Free all objects within the requested cache and delete the
1107 * cache object.
1108 *
1109 ******************************************************************************/
1110
Len Brown4be44fc2005-08-05 00:44:28 -04001111acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001112{
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001113 kmem_cache_destroy(cache);
Len Brown4be44fc2005-08-05 00:44:28 -04001114 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001115}
1116
1117/*******************************************************************************
1118 *
1119 * FUNCTION: acpi_os_release_object
1120 *
1121 * PARAMETERS: Cache - Handle to cache object
1122 * Object - The object to be released
1123 *
1124 * RETURN: None
1125 *
1126 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1127 * the object is deleted.
1128 *
1129 ******************************************************************************/
1130
Len Brown4be44fc2005-08-05 00:44:28 -04001131acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001132{
Len Brown4be44fc2005-08-05 00:44:28 -04001133 kmem_cache_free(cache, object);
1134 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001135}
1136
Bob Mooreb229cf92006-04-21 17:15:00 -04001137/******************************************************************************
1138 *
1139 * FUNCTION: acpi_os_validate_interface
1140 *
1141 * PARAMETERS: interface - Requested interface to be validated
1142 *
1143 * RETURN: AE_OK if interface is supported, AE_SUPPORT otherwise
1144 *
1145 * DESCRIPTION: Match an interface string to the interfaces supported by the
1146 * host. Strings originate from an AML call to the _OSI method.
1147 *
1148 *****************************************************************************/
1149
1150acpi_status
1151acpi_os_validate_interface (char *interface)
1152{
1153
1154 return AE_SUPPORT;
1155}
1156
1157
1158/******************************************************************************
1159 *
1160 * FUNCTION: acpi_os_validate_address
1161 *
1162 * PARAMETERS: space_id - ACPI space ID
1163 * address - Physical address
1164 * length - Address length
1165 *
1166 * RETURN: AE_OK if address/length is valid for the space_id. Otherwise,
1167 * should return AE_AML_ILLEGAL_ADDRESS.
1168 *
1169 * DESCRIPTION: Validate a system address via the host OS. Used to validate
1170 * the addresses accessed by AML operation regions.
1171 *
1172 *****************************************************************************/
1173
1174acpi_status
1175acpi_os_validate_address (
1176 u8 space_id,
1177 acpi_physical_address address,
1178 acpi_size length)
1179{
1180
1181 return AE_OK;
1182}
1183
1184
Robert Moore73459f72005-06-24 00:00:00 -04001185#endif