blob: 893a28043614bd9901fdbf734f91942c5739e024 [file] [log] [blame] [edit]
/*
* Copyright (c) 2022 Piotr Dymacz
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/device.h>
#include <zephyr/drivers/flash.h>
#include <zephyr/irq.h>
#include <zephyr/kernel.h>
#include <string.h>
#include <driverlib/flash.h>
#include <driverlib/vims.h>
#define DT_DRV_COMPAT ti_cc13xx_cc26xx_flash_controller
#define SOC_NV_FLASH_NODE DT_INST(0, soc_nv_flash)
#define FLASH_ADDR DT_REG_ADDR(SOC_NV_FLASH_NODE)
#define FLASH_SIZE DT_REG_SIZE(SOC_NV_FLASH_NODE)
#define FLASH_ERASE_SIZE DT_PROP(SOC_NV_FLASH_NODE, erase_block_size)
#define FLASH_WRITE_SIZE DT_PROP(SOC_NV_FLASH_NODE, write_block_size)
struct flash_priv {
struct k_sem mutex;
};
static const struct flash_parameters flash_cc13xx_cc26xx_parameters = {
.write_block_size = FLASH_WRITE_SIZE,
.erase_value = 0xff,
};
static int flash_cc13xx_cc26xx_init(const struct device *dev)
{
struct flash_priv *priv = dev->data;
k_sem_init(&priv->mutex, 1, 1);
return 0;
}
static void flash_cc13xx_cc26xx_cache_restore(uint32_t vims_mode)
{
while (VIMSModeGet(VIMS_BASE) == VIMS_MODE_CHANGING)
;
/* Restore VIMS mode and line buffers */
if (vims_mode != VIMS_MODE_DISABLED) {
VIMSModeSafeSet(VIMS_BASE, vims_mode, true);
}
VIMSLineBufEnable(VIMS_BASE);
}
static uint32_t flash_cc13xx_cc26xx_cache_disable(void)
{
uint32_t vims_mode;
/* VIMS and both line buffers should be off during flash update */
VIMSLineBufDisable(VIMS_BASE);
while (VIMSModeGet(VIMS_BASE) == VIMS_MODE_CHANGING)
;
/* Save current VIMS mode for restoring it later */
vims_mode = VIMSModeGet(VIMS_BASE);
if (vims_mode != VIMS_MODE_DISABLED) {
VIMSModeSafeSet(VIMS_BASE, VIMS_MODE_DISABLED, true);
}
return vims_mode;
}
static bool flash_cc13xx_cc26xx_range_protected(off_t offs, size_t size)
{
off_t sector, end;
sector = (offs / FLASH_ERASE_SIZE) * FLASH_ERASE_SIZE;
end = offs + size;
/*
* From TI's HAL 'driverlib/flash.h':
*
* After write protecting a sector this sector can only be set back
* to unprotected by a device reset.
*
* Return early if any of sectors from requested range is protected.
*/
do {
if (FlashProtectionGet(sector) == FLASH_WRITE_PROTECT) {
return true;
}
sector += FLASH_ERASE_SIZE;
} while (sector < end);
return false;
}
static int flash_cc13xx_cc26xx_erase(const struct device *dev, off_t offs,
size_t size)
{
struct flash_priv *priv = dev->data;
uint32_t vims_mode;
unsigned int key;
int i, rc = 0;
size_t cnt;
if (!size) {
return 0;
}
/* Offset and length should be multiple of erase size */
if (((offs % FLASH_ERASE_SIZE) != 0) ||
((size % FLASH_ERASE_SIZE) != 0)) {
return -EINVAL;
}
if (flash_cc13xx_cc26xx_range_protected(offs, size)) {
return -EINVAL;
}
if (k_sem_take(&priv->mutex, K_FOREVER)) {
return -EACCES;
}
vims_mode = flash_cc13xx_cc26xx_cache_disable();
/*
* Disable all interrupts to prevent flash read, from TI's TRF:
*
* During a FLASH memory write or erase operation, the FLASH memory
* must not be read.
*/
key = irq_lock();
/* Erase sector/page one by one, break out in case of an error */
cnt = size / FLASH_ERASE_SIZE;
for (i = 0; i < cnt; i++, offs += FLASH_ERASE_SIZE) {
while (FlashCheckFsmForReady() != FAPI_STATUS_FSM_READY)
;
rc = FlashSectorErase(offs);
if (rc != FAPI_STATUS_SUCCESS) {
rc = -EIO;
break;
}
}
irq_unlock(key);
flash_cc13xx_cc26xx_cache_restore(vims_mode);
k_sem_give(&priv->mutex);
return rc;
}
static int flash_cc13xx_cc26xx_write(const struct device *dev, off_t offs,
const void *data, size_t size)
{
struct flash_priv *priv = dev->data;
uint32_t vims_mode;
unsigned int key;
int rc = 0;
if (!size) {
return 0;
}
if ((offs < 0) || (size < 1)) {
return -EINVAL;
}
if ((offs + size) > FLASH_SIZE) {
return -EINVAL;
}
/*
* From TI's HAL 'driverlib/flash.h':
*
* The pui8DataBuffer pointer can not point to flash.
*/
if ((data >= (void *)FLASH_ADDR) &&
(data <= (void *)(FLASH_ADDR + FLASH_SIZE))) {
return -EINVAL;
}
if (flash_cc13xx_cc26xx_range_protected(offs, size)) {
return -EINVAL;
}
if (k_sem_take(&priv->mutex, K_FOREVER)) {
return -EACCES;
}
vims_mode = flash_cc13xx_cc26xx_cache_disable();
key = irq_lock();
while (FlashCheckFsmForReady() != FAPI_STATUS_FSM_READY)
;
rc = FlashProgram((uint8_t *)data, offs, size);
if (rc != FAPI_STATUS_SUCCESS) {
rc = -EIO;
}
irq_unlock(key);
flash_cc13xx_cc26xx_cache_restore(vims_mode);
k_sem_give(&priv->mutex);
return rc;
}
static int flash_cc13xx_cc26xx_read(const struct device *dev, off_t offs,
void *data, size_t size)
{
ARG_UNUSED(dev);
if (!size) {
return 0;
}
if ((offs < 0) || (size < 1)) {
return -EINVAL;
}
if ((offs + size) > FLASH_SIZE) {
return -EINVAL;
}
memcpy(data, (void *)offs, size);
return 0;
}
static const struct flash_parameters *
flash_cc13xx_cc26xx_get_parameters(const struct device *dev)
{
ARG_UNUSED(dev);
return &flash_cc13xx_cc26xx_parameters;
}
#if defined(CONFIG_FLASH_PAGE_LAYOUT)
static const struct flash_pages_layout dev_layout = {
.pages_count = FLASH_SIZE / FLASH_ERASE_SIZE,
.pages_size = FLASH_ERASE_SIZE,
};
static void flash_cc13xx_cc26xx_layout(const struct device *dev,
const struct flash_pages_layout **layout,
size_t *layout_size)
{
*layout = &dev_layout;
*layout_size = 1;
}
#endif /* CONFIG_FLASH_PAGE_LAYOUT */
static const struct flash_driver_api flash_cc13xx_cc26xx_api = {
.erase = flash_cc13xx_cc26xx_erase,
.write = flash_cc13xx_cc26xx_write,
.read = flash_cc13xx_cc26xx_read,
.get_parameters = flash_cc13xx_cc26xx_get_parameters,
#if defined(CONFIG_FLASH_PAGE_LAYOUT)
.page_layout = flash_cc13xx_cc26xx_layout,
#endif
};
static struct flash_priv flash_data;
DEVICE_DT_INST_DEFINE(0, flash_cc13xx_cc26xx_init, NULL, &flash_data, NULL,
POST_KERNEL, CONFIG_FLASH_INIT_PRIORITY,
&flash_cc13xx_cc26xx_api);