Commit 54932d72 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge tag 'fpga-for-6.14-rc1' of... 

Merge tag 'fpga-for-6.14-rc1' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/fpga/linux-fpga

 into char-misc-next

Xu writes:

FPGA Manager changes for 6.14-rc1

- Peter's change fixes SRIOV problems for Intel DFL device.

All patches have been reviewed on the mailing list, and have been in the
last linux-next releases (as part of our for-next branch).

Signed-off-by: default avatarXu Yilun <yilun.xu@intel.com>

* tag 'fpga-for-6.14-rc1' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/fpga/linux-fpga:
  fpga: dfl: destroy/recreate feature platform device on port release/assign
  fpga: dfl: drop unneeded get_device() and put_device() of feature device
  fpga: dfl: remove unneeded function build_info_create_dev()
  fpga: dfl: allocate platform device after feature device data
  fpga: dfl: store platform device id in feature device data
  fpga: dfl: store platform device name in feature device data
  fpga: dfl: store MMIO resources in feature device data
  fpga: dfl: convert features from flexible array member to separate array
  fpga: dfl: factor out feature device data from platform device data
  fpga: dfl: factor out feature device registration
  fpga: dfl: refactor internal DFL APIs to take/return feature device data
  fpga: dfl: store FIU type in feature platform data
  fpga: dfl: factor out feature data creation from build_info_commit_dev()
  fpga: dfl: pass feature platform data instead of device as argument
  fpga: dfl: afu: define local pointer to feature device
  fpga: dfl: afu: use parent device to log errors on port enable/disable
  fpga: dfl: return platform data from dfl_fpga_inode_to_feature_dev_data()
  fpga: dfl: omit unneeded argument pdata from dfl_feature_instance_init()
parents 034f1cc9 46b155ac

drivers/fpga/dfl-afu-dma-region.c

+59 −58
Original line number Diff line number Diff line
@@ -16,26 +16,26 @@ 


#include "dfl-afu.h"



void afu_dma_region_init(struct dfl_feature_platform_data *pdata)

void afu_dma_region_init(struct dfl_feature_dev_data *fdata)

{

	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);

	struct dfl_afu *afu = dfl_fpga_fdata_get_private(fdata);



	afu->dma_regions = RB_ROOT;

}



/**

 * afu_dma_pin_pages - pin pages of given dma memory region

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @region: dma memory region to be pinned

 *

 * Pin all the pages of given dfl_afu_dma_region.

 * Return 0 for success or negative error code.

 */

static int afu_dma_pin_pages(struct dfl_feature_platform_data *pdata,

static int afu_dma_pin_pages(struct dfl_feature_dev_data *fdata,

			     struct dfl_afu_dma_region *region)

{

	int npages = region->length >> PAGE_SHIFT;

	struct device *dev = &pdata->dev->dev;

	struct device *dev = &fdata->dev->dev;

	int ret, pinned;



	ret = account_locked_vm(current->mm, npages, true);
@@ -73,17 +73,17 @@ static int afu_dma_pin_pages(struct dfl_feature_platform_data *pdata, 


/**

 * afu_dma_unpin_pages - unpin pages of given dma memory region

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @region: dma memory region to be unpinned

 *

 * Unpin all the pages of given dfl_afu_dma_region.

 * Return 0 for success or negative error code.

 */

static void afu_dma_unpin_pages(struct dfl_feature_platform_data *pdata,

static void afu_dma_unpin_pages(struct dfl_feature_dev_data *fdata,

				struct dfl_afu_dma_region *region)

{

	long npages = region->length >> PAGE_SHIFT;

	struct device *dev = &pdata->dev->dev;

	struct device *dev = &fdata->dev->dev;



	unpin_user_pages(region->pages, npages);

	kfree(region->pages);
@@ -133,20 +133,20 @@ static bool dma_region_check_iova(struct dfl_afu_dma_region *region, 


/**

 * afu_dma_region_add - add given dma region to rbtree

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @region: dma region to be added

 *

 * Return 0 for success, -EEXIST if dma region has already been added.

 *

 * Needs to be called with pdata->lock heold.

 * Needs to be called with fdata->lock held.

 */

static int afu_dma_region_add(struct dfl_feature_platform_data *pdata,

static int afu_dma_region_add(struct dfl_feature_dev_data *fdata,

			      struct dfl_afu_dma_region *region)

{

	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);

	struct dfl_afu *afu = dfl_fpga_fdata_get_private(fdata);

	struct rb_node **new, *parent = NULL;



	dev_dbg(&pdata->dev->dev, "add region (iova = %llx)\n",

	dev_dbg(&fdata->dev->dev, "add region (iova = %llx)\n",

		(unsigned long long)region->iova);



	new = &afu->dma_regions.rb_node;
@@ -177,50 +177,50 @@ static int afu_dma_region_add(struct dfl_feature_platform_data *pdata, 


/**

 * afu_dma_region_remove - remove given dma region from rbtree

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @region: dma region to be removed

 *

 * Needs to be called with pdata->lock heold.

 * Needs to be called with fdata->lock held.

 */

static void afu_dma_region_remove(struct dfl_feature_platform_data *pdata,

static void afu_dma_region_remove(struct dfl_feature_dev_data *fdata,

				  struct dfl_afu_dma_region *region)

{

	struct dfl_afu *afu;



	dev_dbg(&pdata->dev->dev, "del region (iova = %llx)\n",

	dev_dbg(&fdata->dev->dev, "del region (iova = %llx)\n",

		(unsigned long long)region->iova);



	afu = dfl_fpga_pdata_get_private(pdata);

	afu = dfl_fpga_fdata_get_private(fdata);

	rb_erase(&region->node, &afu->dma_regions);

}



/**

 * afu_dma_region_destroy - destroy all regions in rbtree

 * @pdata: feature device platform data

 * @fdata: feature dev data

 *

 * Needs to be called with pdata->lock heold.

 * Needs to be called with fdata->lock held.

 */

void afu_dma_region_destroy(struct dfl_feature_platform_data *pdata)

void afu_dma_region_destroy(struct dfl_feature_dev_data *fdata)

{

	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);

	struct dfl_afu *afu = dfl_fpga_fdata_get_private(fdata);

	struct rb_node *node = rb_first(&afu->dma_regions);

	struct dfl_afu_dma_region *region;



	while (node) {

		region = container_of(node, struct dfl_afu_dma_region, node);



		dev_dbg(&pdata->dev->dev, "del region (iova = %llx)\n",

		dev_dbg(&fdata->dev->dev, "del region (iova = %llx)\n",

			(unsigned long long)region->iova);



		rb_erase(node, &afu->dma_regions);



		if (region->iova)

			dma_unmap_page(dfl_fpga_pdata_to_parent(pdata),

			dma_unmap_page(dfl_fpga_fdata_to_parent(fdata),

				       region->iova, region->length,

				       DMA_BIDIRECTIONAL);



		if (region->pages)

			afu_dma_unpin_pages(pdata, region);

			afu_dma_unpin_pages(fdata, region);



		node = rb_next(node);

		kfree(region);
@@ -229,7 +229,7 @@ void afu_dma_region_destroy(struct dfl_feature_platform_data *pdata) 


/**

 * afu_dma_region_find - find the dma region from rbtree based on iova and size

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @iova: address of the dma memory area

 * @size: size of the dma memory area

 *
@@ -239,14 +239,14 @@ void afu_dma_region_destroy(struct dfl_feature_platform_data *pdata) 
 *   [@iova, @iova+size)

 * If nothing is matched returns NULL.

 *

 * Needs to be called with pdata->lock held.

 * Needs to be called with fdata->lock held.

 */

struct dfl_afu_dma_region *

afu_dma_region_find(struct dfl_feature_platform_data *pdata, u64 iova, u64 size)

afu_dma_region_find(struct dfl_feature_dev_data *fdata, u64 iova, u64 size)

{

	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);

	struct dfl_afu *afu = dfl_fpga_fdata_get_private(fdata);

	struct rb_node *node = afu->dma_regions.rb_node;

	struct device *dev = &pdata->dev->dev;

	struct device *dev = &fdata->dev->dev;



	while (node) {

		struct dfl_afu_dma_region *region;
@@ -276,20 +276,20 @@ afu_dma_region_find(struct dfl_feature_platform_data *pdata, u64 iova, u64 size) 


/**

 * afu_dma_region_find_iova - find the dma region from rbtree by iova

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @iova: address of the dma region

 *

 * Needs to be called with pdata->lock held.

 * Needs to be called with fdata->lock held.

 */

static struct dfl_afu_dma_region *

afu_dma_region_find_iova(struct dfl_feature_platform_data *pdata, u64 iova)

afu_dma_region_find_iova(struct dfl_feature_dev_data *fdata, u64 iova)

{

	return afu_dma_region_find(pdata, iova, 0);

	return afu_dma_region_find(fdata, iova, 0);

}



/**

 * afu_dma_map_region - map memory region for dma

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @user_addr: address of the memory region

 * @length: size of the memory region

 * @iova: pointer of iova address
@@ -298,9 +298,10 @@ afu_dma_region_find_iova(struct dfl_feature_platform_data *pdata, u64 iova) 
 * of the memory region via @iova.

 * Return 0 for success, otherwise error code.

 */

int afu_dma_map_region(struct dfl_feature_platform_data *pdata,

int afu_dma_map_region(struct dfl_feature_dev_data *fdata,

		       u64 user_addr, u64 length, u64 *iova)

{

	struct device *dev = &fdata->dev->dev;

	struct dfl_afu_dma_region *region;

	int ret;
@@ -323,47 +324,47 @@ int afu_dma_map_region(struct dfl_feature_platform_data *pdata, 
	region->length = length;



	/* Pin the user memory region */

	ret = afu_dma_pin_pages(pdata, region);

	ret = afu_dma_pin_pages(fdata, region);

	if (ret) {

		dev_err(&pdata->dev->dev, "failed to pin memory region\n");

		dev_err(dev, "failed to pin memory region\n");

		goto free_region;

	}



	/* Only accept continuous pages, return error else */

	if (!afu_dma_check_continuous_pages(region)) {

		dev_err(&pdata->dev->dev, "pages are not continuous\n");

		dev_err(dev, "pages are not continuous\n");

		ret = -EINVAL;

		goto unpin_pages;

	}



	/* As pages are continuous then start to do DMA mapping */

	region->iova = dma_map_page(dfl_fpga_pdata_to_parent(pdata),

	region->iova = dma_map_page(dfl_fpga_fdata_to_parent(fdata),

				    region->pages[0], 0,

				    region->length,

				    DMA_BIDIRECTIONAL);

	if (dma_mapping_error(dfl_fpga_pdata_to_parent(pdata), region->iova)) {

		dev_err(&pdata->dev->dev, "failed to map for dma\n");

	if (dma_mapping_error(dfl_fpga_fdata_to_parent(fdata), region->iova)) {

		dev_err(dev, "failed to map for dma\n");

		ret = -EFAULT;

		goto unpin_pages;

	}



	*iova = region->iova;



	mutex_lock(&pdata->lock);

	ret = afu_dma_region_add(pdata, region);

	mutex_unlock(&pdata->lock);

	mutex_lock(&fdata->lock);

	ret = afu_dma_region_add(fdata, region);

	mutex_unlock(&fdata->lock);

	if (ret) {

		dev_err(&pdata->dev->dev, "failed to add dma region\n");

		dev_err(dev, "failed to add dma region\n");

		goto unmap_dma;

	}



	return 0;



unmap_dma:

	dma_unmap_page(dfl_fpga_pdata_to_parent(pdata),

	dma_unmap_page(dfl_fpga_fdata_to_parent(fdata),

		       region->iova, region->length, DMA_BIDIRECTIONAL);

unpin_pages:

	afu_dma_unpin_pages(pdata, region);

	afu_dma_unpin_pages(fdata, region);

free_region:

	kfree(region);

	return ret;
@@ -371,34 +372,34 @@ int afu_dma_map_region(struct dfl_feature_platform_data *pdata, 


/**

 * afu_dma_unmap_region - unmap dma memory region

 * @pdata: feature device platform data

 * @fdata: feature dev data

 * @iova: dma address of the region

 *

 * Unmap dma memory region based on @iova.

 * Return 0 for success, otherwise error code.

 */

int afu_dma_unmap_region(struct dfl_feature_platform_data *pdata, u64 iova)

int afu_dma_unmap_region(struct dfl_feature_dev_data *fdata, u64 iova)

{

	struct dfl_afu_dma_region *region;



	mutex_lock(&pdata->lock);

	region = afu_dma_region_find_iova(pdata, iova);

	mutex_lock(&fdata->lock);

	region = afu_dma_region_find_iova(fdata, iova);

	if (!region) {

		mutex_unlock(&pdata->lock);

		mutex_unlock(&fdata->lock);

		return -EINVAL;

	}



	if (region->in_use) {

		mutex_unlock(&pdata->lock);

		mutex_unlock(&fdata->lock);

		return -EBUSY;

	}



	afu_dma_region_remove(pdata, region);

	mutex_unlock(&pdata->lock);

	afu_dma_region_remove(fdata, region);

	mutex_unlock(&fdata->lock);



	dma_unmap_page(dfl_fpga_pdata_to_parent(pdata),

	dma_unmap_page(dfl_fpga_fdata_to_parent(fdata),

		       region->iova, region->length, DMA_BIDIRECTIONAL);

	afu_dma_unpin_pages(pdata, region);

	afu_dma_unpin_pages(fdata, region);

	kfree(region);



	return 0;

drivers/fpga/dfl-afu-error.c

+30 −29
Original line number Diff line number Diff line
@@ -28,37 +28,36 @@ 
#define ERROR_MASK		GENMASK_ULL(63, 0)



/* mask or unmask port errors by the error mask register. */

static void __afu_port_err_mask(struct device *dev, bool mask)

static void __afu_port_err_mask(struct dfl_feature_dev_data *fdata, bool mask)

{

	void __iomem *base;



	base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);

	base = dfl_get_feature_ioaddr_by_id(fdata, PORT_FEATURE_ID_ERROR);



	writeq(mask ? ERROR_MASK : 0, base + PORT_ERROR_MASK);

}



static void afu_port_err_mask(struct device *dev, bool mask)

{

	struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);

	struct dfl_feature_dev_data *fdata = to_dfl_feature_dev_data(dev);



	mutex_lock(&pdata->lock);

	__afu_port_err_mask(dev, mask);

	mutex_unlock(&pdata->lock);

	mutex_lock(&fdata->lock);

	__afu_port_err_mask(fdata, mask);

	mutex_unlock(&fdata->lock);

}



/* clear port errors. */

static int afu_port_err_clear(struct device *dev, u64 err)

{

	struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);

	struct platform_device *pdev = to_platform_device(dev);

	struct dfl_feature_dev_data *fdata = to_dfl_feature_dev_data(dev);

	void __iomem *base_err, *base_hdr;

	int enable_ret = 0, ret = -EBUSY;

	u64 v;



	base_err = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);

	base_hdr = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_HEADER);

	base_err = dfl_get_feature_ioaddr_by_id(fdata, PORT_FEATURE_ID_ERROR);

	base_hdr = dfl_get_feature_ioaddr_by_id(fdata, PORT_FEATURE_ID_HEADER);



	mutex_lock(&pdata->lock);

	mutex_lock(&fdata->lock);



	/*

	 * clear Port Errors
@@ -80,12 +79,12 @@ static int afu_port_err_clear(struct device *dev, u64 err) 
	}



	/* Halt Port by keeping Port in reset */

	ret = __afu_port_disable(pdev);

	ret = __afu_port_disable(fdata);

	if (ret)

		goto done;



	/* Mask all errors */

	__afu_port_err_mask(dev, true);

	__afu_port_err_mask(fdata, true);



	/* Clear errors if err input matches with current port errors.*/

	v = readq(base_err + PORT_ERROR);
@@ -102,28 +101,28 @@ static int afu_port_err_clear(struct device *dev, u64 err) 
	}



	/* Clear mask */

	__afu_port_err_mask(dev, false);

	__afu_port_err_mask(fdata, false);



	/* Enable the Port by clearing the reset */

	enable_ret = __afu_port_enable(pdev);

	enable_ret = __afu_port_enable(fdata);



done:

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);

	return enable_ret ? enable_ret : ret;

}



static ssize_t errors_show(struct device *dev, struct device_attribute *attr,

			   char *buf)

{

	struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);

	struct dfl_feature_dev_data *fdata = to_dfl_feature_dev_data(dev);

	void __iomem *base;

	u64 error;



	base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);

	base = dfl_get_feature_ioaddr_by_id(fdata, PORT_FEATURE_ID_ERROR);



	mutex_lock(&pdata->lock);

	mutex_lock(&fdata->lock);

	error = readq(base + PORT_ERROR);

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);



	return sprintf(buf, "0x%llx\n", (unsigned long long)error);

}
@@ -146,15 +145,15 @@ static DEVICE_ATTR_RW(errors); 
static ssize_t first_error_show(struct device *dev,

				struct device_attribute *attr, char *buf)

{

	struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);

	struct dfl_feature_dev_data *fdata = to_dfl_feature_dev_data(dev);

	void __iomem *base;

	u64 error;



	base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);

	base = dfl_get_feature_ioaddr_by_id(fdata, PORT_FEATURE_ID_ERROR);



	mutex_lock(&pdata->lock);

	mutex_lock(&fdata->lock);

	error = readq(base + PORT_FIRST_ERROR);

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);



	return sprintf(buf, "0x%llx\n", (unsigned long long)error);

}
@@ -164,16 +163,16 @@ static ssize_t first_malformed_req_show(struct device *dev, 
					struct device_attribute *attr,

					char *buf)

{

	struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);

	struct dfl_feature_dev_data *fdata = to_dfl_feature_dev_data(dev);

	void __iomem *base;

	u64 req0, req1;



	base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);

	base = dfl_get_feature_ioaddr_by_id(fdata, PORT_FEATURE_ID_ERROR);



	mutex_lock(&pdata->lock);

	mutex_lock(&fdata->lock);

	req0 = readq(base + PORT_MALFORMED_REQ0);

	req1 = readq(base + PORT_MALFORMED_REQ1);

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);



	return sprintf(buf, "0x%016llx%016llx\n",

		       (unsigned long long)req1, (unsigned long long)req0);
@@ -191,12 +190,14 @@ static umode_t port_err_attrs_visible(struct kobject *kobj, 
				      struct attribute *attr, int n)

{

	struct device *dev = kobj_to_dev(kobj);

	struct dfl_feature_dev_data *fdata;



	fdata = to_dfl_feature_dev_data(dev);

	/*

	 * sysfs entries are visible only if related private feature is

	 * enumerated.

	 */

	if (!dfl_get_feature_by_id(dev, PORT_FEATURE_ID_ERROR))

	if (!dfl_get_feature_by_id(fdata, PORT_FEATURE_ID_ERROR))

		return 0;



	return attr->mode;

drivers/fpga/dfl-afu-main.c

+140 −138

File changed.

Preview size limit exceeded, changes collapsed.

drivers/fpga/dfl-afu-region.c

+26 −25
Original line number Diff line number Diff line
@@ -12,11 +12,11 @@ 


/**

 * afu_mmio_region_init - init function for afu mmio region support

 * @pdata: afu platform device's pdata.

 * @fdata: afu feature dev data

 */

void afu_mmio_region_init(struct dfl_feature_platform_data *pdata)

void afu_mmio_region_init(struct dfl_feature_dev_data *fdata)

{

	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);

	struct dfl_afu *afu = dfl_fpga_fdata_get_private(fdata);



	INIT_LIST_HEAD(&afu->regions);

}
@@ -39,7 +39,7 @@ static struct dfl_afu_mmio_region *get_region_by_index(struct dfl_afu *afu, 
/**

 * afu_mmio_region_add - add a mmio region to given feature dev.

 *

 * @pdata: afu platform device's pdata.

 * @fdata: afu feature dev data

 * @region_index: region index.

 * @region_size: region size.

 * @phys: region's physical address of this region.
@@ -47,14 +47,15 @@ static struct dfl_afu_mmio_region *get_region_by_index(struct dfl_afu *afu, 
 *

 * Return: 0 on success, negative error code otherwise.

 */

int afu_mmio_region_add(struct dfl_feature_platform_data *pdata,

int afu_mmio_region_add(struct dfl_feature_dev_data *fdata,

			u32 region_index, u64 region_size, u64 phys, u32 flags)

{

	struct device *dev = &fdata->dev->dev;

	struct dfl_afu_mmio_region *region;

	struct dfl_afu *afu;

	int ret = 0;



	region = devm_kzalloc(&pdata->dev->dev, sizeof(*region), GFP_KERNEL);

	region = devm_kzalloc(dev, sizeof(*region), GFP_KERNEL);

	if (!region)

		return -ENOMEM;
@@ -63,13 +64,13 @@ int afu_mmio_region_add(struct dfl_feature_platform_data *pdata, 
	region->phys = phys;

	region->flags = flags;



	mutex_lock(&pdata->lock);

	mutex_lock(&fdata->lock);



	afu = dfl_fpga_pdata_get_private(pdata);

	afu = dfl_fpga_fdata_get_private(fdata);



	/* check if @index already exists */

	if (get_region_by_index(afu, region_index)) {

		mutex_unlock(&pdata->lock);

		mutex_unlock(&fdata->lock);

		ret = -EEXIST;

		goto exit;

	}
@@ -80,37 +81,37 @@ int afu_mmio_region_add(struct dfl_feature_platform_data *pdata, 


	afu->region_cur_offset += region_size;

	afu->num_regions++;

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);



	return 0;



exit:

	devm_kfree(&pdata->dev->dev, region);

	devm_kfree(dev, region);

	return ret;

}



/**

 * afu_mmio_region_destroy - destroy all mmio regions under given feature dev.

 * @pdata: afu platform device's pdata.

 * @fdata: afu feature dev data

 */

void afu_mmio_region_destroy(struct dfl_feature_platform_data *pdata)

void afu_mmio_region_destroy(struct dfl_feature_dev_data *fdata)

{

	struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);

	struct dfl_afu *afu = dfl_fpga_fdata_get_private(fdata);

	struct dfl_afu_mmio_region *tmp, *region;



	list_for_each_entry_safe(region, tmp, &afu->regions, node)

		devm_kfree(&pdata->dev->dev, region);

		devm_kfree(&fdata->dev->dev, region);

}



/**

 * afu_mmio_region_get_by_index - find an afu region by index.

 * @pdata: afu platform device's pdata.

 * @fdata: afu feature dev data

 * @region_index: region index.

 * @pregion: ptr to region for result.

 *

 * Return: 0 on success, negative error code otherwise.

 */

int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata,

int afu_mmio_region_get_by_index(struct dfl_feature_dev_data *fdata,

				 u32 region_index,

				 struct dfl_afu_mmio_region *pregion)

{
@@ -118,8 +119,8 @@ int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata, 
	struct dfl_afu *afu;

	int ret = 0;



	mutex_lock(&pdata->lock);

	afu = dfl_fpga_pdata_get_private(pdata);

	mutex_lock(&fdata->lock);

	afu = dfl_fpga_fdata_get_private(fdata);

	region = get_region_by_index(afu, region_index);

	if (!region) {

		ret = -EINVAL;
@@ -127,14 +128,14 @@ int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata, 
	}

	*pregion = *region;

exit:

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);

	return ret;

}



/**

 * afu_mmio_region_get_by_offset - find an afu mmio region by offset and size

 *

 * @pdata: afu platform device's pdata.

 * @fdata: afu feature dev data

 * @offset: region offset from start of the device fd.

 * @size: region size.

 * @pregion: ptr to region for result.
@@ -144,7 +145,7 @@ int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata, 
 *

 * Return: 0 on success, negative error code otherwise.

 */

int afu_mmio_region_get_by_offset(struct dfl_feature_platform_data *pdata,

int afu_mmio_region_get_by_offset(struct dfl_feature_dev_data *fdata,

				  u64 offset, u64 size,

				  struct dfl_afu_mmio_region *pregion)

{
@@ -152,8 +153,8 @@ int afu_mmio_region_get_by_offset(struct dfl_feature_platform_data *pdata, 
	struct dfl_afu *afu;

	int ret = 0;



	mutex_lock(&pdata->lock);

	afu = dfl_fpga_pdata_get_private(pdata);

	mutex_lock(&fdata->lock);

	afu = dfl_fpga_fdata_get_private(fdata);

	for_each_region(region, afu)

		if (region->offset <= offset &&

		    region->offset + region->size >= offset + size) {
@@ -162,6 +163,6 @@ int afu_mmio_region_get_by_offset(struct dfl_feature_platform_data *pdata, 
		}

	ret = -EINVAL;

exit:

	mutex_unlock(&pdata->lock);

	mutex_unlock(&fdata->lock);

	return ret;

}

drivers/fpga/dfl-afu.h

+13 −13
Original line number Diff line number Diff line
@@ -76,27 +76,27 @@ struct dfl_afu { 
	struct rb_root dma_regions;

};



/* hold pdata->lock when call __afu_port_enable/disable */

int __afu_port_enable(struct platform_device *pdev);

int __afu_port_disable(struct platform_device *pdev);

/* hold fdata->lock when call __afu_port_enable/disable */

int __afu_port_enable(struct dfl_feature_dev_data *fdata);

int __afu_port_disable(struct dfl_feature_dev_data *fdata);



void afu_mmio_region_init(struct dfl_feature_platform_data *pdata);

int afu_mmio_region_add(struct dfl_feature_platform_data *pdata,

void afu_mmio_region_init(struct dfl_feature_dev_data *fdata);

int afu_mmio_region_add(struct dfl_feature_dev_data *fdata,

			u32 region_index, u64 region_size, u64 phys, u32 flags);

void afu_mmio_region_destroy(struct dfl_feature_platform_data *pdata);

int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata,

void afu_mmio_region_destroy(struct dfl_feature_dev_data *fdata);

int afu_mmio_region_get_by_index(struct dfl_feature_dev_data *fdata,

				 u32 region_index,

				 struct dfl_afu_mmio_region *pregion);

int afu_mmio_region_get_by_offset(struct dfl_feature_platform_data *pdata,

int afu_mmio_region_get_by_offset(struct dfl_feature_dev_data *fdata,

				  u64 offset, u64 size,

				  struct dfl_afu_mmio_region *pregion);

void afu_dma_region_init(struct dfl_feature_platform_data *pdata);

void afu_dma_region_destroy(struct dfl_feature_platform_data *pdata);

int afu_dma_map_region(struct dfl_feature_platform_data *pdata,

void afu_dma_region_init(struct dfl_feature_dev_data *fdata);

void afu_dma_region_destroy(struct dfl_feature_dev_data *fdata);

int afu_dma_map_region(struct dfl_feature_dev_data *fdata,

		       u64 user_addr, u64 length, u64 *iova);

int afu_dma_unmap_region(struct dfl_feature_platform_data *pdata, u64 iova);

int afu_dma_unmap_region(struct dfl_feature_dev_data *fdata, u64 iova);

struct dfl_afu_dma_region *

afu_dma_region_find(struct dfl_feature_platform_data *pdata,

afu_dma_region_find(struct dfl_feature_dev_data *fdata,

		    u64 iova, u64 size);



extern const struct dfl_feature_ops port_err_ops;