Commit 45a3fd55 authored by Ben Hutchings's avatar Ben Hutchings
Browse files

sfc: Move MTD operations into efx_nic_type 



Merge the per-NIC-type MTD probe selection and struct efx_mtd_ops into
struct efx_nic_type.  Move the implementations into the appropriate
source files.

Several NVRAM functions are now only called from MTD operations which
are now implemented in the same file (falcon.c or mcdi.c).  There is no
need for them to be extern, or to be defined at all if CONFIG_SFC_MTD
is not enabled, so move them into the #ifdef CONFIG_SFC_MTD sections
in those files.

Most of the SPI-related definitions are also only used in falcon.c,
so move them there.  Put the remainder of spi.h into nic.h (which
previously included it).

Signed-off-by: default avatarBen Hutchings <bhutchings@solarflare.com>
parent 141d748e

drivers/net/ethernet/sfc/efx.h

+6 −1
Original line number Diff line number Diff line
@@ -204,7 +204,12 @@ extern void efx_port_dummy_op_void(struct efx_nic *efx); 


/* MTD */

#ifdef CONFIG_SFC_MTD

extern int efx_mtd_probe(struct efx_nic *efx);

extern int efx_mtd_add(struct efx_nic *efx, struct efx_mtd_partition *parts,

		       size_t n_parts, size_t sizeof_part);

static inline int efx_mtd_probe(struct efx_nic *efx)

{

	return efx->type->mtd_probe(efx);

}

extern void efx_mtd_rename(struct efx_nic *efx);

extern void efx_mtd_remove(struct efx_nic *efx);

#else

drivers/net/ethernet/sfc/falcon.c

+340 −41
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 
#include "net_driver.h"

#include "bitfield.h"

#include "efx.h"

#include "spi.h"

#include "nic.h"

#include "farch_regs.h"

#include "io.h"
@@ -159,11 +158,49 @@ 


/**************************************************************************

 *

 * Non-volatile configuration

 * Basic SPI command set and bit definitions

 *

 *************************************************************************/



#define SPI_WRSR 0x01		/* Write status register */

#define SPI_WRITE 0x02		/* Write data to memory array */

#define SPI_READ 0x03		/* Read data from memory array */

#define SPI_WRDI 0x04		/* Reset write enable latch */

#define SPI_RDSR 0x05		/* Read status register */

#define SPI_WREN 0x06		/* Set write enable latch */

#define SPI_SST_EWSR 0x50	/* SST: Enable write to status register */



#define SPI_STATUS_WPEN 0x80	/* Write-protect pin enabled */

#define SPI_STATUS_BP2 0x10	/* Block protection bit 2 */

#define SPI_STATUS_BP1 0x08	/* Block protection bit 1 */

#define SPI_STATUS_BP0 0x04	/* Block protection bit 0 */

#define SPI_STATUS_WEN 0x02	/* State of the write enable latch */

#define SPI_STATUS_NRDY 0x01	/* Device busy flag */



/**************************************************************************

 *

 * Non-volatile memory layout

 *

 **************************************************************************

 */



/* SFC4000 flash is partitioned into:

 *     0-0x400       chip and board config (see struct falcon_nvconfig)

 *     0x400-0x8000  unused (or may contain VPD if EEPROM not present)

 *     0x8000-end    boot code (mapped to PCI expansion ROM)

 * SFC4000 small EEPROM (size < 0x400) is used for VPD only.

 * SFC4000 large EEPROM (size >= 0x400) is partitioned into:

 *     0-0x400       chip and board config

 *     configurable  VPD

 *     0x800-0x1800  boot config

 * Aside from the chip and board config, all of these are optional and may

 * be absent or truncated depending on the devices used.

 */

#define FALCON_NVCONFIG_END 0x400U

#define FALCON_FLASH_BOOTCODE_START 0x8000U

#define FALCON_EEPROM_BOOTCONFIG_START 0x800U

#define FALCON_EEPROM_BOOTCONFIG_END 0x1800U



/* Board configuration v2 (v1 is obsolete; later versions are compatible) */

struct falcon_nvconfig_board_v2 {

	__le16 nports;
@@ -434,7 +471,8 @@ static int falcon_spi_wait(struct efx_nic *efx) 
	}

}



int falcon_spi_cmd(struct efx_nic *efx, const struct falcon_spi_device *spi,

static int

falcon_spi_cmd(struct efx_nic *efx, const struct falcon_spi_device *spi,

	       unsigned int command, int address,

	       const void *in, void *out, size_t len)

{
@@ -490,13 +528,6 @@ int falcon_spi_cmd(struct efx_nic *efx, const struct falcon_spi_device *spi, 
	return 0;

}



static size_t

falcon_spi_write_limit(const struct falcon_spi_device *spi, size_t start)

{

	return min(FALCON_SPI_MAX_LEN,

		   (spi->block_size - (start & (spi->block_size - 1))));

}



static inline u8

falcon_spi_munge_command(const struct falcon_spi_device *spi,

			 const u8 command, const unsigned int address)
@@ -504,33 +535,8 @@ falcon_spi_munge_command(const struct falcon_spi_device *spi, 
	return command | (((address >> 8) & spi->munge_address) << 3);

}



/* Wait up to 10 ms for buffered write completion */

int

falcon_spi_wait_write(struct efx_nic *efx, const struct falcon_spi_device *spi)

{

	unsigned long timeout = jiffies + 1 + DIV_ROUND_UP(HZ, 100);

	u8 status;

	int rc;



	for (;;) {

		rc = falcon_spi_cmd(efx, spi, SPI_RDSR, -1, NULL,

				    &status, sizeof(status));

		if (rc)

			return rc;

		if (!(status & SPI_STATUS_NRDY))

			return 0;

		if (time_after_eq(jiffies, timeout)) {

			netif_err(efx, hw, efx->net_dev,

				  "SPI write timeout on device %d"

				  " last status=0x%02x\n",

				  spi->device_id, status);

			return -ETIMEDOUT;

		}

		schedule_timeout_uninterruptible(1);

	}

}



int falcon_spi_read(struct efx_nic *efx, const struct falcon_spi_device *spi,

static int

falcon_spi_read(struct efx_nic *efx, const struct falcon_spi_device *spi,

		loff_t start, size_t len, size_t *retlen, u8 *buffer)

{

	size_t block_len, pos = 0;
@@ -560,7 +566,51 @@ int falcon_spi_read(struct efx_nic *efx, const struct falcon_spi_device *spi, 
	return rc;

}



int

#ifdef CONFIG_SFC_MTD



struct falcon_mtd_partition {

	struct efx_mtd_partition common;

	const struct falcon_spi_device *spi;

	size_t offset;

};



#define to_falcon_mtd_partition(mtd)				\

	container_of(mtd, struct falcon_mtd_partition, common.mtd)



static size_t

falcon_spi_write_limit(const struct falcon_spi_device *spi, size_t start)

{

	return min(FALCON_SPI_MAX_LEN,

		   (spi->block_size - (start & (spi->block_size - 1))));

}



/* Wait up to 10 ms for buffered write completion */

static int

falcon_spi_wait_write(struct efx_nic *efx, const struct falcon_spi_device *spi)

{

	unsigned long timeout = jiffies + 1 + DIV_ROUND_UP(HZ, 100);

	u8 status;

	int rc;



	for (;;) {

		rc = falcon_spi_cmd(efx, spi, SPI_RDSR, -1, NULL,

				    &status, sizeof(status));

		if (rc)

			return rc;

		if (!(status & SPI_STATUS_NRDY))

			return 0;

		if (time_after_eq(jiffies, timeout)) {

			netif_err(efx, hw, efx->net_dev,

				  "SPI write timeout on device %d"

				  " last status=0x%02x\n",

				  spi->device_id, status);

			return -ETIMEDOUT;

		}

		schedule_timeout_uninterruptible(1);

	}

}



static int

falcon_spi_write(struct efx_nic *efx, const struct falcon_spi_device *spi,

		 loff_t start, size_t len, size_t *retlen, const u8 *buffer)

{
@@ -609,6 +659,238 @@ falcon_spi_write(struct efx_nic *efx, const struct falcon_spi_device *spi, 
	return rc;

}



static int

falcon_spi_slow_wait(struct falcon_mtd_partition *part, bool uninterruptible)

{

	const struct falcon_spi_device *spi = part->spi;

	struct efx_nic *efx = part->common.mtd.priv;

	u8 status;

	int rc, i;



	/* Wait up to 4s for flash/EEPROM to finish a slow operation. */

	for (i = 0; i < 40; i++) {

		__set_current_state(uninterruptible ?

				    TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE);

		schedule_timeout(HZ / 10);

		rc = falcon_spi_cmd(efx, spi, SPI_RDSR, -1, NULL,

				    &status, sizeof(status));

		if (rc)

			return rc;

		if (!(status & SPI_STATUS_NRDY))

			return 0;

		if (signal_pending(current))

			return -EINTR;

	}

	pr_err("%s: timed out waiting for %s\n",

	       part->common.name, part->common.dev_type_name);

	return -ETIMEDOUT;

}



static int

falcon_spi_unlock(struct efx_nic *efx, const struct falcon_spi_device *spi)

{

	const u8 unlock_mask = (SPI_STATUS_BP2 | SPI_STATUS_BP1 |

				SPI_STATUS_BP0);

	u8 status;

	int rc;



	rc = falcon_spi_cmd(efx, spi, SPI_RDSR, -1, NULL,

			    &status, sizeof(status));

	if (rc)

		return rc;



	if (!(status & unlock_mask))

		return 0; /* already unlocked */



	rc = falcon_spi_cmd(efx, spi, SPI_WREN, -1, NULL, NULL, 0);

	if (rc)

		return rc;

	rc = falcon_spi_cmd(efx, spi, SPI_SST_EWSR, -1, NULL, NULL, 0);

	if (rc)

		return rc;



	status &= ~unlock_mask;

	rc = falcon_spi_cmd(efx, spi, SPI_WRSR, -1, &status,

			    NULL, sizeof(status));

	if (rc)

		return rc;

	rc = falcon_spi_wait_write(efx, spi);

	if (rc)

		return rc;



	return 0;

}



#define FALCON_SPI_VERIFY_BUF_LEN 16



static int

falcon_spi_erase(struct falcon_mtd_partition *part, loff_t start, size_t len)

{

	const struct falcon_spi_device *spi = part->spi;

	struct efx_nic *efx = part->common.mtd.priv;

	unsigned pos, block_len;

	u8 empty[FALCON_SPI_VERIFY_BUF_LEN];

	u8 buffer[FALCON_SPI_VERIFY_BUF_LEN];

	int rc;



	if (len != spi->erase_size)

		return -EINVAL;



	if (spi->erase_command == 0)

		return -EOPNOTSUPP;



	rc = falcon_spi_unlock(efx, spi);

	if (rc)

		return rc;

	rc = falcon_spi_cmd(efx, spi, SPI_WREN, -1, NULL, NULL, 0);

	if (rc)

		return rc;

	rc = falcon_spi_cmd(efx, spi, spi->erase_command, start, NULL,

			    NULL, 0);

	if (rc)

		return rc;

	rc = falcon_spi_slow_wait(part, false);



	/* Verify the entire region has been wiped */

	memset(empty, 0xff, sizeof(empty));

	for (pos = 0; pos < len; pos += block_len) {

		block_len = min(len - pos, sizeof(buffer));

		rc = falcon_spi_read(efx, spi, start + pos, block_len,

				     NULL, buffer);

		if (rc)

			return rc;

		if (memcmp(empty, buffer, block_len))

			return -EIO;



		/* Avoid locking up the system */

		cond_resched();

		if (signal_pending(current))

			return -EINTR;

	}



	return rc;

}



static void falcon_mtd_rename(struct efx_mtd_partition *part)

{

	struct efx_nic *efx = part->mtd.priv;



	snprintf(part->name, sizeof(part->name), "%s %s",

		 efx->name, part->type_name);

}



static int falcon_mtd_read(struct mtd_info *mtd, loff_t start,

			   size_t len, size_t *retlen, u8 *buffer)

{

	struct falcon_mtd_partition *part = to_falcon_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	struct falcon_nic_data *nic_data = efx->nic_data;

	int rc;



	rc = mutex_lock_interruptible(&nic_data->spi_lock);

	if (rc)

		return rc;

	rc = falcon_spi_read(efx, part->spi, part->offset + start,

			     len, retlen, buffer);

	mutex_unlock(&nic_data->spi_lock);

	return rc;

}



static int falcon_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len)

{

	struct falcon_mtd_partition *part = to_falcon_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	struct falcon_nic_data *nic_data = efx->nic_data;

	int rc;



	rc = mutex_lock_interruptible(&nic_data->spi_lock);

	if (rc)

		return rc;

	rc = falcon_spi_erase(part, part->offset + start, len);

	mutex_unlock(&nic_data->spi_lock);

	return rc;

}



static int falcon_mtd_write(struct mtd_info *mtd, loff_t start,

			    size_t len, size_t *retlen, const u8 *buffer)

{

	struct falcon_mtd_partition *part = to_falcon_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	struct falcon_nic_data *nic_data = efx->nic_data;

	int rc;



	rc = mutex_lock_interruptible(&nic_data->spi_lock);

	if (rc)

		return rc;

	rc = falcon_spi_write(efx, part->spi, part->offset + start,

			      len, retlen, buffer);

	mutex_unlock(&nic_data->spi_lock);

	return rc;

}



static int falcon_mtd_sync(struct mtd_info *mtd)

{

	struct falcon_mtd_partition *part = to_falcon_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	struct falcon_nic_data *nic_data = efx->nic_data;

	int rc;



	mutex_lock(&nic_data->spi_lock);

	rc = falcon_spi_slow_wait(part, true);

	mutex_unlock(&nic_data->spi_lock);

	return rc;

}



static int falcon_mtd_probe(struct efx_nic *efx)

{

	struct falcon_nic_data *nic_data = efx->nic_data;

	struct falcon_mtd_partition *parts;

	struct falcon_spi_device *spi;

	size_t n_parts;

	int rc = -ENODEV;



	ASSERT_RTNL();



	/* Allocate space for maximum number of partitions */

	parts = kcalloc(2, sizeof(*parts), GFP_KERNEL);

	n_parts = 0;



	spi = &nic_data->spi_flash;

	if (falcon_spi_present(spi) && spi->size > FALCON_FLASH_BOOTCODE_START) {

		parts[n_parts].spi = spi;

		parts[n_parts].offset = FALCON_FLASH_BOOTCODE_START;

		parts[n_parts].common.dev_type_name = "flash";

		parts[n_parts].common.type_name = "sfc_flash_bootrom";

		parts[n_parts].common.mtd.type = MTD_NORFLASH;

		parts[n_parts].common.mtd.flags = MTD_CAP_NORFLASH;

		parts[n_parts].common.mtd.size = spi->size - FALCON_FLASH_BOOTCODE_START;

		parts[n_parts].common.mtd.erasesize = spi->erase_size;

		n_parts++;

	}



	spi = &nic_data->spi_eeprom;

	if (falcon_spi_present(spi) && spi->size > FALCON_EEPROM_BOOTCONFIG_START) {

		parts[n_parts].spi = spi;

		parts[n_parts].offset = FALCON_EEPROM_BOOTCONFIG_START;

		parts[n_parts].common.dev_type_name = "EEPROM";

		parts[n_parts].common.type_name = "sfc_bootconfig";

		parts[n_parts].common.mtd.type = MTD_RAM;

		parts[n_parts].common.mtd.flags = MTD_CAP_RAM;

		parts[n_parts].common.mtd.size =

			min(spi->size, FALCON_EEPROM_BOOTCONFIG_END) -

			FALCON_EEPROM_BOOTCONFIG_START;

		parts[n_parts].common.mtd.erasesize = spi->erase_size;

		n_parts++;

	}



	rc = efx_mtd_add(efx, &parts[0].common, n_parts, sizeof(*parts));

	if (rc)

		kfree(parts);

	return rc;

}



#endif /* CONFIG_SFC_MTD */



/**************************************************************************

 *

 * XMAC operations
@@ -2417,6 +2699,15 @@ const struct efx_nic_type falcon_a1_nic_type = { 
	.filter_get_rx_id_limit = efx_farch_filter_get_rx_id_limit,

	.filter_get_rx_ids = efx_farch_filter_get_rx_ids,



#ifdef CONFIG_SFC_MTD

	.mtd_probe = falcon_mtd_probe,

	.mtd_rename = falcon_mtd_rename,

	.mtd_read = falcon_mtd_read,

	.mtd_erase = falcon_mtd_erase,

	.mtd_write = falcon_mtd_write,

	.mtd_sync = falcon_mtd_sync,

#endif



	.revision = EFX_REV_FALCON_A1,

	.txd_ptr_tbl_base = FR_AA_TX_DESC_PTR_TBL_KER,

	.rxd_ptr_tbl_base = FR_AA_RX_DESC_PTR_TBL_KER,
@@ -2500,6 +2791,14 @@ const struct efx_nic_type falcon_b0_nic_type = { 
	.filter_rfs_insert = efx_farch_filter_rfs_insert,

	.filter_rfs_expire_one = efx_farch_filter_rfs_expire_one,

#endif

#ifdef CONFIG_SFC_MTD

	.mtd_probe = falcon_mtd_probe,

	.mtd_rename = falcon_mtd_rename,

	.mtd_read = falcon_mtd_read,

	.mtd_erase = falcon_mtd_erase,

	.mtd_write = falcon_mtd_write,

	.mtd_sync = falcon_mtd_sync,

#endif



	.revision = EFX_REV_FALCON_B0,

	.txd_ptr_tbl_base = FR_BZ_TX_DESC_PTR_TBL,

drivers/net/ethernet/sfc/mcdi.c

+233 −119
Original line number Diff line number Diff line
@@ -811,125 +811,6 @@ fail: 
	return rc;

}



int efx_mcdi_nvram_update_start(struct efx_nic *efx, unsigned int type)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_START_IN_LEN);

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_START_IN_TYPE, type);



	BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_START_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_START, inbuf, sizeof(inbuf),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,

			loff_t offset, u8 *buffer, size_t length)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_READ_IN_LEN);

	MCDI_DECLARE_BUF(outbuf,

			 MC_CMD_NVRAM_READ_OUT_LEN(EFX_MCDI_NVRAM_LEN_MAX));

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_TYPE, type);

	MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_OFFSET, offset);

	MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_LENGTH, length);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_READ, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);

	if (rc)

		goto fail;



	memcpy(buffer, MCDI_PTR(outbuf, NVRAM_READ_OUT_READ_BUFFER), length);

	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,

			   loff_t offset, const u8 *buffer, size_t length)

{

	MCDI_DECLARE_BUF(inbuf,

			 MC_CMD_NVRAM_WRITE_IN_LEN(EFX_MCDI_NVRAM_LEN_MAX));

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_TYPE, type);

	MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_OFFSET, offset);

	MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_LENGTH, length);

	memcpy(MCDI_PTR(inbuf, NVRAM_WRITE_IN_WRITE_BUFFER), buffer, length);



	BUILD_BUG_ON(MC_CMD_NVRAM_WRITE_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_WRITE, inbuf,

			  ALIGN(MC_CMD_NVRAM_WRITE_IN_LEN(length), 4),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,

			 loff_t offset, size_t length)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_ERASE_IN_LEN);

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_TYPE, type);

	MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_OFFSET, offset);

	MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_LENGTH, length);



	BUILD_BUG_ON(MC_CMD_NVRAM_ERASE_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_ERASE, inbuf, sizeof(inbuf),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



int efx_mcdi_nvram_update_finish(struct efx_nic *efx, unsigned int type)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_FINISH_IN_LEN);

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_FINISH_IN_TYPE, type);



	BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_FINISH_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_FINISH, inbuf, sizeof(inbuf),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



static int efx_mcdi_nvram_test(struct efx_nic *efx, unsigned int type)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_TEST_IN_LEN);
@@ -1272,3 +1153,236 @@ fail: 
	return rc;

}



#ifdef CONFIG_SFC_MTD



#define EFX_MCDI_NVRAM_LEN_MAX 128



static int efx_mcdi_nvram_update_start(struct efx_nic *efx, unsigned int type)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_START_IN_LEN);

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_START_IN_TYPE, type);



	BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_START_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_START, inbuf, sizeof(inbuf),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



static int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,

			       loff_t offset, u8 *buffer, size_t length)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_READ_IN_LEN);

	MCDI_DECLARE_BUF(outbuf,

			 MC_CMD_NVRAM_READ_OUT_LEN(EFX_MCDI_NVRAM_LEN_MAX));

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_TYPE, type);

	MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_OFFSET, offset);

	MCDI_SET_DWORD(inbuf, NVRAM_READ_IN_LENGTH, length);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_READ, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);

	if (rc)

		goto fail;



	memcpy(buffer, MCDI_PTR(outbuf, NVRAM_READ_OUT_READ_BUFFER), length);

	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



static int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,

				loff_t offset, const u8 *buffer, size_t length)

{

	MCDI_DECLARE_BUF(inbuf,

			 MC_CMD_NVRAM_WRITE_IN_LEN(EFX_MCDI_NVRAM_LEN_MAX));

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_TYPE, type);

	MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_OFFSET, offset);

	MCDI_SET_DWORD(inbuf, NVRAM_WRITE_IN_LENGTH, length);

	memcpy(MCDI_PTR(inbuf, NVRAM_WRITE_IN_WRITE_BUFFER), buffer, length);



	BUILD_BUG_ON(MC_CMD_NVRAM_WRITE_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_WRITE, inbuf,

			  ALIGN(MC_CMD_NVRAM_WRITE_IN_LEN(length), 4),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



static int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,

				loff_t offset, size_t length)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_ERASE_IN_LEN);

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_TYPE, type);

	MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_OFFSET, offset);

	MCDI_SET_DWORD(inbuf, NVRAM_ERASE_IN_LENGTH, length);



	BUILD_BUG_ON(MC_CMD_NVRAM_ERASE_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_ERASE, inbuf, sizeof(inbuf),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



static int efx_mcdi_nvram_update_finish(struct efx_nic *efx, unsigned int type)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_UPDATE_FINISH_IN_LEN);

	int rc;



	MCDI_SET_DWORD(inbuf, NVRAM_UPDATE_FINISH_IN_TYPE, type);



	BUILD_BUG_ON(MC_CMD_NVRAM_UPDATE_FINISH_OUT_LEN != 0);



	rc = efx_mcdi_rpc(efx, MC_CMD_NVRAM_UPDATE_FINISH, inbuf, sizeof(inbuf),

			  NULL, 0, NULL);

	if (rc)

		goto fail;



	return 0;



fail:

	netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);

	return rc;

}



int efx_mcdi_mtd_read(struct mtd_info *mtd, loff_t start,

		      size_t len, size_t *retlen, u8 *buffer)

{

	struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	loff_t offset = start;

	loff_t end = min_t(loff_t, start + len, mtd->size);

	size_t chunk;

	int rc = 0;



	while (offset < end) {

		chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);

		rc = efx_mcdi_nvram_read(efx, part->nvram_type, offset,

					 buffer, chunk);

		if (rc)

			goto out;

		offset += chunk;

		buffer += chunk;

	}

out:

	*retlen = offset - start;

	return rc;

}



int efx_mcdi_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len)

{

	struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	loff_t offset = start & ~((loff_t)(mtd->erasesize - 1));

	loff_t end = min_t(loff_t, start + len, mtd->size);

	size_t chunk = part->common.mtd.erasesize;

	int rc = 0;



	if (!part->updating) {

		rc = efx_mcdi_nvram_update_start(efx, part->nvram_type);

		if (rc)

			goto out;

		part->updating = true;

	}



	/* The MCDI interface can in fact do multiple erase blocks at once;

	 * but erasing may be slow, so we make multiple calls here to avoid

	 * tripping the MCDI RPC timeout. */

	while (offset < end) {

		rc = efx_mcdi_nvram_erase(efx, part->nvram_type, offset,

					  chunk);

		if (rc)

			goto out;

		offset += chunk;

	}

out:

	return rc;

}



int efx_mcdi_mtd_write(struct mtd_info *mtd, loff_t start,

		       size_t len, size_t *retlen, const u8 *buffer)

{

	struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	loff_t offset = start;

	loff_t end = min_t(loff_t, start + len, mtd->size);

	size_t chunk;

	int rc = 0;



	if (!part->updating) {

		rc = efx_mcdi_nvram_update_start(efx, part->nvram_type);

		if (rc)

			goto out;

		part->updating = true;

	}



	while (offset < end) {

		chunk = min_t(size_t, end - offset, EFX_MCDI_NVRAM_LEN_MAX);

		rc = efx_mcdi_nvram_write(efx, part->nvram_type, offset,

					  buffer, chunk);

		if (rc)

			goto out;

		offset += chunk;

		buffer += chunk;

	}

out:

	*retlen = offset - start;

	return rc;

}



int efx_mcdi_mtd_sync(struct mtd_info *mtd)

{

	struct efx_mcdi_mtd_partition *part = to_efx_mcdi_mtd_partition(mtd);

	struct efx_nic *efx = mtd->priv;

	int rc = 0;



	if (part->updating) {

		part->updating = false;

		rc = efx_mcdi_nvram_update_finish(efx, part->nvram_type);

	}



	return rc;

}



void efx_mcdi_mtd_rename(struct efx_mtd_partition *part)

{

	struct efx_mcdi_mtd_partition *mcdi_part =

		container_of(part, struct efx_mcdi_mtd_partition, common);

	struct efx_nic *efx = part->mtd.priv;



	snprintf(part->name, sizeof(part->name), "%s %s:%02x",

		 efx->name, part->type_name, mcdi_part->fw_subtype);

}



#endif /* CONFIG_SFC_MTD */

drivers/net/ethernet/sfc/mcdi.h

+20 −12
Original line number Diff line number Diff line
@@ -65,6 +65,16 @@ struct efx_mcdi_mon { 
	unsigned int n_attrs;

};



struct efx_mcdi_mtd_partition {

	struct efx_mtd_partition common;

	bool updating;

	u8 nvram_type;

	u16 fw_subtype;

};



#define to_efx_mcdi_mtd_partition(mtd)				\

	container_of(mtd, struct efx_mcdi_mtd_partition, common.mtd)



/**

 * struct efx_mcdi_data - extra state for NICs that implement MCDI

 * @iface: Interface/protocol state
@@ -250,18 +260,6 @@ extern int efx_mcdi_nvram_types(struct efx_nic *efx, u32 *nvram_types_out); 
extern int efx_mcdi_nvram_info(struct efx_nic *efx, unsigned int type,

			       size_t *size_out, size_t *erase_size_out,

			       bool *protected_out);

extern int efx_mcdi_nvram_update_start(struct efx_nic *efx,

				       unsigned int type);

extern int efx_mcdi_nvram_read(struct efx_nic *efx, unsigned int type,

			       loff_t offset, u8 *buffer, size_t length);

extern int efx_mcdi_nvram_write(struct efx_nic *efx, unsigned int type,

				loff_t offset, const u8 *buffer,

				size_t length);

#define EFX_MCDI_NVRAM_LEN_MAX 128

extern int efx_mcdi_nvram_erase(struct efx_nic *efx, unsigned int type,

				loff_t offset, size_t length);

extern int efx_mcdi_nvram_update_finish(struct efx_nic *efx,

					unsigned int type);

extern int efx_mcdi_nvram_test_all(struct efx_nic *efx);

extern int efx_mcdi_handle_assertion(struct efx_nic *efx);

extern void efx_mcdi_set_id_led(struct efx_nic *efx, enum efx_led_mode mode);
@@ -291,4 +289,14 @@ static inline int efx_mcdi_mon_probe(struct efx_nic *efx) { return 0; } 
static inline void efx_mcdi_mon_remove(struct efx_nic *efx) {}

#endif



#ifdef CONFIG_SFC_MTD

extern int efx_mcdi_mtd_read(struct mtd_info *mtd, loff_t start,

			     size_t len, size_t *retlen, u8 *buffer);

extern int efx_mcdi_mtd_erase(struct mtd_info *mtd, loff_t start, size_t len);

extern int efx_mcdi_mtd_write(struct mtd_info *mtd, loff_t start,

			      size_t len, size_t *retlen, const u8 *buffer);

extern int efx_mcdi_mtd_sync(struct mtd_info *mtd);

extern void efx_mcdi_mtd_rename(struct efx_mtd_partition *part);

#endif



#endif /* EFX_MCDI_H */

drivers/net/ethernet/sfc/mtd.c

+8 −556

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE