?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with 2.4.0-test3-pre4.
[linux-2.6/linux-mips.git] / drivers / acpi / resources / rsmisc.c
blobfc5a6725f031a666f4c7fef6f1b22f3cbc69d126
1 /******************************************************************************
2 *
3 * Module Name: rsmisc - Acpi_rs_end_tag_resource
4 * Acpi_rs_end_tag_stream
5 * Acpi_rs_vendor_resource
6 * Acpi_rs_vendor_stream
7 * Acpi_rs_start_dependent_functions_resource
8 * Acpi_rs_end_dependent_functions_resource
9 * Acpi_rs_start_dependent_functions_stream
10 * Acpi_rs_end_dependent_functions_stream
11 *
12 *****************************************************************************/
13
14 /*
15 * Copyright (C) 2000 R. Byron Moore
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 */
31
32
33 #include "acpi.h"
34
35 #define _COMPONENT RESOURCE_MANAGER
36 MODULE_NAME ("rsmisc");
37
38
39 /***************************************************************************
40 * FUNCTION: Acpi_rs_end_tag_resource
41 *
42 * PARAMETERS:
43 * Byte_stream_buffer - Pointer to the resource input byte
44 * stream
45 * Bytes_consumed - u32 pointer that is filled with
46 * the number of bytes consumed from
47 * the Byte_stream_buffer
48 * Output_buffer - Pointer to the user's return buffer
49 * Structure_size - u32 pointer that is filled with
50 * the number of bytes in the filled
51 * in structure
52 *
53 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
54 *
55 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
56 * structure pointed to by the Output_buffer. Return the
57 * number of bytes consumed from the byte stream.
58 *
59 ***************************************************************************/
60
61 ACPI_STATUS
62 acpi_rs_end_tag_resource (
63 u8 *byte_stream_buffer,
64 u32 *bytes_consumed,
65 u8 **output_buffer,
66 u32 *structure_size)
67 {
68 RESOURCE *output_struct = (RESOURCE *) * output_buffer;
69 u32 struct_size = RESOURCE_LENGTH;
70
71
72 /*
73 * The number of bytes consumed is static
74 */
75 *bytes_consumed = 2;
76
77 /*
78 * Fill out the structure
79 */
80 output_struct->id = end_tag;
81
82 /*
83 * Set the Length parameter
84 */
85 output_struct->length = 0;
86
87 /*
88 * Return the final size of the structure
89 */
90 *structure_size = struct_size;
91
92 return (AE_OK);
93 }
94
95
96 /***************************************************************************
97 * FUNCTION: Acpi_rs_end_tag_stream
98 *
99 * PARAMETERS:
100 * Linked_list - Pointer to the resource linked list
101 * Output_buffer - Pointer to the user's return buffer
102 * Bytes_consumed - u32 pointer that is filled with
103 * the number of bytes of the
104 * Output_buffer used
105 *
106 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
107 *
108 * DESCRIPTION: Take the linked list resource structure and fills in the
109 * the appropriate bytes in a byte stream
110 *
111 ***************************************************************************/
112
113 ACPI_STATUS
114 acpi_rs_end_tag_stream (
115 RESOURCE *linked_list,
116 u8 **output_buffer,
117 u32 *bytes_consumed)
118 {
119 u8 *buffer = *output_buffer;
120 u8 temp8 = 0;
121
122
123 /*
124 * The descriptor field is static
125 */
126 *buffer = 0x79;
127
128 buffer += 1;
129
130 /*
131 * Set the Checksum - zero means that the resource data is treated as if
132 * the checksum operation succeeded (ACPI Spec 1.0b Section 6.4.2.8)
133 */
134 temp8 = 0;
135
136 *buffer = temp8;
137
138 buffer += 1;
139
140 /*
141 * Return the number of bytes consumed in this operation
142 */
143 *bytes_consumed = (u32) ((NATIVE_UINT) buffer -
144 (NATIVE_UINT) *output_buffer);
145
146 return (AE_OK);
147 }
148
149 /***************************************************************************
150 * FUNCTION: Acpi_rs_vendor_resource
151 *
152 * PARAMETERS:
153 * Byte_stream_buffer - Pointer to the resource input byte
154 * stream
155 * Bytes_consumed - u32 pointer that is filled with
156 * the number of bytes consumed from
157 * the Byte_stream_buffer
158 * Output_buffer - Pointer to the user's return buffer
159 * Structure_size - u32 pointer that is filled with
160 * the number of bytes in the filled
161 * in structure
162 *
163 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
164 *
165 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
166 * structure pointed to by the Output_buffer. Return the
167 * number of bytes consumed from the byte stream.
168 *
169 ***************************************************************************/
170
171 ACPI_STATUS
172 acpi_rs_vendor_resource (
173 u8 *byte_stream_buffer,
174 u32 *bytes_consumed,
175 u8 **output_buffer,
176 u32 *structure_size)
177 {
178 u8 *buffer = byte_stream_buffer;
179 RESOURCE *output_struct = (RESOURCE *) * output_buffer;
180 u16 temp16 = 0;
181 u8 temp8 = 0;
182 u8 index;
183 u32 struct_size = sizeof (VENDOR_RESOURCE) +
184 RESOURCE_LENGTH_NO_DATA;
185
186
187 /*
188 * Dereference the Descriptor to find if this is a large or small item.
189 */
190 temp8 = *buffer;
191
192 if (temp8 & 0x80) {
193 /*
194 * Large Item
195 */
196 /* Point to the length field */
197
198 buffer += 1;
199
200 /* Dereference */
201
202 temp16 = *(u16 *)buffer;
203
204 /* Calculate bytes consumed */
205
206 *bytes_consumed = temp16 + 3;
207
208 /* Point to the first vendor byte */
209
210 buffer += 2;
211 }
212
213 else {
214 /*
215 * Small Item
216 */
217
218 /* Dereference the size */
219
220 temp16 = (u8)(*buffer & 0x07);
221
222 /* Calculate bytes consumed */
223
224 *bytes_consumed = temp16 + 1;
225
226 /* Point to the first vendor byte */
227
228 buffer += 1;
229 }
230
231 output_struct->id = vendor_specific;
232
233 output_struct->data.vendor_specific.length = temp16;
234
235 for (index = 0; index < temp16; index++) {
236 output_struct->data.vendor_specific.reserved[index] = *buffer;
237 buffer += 1;
238 }
239
240 /*
241 * In order for the Struct_size to fall on a 32-bit boundry,
242 * calculate the length of the vendor string and expand the
243 * Struct_size to the next 32-bit boundry.
244 */
245 struct_size += ROUND_UP_TO_32_bITS (temp16);
246
247 /*
248 * Set the Length parameter
249 */
250 output_struct->length = struct_size;
251
252 /*
253 * Return the final size of the structure
254 */
255 *structure_size = struct_size;
256
257 return (AE_OK);
258 }
259
260
261 /***************************************************************************
262 * FUNCTION: Acpi_rs_vendor_stream
263 *
264 * PARAMETERS:
265 * Linked_list - Pointer to the resource linked list
266 * Output_buffer - Pointer to the user's return buffer
267 * Bytes_consumed - u32 pointer that is filled with
268 * the number of bytes of the
269 * Output_buffer used
270 *
271 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
272 *
273 * DESCRIPTION: Take the linked list resource structure and fills in the
274 * the appropriate bytes in a byte stream
275 *
276 ***************************************************************************/
277
278 ACPI_STATUS
279 acpi_rs_vendor_stream (
280 RESOURCE *linked_list,
281 u8 **output_buffer,
282 u32 *bytes_consumed)
283 {
284 u8 *buffer = *output_buffer;
285 u16 temp16 = 0;
286 u8 temp8 = 0;
287 u8 index;
288
289
290 /*
291 * Dereference the length to find if this is a large or small item.
292 */
293
294 if(linked_list->data.vendor_specific.length > 7) {
295 /*
296 * Large Item
297 */
298 /*
299 * Set the descriptor field and length bytes
300 */
301 *buffer = 0x84;
302
303 buffer += 1;
304
305 temp16 = (u16) linked_list->data.vendor_specific.length;
306
307 *(u16 *)buffer = temp16;
308
309 buffer += 2;
310 }
311
312 else {
313 /*
314 * Small Item
315 */
316
317 /*
318 * Set the descriptor field
319 */
320 temp8 = 0x70;
321
322 temp8 |= linked_list->data.vendor_specific.length;
323
324 *buffer = temp8;
325
326 buffer += 1;
327 }
328
329 /*
330 * Loop through all of the Vendor Specific fields
331 */
332 for (index = 0; index < linked_list->data.vendor_specific.length; index++) {
333 temp8 = linked_list->data.vendor_specific.reserved[index];
334 *buffer = temp8;
335 buffer += 1;
336 }
337
338 /*
339 * Return the number of bytes consumed in this operation
340 */
341 *bytes_consumed = (u32) ((NATIVE_UINT) buffer -
342 (NATIVE_UINT) *output_buffer);
343
344 return (AE_OK);
345 }
346
347 /***************************************************************************
348 * FUNCTION: Acpi_rs_start_dependent_functions_resource
349 *
350 * PARAMETERS:
351 * Byte_stream_buffer - Pointer to the resource input byte
352 * stream
353 * Bytes_consumed - u32 pointer that is filled with
354 * the number of bytes consumed from
355 * the Byte_stream_buffer
356 * Output_buffer - Pointer to the user's return buffer
357 * Structure_size - u32 pointer that is filled with
358 * the number of bytes in the filled
359 * in structure
360 *
361 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
362 *
363 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
364 * structure pointed to by the Output_buffer. Return the
365 * number of bytes consumed from the byte stream.
366 *
367 ***************************************************************************/
368
369 ACPI_STATUS
370 acpi_rs_start_dependent_functions_resource (
371 u8 *byte_stream_buffer,
372 u32 *bytes_consumed,
373 u8 **output_buffer,
374 u32 *structure_size)
375 {
376 u8 *buffer = byte_stream_buffer;
377 RESOURCE *output_struct = (RESOURCE *) * output_buffer;
378 u8 temp8 = 0;
379 u32 struct_size =
380 sizeof(START_DEPENDENT_FUNCTIONS_RESOURCE) +
381 RESOURCE_LENGTH_NO_DATA;
382
383
384 /*
385 * The number of bytes consumed are contained in the descriptor (Bits:0-1)
386 */
387 temp8 = *buffer;
388
389 *bytes_consumed = (temp8 & 0x01) + 1;
390
391 output_struct->id = start_dependent_functions;
392
393 /*
394 * Point to Byte 1 if it is used
395 */
396 if (2 == *bytes_consumed) {
397 buffer += 1;
398 temp8 = *buffer;
399
400 /*
401 * Check Compatibility priority
402 */
403 output_struct->data.start_dependent_functions.compatibility_priority =
404 temp8 & 0x03;
405
406 if (3 == output_struct->data.start_dependent_functions.compatibility_priority) {
407 return (AE_ERROR);
408 }
409
410 /*
411 * Check Performance/Robustness preference
412 */
413 output_struct->data.start_dependent_functions.performance_robustness =
414 (temp8 >> 2) & 0x03;
415
416 if (3 == output_struct->data.start_dependent_functions.performance_robustness) {
417 return (AE_ERROR);
418 }
419 }
420
421 else {
422 output_struct->data.start_dependent_functions.compatibility_priority =
423 ACCEPTABLE_CONFIGURATION;
424
425 output_struct->data.start_dependent_functions.performance_robustness =
426 ACCEPTABLE_CONFIGURATION;
427 }
428
429 /*
430 * Set the Length parameter
431 */
432 output_struct->length = struct_size;
433
434 /*
435 * Return the final size of the structure
436 */
437 *structure_size = struct_size;
438
439 return (AE_OK);
440 }
441
442
443 /***************************************************************************
444 * FUNCTION: Acpi_rs_end_dependent_functions_resource
445 *
446 * PARAMETERS:
447 * Byte_stream_buffer - Pointer to the resource input byte
448 * stream
449 * Bytes_consumed - u32 pointer that is filled with
450 * the number of bytes consumed from
451 * the Byte_stream_buffer
452 * Output_buffer - Pointer to the user's return buffer
453 * Structure_size - u32 pointer that is filled with
454 * the number of bytes in the filled
455 * in structure
456 *
457 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
458 *
459 * DESCRIPTION: Take the resource byte stream and fill out the appropriate
460 * structure pointed to by the Output_buffer. Return the
461 * number of bytes consumed from the byte stream.
462 *
463 ***************************************************************************/
464
465 ACPI_STATUS
466 acpi_rs_end_dependent_functions_resource (
467 u8 *byte_stream_buffer,
468 u32 *bytes_consumed,
469 u8 **output_buffer,
470 u32 *structure_size)
471 {
472 RESOURCE *output_struct = (RESOURCE *) * output_buffer;
473 u32 struct_size = RESOURCE_LENGTH;
474
475
476 /*
477 * The number of bytes consumed is static
478 */
479 *bytes_consumed = 1;
480
481 /*
482 * Fill out the structure
483 */
484 output_struct->id = end_dependent_functions;
485
486 /*
487 * Set the Length parameter
488 */
489 output_struct->length = struct_size;
490
491 /*
492 * Return the final size of the structure
493 */
494 *structure_size = struct_size;
495
496 return (AE_OK);
497 }
498
499
500 /***************************************************************************
501 * FUNCTION: Acpi_rs_start_dependent_functions_stream
502 *
503 * PARAMETERS:
504 * Linked_list - Pointer to the resource linked list
505 * Output_buffer - Pointer to the user's return buffer
506 * Bytes_consumed - u32 pointer that is filled with
507 * the number of bytes of the
508 * Output_buffer used
509 *
510 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
511 *
512 * DESCRIPTION: Take the linked list resource structure and fills in the
513 * the appropriate bytes in a byte stream
514 *
515 ***************************************************************************/
516 ACPI_STATUS
517 acpi_rs_start_dependent_functions_stream (
518 RESOURCE *linked_list,
519 u8 **output_buffer,
520 u32 *bytes_consumed)
521 {
522 u8 *buffer = *output_buffer;
523 u8 temp8 = 0;
524
525
526 /*
527 * The descriptor field is set based upon whether a byte is needed
528 * to contain Priority data.
529 */
530 if (ACCEPTABLE_CONFIGURATION ==
531 linked_list->data.start_dependent_functions.compatibility_priority &&
532 ACCEPTABLE_CONFIGURATION ==
533 linked_list->data.start_dependent_functions.performance_robustness)
534 {
535 *buffer = 0x30;
536 }
537 else {
538 *buffer = 0x31;
539
540 buffer += 1;
541
542 /*
543 * Set the Priority Byte Definition
544 */
545 temp8 = 0;
546
547 temp8 = (u8)
548 ((linked_list->data.start_dependent_functions.performance_robustness &
549 0x03) << 2);
550
551 temp8 |=
552 (linked_list->data.start_dependent_functions.compatibility_priority &
553 0x03);
554
555 *buffer = temp8;
556 }
557
558 buffer += 1;
559
560 /*
561 * Return the number of bytes consumed in this operation
562 */
563 *bytes_consumed = (u32) ((NATIVE_UINT) buffer -
564 (NATIVE_UINT) *output_buffer);
565
566 return (AE_OK);
567 }
568
569
570 /***************************************************************************
571 * FUNCTION: Acpi_rs_end_dependent_functions_stream
572 *
573 * PARAMETERS:
574 * Linked_list - Pointer to the resource linked list
575 * Output_buffer - Pointer to the user's return buffer
576 * Bytes_consumed - u32 pointer that is filled with
577 * the number of bytes of the
578 * Output_buffer used
579 *
580 * RETURN: Status AE_OK if okay, else a valid ACPI_STATUS code
581 *
582 * DESCRIPTION: Take the linked list resource structure and fills in the
583 * the appropriate bytes in a byte stream
584 *
585 ***************************************************************************/
586
587 ACPI_STATUS
588 acpi_rs_end_dependent_functions_stream (
589 RESOURCE *linked_list,
590 u8 **output_buffer,
591 u32 *bytes_consumed
592 )
593 {
594 u8 *buffer = *output_buffer;
595
596
597 /*
598 * The descriptor field is static
599 */
600 *buffer = 0x38;
601
602 buffer += 1;
603
604 /*
605 * Return the number of bytes consumed in this operation
606 */
607 *bytes_consumed = (u32) ((NATIVE_UINT) buffer -
608 (NATIVE_UINT) *output_buffer);
609
610 return (AE_OK);
611 }
612
Mirror of the linux-mips.org kernel tree