Exemple #1
0
/**
 * @brief     Write data to EEPROM.
 * @details   Only one EEPROM page can be written at once. So fucntion
 *            splits large data chunks in small EEPROM transactions if needed.
 * @note      To achieve the maximum effectivity use write operations
 *            aligned to EEPROM page boundaries.
 */
static size_t write(void *ip, const uint8_t *bp, size_t n) {

    size_t   len = 0;     /* bytes to be written at one trasaction */
    uint32_t written; /* total bytes successfully written */
    uint16_t pagesize;
    uint32_t firstpage;
    uint32_t lastpage;

    chDbgCheck((ip != NULL) && (((EepromFileStream *)ip)->vmt != NULL), "write");

    if (n == 0)
        return 0;

    n = __clamp_size(ip, n);
    if (n == 0)
        return 0;

    pagesize  =  ((EepromFileStream *)ip)->cfg->pagesize;
    firstpage = (((EepromFileStream *)ip)->cfg->barrier_low +
                 eepfs_getposition(ip)) / pagesize;
    lastpage  = (((EepromFileStream *)ip)->cfg->barrier_low +
                 eepfs_getposition(ip) + n - 1) / pagesize;

    written = 0;
    /* data fitted in single page */
    if (firstpage == lastpage) {
        len = n;
        __fitted_write(ip, bp, len, &written);
        bp += len;
        return written;
    }

    else {
        /* write first piece of data to first page boundary */
        len =  ((firstpage + 1) * pagesize) - eepfs_getposition(ip);
        len -= ((EepromFileStream *)ip)->cfg->barrier_low;
        __fitted_write(ip, bp, len, &written);
        bp += len;

        /* now writes blocks at a size of pages (may be no one) */
        while ((n - written) > pagesize) {
            len = pagesize;
            __fitted_write(ip, bp, len, &written);
            bp += len;
        }

        /* wrtie tail */
        len = n - written;
        if (len == 0)
            return written;
        else {
            __fitted_write(ip, bp, len, &written);
        }
    }

    return written;
}
Exemple #2
0
/**
 * @brief     Write data to EEPROM.
 * @details   Only one EEPROM page can be written at once. So fucntion
 *            splits large data chunks in small EEPROM transactions if needed.
 * @note      To achieve the maximum effectivity use write operations
 *            aligned to EEPROM page boundaries.
 */
static size_t write(void *ip, const uint8_t *bp, size_t n) {
    msg_t status = RDY_OK;

    size_t   len = 0;     /* bytes to be written at one trasaction */
    uint32_t written = 0; /* total bytes successfully written */
    uint32_t firstpage = getposition(ip) / EEPROM_PAGE_SIZE;
    uint32_t lastpage  = (getposition(ip) + n - 1) / EEPROM_PAGE_SIZE;

    chDbgCheck((ip != NULL) && (((EepromFileStream*)ip)->vmt != NULL), "");

    if (n == 0)
        return 0;

    n = __clamp_size(ip, n);
    if (n == 0)
        return 0;

    /* data fitted in single page */
    if (firstpage == lastpage) {
        len = n;
        __fitted_write();
        return written;
    }

    else {
        /* write first piece of data to first page boundary */
        len = ((firstpage + 1) * EEPROM_PAGE_SIZE) - getposition(ip);
        __fitted_write();

        /* now writes blocks at a size of pages (may be no one) */
        while ((n - written) > EEPROM_PAGE_SIZE) {
            len = EEPROM_PAGE_SIZE;
            __fitted_write();
        }

        /* wrtie tail */
        len = n - written;
        if (len == 0)
            return written;
        else {
            __fitted_write();
        }
    }
    return written;
}