]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/acpi/acpica/rsaddr.c
Merge branch 'master' of git://1984.lsi.us.es/nf
[karo-tx-linux.git] / drivers / acpi / acpica / rsaddr.c
1 /*******************************************************************************
2  *
3  * Module Name: rsaddr - Address resource descriptors (16/32/64)
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 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acresrc.h"
47
48 #define _COMPONENT          ACPI_RESOURCES
49 ACPI_MODULE_NAME("rsaddr")
50
51 /*******************************************************************************
52  *
53  * acpi_rs_convert_address16 - All WORD (16-bit) address resources
54  *
55  ******************************************************************************/
56 struct 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
94 struct 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
132 struct 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
170 struct 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
208 static 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
243 static 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
272 static 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
306 u8
307 acpi_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
356 void
357 acpi_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 }