Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /******************************************************************************* |
2 | * | |
3 | * Module Name: rsmisc - Miscellaneous resource descriptors | |
4 | * | |
5 | ******************************************************************************/ | |
6 | ||
7 | /* | |
75a44ce0 | 8 | * Copyright (C) 2000 - 2008, Intel Corp. |
1da177e4 LT |
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 | ||
1da177e4 LT |
44 | #include <acpi/acpi.h> |
45 | #include <acpi/acresrc.h> | |
46 | ||
47 | #define _COMPONENT ACPI_RESOURCES | |
4be44fcd | 48 | ACPI_MODULE_NAME("rsmisc") |
0897831b BM |
49 | #define INIT_RESOURCE_TYPE(i) i->resource_offset |
50 | #define INIT_RESOURCE_LENGTH(i) i->aml_offset | |
51 | #define INIT_TABLE_LENGTH(i) i->value | |
52 | #define COMPARE_OPCODE(i) i->resource_offset | |
53 | #define COMPARE_TARGET(i) i->aml_offset | |
54 | #define COMPARE_VALUE(i) i->value | |
bda663d3 RM |
55 | /******************************************************************************* |
56 | * | |
0897831b | 57 | * FUNCTION: acpi_rs_convert_aml_to_resource |
bda663d3 | 58 | * |
50eca3eb BM |
59 | * PARAMETERS: Resource - Pointer to the resource descriptor |
60 | * Aml - Where the AML descriptor is returned | |
0897831b | 61 | * Info - Pointer to appropriate conversion table |
bda663d3 RM |
62 | * |
63 | * RETURN: Status | |
64 | * | |
0897831b BM |
65 | * DESCRIPTION: Convert an external AML resource descriptor to the corresponding |
66 | * internal resource descriptor | |
1da177e4 LT |
67 | * |
68 | ******************************************************************************/ | |
1da177e4 | 69 | acpi_status |
0897831b BM |
70 | acpi_rs_convert_aml_to_resource(struct acpi_resource *resource, |
71 | union aml_resource *aml, | |
72 | struct acpi_rsconvert_info *info) | |
1da177e4 | 73 | { |
0897831b BM |
74 | acpi_rs_length aml_resource_length; |
75 | void *source; | |
76 | void *destination; | |
77 | char *target; | |
78 | u8 count; | |
79 | u8 flags_mode = FALSE; | |
80 | u16 item_count = 0; | |
81 | u16 temp16 = 0; | |
82 | ||
b229cf92 | 83 | ACPI_FUNCTION_TRACE(rs_convert_aml_to_resource); |
0897831b | 84 | |
67a119f9 | 85 | if (((acpi_size) resource) & 0x3) { |
52fc0b02 | 86 | |
b8e4d893 BM |
87 | /* Each internal resource struct is expected to be 32-bit aligned */ |
88 | ||
89 | ACPI_WARNING((AE_INFO, | |
90 | "Misaligned resource pointer (get): %p Type %2.2X Len %X", | |
91 | resource, resource->type, resource->length)); | |
0897831b | 92 | } |
44f6c012 | 93 | |
0897831b | 94 | /* Extract the resource Length field (does not include header length) */ |
1da177e4 | 95 | |
0897831b | 96 | aml_resource_length = acpi_ut_get_resource_length(aml); |
44f6c012 | 97 | |
0897831b BM |
98 | /* |
99 | * First table entry must be ACPI_RSC_INITxxx and must contain the | |
100 | * table length (# of table entries) | |
101 | */ | |
102 | count = INIT_TABLE_LENGTH(info); | |
103 | ||
104 | while (count) { | |
105 | /* | |
106 | * Source is the external AML byte stream buffer, | |
107 | * destination is the internal resource descriptor | |
108 | */ | |
c51a4de8 BM |
109 | source = ACPI_ADD_PTR(void, aml, info->aml_offset); |
110 | destination = | |
111 | ACPI_ADD_PTR(void, resource, info->resource_offset); | |
0897831b BM |
112 | |
113 | switch (info->opcode) { | |
114 | case ACPI_RSC_INITGET: | |
115 | /* | |
116 | * Get the resource type and the initial (minimum) length | |
117 | */ | |
118 | ACPI_MEMSET(resource, 0, INIT_RESOURCE_LENGTH(info)); | |
119 | resource->type = INIT_RESOURCE_TYPE(info); | |
120 | resource->length = INIT_RESOURCE_LENGTH(info); | |
121 | break; | |
122 | ||
123 | case ACPI_RSC_INITSET: | |
124 | break; | |
125 | ||
126 | case ACPI_RSC_FLAGINIT: | |
127 | ||
128 | flags_mode = TRUE; | |
129 | break; | |
130 | ||
131 | case ACPI_RSC_1BITFLAG: | |
132 | /* | |
133 | * Mask and shift the flag bit | |
134 | */ | |
c51a4de8 BM |
135 | ACPI_SET8(destination) = (u8) |
136 | ((ACPI_GET8(source) >> info->value) & 0x01); | |
0897831b BM |
137 | break; |
138 | ||
139 | case ACPI_RSC_2BITFLAG: | |
140 | /* | |
141 | * Mask and shift the flag bits | |
142 | */ | |
c51a4de8 BM |
143 | ACPI_SET8(destination) = (u8) |
144 | ((ACPI_GET8(source) >> info->value) & 0x03); | |
0897831b BM |
145 | break; |
146 | ||
147 | case ACPI_RSC_COUNT: | |
148 | ||
c51a4de8 BM |
149 | item_count = ACPI_GET8(source); |
150 | ACPI_SET8(destination) = (u8) item_count; | |
0897831b BM |
151 | |
152 | resource->length = resource->length + | |
153 | (info->value * (item_count - 1)); | |
154 | break; | |
155 | ||
156 | case ACPI_RSC_COUNT16: | |
157 | ||
158 | item_count = aml_resource_length; | |
c51a4de8 | 159 | ACPI_SET16(destination) = item_count; |
0897831b BM |
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 | ||
c51a4de8 BM |
192 | target = ACPI_ADD_PTR(char, resource, info->value); |
193 | ACPI_MEMCPY(destination, source, ACPI_GET16(target)); | |
0897831b BM |
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 = | |
c51a4de8 BM |
222 | ACPI_ADD_PTR(char, resource, |
223 | info->aml_offset + (item_count * 4)); | |
0897831b BM |
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 = | |
c51a4de8 | 235 | acpi_rs_decode_bitmask(ACPI_GET8(source), |
0897831b BM |
236 | destination); |
237 | if (item_count) { | |
c51a4de8 | 238 | resource->length += (item_count - 1); |
0897831b BM |
239 | } |
240 | ||
c51a4de8 BM |
241 | target = ACPI_ADD_PTR(char, resource, info->value); |
242 | ACPI_SET8(target) = (u8) item_count; | |
0897831b BM |
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) { | |
c51a4de8 | 254 | resource->length += (item_count - 1); |
0897831b BM |
255 | } |
256 | ||
c51a4de8 BM |
257 | target = ACPI_ADD_PTR(char, resource, info->value); |
258 | ACPI_SET8(target) = (u8) item_count; | |
0897831b BM |
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: | |
c51a4de8 | 273 | if (ACPI_GET8(source) != info->value) { |
0897831b BM |
274 | goto exit; |
275 | } | |
276 | break; | |
277 | ||
278 | default: | |
b8e4d893 BM |
279 | |
280 | ACPI_ERROR((AE_INFO, | |
281 | "Invalid conversion sub-opcode")); | |
0897831b BM |
282 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
283 | } | |
284 | break; | |
285 | ||
286 | default: | |
287 | ||
b8e4d893 | 288 | ACPI_ERROR((AE_INFO, "Invalid conversion opcode")); |
0897831b BM |
289 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
290 | } | |
1da177e4 | 291 | |
0897831b BM |
292 | count--; |
293 | info++; | |
50eca3eb | 294 | } |
44f6c012 | 295 | |
0897831b BM |
296 | exit: |
297 | if (!flags_mode) { | |
52fc0b02 | 298 | |
ea936b78 | 299 | /* Round the resource struct length up to the next boundary (32 or 64) */ |
44f6c012 | 300 | |
52fc0b02 | 301 | resource->length = |
ea936b78 | 302 | (u32) ACPI_ROUND_UP_TO_NATIVE_WORD(resource->length); |
0897831b | 303 | } |
4be44fcd | 304 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
305 | } |
306 | ||
1da177e4 LT |
307 | /******************************************************************************* |
308 | * | |
0897831b | 309 | * FUNCTION: acpi_rs_convert_resource_to_aml |
1da177e4 | 310 | * |
50eca3eb BM |
311 | * PARAMETERS: Resource - Pointer to the resource descriptor |
312 | * Aml - Where the AML descriptor is returned | |
0897831b | 313 | * Info - Pointer to appropriate conversion table |
1da177e4 LT |
314 | * |
315 | * RETURN: Status | |
316 | * | |
50eca3eb BM |
317 | * DESCRIPTION: Convert an internal resource descriptor to the corresponding |
318 | * external AML resource descriptor. | |
1da177e4 LT |
319 | * |
320 | ******************************************************************************/ | |
321 | ||
322 | acpi_status | |
0897831b BM |
323 | acpi_rs_convert_resource_to_aml(struct acpi_resource *resource, |
324 | union aml_resource *aml, | |
325 | struct acpi_rsconvert_info *info) | |
1da177e4 | 326 | { |
0897831b BM |
327 | void *source = NULL; |
328 | void *destination; | |
329 | acpi_rsdesc_size aml_length = 0; | |
330 | u8 count; | |
331 | u16 temp16 = 0; | |
332 | u16 item_count = 0; | |
1da177e4 | 333 | |
b229cf92 | 334 | ACPI_FUNCTION_TRACE(rs_convert_resource_to_aml); |
50eca3eb | 335 | |
0897831b BM |
336 | /* |
337 | * First table entry must be ACPI_RSC_INITxxx and must contain the | |
338 | * table length (# of table entries) | |
339 | */ | |
340 | count = INIT_TABLE_LENGTH(info); | |
341 | ||
342 | while (count) { | |
343 | /* | |
344 | * Source is the internal resource descriptor, | |
345 | * destination is the external AML byte stream buffer | |
346 | */ | |
c51a4de8 BM |
347 | source = ACPI_ADD_PTR(void, resource, info->resource_offset); |
348 | destination = ACPI_ADD_PTR(void, aml, info->aml_offset); | |
0897831b BM |
349 | |
350 | switch (info->opcode) { | |
351 | case ACPI_RSC_INITSET: | |
352 | ||
353 | ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info)); | |
354 | aml_length = INIT_RESOURCE_LENGTH(info); | |
355 | acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info), | |
356 | aml_length, aml); | |
357 | break; | |
358 | ||
359 | case ACPI_RSC_INITGET: | |
360 | break; | |
361 | ||
362 | case ACPI_RSC_FLAGINIT: | |
363 | /* | |
364 | * Clear the flag byte | |
365 | */ | |
c51a4de8 | 366 | ACPI_SET8(destination) = 0; |
0897831b BM |
367 | break; |
368 | ||
369 | case ACPI_RSC_1BITFLAG: | |
370 | /* | |
371 | * Mask and shift the flag bit | |
372 | */ | |
c51a4de8 BM |
373 | ACPI_SET8(destination) |= (u8) |
374 | ((ACPI_GET8(source) & 0x01) << info->value); | |
0897831b BM |
375 | break; |
376 | ||
377 | case ACPI_RSC_2BITFLAG: | |
378 | /* | |
379 | * Mask and shift the flag bits | |
380 | */ | |
c51a4de8 BM |
381 | ACPI_SET8(destination) |= (u8) |
382 | ((ACPI_GET8(source) & 0x03) << info->value); | |
0897831b BM |
383 | break; |
384 | ||
385 | case ACPI_RSC_COUNT: | |
386 | ||
c51a4de8 BM |
387 | item_count = ACPI_GET8(source); |
388 | ACPI_SET8(destination) = (u8) item_count; | |
0897831b | 389 | |
c51a4de8 BM |
390 | aml_length = |
391 | (u16) (aml_length + | |
392 | (info->value * (item_count - 1))); | |
0897831b BM |
393 | break; |
394 | ||
395 | case ACPI_RSC_COUNT16: | |
396 | ||
c51a4de8 | 397 | item_count = ACPI_GET16(source); |
0897831b BM |
398 | aml_length = (u16) (aml_length + item_count); |
399 | acpi_rs_set_resource_length(aml_length, aml); | |
400 | break; | |
401 | ||
402 | case ACPI_RSC_LENGTH: | |
403 | ||
404 | acpi_rs_set_resource_length(info->value, aml); | |
405 | break; | |
406 | ||
407 | case ACPI_RSC_MOVE8: | |
408 | case ACPI_RSC_MOVE16: | |
409 | case ACPI_RSC_MOVE32: | |
410 | case ACPI_RSC_MOVE64: | |
411 | ||
412 | if (info->value) { | |
413 | item_count = info->value; | |
414 | } | |
415 | acpi_rs_move_data(destination, source, item_count, | |
416 | info->opcode); | |
417 | break; | |
418 | ||
419 | case ACPI_RSC_ADDRESS: | |
420 | ||
421 | /* Set the Resource Type, General Flags, and Type-Specific Flags */ | |
422 | ||
423 | acpi_rs_set_address_common(aml, resource); | |
424 | break; | |
425 | ||
426 | case ACPI_RSC_SOURCEX: | |
427 | /* | |
428 | * Optional resource_source (Index and String) | |
429 | */ | |
430 | aml_length = | |
fd350943 | 431 | acpi_rs_set_resource_source(aml, (acpi_rs_length) |
0897831b BM |
432 | aml_length, source); |
433 | acpi_rs_set_resource_length(aml_length, aml); | |
434 | break; | |
435 | ||
436 | case ACPI_RSC_SOURCE: | |
437 | /* | |
438 | * Optional resource_source (Index and String). This is the more | |
439 | * complicated case used by the Interrupt() macro | |
440 | */ | |
441 | aml_length = | |
442 | acpi_rs_set_resource_source(aml, info->value, | |
443 | source); | |
444 | acpi_rs_set_resource_length(aml_length, aml); | |
445 | break; | |
446 | ||
447 | case ACPI_RSC_BITMASK: | |
448 | /* | |
449 | * 8-bit encoded bitmask (DMA macro) | |
450 | */ | |
c51a4de8 | 451 | ACPI_SET8(destination) = (u8) |
0897831b | 452 | acpi_rs_encode_bitmask(source, |
c51a4de8 BM |
453 | *ACPI_ADD_PTR(u8, resource, |
454 | info->value)); | |
0897831b BM |
455 | break; |
456 | ||
457 | case ACPI_RSC_BITMASK16: | |
458 | /* | |
459 | * 16-bit encoded bitmask (IRQ macro) | |
460 | */ | |
c51a4de8 BM |
461 | temp16 = acpi_rs_encode_bitmask(source, |
462 | *ACPI_ADD_PTR(u8, | |
463 | resource, | |
464 | info-> | |
465 | value)); | |
0897831b BM |
466 | ACPI_MOVE_16_TO_16(destination, &temp16); |
467 | break; | |
468 | ||
469 | case ACPI_RSC_EXIT_LE: | |
470 | /* | |
471 | * Control - Exit conversion if less than or equal | |
472 | */ | |
473 | if (item_count <= info->value) { | |
474 | goto exit; | |
475 | } | |
476 | break; | |
477 | ||
478 | case ACPI_RSC_EXIT_NE: | |
479 | /* | |
480 | * Control - Exit conversion if not equal | |
481 | */ | |
482 | switch (COMPARE_OPCODE(info)) { | |
483 | case ACPI_RSC_COMPARE_VALUE: | |
c51a4de8 BM |
484 | |
485 | if (*ACPI_ADD_PTR(u8, resource, | |
486 | COMPARE_TARGET(info)) != | |
0897831b BM |
487 | COMPARE_VALUE(info)) { |
488 | goto exit; | |
489 | } | |
490 | break; | |
491 | ||
492 | default: | |
b8e4d893 BM |
493 | |
494 | ACPI_ERROR((AE_INFO, | |
495 | "Invalid conversion sub-opcode")); | |
0897831b BM |
496 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
497 | } | |
498 | break; | |
499 | ||
1d5b285d BM |
500 | case ACPI_RSC_EXIT_EQ: |
501 | /* | |
502 | * Control - Exit conversion if equal | |
503 | */ | |
504 | if (*ACPI_ADD_PTR(u8, resource, | |
505 | COMPARE_TARGET(info)) == | |
506 | COMPARE_VALUE(info)) { | |
507 | goto exit; | |
508 | } | |
509 | break; | |
510 | ||
0897831b BM |
511 | default: |
512 | ||
b8e4d893 | 513 | ACPI_ERROR((AE_INFO, "Invalid conversion opcode")); |
0897831b | 514 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
50eca3eb | 515 | } |
1da177e4 | 516 | |
0897831b BM |
517 | count--; |
518 | info++; | |
1da177e4 LT |
519 | } |
520 | ||
0897831b | 521 | exit: |
4be44fcd | 522 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
523 | } |
524 | ||
0897831b BM |
525 | #if 0 |
526 | /* Previous resource validations */ | |
44f6c012 | 527 | |
0897831b BM |
528 | if (aml->ext_address64.revision_iD != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) { |
529 | return_ACPI_STATUS(AE_SUPPORT); | |
1da177e4 LT |
530 | } |
531 | ||
0897831b BM |
532 | if (resource->data.start_dpf.performance_robustness >= 3) { |
533 | return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE); | |
1da177e4 LT |
534 | } |
535 | ||
0897831b BM |
536 | if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) { |
537 | /* | |
538 | * Only [active_high, edge_sensitive] or [active_low, level_sensitive] | |
539 | * polarity/trigger interrupts are allowed (ACPI spec, section | |
540 | * "IRQ Format"), so 0x00 and 0x09 are illegal. | |
541 | */ | |
b8e4d893 BM |
542 | ACPI_ERROR((AE_INFO, |
543 | "Invalid interrupt polarity/trigger in resource list, %X", | |
544 | aml->irq.flags)); | |
0897831b | 545 | return_ACPI_STATUS(AE_BAD_DATA); |
1da177e4 LT |
546 | } |
547 | ||
0897831b BM |
548 | resource->data.extended_irq.interrupt_count = temp8; |
549 | if (temp8 < 1) { | |
52fc0b02 | 550 | |
0897831b | 551 | /* Must have at least one IRQ */ |
44f6c012 | 552 | |
0897831b | 553 | return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH); |
1da177e4 LT |
554 | } |
555 | ||
0897831b | 556 | if (resource->data.dma.transfer == 0x03) { |
b8e4d893 | 557 | ACPI_ERROR((AE_INFO, "Invalid DMA.Transfer preference (3)")); |
0897831b | 558 | return_ACPI_STATUS(AE_BAD_DATA); |
1da177e4 | 559 | } |
0897831b | 560 | #endif |