Loading...
1/*******************************************************************************
2 *
3 * Module Name: rsaddr - Address resource descriptors (16/32/64)
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2012, 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#include <acpi/acpi.h>
45#include "accommon.h"
46#include "acresrc.h"
47
48#define _COMPONENT ACPI_RESOURCES
49ACPI_MODULE_NAME("rsaddr")
50
51/*******************************************************************************
52 *
53 * acpi_rs_convert_address16 - All WORD (16-bit) address resources
54 *
55 ******************************************************************************/
56struct acpi_rsconvert_info acpi_rs_convert_address16[5] = {
57 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS16,
58 ACPI_RS_SIZE(struct acpi_resource_address16),
59 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address16)},
60
61 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS16,
62 sizeof(struct aml_resource_address16),
63 0},
64
65 /* Resource Type, General Flags, and Type-Specific Flags */
66
67 {ACPI_RSC_ADDRESS, 0, 0, 0},
68
69 /*
70 * These fields are contiguous in both the source and destination:
71 * Address Granularity
72 * Address Range Minimum
73 * Address Range Maximum
74 * Address Translation Offset
75 * Address Length
76 */
77 {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.address16.granularity),
78 AML_OFFSET(address16.granularity),
79 5},
80
81 /* Optional resource_source (Index and String) */
82
83 {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address16.resource_source),
84 0,
85 sizeof(struct aml_resource_address16)}
86};
87
88/*******************************************************************************
89 *
90 * acpi_rs_convert_address32 - All DWORD (32-bit) address resources
91 *
92 ******************************************************************************/
93
94struct acpi_rsconvert_info acpi_rs_convert_address32[5] = {
95 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS32,
96 ACPI_RS_SIZE(struct acpi_resource_address32),
97 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address32)},
98
99 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS32,
100 sizeof(struct aml_resource_address32),
101 0},
102
103 /* Resource Type, General Flags, and Type-Specific Flags */
104
105 {ACPI_RSC_ADDRESS, 0, 0, 0},
106
107 /*
108 * These fields are contiguous in both the source and destination:
109 * Address Granularity
110 * Address Range Minimum
111 * Address Range Maximum
112 * Address Translation Offset
113 * Address Length
114 */
115 {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.address32.granularity),
116 AML_OFFSET(address32.granularity),
117 5},
118
119 /* Optional resource_source (Index and String) */
120
121 {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address32.resource_source),
122 0,
123 sizeof(struct aml_resource_address32)}
124};
125
126/*******************************************************************************
127 *
128 * acpi_rs_convert_address64 - All QWORD (64-bit) address resources
129 *
130 ******************************************************************************/
131
132struct acpi_rsconvert_info acpi_rs_convert_address64[5] = {
133 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS64,
134 ACPI_RS_SIZE(struct acpi_resource_address64),
135 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address64)},
136
137 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS64,
138 sizeof(struct aml_resource_address64),
139 0},
140
141 /* Resource Type, General Flags, and Type-Specific Flags */
142
143 {ACPI_RSC_ADDRESS, 0, 0, 0},
144
145 /*
146 * These fields are contiguous in both the source and destination:
147 * Address Granularity
148 * Address Range Minimum
149 * Address Range Maximum
150 * Address Translation Offset
151 * Address Length
152 */
153 {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.address64.granularity),
154 AML_OFFSET(address64.granularity),
155 5},
156
157 /* Optional resource_source (Index and String) */
158
159 {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address64.resource_source),
160 0,
161 sizeof(struct aml_resource_address64)}
162};
163
164/*******************************************************************************
165 *
166 * acpi_rs_convert_ext_address64 - All Extended (64-bit) address resources
167 *
168 ******************************************************************************/
169
170struct acpi_rsconvert_info acpi_rs_convert_ext_address64[5] = {
171 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
172 ACPI_RS_SIZE(struct acpi_resource_extended_address64),
173 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_address64)},
174
175 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
176 sizeof(struct aml_resource_extended_address64),
177 0},
178
179 /* Resource Type, General Flags, and Type-Specific Flags */
180
181 {ACPI_RSC_ADDRESS, 0, 0, 0},
182
183 /* Revision ID */
184
185 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.ext_address64.revision_iD),
186 AML_OFFSET(ext_address64.revision_iD),
187 1},
188 /*
189 * These fields are contiguous in both the source and destination:
190 * Address Granularity
191 * Address Range Minimum
192 * Address Range Maximum
193 * Address Translation Offset
194 * Address Length
195 * Type-Specific Attribute
196 */
197 {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.ext_address64.granularity),
198 AML_OFFSET(ext_address64.granularity),
199 6}
200};
201
202/*******************************************************************************
203 *
204 * acpi_rs_convert_general_flags - Flags common to all address descriptors
205 *
206 ******************************************************************************/
207
208static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
209 {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
210 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
211
212 /* Resource Type (Memory, Io, bus_number, etc.) */
213
214 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
215 AML_OFFSET(address.resource_type),
216 1},
217
218 /* General Flags - Consume, Decode, min_fixed, max_fixed */
219
220 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
221 AML_OFFSET(address.flags),
222 0},
223
224 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
225 AML_OFFSET(address.flags),
226 1},
227
228 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
229 AML_OFFSET(address.flags),
230 2},
231
232 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
233 AML_OFFSET(address.flags),
234 3}
235};
236
237/*******************************************************************************
238 *
239 * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
240 *
241 ******************************************************************************/
242
243static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
244 {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
245 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
246
247 /* Memory-specific flags */
248
249 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
250 AML_OFFSET(address.specific_flags),
251 0},
252
253 {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
254 AML_OFFSET(address.specific_flags),
255 1},
256
257 {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
258 AML_OFFSET(address.specific_flags),
259 3},
260
261 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
262 AML_OFFSET(address.specific_flags),
263 5}
264};
265
266/*******************************************************************************
267 *
268 * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
269 *
270 ******************************************************************************/
271
272static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
273 {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
274 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
275
276 /* I/O-specific flags */
277
278 {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
279 AML_OFFSET(address.specific_flags),
280 0},
281
282 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
283 AML_OFFSET(address.specific_flags),
284 4},
285
286 {ACPI_RSC_1BITFLAG,
287 ACPI_RS_OFFSET(data.address.info.io.translation_type),
288 AML_OFFSET(address.specific_flags),
289 5}
290};
291
292/*******************************************************************************
293 *
294 * FUNCTION: acpi_rs_get_address_common
295 *
296 * PARAMETERS: Resource - Pointer to the internal resource struct
297 * Aml - Pointer to the AML resource descriptor
298 *
299 * RETURN: TRUE if the resource_type field is OK, FALSE otherwise
300 *
301 * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
302 * to an internal resource descriptor
303 *
304 ******************************************************************************/
305
306u8
307acpi_rs_get_address_common(struct acpi_resource *resource,
308 union aml_resource *aml)
309{
310 ACPI_FUNCTION_ENTRY();
311
312 /* Validate the Resource Type */
313
314 if ((aml->address.resource_type > 2)
315 && (aml->address.resource_type < 0xC0)) {
316 return (FALSE);
317 }
318
319 /* Get the Resource Type and General Flags */
320
321 (void)acpi_rs_convert_aml_to_resource(resource, aml,
322 acpi_rs_convert_general_flags);
323
324 /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
325
326 if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
327 (void)acpi_rs_convert_aml_to_resource(resource, aml,
328 acpi_rs_convert_mem_flags);
329 } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
330 (void)acpi_rs_convert_aml_to_resource(resource, aml,
331 acpi_rs_convert_io_flags);
332 } else {
333 /* Generic resource type, just grab the type_specific byte */
334
335 resource->data.address.info.type_specific =
336 aml->address.specific_flags;
337 }
338
339 return (TRUE);
340}
341
342/*******************************************************************************
343 *
344 * FUNCTION: acpi_rs_set_address_common
345 *
346 * PARAMETERS: Aml - Pointer to the AML resource descriptor
347 * Resource - Pointer to the internal resource struct
348 *
349 * RETURN: None
350 *
351 * DESCRIPTION: Convert common flag fields from a resource descriptor to an
352 * AML descriptor
353 *
354 ******************************************************************************/
355
356void
357acpi_rs_set_address_common(union aml_resource *aml,
358 struct acpi_resource *resource)
359{
360 ACPI_FUNCTION_ENTRY();
361
362 /* Set the Resource Type and General Flags */
363
364 (void)acpi_rs_convert_resource_to_aml(resource, aml,
365 acpi_rs_convert_general_flags);
366
367 /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
368
369 if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
370 (void)acpi_rs_convert_resource_to_aml(resource, aml,
371 acpi_rs_convert_mem_flags);
372 } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
373 (void)acpi_rs_convert_resource_to_aml(resource, aml,
374 acpi_rs_convert_io_flags);
375 } else {
376 /* Generic resource type, just copy the type_specific byte */
377
378 aml->address.specific_flags =
379 resource->data.address.info.type_specific;
380 }
381}
1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2/*******************************************************************************
3 *
4 * Module Name: rsaddr - Address resource descriptors (16/32/64)
5 *
6 ******************************************************************************/
7
8#include <acpi/acpi.h>
9#include "accommon.h"
10#include "acresrc.h"
11
12#define _COMPONENT ACPI_RESOURCES
13ACPI_MODULE_NAME("rsaddr")
14
15/*******************************************************************************
16 *
17 * acpi_rs_convert_address16 - All WORD (16-bit) address resources
18 *
19 ******************************************************************************/
20struct acpi_rsconvert_info acpi_rs_convert_address16[5] = {
21 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS16,
22 ACPI_RS_SIZE(struct acpi_resource_address16),
23 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address16)},
24
25 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS16,
26 sizeof(struct aml_resource_address16),
27 0},
28
29 /* Resource Type, General Flags, and Type-Specific Flags */
30
31 {ACPI_RSC_ADDRESS, 0, 0, 0},
32
33 /*
34 * These fields are contiguous in both the source and destination:
35 * Address Granularity
36 * Address Range Minimum
37 * Address Range Maximum
38 * Address Translation Offset
39 * Address Length
40 */
41 {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.address16.address.granularity),
42 AML_OFFSET(address16.granularity),
43 5},
44
45 /* Optional resource_source (Index and String) */
46
47 {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address16.resource_source),
48 0,
49 sizeof(struct aml_resource_address16)}
50};
51
52/*******************************************************************************
53 *
54 * acpi_rs_convert_address32 - All DWORD (32-bit) address resources
55 *
56 ******************************************************************************/
57
58struct acpi_rsconvert_info acpi_rs_convert_address32[5] = {
59 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS32,
60 ACPI_RS_SIZE(struct acpi_resource_address32),
61 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address32)},
62
63 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS32,
64 sizeof(struct aml_resource_address32),
65 0},
66
67 /* Resource Type, General Flags, and Type-Specific Flags */
68
69 {ACPI_RSC_ADDRESS, 0, 0, 0},
70
71 /*
72 * These fields are contiguous in both the source and destination:
73 * Address Granularity
74 * Address Range Minimum
75 * Address Range Maximum
76 * Address Translation Offset
77 * Address Length
78 */
79 {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.address32.address.granularity),
80 AML_OFFSET(address32.granularity),
81 5},
82
83 /* Optional resource_source (Index and String) */
84
85 {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address32.resource_source),
86 0,
87 sizeof(struct aml_resource_address32)}
88};
89
90/*******************************************************************************
91 *
92 * acpi_rs_convert_address64 - All QWORD (64-bit) address resources
93 *
94 ******************************************************************************/
95
96struct acpi_rsconvert_info acpi_rs_convert_address64[5] = {
97 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS64,
98 ACPI_RS_SIZE(struct acpi_resource_address64),
99 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address64)},
100
101 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS64,
102 sizeof(struct aml_resource_address64),
103 0},
104
105 /* Resource Type, General Flags, and Type-Specific Flags */
106
107 {ACPI_RSC_ADDRESS, 0, 0, 0},
108
109 /*
110 * These fields are contiguous in both the source and destination:
111 * Address Granularity
112 * Address Range Minimum
113 * Address Range Maximum
114 * Address Translation Offset
115 * Address Length
116 */
117 {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.address64.address.granularity),
118 AML_OFFSET(address64.granularity),
119 5},
120
121 /* Optional resource_source (Index and String) */
122
123 {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address64.resource_source),
124 0,
125 sizeof(struct aml_resource_address64)}
126};
127
128/*******************************************************************************
129 *
130 * acpi_rs_convert_ext_address64 - All Extended (64-bit) address resources
131 *
132 ******************************************************************************/
133
134struct acpi_rsconvert_info acpi_rs_convert_ext_address64[5] = {
135 {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
136 ACPI_RS_SIZE(struct acpi_resource_extended_address64),
137 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_address64)},
138
139 {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
140 sizeof(struct aml_resource_extended_address64),
141 0},
142
143 /* Resource Type, General Flags, and Type-Specific Flags */
144
145 {ACPI_RSC_ADDRESS, 0, 0, 0},
146
147 /* Revision ID */
148
149 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.ext_address64.revision_ID),
150 AML_OFFSET(ext_address64.revision_ID),
151 1},
152 /*
153 * These fields are contiguous in both the source and destination:
154 * Address Granularity
155 * Address Range Minimum
156 * Address Range Maximum
157 * Address Translation Offset
158 * Address Length
159 * Type-Specific Attribute
160 */
161 {ACPI_RSC_MOVE64,
162 ACPI_RS_OFFSET(data.ext_address64.address.granularity),
163 AML_OFFSET(ext_address64.granularity),
164 6}
165};
166
167/*******************************************************************************
168 *
169 * acpi_rs_convert_general_flags - Flags common to all address descriptors
170 *
171 ******************************************************************************/
172
173static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
174 {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
175 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
176
177 /* Resource Type (Memory, Io, bus_number, etc.) */
178
179 {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
180 AML_OFFSET(address.resource_type),
181 1},
182
183 /* General flags - Consume, Decode, min_fixed, max_fixed */
184
185 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
186 AML_OFFSET(address.flags),
187 0},
188
189 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
190 AML_OFFSET(address.flags),
191 1},
192
193 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
194 AML_OFFSET(address.flags),
195 2},
196
197 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
198 AML_OFFSET(address.flags),
199 3}
200};
201
202/*******************************************************************************
203 *
204 * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
205 *
206 ******************************************************************************/
207
208static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
209 {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
210 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
211
212 /* Memory-specific flags */
213
214 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
215 AML_OFFSET(address.specific_flags),
216 0},
217
218 {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
219 AML_OFFSET(address.specific_flags),
220 1},
221
222 {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
223 AML_OFFSET(address.specific_flags),
224 3},
225
226 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
227 AML_OFFSET(address.specific_flags),
228 5}
229};
230
231/*******************************************************************************
232 *
233 * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
234 *
235 ******************************************************************************/
236
237static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
238 {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
239 ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
240
241 /* I/O-specific flags */
242
243 {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
244 AML_OFFSET(address.specific_flags),
245 0},
246
247 {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
248 AML_OFFSET(address.specific_flags),
249 4},
250
251 {ACPI_RSC_1BITFLAG,
252 ACPI_RS_OFFSET(data.address.info.io.translation_type),
253 AML_OFFSET(address.specific_flags),
254 5}
255};
256
257/*******************************************************************************
258 *
259 * FUNCTION: acpi_rs_get_address_common
260 *
261 * PARAMETERS: resource - Pointer to the internal resource struct
262 * aml - Pointer to the AML resource descriptor
263 *
264 * RETURN: TRUE if the resource_type field is OK, FALSE otherwise
265 *
266 * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
267 * to an internal resource descriptor
268 *
269 ******************************************************************************/
270
271u8
272acpi_rs_get_address_common(struct acpi_resource *resource,
273 union aml_resource *aml)
274{
275 struct aml_resource_address address;
276
277 ACPI_FUNCTION_ENTRY();
278
279 /* Avoid undefined behavior: member access within misaligned address */
280
281 memcpy(&address, aml, sizeof(address));
282
283 /* Validate the Resource Type */
284
285 if ((address.resource_type > 2) && (address.resource_type < 0xC0)) {
286 return (FALSE);
287 }
288
289 /* Get the Resource Type and General Flags */
290
291 (void)acpi_rs_convert_aml_to_resource(resource, aml,
292 acpi_rs_convert_general_flags);
293
294 /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
295
296 if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
297 (void)acpi_rs_convert_aml_to_resource(resource, aml,
298 acpi_rs_convert_mem_flags);
299 } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
300 (void)acpi_rs_convert_aml_to_resource(resource, aml,
301 acpi_rs_convert_io_flags);
302 } else {
303 /* Generic resource type, just grab the type_specific byte */
304
305 resource->data.address.info.type_specific =
306 address.specific_flags;
307 }
308
309 return (TRUE);
310}
311
312/*******************************************************************************
313 *
314 * FUNCTION: acpi_rs_set_address_common
315 *
316 * PARAMETERS: aml - Pointer to the AML resource descriptor
317 * resource - Pointer to the internal resource struct
318 *
319 * RETURN: None
320 *
321 * DESCRIPTION: Convert common flag fields from a resource descriptor to an
322 * AML descriptor
323 *
324 ******************************************************************************/
325
326void
327acpi_rs_set_address_common(union aml_resource *aml,
328 struct acpi_resource *resource)
329{
330 ACPI_FUNCTION_ENTRY();
331
332 /* Set the Resource Type and General Flags */
333
334 (void)acpi_rs_convert_resource_to_aml(resource, aml,
335 acpi_rs_convert_general_flags);
336
337 /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
338
339 if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
340 (void)acpi_rs_convert_resource_to_aml(resource, aml,
341 acpi_rs_convert_mem_flags);
342 } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
343 (void)acpi_rs_convert_resource_to_aml(resource, aml,
344 acpi_rs_convert_io_flags);
345 } else {
346 /* Generic resource type, just copy the type_specific byte */
347
348 aml->address.specific_flags =
349 resource->data.address.info.type_specific;
350 }
351}