1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: osunixxf - UNIX OSL interfaces
5  *
6  * Copyright (C) 2000 - 2020, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 /*
11  * These interfaces are required in order to compile the ASL compiler and the
12  * various ACPICA tools under Linux or other Unix-like system.
13  */
14 #include <acpi/acpi.h>
15 #include "accommon.h"
16 #include "amlcode.h"
17 #include "acparser.h"
18 #include "acdebug.h"
19 
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <stdarg.h>
23 #include <unistd.h>
24 #include <sys/time.h>
25 #include <semaphore.h>
26 #include <pthread.h>
27 #include <errno.h>
28 
29 #define _COMPONENT          ACPI_OS_SERVICES
30 ACPI_MODULE_NAME("osunixxf")
31 
32 /* Upcalls to acpi_exec */
33 void
34 ae_table_override(struct acpi_table_header *existing_table,
35 		  struct acpi_table_header **new_table);
36 
37 typedef void *(*PTHREAD_CALLBACK) (void *);
38 
39 /* Buffer used by acpi_os_vprintf */
40 
41 #define ACPI_VPRINTF_BUFFER_SIZE    512
42 #define _ASCII_NEWLINE              '\n'
43 
44 /* Terminal support for acpi_exec only */
45 
46 #ifdef ACPI_EXEC_APP
47 #include <termios.h>
48 
49 struct termios original_term_attributes;
50 int term_attributes_were_set = 0;
51 
52 acpi_status acpi_ut_read_line(char *buffer, u32 buffer_length, u32 *bytes_read);
53 
54 static void os_enter_line_edit_mode(void);
55 
56 static void os_exit_line_edit_mode(void);
57 
58 /******************************************************************************
59  *
60  * FUNCTION:    os_enter_line_edit_mode, os_exit_line_edit_mode
61  *
62  * PARAMETERS:  None
63  *
64  * RETURN:      None
65  *
66  * DESCRIPTION: Enter/Exit the raw character input mode for the terminal.
67  *
68  * Interactive line-editing support for the AML debugger. Used with the
69  * common/acgetline module.
70  *
71  * readline() is not used because of non-portability. It is not available
72  * on all systems, and if it is, often the package must be manually installed.
73  *
74  * Therefore, we use the POSIX tcgetattr/tcsetattr and do the minimal line
75  * editing that we need in acpi_os_get_line.
76  *
77  * If the POSIX tcgetattr/tcsetattr interfaces are unavailable, these
78  * calls will also work:
79  *     For os_enter_line_edit_mode: system ("stty cbreak -echo")
80  *     For os_exit_line_edit_mode: system ("stty cooked echo")
81  *
82  *****************************************************************************/
83 
84 static void os_enter_line_edit_mode(void)
85 {
86 	struct termios local_term_attributes;
87 
88 	term_attributes_were_set = 0;
89 
90 	/* STDIN must be a terminal */
91 
92 	if (!isatty(STDIN_FILENO)) {
93 		return;
94 	}
95 
96 	/* Get and keep the original attributes */
97 
98 	if (tcgetattr(STDIN_FILENO, &original_term_attributes)) {
99 		fprintf(stderr, "Could not get terminal attributes!\n");
100 		return;
101 	}
102 
103 	/* Set the new attributes to enable raw character input */
104 
105 	memcpy(&local_term_attributes, &original_term_attributes,
106 	       sizeof(struct termios));
107 
108 	local_term_attributes.c_lflag &= ~(ICANON | ECHO);
109 	local_term_attributes.c_cc[VMIN] = 1;
110 	local_term_attributes.c_cc[VTIME] = 0;
111 
112 	if (tcsetattr(STDIN_FILENO, TCSANOW, &local_term_attributes)) {
113 		fprintf(stderr, "Could not set terminal attributes!\n");
114 		return;
115 	}
116 
117 	term_attributes_were_set = 1;
118 }
119 
120 static void os_exit_line_edit_mode(void)
121 {
122 
123 	if (!term_attributes_were_set) {
124 		return;
125 	}
126 
127 	/* Set terminal attributes back to the original values */
128 
129 	if (tcsetattr(STDIN_FILENO, TCSANOW, &original_term_attributes)) {
130 		fprintf(stderr, "Could not restore terminal attributes!\n");
131 	}
132 }
133 
134 #else
135 
136 /* These functions are not needed for other ACPICA utilities */
137 
138 #define os_enter_line_edit_mode()
139 #define os_exit_line_edit_mode()
140 #endif
141 
142 /******************************************************************************
143  *
144  * FUNCTION:    acpi_os_initialize, acpi_os_terminate
145  *
146  * PARAMETERS:  None
147  *
148  * RETURN:      Status
149  *
150  * DESCRIPTION: Initialize and terminate this module.
151  *
152  *****************************************************************************/
153 
154 acpi_status acpi_os_initialize(void)
155 {
156 	acpi_status status;
157 
158 	acpi_gbl_output_file = stdout;
159 
160 	os_enter_line_edit_mode();
161 
162 	status = acpi_os_create_lock(&acpi_gbl_print_lock);
163 	if (ACPI_FAILURE(status)) {
164 		return (status);
165 	}
166 
167 	return (AE_OK);
168 }
169 
170 acpi_status acpi_os_terminate(void)
171 {
172 
173 	os_exit_line_edit_mode();
174 	return (AE_OK);
175 }
176 
177 #ifndef ACPI_USE_NATIVE_RSDP_POINTER
178 /******************************************************************************
179  *
180  * FUNCTION:    acpi_os_get_root_pointer
181  *
182  * PARAMETERS:  None
183  *
184  * RETURN:      RSDP physical address
185  *
186  * DESCRIPTION: Gets the ACPI root pointer (RSDP)
187  *
188  *****************************************************************************/
189 
190 acpi_physical_address acpi_os_get_root_pointer(void)
191 {
192 
193 	return (0);
194 }
195 #endif
196 
197 /******************************************************************************
198  *
199  * FUNCTION:    acpi_os_predefined_override
200  *
201  * PARAMETERS:  init_val            - Initial value of the predefined object
202  *              new_val             - The new value for the object
203  *
204  * RETURN:      Status, pointer to value. Null pointer returned if not
205  *              overriding.
206  *
207  * DESCRIPTION: Allow the OS to override predefined names
208  *
209  *****************************************************************************/
210 
211 acpi_status
212 acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
213 			    acpi_string *new_val)
214 {
215 
216 	if (!init_val || !new_val) {
217 		return (AE_BAD_PARAMETER);
218 	}
219 
220 	*new_val = NULL;
221 	return (AE_OK);
222 }
223 
224 /******************************************************************************
225  *
226  * FUNCTION:    acpi_os_table_override
227  *
228  * PARAMETERS:  existing_table      - Header of current table (probably
229  *                                    firmware)
230  *              new_table           - Where an entire new table is returned.
231  *
232  * RETURN:      Status, pointer to new table. Null pointer returned if no
233  *              table is available to override
234  *
235  * DESCRIPTION: Return a different version of a table if one is available
236  *
237  *****************************************************************************/
238 
239 acpi_status
240 acpi_os_table_override(struct acpi_table_header *existing_table,
241 		       struct acpi_table_header **new_table)
242 {
243 
244 	if (!existing_table || !new_table) {
245 		return (AE_BAD_PARAMETER);
246 	}
247 
248 	*new_table = NULL;
249 
250 #ifdef ACPI_EXEC_APP
251 
252 	ae_table_override(existing_table, new_table);
253 	return (AE_OK);
254 #else
255 
256 	return (AE_NO_ACPI_TABLES);
257 #endif
258 }
259 
260 /******************************************************************************
261  *
262  * FUNCTION:    acpi_os_physical_table_override
263  *
264  * PARAMETERS:  existing_table      - Header of current table (probably firmware)
265  *              new_address         - Where new table address is returned
266  *                                    (Physical address)
267  *              new_table_length    - Where new table length is returned
268  *
269  * RETURN:      Status, address/length of new table. Null pointer returned
270  *              if no table is available to override.
271  *
272  * DESCRIPTION: Returns AE_SUPPORT, function not used in user space.
273  *
274  *****************************************************************************/
275 
276 acpi_status
277 acpi_os_physical_table_override(struct acpi_table_header *existing_table,
278 				acpi_physical_address *new_address,
279 				u32 *new_table_length)
280 {
281 
282 	return (AE_SUPPORT);
283 }
284 
285 /******************************************************************************
286  *
287  * FUNCTION:    acpi_os_enter_sleep
288  *
289  * PARAMETERS:  sleep_state         - Which sleep state to enter
290  *              rega_value          - Register A value
291  *              regb_value          - Register B value
292  *
293  * RETURN:      Status
294  *
295  * DESCRIPTION: A hook before writing sleep registers to enter the sleep
296  *              state. Return AE_CTRL_TERMINATE to skip further sleep register
297  *              writes.
298  *
299  *****************************************************************************/
300 
301 acpi_status acpi_os_enter_sleep(u8 sleep_state, u32 rega_value, u32 regb_value)
302 {
303 
304 	return (AE_OK);
305 }
306 
307 /******************************************************************************
308  *
309  * FUNCTION:    acpi_os_redirect_output
310  *
311  * PARAMETERS:  destination         - An open file handle/pointer
312  *
313  * RETURN:      None
314  *
315  * DESCRIPTION: Causes redirect of acpi_os_printf and acpi_os_vprintf
316  *
317  *****************************************************************************/
318 
319 void acpi_os_redirect_output(void *destination)
320 {
321 
322 	acpi_gbl_output_file = destination;
323 }
324 
325 /******************************************************************************
326  *
327  * FUNCTION:    acpi_os_printf
328  *
329  * PARAMETERS:  fmt, ...            - Standard printf format
330  *
331  * RETURN:      None
332  *
333  * DESCRIPTION: Formatted output. Note: very similar to acpi_os_vprintf
334  *              (performance), changes should be tracked in both functions.
335  *
336  *****************************************************************************/
337 
338 void ACPI_INTERNAL_VAR_XFACE acpi_os_printf(const char *fmt, ...)
339 {
340 	va_list args;
341 	u8 flags;
342 
343 	flags = acpi_gbl_db_output_flags;
344 	if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
345 
346 		/* Output is directable to either a file (if open) or the console */
347 
348 		if (acpi_gbl_debug_file) {
349 
350 			/* Output file is open, send the output there */
351 
352 			va_start(args, fmt);
353 			vfprintf(acpi_gbl_debug_file, fmt, args);
354 			va_end(args);
355 		} else {
356 			/* No redirection, send output to console (once only!) */
357 
358 			flags |= ACPI_DB_CONSOLE_OUTPUT;
359 		}
360 	}
361 
362 	if (flags & ACPI_DB_CONSOLE_OUTPUT) {
363 		va_start(args, fmt);
364 		vfprintf(acpi_gbl_output_file, fmt, args);
365 		va_end(args);
366 	}
367 }
368 
369 /******************************************************************************
370  *
371  * FUNCTION:    acpi_os_vprintf
372  *
373  * PARAMETERS:  fmt                 - Standard printf format
374  *              args                - Argument list
375  *
376  * RETURN:      None
377  *
378  * DESCRIPTION: Formatted output with argument list pointer. Note: very
379  *              similar to acpi_os_printf, changes should be tracked in both
380  *              functions.
381  *
382  *****************************************************************************/
383 
384 void acpi_os_vprintf(const char *fmt, va_list args)
385 {
386 	u8 flags;
387 	char buffer[ACPI_VPRINTF_BUFFER_SIZE];
388 
389 	/*
390 	 * We build the output string in a local buffer because we may be
391 	 * outputting the buffer twice. Using vfprintf is problematic because
392 	 * some implementations modify the args pointer/structure during
393 	 * execution. Thus, we use the local buffer for portability.
394 	 *
395 	 * Note: Since this module is intended for use by the various ACPICA
396 	 * utilities/applications, we can safely declare the buffer on the stack.
397 	 * Also, This function is used for relatively small error messages only.
398 	 */
399 	vsnprintf(buffer, ACPI_VPRINTF_BUFFER_SIZE, fmt, args);
400 
401 	flags = acpi_gbl_db_output_flags;
402 	if (flags & ACPI_DB_REDIRECTABLE_OUTPUT) {
403 
404 		/* Output is directable to either a file (if open) or the console */
405 
406 		if (acpi_gbl_debug_file) {
407 
408 			/* Output file is open, send the output there */
409 
410 			fputs(buffer, acpi_gbl_debug_file);
411 		} else {
412 			/* No redirection, send output to console (once only!) */
413 
414 			flags |= ACPI_DB_CONSOLE_OUTPUT;
415 		}
416 	}
417 
418 	if (flags & ACPI_DB_CONSOLE_OUTPUT) {
419 		fputs(buffer, acpi_gbl_output_file);
420 	}
421 }
422 
423 #ifndef ACPI_EXEC_APP
424 /******************************************************************************
425  *
426  * FUNCTION:    acpi_os_get_line
427  *
428  * PARAMETERS:  buffer              - Where to return the command line
429  *              buffer_length       - Maximum length of Buffer
430  *              bytes_read          - Where the actual byte count is returned
431  *
432  * RETURN:      Status and actual bytes read
433  *
434  * DESCRIPTION: Get the next input line from the terminal. NOTE: For the
435  *              acpi_exec utility, we use the acgetline module instead to
436  *              provide line-editing and history support.
437  *
438  *****************************************************************************/
439 
440 acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read)
441 {
442 	int input_char;
443 	u32 end_of_line;
444 
445 	/* Standard acpi_os_get_line for all utilities except acpi_exec */
446 
447 	for (end_of_line = 0;; end_of_line++) {
448 		if (end_of_line >= buffer_length) {
449 			return (AE_BUFFER_OVERFLOW);
450 		}
451 
452 		if ((input_char = getchar()) == EOF) {
453 			return (AE_ERROR);
454 		}
455 
456 		if (!input_char || input_char == _ASCII_NEWLINE) {
457 			break;
458 		}
459 
460 		buffer[end_of_line] = (char)input_char;
461 	}
462 
463 	/* Null terminate the buffer */
464 
465 	buffer[end_of_line] = 0;
466 
467 	/* Return the number of bytes in the string */
468 
469 	if (bytes_read) {
470 		*bytes_read = end_of_line;
471 	}
472 
473 	return (AE_OK);
474 }
475 #endif
476 
477 #ifndef ACPI_USE_NATIVE_MEMORY_MAPPING
478 /******************************************************************************
479  *
480  * FUNCTION:    acpi_os_map_memory
481  *
482  * PARAMETERS:  where               - Physical address of memory to be mapped
483  *              length              - How much memory to map
484  *
485  * RETURN:      Pointer to mapped memory. Null on error.
486  *
487  * DESCRIPTION: Map physical memory into caller's address space
488  *
489  *****************************************************************************/
490 
491 void *acpi_os_map_memory(acpi_physical_address where, acpi_size length)
492 {
493 
494 	return (ACPI_TO_POINTER((acpi_size)where));
495 }
496 
497 /******************************************************************************
498  *
499  * FUNCTION:    acpi_os_unmap_memory
500  *
501  * PARAMETERS:  where               - Logical address of memory to be unmapped
502  *              length              - How much memory to unmap
503  *
504  * RETURN:      None.
505  *
506  * DESCRIPTION: Delete a previously created mapping. Where and Length must
507  *              correspond to a previous mapping exactly.
508  *
509  *****************************************************************************/
510 
511 void acpi_os_unmap_memory(void *where, acpi_size length)
512 {
513 
514 	return;
515 }
516 #endif
517 
518 /******************************************************************************
519  *
520  * FUNCTION:    acpi_os_allocate
521  *
522  * PARAMETERS:  size                - Amount to allocate, in bytes
523  *
524  * RETURN:      Pointer to the new allocation. Null on error.
525  *
526  * DESCRIPTION: Allocate memory. Algorithm is dependent on the OS.
527  *
528  *****************************************************************************/
529 
530 void *acpi_os_allocate(acpi_size size)
531 {
532 	void *mem;
533 
534 	mem = (void *)malloc((size_t) size);
535 	return (mem);
536 }
537 
538 #ifdef USE_NATIVE_ALLOCATE_ZEROED
539 /******************************************************************************
540  *
541  * FUNCTION:    acpi_os_allocate_zeroed
542  *
543  * PARAMETERS:  size                - Amount to allocate, in bytes
544  *
545  * RETURN:      Pointer to the new allocation. Null on error.
546  *
547  * DESCRIPTION: Allocate and zero memory. Algorithm is dependent on the OS.
548  *
549  *****************************************************************************/
550 
551 void *acpi_os_allocate_zeroed(acpi_size size)
552 {
553 	void *mem;
554 
555 	mem = (void *)calloc(1, (size_t) size);
556 	return (mem);
557 }
558 #endif
559 
560 /******************************************************************************
561  *
562  * FUNCTION:    acpi_os_free
563  *
564  * PARAMETERS:  mem                 - Pointer to previously allocated memory
565  *
566  * RETURN:      None.
567  *
568  * DESCRIPTION: Free memory allocated via acpi_os_allocate
569  *
570  *****************************************************************************/
571 
572 void acpi_os_free(void *mem)
573 {
574 
575 	free(mem);
576 }
577 
578 #ifdef ACPI_SINGLE_THREADED
579 /******************************************************************************
580  *
581  * FUNCTION:    Semaphore stub functions
582  *
583  * DESCRIPTION: Stub functions used for single-thread applications that do
584  *              not require semaphore synchronization. Full implementations
585  *              of these functions appear after the stubs.
586  *
587  *****************************************************************************/
588 
589 acpi_status
590 acpi_os_create_semaphore(u32 max_units,
591 			 u32 initial_units, acpi_handle *out_handle)
592 {
593 	*out_handle = (acpi_handle)1;
594 	return (AE_OK);
595 }
596 
597 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
598 {
599 	return (AE_OK);
600 }
601 
602 acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout)
603 {
604 	return (AE_OK);
605 }
606 
607 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
608 {
609 	return (AE_OK);
610 }
611 
612 #else
613 /******************************************************************************
614  *
615  * FUNCTION:    acpi_os_create_semaphore
616  *
617  * PARAMETERS:  initial_units       - Units to be assigned to the new semaphore
618  *              out_handle          - Where a handle will be returned
619  *
620  * RETURN:      Status
621  *
622  * DESCRIPTION: Create an OS semaphore
623  *
624  *****************************************************************************/
625 
626 acpi_status
627 acpi_os_create_semaphore(u32 max_units,
628 			 u32 initial_units, acpi_handle *out_handle)
629 {
630 	sem_t *sem;
631 
632 	if (!out_handle) {
633 		return (AE_BAD_PARAMETER);
634 	}
635 #ifdef __APPLE__
636 	{
637 		static int semaphore_count = 0;
638 		char semaphore_name[32];
639 
640 		snprintf(semaphore_name, sizeof(semaphore_name), "acpi_sem_%d",
641 			 semaphore_count++);
642 		printf("%s\n", semaphore_name);
643 		sem =
644 		    sem_open(semaphore_name, O_EXCL | O_CREAT, 0755,
645 			     initial_units);
646 		if (!sem) {
647 			return (AE_NO_MEMORY);
648 		}
649 		sem_unlink(semaphore_name);	/* This just deletes the name */
650 	}
651 
652 #else
653 	sem = acpi_os_allocate(sizeof(sem_t));
654 	if (!sem) {
655 		return (AE_NO_MEMORY);
656 	}
657 
658 	if (sem_init(sem, 0, initial_units) == -1) {
659 		acpi_os_free(sem);
660 		return (AE_BAD_PARAMETER);
661 	}
662 #endif
663 
664 	*out_handle = (acpi_handle)sem;
665 	return (AE_OK);
666 }
667 
668 /******************************************************************************
669  *
670  * FUNCTION:    acpi_os_delete_semaphore
671  *
672  * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
673  *
674  * RETURN:      Status
675  *
676  * DESCRIPTION: Delete an OS semaphore
677  *
678  *****************************************************************************/
679 
680 acpi_status acpi_os_delete_semaphore(acpi_handle handle)
681 {
682 	sem_t *sem = (sem_t *) handle;
683 
684 	if (!sem) {
685 		return (AE_BAD_PARAMETER);
686 	}
687 #ifdef __APPLE__
688 	if (sem_close(sem) == -1) {
689 		return (AE_BAD_PARAMETER);
690 	}
691 #else
692 	if (sem_destroy(sem) == -1) {
693 		return (AE_BAD_PARAMETER);
694 	}
695 #endif
696 
697 	return (AE_OK);
698 }
699 
700 /******************************************************************************
701  *
702  * FUNCTION:    acpi_os_wait_semaphore
703  *
704  * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
705  *              units               - How many units to wait for
706  *              msec_timeout        - How long to wait (milliseconds)
707  *
708  * RETURN:      Status
709  *
710  * DESCRIPTION: Wait for units
711  *
712  *****************************************************************************/
713 
714 acpi_status
715 acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 msec_timeout)
716 {
717 	acpi_status status = AE_OK;
718 	sem_t *sem = (sem_t *) handle;
719 	int ret_val;
720 #ifndef ACPI_USE_ALTERNATE_TIMEOUT
721 	struct timespec time;
722 #endif
723 
724 	if (!sem) {
725 		return (AE_BAD_PARAMETER);
726 	}
727 
728 	switch (msec_timeout) {
729 		/*
730 		 * No Wait:
731 		 * --------
732 		 * A zero timeout value indicates that we shouldn't wait - just
733 		 * acquire the semaphore if available otherwise return AE_TIME
734 		 * (a.k.a. 'would block').
735 		 */
736 	case 0:
737 
738 		if (sem_trywait(sem) == -1) {
739 			status = (AE_TIME);
740 		}
741 		break;
742 
743 		/* Wait Indefinitely */
744 
745 	case ACPI_WAIT_FOREVER:
746 
747 		while (((ret_val = sem_wait(sem)) == -1) && (errno == EINTR)) {
748 			continue;	/* Restart if interrupted */
749 		}
750 		if (ret_val != 0) {
751 			status = (AE_TIME);
752 		}
753 		break;
754 
755 		/* Wait with msec_timeout */
756 
757 	default:
758 
759 #ifdef ACPI_USE_ALTERNATE_TIMEOUT
760 		/*
761 		 * Alternate timeout mechanism for environments where
762 		 * sem_timedwait is not available or does not work properly.
763 		 */
764 		while (msec_timeout) {
765 			if (sem_trywait(sem) == 0) {
766 
767 				/* Got the semaphore */
768 				return (AE_OK);
769 			}
770 
771 			if (msec_timeout >= 10) {
772 				msec_timeout -= 10;
773 				usleep(10 * ACPI_USEC_PER_MSEC);	/* ten milliseconds */
774 			} else {
775 				msec_timeout--;
776 				usleep(ACPI_USEC_PER_MSEC);	/* one millisecond */
777 			}
778 		}
779 		status = (AE_TIME);
780 #else
781 		/*
782 		 * The interface to sem_timedwait is an absolute time, so we need to
783 		 * get the current time, then add in the millisecond Timeout value.
784 		 */
785 		if (clock_gettime(CLOCK_REALTIME, &time) == -1) {
786 			perror("clock_gettime");
787 			return (AE_TIME);
788 		}
789 
790 		time.tv_sec += (msec_timeout / ACPI_MSEC_PER_SEC);
791 		time.tv_nsec +=
792 		    ((msec_timeout % ACPI_MSEC_PER_SEC) * ACPI_NSEC_PER_MSEC);
793 
794 		/* Handle nanosecond overflow (field must be less than one second) */
795 
796 		if (time.tv_nsec >= ACPI_NSEC_PER_SEC) {
797 			time.tv_sec += (time.tv_nsec / ACPI_NSEC_PER_SEC);
798 			time.tv_nsec = (time.tv_nsec % ACPI_NSEC_PER_SEC);
799 		}
800 
801 		while (((ret_val = sem_timedwait(sem, &time)) == -1)
802 		       && (errno == EINTR)) {
803 			continue;	/* Restart if interrupted */
804 
805 		}
806 
807 		if (ret_val != 0) {
808 			if (errno != ETIMEDOUT) {
809 				perror("sem_timedwait");
810 			}
811 			status = (AE_TIME);
812 		}
813 #endif
814 		break;
815 	}
816 
817 	return (status);
818 }
819 
820 /******************************************************************************
821  *
822  * FUNCTION:    acpi_os_signal_semaphore
823  *
824  * PARAMETERS:  handle              - Handle returned by acpi_os_create_semaphore
825  *              units               - Number of units to send
826  *
827  * RETURN:      Status
828  *
829  * DESCRIPTION: Send units
830  *
831  *****************************************************************************/
832 
833 acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
834 {
835 	sem_t *sem = (sem_t *) handle;
836 
837 	if (!sem) {
838 		return (AE_BAD_PARAMETER);
839 	}
840 
841 	if (sem_post(sem) == -1) {
842 		return (AE_LIMIT);
843 	}
844 
845 	return (AE_OK);
846 }
847 
848 #endif				/* ACPI_SINGLE_THREADED */
849 
850 /******************************************************************************
851  *
852  * FUNCTION:    Spinlock interfaces
853  *
854  * DESCRIPTION: Map these interfaces to semaphore interfaces
855  *
856  *****************************************************************************/
857 
858 acpi_status acpi_os_create_lock(acpi_spinlock * out_handle)
859 {
860 
861 	return (acpi_os_create_semaphore(1, 1, out_handle));
862 }
863 
864 void acpi_os_delete_lock(acpi_spinlock handle)
865 {
866 	acpi_os_delete_semaphore(handle);
867 }
868 
869 acpi_cpu_flags acpi_os_acquire_lock(acpi_handle handle)
870 {
871 	acpi_os_wait_semaphore(handle, 1, 0xFFFF);
872 	return (0);
873 }
874 
875 void acpi_os_release_lock(acpi_spinlock handle, acpi_cpu_flags flags)
876 {
877 	acpi_os_signal_semaphore(handle, 1);
878 }
879 
880 /******************************************************************************
881  *
882  * FUNCTION:    acpi_os_install_interrupt_handler
883  *
884  * PARAMETERS:  interrupt_number    - Level handler should respond to.
885  *              isr                 - Address of the ACPI interrupt handler
886  *              except_ptr          - Where status is returned
887  *
888  * RETURN:      Handle to the newly installed handler.
889  *
890  * DESCRIPTION: Install an interrupt handler. Used to install the ACPI
891  *              OS-independent handler.
892  *
893  *****************************************************************************/
894 
895 u32
896 acpi_os_install_interrupt_handler(u32 interrupt_number,
897 				  acpi_osd_handler service_routine,
898 				  void *context)
899 {
900 
901 	return (AE_OK);
902 }
903 
904 /******************************************************************************
905  *
906  * FUNCTION:    acpi_os_remove_interrupt_handler
907  *
908  * PARAMETERS:  handle              - Returned when handler was installed
909  *
910  * RETURN:      Status
911  *
912  * DESCRIPTION: Uninstalls an interrupt handler.
913  *
914  *****************************************************************************/
915 
916 acpi_status
917 acpi_os_remove_interrupt_handler(u32 interrupt_number,
918 				 acpi_osd_handler service_routine)
919 {
920 
921 	return (AE_OK);
922 }
923 
924 /******************************************************************************
925  *
926  * FUNCTION:    acpi_os_stall
927  *
928  * PARAMETERS:  microseconds        - Time to sleep
929  *
930  * RETURN:      Blocks until sleep is completed.
931  *
932  * DESCRIPTION: Sleep at microsecond granularity
933  *
934  *****************************************************************************/
935 
936 void acpi_os_stall(u32 microseconds)
937 {
938 
939 	if (microseconds) {
940 		usleep(microseconds);
941 	}
942 }
943 
944 /******************************************************************************
945  *
946  * FUNCTION:    acpi_os_sleep
947  *
948  * PARAMETERS:  milliseconds        - Time to sleep
949  *
950  * RETURN:      Blocks until sleep is completed.
951  *
952  * DESCRIPTION: Sleep at millisecond granularity
953  *
954  *****************************************************************************/
955 
956 void acpi_os_sleep(u64 milliseconds)
957 {
958 
959 	/* Sleep for whole seconds */
960 
961 	sleep(milliseconds / ACPI_MSEC_PER_SEC);
962 
963 	/*
964 	 * Sleep for remaining microseconds.
965 	 * Arg to usleep() is in usecs and must be less than 1,000,000 (1 second).
966 	 */
967 	usleep((milliseconds % ACPI_MSEC_PER_SEC) * ACPI_USEC_PER_MSEC);
968 }
969 
970 /******************************************************************************
971  *
972  * FUNCTION:    acpi_os_get_timer
973  *
974  * PARAMETERS:  None
975  *
976  * RETURN:      Current time in 100 nanosecond units
977  *
978  * DESCRIPTION: Get the current system time
979  *
980  *****************************************************************************/
981 
982 u64 acpi_os_get_timer(void)
983 {
984 	struct timeval time;
985 
986 	/* This timer has sufficient resolution for user-space application code */
987 
988 	gettimeofday(&time, NULL);
989 
990 	/* (Seconds * 10^7 = 100ns(10^-7)) + (Microseconds(10^-6) * 10^1 = 100ns) */
991 
992 	return (((u64)time.tv_sec * ACPI_100NSEC_PER_SEC) +
993 		((u64)time.tv_usec * ACPI_100NSEC_PER_USEC));
994 }
995 
996 /******************************************************************************
997  *
998  * FUNCTION:    acpi_os_read_pci_configuration
999  *
1000  * PARAMETERS:  pci_id              - Seg/Bus/Dev
1001  *              pci_register        - Device Register
1002  *              value               - Buffer where value is placed
1003  *              width               - Number of bits
1004  *
1005  * RETURN:      Status
1006  *
1007  * DESCRIPTION: Read data from PCI configuration space
1008  *
1009  *****************************************************************************/
1010 
1011 acpi_status
1012 acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id,
1013 			       u32 pci_register, u64 *value, u32 width)
1014 {
1015 
1016 	*value = 0;
1017 	return (AE_OK);
1018 }
1019 
1020 /******************************************************************************
1021  *
1022  * FUNCTION:    acpi_os_write_pci_configuration
1023  *
1024  * PARAMETERS:  pci_id              - Seg/Bus/Dev
1025  *              pci_register        - Device Register
1026  *              value               - Value to be written
1027  *              width               - Number of bits
1028  *
1029  * RETURN:      Status.
1030  *
1031  * DESCRIPTION: Write data to PCI configuration space
1032  *
1033  *****************************************************************************/
1034 
1035 acpi_status
1036 acpi_os_write_pci_configuration(struct acpi_pci_id *pci_id,
1037 				u32 pci_register, u64 value, u32 width)
1038 {
1039 
1040 	return (AE_OK);
1041 }
1042 
1043 /******************************************************************************
1044  *
1045  * FUNCTION:    acpi_os_read_port
1046  *
1047  * PARAMETERS:  address             - Address of I/O port/register to read
1048  *              value               - Where value is placed
1049  *              width               - Number of bits
1050  *
1051  * RETURN:      Value read from port
1052  *
1053  * DESCRIPTION: Read data from an I/O port or register
1054  *
1055  *****************************************************************************/
1056 
1057 acpi_status acpi_os_read_port(acpi_io_address address, u32 *value, u32 width)
1058 {
1059 
1060 	switch (width) {
1061 	case 8:
1062 
1063 		*value = 0xFF;
1064 		break;
1065 
1066 	case 16:
1067 
1068 		*value = 0xFFFF;
1069 		break;
1070 
1071 	case 32:
1072 
1073 		*value = 0xFFFFFFFF;
1074 		break;
1075 
1076 	default:
1077 
1078 		return (AE_BAD_PARAMETER);
1079 	}
1080 
1081 	return (AE_OK);
1082 }
1083 
1084 /******************************************************************************
1085  *
1086  * FUNCTION:    acpi_os_write_port
1087  *
1088  * PARAMETERS:  address             - Address of I/O port/register to write
1089  *              value               - Value to write
1090  *              width               - Number of bits
1091  *
1092  * RETURN:      None
1093  *
1094  * DESCRIPTION: Write data to an I/O port or register
1095  *
1096  *****************************************************************************/
1097 
1098 acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width)
1099 {
1100 
1101 	return (AE_OK);
1102 }
1103 
1104 /******************************************************************************
1105  *
1106  * FUNCTION:    acpi_os_read_memory
1107  *
1108  * PARAMETERS:  address             - Physical Memory Address to read
1109  *              value               - Where value is placed
1110  *              width               - Number of bits (8,16,32, or 64)
1111  *
1112  * RETURN:      Value read from physical memory address. Always returned
1113  *              as a 64-bit integer, regardless of the read width.
1114  *
1115  * DESCRIPTION: Read data from a physical memory address
1116  *
1117  *****************************************************************************/
1118 
1119 acpi_status
1120 acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width)
1121 {
1122 
1123 	switch (width) {
1124 	case 8:
1125 	case 16:
1126 	case 32:
1127 	case 64:
1128 
1129 		*value = 0;
1130 		break;
1131 
1132 	default:
1133 
1134 		return (AE_BAD_PARAMETER);
1135 	}
1136 	return (AE_OK);
1137 }
1138 
1139 /******************************************************************************
1140  *
1141  * FUNCTION:    acpi_os_write_memory
1142  *
1143  * PARAMETERS:  address             - Physical Memory Address to write
1144  *              value               - Value to write
1145  *              width               - Number of bits (8,16,32, or 64)
1146  *
1147  * RETURN:      None
1148  *
1149  * DESCRIPTION: Write data to a physical memory address
1150  *
1151  *****************************************************************************/
1152 
1153 acpi_status
1154 acpi_os_write_memory(acpi_physical_address address, u64 value, u32 width)
1155 {
1156 
1157 	return (AE_OK);
1158 }
1159 
1160 /******************************************************************************
1161  *
1162  * FUNCTION:    acpi_os_readable
1163  *
1164  * PARAMETERS:  pointer             - Area to be verified
1165  *              length              - Size of area
1166  *
1167  * RETURN:      TRUE if readable for entire length
1168  *
1169  * DESCRIPTION: Verify that a pointer is valid for reading
1170  *
1171  *****************************************************************************/
1172 
1173 u8 acpi_os_readable(void *pointer, acpi_size length)
1174 {
1175 
1176 	return (TRUE);
1177 }
1178 
1179 /******************************************************************************
1180  *
1181  * FUNCTION:    acpi_os_writable
1182  *
1183  * PARAMETERS:  pointer             - Area to be verified
1184  *              length              - Size of area
1185  *
1186  * RETURN:      TRUE if writable for entire length
1187  *
1188  * DESCRIPTION: Verify that a pointer is valid for writing
1189  *
1190  *****************************************************************************/
1191 
1192 u8 acpi_os_writable(void *pointer, acpi_size length)
1193 {
1194 
1195 	return (TRUE);
1196 }
1197 
1198 /******************************************************************************
1199  *
1200  * FUNCTION:    acpi_os_signal
1201  *
1202  * PARAMETERS:  function            - ACPI A signal function code
1203  *              info                - Pointer to function-dependent structure
1204  *
1205  * RETURN:      Status
1206  *
1207  * DESCRIPTION: Miscellaneous functions. Example implementation only.
1208  *
1209  *****************************************************************************/
1210 
1211 acpi_status acpi_os_signal(u32 function, void *info)
1212 {
1213 
1214 	switch (function) {
1215 	case ACPI_SIGNAL_FATAL:
1216 
1217 		break;
1218 
1219 	case ACPI_SIGNAL_BREAKPOINT:
1220 
1221 		break;
1222 
1223 	default:
1224 
1225 		break;
1226 	}
1227 
1228 	return (AE_OK);
1229 }
1230 
1231 /* Optional multi-thread support */
1232 
1233 #ifndef ACPI_SINGLE_THREADED
1234 /******************************************************************************
1235  *
1236  * FUNCTION:    acpi_os_get_thread_id
1237  *
1238  * PARAMETERS:  None
1239  *
1240  * RETURN:      Id of the running thread
1241  *
1242  * DESCRIPTION: Get the ID of the current (running) thread
1243  *
1244  *****************************************************************************/
1245 
1246 acpi_thread_id acpi_os_get_thread_id(void)
1247 {
1248 	pthread_t thread;
1249 
1250 	thread = pthread_self();
1251 	return (ACPI_CAST_PTHREAD_T(thread));
1252 }
1253 
1254 /******************************************************************************
1255  *
1256  * FUNCTION:    acpi_os_execute
1257  *
1258  * PARAMETERS:  type                - Type of execution
1259  *              function            - Address of the function to execute
1260  *              context             - Passed as a parameter to the function
1261  *
1262  * RETURN:      Status.
1263  *
1264  * DESCRIPTION: Execute a new thread
1265  *
1266  *****************************************************************************/
1267 
1268 acpi_status
1269 acpi_os_execute(acpi_execute_type type,
1270 		acpi_osd_exec_callback function, void *context)
1271 {
1272 	pthread_t thread;
1273 	int ret;
1274 
1275 	ret =
1276 	    pthread_create(&thread, NULL, (PTHREAD_CALLBACK) function, context);
1277 	if (ret) {
1278 		acpi_os_printf("Create thread failed");
1279 	}
1280 	return (0);
1281 }
1282 
1283 #else				/* ACPI_SINGLE_THREADED */
1284 acpi_thread_id acpi_os_get_thread_id(void)
1285 {
1286 	return (1);
1287 }
1288 
1289 acpi_status
1290 acpi_os_execute(acpi_execute_type type,
1291 		acpi_osd_exec_callback function, void *context)
1292 {
1293 
1294 	function(context);
1295 
1296 	return (AE_OK);
1297 }
1298 
1299 #endif				/* ACPI_SINGLE_THREADED */
1300 
1301 /******************************************************************************
1302  *
1303  * FUNCTION:    acpi_os_wait_events_complete
1304  *
1305  * PARAMETERS:  None
1306  *
1307  * RETURN:      None
1308  *
1309  * DESCRIPTION: Wait for all asynchronous events to complete. This
1310  *              implementation does nothing.
1311  *
1312  *****************************************************************************/
1313 
1314 void acpi_os_wait_events_complete(void)
1315 {
1316 	return;
1317 }
1318