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