?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sky2: version 1.3
[linux-2.6/verdex.git] / drivers / acpi / hardware / hwregs.c
blobe1fe75498415c6eaffbc634d3529665d5fad83ca
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 <linux/module.h>
47
48 #include <acpi/acpi.h>
49 #include <acpi/acnamesp.h>
50 #include <acpi/acevents.h>
51
52 #define _COMPONENT ACPI_HARDWARE
53 ACPI_MODULE_NAME("hwregs")
54
55 /*******************************************************************************
56 *
57 * FUNCTION: acpi_hw_clear_acpi_status
58 *
59 * PARAMETERS: Flags - Lock the hardware or not
60 *
61 * RETURN: none
62 *
63 * DESCRIPTION: Clears all fixed and general purpose status bits
64 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED
65 *
66 ******************************************************************************/
67 acpi_status acpi_hw_clear_acpi_status(u32 flags)
68 {
69 acpi_status status;
70
71 ACPI_FUNCTION_TRACE("hw_clear_acpi_status");
72
73 ACPI_DEBUG_PRINT((ACPI_DB_IO, "About to write %04X to %04X\n",
74 ACPI_BITMASK_ALL_FIXED_STATUS,
75 (u16) acpi_gbl_FADT->xpm1a_evt_blk.address));
76
77 if (flags & ACPI_MTX_LOCK) {
78 status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
79 if (ACPI_FAILURE(status)) {
80 return_ACPI_STATUS(status);
81 }
82 }
83
84 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
85 ACPI_REGISTER_PM1_STATUS,
86 ACPI_BITMASK_ALL_FIXED_STATUS);
87 if (ACPI_FAILURE(status)) {
88 goto unlock_and_exit;
89 }
90
91 /* Clear the fixed events */
92
93 if (acpi_gbl_FADT->xpm1b_evt_blk.address) {
94 status =
95 acpi_hw_low_level_write(16, ACPI_BITMASK_ALL_FIXED_STATUS,
96 &acpi_gbl_FADT->xpm1b_evt_blk);
97 if (ACPI_FAILURE(status)) {
98 goto unlock_and_exit;
99 }
100 }
101
102 /* Clear the GPE Bits in all GPE registers in all GPE blocks */
103
104 status = acpi_ev_walk_gpe_list(acpi_hw_clear_gpe_block);
105
106 unlock_and_exit:
107 if (flags & ACPI_MTX_LOCK) {
108 (void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
109 }
110 return_ACPI_STATUS(status);
111 }
112
113 /*******************************************************************************
114 *
115 * FUNCTION: acpi_get_sleep_type_data
116 *
117 * PARAMETERS: sleep_state - Numeric sleep state
118 * *sleep_type_a - Where SLP_TYPa is returned
119 * *sleep_type_b - Where SLP_TYPb is returned
120 *
121 * RETURN: Status - ACPI status
122 *
123 * DESCRIPTION: Obtain the SLP_TYPa and SLP_TYPb values for the requested sleep
124 * state.
125 *
126 ******************************************************************************/
127
128 acpi_status
129 acpi_get_sleep_type_data(u8 sleep_state, u8 * sleep_type_a, u8 * sleep_type_b)
130 {
131 acpi_status status = AE_OK;
132 struct acpi_parameter_info info;
133 char *sleep_state_name;
134
135 ACPI_FUNCTION_TRACE("acpi_get_sleep_type_data");
136
137 /* Validate parameters */
138
139 if ((sleep_state > ACPI_S_STATES_MAX) || !sleep_type_a || !sleep_type_b) {
140 return_ACPI_STATUS(AE_BAD_PARAMETER);
141 }
142
143 /* Evaluate the namespace object containing the values for this state */
144
145 info.parameters = NULL;
146 info.return_object = NULL;
147 sleep_state_name =
148 ACPI_CAST_PTR(char, acpi_gbl_sleep_state_names[sleep_state]);
149
150 status = acpi_ns_evaluate_by_name(sleep_state_name, &info);
151 if (ACPI_FAILURE(status)) {
152 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
153 "%s while evaluating sleep_state [%s]\n",
154 acpi_format_exception(status),
155 sleep_state_name));
156
157 return_ACPI_STATUS(status);
158 }
159
160 /* Must have a return object */
161
162 if (!info.return_object) {
163 ACPI_ERROR((AE_INFO, "No Sleep State object returned from [%s]",
164 sleep_state_name));
165 status = AE_NOT_EXIST;
166 }
167
168 /* It must be of type Package */
169
170 else if (ACPI_GET_OBJECT_TYPE(info.return_object) != ACPI_TYPE_PACKAGE) {
171 ACPI_ERROR((AE_INFO,
172 "Sleep State return object is not a Package"));
173 status = AE_AML_OPERAND_TYPE;
174 }
175
176 /*
177 * The package must have at least two elements. NOTE (March 2005): This
178 * goes against the current ACPI spec which defines this object as a
179 * package with one encoded DWORD element. However, existing practice
180 * by BIOS vendors seems to be to have 2 or more elements, at least
181 * one per sleep type (A/B).
182 */
183 else if (info.return_object->package.count < 2) {
184 ACPI_ERROR((AE_INFO,
185 "Sleep State return package does not have at least two elements"));
186 status = AE_AML_NO_OPERAND;
187 }
188
189 /* The first two elements must both be of type Integer */
190
191 else if ((ACPI_GET_OBJECT_TYPE(info.return_object->package.elements[0])
192 != ACPI_TYPE_INTEGER) ||
193 (ACPI_GET_OBJECT_TYPE(info.return_object->package.elements[1])
194 != ACPI_TYPE_INTEGER)) {
195 ACPI_ERROR((AE_INFO,
196 "Sleep State return package elements are not both Integers (%s, %s)",
197 acpi_ut_get_object_type_name(info.return_object->
198 package.elements[0]),
199 acpi_ut_get_object_type_name(info.return_object->
200 package.elements[1])));
201 status = AE_AML_OPERAND_TYPE;
202 } else {
203 /* Valid _Sx_ package size, type, and value */
204
205 *sleep_type_a = (u8)
206 (info.return_object->package.elements[0])->integer.value;
207 *sleep_type_b = (u8)
208 (info.return_object->package.elements[1])->integer.value;
209 }
210
211 if (ACPI_FAILURE(status)) {
212 ACPI_EXCEPTION((AE_INFO, status,
213 "While evaluating sleep_state [%s], bad Sleep object %p type %s",
214 sleep_state_name, info.return_object,
215 acpi_ut_get_object_type_name(info.
216 return_object)));
217 }
218
219 acpi_ut_remove_reference(info.return_object);
220 return_ACPI_STATUS(status);
221 }
222
223 EXPORT_SYMBOL(acpi_get_sleep_type_data);
224
225 /*******************************************************************************
226 *
227 * FUNCTION: acpi_hw_get_register_bit_mask
228 *
229 * PARAMETERS: register_id - Index of ACPI Register to access
230 *
231 * RETURN: The bitmask to be used when accessing the register
232 *
233 * DESCRIPTION: Map register_id into a register bitmask.
234 *
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 bit_register 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 ******************************************************************************/
264
265 acpi_status acpi_get_register(u32 register_id, u32 * return_value, u32 flags)
266 {
267 u32 register_value = 0;
268 struct acpi_bit_register_info *bit_reg_info;
269 acpi_status status;
270
271 ACPI_FUNCTION_TRACE("acpi_get_register");
272
273 /* Get the info structure corresponding to the requested ACPI Register */
274
275 bit_reg_info = acpi_hw_get_bit_register_info(register_id);
276 if (!bit_reg_info) {
277 return_ACPI_STATUS(AE_BAD_PARAMETER);
278 }
279
280 if (flags & ACPI_MTX_LOCK) {
281 status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
282 if (ACPI_FAILURE(status)) {
283 return_ACPI_STATUS(status);
284 }
285 }
286
287 /* Read from the register */
288
289 status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
290 bit_reg_info->parent_register,
291 &register_value);
292
293 if (flags & ACPI_MTX_LOCK) {
294 (void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
295 }
296
297 if (ACPI_SUCCESS(status)) {
298 /* Normalize the value that was read */
299
300 register_value =
301 ((register_value & bit_reg_info->access_bit_mask)
302 >> bit_reg_info->bit_position);
303
304 *return_value = register_value;
305
306 ACPI_DEBUG_PRINT((ACPI_DB_IO, "Read value %8.8X register %X\n",
307 register_value,
308 bit_reg_info->parent_register));
309 }
310
311 return_ACPI_STATUS(status);
312 }
313
314 EXPORT_SYMBOL(acpi_get_register);
315
316 /*******************************************************************************
317 *
318 * FUNCTION: acpi_set_register
319 *
320 * PARAMETERS: register_id - ID of ACPI bit_register to access
321 * Value - (only used on write) value to write to the
322 * Register, NOT pre-normalized to the bit pos
323 * Flags - Lock the hardware or not
324 *
325 * RETURN: Status
326 *
327 * DESCRIPTION: ACPI Bit Register write function.
328 *
329 ******************************************************************************/
330
331 acpi_status acpi_set_register(u32 register_id, u32 value, u32 flags)
332 {
333 u32 register_value = 0;
334 struct acpi_bit_register_info *bit_reg_info;
335 acpi_status status;
336
337 ACPI_FUNCTION_TRACE_U32("acpi_set_register", register_id);
338
339 /* Get the info structure corresponding to the requested ACPI Register */
340
341 bit_reg_info = acpi_hw_get_bit_register_info(register_id);
342 if (!bit_reg_info) {
343 ACPI_ERROR((AE_INFO, "Bad ACPI HW register_id: %X",
344 register_id));
345 return_ACPI_STATUS(AE_BAD_PARAMETER);
346 }
347
348 if (flags & ACPI_MTX_LOCK) {
349 status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
350 if (ACPI_FAILURE(status)) {
351 return_ACPI_STATUS(status);
352 }
353 }
354
355 /* Always do a register read first so we can insert the new bits */
356
357 status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
358 bit_reg_info->parent_register,
359 &register_value);
360 if (ACPI_FAILURE(status)) {
361 goto unlock_and_exit;
362 }
363
364 /*
365 * Decode the Register ID
366 * Register ID = [Register block ID] | [bit ID]
367 *
368 * Check bit ID to fine locate Register offset.
369 * Check Mask to determine Register offset, and then read-write.
370 */
371 switch (bit_reg_info->parent_register) {
372 case ACPI_REGISTER_PM1_STATUS:
373
374 /*
375 * Status Registers are different from the rest. Clear by
376 * writing 1, and writing 0 has no effect. So, the only relevant
377 * information is the single bit we're interested in, all others should
378 * be written as 0 so they will be left unchanged.
379 */
380 value = ACPI_REGISTER_PREPARE_BITS(value,
381 bit_reg_info->bit_position,
382 bit_reg_info->
383 access_bit_mask);
384 if (value) {
385 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
386 ACPI_REGISTER_PM1_STATUS,
387 (u16) value);
388 register_value = 0;
389 }
390 break;
391
392 case ACPI_REGISTER_PM1_ENABLE:
393
394 ACPI_REGISTER_INSERT_VALUE(register_value,
395 bit_reg_info->bit_position,
396 bit_reg_info->access_bit_mask,
397 value);
398
399 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
400 ACPI_REGISTER_PM1_ENABLE,
401 (u16) register_value);
402 break;
403
404 case ACPI_REGISTER_PM1_CONTROL:
405
406 /*
407 * Write the PM1 Control register.
408 * Note that at this level, the fact that there are actually TWO
409 * registers (A and B - and B may not exist) is abstracted.
410 */
411 ACPI_DEBUG_PRINT((ACPI_DB_IO, "PM1 control: Read %X\n",
412 register_value));
413
414 ACPI_REGISTER_INSERT_VALUE(register_value,
415 bit_reg_info->bit_position,
416 bit_reg_info->access_bit_mask,
417 value);
418
419 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
420 ACPI_REGISTER_PM1_CONTROL,
421 (u16) register_value);
422 break;
423
424 case ACPI_REGISTER_PM2_CONTROL:
425
426 status = acpi_hw_register_read(ACPI_MTX_DO_NOT_LOCK,
427 ACPI_REGISTER_PM2_CONTROL,
428 &register_value);
429 if (ACPI_FAILURE(status)) {
430 goto unlock_and_exit;
431 }
432
433 ACPI_DEBUG_PRINT((ACPI_DB_IO,
434 "PM2 control: Read %X from %8.8X%8.8X\n",
435 register_value,
436 ACPI_FORMAT_UINT64(acpi_gbl_FADT->
437 xpm2_cnt_blk.address)));
438
439 ACPI_REGISTER_INSERT_VALUE(register_value,
440 bit_reg_info->bit_position,
441 bit_reg_info->access_bit_mask,
442 value);
443
444 ACPI_DEBUG_PRINT((ACPI_DB_IO,
445 "About to write %4.4X to %8.8X%8.8X\n",
446 register_value,
447 ACPI_FORMAT_UINT64(acpi_gbl_FADT->
448 xpm2_cnt_blk.address)));
449
450 status = acpi_hw_register_write(ACPI_MTX_DO_NOT_LOCK,
451 ACPI_REGISTER_PM2_CONTROL,
452 (u8) (register_value));
453 break;
454
455 default:
456 break;
457 }
458
459 unlock_and_exit:
460
461 if (flags & ACPI_MTX_LOCK) {
462 (void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
463 }
464
465 /* Normalize the value that was read */
466
467 ACPI_DEBUG_EXEC(register_value =
468 ((register_value & bit_reg_info->access_bit_mask) >>
469 bit_reg_info->bit_position));
470
471 ACPI_DEBUG_PRINT((ACPI_DB_IO,
472 "Set bits: %8.8X actual %8.8X register %X\n", value,
473 register_value, bit_reg_info->parent_register));
474 return_ACPI_STATUS(status);
475 }
476
477 EXPORT_SYMBOL(acpi_set_register);
478
479 /******************************************************************************
480 *
481 * FUNCTION: acpi_hw_register_read
482 *
483 * PARAMETERS: use_lock - Mutex hw access
484 * register_id - register_iD + Offset
485 * return_value - Where the register value is returned
486 *
487 * RETURN: Status and the value read.
488 *
489 * DESCRIPTION: Acpi register read function. Registers are read at the
490 * given offset.
491 *
492 ******************************************************************************/
493
494 acpi_status
495 acpi_hw_register_read(u8 use_lock, u32 register_id, u32 * return_value)
496 {
497 u32 value1 = 0;
498 u32 value2 = 0;
499 acpi_status status;
500
501 ACPI_FUNCTION_TRACE("hw_register_read");
502
503 if (ACPI_MTX_LOCK == use_lock) {
504 status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
505 if (ACPI_FAILURE(status)) {
506 return_ACPI_STATUS(status);
507 }
508 }
509
510 switch (register_id) {
511 case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */
512
513 status =
514 acpi_hw_low_level_read(16, &value1,
515 &acpi_gbl_FADT->xpm1a_evt_blk);
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,
524 &acpi_gbl_FADT->xpm1b_evt_blk);
525 value1 |= value2;
526 break;
527
528 case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */
529
530 status =
531 acpi_hw_low_level_read(16, &value1, &acpi_gbl_xpm1a_enable);
532 if (ACPI_FAILURE(status)) {
533 goto unlock_and_exit;
534 }
535
536 /* PM1B is optional */
537
538 status =
539 acpi_hw_low_level_read(16, &value2, &acpi_gbl_xpm1b_enable);
540 value1 |= value2;
541 break;
542
543 case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
544
545 status =
546 acpi_hw_low_level_read(16, &value1,
547 &acpi_gbl_FADT->xpm1a_cnt_blk);
548 if (ACPI_FAILURE(status)) {
549 goto unlock_and_exit;
550 }
551
552 status =
553 acpi_hw_low_level_read(16, &value2,
554 &acpi_gbl_FADT->xpm1b_cnt_blk);
555 value1 |= value2;
556 break;
557
558 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
559
560 status =
561 acpi_hw_low_level_read(8, &value1,
562 &acpi_gbl_FADT->xpm2_cnt_blk);
563 break;
564
565 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
566
567 status =
568 acpi_hw_low_level_read(32, &value1,
569 &acpi_gbl_FADT->xpm_tmr_blk);
570 break;
571
572 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
573
574 status = acpi_os_read_port(acpi_gbl_FADT->smi_cmd, &value1, 8);
575 break;
576
577 default:
578 ACPI_ERROR((AE_INFO, "Unknown Register ID: %X", register_id));
579 status = AE_BAD_PARAMETER;
580 break;
581 }
582
583 unlock_and_exit:
584 if (ACPI_MTX_LOCK == use_lock) {
585 (void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
586 }
587
588 if (ACPI_SUCCESS(status)) {
589 *return_value = value1;
590 }
591
592 return_ACPI_STATUS(status);
593 }
594
595 /******************************************************************************
596 *
597 * FUNCTION: acpi_hw_register_write
598 *
599 * PARAMETERS: use_lock - Mutex hw access
600 * register_id - register_iD + Offset
601 * Value - The value to write
602 *
603 * RETURN: Status
604 *
605 * DESCRIPTION: Acpi register Write function. Registers are written at the
606 * given offset.
607 *
608 ******************************************************************************/
609
610 acpi_status acpi_hw_register_write(u8 use_lock, u32 register_id, u32 value)
611 {
612 acpi_status status;
613
614 ACPI_FUNCTION_TRACE("hw_register_write");
615
616 if (ACPI_MTX_LOCK == use_lock) {
617 status = acpi_ut_acquire_mutex(ACPI_MTX_HARDWARE);
618 if (ACPI_FAILURE(status)) {
619 return_ACPI_STATUS(status);
620 }
621 }
622
623 switch (register_id) {
624 case ACPI_REGISTER_PM1_STATUS: /* 16-bit access */
625
626 status =
627 acpi_hw_low_level_write(16, value,
628 &acpi_gbl_FADT->xpm1a_evt_blk);
629 if (ACPI_FAILURE(status)) {
630 goto unlock_and_exit;
631 }
632
633 /* PM1B is optional */
634
635 status =
636 acpi_hw_low_level_write(16, value,
637 &acpi_gbl_FADT->xpm1b_evt_blk);
638 break;
639
640 case ACPI_REGISTER_PM1_ENABLE: /* 16-bit access */
641
642 status =
643 acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1a_enable);
644 if (ACPI_FAILURE(status)) {
645 goto unlock_and_exit;
646 }
647
648 /* PM1B is optional */
649
650 status =
651 acpi_hw_low_level_write(16, value, &acpi_gbl_xpm1b_enable);
652 break;
653
654 case ACPI_REGISTER_PM1_CONTROL: /* 16-bit access */
655
656 status =
657 acpi_hw_low_level_write(16, value,
658 &acpi_gbl_FADT->xpm1a_cnt_blk);
659 if (ACPI_FAILURE(status)) {
660 goto unlock_and_exit;
661 }
662
663 status =
664 acpi_hw_low_level_write(16, value,
665 &acpi_gbl_FADT->xpm1b_cnt_blk);
666 break;
667
668 case ACPI_REGISTER_PM1A_CONTROL: /* 16-bit access */
669
670 status =
671 acpi_hw_low_level_write(16, value,
672 &acpi_gbl_FADT->xpm1a_cnt_blk);
673 break;
674
675 case ACPI_REGISTER_PM1B_CONTROL: /* 16-bit access */
676
677 status =
678 acpi_hw_low_level_write(16, value,
679 &acpi_gbl_FADT->xpm1b_cnt_blk);
680 break;
681
682 case ACPI_REGISTER_PM2_CONTROL: /* 8-bit access */
683
684 status =
685 acpi_hw_low_level_write(8, value,
686 &acpi_gbl_FADT->xpm2_cnt_blk);
687 break;
688
689 case ACPI_REGISTER_PM_TIMER: /* 32-bit access */
690
691 status =
692 acpi_hw_low_level_write(32, value,
693 &acpi_gbl_FADT->xpm_tmr_blk);
694 break;
695
696 case ACPI_REGISTER_SMI_COMMAND_BLOCK: /* 8-bit access */
697
698 /* SMI_CMD is currently always in IO space */
699
700 status = acpi_os_write_port(acpi_gbl_FADT->smi_cmd, value, 8);
701 break;
702
703 default:
704 status = AE_BAD_PARAMETER;
705 break;
706 }
707
708 unlock_and_exit:
709 if (ACPI_MTX_LOCK == use_lock) {
710 (void)acpi_ut_release_mutex(ACPI_MTX_HARDWARE);
711 }
712
713 return_ACPI_STATUS(status);
714 }
715
716 /******************************************************************************
717 *
718 * FUNCTION: acpi_hw_low_level_read
719 *
720 * PARAMETERS: Width - 8, 16, or 32
721 * Value - Where the value is returned
722 * Reg - GAS register structure
723 *
724 * RETURN: Status
725 *
726 * DESCRIPTION: Read from either memory or IO space.
727 *
728 ******************************************************************************/
729
730 acpi_status
731 acpi_hw_low_level_read(u32 width, u32 * value, struct acpi_generic_address *reg)
732 {
733 u64 address;
734 acpi_status status;
735
736 ACPI_FUNCTION_NAME("hw_low_level_read");
737
738 /*
739 * Must have a valid pointer to a GAS structure, and
740 * a non-zero address within. However, don't return an error
741 * because the PM1A/B code must not fail if B isn't present.
742 */
743 if (!reg) {
744 return (AE_OK);
745 }
746
747 /* Get a local copy of the address. Handles possible alignment issues */
748
749 ACPI_MOVE_64_TO_64(&address, &reg->address);
750 if (!address) {
751 return (AE_OK);
752 }
753 *value = 0;
754
755 /*
756 * Two address spaces supported: Memory or IO.
757 * PCI_Config is not supported here because the GAS struct is insufficient
758 */
759 switch (reg->address_space_id) {
760 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
761
762 status = acpi_os_read_memory((acpi_physical_address) address,
763 value, width);
764 break;
765
766 case ACPI_ADR_SPACE_SYSTEM_IO:
767
768 status = acpi_os_read_port((acpi_io_address) address,
769 value, width);
770 break;
771
772 default:
773 ACPI_ERROR((AE_INFO,
774 "Unsupported address space: %X",
775 reg->address_space_id));
776 return (AE_BAD_PARAMETER);
777 }
778
779 ACPI_DEBUG_PRINT((ACPI_DB_IO,
780 "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
781 *value, width,
782 ACPI_FORMAT_UINT64(address),
783 acpi_ut_get_region_name(reg->address_space_id)));
784
785 return (status);
786 }
787
788 /******************************************************************************
789 *
790 * FUNCTION: acpi_hw_low_level_write
791 *
792 * PARAMETERS: Width - 8, 16, or 32
793 * Value - To be written
794 * Reg - GAS register structure
795 *
796 * RETURN: Status
797 *
798 * DESCRIPTION: Write to either memory or IO space.
799 *
800 ******************************************************************************/
801
802 acpi_status
803 acpi_hw_low_level_write(u32 width, u32 value, struct acpi_generic_address * reg)
804 {
805 u64 address;
806 acpi_status status;
807
808 ACPI_FUNCTION_NAME("hw_low_level_write");
809
810 /*
811 * Must have a valid pointer to a GAS structure, and
812 * a non-zero address within. However, don't return an error
813 * because the PM1A/B code must not fail if B isn't present.
814 */
815 if (!reg) {
816 return (AE_OK);
817 }
818
819 /* Get a local copy of the address. Handles possible alignment issues */
820
821 ACPI_MOVE_64_TO_64(&address, &reg->address);
822 if (!address) {
823 return (AE_OK);
824 }
825
826 /*
827 * Two address spaces supported: Memory or IO.
828 * PCI_Config is not supported here because the GAS struct is insufficient
829 */
830 switch (reg->address_space_id) {
831 case ACPI_ADR_SPACE_SYSTEM_MEMORY:
832
833 status = acpi_os_write_memory((acpi_physical_address) address,
834 value, width);
835 break;
836
837 case ACPI_ADR_SPACE_SYSTEM_IO:
838
839 status = acpi_os_write_port((acpi_io_address) address,
840 value, width);
841 break;
842
843 default:
844 ACPI_ERROR((AE_INFO,
845 "Unsupported address space: %X",
846 reg->address_space_id));
847 return (AE_BAD_PARAMETER);
848 }
849
850 ACPI_DEBUG_PRINT((ACPI_DB_IO,
851 "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
852 value, width,
853 ACPI_FORMAT_UINT64(address),
854 acpi_ut_get_region_name(reg->address_space_id)));
855
856 return (status);
857 }
Verdex Pro support