blob: 1bb558adee66cbf90fa930ce93165d6a1d99ba6f [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
28#include <linux/config.h>
29#include <linux/module.h>
30#include <linux/kernel.h>
31#include <linux/slab.h>
32#include <linux/mm.h>
33#include <linux/pci.h>
34#include <linux/smp_lock.h>
35#include <linux/interrupt.h>
36#include <linux/kmod.h>
37#include <linux/delay.h>
38#include <linux/workqueue.h>
39#include <linux/nmi.h>
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -040040#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <acpi/acpi.h>
42#include <asm/io.h>
43#include <acpi/acpi_bus.h>
44#include <acpi/processor.h>
45#include <asm/uaccess.h>
46
47#include <linux/efi.h>
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define _COMPONENT ACPI_OS_SERVICES
Len Brown4be44fc2005-08-05 00:44:28 -040050ACPI_MODULE_NAME("osl")
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#define PREFIX "ACPI: "
Len Brown4be44fc2005-08-05 00:44:28 -040052struct acpi_os_dpc {
53 acpi_osd_exec_callback function;
54 void *context;
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
Len Brown4be44fc2005-08-05 00:44:28 -040079acpi_status acpi_os_initialize(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070080{
81 return AE_OK;
82}
83
Len Brown4be44fc2005-08-05 00:44:28 -040084acpi_status acpi_os_initialize1(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070085{
86 /*
87 * Initialize PCI configuration space access, as we'll need to access
88 * it while walking the namespace (bus 0 and root bridges w/ _BBNs).
89 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 if (!raw_pci_ops) {
Len Brown4be44fc2005-08-05 00:44:28 -040091 printk(KERN_ERR PREFIX
92 "Access to PCI configuration space unavailable\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 return AE_NULL_ENTRY;
94 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 kacpid_wq = create_singlethread_workqueue("kacpid");
96 BUG_ON(!kacpid_wq);
97
98 return AE_OK;
99}
100
Len Brown4be44fc2005-08-05 00:44:28 -0400101acpi_status acpi_os_terminate(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102{
103 if (acpi_irq_handler) {
104 acpi_os_remove_interrupt_handler(acpi_irq_irq,
105 acpi_irq_handler);
106 }
107
108 destroy_workqueue(kacpid_wq);
109
110 return AE_OK;
111}
112
Len Brown4be44fc2005-08-05 00:44:28 -0400113void acpi_os_printf(const char *fmt, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 va_list args;
116 va_start(args, fmt);
117 acpi_os_vprintf(fmt, args);
118 va_end(args);
119}
Len Brown4be44fc2005-08-05 00:44:28 -0400120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121EXPORT_SYMBOL(acpi_os_printf);
122
Len Brown4be44fc2005-08-05 00:44:28 -0400123void acpi_os_vprintf(const char *fmt, va_list args)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124{
125 static char buffer[512];
Len Brown4be44fc2005-08-05 00:44:28 -0400126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 vsprintf(buffer, fmt, args);
128
129#ifdef ENABLE_DEBUGGER
130 if (acpi_in_debugger) {
131 kdb_printf("%s", buffer);
132 } else {
133 printk("%s", buffer);
134 }
135#else
136 printk("%s", buffer);
137#endif
138}
139
David Shaohua Li11e981f2005-08-03 23:46:33 -0400140extern int acpi_in_resume;
Len Brown4be44fc2005-08-05 00:44:28 -0400141void *acpi_os_allocate(acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142{
David Shaohua Li11e981f2005-08-03 23:46:33 -0400143 if (acpi_in_resume)
144 return kmalloc(size, GFP_ATOMIC);
145 else
146 return kmalloc(size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147}
148
Len Brown4be44fc2005-08-05 00:44:28 -0400149void acpi_os_free(void *ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
151 kfree(ptr);
152}
Len Brown4be44fc2005-08-05 00:44:28 -0400153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154EXPORT_SYMBOL(acpi_os_free);
155
Len Brown4be44fc2005-08-05 00:44:28 -0400156acpi_status acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 if (efi_enabled) {
159 addr->pointer_type = ACPI_PHYSICAL_POINTER;
Bjorn Helgaasb2c99e32006-03-26 01:37:08 -0800160 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
161 addr->pointer.physical = efi.acpi20;
162 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
163 addr->pointer.physical = efi.acpi;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 else {
Len Brown4be44fc2005-08-05 00:44:28 -0400165 printk(KERN_ERR PREFIX
166 "System description tables not found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 return AE_NOT_FOUND;
168 }
169 } else {
170 if (ACPI_FAILURE(acpi_find_root_pointer(flags, addr))) {
Len Brown4be44fc2005-08-05 00:44:28 -0400171 printk(KERN_ERR PREFIX
172 "System description tables not found\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 return AE_NOT_FOUND;
174 }
175 }
176
177 return AE_OK;
178}
179
180acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400181acpi_os_map_memory(acpi_physical_address phys, acpi_size size,
182 void __iomem ** virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800184 if (phys > ULONG_MAX) {
185 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
186 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 }
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800188 /*
189 * ioremap checks to ensure this is in reserved space
190 */
191 *virt = ioremap((unsigned long)phys, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193 if (!*virt)
194 return AE_NO_MEMORY;
195
196 return AE_OK;
197}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800198EXPORT_SYMBOL_GPL(acpi_os_map_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Len Brown4be44fc2005-08-05 00:44:28 -0400200void acpi_os_unmap_memory(void __iomem * virt, acpi_size size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
202 iounmap(virt);
203}
Kylene Jo Hall55a82ab2006-01-08 01:03:15 -0800204EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206#ifdef ACPI_FUTURE_USAGE
207acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400208acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
Len Brown4be44fc2005-08-05 00:44:28 -0400210 if (!phys || !virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 return AE_BAD_PARAMETER;
212
213 *phys = virt_to_phys(virt);
214
215 return AE_OK;
216}
217#endif
218
219#define ACPI_MAX_OVERRIDE_LEN 100
220
221static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
222
223acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400224acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
225 acpi_string * new_val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226{
227 if (!init_val || !new_val)
228 return AE_BAD_PARAMETER;
229
230 *new_val = NULL;
Len Brown4be44fc2005-08-05 00:44:28 -0400231 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400233 acpi_os_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 *new_val = acpi_os_name;
235 }
236
237 return AE_OK;
238}
239
240acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400241acpi_os_table_override(struct acpi_table_header * existing_table,
242 struct acpi_table_header ** new_table)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
244 if (!existing_table || !new_table)
245 return AE_BAD_PARAMETER;
246
247#ifdef CONFIG_ACPI_CUSTOM_DSDT
248 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
Len Brown4be44fc2005-08-05 00:44:28 -0400249 *new_table = (struct acpi_table_header *)AmlCode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 else
251 *new_table = NULL;
252#else
253 *new_table = NULL;
254#endif
255 return AE_OK;
256}
257
Len Brown4be44fc2005-08-05 00:44:28 -0400258static irqreturn_t acpi_irq(int irq, void *dev_id, struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259{
Len Brown4be44fc2005-08-05 00:44:28 -0400260 return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261}
262
263acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400264acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
265 void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{
267 unsigned int irq;
268
269 /*
270 * Ignore the GSI from the core, and use the value in our copy of the
271 * FADT. It may not be the same if an interrupt source override exists
272 * for the SCI.
273 */
274 gsi = acpi_fadt.sci_int;
275 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
276 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
277 gsi);
278 return AE_OK;
279 }
280
281 acpi_irq_handler = handler;
282 acpi_irq_context = context;
283 if (request_irq(irq, acpi_irq, SA_SHIRQ, "acpi", acpi_irq)) {
284 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
285 return AE_NOT_ACQUIRED;
286 }
287 acpi_irq_irq = irq;
288
289 return AE_OK;
290}
291
Len Brown4be44fc2005-08-05 00:44:28 -0400292acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
294 if (irq) {
295 free_irq(irq, acpi_irq);
296 acpi_irq_handler = NULL;
297 acpi_irq_irq = 0;
298 }
299
300 return AE_OK;
301}
302
303/*
304 * Running in interpreter thread context, safe to sleep
305 */
306
Len Brown4be44fc2005-08-05 00:44:28 -0400307void acpi_os_sleep(acpi_integer ms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308{
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800309 schedule_timeout_interruptible(msecs_to_jiffies(ms));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
Len Brown4be44fc2005-08-05 00:44:28 -0400311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312EXPORT_SYMBOL(acpi_os_sleep);
313
Len Brown4be44fc2005-08-05 00:44:28 -0400314void acpi_os_stall(u32 us)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
316 while (us) {
317 u32 delay = 1000;
318
319 if (delay > us)
320 delay = us;
321 udelay(delay);
322 touch_nmi_watchdog();
323 us -= delay;
324 }
325}
Len Brown4be44fc2005-08-05 00:44:28 -0400326
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327EXPORT_SYMBOL(acpi_os_stall);
328
329/*
330 * Support ACPI 3.0 AML Timer operand
331 * Returns 64-bit free-running, monotonically increasing timer
332 * with 100ns granularity
333 */
Len Brown4be44fc2005-08-05 00:44:28 -0400334u64 acpi_os_get_timer(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
336 static u64 t;
337
338#ifdef CONFIG_HPET
339 /* TBD: use HPET if available */
340#endif
341
342#ifdef CONFIG_X86_PM_TIMER
343 /* TBD: default to PM timer if HPET was not available */
344#endif
345 if (!t)
346 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
347
348 return ++t;
349}
350
Len Brown4be44fc2005-08-05 00:44:28 -0400351acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
353 u32 dummy;
354
355 if (!value)
356 value = &dummy;
357
Len Brown4be44fc2005-08-05 00:44:28 -0400358 switch (width) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 case 8:
Len Brown4be44fc2005-08-05 00:44:28 -0400360 *(u8 *) value = inb(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 break;
362 case 16:
Len Brown4be44fc2005-08-05 00:44:28 -0400363 *(u16 *) value = inw(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 break;
365 case 32:
Len Brown4be44fc2005-08-05 00:44:28 -0400366 *(u32 *) value = inl(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 break;
368 default:
369 BUG();
370 }
371
372 return AE_OK;
373}
Len Brown4be44fc2005-08-05 00:44:28 -0400374
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375EXPORT_SYMBOL(acpi_os_read_port);
376
Len Brown4be44fc2005-08-05 00:44:28 -0400377acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Len Brown4be44fc2005-08-05 00:44:28 -0400379 switch (width) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 case 8:
381 outb(value, port);
382 break;
383 case 16:
384 outw(value, port);
385 break;
386 case 32:
387 outl(value, port);
388 break;
389 default:
390 BUG();
391 }
392
393 return AE_OK;
394}
Len Brown4be44fc2005-08-05 00:44:28 -0400395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396EXPORT_SYMBOL(acpi_os_write_port);
397
398acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400399acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Len Brown4be44fc2005-08-05 00:44:28 -0400401 u32 dummy;
402 void __iomem *virt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800404 virt_addr = ioremap(phys_addr, width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 if (!value)
406 value = &dummy;
407
408 switch (width) {
409 case 8:
Len Brown4be44fc2005-08-05 00:44:28 -0400410 *(u8 *) value = readb(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 break;
412 case 16:
Len Brown4be44fc2005-08-05 00:44:28 -0400413 *(u16 *) value = readw(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 break;
415 case 32:
Len Brown4be44fc2005-08-05 00:44:28 -0400416 *(u32 *) value = readl(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 break;
418 default:
419 BUG();
420 }
421
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800422 iounmap(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 return AE_OK;
425}
426
427acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400428acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
Len Brown4be44fc2005-08-05 00:44:28 -0400430 void __iomem *virt_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800432 virt_addr = ioremap(phys_addr, width);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
434 switch (width) {
435 case 8:
436 writeb(value, virt_addr);
437 break;
438 case 16:
439 writew(value, virt_addr);
440 break;
441 case 32:
442 writel(value, virt_addr);
443 break;
444 default:
445 BUG();
446 }
447
Bjorn Helgaas9f4fd612006-03-26 01:37:10 -0800448 iounmap(virt_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
450 return AE_OK;
451}
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400454acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
455 void *value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
457 int result, size;
458
459 if (!value)
460 return AE_BAD_PARAMETER;
461
462 switch (width) {
463 case 8:
464 size = 1;
465 break;
466 case 16:
467 size = 2;
468 break;
469 case 32:
470 size = 4;
471 break;
472 default:
473 return AE_ERROR;
474 }
475
476 BUG_ON(!raw_pci_ops);
477
478 result = raw_pci_ops->read(pci_id->segment, pci_id->bus,
Len Brown4be44fc2005-08-05 00:44:28 -0400479 PCI_DEVFN(pci_id->device, pci_id->function),
480 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481
482 return (result ? AE_ERROR : AE_OK);
483}
Len Brown4be44fc2005-08-05 00:44:28 -0400484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485EXPORT_SYMBOL(acpi_os_read_pci_configuration);
486
487acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400488acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
489 acpi_integer value, u32 width)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490{
491 int result, size;
492
493 switch (width) {
494 case 8:
495 size = 1;
496 break;
497 case 16:
498 size = 2;
499 break;
500 case 32:
501 size = 4;
502 break;
503 default:
504 return AE_ERROR;
505 }
506
507 BUG_ON(!raw_pci_ops);
508
509 result = raw_pci_ops->write(pci_id->segment, pci_id->bus,
Len Brown4be44fc2005-08-05 00:44:28 -0400510 PCI_DEVFN(pci_id->device, pci_id->function),
511 reg, size, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
513 return (result ? AE_ERROR : AE_OK);
514}
515
516/* TODO: Change code to take advantage of driver model more */
Len Brown4be44fc2005-08-05 00:44:28 -0400517static void acpi_os_derive_pci_id_2(acpi_handle rhandle, /* upper bound */
518 acpi_handle chandle, /* current node */
519 struct acpi_pci_id **id,
520 int *is_bridge, u8 * bus_number)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521{
Len Brown4be44fc2005-08-05 00:44:28 -0400522 acpi_handle handle;
523 struct acpi_pci_id *pci_id = *id;
524 acpi_status status;
525 unsigned long temp;
526 acpi_object_type type;
527 u8 tu8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
529 acpi_get_parent(chandle, &handle);
530 if (handle != rhandle) {
Len Brown4be44fc2005-08-05 00:44:28 -0400531 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
532 bus_number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
534 status = acpi_get_type(handle, &type);
Len Brown4be44fc2005-08-05 00:44:28 -0400535 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 return;
537
Len Brown4be44fc2005-08-05 00:44:28 -0400538 status =
539 acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
540 &temp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 if (ACPI_SUCCESS(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400542 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
543 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 if (*is_bridge)
546 pci_id->bus = *bus_number;
547
548 /* any nicer way to get bus number of bridge ? */
Len Brown4be44fc2005-08-05 00:44:28 -0400549 status =
550 acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8,
551 8);
552 if (ACPI_SUCCESS(status)
553 && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) {
554 status =
555 acpi_os_read_pci_configuration(pci_id, 0x18,
556 &tu8, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 if (!ACPI_SUCCESS(status)) {
558 /* Certainly broken... FIX ME */
559 return;
560 }
561 *is_bridge = 1;
562 pci_id->bus = tu8;
Len Brown4be44fc2005-08-05 00:44:28 -0400563 status =
564 acpi_os_read_pci_configuration(pci_id, 0x19,
565 &tu8, 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 if (ACPI_SUCCESS(status)) {
567 *bus_number = tu8;
568 }
569 } else
570 *is_bridge = 0;
571 }
572 }
573}
574
Len Brown4be44fc2005-08-05 00:44:28 -0400575void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */
576 acpi_handle chandle, /* current node */
577 struct acpi_pci_id **id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
579 int is_bridge = 1;
580 u8 bus_number = (*id)->bus;
581
582 acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
583}
584
Len Brown4be44fc2005-08-05 00:44:28 -0400585static void acpi_os_execute_deferred(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586{
Len Brown4be44fc2005-08-05 00:44:28 -0400587 struct acpi_os_dpc *dpc = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Len Brown4be44fc2005-08-05 00:44:28 -0400589 ACPI_FUNCTION_TRACE("os_execute_deferred");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
Len Brown4be44fc2005-08-05 00:44:28 -0400591 dpc = (struct acpi_os_dpc *)context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 if (!dpc) {
Len Brown4be44fc2005-08-05 00:44:28 -0400593 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid (NULL) context.\n"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 return_VOID;
595 }
596
597 dpc->function(dpc->context);
598
599 kfree(dpc);
600
601 return_VOID;
602}
603
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400604static int acpi_os_execute_thread(void *context)
605{
606 struct acpi_os_dpc *dpc = (struct acpi_os_dpc *)context;
607 if (dpc) {
608 dpc->function(dpc->context);
609 kfree(dpc);
610 }
611 do_exit(0);
612}
613
614/*******************************************************************************
615 *
616 * FUNCTION: acpi_os_execute
617 *
618 * PARAMETERS: Type - Type of the callback
619 * Function - Function to be executed
620 * Context - Function parameters
621 *
622 * RETURN: Status
623 *
624 * DESCRIPTION: Depending on type, either queues function for deferred execution or
625 * immediately executes function on a separate thread.
626 *
627 ******************************************************************************/
628
629acpi_status acpi_os_execute(acpi_execute_type type,
Len Brown4be44fc2005-08-05 00:44:28 -0400630 acpi_osd_exec_callback function, void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Len Brown4be44fc2005-08-05 00:44:28 -0400632 acpi_status status = AE_OK;
633 struct acpi_os_dpc *dpc;
634 struct work_struct *task;
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400635 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
637 if (!function)
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400638 return AE_BAD_PARAMETER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 /*
640 * Allocate/initialize DPC structure. Note that this memory will be
641 * freed by the callee. The kernel handles the tq_struct list in a
642 * way that allows us to also free its memory inside the callee.
643 * Because we may want to schedule several tasks with different
644 * parameters we can't use the approach some kernel code uses of
645 * having a static tq_struct.
646 * We can save time and code by allocating the DPC and tq_structs
647 * from the same memory.
648 */
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400649 if (type == OSL_NOTIFY_HANDLER) {
650 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_KERNEL);
651 } else {
652 dpc = kmalloc(sizeof(struct acpi_os_dpc) +
653 sizeof(struct work_struct), GFP_ATOMIC);
654 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (!dpc)
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400656 return AE_NO_MEMORY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 dpc->function = function;
658 dpc->context = context;
659
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400660 if (type == OSL_NOTIFY_HANDLER) {
661 p = kthread_create(acpi_os_execute_thread, dpc, "kacpid_notify");
662 if (!IS_ERR(p)) {
663 wake_up_process(p);
664 } else {
665 status = AE_NO_MEMORY;
666 kfree(dpc);
667 }
668 } else {
669 task = (void *)(dpc + 1);
670 INIT_WORK(task, acpi_os_execute_deferred, (void *)dpc);
671 if (!queue_work(kacpid_wq, task)) {
672 status = AE_ERROR;
673 kfree(dpc);
674 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400676 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677}
Len Brown4be44fc2005-08-05 00:44:28 -0400678
Alexey Starikovskiyb8d35192006-05-05 03:23:00 -0400679EXPORT_SYMBOL(acpi_os_execute);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Len Brown4be44fc2005-08-05 00:44:28 -0400681void acpi_os_wait_events_complete(void *context)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682{
683 flush_workqueue(kacpid_wq);
684}
Len Brown4be44fc2005-08-05 00:44:28 -0400685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686EXPORT_SYMBOL(acpi_os_wait_events_complete);
687
688/*
689 * Allocate the memory for a spinlock and initialize it.
690 */
Len Brown4be44fc2005-08-05 00:44:28 -0400691acpi_status acpi_os_create_lock(acpi_handle * out_handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
693 spinlock_t *lock_ptr;
694
Len Brown4be44fc2005-08-05 00:44:28 -0400695 ACPI_FUNCTION_TRACE("os_create_lock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 lock_ptr = acpi_os_allocate(sizeof(spinlock_t));
698
699 spin_lock_init(lock_ptr);
700
Len Brown4be44fc2005-08-05 00:44:28 -0400701 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating spinlock[%p].\n", lock_ptr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
703 *out_handle = lock_ptr;
704
Len Brown4be44fc2005-08-05 00:44:28 -0400705 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706}
707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708/*
709 * Deallocate the memory for a spinlock.
710 */
Len Brown4be44fc2005-08-05 00:44:28 -0400711void acpi_os_delete_lock(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712{
Len Brown4be44fc2005-08-05 00:44:28 -0400713 ACPI_FUNCTION_TRACE("os_create_lock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714
Len Brown4be44fc2005-08-05 00:44:28 -0400715 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting spinlock[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
717 acpi_os_free(handle);
718
719 return_VOID;
720}
721
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400723acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
Len Brown4be44fc2005-08-05 00:44:28 -0400725 struct semaphore *sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Len Brown4be44fc2005-08-05 00:44:28 -0400727 ACPI_FUNCTION_TRACE("os_create_semaphore");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728
729 sem = acpi_os_allocate(sizeof(struct semaphore));
730 if (!sem)
Len Brown4be44fc2005-08-05 00:44:28 -0400731 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 memset(sem, 0, sizeof(struct semaphore));
733
734 sema_init(sem, initial_units);
735
Len Brown4be44fc2005-08-05 00:44:28 -0400736 *handle = (acpi_handle *) sem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737
Len Brown4be44fc2005-08-05 00:44:28 -0400738 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
739 *handle, initial_units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Len Brown4be44fc2005-08-05 00:44:28 -0400741 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743
Len Brown4be44fc2005-08-05 00:44:28 -0400744EXPORT_SYMBOL(acpi_os_create_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746/*
747 * TODO: A better way to delete semaphores? Linux doesn't have a
748 * 'delete_semaphore()' function -- may result in an invalid
749 * pointer dereference for non-synchronized consumers. Should
750 * we at least check for blocked threads and signal/cancel them?
751 */
752
Len Brown4be44fc2005-08-05 00:44:28 -0400753acpi_status acpi_os_delete_semaphore(acpi_handle handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754{
Len Brown4be44fc2005-08-05 00:44:28 -0400755 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Len Brown4be44fc2005-08-05 00:44:28 -0400757 ACPI_FUNCTION_TRACE("os_delete_semaphore");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
759 if (!sem)
Len Brown4be44fc2005-08-05 00:44:28 -0400760 return_ACPI_STATUS(AE_BAD_PARAMETER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Len Brown4be44fc2005-08-05 00:44:28 -0400762 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Len Brown4be44fc2005-08-05 00:44:28 -0400764 acpi_os_free(sem);
765 sem = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Len Brown4be44fc2005-08-05 00:44:28 -0400767 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
Len Brown4be44fc2005-08-05 00:44:28 -0400770EXPORT_SYMBOL(acpi_os_delete_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
772/*
773 * TODO: The kernel doesn't have a 'down_timeout' function -- had to
774 * improvise. The process is to sleep for one scheduler quantum
775 * until the semaphore becomes available. Downside is that this
776 * may result in starvation for timeout-based waits when there's
777 * lots of semaphore activity.
778 *
779 * TODO: Support for units > 1?
780 */
Len Brown4be44fc2005-08-05 00:44:28 -0400781acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782{
Len Brown4be44fc2005-08-05 00:44:28 -0400783 acpi_status status = AE_OK;
784 struct semaphore *sem = (struct semaphore *)handle;
785 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Len Brown4be44fc2005-08-05 00:44:28 -0400787 ACPI_FUNCTION_TRACE("os_wait_semaphore");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
789 if (!sem || (units < 1))
Len Brown4be44fc2005-08-05 00:44:28 -0400790 return_ACPI_STATUS(AE_BAD_PARAMETER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
792 if (units > 1)
Len Brown4be44fc2005-08-05 00:44:28 -0400793 return_ACPI_STATUS(AE_SUPPORT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Len Brown4be44fc2005-08-05 00:44:28 -0400795 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
796 handle, units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
Len Brown4be44fc2005-08-05 00:44:28 -0400798 switch (timeout) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 /*
800 * No Wait:
801 * --------
802 * A zero timeout value indicates that we shouldn't wait - just
803 * acquire the semaphore if available otherwise return AE_TIME
804 * (a.k.a. 'would block').
805 */
Len Brown4be44fc2005-08-05 00:44:28 -0400806 case 0:
807 if (down_trylock(sem))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 status = AE_TIME;
809 break;
810
811 /*
812 * Wait Indefinitely:
813 * ------------------
814 */
Len Brown4be44fc2005-08-05 00:44:28 -0400815 case ACPI_WAIT_FOREVER:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 down(sem);
817 break;
818
819 /*
820 * Wait w/ Timeout:
821 * ----------------
822 */
Len Brown4be44fc2005-08-05 00:44:28 -0400823 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 // TODO: A better timeout algorithm?
825 {
826 int i = 0;
Len Brown4be44fc2005-08-05 00:44:28 -0400827 static const int quantum_ms = 1000 / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
829 ret = down_trylock(sem);
Yu Lumingdacd9b82005-12-31 01:45:00 -0500830 for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) {
Nishanth Aravamudan01a527e2005-11-07 01:01:14 -0800831 schedule_timeout_interruptible(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 ret = down_trylock(sem);
833 }
Len Brown4be44fc2005-08-05 00:44:28 -0400834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 if (ret != 0)
836 status = AE_TIME;
837 }
838 break;
839 }
840
841 if (ACPI_FAILURE(status)) {
Len Brown4be44fc2005-08-05 00:44:28 -0400842 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
843 "Failed to acquire semaphore[%p|%d|%d], %s\n",
844 handle, units, timeout,
845 acpi_format_exception(status)));
846 } else {
847 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
848 "Acquired semaphore[%p|%d|%d]\n", handle,
849 units, timeout));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 }
851
Len Brown4be44fc2005-08-05 00:44:28 -0400852 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854
Len Brown4be44fc2005-08-05 00:44:28 -0400855EXPORT_SYMBOL(acpi_os_wait_semaphore);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856
857/*
858 * TODO: Support for units > 1?
859 */
Len Brown4be44fc2005-08-05 00:44:28 -0400860acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861{
Len Brown4be44fc2005-08-05 00:44:28 -0400862 struct semaphore *sem = (struct semaphore *)handle;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
Len Brown4be44fc2005-08-05 00:44:28 -0400864 ACPI_FUNCTION_TRACE("os_signal_semaphore");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865
866 if (!sem || (units < 1))
Len Brown4be44fc2005-08-05 00:44:28 -0400867 return_ACPI_STATUS(AE_BAD_PARAMETER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868
869 if (units > 1)
Len Brown4be44fc2005-08-05 00:44:28 -0400870 return_ACPI_STATUS(AE_SUPPORT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871
Len Brown4be44fc2005-08-05 00:44:28 -0400872 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
873 units));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
875 up(sem);
876
Len Brown4be44fc2005-08-05 00:44:28 -0400877 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878}
Len Brown4be44fc2005-08-05 00:44:28 -0400879
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880EXPORT_SYMBOL(acpi_os_signal_semaphore);
881
882#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -0400883u32 acpi_os_get_line(char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884{
885
886#ifdef ENABLE_DEBUGGER
887 if (acpi_in_debugger) {
888 u32 chars;
889
890 kdb_read(buffer, sizeof(line_buf));
891
892 /* remove the CR kdb includes */
893 chars = strlen(buffer) - 1;
894 buffer[chars] = '\0';
895 }
896#endif
897
898 return 0;
899}
Len Brown4be44fc2005-08-05 00:44:28 -0400900#endif /* ACPI_FUTURE_USAGE */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
902/* Assumes no unreadable holes inbetween */
Len Brown4be44fc2005-08-05 00:44:28 -0400903u8 acpi_os_readable(void *ptr, acpi_size len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904{
Len Brown4be44fc2005-08-05 00:44:28 -0400905#if defined(__i386__) || defined(__x86_64__)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 char tmp;
Len Brown4be44fc2005-08-05 00:44:28 -0400907 return !__get_user(tmp, (char __user *)ptr)
908 && !__get_user(tmp, (char __user *)ptr + len - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909#endif
910 return 1;
911}
912
913#ifdef ACPI_FUTURE_USAGE
Len Brown4be44fc2005-08-05 00:44:28 -0400914u8 acpi_os_writable(void *ptr, acpi_size len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915{
916 /* could do dummy write (racy) or a kernel page table lookup.
917 The later may be difficult at early boot when kmap doesn't work yet. */
918 return 1;
919}
920#endif
921
Len Brown4be44fc2005-08-05 00:44:28 -0400922acpi_status acpi_os_signal(u32 function, void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923{
Len Brown4be44fc2005-08-05 00:44:28 -0400924 switch (function) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 case ACPI_SIGNAL_FATAL:
926 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
927 break;
928 case ACPI_SIGNAL_BREAKPOINT:
929 /*
930 * AML Breakpoint
931 * ACPI spec. says to treat it as a NOP unless
932 * you are debugging. So if/when we integrate
933 * AML debugger into the kernel debugger its
934 * hook will go here. But until then it is
935 * not useful to print anything on breakpoints.
936 */
937 break;
938 default:
939 break;
940 }
941
942 return AE_OK;
943}
Len Brown4be44fc2005-08-05 00:44:28 -0400944
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945EXPORT_SYMBOL(acpi_os_signal);
946
Len Brown4be44fc2005-08-05 00:44:28 -0400947static int __init acpi_os_name_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948{
949 char *p = acpi_os_name;
Len Brown4be44fc2005-08-05 00:44:28 -0400950 int count = ACPI_MAX_OVERRIDE_LEN - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
952 if (!str || !*str)
953 return 0;
954
955 for (; count-- && str && *str; str++) {
956 if (isalnum(*str) || *str == ' ' || *str == ':')
957 *p++ = *str;
958 else if (*str == '\'' || *str == '"')
959 continue;
960 else
961 break;
962 }
963 *p = 0;
964
965 return 1;
Len Brown4be44fc2005-08-05 00:44:28 -0400966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967}
968
969__setup("acpi_os_name=", acpi_os_name_setup);
970
971/*
972 * _OSI control
973 * empty string disables _OSI
974 * TBD additional string adds to _OSI
975 */
Len Brown4be44fc2005-08-05 00:44:28 -0400976static int __init acpi_osi_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977{
978 if (str == NULL || *str == '\0') {
979 printk(KERN_INFO PREFIX "_OSI method disabled\n");
980 acpi_gbl_create_osi_method = FALSE;
Len Brown4be44fc2005-08-05 00:44:28 -0400981 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 /* TBD */
Len Brown4be44fc2005-08-05 00:44:28 -0400983 printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n",
984 str);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 }
986
987 return 1;
988}
989
990__setup("acpi_osi=", acpi_osi_setup);
991
992/* enable serialization to combat AE_ALREADY_EXISTS errors */
Len Brown4be44fc2005-08-05 00:44:28 -0400993static int __init acpi_serialize_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994{
995 printk(KERN_INFO PREFIX "serialize enabled\n");
996
997 acpi_gbl_all_methods_serialized = TRUE;
998
999 return 1;
1000}
1001
1002__setup("acpi_serialize", acpi_serialize_setup);
1003
1004/*
1005 * Wake and Run-Time GPES are expected to be separate.
1006 * We disable wake-GPEs at run-time to prevent spurious
1007 * interrupts.
1008 *
1009 * However, if a system exists that shares Wake and
1010 * Run-time events on the same GPE this flag is available
1011 * to tell Linux to keep the wake-time GPEs enabled at run-time.
1012 */
Len Brown4be44fc2005-08-05 00:44:28 -04001013static int __init acpi_wake_gpes_always_on_setup(char *str)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014{
1015 printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
1016
1017 acpi_gbl_leave_wake_gpes_disabled = FALSE;
1018
1019 return 1;
1020}
1021
1022__setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
1023
Adrian Bunk8713cbe2005-09-02 17:16:48 -04001024static int __init acpi_hotkey_setup(char *str)
Luming Yufb9802f2005-03-18 18:03:45 -05001025{
Luming Yu30e332f2005-08-12 00:31:00 -04001026 acpi_specific_hotkey_enabled = FALSE;
Luming Yufb9802f2005-03-18 18:03:45 -05001027 return 1;
1028}
1029
Luming Yu30e332f2005-08-12 00:31:00 -04001030__setup("acpi_generic_hotkey", acpi_hotkey_setup);
Luming Yufb9802f2005-03-18 18:03:45 -05001031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032/*
1033 * max_cstate is defined in the base kernel so modules can
1034 * change it w/o depending on the state of the processor module.
1035 */
1036unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
1037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038EXPORT_SYMBOL(max_cstate);
Robert Moore73459f72005-06-24 00:00:00 -04001039
1040/*
1041 * Acquire a spinlock.
1042 *
1043 * handle is a pointer to the spinlock_t.
Robert Moore73459f72005-06-24 00:00:00 -04001044 */
1045
Bob Mooreb8e4d892006-01-27 16:43:00 -05001046acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle)
Robert Moore73459f72005-06-24 00:00:00 -04001047{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001048 acpi_cpu_flags flags;
Len Brown4be44fc2005-08-05 00:44:28 -04001049 spin_lock_irqsave((spinlock_t *) handle, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001050 return flags;
1051}
1052
1053/*
1054 * Release a spinlock. See above.
1055 */
1056
Bob Mooreb8e4d892006-01-27 16:43:00 -05001057void acpi_os_release_lock(acpi_handle handle, acpi_cpu_flags flags)
Robert Moore73459f72005-06-24 00:00:00 -04001058{
Bob Mooreb8e4d892006-01-27 16:43:00 -05001059 spin_unlock_irqrestore((spinlock_t *) handle, flags);
Robert Moore73459f72005-06-24 00:00:00 -04001060}
1061
Robert Moore73459f72005-06-24 00:00:00 -04001062#ifndef ACPI_USE_LOCAL_CACHE
1063
1064/*******************************************************************************
1065 *
1066 * FUNCTION: acpi_os_create_cache
1067 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001068 * PARAMETERS: name - Ascii name for the cache
1069 * size - Size of each cached object
1070 * depth - Maximum depth of the cache (in objects) <ignored>
1071 * cache - Where the new cache object is returned
Robert Moore73459f72005-06-24 00:00:00 -04001072 *
Bob Mooreb229cf92006-04-21 17:15:00 -04001073 * RETURN: status
Robert Moore73459f72005-06-24 00:00:00 -04001074 *
1075 * DESCRIPTION: Create a cache object
1076 *
1077 ******************************************************************************/
1078
1079acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -04001080acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
Robert Moore73459f72005-06-24 00:00:00 -04001081{
Len Brown4be44fc2005-08-05 00:44:28 -04001082 *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
Bob Mooreb229cf92006-04-21 17:15:00 -04001083 if (cache == NULL)
1084 return AE_ERROR;
1085 else
1086 return AE_OK;
Robert Moore73459f72005-06-24 00:00:00 -04001087}
1088
1089/*******************************************************************************
1090 *
1091 * FUNCTION: acpi_os_purge_cache
1092 *
1093 * PARAMETERS: Cache - Handle to cache object
1094 *
1095 * RETURN: Status
1096 *
1097 * DESCRIPTION: Free all objects within the requested cache.
1098 *
1099 ******************************************************************************/
1100
Len Brown4be44fc2005-08-05 00:44:28 -04001101acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001102{
Len Brown4be44fc2005-08-05 00:44:28 -04001103 (void)kmem_cache_shrink(cache);
1104 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001105}
1106
1107/*******************************************************************************
1108 *
1109 * FUNCTION: acpi_os_delete_cache
1110 *
1111 * PARAMETERS: Cache - Handle to cache object
1112 *
1113 * RETURN: Status
1114 *
1115 * DESCRIPTION: Free all objects within the requested cache and delete the
1116 * cache object.
1117 *
1118 ******************************************************************************/
1119
Len Brown4be44fc2005-08-05 00:44:28 -04001120acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001121{
Len Brown4be44fc2005-08-05 00:44:28 -04001122 (void)kmem_cache_destroy(cache);
1123 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001124}
1125
1126/*******************************************************************************
1127 *
1128 * FUNCTION: acpi_os_release_object
1129 *
1130 * PARAMETERS: Cache - Handle to cache object
1131 * Object - The object to be released
1132 *
1133 * RETURN: None
1134 *
1135 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1136 * the object is deleted.
1137 *
1138 ******************************************************************************/
1139
Len Brown4be44fc2005-08-05 00:44:28 -04001140acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
Robert Moore73459f72005-06-24 00:00:00 -04001141{
Len Brown4be44fc2005-08-05 00:44:28 -04001142 kmem_cache_free(cache, object);
1143 return (AE_OK);
Robert Moore73459f72005-06-24 00:00:00 -04001144}
1145
1146/*******************************************************************************
1147 *
1148 * FUNCTION: acpi_os_acquire_object
1149 *
1150 * PARAMETERS: Cache - Handle to cache object
1151 * ReturnObject - Where the object is returned
1152 *
1153 * RETURN: Status
1154 *
Bob Moore616861242006-03-17 16:44:00 -05001155 * DESCRIPTION: Return a zero-filled object.
Robert Moore73459f72005-06-24 00:00:00 -04001156 *
1157 ******************************************************************************/
1158
Len Brown4be44fc2005-08-05 00:44:28 -04001159void *acpi_os_acquire_object(acpi_cache_t * cache)
Robert Moore73459f72005-06-24 00:00:00 -04001160{
Bob Moore616861242006-03-17 16:44:00 -05001161 void *object = kmem_cache_zalloc(cache, GFP_KERNEL);
Len Brown4be44fc2005-08-05 00:44:28 -04001162 WARN_ON(!object);
1163 return object;
Robert Moore73459f72005-06-24 00:00:00 -04001164}
1165
Bob Mooreb229cf92006-04-21 17:15:00 -04001166/******************************************************************************
1167 *
1168 * FUNCTION: acpi_os_validate_interface
1169 *
1170 * PARAMETERS: interface - Requested interface to be validated
1171 *
1172 * RETURN: AE_OK if interface is supported, AE_SUPPORT otherwise
1173 *
1174 * DESCRIPTION: Match an interface string to the interfaces supported by the
1175 * host. Strings originate from an AML call to the _OSI method.
1176 *
1177 *****************************************************************************/
1178
1179acpi_status
1180acpi_os_validate_interface (char *interface)
1181{
1182
1183 return AE_SUPPORT;
1184}
1185
1186
1187/******************************************************************************
1188 *
1189 * FUNCTION: acpi_os_validate_address
1190 *
1191 * PARAMETERS: space_id - ACPI space ID
1192 * address - Physical address
1193 * length - Address length
1194 *
1195 * RETURN: AE_OK if address/length is valid for the space_id. Otherwise,
1196 * should return AE_AML_ILLEGAL_ADDRESS.
1197 *
1198 * DESCRIPTION: Validate a system address via the host OS. Used to validate
1199 * the addresses accessed by AML operation regions.
1200 *
1201 *****************************************************************************/
1202
1203acpi_status
1204acpi_os_validate_address (
1205 u8 space_id,
1206 acpi_physical_address address,
1207 acpi_size length)
1208{
1209
1210 return AE_OK;
1211}
1212
1213
Robert Moore73459f72005-06-24 00:00:00 -04001214#endif