Merge tag 'kvmarm-fixes-5.4-1' of git://git.kernel.org/pub/scm/linux/kernel/git/kvmar...
[linux-2.6-microblaze.git] / drivers / fpga / dfl-afu-error.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Driver for FPGA Accelerated Function Unit (AFU) Error Reporting
4  *
5  * Copyright 2019 Intel Corporation, Inc.
6  *
7  * Authors:
8  *   Wu Hao <hao.wu@linux.intel.com>
9  *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
10  *   Joseph Grecco <joe.grecco@intel.com>
11  *   Enno Luebbers <enno.luebbers@intel.com>
12  *   Tim Whisonant <tim.whisonant@intel.com>
13  *   Ananda Ravuri <ananda.ravuri@intel.com>
14  *   Mitchel Henry <henry.mitchel@intel.com>
15  */
16
17 #include <linux/uaccess.h>
18
19 #include "dfl-afu.h"
20
21 #define PORT_ERROR_MASK         0x8
22 #define PORT_ERROR              0x10
23 #define PORT_FIRST_ERROR        0x18
24 #define PORT_MALFORMED_REQ0     0x20
25 #define PORT_MALFORMED_REQ1     0x28
26
27 #define ERROR_MASK              GENMASK_ULL(63, 0)
28
29 /* mask or unmask port errors by the error mask register. */
30 static void __afu_port_err_mask(struct device *dev, bool mask)
31 {
32         void __iomem *base;
33
34         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
35
36         writeq(mask ? ERROR_MASK : 0, base + PORT_ERROR_MASK);
37 }
38
39 static void afu_port_err_mask(struct device *dev, bool mask)
40 {
41         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
42
43         mutex_lock(&pdata->lock);
44         __afu_port_err_mask(dev, mask);
45         mutex_unlock(&pdata->lock);
46 }
47
48 /* clear port errors. */
49 static int afu_port_err_clear(struct device *dev, u64 err)
50 {
51         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
52         struct platform_device *pdev = to_platform_device(dev);
53         void __iomem *base_err, *base_hdr;
54         int ret = -EBUSY;
55         u64 v;
56
57         base_err = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
58         base_hdr = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_HEADER);
59
60         mutex_lock(&pdata->lock);
61
62         /*
63          * clear Port Errors
64          *
65          * - Check for AP6 State
66          * - Halt Port by keeping Port in reset
67          * - Set PORT Error mask to all 1 to mask errors
68          * - Clear all errors
69          * - Set Port mask to all 0 to enable errors
70          * - All errors start capturing new errors
71          * - Enable Port by pulling the port out of reset
72          */
73
74         /* if device is still in AP6 power state, can not clear any error. */
75         v = readq(base_hdr + PORT_HDR_STS);
76         if (FIELD_GET(PORT_STS_PWR_STATE, v) == PORT_STS_PWR_STATE_AP6) {
77                 dev_err(dev, "Could not clear errors, device in AP6 state.\n");
78                 goto done;
79         }
80
81         /* Halt Port by keeping Port in reset */
82         ret = __afu_port_disable(pdev);
83         if (ret)
84                 goto done;
85
86         /* Mask all errors */
87         __afu_port_err_mask(dev, true);
88
89         /* Clear errors if err input matches with current port errors.*/
90         v = readq(base_err + PORT_ERROR);
91
92         if (v == err) {
93                 writeq(v, base_err + PORT_ERROR);
94
95                 v = readq(base_err + PORT_FIRST_ERROR);
96                 writeq(v, base_err + PORT_FIRST_ERROR);
97         } else {
98                 ret = -EINVAL;
99         }
100
101         /* Clear mask */
102         __afu_port_err_mask(dev, false);
103
104         /* Enable the Port by clear the reset */
105         __afu_port_enable(pdev);
106
107 done:
108         mutex_unlock(&pdata->lock);
109         return ret;
110 }
111
112 static ssize_t errors_show(struct device *dev, struct device_attribute *attr,
113                            char *buf)
114 {
115         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
116         void __iomem *base;
117         u64 error;
118
119         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
120
121         mutex_lock(&pdata->lock);
122         error = readq(base + PORT_ERROR);
123         mutex_unlock(&pdata->lock);
124
125         return sprintf(buf, "0x%llx\n", (unsigned long long)error);
126 }
127
128 static ssize_t errors_store(struct device *dev, struct device_attribute *attr,
129                             const char *buff, size_t count)
130 {
131         u64 value;
132         int ret;
133
134         if (kstrtou64(buff, 0, &value))
135                 return -EINVAL;
136
137         ret = afu_port_err_clear(dev, value);
138
139         return ret ? ret : count;
140 }
141 static DEVICE_ATTR_RW(errors);
142
143 static ssize_t first_error_show(struct device *dev,
144                                 struct device_attribute *attr, char *buf)
145 {
146         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
147         void __iomem *base;
148         u64 error;
149
150         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
151
152         mutex_lock(&pdata->lock);
153         error = readq(base + PORT_FIRST_ERROR);
154         mutex_unlock(&pdata->lock);
155
156         return sprintf(buf, "0x%llx\n", (unsigned long long)error);
157 }
158 static DEVICE_ATTR_RO(first_error);
159
160 static ssize_t first_malformed_req_show(struct device *dev,
161                                         struct device_attribute *attr,
162                                         char *buf)
163 {
164         struct dfl_feature_platform_data *pdata = dev_get_platdata(dev);
165         void __iomem *base;
166         u64 req0, req1;
167
168         base = dfl_get_feature_ioaddr_by_id(dev, PORT_FEATURE_ID_ERROR);
169
170         mutex_lock(&pdata->lock);
171         req0 = readq(base + PORT_MALFORMED_REQ0);
172         req1 = readq(base + PORT_MALFORMED_REQ1);
173         mutex_unlock(&pdata->lock);
174
175         return sprintf(buf, "0x%016llx%016llx\n",
176                        (unsigned long long)req1, (unsigned long long)req0);
177 }
178 static DEVICE_ATTR_RO(first_malformed_req);
179
180 static struct attribute *port_err_attrs[] = {
181         &dev_attr_errors.attr,
182         &dev_attr_first_error.attr,
183         &dev_attr_first_malformed_req.attr,
184         NULL,
185 };
186
187 static umode_t port_err_attrs_visible(struct kobject *kobj,
188                                       struct attribute *attr, int n)
189 {
190         struct device *dev = kobj_to_dev(kobj);
191
192         /*
193          * sysfs entries are visible only if related private feature is
194          * enumerated.
195          */
196         if (!dfl_get_feature_by_id(dev, PORT_FEATURE_ID_ERROR))
197                 return 0;
198
199         return attr->mode;
200 }
201
202 const struct attribute_group port_err_group = {
203         .name       = "errors",
204         .attrs      = port_err_attrs,
205         .is_visible = port_err_attrs_visible,
206 };
207
208 static int port_err_init(struct platform_device *pdev,
209                          struct dfl_feature *feature)
210 {
211         afu_port_err_mask(&pdev->dev, false);
212
213         return 0;
214 }
215
216 static void port_err_uinit(struct platform_device *pdev,
217                            struct dfl_feature *feature)
218 {
219         afu_port_err_mask(&pdev->dev, true);
220 }
221
222 const struct dfl_feature_id port_err_id_table[] = {
223         {.id = PORT_FEATURE_ID_ERROR,},
224         {0,}
225 };
226
227 const struct dfl_feature_ops port_err_ops = {
228         .init = port_err_init,
229         .uinit = port_err_uinit,
230 };