PageRenderTime 52ms CodeModel.GetById 11ms app.highlight 34ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/acpi/executer/exprep.c

https://bitbucket.org/evzijst/gittest
C | 530 lines | 246 code | 96 blank | 188 comment | 22 complexity | 48d64be87d7ab02ed8ff4d74693ba289 MD5 | raw file
  1
  2/******************************************************************************
  3 *
  4 * Module Name: exprep - ACPI AML (p-code) execution - field prep utilities
  5 *
  6 *****************************************************************************/
  7
  8/*
  9 * Copyright (C) 2000 - 2005, R. Byron Moore
 10 * All rights reserved.
 11 *
 12 * Redistribution and use in source and binary forms, with or without
 13 * modification, are permitted provided that the following conditions
 14 * are met:
 15 * 1. Redistributions of source code must retain the above copyright
 16 *    notice, this list of conditions, and the following disclaimer,
 17 *    without modification.
 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 19 *    substantially similar to the "NO WARRANTY" disclaimer below
 20 *    ("Disclaimer") and any redistribution must be conditioned upon
 21 *    including a substantially similar Disclaimer requirement for further
 22 *    binary redistribution.
 23 * 3. Neither the names of the above-listed copyright holders nor the names
 24 *    of any contributors may be used to endorse or promote products derived
 25 *    from this software without specific prior written permission.
 26 *
 27 * Alternatively, this software may be distributed under the terms of the
 28 * GNU General Public License ("GPL") version 2 as published by the Free
 29 * Software Foundation.
 30 *
 31 * NO WARRANTY
 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 42 * POSSIBILITY OF SUCH DAMAGES.
 43 */
 44
 45
 46#include <acpi/acpi.h>
 47#include <acpi/acinterp.h>
 48#include <acpi/amlcode.h>
 49#include <acpi/acnamesp.h>
 50
 51
 52#define _COMPONENT          ACPI_EXECUTER
 53	 ACPI_MODULE_NAME    ("exprep")
 54
 55
 56#ifdef ACPI_UNDER_DEVELOPMENT
 57/*******************************************************************************
 58 *
 59 * FUNCTION:    acpi_ex_generate_access
 60 *
 61 * PARAMETERS:  field_bit_offset    - Start of field within parent region/buffer
 62 *              field_bit_length    - Length of field in bits
 63 *              region_length       - Length of parent in bytes
 64 *
 65 * RETURN:      Field granularity (8, 16, 32 or 64) and
 66 *              byte_alignment (1, 2, 3, or 4)
 67 *
 68 * DESCRIPTION: Generate an optimal access width for fields defined with the
 69 *              any_acc keyword.
 70 *
 71 * NOTE: Need to have the region_length in order to check for boundary
 72 *       conditions (end-of-region).  However, the region_length is a deferred
 73 *       operation.  Therefore, to complete this implementation, the generation
 74 *       of this access width must be deferred until the region length has
 75 *       been evaluated.
 76 *
 77 ******************************************************************************/
 78
 79static u32
 80acpi_ex_generate_access (
 81	u32                             field_bit_offset,
 82	u32                             field_bit_length,
 83	u32                             region_length)
 84{
 85	u32                             field_byte_length;
 86	u32                             field_byte_offset;
 87	u32                             field_byte_end_offset;
 88	u32                             access_byte_width;
 89	u32                             field_start_offset;
 90	u32                             field_end_offset;
 91	u32                             minimum_access_width = 0xFFFFFFFF;
 92	u32                             minimum_accesses = 0xFFFFFFFF;
 93	u32                             accesses;
 94
 95
 96	ACPI_FUNCTION_TRACE ("ex_generate_access");
 97
 98
 99	/* Round Field start offset and length to "minimal" byte boundaries */
100
101	field_byte_offset  = ACPI_DIV_8 (ACPI_ROUND_DOWN (field_bit_offset, 8));
102	field_byte_end_offset = ACPI_DIV_8 (ACPI_ROUND_UP (field_bit_length + field_bit_offset, 8));
103	field_byte_length  = field_byte_end_offset - field_byte_offset;
104
105	ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
106			"Bit length %d, Bit offset %d\n",
107			field_bit_length, field_bit_offset));
108	ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
109			"Byte Length %d, Byte Offset %d, End Offset %d\n",
110			field_byte_length, field_byte_offset, field_byte_end_offset));
111
112	/*
113	 * Iterative search for the maximum access width that is both aligned
114	 * and does not go beyond the end of the region
115	 *
116	 * Start at byte_acc and work upwards to qword_acc max. (1,2,4,8 bytes)
117	 */
118	for (access_byte_width = 1; access_byte_width <= 8; access_byte_width <<= 1) {
119		/*
120		 * 1) Round end offset up to next access boundary and make sure that this
121		 *    does not go beyond the end of the parent region.
122		 * 2) When the Access width is greater than the field_byte_length, we are done.
123		 *    (This does not optimize for the perfectly aligned case yet).
124		 */
125		if (ACPI_ROUND_UP (field_byte_end_offset, access_byte_width) <= region_length) {
126			field_start_offset = ACPI_ROUND_DOWN (field_byte_offset, access_byte_width) /
127					  access_byte_width;
128			field_end_offset = ACPI_ROUND_UP   ((field_byte_length + field_byte_offset),
129					  access_byte_width) / access_byte_width;
130			accesses         = field_end_offset - field_start_offset;
131
132			ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
133					"access_width %d end is within region\n", access_byte_width));
134			ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
135					"Field Start %d, Field End %d -- requires %d accesses\n",
136					field_start_offset, field_end_offset, accesses));
137
138			/* Single access is optimal */
139
140			if (accesses <= 1) {
141				ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
142						"Entire field can be accessed with one operation of size %d\n",
143						access_byte_width));
144				return_VALUE (access_byte_width);
145			}
146
147			/*
148			 * Fits in the region, but requires more than one read/write.
149			 * try the next wider access on next iteration
150			 */
151			if (accesses < minimum_accesses) {
152				minimum_accesses   = accesses;
153				minimum_access_width = access_byte_width;
154			}
155		}
156		else {
157			ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
158					"access_width %d end is NOT within region\n", access_byte_width));
159			if (access_byte_width == 1) {
160				ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
161						"Field goes beyond end-of-region!\n"));
162				return_VALUE (0);     /* Field does not fit in the region at all */
163			}
164
165			/* This width goes beyond the end-of-region, back off to previous access */
166
167			ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
168					"Backing off to previous optimal access width of %d\n",
169					minimum_access_width));
170			return_VALUE (minimum_access_width);
171		}
172	}
173
174	/* Could not read/write field with one operation, just use max access width */
175
176	ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
177			"Cannot access field in one operation, using width 8\n"));
178	return_VALUE (8);
179}
180#endif /* ACPI_UNDER_DEVELOPMENT */
181
182
183/*******************************************************************************
184 *
185 * FUNCTION:    acpi_ex_decode_field_access
186 *
187 * PARAMETERS:  Access          - Encoded field access bits
188 *              Length          - Field length.
189 *
190 * RETURN:      Field granularity (8, 16, 32 or 64) and
191 *              byte_alignment (1, 2, 3, or 4)
192 *
193 * DESCRIPTION: Decode the access_type bits of a field definition.
194 *
195 ******************************************************************************/
196
197static u32
198acpi_ex_decode_field_access (
199	union acpi_operand_object       *obj_desc,
200	u8                              field_flags,
201	u32                             *return_byte_alignment)
202{
203	u32                             access;
204	u32                             byte_alignment;
205	u32                             bit_length;
206
207
208	ACPI_FUNCTION_TRACE ("ex_decode_field_access");
209
210
211	access = (field_flags & AML_FIELD_ACCESS_TYPE_MASK);
212
213	switch (access) {
214	case AML_FIELD_ACCESS_ANY:
215
216#ifdef ACPI_UNDER_DEVELOPMENT
217		byte_alignment = acpi_ex_generate_access (obj_desc->common_field.start_field_bit_offset,
218				 obj_desc->common_field.bit_length,
219				 0xFFFFFFFF /* Temp until we pass region_length as param */);
220		bit_length = byte_alignment * 8;
221#endif
222
223		byte_alignment = 1;
224		bit_length = 8;
225		break;
226
227	case AML_FIELD_ACCESS_BYTE:
228	case AML_FIELD_ACCESS_BUFFER:   /* ACPI 2.0 (SMBus Buffer) */
229		byte_alignment = 1;
230		bit_length    = 8;
231		break;
232
233	case AML_FIELD_ACCESS_WORD:
234		byte_alignment = 2;
235		bit_length    = 16;
236		break;
237
238	case AML_FIELD_ACCESS_DWORD:
239		byte_alignment = 4;
240		bit_length    = 32;
241		break;
242
243	case AML_FIELD_ACCESS_QWORD:    /* ACPI 2.0 */
244		byte_alignment = 8;
245		bit_length    = 64;
246		break;
247
248	default:
249		/* Invalid field access type */
250
251		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
252			"Unknown field access type %X\n",
253			access));
254		return_VALUE (0);
255	}
256
257	if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_BUFFER_FIELD) {
258		/*
259		 * buffer_field access can be on any byte boundary, so the
260		 * byte_alignment is always 1 byte -- regardless of any byte_alignment
261		 * implied by the field access type.
262		 */
263		byte_alignment = 1;
264	}
265
266	*return_byte_alignment = byte_alignment;
267	return_VALUE (bit_length);
268}
269
270
271/*******************************************************************************
272 *
273 * FUNCTION:    acpi_ex_prep_common_field_object
274 *
275 * PARAMETERS:  obj_desc            - The field object
276 *              field_flags         - Access, lock_rule, and update_rule.
277 *                                    The format of a field_flag is described
278 *                                    in the ACPI specification
279 *              field_bit_position  - Field start position
280 *              field_bit_length    - Field length in number of bits
281 *
282 * RETURN:      Status
283 *
284 * DESCRIPTION: Initialize the areas of the field object that are common
285 *              to the various types of fields.  Note: This is very "sensitive"
286 *              code because we are solving the general case for field
287 *              alignment.
288 *
289 ******************************************************************************/
290
291acpi_status
292acpi_ex_prep_common_field_object (
293	union acpi_operand_object       *obj_desc,
294	u8                              field_flags,
295	u8                              field_attribute,
296	u32                             field_bit_position,
297	u32                             field_bit_length)
298{
299	u32                             access_bit_width;
300	u32                             byte_alignment;
301	u32                             nearest_byte_address;
302
303
304	ACPI_FUNCTION_TRACE ("ex_prep_common_field_object");
305
306
307	/*
308	 * Note: the structure being initialized is the
309	 * ACPI_COMMON_FIELD_INFO;  No structure fields outside of the common
310	 * area are initialized by this procedure.
311	 */
312	obj_desc->common_field.field_flags = field_flags;
313	obj_desc->common_field.attribute = field_attribute;
314	obj_desc->common_field.bit_length = field_bit_length;
315
316	/*
317	 * Decode the access type so we can compute offsets.  The access type gives
318	 * two pieces of information - the width of each field access and the
319	 * necessary byte_alignment (address granularity) of the access.
320	 *
321	 * For any_acc, the access_bit_width is the largest width that is both
322	 * necessary and possible in an attempt to access the whole field in one
323	 * I/O operation.  However, for any_acc, the byte_alignment is always one
324	 * byte.
325	 *
326	 * For all Buffer Fields, the byte_alignment is always one byte.
327	 *
328	 * For all other access types (Byte, Word, Dword, Qword), the Bitwidth is
329	 * the same (equivalent) as the byte_alignment.
330	 */
331	access_bit_width = acpi_ex_decode_field_access (obj_desc, field_flags,
332			  &byte_alignment);
333	if (!access_bit_width) {
334		return_ACPI_STATUS (AE_AML_OPERAND_VALUE);
335	}
336
337	/* Setup width (access granularity) fields */
338
339	obj_desc->common_field.access_byte_width = (u8)
340			ACPI_DIV_8 (access_bit_width); /* 1, 2, 4,  8 */
341
342	obj_desc->common_field.access_bit_width = (u8) access_bit_width;
343
344	/*
345	 * base_byte_offset is the address of the start of the field within the
346	 * region.  It is the byte address of the first *datum* (field-width data
347	 * unit) of the field. (i.e., the first datum that contains at least the
348	 * first *bit* of the field.)
349	 *
350	 * Note: byte_alignment is always either equal to the access_bit_width or 8
351	 * (Byte access), and it defines the addressing granularity of the parent
352	 * region or buffer.
353	 */
354	nearest_byte_address =
355			ACPI_ROUND_BITS_DOWN_TO_BYTES (field_bit_position);
356	obj_desc->common_field.base_byte_offset = (u32)
357			ACPI_ROUND_DOWN (nearest_byte_address, byte_alignment);
358
359	/*
360	 * start_field_bit_offset is the offset of the first bit of the field within
361	 * a field datum.
362	 */
363	obj_desc->common_field.start_field_bit_offset = (u8)
364		(field_bit_position - ACPI_MUL_8 (obj_desc->common_field.base_byte_offset));
365
366	/*
367	 * Does the entire field fit within a single field access element? (datum)
368	 * (i.e., without crossing a datum boundary)
369	 */
370	if ((obj_desc->common_field.start_field_bit_offset + field_bit_length) <=
371			(u16) access_bit_width) {
372		obj_desc->common.flags |= AOPOBJ_SINGLE_DATUM;
373	}
374
375	return_ACPI_STATUS (AE_OK);
376}
377
378
379/*******************************************************************************
380 *
381 * FUNCTION:    acpi_ex_prep_field_value
382 *
383 * PARAMETERS:  Node                - Owning Node
384 *              region_node         - Region in which field is being defined
385 *              field_flags         - Access, lock_rule, and update_rule.
386 *              field_bit_position  - Field start position
387 *              field_bit_length    - Field length in number of bits
388 *
389 * RETURN:      Status
390 *
391 * DESCRIPTION: Construct an union acpi_operand_object of type def_field and
392 *              connect it to the parent Node.
393 *
394 ******************************************************************************/
395
396acpi_status
397acpi_ex_prep_field_value (
398	struct acpi_create_field_info   *info)
399{
400	union acpi_operand_object       *obj_desc;
401	u32                             type;
402	acpi_status                     status;
403
404
405	ACPI_FUNCTION_TRACE ("ex_prep_field_value");
406
407
408	/* Parameter validation */
409
410	if (info->field_type != ACPI_TYPE_LOCAL_INDEX_FIELD) {
411		if (!info->region_node) {
412			ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Null region_node\n"));
413			return_ACPI_STATUS (AE_AML_NO_OPERAND);
414		}
415
416		type = acpi_ns_get_type (info->region_node);
417		if (type != ACPI_TYPE_REGION) {
418			ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
419				"Needed Region, found type %X (%s)\n",
420				type, acpi_ut_get_type_name (type)));
421
422			return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
423		}
424	}
425
426	/* Allocate a new field object */
427
428	obj_desc = acpi_ut_create_internal_object (info->field_type);
429	if (!obj_desc) {
430		return_ACPI_STATUS (AE_NO_MEMORY);
431	}
432
433	/* Initialize areas of the object that are common to all fields */
434
435	obj_desc->common_field.node = info->field_node;
436	status = acpi_ex_prep_common_field_object (obj_desc, info->field_flags,
437			 info->attribute, info->field_bit_position, info->field_bit_length);
438	if (ACPI_FAILURE (status)) {
439		acpi_ut_delete_object_desc (obj_desc);
440		return_ACPI_STATUS (status);
441	}
442
443	/* Initialize areas of the object that are specific to the field type */
444
445	switch (info->field_type) {
446	case ACPI_TYPE_LOCAL_REGION_FIELD:
447
448		obj_desc->field.region_obj   = acpi_ns_get_attached_object (info->region_node);
449
450		/* An additional reference for the container */
451
452		acpi_ut_add_reference (obj_desc->field.region_obj);
453
454		ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
455			"region_field: bit_off %X, Off %X, Gran %X, Region %p\n",
456			obj_desc->field.start_field_bit_offset, obj_desc->field.base_byte_offset,
457			obj_desc->field.access_byte_width, obj_desc->field.region_obj));
458		break;
459
460
461	case ACPI_TYPE_LOCAL_BANK_FIELD:
462
463		obj_desc->bank_field.value   = info->bank_value;
464		obj_desc->bank_field.region_obj = acpi_ns_get_attached_object (info->region_node);
465		obj_desc->bank_field.bank_obj = acpi_ns_get_attached_object (info->register_node);
466
467		/* An additional reference for the attached objects */
468
469		acpi_ut_add_reference (obj_desc->bank_field.region_obj);
470		acpi_ut_add_reference (obj_desc->bank_field.bank_obj);
471
472		ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
473			"Bank Field: bit_off %X, Off %X, Gran %X, Region %p, bank_reg %p\n",
474			obj_desc->bank_field.start_field_bit_offset,
475			obj_desc->bank_field.base_byte_offset,
476			obj_desc->field.access_byte_width,
477			obj_desc->bank_field.region_obj,
478			obj_desc->bank_field.bank_obj));
479		break;
480
481
482	case ACPI_TYPE_LOCAL_INDEX_FIELD:
483
484		obj_desc->index_field.index_obj = acpi_ns_get_attached_object (info->register_node);
485		obj_desc->index_field.data_obj = acpi_ns_get_attached_object (info->data_register_node);
486		obj_desc->index_field.value  = (u32)
487			(info->field_bit_position / ACPI_MUL_8 (obj_desc->field.access_byte_width));
488
489		if (!obj_desc->index_field.data_obj || !obj_desc->index_field.index_obj) {
490			ACPI_REPORT_ERROR (("Null Index Object during field prep\n"));
491			acpi_ut_delete_object_desc (obj_desc);
492			return_ACPI_STATUS (AE_AML_INTERNAL);
493		}
494
495		/* An additional reference for the attached objects */
496
497		acpi_ut_add_reference (obj_desc->index_field.data_obj);
498		acpi_ut_add_reference (obj_desc->index_field.index_obj);
499
500		ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
501			"index_field: bit_off %X, Off %X, Value %X, Gran %X, Index %p, Data %p\n",
502			obj_desc->index_field.start_field_bit_offset,
503			obj_desc->index_field.base_byte_offset,
504			obj_desc->index_field.value,
505			obj_desc->field.access_byte_width,
506			obj_desc->index_field.index_obj,
507			obj_desc->index_field.data_obj));
508		break;
509
510	default:
511		/* No other types should get here */
512		break;
513	}
514
515	/*
516	 * Store the constructed descriptor (obj_desc) into the parent Node,
517	 * preserving the current type of that named_obj.
518	 */
519	status = acpi_ns_attach_object (info->field_node, obj_desc,
520			  acpi_ns_get_type (info->field_node));
521
522	ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set named_obj %p [%4.4s], obj_desc %p\n",
523			info->field_node, acpi_ut_get_node_name (info->field_node), obj_desc));
524
525	/* Remove local reference to the object */
526
527	acpi_ut_remove_reference (obj_desc);
528	return_ACPI_STATUS (status);
529}
530