~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/power/acpi/os_specific/service_layers/osunixxf.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 - 2019, 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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp