Input: corgi_ts - mark probe function as __devinit
[linux-2.6] / drivers / acpi / resources / rsio.c
1 /*******************************************************************************
2  *
3  * Module Name: rsio - IO and DMA resource descriptors
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2008, 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 <acpi/acresrc.h>
46
47 #define _COMPONENT          ACPI_RESOURCES
48 ACPI_MODULE_NAME("rsio")
49
50 /*******************************************************************************
51  *
52  * acpi_rs_convert_io
53  *
54  ******************************************************************************/
55 struct acpi_rsconvert_info acpi_rs_convert_io[5] = {
56         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IO,
57          ACPI_RS_SIZE(struct acpi_resource_io),
58          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io)},
59
60         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_IO,
61          sizeof(struct aml_resource_io),
62          0},
63
64         /* Decode flag */
65
66         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.io.io_decode),
67          AML_OFFSET(io.flags),
68          0},
69         /*
70          * These fields are contiguous in both the source and destination:
71          * Address Alignment
72          * Length
73          * Minimum Base Address
74          * Maximum Base Address
75          */
76         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.io.alignment),
77          AML_OFFSET(io.alignment),
78          2},
79
80         {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.io.minimum),
81          AML_OFFSET(io.minimum),
82          2}
83 };
84
85 /*******************************************************************************
86  *
87  * acpi_rs_convert_fixed_io
88  *
89  ******************************************************************************/
90
91 struct acpi_rsconvert_info acpi_rs_convert_fixed_io[4] = {
92         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_IO,
93          ACPI_RS_SIZE(struct acpi_resource_fixed_io),
94          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_io)},
95
96         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_IO,
97          sizeof(struct aml_resource_fixed_io),
98          0},
99         /*
100          * These fields are contiguous in both the source and destination:
101          * Base Address
102          * Length
103          */
104         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.fixed_io.address_length),
105          AML_OFFSET(fixed_io.address_length),
106          1},
107
108         {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.fixed_io.address),
109          AML_OFFSET(fixed_io.address),
110          1}
111 };
112
113 /*******************************************************************************
114  *
115  * acpi_rs_convert_generic_reg
116  *
117  ******************************************************************************/
118
119 struct acpi_rsconvert_info acpi_rs_convert_generic_reg[4] = {
120         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_GENERIC_REGISTER,
121          ACPI_RS_SIZE(struct acpi_resource_generic_register),
122          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_generic_reg)},
123
124         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_GENERIC_REGISTER,
125          sizeof(struct aml_resource_generic_register),
126          0},
127         /*
128          * These fields are contiguous in both the source and destination:
129          * Address Space ID
130          * Register Bit Width
131          * Register Bit Offset
132          * Access Size
133          */
134         {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.generic_reg.space_id),
135          AML_OFFSET(generic_reg.address_space_id),
136          4},
137
138         /* Get the Register Address */
139
140         {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.generic_reg.address),
141          AML_OFFSET(generic_reg.address),
142          1}
143 };
144
145 /*******************************************************************************
146  *
147  * acpi_rs_convert_end_dpf
148  *
149  ******************************************************************************/
150
151 struct acpi_rsconvert_info acpi_rs_convert_end_dpf[2] = {
152         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_END_DEPENDENT,
153          ACPI_RS_SIZE_MIN,
154          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_end_dpf)},
155
156         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_END_DEPENDENT,
157          sizeof(struct aml_resource_end_dependent),
158          0}
159 };
160
161 /*******************************************************************************
162  *
163  * acpi_rs_convert_end_tag
164  *
165  ******************************************************************************/
166
167 struct acpi_rsconvert_info acpi_rs_convert_end_tag[2] = {
168         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_END_TAG,
169          ACPI_RS_SIZE_MIN,
170          ACPI_RSC_TABLE_SIZE(acpi_rs_convert_end_tag)},
171
172         /*
173          * Note: The checksum field is set to zero, meaning that the resource
174          * data is treated as if the checksum operation succeeded.
175          * (ACPI Spec 1.0b Section 6.4.2.8)
176          */
177         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_END_TAG,
178          sizeof(struct aml_resource_end_tag),
179          0}
180 };
181
182 /*******************************************************************************
183  *
184  * acpi_rs_get_start_dpf
185  *
186  ******************************************************************************/
187
188 struct acpi_rsconvert_info acpi_rs_get_start_dpf[6] = {
189         {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_START_DEPENDENT,
190          ACPI_RS_SIZE(struct acpi_resource_start_dependent),
191          ACPI_RSC_TABLE_SIZE(acpi_rs_get_start_dpf)},
192
193         /* Defaults for Compatibility and Performance priorities */
194
195         {ACPI_RSC_SET8, ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
196          ACPI_ACCEPTABLE_CONFIGURATION,
197          2},
198
199         /* Get the descriptor length (0 or 1 for Start Dpf descriptor) */
200
201         {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.start_dpf.descriptor_length),
202          AML_OFFSET(start_dpf.descriptor_type),
203          0},
204
205         /* All done if there is no flag byte present in the descriptor */
206
207         {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 1},
208
209         /* Flag byte is present, get the flags */
210
211         {ACPI_RSC_2BITFLAG,
212          ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
213          AML_OFFSET(start_dpf.flags),
214          0},
215
216         {ACPI_RSC_2BITFLAG,
217          ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
218          AML_OFFSET(start_dpf.flags),
219          2}
220 };
221
222 /*******************************************************************************
223  *
224  * acpi_rs_set_start_dpf
225  *
226  ******************************************************************************/
227
228 struct acpi_rsconvert_info acpi_rs_set_start_dpf[10] = {
229         /* Start with a default descriptor of length 1 */
230
231         {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_START_DEPENDENT,
232          sizeof(struct aml_resource_start_dependent),
233          ACPI_RSC_TABLE_SIZE(acpi_rs_set_start_dpf)},
234
235         /* Set the default flag values */
236
237         {ACPI_RSC_2BITFLAG,
238          ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
239          AML_OFFSET(start_dpf.flags),
240          0},
241
242         {ACPI_RSC_2BITFLAG,
243          ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
244          AML_OFFSET(start_dpf.flags),
245          2},
246         /*
247          * All done if the output descriptor length is required to be 1
248          * (i.e., optimization to 0 bytes cannot be attempted)
249          */
250         {ACPI_RSC_EXIT_EQ, ACPI_RSC_COMPARE_VALUE,
251          ACPI_RS_OFFSET(data.start_dpf.descriptor_length),
252          1},
253
254         /* Set length to 0 bytes (no flags byte) */
255
256         {ACPI_RSC_LENGTH, 0, 0,
257          sizeof(struct aml_resource_start_dependent_noprio)},
258
259         /*
260          * All done if the output descriptor length is required to be 0.
261          *
262          * TBD: Perhaps we should check for error if input flags are not
263          * compatible with a 0-byte descriptor.
264          */
265         {ACPI_RSC_EXIT_EQ, ACPI_RSC_COMPARE_VALUE,
266          ACPI_RS_OFFSET(data.start_dpf.descriptor_length),
267          0},
268
269         /* Reset length to 1 byte (descriptor with flags byte) */
270
271         {ACPI_RSC_LENGTH, 0, 0, sizeof(struct aml_resource_start_dependent)},
272
273         /*
274          * All done if flags byte is necessary -- if either priority value
275          * is not ACPI_ACCEPTABLE_CONFIGURATION
276          */
277         {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
278          ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
279          ACPI_ACCEPTABLE_CONFIGURATION},
280
281         {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
282          ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
283          ACPI_ACCEPTABLE_CONFIGURATION},
284
285         /* Flag byte is not necessary */
286
287         {ACPI_RSC_LENGTH, 0, 0,
288          sizeof(struct aml_resource_start_dependent_noprio)}
289 };