RequestDownload & TransferData

/* UDS 0x34: RequestDownload — negotiates download parameters */
/* Request: 0x34 + dataFormatIdentifier + addressAndLengthFormatIdentifier + memoryAddress + memorySize */
/* Response: 0x74 + lengthFormatIdentifier + maxBlockLength */

#include 
#include "Flash_If.h"

typedef struct {
    uint32_t address;     /* target flash address */
    uint32_t length;      /* total bytes to download */
    uint8_t  compression; /* dataFormatIdentifier high nibble */
    uint8_t  encryption;  /* dataFormatIdentifier low nibble */
    boolean  active;      /* download session is open */
    uint32_t bytes_received; /* running count */
    uint8_t  next_block;  /* expected next block sequence counter */
} DownloadSession_t;

static DownloadSession_t g_download;

Std_ReturnType RD_RequestDownload(const uint8_t *req, uint16_t req_len,
                                   uint8_t *resp, uint16_t *resp_len)
{
    /* Parse dataFormatIdentifier (byte 1): compression + encryption */
    uint8_t dfi = req[1];
    uint8_t compression = (dfi >> 4u) & 0x0Fu;  /* 0=none; 1=zlib */
    uint8_t encryption  =  dfi & 0x0Fu;           /* 0=none; 1=AES-128 */

    /* Parse addressAndLengthFormatIdentifier (byte 2) */
    uint8_t alfi = req[2];
    uint8_t addr_len = (alfi >> 4u) & 0x0Fu;   /* number of address bytes (e.g., 4) */
    uint8_t size_len =  alfi & 0x0Fu;            /* number of size bytes (e.g., 4) */

    if (addr_len != 4u || size_len != 4u) {
        resp[0]=0x7Fu; resp[1]=0x34u; resp[2]=0x31u;  /* NRC 0x31: requestOutOfRange */
        *resp_len = 3u; return E_NOT_OK;
    }

    /* Extract memory address (4 bytes big-endian) */
    uint32_t address = ((uint32_t)req[3]<<24)|((uint32_t)req[4]<<16)
                      |((uint32_t)req[5]<<8)| (uint32_t)req[6];
    uint32_t length  = ((uint32_t)req[7]<<24)|((uint32_t)req[8]<<16)
                      |((uint32_t)req[9]<<8)| (uint32_t)req[10];

    /* Validate address range is in programmable region */
    if (!Flash_IsAddressValid(address, length)) {
        resp[0]=0x7Fu; resp[1]=0x34u; resp[2]=0x31u;
        *resp_len = 3u; return E_NOT_OK;
    }

    /* Open download session */
    g_download.address       = address;
    g_download.length        = length;
    g_download.compression   = compression;
    g_download.encryption    = encryption;
    g_download.active        = TRUE;
    g_download.bytes_received= 0u;
    g_download.next_block    = 0x01u;

    /* Response: 0x74 + maxBlockLength (4 bytes: 0x04 + 3-byte value) */
    uint32_t max_block = 0x400u;  /* 1 kB per block; adjust for RAM buffer size */
    resp[0] = 0x74u;
    resp[1] = 0x40u;  /* lengthFormatIdentifier: 4-byte maxBlockLength */
    resp[2] = (uint8_t)((max_block >> 16u) & 0xFFu);
    resp[3] = (uint8_t)((max_block >>  8u) & 0xFFu);
    resp[4] = (uint8_t)( max_block         & 0xFFu);
    *resp_len = 5u;
    return E_OK;
}

/* UDS 0x36: TransferData — sends one block of firmware data */
/* Request: 0x36 + blockSequenceCounter(1) + data[maxBlockLen-2] */
/* Response: 0x76 + blockSequenceCounter(1) */

#include "Flash_If.h"

Std_ReturnType TD_TransferData(const uint8_t *req, uint16_t req_len,
                                uint8_t *resp, uint16_t *resp_len)
{
    if (!g_download.active) {
        resp[0]=0x7Fu; resp[1]=0x36u; resp[2]=0x24u;  /* 0x24: requestSequenceError */
        *resp_len = 3u; return E_NOT_OK;
    }

    uint8_t block_seq = req[1];   /* block sequence counter: 0x01–0xFF, then wraps to 0x00 */

    /* Verify sequence counter */
    if (block_seq != g_download.next_block) {
        resp[0]=0x7Fu; resp[1]=0x36u; resp[2]=0x73u;  /* 0x73: wrongBlockSequenceCounter */
        *resp_len = 3u; return E_NOT_OK;
    }

    const uint8_t *data     = &req[2];
    uint16_t       data_len = req_len - 2u;

    /* Bounds check: ensure we don't write past declared length */
    if (g_download.bytes_received + data_len > g_download.length) {
        resp[0]=0x7Fu; resp[1]=0x36u; resp[2]=0x31u;
        *resp_len = 3u; return E_NOT_OK;
    }

    /* Write data to flash */
    uint32_t write_addr = g_download.address + g_download.bytes_received;
    Std_ReturnType ret  = Flash_WriteData(write_addr, data, data_len);
    if (ret != E_OK) {
        resp[0]=0x7Fu; resp[1]=0x36u; resp[2]=0x72u;  /* 0x72: uploadDownloadNotAccepted */
        *resp_len = 3u; return E_NOT_OK;
    }

    g_download.bytes_received += data_len;
    g_download.next_block = (block_seq == 0xFFu) ? 0x00u : (block_seq + 1u);  /* wrap */

    resp[0] = 0x76u;
    resp[1] = block_seq;
    *resp_len = 2u;
    return E_OK;
}