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 | ||
84 | ACPI_FUNCTION_TRACE("rs_get_resource"); | |
85 | ||
86 | if (((acpi_native_uint) resource) & 0x3) { | |
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) { | |
298 | /* Round the resource struct length up to the next 32-bit boundary */ | |
44f6c012 | 299 | |
0897831b BM |
300 | resource->length = ACPI_ROUND_UP_to_32_bITS(resource->length); |
301 | } | |
4be44fcd | 302 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
303 | } |
304 | ||
1da177e4 LT |
305 | /******************************************************************************* |
306 | * | |
0897831b | 307 | * FUNCTION: acpi_rs_convert_resource_to_aml |
1da177e4 | 308 | * |
50eca3eb BM |
309 | * PARAMETERS: Resource - Pointer to the resource descriptor |
310 | * Aml - Where the AML descriptor is returned | |
0897831b | 311 | * Info - Pointer to appropriate conversion table |
1da177e4 LT |
312 | * |
313 | * RETURN: Status | |
314 | * | |
50eca3eb BM |
315 | * DESCRIPTION: Convert an internal resource descriptor to the corresponding |
316 | * external AML resource descriptor. | |
1da177e4 LT |
317 | * |
318 | ******************************************************************************/ | |
319 | ||
320 | acpi_status | |
0897831b BM |
321 | acpi_rs_convert_resource_to_aml(struct acpi_resource *resource, |
322 | union aml_resource *aml, | |
323 | struct acpi_rsconvert_info *info) | |
1da177e4 | 324 | { |
0897831b BM |
325 | void *source = NULL; |
326 | void *destination; | |
327 | acpi_rsdesc_size aml_length = 0; | |
328 | u8 count; | |
329 | u16 temp16 = 0; | |
330 | u16 item_count = 0; | |
1da177e4 | 331 | |
0897831b | 332 | ACPI_FUNCTION_TRACE("rs_convert_resource_to_aml"); |
50eca3eb | 333 | |
0897831b BM |
334 | /* |
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 | */ | |
c51a4de8 BM |
345 | source = ACPI_ADD_PTR(void, resource, info->resource_offset); |
346 | destination = ACPI_ADD_PTR(void, aml, info->aml_offset); | |
0897831b BM |
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 | */ | |
c51a4de8 | 364 | ACPI_SET8(destination) = 0; |
0897831b BM |
365 | break; |
366 | ||
367 | case ACPI_RSC_1BITFLAG: | |
368 | /* | |
369 | * Mask and shift the flag bit | |
370 | */ | |
c51a4de8 BM |
371 | ACPI_SET8(destination) |= (u8) |
372 | ((ACPI_GET8(source) & 0x01) << info->value); | |
0897831b BM |
373 | break; |
374 | ||
375 | case ACPI_RSC_2BITFLAG: | |
376 | /* | |
377 | * Mask and shift the flag bits | |
378 | */ | |
c51a4de8 BM |
379 | ACPI_SET8(destination) |= (u8) |
380 | ((ACPI_GET8(source) & 0x03) << info->value); | |
0897831b BM |
381 | break; |
382 | ||
383 | case ACPI_RSC_COUNT: | |
384 | ||
c51a4de8 BM |
385 | item_count = ACPI_GET8(source); |
386 | ACPI_SET8(destination) = (u8) item_count; | |
0897831b | 387 | |
c51a4de8 BM |
388 | aml_length = |
389 | (u16) (aml_length + | |
390 | (info->value * (item_count - 1))); | |
0897831b BM |
391 | break; |
392 | ||
393 | case ACPI_RSC_COUNT16: | |
394 | ||
c51a4de8 | 395 | item_count = ACPI_GET16(source); |
0897831b BM |
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 | */ | |
c51a4de8 | 450 | ACPI_SET8(destination) = (u8) |
0897831b | 451 | acpi_rs_encode_bitmask(source, |
c51a4de8 BM |
452 | *ACPI_ADD_PTR(u8, resource, |
453 | info->value)); | |
0897831b BM |
454 | break; |
455 | ||
456 | case ACPI_RSC_BITMASK16: | |
457 | /* | |
458 | * 16-bit encoded bitmask (IRQ macro) | |
459 | */ | |
c51a4de8 BM |
460 | temp16 = acpi_rs_encode_bitmask(source, |
461 | *ACPI_ADD_PTR(u8, | |
462 | resource, | |
463 | info-> | |
464 | value)); | |
0897831b BM |
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: | |
c51a4de8 BM |
483 | |
484 | if (*ACPI_ADD_PTR(u8, resource, | |
485 | COMPARE_TARGET(info)) != | |
0897831b BM |
486 | COMPARE_VALUE(info)) { |
487 | goto exit; | |
488 | } | |
489 | break; | |
490 | ||
491 | default: | |
b8e4d893 BM |
492 | |
493 | ACPI_ERROR((AE_INFO, | |
494 | "Invalid conversion sub-opcode")); | |
0897831b BM |
495 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
496 | } | |
497 | break; | |
498 | ||
499 | default: | |
500 | ||
b8e4d893 | 501 | ACPI_ERROR((AE_INFO, "Invalid conversion opcode")); |
0897831b | 502 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
50eca3eb | 503 | } |
1da177e4 | 504 | |
0897831b BM |
505 | count--; |
506 | info++; | |
1da177e4 LT |
507 | } |
508 | ||
0897831b | 509 | exit: |
4be44fcd | 510 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
511 | } |
512 | ||
0897831b BM |
513 | #if 0 |
514 | /* Previous resource validations */ | |
44f6c012 | 515 | |
0897831b BM |
516 | if (aml->ext_address64.revision_iD != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) { |
517 | return_ACPI_STATUS(AE_SUPPORT); | |
1da177e4 LT |
518 | } |
519 | ||
0897831b BM |
520 | if (resource->data.start_dpf.performance_robustness >= 3) { |
521 | return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE); | |
1da177e4 LT |
522 | } |
523 | ||
0897831b BM |
524 | if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) { |
525 | /* | |
526 | * Only [active_high, edge_sensitive] or [active_low, level_sensitive] | |
527 | * polarity/trigger interrupts are allowed (ACPI spec, section | |
528 | * "IRQ Format"), so 0x00 and 0x09 are illegal. | |
529 | */ | |
b8e4d893 BM |
530 | ACPI_ERROR((AE_INFO, |
531 | "Invalid interrupt polarity/trigger in resource list, %X", | |
532 | aml->irq.flags)); | |
0897831b | 533 | return_ACPI_STATUS(AE_BAD_DATA); |
1da177e4 LT |
534 | } |
535 | ||
0897831b BM |
536 | resource->data.extended_irq.interrupt_count = temp8; |
537 | if (temp8 < 1) { | |
538 | /* Must have at least one IRQ */ | |
44f6c012 | 539 | |
0897831b | 540 | return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH); |
1da177e4 LT |
541 | } |
542 | ||
0897831b | 543 | if (resource->data.dma.transfer == 0x03) { |
b8e4d893 | 544 | ACPI_ERROR((AE_INFO, "Invalid DMA.Transfer preference (3)")); |
0897831b | 545 | return_ACPI_STATUS(AE_BAD_DATA); |
1da177e4 | 546 | } |
0897831b | 547 | #endif |