drivers/net/ethernet/intel/ixgbe/devlink/region.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (c) 2025, Intel Corporation. */

 #include "ixgbe.h"
 #include "devlink.h"

 #define IXGBE_DEVLINK_READ_BLK_SIZE (1024 * 1024)

 static const struct devlink_region_ops ixgbe_nvm_region_ops;
 static const struct devlink_region_ops ixgbe_sram_region_ops;

 static int ixgbe_devlink_parse_region(struct ixgbe_hw *hw,
 				      const struct devlink_region_ops *ops,
 				      bool *read_shadow_ram, u32 *nvm_size)
 {
 	if (ops == &ixgbe_nvm_region_ops) {
 		*read_shadow_ram = false;
 		*nvm_size = hw->flash.flash_size;
 	} else if (ops == &ixgbe_sram_region_ops) {
 		*read_shadow_ram = true;
 		*nvm_size = hw->flash.sr_words * 2u;
 	} else {
 		return -EOPNOTSUPP;
 	}

 	return 0;
 }

 /**
  * ixgbe_devlink_nvm_snapshot - Capture a snapshot of the NVM content
  * @devlink: the devlink instance
  * @ops: the devlink region being snapshotted
  * @extack: extended ACK response structure
  * @data: on exit points to snapshot data buffer
  *
  * This function is called in response to the DEVLINK_CMD_REGION_NEW cmd.
  *
  * Capture a snapshot of the whole requested NVM region.
  *
  * No need to worry with freeing @data, devlink core takes care if it.
  *
  * Return: 0 on success, -EOPNOTSUPP for unsupported regions, -EBUSY when
  * cannot lock NVM, -ENOMEM when cannot alloc mem and -EIO when error
  * occurs during reading.
  */
 static int ixgbe_devlink_nvm_snapshot(struct devlink *devlink,
 				      const struct devlink_region_ops *ops,
 				      struct netlink_ext_ack *extack, u8 **data)
 {
 	struct ixgbe_adapter *adapter = devlink_priv(devlink);
 	struct ixgbe_hw *hw = &adapter->hw;
 	bool read_shadow_ram;
 	u8 *nvm_data, *buf;
 	u32 nvm_size, left;
 	u8 num_blks;
 	int err;

 	err = ixgbe_devlink_parse_region(hw, ops, &read_shadow_ram, &nvm_size);
 	if (err)
 		return err;

 	nvm_data = kvzalloc(nvm_size, GFP_KERNEL);
 	if (!nvm_data)
 		return -ENOMEM;

 	num_blks = DIV_ROUND_UP(nvm_size, IXGBE_DEVLINK_READ_BLK_SIZE);
 	buf = nvm_data;
 	left = nvm_size;

 	for (int i = 0; i < num_blks; i++) {
 		u32 read_sz = min_t(u32, IXGBE_DEVLINK_READ_BLK_SIZE, left);

 		/* Need to acquire NVM lock during each loop run because the
 		 * total period of reading whole NVM is longer than the maximum
 		 * period the lock can be taken defined by the IXGBE_NVM_TIMEOUT.
 		 */
 		err = ixgbe_acquire_nvm(hw, LIBIE_AQC_RES_ACCESS_READ);
 		if (err) {
 			NL_SET_ERR_MSG_MOD(extack,
 					   "Failed to acquire NVM semaphore");
 			kvfree(nvm_data);
 			return -EBUSY;
 		}

 		err = ixgbe_read_flat_nvm(hw, i * IXGBE_DEVLINK_READ_BLK_SIZE,
 					  &read_sz, buf, read_shadow_ram);
 		if (err) {
 			NL_SET_ERR_MSG_MOD(extack,
 					   "Failed to read RAM content");
 			ixgbe_release_nvm(hw);
 			kvfree(nvm_data);
 			return -EIO;
 		}

 		ixgbe_release_nvm(hw);

 		buf += read_sz;
 		left -= read_sz;
 	}

 	*data = nvm_data;
 	return 0;
 }

 /**
  * ixgbe_devlink_devcaps_snapshot - Capture a snapshot of device capabilities
  * @devlink: the devlink instance
  * @ops: the devlink region being snapshotted
  * @extack: extended ACK response structure
  * @data: on exit points to snapshot data buffer
  *
  * This function is called in response to the DEVLINK_CMD_REGION_NEW for
  * the device-caps devlink region.
  *
  * Capture a snapshot of the device capabilities reported by firmware.
  *
  * No need to worry with freeing @data, devlink core takes care if it.
  *
  * Return: 0 on success, -ENOMEM when cannot alloc mem, or return code of
  * the reading operation.
  */
 static int ixgbe_devlink_devcaps_snapshot(struct devlink *devlink,
 					  const struct devlink_region_ops *ops,
 					  struct netlink_ext_ack *extack,
 					  u8 **data)
 {
 	struct ixgbe_adapter *adapter = devlink_priv(devlink);
 	struct ixgbe_aci_cmd_list_caps_elem *caps;
 	struct ixgbe_hw *hw = &adapter->hw;
 	int err;

 	caps = kvzalloc(IXGBE_ACI_MAX_BUFFER_SIZE, GFP_KERNEL);
 	if (!caps)
 		return -ENOMEM;

 	err = ixgbe_aci_list_caps(hw, caps, IXGBE_ACI_MAX_BUFFER_SIZE, NULL,
 				  ixgbe_aci_opc_list_dev_caps);
 	if (err) {
 		NL_SET_ERR_MSG_MOD(extack,
 				   "Failed to read device capabilities");
 		kvfree(caps);
 		return err;
 	}

 	*data = (u8 *)caps;
 	return 0;
 }

 /**
  * ixgbe_devlink_nvm_read - Read a portion of NVM flash content
  * @devlink: the devlink instance
  * @ops: the devlink region to snapshot
  * @extack: extended ACK response structure
  * @offset: the offset to start at
  * @size: the amount to read
  * @data: the data buffer to read into
  *
  * This function is called in response to DEVLINK_CMD_REGION_READ to directly
  * read a section of the NVM contents.
  *
  * Read from either the nvm-flash region either shadow-ram region.
  *
  * Return: 0 on success, -EOPNOTSUPP for unsupported regions, -EBUSY when
  * cannot lock NVM, -ERANGE when buffer limit exceeded and -EIO when error
  * occurs during reading.
  */
 static int ixgbe_devlink_nvm_read(struct devlink *devlink,
 				  const struct devlink_region_ops *ops,
 				  struct netlink_ext_ack *extack,
 				  u64 offset, u32 size, u8 *data)
 {
 	struct ixgbe_adapter *adapter = devlink_priv(devlink);
 	struct ixgbe_hw *hw = &adapter->hw;
 	bool read_shadow_ram;
 	u32 nvm_size;
 	int err;

 	err = ixgbe_devlink_parse_region(hw, ops, &read_shadow_ram, &nvm_size);
 	if (err)
 		return err;

 	if (offset + size > nvm_size) {
 		NL_SET_ERR_MSG_MOD(extack, "Cannot read beyond the region size");
 		return -ERANGE;
 	}

 	err = ixgbe_acquire_nvm(hw, LIBIE_AQC_RES_ACCESS_READ);
 	if (err) {
 		NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
 		return -EBUSY;
 	}

 	err = ixgbe_read_flat_nvm(hw, (u32)offset, &size, data, read_shadow_ram);
 	if (err) {
 		NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
 		ixgbe_release_nvm(hw);
 		return -EIO;
 	}

 	ixgbe_release_nvm(hw);
 	return 0;
 }

 static const struct devlink_region_ops ixgbe_nvm_region_ops = {
 	.name = "nvm-flash",
 	.destructor = kvfree,
 	.snapshot = ixgbe_devlink_nvm_snapshot,
 	.read = ixgbe_devlink_nvm_read,
 };

 static const struct devlink_region_ops ixgbe_sram_region_ops = {
 	.name = "shadow-ram",
 	.destructor = kvfree,
 	.snapshot = ixgbe_devlink_nvm_snapshot,
 	.read = ixgbe_devlink_nvm_read,
 };

 static const struct devlink_region_ops ixgbe_devcaps_region_ops = {
 	.name = "device-caps",
 	.destructor = kvfree,
 	.snapshot = ixgbe_devlink_devcaps_snapshot,
 };

 /**
  * ixgbe_devlink_init_regions - Initialize devlink regions
  * @adapter: adapter instance
  *
  * Create devlink regions used to enable access to dump the contents of the
  * flash memory of the device.
  */
 void ixgbe_devlink_init_regions(struct ixgbe_adapter *adapter)
 {
 	struct devlink *devlink = adapter->devlink;
 	struct device *dev = &adapter->pdev->dev;
 	u64 nvm_size, sram_size;

 	if (adapter->hw.mac.type != ixgbe_mac_e610)
 		return;

 	nvm_size = adapter->hw.flash.flash_size;
 	adapter->nvm_region = devl_region_create(devlink, &ixgbe_nvm_region_ops,
 						 1, nvm_size);
 	if (IS_ERR(adapter->nvm_region)) {
 		dev_err(dev,
 			"Failed to create NVM devlink region, err %ld\n",
 			PTR_ERR(adapter->nvm_region));
 		adapter->nvm_region = NULL;
 	}

 	sram_size = adapter->hw.flash.sr_words * 2u;
 	adapter->sram_region = devl_region_create(devlink, &ixgbe_sram_region_ops,
 						  1, sram_size);
 	if (IS_ERR(adapter->sram_region)) {
 		dev_err(dev,
 			"Failed to create shadow-ram devlink region, err %ld\n",
 			PTR_ERR(adapter->sram_region));
 		adapter->sram_region = NULL;
 	}

 	adapter->devcaps_region = devl_region_create(devlink,
 						     &ixgbe_devcaps_region_ops,
 						     10, IXGBE_ACI_MAX_BUFFER_SIZE);
 	if (IS_ERR(adapter->devcaps_region)) {
 		dev_err(dev,
 			"Failed to create device-caps devlink region, err %ld\n",
 			PTR_ERR(adapter->devcaps_region));
 		adapter->devcaps_region = NULL;
 	}
 }

 /**
  * ixgbe_devlink_destroy_regions - Destroy devlink regions
  * @adapter: adapter instance
  *
  * Remove previously created regions for this adapter instance.
  */
 void ixgbe_devlink_destroy_regions(struct ixgbe_adapter *adapter)
 {
 	if (adapter->hw.mac.type != ixgbe_mac_e610)
 		return;

 	if (adapter->nvm_region)
 		devl_region_destroy(adapter->nvm_region);

 	if (adapter->sram_region)
 		devl_region_destroy(adapter->sram_region);

 	if (adapter->devcaps_region)
 		devl_region_destroy(adapter->devcaps_region);
 }
	// SPDX-License-Identifier: GPL-2.0
	/* Copyright (c) 2025, Intel Corporation. */

	#include "ixgbe.h"
	#include "devlink.h"

	#define IXGBE_DEVLINK_READ_BLK_SIZE (1024 * 1024)

	static const struct devlink_region_ops ixgbe_nvm_region_ops;
	static const struct devlink_region_ops ixgbe_sram_region_ops;

	static int ixgbe_devlink_parse_region(struct ixgbe_hw *hw,
	const struct devlink_region_ops *ops,
	bool read_shadow_ram, u32 nvm_size)
	{
	if (ops == &ixgbe_nvm_region_ops) {
	*read_shadow_ram = false;
	*nvm_size = hw->flash.flash_size;
	} else if (ops == &ixgbe_sram_region_ops) {
	*read_shadow_ram = true;
	nvm_size = hw->flash.sr_words 2u;
	} else {
	return -EOPNOTSUPP;
	}

	return 0;
	}

	/**
	* ixgbe_devlink_nvm_snapshot - Capture a snapshot of the NVM content
	* @devlink: the devlink instance
	* @ops: the devlink region being snapshotted
	* @extack: extended ACK response structure
	* @data: on exit points to snapshot data buffer
	*
	* This function is called in response to the DEVLINK_CMD_REGION_NEW cmd.
	*
	* Capture a snapshot of the whole requested NVM region.
	*
	* No need to worry with freeing @data, devlink core takes care if it.
	*
	* Return: 0 on success, -EOPNOTSUPP for unsupported regions, -EBUSY when
	* cannot lock NVM, -ENOMEM when cannot alloc mem and -EIO when error
	* occurs during reading.
	*/
	static int ixgbe_devlink_nvm_snapshot(struct devlink *devlink,
	const struct devlink_region_ops *ops,
	struct netlink_ext_ack extack, u8 *data)
	{
	struct ixgbe_adapter *adapter = devlink_priv(devlink);
	struct ixgbe_hw *hw = &adapter->hw;
	bool read_shadow_ram;
	u8 nvm_data, buf;
	u32 nvm_size, left;
	u8 num_blks;
	int err;

	err = ixgbe_devlink_parse_region(hw, ops, &read_shadow_ram, &nvm_size);
	if (err)
	return err;

	nvm_data = kvzalloc(nvm_size, GFP_KERNEL);
	if (!nvm_data)
	return -ENOMEM;

	num_blks = DIV_ROUND_UP(nvm_size, IXGBE_DEVLINK_READ_BLK_SIZE);
	buf = nvm_data;
	left = nvm_size;

	for (int i = 0; i < num_blks; i++) {
	u32 read_sz = min_t(u32, IXGBE_DEVLINK_READ_BLK_SIZE, left);

	/* Need to acquire NVM lock during each loop run because the
	* total period of reading whole NVM is longer than the maximum
	* period the lock can be taken defined by the IXGBE_NVM_TIMEOUT.
	*/
	err = ixgbe_acquire_nvm(hw, LIBIE_AQC_RES_ACCESS_READ);
	if (err) {
	NL_SET_ERR_MSG_MOD(extack,
	"Failed to acquire NVM semaphore");
	kvfree(nvm_data);
	return -EBUSY;
	}

	err = ixgbe_read_flat_nvm(hw, i * IXGBE_DEVLINK_READ_BLK_SIZE,
	&read_sz, buf, read_shadow_ram);
	if (err) {
	NL_SET_ERR_MSG_MOD(extack,
	"Failed to read RAM content");
	ixgbe_release_nvm(hw);
	kvfree(nvm_data);
	return -EIO;
	}

	ixgbe_release_nvm(hw);

	buf += read_sz;
	left -= read_sz;
	}

	*data = nvm_data;
	return 0;
	}

	/**
	* ixgbe_devlink_devcaps_snapshot - Capture a snapshot of device capabilities
	* @devlink: the devlink instance
	* @ops: the devlink region being snapshotted
	* @extack: extended ACK response structure
	* @data: on exit points to snapshot data buffer
	*
	* This function is called in response to the DEVLINK_CMD_REGION_NEW for
	* the device-caps devlink region.
	*
	* Capture a snapshot of the device capabilities reported by firmware.
	*
	* No need to worry with freeing @data, devlink core takes care if it.
	*
	* Return: 0 on success, -ENOMEM when cannot alloc mem, or return code of
	* the reading operation.
	*/
	static int ixgbe_devlink_devcaps_snapshot(struct devlink *devlink,
	const struct devlink_region_ops *ops,
	struct netlink_ext_ack *extack,
	u8 **data)
	{
	struct ixgbe_adapter *adapter = devlink_priv(devlink);
	struct ixgbe_aci_cmd_list_caps_elem *caps;
	struct ixgbe_hw *hw = &adapter->hw;
	int err;

	caps = kvzalloc(IXGBE_ACI_MAX_BUFFER_SIZE, GFP_KERNEL);
	if (!caps)
	return -ENOMEM;

	err = ixgbe_aci_list_caps(hw, caps, IXGBE_ACI_MAX_BUFFER_SIZE, NULL,
	ixgbe_aci_opc_list_dev_caps);
	if (err) {
	NL_SET_ERR_MSG_MOD(extack,
	"Failed to read device capabilities");
	kvfree(caps);
	return err;
	}

	data = (u8 )caps;
	return 0;
	}

	/**
	* ixgbe_devlink_nvm_read - Read a portion of NVM flash content
	* @devlink: the devlink instance
	* @ops: the devlink region to snapshot
	* @extack: extended ACK response structure
	* @offset: the offset to start at
	* @size: the amount to read
	* @data: the data buffer to read into
	*
	* This function is called in response to DEVLINK_CMD_REGION_READ to directly
	* read a section of the NVM contents.
	*
	* Read from either the nvm-flash region either shadow-ram region.
	*
	* Return: 0 on success, -EOPNOTSUPP for unsupported regions, -EBUSY when
	* cannot lock NVM, -ERANGE when buffer limit exceeded and -EIO when error
	* occurs during reading.
	*/
	static int ixgbe_devlink_nvm_read(struct devlink *devlink,
	const struct devlink_region_ops *ops,
	struct netlink_ext_ack *extack,
	u64 offset, u32 size, u8 *data)
	{
	struct ixgbe_adapter *adapter = devlink_priv(devlink);
	struct ixgbe_hw *hw = &adapter->hw;
	bool read_shadow_ram;
	u32 nvm_size;
	int err;

	err = ixgbe_devlink_parse_region(hw, ops, &read_shadow_ram, &nvm_size);
	if (err)
	return err;

	if (offset + size > nvm_size) {
	NL_SET_ERR_MSG_MOD(extack, "Cannot read beyond the region size");
	return -ERANGE;
	}

	err = ixgbe_acquire_nvm(hw, LIBIE_AQC_RES_ACCESS_READ);
	if (err) {
	NL_SET_ERR_MSG_MOD(extack, "Failed to acquire NVM semaphore");
	return -EBUSY;
	}

	err = ixgbe_read_flat_nvm(hw, (u32)offset, &size, data, read_shadow_ram);
	if (err) {
	NL_SET_ERR_MSG_MOD(extack, "Failed to read NVM contents");
	ixgbe_release_nvm(hw);
	return -EIO;
	}

	ixgbe_release_nvm(hw);
	return 0;
	}

	static const struct devlink_region_ops ixgbe_nvm_region_ops = {
	.name = "nvm-flash",
	.destructor = kvfree,
	.snapshot = ixgbe_devlink_nvm_snapshot,
	.read = ixgbe_devlink_nvm_read,
	};

	static const struct devlink_region_ops ixgbe_sram_region_ops = {
	.name = "shadow-ram",
	.destructor = kvfree,
	.snapshot = ixgbe_devlink_nvm_snapshot,
	.read = ixgbe_devlink_nvm_read,
	};

	static const struct devlink_region_ops ixgbe_devcaps_region_ops = {
	.name = "device-caps",
	.destructor = kvfree,
	.snapshot = ixgbe_devlink_devcaps_snapshot,
	};

	/**
	* ixgbe_devlink_init_regions - Initialize devlink regions
	* @adapter: adapter instance
	*
	* Create devlink regions used to enable access to dump the contents of the
	* flash memory of the device.
	*/
	void ixgbe_devlink_init_regions(struct ixgbe_adapter *adapter)
	{
	struct devlink *devlink = adapter->devlink;
	struct device *dev = &adapter->pdev->dev;
	u64 nvm_size, sram_size;

	if (adapter->hw.mac.type != ixgbe_mac_e610)
	return;

	nvm_size = adapter->hw.flash.flash_size;
	adapter->nvm_region = devl_region_create(devlink, &ixgbe_nvm_region_ops,
	1, nvm_size);
	if (IS_ERR(adapter->nvm_region)) {
	dev_err(dev,
	"Failed to create NVM devlink region, err %ld\n",
	PTR_ERR(adapter->nvm_region));
	adapter->nvm_region = NULL;
	}

	sram_size = adapter->hw.flash.sr_words * 2u;
	adapter->sram_region = devl_region_create(devlink, &ixgbe_sram_region_ops,
	1, sram_size);
	if (IS_ERR(adapter->sram_region)) {
	dev_err(dev,
	"Failed to create shadow-ram devlink region, err %ld\n",
	PTR_ERR(adapter->sram_region));
	adapter->sram_region = NULL;
	}

	adapter->devcaps_region = devl_region_create(devlink,
	&ixgbe_devcaps_region_ops,
	10, IXGBE_ACI_MAX_BUFFER_SIZE);
	if (IS_ERR(adapter->devcaps_region)) {
	dev_err(dev,
	"Failed to create device-caps devlink region, err %ld\n",
	PTR_ERR(adapter->devcaps_region));
	adapter->devcaps_region = NULL;
	}
	}

	/**
	* ixgbe_devlink_destroy_regions - Destroy devlink regions
	* @adapter: adapter instance
	*
	* Remove previously created regions for this adapter instance.
	*/
	void ixgbe_devlink_destroy_regions(struct ixgbe_adapter *adapter)
	{
	if (adapter->hw.mac.type != ixgbe_mac_e610)
	return;

	if (adapter->nvm_region)
	devl_region_destroy(adapter->nvm_region);

	if (adapter->sram_region)
	devl_region_destroy(adapter->sram_region);

	if (adapter->devcaps_region)
	devl_region_destroy(adapter->devcaps_region);
	}