ACPI: ACPICA 20060608
[sfrench/cifs-2.6.git] / drivers / acpi / hardware / hwregs.c
1
2 /*******************************************************************************
3  *
4  * Module Name: hwregs - Read/write access functions for the various ACPI
5  *                       control and status registers.
6  *
7  ******************************************************************************/
8
9 /*
10  * Copyright (C) 2000 - 2006, R. Byron Moore
11  * All rights reserved.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions, and the following disclaimer,
18  *    without modification.
19  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
20  *    substantially similar to the "NO WARRANTY" disclaimer below
21  *    ("Disclaimer") and any redistribution must be conditioned upon
22  *    including a substantially similar Disclaimer requirement for further
23  *    binary redistribution.
24  * 3. Neither the names of the above-listed copyright holders nor the names
25  *    of any contributors may be used to endorse or promote products derived
26  *    from this software without specific prior written permission.
27  *
28  * Alternatively, this software may be distributed under the terms of the
29  * GNU General Public License ("GPL") version 2 as published by the Free
30  * Software Foundation.
31  *
32  * NO WARRANTY
33  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
34  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
35  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
36  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
37  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
42  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
43  * POSSIBILITY OF SUCH DAMAGES.
44  */
45
46 #include <acpi/acpi.h>
47 #include <acpi/acnamesp.h>
48 #include <acpi/acevents.h>
49
50 #define _COMPONENT          ACPI_HARDWARE
51 ACPI_MODULE_NAME("hwregs")
52
53 /*******************************************************************************
54  *
55  * FUNCTION:    acpi_hw_clear_acpi_status
56  *
57  * PARAMETERS:  Flags           - Lock the hardware or not
58  *
59  * RETURN:      none
60  *
61  * DESCRIPTION: Clears all fixed and general purpose status bits
62  *              THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
63  *
64  * NOTE: TBD: Flags parameter is obsolete, to be removed
65  *
66  ******************************************************************************/
67 acpi_status acpi_hw_clear_acpi_status(u32 flags)
68 {
69         acpi_status status;
70         acpi_cpu_flags lock_flags = 0;
71
72         ACPI_FUNCTION_TRACE(hw_clear_acpi_status);
73
74         ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %04X\n",
75                           ACPI_BITMASK_ALL_FIXED_STATUS,
76                           (u16) acpi_gbl_FADT->xpm1a_evt_blk.address));
77
78         lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
79
80         status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
81                                         ACPI_REGISTER_PM1_STATUS,
82                                         ACPI_BITMASK_ALL_FIXED_STATUS);
83         if (ACPI_FAILURE(status)) {
84                 goto unlock_and_exit;
85         }
86
87         /* Clear the fixed events */
88
89         if (acpi_gbl_FADT->xpm1b_evt_blk.address) {
90                 status =
91                     acpi_hw_low_level_write(16, ACPI_BITMASK_ALL_FIXED_STATUS,
92                                             &acpi_gbl_FADT->xpm1b_evt_blk);
93                 if (ACPI_FAILURE(status)) {
94                         goto unlock_and_exit;
95                 }
96         }
97
98         /* Clear the GPE Bits in all GPE registers in all GPE blocks */
99
100         status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block);
101
102       unlock_and_exit:
103         acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
104         return_ACPI_STATUS(status);
105 }
106
107 /*******************************************************************************
108  *
109  * FUNCTION:    acpi_get_sleep_type_data
110  *
111  * PARAMETERS:  sleep_state         - Numeric sleep state
112  *              *sleep_type_a        - Where SLP_TYPa is returned
113  *              *sleep_type_b        - Where SLP_TYPb is returned
114  *
115  * RETURN:      Status - ACPI status
116  *
117  * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep
118  *              state.
119  *
120  ******************************************************************************/
121
122 acpi_status
123 acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
124 {
125         acpi_status status = AE_OK;
126         struct acpi_evaluate_info *info;
127
128         ACPI_FUNCTION_TRACE(acpi_get_sleep_type_data);
129
130         /* Validate parameters */
131
132         if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) {
133                 return_ACPI_STATUS(AE_BAD_PARAMETER);
134         }
135
136         /* Allocate the evaluation information block */
137
138         info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
139         if (!info) {
140                 return_ACPI_STATUS(AE_NO_MEMORY);
141         }
142
143         info->pathname =
144             ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]);
145
146         /* Evaluate the namespace object containing the values for this state */
147
148         status = acpi_ns_evaluate(info);
149         if (ACPI_FAILURE(status)) {
150                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
151                                   "%s while evaluating SleepState [%s]\n",
152                                   acpi_format_exception(status),
153                                   info->pathname));
154
155                 goto cleanup;
156         }
157
158         /* Must have a return object */
159
160         if (!info->return_object) {
161                 ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]",
162                             info->pathname));
163                 status = AE_NOT_EXIST;
164         }
165
166         /* It must be of type Package */
167
168         else if (ACPI_GET_OBJECT_TYPE(info->return_object) != ACPI_TYPE_PACKAGE) {
169                 ACPI_ERROR((AE_INFO,
170                             "Sleep State return object is not a Package"));
171                 status = AE_AML_OPERAND_TYPE;
172         }
173
174         /*
175          * The package must have at least two elements.  NOTE (March 2005): This
176          * goes against the current ACPI spec which defines this object as a
177          * package with one encoded DWORD element.  However, existing practice
178          * by BIOS vendors seems to be to have 2 or more elements, at least
179          * one per sleep type (A/B).
180          */
181         else if (info->return_object->package.count < 2) {
182                 ACPI_ERROR((AE_INFO,
183                             "Sleep State return package does not have at least two elements"));
184                 status = AE_AML_NO_OPERAND;
185         }
186
187         /* The first two elements must both be of type Integer */
188
189         else if ((ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[0])
190                   != ACPI_TYPE_INTEGER) ||
191                  (ACPI_GET_OBJECT_TYPE(info->return_object->package.elements[1])
192                   != ACPI_TYPE_INTEGER)) {
193                 ACPI_ERROR((AE_INFO,
194                             "Sleep State return package elements are not both Integers (%s, %s)",
195                             acpi_ut_get_object_type_name(info->return_object->
196                                                          package.elements[0]),
197                             acpi_ut_get_object_type_name(info->return_object->
198                                                          package.elements[1])));
199                 status = AE_AML_OPERAND_TYPE;
200         } else {
201                 /* Valid _Sx_ package size, type, and value */
202
203                 *sleep_type_a = (u8)
204                     (info->return_object->package.elements[0])->integer.value;
205                 *sleep_type_b = (u8)
206                     (info->return_object->package.elements[1])->integer.value;
207         }
208
209         if (ACPI_FAILURE(status)) {
210                 ACPI_EXCEPTION((AE_INFO, status,
211                                 "While evaluating SleepState [%s], bad Sleep object %p type %s",
212                                 info->pathname, info->return_object,
213                                 acpi_ut_get_object_type_name(info->
214                                                              return_object)));
215         }
216
217         acpi_ut_remove_reference(info->return_object);
218
219       cleanup:
220         ACPI_FREE(info);
221         return_ACPI_STATUS(status);
222 }
223
224 ACPI_EXPORT_SYMBOL(acpi_get_sleep_type_data)
225
226 /*******************************************************************************
227  *
228  * FUNCTION:    acpi_hw_get_register_bit_mask
229  *
230  * PARAMETERS:  register_id         - Index of ACPI Register to access
231  *
232  * RETURN:      The bitmask to be used when accessing the register
233  *
234  * DESCRIPTION: Map register_id into a register bitmask.
235  *
236  ******************************************************************************/
237 struct acpi_bit_register_info *acpi_hw_get_bit_register_info(u32 register_id)
238 {
239         ACPI_FUNCTION_ENTRY();
240
241         if (register_id > ACPI_BITREG_MAX) {
242                 ACPI_ERROR((AE_INFO, "Invalid BitRegister ID: %X",
243                             register_id));
244                 return (NULL);
245         }
246
247         return (&acpi_gbl_bit_register_info[register_id]);
248 }
249
250 /*******************************************************************************
251  *
252  * FUNCTION:    acpi_get_register
253  *
254  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
255  *              return_value    - Value that was read from the register
256  *              Flags           - Lock the hardware or not
257  *
258  * RETURN:      Status and the value read from specified Register.  Value
259  *              returned is normalized to bit0 (is shifted all the way right)
260  *
261  * DESCRIPTION: ACPI bit_register read function.
262  *
263  * NOTE: TBD: Flags parameter is obsolete, to be removed
264  *
265  ******************************************************************************/
266
267 acpi_status acpi_get_register(u32 register_id, u32 * return_value, u32 flags)
268 {
269         u32 register_value = 0;
270         struct acpi_bit_register_info *bit_reg_info;
271         acpi_status status;
272
273         ACPI_FUNCTION_TRACE(acpi_get_register);
274
275         /* Get the info structure corresponding to the requested ACPI Register */
276
277         bit_reg_info = acpi_hw_get_bit_register_info(register_id);
278         if (!bit_reg_info) {
279                 return_ACPI_STATUS(AE_BAD_PARAMETER);
280         }
281
282         /* Read from the register */
283
284         status = acpi_hw_register_read(ACPI_MTX_LOCK,
285                                        bit_reg_info->parent_register,
286                                        &register_value);
287
288         if (ACPI_SUCCESS(status)) {
289
290                 /* Normalize the value that was read */
291
292                 register_value =
293                     ((register_value & bit_reg_info->access_bit_mask)
294                      >> bit_reg_info->bit_position);
295
296                 *return_value = register_value;
297
298                 ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n",
299                                   register_value,
300                                   bit_reg_info->parent_register));
301         }
302
303         return_ACPI_STATUS(status);
304 }
305
306 ACPI_EXPORT_SYMBOL(acpi_get_register)
307
308 /*******************************************************************************
309  *
310  * FUNCTION:    acpi_set_register
311  *
312  * PARAMETERS:  register_id     - ID of ACPI bit_register to access
313  *              Value           - (only used on write) value to write to the
314  *                                Register, NOT pre-normalized to the bit pos
315  *              Flags           - Lock the hardware or not
316  *
317  * RETURN:      Status
318  *
319  * DESCRIPTION: ACPI Bit Register write function.
320  *
321  * NOTE: TBD: Flags parameter is obsolete, to be removed
322  *
323  ******************************************************************************/
324 acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
325 {
326         u32 register_value = 0;
327         struct acpi_bit_register_info *bit_reg_info;
328         acpi_status status;
329         acpi_cpu_flags lock_flags;
330
331         ACPI_FUNCTION_TRACE_U32(acpi_set_register, register_id);
332
333         /* Get the info structure corresponding to the requested ACPI Register */
334
335         bit_reg_info = acpi_hw_get_bit_register_info(register_id);
336         if (!bit_reg_info) {
337                 ACPI_ERROR((AE_INFO, "Bad ACPI HW RegisterId: %X",
338                             register_id));
339                 return_ACPI_STATUS(AE_BAD_PARAMETER);
340         }
341
342         lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
343
344         /* Always do a register read first so we can insert the new bits  */
345
346         status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
347                                        bit_reg_info->parent_register,
348                                        &register_value);
349         if (ACPI_FAILURE(status)) {
350                 goto unlock_and_exit;
351         }
352
353         /*
354          * Decode the Register ID
355          * Register ID = [Register block ID] | [bit ID]
356          *
357          * Check bit ID to fine locate Register offset.
358          * Check Mask to determine Register offset, and then read-write.
359          */
360         switch (bit_reg_info->parent_register) {
361         case ACPI_REGISTER_PM1_STATUS:
362
363                 /*
364                  * Status Registers are different from the rest.  Clear by
365                  * writing 1, and writing 0 has no effect.  So, the only relevant
366                  * information is the single bit we're interested in, all others should
367                  * be written as 0 so they will be left unchanged.
368                  */
369                 value = ACPI_REGISTER_PREPARE_BITS(value,
370                                                    bit_reg_info->bit_position,
371                                                    bit_reg_info->
372                                                    access_bit_mask);
373                 if (value) {
374                         status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
375                                                         ACPI_REGISTER_PM1_STATUS,
376                                                         (u16) value);
377                         register_value = 0;
378                 }
379                 break;
380
381         case ACPI_REGISTER_PM1_ENABLE:
382
383                 ACPI_REGISTER_INSERT_VALUE(register_value,
384                                            bit_reg_info->bit_position,
385                                            bit_reg_info->access_bit_mask,
386                                            value);
387
388                 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
389                                                 ACPI_REGISTER_PM1_ENABLE,
390                                                 (u16) register_value);
391                 break;
392
393         case ACPI_REGISTER_PM1_CONTROL:
394
395                 /*
396                  * Write the PM1 Control register.
397                  * Note that at this level, the fact that there are actually TWO
398                  * registers (A and B - and B may not exist) is abstracted.
399                  */
400                 ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n",
401                                   register_value));
402
403                 ACPI_REGISTER_INSERT_VALUE(register_value,
404                                            bit_reg_info->bit_position,
405                                            bit_reg_info->access_bit_mask,
406                                            value);
407
408                 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
409                                                 ACPI_REGISTER_PM1_CONTROL,
410                                                 (u16) register_value);
411                 break;
412
413         case ACPI_REGISTER_PM2_CONTROL:
414
415                 status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
416                                                ACPI_REGISTER_PM2_CONTROL,
417                                                &register_value);
418                 if (ACPI_FAILURE(status)) {
419                         goto unlock_and_exit;
420                 }
421
422                 ACPI_DEBUG_PRINT((ACPI_DB_IO,
423                                   "PM2 control: Read %X from %8.8X%8.8X\n",
424                                   register_value,
425                                   ACPI_FORMAT_UINT64(acpi_gbl_FADT->
426                                                      xpm2_cnt_blk.address)));
427
428                 ACPI_REGISTER_INSERT_VALUE(register_value,
429                                            bit_reg_info->bit_position,
430                                            bit_reg_info->access_bit_mask,
431                                            value);
432
433                 ACPI_DEBUG_PRINT((ACPI_DB_IO,
434                                   "About to write %4.4X to %8.8X%8.8X\n",
435                                   register_value,
436                                   ACPI_FORMAT_UINT64(acpi_gbl_FADT->
437                                                      xpm2_cnt_blk.address)));
438
439                 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
440                                                 ACPI_REGISTER_PM2_CONTROL,
441                                                 (u8) (register_value));
442                 break;
443
444         default:
445                 break;
446         }
447
448       unlock_and_exit:
449
450         acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
451
452         /* Normalize the value that was read */
453
454         ACPI_DEBUG_EXEC(register_value =
455                         ((register_value & bit_reg_info->access_bit_mask) >>
456                          bit_reg_info->bit_position));
457
458         ACPI_DEBUG_PRINT((ACPI_DB_IO,
459                           "Set bits: %8.8X actual %8.8X register %X\n", value,
460                           register_value, bit_reg_info->parent_register));
461         return_ACPI_STATUS(status);
462 }
463
464 ACPI_EXPORT_SYMBOL(acpi_set_register)
465
466 /******************************************************************************
467  *
468  * FUNCTION:    acpi_hw_register_read
469  *
470  * PARAMETERS:  use_lock            - Mutex hw access
471  *              register_id         - register_iD + Offset
472  *              return_value        - Where the register value is returned
473  *
474  * RETURN:      Status and the value read.
475  *
476  * DESCRIPTION: Acpi register read function.  Registers are read at the
477  *              given offset.
478  *
479  ******************************************************************************/
480 acpi_status
481 acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value)
482 {
483         u32 value1 = 0;
484         u32 value2 = 0;
485         acpi_status status;
486         acpi_cpu_flags lock_flags = 0;
487
488         ACPI_FUNCTION_TRACE(hw_register_read);
489
490         if (ACPI_MTX_LOCK == use_lock) {
491                 lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
492         }
493
494         switch (register_id) {
495         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
496
497                 status =
498                     acpi_hw_low_level_read(16, &value1,
499                                            &acpi_gbl_FADT->xpm1a_evt_blk);
500                 if (ACPI_FAILURE(status)) {
501                         goto unlock_and_exit;
502                 }
503
504                 /* PM1B is optional */
505
506                 status =
507                     acpi_hw_low_level_read(16, &value2,
508                                            &acpi_gbl_FADT->xpm1b_evt_blk);
509                 value1 |= value2;
510                 break;
511
512         case ACPI_REGISTER_PM1_ENABLE:  /* 16-bit access */
513
514                 status =
515                     acpi_hw_low_level_read(16, &value1, &acpi_gbl_xpm1a_enable);
516                 if (ACPI_FAILURE(status)) {
517                         goto unlock_and_exit;
518                 }
519
520                 /* PM1B is optional */
521
522                 status =
523                     acpi_hw_low_level_read(16, &value2, &acpi_gbl_xpm1b_enable);
524                 value1 |= value2;
525                 break;
526
527         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
528
529                 status =
530                     acpi_hw_low_level_read(16, &value1,
531                                            &acpi_gbl_FADT->xpm1a_cnt_blk);
532                 if (ACPI_FAILURE(status)) {
533                         goto unlock_and_exit;
534                 }
535
536                 status =
537                     acpi_hw_low_level_read(16, &value2,
538                                            &acpi_gbl_FADT->xpm1b_cnt_blk);
539                 value1 |= value2;
540                 break;
541
542         case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
543
544                 status =
545                     acpi_hw_low_level_read(8, &value1,
546                                            &acpi_gbl_FADT->xpm2_cnt_blk);
547                 break;
548
549         case ACPI_REGISTER_PM_TIMER:    /* 32-bit access */
550
551                 status =
552                     acpi_hw_low_level_read(32, &value1,
553                                            &acpi_gbl_FADT->xpm_tmr_blk);
554                 break;
555
556         case ACPI_REGISTER_SMI_COMMAND_BLOCK:   /* 8-bit access */
557
558                 status = acpi_os_read_port(acpi_gbl_FADT->smi_cmd, &value1, 8);
559                 break;
560
561         default:
562                 ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
563                 status = AE_BAD_PARAMETER;
564                 break;
565         }
566
567       unlock_and_exit:
568         if (ACPI_MTX_LOCK == use_lock) {
569                 acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
570         }
571
572         if (ACPI_SUCCESS(status)) {
573                 *return_value = value1;
574         }
575
576         return_ACPI_STATUS(status);
577 }
578
579 /******************************************************************************
580  *
581  * FUNCTION:    acpi_hw_register_write
582  *
583  * PARAMETERS:  use_lock            - Mutex hw access
584  *              register_id         - register_iD + Offset
585  *              Value               - The value to write
586  *
587  * RETURN:      Status
588  *
589  * DESCRIPTION: Acpi register Write function.  Registers are written at the
590  *              given offset.
591  *
592  ******************************************************************************/
593
594 acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
595 {
596         acpi_status status;
597         acpi_cpu_flags lock_flags = 0;
598
599         ACPI_FUNCTION_TRACE(hw_register_write);
600
601         if (ACPI_MTX_LOCK == use_lock) {
602                 lock_flags = acpi_os_acquire_lock(acpi_gbl_hardware_lock);
603         }
604
605         switch (register_id) {
606         case ACPI_REGISTER_PM1_STATUS:  /* 16-bit access */
607
608                 status =
609                     acpi_hw_low_level_write(16, value,
610                                             &acpi_gbl_FADT->xpm1a_evt_blk);
611                 if (ACPI_FAILURE(status)) {
612                         goto unlock_and_exit;
613                 }
614
615                 /* PM1B is optional */
616
617                 status =
618                     acpi_hw_low_level_write(16, value,
619                                             &acpi_gbl_FADT->xpm1b_evt_blk);
620                 break;
621
622         case ACPI_REGISTER_PM1_ENABLE:  /* 16-bit access */
623
624                 status =
625                     acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1a_enable);
626                 if (ACPI_FAILURE(status)) {
627                         goto unlock_and_exit;
628                 }
629
630                 /* PM1B is optional */
631
632                 status =
633                     acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1b_enable);
634                 break;
635
636         case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
637
638                 status =
639                     acpi_hw_low_level_write(16, value,
640                                             &acpi_gbl_FADT->xpm1a_cnt_blk);
641                 if (ACPI_FAILURE(status)) {
642                         goto unlock_and_exit;
643                 }
644
645                 status =
646                     acpi_hw_low_level_write(16, value,
647                                             &acpi_gbl_FADT->xpm1b_cnt_blk);
648                 break;
649
650         case ACPI_REGISTER_PM1A_CONTROL:        /* 16-bit access */
651
652                 status =
653                     acpi_hw_low_level_write(16, value,
654                                             &acpi_gbl_FADT->xpm1a_cnt_blk);
655                 break;
656
657         case ACPI_REGISTER_PM1B_CONTROL:        /* 16-bit access */
658
659                 status =
660                     acpi_hw_low_level_write(16, value,
661                                             &acpi_gbl_FADT->xpm1b_cnt_blk);
662                 break;
663
664         case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
665
666                 status =
667                     acpi_hw_low_level_write(8, value,
668                                             &acpi_gbl_FADT->xpm2_cnt_blk);
669                 break;
670
671         case ACPI_REGISTER_PM_TIMER:    /* 32-bit access */
672
673                 status =
674                     acpi_hw_low_level_write(32, value,
675                                             &acpi_gbl_FADT->xpm_tmr_blk);
676                 break;
677
678         case ACPI_REGISTER_SMI_COMMAND_BLOCK:   /* 8-bit access */
679
680                 /* SMI_CMD is currently always in IO space */
681
682                 status = acpi_os_write_port(acpi_gbl_FADT->smi_cmd, value, 8);
683                 break;
684
685         default:
686                 status = AE_BAD_PARAMETER;
687                 break;
688         }
689
690       unlock_and_exit:
691         if (ACPI_MTX_LOCK == use_lock) {
692                 acpi_os_release_lock(acpi_gbl_hardware_lock, lock_flags);
693         }
694
695         return_ACPI_STATUS(status);
696 }
697
698 /******************************************************************************
699  *
700  * FUNCTION:    acpi_hw_low_level_read
701  *
702  * PARAMETERS:  Width               - 8, 16, or 32
703  *              Value               - Where the value is returned
704  *              Reg                 - GAS register structure
705  *
706  * RETURN:      Status
707  *
708  * DESCRIPTION: Read from either memory or IO space.
709  *
710  ******************************************************************************/
711
712 acpi_status
713 acpi_hw_low_level_read(u32 width, u32 * value, struct acpi_generic_address *reg)
714 {
715         u64 address;
716         acpi_status status;
717
718         ACPI_FUNCTION_NAME(hw_low_level_read);
719
720         /*
721          * Must have a valid pointer to a GAS structure, and
722          * a non-zero address within. However, don't return an error
723          * because the PM1A/B code must not fail if B isn't present.
724          */
725         if (!reg) {
726                 return (AE_OK);
727         }
728
729         /* Get a local copy of the address.  Handles possible alignment issues */
730
731         ACPI_MOVE_64_TO_64(&address, &reg->address);
732         if (!address) {
733                 return (AE_OK);
734         }
735         *value = 0;
736
737         /*
738          * Two address spaces supported: Memory or IO.
739          * PCI_Config is not supported here because the GAS struct is insufficient
740          */
741         switch (reg->address_space_id) {
742         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
743
744                 status = acpi_os_read_memory((acpi_physical_address) address,
745                                              value, width);
746                 break;
747
748         case ACPI_ADR_SPACE_SYSTEM_IO:
749
750                 status = acpi_os_read_port((acpi_io_address) address,
751                                            value, width);
752                 break;
753
754         default:
755                 ACPI_ERROR((AE_INFO,
756                             "Unsupported address space: %X",
757                             reg->address_space_id));
758                 return (AE_BAD_PARAMETER);
759         }
760
761         ACPI_DEBUG_PRINT((ACPI_DB_IO,
762                           "Read:  %8.8X width %2d from %8.8X%8.8X (%s)\n",
763                           *value, width,
764                           ACPI_FORMAT_UINT64(address),
765                           acpi_ut_get_region_name(reg->address_space_id)));
766
767         return (status);
768 }
769
770 /******************************************************************************
771  *
772  * FUNCTION:    acpi_hw_low_level_write
773  *
774  * PARAMETERS:  Width               - 8, 16, or 32
775  *              Value               - To be written
776  *              Reg                 - GAS register structure
777  *
778  * RETURN:      Status
779  *
780  * DESCRIPTION: Write to either memory or IO space.
781  *
782  ******************************************************************************/
783
784 acpi_status
785 acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address * reg)
786 {
787         u64 address;
788         acpi_status status;
789
790         ACPI_FUNCTION_NAME(hw_low_level_write);
791
792         /*
793          * Must have a valid pointer to a GAS structure, and
794          * a non-zero address within. However, don't return an error
795          * because the PM1A/B code must not fail if B isn't present.
796          */
797         if (!reg) {
798                 return (AE_OK);
799         }
800
801         /* Get a local copy of the address.  Handles possible alignment issues */
802
803         ACPI_MOVE_64_TO_64(&address, &reg->address);
804         if (!address) {
805                 return (AE_OK);
806         }
807
808         /*
809          * Two address spaces supported: Memory or IO.
810          * PCI_Config is not supported here because the GAS struct is insufficient
811          */
812         switch (reg->address_space_id) {
813         case ACPI_ADR_SPACE_SYSTEM_MEMORY:
814
815                 status = acpi_os_write_memory((acpi_physical_address) address,
816                                               value, width);
817                 break;
818
819         case ACPI_ADR_SPACE_SYSTEM_IO:
820
821                 status = acpi_os_write_port((acpi_io_address) address,
822                                             value, width);
823                 break;
824
825         default:
826                 ACPI_ERROR((AE_INFO,
827                             "Unsupported address space: %X",
828                             reg->address_space_id));
829                 return (AE_BAD_PARAMETER);
830         }
831
832         ACPI_DEBUG_PRINT((ACPI_DB_IO,
833                           "Wrote: %8.8X width %2d   to %8.8X%8.8X (%s)\n",
834                           value, width,
835                           ACPI_FORMAT_UINT64(address),
836                           acpi_ut_get_region_name(reg->address_space_id)));
837
838         return (status);
839 }