int8_t spi_transfer_block(const uint8_t *out_buf, uint8_t *in_buf, uint16_t len)
{
	uint16_t i;

	if (in_buf && out_buf) {
		for (i = 0; i < len; i++) {
			in_buf[i] = spi_transfer(out_buf[i]);
		}
	}
	else if (!in_buf && out_buf) {
		for (i = 0; i < len; i++) {
			spi_transfer(out_buf[i]);
		}
	}
	else if (in_buf && !out_buf) {
		for (i = 0; i < len; i++) {
			in_buf[i] = spi_transfer(0xff);
		}
	}
	else if (!in_buf && !out_buf) {
		/* No in or out buffer; just move the clock line. */
		for (i = 0; i < len; i++) {
			spi_transfer(0xff);
		}
	}

	return 0;
}

void OSD::ClosePanel(void)
{
    spi_transfer(MAX7456_DMDI_reg);
    spi_transfer(MAX7456_END_string); //This is needed "trick" to finish auto increment
    DeSelect();;
    row++; //only after finish the auto increment the new row will really act as desired
}

void spi_write_eeprom(unsigned int addr, unsigned char data_in)
{
	unsigned char temp;

	EE_NCS = 0;
	delay1();
	spi_transfer(WRITE_ENABLE);
	EE_NCS = 1;

	delay_us(300);

	EE_NCS = 0;
	delay1();
	if((addr & 0x0100) == 0x0100)
	{
		temp = (WRITE_DATA | 0x08);
	}
	else
	{
		temp = WRITE_DATA;
	}
	spi_transfer(temp);
	delay1();
	spi_transfer((unsigned char)addr);
	delay1();
	spi_transfer(data_in);
	delay1();
	EE_NCS = 1;
}

// Checks if MAX_RT has been reached
uint8_t mirf_max_rt_reached(void) {
  mirf_CSN_lo; // Pull down chip select
  spi_transfer(R_REGISTER | (REGISTER_MASK & STATUS));
  uint8_t status = spi_transfer(NOP); // Read status register
  mirf_CSN_hi; // Pull up chip select
  return status & (1<<MAX_RT);
}

// Sends a data package to the default address. Be sure to send the correct
// amount of bytes as configured as payload on the receiver.
void nrf24_send(uint8_t* value)
{
    /* Go to Standby-I first */
    nrf24_ce_digitalWrite(LOW);

    /* Set to transmitter mode , Power up if needed */
    nrf24_powerUpTx();

    /* Do we really need to flush TX fifo each time ? */
    #if 1
        /* Pull down chip select */
        nrf24_csn_digitalWrite(LOW);

        /* Write cmd to flush transmit FIFO */
        spi_transfer(NRF24L01P_CMD_FLUSH_TX, 1);

        /* Pull up chip select */
        nrf24_csn_digitalWrite(HIGH);
    #endif

    /* Pull down chip select */
    nrf24_csn_digitalWrite(LOW);

    /* Write cmd to write payload */
    spi_transfer(NRF24L01P_CMD_W_TX_PAYLOAD, 0);

    /* Write payload */
    nrf24_transmitSync(value,payload_len);

    /* Pull up chip select */
    nrf24_csn_digitalWrite(HIGH);

    /* Start the transmission */
    nrf24_ce_digitalWrite(HIGH);
}

// Checks if data is available for reading
uint8_t mirf_data_ready(void) {
  mirf_CSN_lo; // Pull down chip select
  spi_transfer(R_REGISTER | (REGISTER_MASK & STATUS));
  uint8_t status = spi_transfer(NOP); // Read status register
  mirf_CSN_hi; // Pull up chip select
  return status & (1<<RX_DR);
}

void cmd_spirom_id() {
	unsigned long recv1;
	unsigned short recv2;

//	spi_init();
	spi_set_port(SPI_PORT_NONE); // CSを自分で制御する
	spi_set_bit_order(SPI_MSBFIRST);

	gpio_set_pinmode(SPI_ROM_PORT,1);
	gpio_write_port(SPI_ROM_PORT,0); // CSを下げる
	spi_set_bit_length(8);
	spi_transfer(0x9f); // コマンド送信
	spi_set_bit_length(24);
	recv1 = spi_transfer(0) & 0xffffff;
	printf("SPI ROM JEDEC ID=%08lx, ",recv1);
//	gpio_write_port(SPI_ROM_PORT,1); // CSを上げる

	gpio_write_port(SPI_ROM_PORT,0); // CSを下げる
	spi_set_bit_length(32);
	recv2 = spi_transfer(0x90000000) & 0xffff; // コマンド送信
	printf("ID=%04x\n",recv2);
	gpio_write_port(SPI_ROM_PORT,1); // CSを上げる

	gpio_set_pinmode(SPI_ROM_PORT,0);
//	spi_terminate();
}

void xhide(void)
{
	spi_transfer(low_byte(400));
  spi_transfer(high_byte(400));
  spi_transfer(low_byte(400));
  spi_transfer(high_byte(400));
  //spr++;
}

void wr16(unsigned int addr, unsigned int v)
{
	  __wstart(addr);
  spi_transfer(low_byte(v));
  spi_transfer(high_byte(v));
  __end();
	
}

unsigned char accel_read(unsigned char address) {
    unsigned char result;
    pin_clear(&ACCEL_CS);
    spi_transfer(&spi1, (address&0x3F)<<1);
    result = spi_transfer(&spi1, 0x00);
    pin_set(&ACCEL_CS);
    return result;
}

unsigned char gyro_read(unsigned char address) {
    unsigned char result;
    pin_clear(&GYRO_CS);
    spi_transfer(&spi1, 0x80|(address&0x3F));
    result = spi_transfer(&spi1, 0x00);
    pin_set(&GYRO_CS);
    return result;
}

//null args for some cmd's
void sd_send_null_args(void)
{
    spi_transfer(0x00);
    spi_transfer(0x00);
    spi_transfer(0x00);
    spi_transfer(0x00);
    spi_transfer(0x95);
}

static void nrf24_write_reg(uint8_t addr, uint8_t value) {
	nrf24_csn(0);

	spi_transfer(addr | W_REGISTER);
	spi_transfer(value);

	nrf24_csn(1);
}

uint8_t rx_fifo_empty() {
  uint8_t status = 0x00;
  NRF_CS_LOW;
  spi_transfer(FIFO_STATUS);
  status = spi_transfer(0);
  NRF_CS_HIGH;
  return (status & (1 << RX_EMPTY));
}

/*!	\fn int spi_write(int pin, uint8_t reg, uint8_t data)
 *	\brief Write 8 address bits to an spi device then writes 8 data bits to the spi device
 *	@param[in] pin the chipselect pin to toggle
 *	@param[in] reg the address bits to send to the spi device
 * 	@param[in] the data to send to the spi device
 * 	\return returns ERR_NOERR unless an attempt has been made to perform two simultaneous spi transactions, then an error is returned
 */
int spi_write(int pin, uint8_t reg, uint8_t data)
{
	int ret = spi_begin(pin);
	if (ret < 0)
		return ret;
	spi_transfer(reg);
	spi_transfer(data);
	return spi_end();	
}

/*!	\fn int spi_read(int pin, uint8_t reg, uint8_t *data) 
 *	\brief Write 8 address bits to an spi device then read 8 bits from spi device
 *	@param[in] pin the chipselect pin to toggle
 *	@param[in] reg the address bits to send to the spi device
 * 	@param[out] the data the spi device sent back
 * 	\return returns ERR_NOERR unless an attempt has been made to perform two simultaneous spi transactions, then an error is returned
 */
int spi_read(int pin, uint8_t reg, uint8_t *data) 
{
	int ret = spi_begin(pin);
	if (ret < 0)
		return ret;
	spi_transfer(reg|0x80);
	*data = spi_transfer(0);
	return spi_end();
}

/* Returns the length of data waiting in the RX fifo */
uint8_t nrf24_payloadLength()
{
    uint8_t status;
    nrf24_csn_digitalWrite(LOW);
    spi_transfer(NRF24L01P_CMD_R_RX_PL_WID, 0);
    status = spi_transfer(0x00, 1);
    nrf24_csn_digitalWrite(HIGH);
    return status;
}

void can_w_bit(uint8_t addr, uint8_t mask, uint8_t val)
{
	CAN_CS_LOW;
	spi_transfer(MCP2515_SPI_BITMOD);
	spi_transfer(addr);
	spi_transfer(mask);
	spi_transfer(val);
	CAN_CS_HIGH;
}

void spi_setRegister(
    uint8_t reg,
    uint8_t value)
{
    nrf24_csn_digitalWrite(LOW);
    spi_transfer(W_REGISTER | (REGISTER_MASK & reg));
    spi_transfer(value);
    nrf24_csn_digitalWrite(HIGH);
}

/* Returns the length of data waiting in the RX fifo */
uint8_t nrf24_payloadLength()
{
    uint8_t status;
    nrf24_csn_digitalWrite(LOW);
    spi_transfer(R_RX_PL_WID);
    status = spi_transfer(0x00);
    nrf24_csn_digitalWrite(HIGH);
    return status;
}