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