bool mpu6000WriteRegister(uint8_t reg, uint8_t data)
{
    ENABLE_MPU6000;
    spiTransferByte(MPU6000_SPI_INSTANCE, reg);
    spiTransferByte(MPU6000_SPI_INSTANCE, data);
    DISABLE_MPU6000;

    return true;
}

void mmcCommandNoWait(u08 cmd, u32 arg) {
	// send command
	spiTransferByte(cmd | 0x40);
	spiTransferByte(arg>>24);
	spiTransferByte(arg>>16);
	spiTransferByte(arg>>8);
	spiTransferByte(arg);
	spiTransferByte(0x95);	// crc valid only for MMC_GO_IDLE_STATE
	// end command
}

void set_avr_bank(uint8_t val) {
	SPI_SS_HIGH();
	FPGA_SS_LOW();
	spiTransferByte(0x00); // SET ADDRESS
	spiTransferByte(val * 0x20); // select chip
	spiTransferByte(0x00); // select chip
	spiTransferByte(0x00); // select chip
	FPGA_SS_HIGH();
	SPI_SS_LOW();
}

void cc2420WriteFifo(u08* data, u16 nBytes)
{
		// assert chip select
	cbi(PORTB, CC2420_PIN_CS);
		// send command
	spiTransferByte(CC2420_TXFIFO);
	while(nBytes--)
		spiTransferByte(*data++);
		// release chip select
	sbi(PORTB, CC2420_PIN_CS);
}

void cc2420DumpFifo(u16 nBytes)
{
	// assert chip select
	cbi(PORTB, CC2420_PIN_CS);
	// send command
	spiTransferByte(CC2420_RXFIFO | 0x40);
	while(nBytes--)
		spiTransferByte(0x00);
	// release chip select
	sbi(PORTB, CC2420_PIN_CS);
}

u08 spieepromReadStatus(void)
{
	u08 status;
//	cbi(PORTB,0);
	// send command
	spiTransferByte(SPIEEPROM_CMD_RDSR);
	// get status register value
	status = spiTransferByte(0xFF);
//	sbi(PORTB,0);
	return status;
}

bool mpu9250WriteRegister(uint8_t reg, uint8_t data)
{
	ENABLE_MPU9250;
    delayMicroseconds(1);
    spiTransferByte(MPU9250_SPI_INSTANCE, reg);
    spiTransferByte(MPU9250_SPI_INSTANCE, data);
    DISABLE_MPU9250;
    delayMicroseconds(1);

    return true;
}

void ads7870WriteReg(u08 reg, u08 value)
{
	// assert chip select
	cbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
	// issue reg write command
	spiTransferByte(ADS7870_REG_WRITE | reg);
	// write data
	spiTransferByte(value);
	// release chip select
	sbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
}

void cc2420WriteRam(u16 addr, u08* data, u16 nBytes)
{
		// assert chip select
	cbi(PORTB, CC2420_PIN_CS);
	// send command
	spiTransferByte(0x80|addr);
	spiTransferByte((addr>>1) & 0xC0);
	while(nBytes--)
		spiTransferByte(*data++);
		// release chip select
	sbi(PORTB, CC2420_PIN_CS);
}

/**
 * sendCommand - send a command to the SD card
 * @command  : command to be sent
 * @parameter: parameter to be sent
 * @deselect : Flags if the card should be deselected afterwards
 *
 * This function calculates the correct CRC7 for the command and
 * parameter and transmits all of it to the SD card. If requested
 * the card will be deselected afterwards.
 */
int mmc::sendCommand(const byte  command,
const uint32_t parameter,
const byte  deselect) {
  union {
    unsigned long l;
    unsigned char c[4];
  } 
  long2char;

  byte  i,crc,errorcount;
  uint16_t counter;

  long2char.l = parameter;
  crc = crc7update(0  , 0x40+command);
  crc = crc7update(crc, long2char.c[3]);
  crc = crc7update(crc, long2char.c[2]);
  crc = crc7update(crc, long2char.c[1]);
  crc = crc7update(crc, long2char.c[0]);
  crc = (crc << 1) | 1;

  errorcount = 0;
  while (errorcount < CONFIG_SD_AUTO_RETRIES) {
    // Select card
    SPI_SS_LOW();

    // Transfer command
    spiTransferByte(0x40+command);
    spiTransferLong(parameter);
    spiTransferByte(crc);

    // Wait for a valid response
    counter = 0;
    do {
      i = spiTransferByte(0xff);
      counter++;
    } 
    while (i & 0x80 && counter < 0x1000);

    // Check for CRC error
    // can't reliably retry unless deselect is allowed
    if (deselect && (i & STATUS_CRC_ERROR)) {
      //      uart_putc('x');
      deselectCard();
      errorcount++;
      continue;
    }

    if (deselect) deselectCard();
    break;
  }

  return i;
}

void cc2420WriteReg(u08 addr, u16 data)
{
		// assert chip select
	cbi(PORTB, CC2420_PIN_CS);
		// send command
	spiTransferByte(addr);
		// write data
	spiTransferByte(data>>8);
	spiTransferByte(data);
		// release chip select
	sbi(PORTB, CC2420_PIN_CS);
}

unsigned short spiflashGetID(void)
{
	unsigned short id;

	SPIFLASH_ASSERT_CS;
	spiTransferByte(SPIFLASH_CMD_RDID);
	id  = spiTransferByte(0x00)<<8;
	id |= spiTransferByte(0x00);
	SPIFLASH_RELEASE_CS;

	return id;
}

u08 ads7870ReadReg(u08 reg)
{
	u08 data;
	// assert chip select
	cbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
	// issue reg read command
	spiTransferByte(ADS7870_REG_READ | reg);
	// read data
	data = spiTransferByte(0x00);
	// release chip select
	sbi(ADS7870_CS_PORT, ADS7870_CS_PIN);
	// return data
	return data;
}

void spieepromWriteByte(u32 memAddr, u08 data)
{
	// wait for any previous write to complete
	while(spieepromReadStatus() & SPIEEPROM_STATUS_WIP);

//	cbi(PORTB,0);
	// send command
	spiTransferByte(SPIEEPROM_CMD_WRITE);
	// send address
	spiTransferByte(memAddr>>8);
	spiTransferByte(memAddr&0x00FF);
	// send data to be written
	spiTransferByte(data);
//	sbi(PORTB,0);
}

u08 spieepromReadByte(u32 memAddr)
{
	u08 data;
//	cbi(PORTB,0);
	// send command
	spiTransferByte(SPIEEPROM_CMD_READ);
	// send address
	spiTransferByte(memAddr>>8);
	spiTransferByte(memAddr&0x00FF);
	// read contents of memory address
	data = spiTransferByte(0xFF);
	// return data
	return data;
//	sbi(PORTB,0);
}

void max7456_write_nvm(uint8_t char_address, uint8_t *font_data) {
    uint8_t x;

#ifdef MAX7456_DMA_CHANNEL_TX
    while (dma_transaction_in_progress);
#endif
    while (max7456_lock);
    max7456_lock = 1;
    ENABLE_MAX7456;

    // disable display
    max7456_send(VM0_REG, video_signal_type);

    max7456_send(MAX7456ADD_CMAH, char_address); // set start address high

    for(x = 0; x < 54; x++) {
        max7456_send(MAX7456ADD_CMAL, x); //set start address low
        max7456_send(MAX7456ADD_CMDI, font_data[x]);
#ifdef LED0_TOGGLE
        LED0_TOGGLE;
#else
        LED1_TOGGLE;
#endif
    }

    // transfer 54 bytes from shadow ram to NVM
    max7456_send(MAX7456ADD_CMM, WRITE_NVR);

    // wait until bit 5 in the status register returns to 0 (12ms)
    while ((spiTransferByte(MAX7456_SPI_INSTANCE, MAX7456ADD_STAT) & STATUS_REG_NVR_BUSY) != 0);

    max7456_send(VM0_REG, video_signal_type | 0x0C);
    DISABLE_MAX7456;
    max7456_lock = 0;
}

void spiflashRead(unsigned long addr, unsigned long nbytes, unsigned char *data)
{
	// begin read
	SPIFLASH_ASSERT_CS;
	// issue read command
	spiTransferByte(SPIFLASH_CMD_READ);
	// send address
	spiTransferByte(addr>>16);
	spiTransferByte(addr>>8);
	spiTransferByte(addr>>0);
	// read data
	while(nbytes--)
		*data++ = spiTransferByte(0x00);
	// end read
	SPIFLASH_RELEASE_CS;
}

void _mmcEnableCS(void) {

	cbi(MMC_CS_PORT,MMC_CS_PIN);

	spiTransferByte(0xFF);

}

void spieepromWriteDisable(void)
{
//	cbi(PORTB,0);
	// send command
	spiTransferByte(SPIEEPROM_CMD_WRDI);
//	sbi(PORTB,0);
}

void set_avr_mapper(uint8_t val) {
	SPI_SS_HIGH();
	FPGA_SS_LOW();
	spiTransferByte(0x30 | (val & 0x0f));
	FPGA_SS_HIGH();
	SPI_SS_LOW();
}