/* * Copyright (c) 2019 Intel Corporation * Copyright (c) 2020 Microchip Technology Inc. * * SPDX-License-Identifier: Apache-2.0 */ #define DT_DRV_COMPAT microchip_xec_espi_saf #include #include #include #include #include #include #include "espi_utils.h" LOG_MODULE_REGISTER(espi_saf, CONFIG_ESPI_LOG_LEVEL); /* SAF EC Portal read/write flash access limited to 1-64 bytes */ #define MAX_SAF_ECP_BUFFER_SIZE 64ul /* 1 second maximum for flash operations */ #define MAX_SAF_FLASH_TIMEOUT 125000ul /* 1000ul */ /* 64 bytes @ 24MHz quad is approx. 6 us */ #define SAF_WAIT_INTERVAL 8 /* After 8 wait intervals yield */ #define SAF_YIELD_THRESHOLD 64 struct espi_isr { uint32_t girq_bit; void (*the_isr)(const struct device *dev); }; /* * SAF configuration from Device Tree * SAF controller register block base address * QMSPI controller register block base address * SAF communications register block base address * Flash STATUS1 poll timeout in 32KHz periods * Flash consecutive read timeout in units of 20 ns * Delay before first Poll-1 command after suspend in 20 ns units * Hold off suspend for this interval if erase or program in 32KHz periods. * Add delay between Poll STATUS1 commands in 20 ns units. */ struct espi_saf_xec_config { uintptr_t saf_base_addr; uintptr_t qmspi_base_addr; uintptr_t saf_comm_base_addr; uint32_t poll_timeout; uint32_t consec_rd_timeout; uint32_t sus_chk_delay; uint16_t sus_rsm_interval; uint16_t poll_interval; }; struct espi_saf_xec_data { sys_slist_t callbacks; struct k_sem ecp_lock; uint32_t hwstatus; }; /* EC portal local flash r/w buffer */ static uint32_t slave_mem[MAX_SAF_ECP_BUFFER_SIZE]; /* * @brief eSPI SAF configuration */ static inline void mchp_saf_cs_descr_wr(MCHP_SAF_HW_REGS *regs, uint8_t cs, uint32_t val) { regs->SAF_CS_OP[cs].OP_DESCR = val; } static inline void mchp_saf_poll2_mask_wr(MCHP_SAF_HW_REGS *regs, uint8_t cs, uint16_t val) { LOG_DBG("%s cs: %d mask %x", __func__, cs, val); if (cs == 0) { regs->SAF_CS0_CFG_P2M = val; } else { regs->SAF_CS1_CFG_P2M = val; } } static inline void mchp_saf_cm_prefix_wr(MCHP_SAF_HW_REGS *regs, uint8_t cs, uint16_t val) { if (cs == 0) { regs->SAF_CS0_CM_PRF = val; } else { regs->SAF_CS1_CM_PRF = val; } } /* busy wait or yield until we have SAF interrupt support */ static int xec_saf_spin_yield(int *counter) { *counter = *counter + 1; if (*counter > MAX_SAF_FLASH_TIMEOUT) { return -ETIMEDOUT; } if (*counter > SAF_YIELD_THRESHOLD) { k_yield(); } else { k_busy_wait(SAF_WAIT_INTERVAL); } return 0; } /* * Initialize SAF flash protection regions. * SAF HW implements 17 protection regions. * At least one protection region must be configured to allow * EC access to the local flash through the EC Portal. * Each protection region is composed of 4 32-bit registers * Start bits[19:0] = bits[31:12] region start address (4KB boundaries) * Limit bits[19:0] = bits[31:12] region limit address (4KB boundaries) * Write protect b[7:0] = masters[7:0] allow write/erase. 1=allowed * Read protetc b[7:0] = masters[7:0] allow read. 1=allowed * * This routine configures protection region 0 for full flash array * address range and read-write-erase for all masters. * This routine must be called AFTER the flash configuration size/limit and * threshold registers have been programmed. * * POR default values: * Start = 0x7ffff * Limit = 0 * Write Prot = 0x01 Master 0 always granted write/erase * Read Prot = 0x01 Master 0 always granted read * * Sample code configures PR[0] * Start = 0 * Limit = 0x7ffff * WR = 0xFF * RD = 0xFF */ static void saf_protection_regions_init(MCHP_SAF_HW_REGS *regs) { LOG_DBG("%s", __func__); for (size_t n = 0; n < MCHP_ESPI_SAF_PR_MAX; n++) { if (n == 0) { regs->SAF_PROT_RG[0].START = 0U; regs->SAF_PROT_RG[0].LIMIT = regs->SAF_FL_CFG_SIZE_LIM >> 12; regs->SAF_PROT_RG[0].WEBM = MCHP_SAF_MSTR_ALL; regs->SAF_PROT_RG[0].RDBM = MCHP_SAF_MSTR_ALL; } else { regs->SAF_PROT_RG[n].START = MCHP_SAF_PROT_RG_START_DFLT; regs->SAF_PROT_RG[n].LIMIT = MCHP_SAF_PROT_RG_LIMIT_DFLT; regs->SAF_PROT_RG[n].WEBM = 0U; regs->SAF_PROT_RG[n].RDBM = 0U; } LOG_DBG("PROT[%d] START %x", n, regs->SAF_PROT_RG[n].START); LOG_DBG("PROT[%d] LIMIT %x", n, regs->SAF_PROT_RG[n].LIMIT); LOG_DBG("PROT[%d] WEBM %x", n, regs->SAF_PROT_RG[n].WEBM); LOG_DBG("PROT[%d] RDBM %x", n, regs->SAF_PROT_RG[n].RDBM); } } static uint32_t qmspi_freq_div(uint32_t freqhz) { uint32_t fdiv; if (freqhz < (MCHP_QMSPI_MIN_FREQ_KHZ * 1000U)) { fdiv = 0U; /* freq divider field -> 256 */ } else if (freqhz >= (MCHP_QMSPI_MAX_FREQ_KHZ * 1000U)) { fdiv = 1U; } else { /* truncation produces next higher integer frequency */ fdiv = MCHP_QMSPI_INPUT_CLOCK_FREQ_HZ / freqhz; } fdiv &= MCHP_QMSPI_M_FDIV_MASK0; fdiv <<= MCHP_QMSPI_M_FDIV_POS; return fdiv; } /* * Take over and re-initialize QMSPI for use by SAF HW engine. * When SAF is activated, QMSPI registers are controlled by SAF * HW engine. CPU no longer has access to QMSPI registers. * 1. Save QMSPI driver frequency divider, SPI signalling mode, and * chip select timing. * 2. Put QMSPI controller in a known state by performing a soft reset. * 3. Clear QMSPI GIRQ status * 4. Configure QMSPI interface control for SAF. * 5. Load flash device independent (generic) descriptors. * 6. Enable transfer done interrupt in QMSPI * 7. Enable QMSPI SAF mode * 8. If user configuration overrides frequency, signalling mode, * or chip select timing derive user values. * 9. Program QMSPI MODE and CSTIM registers with activate set. */ static int saf_qmspi_init(const struct espi_saf_xec_config *xcfg, const struct espi_saf_cfg *cfg) { uint32_t qmode, cstim, n; QMSPI_Type *regs = (QMSPI_Type *)xcfg->qmspi_base_addr; const struct espi_saf_hw_cfg *hwcfg = &cfg->hwcfg; qmode = regs->MODE; if (!(qmode & MCHP_QMSPI_M_ACTIVATE)) { return -EAGAIN; } qmode = regs->MODE & (MCHP_QMSPI_M_FDIV_MASK | MCHP_QMSPI_M_SIG_MASK); cstim = regs->CSTM; regs->MODE = MCHP_QMSPI_M_SRST; regs->STS = MCHP_QMSPI_STS_RW1C_MASK; MCHP_GIRQ_ENCLR(MCHP_QMSPI_GIRQ_NUM) = MCHP_QMSPI_GIRQ_VAL; MCHP_GIRQ_SRC(MCHP_QMSPI_GIRQ_NUM) = MCHP_QMSPI_GIRQ_VAL; regs->IFCTRL = (MCHP_QMSPI_IFC_WP_OUT_HI | MCHP_QMSPI_IFC_WP_OUT_EN | MCHP_QMSPI_IFC_HOLD_OUT_HI | MCHP_QMSPI_IFC_HOLD_OUT_EN); for (n = 0; n < MCHP_SAF_NUM_GENERIC_DESCR; n++) { regs->DESCR[MCHP_SAF_CM_EXIT_START_DESCR + n] = hwcfg->generic_descr[n]; } regs->IEN = MCHP_QMSPI_IEN_XFR_DONE; qmode |= (MCHP_QMSPI_M_SAF_DMA_MODE_EN | MCHP_QMSPI_M_CS0 | MCHP_QMSPI_M_ACTIVATE); if (hwcfg->flags & MCHP_SAF_HW_CFG_FLAG_CPHA) { qmode = (qmode & ~(MCHP_QMSPI_M_SIG_MASK)) | ((hwcfg->qmspi_cpha << MCHP_QMSPI_M_SIG_POS) & MCHP_QMSPI_M_SIG_MASK); } if (hwcfg->flags & MCHP_SAF_HW_CFG_FLAG_FREQ) { qmode = (qmode & ~(MCHP_QMSPI_M_FDIV_MASK)) | qmspi_freq_div(hwcfg->qmspi_freq_hz); } if (hwcfg->flags & MCHP_SAF_HW_CFG_FLAG_CSTM) { cstim = hwcfg->qmspi_cs_timing; } regs->MODE = qmode; regs->CSTM = cstim; return 0; } /* * Registers at offsets: * SAF Poll timeout @ 0x194. Hard coded to 0x28000. Default value = 0. * recommended value = 0x28000 32KHz clocks (5 seconds). b[17:0] * SAF Poll interval @ 0x198. Hard coded to 0 * Default value = 0. Recommended = 0. b[15:0] * SAF Suspend/Resume Interval @ 0x19c. Hard coded to 0x8 * Default value = 0x01. Min time erase/prog in 32KHz units. * SAF Consecutive Read Timeout @ 0x1a0. Hard coded to 0x2. b[15:0] * Units of MCLK. Recommend < 20us. b[19:0] * SAF Suspend Check Delay @ 0x1ac. Not touched. * Default = 0. Recommend = 20us. Units = MCLK. b[19:0] */ static void saf_flash_timing_init(MCHP_SAF_HW_REGS *regs, const struct espi_saf_xec_config *cfg) { LOG_DBG("%s\n", __func__); regs->SAF_POLL_TMOUT = cfg->poll_timeout; regs->SAF_POLL_INTRVL = cfg->poll_interval; regs->SAF_SUS_RSM_INTRVL = cfg->sus_rsm_interval; regs->SAF_CONSEC_RD_TMOUT = cfg->consec_rd_timeout; regs->SAF_SUS_CHK_DLY = cfg->sus_chk_delay; LOG_DBG("SAF_POLL_TMOUT %x\n", regs->SAF_POLL_TMOUT); LOG_DBG("SAF_POLL_INTRVL %x\n", regs->SAF_POLL_INTRVL); LOG_DBG("SAF_SUS_RSM_INTRVL %x\n", regs->SAF_SUS_RSM_INTRVL); LOG_DBG("SAF_CONSEC_RD_TMOUT %x\n", regs->SAF_CONSEC_RD_TMOUT); LOG_DBG("SAF_SUS_CHK_DLY %x\n", regs->SAF_SUS_CHK_DLY); } /* * Disable DnX bypass feature. */ static void saf_dnx_bypass_init(MCHP_SAF_HW_REGS *regs) { regs->SAF_DNX_PROT_BYP = 0; regs->SAF_DNX_PROT_BYP = 0xffffffff; } /* * Bitmap of flash erase size from 1KB up to 128KB. * eSPI SAF specification requires 4KB erase support. * MCHP SAF supports 4KB, 32KB, and 64KB. * Only report 32KB and 64KB to Host if supported by both * flash devices. */ static int saf_init_erase_block_size(const struct espi_saf_cfg *cfg) { struct espi_saf_flash_cfg *fcfg = cfg->flash_cfgs; uint32_t opb = fcfg->opb; uint8_t erase_bitmap = MCHP_ESPI_SERASE_SZ_4K; LOG_DBG("%s\n", __func__); if (cfg->nflash_devices > 1) { fcfg++; opb &= fcfg->opb; } if ((opb & MCHP_SAF_CS_OPB_ER0_MASK) == 0) { /* One or both do not support 4KB erase! */ return -EINVAL; } if (opb & MCHP_SAF_CS_OPB_ER1_MASK) { erase_bitmap |= MCHP_ESPI_SERASE_SZ_32K; } if (opb & MCHP_SAF_CS_OPB_ER2_MASK) { erase_bitmap |= MCHP_ESPI_SERASE_SZ_64K; } ESPI_CAP_REGS->FC_SERBZ = erase_bitmap; return 0; } /* * Set the continuous mode prefix and 4-byte address mode bits * based upon the flash configuration information. * Updates: * SAF Flash Config Poll2 Mask @ 0x1A4 * SAF Flash Config Special Mode @ 0x1B0 * SAF Flash Misc Config @ 0x38 */ static void saf_flash_misc_cfg(MCHP_SAF_HW_REGS *regs, uint8_t cs, const struct espi_saf_flash_cfg *fcfg) { uint32_t d, v; d = regs->SAF_FL_CFG_MISC; v = MCHP_SAF_FL_CFG_MISC_CS0_CPE; if (cs) { v = MCHP_SAF_FL_CFG_MISC_CS1_CPE; } /* Does this flash device require a prefix for continuous mode? */ if (fcfg->cont_prefix != 0) { d |= v; } else { d &= ~v; } v = MCHP_SAF_FL_CFG_MISC_CS0_4BM; if (cs) { v = MCHP_SAF_FL_CFG_MISC_CS1_4BM; } /* Use 32-bit addressing for this flash device? */ if (fcfg->flags & MCHP_FLASH_FLAG_ADDR32) { d |= v; } else { d &= ~v; } regs->SAF_FL_CFG_MISC = d; LOG_DBG("%s SAF_FL_CFG_MISC: %x", __func__, d); } /* * Program flash device specific SAF and QMSPI registers. * * CS0 OpA @ 0x4c or CS1 OpA @ 0x5C * CS0 OpB @ 0x50 or CS1 OpB @ 0x60 * CS0 OpC @ 0x54 or CS1 OpC @ 0x64 * Poll 2 Mask @ 0x1a4 * Continuous Prefix @ 0x1b0 * CS0: QMSPI descriptors 0-5 or CS1 QMSPI descriptors 6-11 * CS0 Descrs @ 0x58 or CS1 Descrs @ 0x68 */ static void saf_flash_cfg(const struct device *dev, const struct espi_saf_flash_cfg *fcfg, uint8_t cs) { uint32_t d, did; const struct espi_saf_xec_config *xcfg = dev->config; MCHP_SAF_HW_REGS *regs = (MCHP_SAF_HW_REGS *)xcfg->saf_base_addr; QMSPI_Type *qregs = (QMSPI_Type *)xcfg->qmspi_base_addr; LOG_DBG("%s cs=%u", __func__, cs); regs->SAF_CS_OP[cs].OPA = fcfg->opa; regs->SAF_CS_OP[cs].OPB = fcfg->opb; regs->SAF_CS_OP[cs].OPC = fcfg->opc; regs->SAF_CS_OP[cs].OP_DESCR = (uint32_t)fcfg->cs_cfg_descr_ids; did = MCHP_SAF_QMSPI_CS0_START_DESCR; if (cs != 0) { did = MCHP_SAF_QMSPI_CS1_START_DESCR; } for (size_t i = 0; i < MCHP_SAF_QMSPI_NUM_FLASH_DESCR; i++) { d = fcfg->descr[i] & ~(MCHP_QMSPI_C_NEXT_DESCR_MASK); d |= (((did + 1) << MCHP_QMSPI_C_NEXT_DESCR_POS) & MCHP_QMSPI_C_NEXT_DESCR_MASK); qregs->DESCR[did++] = d; } mchp_saf_poll2_mask_wr(regs, cs, fcfg->poll2_mask); mchp_saf_cm_prefix_wr(regs, cs, fcfg->cont_prefix); saf_flash_misc_cfg(regs, cs, fcfg); } static const uint32_t tag_map_dflt[MCHP_ESPI_SAF_TAGMAP_MAX] = { MCHP_SAF_TAG_MAP0_DFLT, MCHP_SAF_TAG_MAP1_DFLT, MCHP_SAF_TAG_MAP2_DFLT }; static void saf_tagmap_init(MCHP_SAF_HW_REGS *regs, const struct espi_saf_cfg *cfg) { const struct espi_saf_hw_cfg *hwcfg = &cfg->hwcfg; for (int i = 0; i < MCHP_ESPI_SAF_TAGMAP_MAX; i++) { if (hwcfg->tag_map[i] & MCHP_SAF_HW_CFG_TAGMAP_USE) { regs->SAF_TAG_MAP[i] = hwcfg->tag_map[i]; } else { regs->SAF_TAG_MAP[i] = tag_map_dflt[i]; } } LOG_DBG("SAF TAG0 %x", regs->SAF_TAG_MAP[0]); LOG_DBG("SAF TAG1 %x", regs->SAF_TAG_MAP[1]); LOG_DBG("SAF TAG2 %x", regs->SAF_TAG_MAP[2]); } /* * Configure SAF and QMSPI for SAF operation based upon the * number and characteristics of local SPI flash devices. * NOTE: SAF is configured but not activated. SAF should be * activated only when eSPI master sends Flash Channel enable * message with MAF/SAF select flag. */ static int espi_saf_xec_configuration(const struct device *dev, const struct espi_saf_cfg *cfg) { int ret = 0; uint32_t totalsz = 0; uint32_t u = 0; LOG_DBG("%s", __func__); if ((dev == NULL) || (cfg == NULL)) { return -EINVAL; } const struct espi_saf_xec_config *xcfg = dev->config; MCHP_SAF_HW_REGS *regs = (MCHP_SAF_HW_REGS *)xcfg->saf_base_addr; const struct espi_saf_flash_cfg *fcfg = cfg->flash_cfgs; if ((fcfg == NULL) || (cfg->nflash_devices == 0U) || (cfg->nflash_devices > MCHP_SAF_MAX_FLASH_DEVICES)) { return -EINVAL; } if (regs->SAF_FL_CFG_MISC & MCHP_SAF_FL_CFG_MISC_SAF_EN) { return -EAGAIN; } saf_qmspi_init(xcfg, cfg); regs->SAF_CS0_CFG_P2M = 0; regs->SAF_CS1_CFG_P2M = 0; regs->SAF_FL_CFG_GEN_DESCR = MCHP_SAF_FL_CFG_GEN_DESCR_STD; /* flash device connected to CS0 required */ totalsz = fcfg->flashsz; regs->SAF_FL_CFG_THRH = totalsz; saf_flash_cfg(dev, fcfg, 0); /* optional second flash device connected to CS1 */ if (cfg->nflash_devices > 1) { fcfg++; totalsz += fcfg->flashsz; } /* Program CS1 configuration (same as CS0 if only one device) */ saf_flash_cfg(dev, fcfg, 1); if (totalsz == 0) { return -EAGAIN; } regs->SAF_FL_CFG_SIZE_LIM = totalsz - 1; LOG_DBG("SAF_FL_CFG_THRH = %x SAF_FL_CFG_SIZE_LIM = %x", regs->SAF_FL_CFG_THRH, regs->SAF_FL_CFG_SIZE_LIM); saf_tagmap_init(regs, cfg); saf_protection_regions_init(regs); saf_dnx_bypass_init(regs); saf_flash_timing_init(regs, xcfg); ret = saf_init_erase_block_size(cfg); if (ret != 0) { LOG_ERR("SAF Config bad flash erase config"); return ret; } /* Default or expedited prefetch? */ u = MCHP_SAF_FL_CFG_MISC_PFOE_DFLT; if (cfg->hwcfg.flags & MCHP_SAF_HW_CFG_FLAG_PFEXP) { u = MCHP_SAF_FL_CFG_MISC_PFOE_EXP; } regs->SAF_FL_CFG_MISC = (regs->SAF_FL_CFG_MISC & ~(MCHP_SAF_FL_CFG_MISC_PFOE_MASK)) | u; /* enable prefetch ? */ if (cfg->hwcfg.flags & MCHP_SAF_HW_CFG_FLAG_PFEN) { MCHP_SAF_COMM_MODE_REG |= MCHP_SAF_COMM_MODE_PF_EN; } else { MCHP_SAF_COMM_MODE_REG &= ~(MCHP_SAF_COMM_MODE_PF_EN); } LOG_DBG("%s SAF_FL_CFG_MISC: %x", __func__, regs->SAF_FL_CFG_MISC); LOG_DBG("%s Aft MCHP_SAF_COMM_MODE_REG: %x", __func__, MCHP_SAF_COMM_MODE_REG); return 0; } static int espi_saf_xec_set_pr(const struct device *dev, const struct espi_saf_protection *pr) { if ((dev == NULL) || (pr == NULL)) { return -EINVAL; } if (pr->nregions >= MCHP_ESPI_SAF_PR_MAX) { return -EINVAL; } const struct espi_saf_xec_config *xcfg = dev->config; MCHP_SAF_HW_REGS *regs = (MCHP_SAF_HW_REGS *)xcfg->saf_base_addr; if (regs->SAF_FL_CFG_MISC & MCHP_SAF_FL_CFG_MISC_SAF_EN) { return -EAGAIN; } const struct espi_saf_pr *preg = pr->pregions; size_t n = pr->nregions; while (n--) { uint8_t regnum = preg->pr_num; if (regnum >= MCHP_ESPI_SAF_PR_MAX) { return -EINVAL; } /* NOTE: If previously locked writes have no effect */ if (preg->flags & MCHP_SAF_PR_FLAG_ENABLE) { regs->SAF_PROT_RG[regnum].START = preg->start >> 12U; regs->SAF_PROT_RG[regnum].LIMIT = (preg->start + preg->size - 1U) >> 12U; regs->SAF_PROT_RG[regnum].WEBM = preg->master_bm_we; regs->SAF_PROT_RG[regnum].RDBM = preg->master_bm_rd; } else { regs->SAF_PROT_RG[regnum].START = 0x7FFFFU; regs->SAF_PROT_RG[regnum].LIMIT = 0U; regs->SAF_PROT_RG[regnum].WEBM = 0U; regs->SAF_PROT_RG[regnum].RDBM = 0U; } if (preg->flags & MCHP_SAF_PR_FLAG_LOCK) { regs->SAF_PROT_LOCK |= (1UL << regnum); } preg++; } return 0; } static bool espi_saf_xec_channel_ready(const struct device *dev) { const struct espi_saf_xec_config *cfg = dev->config; MCHP_SAF_HW_REGS *regs = (MCHP_SAF_HW_REGS *)cfg->saf_base_addr; if (regs->SAF_FL_CFG_MISC & MCHP_SAF_FL_CFG_MISC_SAF_EN) { return true; } return false; } /* * MCHP SAF hardware supports a range of flash block erase * sizes from 1KB to 128KB. The eSPI Host specification requires * 4KB must be supported. The MCHP SAF QMSPI HW interface only * supported three erase sizes. Most SPI flash devices chosen for * SAF support 4KB, 32KB, and 64KB. * Get flash erase sizes driver has configured from eSPI capabilities * registers. We assume driver flash tables have opcodes to match * capabilities configuration. * Check requested erase size is supported. */ struct erase_size_encoding { uint8_t hwbitpos; uint8_t encoding; }; static const struct erase_size_encoding ersz_enc[] = { { MCHP_ESPI_SERASE_SZ_4K_BITPOS, 0 }, { MCHP_ESPI_SERASE_SZ_32K_BITPOS, 1 }, { MCHP_ESPI_SERASE_SZ_64K_BITPOS, 2 } }; #define SAF_ERASE_ENCODING_MAX_ENTRY \ (sizeof(ersz_enc) / sizeof(struct erase_size_encoding)) static uint32_t get_erase_size_encoding(uint32_t erase_size) { uint8_t supsz = ESPI_CAP_REGS->FC_SERBZ; LOG_DBG("%s\n", __func__); for (int i = 0; i < SAF_ERASE_ENCODING_MAX_ENTRY; i++) { uint32_t sz = MCHP_ESPI_SERASE_SZ(ersz_enc[i].hwbitpos); if ((sz == erase_size) && (supsz & (1 << ersz_enc[i].hwbitpos))) { return ersz_enc[i].encoding; } } return 0xffffffffU; } static int check_ecp_access_size(uint32_t reqlen) { if ((reqlen < MCHP_SAF_ECP_CMD_RW_LEN_MIN) || (reqlen > MCHP_SAF_ECP_CMD_RW_LEN_MAX)) { return -EAGAIN; } return 0; } /* * EC access (read/erase/write) to SAF attached flash array * cmd 0 = read * 1 = write * 2 = erase */ static int saf_ecp_access(const struct device *dev, struct espi_saf_packet *pckt, uint8_t cmd) { uint32_t err_mask, n; int rc, counter; struct espi_saf_xec_data *xdat = dev->data; const struct espi_saf_xec_config *cfg = dev->config; MCHP_SAF_HW_REGS *regs = (MCHP_SAF_HW_REGS *)cfg->saf_base_addr; counter = 0; err_mask = MCHP_SAF_ECP_STS_ERR_MASK; LOG_DBG("%s", __func__); if (!(regs->SAF_FL_CFG_MISC & MCHP_SAF_FL_CFG_MISC_SAF_EN)) { LOG_ERR("SAF is disabled"); return -EIO; } if (regs->SAF_ECP_BUSY & MCHP_SAF_ECP_BUSY) { LOG_ERR("SAF EC Portal is busy"); return -EBUSY; } if ((cmd == MCHP_SAF_ECP_CMD_CTYPE_READ0) || (cmd == MCHP_SAF_ECP_CMD_CTYPE_WRITE0)) { rc = check_ecp_access_size(pckt->len); if (rc) { LOG_ERR("SAF EC Portal size out of bounds"); return rc; } if (cmd == MCHP_SAF_ECP_CMD_CTYPE_WRITE0) { memcpy(slave_mem, pckt->buf, pckt->len); } n = pckt->len; } else if (cmd == MCHP_SAF_ECP_CMD_CTYPE_ERASE0) { n = get_erase_size_encoding(pckt->len); if (n == 0xffffffff) { LOG_ERR("SAF EC Portal unsupported erase size"); return -EAGAIN; } } else { LOG_ERR("SAF EC Portal bad cmd"); return -EAGAIN; } LOG_DBG("%s params val done", __func__); k_sem_take(&xdat->ecp_lock, K_FOREVER); regs->SAF_ECP_INTEN = 0; regs->SAF_ECP_STATUS = 0xffffffff; /* * TODO - Force SAF Done interrupt disabled until we have support * from eSPI driver. */ MCHP_GIRQ_ENCLR(MCHP_SAF_GIRQ) = MCHP_SAF_GIRQ_ECP_DONE_BIT; MCHP_GIRQ_SRC(MCHP_SAF_GIRQ) = MCHP_SAF_GIRQ_ECP_DONE_BIT; regs->SAF_ECP_FLAR = pckt->flash_addr; regs->SAF_ECP_BFAR = (uint32_t)&slave_mem[0]; regs->SAF_ECP_CMD = MCHP_SAF_ECP_CMD_PUT_FLASH_NP | ((uint32_t)cmd << MCHP_SAF_ECP_CMD_CTYPE_POS) | ((n << MCHP_SAF_ECP_CMD_LEN_POS) & MCHP_SAF_ECP_CMD_LEN_MASK); /* TODO when interrupts are available enable here */ regs->SAF_ECP_START = MCHP_SAF_ECP_START; /* TODO * ISR is in eSPI driver. Use polling until eSPI driver has been * modified to provide callback for GIRQ19 SAF ECP Done. */ rc = 0; xdat->hwstatus = regs->SAF_ECP_STATUS; while (!(xdat->hwstatus & MCHP_SAF_ECP_STS_DONE)) { rc = xec_saf_spin_yield(&counter); if (rc < 0) { goto ecp_exit; } xdat->hwstatus = regs->SAF_ECP_STATUS; } /* clear hardware status and check for errors */ regs->SAF_ECP_STATUS = xdat->hwstatus; if (xdat->hwstatus & MCHP_SAF_ECP_STS_ERR_MASK) { rc = -EIO; goto ecp_exit; } if (cmd == MCHP_SAF_ECP_CMD_CTYPE_READ0) { memcpy(pckt->buf, slave_mem, pckt->len); } ecp_exit: k_sem_give(&xdat->ecp_lock); return rc; } /* Flash read using SAF EC Portal */ static int saf_xec_flash_read(const struct device *dev, struct espi_saf_packet *pckt) { LOG_DBG("%s", __func__); return saf_ecp_access(dev, pckt, MCHP_SAF_ECP_CMD_CTYPE_READ0); } /* Flash write using SAF EC Portal */ static int saf_xec_flash_write(const struct device *dev, struct espi_saf_packet *pckt) { return saf_ecp_access(dev, pckt, MCHP_SAF_ECP_CMD_CTYPE_WRITE0); } /* Flash erase using SAF EC Portal */ static int saf_xec_flash_erase(const struct device *dev, struct espi_saf_packet *pckt) { return saf_ecp_access(dev, pckt, MCHP_SAF_ECP_CMD_CTYPE_ERASE0); } static int espi_saf_xec_manage_callback(const struct device *dev, struct espi_callback *callback, bool set) { struct espi_saf_xec_data *data = dev->data; return espi_manage_callback(&data->callbacks, callback, set); } static int espi_saf_xec_activate(const struct device *dev) { const struct espi_saf_xec_config *cfg; MCHP_SAF_HW_REGS *regs; if (dev == NULL) { return -EINVAL; } cfg = dev->config; regs = (MCHP_SAF_HW_REGS *)cfg->saf_base_addr; regs->SAF_FL_CFG_MISC |= MCHP_SAF_FL_CFG_MISC_SAF_EN; return 0; } static int espi_saf_xec_init(const struct device *dev); static const struct espi_saf_driver_api espi_saf_xec_driver_api = { .config = espi_saf_xec_configuration, .set_protection_regions = espi_saf_xec_set_pr, .activate = espi_saf_xec_activate, .get_channel_status = espi_saf_xec_channel_ready, .flash_read = saf_xec_flash_read, .flash_write = saf_xec_flash_write, .flash_erase = saf_xec_flash_erase, .manage_callback = espi_saf_xec_manage_callback, }; static struct espi_saf_xec_data espi_saf_xec_data; static const struct espi_saf_xec_config espi_saf_xec_config = { .saf_base_addr = DT_INST_REG_ADDR_BY_IDX(0, 0), .qmspi_base_addr = DT_INST_REG_ADDR_BY_IDX(0, 1), .saf_comm_base_addr = DT_INST_REG_ADDR_BY_IDX(0, 2), .poll_timeout = DT_INST_PROP_OR(inst, poll_timeout, MCHP_SAF_FLASH_POLL_TIMEOUT), .consec_rd_timeout = DT_INST_PROP_OR( inst, consec_rd_timeout, MCHP_SAF_FLASH_CONSEC_READ_TIMEOUT), .sus_chk_delay = DT_INST_PROP_OR(inst, sus_chk_delay, MCHP_SAF_FLASH_SUS_CHK_DELAY), .sus_rsm_interval = DT_INST_PROP_OR(inst, sus_rsm_interval, MCHP_SAF_FLASH_SUS_RSM_INTERVAL), .poll_interval = DT_INST_PROP_OR(inst, poll_interval, MCHP_SAF_FLASH_POLL_INTERVAL), }; DEVICE_DT_INST_DEFINE(0, &espi_saf_xec_init, NULL, &espi_saf_xec_data, &espi_saf_xec_config, POST_KERNEL, CONFIG_ESPI_TAF_INIT_PRIORITY, &espi_saf_xec_driver_api); static int espi_saf_xec_init(const struct device *dev) { struct espi_saf_xec_data *data = dev->data; /* ungate SAF clocks by disabling PCR sleep enable */ mchp_pcr_periph_slp_ctrl(PCR_ESPI_SAF, MCHP_PCR_SLEEP_DIS); /* reset the SAF block */ mchp_pcr_periph_reset(PCR_ESPI_SAF); /* Configure the channels and its capabilities based on build config */ ESPI_CAP_REGS->GLB_CAP0 |= MCHP_ESPI_GBL_CAP0_FC_SUPP; ESPI_CAP_REGS->FC_CAP &= ~(MCHP_ESPI_FC_CAP_SHARE_MASK); ESPI_CAP_REGS->FC_CAP |= MCHP_ESPI_FC_CAP_SHARE_MAF_SAF; k_sem_init(&data->ecp_lock, 1, 1); return 0; }