Ejemplo n.º 1
0
def uart_rx():
    print("+++ Sending UART discovery rx command")
    request_args = []
    bs.NewTimeout(120)
    rv = bs.requestreply(11, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv

    ngpio = 9
    for i in range(ngpio):
        changes = bs_reply_args[5*i + 0]
        print("+++ GPIO %d has %d signal changes" % (i+1, changes))
        if changes > 0:
            databits = bs_reply_args[5*i + 1]
            if databits > 0:
                stopbits = bs_reply_args[5*i + 2]
                parity = bs_reply_args[5*i + 3]
                baudrate = bs_reply_args[5*i + 4]
                print("+++ UART FOUND")
                print("+++ DATABITS: %d" % (databits))
                print("+++ STOPBITS: %d" % (stopbits))
                if parity == 0:
                    print("+++ PARITY: EVEN")
                elif parity == 1:
                    print("+++ PARITY: ODD")
                else:
                    print("+++ PARITY: NONE")
                print("+++ BAUDRATE: %d" % (baudrate))
    print("+++ SUCCESS")
    return (bs_reply_length, bs_reply_args)
Ejemplo n.º 2
0
def i2c_write_flash(sda, scl, slave, alen, dumpsize, infile):
    bs.NewTimeout(5)
    skip = 0
    print("+++ Writing I2C")
    with open(infile, 'rb') as f:
        while dumpsize > 0:
            if dumpsize < WRITEBLOCKSIZE:
                size = dumpsize
            else:
                size = WRITEBLOCKSIZE
            f.seek(skip)
            rawdata = f.read(size)
            data = list(range(size / 4))
            for i in range(size / 4):
                a = ord(rawdata[4 * i + 0])
                b = ord(rawdata[4 * i + 1])
                c = ord(rawdata[4 * i + 2])
                d = ord(rawdata[4 * i + 3])
                data[i] = (d << 24) + (c << 16) + (b << 8) + a
            rv = writeI2C(sda, scl, slave, size, skip, alen, data)
            if rv is None:
                print("Timeout")
                return None
            skip = skip + WRITEBLOCKSIZE
            dumpsize = dumpsize - size
        print("+++ SUCCESS\n")
        return (1, 1)
Ejemplo n.º 3
0
def spi_fuzz(cs, clk, mosi, miso):
    print("+++ Sending spi fuzz command")
    request_args = [1000000, cs, clk, mosi, miso]
    bs.NewTimeout(60)
    rv = bs.requestreply(35, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv

    n = bs_reply_length / (4 * 6)
    print("+++ FOUND %d SPI commands" % (n))
    for i in range(n):
        cmd = bs_reply_args[i * 6 + 0]
        v1 = bs_reply_args[i * 6 + 1]
        v2 = bs_reply_args[i * 6 + 2]
        v3 = bs_reply_args[i * 6 + 3]
        v4 = bs_reply_args[i * 6 + 4]
        v5 = bs_reply_args[i * 6 + 5]
        print("+++ SPI command FOUND")
        print("+++ SPI command %.2x" % (cmd))
        print("+++ SPI v1 %.2x" % (v1))
        print("+++ SPI v2 %.2x" % (v2))
        print("+++ SPI v3 %.2x" % (v3))
        print("+++ SPI v4 %.2x" % (v4))
        print("+++ SPI v5 %.2x" % (v5))
    print("+++ SUCCESS\n")
    return (bs_reply_length, bs_reply_args)
Ejemplo n.º 4
0
def uart_data_discover():
    print("+++ Sending UART data discovery command")
    request_args = []
    bs.NewTimeout(60)
    rv = bs.requestreply(15, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv

    ngpio = 9
    for i in range(ngpio):
        print("+++ SIGNAL CHANGES: D%d --> %d" % ((i+1), bs_reply_args[i]))
    print("+++ SUCCESS")
    return rv
Ejemplo n.º 5
0
def uart_tx(rxpin, baudrate):
    print("+++ Sending UART discovery tx command")
    request_args = [rxpin, baudrate]
    bs.NewTimeout(3)
    rv = bs.requestreply(21, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv

    txpin = bs_reply_args[0]
    if txpin != 0xffffffff:
        print("+++ FOUND UART TX on GPIO %d" % (txpin + 1))
    else:
        print("+++ NOT FOUND. Note that GPIO 1 can't be used here.")
    print("+++ SUCCESS")
    return rv
Ejemplo n.º 6
0
def i2c_discover():
    print("+++ Sending i2c discover pinout command")
    request_args = []
    bs.NewTimeout(30)
    rv = bs.requestreply(23, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv

    n = bs_reply_length / 8
    print("+++ FOUND %d I2C interfaces" % (n))
    for i in range(n):
        sda = bs_reply_args[i * 2 + 0]
        scl = bs_reply_args[i * 2 + 1]
        print("+++ I2C interface FOUND")
        print("+++ I2C SDA at GPIO %i" % (sda))
        print("+++ I2C SCL at GPIO %i" % (scl))
    print("+++ SUCCESS\n")
    return (bs_reply_length, bs_reply_args)
Ejemplo n.º 7
0
def spi_dump_flash(dumpsize, outfile):
    bs.NewTimeout(5)
    skip = 0
    print("+++ Dumping SPI")
    with open(outfile, 'wb') as f:
        while dumpsize > 0:
            if dumpsize < BLOCKSIZE:
                size = dumpsize
            else:
                size = BLOCKSIZE
            data = dumpSPI(size, skip)
            if data is None:
                print("Timeout")
                return None
            f.write(data)
            f.flush()
            skip = skip + BLOCKSIZE
            dumpsize = dumpsize - size
        print("+++ SUCCESS\n")
        return (1, 1)
Ejemplo n.º 8
0
def uart_passthrough(gpiorx, gpiotx, baudrate):
    request_args = [gpiorx-1, gpiotx-1, baudrate]
    bs.NewTimeout(30)
    rv = bs.requestreply(19, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv
    print("+++ Entering passthrough mode")
    bs.keys_init()
    ser = bs.getSerial()
    while True:
        if ser.inWaiting() > 0:
            ch = ser.read(1)
            sys.stdout.write(ch)
            sys.stdout.flush()
        inCh = bs.keys_getchar()
        if inCh is not None:
            ser.write(inCh)
        # not reached
    bs.keys_cleanup()
    return None
Ejemplo n.º 9
0
def jtag_discover_pinout():
    print("+++ Sending jtag pinout discovery command")

    request_args = []
    bs.NewTimeout(30)
    rv = bs.requestreply(13, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv
    if bs_reply_args[0] != 0:
        tck = bs_reply_args[1]
        tms = bs_reply_args[2]
        tdi = bs_reply_args[3]
        tdo = bs_reply_args[4]
        ntrst = bs_reply_args[5]
        print("+++ %d JTAG FOUND" % (bs_reply_args[0]))
        print("+++ TCK %i" % (tck))
        print("+++ TMS %i" % (tms))
        print("+++ TDI %i" % (tdi))
        print("+++ TDO %i" % (tdo))
        print("+++ NTRST %i" % (ntrst))
    print("+++ SUCCESS")
    return (bs_reply_length, bs_reply_args)
Ejemplo n.º 10
0
def spi_discover_pinout():
    print("+++ Sending spi discover pinout command")
    request_args = [1000000]
    bs.NewTimeout(60)
    rv = bs.requestreply(29, request_args)
    if rv is None:
        return None
    (bs_reply_length, bs_reply_args) = rv

    n = bs_reply_length / (4 * 4)
    print("+++ FOUND %d SPI interfaces" % (n))
    for i in range(n):
        cs = bs_reply_args[i * 4 + 0]
        clk = bs_reply_args[i * 4 + 1]
        mosi = bs_reply_args[i * 4 + 2]
        miso = bs_reply_args[i * 4 + 3]
        print("+++ SPI interface FOUND")
        print("+++ SPI CS at GPIO %i" % (cs))
        print("+++ SPI CLK at GPIO %i" % (clk))
        print("+++ SPI MOSI at GPIO %i" % (mosi))
        print("+++ SPI MISO at GPIO %i" % (miso))
    print("+++ SUCCESS\n")
    return (bs_reply_length, bs_reply_args)