Michael S. Tsirkin | 2597b75 | 2011-10-04 15:26:01 +0200 | [diff] [blame] | 1 | #!/usr/bin/python |
| 2 | # Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <mst@redhat.com> |
| 3 | # |
| 4 | # This file may be distributed under the terms of the GNU GPLv3 license. |
| 5 | |
| 6 | # Process mixed ASL/AML listing (.lst file) produced by iasl -l |
| 7 | # Locate and execute ACPI_EXTRACT directives, output offset info |
| 8 | # |
| 9 | # Documentation of ACPI_EXTRACT_* directive tags: |
| 10 | # |
| 11 | # These directive tags output offset information from AML for BIOS runtime |
| 12 | # table generation. |
| 13 | # Each directive is of the form: |
| 14 | # ACPI_EXTRACT_<TYPE> <array_name> <Operator> (...) |
| 15 | # and causes the extractor to create an array |
| 16 | # named <array_name> with offset, in the generated AML, |
| 17 | # of an object of a given type in the following <Operator>. |
| 18 | # |
| 19 | # A directive must fit on a single code line. |
| 20 | # |
| 21 | # Object type in AML is verified, a mismatch causes a build failure. |
| 22 | # |
| 23 | # Directives and operators currently supported are: |
| 24 | # ACPI_EXTRACT_NAME_DWORD_CONST - extract a Dword Const object from Name() |
| 25 | # ACPI_EXTRACT_NAME_WORD_CONST - extract a Word Const object from Name() |
| 26 | # ACPI_EXTRACT_NAME_BYTE_CONST - extract a Byte Const object from Name() |
| 27 | # ACPI_EXTRACT_METHOD_STRING - extract a NameString from Method() |
| 28 | # ACPI_EXTRACT_NAME_STRING - extract a NameString from Name() |
| 29 | # ACPI_EXTRACT_PROCESSOR_START - start of Processor() block |
| 30 | # ACPI_EXTRACT_PROCESSOR_STRING - extract a NameString from Processor() |
| 31 | # ACPI_EXTRACT_PROCESSOR_END - offset at last byte of Processor() + 1 |
Michael S. Tsirkin | 2e55b03 | 2011-10-26 23:28:02 +0200 | [diff] [blame] | 32 | # |
| 33 | # ACPI_EXTRACT_ALL_CODE - create an array storing the generated AML bytecode |
Michael S. Tsirkin | 2597b75 | 2011-10-04 15:26:01 +0200 | [diff] [blame] | 34 | # |
| 35 | # ACPI_EXTRACT is not allowed anywhere else in code, except in comments. |
| 36 | |
| 37 | import re; |
| 38 | import sys; |
| 39 | import fileinput; |
| 40 | |
| 41 | aml = [] |
| 42 | asl = [] |
| 43 | output = {} |
| 44 | debug = "" |
| 45 | |
| 46 | class asl_line: |
| 47 | line = None |
| 48 | lineno = None |
| 49 | aml_offset = None |
| 50 | |
| 51 | def die(diag): |
| 52 | sys.stderr.write("Error: %s; %s\n" % (diag, debug)) |
| 53 | sys.exit(1) |
| 54 | |
| 55 | #Store an ASL command, matching AML offset, and input line (for debugging) |
| 56 | def add_asl(lineno, line): |
| 57 | l = asl_line() |
| 58 | l.line = line |
| 59 | l.lineno = lineno |
| 60 | l.aml_offset = len(aml) |
| 61 | asl.append(l) |
| 62 | |
| 63 | #Store an AML byte sequence |
| 64 | #Verify that offset output by iasl matches # of bytes so far |
| 65 | def add_aml(offset, line): |
| 66 | o = int(offset, 16); |
| 67 | # Sanity check: offset must match size of code so far |
| 68 | if (o != len(aml)): |
| 69 | die("Offset 0x%x != 0x%x" % (o, len(aml))) |
| 70 | # Strip any trailing dots and ASCII dump after " |
| 71 | line = re.sub(r'\s*\.*\s*".*$',"", line) |
| 72 | # Strip traling whitespace |
| 73 | line = re.sub(r'\s+$',"", line) |
| 74 | # Strip leading whitespace |
| 75 | line = re.sub(r'^\s+',"", line) |
| 76 | # Split on whitespace |
| 77 | code = re.split(r'\s+', line) |
| 78 | for c in code: |
| 79 | # Require a legal hex number, two digits |
| 80 | if (not(re.search(r'^[0-9A-Fa-f][0-9A-Fa-f]$', c))): |
| 81 | die("Unexpected octet %s" % c); |
| 82 | aml.append(int(c, 16)); |
| 83 | |
| 84 | # Process aml bytecode array, decoding AML |
| 85 | def aml_pkglen_bytes(offset): |
| 86 | # PkgLength can be multibyte. Bits 8-7 give the # of extra bytes. |
| 87 | pkglenbytes = aml[offset] >> 6; |
| 88 | return pkglenbytes + 1 |
| 89 | |
| 90 | def aml_pkglen(offset): |
| 91 | pkgstart = offset |
| 92 | pkglenbytes = aml_pkglen_bytes(offset) |
| 93 | pkglen = aml[offset] & 0x3F |
| 94 | # If multibyte, first nibble only uses bits 0-3 |
| 95 | if ((pkglenbytes > 0) and (pkglen & 0x30)): |
| 96 | die("PkgLen bytes 0x%x but first nibble 0x%x expected 0x0X" % |
| 97 | (pkglen, pkglen)) |
| 98 | offset += 1 |
| 99 | pkglenbytes -= 1 |
| 100 | for i in range(pkglenbytes): |
| 101 | pkglen |= aml[offset + i] << (i * 8 + 4) |
| 102 | if (len(aml) < pkgstart + pkglen): |
| 103 | die("PckgLen 0x%x at offset 0x%x exceeds AML size 0x%x" % |
| 104 | (pkglen, offset, len(aml))) |
| 105 | return pkglen |
| 106 | |
| 107 | # Given method offset, find its NameString offset |
| 108 | def aml_method_string(offset): |
| 109 | #0x14 MethodOp PkgLength NameString MethodFlags TermList |
| 110 | if (aml[offset] != 0x14): |
| 111 | die( "Method offset 0x%x: expected 0x14 actual 0x%x" % |
| 112 | (offset, aml[offset])); |
| 113 | offset += 1; |
| 114 | pkglenbytes = aml_pkglen_bytes(offset) |
| 115 | offset += pkglenbytes; |
| 116 | return offset; |
| 117 | |
| 118 | # Given name offset, find its NameString offset |
| 119 | def aml_name_string(offset): |
| 120 | #0x08 NameOp NameString DataRef |
| 121 | if (aml[offset] != 0x08): |
| 122 | die( "Name offset 0x%x: expected 0x08 actual 0x%x" % |
| 123 | (offset, aml[offset])); |
| 124 | return offset + 1; |
| 125 | |
| 126 | # Given data offset, find dword const offset |
| 127 | def aml_data_dword_const(offset): |
| 128 | #0x08 NameOp NameString DataRef |
| 129 | if (aml[offset] != 0x0C): |
| 130 | die( "Name offset 0x%x: expected 0x0C actual 0x%x" % |
| 131 | (offset, aml[offset])); |
| 132 | return offset + 1; |
| 133 | |
| 134 | # Given data offset, find word const offset |
| 135 | def aml_data_word_const(offset): |
| 136 | #0x08 NameOp NameString DataRef |
| 137 | if (aml[offset] != 0x0B): |
| 138 | die( "Name offset 0x%x: expected 0x0B actual 0x%x" % |
| 139 | (offset, aml[offset])); |
| 140 | return offset + 1; |
| 141 | |
| 142 | # Given data offset, find byte const offset |
| 143 | def aml_data_byte_const(offset): |
| 144 | #0x08 NameOp NameString DataRef |
| 145 | if (aml[offset] != 0x0A): |
| 146 | die( "Name offset 0x%x: expected 0x0A actual 0x%x" % |
| 147 | (offset, aml[offset])); |
| 148 | return offset + 1; |
| 149 | |
| 150 | # Given name offset, find dword const offset |
| 151 | def aml_name_dword_const(offset): |
| 152 | return aml_data_dword_const(aml_name_string(offset) + 4) |
| 153 | |
| 154 | # Given name offset, find word const offset |
| 155 | def aml_name_word_const(offset): |
| 156 | return aml_data_word_const(aml_name_string(offset) + 4) |
| 157 | |
| 158 | # Given name offset, find byte const offset |
| 159 | def aml_name_byte_const(offset): |
| 160 | return aml_data_byte_const(aml_name_string(offset) + 4) |
| 161 | |
| 162 | def aml_processor_start(offset): |
| 163 | #0x5B 0x83 ProcessorOp PkgLength NameString ProcID |
| 164 | if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x83)): |
| 165 | die( "Name offset 0x%x: expected 0x5B 0x83 actual 0x%x 0x%x" % |
| 166 | (offset, aml[offset], aml[offset + 1])); |
| 167 | return offset |
| 168 | |
| 169 | def aml_processor_string(offset): |
| 170 | #0x5B 0x83 ProcessorOp PkgLength NameString ProcID |
| 171 | start = aml_processor_start(offset) |
| 172 | offset += 2 |
| 173 | pkglenbytes = aml_pkglen_bytes(offset) |
| 174 | offset += pkglenbytes |
| 175 | return offset |
| 176 | |
| 177 | def aml_processor_end(offset): |
| 178 | start = aml_processor_start(offset) |
| 179 | offset += 2 |
| 180 | pkglenbytes = aml_pkglen_bytes(offset) |
| 181 | pkglen = aml_pkglen(offset) |
| 182 | return offset + pkglen |
| 183 | |
| 184 | lineno = 0 |
| 185 | for line in fileinput.input(): |
| 186 | # Strip trailing newline |
| 187 | line = line.rstrip(); |
| 188 | # line number and debug string to output in case of errors |
| 189 | lineno = lineno + 1 |
| 190 | debug = "input line %d: %s" % (lineno, line) |
| 191 | #ASL listing: space, then line#, then ...., then code |
| 192 | pasl = re.compile('^\s+([0-9]+)\.\.\.\.\s*') |
| 193 | m = pasl.search(line) |
| 194 | if (m): |
| 195 | add_asl(lineno, pasl.sub("", line)); |
| 196 | # AML listing: offset in hex, then ...., then code |
| 197 | paml = re.compile('^([0-9A-Fa-f]+)\.\.\.\.\s*') |
| 198 | m = paml.search(line) |
| 199 | if (m): |
| 200 | add_aml(m.group(1), paml.sub("", line)) |
| 201 | |
| 202 | # Now go over code |
| 203 | # Track AML offset of a previous non-empty ASL command |
| 204 | prev_aml_offset = -1 |
| 205 | for i in range(len(asl)): |
| 206 | debug = "input line %d: %s" % (asl[i].lineno, asl[i].line) |
| 207 | |
| 208 | l = asl[i].line |
| 209 | |
| 210 | # skip if not an extract directive |
| 211 | a = len(re.findall(r'ACPI_EXTRACT', l)) |
| 212 | if (not a): |
| 213 | # If not empty, store AML offset. Will be used for sanity checks |
| 214 | # IASL seems to put {}. at random places in the listing. |
| 215 | # Ignore any non-words for the purpose of this test. |
| 216 | m = re.search(r'\w+', l) |
| 217 | if (m): |
| 218 | prev_aml_offset = asl[i].aml_offset |
| 219 | continue |
| 220 | |
| 221 | if (a > 1): |
| 222 | die("Expected at most one ACPI_EXTRACT per line, actual %d" % a) |
| 223 | |
| 224 | mext = re.search(r''' |
| 225 | ^\s* # leading whitespace |
| 226 | /\*\s* # start C comment |
| 227 | (ACPI_EXTRACT_\w+) # directive: group(1) |
| 228 | \s+ # whitspace separates directive from array name |
| 229 | (\w+) # array name: group(2) |
| 230 | \s*\*/ # end of C comment |
| 231 | \s*$ # trailing whitespace |
| 232 | ''', l, re.VERBOSE) |
| 233 | if (not mext): |
| 234 | die("Stray ACPI_EXTRACT in input") |
| 235 | |
| 236 | # previous command must have produced some AML, |
| 237 | # otherwise we are in a middle of a block |
| 238 | if (prev_aml_offset == asl[i].aml_offset): |
| 239 | die("ACPI_EXTRACT directive in the middle of a block") |
| 240 | |
| 241 | directive = mext.group(1) |
| 242 | array = mext.group(2) |
| 243 | offset = asl[i].aml_offset |
| 244 | |
Michael S. Tsirkin | 2e55b03 | 2011-10-26 23:28:02 +0200 | [diff] [blame] | 245 | if (directive == "ACPI_EXTRACT_ALL_CODE"): |
| 246 | if array in output: |
| 247 | die("%s directive used more than once" % directive) |
| 248 | output[array] = aml |
| 249 | continue |
Michael S. Tsirkin | 2597b75 | 2011-10-04 15:26:01 +0200 | [diff] [blame] | 250 | if (directive == "ACPI_EXTRACT_NAME_DWORD_CONST"): |
| 251 | offset = aml_name_dword_const(offset) |
| 252 | elif (directive == "ACPI_EXTRACT_NAME_WORD_CONST"): |
| 253 | offset = aml_name_word_const(offset) |
| 254 | elif (directive == "ACPI_EXTRACT_NAME_BYTE_CONST"): |
| 255 | offset = aml_name_byte_const(offset) |
| 256 | elif (directive == "ACPI_EXTRACT_NAME_STRING"): |
| 257 | offset = aml_name_string(offset) |
| 258 | elif (directive == "ACPI_EXTRACT_METHOD_STRING"): |
| 259 | offset = aml_method_string(offset) |
| 260 | elif (directive == "ACPI_EXTRACT_PROCESSOR_START"): |
| 261 | offset = aml_processor_start(offset) |
| 262 | elif (directive == "ACPI_EXTRACT_PROCESSOR_STRING"): |
| 263 | offset = aml_processor_string(offset) |
| 264 | elif (directive == "ACPI_EXTRACT_PROCESSOR_END"): |
| 265 | offset = aml_processor_end(offset) |
| 266 | else: |
| 267 | die("Unsupported directive %s" % directive) |
| 268 | |
| 269 | if array not in output: |
| 270 | output[array] = [] |
Michael S. Tsirkin | 2e55b03 | 2011-10-26 23:28:02 +0200 | [diff] [blame] | 271 | output[array].append(offset) |
Michael S. Tsirkin | 2597b75 | 2011-10-04 15:26:01 +0200 | [diff] [blame] | 272 | |
| 273 | debug = "at end of file" |
| 274 | |
Michael S. Tsirkin | 2e55b03 | 2011-10-26 23:28:02 +0200 | [diff] [blame] | 275 | def get_value_type(maxvalue): |
| 276 | #Use type large enough to fit the table |
| 277 | if (maxvalue >= 0x10000): |
| 278 | return "int" |
| 279 | elif (maxvalue >= 0x100): |
| 280 | return "short" |
| 281 | else: |
| 282 | return "char" |
Michael S. Tsirkin | 2597b75 | 2011-10-04 15:26:01 +0200 | [diff] [blame] | 283 | |
| 284 | # Pretty print output |
| 285 | for array in output.keys(): |
Michael S. Tsirkin | 2e55b03 | 2011-10-26 23:28:02 +0200 | [diff] [blame] | 286 | otype = get_value_type(max(output[array])) |
| 287 | odata = [] |
| 288 | for value in output[array]: |
| 289 | odata.append("0x%x" % value) |
| 290 | sys.stdout.write("static unsigned %s %s[] = {\n" % (otype, array)) |
| 291 | sys.stdout.write(",\n".join(odata)) |
Michael S. Tsirkin | 2597b75 | 2011-10-04 15:26:01 +0200 | [diff] [blame] | 292 | sys.stdout.write('\n};\n'); |