1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include <acpi/acpi.h>
46#include "accommon.h"
47#include "acinterp.h"
48
49#define _COMPONENT ACPI_EXECUTER
50ACPI_MODULE_NAME("exregion")
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69acpi_status
70acpi_ex_system_memory_space_handler(u32 function,
71 acpi_physical_address address,
72 u32 bit_width,
73 acpi_integer * value,
74 void *handler_context, void *region_context)
75{
76 acpi_status status = AE_OK;
77 void *logical_addr_ptr = NULL;
78 struct acpi_mem_space_context *mem_info = region_context;
79 u32 length;
80 acpi_size map_length;
81 acpi_size page_boundary_map_length;
82#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
83 u32 remainder;
84#endif
85
86 ACPI_FUNCTION_TRACE(ex_system_memory_space_handler);
87
88
89
90 switch (bit_width) {
91 case 8:
92 length = 1;
93 break;
94
95 case 16:
96 length = 2;
97 break;
98
99 case 32:
100 length = 4;
101 break;
102
103 case 64:
104 length = 8;
105 break;
106
107 default:
108 ACPI_ERROR((AE_INFO, "Invalid SystemMemory width %d",
109 bit_width));
110 return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
111 }
112
113#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
114
115
116
117
118 (void)acpi_ut_short_divide((acpi_integer) address, length, NULL,
119 &remainder);
120 if (remainder != 0) {
121 return_ACPI_STATUS(AE_AML_ALIGNMENT);
122 }
123#endif
124
125
126
127
128
129
130 if ((address < mem_info->mapped_physical_address) ||
131 (((acpi_integer) address + length) > ((acpi_integer)
132 mem_info->
133 mapped_physical_address +
134 mem_info->mapped_length))) {
135
136
137
138
139 if (mem_info->mapped_length) {
140
141
142
143 acpi_os_unmap_memory(mem_info->mapped_logical_address,
144 mem_info->mapped_length);
145 }
146
147
148
149
150
151
152 map_length = (acpi_size)
153 ((mem_info->address + mem_info->length) - address);
154
155
156
157
158
159
160
161
162 page_boundary_map_length =
163 ACPI_ROUND_UP(address, ACPI_DEFAULT_PAGE_SIZE) - address;
164
165 if (!page_boundary_map_length) {
166 page_boundary_map_length = ACPI_DEFAULT_PAGE_SIZE;
167 }
168
169 if (map_length > page_boundary_map_length) {
170 map_length = page_boundary_map_length;
171 }
172
173
174
175 mem_info->mapped_logical_address = acpi_os_map_memory((acpi_physical_address) address, map_length);
176 if (!mem_info->mapped_logical_address) {
177 ACPI_ERROR((AE_INFO,
178 "Could not map memory at %8.8X%8.8X, size %X",
179 ACPI_FORMAT_NATIVE_UINT(address),
180 (u32) map_length));
181 mem_info->mapped_length = 0;
182 return_ACPI_STATUS(AE_NO_MEMORY);
183 }
184
185
186
187 mem_info->mapped_physical_address = address;
188 mem_info->mapped_length = map_length;
189 }
190
191
192
193
194
195 logical_addr_ptr = mem_info->mapped_logical_address +
196 ((acpi_integer) address -
197 (acpi_integer) mem_info->mapped_physical_address);
198
199 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
200 "System-Memory (width %d) R/W %d Address=%8.8X%8.8X\n",
201 bit_width, function,
202 ACPI_FORMAT_NATIVE_UINT(address)));
203
204
205
206
207
208
209
210
211
212 switch (function) {
213 case ACPI_READ:
214
215 *value = 0;
216 switch (bit_width) {
217 case 8:
218 *value = (acpi_integer) ACPI_GET8(logical_addr_ptr);
219 break;
220
221 case 16:
222 *value = (acpi_integer) ACPI_GET16(logical_addr_ptr);
223 break;
224
225 case 32:
226 *value = (acpi_integer) ACPI_GET32(logical_addr_ptr);
227 break;
228
229 case 64:
230 *value = (acpi_integer) ACPI_GET64(logical_addr_ptr);
231 break;
232
233 default:
234
235 break;
236 }
237 break;
238
239 case ACPI_WRITE:
240
241 switch (bit_width) {
242 case 8:
243 ACPI_SET8(logical_addr_ptr) = (u8) * value;
244 break;
245
246 case 16:
247 ACPI_SET16(logical_addr_ptr) = (u16) * value;
248 break;
249
250 case 32:
251 ACPI_SET32(logical_addr_ptr) = (u32) * value;
252 break;
253
254 case 64:
255 ACPI_SET64(logical_addr_ptr) = (u64) * value;
256 break;
257
258 default:
259
260 break;
261 }
262 break;
263
264 default:
265 status = AE_BAD_PARAMETER;
266 break;
267 }
268
269 return_ACPI_STATUS(status);
270}
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290acpi_status
291acpi_ex_system_io_space_handler(u32 function,
292 acpi_physical_address address,
293 u32 bit_width,
294 acpi_integer * value,
295 void *handler_context, void *region_context)
296{
297 acpi_status status = AE_OK;
298 u32 value32;
299
300 ACPI_FUNCTION_TRACE(ex_system_io_space_handler);
301
302 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
303 "System-IO (width %d) R/W %d Address=%8.8X%8.8X\n",
304 bit_width, function,
305 ACPI_FORMAT_NATIVE_UINT(address)));
306
307
308
309 switch (function) {
310 case ACPI_READ:
311
312 status = acpi_hw_read_port((acpi_io_address) address,
313 &value32, bit_width);
314 *value = value32;
315 break;
316
317 case ACPI_WRITE:
318
319 status = acpi_hw_write_port((acpi_io_address) address,
320 (u32) * value, bit_width);
321 break;
322
323 default:
324 status = AE_BAD_PARAMETER;
325 break;
326 }
327
328 return_ACPI_STATUS(status);
329}
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349acpi_status
350acpi_ex_pci_config_space_handler(u32 function,
351 acpi_physical_address address,
352 u32 bit_width,
353 acpi_integer * value,
354 void *handler_context, void *region_context)
355{
356 acpi_status status = AE_OK;
357 struct acpi_pci_id *pci_id;
358 u16 pci_register;
359 u32 value32;
360
361 ACPI_FUNCTION_TRACE(ex_pci_config_space_handler);
362
363
364
365
366
367
368
369
370
371
372
373
374
375 pci_id = (struct acpi_pci_id *)region_context;
376 pci_register = (u16) (u32) address;
377
378 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
379 "Pci-Config %d (%d) Seg(%04x) Bus(%04x) Dev(%04x) Func(%04x) Reg(%04x)\n",
380 function, bit_width, pci_id->segment, pci_id->bus,
381 pci_id->device, pci_id->function, pci_register));
382
383 switch (function) {
384 case ACPI_READ:
385
386 status = acpi_os_read_pci_configuration(pci_id, pci_register,
387 &value32, bit_width);
388 *value = value32;
389 break;
390
391 case ACPI_WRITE:
392
393 status = acpi_os_write_pci_configuration(pci_id, pci_register,
394 *value, bit_width);
395 break;
396
397 default:
398
399 status = AE_BAD_PARAMETER;
400 break;
401 }
402
403 return_ACPI_STATUS(status);
404}
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424acpi_status
425acpi_ex_cmos_space_handler(u32 function,
426 acpi_physical_address address,
427 u32 bit_width,
428 acpi_integer * value,
429 void *handler_context, void *region_context)
430{
431 acpi_status status = AE_OK;
432
433 ACPI_FUNCTION_TRACE(ex_cmos_space_handler);
434
435 return_ACPI_STATUS(status);
436}
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456acpi_status
457acpi_ex_pci_bar_space_handler(u32 function,
458 acpi_physical_address address,
459 u32 bit_width,
460 acpi_integer * value,
461 void *handler_context, void *region_context)
462{
463 acpi_status status = AE_OK;
464
465 ACPI_FUNCTION_TRACE(ex_pci_bar_space_handler);
466
467 return_ACPI_STATUS(status);
468}
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488acpi_status
489acpi_ex_data_table_space_handler(u32 function,
490 acpi_physical_address address,
491 u32 bit_width,
492 acpi_integer * value,
493 void *handler_context, void *region_context)
494{
495 ACPI_FUNCTION_TRACE(ex_data_table_space_handler);
496
497
498
499 switch (function) {
500 case ACPI_READ:
501
502 ACPI_MEMCPY(ACPI_CAST_PTR(char, value),
503 ACPI_PHYSADDR_TO_PTR(address),
504 ACPI_DIV_8(bit_width));
505 break;
506
507 case ACPI_WRITE:
508 default:
509
510 return_ACPI_STATUS(AE_SUPPORT);
511 }
512
513 return_ACPI_STATUS(AE_OK);
514}
515