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