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         unsigned long end_time;
 329         u32 status;
 330         int rc;
 331
 332         dev_dbg(dev, "Requesting FIFO reset\n");
 333
 334         /* Mark broken first, will be cleared if reset succeeds */
 335         sbefifo->broken = true;
 336
 337         /* Send reset request */
 338         rc = sbefifo_regw(sbefifo, SBEFIFO_UP | SBEFIFO_REQ_RESET, 1);
 339         if (rc) {
 340                 dev_err(dev, "Sending reset request failed, rc=%d\n", rc);
 341                 return rc;
 342         }
 343
 344         /* Wait for it to complete */
 345         end_time = jiffies + msecs_to_jiffies(SBEFIFO_RESET_TIMEOUT);
 346         while (!time_after(jiffies, end_time)) {
 347                 rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &status);
 348                 if (rc) {
 349                         dev_err(dev, "Failed to read UP fifo status during reset"
 350                                 " , rc=%d\n", rc);
 351                         return rc;
 352                 }
 353
 354                 if (!(status & SBEFIFO_STS_RESET_REQ)) {
 355                         dev_dbg(dev, "FIFO reset done\n");
 356                         sbefifo->broken = false;
 357                         return 0;
 358                 }
 359
 360                 cond_resched();
 361         }
 362         dev_err(dev, "FIFO reset timed out\n");
 363
 364         return -ETIMEDOUT;
 365 }
 366
 367 static int sbefifo_cleanup_hw(struct sbefifo *sbefifo)
 368 {
 369         struct device *dev = &sbefifo->fsi_dev->dev;
 370         u32 up_status, down_status;
 371         bool need_reset = false;
 372         int rc;
 373
 374         rc = sbefifo_check_sbe_state(sbefifo);
 375         if (rc) {
 376                 dev_dbg(dev, "SBE state=%d\n", rc);
 377                 return rc;
 378         }
 379
 380         /* If broken, we don't need to look at status, go straight to reset */
 381         if (sbefifo->broken)
 382                 goto do_reset;
 383
 384         rc = sbefifo_regr(sbefifo, SBEFIFO_UP | SBEFIFO_STS, &up_status);
 385         if (rc) {
 386                 dev_err(dev, "Cleanup: Reading UP status failed, rc=%d\n", rc);
 387
 388                 /* Will try reset again on next attempt at using it */
 389                 sbefifo->broken = true;
 390                 return rc;
 391         }
 392
 393         rc = sbefifo_regr(sbefifo, SBEFIFO_DOWN | SBEFIFO_STS, &down_status);
 394         if (rc) {
 395                 dev_err(dev, "Cleanup: Reading DOWN status failed, rc=%d\n", rc);
 396
 397                 /* Will try reset again on next attempt at using it */
 398                 sbefifo->broken = true;
 399                 return rc;
 400         }
 401
 402         /* The FIFO already contains a reset request from the SBE ? */
 403         if (down_status & SBEFIFO_STS_RESET_REQ) {
 404                 dev_info(dev, "Cleanup: FIFO reset request set, resetting\n");
 405                 rc = sbefifo_regw(sbefifo, SBEFIFO_DOWN, SBEFIFO_PERFORM_RESET);
 406                 if (rc) {
 407                         sbefifo->broken = true;
 408                         dev_err(dev, "Cleanup: Reset reg write failed, rc=%d\n", rc);
 409                         return rc;
 410                 }
 411                 sbefifo->broken = false;
 412                 return 0;
 413         }
 414
 415         /* Parity error on either FIFO ? */
 416         if ((up_status | down_status) & SBEFIFO_STS_PARITY_ERR)
 417                 need_reset = true;
 418
 419         /* Either FIFO not empty ? */
 420         if (!((up_status & down_status) & SBEFIFO_STS_EMPTY))
 421                 need_reset = true;
 422
 423         if (!need_reset)
 424                 return 0;
 425
 426         dev_info(dev, "Cleanup: FIFO not clean (up=0x%08x down=0x%08x)\n",
 427                  up_status, down_status);
 428
 429  do_reset:
 430
 431         /* Mark broken, will be cleared if/when reset succeeds */
 432         return sbefifo_request_reset(sbefifo);
 433 }
 434
 435 static int sbefifo_wait(struct sbefifo *sbefifo, bool up,
 436                         u32 *status, unsigned long timeout)
 437 {
 438         struct device *dev = &sbefifo->fsi_dev->dev;
 439         unsigned long end_time;
 440         bool ready = false;
 441         u32 addr, sts = 0;
 442         int rc;
 443
 444         dev_vdbg(dev, "Wait on %s fifo...\n", up ? "up" : "down");
 445
 446         addr = (up ? SBEFIFO_UP : SBEFIFO_DOWN) | SBEFIFO_STS;
 447
 448         end_time = jiffies + timeout;
 449         while (!time_after(jiffies, end_time)) {
 450                 cond_resched();
 451                 rc = sbefifo_regr(sbefifo, addr, &sts);
 452                 if (rc < 0) {
 453                         dev_err(dev, "FSI error %d reading status register\n", rc);
 454                         return rc;
 455                 }
 456                 if (!up && sbefifo_parity_err(sts)) {
 457                         dev_err(dev, "Parity error in DOWN FIFO\n");
 458                         return -ENXIO;
 459                 }
 460                 ready = !(up ? sbefifo_full(sts) : sbefifo_empty(sts));
 461                 if (ready)
 462                         break;
 463         }
 464         if (!ready) {
 465                 dev_err(dev, "%s FIFO Timeout ! status=%08x\n", up ? "UP" : "DOWN", sts);
 466                 return -ETIMEDOUT;
 467         }
 468         dev_vdbg(dev, "End of wait status: %08x\n", sts);
 469
 470         *status = sts;
 471
 472         return 0;
 473 }
 474
 475 static int sbefifo_send_command(struct sbefifo *sbefifo,
 476                                 const __be32 *command, size_t cmd_len)
 477 {
 478         struct device *dev = &sbefifo->fsi_dev->dev;
 479         size_t len, chunk, vacant = 0, remaining = cmd_len;
 480         unsigned long timeout;
 481         u32 status;
 482         int rc;
 483
 484         dev_vdbg(dev, "sending command (%zd words, cmd=%04x)\n",
 485                  cmd_len, be32_to_cpu(command[1]));
 486
 487         /* As long as there's something to send */
 488         timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_START_CMD);
 489         while (remaining) {
 490                 /* Wait for room in the FIFO */
 491                 rc = sbefifo_wait(sbefifo, true, &status, timeout);
 492                 if (rc < 0)
 493                         return rc;
 494                 timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_IN_CMD);
 495
 496                 vacant = sbefifo_vacant(status);
 497                 len = chunk = min(vacant, remaining);
 498
 499                 dev_vdbg(dev, "  status=%08x vacant=%zd chunk=%zd\n",
 500                          status, vacant, chunk);
 501
 502                 /* Write as much as we can */
 503                 while (len--) {
 504                         rc = sbefifo_up_write(sbefifo, *(command++));
 505                         if (rc) {
 506                                 dev_err(dev, "FSI error %d writing UP FIFO\n", rc);
 507                                 return rc;
 508                         }
 509                 }
 510                 remaining -= chunk;
 511                 vacant -= chunk;
 512         }
 513
 514         /* If there's no room left, wait for some to write EOT */
 515         if (!vacant) {
 516                 rc = sbefifo_wait(sbefifo, true, &status, timeout);
 517                 if (rc)
 518                         return rc;
 519         }
 520
 521         /* Send an EOT */
 522         rc = sbefifo_regw(sbefifo, SBEFIFO_UP | SBEFIFO_EOT_RAISE, 0);
 523         if (rc)
 524                 dev_err(dev, "FSI error %d writing EOT\n", rc);
 525         return rc;
 526 }
 527
 528 static int sbefifo_read_response(struct sbefifo *sbefifo, struct iov_iter *response)
 529 {
 530         struct device *dev = &sbefifo->fsi_dev->dev;
 531         u32 status, eot_set;
 532         unsigned long timeout;
 533         bool overflow = false;
 534         __be32 data;
 535         size_t len;
 536         int rc;
 537
 538         dev_vdbg(dev, "reading response, buflen = %zd\n", iov_iter_count(response));
 539
 540         timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_START_RSP);
 541         for (;;) {
 542                 /* Grab FIFO status (this will handle parity errors) */
 543                 rc = sbefifo_wait(sbefifo, false, &status, timeout);
 544                 if (rc < 0)
 545                         return rc;
 546                 timeout = msecs_to_jiffies(SBEFIFO_TIMEOUT_IN_RSP);
 547
 548                 /* Decode status */
 549                 len = sbefifo_populated(status);
 550                 eot_set = sbefifo_eot_set(status);
 551
 552                 dev_vdbg(dev, "  chunk size %zd eot_set=0x%x\n", len, eot_set);
 553
 554                 /* Go through the chunk */
 555                 while(len--) {
 556                         /* Read the data */
 557                         rc = sbefifo_down_read(sbefifo, &data);
 558                         if (rc < 0)
 559                                 return rc;
 560
 561                         /* Was it an EOT ? */
 562                         if (eot_set & 0x80) {
 563                                 /*
 564                                  * There should be nothing else in the FIFO,
 565                                  * if there is, mark broken, this will force
 566                                  * a reset on next use, but don't fail the
 567                                  * command.
 568                                  */
 569                                 if (len) {
 570                                         dev_warn(dev, "FIFO read hit"
 571                                                  " EOT with still %zd data\n",
 572                                                  len);
 573                                         sbefifo->broken = true;
 574                                 }
 575
 576                                 /* We are done */
 577                                 rc = sbefifo_regw(sbefifo,
 578                                                   SBEFIFO_DOWN | SBEFIFO_EOT_ACK, 0);
 579
 580                                 /*
 581                                  * If that write fail, still complete the request but mark
 582                                  * the fifo as broken for subsequent reset (not much else
 583                                  * we can do here).
 584                                  */
 585                                 if (rc) {
 586                                         dev_err(dev, "FSI error %d ack'ing EOT\n", rc);
 587                                         sbefifo->broken = true;
 588                                 }
 589
 590                                 /* Tell whether we overflowed */
 591                                 return overflow ? -EOVERFLOW : 0;
 592                         }
 593
 594                         /* Store it if there is room */
 595                         if (iov_iter_count(response) >= sizeof(__be32)) {
 596                                 if (copy_to_iter(&data, sizeof(__be32), response) < sizeof(__be32))
 597                                         return -EFAULT;
 598                         } else {
 599                                 dev_vdbg(dev, "Response overflowed !\n");
 600
 601                                 overflow = true;
 602                         }
 603
 604                         /* Next EOT bit */
 605                         eot_set <<= 1;
 606                 }
 607         }
 608         /* Shouldn't happen */
 609         return -EIO;
 610 }
 611
 612 static int sbefifo_do_command(struct sbefifo *sbefifo,
 613                               const __be32 *command, size_t cmd_len,
 614                               struct iov_iter *response)
 615 {
 616         /* Try sending the command */
 617         int rc = sbefifo_send_command(sbefifo, command, cmd_len);
 618         if (rc)
 619                 return rc;
 620
 621         /* Now, get the response */
 622         return sbefifo_read_response(sbefifo, response);
 623 }
 624
 625 static void sbefifo_collect_async_ffdc(struct sbefifo *sbefifo)
 626 {
 627         struct device *dev = &sbefifo->fsi_dev->dev;
 628         struct iov_iter ffdc_iter;
 629         struct kvec ffdc_iov;
 630         __be32 *ffdc;
 631         size_t ffdc_sz;
 632         __be32 cmd[2];
 633         int rc;
 634
 635         sbefifo->async_ffdc = false;
 636         ffdc = vmalloc(SBEFIFO_MAX_FFDC_SIZE);
 637         if (!ffdc) {
 638                 dev_err(dev, "Failed to allocate SBE FFDC buffer\n");
 639                 return;
 640         }
 641         ffdc_iov.iov_base = ffdc;
 642         ffdc_iov.iov_len = SBEFIFO_MAX_FFDC_SIZE;
 643         iov_iter_kvec(&ffdc_iter, WRITE, &ffdc_iov, 1, SBEFIFO_MAX_FFDC_SIZE);
 644         cmd[0] = cpu_to_be32(2);
 645         cmd[1] = cpu_to_be32(SBEFIFO_CMD_GET_SBE_FFDC);
 646         rc = sbefifo_do_command(sbefifo, cmd, 2, &ffdc_iter);
 647         if (rc != 0) {
 648                 dev_err(dev, "Error %d retrieving SBE FFDC\n", rc);
 649                 goto bail;
 650         }
 651         ffdc_sz = SBEFIFO_MAX_FFDC_SIZE - iov_iter_count(&ffdc_iter);
 652         ffdc_sz /= sizeof(__be32);
 653         rc = sbefifo_parse_status(dev, SBEFIFO_CMD_GET_SBE_FFDC, ffdc,
 654                                   ffdc_sz, &ffdc_sz);
 655         if (rc != 0) {
 656                 dev_err(dev, "Error %d decoding SBE FFDC\n", rc);
 657                 goto bail;
 658         }
 659         if (ffdc_sz > 0)
 660                 sbefifo_dump_ffdc(dev, ffdc, ffdc_sz, true);
 661  bail:
 662         vfree(ffdc);
 663
 664 }
 665
 666 static int __sbefifo_submit(struct sbefifo *sbefifo,
 667                             const __be32 *command, size_t cmd_len,
 668                             struct iov_iter *response)
 669 {
 670         struct device *dev = &sbefifo->fsi_dev->dev;
 671         int rc;
 672
 673         if (sbefifo->dead)
 674                 return -ENODEV;
 675
 676         if (cmd_len < 2 || be32_to_cpu(command[0]) != cmd_len) {
 677                 dev_vdbg(dev, "Invalid command len %zd (header: %d)\n",
 678                          cmd_len, be32_to_cpu(command[0]));
 679                 return -EINVAL;
 680         }
 681
 682         /* First ensure the HW is in a clean state */
 683         rc = sbefifo_cleanup_hw(sbefifo);
 684         if (rc)
 685                 return rc;
 686
 687         /* Look for async FFDC first if any */
 688         if (sbefifo->async_ffdc)
 689                 sbefifo_collect_async_ffdc(sbefifo);
 690
 691         rc = sbefifo_do_command(sbefifo, command, cmd_len, response);
 692         if (rc != 0 && rc != -EOVERFLOW)
 693                 goto fail;
 694         return rc;
 695  fail:
 696         /*
 697          * On failure, attempt a reset. Ignore the result, it will mark
 698          * the fifo broken if the reset fails
 699          */
 700         sbefifo_request_reset(sbefifo);
 701
 702         /* Return original error */
 703         return rc;
 704 }
 705
 706 /**
 707  * sbefifo_submit() - Submit and SBE fifo command and receive response
 708  * @dev: The sbefifo device
 709  * @command: The raw command data
 710  * @cmd_len: The command size (in 32-bit words)
 711  * @response: The output response buffer
 712  * @resp_len: In: Response buffer size, Out: Response size
 713  *
 714  * This will perform the entire operation. If the reponse buffer
 715  * overflows, returns -EOVERFLOW
 716  */
 717 int sbefifo_submit(struct device *dev, const __be32 *command, size_t cmd_len,
 718                    __be32 *response, size_t *resp_len)
 719 {
 720         struct sbefifo *sbefifo;
 721         struct iov_iter resp_iter;
 722         struct kvec resp_iov;
 723         size_t rbytes;
 724         int rc;
 725
 726         if (!dev)
 727                 return -ENODEV;
 728         sbefifo = dev_get_drvdata(dev);
 729         if (!sbefifo)
 730                 return -ENODEV;
 731         if (WARN_ON_ONCE(sbefifo->magic != SBEFIFO_MAGIC))
 732                 return -ENODEV;
 733         if (!resp_len || !command || !response)
 734                 return -EINVAL;
 735
 736         /* Prepare iov iterator */
 737         rbytes = (*resp_len) * sizeof(__be32);
 738         resp_iov.iov_base = response;
 739         resp_iov.iov_len = rbytes;
 740         iov_iter_kvec(&resp_iter, WRITE, &resp_iov, 1, rbytes);
 741
 742         /* Perform the command */
 743         mutex_lock(&sbefifo->lock);
 744         rc = __sbefifo_submit(sbefifo, command, cmd_len, &resp_iter);
 745         mutex_unlock(&sbefifo->lock);
 746
 747         /* Extract the response length */
 748         rbytes -= iov_iter_count(&resp_iter);
 749         *resp_len = rbytes / sizeof(__be32);
 750
 751         return rc;
 752 }
 753 EXPORT_SYMBOL_GPL(sbefifo_submit);
 754
 755 /*
 756  * Char device interface
 757  */
 758
 759 static void sbefifo_release_command(struct sbefifo_user *user)
 760 {
 761         if (is_vmalloc_addr(user->pending_cmd))
 762                 vfree(user->pending_cmd);
 763         user->pending_cmd = NULL;
 764         user->pending_len = 0;
 765 }
 766
 767 static int sbefifo_user_open(struct inode *inode, struct file *file)
 768 {
 769         struct sbefifo *sbefifo = container_of(inode->i_cdev, struct sbefifo, cdev);
 770         struct sbefifo_user *user;
 771
 772         user = kzalloc(sizeof(struct sbefifo_user), GFP_KERNEL);
 773         if (!user)
 774                 return -ENOMEM;
 775
 776         file->private_data = user;
 777         user->sbefifo = sbefifo;
 778         user->cmd_page = (void *)__get_free_page(GFP_KERNEL);
 779         if (!user->cmd_page) {
 780                 kfree(user);
 781                 return -ENOMEM;
 782         }
 783         mutex_init(&user->file_lock);
 784
 785         return 0;
 786 }
 787
 788 static ssize_t sbefifo_user_read(struct file *file, char __user *buf,
 789                                  size_t len, loff_t *offset)
 790 {
 791         struct sbefifo_user *user = file->private_data;
 792         struct sbefifo *sbefifo;
 793         struct iov_iter resp_iter;
 794         struct iovec resp_iov;
 795         size_t cmd_len;
 796         int rc;
 797
 798         if (!user)
 799                 return -EINVAL;
 800         sbefifo = user->sbefifo;
 801         if (len & 3)
 802                 return -EINVAL;
 803
 804         mutex_lock(&user->file_lock);
 805
 806         /* Cronus relies on -EAGAIN after a short read */
 807         if (user->pending_len == 0) {
 808                 rc = -EAGAIN;
 809                 goto bail;
 810         }
 811         if (user->pending_len < 8) {
 812                 rc = -EINVAL;
 813                 goto bail;
 814         }
 815         cmd_len = user->pending_len >> 2;
 816
 817         /* Prepare iov iterator */
 818         resp_iov.iov_base = buf;
 819         resp_iov.iov_len = len;
 820         iov_iter_init(&resp_iter, WRITE, &resp_iov, 1, len);
 821
 822         /* Perform the command */
 823         mutex_lock(&sbefifo->lock);
 824         rc = __sbefifo_submit(sbefifo, user->pending_cmd, cmd_len, &resp_iter);
 825         mutex_unlock(&sbefifo->lock);
 826         if (rc < 0)
 827                 goto bail;
 828
 829         /* Extract the response length */
 830         rc = len - iov_iter_count(&resp_iter);
 831  bail:
 832         sbefifo_release_command(user);
 833         mutex_unlock(&user->file_lock);
 834         return rc;
 835 }
 836
 837 static ssize_t sbefifo_user_write(struct file *file, const char __user *buf,
 838                                   size_t len, loff_t *offset)
 839 {
 840         struct sbefifo_user *user = file->private_data;
 841         struct sbefifo *sbefifo;
 842         int rc = len;
 843
 844         if (!user)
 845                 return -EINVAL;
 846         sbefifo = user->sbefifo;
 847         if (len > SBEFIFO_MAX_USER_CMD_LEN)
 848                 return -EINVAL;
 849         if (len & 3)
 850                 return -EINVAL;
 851
 852         mutex_lock(&user->file_lock);
 853
 854         /* Can we use the pre-allocate buffer ? If not, allocate */
 855         if (len <= PAGE_SIZE)
 856                 user->pending_cmd = user->cmd_page;
 857         else
 858                 user->pending_cmd = vmalloc(len);
 859         if (!user->pending_cmd) {
 860                 rc = -ENOMEM;
 861                 goto bail;
 862         }
 863
 864         /* Copy the command into the staging buffer */
 865         if (copy_from_user(user->pending_cmd, buf, len)) {
 866                 rc = -EFAULT;
 867                 goto bail;
 868         }
 869
 870         /* Check for the magic reset command */
 871         if (len == 4 && be32_to_cpu(*(__be32 *)user->pending_cmd) ==
 872             SBEFIFO_RESET_MAGIC)  {
 873
 874                 /* Clear out any pending command */
 875                 user->pending_len = 0;
 876
 877                 /* Trigger reset request */
 878                 mutex_lock(&sbefifo->lock);
 879                 rc = sbefifo_request_reset(user->sbefifo);
 880                 mutex_unlock(&sbefifo->lock);
 881                 if (rc == 0)
 882                         rc = 4;
 883                 goto bail;
 884         }
 885
 886         /* Update the staging buffer size */
 887         user->pending_len = len;
 888  bail:
 889         if (!user->pending_len)
 890                 sbefifo_release_command(user);
 891
 892         mutex_unlock(&user->file_lock);
 893
 894         /* And that's it, we'll issue the command on a read */
 895         return rc;
 896 }
 897
 898 static int sbefifo_user_release(struct inode *inode, struct file *file)
 899 {
 900         struct sbefifo_user *user = file->private_data;
 901
 902         if (!user)
 903                 return -EINVAL;
 904
 905         sbefifo_release_command(user);
 906         free_page((unsigned long)user->cmd_page);
 907         kfree(user);
 908
 909         return 0;
 910 }
 911
 912 static const struct file_operations sbefifo_fops = {
 913         .owner          = THIS_MODULE,
 914         .open           = sbefifo_user_open,
 915         .read           = sbefifo_user_read,
 916         .write          = sbefifo_user_write,
 917         .release        = sbefifo_user_release,
 918 };
 919
 920 static void sbefifo_free(struct device *dev)
 921 {
 922         struct sbefifo *sbefifo = container_of(dev, struct sbefifo, dev);
 923
 924         put_device(&sbefifo->fsi_dev->dev);
 925         kfree(sbefifo);
 926 }
 927
 928 /*
 929  * Probe/remove
 930  */
 931
 932 static int sbefifo_probe(struct device *dev)
 933 {
 934         struct fsi_device *fsi_dev = to_fsi_dev(dev);
 935         struct sbefifo *sbefifo;
 936         struct device_node *np;
 937         struct platform_device *child;
 938         char child_name[32];
 939         int rc, didx, child_idx = 0;
 940
 941         dev_dbg(dev, "Found sbefifo device\n");
 942
 943         sbefifo = kzalloc(sizeof(*sbefifo), GFP_KERNEL);
 944         if (!sbefifo)
 945                 return -ENOMEM;
 946
 947         /* Grab a reference to the device (parent of our cdev), we'll drop it later */
 948         if (!get_device(dev)) {
 949                 kfree(sbefifo);
 950                 return -ENODEV;
 951         }
 952
 953         sbefifo->magic = SBEFIFO_MAGIC;
 954         sbefifo->fsi_dev = fsi_dev;
 955         dev_set_drvdata(dev, sbefifo);
 956         mutex_init(&sbefifo->lock);
 957
 958         /*
 959          * Try cleaning up the FIFO. If this fails, we still register the
 960          * driver and will try cleaning things up again on the next access.
 961          */
 962         rc = sbefifo_cleanup_hw(sbefifo);
 963         if (rc && rc != -ESHUTDOWN)
 964                 dev_err(dev, "Initial HW cleanup failed, will retry later\n");
 965
 966         /* Create chardev for userspace access */
 967         sbefifo->dev.type = &fsi_cdev_type;
 968         sbefifo->dev.parent = dev;
 969         sbefifo->dev.release = sbefifo_free;
 970         device_initialize(&sbefifo->dev);
 971
 972         /* Allocate a minor in the FSI space */
 973         rc = fsi_get_new_minor(fsi_dev, fsi_dev_sbefifo, &sbefifo->dev.devt, &didx);
 974         if (rc)
 975                 goto err;
 976
 977         dev_set_name(&sbefifo->dev, "sbefifo%d", didx);
 978         cdev_init(&sbefifo->cdev, &sbefifo_fops);
 979         rc = cdev_device_add(&sbefifo->cdev, &sbefifo->dev);
 980         if (rc) {
 981                 dev_err(dev, "Error %d creating char device %s\n",
 982                         rc, dev_name(&sbefifo->dev));
 983                 goto err_free_minor;
 984         }
 985
 986         /* Create platform devs for dts child nodes (occ, etc) */
 987         for_each_available_child_of_node(dev->of_node, np) {
 988                 snprintf(child_name, sizeof(child_name), "%s-dev%d",
 989                          dev_name(&sbefifo->dev), child_idx++);
 990                 child = of_platform_device_create(np, child_name, dev);
 991                 if (!child)
 992                         dev_warn(dev, "failed to create child %s dev\n",
 993                                  child_name);
 994         }
 995
 996         return 0;
 997  err_free_minor:
 998         fsi_free_minor(sbefifo->dev.devt);
 999  err:
1000         put_device(&sbefifo->dev);
1001         return rc;
1002 }
1003
1004 static int sbefifo_unregister_child(struct device *dev, void *data)
1005 {
1006         struct platform_device *child = to_platform_device(dev);
1007
1008         of_device_unregister(child);
1009         if (dev->of_node)
1010                 of_node_clear_flag(dev->of_node, OF_POPULATED);
1011
1012         return 0;
1013 }
1014
1015 static int sbefifo_remove(struct device *dev)
1016 {
1017         struct sbefifo *sbefifo = dev_get_drvdata(dev);
1018
1019         dev_dbg(dev, "Removing sbefifo device...\n");
1020
1021         mutex_lock(&sbefifo->lock);
1022         sbefifo->dead = true;
1023         mutex_unlock(&sbefifo->lock);
1024
1025         cdev_device_del(&sbefifo->cdev, &sbefifo->dev);
1026         fsi_free_minor(sbefifo->dev.devt);
1027         device_for_each_child(dev, NULL, sbefifo_unregister_child);
1028         put_device(&sbefifo->dev);
1029
1030         return 0;
1031 }
1032
1033 static const struct fsi_device_id sbefifo_ids[] = {
1034         {
1035                 .engine_type = FSI_ENGID_SBE,
1036                 .version = FSI_VERSION_ANY,
1037         },
1038         { 0 }
1039 };
1040
1041 static struct fsi_driver sbefifo_drv = {
1042         .id_table = sbefifo_ids,
1043         .drv = {
1044                 .name = DEVICE_NAME,
1045                 .bus = &fsi_bus_type,
1046                 .probe = sbefifo_probe,
1047                 .remove = sbefifo_remove,
1048         }
1049 };
1050
1051 static int sbefifo_init(void)
1052 {
1053         return fsi_driver_register(&sbefifo_drv);
1054 }
1055
1056 static void sbefifo_exit(void)
1057 {
1058         fsi_driver_unregister(&sbefifo_drv);
1059 }
1060
1061 module_init(sbefifo_init);
1062 module_exit(sbefifo_exit);
1063 MODULE_LICENSE("GPL");
1064 MODULE_AUTHOR("Brad Bishop <bradleyb@fuzziesquirrel.com>");
1065 MODULE_AUTHOR("Eddie James <eajames@linux.vnet.ibm.com>");
1066 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
1067 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
1068 MODULE_DESCRIPTION("Linux device interface to the POWER Self Boot Engine");