[ACPICA]
[reactos.git] / reactos / drivers / bus / acpi / acpica / executer / exconcat.c
1 /******************************************************************************
2 *
3 * Module Name: exconcat - Concatenate-type AML operators
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2016, Intel Corp.
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 #include "acpi.h"
45 #include "accommon.h"
46 #include "acinterp.h"
47 #include "amlresrc.h"
48
49
50 #define _COMPONENT ACPI_EXECUTER
51 ACPI_MODULE_NAME ("exconcat")
52
53 /* Local Prototypes */
54
55 static ACPI_STATUS
56 AcpiExConvertToObjectTypeString (
57 ACPI_OPERAND_OBJECT *ObjDesc,
58 ACPI_OPERAND_OBJECT **ResultDesc);
59
60
61 /*******************************************************************************
62 *
63 * FUNCTION: AcpiExDoConcatenate
64 *
65 * PARAMETERS: Operand0 - First source object
66 * Operand1 - Second source object
67 * ActualReturnDesc - Where to place the return object
68 * WalkState - Current walk state
69 *
70 * RETURN: Status
71 *
72 * DESCRIPTION: Concatenate two objects with the ACPI-defined conversion
73 * rules as necessary.
74 * NOTE:
75 * Per the ACPI spec (up to 6.1), Concatenate only supports Integer,
76 * String, and Buffer objects. However, we support all objects here
77 * as an extension. This improves the usefulness of both Concatenate
78 * and the Printf/Fprintf macros. The extension returns a string
79 * describing the object type for the other objects.
80 * 02/2016.
81 *
82 ******************************************************************************/
83
84 ACPI_STATUS
85 AcpiExDoConcatenate (
86 ACPI_OPERAND_OBJECT *Operand0,
87 ACPI_OPERAND_OBJECT *Operand1,
88 ACPI_OPERAND_OBJECT **ActualReturnDesc,
89 ACPI_WALK_STATE *WalkState)
90 {
91 ACPI_OPERAND_OBJECT *LocalOperand0 = Operand0;
92 ACPI_OPERAND_OBJECT *LocalOperand1 = Operand1;
93 ACPI_OPERAND_OBJECT *TempOperand1 = NULL;
94 ACPI_OPERAND_OBJECT *ReturnDesc;
95 char *Buffer;
96 ACPI_OBJECT_TYPE Operand0Type;
97 ACPI_OBJECT_TYPE Operand1Type;
98 ACPI_STATUS Status;
99
100
101 ACPI_FUNCTION_TRACE (ExDoConcatenate);
102
103
104 /* Operand 0 preprocessing */
105
106 switch (Operand0->Common.Type)
107 {
108 case ACPI_TYPE_INTEGER:
109 case ACPI_TYPE_STRING:
110 case ACPI_TYPE_BUFFER:
111
112 Operand0Type = Operand0->Common.Type;
113 break;
114
115 default:
116
117 /* For all other types, get the "object type" string */
118
119 Status = AcpiExConvertToObjectTypeString (
120 Operand0, &LocalOperand0);
121 if (ACPI_FAILURE (Status))
122 {
123 goto Cleanup;
124 }
125
126 Operand0Type = ACPI_TYPE_STRING;
127 break;
128 }
129
130 /* Operand 1 preprocessing */
131
132 switch (Operand1->Common.Type)
133 {
134 case ACPI_TYPE_INTEGER:
135 case ACPI_TYPE_STRING:
136 case ACPI_TYPE_BUFFER:
137
138 Operand1Type = Operand1->Common.Type;
139 break;
140
141 default:
142
143 /* For all other types, get the "object type" string */
144
145 Status = AcpiExConvertToObjectTypeString (
146 Operand1, &LocalOperand1);
147 if (ACPI_FAILURE (Status))
148 {
149 goto Cleanup;
150 }
151
152 Operand1Type = ACPI_TYPE_STRING;
153 break;
154 }
155
156 /*
157 * Convert the second operand if necessary. The first operand (0)
158 * determines the type of the second operand (1) (See the Data Types
159 * section of the ACPI specification). Both object types are
160 * guaranteed to be either Integer/String/Buffer by the operand
161 * resolution mechanism.
162 */
163 switch (Operand0Type)
164 {
165 case ACPI_TYPE_INTEGER:
166
167 Status = AcpiExConvertToInteger (LocalOperand1, &TempOperand1, 16);
168 break;
169
170 case ACPI_TYPE_BUFFER:
171
172 Status = AcpiExConvertToBuffer (LocalOperand1, &TempOperand1);
173 break;
174
175 case ACPI_TYPE_STRING:
176
177 switch (Operand1Type)
178 {
179 case ACPI_TYPE_INTEGER:
180 case ACPI_TYPE_STRING:
181 case ACPI_TYPE_BUFFER:
182
183 /* Other types have already been converted to string */
184
185 Status = AcpiExConvertToString (
186 LocalOperand1, &TempOperand1, ACPI_IMPLICIT_CONVERT_HEX);
187 break;
188
189 default:
190
191 Status = AE_OK;
192 break;
193 }
194 break;
195
196 default:
197
198 ACPI_ERROR ((AE_INFO, "Invalid object type: 0x%X",
199 Operand0->Common.Type));
200 Status = AE_AML_INTERNAL;
201 }
202
203 if (ACPI_FAILURE (Status))
204 {
205 goto Cleanup;
206 }
207
208 /* Take care with any newly created operand objects */
209
210 if ((LocalOperand1 != Operand1) &&
211 (LocalOperand1 != TempOperand1))
212 {
213 AcpiUtRemoveReference (LocalOperand1);
214 }
215
216 LocalOperand1 = TempOperand1;
217
218 /*
219 * Both operands are now known to be the same object type
220 * (Both are Integer, String, or Buffer), and we can now perform
221 * the concatenation.
222 *
223 * There are three cases to handle, as per the ACPI spec:
224 *
225 * 1) Two Integers concatenated to produce a new Buffer
226 * 2) Two Strings concatenated to produce a new String
227 * 3) Two Buffers concatenated to produce a new Buffer
228 */
229 switch (Operand0Type)
230 {
231 case ACPI_TYPE_INTEGER:
232
233 /* Result of two Integers is a Buffer */
234 /* Need enough buffer space for two integers */
235
236 ReturnDesc = AcpiUtCreateBufferObject (
237 (ACPI_SIZE) ACPI_MUL_2 (AcpiGbl_IntegerByteWidth));
238 if (!ReturnDesc)
239 {
240 Status = AE_NO_MEMORY;
241 goto Cleanup;
242 }
243
244 Buffer = (char *) ReturnDesc->Buffer.Pointer;
245
246 /* Copy the first integer, LSB first */
247
248 memcpy (Buffer, &Operand0->Integer.Value,
249 AcpiGbl_IntegerByteWidth);
250
251 /* Copy the second integer (LSB first) after the first */
252
253 memcpy (Buffer + AcpiGbl_IntegerByteWidth,
254 &LocalOperand1->Integer.Value, AcpiGbl_IntegerByteWidth);
255 break;
256
257 case ACPI_TYPE_STRING:
258
259 /* Result of two Strings is a String */
260
261 ReturnDesc = AcpiUtCreateStringObject (
262 ((ACPI_SIZE) LocalOperand0->String.Length +
263 LocalOperand1->String.Length));
264 if (!ReturnDesc)
265 {
266 Status = AE_NO_MEMORY;
267 goto Cleanup;
268 }
269
270 Buffer = ReturnDesc->String.Pointer;
271
272 /* Concatenate the strings */
273
274 strcpy (Buffer, LocalOperand0->String.Pointer);
275 strcat (Buffer, LocalOperand1->String.Pointer);
276 break;
277
278 case ACPI_TYPE_BUFFER:
279
280 /* Result of two Buffers is a Buffer */
281
282 ReturnDesc = AcpiUtCreateBufferObject (
283 ((ACPI_SIZE) Operand0->Buffer.Length +
284 LocalOperand1->Buffer.Length));
285 if (!ReturnDesc)
286 {
287 Status = AE_NO_MEMORY;
288 goto Cleanup;
289 }
290
291 Buffer = (char *) ReturnDesc->Buffer.Pointer;
292
293 /* Concatenate the buffers */
294
295 memcpy (Buffer, Operand0->Buffer.Pointer,
296 Operand0->Buffer.Length);
297 memcpy (Buffer + Operand0->Buffer.Length,
298 LocalOperand1->Buffer.Pointer,
299 LocalOperand1->Buffer.Length);
300 break;
301
302 default:
303
304 /* Invalid object type, should not happen here */
305
306 ACPI_ERROR ((AE_INFO, "Invalid object type: 0x%X",
307 Operand0->Common.Type));
308 Status = AE_AML_INTERNAL;
309 goto Cleanup;
310 }
311
312 *ActualReturnDesc = ReturnDesc;
313
314 Cleanup:
315 if (LocalOperand0 != Operand0)
316 {
317 AcpiUtRemoveReference (LocalOperand0);
318 }
319
320 if (LocalOperand1 != Operand1)
321 {
322 AcpiUtRemoveReference (LocalOperand1);
323 }
324
325 return_ACPI_STATUS (Status);
326 }
327
328
329 /*******************************************************************************
330 *
331 * FUNCTION: AcpiExConvertToObjectTypeString
332 *
333 * PARAMETERS: ObjDesc - Object to be converted
334 * ReturnDesc - Where to place the return object
335 *
336 * RETURN: Status
337 *
338 * DESCRIPTION: Convert an object of arbitrary type to a string object that
339 * contains the namestring for the object. Used for the
340 * concatenate operator.
341 *
342 ******************************************************************************/
343
344 static ACPI_STATUS
345 AcpiExConvertToObjectTypeString (
346 ACPI_OPERAND_OBJECT *ObjDesc,
347 ACPI_OPERAND_OBJECT **ResultDesc)
348 {
349 ACPI_OPERAND_OBJECT *ReturnDesc;
350 const char *TypeString;
351
352
353 TypeString = AcpiUtGetTypeName (ObjDesc->Common.Type);
354
355 ReturnDesc = AcpiUtCreateStringObject (
356 ((ACPI_SIZE) strlen (TypeString) + 9)); /* 9 For "[ Object]" */
357 if (!ReturnDesc)
358 {
359 return (AE_NO_MEMORY);
360 }
361
362 strcpy (ReturnDesc->String.Pointer, "[");
363 strcat (ReturnDesc->String.Pointer, TypeString);
364 strcat (ReturnDesc->String.Pointer, " Object]");
365
366 *ResultDesc = ReturnDesc;
367 return (AE_OK);
368 }
369
370
371 /*******************************************************************************
372 *
373 * FUNCTION: AcpiExConcatTemplate
374 *
375 * PARAMETERS: Operand0 - First source object
376 * Operand1 - Second source object
377 * ActualReturnDesc - Where to place the return object
378 * WalkState - Current walk state
379 *
380 * RETURN: Status
381 *
382 * DESCRIPTION: Concatenate two resource templates
383 *
384 ******************************************************************************/
385
386 ACPI_STATUS
387 AcpiExConcatTemplate (
388 ACPI_OPERAND_OBJECT *Operand0,
389 ACPI_OPERAND_OBJECT *Operand1,
390 ACPI_OPERAND_OBJECT **ActualReturnDesc,
391 ACPI_WALK_STATE *WalkState)
392 {
393 ACPI_STATUS Status;
394 ACPI_OPERAND_OBJECT *ReturnDesc;
395 UINT8 *NewBuf;
396 UINT8 *EndTag;
397 ACPI_SIZE Length0;
398 ACPI_SIZE Length1;
399 ACPI_SIZE NewLength;
400
401
402 ACPI_FUNCTION_TRACE (ExConcatTemplate);
403
404
405 /*
406 * Find the EndTag descriptor in each resource template.
407 * Note1: returned pointers point TO the EndTag, not past it.
408 * Note2: zero-length buffers are allowed; treated like one EndTag
409 */
410
411 /* Get the length of the first resource template */
412
413 Status = AcpiUtGetResourceEndTag (Operand0, &EndTag);
414 if (ACPI_FAILURE (Status))
415 {
416 return_ACPI_STATUS (Status);
417 }
418
419 Length0 = ACPI_PTR_DIFF (EndTag, Operand0->Buffer.Pointer);
420
421 /* Get the length of the second resource template */
422
423 Status = AcpiUtGetResourceEndTag (Operand1, &EndTag);
424 if (ACPI_FAILURE (Status))
425 {
426 return_ACPI_STATUS (Status);
427 }
428
429 Length1 = ACPI_PTR_DIFF (EndTag, Operand1->Buffer.Pointer);
430
431 /* Combine both lengths, minimum size will be 2 for EndTag */
432
433 NewLength = Length0 + Length1 + sizeof (AML_RESOURCE_END_TAG);
434
435 /* Create a new buffer object for the result (with one EndTag) */
436
437 ReturnDesc = AcpiUtCreateBufferObject (NewLength);
438 if (!ReturnDesc)
439 {
440 return_ACPI_STATUS (AE_NO_MEMORY);
441 }
442
443 /*
444 * Copy the templates to the new buffer, 0 first, then 1 follows. One
445 * EndTag descriptor is copied from Operand1.
446 */
447 NewBuf = ReturnDesc->Buffer.Pointer;
448 memcpy (NewBuf, Operand0->Buffer.Pointer, Length0);
449 memcpy (NewBuf + Length0, Operand1->Buffer.Pointer, Length1);
450
451 /* Insert EndTag and set the checksum to zero, means "ignore checksum" */
452
453 NewBuf[NewLength - 1] = 0;
454 NewBuf[NewLength - 2] = ACPI_RESOURCE_NAME_END_TAG | 1;
455
456 /* Return the completed resource template */
457
458 *ActualReturnDesc = ReturnDesc;
459 return_ACPI_STATUS (AE_OK);
460 }