path: root/drivers/dpll/zl3073x/flash.c

// SPDX-License-Identifier: GPL-2.0-or-later

#include <linux/array_size.h>
#include <linux/bitfield.h>
#include <linux/bits.h>
#include <linux/delay.h>
#include <linux/dev_printk.h>
#include <linux/errno.h>
#include <linux/jiffies.h>
#include <linux/minmax.h>
#include <linux/netlink.h>
#include <linux/sched/signal.h>
#include <linux/sizes.h>
#include <linux/sprintf.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/unaligned.h>
#include <net/devlink.h>

#include "core.h"
#include "devlink.h"
#include "flash.h"

#define ZL_FLASH_ERR_PFX "FW update failed: "
#define ZL_FLASH_ERR_MSG(_extack, _msg, ...)				\
	NL_SET_ERR_MSG_FMT_MOD((_extack), ZL_FLASH_ERR_PFX _msg,	\
			       ## __VA_ARGS__)

/**
 * zl3073x_flash_download - Download image block to device memory
 * @zldev: zl3073x device structure
 * @component: name of the component to be downloaded
 * @addr: device memory target address
 * @data: pointer to data to download
 * @size: size of data to download
 * @extack: netlink extack pointer to report errors
 *
 * Return: 0 on success, <0 on error
 */
static int
zl3073x_flash_download(struct zl3073x_dev *zldev, const char *component,
		       u32 addr, const void *data, size_t size,
		       struct netlink_ext_ack *extack)
{
#define ZL_CHECK_DELAY	5000 /* Check for interrupt each 5 seconds */
	unsigned long check_time;
	const void *ptr, *end;
	int rc = 0;

	dev_dbg(zldev->dev, "Downloading %zu bytes to device memory at 0x%0x\n",
		size, addr);

	check_time = jiffies + msecs_to_jiffies(ZL_CHECK_DELAY);

	for (ptr = data, end = data + size; ptr < end; ptr += 4, addr += 4) {
		/* Write current word to HW memory */
		rc = zl3073x_write_hwreg(zldev, addr,
					 get_unaligned((u32 *)ptr));
		if (rc) {
			ZL_FLASH_ERR_MSG(extack,
					 "failed to write to memory at 0x%0x",
					 addr);
			return rc;
		}

		if (time_is_before_jiffies(check_time)) {
			if (signal_pending(current)) {
				ZL_FLASH_ERR_MSG(extack,
						 "Flashing interrupted");
				return -EINTR;
			}

			check_time = jiffies + msecs_to_jiffies(ZL_CHECK_DELAY);
		}

		/* Report status each 1 kB block */
		if ((ptr - data) % 1024 == 0)
			zl3073x_devlink_flash_notify(zldev, "Downloading image",
						     component, ptr - data,
						     size);
	}

	zl3073x_devlink_flash_notify(zldev, "Downloading image", component,
				     ptr - data, size);

	dev_dbg(zldev->dev, "%zu bytes downloaded to device memory\n", size);

	return rc;
}

/**
 * zl3073x_flash_error_check - Check for flash utility errors
 * @zldev: zl3073x device structure
 * @extack: netlink extack pointer to report errors
 *
 * The function checks for errors detected by the flash utility and
 * reports them if any were found.
 *
 * Return: 0 on success, -EIO when errors are detected
 */
static int
zl3073x_flash_error_check(struct zl3073x_dev *zldev,
			  struct netlink_ext_ack *extack)
{
	u32 count, cause;
	int rc;

	rc = zl3073x_read_u32(zldev, ZL_REG_ERROR_COUNT, &count);
	if (rc)
		return rc;
	else if (!count)
		return 0; /* No error */

	rc = zl3073x_read_u32(zldev, ZL_REG_ERROR_CAUSE, &cause);
	if (rc)
		return rc;

	/* Report errors */
	ZL_FLASH_ERR_MSG(extack,
			 "utility error occurred: count=%u cause=0x%x", count,
			 cause);

	return -EIO;
}

/**
 * zl3073x_flash_wait_ready - Check or wait for utility to be ready to flash
 * @zldev: zl3073x device structure
 * @timeout_ms: timeout for the waiting
 *
 * Return: 0 on success, <0 on error
 */
static int
zl3073x_flash_wait_ready(struct zl3073x_dev *zldev, unsigned int timeout_ms)
{
#define ZL_FLASH_POLL_DELAY_MS	100
	unsigned long timeout;
	int rc, i;

	dev_dbg(zldev->dev, "Waiting for flashing to be ready\n");

	timeout = jiffies + msecs_to_jiffies(timeout_ms);

	for (i = 0; time_is_after_jiffies(timeout); i++) {
		u8 value;

		/* Check for interrupt each 1s */
		if (i > 9) {
			if (signal_pending(current))
				return -EINTR;
			i = 0;
		}

		rc = zl3073x_read_u8(zldev, ZL_REG_WRITE_FLASH, &value);
		if (rc)
			return rc;

		value = FIELD_GET(ZL_WRITE_FLASH_OP, value);

		if (value == ZL_WRITE_FLASH_OP_DONE)
			return 0; /* Successfully done */

		msleep(ZL_FLASH_POLL_DELAY_MS);
	}

	return -ETIMEDOUT;
}

/**
 * zl3073x_flash_cmd_wait - Perform flash operation and wait for finish
 * @zldev: zl3073x device structure
 * @operation: operation to perform
 * @extack: netlink extack pointer to report errors
 *
 * Return: 0 on success, <0 on error
 */
static int
zl3073x_flash_cmd_wait(struct zl3073x_dev *zldev, u32 operation,
		       struct netlink_ext_ack *extack)
{
#define ZL_FLASH_PHASE1_TIMEOUT_MS 60000	/* up to 1 minute */
#define ZL_FLASH_PHASE2_TIMEOUT_MS 120000	/* up to 2 minutes */
	u8 value;
	int rc;

	dev_dbg(zldev->dev, "Sending flash command: 0x%x\n", operation);

	rc = zl3073x_flash_wait_ready(zldev, ZL_FLASH_PHASE1_TIMEOUT_MS);
	if (rc)
		return rc;

	/* Issue the requested operation */
	rc = zl3073x_read_u8(zldev, ZL_REG_WRITE_FLASH, &value);
	if (rc)
		return rc;

	FIELD_MODIFY(ZL_WRITE_FLASH_OP, &value, operation);

	rc = zl3073x_write_u8(zldev, ZL_REG_WRITE_FLASH, value);
	if (rc)
		return rc;

	/* Wait for command completion */
	rc = zl3073x_flash_wait_ready(zldev, ZL_FLASH_PHASE2_TIMEOUT_MS);
	if (rc)
		return rc;

	return zl3073x_flash_error_check(zldev, extack);
}

/**
 * zl3073x_flash_get_sector_size - Get flash sector size
 * @zldev: zl3073x device structure
 * @sector_size: sector size returned by the function
 *
 * The function reads the flash sector size detected by flash utility and
 * stores it into @sector_size.
 *
 * Return: 0 on success, <0 on error
 */
static int
zl3073x_flash_get_sector_size(struct zl3073x_dev *zldev, size_t *sector_size)
{
	u8 flash_info;
	int rc;

	rc = zl3073x_read_u8(zldev, ZL_REG_FLASH_INFO, &flash_info);
	if (rc)
		return rc;

	switch (FIELD_GET(ZL_FLASH_INFO_SECTOR_SIZE, flash_info)) {
	case ZL_FLASH_INFO_SECTOR_4K:
		*sector_size = SZ_4K;
		break;
	case ZL_FLASH_INFO_SECTOR_64K:
		*sector_size = SZ_64K;
		break;
	default:
		rc = -EINVAL;
		break;
	}

	return rc;
}

/**
 * zl3073x_flash_block - Download and flash memory block
 * @zldev: zl3073x device structure
 * @component: component name
 * @operation: flash operation to perform
 * @page: destination flash page
 * @addr: device memory address to load data
 * @data: pointer to data to be flashed
 * @size: size of data
 * @extack: netlink extack pointer to report errors
 *
 * The function downloads the memory block given by the @data pointer and
 * the size @size and flashes it into internal memory on flash page @page.
 * The internal flash operation performed by the firmware is specified by
 * the @operation parameter.
 *
 * Return: 0 on success, <0 on error
 */
static int
zl3073x_flash_block(struct zl3073x_dev *zldev, const char *component,
		    u32 operation, u32 page, u32 addr, const void *data,
		    size_t size, struct netlink_ext_ack *extack)
{
	int rc;