tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1
2/******************************************************************************
3 *
4 * Module Name: exregion - ACPI default op_region (address space) handlers
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2005, R. Byron Moore
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45#include <acpi/acpi.h>
46#include <acpi/acinterp.h>
47
48#define _COMPONENT ACPI_EXECUTER
49ACPI_MODULE_NAME("exregion")
50
51/*******************************************************************************
52 *
53 * FUNCTION: acpi_ex_system_memory_space_handler
54 *
55 * PARAMETERS: Function - Read or Write operation
56 * Address - Where in the space to read or write
57 * bit_width - Field width in bits (8, 16, or 32)
58 * Value - Pointer to in or out value
59 * handler_context - Pointer to Handler's context
60 * region_context - Pointer to context specific to the
61 * accessed region
62 *
63 * RETURN: Status
64 *
65 * DESCRIPTION: Handler for the System Memory address space (Op Region)
66 *
67 ******************************************************************************/
68acpi_status
69acpi_ex_system_memory_space_handler(u32 function,
70 acpi_physical_address address,
71 u32 bit_width,
72 acpi_integer * value,
73 void *handler_context, void *region_context)
74{
75 acpi_status status = AE_OK;
76 void *logical_addr_ptr = NULL;
77 struct acpi_mem_space_context *mem_info = region_context;
78 u32 length;
79 acpi_size window_size;
80#ifndef ACPI_MISALIGNED_TRANSFERS
81 u32 remainder;
82#endif
83
84 ACPI_FUNCTION_TRACE("ex_system_memory_space_handler");
85
86 /* Validate and translate the bit width */
87
88 switch (bit_width) {
89 case 8:
90 length = 1;
91 break;
92
93 case 16:
94 length = 2;
95 break;
96
97 case 32:
98 length = 4;
99 break;
100
101 case 64:
102 length = 8;
103 break;
104
105 default:
106 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
107 "Invalid system_memory width %d\n",
108 bit_width));
109 return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
110 }
111
112#ifndef ACPI_MISALIGNED_TRANSFERS
113 /*
114 * Hardware does not support non-aligned data transfers, we must verify
115 * the request.
116 */
117 (void)acpi_ut_short_divide((acpi_integer) address, length, NULL,
118 &remainder);
119 if (remainder != 0) {
120 return_ACPI_STATUS(AE_AML_ALIGNMENT);
121 }
122#endif
123
124 /*
125 * Does the request fit into the cached memory mapping?
126 * Is 1) Address below the current mapping? OR
127 * 2) Address beyond the current mapping?
128 */
129 if ((address < mem_info->mapped_physical_address) ||
130 (((acpi_integer) address + length) > ((acpi_integer)
131 mem_info->
132 mapped_physical_address +
133 mem_info->mapped_length))) {
134 /*
135 * The request cannot be resolved by the current memory mapping;
136 * Delete the existing mapping and create a new one.
137 */
138 if (mem_info->mapped_length) {
139 /* Valid mapping, delete it */
140
141 acpi_os_unmap_memory(mem_info->mapped_logical_address,
142 mem_info->mapped_length);
143 }
144
145 /*
146 * Don't attempt to map memory beyond the end of the region, and
147 * constrain the maximum mapping size to something reasonable.
148 */
149 window_size = (acpi_size)
150 ((mem_info->address + mem_info->length) - address);
151
152 if (window_size > ACPI_SYSMEM_REGION_WINDOW_SIZE) {
153 window_size = ACPI_SYSMEM_REGION_WINDOW_SIZE;
154 }
155
156 /* Create a new mapping starting at the address given */
157
158 status = acpi_os_map_memory(address, window_size,
159 (void **)&mem_info->
160 mapped_logical_address);
161 if (ACPI_FAILURE(status)) {
162 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
163 "Could not map memory at %8.8X%8.8X, size %X\n",
164 ACPI_FORMAT_UINT64(address),
165 (u32) window_size));
166 mem_info->mapped_length = 0;
167 return_ACPI_STATUS(status);
168 }
169
170 /* Save the physical address and mapping size */
171
172 mem_info->mapped_physical_address = address;
173 mem_info->mapped_length = window_size;
174 }
175
176 /*
177 * Generate a logical pointer corresponding to the address we want to
178 * access
179 */
180 logical_addr_ptr = mem_info->mapped_logical_address +
181 ((acpi_integer) address -
182 (acpi_integer) mem_info->mapped_physical_address);
183
184 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
185 "system_memory %d (%d width) Address=%8.8X%8.8X\n",
186 function, bit_width, ACPI_FORMAT_UINT64(address)));
187
188 /*
189 * Perform the memory read or write
190 *
191 * Note: For machines that do not support non-aligned transfers, the target
192 * address was checked for alignment above. We do not attempt to break the
193 * transfer up into smaller (byte-size) chunks because the AML specifically
194 * asked for a transfer width that the hardware may require.
195 */
196 switch (function) {
197 case ACPI_READ:
198
199 *value = 0;
200 switch (bit_width) {
201 case 8:
202 *value = (acpi_integer) * ((u8 *) logical_addr_ptr);
203 break;
204
205 case 16:
206 *value = (acpi_integer) * ((u16 *) logical_addr_ptr);
207 break;
208
209 case 32:
210 *value = (acpi_integer) * ((u32 *) logical_addr_ptr);
211 break;
212
213#if ACPI_MACHINE_WIDTH != 16
214 case 64:
215 *value = (acpi_integer) * ((u64 *) logical_addr_ptr);
216 break;
217#endif
218 default:
219 /* bit_width was already validated */
220 break;
221 }
222 break;
223
224 case ACPI_WRITE:
225
226 switch (bit_width) {
227 case 8:
228 *(u8 *) logical_addr_ptr = (u8) * value;
229 break;
230
231 case 16:
232 *(u16 *) logical_addr_ptr = (u16) * value;
233 break;
234
235 case 32:
236 *(u32 *) logical_addr_ptr = (u32) * value;
237 break;
238
239#if ACPI_MACHINE_WIDTH != 16
240 case 64:
241 *(u64 *) logical_addr_ptr = (u64) * value;
242 break;
243#endif
244
245 default:
246 /* bit_width was already validated */
247 break;
248 }
249 break;
250
251 default:
252 status = AE_BAD_PARAMETER;
253 break;
254 }
255
256 return_ACPI_STATUS(status);
257}
258
259/*******************************************************************************
260 *
261 * FUNCTION: acpi_ex_system_io_space_handler
262 *
263 * PARAMETERS: Function - Read or Write operation
264 * Address - Where in the space to read or write
265 * bit_width - Field width in bits (8, 16, or 32)
266 * Value - Pointer to in or out value
267 * handler_context - Pointer to Handler's context
268 * region_context - Pointer to context specific to the
269 * accessed region
270 *
271 * RETURN: Status
272 *
273 * DESCRIPTION: Handler for the System IO address space (Op Region)
274 *
275 ******************************************************************************/
276
277acpi_status
278acpi_ex_system_io_space_handler(u32 function,
279 acpi_physical_address address,
280 u32 bit_width,
281 acpi_integer * value,
282 void *handler_context, void *region_context)
283{
284 acpi_status status = AE_OK;
285 u32 value32;
286
287 ACPI_FUNCTION_TRACE("ex_system_io_space_handler");
288
289 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
290 "system_iO %d (%d width) Address=%8.8X%8.8X\n",
291 function, bit_width, ACPI_FORMAT_UINT64(address)));
292
293 /* Decode the function parameter */
294
295 switch (function) {
296 case ACPI_READ:
297
298 status = acpi_os_read_port((acpi_io_address) address,
299 &value32, bit_width);
300 *value = value32;
301 break;
302
303 case ACPI_WRITE:
304
305 status = acpi_os_write_port((acpi_io_address) address,
306 (u32) * value, bit_width);
307 break;
308
309 default:
310 status = AE_BAD_PARAMETER;
311 break;
312 }
313
314 return_ACPI_STATUS(status);
315}
316
317/*******************************************************************************
318 *
319 * FUNCTION: acpi_ex_pci_config_space_handler
320 *
321 * PARAMETERS: Function - Read or Write operation
322 * Address - Where in the space to read or write
323 * bit_width - Field width in bits (8, 16, or 32)
324 * Value - Pointer to in or out value
325 * handler_context - Pointer to Handler's context
326 * region_context - Pointer to context specific to the
327 * accessed region
328 *
329 * RETURN: Status
330 *
331 * DESCRIPTION: Handler for the PCI Config address space (Op Region)
332 *
333 ******************************************************************************/
334
335acpi_status
336acpi_ex_pci_config_space_handler(u32 function,
337 acpi_physical_address address,
338 u32 bit_width,
339 acpi_integer * value,
340 void *handler_context, void *region_context)
341{
342 acpi_status status = AE_OK;
343 struct acpi_pci_id *pci_id;
344 u16 pci_register;
345
346 ACPI_FUNCTION_TRACE("ex_pci_config_space_handler");
347
348 /*
349 * The arguments to acpi_os(Read|Write)pci_configuration are:
350 *
351 * pci_segment is the PCI bus segment range 0-31
352 * pci_bus is the PCI bus number range 0-255
353 * pci_device is the PCI device number range 0-31
354 * pci_function is the PCI device function number
355 * pci_register is the Config space register range 0-255 bytes
356 *
357 * Value - input value for write, output address for read
358 *
359 */
360 pci_id = (struct acpi_pci_id *)region_context;
361 pci_register = (u16) (u32) address;
362
363 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
364 "pci_config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
365 function, bit_width, pci_id->segment, pci_id->bus,
366 pci_id->device, pci_id->function, pci_register));
367
368 switch (function) {
369 case ACPI_READ:
370
371 *value = 0;
372 status = acpi_os_read_pci_configuration(pci_id, pci_register,
373 value, bit_width);
374 break;
375
376 case ACPI_WRITE:
377
378 status = acpi_os_write_pci_configuration(pci_id, pci_register,
379 *value, bit_width);
380 break;
381
382 default:
383
384 status = AE_BAD_PARAMETER;
385 break;
386 }
387
388 return_ACPI_STATUS(status);
389}
390
391/*******************************************************************************
392 *
393 * FUNCTION: acpi_ex_cmos_space_handler
394 *
395 * PARAMETERS: Function - Read or Write operation
396 * Address - Where in the space to read or write
397 * bit_width - Field width in bits (8, 16, or 32)
398 * Value - Pointer to in or out value
399 * handler_context - Pointer to Handler's context
400 * region_context - Pointer to context specific to the
401 * accessed region
402 *
403 * RETURN: Status
404 *
405 * DESCRIPTION: Handler for the CMOS address space (Op Region)
406 *
407 ******************************************************************************/
408
409acpi_status
410acpi_ex_cmos_space_handler(u32 function,
411 acpi_physical_address address,
412 u32 bit_width,
413 acpi_integer * value,
414 void *handler_context, void *region_context)
415{
416 acpi_status status = AE_OK;
417
418 ACPI_FUNCTION_TRACE("ex_cmos_space_handler");
419
420 return_ACPI_STATUS(status);
421}
422
423/*******************************************************************************
424 *
425 * FUNCTION: acpi_ex_pci_bar_space_handler
426 *
427 * PARAMETERS: Function - Read or Write operation
428 * Address - Where in the space to read or write
429 * bit_width - Field width in bits (8, 16, or 32)
430 * Value - Pointer to in or out value
431 * handler_context - Pointer to Handler's context
432 * region_context - Pointer to context specific to the
433 * accessed region
434 *
435 * RETURN: Status
436 *
437 * DESCRIPTION: Handler for the PCI bar_target address space (Op Region)
438 *
439 ******************************************************************************/
440
441acpi_status
442acpi_ex_pci_bar_space_handler(u32 function,
443 acpi_physical_address address,
444 u32 bit_width,
445 acpi_integer * value,
446 void *handler_context, void *region_context)
447{
448 acpi_status status = AE_OK;
449
450 ACPI_FUNCTION_TRACE("ex_pci_bar_space_handler");
451
452 return_ACPI_STATUS(status);
453}
454
455/*******************************************************************************
456 *
457 * FUNCTION: acpi_ex_data_table_space_handler
458 *
459 * PARAMETERS: Function - Read or Write operation
460 * Address - Where in the space to read or write
461 * bit_width - Field width in bits (8, 16, or 32)
462 * Value - Pointer to in or out value
463 * handler_context - Pointer to Handler's context
464 * region_context - Pointer to context specific to the
465 * accessed region
466 *
467 * RETURN: Status
468 *
469 * DESCRIPTION: Handler for the Data Table address space (Op Region)
470 *
471 ******************************************************************************/
472
473acpi_status
474acpi_ex_data_table_space_handler(u32 function,
475 acpi_physical_address address,
476 u32 bit_width,
477 acpi_integer * value,
478 void *handler_context, void *region_context)
479{
480 acpi_status status = AE_OK;
481 u32 byte_width = ACPI_DIV_8(bit_width);
482 u32 i;
483 char *logical_addr_ptr;
484
485 ACPI_FUNCTION_TRACE("ex_data_table_space_handler");
486
487 logical_addr_ptr = ACPI_PHYSADDR_TO_PTR(address);
488
489 /* Perform the memory read or write */
490
491 switch (function) {
492 case ACPI_READ:
493
494 for (i = 0; i < byte_width; i++) {
495 ((char *)value)[i] = logical_addr_ptr[i];
496 }
497 break;
498
499 case ACPI_WRITE:
500 default:
501
502 return_ACPI_STATUS(AE_SUPPORT);
503 }
504
505 return_ACPI_STATUS(status);
506}