GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / fpga / dfl-afu-region.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for FPGA Accelerated Function Unit (AFU) MMIO Region Management
4  *
5  * Copyright (C) 2017-2018 Intel Corporation, Inc.
6  *
7  * Authors:
8  *   Wu Hao <hao.wu@intel.com>
9  *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
10  */
11 #include "dfl-afu.h"
12
13 /**
14  * afu_mmio_region_init - init function for afu mmio region support
15  * @pdata: afu platform device's pdata.
16  */
17 void afu_mmio_region_init(struct dfl_feature_platform_data *pdata)
18 {
19         struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);
20
21         INIT_LIST_HEAD(&afu->regions);
22 }
23
24 #define for_each_region(region, afu)    \
25         list_for_each_entry((region), &(afu)->regions, node)
26
27 static struct dfl_afu_mmio_region *get_region_by_index(struct dfl_afu *afu,
28                                                        u32 region_index)
29 {
30         struct dfl_afu_mmio_region *region;
31
32         for_each_region(region, afu)
33                 if (region->index == region_index)
34                         return region;
35
36         return NULL;
37 }
38
39 /**
40  * afu_mmio_region_add - add a mmio region to given feature dev.
41  *
42  * @region_index: region index.
43  * @region_size: region size.
44  * @phys: region's physical address of this region.
45  * @flags: region flags (access permission).
46  *
47  * Return: 0 on success, negative error code otherwise.
48  */
49 int afu_mmio_region_add(struct dfl_feature_platform_data *pdata,
50                         u32 region_index, u64 region_size, u64 phys, u32 flags)
51 {
52         struct dfl_afu_mmio_region *region;
53         struct dfl_afu *afu;
54         int ret = 0;
55
56         region = devm_kzalloc(&pdata->dev->dev, sizeof(*region), GFP_KERNEL);
57         if (!region)
58                 return -ENOMEM;
59
60         region->index = region_index;
61         region->size = region_size;
62         region->phys = phys;
63         region->flags = flags;
64
65         mutex_lock(&pdata->lock);
66
67         afu = dfl_fpga_pdata_get_private(pdata);
68
69         /* check if @index already exists */
70         if (get_region_by_index(afu, region_index)) {
71                 mutex_unlock(&pdata->lock);
72                 ret = -EEXIST;
73                 goto exit;
74         }
75
76         region_size = PAGE_ALIGN(region_size);
77         region->offset = afu->region_cur_offset;
78         list_add(&region->node, &afu->regions);
79
80         afu->region_cur_offset += region_size;
81         afu->num_regions++;
82         mutex_unlock(&pdata->lock);
83
84         return 0;
85
86 exit:
87         devm_kfree(&pdata->dev->dev, region);
88         return ret;
89 }
90
91 /**
92  * afu_mmio_region_destroy - destroy all mmio regions under given feature dev.
93  * @pdata: afu platform device's pdata.
94  */
95 void afu_mmio_region_destroy(struct dfl_feature_platform_data *pdata)
96 {
97         struct dfl_afu *afu = dfl_fpga_pdata_get_private(pdata);
98         struct dfl_afu_mmio_region *tmp, *region;
99
100         list_for_each_entry_safe(region, tmp, &afu->regions, node)
101                 devm_kfree(&pdata->dev->dev, region);
102 }
103
104 /**
105  * afu_mmio_region_get_by_index - find an afu region by index.
106  * @pdata: afu platform device's pdata.
107  * @region_index: region index.
108  * @pregion: ptr to region for result.
109  *
110  * Return: 0 on success, negative error code otherwise.
111  */
112 int afu_mmio_region_get_by_index(struct dfl_feature_platform_data *pdata,
113                                  u32 region_index,
114                                  struct dfl_afu_mmio_region *pregion)
115 {
116         struct dfl_afu_mmio_region *region;
117         struct dfl_afu *afu;
118         int ret = 0;
119
120         mutex_lock(&pdata->lock);
121         afu = dfl_fpga_pdata_get_private(pdata);
122         region = get_region_by_index(afu, region_index);
123         if (!region) {
124                 ret = -EINVAL;
125                 goto exit;
126         }
127         *pregion = *region;
128 exit:
129         mutex_unlock(&pdata->lock);
130         return ret;
131 }
132
133 /**
134  * afu_mmio_region_get_by_offset - find an afu mmio region by offset and size
135  *
136  * @pdata: afu platform device's pdata.
137  * @offset: region offset from start of the device fd.
138  * @size: region size.
139  * @pregion: ptr to region for result.
140  *
141  * Find the region which fully contains the region described by input
142  * parameters (offset and size) from the feature dev's region linked list.
143  *
144  * Return: 0 on success, negative error code otherwise.
145  */
146 int afu_mmio_region_get_by_offset(struct dfl_feature_platform_data *pdata,
147                                   u64 offset, u64 size,
148                                   struct dfl_afu_mmio_region *pregion)
149 {
150         struct dfl_afu_mmio_region *region;
151         struct dfl_afu *afu;
152         int ret = 0;
153
154         mutex_lock(&pdata->lock);
155         afu = dfl_fpga_pdata_get_private(pdata);
156         for_each_region(region, afu)
157                 if (region->offset <= offset &&
158                     region->offset + region->size >= offset + size) {
159                         *pregion = *region;
160                         goto exit;
161                 }
162         ret = -EINVAL;
163 exit:
164         mutex_unlock(&pdata->lock);
165         return ret;
166 }