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 ACPI_FUNCTION_ENTRY();
276
277 /* Validate the Resource Type */
278
279 if ((aml->address.resource_type > 2) &&
280 (aml->address.resource_type < 0xC0) &&
281 (aml->address.resource_type != 0x0A)) {
282 return (FALSE);
283 }
284
285 /* Get the Resource Type and General Flags */
286
287 (void)acpi_rs_convert_aml_to_resource(resource, aml,
288 info: acpi_rs_convert_general_flags);
289
290 /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
291
292 if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
293 (void)acpi_rs_convert_aml_to_resource(resource, aml,
294 info: acpi_rs_convert_mem_flags);
295 } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
296 (void)acpi_rs_convert_aml_to_resource(resource, aml,
297 info: acpi_rs_convert_io_flags);
298 } else {
299 /* Generic resource type, just grab the type_specific byte */
300
301 resource->data.address.info.type_specific =
302 aml->address.specific_flags;
303 }
304
305 return (TRUE);
306}
307
308/*******************************************************************************
309 *
310 * FUNCTION: acpi_rs_set_address_common
311 *
312 * PARAMETERS: aml - Pointer to the AML resource descriptor
313 * resource - Pointer to the internal resource struct
314 *
315 * RETURN: None
316 *
317 * DESCRIPTION: Convert common flag fields from a resource descriptor to an
318 * AML descriptor
319 *
320 ******************************************************************************/
321
322void
323acpi_rs_set_address_common(union aml_resource *aml,
324 struct acpi_resource *resource)
325{
326 ACPI_FUNCTION_ENTRY();
327
328 /* Set the Resource Type and General Flags */
329
330 (void)acpi_rs_convert_resource_to_aml(resource, aml,
331 info: acpi_rs_convert_general_flags);
332
333 /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
334
335 if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
336 (void)acpi_rs_convert_resource_to_aml(resource, aml,
337 info: acpi_rs_convert_mem_flags);
338 } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
339 (void)acpi_rs_convert_resource_to_aml(resource, aml,
340 info: acpi_rs_convert_io_flags);
341 } else {
342 /* Generic resource type, just copy the type_specific byte */
343
344 aml->address.specific_flags =
345 resource->data.address.info.type_specific;
346 }
347}
348