projects/linux·blob master · refs

397 lines · 8.7 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Lattice FPGA sysCONFIG interface functions independent of port type.
4 */
5
6#include <linux/delay.h>
7#include <linux/fpga/fpga-mgr.h>
8#include <linux/gpio/consumer.h>
9#include <linux/iopoll.h>
10
11#include "lattice-sysconfig.h"
12
13static int sysconfig_cmd_write(struct sysconfig_priv *priv, const void *buf,
14 size_t buf_len)
15{
16 return priv->command_transfer(priv, buf, buf_len, NULL, 0);
17}
18
19static int sysconfig_cmd_read(struct sysconfig_priv *priv, const void *tx_buf,
20 size_t tx_len, void *rx_buf, size_t rx_len)
21{
22 return priv->command_transfer(priv, tx_buf, tx_len, rx_buf, rx_len);
23}
24
25static int sysconfig_read_busy(struct sysconfig_priv *priv)
26{
27 const u8 lsc_check_busy[] = SYSCONFIG_LSC_CHECK_BUSY;
28 u8 busy;
29 int ret;
30
31 ret = sysconfig_cmd_read(priv, lsc_check_busy, sizeof(lsc_check_busy),
32 &busy, sizeof(busy));
33
34 return ret ? : busy;
35}
36
37static int sysconfig_poll_busy(struct sysconfig_priv *priv)
38{
39 int ret, busy;
40
41 ret = read_poll_timeout(sysconfig_read_busy, busy, busy <= 0,
42 SYSCONFIG_POLL_INTERVAL_US,
43 SYSCONFIG_POLL_BUSY_TIMEOUT_US, false, priv);
44
45 return ret ? : busy;
46}
47
48static int sysconfig_read_status(struct sysconfig_priv *priv, u32 *status)
49{
50 const u8 lsc_read_status[] = SYSCONFIG_LSC_READ_STATUS;
51 __be32 device_status;
52 int ret;
53
54 ret = sysconfig_cmd_read(priv, lsc_read_status, sizeof(lsc_read_status),
55 &device_status, sizeof(device_status));
56 if (ret)
57 return ret;
58
59 *status = be32_to_cpu(device_status);
60
61 return 0;
62}
63
64static int sysconfig_poll_status(struct sysconfig_priv *priv, u32 *status)
65{
66 int ret = sysconfig_poll_busy(priv);
67
68 if (ret)
69 return ret;
70
71 return sysconfig_read_status(priv, status);
72}
73
74static int sysconfig_poll_gpio(struct gpio_desc *gpio, bool is_active)
75{
76 int ret, val;
77
78 ret = read_poll_timeout(gpiod_get_value, val,
79 val < 0 || !!val == is_active,
80 SYSCONFIG_POLL_INTERVAL_US,
81 SYSCONFIG_POLL_GPIO_TIMEOUT_US, false, gpio);
82
83 if (val < 0)
84 return val;
85
86 return ret;
87}
88
89static int sysconfig_gpio_refresh(struct sysconfig_priv *priv)
90{
91 struct gpio_desc *program = priv->program;
92 struct gpio_desc *init = priv->init;
93 struct gpio_desc *done = priv->done;
94 int ret;
95
96 /* Enter init mode */
97 gpiod_set_value(program, 1);
98
99 ret = sysconfig_poll_gpio(init, true);
100 if (!ret)
101 ret = sysconfig_poll_gpio(done, false);
102
103 if (ret)
104 return ret;
105
106 /* Enter program mode */
107 gpiod_set_value(program, 0);
108
109 return sysconfig_poll_gpio(init, false);
110}
111
112static int sysconfig_lsc_refresh(struct sysconfig_priv *priv)
113{
114 static const u8 lsc_refresh[] = SYSCONFIG_LSC_REFRESH;
115 int ret;
116
117 ret = sysconfig_cmd_write(priv, lsc_refresh, sizeof(lsc_refresh));
118 if (ret)
119 return ret;
120
121 usleep_range(4000, 8000);
122
123 return 0;
124}
125
126static int sysconfig_refresh(struct sysconfig_priv *priv)
127{
128 struct gpio_desc *program = priv->program;
129 struct gpio_desc *init = priv->init;
130 struct gpio_desc *done = priv->done;
131
132 if (program && init && done)
133 return sysconfig_gpio_refresh(priv);
134
135 return sysconfig_lsc_refresh(priv);
136}
137
138static int sysconfig_isc_enable(struct sysconfig_priv *priv)
139{
140 u8 isc_enable[] = SYSCONFIG_ISC_ENABLE;
141 u32 status;
142 int ret;
143
144 ret = sysconfig_cmd_write(priv, isc_enable, sizeof(isc_enable));
145 if (ret)
146 return ret;
147
148 ret = sysconfig_poll_status(priv, &status);
149 if (ret)
150 return ret;
151
152 if (status & SYSCONFIG_STATUS_FAIL)
153 return -EFAULT;
154
155 return 0;
156}
157
158static int sysconfig_isc_erase(struct sysconfig_priv *priv)
159{
160 u8 isc_erase[] = SYSCONFIG_ISC_ERASE;
161 u32 status;
162 int ret;
163
164 ret = sysconfig_cmd_write(priv, isc_erase, sizeof(isc_erase));
165 if (ret)
166 return ret;
167
168 ret = sysconfig_poll_status(priv, &status);
169 if (ret)
170 return ret;
171
172 if (status & SYSCONFIG_STATUS_FAIL)
173 return -EFAULT;
174
175 return 0;
176}
177
178static int sysconfig_isc_init(struct sysconfig_priv *priv)
179{
180 int ret = sysconfig_isc_enable(priv);
181
182 if (ret)
183 return ret;
184
185 return sysconfig_isc_erase(priv);
186}
187
188static int sysconfig_lsc_init_addr(struct sysconfig_priv *priv)
189{
190 const u8 lsc_init_addr[] = SYSCONFIG_LSC_INIT_ADDR;
191
192 return sysconfig_cmd_write(priv, lsc_init_addr, sizeof(lsc_init_addr));
193}
194
195static int sysconfig_burst_write_init(struct sysconfig_priv *priv)
196{
197 return priv->bitstream_burst_write_init(priv);
198}
199
200static int sysconfig_burst_write_complete(struct sysconfig_priv *priv)
201{
202 return priv->bitstream_burst_write_complete(priv);
203}
204
205static int sysconfig_bitstream_burst_write(struct sysconfig_priv *priv,
206 const char *buf, size_t count)
207{
208 int ret = priv->bitstream_burst_write(priv, buf, count);
209
210 if (ret)
211 sysconfig_burst_write_complete(priv);
212
213 return ret;
214}
215
216static int sysconfig_isc_disable(struct sysconfig_priv *priv)
217{
218 const u8 isc_disable[] = SYSCONFIG_ISC_DISABLE;
219
220 return sysconfig_cmd_write(priv, isc_disable, sizeof(isc_disable));
221}
222
223static void sysconfig_cleanup(struct sysconfig_priv *priv)
224{
225 sysconfig_isc_erase(priv);
226 sysconfig_refresh(priv);
227}
228
229static int sysconfig_isc_finish(struct sysconfig_priv *priv)
230{
231 struct gpio_desc *done_gpio = priv->done;
232 u32 status;
233 int ret;
234
235 if (done_gpio) {
236 ret = sysconfig_isc_disable(priv);
237 if (ret)
238 return ret;
239
240 return sysconfig_poll_gpio(done_gpio, true);
241 }
242
243 ret = sysconfig_poll_status(priv, &status);
244 if (ret)
245 return ret;
246
247 if ((status & SYSCONFIG_STATUS_DONE) &&
248 !(status & SYSCONFIG_STATUS_BUSY) &&
249 !(status & SYSCONFIG_STATUS_ERR))
250 return sysconfig_isc_disable(priv);
251
252 return -EFAULT;
253}
254
255static enum fpga_mgr_states sysconfig_ops_state(struct fpga_manager *mgr)
256{
257 struct sysconfig_priv *priv = mgr->priv;
258 struct gpio_desc *done = priv->done;
259 u32 status;
260 int ret;
261
262 if (done && (gpiod_get_value(done) > 0))
263 return FPGA_MGR_STATE_OPERATING;
264
265 ret = sysconfig_read_status(priv, &status);
266 if (!ret && (status & SYSCONFIG_STATUS_DONE))
267 return FPGA_MGR_STATE_OPERATING;
268
269 return FPGA_MGR_STATE_UNKNOWN;
270}
271
272static int sysconfig_ops_write_init(struct fpga_manager *mgr,
273 struct fpga_image_info *info,
274 const char *buf, size_t count)
275{
276 struct sysconfig_priv *priv = mgr->priv;
277 struct device *dev = &mgr->dev;
278 int ret;
279
280 if (info->flags & FPGA_MGR_PARTIAL_RECONFIG) {
281 dev_err(dev, "Partial reconfiguration is not supported\n");
282 return -EOPNOTSUPP;
283 }
284
285 /* Enter program mode */
286 ret = sysconfig_refresh(priv);
287 if (ret) {
288 dev_err(dev, "Failed to go to program mode\n");
289 return ret;
290 }
291
292 /* Enter ISC mode */
293 ret = sysconfig_isc_init(priv);
294 if (ret) {
295 dev_err(dev, "Failed to go to ISC mode\n");
296 return ret;
297 }
298
299 /* Initialize the Address Shift Register */
300 ret = sysconfig_lsc_init_addr(priv);
301 if (ret) {
302 dev_err(dev,
303 "Failed to initialize the Address Shift Register\n");
304 return ret;
305 }
306
307 /* Prepare for bitstream burst write */
308 ret = sysconfig_burst_write_init(priv);
309 if (ret)
310 dev_err(dev, "Failed to prepare for bitstream burst write\n");
311
312 return ret;
313}
314
315static int sysconfig_ops_write(struct fpga_manager *mgr, const char *buf,
316 size_t count)
317{
318 return sysconfig_bitstream_burst_write(mgr->priv, buf, count);
319}
320
321static int sysconfig_ops_write_complete(struct fpga_manager *mgr,
322 struct fpga_image_info *info)
323{
324 struct sysconfig_priv *priv = mgr->priv;
325 struct device *dev = &mgr->dev;
326 int ret;
327
328 ret = sysconfig_burst_write_complete(priv);
329 if (!ret)
330 ret = sysconfig_poll_busy(priv);
331
332 if (ret) {
333 dev_err(dev, "Error while waiting bitstream write to finish\n");
334 goto fail;
335 }
336
337 ret = sysconfig_isc_finish(priv);
338
339fail:
340 if (ret)
341 sysconfig_cleanup(priv);
342
343 return ret;
344}
345
346static const struct fpga_manager_ops sysconfig_fpga_mgr_ops = {
347 .state = sysconfig_ops_state,
348 .write_init = sysconfig_ops_write_init,
349 .write = sysconfig_ops_write,
350 .write_complete = sysconfig_ops_write_complete,
351};
352
353int sysconfig_probe(struct sysconfig_priv *priv)
354{
355 struct gpio_desc *program, *init, *done;
356 struct device *dev = priv->dev;
357 struct fpga_manager *mgr;
358
359 if (!dev)
360 return -ENODEV;
361
362 if (!priv->command_transfer ||
363 !priv->bitstream_burst_write_init ||
364 !priv->bitstream_burst_write ||
365 !priv->bitstream_burst_write_complete) {
366 dev_err(dev, "Essential callback is missing\n");
367 return -EINVAL;
368 }
369
370 program = devm_gpiod_get_optional(dev, "program", GPIOD_OUT_LOW);
371 if (IS_ERR(program))
372 return dev_err_probe(dev, PTR_ERR(program),
373 "Failed to get PROGRAM GPIO\n");
374
375 init = devm_gpiod_get_optional(dev, "init", GPIOD_IN);
376 if (IS_ERR(init))
377 return dev_err_probe(dev, PTR_ERR(init),
378 "Failed to get INIT GPIO\n");
379
380 done = devm_gpiod_get_optional(dev, "done", GPIOD_IN);
381 if (IS_ERR(done))
382 return dev_err_probe(dev, PTR_ERR(done),
383 "Failed to get DONE GPIO\n");
384
385 priv->program = program;
386 priv->init = init;
387 priv->done = done;
388
389 mgr = devm_fpga_mgr_register(dev, "Lattice sysCONFIG FPGA Manager",
390 &sysconfig_fpga_mgr_ops, priv);
391
392 return PTR_ERR_OR_ZERO(mgr);
393}
394EXPORT_SYMBOL(sysconfig_probe);
395
396MODULE_DESCRIPTION("Lattice sysCONFIG FPGA Manager Core");
397MODULE_LICENSE("GPL");