1 /******************************************************************************
2 *
3 * Module Name: exregion - ACPI default OpRegion (address space) handlers
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44
45 #define __EXREGION_C__
46
47 #include "acpi.h"
48 #include "accommon.h"
49 #include "acinterp.h"
50
51
52 #define _COMPONENT ACPI_EXECUTER
53 ACPI_MODULE_NAME ("exregion")
54
55
56 /*******************************************************************************
57 *
58 * FUNCTION: AcpiExSystemMemorySpaceHandler
59 *
60 * PARAMETERS: Function - Read or Write operation
61 * Address - Where in the space to read or write
62 * BitWidth - Field width in bits (8, 16, or 32)
63 * Value - Pointer to in or out value
64 * HandlerContext - Pointer to Handler's context
65 * RegionContext - Pointer to context specific to the
66 * accessed region
67 *
68 * RETURN: Status
69 *
70 * DESCRIPTION: Handler for the System Memory address space (Op Region)
71 *
72 ******************************************************************************/
73
74 ACPI_STATUS
75 AcpiExSystemMemorySpaceHandler (
76 UINT32 Function,
77 ACPI_PHYSICAL_ADDRESS Address,
78 UINT32 BitWidth,
79 UINT64 *Value,
80 void *HandlerContext,
81 void *RegionContext)
82 {
83 ACPI_STATUS Status = AE_OK;
84 void *LogicalAddrPtr = NULL;
85 ACPI_MEM_SPACE_CONTEXT *MemInfo = RegionContext;
86 UINT32 Length;
87 ACPI_SIZE MapLength;
88 ACPI_SIZE PageBoundaryMapLength;
89 #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
90 UINT32 Remainder;
91 #endif
92
93
94 ACPI_FUNCTION_TRACE (ExSystemMemorySpaceHandler);
95
96
97 /* Validate and translate the bit width */
98
99 switch (BitWidth)
100 {
101 case 8:
102
103 Length = 1;
104 break;
105
106 case 16:
107
108 Length = 2;
109 break;
110
111 case 32:
112
113 Length = 4;
114 break;
115
116 case 64:
117
118 Length = 8;
119 break;
120
121 default:
122
123 ACPI_ERROR ((AE_INFO, "Invalid SystemMemory width %u",
124 BitWidth));
125 return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
126 }
127
128 #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
129 /*
130 * Hardware does not support non-aligned data transfers, we must verify
131 * the request.
132 */
133 (void) AcpiUtShortDivide ((UINT64) Address, Length, NULL, &Remainder);
134 if (Remainder != 0)
135 {
136 return_ACPI_STATUS (AE_AML_ALIGNMENT);
137 }
138 #endif
139
140 /*
141 * Does the request fit into the cached memory mapping?
142 * Is 1) Address below the current mapping? OR
143 * 2) Address beyond the current mapping?
144 */
145 if ((Address < MemInfo->MappedPhysicalAddress) ||
146 (((UINT64) Address + Length) >
147 ((UINT64)
148 MemInfo->MappedPhysicalAddress + MemInfo->MappedLength)))
149 {
150 /*
151 * The request cannot be resolved by the current memory mapping;
152 * Delete the existing mapping and create a new one.
153 */
154 if (MemInfo->MappedLength)
155 {
156 /* Valid mapping, delete it */
157
158 AcpiOsUnmapMemory (MemInfo->MappedLogicalAddress,
159 MemInfo->MappedLength);
160 }
161
162 /*
163 * October 2009: Attempt to map from the requested address to the
164 * end of the region. However, we will never map more than one
165 * page, nor will we cross a page boundary.
166 */
167 MapLength = (ACPI_SIZE)
168 ((MemInfo->Address + MemInfo->Length) - Address);
169
170 /*
171 * If mapping the entire remaining portion of the region will cross
172 * a page boundary, just map up to the page boundary, do not cross.
173 * On some systems, crossing a page boundary while mapping regions
174 * can cause warnings if the pages have different attributes
175 * due to resource management.
176 *
177 * This has the added benefit of constraining a single mapping to
178 * one page, which is similar to the original code that used a 4k
179 * maximum window.
180 */
181 PageBoundaryMapLength =
182 ACPI_ROUND_UP (Address, ACPI_DEFAULT_PAGE_SIZE) - Address;
183 if (PageBoundaryMapLength == 0)
184 {
185 PageBoundaryMapLength = ACPI_DEFAULT_PAGE_SIZE;
186 }
187
188 if (MapLength > PageBoundaryMapLength)
189 {
190 MapLength = PageBoundaryMapLength;
191 }
192
193 /* Create a new mapping starting at the address given */
194
195 MemInfo->MappedLogicalAddress = AcpiOsMapMemory (
196 (ACPI_PHYSICAL_ADDRESS) Address, MapLength);
197 if (!MemInfo->MappedLogicalAddress)
198 {
199 ACPI_ERROR ((AE_INFO,
200 "Could not map memory at 0x%8.8X%8.8X, size %u",
201 ACPI_FORMAT_NATIVE_UINT (Address), (UINT32) MapLength));
202 MemInfo->MappedLength = 0;
203 return_ACPI_STATUS (AE_NO_MEMORY);
204 }
205
206 /* Save the physical address and mapping size */
207
208 MemInfo->MappedPhysicalAddress = Address;
209 MemInfo->MappedLength = MapLength;
210 }
211
212 /*
213 * Generate a logical pointer corresponding to the address we want to
214 * access
215 */
216 LogicalAddrPtr = MemInfo->MappedLogicalAddress +
217 ((UINT64) Address - (UINT64) MemInfo->MappedPhysicalAddress);
218
219 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
220 "System-Memory (width %u) R/W %u Address=%8.8X%8.8X\n",
221 BitWidth, Function, ACPI_FORMAT_NATIVE_UINT (Address)));
222
223 /*
224 * Perform the memory read or write
225 *
226 * Note: For machines that do not support non-aligned transfers, the target
227 * address was checked for alignment above. We do not attempt to break the
228 * transfer up into smaller (byte-size) chunks because the AML specifically
229 * asked for a transfer width that the hardware may require.
230 */
231 switch (Function)
232 {
233 case ACPI_READ:
234
235 *Value = 0;
236 switch (BitWidth)
237 {
238 case 8:
239
240 *Value = (UINT64) ACPI_GET8 (LogicalAddrPtr);
241 break;
242
243 case 16:
244
245 *Value = (UINT64) ACPI_GET16 (LogicalAddrPtr);
246 break;
247
248 case 32:
249
250 *Value = (UINT64) ACPI_GET32 (LogicalAddrPtr);
251 break;
252
253 case 64:
254
255 *Value = (UINT64) ACPI_GET64 (LogicalAddrPtr);
256 break;
257
258 default:
259
260 /* BitWidth was already validated */
261
262 break;
263 }
264 break;
265
266 case ACPI_WRITE:
267
268 switch (BitWidth)
269 {
270 case 8:
271
272 ACPI_SET8 (LogicalAddrPtr, *Value);
273 break;
274
275 case 16:
276
277 ACPI_SET16 (LogicalAddrPtr, *Value);
278 break;
279
280 case 32:
281
282 ACPI_SET32 (LogicalAddrPtr, *Value);
283 break;
284
285 case 64:
286
287 ACPI_SET64 (LogicalAddrPtr, *Value);
288 break;
289
290 default:
291
292 /* BitWidth was already validated */
293
294 break;
295 }
296 break;
297
298 default:
299
300 Status = AE_BAD_PARAMETER;
301 break;
302 }
303
304 return_ACPI_STATUS (Status);
305 }
306
307
308 /*******************************************************************************
309 *
310 * FUNCTION: AcpiExSystemIoSpaceHandler
311 *
312 * PARAMETERS: Function - Read or Write operation
313 * Address - Where in the space to read or write
314 * BitWidth - Field width in bits (8, 16, or 32)
315 * Value - Pointer to in or out value
316 * HandlerContext - Pointer to Handler's context
317 * RegionContext - Pointer to context specific to the
318 * accessed region
319 *
320 * RETURN: Status
321 *
322 * DESCRIPTION: Handler for the System IO address space (Op Region)
323 *
324 ******************************************************************************/
325
326 ACPI_STATUS
327 AcpiExSystemIoSpaceHandler (
328 UINT32 Function,
329 ACPI_PHYSICAL_ADDRESS Address,
330 UINT32 BitWidth,
331 UINT64 *Value,
332 void *HandlerContext,
333 void *RegionContext)
334 {
335 ACPI_STATUS Status = AE_OK;
336 UINT32 Value32;
337
338
339 ACPI_FUNCTION_TRACE (ExSystemIoSpaceHandler);
340
341
342 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
343 "System-IO (width %u) R/W %u Address=%8.8X%8.8X\n",
344 BitWidth, Function, ACPI_FORMAT_NATIVE_UINT (Address)));
345
346 /* Decode the function parameter */
347
348 switch (Function)
349 {
350 case ACPI_READ:
351
352 Status = AcpiHwReadPort ((ACPI_IO_ADDRESS) Address,
353 &Value32, BitWidth);
354 *Value = Value32;
355 break;
356
357 case ACPI_WRITE:
358
359 Status = AcpiHwWritePort ((ACPI_IO_ADDRESS) Address,
360 (UINT32) *Value, BitWidth);
361 break;
362
363 default:
364
365 Status = AE_BAD_PARAMETER;
366 break;
367 }
368
369 return_ACPI_STATUS (Status);
370 }
371
372
373 /*******************************************************************************
374 *
375 * FUNCTION: AcpiExPciConfigSpaceHandler
376 *
377 * PARAMETERS: Function - Read or Write operation
378 * Address - Where in the space to read or write
379 * BitWidth - Field width in bits (8, 16, or 32)
380 * Value - Pointer to in or out value
381 * HandlerContext - Pointer to Handler's context
382 * RegionContext - Pointer to context specific to the
383 * accessed region
384 *
385 * RETURN: Status
386 *
387 * DESCRIPTION: Handler for the PCI Config address space (Op Region)
388 *
389 ******************************************************************************/
390
391 ACPI_STATUS
392 AcpiExPciConfigSpaceHandler (
393 UINT32 Function,
394 ACPI_PHYSICAL_ADDRESS Address,
395 UINT32 BitWidth,
396 UINT64 *Value,
397 void *HandlerContext,
398 void *RegionContext)
399 {
400 ACPI_STATUS Status = AE_OK;
401 ACPI_PCI_ID *PciId;
402 UINT16 PciRegister;
403
404
405 ACPI_FUNCTION_TRACE (ExPciConfigSpaceHandler);
406
407
408 /*
409 * The arguments to AcpiOs(Read|Write)PciConfiguration are:
410 *
411 * PciSegment is the PCI bus segment range 0-31
412 * PciBus is the PCI bus number range 0-255
413 * PciDevice is the PCI device number range 0-31
414 * PciFunction is the PCI device function number
415 * PciRegister is the Config space register range 0-255 bytes
416 *
417 * Value - input value for write, output address for read
418 *
419 */
420 PciId = (ACPI_PCI_ID *) RegionContext;
421 PciRegister = (UINT16) (UINT32) Address;
422
423 ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
424 "Pci-Config %u (%u) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
425 Function, BitWidth, PciId->Segment, PciId->Bus, PciId->Device,
426 PciId->Function, PciRegister));
427
428 switch (Function)
429 {
430 case ACPI_READ:
431
432 *Value = 0;
433 Status = AcpiOsReadPciConfiguration (PciId, PciRegister,
434 Value, BitWidth);
435 break;
436
437 case ACPI_WRITE:
438
439 Status = AcpiOsWritePciConfiguration (PciId, PciRegister,
440 *Value, BitWidth);
441 break;
442
443 default:
444
445 Status = AE_BAD_PARAMETER;
446 break;
447 }
448
449 return_ACPI_STATUS (Status);
450 }
451
452
453 /*******************************************************************************
454 *
455 * FUNCTION: AcpiExCmosSpaceHandler
456 *
457 * PARAMETERS: Function - Read or Write operation
458 * Address - Where in the space to read or write
459 * BitWidth - Field width in bits (8, 16, or 32)
460 * Value - Pointer to in or out value
461 * HandlerContext - Pointer to Handler's context
462 * RegionContext - Pointer to context specific to the
463 * accessed region
464 *
465 * RETURN: Status
466 *
467 * DESCRIPTION: Handler for the CMOS address space (Op Region)
468 *
469 ******************************************************************************/
470
471 ACPI_STATUS
472 AcpiExCmosSpaceHandler (
473 UINT32 Function,
474 ACPI_PHYSICAL_ADDRESS Address,
475 UINT32 BitWidth,
476 UINT64 *Value,
477 void *HandlerContext,
478 void *RegionContext)
479 {
480 ACPI_STATUS Status = AE_OK;
481
482
483 ACPI_FUNCTION_TRACE (ExCmosSpaceHandler);
484
485
486 return_ACPI_STATUS (Status);
487 }
488
489
490 /*******************************************************************************
491 *
492 * FUNCTION: AcpiExPciBarSpaceHandler
493 *
494 * PARAMETERS: Function - Read or Write operation
495 * Address - Where in the space to read or write
496 * BitWidth - Field width in bits (8, 16, or 32)
497 * Value - Pointer to in or out value
498 * HandlerContext - Pointer to Handler's context
499 * RegionContext - Pointer to context specific to the
500 * accessed region
501 *
502 * RETURN: Status
503 *
504 * DESCRIPTION: Handler for the PCI BarTarget address space (Op Region)
505 *
506 ******************************************************************************/
507
508 ACPI_STATUS
509 AcpiExPciBarSpaceHandler (
510 UINT32 Function,
511 ACPI_PHYSICAL_ADDRESS Address,
512 UINT32 BitWidth,
513 UINT64 *Value,
514 void *HandlerContext,
515 void *RegionContext)
516 {
517 ACPI_STATUS Status = AE_OK;
518
519
520 ACPI_FUNCTION_TRACE (ExPciBarSpaceHandler);
521
522
523 return_ACPI_STATUS (Status);
524 }
525
526
527 /*******************************************************************************
528 *
529 * FUNCTION: AcpiExDataTableSpaceHandler
530 *
531 * PARAMETERS: Function - Read or Write operation
532 * Address - Where in the space to read or write
533 * BitWidth - Field width in bits (8, 16, or 32)
534 * Value - Pointer to in or out value
535 * HandlerContext - Pointer to Handler's context
536 * RegionContext - Pointer to context specific to the
537 * accessed region
538 *
539 * RETURN: Status
540 *
541 * DESCRIPTION: Handler for the Data Table address space (Op Region)
542 *
543 ******************************************************************************/
544
545 ACPI_STATUS
546 AcpiExDataTableSpaceHandler (
547 UINT32 Function,
548 ACPI_PHYSICAL_ADDRESS Address,
549 UINT32 BitWidth,
550 UINT64 *Value,
551 void *HandlerContext,
552 void *RegionContext)
553 {
554 ACPI_FUNCTION_TRACE (ExDataTableSpaceHandler);
555
556
557 /*
558 * Perform the memory read or write. The BitWidth was already
559 * validated.
560 */
561 switch (Function)
562 {
563 case ACPI_READ:
564
565 ACPI_MEMCPY (ACPI_CAST_PTR (char, Value), ACPI_PHYSADDR_TO_PTR (Address),
566 ACPI_DIV_8 (BitWidth));
567 break;
568
569 case ACPI_WRITE:
570
571 ACPI_MEMCPY (ACPI_PHYSADDR_TO_PTR (Address), ACPI_CAST_PTR (char, Value),
572 ACPI_DIV_8 (BitWidth));
573 break;
574
575 default:
576
577 return_ACPI_STATUS (AE_BAD_PARAMETER);
578 }
579
580 return_ACPI_STATUS (AE_OK);
581 }