PageRenderTime 31ms CodeModel.GetById 9ms app.highlight 17ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/acpi/resources/rsmisc.c

https://bitbucket.org/evzijst/gittest
C | 597 lines | 201 code | 106 blank | 290 comment | 15 complexity | 4f83ba7fdb5bfa12ebd1dcddab281dc3 MD5 | raw file
  1/*******************************************************************************
  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