]> git.proxmox.com Git - mirror_ubuntu-hirsute-kernel.git/blob - drivers/fsi/fsi-sbefifo.c
projects / mirror_ubuntu-hirsute-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'acpi-5.10-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael...
[mirror_ubuntu-hirsute-kernel.git] / drivers / fsi / fsi-sbefifo.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) IBM Corporation 2017
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERGCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 */
14
15 #include <linux/device.h>
16 #include <linux/errno.h>
17 #include <linux/fs.h>
18 #include <linux/fsi.h>
19 #include <linux/fsi-sbefifo.h>
20 #include <linux/kernel.h>
21 #include <linux/cdev.h>
22 #include <linux/module.h>
23 #include <linux/mutex.h>
24 #include <linux/of.h>
25 #include <linux/of_device.h>
26 #include <linux/of_platform.h>
27 #include <linux/sched.h>
28 #include <linux/slab.h>
29 #include <linux/uaccess.h>
30 #include <linux/delay.h>
31 #include <linux/uio.h>
32 #include <linux/vmalloc.h>
33 #include <linux/mm.h>
34
35 /*
36 * The SBEFIFO is a pipe-like FSI device for communicating with
37 * the self boot engine on POWER processors.
38 */
39
40 #define DEVICE_NAME "sbefifo"
41 #define FSI_ENGID_SBE 0x22
42
43 /*
44 * Register layout
45 */
46
47 /* Register banks */
48 #define SBEFIFO_UP 0x00 /* FSI -> Host */
49 #define SBEFIFO_DOWN 0x40 /* Host -> FSI */
50
51 /* Per-bank registers */
52 #define SBEFIFO_FIFO 0x00 /* The FIFO itself */
53 #define SBEFIFO_STS 0x04 /* Status register */
54 #define SBEFIFO_STS_PARITY_ERR 0x20000000
55 #define SBEFIFO_STS_RESET_REQ 0x02000000
56 #define SBEFIFO_STS_GOT_EOT 0x00800000
57 #define SBEFIFO_STS_MAX_XFER_LIMIT 0x00400000
58 #define SBEFIFO_STS_FULL 0x00200000
59 #define SBEFIFO_STS_EMPTY 0x00100000
60 #define SBEFIFO_STS_ECNT_MASK 0x000f0000
61 #define SBEFIFO_STS_ECNT_SHIFT 16
62 #define SBEFIFO_STS_VALID_MASK 0x0000ff00
63 #define SBEFIFO_STS_VALID_SHIFT 8
64 #define SBEFIFO_STS_EOT_MASK 0x000000ff
65 #define SBEFIFO_STS_EOT_SHIFT 0
66 #define SBEFIFO_EOT_RAISE 0x08 /* (Up only) Set End Of Transfer */
67 #define SBEFIFO_REQ_RESET 0x0C /* (Up only) Reset Request */
68 #define SBEFIFO_PERFORM_RESET 0x10 /* (Down only) Perform Reset */
69 #define SBEFIFO_EOT_ACK 0x14 /* (Down only) Acknowledge EOT */
70 #define SBEFIFO_DOWN_MAX 0x18 /* (Down only) Max transfer */
71
72 /* CFAM GP Mailbox SelfBoot Message register */
73 #define CFAM_GP_MBOX_SBM_ADDR 0x2824 /* Converted 0x2809 */
74
75 #define CFAM_SBM_SBE_BOOTED 0x80000000
76 #define CFAM_SBM_SBE_ASYNC_FFDC 0x40000000
77 #define CFAM_SBM_SBE_STATE_MASK 0x00f00000
78 #define CFAM_SBM_SBE_STATE_SHIFT 20
79
80 enum sbe_state
81 {
82 SBE_STATE_UNKNOWN = 0x0, // Unkown, initial state
83 SBE_STATE_IPLING = 0x1, // IPL'ing - autonomous mode (transient)
84 SBE_STATE_ISTEP = 0x2, // ISTEP - Running IPL by steps (transient)
85 SBE_STATE_MPIPL = 0x3, // MPIPL
86 SBE_STATE_RUNTIME = 0x4, // SBE Runtime
87 SBE_STATE_DMT = 0x5, // Dead Man Timer State (transient)
88 SBE_STATE_DUMP = 0x6, // Dumping
89 SBE_STATE_FAILURE = 0x7, // Internal SBE failure
90 SBE_STATE_QUIESCE = 0x8, // Final state - needs SBE reset to get out
91 };
92
93 /* FIFO depth */
94 #define SBEFIFO_FIFO_DEPTH 8
95
96 /* Helpers */
97 #define sbefifo_empty(sts) ((sts) & SBEFIFO_STS_EMPTY)
98 #define sbefifo_full(sts) ((sts) & SBEFIFO_STS_FULL)
99 #define sbefifo_parity_err(sts) ((sts) & SBEFIFO_STS_PARITY_ERR)
100 #define sbefifo_populated(sts) (((sts) & SBEFIFO_STS_ECNT_MASK) >> SBEFIFO_STS_ECNT_SHIFT)
101 #define sbefifo_vacant(sts) (SBEFIFO_FIFO_DEPTH - sbefifo_populated(sts))
102 #define sbefifo_eot_set(sts) (((sts) & SBEFIFO_STS_EOT_MASK) >> SBEFIFO_STS_EOT_SHIFT)
103
104 /* Reset request timeout in ms */
105 #define SBEFIFO_RESET_TIMEOUT 10000
106
107 /* Timeouts for commands in ms */
108 #define SBEFIFO_TIMEOUT_START_CMD 10000
109 #define SBEFIFO_TIMEOUT_IN_CMD 1000
110 #define SBEFIFO_TIMEOUT_START_RSP 10000
111 #define SBEFIFO_TIMEOUT_IN_RSP 1000
112
113 /* Other constants */
114 #define SBEFIFO_MAX_USER_CMD_LEN (0x100000 + PAGE_SIZE)
115 #define SBEFIFO_RESET_MAGIC 0x52534554 /* "RSET" */
116
117 struct sbefifo {
118 uint32_t magic;
119 #define SBEFIFO_MAGIC 0x53424546 /* "SBEF" */
120 struct fsi_device *fsi_dev;
121 struct device dev;
122 struct cdev cdev;
123 struct mutex lock;
124 bool broken;
125 bool dead;
126 bool async_ffdc;
127 };
128
129 struct sbefifo_user {
130 struct sbefifo *sbefifo;
131 struct mutex file_lock;
132 void *cmd_page;
133 void *pending_cmd;
134 size_t pending_len;
135 };
136
137 static DEFINE_MUTEX(sbefifo_ffdc_mutex);
138
139
140 static void __sbefifo_dump_ffdc(struct device *dev, const __be32 *ffdc,
141 size_t ffdc_sz, bool internal)
142 {
143 int pack = 0;
144 #define FFDC_LSIZE 60
145 static char ffdc_line[FFDC_LSIZE];
146 char *p = ffdc_line;
147
148 while (ffdc_sz) {
149 u32 w0, w1, w2, i;
150 if (ffdc_sz < 3) {
151 dev_err(dev, "SBE invalid FFDC package size %zd\n", ffdc_sz);
152 return;
153 }
154 w0 = be32_to_cpu(*(ffdc++));
155 w1 = be32_to_cpu(*(ffdc++));
156 w2 = be32_to_cpu(*(ffdc++));
157 ffdc_sz -= 3;
158 if ((w0 >> 16) != 0xFFDC) {
159 dev_err(dev, "SBE invalid FFDC package signature %08x %08x %08x\n",
160 w0, w1, w2);
161 break;
162 }
163 w0 &= 0xffff;
164 if (w0 > ffdc_sz) {
165 dev_err(dev, "SBE FFDC package len %d words but only %zd remaining\n",
166 w0, ffdc_sz);
167 w0 = ffdc_sz;
168 break;
169 }
170 if (internal) {
171 dev_warn(dev, "+---- SBE FFDC package %d for async err -----+\n",
172 pack++);
173 } else {
174 dev_warn(dev, "+---- SBE FFDC package %d for cmd %02x:%02x -----+\n",
175 pack++, (w1 >> 8) & 0xff, w1 & 0xff);
176 }
177 dev_warn(dev, "| Response code: %08x |\n", w2);
178 dev_warn(dev, "|-------------------------------------------|\n");
179 for (i = 0; i < w0; i++) {
180 if ((i & 3) == 0) {
181 p = ffdc_line;
182 p += sprintf(p, "| %04x:", i << 4);
183 }
184 p += sprintf(p, " %08x", be32_to_cpu(*(ffdc++)));
185 ffdc_sz--;
186 if ((i & 3) == 3 || i == (w0 - 1)) {
187 while ((i & 3) < 3) {
188 p += sprintf(p, " ");
189 i++;
190 }
191 dev_warn(dev, "%s |\n", ffdc_line);
192 }
193 }
194 dev_warn(dev, "+-------------------------------------------+\n");
195 }
196 }
197
198 static void sbefifo_dump_ffdc(struct device *dev, const __be32 *ffdc,
199 size_t ffdc_sz, bool internal)
200 {
201 mutex_lock(&sbefifo_ffdc_mutex);
202 __sbefifo_dump_ffdc(dev, ffdc, ffdc_sz, internal);
203 mutex_unlock(&sbefifo_ffdc_mutex);
204 }
205
206 int sbefifo_parse_status(struct device *dev, u16 cmd, __be32 *response,
207 size_t resp_len, size_t *data_len)
208 {
209 u32 dh, s0, s1;
210 size_t ffdc_sz;
211
212 if (resp_len < 3) {
213 pr_debug("sbefifo: cmd %04x, response too small: %zd\n",
214 cmd, resp_len);
215 return -ENXIO;
216 }
217 dh = be32_to_cpu(response[resp_len - 1]);
218 if (dh > resp_len || dh < 3) {
219 dev_err(dev, "SBE cmd %02x:%02x status offset out of range: %d/%zd\n",
220 cmd >> 8, cmd & 0xff, dh, resp_len);
221 return -ENXIO;
222 }
223 s0 = be32_to_cpu(response[resp_len - dh]);
224 s1 = be32_to_cpu(response[resp_len - dh + 1]);
225 if (((s0 >> 16) != 0xC0DE) || ((s0 & 0xffff) != cmd)) {
226 dev_err(dev, "SBE cmd %02x:%02x, status signature invalid: 0x%08x 0x%08x\n",
227 cmd >> 8, cmd & 0xff, s0, s1);
228 return -ENXIO;
229 }
230 if (s1 != 0) {
231 ffdc_sz = dh - 3;
232 dev_warn(dev, "SBE error cmd %02x:%02x status=%04x:%04x\n",
233 cmd >> 8, cmd & 0xff, s1 >> 16, s1 & 0xffff);
234 if (ffdc_sz)
235 sbefifo_dump_ffdc(dev, &response[resp_len - dh + 2],
236 ffdc_sz, false);
237 }
238 if (data_len)
239 *data_len = resp_len - dh;
240
241 /*
242 * Primary status don't have the top bit set, so can't be confused with
243 * Linux negative error codes, so return the status word whole.
244 */
245 return s1;
246 }
247 EXPORT_SYMBOL_GPL(sbefifo_parse_status);
248
249 static int sbefifo_regr(struct sbefifo *sbefifo, int reg, u32 *word)
250 {
251 __be32 raw_word;
252 int rc;
253
254 rc = fsi_device_read(sbefifo->fsi_dev, reg, &raw_word,
255 sizeof(raw_word));
256 if (rc)
257 return rc;
258
259 *word = be32_to_cpu(raw_word);
260
261 return 0;
262 }
263
264 static int sbefifo_regw(struct sbefifo *sbefifo, int reg, u32 word)
265 {
266 __be32 raw_word = cpu_to_be32(word);
267
268 return fsi_device_write(sbefifo->fsi_dev, reg, &raw_word,
269 sizeof(raw_word));
270 }
271
272 static int sbefifo_check_sbe_state(struct sbefifo *sbefifo)
273 {
274 __be32 raw_word;
275 u32 sbm;
276 int rc;
277
278 rc = fsi_slave_read(sbefifo->fsi_dev->slave, CFAM_GP_MBOX_SBM_ADDR,
279 &raw_word, sizeof(raw_word));
280 if (rc)
281 return rc;
282 sbm = be32_to_cpu(raw_word);
283
284 /* SBE booted at all ? */
285 if (!(sbm & CFAM_SBM_SBE_BOOTED))
286 return -ESHUTDOWN;
287
288 /* Check its state */
289 switch ((sbm & CFAM_SBM_SBE_STATE_MASK) >> CFAM_SBM_SBE_STATE_SHIFT) {
290 case SBE_STATE_UNKNOWN:
291 return -ESHUTDOWN;
292 case SBE_STATE_DMT:
293 return -EBUSY;
294 case SBE_STATE_IPLING:
295 case SBE_STATE_ISTEP:
296 case SBE_STATE_MPIPL:
297 case SBE_STATE_RUNTIME:
298 case SBE_STATE_DUMP: /* Not sure about that one */
299 break;
300 case SBE_STATE_FAILURE:
301 case SBE_STATE_QUIESCE:
302 return -ESHUTDOWN;
303 }
304
305 /* Is there async FFDC available ? Remember it */
306 if (sbm & CFAM_SBM_SBE_ASYNC_FFDC)
307 sbefifo->async_ffdc = true;
308
309 return 0;
310 }
311
312 /* Don't flip endianness of data to/from FIFO, just pass through. */
313 static int sbefifo_down_read(struct sbefifo *sbefifo, __be32 *word)
314 {
315 return fsi_device_read(sbefifo->fsi_dev, SBEFIFO_DOWN, word,
316 sizeof(*word));
317 }
318
319 static int sbefifo_up_write(struct sbefifo *sbefifo, __be32 word)
320 {
321 return fsi_device_write(sbefifo->fsi_dev, SBEFIFO_UP, &word,
322 sizeof(word));
323 }
324
325 static int sbefifo_request_reset(struct sbefifo *sbefifo)
326 {
327 struct device *dev = &sbefifo->fsi_dev->dev;
328 u32 status, timeout;
329 int rc;
330
331 dev_dbg(dev, "Requesting FIFO reset\n");
332
333 /* Mark broken first, will be cleared if reset succeeds */
334 sbefifo->broken = true;
335
336 /* Send reset request */
337 rc = sbefifo_regw(sbefifo, SBEFIFO_UP | SBEFIFO_REQ_RESET, 1);
338 if (rc) {
339 dev_err(dev, "Sending reset request failed, rc=%d\n", rc);
340 return rc;
341 }
342
343 /* Wait for it to complete */
344 for (timeout = 0; timeout < SBEFIFO_RESET_TIMEOUT; timeout++) {
345 rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &status);
346 if (rc) {
347 dev_err(dev, "Failed to read UP fifo status during reset"
348 " , rc=%d\n", rc);
349 return rc;
350 }
351
352 if (!(status & SBEFIFO_STS_RESET_REQ)) {
353 dev_dbg(dev, "FIFO reset done\n");
354 sbefifo->broken = false;
355 return 0;
356 }
357
358 msleep(1);
359 }
360 dev_err(dev, "FIFO reset timed out\n");
361
362 return -ETIMEDOUT;
363 }
364
365 static int sbefifo_cleanup_hw(struct sbefifo *sbefifo)
366 {
367 struct device *dev = &sbefifo->fsi_dev->dev;
368 u32 up_status, down_status;
369 bool need_reset = false;
370 int rc;
371
372 rc = sbefifo_check_sbe_state(sbefifo);
373 if (rc) {
374 dev_dbg(dev, "SBE state=%d\n", rc);
375 return rc;
376 }
377
378 /* If broken, we don't need to look at status, go straight to reset */
379 if (sbefifo->broken)
380 goto do_reset;
381
382 rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &up_status);
383 if (rc) {
384 dev_err(dev, "Cleanup: Reading UP status failed, rc=%d\n", rc);
385
386 /* Will try reset again on next attempt at using it */
387 sbefifo->broken = true;
388 return rc;
389 }
390
391 rc = sbefifo_regr(sbefifo, SBEFIFO_DOWN | SBEFIFO_STS, &down_status);
392 if (rc) {
393 dev_err(dev, "Cleanup: Reading DOWN status failed, rc=%d\n", rc);
394
395 /* Will try reset again on next attempt at using it */
396 sbefifo->broken = true;
397 return rc;
398 }
399
400 /* The FIFO already contains a reset request from the SBE ? */
401 if (down_status & SBEFIFO_STS_RESET_REQ) {
402 dev_info(dev, "Cleanup: FIFO reset request set, resetting\n");
403 rc = sbefifo_regw(sbefifo, SBEFIFO_UP, SBEFIFO_PERFORM_RESET);
404 if (rc) {
405 sbefifo->broken = true;
406 dev_err(dev, "Cleanup: Reset reg write failed, rc=%d\n", rc);
407 return rc;
408 }
409 sbefifo->broken = false;
410 return 0;
411 }
412
413 /* Parity error on either FIFO ? */
414 if ((up_status | down_status) & SBEFIFO_STS_PARITY_ERR)
415 need_reset = true;
416
417 /* Either FIFO not empty ? */
418 if (!((up_status & down_status) & SBEFIFO_STS_EMPTY))
419 need_reset = true;
420
421 if (!need_reset)
422 return 0;
423
424 dev_info(dev, "Cleanup: FIFO not clean (up=0x%08x down=0x%08x)\n",
425 up_status, down_status);
426
427 do_reset:
428
429 /* Mark broken, will be cleared if/when reset succeeds */
430 return sbefifo_request_reset(sbefifo);
431 }
432
433 static int sbefifo_wait(struct sbefifo *sbefifo, bool up,
434 u32 *status, unsigned long timeout)
435 {
436 struct device *dev = &sbefifo->fsi_dev->dev;
437 unsigned long end_time;
438 bool ready = false;
439 u32 addr, sts = 0;
440 int rc;
441
442 dev_vdbg(dev, "Wait on %s fifo...\n", up ? "up" : "down");
443
444 addr = (up ? SBEFIFO_UP : SBEFIFO_DOWN) | SBEFIFO_STS;
445
446 end_time = jiffies + timeout;
447 while (!time_after(jiffies, end_time)) {
448 cond_resched();
449 rc = sbefifo_regr(sbefifo, addr, &sts);
450 if (rc < 0) {
451 dev_err(dev, "FSI error %d reading status register\n", rc);
452 return rc;
453 }
454 if (!up && sbefifo_parity_err(sts)) {
455 dev_err(dev, "Parity error in DOWN FIFO\n");
456 return -ENXIO;
457 }
458 ready = !(up ? sbefifo_full(sts) : sbefifo_empty(sts));
459 if (ready)
460 break;
461 }
462 if (!ready) {
463 dev_err(dev, "%s FIFO Timeout ! status=%08x\n", up ? "UP" : "DOWN", sts);
464 return -ETIMEDOUT;
465 }
466 dev_vdbg(dev, "End of wait status: %08x\n", sts);
467
468 *status = sts;
469
470 return 0;
471 }
472
473 static int sbefifo_send_command(struct sbefifo *sbefifo,
474 const __be32 *command, size_t cmd_len)
475 {
476 struct device *dev = &sbefifo->fsi_dev->dev;
477 size_t len, chunk, vacant = 0, remaining = cmd_len;
478 unsigned long timeout;
479 u32 status;
480 int rc;
481
482 dev_vdbg(dev, "sending command (%zd words, cmd=%04x)\n",
483 cmd_len, be32_to_cpu(command[1]));
484
485 /* As long as there's something to send */
486 timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_START_CMD);
487 while (remaining) {
488 /* Wait for room in the FIFO */
489 rc = sbefifo_wait(sbefifo, true, &status, timeout);
490 if (rc < 0)
491 return rc;
492 timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_IN_CMD);
493
494 vacant = sbefifo_vacant(status);
495 len = chunk = min(vacant, remaining);
496
497 dev_vdbg(dev, " status=%08x vacant=%zd chunk=%zd\n",
498 status, vacant, chunk);
499
500 /* Write as much as we can */
501 while (len--) {
502 rc = sbefifo_up_write(sbefifo, *(command++));
503 if (rc) {
504 dev_err(dev, "FSI error %d writing UP FIFO\n", rc);
505 return rc;
506 }
507 }
508 remaining -= chunk;
509 vacant -= chunk;
510 }
511
512 /* If there's no room left, wait for some to write EOT */
513 if (!vacant) {
514 rc = sbefifo_wait(sbefifo, true, &status, timeout);
515 if (rc)
516 return rc;
517 }
518
519 /* Send an EOT */
520 rc = sbefifo_regw(sbefifo, SBEFIFO_UP | SBEFIFO_EOT_RAISE, 0);
521 if (rc)
522 dev_err(dev, "FSI error %d writing EOT\n", rc);
523 return rc;
524 }
525
526 static int sbefifo_read_response(struct sbefifo *sbefifo, struct iov_iter *response)
527 {
528 struct device *dev = &sbefifo->fsi_dev->dev;
529 u32 status, eot_set;
530 unsigned long timeout;
531 bool overflow = false;
532 __be32 data;
533 size_t len;
534 int rc;
535
536 dev_vdbg(dev, "reading response, buflen = %zd\n", iov_iter_count(response));
537
538 timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_START_RSP);
539 for (;;) {
540 /* Grab FIFO status (this will handle parity errors) */
541 rc = sbefifo_wait(sbefifo, false, &status, timeout);
542 if (rc < 0)
543 return rc;
544 timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_IN_RSP);
545
546 /* Decode status */
547 len = sbefifo_populated(status);
548 eot_set = sbefifo_eot_set(status);
549
550 dev_vdbg(dev, " chunk size %zd eot_set=0x%x\n", len, eot_set);
551
552 /* Go through the chunk */
553 while(len--) {
554 /* Read the data */
555 rc = sbefifo_down_read(sbefifo, &data);
556 if (rc < 0)
557 return rc;
558
559 /* Was it an EOT ? */
560 if (eot_set & 0x80) {
561 /*
562 * There should be nothing else in the FIFO,
563 * if there is, mark broken, this will force
564 * a reset on next use, but don't fail the
565 * command.
566 */
567 if (len) {
568 dev_warn(dev, "FIFO read hit"
569 " EOT with still %zd data\n",
570 len);
571 sbefifo->broken = true;
572 }
573
574 /* We are done */
575 rc = sbefifo_regw(sbefifo,
576 SBEFIFO_DOWN | SBEFIFO_EOT_ACK, 0);
577
578 /*
579 * If that write fail, still complete the request but mark
580 * the fifo as broken for subsequent reset (not much else
581 * we can do here).
582 */
583 if (rc) {
584 dev_err(dev, "FSI error %d ack'ing EOT\n", rc);
585 sbefifo->broken = true;
586 }
587
588 /* Tell whether we overflowed */
589 return overflow ? -EOVERFLOW : 0;
590 }
591
592 /* Store it if there is room */
593 if (iov_iter_count(response) >= sizeof(__be32)) {
594 if (copy_to_iter(&data, sizeof(__be32), response) < sizeof(__be32))
595 return -EFAULT;
596 } else {
597 dev_vdbg(dev, "Response overflowed !\n");
598
599 overflow = true;
600 }
601
602 /* Next EOT bit */
603 eot_set <<= 1;
604 }
605 }
606 /* Shouldn't happen */
607 return -EIO;
608 }
609
610 static int sbefifo_do_command(struct sbefifo *sbefifo,
611 const __be32 *command, size_t cmd_len,
612 struct iov_iter *response)
613 {
614 /* Try sending the command */
615 int rc = sbefifo_send_command(sbefifo, command, cmd_len);
616 if (rc)
617 return rc;
618
619 /* Now, get the response */
620 return sbefifo_read_response(sbefifo, response);
621 }
622
623 static void sbefifo_collect_async_ffdc(struct sbefifo *sbefifo)
624 {
625 struct device *dev = &sbefifo->fsi_dev->dev;
626 struct iov_iter ffdc_iter;
627 struct kvec ffdc_iov;
628 __be32 *ffdc;
629 size_t ffdc_sz;
630 __be32 cmd[2];
631 int rc;
632
633 sbefifo->async_ffdc = false;
634 ffdc = vmalloc(SBEFIFO_MAX_FFDC_SIZE);
635 if (!ffdc) {
636 dev_err(dev, "Failed to allocate SBE FFDC buffer\n");
637 return;
638 }
639 ffdc_iov.iov_base = ffdc;
640 ffdc_iov.iov_len = SBEFIFO_MAX_FFDC_SIZE;
641 iov_iter_kvec(&ffdc_iter, WRITE, &ffdc_iov, 1, SBEFIFO_MAX_FFDC_SIZE);
642 cmd[0] = cpu_to_be32(2);
643 cmd[1] = cpu_to_be32(SBEFIFO_CMD_GET_SBE_FFDC);
644 rc = sbefifo_do_command(sbefifo, cmd, 2, &ffdc_iter);
645 if (rc != 0) {
646 dev_err(dev, "Error %d retrieving SBE FFDC\n", rc);
647 goto bail;
648 }
649 ffdc_sz = SBEFIFO_MAX_FFDC_SIZE - iov_iter_count(&ffdc_iter);
650 ffdc_sz /= sizeof(__be32);
651 rc = sbefifo_parse_status(dev, SBEFIFO_CMD_GET_SBE_FFDC, ffdc,
652 ffdc_sz, &ffdc_sz);
653 if (rc != 0) {
654 dev_err(dev, "Error %d decoding SBE FFDC\n", rc);
655 goto bail;
656 }
657 if (ffdc_sz > 0)
658 sbefifo_dump_ffdc(dev, ffdc, ffdc_sz, true);
659 bail:
660 vfree(ffdc);
661
662 }
663
664 static int __sbefifo_submit(struct sbefifo *sbefifo,
665 const __be32 *command, size_t cmd_len,
666 struct iov_iter *response)
667 {
668 struct device *dev = &sbefifo->fsi_dev->dev;
669 int rc;
670
671 if (sbefifo->dead)
672 return -ENODEV;
673
674 if (cmd_len < 2 || be32_to_cpu(command[0]) != cmd_len) {
675 dev_vdbg(dev, "Invalid command len %zd (header: %d)\n",
676 cmd_len, be32_to_cpu(command[0]));
677 return -EINVAL;
678 }
679
680 /* First ensure the HW is in a clean state */
681 rc = sbefifo_cleanup_hw(sbefifo);
682 if (rc)
683 return rc;
684
685 /* Look for async FFDC first if any */
686 if (sbefifo->async_ffdc)
687 sbefifo_collect_async_ffdc(sbefifo);
688
689 rc = sbefifo_do_command(sbefifo, command, cmd_len, response);
690 if (rc != 0 && rc != -EOVERFLOW)
691 goto fail;
692 return rc;
693 fail:
694 /*
695 * On failure, attempt a reset. Ignore the result, it will mark
696 * the fifo broken if the reset fails
697 */
698 sbefifo_request_reset(sbefifo);
699
700 /* Return original error */
701 return rc;
702 }
703
704 /**
705 * sbefifo_submit() - Submit and SBE fifo command and receive response
706 * @dev: The sbefifo device
707 * @command: The raw command data
708 * @cmd_len: The command size (in 32-bit words)
709 * @response: The output response buffer
710 * @resp_len: In: Response buffer size, Out: Response size
711 *
712 * This will perform the entire operation. If the reponse buffer
713 * overflows, returns -EOVERFLOW
714 */
715 int sbefifo_submit(struct device *dev, const __be32 *command, size_t cmd_len,
716 __be32 *response, size_t *resp_len)
717 {
718 struct sbefifo *sbefifo;
719 struct iov_iter resp_iter;
720 struct kvec resp_iov;
721 size_t rbytes;
722 int rc;
723
724 if (!dev)
725 return -ENODEV;
726 sbefifo = dev_get_drvdata(dev);
727 if (!sbefifo)
728 return -ENODEV;
729 if (WARN_ON_ONCE(sbefifo->magic != SBEFIFO_MAGIC))
730 return -ENODEV;
731 if (!resp_len || !command || !response)
732 return -EINVAL;
733
734 /* Prepare iov iterator */
735 rbytes = (*resp_len) * sizeof(__be32);
736 resp_iov.iov_base = response;
737 resp_iov.iov_len = rbytes;
738 iov_iter_kvec(&resp_iter, WRITE, &resp_iov, 1, rbytes);
739
740 /* Perform the command */
741 mutex_lock(&sbefifo->lock);
742 rc = __sbefifo_submit(sbefifo, command, cmd_len, &resp_iter);
743 mutex_unlock(&sbefifo->lock);
744
745 /* Extract the response length */
746 rbytes -= iov_iter_count(&resp_iter);
747 *resp_len = rbytes / sizeof(__be32);
748
749 return rc;
750 }
751 EXPORT_SYMBOL_GPL(sbefifo_submit);
752
753 /*
754 * Char device interface
755 */
756
757 static void sbefifo_release_command(struct sbefifo_user *user)
758 {
759 if (is_vmalloc_addr(user->pending_cmd))
760 vfree(user->pending_cmd);
761 user->pending_cmd = NULL;
762 user->pending_len = 0;
763 }
764
765 static int sbefifo_user_open(struct inode *inode, struct file *file)
766 {
767 struct sbefifo *sbefifo = container_of(inode->i_cdev, struct sbefifo, cdev);
768 struct sbefifo_user *user;
769
770 user = kzalloc(sizeof(struct sbefifo_user), GFP_KERNEL);
771 if (!user)
772 return -ENOMEM;
773
774 file->private_data = user;
775 user->sbefifo = sbefifo;
776 user->cmd_page = (void *)__get_free_page(GFP_KERNEL);
777 if (!user->cmd_page) {
778 kfree(user);
779 return -ENOMEM;
780 }
781 mutex_init(&user->file_lock);
782
783 return 0;
784 }
785
786 static ssize_t sbefifo_user_read(struct file *file, char __user *buf,
787 size_t len, loff_t *offset)
788 {
789 struct sbefifo_user *user = file->private_data;
790 struct sbefifo *sbefifo;
791 struct iov_iter resp_iter;
792 struct iovec resp_iov;
793 size_t cmd_len;
794 int rc;
795
796 if (!user)
797 return -EINVAL;
798 sbefifo = user->sbefifo;
799 if (len & 3)
800 return -EINVAL;
801
802 mutex_lock(&user->file_lock);
803
804 /* Cronus relies on -EAGAIN after a short read */
805 if (user->pending_len == 0) {
806 rc = -EAGAIN;
807 goto bail;
808 }
809 if (user->pending_len < 8) {
810 rc = -EINVAL;
811 goto bail;
812 }
813 cmd_len = user->pending_len >> 2;
814
815 /* Prepare iov iterator */
816 resp_iov.iov_base = buf;
817 resp_iov.iov_len = len;
818 iov_iter_init(&resp_iter, WRITE, &resp_iov, 1, len);
819
820 /* Perform the command */
821 mutex_lock(&sbefifo->lock);
822 rc = __sbefifo_submit(sbefifo, user->pending_cmd, cmd_len, &resp_iter);
823 mutex_unlock(&sbefifo->lock);
824 if (rc < 0)
825 goto bail;
826
827 /* Extract the response length */
828 rc = len - iov_iter_count(&resp_iter);
829 bail:
830 sbefifo_release_command(user);
831 mutex_unlock(&user->file_lock);
832 return rc;
833 }
834
835 static ssize_t sbefifo_user_write(struct file *file, const char __user *buf,
836 size_t len, loff_t *offset)
837 {
838 struct sbefifo_user *user = file->private_data;
839 struct sbefifo *sbefifo;
840 int rc = len;
841
842 if (!user)
843 return -EINVAL;
844 sbefifo = user->sbefifo;
845 if (len > SBEFIFO_MAX_USER_CMD_LEN)
846 return -EINVAL;
847 if (len & 3)
848 return -EINVAL;
849
850 mutex_lock(&user->file_lock);
851
852 /* Can we use the pre-allocate buffer ? If not, allocate */
853 if (len <= PAGE_SIZE)
854 user->pending_cmd = user->cmd_page;
855 else
856 user->pending_cmd = vmalloc(len);
857 if (!user->pending_cmd) {
858 rc = -ENOMEM;
859 goto bail;
860 }
861
862 /* Copy the command into the staging buffer */
863 if (copy_from_user(user->pending_cmd, buf, len)) {
864 rc = -EFAULT;
865 goto bail;
866 }
867
868 /* Check for the magic reset command */
869 if (len == 4 && be32_to_cpu(*(__be32 *)user->pending_cmd) ==
870 SBEFIFO_RESET_MAGIC) {
871
872 /* Clear out any pending command */
873 user->pending_len = 0;
874
875 /* Trigger reset request */
876 mutex_lock(&sbefifo->lock);
877 rc = sbefifo_request_reset(user->sbefifo);
878 mutex_unlock(&sbefifo->lock);
879 if (rc == 0)
880 rc = 4;
881 goto bail;
882 }
883
884 /* Update the staging buffer size */
885 user->pending_len = len;
886 bail:
887 if (!user->pending_len)
888 sbefifo_release_command(user);
889
890 mutex_unlock(&user->file_lock);
891
892 /* And that's it, we'll issue the command on a read */
893 return rc;
894 }
895
896 static int sbefifo_user_release(struct inode *inode, struct file *file)
897 {
898 struct sbefifo_user *user = file->private_data;
899
900 if (!user)
901 return -EINVAL;
902
903 sbefifo_release_command(user);
904 free_page((unsigned long)user->cmd_page);
905 kfree(user);
906
907 return 0;
908 }
909
910 static const struct file_operations sbefifo_fops = {
911 .owner = THIS_MODULE,
912 .open = sbefifo_user_open,
913 .read = sbefifo_user_read,
914 .write = sbefifo_user_write,
915 .release = sbefifo_user_release,
916 };
917
918 static void sbefifo_free(struct device *dev)
919 {
920 struct sbefifo *sbefifo = container_of(dev, struct sbefifo, dev);
921
922 put_device(&sbefifo->fsi_dev->dev);
923 kfree(sbefifo);
924 }
925
926 /*
927 * Probe/remove
928 */
929
930 static int sbefifo_probe(struct device *dev)
931 {
932 struct fsi_device *fsi_dev = to_fsi_dev(dev);
933 struct sbefifo *sbefifo;
934 struct device_node *np;
935 struct platform_device *child;
936 char child_name[32];
937 int rc, didx, child_idx = 0;
938
939 dev_dbg(dev, "Found sbefifo device\n");
940
941 sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL);
942 if (!sbefifo)
943 return -ENOMEM;
944
945 /* Grab a reference to the device (parent of our cdev), we'll drop it later */
946 if (!get_device(dev)) {
947 kfree(sbefifo);
948 return -ENODEV;
949 }
950
951 sbefifo->magic = SBEFIFO_MAGIC;
952 sbefifo->fsi_dev = fsi_dev;
953 dev_set_drvdata(dev, sbefifo);
954 mutex_init(&sbefifo->lock);
955
956 /*
957 * Try cleaning up the FIFO. If this fails, we still register the
958 * driver and will try cleaning things up again on the next access.
959 */
960 rc = sbefifo_cleanup_hw(sbefifo);
961 if (rc && rc != -ESHUTDOWN)
962 dev_err(dev, "Initial HW cleanup failed, will retry later\n");
963
964 /* Create chardev for userspace access */
965 sbefifo->dev.type = &fsi_cdev_type;
966 sbefifo->dev.parent = dev;
967 sbefifo->dev.release = sbefifo_free;
968 device_initialize(&sbefifo->dev);
969
970 /* Allocate a minor in the FSI space */
971 rc = fsi_get_new_minor(fsi_dev, fsi_dev_sbefifo, &sbefifo->dev.devt, &didx);
972 if (rc)
973 goto err;
974
975 dev_set_name(&sbefifo->dev, "sbefifo%d", didx);
976 cdev_init(&sbefifo->cdev, &sbefifo_fops);
977 rc = cdev_device_add(&sbefifo->cdev, &sbefifo->dev);
978 if (rc) {
979 dev_err(dev, "Error %d creating char device %s\n",
980 rc, dev_name(&sbefifo->dev));
981 goto err_free_minor;
982 }
983
984 /* Create platform devs for dts child nodes (occ, etc) */
985 for_each_available_child_of_node(dev->of_node, np) {
986 snprintf(child_name, sizeof(child_name), "%s-dev%d",
987 dev_name(&sbefifo->dev), child_idx++);
988 child = of_platform_device_create(np, child_name, dev);
989 if (!child)
990 dev_warn(dev, "failed to create child %s dev\n",
991 child_name);
992 }
993
994 return 0;
995 err_free_minor:
996 fsi_free_minor(sbefifo->dev.devt);
997 err:
998 put_device(&sbefifo->dev);
999 return rc;
1000 }
1001
1002 static int sbefifo_unregister_child(struct device *dev, void *data)
1003 {
1004 struct platform_device *child = to_platform_device(dev);
1005
1006 of_device_unregister(child);
1007 if (dev->of_node)
1008 of_node_clear_flag(dev->of_node, OF_POPULATED);
1009
1010 return 0;
1011 }
1012
1013 static int sbefifo_remove(struct device *dev)
1014 {
1015 struct sbefifo *sbefifo = dev_get_drvdata(dev);
1016
1017 dev_dbg(dev, "Removing sbefifo device...\n");
1018
1019 mutex_lock(&sbefifo->lock);
1020 sbefifo->dead = true;
1021 mutex_unlock(&sbefifo->lock);
1022
1023 cdev_device_del(&sbefifo->cdev, &sbefifo->dev);
1024 fsi_free_minor(sbefifo->dev.devt);
1025 device_for_each_child(dev, NULL, sbefifo_unregister_child);
1026 put_device(&sbefifo->dev);
1027
1028 return 0;
1029 }
1030
1031 static const struct fsi_device_id sbefifo_ids[] = {
1032 {
1033 .engine_type = FSI_ENGID_SBE,
1034 .version = FSI_VERSION_ANY,
1035 },
1036 { 0 }
1037 };
1038
1039 static struct fsi_driver sbefifo_drv = {
1040 .id_table = sbefifo_ids,
1041 .drv = {
1042 .name = DEVICE_NAME,
1043 .bus = &fsi_bus_type,
1044 .probe = sbefifo_probe,
1045 .remove = sbefifo_remove,
1046 }
1047 };
1048
1049 static int sbefifo_init(void)
1050 {
1051 return fsi_driver_register(&sbefifo_drv);
1052 }
1053
1054 static void sbefifo_exit(void)
1055 {
1056 fsi_driver_unregister(&sbefifo_drv);
1057 }
1058
1059 module_init(sbefifo_init);
1060 module_exit(sbefifo_exit);
1061 MODULE_LICENSE("GPL");
1062 MODULE_AUTHOR("Brad Bishop <bradleyb@fuzziesquirrel.com>");
1063 MODULE_AUTHOR("Eddie James <eajames@linux.vnet.ibm.com>");
1064 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
1065 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
1066 MODULE_DESCRIPTION("Linux device interface to the POWER Self Boot Engine");
Ubuntu Hirsute Linux kernel mirror