Print this page
acpica-unix2-20130823
PANKOVs restructure
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/intel/io/acpica/parser/psutils.c
+++ new/usr/src/common/acpica/components/parser/psutils.c
1 1 /******************************************************************************
2 2 *
3 3 * Module Name: psutils - Parser miscellaneous utilities (Parser only)
4 4 *
5 5 *****************************************************************************/
6 6
7 7 /*
8 - * Copyright (C) 2000 - 2011, Intel Corp.
8 + * Copyright (C) 2000 - 2013, Intel Corp.
9 9 * All rights reserved.
10 10 *
11 11 * Redistribution and use in source and binary forms, with or without
12 12 * modification, are permitted provided that the following conditions
13 13 * are met:
14 14 * 1. Redistributions of source code must retain the above copyright
15 15 * notice, this list of conditions, and the following disclaimer,
16 16 * without modification.
17 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 18 * substantially similar to the "NO WARRANTY" disclaimer below
19 19 * ("Disclaimer") and any redistribution must be conditioned upon
20 20 * including a substantially similar Disclaimer requirement for further
21 21 * binary redistribution.
22 22 * 3. Neither the names of the above-listed copyright holders nor the names
23 23 * of any contributors may be used to endorse or promote products derived
24 24 * from this software without specific prior written permission.
25 25 *
26 26 * Alternatively, this software may be distributed under the terms of the
27 27 * GNU General Public License ("GPL") version 2 as published by the Free
28 28 * Software Foundation.
29 29 *
30 30 * NO WARRANTY
31 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 41 * POSSIBILITY OF SUCH DAMAGES.
42 42 */
43 43
44 44
45 45 #include "acpi.h"
46 46 #include "accommon.h"
47 47 #include "acparser.h"
48 48 #include "amlcode.h"
49 49
50 50 #define _COMPONENT ACPI_PARSER
51 51 ACPI_MODULE_NAME ("psutils")
52 52
53 53
54 54 /*******************************************************************************
55 55 *
56 56 * FUNCTION: AcpiPsCreateScopeOp
57 57 *
58 58 * PARAMETERS: None
59 59 *
60 60 * RETURN: A new Scope object, null on failure
61 61 *
62 62 * DESCRIPTION: Create a Scope and associated namepath op with the root name
63 63 *
64 64 ******************************************************************************/
65 65
66 66 ACPI_PARSE_OBJECT *
67 67 AcpiPsCreateScopeOp (
68 68 void)
69 69 {
70 70 ACPI_PARSE_OBJECT *ScopeOp;
71 71
72 72
73 73 ScopeOp = AcpiPsAllocOp (AML_SCOPE_OP);
74 74 if (!ScopeOp)
75 75 {
76 76 return (NULL);
77 77 }
78 78
79 79 ScopeOp->Named.Name = ACPI_ROOT_NAME;
80 80 return (ScopeOp);
81 81 }
82 82
83 83
84 84 /*******************************************************************************
85 85 *
86 86 * FUNCTION: AcpiPsInitOp
87 87 *
88 88 * PARAMETERS: Op - A newly allocated Op object
89 89 * Opcode - Opcode to store in the Op
90 90 *
91 91 * RETURN: None
92 92 *
93 93 * DESCRIPTION: Initialize a parse (Op) object
94 94 *
95 95 ******************************************************************************/
96 96
97 97 void
98 98 AcpiPsInitOp (
99 99 ACPI_PARSE_OBJECT *Op,
100 100 UINT16 Opcode)
101 101 {
102 102 ACPI_FUNCTION_ENTRY ();
103 103
104 104
105 105 Op->Common.DescriptorType = ACPI_DESC_TYPE_PARSER;
106 106 Op->Common.AmlOpcode = Opcode;
107 107
108 108 ACPI_DISASM_ONLY_MEMBERS (ACPI_STRNCPY (Op->Common.AmlOpName,
109 109 (AcpiPsGetOpcodeInfo (Opcode))->Name,
110 110 sizeof (Op->Common.AmlOpName)));
111 111 }
112 112
|
↓ open down ↓ |
94 lines elided |
↑ open up ↑ |
113 113
114 114 /*******************************************************************************
115 115 *
116 116 * FUNCTION: AcpiPsAllocOp
117 117 *
118 118 * PARAMETERS: Opcode - Opcode that will be stored in the new Op
119 119 *
120 120 * RETURN: Pointer to the new Op, null on failure
121 121 *
122 122 * DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on
123 - * opcode. A cache of opcodes is available for the pure
123 + * opcode. A cache of opcodes is available for the pure
124 124 * GENERIC_OP, since this is by far the most commonly used.
125 125 *
126 126 ******************************************************************************/
127 127
128 128 ACPI_PARSE_OBJECT*
129 129 AcpiPsAllocOp (
130 130 UINT16 Opcode)
131 131 {
132 132 ACPI_PARSE_OBJECT *Op;
133 133 const ACPI_OPCODE_INFO *OpInfo;
134 134 UINT8 Flags = ACPI_PARSEOP_GENERIC;
135 135
136 136
137 137 ACPI_FUNCTION_ENTRY ();
138 138
139 139
140 140 OpInfo = AcpiPsGetOpcodeInfo (Opcode);
141 141
142 142 /* Determine type of ParseOp required */
143 143
144 144 if (OpInfo->Flags & AML_DEFER)
145 145 {
146 146 Flags = ACPI_PARSEOP_DEFERRED;
147 147 }
148 148 else if (OpInfo->Flags & AML_NAMED)
149 149 {
150 150 Flags = ACPI_PARSEOP_NAMED;
151 151 }
152 152 else if (Opcode == AML_INT_BYTELIST_OP)
153 153 {
154 154 Flags = ACPI_PARSEOP_BYTELIST;
155 155 }
156 156
157 157 /* Allocate the minimum required size object */
158 158
159 159 if (Flags == ACPI_PARSEOP_GENERIC)
160 160 {
161 161 /* The generic op (default) is by far the most common (16 to 1) */
162 162
163 163 Op = AcpiOsAcquireObject (AcpiGbl_PsNodeCache);
164 164 }
165 165 else
166 166 {
167 167 /* Extended parseop */
168 168
169 169 Op = AcpiOsAcquireObject (AcpiGbl_PsNodeExtCache);
170 170 }
171 171
172 172 /* Initialize the Op */
173 173
174 174 if (Op)
175 175 {
176 176 AcpiPsInitOp (Op, Opcode);
177 177 Op->Common.Flags = Flags;
178 178 }
179 179
180 180 return (Op);
181 181 }
|
↓ open down ↓ |
48 lines elided |
↑ open up ↑ |
182 182
183 183
184 184 /*******************************************************************************
185 185 *
186 186 * FUNCTION: AcpiPsFreeOp
187 187 *
188 188 * PARAMETERS: Op - Op to be freed
189 189 *
190 190 * RETURN: None.
191 191 *
192 - * DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list
192 + * DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list
193 193 * or actually free it.
194 194 *
195 195 ******************************************************************************/
196 196
197 197 void
198 198 AcpiPsFreeOp (
199 199 ACPI_PARSE_OBJECT *Op)
200 200 {
201 201 ACPI_FUNCTION_NAME (PsFreeOp);
202 202
203 203
204 204 if (Op->Common.AmlOpcode == AML_INT_RETURN_VALUE_OP)
205 205 {
206 206 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Free retval op: %p\n", Op));
207 207 }
208 208
209 209 if (Op->Common.Flags & ACPI_PARSEOP_GENERIC)
210 210 {
211 211 (void) AcpiOsReleaseObject (AcpiGbl_PsNodeCache, Op);
212 212 }
213 213 else
214 214 {
215 215 (void) AcpiOsReleaseObject (AcpiGbl_PsNodeExtCache, Op);
216 216 }
217 217 }
218 218
219 219
220 220 /*******************************************************************************
221 221 *
222 222 * FUNCTION: Utility functions
223 223 *
224 224 * DESCRIPTION: Low level character and object functions
225 225 *
226 226 ******************************************************************************/
227 227
228 228
229 229 /*
230 230 * Is "c" a namestring lead character?
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
231 231 */
232 232 BOOLEAN
233 233 AcpiPsIsLeadingChar (
234 234 UINT32 c)
235 235 {
236 236 return ((BOOLEAN) (c == '_' || (c >= 'A' && c <= 'Z')));
237 237 }
238 238
239 239
240 240 /*
241 - * Is "c" a namestring prefix character?
242 - */
243 -BOOLEAN
244 -AcpiPsIsPrefixChar (
245 - UINT32 c)
246 -{
247 - return ((BOOLEAN) (c == '\\' || c == '^'));
248 -}
249 -
250 -
251 -/*
252 241 * Get op's name (4-byte name segment) or 0 if unnamed
253 242 */
254 243 UINT32
255 244 AcpiPsGetName (
256 245 ACPI_PARSE_OBJECT *Op)
257 246 {
258 247
259 248 /* The "generic" object has no name associated with it */
260 249
261 250 if (Op->Common.Flags & ACPI_PARSEOP_GENERIC)
262 251 {
263 252 return (0);
264 253 }
265 254
266 255 /* Only the "Extended" parse objects have a name */
267 256
268 257 return (Op->Named.Name);
269 258 }
270 259
271 260
272 261 /*
273 262 * Set op's name
274 263 */
275 264 void
276 265 AcpiPsSetName (
277 266 ACPI_PARSE_OBJECT *Op,
278 267 UINT32 name)
279 268 {
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
280 269
281 270 /* The "generic" object has no name associated with it */
282 271
283 272 if (Op->Common.Flags & ACPI_PARSEOP_GENERIC)
284 273 {
285 274 return;
286 275 }
287 276
288 277 Op->Named.Name = name;
289 278 }
290 -
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX