'Run an arbitrary SPI flash command.
This function uses the "USR_COMMAND" functionality in the ESP
SPI hardware, rather than the precanned commands supported by
hardware. So the value of spiflash_command is an actual command
byte, sent over the wire.
After writing command byte, writes \'data\' to MOSI and then
reads back \'read_bits\' of reply on MISO. Result is a number.'

def run_spiflash_command(self, spiflash_command, data='', read_bits=0):

    SPI_USR_COMMAND = (1 << 31)
    SPI_USR_MISO = (1 << 28)
    SPI_USR_MOSI = (1 << 27)
    base = self.SPI_REG_BASE
    SPI_CMD_REG = (base + 0)
    SPI_USR_REG = (base + 28)
    SPI_USR1_REG = (base + 32)
    SPI_USR2_REG = (base + 36)
    SPI_W0_REG = (base + self.SPI_W0_OFFS)
    if self.SPI_HAS_MOSI_DLEN_REG:
        def set_data_lengths(mosi_bits, miso_bits):
            SPI_MOSI_DLEN_REG = (base + 40)
            SPI_MISO_DLEN_REG = (base + 44)
            if (mosi_bits > 0):
                self.write_reg(SPI_MOSI_DLEN_REG, (mosi_bits - 1))
            if (miso_bits > 0):
                self.write_reg(SPI_MISO_DLEN_REG, (miso_bits - 1))
    else:
        def set_data_lengths(mosi_bits, miso_bits):
            SPI_DATA_LEN_REG = SPI_USR1_REG
            SPI_MOSI_BITLEN_S = 17
            SPI_MISO_BITLEN_S = 8
            mosi_mask = (0 if (mosi_bits == 0) else (mosi_bits - 1))
            miso_mask = (0 if (miso_bits == 0) else (miso_bits - 1))
            self.write_reg(SPI_DATA_LEN_REG, ((miso_mask << SPI_MISO_BITLEN_S) | (mosi_mask << SPI_MOSI_BITLEN_S)))
    SPI_CMD_USR = (1 << 18)
    SPI_USR2_DLEN_SHIFT = 28
    if (read_bits > 32):
        raise FatalError('Reading    more    than    32    bits    back    from    a    SPI    flash    operation    is    unsupported')
    if (len(data) > 64):
        raise FatalError('Writing    more    than    64    bytes    of    data    with    one    SPI    command    is    unsupported')
    data_bits = (len(data) * 8)
    old_spi_usr = self.read_reg(SPI_USR_REG)
    old_spi_usr2 = self.read_reg(SPI_USR2_REG)
    flags = SPI_USR_COMMAND
    if (read_bits > 0):
        flags |= SPI_USR_MISO
    if (data_bits > 0):
        flags |= SPI_USR_MOSI
    set_data_lengths(data_bits, read_bits)
    self.write_reg(SPI_USR_REG, flags)
    self.write_reg(SPI_USR2_REG, ((7 << SPI_USR2_DLEN_SHIFT) | spiflash_command))
    if (data_bits == 0):
        self.write_reg(SPI_W0_REG, 0)
    else:
        data = pad_to(data, 4, '\x00')
        words = struct.unpack(('I' * (len(data) // 4)), data)
        next_reg = SPI_W0_REG
        for word in words:
            self.write_reg(next_reg, word)
            next_reg += 4
    self.write_reg(SPI_CMD_REG, SPI_CMD_USR)
    def wait_done():
        for _ in range(10):
            if ((self.read_reg(SPI_CMD_REG) & SPI_CMD_USR) == 0):
                return
        raise FatalError('SPI    command    did    not    complete    in    time')
    wait_done()
    status = self.read_reg(SPI_W0_REG)
    self.write_reg(SPI_USR_REG, old_spi_usr)
    self.write_reg(SPI_USR2_REG, old_spi_usr2)
    return status
