[deliverable/linux.git] / drivers / acpi / resources / rsxface.c

/*******************************************************************************
 *
 * Module Name: rsxface - Public interfaces to the resource manager
 *
 ******************************************************************************/

/*
 * Copyright (C) 2000 - 2005, R. Byron Moore
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 */

#include <linux/module.h>

#include <acpi/acpi.h>
#include <acpi/acresrc.h>

#define _COMPONENT          ACPI_RESOURCES
	 ACPI_MODULE_NAME    ("rsxface")

/* Local macros for 16,32-bit to 64-bit conversion */

#define ACPI_COPY_FIELD(out, in, field)  ((out)->field = (in)->field)
#define ACPI_COPY_ADDRESS(out, in)                      \
	ACPI_COPY_FIELD(out, in, resource_type);             \
	ACPI_COPY_FIELD(out, in, producer_consumer);         \
	ACPI_COPY_FIELD(out, in, decode);                    \
	ACPI_COPY_FIELD(out, in, min_address_fixed);         \
	ACPI_COPY_FIELD(out, in, max_address_fixed);         \
	ACPI_COPY_FIELD(out, in, attribute);                 \
	ACPI_COPY_FIELD(out, in, granularity);               \
	ACPI_COPY_FIELD(out, in, min_address_range);         \
	ACPI_COPY_FIELD(out, in, max_address_range);         \
	ACPI_COPY_FIELD(out, in, address_translation_offset); \
	ACPI_COPY_FIELD(out, in, address_length);            \
	ACPI_COPY_FIELD(out, in, resource_source);


/*******************************************************************************
 *
 * FUNCTION:    acpi_get_irq_routing_table
 *
 * PARAMETERS:  device_handle   - a handle to the Bus device we are querying
 *              ret_buffer      - a pointer to a buffer to receive the
 *                                current resources for the device
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This function is called to get the IRQ routing table for a
 *              specific bus.  The caller must first acquire a handle for the
 *              desired bus.  The routine table is placed in the buffer pointed
 *              to by the ret_buffer variable parameter.
 *
 *              If the function fails an appropriate status will be returned
 *              and the value of ret_buffer is undefined.
 *
 *              This function attempts to execute the _PRT method contained in
 *              the object indicated by the passed device_handle.
 *
 ******************************************************************************/

acpi_status
acpi_get_irq_routing_table (
	acpi_handle                     device_handle,
	struct acpi_buffer              *ret_buffer)
{
	acpi_status                     status;


	ACPI_FUNCTION_TRACE ("acpi_get_irq_routing_table ");


	/*
	 * Must have a valid handle and buffer, So we have to have a handle
	 * and a return buffer structure, and if there is a non-zero buffer length
	 * we also need a valid pointer in the buffer. If it's a zero buffer length,
	 * we'll be returning the needed buffer size, so keep going.
	 */
	if (!device_handle) {
		return_ACPI_STATUS (AE_BAD_PARAMETER);
	}

	status = acpi_ut_validate_buffer (ret_buffer);
	if (ACPI_FAILURE (status)) {
		return_ACPI_STATUS (status);
	}

	status = acpi_rs_get_prt_method_data (device_handle, ret_buffer);
	return_ACPI_STATUS (status);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_get_current_resources
 *
 * PARAMETERS:  device_handle   - a handle to the device object for the
 *                                device we are querying
 *              ret_buffer      - a pointer to a buffer to receive the
 *                                current resources for the device
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This function is called to get the current resources for a
 *              specific device.  The caller must first acquire a handle for
 *              the desired device.  The resource data is placed in the buffer
 *              pointed to by the ret_buffer variable parameter.
 *
 *              If the function fails an appropriate status will be returned
 *              and the value of ret_buffer is undefined.
 *
 *              This function attempts to execute the _CRS method contained in
 *              the object indicated by the passed device_handle.
 *
 ******************************************************************************/

acpi_status
acpi_get_current_resources (
	acpi_handle                     device_handle,
	struct acpi_buffer              *ret_buffer)
{
	acpi_status                     status;


	ACPI_FUNCTION_TRACE ("acpi_get_current_resources");


	/*
	 * Must have a valid handle and buffer, So we have to have a handle
	 * and a return buffer structure, and if there is a non-zero buffer length
	 * we also need a valid pointer in the buffer. If it's a zero buffer length,
	 * we'll be returning the needed buffer size, so keep going.
	 */
	if (!device_handle) {
		return_ACPI_STATUS (AE_BAD_PARAMETER);
	}

	status = acpi_ut_validate_buffer (ret_buffer);
	if (ACPI_FAILURE (status)) {
		return_ACPI_STATUS (status);
	}

	status = acpi_rs_get_crs_method_data (device_handle, ret_buffer);
	return_ACPI_STATUS (status);
}
EXPORT_SYMBOL(acpi_get_current_resources);


/*******************************************************************************
 *
 * FUNCTION:    acpi_get_possible_resources
 *
 * PARAMETERS:  device_handle   - a handle to the device object for the
 *                                device we are querying
 *              ret_buffer      - a pointer to a buffer to receive the
 *                                resources for the device
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This function is called to get a list of the possible resources
 *              for a specific device.  The caller must first acquire a handle
 *              for the desired device.  The resource data is placed in the
 *              buffer pointed to by the ret_buffer variable.
 *
 *              If the function fails an appropriate status will be returned
 *              and the value of ret_buffer is undefined.
 *
 ******************************************************************************/

#ifdef ACPI_FUTURE_USAGE
acpi_status
acpi_get_possible_resources (
	acpi_handle                     device_handle,
	struct acpi_buffer              *ret_buffer)
{
	acpi_status                     status;


	ACPI_FUNCTION_TRACE ("acpi_get_possible_resources");


	/*
	 * Must have a valid handle and buffer, So we have to have a handle
	 * and a return buffer structure, and if there is a non-zero buffer length
	 * we also need a valid pointer in the buffer. If it's a zero buffer length,
	 * we'll be returning the needed buffer size, so keep going.
	 */
	if (!device_handle) {
		return_ACPI_STATUS (AE_BAD_PARAMETER);
	}

	status = acpi_ut_validate_buffer (ret_buffer);
	if (ACPI_FAILURE (status)) {
		return_ACPI_STATUS (status);
	}

	status = acpi_rs_get_prs_method_data (device_handle, ret_buffer);
	return_ACPI_STATUS (status);
}
EXPORT_SYMBOL(acpi_get_possible_resources);
#endif  /*  ACPI_FUTURE_USAGE  */


/*******************************************************************************
 *
 * FUNCTION:    acpi_walk_resources
 *
 * PARAMETERS:  device_handle   - a handle to the device object for the
 *                                device we are querying
 *              Path            - method name of the resources we want
 *                                (METHOD_NAME__CRS or METHOD_NAME__PRS)
 *              user_function   - called for each resource
 *              Context         - passed to user_function
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Retrieves the current or possible resource list for the
 *              specified device.  The user_function is called once for
 *              each resource in the list.
 *
 ******************************************************************************/

acpi_status
acpi_walk_resources (
	acpi_handle                             device_handle,
	char                                    *path,
	ACPI_WALK_RESOURCE_CALLBACK     user_function,
	void                                    *context)
{
	acpi_status                         status;
	struct acpi_buffer                  buffer = {ACPI_ALLOCATE_BUFFER, NULL};
	struct acpi_resource                *resource;
	struct acpi_resource                *buffer_end;


	ACPI_FUNCTION_TRACE ("acpi_walk_resources");


	if (!device_handle ||
		(ACPI_STRNCMP (path, METHOD_NAME__CRS, sizeof (METHOD_NAME__CRS)) &&
		 ACPI_STRNCMP (path, METHOD_NAME__PRS, sizeof (METHOD_NAME__PRS)))) {
		return_ACPI_STATUS (AE_BAD_PARAMETER);
	}

	status = acpi_rs_get_method_data (device_handle, path, &buffer);
	if (ACPI_FAILURE (status)) {
		return_ACPI_STATUS (status);
	}

	/* Setup pointers */

	resource  = (struct acpi_resource *) buffer.pointer;
	buffer_end = ACPI_CAST_PTR (struct acpi_resource,
			  ((u8 *) buffer.pointer + buffer.length));

	/* Walk the resource list */

	for (;;) {
		if (!resource || resource->id == ACPI_RSTYPE_END_TAG) {
			break;
		}

		status = user_function (resource, context);

		switch (status) {
		case AE_OK:
		case AE_CTRL_DEPTH:

			/* Just keep going */

			status = AE_OK;
			break;

		case AE_CTRL_TERMINATE:

			/* Exit now, with OK stats */

			status = AE_OK;
			goto cleanup;

		default:

			/* All others are valid exceptions */

			goto cleanup;
		}

		/* Get the next resource descriptor */

		resource = ACPI_NEXT_RESOURCE (resource);

		/* Check for end-of-buffer */

		if (resource >= buffer_end) {
			goto cleanup;
		}
	}

cleanup:

	acpi_os_free (buffer.pointer);
	return_ACPI_STATUS (status);
}
EXPORT_SYMBOL(acpi_walk_resources);


/*******************************************************************************
 *
 * FUNCTION:    acpi_set_current_resources
 *
 * PARAMETERS:  device_handle   - a handle to the device object for the
 *                                device we are changing the resources of
 *              in_buffer       - a pointer to a buffer containing the
 *                                resources to be set for the device
 *
 * RETURN:      Status
 *
 * DESCRIPTION: This function is called to set the current resources for a
 *              specific device.  The caller must first acquire a handle for
 *              the desired device.  The resource data is passed to the routine
 *              the buffer pointed to by the in_buffer variable.
 *
 ******************************************************************************/

acpi_status
acpi_set_current_resources (
	acpi_handle                     device_handle,
	struct acpi_buffer              *in_buffer)
{
	acpi_status                     status;


	ACPI_FUNCTION_TRACE ("acpi_set_current_resources");


	/* Must have a valid handle and buffer */

	if ((!device_handle)      ||
		(!in_buffer)          ||
		(!in_buffer->pointer) ||
		(!in_buffer->length)) {
		return_ACPI_STATUS (AE_BAD_PARAMETER);
	}

	status = acpi_rs_set_srs_method_data (device_handle, in_buffer);
	return_ACPI_STATUS (status);
}
EXPORT_SYMBOL(acpi_set_current_resources);


/******************************************************************************
 *
 * FUNCTION:    acpi_resource_to_address64
 *
 * PARAMETERS:  resource                - Pointer to a resource
 *              out                     - Pointer to the users's return
 *                                        buffer (a struct
 *                                        struct acpi_resource_address64)
 *
 * RETURN:      Status
 *
 * DESCRIPTION: If the resource is an address16, address32, or address64,
 *              copy it to the address64 return buffer.  This saves the
 *              caller from having to duplicate code for different-sized
 *              addresses.
 *
 ******************************************************************************/

acpi_status
acpi_resource_to_address64 (
	struct acpi_resource                *resource,
	struct acpi_resource_address64      *out)
{
	struct acpi_resource_address16      *address16;
	struct acpi_resource_address32      *address32;


	switch (resource->id) {
	case ACPI_RSTYPE_ADDRESS16:

		address16 = (struct acpi_resource_address16 *) &resource->data;
		ACPI_COPY_ADDRESS (out, address16);
		break;


	case ACPI_RSTYPE_ADDRESS32:

		address32 = (struct acpi_resource_address32 *) &resource->data;
		ACPI_COPY_ADDRESS (out, address32);
		break;


	case ACPI_RSTYPE_ADDRESS64:

		/* Simple copy for 64 bit source */

		ACPI_MEMCPY (out, &resource->data, sizeof (struct acpi_resource_address64));
		break;


	default:
		return (AE_BAD_PARAMETER);
	}

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