1 /*******************************************************************************
2 *
3 * Module Name: rsxface - Public interfaces to the resource manager
4 *
5 ******************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2005, R. Byron Moore
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 <linux/module.h>
45
46 #include <acpi/acpi.h>
47 #include <acpi/acresrc.h>
48
49 #define _COMPONENT ACPI_RESOURCES
50 ACPI_MODULE_NAME ("rsxface")
51
52
53 /*******************************************************************************
54 *
55 * FUNCTION: acpi_get_irq_routing_table
56 *
57 * PARAMETERS: device_handle - a handle to the Bus device we are querying
58 * ret_buffer - a pointer to a buffer to receive the
59 * current resources for the device
60 *
61 * RETURN: Status
62 *
63 * DESCRIPTION: This function is called to get the IRQ routing table for a
64 * specific bus. The caller must first acquire a handle for the
65 * desired bus. The routine table is placed in the buffer pointed
66 * to by the ret_buffer variable parameter.
67 *
68 * If the function fails an appropriate status will be returned
69 * and the value of ret_buffer is undefined.
70 *
71 * This function attempts to execute the _PRT method contained in
72 * the object indicated by the passed device_handle.
73 *
74 ******************************************************************************/
75
76 acpi_status
77 acpi_get_irq_routing_table (
78 acpi_handle device_handle,
79 struct acpi_buffer *ret_buffer)
80 {
81 acpi_status status;
82
83
84 ACPI_FUNCTION_TRACE ("acpi_get_irq_routing_table ");
85
86
87 /*
88 * Must have a valid handle and buffer, So we have to have a handle
89 * and a return buffer structure, and if there is a non-zero buffer length
90 * we also need a valid pointer in the buffer. If it's a zero buffer length,
91 * we'll be returning the needed buffer size, so keep going.
92 */
93 if (!device_handle) {
94 return_ACPI_STATUS (AE_BAD_PARAMETER);
95 }
96
97 status = acpi_ut_validate_buffer (ret_buffer);
98 if (ACPI_FAILURE (status)) {
99 return_ACPI_STATUS (status);
100 }
101
102 status = acpi_rs_get_prt_method_data (device_handle, ret_buffer);
103 return_ACPI_STATUS (status);
104 }
105
106
107 /*******************************************************************************
108 *
109 * FUNCTION: acpi_get_current_resources
110 *
111 * PARAMETERS: device_handle - a handle to the device object for the
112 * device we are querying
113 * ret_buffer - a pointer to a buffer to receive the
114 * current resources for the device
115 *
116 * RETURN: Status
117 *
118 * DESCRIPTION: This function is called to get the current resources for a
119 * specific device. The caller must first acquire a handle for
120 * the desired device. The resource data is placed in the buffer
121 * pointed to by the ret_buffer variable parameter.
122 *
123 * If the function fails an appropriate status will be returned
124 * and the value of ret_buffer is undefined.
125 *
126 * This function attempts to execute the _CRS method contained in
127 * the object indicated by the passed device_handle.
128 *
129 ******************************************************************************/
130
131 acpi_status
132 acpi_get_current_resources (
133 acpi_handle device_handle,
134 struct acpi_buffer *ret_buffer)
135 {
136 acpi_status status;
137
138
139 ACPI_FUNCTION_TRACE ("acpi_get_current_resources");
140
141
142 /*
143 * Must have a valid handle and buffer, So we have to have a handle
144 * and a return buffer structure, and if there is a non-zero buffer length
145 * we also need a valid pointer in the buffer. If it's a zero buffer length,
146 * we'll be returning the needed buffer size, so keep going.
147 */
148 if (!device_handle) {
149 return_ACPI_STATUS (AE_BAD_PARAMETER);
150 }
151
152 status = acpi_ut_validate_buffer (ret_buffer);
153 if (ACPI_FAILURE (status)) {
154 return_ACPI_STATUS (status);
155 }
156
157 status = acpi_rs_get_crs_method_data (device_handle, ret_buffer);
158 return_ACPI_STATUS (status);
159 }
160 EXPORT_SYMBOL(acpi_get_current_resources);
161
162
163 /*******************************************************************************
164 *
165 * FUNCTION: acpi_get_possible_resources
166 *
167 * PARAMETERS: device_handle - a handle to the device object for the
168 * device we are querying
169 * ret_buffer - a pointer to a buffer to receive the
170 * resources for the device
171 *
172 * RETURN: Status
173 *
174 * DESCRIPTION: This function is called to get a list of the possible resources
175 * for a specific device. The caller must first acquire a handle
176 * for the desired device. The resource data is placed in the
177 * buffer pointed to by the ret_buffer variable.
178 *
179 * If the function fails an appropriate status will be returned
180 * and the value of ret_buffer is undefined.
181 *
182 ******************************************************************************/
183 #ifdef ACPI_FUTURE_USAGE
184 acpi_status
185 acpi_get_possible_resources (
186 acpi_handle device_handle,
187 struct acpi_buffer *ret_buffer)
188 {
189 acpi_status status;
190
191
192 ACPI_FUNCTION_TRACE ("acpi_get_possible_resources");
193
194
195 /*
196 * Must have a valid handle and buffer, So we have to have a handle
197 * and a return buffer structure, and if there is a non-zero buffer length
198 * we also need a valid pointer in the buffer. If it's a zero buffer length,
199 * we'll be returning the needed buffer size, so keep going.
200 */
201 if (!device_handle) {
202 return_ACPI_STATUS (AE_BAD_PARAMETER);
203 }
204
205 status = acpi_ut_validate_buffer (ret_buffer);
206 if (ACPI_FAILURE (status)) {
207 return_ACPI_STATUS (status);
208 }
209
210 status = acpi_rs_get_prs_method_data (device_handle, ret_buffer);
211 return_ACPI_STATUS (status);
212 }
213 EXPORT_SYMBOL(acpi_get_possible_resources);
214 #endif /* ACPI_FUTURE_USAGE */
215
216
217 /*******************************************************************************
218 *
219 * FUNCTION: acpi_walk_resources
220 *
221 * PARAMETERS: device_handle - a handle to the device object for the
222 * device we are querying
223 * Path - method name of the resources we want
224 * (METHOD_NAME__CRS or METHOD_NAME__PRS)
225 * user_function - called for each resource
226 * Context - passed to user_function
227 *
228 * RETURN: Status
229 *
230 * DESCRIPTION: Retrieves the current or possible resource list for the
231 * specified device. The user_function is called once for
232 * each resource in the list.
233 *
234 ******************************************************************************/
235
236 acpi_status
237 acpi_walk_resources (
238 acpi_handle device_handle,
239 char *path,
240 ACPI_WALK_RESOURCE_CALLBACK user_function,
241 void *context)
242 {
243 acpi_status status;
244 struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
245 struct acpi_resource *resource;
246 struct acpi_resource *buffer_end;
247
248
249 ACPI_FUNCTION_TRACE ("acpi_walk_resources");
250
251
252 if (!device_handle ||
253 (ACPI_STRNCMP (path, METHOD_NAME__CRS, sizeof (METHOD_NAME__CRS)) &&
254 ACPI_STRNCMP (path, METHOD_NAME__PRS, sizeof (METHOD_NAME__PRS)))) {
255 return_ACPI_STATUS (AE_BAD_PARAMETER);
256 }
257
258 status = acpi_rs_get_method_data (device_handle, path, &buffer);
259 if (ACPI_FAILURE (status)) {
260 return_ACPI_STATUS (status);
261 }
262
263 /* Setup pointers */
264
265 resource = (struct acpi_resource *) buffer.pointer;
266 buffer_end = ACPI_CAST_PTR (struct acpi_resource,
267 ((u8 *) buffer.pointer + buffer.length));
268
269 /* Walk the resource list */
270
271 for (;;) {
272 if (!resource || resource->id == ACPI_RSTYPE_END_TAG) {
273 break;
274 }
275
276 status = user_function (resource, context);
277
278 switch (status) {
279 case AE_OK:
280 case AE_CTRL_DEPTH:
281
282 /* Just keep going */
283
284 status = AE_OK;
285 break;
286
287 case AE_CTRL_TERMINATE:
288
289 /* Exit now, with OK stats */
290
291 status = AE_OK;
292 goto cleanup;
293
294 default:
295
296 /* All others are valid exceptions */
297
298 goto cleanup;
299 }
300
301 /* Get the next resource descriptor */
302
303 resource = ACPI_NEXT_RESOURCE (resource);
304
305 /* Check for end-of-buffer */
306
307 if (resource >= buffer_end) {
308 goto cleanup;
309 }
310 }
311
312 cleanup:
313
314 acpi_os_free (buffer.pointer);
315 return_ACPI_STATUS (status);
316 }
317 EXPORT_SYMBOL(acpi_walk_resources);
318
319
320 /*******************************************************************************
321 *
322 * FUNCTION: acpi_set_current_resources
323 *
324 * PARAMETERS: device_handle - a handle to the device object for the
325 * device we are changing the resources of
326 * in_buffer - a pointer to a buffer containing the
327 * resources to be set for the device
328 *
329 * RETURN: Status
330 *
331 * DESCRIPTION: This function is called to set the current resources for a
332 * specific device. The caller must first acquire a handle for
333 * the desired device. The resource data is passed to the routine
334 * the buffer pointed to by the in_buffer variable.
335 *
336 ******************************************************************************/
337
338 acpi_status
339 acpi_set_current_resources (
340 acpi_handle device_handle,
341 struct acpi_buffer *in_buffer)
342 {
343 acpi_status status;
344
345
346 ACPI_FUNCTION_TRACE ("acpi_set_current_resources");
347
348
349 /*
350 * Must have a valid handle and buffer
351 */
352 if ((!device_handle) ||
353 (!in_buffer) ||
354 (!in_buffer->pointer) ||
355 (!in_buffer->length)) {
356 return_ACPI_STATUS (AE_BAD_PARAMETER);
357 }
358
359 status = acpi_rs_set_srs_method_data (device_handle, in_buffer);
360 return_ACPI_STATUS (status);
361 }
362 EXPORT_SYMBOL(acpi_set_current_resources);
363
364
365 #define ACPI_COPY_FIELD(out, in, field) ((out)->field = (in)->field)
366 #define ACPI_COPY_ADDRESS(out, in) \
367 ACPI_COPY_FIELD(out, in, resource_type); \
368 ACPI_COPY_FIELD(out, in, producer_consumer); \
369 ACPI_COPY_FIELD(out, in, decode); \
370 ACPI_COPY_FIELD(out, in, min_address_fixed); \
371 ACPI_COPY_FIELD(out, in, max_address_fixed); \
372 ACPI_COPY_FIELD(out, in, attribute); \
373 ACPI_COPY_FIELD(out, in, granularity); \
374 ACPI_COPY_FIELD(out, in, min_address_range); \
375 ACPI_COPY_FIELD(out, in, max_address_range); \
376 ACPI_COPY_FIELD(out, in, address_translation_offset); \
377 ACPI_COPY_FIELD(out, in, address_length); \
378 ACPI_COPY_FIELD(out, in, resource_source);
379
380 /******************************************************************************
381 *
382 * FUNCTION: acpi_resource_to_address64
383 *
384 * PARAMETERS: resource - Pointer to a resource
385 * out - Pointer to the users's return
386 * buffer (a struct
387 * struct acpi_resource_address64)
388 *
389 * RETURN: Status
390 *
391 * DESCRIPTION: If the resource is an address16, address32, or address64,
392 * copy it to the address64 return buffer. This saves the
393 * caller from having to duplicate code for different-sized
394 * addresses.
395 *
396 ******************************************************************************/
397
398 acpi_status
399 acpi_resource_to_address64 (
400 struct acpi_resource *resource,
401 struct acpi_resource_address64 *out)
402 {
403 struct acpi_resource_address16 *address16;
404 struct acpi_resource_address32 *address32;
405
406
407 switch (resource->id) {
408 case ACPI_RSTYPE_ADDRESS16:
409
410 address16 = (struct acpi_resource_address16 *) &resource->data;
411 ACPI_COPY_ADDRESS(out, address16);
412 break;
413
414
415 case ACPI_RSTYPE_ADDRESS32:
416
417 address32 = (struct acpi_resource_address32 *) &resource->data;
418 ACPI_COPY_ADDRESS(out, address32);
419 break;
420
421
422 case ACPI_RSTYPE_ADDRESS64:
423
424 /* Simple copy for 64 bit source */
425
426 ACPI_MEMCPY (out, &resource->data, sizeof (struct acpi_resource_address64));
427 break;
428
429
430 default:
431 return (AE_BAD_PARAMETER);
432 }
433
434 return (AE_OK);
435 }
436 EXPORT_SYMBOL(acpi_resource_to_address64);
437
438
|
This page was automatically generated by the
LXR engine.
|