unsigned char CC2500xcvr::sendBurstCommand(unsigned char command, unsigned char* data, unsigned char length)
{
    spiTransactionBegin();	// enable device

    // send command byte
    spiTransfer(command);			    // this is a burst command
    unsigned char result = 0;

    // send/recv data bytes
    for (int i=0; i<length; ++i)
	{
        result = spiTransfer(data[i]);	// send
        data[i] = result;				// receive into the same buffer
    }

    spiTransactionEnd(); 	// disable device
    return result;	// return result
}

bool mpu6000ReadRegister(uint8_t reg, uint8_t length, uint8_t *data)
{
    ENABLE_MPU6000;
    spiTransferByte(MPU6000_SPI_INSTANCE, reg | 0x80); // read transaction
    spiTransfer(MPU6000_SPI_INSTANCE, data, NULL, length);
    DISABLE_MPU6000;

    return true;
}

void readEepromPage(uint16_t address, uint16_t length)
{
	// here again we have a word address
	for (uint16_t addr = address * 2, i = 0; i < length; i++)
	{
		uint8_t ee = spiTransfer(0xA0, addr++, 0xFF);
		Serial.write(ee);
	}
	Serial.write(STK_OK);
}

void LedControl::setRow(int addr, int row, byte value) {
    int offset;
    if(addr<0 || addr>=maxDevices)
	return;
    if(row<0 || row>7)
	return;
    offset=addr*8;
    status[offset+row]=value;
    spiTransfer(addr, row+1,status[offset+row]);
}

void writeEnable(void)
{
	ENABLE_EEPROM;

    spiTransfer(EEPROM_SPI, WRITE_ENABLE);

    DISABLE_EEPROM;

    delayMicroseconds(2);
}

void MAX7219::clearDisplay(int addr) {
	if (addr < 0 || addr >= maxDevices) return;

	int offset;
	offset = addr * 8;
	for (uint8_t i = 0; i < 8; i++) {
		status[offset + i] = 0;
		spiTransfer(addr, i + 1, status[offset + i]);
	}
}

bool mpu9250SlowReadRegister(uint8_t reg, uint8_t length, uint8_t *data)
{
	ENABLE_MPU9250;
    delayMicroseconds(1);
    spiTransferByte(MPU9250_SPI_INSTANCE, reg | 0x80); // read transaction
    spiTransfer(MPU9250_SPI_INSTANCE, data, NULL, length);
    DISABLE_MPU9250;
    delayMicroseconds(1);

    return true;
}

void LedControl::clearDisplay(int addr) {
    int offset;

    if(addr<0 || addr>=maxDevices)
	return;
    offset=addr*8;
    for(int i=0;i<8;i++) {
	status[offset+i]=0;
    }
    if (anodeMode) {
    	transposeData(addr);
    	for(int i=0;i<8;i++) {
	    spiTransfer(addr, i+1, statusTransposed[offset+i]);
    	}
    } else {
    	for(int i=0;i<8;i++) {
	    spiTransfer(addr, i+1, status[offset+i]);
    	}
    }
}

void LedControl::clearDisplay(int addr) {
    int offset;

    if(addr<0 || addr>=maxDevices)
	return;
    offset=addr*8;
    for(int i=0;i<8;i++) {
	status[offset+i]=0;
	spiTransfer(addr, i+1,status[offset+i]);
    }
}

void m25p16_pageProgramBegin(uint32_t address)
{
    uint8_t command[] = { M25P16_INSTRUCTION_PAGE_PROGRAM, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};

    m25p16_waitForReady(DEFAULT_TIMEOUT_MILLIS);

    m25p16_writeEnable();

    ENABLE_M25P16;

    spiTransfer(M25P16_SPI_INSTANCE, NULL, command, sizeof(command));
}

static bool spiTest(void)
{
    uint8_t out[] = { 0x9F, 0, 0, 0 };
    uint8_t in[4];

    spiSelect(true);
    spiTransfer(in, out, sizeof(out));
    spiSelect(false);
    if (in[1] == 0xEF)
        return true;

    return false;
}

MAX7219::MAX7219(SPI* spi, int numDevices) {
	assert(spi != nullptr);
	this->spi = spi;
	if (numDevices <= 0 || numDevices > 8) {
		numDevices = 8;
	}
	maxDevices = numDevices;

	for (uint8_t i = 0; i < 64; i++) {
		status[i] = 0x00;
	}
	for (int i = 0; i < maxDevices; i++) {
		spiTransfer(i, OP_DISPLAYTEST, 0);
		//scanlimit is set to max on startup
		setScanLimit(7, i);
		//decode is done in source
		spiTransfer(i, OP_DECODEMODE, 0);
		clearDisplay(i);
		//we go into shutdown-mode on startup
		shutdown(true, i);
	}
}

static uint8_t m25p16_readStatus()
{
    uint8_t command[2] = { M25P16_INSTRUCTION_READ_STATUS_REG, 0 };
    uint8_t in[2];

    ENABLE_M25P16;

    spiTransfer(M25P16_SPI_INSTANCE, in, command, sizeof(command));

    DISABLE_M25P16;

    return in[1];
}

/**
 * Erase a sector full of bytes to all 1's at the given byte offset in the flash chip.
 */
void m25p16_eraseSector(uint32_t address)
{
    uint8_t out[] = { M25P16_INSTRUCTION_SECTOR_ERASE, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};

    m25p16_waitForReady(SECTOR_ERASE_TIMEOUT_MILLIS);

    m25p16_writeEnable();

    ENABLE_M25P16;

    spiTransfer(M25P16_SPI_INSTANCE, NULL, out, sizeof(out));

    DISABLE_M25P16;
}

/** \brief SPI command.

    Setup DC and SS pins, then send command via SPI to SSD1306 controller.
*/
void MicroOLED::command(uint8_t c) {

	if (interface == MODE_SPI)
	{
		digitalWrite(dcPin, LOW);
		digitalWrite(csPin, LOW);
		spiTransfer(c);
		digitalWrite(csPin, HIGH);
	}
	else if (interface == MODE_I2C)
	{
		digitalWrite(dcPin, LOW);	// DC pin LOW
		i2cWrite(I2C_ADDRESS_SA0_1, I2C_COMMAND, c);
	}
}

void CC2500xcvr::reset()
// REFERENCES:	19.1.2 "Manual Reset" in [1]
{
    // enable device
    digitalWrite(m_pinCS_n, LOW);
    delayMicroseconds(1);

    // disable device and wait at least 40 microseconds
    digitalWrite(m_pinCS_n, HIGH);
    delayMicroseconds(41);
    
	spiTransactionBegin();	// enable device
    spiTransfer(0x30);	// send reset command (SRES)
    spiTransactionEnd(); 	// disable device
}

void writeFlash(uint16_t address, uint16_t length)
{
	if (length > _param.flash_pagesize || length > BUFF_LENGTH)
	{
		_error = true;
		Serial.write(STK_FAILED);
		return;
	}

	fill(length);

	if (!receiveEop())
		return;

	for (uint8_t *p = _buff, word_length = length >> 1, i = 0; i < word_length;
			i++)
	{
		spiTransfer(0x40, i, *p++);
		spiTransfer(0x48, i, *p++);
	}
	spiTransfer(0x4C, getPage(address), 0);

	Serial.write(STK_OK);
}

/*
 * Class:     io_silverspoon_bulldog_linux_jni_NativeSpi
 * Method:    spiTransfer
 * Signature: (IJJIIII)I
 */
JNIEXPORT jint JNICALL Java_io_silverspoon_bulldog_linux_jni_NativeSpi_spiTransfer
  (JNIEnv * env , jclass clazz, jint fileDescriptor, jobject txBuffer, jobject rxBuffer, jint transferLength, jint delay, jint speed, jint bitsPerWord) {
	unsigned int* pTx = NULL;
	unsigned int* pRx = NULL;

	if(txBuffer != NULL) {
		pTx = (unsigned int*) (*env)->GetDirectBufferAddress(env, txBuffer);
	}

	if(rxBuffer != NULL) {
		pRx = (unsigned int*) (*env)->GetDirectBufferAddress(env, rxBuffer);
	}

	return spiTransfer((int)fileDescriptor, (unsigned int*)pTx, (unsigned int*)pTx, (int)transferLength, (int)delay, (int)speed, (int)bitsPerWord);
}

void beginProgramming()
{
	SPI.begin();

	digitalWrite(RESET, HIGH);
	pinMode(RESET, OUTPUT);

	digitalWrite(SCK, LOW);
	digitalWrite(RESET, LOW);
	digitalWrite(RESET, HIGH);
	digitalWrite(RESET, LOW);

	delay(20);

	spiTransfer(0xAC, 0x53, 0x00, 0x00);
	_programming = true;
}

int SpiDrv::waitResponse(uint8_t cmd, uint8_t* numParamRead, uint8_t** params, uint8_t maxNumParams)
{
    char _data = 0;
    int i =0, ii = 0;

    char    *index[WL_SSID_MAX_LENGTH];

    for (i = 0 ; i < WL_NETWORKS_LIST_MAXNUM ; i++)
            index[i] = (char *)params + WL_SSID_MAX_LENGTH*i;

    IF_CHECK_START_CMD(_data)
    {
        CHECK_DATA(cmd | REPLY_FLAG, _data){};

        uint8_t numParam = readChar();

        if (numParam > maxNumParams)
        {
            numParam = maxNumParams;
        }
        *numParamRead = numParam;
        if (numParam != 0)
        {
            for (i=0; i<numParam; ++i)
            {
            	uint8_t paramLen = readParamLen8();
                for (ii=0; ii<paramLen; ++ii)
                {
                	//ssid[ii] = spiTransfer(DUMMY_DATA);
                    // Get Params data
                    index[i][ii] = (uint8_t)spiTransfer(DUMMY_DATA);

                }
                index[i][ii]=0;
            }
        } else
        {
            WARN("Error numParams == 0");
            readAndCheckChar(END_CMD, &_data);
            return 0;
        }
        readAndCheckChar(END_CMD, &_data);
    }
    return 1;
}