driver.c

浏览该文件的文档.

 
#include <xwos/standard.h>
#include <string.h>
#include <xwos/osal/thd.h>
#include <xwcd/ds/spi/peripheral.h>
#include <xwcd/peripheral/spi/flash/w25qxx/device.h>
#include <xwcd/peripheral/spi/flash/w25qxx/driver.h>
 
/******** ******** base driver ******** ********/
__xwbsp_code
xwer_t xwds_w25qxx_drv_start(struct xwds_device * dev)
{
        struct xwds_w25qxx * w25qxx;
        const struct xwds_w25qxx_driver * drv;
        const struct xwds_w25qxx_cmd * cmdtbl;
        xwer_t rc;
 
        w25qxx = xwds_cast(struct xwds_w25qxx *, dev);
        drv = xwds_cast(struct xwds_w25qxx_driver *, dev->drv);
        cmdtbl = w25qxx->cmdtbl;
        if ((NULL == drv) || (NULL == drv->io) ||
            (NULL == cmdtbl) || (NULL == w25qxx->spip.bus)) {
                rc = -EINVAL;
                goto err_desc_err;
        }
        memset(w25qxx->txq, 0, sizeof(w25qxx->txq));
        memset(w25qxx->rxq, 0, sizeof(w25qxx->rxq));
        return XWOK;
 
err_desc_err:
        return rc;
}
 
__xwbsp_code
xwer_t xwds_w25qxx_drv_stop(struct xwds_device * dev)
{
        XWOS_UNUSED(dev);
        return XWOK;
}
 
#if defined(XWCDCFG_ds_PM) && (1 == XWCDCFG_ds_PM)
__xwbsp_code
xwer_t xwds_w25qxx_drv_resume(struct xwds_device * dev)
{
        return xwds_w25qxx_drv_start(dev);
}
 
__xwbsp_code
xwer_t xwds_w25qxx_drv_suspend(struct xwds_device * dev)
{
        return xwds_w25qxx_drv_stop(dev);
}
#endif
 
/******** ******** ******** APIs ******** ******** ********/
__xwbsp_api
xwer_t xwds_w25qxx_ctrl(struct xwds_w25qxx * w25qxx,
                        xwu8_t instruction,
                        xwu8_t address_size, xwu32_t address,
                        xwu32_t dummy_cycles,
                        const xwu8_t txd[], xwu8_t * rxb, xwsz_t size,
                        xwtm_t to)
{
        const struct xwds_w25qxx_driver * drv;
        xwsz_t i, j, idx, rxofs, xfersize;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        rc = xwds_w25qxx_grab(w25qxx);
        if (__xwcc_unlikely(rc < 0)) {
                goto err_w25qxx_grab;
        }
        drv = xwds_cast(struct xwds_w25qxx_driver *, w25qxx->spip.dev.drv);
        idx = 0;
        w25qxx->txq[idx] = instruction;
        idx++;
        if (address_size) {
                for (i = 0, j = (xwsz_t)(address_size - 1);
                     i < address_size;
                     i++, j--) {
                        w25qxx->txq[idx] = (xwu8_t)(address >> (j * 8));
                        idx++;
                }
        }
        if (dummy_cycles) {
                for (i = 0; i < (dummy_cycles / 8); i++) {
                        w25qxx->txq[idx] = 0;
                        idx++;
                }
        }
        rxofs = idx;
        for (i = 0; i < size; i++) {
                if (txd) {
                        w25qxx->txq[idx] = txd[i];
                } else {
                        w25qxx->txq[idx] = 0;
                }
                idx++;
        }
        xfersize = idx;
        rc = drv->io(w25qxx,
                     w25qxx->txq, w25qxx->rxq, &xfersize,
                     to);
        if (rc < 0) {
                goto err_spim_xfer;
        }
        if (rxb) {
                for (i = 0; i < size; i++) {
                        rxb[i] = w25qxx->rxq[rxofs + i];
                }
        }
        xwds_w25qxx_put(w25qxx);
        return XWOK;
 
err_spim_xfer:
        xwds_w25qxx_put(w25qxx);
err_w25qxx_grab:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_reset(struct xwds_w25qxx * w25qxx, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_ENABLE_RESET];
        if (cmd.existing) {
                rc = xwds_w25qxx_ctrl(w25qxx,
                                      cmd.instruction,
                                      cmd.address_size, cmd.address,
                                      cmd.dummy_cycles,
                                      NULL, NULL, 0, to);
                if (rc < 0) {
                        goto err_w25qxx_ctrl;
                }
        }
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_RESET];
        if (cmd.existing) {
                rc = xwds_w25qxx_ctrl(w25qxx,
                                      cmd.instruction,
                                      cmd.address_size, cmd.address,
                                      cmd.dummy_cycles,
                                      NULL, NULL, 0, to);
                if (rc < 0) {
                        goto err_w25qxx_ctrl;
                }
        }
        return XWOK;
 
err_w25qxx_ctrl:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_init_parameter(struct xwds_w25qxx * w25qxx, xwtm_t to)
{
        xwu64_t uid;
        xwu32_t jid;
        xwu16_t mid;
        xwer_t rc;
 
        rc = xwds_w25qxx_read_uid(w25qxx, &uid, to);
        if (rc < 0) {
                goto err_read_uid;
        }
        rc = xwds_w25qxx_read_mid(w25qxx, &mid, to);
        if (rc < 0) {
                goto err_read_mid;
        }
        rc = xwds_w25qxx_read_jid(w25qxx, &jid, to);
        if (rc < 0) {
                goto err_read_jid;
        }
        switch (w25qxx->parameter.mid) {
        case XWDS_W25Q80_MID:
                w25qxx->parameter.size = 1 * 1024 * 1024;
                break;
        case XWDS_W25Q16_MID:
                w25qxx->parameter.size = 2 * 1024 * 1024;
                break;
        case XWDS_W25Q32_MID:
                w25qxx->parameter.size = 4 * 1024 * 1024;
                break;
        case XWDS_W25Q64_MID:
                w25qxx->parameter.size = 8 * 1024 * 1024;
                break;
        case XWDS_W25Q128_MID:
                w25qxx->parameter.size = 16 * 1024 * 1024;
                break;
        case XWDS_W25Q256_MID:
                w25qxx->parameter.size = 32 * 1024 * 1024;
                break;
        default:
                break;
        }
        return XWOK;
 
err_read_jid:
err_read_mid:
err_read_uid:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_write_enable(struct xwds_w25qxx * w25qxx, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
        xwu8_t sr1;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_WRITE_ENABLE];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, NULL, 0, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        rc = xwds_w25qxx_read_sr(w25qxx,
                                 XWDS_W25QXX_SR_1, &sr1,
                                 to);
        if (rc < 0) {
                goto err_chk_wel;
        }
        if (!(sr1 & XWDS_W25QXX_SR1_WEL)) {
                rc = -EACCES;
                goto err_chk_wel;
        }
        return XWOK;
 
err_chk_wel:
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_write_disable(struct xwds_w25qxx * w25qxx, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_WRITE_DISABLE];
        if (cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, NULL, 0, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_read_sr(struct xwds_w25qxx * w25qxx,
                           xwu32_t sridx, xwu8_t * srbuf,
                           xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
        XWDS_VALIDATE((sridx < XWDS_W25QXX_SR_NUM), "out-of-range", -ECHRNG);
 
        switch (sridx) {
        case XWDS_W25QXX_SR_2:
                cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_READ_STATUS_REG_2];
                break;
        case XWDS_W25QXX_SR_3:
                cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_READ_STATUS_REG_3];
                break;
        case XWDS_W25QXX_SR_1:
        default:
                cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_READ_STATUS_REG_1];
                break;
        }
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, srbuf, 1, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_check_idle(struct xwds_w25qxx * w25qxx, xwtm_t to)
{
        xwer_t rc;
        xwu8_t sr1;
 
        rc = xwds_w25qxx_read_sr(w25qxx,
                                 XWDS_W25QXX_SR_1, &sr1,
                                 to);
        if (XWOK == rc) {
                if (sr1 & XWDS_W25QXX_SR1_BUSY) {
                        rc = -EBUSY;
                }
        }
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_wait_idle(struct xwds_w25qxx * w25qxx, xwtm_t period, xwtm_t to)
{
        xwer_t rc;
        xwtm_t from, sleepto;
 
        rc = xwds_w25qxx_check_idle(w25qxx, to);
        from = xwtm_now();
        while ((-EBUSY == rc) && (xwtm_cmp(to, from) > 0)) {
                sleepto = xwtm_add_safely(from, period);
                sleepto = xwtm_cmp(sleepto, to) > 0 ? to : sleepto;
                rc = xwos_cthd_sleep_to(sleepto);
                if (XWOK == rc) {
                        rc = xwds_w25qxx_check_idle(w25qxx, to);
                        from = xwtm_now();
                }
        }
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_read_uid(struct xwds_w25qxx * w25qxx, xwu64_t * uidbuf, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_UNIQUE_ID];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, (xwu8_t *)uidbuf, 8, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        *uidbuf = xwbop_re(xwu64_t, *uidbuf);
        w25qxx->parameter.uid = *uidbuf;
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_read_mid(struct xwds_w25qxx * w25qxx, xwu16_t * midbuf, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_MANUFACTURER_DEVICE_ID];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, (xwu8_t *)midbuf, 2, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        *midbuf = xwbop_re(xwu16_t, *midbuf);
        w25qxx->parameter.mid = *midbuf;
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_read_jid(struct xwds_w25qxx * w25qxx, xwu32_t * jidbuf, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_JEDEC_DEVICE_ID];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, (xwu8_t *)jidbuf, 3, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        *jidbuf = xwbop_re(xwu32_t, *jidbuf);
        *jidbuf >>= 8;
        w25qxx->parameter.jid = *jidbuf;
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_read(struct xwds_w25qxx * w25qxx, xwu32_t address,
                        xwu8_t * rxb, xwsz_t * size, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwsz_t xfsize;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
        XWDS_VALIDATE(rxb, "nullptr", -EFAULT);
        XWDS_VALIDATE(size, "nullptr", -EFAULT);
 
        xfsize = *size;
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_FAST_READ_DATA];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, address,
                              cmd.dummy_cycles,
                              NULL, rxb, xfsize, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        *size = xfsize;
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_write(struct xwds_w25qxx * w25qxx, xwu32_t address,
                         xwu8_t * txb, xwsz_t * size, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwsz_t xfsize;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
        XWDS_VALIDATE(txb, "nullptr", -EFAULT);
        XWDS_VALIDATE(size, "nullptr", -EFAULT);
 
        rc = xwds_w25qxx_write_enable(w25qxx, to);
        if (rc < 0) {
                goto err_we;
        }
        rc = xwds_w25qxx_wait_idle(w25qxx, XWTM_MS(1), to);
        if (rc < 0) {
                goto err_wait_idle;
        }
        xfsize = *size;
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_PAGE_PROGRAM];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, address,
                              cmd.dummy_cycles,
                              txb, NULL, xfsize, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        *size = xfsize;
        return XWOK;
 
err_w25qxx_ctrl:
err_not_support:
err_wait_idle:
        xwds_w25qxx_write_disable(w25qxx, to);
err_we:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_erase_sector(struct xwds_w25qxx * w25qxx, xwu32_t address, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        rc = xwds_w25qxx_write_enable(w25qxx, to);
        if (rc < 0) {
                goto err_we;
        }
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_SECTOR_ERASE];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, address,
                              cmd.dummy_cycles,
                              NULL, NULL, 0, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        rc = xwds_w25qxx_wait_idle(w25qxx, XWTM_MS(400), to);
        if (rc < 0) {
                goto err_chk_idle;
        }
        return XWOK;
 
err_chk_idle:
err_w25qxx_ctrl:
err_not_support:
        xwds_w25qxx_write_disable(w25qxx, to);
err_we:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_erase_32kblk(struct xwds_w25qxx * w25qxx, xwu32_t address, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        rc = xwds_w25qxx_write_enable(w25qxx, to);
        if (rc < 0) {
                goto err_we;
        }
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_32KBLOCK_ERASE];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, address,
                              cmd.dummy_cycles,
                              NULL, NULL, 0, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        rc = xwds_w25qxx_wait_idle(w25qxx, XWTM_MS(1600), to);
        if (rc < 0) {
                goto err_chk_idle;
        }
        return XWOK;
 
err_chk_idle:
err_w25qxx_ctrl:
err_not_support:
        xwds_w25qxx_write_disable(w25qxx, to);
err_we:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_erase_64kblk(struct xwds_w25qxx * w25qxx, xwu32_t address, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        rc = xwds_w25qxx_write_enable(w25qxx, to);
        if (rc < 0) {
                goto err_we;
        }
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_64KBLOCK_ERASE];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, address,
                              cmd.dummy_cycles,
                              NULL, NULL, 0, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        rc = xwds_w25qxx_wait_idle(w25qxx, XWTM_MS(2000), to);
        if (rc < 0) {
                goto err_chk_idle;
        }
        return XWOK;
 
err_chk_idle:
err_w25qxx_ctrl:
err_not_support:
        xwds_w25qxx_write_disable(w25qxx, to);
err_we:
        return rc;
}
 
__xwbsp_api
xwer_t xwds_w25qxx_erase_chip(struct xwds_w25qxx * w25qxx, xwtm_t to)
{
        struct xwds_w25qxx_cmd cmd;
        xwer_t rc;
 
        XWDS_VALIDATE(w25qxx, "nullptr", -EFAULT);
 
        rc = xwds_w25qxx_write_enable(w25qxx, to);
        if (rc < 0) {
                goto err_we;
        }
        cmd = w25qxx->cmdtbl[XWDS_W25QXX_CMD_CHIP_ERASE];
        if (1 != cmd.existing) {
                rc = -ENOTSUP;
                goto err_not_support;
        }
        rc = xwds_w25qxx_ctrl(w25qxx,
                              cmd.instruction,
                              cmd.address_size, cmd.address,
                              cmd.dummy_cycles,
                              NULL, NULL, 0, to);
        if (rc < 0) {
                goto err_w25qxx_ctrl;
        }
        rc = xwds_w25qxx_wait_idle(w25qxx, XWTM_MS(2000), to);
        if (rc < 0) {
                goto err_chk_idle;
        }
        return XWOK;
 
err_chk_idle:
err_w25qxx_ctrl:
err_not_support:
        xwds_w25qxx_write_disable(w25qxx, to);
err_we:
        return rc;
}