docs: def run_spiflash_command(self, spiflash_command, data=b"", read_bits=0):
          """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.
          """
  
          # SPI_USR register flags
          SPI_USR_COMMAND = (1 << 31)
          SPI_USR_MISO    = (1 << 28)
          SPI_USR_MOSI    = (1 << 27)
  
          # SPI registers, base address differs ESP32 vs 8266
          base = self.SPI_REG_BASE
          SPI_CMD_REG       = base + 0x00
          SPI_USR_REG       = base + 0x1C
          SPI_USR1_REG      = base + 0x20
          SPI_USR2_REG      = base + 0x24
          SPI_W0_REG        = base + self.SPI_W0_OFFS
  
          # following two registers are ESP32 only
          if self.SPI_HAS_MOSI_DLEN_REG:
              # ESP32 has a more sophisticated wayto set up "user" commands
              def set_data_lengths(mosi_bits, miso_bits):
                  SPI_MOSI_DLEN_REG = base + 0x28
                  SPI_MISO_DLEN_REG = base + 0x2C
                  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 peripheral "command" bitmasks for SPI_CMD_REG
          SPI_CMD_USR  = (1 << 18)
  
          # shift values
          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)  # clear data register before we read it
          else:
              data = pad_to(data, 4, b'\00')  # pad to 32-bit multiple
              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)
          # restore some SPI controller registers
          self.write_reg(SPI_USR_REG, old_spi_usr)
          self.write_reg(SPI_USR2_REG, old_spi_usr2)
          return status