ACPI: use more understandable bus_id for ACPI devices
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / acpi / osl.c
CommitLineData
1da177e4
LT
1/*
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
1da177e4
LT
28#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>
39#include <acpi/acpi.h>
40#include <asm/io.h>
41#include <acpi/acpi_bus.h>
42#include <acpi/processor.h>
43#include <asm/uaccess.h>
44
45#include <linux/efi.h>
46
1da177e4 47#define _COMPONENT ACPI_OS_SERVICES
4be44fcd 48ACPI_MODULE_NAME("osl")
1da177e4 49#define PREFIX "ACPI: "
4be44fcd
LB
50struct acpi_os_dpc {
51 acpi_osd_exec_callback function;
52 void *context;
65f27f38 53 struct work_struct work;
1da177e4
LT
54};
55
56#ifdef CONFIG_ACPI_CUSTOM_DSDT
57#include CONFIG_ACPI_CUSTOM_DSDT_FILE
58#endif
59
60#ifdef ENABLE_DEBUGGER
61#include <linux/kdb.h>
62
63/* stuff for debugger support */
64int acpi_in_debugger;
65EXPORT_SYMBOL(acpi_in_debugger);
66
67extern char line_buf[80];
4be44fcd 68#endif /*ENABLE_DEBUGGER */
1da177e4 69
30e332f3 70int acpi_specific_hotkey_enabled = TRUE;
fb9802fa
LY
71EXPORT_SYMBOL(acpi_specific_hotkey_enabled);
72
1da177e4
LT
73static unsigned int acpi_irq_irq;
74static acpi_osd_handler acpi_irq_handler;
75static void *acpi_irq_context;
76static struct workqueue_struct *kacpid_wq;
77
4be44fcd 78acpi_status acpi_os_initialize(void)
1da177e4
LT
79{
80 return AE_OK;
81}
82
4be44fcd 83acpi_status acpi_os_initialize1(void)
1da177e4
LT
84{
85 /*
86 * Initialize PCI configuration space access, as we'll need to access
87 * it while walking the namespace (bus 0 and root bridges w/ _BBNs).
88 */
1da177e4 89 if (!raw_pci_ops) {
4be44fcd
LB
90 printk(KERN_ERR PREFIX
91 "Access to PCI configuration space unavailable\n");
1da177e4
LT
92 return AE_NULL_ENTRY;
93 }
1da177e4
LT
94 kacpid_wq = create_singlethread_workqueue("kacpid");
95 BUG_ON(!kacpid_wq);
b976fe19 96
1da177e4
LT
97 return AE_OK;
98}
99
4be44fcd 100acpi_status acpi_os_terminate(void)
1da177e4
LT
101{
102 if (acpi_irq_handler) {
103 acpi_os_remove_interrupt_handler(acpi_irq_irq,
104 acpi_irq_handler);
105 }
106
107 destroy_workqueue(kacpid_wq);
108
109 return AE_OK;
110}
111
4be44fcd 112void acpi_os_printf(const char *fmt, ...)
1da177e4
LT
113{
114 va_list args;
115 va_start(args, fmt);
116 acpi_os_vprintf(fmt, args);
117 va_end(args);
118}
4be44fcd 119
1da177e4
LT
120EXPORT_SYMBOL(acpi_os_printf);
121
4be44fcd 122void acpi_os_vprintf(const char *fmt, va_list args)
1da177e4
LT
123{
124 static char buffer[512];
4be44fcd 125
1da177e4
LT
126 vsprintf(buffer, fmt, args);
127
128#ifdef ENABLE_DEBUGGER
129 if (acpi_in_debugger) {
130 kdb_printf("%s", buffer);
131 } else {
132 printk("%s", buffer);
133 }
134#else
135 printk("%s", buffer);
136#endif
137}
138
4be44fcd 139acpi_status acpi_os_get_root_pointer(u32 flags, struct acpi_pointer *addr)
1da177e4
LT
140{
141 if (efi_enabled) {
142 addr->pointer_type = ACPI_PHYSICAL_POINTER;
b2c99e3c
BH
143 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
144 addr->pointer.physical = efi.acpi20;
145 else if (efi.acpi != EFI_INVALID_TABLE_ADDR)
146 addr->pointer.physical = efi.acpi;
1da177e4 147 else {
4be44fcd
LB
148 printk(KERN_ERR PREFIX
149 "System description tables not found\n");
1da177e4
LT
150 return AE_NOT_FOUND;
151 }
152 } else {
153 if (ACPI_FAILURE(acpi_find_root_pointer(flags, addr))) {
4be44fcd
LB
154 printk(KERN_ERR PREFIX
155 "System description tables not found\n");
1da177e4
LT
156 return AE_NOT_FOUND;
157 }
158 }
159
160 return AE_OK;
161}
162
163acpi_status
4be44fcd
LB
164acpi_os_map_memory(acpi_physical_address phys, acpi_size size,
165 void __iomem ** virt)
1da177e4 166{
9f4fd61f
BH
167 if (phys > ULONG_MAX) {
168 printk(KERN_ERR PREFIX "Cannot map memory that high\n");
169 return AE_BAD_PARAMETER;
1da177e4 170 }
9f4fd61f
BH
171 /*
172 * ioremap checks to ensure this is in reserved space
173 */
174 *virt = ioremap((unsigned long)phys, size);
1da177e4
LT
175
176 if (!*virt)
177 return AE_NO_MEMORY;
178
179 return AE_OK;
180}
55a82ab3 181EXPORT_SYMBOL_GPL(acpi_os_map_memory);
1da177e4 182
4be44fcd 183void acpi_os_unmap_memory(void __iomem * virt, acpi_size size)
1da177e4
LT
184{
185 iounmap(virt);
186}
55a82ab3 187EXPORT_SYMBOL_GPL(acpi_os_unmap_memory);
1da177e4
LT
188
189#ifdef ACPI_FUTURE_USAGE
190acpi_status
4be44fcd 191acpi_os_get_physical_address(void *virt, acpi_physical_address * phys)
1da177e4 192{
4be44fcd 193 if (!phys || !virt)
1da177e4
LT
194 return AE_BAD_PARAMETER;
195
196 *phys = virt_to_phys(virt);
197
198 return AE_OK;
199}
200#endif
201
202#define ACPI_MAX_OVERRIDE_LEN 100
203
204static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN];
205
206acpi_status
4be44fcd
LB
207acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
208 acpi_string * new_val)
1da177e4
LT
209{
210 if (!init_val || !new_val)
211 return AE_BAD_PARAMETER;
212
213 *new_val = NULL;
4be44fcd 214 if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) {
1da177e4 215 printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n",
4be44fcd 216 acpi_os_name);
1da177e4
LT
217 *new_val = acpi_os_name;
218 }
219
220 return AE_OK;
221}
222
223acpi_status
4be44fcd
LB
224acpi_os_table_override(struct acpi_table_header * existing_table,
225 struct acpi_table_header ** new_table)
1da177e4
LT
226{
227 if (!existing_table || !new_table)
228 return AE_BAD_PARAMETER;
229
230#ifdef CONFIG_ACPI_CUSTOM_DSDT
231 if (strncmp(existing_table->signature, "DSDT", 4) == 0)
4be44fcd 232 *new_table = (struct acpi_table_header *)AmlCode;
1da177e4
LT
233 else
234 *new_table = NULL;
235#else
236 *new_table = NULL;
237#endif
238 return AE_OK;
239}
240
7d12e780 241static irqreturn_t acpi_irq(int irq, void *dev_id)
1da177e4 242{
4be44fcd 243 return (*acpi_irq_handler) (acpi_irq_context) ? IRQ_HANDLED : IRQ_NONE;
1da177e4
LT
244}
245
246acpi_status
4be44fcd
LB
247acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler,
248 void *context)
1da177e4
LT
249{
250 unsigned int irq;
251
252 /*
253 * Ignore the GSI from the core, and use the value in our copy of the
254 * FADT. It may not be the same if an interrupt source override exists
255 * for the SCI.
256 */
257 gsi = acpi_fadt.sci_int;
258 if (acpi_gsi_to_irq(gsi, &irq) < 0) {
259 printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n",
260 gsi);
261 return AE_OK;
262 }
263
264 acpi_irq_handler = handler;
265 acpi_irq_context = context;
dace1453 266 if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) {
1da177e4
LT
267 printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq);
268 return AE_NOT_ACQUIRED;
269 }
270 acpi_irq_irq = irq;
271
272 return AE_OK;
273}
274
4be44fcd 275acpi_status acpi_os_remove_interrupt_handler(u32 irq, acpi_osd_handler handler)
1da177e4
LT
276{
277 if (irq) {
278 free_irq(irq, acpi_irq);
279 acpi_irq_handler = NULL;
280 acpi_irq_irq = 0;
281 }
282
283 return AE_OK;
284}
285
286/*
287 * Running in interpreter thread context, safe to sleep
288 */
289
4be44fcd 290void acpi_os_sleep(acpi_integer ms)
1da177e4 291{
01a527ec 292 schedule_timeout_interruptible(msecs_to_jiffies(ms));
1da177e4 293}
4be44fcd 294
1da177e4
LT
295EXPORT_SYMBOL(acpi_os_sleep);
296
4be44fcd 297void acpi_os_stall(u32 us)
1da177e4
LT
298{
299 while (us) {
300 u32 delay = 1000;
301
302 if (delay > us)
303 delay = us;
304 udelay(delay);
305 touch_nmi_watchdog();
306 us -= delay;
307 }
308}
4be44fcd 309
1da177e4
LT
310EXPORT_SYMBOL(acpi_os_stall);
311
312/*
313 * Support ACPI 3.0 AML Timer operand
314 * Returns 64-bit free-running, monotonically increasing timer
315 * with 100ns granularity
316 */
4be44fcd 317u64 acpi_os_get_timer(void)
1da177e4
LT
318{
319 static u64 t;
320
321#ifdef CONFIG_HPET
322 /* TBD: use HPET if available */
323#endif
324
325#ifdef CONFIG_X86_PM_TIMER
326 /* TBD: default to PM timer if HPET was not available */
327#endif
328 if (!t)
329 printk(KERN_ERR PREFIX "acpi_os_get_timer() TBD\n");
330
331 return ++t;
332}
333
4be44fcd 334acpi_status acpi_os_read_port(acpi_io_address port, u32 * value, u32 width)
1da177e4
LT
335{
336 u32 dummy;
337
338 if (!value)
339 value = &dummy;
340
4be44fcd 341 switch (width) {
1da177e4 342 case 8:
4be44fcd 343 *(u8 *) value = inb(port);
1da177e4
LT
344 break;
345 case 16:
4be44fcd 346 *(u16 *) value = inw(port);
1da177e4
LT
347 break;
348 case 32:
4be44fcd 349 *(u32 *) value = inl(port);
1da177e4
LT
350 break;
351 default:
352 BUG();
353 }
354
355 return AE_OK;
356}
4be44fcd 357
1da177e4
LT
358EXPORT_SYMBOL(acpi_os_read_port);
359
4be44fcd 360acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width)
1da177e4 361{
4be44fcd 362 switch (width) {
1da177e4
LT
363 case 8:
364 outb(value, port);
365 break;
366 case 16:
367 outw(value, port);
368 break;
369 case 32:
370 outl(value, port);
371 break;
372 default:
373 BUG();
374 }
375
376 return AE_OK;
377}
4be44fcd 378
1da177e4
LT
379EXPORT_SYMBOL(acpi_os_write_port);
380
381acpi_status
4be44fcd 382acpi_os_read_memory(acpi_physical_address phys_addr, u32 * value, u32 width)
1da177e4 383{
4be44fcd
LB
384 u32 dummy;
385 void __iomem *virt_addr;
1da177e4 386
9f4fd61f 387 virt_addr = ioremap(phys_addr, width);
1da177e4
LT
388 if (!value)
389 value = &dummy;
390
391 switch (width) {
392 case 8:
4be44fcd 393 *(u8 *) value = readb(virt_addr);
1da177e4
LT
394 break;
395 case 16:
4be44fcd 396 *(u16 *) value = readw(virt_addr);
1da177e4
LT
397 break;
398 case 32:
4be44fcd 399 *(u32 *) value = readl(virt_addr);
1da177e4
LT
400 break;
401 default:
402 BUG();
403 }
404
9f4fd61f 405 iounmap(virt_addr);
1da177e4
LT
406
407 return AE_OK;
408}
409
410acpi_status
4be44fcd 411acpi_os_write_memory(acpi_physical_address phys_addr, u32 value, u32 width)
1da177e4 412{
4be44fcd 413 void __iomem *virt_addr;
1da177e4 414
9f4fd61f 415 virt_addr = ioremap(phys_addr, width);
1da177e4
LT
416
417 switch (width) {
418 case 8:
419 writeb(value, virt_addr);
420 break;
421 case 16:
422 writew(value, virt_addr);
423 break;
424 case 32:
425 writel(value, virt_addr);
426 break;
427 default:
428 BUG();
429 }
430
9f4fd61f 431 iounmap(virt_addr);
1da177e4
LT
432
433 return AE_OK;
434}
435
1da177e4 436acpi_status
4be44fcd
LB
437acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
438 void *value, u32 width)
1da177e4
LT
439{
440 int result, size;
441
442 if (!value)
443 return AE_BAD_PARAMETER;
444
445 switch (width) {
446 case 8:
447 size = 1;
448 break;
449 case 16:
450 size = 2;
451 break;
452 case 32:
453 size = 4;
454 break;
455 default:
456 return AE_ERROR;
457 }
458
459 BUG_ON(!raw_pci_ops);
460
461 result = raw_pci_ops->read(pci_id->segment, pci_id->bus,
4be44fcd
LB
462 PCI_DEVFN(pci_id->device, pci_id->function),
463 reg, size, value);
1da177e4
LT
464
465 return (result ? AE_ERROR : AE_OK);
466}
4be44fcd 467
1da177e4
LT
468EXPORT_SYMBOL(acpi_os_read_pci_configuration);
469
470acpi_status
4be44fcd
LB
471acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg,
472 acpi_integer value, u32 width)
1da177e4
LT
473{
474 int result, size;
475
476 switch (width) {
477 case 8:
478 size = 1;
479 break;
480 case 16:
481 size = 2;
482 break;
483 case 32:
484 size = 4;
485 break;
486 default:
487 return AE_ERROR;
488 }
489
490 BUG_ON(!raw_pci_ops);
491
492 result = raw_pci_ops->write(pci_id->segment, pci_id->bus,
4be44fcd
LB
493 PCI_DEVFN(pci_id->device, pci_id->function),
494 reg, size, value);
1da177e4
LT
495
496 return (result ? AE_ERROR : AE_OK);
497}
498
499/* TODO: Change code to take advantage of driver model more */
4be44fcd
LB
500static void acpi_os_derive_pci_id_2(acpi_handle rhandle, /* upper bound */
501 acpi_handle chandle, /* current node */
502 struct acpi_pci_id **id,
503 int *is_bridge, u8 * bus_number)
1da177e4 504{
4be44fcd
LB
505 acpi_handle handle;
506 struct acpi_pci_id *pci_id = *id;
507 acpi_status status;
508 unsigned long temp;
509 acpi_object_type type;
510 u8 tu8;
1da177e4
LT
511
512 acpi_get_parent(chandle, &handle);
513 if (handle != rhandle) {
4be44fcd
LB
514 acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge,
515 bus_number);
1da177e4
LT
516
517 status = acpi_get_type(handle, &type);
4be44fcd 518 if ((ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE))
1da177e4
LT
519 return;
520
4be44fcd
LB
521 status =
522 acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL,
523 &temp);
1da177e4 524 if (ACPI_SUCCESS(status)) {
4be44fcd
LB
525 pci_id->device = ACPI_HIWORD(ACPI_LODWORD(temp));
526 pci_id->function = ACPI_LOWORD(ACPI_LODWORD(temp));
1da177e4
LT
527
528 if (*is_bridge)
529 pci_id->bus = *bus_number;
530
531 /* any nicer way to get bus number of bridge ? */
4be44fcd
LB
532 status =
533 acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8,
534 8);
535 if (ACPI_SUCCESS(status)
536 && ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) {
537 status =
538 acpi_os_read_pci_configuration(pci_id, 0x18,
539 &tu8, 8);
1da177e4
LT
540 if (!ACPI_SUCCESS(status)) {
541 /* Certainly broken... FIX ME */
542 return;
543 }
544 *is_bridge = 1;
545 pci_id->bus = tu8;
4be44fcd
LB
546 status =
547 acpi_os_read_pci_configuration(pci_id, 0x19,
548 &tu8, 8);
1da177e4
LT
549 if (ACPI_SUCCESS(status)) {
550 *bus_number = tu8;
551 }
552 } else
553 *is_bridge = 0;
554 }
555 }
556}
557
4be44fcd
LB
558void acpi_os_derive_pci_id(acpi_handle rhandle, /* upper bound */
559 acpi_handle chandle, /* current node */
560 struct acpi_pci_id **id)
1da177e4
LT
561{
562 int is_bridge = 1;
563 u8 bus_number = (*id)->bus;
564
565 acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number);
566}
567
65f27f38 568static void acpi_os_execute_deferred(struct work_struct *work)
1da177e4 569{
65f27f38 570 struct acpi_os_dpc *dpc = container_of(work, struct acpi_os_dpc, work);
1da177e4 571 if (!dpc) {
6468463a 572 printk(KERN_ERR PREFIX "Invalid (NULL) context\n");
d550d98d 573 return;
1da177e4
LT
574 }
575
576 dpc->function(dpc->context);
577
578 kfree(dpc);
579
d550d98d 580 return;
1da177e4
LT
581}
582
b8d35192
AS
583/*******************************************************************************
584 *
585 * FUNCTION: acpi_os_execute
586 *
587 * PARAMETERS: Type - Type of the callback
588 * Function - Function to be executed
589 * Context - Function parameters
590 *
591 * RETURN: Status
592 *
593 * DESCRIPTION: Depending on type, either queues function for deferred execution or
594 * immediately executes function on a separate thread.
595 *
596 ******************************************************************************/
597
598acpi_status acpi_os_execute(acpi_execute_type type,
4be44fcd 599 acpi_osd_exec_callback function, void *context)
1da177e4 600{
4be44fcd
LB
601 acpi_status status = AE_OK;
602 struct acpi_os_dpc *dpc;
72945b2b 603
b976fe19
LT
604 ACPI_FUNCTION_TRACE("os_queue_for_execution");
605
72945b2b
LB
606 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
607 "Scheduling function [%p(%p)] for deferred execution.\n",
608 function, context));
1da177e4
LT
609
610 if (!function)
b976fe19 611 return_ACPI_STATUS(AE_BAD_PARAMETER);
72945b2b 612
1da177e4
LT
613 /*
614 * Allocate/initialize DPC structure. Note that this memory will be
65f27f38 615 * freed by the callee. The kernel handles the work_struct list in a
1da177e4
LT
616 * way that allows us to also free its memory inside the callee.
617 * Because we may want to schedule several tasks with different
618 * parameters we can't use the approach some kernel code uses of
65f27f38 619 * having a static work_struct.
1da177e4 620 */
72945b2b 621
65f27f38 622 dpc = kmalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC);
1da177e4 623 if (!dpc)
b976fe19
LT
624 return_ACPI_STATUS(AE_NO_MEMORY);
625
1da177e4
LT
626 dpc->function = function;
627 dpc->context = context;
b976fe19 628
65f27f38
DH
629 INIT_WORK(&dpc->work, acpi_os_execute_deferred);
630 if (!queue_work(kacpid_wq, &dpc->work)) {
b976fe19
LT
631 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
632 "Call to queue_work() failed.\n"));
37605a69 633 kfree(dpc);
b976fe19 634 status = AE_ERROR;
1da177e4 635 }
b976fe19
LT
636
637 return_ACPI_STATUS(status);
1da177e4 638}
4be44fcd 639
b8d35192 640EXPORT_SYMBOL(acpi_os_execute);
1da177e4 641
4be44fcd 642void acpi_os_wait_events_complete(void *context)
1da177e4
LT
643{
644 flush_workqueue(kacpid_wq);
645}
4be44fcd 646
1da177e4
LT
647EXPORT_SYMBOL(acpi_os_wait_events_complete);
648
649/*
650 * Allocate the memory for a spinlock and initialize it.
651 */
967440e3 652acpi_status acpi_os_create_lock(acpi_spinlock * handle)
1da177e4 653{
967440e3 654 spin_lock_init(*handle);
1da177e4 655
d550d98d 656 return AE_OK;
1da177e4
LT
657}
658
1da177e4
LT
659/*
660 * Deallocate the memory for a spinlock.
661 */
967440e3 662void acpi_os_delete_lock(acpi_spinlock handle)
1da177e4 663{
d550d98d 664 return;
1da177e4
LT
665}
666
1da177e4 667acpi_status
4be44fcd 668acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
1da177e4 669{
4be44fcd 670 struct semaphore *sem = NULL;
1da177e4 671
1da177e4
LT
672
673 sem = acpi_os_allocate(sizeof(struct semaphore));
674 if (!sem)
d550d98d 675 return AE_NO_MEMORY;
1da177e4
LT
676 memset(sem, 0, sizeof(struct semaphore));
677
678 sema_init(sem, initial_units);
679
4be44fcd 680 *handle = (acpi_handle *) sem;
1da177e4 681
4be44fcd
LB
682 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p|%d].\n",
683 *handle, initial_units));
1da177e4 684
d550d98d 685 return AE_OK;
1da177e4 686}
1da177e4 687
4be44fcd 688EXPORT_SYMBOL(acpi_os_create_semaphore);
1da177e4
LT
689
690/*
691 * TODO: A better way to delete semaphores? Linux doesn't have a
692 * 'delete_semaphore()' function -- may result in an invalid
693 * pointer dereference for non-synchronized consumers. Should
694 * we at least check for blocked threads and signal/cancel them?
695 */
696
4be44fcd 697acpi_status acpi_os_delete_semaphore(acpi_handle handle)
1da177e4 698{
4be44fcd 699 struct semaphore *sem = (struct semaphore *)handle;
1da177e4 700
1da177e4
LT
701
702 if (!sem)
d550d98d 703 return AE_BAD_PARAMETER;
1da177e4 704
4be44fcd 705 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle));
1da177e4 706
02438d87 707 kfree(sem);
4be44fcd 708 sem = NULL;
1da177e4 709
d550d98d 710 return AE_OK;
1da177e4 711}
1da177e4 712
4be44fcd 713EXPORT_SYMBOL(acpi_os_delete_semaphore);
1da177e4
LT
714
715/*
716 * TODO: The kernel doesn't have a 'down_timeout' function -- had to
717 * improvise. The process is to sleep for one scheduler quantum
718 * until the semaphore becomes available. Downside is that this
719 * may result in starvation for timeout-based waits when there's
720 * lots of semaphore activity.
721 *
722 * TODO: Support for units > 1?
723 */
4be44fcd 724acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
1da177e4 725{
4be44fcd
LB
726 acpi_status status = AE_OK;
727 struct semaphore *sem = (struct semaphore *)handle;
728 int ret = 0;
1da177e4 729
1da177e4
LT
730
731 if (!sem || (units < 1))
d550d98d 732 return AE_BAD_PARAMETER;
1da177e4
LT
733
734 if (units > 1)
d550d98d 735 return AE_SUPPORT;
1da177e4 736
4be44fcd
LB
737 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p|%d|%d]\n",
738 handle, units, timeout));
1da177e4 739
d68909f4
LB
740 /*
741 * This can be called during resume with interrupts off.
742 * Like boot-time, we should be single threaded and will
743 * always get the lock if we try -- timeout or not.
744 * If this doesn't succeed, then we will oops courtesy of
745 * might_sleep() in down().
746 */
747 if (!down_trylock(sem))
748 return AE_OK;
749
4be44fcd 750 switch (timeout) {
1da177e4
LT
751 /*
752 * No Wait:
753 * --------
754 * A zero timeout value indicates that we shouldn't wait - just
755 * acquire the semaphore if available otherwise return AE_TIME
756 * (a.k.a. 'would block').
757 */
4be44fcd
LB
758 case 0:
759 if (down_trylock(sem))
1da177e4
LT
760 status = AE_TIME;
761 break;
762
763 /*
764 * Wait Indefinitely:
765 * ------------------
766 */
4be44fcd 767 case ACPI_WAIT_FOREVER:
1da177e4
LT
768 down(sem);
769 break;
770
771 /*
772 * Wait w/ Timeout:
773 * ----------------
774 */
4be44fcd 775 default:
1da177e4
LT
776 // TODO: A better timeout algorithm?
777 {
778 int i = 0;
4be44fcd 779 static const int quantum_ms = 1000 / HZ;
1da177e4
LT
780
781 ret = down_trylock(sem);
dacd9b80 782 for (i = timeout; (i > 0 && ret != 0); i -= quantum_ms) {
01a527ec 783 schedule_timeout_interruptible(1);
1da177e4
LT
784 ret = down_trylock(sem);
785 }
4be44fcd 786
1da177e4
LT
787 if (ret != 0)
788 status = AE_TIME;
789 }
790 break;
791 }
792
793 if (ACPI_FAILURE(status)) {
9e7e2c04 794 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
a6fc6720 795 "Failed to acquire semaphore[%p|%d|%d], %s",
4be44fcd
LB
796 handle, units, timeout,
797 acpi_format_exception(status)));
798 } else {
799 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
a6fc6720 800 "Acquired semaphore[%p|%d|%d]", handle,
4be44fcd 801 units, timeout));
1da177e4
LT
802 }
803
d550d98d 804 return status;
1da177e4 805}
1da177e4 806
4be44fcd 807EXPORT_SYMBOL(acpi_os_wait_semaphore);
1da177e4
LT
808
809/*
810 * TODO: Support for units > 1?
811 */
4be44fcd 812acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
1da177e4 813{
4be44fcd 814 struct semaphore *sem = (struct semaphore *)handle;
1da177e4 815
1da177e4
LT
816
817 if (!sem || (units < 1))
d550d98d 818 return AE_BAD_PARAMETER;
1da177e4
LT
819
820 if (units > 1)
d550d98d 821 return AE_SUPPORT;
1da177e4 822
4be44fcd
LB
823 ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p|%d]\n", handle,
824 units));
1da177e4
LT
825
826 up(sem);
827
d550d98d 828 return AE_OK;
1da177e4 829}
4be44fcd 830
1da177e4
LT
831EXPORT_SYMBOL(acpi_os_signal_semaphore);
832
833#ifdef ACPI_FUTURE_USAGE
4be44fcd 834u32 acpi_os_get_line(char *buffer)
1da177e4
LT
835{
836
837#ifdef ENABLE_DEBUGGER
838 if (acpi_in_debugger) {
839 u32 chars;
840
841 kdb_read(buffer, sizeof(line_buf));
842
843 /* remove the CR kdb includes */
844 chars = strlen(buffer) - 1;
845 buffer[chars] = '\0';
846 }
847#endif
848
849 return 0;
850}
4be44fcd 851#endif /* ACPI_FUTURE_USAGE */
1da177e4
LT
852
853/* Assumes no unreadable holes inbetween */
4be44fcd 854u8 acpi_os_readable(void *ptr, acpi_size len)
1da177e4 855{
4be44fcd 856#if defined(__i386__) || defined(__x86_64__)
1da177e4 857 char tmp;
4be44fcd
LB
858 return !__get_user(tmp, (char __user *)ptr)
859 && !__get_user(tmp, (char __user *)ptr + len - 1);
1da177e4
LT
860#endif
861 return 1;
862}
863
864#ifdef ACPI_FUTURE_USAGE
4be44fcd 865u8 acpi_os_writable(void *ptr, acpi_size len)
1da177e4
LT
866{
867 /* could do dummy write (racy) or a kernel page table lookup.
868 The later may be difficult at early boot when kmap doesn't work yet. */
869 return 1;
870}
871#endif
872
4be44fcd 873acpi_status acpi_os_signal(u32 function, void *info)
1da177e4 874{
4be44fcd 875 switch (function) {
1da177e4
LT
876 case ACPI_SIGNAL_FATAL:
877 printk(KERN_ERR PREFIX "Fatal opcode executed\n");
878 break;
879 case ACPI_SIGNAL_BREAKPOINT:
880 /*
881 * AML Breakpoint
882 * ACPI spec. says to treat it as a NOP unless
883 * you are debugging. So if/when we integrate
884 * AML debugger into the kernel debugger its
885 * hook will go here. But until then it is
886 * not useful to print anything on breakpoints.
887 */
888 break;
889 default:
890 break;
891 }
892
893 return AE_OK;
894}
4be44fcd 895
1da177e4
LT
896EXPORT_SYMBOL(acpi_os_signal);
897
4be44fcd 898static int __init acpi_os_name_setup(char *str)
1da177e4
LT
899{
900 char *p = acpi_os_name;
4be44fcd 901 int count = ACPI_MAX_OVERRIDE_LEN - 1;
1da177e4
LT
902
903 if (!str || !*str)
904 return 0;
905
906 for (; count-- && str && *str; str++) {
907 if (isalnum(*str) || *str == ' ' || *str == ':')
908 *p++ = *str;
909 else if (*str == '\'' || *str == '"')
910 continue;
911 else
912 break;
913 }
914 *p = 0;
915
916 return 1;
4be44fcd 917
1da177e4
LT
918}
919
920__setup("acpi_os_name=", acpi_os_name_setup);
921
922/*
923 * _OSI control
924 * empty string disables _OSI
925 * TBD additional string adds to _OSI
926 */
4be44fcd 927static int __init acpi_osi_setup(char *str)
1da177e4
LT
928{
929 if (str == NULL || *str == '\0') {
930 printk(KERN_INFO PREFIX "_OSI method disabled\n");
931 acpi_gbl_create_osi_method = FALSE;
4be44fcd 932 } else {
1da177e4 933 /* TBD */
4be44fcd
LB
934 printk(KERN_ERR PREFIX "_OSI additional string ignored -- %s\n",
935 str);
1da177e4
LT
936 }
937
938 return 1;
939}
940
941__setup("acpi_osi=", acpi_osi_setup);
942
943/* enable serialization to combat AE_ALREADY_EXISTS errors */
4be44fcd 944static int __init acpi_serialize_setup(char *str)
1da177e4
LT
945{
946 printk(KERN_INFO PREFIX "serialize enabled\n");
947
948 acpi_gbl_all_methods_serialized = TRUE;
949
950 return 1;
951}
952
953__setup("acpi_serialize", acpi_serialize_setup);
954
955/*
956 * Wake and Run-Time GPES are expected to be separate.
957 * We disable wake-GPEs at run-time to prevent spurious
958 * interrupts.
959 *
960 * However, if a system exists that shares Wake and
961 * Run-time events on the same GPE this flag is available
962 * to tell Linux to keep the wake-time GPEs enabled at run-time.
963 */
4be44fcd 964static int __init acpi_wake_gpes_always_on_setup(char *str)
1da177e4
LT
965{
966 printk(KERN_INFO PREFIX "wake GPEs not disabled\n");
967
968 acpi_gbl_leave_wake_gpes_disabled = FALSE;
969
970 return 1;
971}
972
973__setup("acpi_wake_gpes_always_on", acpi_wake_gpes_always_on_setup);
974
8713cbef 975static int __init acpi_hotkey_setup(char *str)
fb9802fa 976{
30e332f3 977 acpi_specific_hotkey_enabled = FALSE;
fb9802fa
LY
978 return 1;
979}
980
30e332f3 981__setup("acpi_generic_hotkey", acpi_hotkey_setup);
fb9802fa 982
1da177e4
LT
983/*
984 * max_cstate is defined in the base kernel so modules can
985 * change it w/o depending on the state of the processor module.
986 */
987unsigned int max_cstate = ACPI_PROCESSOR_MAX_POWER;
988
1da177e4 989EXPORT_SYMBOL(max_cstate);
73459f73
RM
990
991/*
992 * Acquire a spinlock.
993 *
994 * handle is a pointer to the spinlock_t.
73459f73
RM
995 */
996
967440e3 997acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp)
73459f73 998{
b8e4d893 999 acpi_cpu_flags flags;
967440e3 1000 spin_lock_irqsave(lockp, flags);
73459f73
RM
1001 return flags;
1002}
1003
1004/*
1005 * Release a spinlock. See above.
1006 */
1007
967440e3 1008void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags)
73459f73 1009{
967440e3 1010 spin_unlock_irqrestore(lockp, flags);
73459f73
RM
1011}
1012
73459f73
RM
1013#ifndef ACPI_USE_LOCAL_CACHE
1014
1015/*******************************************************************************
1016 *
1017 * FUNCTION: acpi_os_create_cache
1018 *
b229cf92
BM
1019 * PARAMETERS: name - Ascii name for the cache
1020 * size - Size of each cached object
1021 * depth - Maximum depth of the cache (in objects) <ignored>
1022 * cache - Where the new cache object is returned
73459f73 1023 *
b229cf92 1024 * RETURN: status
73459f73
RM
1025 *
1026 * DESCRIPTION: Create a cache object
1027 *
1028 ******************************************************************************/
1029
1030acpi_status
4be44fcd 1031acpi_os_create_cache(char *name, u16 size, u16 depth, acpi_cache_t ** cache)
73459f73 1032{
4be44fcd 1033 *cache = kmem_cache_create(name, size, 0, 0, NULL, NULL);
b229cf92
BM
1034 if (cache == NULL)
1035 return AE_ERROR;
1036 else
1037 return AE_OK;
73459f73
RM
1038}
1039
1040/*******************************************************************************
1041 *
1042 * FUNCTION: acpi_os_purge_cache
1043 *
1044 * PARAMETERS: Cache - Handle to cache object
1045 *
1046 * RETURN: Status
1047 *
1048 * DESCRIPTION: Free all objects within the requested cache.
1049 *
1050 ******************************************************************************/
1051
4be44fcd 1052acpi_status acpi_os_purge_cache(acpi_cache_t * cache)
73459f73 1053{
4be44fcd
LB
1054 (void)kmem_cache_shrink(cache);
1055 return (AE_OK);
73459f73
RM
1056}
1057
1058/*******************************************************************************
1059 *
1060 * FUNCTION: acpi_os_delete_cache
1061 *
1062 * PARAMETERS: Cache - Handle to cache object
1063 *
1064 * RETURN: Status
1065 *
1066 * DESCRIPTION: Free all objects within the requested cache and delete the
1067 * cache object.
1068 *
1069 ******************************************************************************/
1070
4be44fcd 1071acpi_status acpi_os_delete_cache(acpi_cache_t * cache)
73459f73 1072{
1a1d92c1 1073 kmem_cache_destroy(cache);
4be44fcd 1074 return (AE_OK);
73459f73
RM
1075}
1076
1077/*******************************************************************************
1078 *
1079 * FUNCTION: acpi_os_release_object
1080 *
1081 * PARAMETERS: Cache - Handle to cache object
1082 * Object - The object to be released
1083 *
1084 * RETURN: None
1085 *
1086 * DESCRIPTION: Release an object to the specified cache. If cache is full,
1087 * the object is deleted.
1088 *
1089 ******************************************************************************/
1090
4be44fcd 1091acpi_status acpi_os_release_object(acpi_cache_t * cache, void *object)
73459f73 1092{
4be44fcd
LB
1093 kmem_cache_free(cache, object);
1094 return (AE_OK);
73459f73
RM
1095}
1096
b229cf92
BM
1097/******************************************************************************
1098 *
1099 * FUNCTION: acpi_os_validate_interface
1100 *
1101 * PARAMETERS: interface - Requested interface to be validated
1102 *
1103 * RETURN: AE_OK if interface is supported, AE_SUPPORT otherwise
1104 *
1105 * DESCRIPTION: Match an interface string to the interfaces supported by the
1106 * host. Strings originate from an AML call to the _OSI method.
1107 *
1108 *****************************************************************************/
1109
1110acpi_status
1111acpi_os_validate_interface (char *interface)
1112{
1113
1114 return AE_SUPPORT;
1115}
1116
1117
1118/******************************************************************************
1119 *
1120 * FUNCTION: acpi_os_validate_address
1121 *
1122 * PARAMETERS: space_id - ACPI space ID
1123 * address - Physical address
1124 * length - Address length
1125 *
1126 * RETURN: AE_OK if address/length is valid for the space_id. Otherwise,
1127 * should return AE_AML_ILLEGAL_ADDRESS.
1128 *
1129 * DESCRIPTION: Validate a system address via the host OS. Used to validate
1130 * the addresses accessed by AML operation regions.
1131 *
1132 *****************************************************************************/
1133
1134acpi_status
1135acpi_os_validate_address (
1136 u8 space_id,
1137 acpi_physical_address address,
1138 acpi_size length)
1139{
1140
1141 return AE_OK;
1142}
1143
1144
73459f73 1145#endif