avrtarget.c

Go to the documentation of this file.

#include <sys/timer.h>
#include <dev/avrtarget.h>


#ifndef AVRTARGET_CHIPERASE_TIMEOUT

#define AVRTARGET_CHIPERASE_TIMEOUT 200
#endif

#ifndef AVRTARGET_PAGEWRITE_TIMEOUT

#define AVRTARGET_PAGEWRITE_TIMEOUT 10
#endif

#define AVR_FUSES_NEVER_PROG     0x00F88062UL

#define AVR_FUSES_ALWAYS_PROG   0x0000201DUL

#ifndef AVRTARGET_SPI_MODE
#define AVRTARGET_SPI_MODE   0
#endif

#ifndef AVRTARGET_SPI_RATE
#define AVRTARGET_SPI_RATE   500000
#endif

#if defined(AVRTARGET_SPI0_DEVICE) /* SPI device. */

#include <dev/sppif0.h>
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define TargetReset(act)    Sppi0ChipReset(AVRTARGET_SPI0_DEVICE, act)
#else
#define TargetReset(act)    Sppi0ChipReset(AVRTARGET_SPI0_DEVICE, !act)
#endif
#define SpiSetMode()        Sppi0SetMode(AVRTARGET_SPI0_DEVICE, AVRTARGET_SPI_MODE)
#define SpiSetSpeed()       Sppi0SetSpeed(AVRTARGET_SPI0_DEVICE, AVRTARGET_SPI_RATE)
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define SpiSelect()         Sppi0SelectDevice(AVRTARGET_SPI0_DEVICE)
#define SpiDeselect()       Sppi0DeselectDevice(AVRTARGET_SPI0_DEVICE)
#else
#define SpiSelect()         Sppi0NegSelectDevice(AVRTARGET_SPI0_DEVICE)
#define SpiDeselect()       Sppi0NegDeselectDevice(AVRTARGET_SPI0_DEVICE)
#endif
#define SpiByte             Sppi0Byte

#elif defined(AVRTARGET_SBBI0_DEVICE) /* SPI device. */

#include <dev/sbbif0.h>
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define TargetReset(act)    Sbbi0ChipReset(AVRTARGET_SBBI0_DEVICE, act)
#else
#define TargetReset(act)    Sbbi0ChipReset(AVRTARGET_SBBI0_DEVICE, !act)
#endif
#define SpiSetMode()        Sbbi0SetMode(AVRTARGET_SBBI0_DEVICE, AVRTARGET_SPI_MODE)
#define SpiSetSpeed()       Sbbi0SetSpeed(AVRTARGET_SBBI0_DEVICE, AVRTARGET_SPI_RATE)
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define SpiSelect()         Sbbi0SelectDevice(AVRTARGET_SBBI0_DEVICE)
#define SpiDeselect()       Sbbi0DeselectDevice(AVRTARGET_SBBI0_DEVICE)
#else
#define SpiSelect()         Sbbi0NegSelectDevice(AVRTARGET_SBBI0_DEVICE)
#define SpiDeselect()       Sbbi0NegDeselectDevice(AVRTARGET_SBBI0_DEVICE)
#endif
#define SpiByte             Sbbi0Byte

#elif defined(AVRTARGET_SBBI1_DEVICE) /* SPI device. */

#include <dev/sbbif1.h>
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define TargetReset(act)    Sbbi1ChipReset(AVRTARGET_SBBI1_DEVICE, act)
#else
#define TargetReset(act)    Sbbi1ChipReset(AVRTARGET_SBBI1_DEVICE, !act)
#endif
#define SpiSetMode()        Sbbi1SetMode(AVRTARGET_SBBI1_DEVICE, AVRTARGET_SPI_MODE)
#define SpiSetSpeed()       Sbbi1SetSpeed(AVRTARGET_SBBI1_DEVICE, AVRTARGET_SPI_RATE)
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define SpiSelect()         Sbbi1SelectDevice(AVRTARGET_SBBI1_DEVICE)
#define SpiDeselect()       Sbbi1DeselectDevice(AVRTARGET_SBBI1_DEVICE)
#else
#define SpiSelect()         Sbbi1NegSelectDevice(AVRTARGET_SBBI1_DEVICE)
#define SpiDeselect()       Sbbi1NegDeselectDevice(AVRTARGET_SBBI1_DEVICE)
#endif
#define SpiByte             Sbbi1Byte

#elif defined(AVRTARGET_SBBI2_DEVICE) /* SPI device. */

#include <dev/sbbif2.h>
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define TargetReset(act)    Sbbi2ChipReset(AVRTARGET_SBBI2_DEVICE, act)
#else
#define TargetReset(act)    Sbbi2ChipReset(AVRTARGET_SBBI2_DEVICE, !act)
#endif
#define SpiSetMode()        Sbbi2SetMode(AVRTARGET_SBBI2_DEVICE, AVRTARGET_SPI_MODE)
#define SpiSetSpeed()       Sbbi2SetSpeed(AVRTARGET_SBBI2_DEVICE, AVRTARGET_SPI_RATE)
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define SpiSelect()         Sbbi2SelectDevice(AVRTARGET_SBBI2_DEVICE)
#define SpiDeselect()       Sbbi2DeselectDevice(AVRTARGET_SBBI2_DEVICE)
#else
#define SpiSelect()         Sbbi2NegSelectDevice(AVRTARGET_SBBI2_DEVICE)
#define SpiDeselect()       Sbbi2NegDeselectDevice(AVRTARGET_SBBI2_DEVICE)
#endif
#define SpiByte             Sbbi2Byte

#elif defined(AVRTARGET_SBBI3_DEVICE) /* SPI device. */

#include <dev/sbbif3.h>
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define TargetReset(act)    Sbbi3ChipReset(AVRTARGET_SBBI3_DEVICE, act)
#else
#define TargetReset(act)    Sbbi3ChipReset(AVRTARGET_SBBI3_DEVICE, !act)
#endif
#define SpiSetMode()        Sbbi3SetMode(AVRTARGET_SBBI3_DEVICE, AVRTARGET_SPI_MODE)
#define SpiSetSpeed()       Sbbi3SetSpeed(AVRTARGET_SBBI3_DEVICE, AVRTARGET_SPI_RATE)
#if defined(AVRTARGET_SELECT_ACTIVE_HIGH)
#define SpiSelect()         Sbbi3SelectDevice(AVRTARGET_SBBI3_DEVICE)
#define SpiDeselect()       Sbbi3DeselectDevice(AVRTARGET_SBBI3_DEVICE)
#else
#define SpiSelect()         Sbbi3NegSelectDevice(AVRTARGET_SBBI3_DEVICE)
#define SpiDeselect()       Sbbi3NegDeselectDevice(AVRTARGET_SBBI3_DEVICE)
#endif
#define SpiByte             Sbbi3Byte

#else /* SPI device. */

#define AVRTARGET_NO_SPI_DEVICE

#endif /* SPI device. */

int AvrTargetInit(void)
{
#if defined(AVRTARGET_NO_SPI_DEVICE)
    return -1;
#else
    if (SpiSetMode()) {
        return -1;
    }
    SpiSetSpeed();
    SpiDeselect();

    return 0;
#endif
}

void AvrTargetSelect(ureg_t act)
{
#if !defined(AVRTARGET_NO_SPI_DEVICE)
    if (act) {
        SpiSelect();
    } else {
        SpiDeselect();
    }
#endif
}

void AvrTargetReset(ureg_t act)
{
#if !defined(AVRTARGET_NO_SPI_DEVICE)
    TargetReset(act);
#endif
}

uint32_t AvrTargetCmd(uint32_t cmd)
{
    uint32_t rc = 0;
#if !defined(AVRTARGET_NO_SPI_DEVICE)
    ureg_t i;

    for (i = 0; i < 4; i++) {
        rc <<= 8;
        rc |= SpiByte((uint8_t) (cmd >> 24));
        cmd <<= 8;
    }
#endif
    return rc;
}

int AvrTargetProgEnable(void)
{
#if defined(AVRTARGET_NO_SPI_DEVICE)
    return -1;
#else
    if ((uint8_t) (AvrTargetCmd(AVRCMD_PROG_ENABLE) >> 8) != 0x53) {
        return -1;
    }
    return 0;
#endif
}

uint32_t AvrTargetSignature(void)
{
    uint32_t rc = 0;
#if !defined(AVRTARGET_NO_SPI_DEVICE)
    ureg_t i;

    for (i = 0; i < 3; i++) {
        rc <<= 8;
        rc |= (uint8_t) AvrTargetCmd(AVRCMD_READ_SIGNATURE_BYTE | ((uint32_t) i << 8));
    }
#endif
    return rc;
}

uint32_t AvrTargetFusesRead(void)
{
    uint32_t rc = 0;

    rc = (uint8_t) AvrTargetCmd(AVRCMD_READ_FUSE_EXT_BITS);
    rc <<= 8;
    rc |= (uint8_t) AvrTargetCmd(AVRCMD_READ_FUSE_HI_BITS);
    rc <<= 8;
    rc |= (uint8_t) AvrTargetCmd(AVRCMD_READ_FUSE_BITS);

    return rc;
}

uint32_t AvrTargetFusesWriteSafe(uint32_t fuses)
{
    uint32_t rc;

    fuses |= AVR_FUSES_NEVER_PROG;
    fuses &= ~AVR_FUSES_ALWAYS_PROG;
    rc = fuses;

    AvrTargetCmd(AVRCMD_WRITE_FUSE_BITS | (uint8_t)fuses);
    fuses >>= 8;
    AvrTargetCmd(AVRCMD_WRITE_FUSE_HI_BITS | (uint8_t)fuses);
    fuses >>= 8;
    AvrTargetCmd(AVRCMD_WRITE_FUSE_EXT_BITS | (uint8_t)fuses);
    fuses >>= 8;

    return rc;
}

int AvrTargetPollReady(unsigned int tmo)
{
#if !defined(AVRTARGET_NO_SPI_DEVICE)
    while (AvrTargetCmd(AVRCMD_POLL_READY) & 1UL) {
        if (tmo-- == 0) {
            return -1;
        }
        NutSleep(1);
        /* We may have lost the SPI. */
        SpiSelect();
    }
#endif
    return 0;
}

int AvrTargetChipErase(void)
{
    AvrTargetCmd(AVRCMD_CHIP_ERASE);

    return AvrTargetPollReady(AVRTARGET_CHIPERASE_TIMEOUT);
}

void AvrTargetPageLoad(uint32_t page, CONST uint8_t * data)
{
    ureg_t bc;

    page <<= 6;
    for (bc = 0; bc < (AVRTARGET_PAGESIZE / 2); bc++) {
        AvrTargetCmd(AVRCMD_LOAD_PROG_MEM_PAGE_LO | (page << 8) | *data);
        data++;
        AvrTargetCmd(AVRCMD_LOAD_PROG_MEM_PAGE_HI | (page << 8) | *data);
        data++;
        page++;
    }
}

int AvrTargetPageWrite(uint32_t page)
{
    AvrTargetCmd(AVRCMD_WRITE_PROG_MEM_PAGE | (page << 14));

    return AvrTargetPollReady(AVRTARGET_PAGEWRITE_TIMEOUT);
}

int AvrTargetPageVerify(uint32_t page, CONST uint8_t * data)
{
    uint32_t waddr = page << 6;
    ureg_t bc;

    for (bc = 0; bc < (AVRTARGET_PAGESIZE / 2); bc++) {
        if ((uint8_t) AvrTargetCmd(AVRCMD_READ_PROG_MEM_LO | (waddr << 8)) != *data++) {
            return -1;
        }
        if ((uint8_t) AvrTargetCmd(AVRCMD_READ_PROG_MEM_HI | (waddr << 8)) != *data++) {
            return -1;
        }
        waddr++;
    }
    return 0;
}