aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/acpi/resources/rsmisc.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/acpi/resources/rsmisc.c')
-rw-r--r--drivers/acpi/resources/rsmisc.c856
1 files changed, 435 insertions, 421 deletions
diff --git a/drivers/acpi/resources/rsmisc.c b/drivers/acpi/resources/rsmisc.c
index 7a8a34e757f5..83bfe0dd3eba 100644
--- a/drivers/acpi/resources/rsmisc.c
+++ b/drivers/acpi/resources/rsmisc.c
@@ -5,7 +5,7 @@
5 ******************************************************************************/ 5 ******************************************************************************/
6 6
7/* 7/*
8 * Copyright (C) 2000 - 2005, R. Byron Moore 8 * Copyright (C) 2000 - 2006, R. Byron Moore
9 * All rights reserved. 9 * All rights reserved.
10 * 10 *
11 * Redistribution and use in source and binary forms, with or without 11 * Redistribution and use in source and binary forms, with or without
@@ -47,481 +47,495 @@
47#define _COMPONENT ACPI_RESOURCES 47#define _COMPONENT ACPI_RESOURCES
48ACPI_MODULE_NAME("rsmisc") 48ACPI_MODULE_NAME("rsmisc")
49 49
50#define INIT_RESOURCE_TYPE(i) i->resource_offset
51#define INIT_RESOURCE_LENGTH(i) i->aml_offset
52#define INIT_TABLE_LENGTH(i) i->value
53#define COMPARE_OPCODE(i) i->resource_offset
54#define COMPARE_TARGET(i) i->aml_offset
55#define COMPARE_VALUE(i) i->value
50/******************************************************************************* 56/*******************************************************************************
51 * 57 *
52 * FUNCTION: acpi_rs_end_tag_resource 58 * FUNCTION: acpi_rs_convert_aml_to_resource
53 * 59 *
54 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte 60 * PARAMETERS: Resource - Pointer to the resource descriptor
55 * stream 61 * Aml - Where the AML descriptor is returned
56 * bytes_consumed - Pointer to where the number of bytes 62 * Info - Pointer to appropriate conversion table
57 * consumed the byte_stream_buffer is
58 * returned
59 * output_buffer - Pointer to the return data buffer
60 * structure_size - Pointer to where the number of bytes
61 * in the return data struct is returned
62 * 63 *
63 * RETURN: Status 64 * RETURN: Status
64 * 65 *
65 * DESCRIPTION: Take the resource byte stream and fill out the appropriate 66 * DESCRIPTION: Convert an external AML resource descriptor to the corresponding
66 * structure pointed to by the output_buffer. Return the 67 * internal resource descriptor
67 * number of bytes consumed from the byte stream.
68 * 68 *
69 ******************************************************************************/ 69 ******************************************************************************/
70acpi_status 70acpi_status
71acpi_rs_end_tag_resource(u8 * byte_stream_buffer, 71acpi_rs_convert_aml_to_resource(struct acpi_resource *resource,
72 acpi_size * bytes_consumed, 72 union aml_resource *aml,
73 u8 ** output_buffer, acpi_size * structure_size) 73 struct acpi_rsconvert_info *info)
74{ 74{
75 struct acpi_resource *output_struct = (void *)*output_buffer; 75 acpi_rs_length aml_resource_length;
76 acpi_size struct_size = ACPI_RESOURCE_LENGTH; 76 void *source;
77 77 void *destination;
78 ACPI_FUNCTION_TRACE("rs_end_tag_resource"); 78 char *target;
79 79 u8 count;
80 /* The number of bytes consumed is static */ 80 u8 flags_mode = FALSE;
81 81 u16 item_count = 0;
82 *bytes_consumed = 2;
83
84 /* Fill out the structure */
85
86 output_struct->id = ACPI_RSTYPE_END_TAG;
87
88 /* Set the Length parameter */
89
90 output_struct->length = 0;
91
92 /* Return the final size of the structure */
93
94 *structure_size = struct_size;
95 return_ACPI_STATUS(AE_OK);
96}
97
98/*******************************************************************************
99 *
100 * FUNCTION: acpi_rs_end_tag_stream
101 *
102 * PARAMETERS: linked_list - Pointer to the resource linked list
103 * output_buffer - Pointer to the user's return buffer
104 * bytes_consumed - Pointer to where the number of bytes
105 * used in the output_buffer is returned
106 *
107 * RETURN: Status
108 *
109 * DESCRIPTION: Take the linked list resource structure and fills in the
110 * the appropriate bytes in a byte stream
111 *
112 ******************************************************************************/
113
114acpi_status
115acpi_rs_end_tag_stream(struct acpi_resource *linked_list,
116 u8 ** output_buffer, acpi_size * bytes_consumed)
117{
118 u8 *buffer = *output_buffer;
119 u8 temp8 = 0;
120
121 ACPI_FUNCTION_TRACE("rs_end_tag_stream");
122
123 /* The descriptor field is static */
124
125 *buffer = 0x79;
126 buffer += 1;
127
128 /*
129 * Set the Checksum - zero means that the resource data is treated as if
130 * the checksum operation succeeded (ACPI Spec 1.0b Section 6.4.2.8)
131 */
132 temp8 = 0;
133
134 *buffer = temp8;
135 buffer += 1;
136
137 /* Return the number of bytes consumed in this operation */
138
139 *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
140 return_ACPI_STATUS(AE_OK);
141}
142
143/*******************************************************************************
144 *
145 * FUNCTION: acpi_rs_vendor_resource
146 *
147 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte
148 * stream
149 * bytes_consumed - Pointer to where the number of bytes
150 * consumed the byte_stream_buffer is
151 * returned
152 * output_buffer - Pointer to the return data buffer
153 * structure_size - Pointer to where the number of bytes
154 * in the return data struct is returned
155 *
156 * RETURN: Status
157 *
158 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
159 * structure pointed to by the output_buffer. Return the
160 * number of bytes consumed from the byte stream.
161 *
162 ******************************************************************************/
163
164acpi_status
165acpi_rs_vendor_resource(u8 * byte_stream_buffer,
166 acpi_size * bytes_consumed,
167 u8 ** output_buffer, acpi_size * structure_size)
168{
169 u8 *buffer = byte_stream_buffer;
170 struct acpi_resource *output_struct = (void *)*output_buffer;
171 u16 temp16 = 0; 82 u16 temp16 = 0;
172 u8 temp8 = 0;
173 u8 index;
174 acpi_size struct_size =
175 ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor);
176
177 ACPI_FUNCTION_TRACE("rs_vendor_resource");
178
179 /* Dereference the Descriptor to find if this is a large or small item. */
180
181 temp8 = *buffer;
182
183 if (temp8 & 0x80) {
184 /* Large Item, point to the length field */
185
186 buffer += 1;
187
188 /* Dereference */
189 83
190 ACPI_MOVE_16_TO_16(&temp16, buffer); 84 ACPI_FUNCTION_TRACE("rs_get_resource");
191 85
192 /* Calculate bytes consumed */ 86 if (((acpi_native_uint) resource) & 0x3) {
193 87 acpi_os_printf
194 *bytes_consumed = (acpi_size) temp16 + 3; 88 ("**** GET: Misaligned resource pointer: %p Type %2.2X Len %X\n",
195 89 resource, resource->type, resource->length);
196 /* Point to the first vendor byte */
197
198 buffer += 2;
199 } else {
200 /* Small Item, dereference the size */
201
202 temp16 = (u8) (*buffer & 0x07);
203
204 /* Calculate bytes consumed */
205
206 *bytes_consumed = (acpi_size) temp16 + 1;
207
208 /* Point to the first vendor byte */
209
210 buffer += 1;
211 } 90 }
212 91
213 output_struct->id = ACPI_RSTYPE_VENDOR; 92 /* Extract the resource Length field (does not include header length) */
214 output_struct->data.vendor_specific.length = temp16;
215 93
216 for (index = 0; index < temp16; index++) { 94 aml_resource_length = acpi_ut_get_resource_length(aml);
217 output_struct->data.vendor_specific.reserved[index] = *buffer;
218 buffer += 1;
219 }
220 95
221 /* 96 /*
222 * In order for the struct_size to fall on a 32-bit boundary, 97 * First table entry must be ACPI_RSC_INITxxx and must contain the
223 * calculate the length of the vendor string and expand the 98 * table length (# of table entries)
224 * struct_size to the next 32-bit boundary.
225 */ 99 */
226 struct_size += ACPI_ROUND_UP_to_32_bITS(temp16); 100 count = INIT_TABLE_LENGTH(info);
227 101
228 /* Set the Length parameter */ 102 while (count) {
229 103 /*
230 output_struct->length = (u32) struct_size; 104 * Source is the external AML byte stream buffer,
231 105 * destination is the internal resource descriptor
232 /* Return the final size of the structure */ 106 */
233 107 source = ACPI_ADD_PTR(void, aml, info->aml_offset);
234 *structure_size = struct_size; 108 destination =
235 return_ACPI_STATUS(AE_OK); 109 ACPI_ADD_PTR(void, resource, info->resource_offset);
236} 110
237 111 switch (info->opcode) {
238/******************************************************************************* 112 case ACPI_RSC_INITGET:
239 * 113 /*
240 * FUNCTION: acpi_rs_vendor_stream 114 * Get the resource type and the initial (minimum) length
241 * 115 */
242 * PARAMETERS: linked_list - Pointer to the resource linked list 116 ACPI_MEMSET(resource, 0, INIT_RESOURCE_LENGTH(info));
243 * output_buffer - Pointer to the user's return buffer 117 resource->type = INIT_RESOURCE_TYPE(info);
244 * bytes_consumed - Pointer to where the number of bytes 118 resource->length = INIT_RESOURCE_LENGTH(info);
245 * used in the output_buffer is returned 119 break;
246 * 120
247 * RETURN: Status 121 case ACPI_RSC_INITSET:
248 * 122 break;
249 * DESCRIPTION: Take the linked list resource structure and fills in the 123
250 * the appropriate bytes in a byte stream 124 case ACPI_RSC_FLAGINIT:
251 * 125
252 ******************************************************************************/ 126 flags_mode = TRUE;
253 127 break;
254acpi_status 128
255acpi_rs_vendor_stream(struct acpi_resource *linked_list, 129 case ACPI_RSC_1BITFLAG:
256 u8 ** output_buffer, acpi_size * bytes_consumed) 130 /*
257{ 131 * Mask and shift the flag bit
258 u8 *buffer = *output_buffer; 132 */
259 u16 temp16 = 0; 133 ACPI_SET8(destination) = (u8)
260 u8 temp8 = 0; 134 ((ACPI_GET8(source) >> info->value) & 0x01);
261 u8 index; 135 break;
262 136
263 ACPI_FUNCTION_TRACE("rs_vendor_stream"); 137 case ACPI_RSC_2BITFLAG:
264 138 /*
265 /* Dereference the length to find if this is a large or small item. */ 139 * Mask and shift the flag bits
266 140 */
267 if (linked_list->data.vendor_specific.length > 7) { 141 ACPI_SET8(destination) = (u8)
268 /* Large Item, Set the descriptor field and length bytes */ 142 ((ACPI_GET8(source) >> info->value) & 0x03);
269 143 break;
270 *buffer = 0x84; 144
271 buffer += 1; 145 case ACPI_RSC_COUNT:
272 146
273 temp16 = (u16) linked_list->data.vendor_specific.length; 147 item_count = ACPI_GET8(source);
274 148 ACPI_SET8(destination) = (u8) item_count;
275 ACPI_MOVE_16_TO_16(buffer, &temp16); 149
276 buffer += 2; 150 resource->length = resource->length +
277 } else { 151 (info->value * (item_count - 1));
278 /* Small Item, Set the descriptor field */ 152 break;
279 153
280 temp8 = 0x70; 154 case ACPI_RSC_COUNT16:
281 temp8 |= (u8) linked_list->data.vendor_specific.length; 155
156 item_count = aml_resource_length;
157 ACPI_SET16(destination) = item_count;
158
159 resource->length = resource->length +
160 (info->value * (item_count - 1));
161 break;
162
163 case ACPI_RSC_LENGTH:
164
165 resource->length = resource->length + info->value;
166 break;
167
168 case ACPI_RSC_MOVE8:
169 case ACPI_RSC_MOVE16:
170 case ACPI_RSC_MOVE32:
171 case ACPI_RSC_MOVE64:
172 /*
173 * Raw data move. Use the Info value field unless item_count has
174 * been previously initialized via a COUNT opcode
175 */
176 if (info->value) {
177 item_count = info->value;
178 }
179 acpi_rs_move_data(destination, source, item_count,
180 info->opcode);
181 break;
182
183 case ACPI_RSC_SET8:
184
185 ACPI_MEMSET(destination, info->aml_offset, info->value);
186 break;
187
188 case ACPI_RSC_DATA8:
189
190 target = ACPI_ADD_PTR(char, resource, info->value);
191 ACPI_MEMCPY(destination, source, ACPI_GET16(target));
192 break;
193
194 case ACPI_RSC_ADDRESS:
195 /*
196 * Common handler for address descriptor flags
197 */
198 if (!acpi_rs_get_address_common(resource, aml)) {
199 return_ACPI_STATUS
200 (AE_AML_INVALID_RESOURCE_TYPE);
201 }
202 break;
203
204 case ACPI_RSC_SOURCE:
205 /*
206 * Optional resource_source (Index and String)
207 */
208 resource->length +=
209 acpi_rs_get_resource_source(aml_resource_length,
210 info->value,
211 destination, aml, NULL);
212 break;
213
214 case ACPI_RSC_SOURCEX:
215 /*
216 * Optional resource_source (Index and String). This is the more
217 * complicated case used by the Interrupt() macro
218 */
219 target =
220 ACPI_ADD_PTR(char, resource,
221 info->aml_offset + (item_count * 4));
222
223 resource->length +=
224 acpi_rs_get_resource_source(aml_resource_length,
225 (acpi_rs_length) (((item_count - 1) * sizeof(u32)) + info->value), destination, aml, target);
226 break;
227
228 case ACPI_RSC_BITMASK:
229 /*
230 * 8-bit encoded bitmask (DMA macro)
231 */
232 item_count =
233 acpi_rs_decode_bitmask(ACPI_GET8(source),
234 destination);
235 if (item_count) {
236 resource->length += (item_count - 1);
237 }
238
239 target = ACPI_ADD_PTR(char, resource, info->value);
240 ACPI_SET8(target) = (u8) item_count;
241 break;
242
243 case ACPI_RSC_BITMASK16:
244 /*
245 * 16-bit encoded bitmask (IRQ macro)
246 */
247 ACPI_MOVE_16_TO_16(&temp16, source);
248
249 item_count =
250 acpi_rs_decode_bitmask(temp16, destination);
251 if (item_count) {
252 resource->length += (item_count - 1);
253 }
254
255 target = ACPI_ADD_PTR(char, resource, info->value);
256 ACPI_SET8(target) = (u8) item_count;
257 break;
258
259 case ACPI_RSC_EXIT_NE:
260 /*
261 * Control - Exit conversion if not equal
262 */
263 switch (info->resource_offset) {
264 case ACPI_RSC_COMPARE_AML_LENGTH:
265 if (aml_resource_length != info->value) {
266 goto exit;
267 }
268 break;
269
270 case ACPI_RSC_COMPARE_VALUE:
271 if (ACPI_GET8(source) != info->value) {
272 goto exit;
273 }
274 break;
275
276 default:
277 acpi_os_printf
278 ("*** Invalid conversion sub-opcode\n");
279 return_ACPI_STATUS(AE_BAD_PARAMETER);
280 }
281 break;
282
283 default:
284
285 acpi_os_printf("*** Invalid conversion opcode\n");
286 return_ACPI_STATUS(AE_BAD_PARAMETER);
287 }
282 288
283 *buffer = temp8; 289 count--;
284 buffer += 1; 290 info++;
285 } 291 }
286 292
287 /* Loop through all of the Vendor Specific fields */ 293 exit:
294 if (!flags_mode) {
295 /* Round the resource struct length up to the next 32-bit boundary */
288 296
289 for (index = 0; index < linked_list->data.vendor_specific.length; 297 resource->length = ACPI_ROUND_UP_to_32_bITS(resource->length);
290 index++) {
291 temp8 = linked_list->data.vendor_specific.reserved[index];
292
293 *buffer = temp8;
294 buffer += 1;
295 } 298 }
296
297 /* Return the number of bytes consumed in this operation */
298
299 *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
300 return_ACPI_STATUS(AE_OK); 299 return_ACPI_STATUS(AE_OK);
301} 300}
302 301
303/******************************************************************************* 302/*******************************************************************************
304 * 303 *
305 * FUNCTION: acpi_rs_start_depend_fns_resource 304 * FUNCTION: acpi_rs_convert_resource_to_aml
306 * 305 *
307 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte 306 * PARAMETERS: Resource - Pointer to the resource descriptor
308 * stream 307 * Aml - Where the AML descriptor is returned
309 * bytes_consumed - Pointer to where the number of bytes 308 * Info - Pointer to appropriate conversion table
310 * consumed the byte_stream_buffer is
311 * returned
312 * output_buffer - Pointer to the return data buffer
313 * structure_size - Pointer to where the number of bytes
314 * in the return data struct is returned
315 * 309 *
316 * RETURN: Status 310 * RETURN: Status
317 * 311 *
318 * DESCRIPTION: Take the resource byte stream and fill out the appropriate 312 * DESCRIPTION: Convert an internal resource descriptor to the corresponding
319 * structure pointed to by the output_buffer. Return the 313 * external AML resource descriptor.
320 * number of bytes consumed from the byte stream.
321 * 314 *
322 ******************************************************************************/ 315 ******************************************************************************/
323 316
324acpi_status 317acpi_status
325acpi_rs_start_depend_fns_resource(u8 * byte_stream_buffer, 318acpi_rs_convert_resource_to_aml(struct acpi_resource *resource,
326 acpi_size * bytes_consumed, 319 union aml_resource *aml,
327 u8 ** output_buffer, 320 struct acpi_rsconvert_info *info)
328 acpi_size * structure_size)
329{ 321{
330 u8 *buffer = byte_stream_buffer; 322 void *source = NULL;
331 struct acpi_resource *output_struct = (void *)*output_buffer; 323 void *destination;
332 u8 temp8 = 0; 324 acpi_rsdesc_size aml_length = 0;
333 acpi_size struct_size = 325 u8 count;
334 ACPI_SIZEOF_RESOURCE(struct acpi_resource_start_dpf); 326 u16 temp16 = 0;
335 327 u16 item_count = 0;
336 ACPI_FUNCTION_TRACE("rs_start_depend_fns_resource");
337
338 /* The number of bytes consumed are found in the descriptor (Bits:0-1) */
339
340 temp8 = *buffer;
341
342 *bytes_consumed = (temp8 & 0x01) + 1;
343
344 output_struct->id = ACPI_RSTYPE_START_DPF;
345
346 /* Point to Byte 1 if it is used */
347
348 if (2 == *bytes_consumed) {
349 buffer += 1;
350 temp8 = *buffer;
351
352 /* Check Compatibility priority */
353
354 output_struct->data.start_dpf.compatibility_priority =
355 temp8 & 0x03;
356
357 if (3 == output_struct->data.start_dpf.compatibility_priority) {
358 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
359 }
360
361 /* Check Performance/Robustness preference */
362 328
363 output_struct->data.start_dpf.performance_robustness = 329 ACPI_FUNCTION_TRACE("rs_convert_resource_to_aml");
364 (temp8 >> 2) & 0x03;
365 330
366 if (3 == output_struct->data.start_dpf.performance_robustness) { 331 /*
367 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE); 332 * First table entry must be ACPI_RSC_INITxxx and must contain the
333 * table length (# of table entries)
334 */
335 count = INIT_TABLE_LENGTH(info);
336
337 while (count) {
338 /*
339 * Source is the internal resource descriptor,
340 * destination is the external AML byte stream buffer
341 */
342 source = ACPI_ADD_PTR(void, resource, info->resource_offset);
343 destination = ACPI_ADD_PTR(void, aml, info->aml_offset);
344
345 switch (info->opcode) {
346 case ACPI_RSC_INITSET:
347
348 ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info));
349 aml_length = INIT_RESOURCE_LENGTH(info);
350 acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
351 aml_length, aml);
352 break;
353
354 case ACPI_RSC_INITGET:
355 break;
356
357 case ACPI_RSC_FLAGINIT:
358 /*
359 * Clear the flag byte
360 */
361 ACPI_SET8(destination) = 0;
362 break;
363
364 case ACPI_RSC_1BITFLAG:
365 /*
366 * Mask and shift the flag bit
367 */
368 ACPI_SET8(destination) |= (u8)
369 ((ACPI_GET8(source) & 0x01) << info->value);
370 break;
371
372 case ACPI_RSC_2BITFLAG:
373 /*
374 * Mask and shift the flag bits
375 */
376 ACPI_SET8(destination) |= (u8)
377 ((ACPI_GET8(source) & 0x03) << info->value);
378 break;
379
380 case ACPI_RSC_COUNT:
381
382 item_count = ACPI_GET8(source);
383 ACPI_SET8(destination) = (u8) item_count;
384
385 aml_length =
386 (u16) (aml_length +
387 (info->value * (item_count - 1)));
388 break;
389
390 case ACPI_RSC_COUNT16:
391
392 item_count = ACPI_GET16(source);
393 aml_length = (u16) (aml_length + item_count);
394 acpi_rs_set_resource_length(aml_length, aml);
395 break;
396
397 case ACPI_RSC_LENGTH:
398
399 acpi_rs_set_resource_length(info->value, aml);
400 break;
401
402 case ACPI_RSC_MOVE8:
403 case ACPI_RSC_MOVE16:
404 case ACPI_RSC_MOVE32:
405 case ACPI_RSC_MOVE64:
406
407 if (info->value) {
408 item_count = info->value;
409 }
410 acpi_rs_move_data(destination, source, item_count,
411 info->opcode);
412 break;
413
414 case ACPI_RSC_ADDRESS:
415
416 /* Set the Resource Type, General Flags, and Type-Specific Flags */
417
418 acpi_rs_set_address_common(aml, resource);
419 break;
420
421 case ACPI_RSC_SOURCEX:
422 /*
423 * Optional resource_source (Index and String)
424 */
425 aml_length =
426 acpi_rs_set_resource_source(aml,
427 (acpi_rs_length)
428 aml_length, source);
429 acpi_rs_set_resource_length(aml_length, aml);
430 break;
431
432 case ACPI_RSC_SOURCE:
433 /*
434 * Optional resource_source (Index and String). This is the more
435 * complicated case used by the Interrupt() macro
436 */
437 aml_length =
438 acpi_rs_set_resource_source(aml, info->value,
439 source);
440 acpi_rs_set_resource_length(aml_length, aml);
441 break;
442
443 case ACPI_RSC_BITMASK:
444 /*
445 * 8-bit encoded bitmask (DMA macro)
446 */
447 ACPI_SET8(destination) = (u8)
448 acpi_rs_encode_bitmask(source,
449 *ACPI_ADD_PTR(u8, resource,
450 info->value));
451 break;
452
453 case ACPI_RSC_BITMASK16:
454 /*
455 * 16-bit encoded bitmask (IRQ macro)
456 */
457 temp16 = acpi_rs_encode_bitmask(source,
458 *ACPI_ADD_PTR(u8,
459 resource,
460 info->
461 value));
462 ACPI_MOVE_16_TO_16(destination, &temp16);
463 break;
464
465 case ACPI_RSC_EXIT_LE:
466 /*
467 * Control - Exit conversion if less than or equal
468 */
469 if (item_count <= info->value) {
470 goto exit;
471 }
472 break;
473
474 case ACPI_RSC_EXIT_NE:
475 /*
476 * Control - Exit conversion if not equal
477 */
478 switch (COMPARE_OPCODE(info)) {
479 case ACPI_RSC_COMPARE_VALUE:
480
481 if (*ACPI_ADD_PTR(u8, resource,
482 COMPARE_TARGET(info)) !=
483 COMPARE_VALUE(info)) {
484 goto exit;
485 }
486 break;
487
488 default:
489 acpi_os_printf
490 ("*** Invalid conversion sub-opcode\n");
491 return_ACPI_STATUS(AE_BAD_PARAMETER);
492 }
493 break;
494
495 default:
496
497 acpi_os_printf("*** Invalid conversion opcode\n");
498 return_ACPI_STATUS(AE_BAD_PARAMETER);
368 } 499 }
369 } else {
370 output_struct->data.start_dpf.compatibility_priority =
371 ACPI_ACCEPTABLE_CONFIGURATION;
372 500
373 output_struct->data.start_dpf.performance_robustness = 501 count--;
374 ACPI_ACCEPTABLE_CONFIGURATION; 502 info++;
375 } 503 }
376 504
377 /* Set the Length parameter */ 505 exit:
378
379 output_struct->length = (u32) struct_size;
380
381 /* Return the final size of the structure */
382
383 *structure_size = struct_size;
384 return_ACPI_STATUS(AE_OK); 506 return_ACPI_STATUS(AE_OK);
385} 507}
386 508
387/******************************************************************************* 509#if 0
388 * 510/* Previous resource validations */
389 * FUNCTION: acpi_rs_end_depend_fns_resource
390 *
391 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte
392 * stream
393 * bytes_consumed - Pointer to where the number of bytes
394 * consumed the byte_stream_buffer is
395 * returned
396 * output_buffer - Pointer to the return data buffer
397 * structure_size - Pointer to where the number of bytes
398 * in the return data struct is returned
399 *
400 * RETURN: Status
401 *
402 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
403 * structure pointed to by the output_buffer. Return the
404 * number of bytes consumed from the byte stream.
405 *
406 ******************************************************************************/
407
408acpi_status
409acpi_rs_end_depend_fns_resource(u8 * byte_stream_buffer,
410 acpi_size * bytes_consumed,
411 u8 ** output_buffer, acpi_size * structure_size)
412{
413 struct acpi_resource *output_struct = (void *)*output_buffer;
414 acpi_size struct_size = ACPI_RESOURCE_LENGTH;
415
416 ACPI_FUNCTION_TRACE("rs_end_depend_fns_resource");
417
418 /* The number of bytes consumed is static */
419
420 *bytes_consumed = 1;
421 511
422 /* Fill out the structure */ 512if (aml->ext_address64.revision_iD != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
423 513 return_ACPI_STATUS(AE_SUPPORT);
424 output_struct->id = ACPI_RSTYPE_END_DPF;
425
426 /* Set the Length parameter */
427
428 output_struct->length = (u32) struct_size;
429
430 /* Return the final size of the structure */
431
432 *structure_size = struct_size;
433 return_ACPI_STATUS(AE_OK);
434} 514}
435 515
436/******************************************************************************* 516if (resource->data.start_dpf.performance_robustness >= 3) {
437 * 517 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
438 * FUNCTION: acpi_rs_start_depend_fns_stream 518}
439 *
440 * PARAMETERS: linked_list - Pointer to the resource linked list
441 * output_buffer - Pointer to the user's return buffer
442 * bytes_consumed - u32 pointer that is filled with
443 * the number of bytes of the
444 * output_buffer used
445 *
446 * RETURN: Status
447 *
448 * DESCRIPTION: Take the linked list resource structure and fills in the
449 * the appropriate bytes in a byte stream
450 *
451 ******************************************************************************/
452
453acpi_status
454acpi_rs_start_depend_fns_stream(struct acpi_resource *linked_list,
455 u8 ** output_buffer, acpi_size * bytes_consumed)
456{
457 u8 *buffer = *output_buffer;
458 u8 temp8 = 0;
459
460 ACPI_FUNCTION_TRACE("rs_start_depend_fns_stream");
461 519
520if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
462 /* 521 /*
463 * The descriptor field is set based upon whether a byte is needed 522 * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
464 * to contain Priority data. 523 * polarity/trigger interrupts are allowed (ACPI spec, section
524 * "IRQ Format"), so 0x00 and 0x09 are illegal.
465 */ 525 */
466 if (ACPI_ACCEPTABLE_CONFIGURATION == 526 ACPI_REPORT_ERROR(("Invalid interrupt polarity/trigger in resource list, %X\n", aml->irq.flags));
467 linked_list->data.start_dpf.compatibility_priority && 527 return_ACPI_STATUS(AE_BAD_DATA);
468 ACPI_ACCEPTABLE_CONFIGURATION ==
469 linked_list->data.start_dpf.performance_robustness) {
470 *buffer = 0x30;
471 } else {
472 *buffer = 0x31;
473 buffer += 1;
474
475 /* Set the Priority Byte Definition */
476
477 temp8 = 0;
478 temp8 =
479 (u8) ((linked_list->data.start_dpf.
480 performance_robustness & 0x03) << 2);
481 temp8 |=
482 (linked_list->data.start_dpf.compatibility_priority & 0x03);
483 *buffer = temp8;
484 }
485
486 buffer += 1;
487
488 /* Return the number of bytes consumed in this operation */
489
490 *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer);
491 return_ACPI_STATUS(AE_OK);
492} 528}
493 529
494/******************************************************************************* 530resource->data.extended_irq.interrupt_count = temp8;
495 * 531if (temp8 < 1) {
496 * FUNCTION: acpi_rs_end_depend_fns_stream 532 /* Must have at least one IRQ */
497 *
498 * PARAMETERS: linked_list - Pointer to the resource linked list
499 * output_buffer - Pointer to the user's return buffer
500 * bytes_consumed - Pointer to where the number of bytes
501 * used in the output_buffer is returned
502 *
503 * RETURN: Status
504 *
505 * DESCRIPTION: Take the linked list resource structure and fills in the
506 * the appropriate bytes in a byte stream
507 *
508 ******************************************************************************/
509
510acpi_status
511acpi_rs_end_depend_fns_stream(struct acpi_resource *linked_list,
512 u8 ** output_buffer, acpi_size * bytes_consumed)
513{
514 u8 *buffer = *output_buffer;
515
516 ACPI_FUNCTION_TRACE("rs_end_depend_fns_stream");
517
518 /* The descriptor field is static */
519
520 *buffer = 0x38;
521 buffer += 1;
522 533
523 /* Return the number of bytes consumed in this operation */ 534 return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
535}
524 536
525 *bytes_consumed = ACPI_PTR_DIFF(buffer, *output_buffer); 537if (resource->data.dma.transfer == 0x03) {
526 return_ACPI_STATUS(AE_OK); 538 ACPI_REPORT_ERROR(("Invalid DMA.Transfer preference (3)\n"));
539 return_ACPI_STATUS(AE_BAD_DATA);
527} 540}
541#endif
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-22 21:25:50 -0500