driver.c 文件参考

SPI Flash W25Qxx Driver 更多...

#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>

driver.c 的引用(Include)关系图:

浏览源代码.

函数
xwer_t	xwds_w25qxx_drv_start (struct xwds_device *dev)
	W25QXX基本驱动：启动设备
xwer_t	xwds_w25qxx_drv_stop (struct xwds_device *dev)
	W25QXX基本驱动：停止设备
xwer_t	xwds_w25qxx_drv_resume (struct xwds_device *dev)
	W25QXX基本驱动：暂停设备
xwer_t	xwds_w25qxx_drv_suspend (struct xwds_device *dev)
	W25QXX基本驱动：继续设备
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)
	W25QXX API：向W25QXX发送指令
xwer_t	xwds_w25qxx_reset (struct xwds_w25qxx *w25qxx, xwtm_t to)
	W25QXX API：向W25QXX发送复位命令
xwer_t	xwds_w25qxx_init_parameter (struct xwds_w25qxx *w25qxx, xwtm_t to)
	W25QXX API：初始化W25QXX的参数
xwer_t	xwds_w25qxx_write_enable (struct xwds_w25qxx *w25qxx, xwtm_t to)
	W25QXX API：开启W25QXX的写操作
xwer_t	xwds_w25qxx_write_disable (struct xwds_w25qxx *w25qxx, xwtm_t to)
	W25QXX API：关闭W25QXX的写操作
xwer_t	xwds_w25qxx_read_sr (struct xwds_w25qxx *w25qxx, xwu32_t sridx, xwu8_t *srbuf, xwtm_t to)
	W25QXX API：读取W25QXX的SR寄存器
xwer_t	xwds_w25qxx_check_idle (struct xwds_w25qxx *w25qxx, xwtm_t to)
	W25QXX API：检测W25QXX是否空闲
xwer_t	xwds_w25qxx_wait_idle (struct xwds_w25qxx *w25qxx, xwtm_t period, xwtm_t to)
	W25QXX API：等待W25QXX是否空闲
xwer_t	xwds_w25qxx_read_uid (struct xwds_w25qxx *w25qxx, xwu64_t *uidbuf, xwtm_t to)
	W25QXX API：读取W25QXX的UID
xwer_t	xwds_w25qxx_read_mid (struct xwds_w25qxx *w25qxx, xwu16_t *midbuf, xwtm_t to)
	W25QXX API：读取W25QXX的MID
xwer_t	xwds_w25qxx_read_jid (struct xwds_w25qxx *w25qxx, xwu32_t *jidbuf, xwtm_t to)
	W25QXX API：读取W25QXX的JID
xwer_t	xwds_w25qxx_read (struct xwds_w25qxx *w25qxx, xwu32_t address, xwu8_t *rxb, xwsz_t *size, xwtm_t to)
	W25QXX API：向W25QXX读取数据
xwer_t	xwds_w25qxx_write (struct xwds_w25qxx *w25qxx, xwu32_t address, xwu8_t *txb, xwsz_t *size, xwtm_t to)
	W25QXX API：向W25QXX写入数据
xwer_t	xwds_w25qxx_erase_sector (struct xwds_w25qxx *w25qxx, xwu32_t address, xwtm_t to)
	W25QXX API：擦除W25QXX的sector
xwer_t	xwds_w25qxx_erase_32kblk (struct xwds_w25qxx *w25qxx, xwu32_t address, xwtm_t to)
	W25QXX API：擦除W25QXX的32KiB的块
xwer_t	xwds_w25qxx_erase_64kblk (struct xwds_w25qxx *w25qxx, xwu32_t address, xwtm_t to)
	W25QXX API：擦除W25QXX的64KiB的块
xwer_t	xwds_w25qxx_erase_chip (struct xwds_w25qxx *w25qxx, xwtm_t to)
	W25QXX API：擦除W25QXX的全部数据

详细描述

SPI Flash W25Qxx Driver

作者

• 隐星魂 (Roy Sun) xwos@.nosp@m.xwos.nosp@m..tech

版权所有

• Copyright © 2015 xwos.tech, All Rights Reserved.

  ‍Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0
  

  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

在文件 driver.c 中定义.

函数说明

xwds_w25qxx_check_idle()

xwer_t xwds_w25qxx_check_idle	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	to
	)

W25QXX API：检测W25QXX是否空闲

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

返回值

XWOK	空闲
-EBUSY	繁忙

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 338 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_ctrl()

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
	)

W25QXX API：向W25QXX发送指令

参数

[in]	w25qxx	W25QXX对象指针
[in]	instruction	指令
[in]	address_size	地址信息长度
[in]	address	地址
[in]	dummy_cycles	SPI通讯过程中的无效时钟周期
[in]	txd	SPI通讯过程中的发送数据的缓冲区
[out]	rxb	SPI通讯过程中的接收数据的缓冲区
[in]	size	SPI通讯过程中的缓冲区大小
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

• 时序由 w25qxx->spip.buscfgid 定义。
• to 表示等待超时的时间点：
  • to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
  • 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 76 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_drv_resume()

xwer_t xwds_w25qxx_drv_resume

(

struct xwds_device *

dev

)

W25QXX基本驱动：暂停设备

在文件 driver.c 第 62 行定义.

{
        return xwds_w25qxx_drv_start(dev);
}

函数调用图:

xwds_w25qxx_drv_start()

xwer_t xwds_w25qxx_drv_start

(

struct xwds_device *

dev

)

W25QXX基本驱动：启动设备

<No error

在文件 driver.c 第 30 行定义.

{
        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;
}

这是这个函数的调用关系图:

xwds_w25qxx_drv_stop()

xwer_t xwds_w25qxx_drv_stop

(

struct xwds_device *

dev

)

W25QXX基本驱动：停止设备

< 去除未使用变量的警告

<No error

在文件 driver.c 第 54 行定义.

{
        XWOS_UNUSED(dev);
        return XWOK;
}

这是这个函数的调用关系图:

xwds_w25qxx_drv_suspend()

xwer_t xwds_w25qxx_drv_suspend

(

struct xwds_device *

dev

)

W25QXX基本驱动：继续设备

在文件 driver.c 第 68 行定义.

{
        return xwds_w25qxx_drv_stop(dev);
}

函数调用图:

xwds_w25qxx_erase_32kblk()

xwer_t xwds_w25qxx_erase_32kblk	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t	address,
		xwtm_t	to
	)

W25QXX API：擦除W25QXX的32KiB的块

参数

[in]	w25qxx	W25QXX对象指针
[in]	address	起始地址
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 584 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_erase_64kblk()

xwer_t xwds_w25qxx_erase_64kblk	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t	address,
		xwtm_t	to
	)

W25QXX API：擦除W25QXX的64KiB的块

参数

[in]	w25qxx	W25QXX对象指针
[in]	address	起始地址
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 623 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_erase_chip()

xwer_t xwds_w25qxx_erase_chip	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	to
	)

W25QXX API：擦除W25QXX的全部数据

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 662 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_erase_sector()

xwer_t xwds_w25qxx_erase_sector	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t	address,
		xwtm_t	to
	)

W25QXX API：擦除W25QXX的sector

参数

[in]	w25qxx	W25QXX对象指针
[in]	address	起始地址
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

<No error

在文件 driver.c 第 545 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_init_parameter()

xwer_t xwds_w25qxx_init_parameter	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	to
	)

W25QXX API：初始化W25QXX的参数

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

<No error

在文件 driver.c 第 178 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_read()

xwer_t xwds_w25qxx_read	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t	address,
		xwu8_t *	rxb,
		xwsz_t *	size,
		xwtm_t	to
	)

W25QXX API：向W25QXX读取数据

参数

[in]	w25qxx	W25QXX对象指针
[in]	address	起始地址
[out]	rxb	指向缓冲区的指针，通过此缓冲区返回数据
[in,out]	size	指向缓冲区的指针，此缓冲区： (I) 作为输入时，表示缓冲区长度 (O) 作为输出时，返回实际读取的长度
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 466 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_read_jid()

xwer_t xwds_w25qxx_read_jid	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t *	jidbuf,
		xwtm_t	to
	)

W25QXX API：读取W25QXX的JID

参数

[in]	w25qxx	W25QXX对象指针
[out]	jidbuf	指向缓冲区的指针，通过此缓冲区返回JID
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 435 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_read_mid()

xwer_t xwds_w25qxx_read_mid	(	struct xwds_w25qxx *	w25qxx,
		xwu16_t *	midbuf,
		xwtm_t	to
	)

W25QXX API：读取W25QXX的MID

参数

[in]	w25qxx	W25QXX对象指针
[out]	midbuf	指向缓冲区的指针，通过此缓冲区返回MID
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 405 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_read_sr()

xwer_t xwds_w25qxx_read_sr	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t	sridx,
		xwu8_t *	srbuf,
		xwtm_t	to
	)

W25QXX API：读取W25QXX的SR寄存器

参数

[in]	w25qxx	W25QXX对象指针
[in]	sridx	SR寄存器的序号
[out]	srbuf	指向缓冲区的指针，通过此缓冲区返回SR寄存器的值
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 296 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_read_uid()

xwer_t xwds_w25qxx_read_uid	(	struct xwds_w25qxx *	w25qxx,
		xwu64_t *	uidbuf,
		xwtm_t	to
	)

W25QXX API：读取W25QXX的UID

参数

[in]	w25qxx	W25QXX对象指针
[out]	uidbuf	指向缓冲区的指针，通过此缓冲区返回UID
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 375 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_reset()

xwer_t xwds_w25qxx_reset	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	to
	)

W25QXX API：向W25QXX发送复位命令

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 142 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_wait_idle()

xwer_t xwds_w25qxx_wait_idle	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	period,
		xwtm_t	to
	)

W25QXX API：等待W25QXX是否空闲

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 355 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_write()

xwer_t xwds_w25qxx_write	(	struct xwds_w25qxx *	w25qxx,
		xwu32_t	address,
		xwu8_t *	txb,
		xwsz_t *	size,
		xwtm_t	to
	)

W25QXX API：向W25QXX写入数据

参数

[in]	w25qxx	W25QXX对象指针
[in]	address	起始地址
[in]	txb	待写入的数据缓冲区
[in,out]	size	指向缓冲区的指针，此缓冲区： (I) 作为输入时，表示缓冲区长度 (O) 作为输出时，返回实际写入的长度
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 500 行定义.

{
        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;
}

函数调用图:

xwds_w25qxx_write_disable()

xwer_t xwds_w25qxx_write_disable	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	to
	)

W25QXX API：关闭W25QXX的写操作

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 268 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图:

xwds_w25qxx_write_enable()

xwer_t xwds_w25qxx_write_enable	(	struct xwds_w25qxx *	w25qxx,
		xwtm_t	to
	)

W25QXX API：开启W25QXX的写操作

参数

[in]	w25qxx	W25QXX对象指针
[in]	to	期望唤醒的时间点

返回

错误码

注解

• 上下文：线程

to 表示等待超时的时间点：

• to 通常是未来的时间，即 当前系统时间 + delta ， 可以使用 xwtm_ft(delta) 表示；
• 如果 to 是过去的时间点，将直接返回 -ETIMEDOUT 。

<No error

在文件 driver.c 第 228 行定义.

{
        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;
}

函数调用图:

这是这个函数的调用关系图: