nexmon – Blame information for rev 1
?pathlinks?
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 1 | office | 1 | """ |
| 2 | # b43 debugging library |
||
| 3 | # |
||
| 4 | # Copyright (C) 2008-2010 Michael Buesch <m@bues.ch> |
||
| 5 | # |
||
| 6 | # This program is free software: you can redistribute it and/or modify |
||
| 7 | # it under the terms of the GNU General Public License version 3 |
||
| 8 | # as published by the Free Software Foundation. |
||
| 9 | # |
||
| 10 | # This program is distributed in the hope that it will be useful, |
||
| 11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
| 12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
| 13 | # GNU General Public License for more details. |
||
| 14 | # |
||
| 15 | # You should have received a copy of the GNU General Public License |
||
| 16 | # along with this program. If not, see <http://www.gnu.org/licenses/>. |
||
| 17 | """ |
||
| 18 | |||
| 19 | import sys |
||
| 20 | import os |
||
| 21 | import re |
||
| 22 | import hashlib |
||
| 23 | from tempfile import * |
||
| 24 | |||
| 25 | |||
| 26 | # SHM routing values |
||
| 27 | B43_SHM_UCODE = 0 |
||
| 28 | B43_SHM_SHARED = 1 |
||
| 29 | B43_SHM_REGS = 2 |
||
| 30 | B43_SHM_IHR = 3 |
||
| 31 | B43_SHM_RCMTA = 4 |
||
| 32 | |||
| 33 | |||
| 34 | class B43Exception(Exception): |
||
| 35 | pass |
||
| 36 | |||
| 37 | |||
| 38 | B43_MMIO_MACCTL = 0x120 |
||
| 39 | B43_MMIO_PSMDEBUG = 0x154 |
||
| 40 | |||
| 41 | B43_MACCTL_PSM_MACEN = 0x00000001 |
||
| 42 | B43_MACCTL_PSM_RUN = 0x00000002 |
||
| 43 | B43_MACCTL_PSM_JMP0 = 0x00000004 |
||
| 44 | B43_MACCTL_PSM_DEBUG = 0x00002000 |
||
| 45 | |||
| 46 | |||
| 47 | class B43PsmDebug: |
||
| 48 | """Parse the contents of the PSM-debug register""" |
||
| 49 | def __init__(self, reg_content): |
||
| 50 | self.raw = reg_content |
||
| 51 | return |
||
| 52 | |||
| 53 | def getRaw(self): |
||
| 54 | """Get the raw PSM-debug register value""" |
||
| 55 | return self.raw |
||
| 56 | |||
| 57 | def getPc(self): |
||
| 58 | """Get the microcode program counter""" |
||
| 59 | return self.raw & 0xFFF |
||
| 60 | |||
| 61 | |||
| 62 | class B43: |
||
| 63 | """Hardware access layer. This accesses the hardware through the debugfs interface.""" |
||
| 64 | |||
| 65 | def __init__(self, phy=None): |
||
| 66 | debugfs_path = self.__debugfs_find() |
||
| 67 | |||
| 68 | # Construct the debugfs b43 path to the device |
||
| 69 | b43_path = debugfs_path + "/b43/" |
||
| 70 | if phy: |
||
| 71 | b43_path += phy |
||
| 72 | else: |
||
| 73 | # Get the PHY. |
||
| 74 | try: |
||
| 75 | phys = os.listdir(b43_path) |
||
| 76 | except OSError: |
||
| 77 | print "Could not find B43's debugfs directory: %s" % b43_path |
||
| 78 | raise B43Exception |
||
| 79 | if not phys: |
||
| 80 | print "Could not find any b43 device" |
||
| 81 | raise B43Exception |
||
| 82 | if len(phys) != 1: |
||
| 83 | print "Found multiple b43 devices." |
||
| 84 | print "You must call this tool with a phyX parameter to specify a device" |
||
| 85 | raise B43Exception |
||
| 86 | phy = phys[0] |
||
| 87 | b43_path += phy; |
||
| 88 | |||
| 89 | # Open the debugfs files |
||
| 90 | try: |
||
| 91 | self.f_mmio16read = file(b43_path + "/mmio16read", "r+") |
||
| 92 | self.f_mmio16write = file(b43_path + "/mmio16write", "w") |
||
| 93 | self.f_mmio32read = file(b43_path + "/mmio32read", "r+") |
||
| 94 | self.f_mmio32write = file(b43_path + "/mmio32write", "w") |
||
| 95 | self.f_shm16read = file(b43_path + "/shm16read", "r+") |
||
| 96 | self.f_shm16write = file(b43_path + "/shm16write", "w") |
||
| 97 | self.f_shm32read = file(b43_path + "/shm32read", "r+") |
||
| 98 | self.f_shm32write = file(b43_path + "/shm32write", "w") |
||
| 99 | except IOError, e: |
||
| 100 | print "Could not open debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 101 | raise B43Exception |
||
| 102 | |||
| 103 | self.b43_path = b43_path |
||
| 104 | return |
||
| 105 | |||
| 106 | # Get the debugfs mountpoint. |
||
| 107 | def __debugfs_find(self): |
||
| 108 | mtab = file("/etc/mtab").read().splitlines() |
||
| 109 | regexp = re.compile(r"^[\w\-_]+\s+([\w/\-_]+)\s+debugfs") |
||
| 110 | path = None |
||
| 111 | for line in mtab: |
||
| 112 | m = regexp.match(line) |
||
| 113 | if m: |
||
| 114 | path = m.group(1) |
||
| 115 | break |
||
| 116 | if not path: |
||
| 117 | print "Could not find debugfs in /etc/mtab" |
||
| 118 | raise B43Exception |
||
| 119 | return path |
||
| 120 | |||
| 121 | def read16(self, reg): |
||
| 122 | """Do a 16bit MMIO read""" |
||
| 123 | try: |
||
| 124 | self.f_mmio16read.seek(0) |
||
| 125 | self.f_mmio16read.write("0x%X" % reg) |
||
| 126 | self.f_mmio16read.flush() |
||
| 127 | self.f_mmio16read.seek(0) |
||
| 128 | val = self.f_mmio16read.read() |
||
| 129 | except IOError, e: |
||
| 130 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 131 | raise B43Exception |
||
| 132 | return int(val, 16) |
||
| 133 | |||
| 134 | def read32(self, reg): |
||
| 135 | """Do a 32bit MMIO read""" |
||
| 136 | try: |
||
| 137 | self.f_mmio32read.seek(0) |
||
| 138 | self.f_mmio32read.write("0x%X" % reg) |
||
| 139 | self.f_mmio32read.flush() |
||
| 140 | self.f_mmio32read.seek(0) |
||
| 141 | val = self.f_mmio32read.read() |
||
| 142 | except IOError, e: |
||
| 143 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 144 | raise B43Exception |
||
| 145 | return int(val, 16) |
||
| 146 | |||
| 147 | def maskSet16(self, reg, mask, set): |
||
| 148 | """Do a 16bit MMIO mask-and-set operation""" |
||
| 149 | try: |
||
| 150 | mask &= 0xFFFF |
||
| 151 | set &= 0xFFFF |
||
| 152 | self.f_mmio16write.seek(0) |
||
| 153 | self.f_mmio16write.write("0x%X 0x%X 0x%X" % (reg, mask, set)) |
||
| 154 | self.f_mmio16write.flush() |
||
| 155 | except IOError, e: |
||
| 156 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 157 | raise B43Exception |
||
| 158 | return |
||
| 159 | |||
| 160 | def write16(self, reg, value): |
||
| 161 | """Do a 16bit MMIO write""" |
||
| 162 | self.maskSet16(reg, 0, value) |
||
| 163 | return |
||
| 164 | |||
| 165 | def maskSet32(self, reg, mask, set): |
||
| 166 | """Do a 32bit MMIO mask-and-set operation""" |
||
| 167 | try: |
||
| 168 | mask &= 0xFFFFFFFF |
||
| 169 | set &= 0xFFFFFFFF |
||
| 170 | self.f_mmio32write.seek(0) |
||
| 171 | self.f_mmio32write.write("0x%X 0x%X 0x%X" % (reg, mask, set)) |
||
| 172 | self.f_mmio32write.flush() |
||
| 173 | except IOError, e: |
||
| 174 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 175 | raise B43Exception |
||
| 176 | return |
||
| 177 | |||
| 178 | def write32(self, reg, value): |
||
| 179 | """Do a 32bit MMIO write""" |
||
| 180 | self.maskSet32(reg, 0, value) |
||
| 181 | return |
||
| 182 | |||
| 183 | def shmRead16(self, routing, offset): |
||
| 184 | """Do a 16bit SHM read""" |
||
| 185 | try: |
||
| 186 | self.f_shm16read.seek(0) |
||
| 187 | self.f_shm16read.write("0x%X 0x%X" % (routing, offset)) |
||
| 188 | self.f_shm16read.flush() |
||
| 189 | self.f_shm16read.seek(0) |
||
| 190 | val = self.f_shm16read.read() |
||
| 191 | except IOError, e: |
||
| 192 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 193 | raise B43Exception |
||
| 194 | return int(val, 16) |
||
| 195 | |||
| 196 | def shmMaskSet16(self, routing, offset, mask, set): |
||
| 197 | """Do a 16bit SHM mask-and-set operation""" |
||
| 198 | try: |
||
| 199 | mask &= 0xFFFF |
||
| 200 | set &= 0xFFFF |
||
| 201 | self.f_shm16write.seek(0) |
||
| 202 | self.f_shm16write.write("0x%X 0x%X 0x%X 0x%X" % (routing, offset, mask, set)) |
||
| 203 | self.f_shm16write.flush() |
||
| 204 | except IOError, e: |
||
| 205 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 206 | raise B43Exception |
||
| 207 | return |
||
| 208 | |||
| 209 | def shmWrite16(self, routing, offset, value): |
||
| 210 | """Do a 16bit SHM write""" |
||
| 211 | self.shmMaskSet16(routing, offset, 0, value) |
||
| 212 | return |
||
| 213 | |||
| 214 | def shmRead32(self, routing, offset): |
||
| 215 | """Do a 32bit SHM read""" |
||
| 216 | try: |
||
| 217 | self.f_shm32read.seek(0) |
||
| 218 | self.f_shm32read.write("0x%X 0x%X" % (routing, offset)) |
||
| 219 | self.f_shm32read.flush() |
||
| 220 | self.f_shm32read.seek(0) |
||
| 221 | val = self.f_shm32read.read() |
||
| 222 | except IOError, e: |
||
| 223 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 224 | raise B43Exception |
||
| 225 | return int(val, 16) |
||
| 226 | |||
| 227 | def shmMaskSet32(self, routing, offset, mask, set): |
||
| 228 | """Do a 32bit SHM mask-and-set operation""" |
||
| 229 | try: |
||
| 230 | mask &= 0xFFFFFFFF |
||
| 231 | set &= 0xFFFFFFFF |
||
| 232 | self.f_shm32write.seek(0) |
||
| 233 | self.f_shm32write.write("0x%X 0x%X 0x%X 0x%X" % (routing, offset, mask, set)) |
||
| 234 | self.f_shm32write.flush() |
||
| 235 | except IOError, e: |
||
| 236 | print "Could not access debugfs file %s: %s" % (e.filename, e.strerror) |
||
| 237 | raise B43Exception |
||
| 238 | return |
||
| 239 | |||
| 240 | def shmWrite32(self, routing, offset, value): |
||
| 241 | """Do a 32bit SHM write""" |
||
| 242 | self.shmMaskSet32(routing, offset, 0, value) |
||
| 243 | return |
||
| 244 | |||
| 245 | def getGprs(self): |
||
| 246 | """Returns an array of 64 ints. One for each General Purpose register.""" |
||
| 247 | ret = [] |
||
| 248 | for i in range(0, 64): |
||
| 249 | val = self.shmRead16(B43_SHM_REGS, i) |
||
| 250 | ret.append(val) |
||
| 251 | return ret |
||
| 252 | |||
| 253 | def getLinkRegs(self): |
||
| 254 | """Returns an array of 4 ints. One for each Link Register.""" |
||
| 255 | ret = [] |
||
| 256 | for i in range(0, 4): |
||
| 257 | val = self.read16(0x4D0 + (i * 2)) |
||
| 258 | ret.append(val) |
||
| 259 | return ret |
||
| 260 | |||
| 261 | def getOffsetRegs(self): |
||
| 262 | """Returns an array of 7 ints. One for each Offset Register.""" |
||
| 263 | ret = [] |
||
| 264 | for i in range(0, 7): |
||
| 265 | val = self.read16(0x4C0 + (i * 2)) |
||
| 266 | ret.append(val) |
||
| 267 | return ret |
||
| 268 | |||
| 269 | def shmSharedRead(self): |
||
| 270 | """Returns a string containing the SHM contents.""" |
||
| 271 | ret = "" |
||
| 272 | for i in range(0, 4096, 4): |
||
| 273 | val = self.shmRead32(B43_SHM_SHARED, i) |
||
| 274 | ret += "%c%c%c%c" % (val & 0xFF, |
||
| 275 | (val >> 8) & 0xFF, |
||
| 276 | (val >> 16) & 0xFF, |
||
| 277 | (val >> 24) & 0xFF) |
||
| 278 | return ret |
||
| 279 | |||
| 280 | def getPsmDebug(self): |
||
| 281 | """Read the PSM-debug register and return an instance of B43PsmDebug.""" |
||
| 282 | val = self.read32(B43_MMIO_PSMDEBUG) |
||
| 283 | return B43PsmDebug(val) |
||
| 284 | |||
| 285 | def getPsmConditions(self): |
||
| 286 | """This returns the contents of the programmable-PSM-conditions register.""" |
||
| 287 | return self.read16(0x4D8) |
||
| 288 | |||
| 289 | def ucodeStop(self): |
||
| 290 | """Unconditionally stop the microcode PSM. """ |
||
| 291 | self.maskSet32(B43_MMIO_MACCTL, ~B43_MACCTL_PSM_RUN, 0) |
||
| 292 | return |
||
| 293 | |||
| 294 | def ucodeStart(self): |
||
| 295 | """Unconditionally start the microcode PSM. This will restart the |
||
| 296 | microcode on the current PC. It will not jump to 0. Warning: This will |
||
| 297 | unconditionally restart the PSM and ignore any driver-state!""" |
||
| 298 | self.maskSet32(B43_MMIO_MACCTL, ~0, B43_MACCTL_PSM_RUN) |
||
| 299 | return |
||
| 300 | |||
| 301 | class Disassembler: |
||
| 302 | """Disassembler for b43 firmware.""" |
||
| 303 | def __init__(self, binaryText, b43DasmOpts): |
||
| 304 | input = NamedTemporaryFile() |
||
| 305 | output = NamedTemporaryFile() |
||
| 306 | |||
| 307 | input.write(binaryText) |
||
| 308 | input.flush() |
||
| 309 | #FIXME check b43-dasm errors |
||
| 310 | os.system("b43-dasm %s %s %s" % (input.name, output.name, b43DasmOpts)) |
||
| 311 | |||
| 312 | self.asmText = output.read() |
||
| 313 | |||
| 314 | def getAsm(self): |
||
| 315 | """Returns the assembly code.""" |
||
| 316 | return self.asmText |
||
| 317 | |||
| 318 | class Assembler: |
||
| 319 | """Assembler for b43 firmware.""" |
||
| 320 | def __init__(self, assemblyText, b43AsmOpts): |
||
| 321 | input = NamedTemporaryFile() |
||
| 322 | output = NamedTemporaryFile() |
||
| 323 | |||
| 324 | input.write(assemblyText) |
||
| 325 | input.flush() |
||
| 326 | #FIXME check b43-asm errors |
||
| 327 | os.system("b43-asm %s %s %s" % (input.name, output.name, b43AsmOpts)) |
||
| 328 | |||
| 329 | self.binaryText = output.read() |
||
| 330 | |||
| 331 | def getBinary(self): |
||
| 332 | """Returns the binary code.""" |
||
| 333 | return self.binaryText |
||
| 334 | |||
| 335 | class TextPatcher: |
||
| 336 | """A textfile patcher that does not include any target context. |
||
| 337 | This can be used to patch b43 firmware files.""" |
||
| 338 | |||
| 339 | class TextLine: |
||
| 340 | def __init__(self, index, line): |
||
| 341 | self.index = index |
||
| 342 | self.line = line |
||
| 343 | self.deleted = False |
||
| 344 | |||
| 345 | def __init__(self, text, expected_md5sum): |
||
| 346 | sum = hashlib.md5(text).hexdigest() |
||
| 347 | if sum != expected_md5sum: |
||
| 348 | print "Patcher: The text does not match the expected MD5 sum" |
||
| 349 | print "Expected: " + expected_md5sum |
||
| 350 | print "Calculated: " + sum |
||
| 351 | raise B43Exception |
||
| 352 | text = text.splitlines() |
||
| 353 | self.lines = [] |
||
| 354 | i = 0 |
||
| 355 | for line in text: |
||
| 356 | self.lines.append(TextPatcher.TextLine(i, line)) |
||
| 357 | i += 1 |
||
| 358 | # Add an after-last dummy. Needed for the add-before logic |
||
| 359 | lastDummy = TextPatcher.TextLine(i, "") |
||
| 360 | lastDummy.deleted = True |
||
| 361 | self.lines.append(lastDummy) |
||
| 362 | |||
| 363 | def getText(self): |
||
| 364 | """This returns the current text.""" |
||
| 365 | textLines = [] |
||
| 366 | for l in self.lines: |
||
| 367 | if not l.deleted: |
||
| 368 | textLines.append(l.line) |
||
| 369 | return "\n".join(textLines) |
||
| 370 | |||
| 371 | def delLine(self, linenumber): |
||
| 372 | """Delete a line of text. The linenumber corresponds to the |
||
| 373 | original unmodified text.""" |
||
| 374 | for l in self.lines: |
||
| 375 | if l.index == linenumber: |
||
| 376 | l.deleted = True |
||
| 377 | return |
||
| 378 | print "Patcher deleteLine: Did not find the line!" |
||
| 379 | raise B43Exception |
||
| 380 | |||
| 381 | def addText(self, beforeLineNumber, text): |
||
| 382 | """Add a text before the specified linenumber. The linenumber |
||
| 383 | corresponds to the original unmodified text.""" |
||
| 384 | text = text.splitlines() |
||
| 385 | index = 0 |
||
| 386 | for l in self.lines: |
||
| 387 | if l.index == beforeLineNumber: |
||
| 388 | break |
||
| 389 | index += 1 |
||
| 390 | if index >= len(self.lines): |
||
| 391 | print "Patcher addText: Did not find the line!" |
||
| 392 | raise B43Exception |
||
| 393 | for l in text: |
||
| 394 | self.lines.insert(index, TextPatcher.TextLine(-1, l)) |
||
| 395 | index += 1 |
||
| 396 | |||
| 397 | class B43SymbolicSpr: |
||
| 398 | """This class converts numeric SPR names into symbolic SPR names.""" |
||
| 399 | |||
| 400 | def __init__(self, header_file): |
||
| 401 | """The passed header_file parameter is a file path to the |
||
| 402 | assembly file containing the symbolic SPR definitions.""" |
||
| 403 | try: |
||
| 404 | defs = file(header_file).readlines() |
||
| 405 | except IOError, e: |
||
| 406 | print "B43SymbolicSpr: Could not read %s: %s" % (e.filename, e.strerror) |
||
| 407 | B43Exception |
||
| 408 | # Parse the definitions |
||
| 409 | self.spr_names = { } |
||
| 410 | r = re.compile(r"#define\s+(\w+)\s+(spr[a-fA-F0-9]+)") |
||
| 411 | for line in defs: |
||
| 412 | m = r.match(line) |
||
| 413 | if not m: |
||
| 414 | continue # unknown line |
||
| 415 | name = m.group(1) |
||
| 416 | offset = m.group(2) |
||
| 417 | self.spr_names[offset.lower()] = name |
||
| 418 | |||
| 419 | def get(self, spr): |
||
| 420 | """Get the symbolic name for an SPR. The spr parameter |
||
| 421 | must be a string like "sprXXX", where XXX is a hex number.""" |
||
| 422 | try: |
||
| 423 | spr = self.spr_names[spr.lower()] |
||
| 424 | except KeyError: |
||
| 425 | pass # Symbol not found. Return numeric name. |
||
| 426 | return spr |
||
| 427 | |||
| 428 | def getRaw(self, spr_hexnumber): |
||
| 429 | """Get the symbolic name for an SPR. The spr_hexnumber |
||
| 430 | parameter is the hexadecimal number for the SPR.""" |
||
| 431 | return self.get("spr%03X" % spr_hexnumber) |
||
| 432 | |||
| 433 | class B43SymbolicShm: |
||
| 434 | """This class converts numeric SHM offsets into symbolic SHM names.""" |
||
| 435 | |||
| 436 | def __init__(self, header_file): |
||
| 437 | """The passed header_file parameter is a file path to the |
||
| 438 | assembly file containing the symbolic SHM definitions.""" |
||
| 439 | try: |
||
| 440 | defs = file(header_file).readlines() |
||
| 441 | except IOError, e: |
||
| 442 | print "B43SymbolicShm: Could not read %s: %s" % (e.filename, e.strerror) |
||
| 443 | raise B43Exception |
||
| 444 | # Parse the definitions |
||
| 445 | self.shm_names = { } |
||
| 446 | in_abi_section = False |
||
| 447 | r = re.compile(r"#define\s+(\w+)\s+SHM\((\w+)\).*") |
||
| 448 | for line in defs: |
||
| 449 | if line.startswith("/* BEGIN ABI"): |
||
| 450 | in_abi_section = True |
||
| 451 | if line.startswith("/* END ABI"): |
||
| 452 | in_abi_section = False |
||
| 453 | if not in_abi_section: |
||
| 454 | continue # Only parse ABI definitions |
||
| 455 | m = r.match(line) |
||
| 456 | if not m: |
||
| 457 | continue # unknown line |
||
| 458 | name = m.group(1) |
||
| 459 | offset = int(m.group(2), 16) |
||
| 460 | offset /= 2 |
||
| 461 | self.shm_names[offset] = name |
||
| 462 | |||
| 463 | def get(self, shm_wordoffset): |
||
| 464 | """Get the symbolic name for an SHM offset.""" |
||
| 465 | try: |
||
| 466 | sym = self.shm_names[shm_wordoffset] |
||
| 467 | except KeyError: |
||
| 468 | # Symbol not found. Return numeric name. |
||
| 469 | sym = "0x%03X" % shm_wordoffset |
||
| 470 | return sym |
||
| 471 | |||
| 472 | class B43SymbolicCondition: |
||
| 473 | """This class converts numeric External Conditions into symbolic names.""" |
||
| 474 | |||
| 475 | def __init__(self, header_file): |
||
| 476 | """The passed header_file parameter is a file path to the |
||
| 477 | assembly file containing the symbolic condition definitions.""" |
||
| 478 | try: |
||
| 479 | defs = file(header_file).readlines() |
||
| 480 | except IOError, e: |
||
| 481 | print "B43SymbolicCondition: Could not read %s: %s" % (e.filename, e.strerror) |
||
| 482 | raise B43Exception |
||
| 483 | # Parse the definitions |
||
| 484 | self.cond_names = { } |
||
| 485 | r = re.compile(r"#define\s+(\w+)\s+EXTCOND\(\s*(\w+),\s*(\d+)\s*\).*") |
||
| 486 | for line in defs: |
||
| 487 | m = r.match(line) |
||
| 488 | if not m: |
||
| 489 | continue # unknown line |
||
| 490 | name = m.group(1) |
||
| 491 | register = m.group(2) |
||
| 492 | bit = int(m.group(3)) |
||
| 493 | if register == "CONDREG_RX": |
||
| 494 | register = 0 |
||
| 495 | elif register == "CONDREG_TX": |
||
| 496 | register = 2 |
||
| 497 | elif register == "CONDREG_PHY": |
||
| 498 | register = 3 |
||
| 499 | elif register == "CONDREG_4": |
||
| 500 | register = 4 |
||
| 501 | elif register == "CONDREG_PSM": |
||
| 502 | continue # No lookup table for this one |
||
| 503 | elif register == "CONDREG_RCM": |
||
| 504 | register = 6 |
||
| 505 | elif register == "CONDREG_7": |
||
| 506 | register = 7 |
||
| 507 | else: |
||
| 508 | continue # unknown register |
||
| 509 | cond_number = bit | (register << 4) |
||
| 510 | self.cond_names[cond_number] = name |
||
| 511 | |||
| 512 | def get(self, cond_number): |
||
| 513 | """Get the symbolic name for an External Condition.""" |
||
| 514 | register = (cond_number >> 4) & 0x7 |
||
| 515 | bit = cond_number & 0xF |
||
| 516 | eoi = ((cond_number & 0x80) != 0) |
||
| 517 | cond_number &= ~0x80 |
||
| 518 | if register == 5: # PSM register |
||
| 519 | return "COND_PSM(%d)" % bit |
||
| 520 | try: |
||
| 521 | sym = self.cond_names[cond_number] |
||
| 522 | except KeyError: |
||
| 523 | # Symbol not found. Return numeric name. |
||
| 524 | sym = "0x%02X" % cond_number |
||
| 525 | if eoi: |
||
| 526 | sym = "EOI(%s)" % sym |
||
| 527 | return sym |
||
| 528 | |||
| 529 | class B43AsmLine: |
||
| 530 | def __init__(self, text): |
||
| 531 | self.text = text |
||
| 532 | |||
| 533 | def getLine(self): |
||
| 534 | return self.text |
||
| 535 | |||
| 536 | def __repr__(self): |
||
| 537 | return self.getLine() |
||
| 538 | |||
| 539 | def isInstruction(self): |
||
| 540 | return False |
||
| 541 | |||
| 542 | class B43AsmInstruction(B43AsmLine): |
||
| 543 | def __init__(self, opcode): |
||
| 544 | self.setOpcode(opcode) |
||
| 545 | self.clearOperands() |
||
| 546 | |||
| 547 | def getOpcode(self): |
||
| 548 | return self.opcode |
||
| 549 | |||
| 550 | def setOpcode(self, opcode): |
||
| 551 | self.opcode = opcode |
||
| 552 | |||
| 553 | def clearOperands(self): |
||
| 554 | self.operands = [] |
||
| 555 | |||
| 556 | def addOperand(self, operand): |
||
| 557 | self.operands.append(operand) |
||
| 558 | |||
| 559 | def getOperands(self): |
||
| 560 | return self.operands |
||
| 561 | |||
| 562 | def getLine(self): |
||
| 563 | ret = "\t" + self.opcode |
||
| 564 | if self.operands: |
||
| 565 | ret += "\t" |
||
| 566 | for op in self.operands: |
||
| 567 | ret += op + ", " |
||
| 568 | if self.operands: |
||
| 569 | ret = ret[:-2] |
||
| 570 | return ret |
||
| 571 | |||
| 572 | def isInstruction(self): |
||
| 573 | return True |
||
| 574 | |||
| 575 | class B43AsmParser: |
||
| 576 | """A simple B43 assembly code parser.""" |
||
| 577 | |||
| 578 | def __init__(self, asm_code): |
||
| 579 | self.__parse_code(asm_code) |
||
| 580 | |||
| 581 | def __parse_code(self, asm_code): |
||
| 582 | self.codelines = [] |
||
| 583 | label = re.compile(r"^\s*\w+:\s*$") |
||
| 584 | insn_0 = re.compile(r"^\s*([@\.\w]+)\s*$") |
||
| 585 | insn_2 = re.compile(r"^\s*([@\.\w]+)\s+([@\[\],\w]+),\s*([@\[\],\w]+)\s*$") |
||
| 586 | insn_3 = re.compile(r"^\s*([@\.\w]+)\s+([@\[\],\w]+),\s*([@\[\],\w]+),\s*([@\[\],\w]+)\s*$") |
||
| 587 | insn_5 = re.compile(r"^\s*([@\.\w]+)\s+([@\[\],\w]+),\s*([@\[\],\w]+),\s*([@\[\],\w]+),\s*([@\[\],\w]+),\s*([@\[\],\w]+)\s*$") |
||
| 588 | for line in asm_code.splitlines(): |
||
| 589 | m = label.match(line) |
||
| 590 | if m: # Label: |
||
| 591 | l = B43AsmLine(line) |
||
| 592 | self.codelines.append(l) |
||
| 593 | continue |
||
| 594 | m = insn_0.match(line) |
||
| 595 | if m: # No operands |
||
| 596 | insn = B43AsmInstruction(m.group(1)) |
||
| 597 | self.codelines.append(insn) |
||
| 598 | continue |
||
| 599 | m = insn_2.match(line) |
||
| 600 | if m: # Two operands |
||
| 601 | insn = B43AsmInstruction(m.group(1)) |
||
| 602 | insn.addOperand(m.group(2)) |
||
| 603 | insn.addOperand(m.group(3)) |
||
| 604 | self.codelines.append(insn) |
||
| 605 | continue |
||
| 606 | m = insn_3.match(line) |
||
| 607 | if m: # Three operands |
||
| 608 | insn = B43AsmInstruction(m.group(1)) |
||
| 609 | insn.addOperand(m.group(2)) |
||
| 610 | insn.addOperand(m.group(3)) |
||
| 611 | insn.addOperand(m.group(4)) |
||
| 612 | self.codelines.append(insn) |
||
| 613 | continue |
||
| 614 | m = insn_5.match(line) |
||
| 615 | if m: # Three operands |
||
| 616 | insn = B43AsmInstruction(m.group(1)) |
||
| 617 | insn.addOperand(m.group(2)) |
||
| 618 | insn.addOperand(m.group(3)) |
||
| 619 | insn.addOperand(m.group(4)) |
||
| 620 | insn.addOperand(m.group(5)) |
||
| 621 | insn.addOperand(m.group(6)) |
||
| 622 | self.codelines.append(insn) |
||
| 623 | continue |
||
| 624 | # Unknown line |
||
| 625 | l = B43AsmLine(line) |
||
| 626 | self.codelines.append(l) |
||
| 627 | |||
| 628 | class B43Beautifier(B43AsmParser): |
||
| 629 | """A B43 assembly code beautifier.""" |
||
| 630 | |||
| 631 | def __init__(self, asm_code, headers_dir): |
||
| 632 | """asm_code is the assembly code. headers_dir is a full |
||
| 633 | path to the directory containing the symbolic SPR,SHM,etc... definitions""" |
||
| 634 | if headers_dir.endswith("/"): |
||
| 635 | headers_dir = headers_dir[:-1] |
||
| 636 | B43AsmParser.__init__(self, asm_code) |
||
| 637 | self.symSpr = B43SymbolicSpr(headers_dir + "/spr.inc") |
||
| 638 | self.symShm = B43SymbolicShm(headers_dir + "/shm.inc") |
||
| 639 | self.symCond = B43SymbolicCondition(headers_dir + "/cond.inc") |
||
| 640 | self.preamble = "#include \"%s/spr.inc\"\n" % headers_dir |
||
| 641 | self.preamble += "#include \"%s/shm.inc\"\n" % headers_dir |
||
| 642 | self.preamble += "#include \"%s/cond.inc\"\n" % headers_dir |
||
| 643 | self.preamble += "\n" |
||
| 644 | self.__process_code() |
||
| 645 | |||
| 646 | def __process_code(self): |
||
| 647 | spr_re = re.compile(r"^spr\w\w\w$") |
||
| 648 | shm_re = re.compile(r"^\[(0x\w+)\]$") |
||
| 649 | code = self.codelines |
||
| 650 | for line in code: |
||
| 651 | if not line.isInstruction(): |
||
| 652 | continue |
||
| 653 | opcode = line.getOpcode() |
||
| 654 | operands = line.getOperands() |
||
| 655 | # Transform unconditional jump |
||
| 656 | if opcode == "jext" and int(operands[0], 16) == 0x7F: |
||
| 657 | label = operands[1] |
||
| 658 | line.setOpcode("jmp") |
||
| 659 | line.clearOperands() |
||
| 660 | line.addOperand(label) |
||
| 661 | continue |
||
| 662 | # Transform external conditions |
||
| 663 | if opcode == "jext" or opcode == "jnext": |
||
| 664 | operands[0] = self.symCond.get(int(operands[0], 16)) |
||
| 665 | continue |
||
| 666 | # Transform orx 7,8,imm,imm,target to mov |
||
| 667 | if opcode == "orx" and \ |
||
| 668 | int(operands[0], 16) == 7 and int(operands[1], 16) == 8 and\ |
||
| 669 | operands[2].startswith("0x") and operands[3].startswith("0x"): |
||
| 670 | value = int(operands[3], 16) & 0xFF |
||
| 671 | value |= (int(operands[2], 16) & 0xFF) << 8 |
||
| 672 | target = operands[4] |
||
| 673 | line.setOpcode("mov") |
||
| 674 | line.clearOperands() |
||
| 675 | line.addOperand("0x%X" % value) |
||
| 676 | line.addOperand(target) |
||
| 677 | opcode = line.getOpcode() |
||
| 678 | operands = line.getOperands() |
||
| 679 | for i in range(0, len(operands)): |
||
| 680 | o = operands[i] |
||
| 681 | # Transform SPR operands |
||
| 682 | m = spr_re.match(o) |
||
| 683 | if m: |
||
| 684 | operands[i] = self.symSpr.get(o) |
||
| 685 | continue |
||
| 686 | # Transform SHM operands |
||
| 687 | m = shm_re.match(o) |
||
| 688 | if m: |
||
| 689 | offset = int(m.group(1), 16) |
||
| 690 | operands[i] = "[" + self.symShm.get(offset) + "]" |
||
| 691 | continue |
||
| 692 | |||
| 693 | def getAsm(self): |
||
| 694 | """Returns the beautified asm code.""" |
||
| 695 | ret = [ self.preamble ] |
||
| 696 | for line in self.codelines: |
||
| 697 | ret.append(str(line)) |
||
| 698 | return "\n".join(ret) |