usbd_dfu_mal.c

Go to the documentation of this file.

/* Includes ------------------------------------------------------------------*/
#include "usbd_dfu_mal.h"
#include "usbd_flash_if.h"

/* The reference tables of global memories callback and string descriptors.
   To add a new memory, You can do as follows: 
   1. Modify the value of MAX_USED_MEDIA in usbd_dfu_mal.h
   2. Add the pointer to the callback structure in this table
   3. Add the pointer to the memory string descriptor in usbd_dfu_StringDesc table
   No other operation is required.
 */
DFU_MAL_Property_TypeDef* tMALTab[MAX_USED_MEMORY_MEDIA] = {
    &DFU_Flash_cb
};

/* The list of memory interface string descriptor pointers. This list
   can be updated whenever a memory has to be added or removed */
const uint8_t* USBD_DFU_StringDesc[MAX_USED_MEMORY_MEDIA] = {
    FLASH_IF_STRING
};

/* Memory buffer for downloaded data */
uint8_t  MAL_Buffer[TRANSFER_SIZE];

static uint8_t  DFU_MAL_CheckAddr (uint32_t Addr);

uint8_t  DFU_MAL_Init (void)
{
    uint32_t memIdx = 0;

    /* Initialize all supported memory medias */
    for(memIdx = 0; memIdx < MAX_USED_MEMORY_MEDIA; memIdx++)
    {
        /* Check if the memory media exists */
        if (tMALTab[memIdx]->pMAL_Init != NULL)
        {
            tMALTab[memIdx]->pMAL_Init();
        }
    }

    return MAL_OK;
}

uint8_t  DFU_MAL_DeInit (void)
{
    uint32_t memIdx = 0;

    /* Deinitializes all supported memory medias */
    for(memIdx = 0; memIdx < MAX_USED_MEMORY_MEDIA; memIdx++)
    {
        /* Check if the memory media exists */
        if (tMALTab[memIdx]->pMAL_DeInit != NULL)
        {
            tMALTab[memIdx]->pMAL_DeInit();
        }
    }

    return MAL_OK;
}

uint8_t  DFU_MAL_Erase (uint32_t Addr)
{
    uint32_t memIdx = DFU_MAL_CheckAddr(Addr);

    /* Check if the address is in protected area */
    if (IS_PROTECTED_AREA(Addr))
    {
        return MAL_FAIL;
    }

    if (memIdx < MAX_USED_MEMORY_MEDIA)
    {
        /* Check if the operation is supported */
        if (tMALTab[memIdx]->pMAL_Erase != NULL)
        {
            return tMALTab[memIdx]->pMAL_Erase(Addr);
        }
        else
        {
            return MAL_FAIL;
        }
    }
    else
    {
        return MAL_FAIL;
    }
}

uint8_t  DFU_MAL_Write (uint32_t Addr, uint32_t Len)
{
    uint32_t memIdx = DFU_MAL_CheckAddr(Addr);

    /* Check if the address is in protected area */
    if (IS_PROTECTED_AREA(Addr))
    {
        return MAL_FAIL;
    }

    if (memIdx < MAX_USED_MEMORY_MEDIA)
    {
        /* Check if the operation is supported */
        if (tMALTab[memIdx]->pMAL_Write != NULL)
        {
            return tMALTab[memIdx]->pMAL_Write(Addr, Len);
        }
        else
        {
            return MAL_FAIL;
        }
    }
    else
    {
        return MAL_FAIL;
    }
}

uint8_t*  DFU_MAL_Read (uint32_t Addr, uint32_t Len)
{
    uint32_t memIdx = 0;

    if(Addr != OB_RDPT)
    {
        memIdx = DFU_MAL_CheckAddr(Addr);
    }

    if (memIdx < MAX_USED_MEMORY_MEDIA)
    {
        /* Check if the operation is supported */
        if (tMALTab[memIdx]->pMAL_Read != NULL)
        {
            return tMALTab[memIdx]->pMAL_Read(Addr, Len);
        }
        else
        {
            return MAL_Buffer;
        }
    }
    else
    {
        return MAL_Buffer;
    }
}

uint8_t  DFU_MAL_GetStatus (uint32_t Addr, uint8_t Cmd, uint8_t *buffer)
{
    uint32_t memIdx = DFU_MAL_CheckAddr(Addr);

    if (memIdx < MAX_USED_MEMORY_MEDIA)
    {
        if (Cmd & 0x01)
        {
            SET_POLLING_TIMEOUT(tMALTab[memIdx]->WriteTimeout);
        }
        else
        {
            SET_POLLING_TIMEOUT(tMALTab[memIdx]->EraseTimeout);
        }

        return MAL_OK;
    }
    else
    {
        return MAL_FAIL;
    }
}

static uint8_t  DFU_MAL_CheckAddr (uint32_t Addr)
{
    uint32_t memIdx = 0;

    /* Check with all supported memories */
    for(memIdx = 0; memIdx < MAX_USED_MEMORY_MEDIA; memIdx++)
    {
        /* If the check address is supported, return the memory index */
        if (tMALTab[memIdx]->pMAL_CheckAdd(Addr) == MAL_OK)
        {
            return memIdx;
        }
    }

    /* If there is no memory found, return MAX_USED_MEDIA */
    return (MAX_USED_MEMORY_MEDIA);
}

/************************ (C) COPYRIGHT 2014 GIGADEVICE *****END OF FILE****/