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