blob: d16be44b5df7c1390c049062edc9a77c8d57a60c [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*******************************************************************************
2 *
3 * Module Name: rsmisc - Miscellaneous resource descriptors
4 *
5 ******************************************************************************/
6
7/*
8 * Copyright (C) 2000 - 2005, R. Byron Moore
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
44
45#include <acpi/acpi.h>
46#include <acpi/acresrc.h>
47
48#define _COMPONENT ACPI_RESOURCES
49 ACPI_MODULE_NAME ("rsmisc")
50
51
52/*******************************************************************************
53 *
54 * FUNCTION: acpi_rs_end_tag_resource
55 *
56 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte
57 * stream
58 * bytes_consumed - Pointer to where the number of bytes
59 * consumed the byte_stream_buffer is
60 * returned
61 * output_buffer - Pointer to the return data buffer
62 * structure_size - Pointer to where the number of bytes
63 * in the return data struct is returned
64 *
65 * RETURN: Status
66 *
67 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
68 * structure pointed to by the output_buffer. Return the
69 * number of bytes consumed from the byte stream.
70 *
71 ******************************************************************************/
72
73acpi_status
74acpi_rs_end_tag_resource (
75 u8 *byte_stream_buffer,
76 acpi_size *bytes_consumed,
77 u8 **output_buffer,
78 acpi_size *structure_size)
79{
80 struct acpi_resource *output_struct = (void *) *output_buffer;
81 acpi_size struct_size = ACPI_RESOURCE_LENGTH;
82
83
84 ACPI_FUNCTION_TRACE ("rs_end_tag_resource");
85
86
87 /*
88 * The number of bytes consumed is static
89 */
90 *bytes_consumed = 2;
91
92 /*
93 * Fill out the structure
94 */
95 output_struct->id = ACPI_RSTYPE_END_TAG;
96
97 /*
98 * Set the Length parameter
99 */
100 output_struct->length = 0;
101
102 /*
103 * Return the final size of the structure
104 */
105 *structure_size = struct_size;
106 return_ACPI_STATUS (AE_OK);
107}
108
109
110/*******************************************************************************
111 *
112 * FUNCTION: acpi_rs_end_tag_stream
113 *
114 * PARAMETERS: linked_list - Pointer to the resource linked list
115 * output_buffer - Pointer to the user's return buffer
116 * bytes_consumed - Pointer to where the number of bytes
117 * used in the output_buffer is returned
118 *
119 * RETURN: Status
120 *
121 * DESCRIPTION: Take the linked list resource structure and fills in the
122 * the appropriate bytes in a byte stream
123 *
124 ******************************************************************************/
125
126acpi_status
127acpi_rs_end_tag_stream (
128 struct acpi_resource *linked_list,
129 u8 **output_buffer,
130 acpi_size *bytes_consumed)
131{
132 u8 *buffer = *output_buffer;
133 u8 temp8 = 0;
134
135
136 ACPI_FUNCTION_TRACE ("rs_end_tag_stream");
137
138
139 /*
140 * The descriptor field is static
141 */
142 *buffer = 0x79;
143 buffer += 1;
144
145 /*
146 * Set the Checksum - zero means that the resource data is treated as if
147 * the checksum operation succeeded (ACPI Spec 1.0b Section 6.4.2.8)
148 */
149 temp8 = 0;
150
151 *buffer = temp8;
152 buffer += 1;
153
154 /*
155 * Return the number of bytes consumed in this operation
156 */
157 *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer);
158 return_ACPI_STATUS (AE_OK);
159}
160
161
162/*******************************************************************************
163 *
164 * FUNCTION: acpi_rs_vendor_resource
165 *
166 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte
167 * stream
168 * bytes_consumed - Pointer to where the number of bytes
169 * consumed the byte_stream_buffer is
170 * returned
171 * output_buffer - Pointer to the return data buffer
172 * structure_size - Pointer to where the number of bytes
173 * in the return data struct is returned
174 *
175 * RETURN: Status
176 *
177 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
178 * structure pointed to by the output_buffer. Return the
179 * number of bytes consumed from the byte stream.
180 *
181 ******************************************************************************/
182
183acpi_status
184acpi_rs_vendor_resource (
185 u8 *byte_stream_buffer,
186 acpi_size *bytes_consumed,
187 u8 **output_buffer,
188 acpi_size *structure_size)
189{
190 u8 *buffer = byte_stream_buffer;
191 struct acpi_resource *output_struct = (void *) *output_buffer;
192 u16 temp16 = 0;
193 u8 temp8 = 0;
194 u8 index;
195 acpi_size struct_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_vendor);
196
197
198 ACPI_FUNCTION_TRACE ("rs_vendor_resource");
199
200
201 /*
202 * Dereference the Descriptor to find if this is a large or small item.
203 */
204 temp8 = *buffer;
205
206 if (temp8 & 0x80) {
207 /*
208 * Large Item, point to the length field
209 */
210 buffer += 1;
211
212 /* Dereference */
213
214 ACPI_MOVE_16_TO_16 (&temp16, buffer);
215
216 /* Calculate bytes consumed */
217
218 *bytes_consumed = (acpi_size) temp16 + 3;
219
220 /* Point to the first vendor byte */
221
222 buffer += 2;
223 }
224 else {
225 /*
226 * Small Item, dereference the size
227 */
228 temp16 = (u8)(*buffer & 0x07);
229
230 /* Calculate bytes consumed */
231
232 *bytes_consumed = (acpi_size) temp16 + 1;
233
234 /* Point to the first vendor byte */
235
236 buffer += 1;
237 }
238
239 output_struct->id = ACPI_RSTYPE_VENDOR;
240 output_struct->data.vendor_specific.length = temp16;
241
242 for (index = 0; index < temp16; index++) {
243 output_struct->data.vendor_specific.reserved[index] = *buffer;
244 buffer += 1;
245 }
246
247 /*
248 * In order for the struct_size to fall on a 32-bit boundary,
249 * calculate the length of the vendor string and expand the
250 * struct_size to the next 32-bit boundary.
251 */
252 struct_size += ACPI_ROUND_UP_to_32_bITS (temp16);
253
254 /*
255 * Set the Length parameter
256 */
257 output_struct->length = (u32) struct_size;
258
259 /*
260 * Return the final size of the structure
261 */
262 *structure_size = struct_size;
263 return_ACPI_STATUS (AE_OK);
264}
265
266
267/*******************************************************************************
268 *
269 * FUNCTION: acpi_rs_vendor_stream
270 *
271 * PARAMETERS: linked_list - Pointer to the resource linked list
272 * output_buffer - Pointer to the user's return buffer
273 * bytes_consumed - Pointer to where the number of bytes
274 * used in the output_buffer is returned
275 *
276 * RETURN: Status
277 *
278 * DESCRIPTION: Take the linked list resource structure and fills in the
279 * the appropriate bytes in a byte stream
280 *
281 ******************************************************************************/
282
283acpi_status
284acpi_rs_vendor_stream (
285 struct acpi_resource *linked_list,
286 u8 **output_buffer,
287 acpi_size *bytes_consumed)
288{
289 u8 *buffer = *output_buffer;
290 u16 temp16 = 0;
291 u8 temp8 = 0;
292 u8 index;
293
294
295 ACPI_FUNCTION_TRACE ("rs_vendor_stream");
296
297
298 /*
299 * Dereference the length to find if this is a large or small item.
300 */
301 if(linked_list->data.vendor_specific.length > 7) {
302 /*
303 * Large Item, Set the descriptor field and length bytes
304 */
305 *buffer = 0x84;
306 buffer += 1;
307
308 temp16 = (u16) linked_list->data.vendor_specific.length;
309
310 ACPI_MOVE_16_TO_16 (buffer, &temp16);
311 buffer += 2;
312 }
313 else {
314 /*
315 * Small Item, Set the descriptor field
316 */
317 temp8 = 0x70;
318 temp8 |= (u8) linked_list->data.vendor_specific.length;
319
320 *buffer = temp8;
321 buffer += 1;
322 }
323
324 /*
325 * Loop through all of the Vendor Specific fields
326 */
327 for (index = 0; index < linked_list->data.vendor_specific.length; index++) {
328 temp8 = linked_list->data.vendor_specific.reserved[index];
329
330 *buffer = temp8;
331 buffer += 1;
332 }
333
334 /*
335 * Return the number of bytes consumed in this operation
336 */
337 *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer);
338 return_ACPI_STATUS (AE_OK);
339}
340
341
342/*******************************************************************************
343 *
344 * FUNCTION: acpi_rs_start_depend_fns_resource
345 *
346 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte
347 * stream
348 * bytes_consumed - Pointer to where the number of bytes
349 * consumed the byte_stream_buffer is
350 * returned
351 * output_buffer - Pointer to the return data buffer
352 * structure_size - Pointer to where the number of bytes
353 * in the return data struct is returned
354 *
355 * RETURN: Status
356 *
357 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
358 * structure pointed to by the output_buffer. Return the
359 * number of bytes consumed from the byte stream.
360 *
361 ******************************************************************************/
362
363acpi_status
364acpi_rs_start_depend_fns_resource (
365 u8 *byte_stream_buffer,
366 acpi_size *bytes_consumed,
367 u8 **output_buffer,
368 acpi_size *structure_size)
369{
370 u8 *buffer = byte_stream_buffer;
371 struct acpi_resource *output_struct = (void *) *output_buffer;
372 u8 temp8 = 0;
373 acpi_size struct_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_start_dpf);
374
375
376 ACPI_FUNCTION_TRACE ("rs_start_depend_fns_resource");
377
378
379 /*
380 * The number of bytes consumed are contained in the descriptor (Bits:0-1)
381 */
382 temp8 = *buffer;
383
384 *bytes_consumed = (temp8 & 0x01) + 1;
385
386 output_struct->id = ACPI_RSTYPE_START_DPF;
387
388 /*
389 * Point to Byte 1 if it is used
390 */
391 if (2 == *bytes_consumed) {
392 buffer += 1;
393 temp8 = *buffer;
394
395 /*
396 * Check Compatibility priority
397 */
398 output_struct->data.start_dpf.compatibility_priority = temp8 & 0x03;
399
400 if (3 == output_struct->data.start_dpf.compatibility_priority) {
401 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_VALUE);
402 }
403
404 /*
405 * Check Performance/Robustness preference
406 */
407 output_struct->data.start_dpf.performance_robustness = (temp8 >> 2) & 0x03;
408
409 if (3 == output_struct->data.start_dpf.performance_robustness) {
410 return_ACPI_STATUS (AE_AML_BAD_RESOURCE_VALUE);
411 }
412 }
413 else {
414 output_struct->data.start_dpf.compatibility_priority =
415 ACPI_ACCEPTABLE_CONFIGURATION;
416
417 output_struct->data.start_dpf.performance_robustness =
418 ACPI_ACCEPTABLE_CONFIGURATION;
419 }
420
421 /*
422 * Set the Length parameter
423 */
424 output_struct->length = (u32) struct_size;
425
426 /*
427 * Return the final size of the structure
428 */
429 *structure_size = struct_size;
430 return_ACPI_STATUS (AE_OK);
431}
432
433
434/*******************************************************************************
435 *
436 * FUNCTION: acpi_rs_end_depend_fns_resource
437 *
438 * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte
439 * stream
440 * bytes_consumed - Pointer to where the number of bytes
441 * consumed the byte_stream_buffer is
442 * returned
443 * output_buffer - Pointer to the return data buffer
444 * structure_size - Pointer to where the number of bytes
445 * in the return data struct is returned
446 *
447 * RETURN: Status
448 *
449 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
450 * structure pointed to by the output_buffer. Return the
451 * number of bytes consumed from the byte stream.
452 *
453 ******************************************************************************/
454
455acpi_status
456acpi_rs_end_depend_fns_resource (
457 u8 *byte_stream_buffer,
458 acpi_size *bytes_consumed,
459 u8 **output_buffer,
460 acpi_size *structure_size)
461{
462 struct acpi_resource *output_struct = (void *) *output_buffer;
463 acpi_size struct_size = ACPI_RESOURCE_LENGTH;
464
465
466 ACPI_FUNCTION_TRACE ("rs_end_depend_fns_resource");
467
468
469 /*
470 * The number of bytes consumed is static
471 */
472 *bytes_consumed = 1;
473
474 /*
475 * Fill out the structure
476 */
477 output_struct->id = ACPI_RSTYPE_END_DPF;
478
479 /*
480 * Set the Length parameter
481 */
482 output_struct->length = (u32) struct_size;
483
484 /*
485 * Return the final size of the structure
486 */
487 *structure_size = struct_size;
488 return_ACPI_STATUS (AE_OK);
489}
490
491
492/*******************************************************************************
493 *
494 * FUNCTION: acpi_rs_start_depend_fns_stream
495 *
496 * PARAMETERS: linked_list - Pointer to the resource linked list
497 * output_buffer - Pointer to the user's return buffer
498 * bytes_consumed - u32 pointer that is filled with
499 * the number of bytes of the
500 * output_buffer used
501 *
502 * RETURN: Status
503 *
504 * DESCRIPTION: Take the linked list resource structure and fills in the
505 * the appropriate bytes in a byte stream
506 *
507 ******************************************************************************/
508
509acpi_status
510acpi_rs_start_depend_fns_stream (
511 struct acpi_resource *linked_list,
512 u8 **output_buffer,
513 acpi_size *bytes_consumed)
514{
515 u8 *buffer = *output_buffer;
516 u8 temp8 = 0;
517
518
519 ACPI_FUNCTION_TRACE ("rs_start_depend_fns_stream");
520
521
522 /*
523 * The descriptor field is set based upon whether a byte is needed
524 * to contain Priority data.
525 */
526 if (ACPI_ACCEPTABLE_CONFIGURATION ==
527 linked_list->data.start_dpf.compatibility_priority &&
528 ACPI_ACCEPTABLE_CONFIGURATION ==
529 linked_list->data.start_dpf.performance_robustness) {
530 *buffer = 0x30;
531 }
532 else {
533 *buffer = 0x31;
534 buffer += 1;
535
536 /*
537 * Set the Priority Byte Definition
538 */
539 temp8 = 0;
540 temp8 = (u8) ((linked_list->data.start_dpf.performance_robustness &
541 0x03) << 2);
542 temp8 |= (linked_list->data.start_dpf.compatibility_priority &
543 0x03);
544 *buffer = temp8;
545 }
546
547 buffer += 1;
548
549 /*
550 * Return the number of bytes consumed in this operation
551 */
552 *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer);
553 return_ACPI_STATUS (AE_OK);
554}
555
556
557/*******************************************************************************
558 *
559 * FUNCTION: acpi_rs_end_depend_fns_stream
560 *
561 * PARAMETERS: linked_list - Pointer to the resource linked list
562 * output_buffer - Pointer to the user's return buffer
563 * bytes_consumed - Pointer to where the number of bytes
564 * used in the output_buffer is returned
565 *
566 * RETURN: Status
567 *
568 * DESCRIPTION: Take the linked list resource structure and fills in the
569 * the appropriate bytes in a byte stream
570 *
571 ******************************************************************************/
572
573acpi_status
574acpi_rs_end_depend_fns_stream (
575 struct acpi_resource *linked_list,
576 u8 **output_buffer,
577 acpi_size *bytes_consumed)
578{
579 u8 *buffer = *output_buffer;
580
581
582 ACPI_FUNCTION_TRACE ("rs_end_depend_fns_stream");
583
584
585 /*
586 * The descriptor field is static
587 */
588 *buffer = 0x38;
589 buffer += 1;
590
591 /*
592 * Return the number of bytes consumed in this operation
593 */
594 *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer);
595 return_ACPI_STATUS (AE_OK);
596}
597