增加所有文件
This commit is contained in:
330
drivers/source/xspi_mst_slv/sdrv_xspi_mst.c
Normal file
330
drivers/source/xspi_mst_slv/sdrv_xspi_mst.c
Normal file
@@ -0,0 +1,330 @@
|
||||
/**
|
||||
* @file sdrv_xspi_mst.c
|
||||
* @brief sdrv_xspi_mst driver
|
||||
*
|
||||
* @copyright Copyright (c) 2021 Semidrive Semiconductor.
|
||||
* All rights reserved.
|
||||
*/
|
||||
|
||||
#include <compiler.h>
|
||||
#include <debug.h>
|
||||
#include <param.h>
|
||||
#include <reg.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "sdrv_xspi_mst_reg.h"
|
||||
#include "regs_base.h"
|
||||
#include "sdrv_xspi_mst.h"
|
||||
#include "udelay/udelay.h"
|
||||
|
||||
#define XSPI_MODE_CTRL (0x0u)
|
||||
#define XSPI_SCLK_CTRL (0xC0u)
|
||||
#define XSPI_DLL_CTRL (0xE0u)
|
||||
#define XSPI_DLL1_CTRL (0xE8u)
|
||||
|
||||
|
||||
static const char *ms_int_st[] = {
|
||||
"read timeout",
|
||||
"read axi id mismatch",
|
||||
"read user check fail",
|
||||
"read sid check fail",
|
||||
"read crc check fail",
|
||||
"read length check fail",
|
||||
"reserved",
|
||||
"reserved",
|
||||
"write timeout",
|
||||
"write aid check fail",
|
||||
"write usr check fail",
|
||||
"write sid check fail",
|
||||
"write crc check fail",
|
||||
"reserved",
|
||||
"reserved",
|
||||
"reserved",
|
||||
"slave axi write utid error", // 16~29 generate master bus error
|
||||
"slave axi write mismatch error",
|
||||
"slave write error",
|
||||
"slave write sid error",
|
||||
"slave write crc check error",
|
||||
"slave axi address access illegal",
|
||||
"slave write len error",
|
||||
"reserved",
|
||||
"slave axi read utid error",
|
||||
"slave axi read mismatch error", // OT error
|
||||
"slave read error", // slave bus error
|
||||
"slave read sid error", // sequence id (4bits) error
|
||||
"slave read crc check error",
|
||||
"slave axi address access illegal",
|
||||
"reserved",
|
||||
"reserved"
|
||||
};
|
||||
|
||||
status_t sdrv_xspi_mst_fail_reason(struct sdrv_xspi_mst *xspi)
|
||||
{
|
||||
uint32_t reg;
|
||||
|
||||
reg = sdrv_xspi_mst_get_attr(xspi, XSPI_MST_MS_INT_ST, ®);
|
||||
|
||||
for (uint32_t i = 0; i < sizeof(ms_int_st) / sizeof(ms_int_st[0]); i++) {
|
||||
if ((0x1u << i) & reg) {
|
||||
ssdk_printf(SSDK_ERR, "xspi ms int status: %s\n", ms_int_st[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return reg;
|
||||
}
|
||||
|
||||
|
||||
static status_t xspi_wait_for_bit_times(addr_t reg, const uint32_t mask, bool clear,
|
||||
uint32_t times)
|
||||
{
|
||||
uint32_t val;
|
||||
uint32_t count = 0;
|
||||
|
||||
while (count < times) {
|
||||
val = readl(reg);
|
||||
if (clear) {
|
||||
val = ~val;
|
||||
}
|
||||
val &= mask;
|
||||
|
||||
if (val == mask) {
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
count++;
|
||||
}
|
||||
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_LOCKED_ERR;
|
||||
}
|
||||
static status_t sdrv_xspi_dll_enable(paddr_t apb_base, int dll_num, int value,
|
||||
bool enable)
|
||||
{
|
||||
uint32_t reg = 0u;
|
||||
int ret = SDRV_STATUS_FAIL;
|
||||
uint32_t addr;
|
||||
|
||||
addr = dll_num ? XSPI_DLL1_CTRL : XSPI_DLL_CTRL;
|
||||
|
||||
if (enable) {
|
||||
writel(reg, apb_base + addr);
|
||||
reg |= value << 1;
|
||||
writel(reg, apb_base + addr);
|
||||
reg |= 1;
|
||||
writel(reg, apb_base + addr);
|
||||
|
||||
ret = xspi_wait_for_bit_times(apb_base + addr + 4, 1 << 16, false, 100000);
|
||||
if (ret != SDRV_STATUS_OK) {
|
||||
ssdk_printf(SSDK_ERR, "dll enable err\n");
|
||||
return ret;
|
||||
}
|
||||
RMWREG32(apb_base + addr, 31, 1, 1);//open update gate
|
||||
}
|
||||
|
||||
RMWREG32(apb_base + XSPI_MODE_CTRL, 31, 1, 1);
|
||||
udelay(1);
|
||||
RMWREG32(apb_base + XSPI_MODE_CTRL, 31, 1, 0);
|
||||
while (sdrv_xspi_master_is_busy(apb_base));
|
||||
|
||||
/* set dll_en */
|
||||
RMWREG32(apb_base + XSPI_SCLK_CTRL, 1, 1, enable ? 1 : 0);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void sdrv_xspi_mst_training(paddr_t apb_base)
|
||||
{
|
||||
sdrv_xspi_dll_enable(apb_base, 0u, 0xf, true);
|
||||
}
|
||||
|
||||
static status_t sdrv_xspi_mst_check_bit(struct sdrv_xspi_mst *master, uint32_t reg,
|
||||
uint8_t offset, bool value, uint32_t count)
|
||||
{
|
||||
ASSERT(master);
|
||||
|
||||
while (count--) {
|
||||
uint32_t tmp = readl(master->base + reg);
|
||||
if (!!((1u << offset) & tmp) == value) {
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
}
|
||||
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_CHECK_BIT_ERR;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_mst_init(struct sdrv_xspi_mst *master,
|
||||
const struct sdrv_xspi_mst_conf *conf)
|
||||
{
|
||||
ASSERT(master && conf);
|
||||
|
||||
memset(master, 0, sizeof(*master));
|
||||
|
||||
master->base = conf->base;
|
||||
master->irq = conf->irq;
|
||||
|
||||
sdrv_xspi_master_sw_rst(master->base);
|
||||
|
||||
if (sdrv_xspi_mst_check_bit(master, XSPI_MASTER_MODE_CTRL_BASE,
|
||||
XSPI_MASTER_MODE_CTRL_IDLE_OFFSET, 1, 10000)) {
|
||||
ssdk_printf(SSDK_EMERG, "xspi mst busy\r\n");
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_MODE_CTRL_BUSY_ERR;
|
||||
}
|
||||
|
||||
sdrv_xspi_master_set_ms_mode(master->base, 1);
|
||||
sdrv_xspi_master_sw_rst_pad(master->base);
|
||||
|
||||
sdrv_xspi_master_set_addr_offset_en(master->base, conf->offset.enable);
|
||||
sdrv_xspi_master_set_addr_offset_val(master->base, conf->offset.addr_offset);
|
||||
|
||||
/* rx dqs */
|
||||
sdrv_xspi_master_set_sclk_rx_sel(master->base, 2);
|
||||
sdrv_xspi_master_set_sclk_dll_en(master->base, 1);
|
||||
|
||||
sdrv_xspi_master_set_cs_sw(master->base, 0);
|
||||
|
||||
if (conf->cs <= 1) {
|
||||
sdrv_xspi_master_set_cs_sel(master->base, conf->cs ? 4 : 8);
|
||||
} else {
|
||||
ssdk_printf(SSDK_EMERG, "cs error: %d\r\n", conf->cs);
|
||||
}
|
||||
|
||||
sdrv_xspi_master_set_dll_enable(master->base, 1);
|
||||
sdrv_xspi_master_set_dll_slv_target(master->base, 0xf);
|
||||
if (sdrv_xspi_mst_check_bit(master, XSPI_MASTER_DLL_ST_BASE,
|
||||
XSPI_MASTER_DLL_ST_SLV_LOCK_OFFSET, 1, 10000)) {
|
||||
ssdk_printf(SSDK_EMERG, "xspi dll err\r\n");
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_LOCKED_ERR;
|
||||
}
|
||||
|
||||
if (sdrv_xspi_mst_check_bit(master, XSPI_MASTER_MS_CTRL_BASE,
|
||||
XSPI_MASTER_MS_CTRL_IDLE_OFFSET, 1, 10000)) {
|
||||
ssdk_printf(SSDK_EMERG, "xspi mst busy\r\n");
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_CTRL_BUSY_ERR;
|
||||
}
|
||||
|
||||
sdrv_xspi_master_set_timeout_thrd(master->base, 40000u);
|
||||
sdrv_xspi_master_set_crc_en(master->base, conf->crc_en);
|
||||
sdrv_xspi_master_set_slv_err_resp_en(master->base, conf->slv_err_resp_en);
|
||||
sdrv_xspi_master_set_dummy(master->base, conf->dummy);
|
||||
sdrv_xspi_master_set_rate(master->base, conf->is_ddr);
|
||||
sdrv_xspi_master_set_line(master->base, conf->line);
|
||||
sdrv_xspi_master_set_cs_time(master->base, 10, 7, 6);
|
||||
sdrv_xspi_master_set_rxmode(master->base, 1);
|
||||
sdrv_xspi_master_set_rxenable_mode(master->base, 1);
|
||||
sdrv_xspi_master_clr_ms_int_en(master->base, 0xffffffffu);
|
||||
sdrv_xspi_master_set_ms_int_en(master->base, 0x1fffu);
|
||||
|
||||
if(conf->is_training){
|
||||
sdrv_xspi_mst_training(master->base);
|
||||
}
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_mst_set_attr(struct sdrv_xspi_mst *master,
|
||||
enum sdrv_xspi_mst_ioctl_flag flag, const void *buf)
|
||||
{
|
||||
ASSERT(master && flag < XSPI_MST_FLAG_MAX && buf);
|
||||
|
||||
const struct sdrv_xspi_mst_addr_offset_conf *offset_conf;
|
||||
|
||||
switch (flag) {
|
||||
case XSPI_MST_FLAG_ADDR_OFFSET:
|
||||
offset_conf = buf;
|
||||
sdrv_xspi_master_set_addr_offset_en(master->base, offset_conf->enable);
|
||||
sdrv_xspi_master_set_addr_offset_val(master->base,
|
||||
offset_conf->addr_offset);
|
||||
break;
|
||||
case XSPI_MST_FLAG_SLV_ERR_RESP:
|
||||
sdrv_xspi_master_set_slv_err_resp_en(master->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_CRC_EN:
|
||||
sdrv_xspi_master_set_crc_en(master->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_DUMMY:
|
||||
sdrv_xspi_master_set_dummy(master->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_RATE:
|
||||
sdrv_xspi_master_set_rate(master->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_LINE:
|
||||
sdrv_xspi_master_set_line(master->base, *(enum sdrv_xspi_mst_line *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_TIMEOUT:
|
||||
sdrv_xspi_master_set_timeout_thrd(master->base, *(uint32_t *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_INT_ST:
|
||||
sdrv_xspi_master_clr_int_st_fuc(master->base, *(uint32_t *)buf);
|
||||
break;
|
||||
case XSPI_MST_FLAG_INT_EN:
|
||||
sdrv_xspi_master_set_int_en_fuc(master->base, *(uint32_t *)buf);
|
||||
break;
|
||||
case XSPI_MST_MS_INT_ST:
|
||||
sdrv_xspi_master_clr_ms_int_st(master->base, *(uint32_t *)buf);
|
||||
break;
|
||||
default:
|
||||
ssdk_printf(SSDK_EMERG, "set flag error: %d\r\n", flag);
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_SET_FLAG_ATTR_ERR;
|
||||
}
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_mst_get_attr(struct sdrv_xspi_mst *master,
|
||||
enum sdrv_xspi_mst_ioctl_flag flag, void *buf)
|
||||
{
|
||||
ASSERT(master && flag < XSPI_MST_FLAG_MAX && buf);
|
||||
|
||||
struct sdrv_xspi_mst_addr_offset_conf *offset_conf;
|
||||
|
||||
switch (flag) {
|
||||
case XSPI_MST_FLAG_ADDR_OFFSET:
|
||||
offset_conf = buf;
|
||||
offset_conf->enable = sdrv_xspi_master_get_addr_offset_en(
|
||||
master->base);
|
||||
offset_conf->addr_offset = sdrv_xspi_master_get_addr_offset_val(
|
||||
master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_SLV_ERR_RESP:
|
||||
*(bool *)buf = sdrv_xspi_master_get_slv_err_resp_en(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_CRC_EN:
|
||||
*(bool *)buf = sdrv_xspi_master_get_crc_en(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_DUMMY:
|
||||
*(uint8_t *)buf = sdrv_xspi_master_get_dummy(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_RATE:
|
||||
*(bool *)buf = sdrv_xspi_master_get_rate(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_LINE:
|
||||
*(enum sdrv_xspi_mst_line *)buf = (enum sdrv_xspi_mst_line)sdrv_xspi_master_get_line(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_WAIT_TIME:
|
||||
*(uint32_t *)buf = sdrv_xspi_master_get_wait_time_cycle(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_TIMEOUT:
|
||||
*(uint32_t *)buf = sdrv_xspi_master_get_timeout_thrd(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_INT_ST:
|
||||
*(uint32_t *)buf = sdrv_xspi_master_get_int_st_fuc(master->base);
|
||||
break;
|
||||
case XSPI_MST_FLAG_INT_EN:
|
||||
*(uint32_t *)buf = sdrv_xspi_master_get_int_en_fuc(master->base);
|
||||
break;
|
||||
case XSPI_MST_MS_INT_ST:
|
||||
*(uint32_t *)buf = sdrv_xspi_master_get_ms_int_st(master->base);
|
||||
break;
|
||||
default:
|
||||
ssdk_printf(SSDK_EMERG, "set flag error: %d\r\n", flag);
|
||||
return SSDRV_STATUS_GROUP_XSPI_MASTER_GET_FLAG_ATTR_ERR;
|
||||
}
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t sdrv_xspi_mst_deinit(struct sdrv_xspi_mst *master)
|
||||
{
|
||||
ASSERT(master);
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
|
||||
1013
drivers/source/xspi_mst_slv/sdrv_xspi_mst_reg.h
Normal file
1013
drivers/source/xspi_mst_slv/sdrv_xspi_mst_reg.h
Normal file
File diff suppressed because it is too large
Load Diff
474
drivers/source/xspi_mst_slv/sdrv_xspi_slv.c
Normal file
474
drivers/source/xspi_mst_slv/sdrv_xspi_slv.c
Normal file
@@ -0,0 +1,474 @@
|
||||
/**
|
||||
* @file sdrv_xspi_slv.c
|
||||
* @brief sdrv_xspi_slv driver
|
||||
*
|
||||
* @copyright Copyright (c) 2021 Semidrive Semiconductor.
|
||||
* All rights reserved.
|
||||
*/
|
||||
|
||||
#include <compiler.h>
|
||||
#include <debug.h>
|
||||
#include <param.h>
|
||||
#include <reg.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "sdrv_xspi_slv.h"
|
||||
#include "regs_base.h"
|
||||
#include "sdrv_xspi_slv_reg.h"
|
||||
#include "udelay/udelay.h"
|
||||
|
||||
status_t sdrv_xspi_slv_init(struct sdrv_xspi_slv *slave,
|
||||
const struct sdrv_xspi_slv_conf *conf)
|
||||
{
|
||||
ASSERT(slave && conf);
|
||||
|
||||
memset(slave, 0, sizeof(*slave));
|
||||
|
||||
slave->base = conf->base;
|
||||
slave->irq = conf->irq;
|
||||
|
||||
sdrv_xspi_slv_set_en(slave->base, 0);
|
||||
|
||||
sdrv_xspi_slv_set_crc_en(slave->base, !conf->crc_dis);
|
||||
sdrv_xspi_slv_set_bit_endian(slave->base, conf->bit_endian);
|
||||
sdrv_xspi_slv_set_tx_mode(slave->base, conf->tx_mode);
|
||||
sdrv_xspi_slv_set_mode(slave->base, conf->mode);
|
||||
sdrv_xspi_slv_set_rate(slave->base, conf->is_ddr);
|
||||
sdrv_xspi_slv_set_line(slave->base, conf->line);
|
||||
sdrv_xspi_slv_set_timeout_time(slave->base, 20000);
|
||||
sdrv_xspi_slv_set_timeout_en(slave->base, 1);
|
||||
sdrv_xspi_slv_set_cmd_write_trigger(slave->base, conf->cmd_wr_trg);
|
||||
sdrv_xspi_slv_set_cmd_read_trigger(slave->base, conf->cmd_rd_trg);
|
||||
sdrv_xspi_slv_set_cmd_write_packet0(slave->base, conf->cmd_wr_packet0);
|
||||
sdrv_xspi_slv_set_cmd_write_packet1(slave->base, conf->cmd_wr_packet1);
|
||||
sdrv_xspi_slv_set_cmd_write_payload(slave->base, conf->cmd_wr_payload);
|
||||
sdrv_xspi_slv_set_cmd_write_wdata(slave->base, conf->cmd_wr_wdata);
|
||||
sdrv_xspi_slv_set_cmd_write_status(slave->base, conf->cmd_wr_st);
|
||||
sdrv_xspi_slv_set_cmd_read_id(slave->base, conf->cmd_rd_id);
|
||||
sdrv_xspi_slv_set_cmd_read_status(slave->base, conf->cmd_rd_st);
|
||||
sdrv_xspi_slv_set_cmd_read_rdata(slave->base, conf->cmd_rd_rdata);
|
||||
sdrv_xspi_slv_set_cmd_read_rdata_crc(slave->base, conf->cmd_rd_rdata_crc);
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_slv_clr_status(struct sdrv_xspi_slv *slave)
|
||||
{
|
||||
sdrv_xspi_slv_set_slv_status_update(slave->base, 0xe0u);
|
||||
sdrv_xspi_slv_set_pad_crcb_mask(slave->base, 0x7cu);
|
||||
udelay(1);
|
||||
uint32_t val = sdrv_xspi_slv_get_slv_status(slave->base);
|
||||
if (val & 0x1f00u) {
|
||||
ssdk_printf(0, "update xspi slv status = 0x%x fail \r\n", val);
|
||||
return SSDRV_STATUS_GROUP_XSPI_SLAVER_GET_STATUS_ERR;
|
||||
}
|
||||
sdrv_xspi_slv_set_pad_crcb_mask(slave->base, 0x0u);
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
status_t sdrv_xspi_slv_enable(struct sdrv_xspi_slv *slave)
|
||||
{
|
||||
ASSERT(slave);
|
||||
|
||||
sdrv_xspi_slv_soft_reset(slave->base);
|
||||
sdrv_xspi_slv_set_en(slave->base, 1);
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_slv_disable(struct sdrv_xspi_slv *slave)
|
||||
{
|
||||
ASSERT(slave);
|
||||
|
||||
sdrv_xspi_slv_set_en(slave->base, 0);
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_slv_set_attr(struct sdrv_xspi_slv *slave,
|
||||
enum sdrv_xspi_slv_ioctl_flag flag, const void *buf)
|
||||
{
|
||||
ASSERT(slave && flag < XSPI_SLV_FLAG_MAX && buf);
|
||||
|
||||
const struct sdrv_xspi_slv_sclk_idle_time_conf *idle_time_conf;
|
||||
const struct sdrv_xspi_slv_debounce_ctrl_conf *debounce_conf;
|
||||
const struct sdrv_xspi_slv_timeout_mon_ctrl_conf *timeout_conf;
|
||||
const struct sdrv_xspi_slv_aid_conf *aid_conf;
|
||||
const struct sdrv_xspi_slv_acache_conf *acache_conf;
|
||||
const struct sdrv_xspi_slv_aprot_conf *aprot_conf;
|
||||
const struct sdrv_xspi_slv_mon_conf *mon_conf;
|
||||
const struct sdrv_xspi_slv_region_map_conf *map_conf;
|
||||
const struct sdrv_xspi_slv_dummy_cycle_conf *dummy_cycle_conf;
|
||||
|
||||
sdrv_xspi_slv_set_en(slave->base, 0);
|
||||
|
||||
switch (flag) {
|
||||
case XSPI_SLV_FLAG_EN:
|
||||
sdrv_xspi_slv_set_en(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CRC_EN:
|
||||
sdrv_xspi_slv_set_crc_en(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_BIT_ENDIAN:
|
||||
sdrv_xspi_slv_set_bit_endian(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_PAD_RESET_MASK:
|
||||
sdrv_xspi_slv_set_pad_reset_mask(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_WR_CHK_EN:
|
||||
sdrv_xspi_slv_set_write_chk_en(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_TX_MODE:
|
||||
sdrv_xspi_slv_set_tx_mode(slave->base, *(enum sdrv_xspi_slv_tx_mode *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AXI_WR_EN:
|
||||
sdrv_xspi_slv_set_write_en(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AXI_RD_EN:
|
||||
sdrv_xspi_slv_set_read_en(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_MODE:
|
||||
sdrv_xspi_slv_set_mode(slave->base, *(enum sdrv_xspi_slv_mode *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_SCLK_IDLE_TIME:
|
||||
idle_time_conf = buf;
|
||||
sdrv_xspi_slv_set_sclk_idle_time_en(slave->base, idle_time_conf->enable);
|
||||
sdrv_xspi_slv_set_sclk_idle_time(slave->base, idle_time_conf->idle_time);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_RATE:
|
||||
sdrv_xspi_slv_set_rate(slave->base, *(bool *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_LINE:
|
||||
sdrv_xspi_slv_set_line(slave->base, *(enum sdrv_xspi_slv_line *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_DEBOUNCE_CTRL:
|
||||
debounce_conf = buf;
|
||||
sdrv_xspi_slv_set_debounce_en(slave->base, debounce_conf->enable);
|
||||
sdrv_xspi_slv_set_debounce_time(slave->base, debounce_conf->time);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_WR_DUMMY_CYCLE:
|
||||
dummy_cycle_conf = buf;
|
||||
sdrv_xspi_slv_set_dummy_cycle(slave->base, dummy_cycle_conf->dummy_val);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_TIMEOUT_CTRL:
|
||||
timeout_conf = buf;
|
||||
sdrv_xspi_slv_set_timeout_en(slave->base, timeout_conf->enable);
|
||||
sdrv_xspi_slv_set_timeout_time(slave->base, timeout_conf->time);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ST_ACCESS:
|
||||
sdrv_xspi_slv_set_status_access_en(slave->base, *(uint16_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ID0:
|
||||
sdrv_xspi_slv_set_id0(slave->base, *(uint32_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ID1:
|
||||
sdrv_xspi_slv_set_id1(slave->base, *(uint32_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_PAD_INTB_MASK:
|
||||
sdrv_xspi_slv_set_pad_intb_mask(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_PAD_CRCB_MASK:
|
||||
sdrv_xspi_slv_set_pad_crcb_mask(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_INT_MASK:
|
||||
sdrv_xspi_slv_set_int_mask(slave->base, *(uint32_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ST_UPDATE:
|
||||
sdrv_xspi_slv_set_slv_status_update(slave->base, *(uint16_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_TRG:
|
||||
sdrv_xspi_slv_set_cmd_write_trigger(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_TRG:
|
||||
sdrv_xspi_slv_set_cmd_read_trigger(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_PACKET0:
|
||||
sdrv_xspi_slv_set_cmd_write_packet0(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_PACKET1:
|
||||
sdrv_xspi_slv_set_cmd_write_packet1(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_PAYLOAD:
|
||||
sdrv_xspi_slv_set_cmd_write_payload(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_WDATA:
|
||||
sdrv_xspi_slv_set_cmd_write_wdata(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_ST:
|
||||
sdrv_xspi_slv_set_cmd_write_status(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_ID:
|
||||
sdrv_xspi_slv_set_cmd_read_id(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_ST:
|
||||
sdrv_xspi_slv_set_cmd_read_status(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_RDATA:
|
||||
sdrv_xspi_slv_set_cmd_read_rdata(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_RDATA_CRC:
|
||||
sdrv_xspi_slv_set_cmd_read_rdata_crc(slave->base, *(uint8_t *)buf);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ARID_OVERRIDE:
|
||||
aid_conf = buf;
|
||||
sdrv_xspi_slv_set_arid_override_en(slave->base, aid_conf->enable);
|
||||
sdrv_xspi_slv_set_override_arid(slave->base, aid_conf->aid);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ARCACHE_OVERRIDE:
|
||||
acache_conf = buf;
|
||||
sdrv_xspi_slv_set_arcache_override_en(slave->base,
|
||||
acache_conf->enable);
|
||||
sdrv_xspi_slv_set_override_arcache(slave->base,
|
||||
acache_conf->acache);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ARPROT_OVERRIDE:
|
||||
aprot_conf = buf;
|
||||
sdrv_xspi_slv_set_arprot_override_en(slave->base,
|
||||
aprot_conf->enable);
|
||||
sdrv_xspi_slv_set_override_arprot(slave->base, aprot_conf->aprot);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AWID_OVERRIDE:
|
||||
aid_conf = buf;
|
||||
sdrv_xspi_slv_set_awid_override_en(slave->base, aid_conf->enable);
|
||||
sdrv_xspi_slv_set_override_awid(slave->base, aid_conf->aid);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AWCACHE_OVERRIDE:
|
||||
acache_conf = buf;
|
||||
sdrv_xspi_slv_set_awcache_override_en(slave->base,
|
||||
acache_conf->enable);
|
||||
sdrv_xspi_slv_set_override_awcache(slave->base,
|
||||
acache_conf->acache);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AWPROT_OVERRIDE:
|
||||
aprot_conf = buf;
|
||||
sdrv_xspi_slv_set_awprot_override_en(slave->base, aprot_conf->enable);
|
||||
sdrv_xspi_slv_set_override_awprot(slave->base, aprot_conf->aprot);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_REGION_MAP:
|
||||
map_conf = buf;
|
||||
sdrv_xspi_slv_set_region_map_en(slave->base, map_conf->enable, map_conf->id);
|
||||
sdrv_xspi_slv_set_region_map_offset(slave->base, map_conf->offset_addr, map_conf->id);
|
||||
sdrv_xspi_slv_set_region_map_begin_addr(slave->base,
|
||||
map_conf->begin_addr, map_conf->id);
|
||||
sdrv_xspi_slv_set_region_map_end_addr(slave->base,
|
||||
map_conf->end_addr, map_conf->id);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_RD_MON:
|
||||
mon_conf = buf;
|
||||
sdrv_xspi_slv_set_read_ctrl_addr_en(slave->base, mon_conf->addr_en);
|
||||
sdrv_xspi_slv_set_read_mon_perm_addr_en(slave->base, mon_conf->addr_en, mon_conf->id);
|
||||
sdrv_xspi_slv_set_r_mon_begin_addr(slave->base, mon_conf->begin_addr, mon_conf->id);
|
||||
sdrv_xspi_slv_set_r_mon_end_addr(slave->base, mon_conf->end_addr, mon_conf->id);
|
||||
sdrv_xspi_slv_set_read_mon_perm_addr_lock(slave->base, mon_conf->addr_lock, mon_conf->id);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_WR_MON:
|
||||
mon_conf = buf;
|
||||
sdrv_xspi_slv_set_write_ctrl_addr_en(slave->base, mon_conf->addr_en);
|
||||
sdrv_xspi_slv_set_write_mon_perm_addr_en(slave->base, mon_conf->addr_en, mon_conf->id);
|
||||
sdrv_xspi_slv_set_w_mon_begin_addr(slave->base, mon_conf->begin_addr, mon_conf->id);
|
||||
sdrv_xspi_slv_set_w_mon_end_addr(slave->base, mon_conf->end_addr, mon_conf->id);
|
||||
sdrv_xspi_slv_set_write_mon_perm_addr_lock(slave->base, mon_conf->addr_lock, mon_conf->id);
|
||||
break;
|
||||
default:
|
||||
ssdk_printf(SSDK_EMERG, "set flag error: %d\r\n", flag);
|
||||
return SSDRV_STATUS_GROUP_XSPI_SLAVER_GET_FLAG_ATTR_ERR;
|
||||
}
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
status_t sdrv_xspi_slv_get_attr(struct sdrv_xspi_slv *slave,
|
||||
enum sdrv_xspi_slv_ioctl_flag flag, void *buf)
|
||||
{
|
||||
ASSERT(slave && flag < XSPI_SLV_FLAG_MAX && buf);
|
||||
|
||||
struct sdrv_xspi_slv_sclk_idle_time_conf *idle_time_conf;
|
||||
struct sdrv_xspi_slv_debounce_ctrl_conf *debounce_conf;
|
||||
struct sdrv_xspi_slv_timeout_mon_ctrl_conf *timeout_conf;
|
||||
struct sdrv_xspi_slv_aid_conf *aid_conf;
|
||||
struct sdrv_xspi_slv_acache_conf *acache_conf;
|
||||
struct sdrv_xspi_slv_aprot_conf *aprot_conf;
|
||||
struct sdrv_xspi_slv_mon_conf *mon_conf;
|
||||
struct sdrv_xspi_slv_region_map_conf *map_conf;
|
||||
|
||||
switch (flag) {
|
||||
case XSPI_SLV_FLAG_EN:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CRC_EN:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_crc_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_BIT_ENDIAN:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_crc_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_PAD_RESET_MASK:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_pad_reset_mask(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_WR_CHK_EN:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_write_chk_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_TX_MODE:
|
||||
*(enum sdrv_xspi_slv_tx_mode *)buf =
|
||||
(enum sdrv_xspi_slv_tx_mode)sdrv_xspi_slv_get_tx_mode(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AXI_WR_EN:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_write_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AXI_RD_EN:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_read_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_MODE:
|
||||
*(enum sdrv_xspi_slv_mode *)buf = (enum sdrv_xspi_slv_mode)sdrv_xspi_slv_get_mode(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_SCLK_IDLE_TIME:
|
||||
idle_time_conf = buf;
|
||||
idle_time_conf->enable =
|
||||
sdrv_xspi_slv_get_sclk_idle_time_en(slave->base);
|
||||
idle_time_conf->idle_time =
|
||||
sdrv_xspi_slv_get_sclk_idle_time(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_RATE:
|
||||
*(bool *)buf = sdrv_xspi_slv_get_rate(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_LINE:
|
||||
*(enum sdrv_xspi_slv_line *)buf = (enum sdrv_xspi_slv_line)sdrv_xspi_slv_get_line(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_DEBOUNCE_CTRL:
|
||||
debounce_conf = buf;
|
||||
debounce_conf->enable = sdrv_xspi_slv_get_debounce_en(slave->base);
|
||||
debounce_conf->time = sdrv_xspi_slv_get_debounce_time(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_TIMEOUT_CTRL:
|
||||
timeout_conf = buf;
|
||||
timeout_conf->enable = sdrv_xspi_slv_get_timeout_en(slave->base);
|
||||
timeout_conf->time = sdrv_xspi_slv_get_timeout_time(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ST_ACCESS:
|
||||
*(uint16_t *)buf = sdrv_xspi_slv_get_status_access_en(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ID0:
|
||||
*(uint32_t *)buf = sdrv_xspi_slv_get_id0(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ID1:
|
||||
*(uint32_t *)buf = sdrv_xspi_slv_get_id1(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_PAD_INTB_MASK:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_pad_intb_mask(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_PAD_CRCB_MASK:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_pad_crcb_mask(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_INT_ST:
|
||||
*(uint32_t *)buf = sdrv_xspi_slv_get_int_st(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_INT_MASK:
|
||||
*(uint32_t *)buf = sdrv_xspi_slv_get_int_mask(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ST:
|
||||
*(uint16_t *)buf = sdrv_xspi_slv_get_slv_status(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ST_UPDATE:
|
||||
*(uint16_t *)buf = sdrv_xspi_slv_get_slv_status_update(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_TRG:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_write_trigger(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_TRG:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_read_trigger(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_PACKET0:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_write_packet0(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_PACKET1:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_write_packet1(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_PAYLOAD:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_write_payload(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_WDATA:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_write_wdata(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_WR_ST:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_write_status(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_ID:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_read_id(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_ST:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_read_status(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_RDATA:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_read_rdata(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_CMD_RD_RDATA_CRC:
|
||||
*(uint8_t *)buf = sdrv_xspi_slv_get_cmd_read_rdata_crc(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ARID_OVERRIDE:
|
||||
aid_conf = buf;
|
||||
aid_conf->enable = sdrv_xspi_slv_get_arid_override_en(slave->base);
|
||||
aid_conf->aid = sdrv_xspi_slv_get_override_arid(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ARCACHE_OVERRIDE:
|
||||
acache_conf = buf;
|
||||
acache_conf->enable = sdrv_xspi_slv_get_arcache_override_en(slave->base);
|
||||
acache_conf->acache = sdrv_xspi_slv_get_override_arcache(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_ARPROT_OVERRIDE:
|
||||
aprot_conf = buf;
|
||||
sdrv_xspi_slv_set_arprot_override_en(slave->base,
|
||||
aprot_conf->enable);
|
||||
sdrv_xspi_slv_set_override_arprot(slave->base, aprot_conf->aprot);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AWID_OVERRIDE:
|
||||
aid_conf = buf;
|
||||
aid_conf->enable = sdrv_xspi_slv_get_awid_override_en(slave->base);
|
||||
aid_conf->aid = sdrv_xspi_slv_get_override_awid(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AWCACHE_OVERRIDE:
|
||||
acache_conf = buf;
|
||||
acache_conf->enable = sdrv_xspi_slv_get_awcache_override_en(slave->base);
|
||||
acache_conf->acache = sdrv_xspi_slv_get_override_awcache(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_AWPROT_OVERRIDE:
|
||||
aprot_conf = buf;
|
||||
aprot_conf->enable = sdrv_xspi_slv_get_awprot_override_en(slave->base);
|
||||
aprot_conf->aprot = sdrv_xspi_slv_get_override_awprot(slave->base);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_REGION_MAP:
|
||||
map_conf = buf;
|
||||
map_conf->enable = sdrv_xspi_slv_get_region_map_en(slave->base, map_conf->id);
|
||||
map_conf->offset_addr = sdrv_xspi_slv_get_region_map_addr(slave->base, map_conf->id);
|
||||
map_conf->begin_addr = sdrv_xspi_slv_get_region_map_begin_addr(slave->base, map_conf->id);
|
||||
map_conf->end_addr = sdrv_xspi_slv_get_region_map_end_addr(slave->base, map_conf->id);
|
||||
case XSPI_SLV_FLAG_RD_MON:
|
||||
mon_conf = buf;
|
||||
mon_conf->addr_en = sdrv_xspi_slv_get_read_ctrl_addr_en(slave->base);
|
||||
mon_conf->addr_en = sdrv_xspi_slv_get_read_mon_perm_addr_en(slave->base, mon_conf->id);
|
||||
mon_conf->begin_addr = sdrv_xspi_slv_get_r_mon_begin_addr(slave->base, mon_conf->id);
|
||||
mon_conf->end_addr = sdrv_xspi_slv_get_r_mon_end_addr(slave->base, mon_conf->id);
|
||||
mon_conf->addr_lock = sdrv_xspi_slv_get_read_mon_perm_addr_lock(slave->base, mon_conf->id);
|
||||
break;
|
||||
case XSPI_SLV_FLAG_WR_MON:
|
||||
mon_conf = buf;
|
||||
mon_conf->addr_en = sdrv_xspi_slv_get_write_ctrl_addr_en(slave->base);
|
||||
mon_conf->addr_en = sdrv_xspi_slv_get_write_mon_perm_addr_en(slave->base, mon_conf->id);
|
||||
mon_conf->begin_addr = sdrv_xspi_slv_get_w_mon_begin_addr(slave->base, mon_conf->id);
|
||||
mon_conf->end_addr = sdrv_xspi_slv_get_w_mon_end_addr(slave->base, mon_conf->id);
|
||||
mon_conf->addr_lock = sdrv_xspi_slv_get_write_mon_perm_addr_lock(slave->base, mon_conf->id);
|
||||
break;
|
||||
default:
|
||||
ssdk_printf(SSDK_EMERG, "set flag error: %d\r\n", flag);
|
||||
return SSDRV_STATUS_GROUP_XSPI_SLAVER_SET_FLAG_ATTR_ERR;
|
||||
}
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t sdrv_xspi_slv_deinit(struct sdrv_xspi_slv *slave)
|
||||
{
|
||||
ASSERT(slave);
|
||||
|
||||
return SDRV_STATUS_OK;
|
||||
}
|
||||
|
||||
|
||||
1236
drivers/source/xspi_mst_slv/sdrv_xspi_slv_reg.h
Normal file
1236
drivers/source/xspi_mst_slv/sdrv_xspi_slv_reg.h
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user