drivers/firmware/stratix10-rsu.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2018-2019, Intel Corporation
   4  */
   5
   6 #include <linux/arm-smccc.h>
   7 #include <linux/bitfield.h>
   8 #include <linux/completion.h>
   9 #include <linux/kobject.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/of.h>
  13 #include <linux/of_platform.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/firmware/intel/stratix10-svc-client.h>
  16 #include <linux/string.h>
  17 #include <linux/sysfs.h>
  18
  19 #define RSU_STATE_MASK                  GENMASK_ULL(31, 0)
  20 #define RSU_VERSION_MASK                GENMASK_ULL(63, 32)
  21 #define RSU_ERROR_LOCATION_MASK         GENMASK_ULL(31, 0)
  22 #define RSU_ERROR_DETAIL_MASK           GENMASK_ULL(63, 32)
  23 #define RSU_DCMF0_MASK                  GENMASK_ULL(31, 0)
  24 #define RSU_DCMF1_MASK                  GENMASK_ULL(63, 32)
  25 #define RSU_DCMF2_MASK                  GENMASK_ULL(31, 0)
  26 #define RSU_DCMF3_MASK                  GENMASK_ULL(63, 32)
  27
  28 #define RSU_TIMEOUT     (msecs_to_jiffies(SVC_RSU_REQUEST_TIMEOUT_MS))
  29
  30 #define INVALID_RETRY_COUNTER           0xFF
  31 #define INVALID_DCMF_VERSION            0xFF
  32
  33
  34 typedef void (*rsu_callback)(struct stratix10_svc_client *client,
  35                              struct stratix10_svc_cb_data *data);
  36 /**
  37  * struct stratix10_rsu_priv - rsu data structure
  38  * @chan: pointer to the allocated service channel
  39  * @client: active service client
  40  * @completion: state for callback completion
  41  * @lock: a mutex to protect callback completion state
  42  * @status.current_image: address of image currently running in flash
  43  * @status.fail_image: address of failed image in flash
  44  * @status.version: the interface version number of RSU firmware
  45  * @status.state: the state of RSU system
  46  * @status.error_details: error code
  47  * @status.error_location: the error offset inside the image that failed
  48  * @dcmf_version.dcmf0: Quartus dcmf0 version
  49  * @dcmf_version.dcmf1: Quartus dcmf1 version
  50  * @dcmf_version.dcmf2: Quartus dcmf2 version
  51  * @dcmf_version.dcmf3: Quartus dcmf3 version
  52  * @retry_counter: the current image's retry counter
  53  * @max_retry: the preset max retry value
  54  */
  55 struct stratix10_rsu_priv {
  56         struct stratix10_svc_chan *chan;
  57         struct stratix10_svc_client client;
  58         struct completion completion;
  59         struct mutex lock;
  60         struct {
  61                 unsigned long current_image;
  62                 unsigned long fail_image;
  63                 unsigned int version;
  64                 unsigned int state;
  65                 unsigned int error_details;
  66                 unsigned int error_location;
  67         } status;
  68
  69         struct {
  70                 unsigned int dcmf0;
  71                 unsigned int dcmf1;
  72                 unsigned int dcmf2;
  73                 unsigned int dcmf3;
  74         } dcmf_version;
  75
  76         unsigned int retry_counter;
  77         unsigned int max_retry;
  78 };
  79
  80 /**
  81  * rsu_status_callback() - Status callback from Intel Service Layer
  82  * @client: pointer to service client
  83  * @data: pointer to callback data structure
  84  *
  85  * Callback from Intel service layer for RSU status request. Status is
  86  * only updated after a system reboot, so a get updated status call is
  87  * made during driver probe.
  88  */
  89 static void rsu_status_callback(struct stratix10_svc_client *client,
  90                                 struct stratix10_svc_cb_data *data)
  91 {
  92         struct stratix10_rsu_priv *priv = client->priv;
  93         struct arm_smccc_res *res = (struct arm_smccc_res *)data->kaddr1;
  94
  95         if (data->status == BIT(SVC_STATUS_OK)) {
  96                 priv->status.version = FIELD_GET(RSU_VERSION_MASK,
  97                                                  res->a2);
  98                 priv->status.state = FIELD_GET(RSU_STATE_MASK, res->a2);
  99                 priv->status.fail_image = res->a1;
 100                 priv->status.current_image = res->a0;
 101                 priv->status.error_location =
 102                         FIELD_GET(RSU_ERROR_LOCATION_MASK, res->a3);
 103                 priv->status.error_details =
 104                         FIELD_GET(RSU_ERROR_DETAIL_MASK, res->a3);
 105         } else {
 106                 dev_err(client->dev, "COMMAND_RSU_STATUS returned 0x%lX\n",
 107                         res->a0);
 108                 priv->status.version = 0;
 109                 priv->status.state = 0;
 110                 priv->status.fail_image = 0;
 111                 priv->status.current_image = 0;
 112                 priv->status.error_location = 0;
 113                 priv->status.error_details = 0;
 114         }
 115
 116         complete(&priv->completion);
 117 }
 118
 119 /**
 120  * rsu_command_callback() - Update callback from Intel Service Layer
 121  * @client: pointer to client
 122  * @data: pointer to callback data structure
 123  *
 124  * Callback from Intel service layer for RSU commands.
 125  */
 126 static void rsu_command_callback(struct stratix10_svc_client *client,
 127                                  struct stratix10_svc_cb_data *data)
 128 {
 129         struct stratix10_rsu_priv *priv = client->priv;
 130
 131         if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
 132                 dev_warn(client->dev, "FW doesn't support notify\n");
 133         else if (data->status == BIT(SVC_STATUS_ERROR))
 134                 dev_err(client->dev, "Failure, returned status is %lu\n",
 135                         BIT(data->status));
 136
 137         complete(&priv->completion);
 138 }
 139
 140 /**
 141  * rsu_retry_callback() - Callback from Intel service layer for getting
 142  * the current image's retry counter from the firmware
 143  * @client: pointer to client
 144  * @data: pointer to callback data structure
 145  *
 146  * Callback from Intel service layer for retry counter, which is used by
 147  * user to know how many times the images is still allowed to reload
 148  * itself before giving up and starting RSU fail-over flow.
 149  */
 150 static void rsu_retry_callback(struct stratix10_svc_client *client,
 151                                struct stratix10_svc_cb_data *data)
 152 {
 153         struct stratix10_rsu_priv *priv = client->priv;
 154         unsigned int *counter = (unsigned int *)data->kaddr1;
 155
 156         if (data->status == BIT(SVC_STATUS_OK))
 157                 priv->retry_counter = *counter;
 158         else if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
 159                 dev_warn(client->dev, "FW doesn't support retry\n");
 160         else
 161                 dev_err(client->dev, "Failed to get retry counter %lu\n",
 162                         BIT(data->status));
 163
 164         complete(&priv->completion);
 165 }
 166
 167 /**
 168  * rsu_max_retry_callback() - Callback from Intel service layer for getting
 169  * the max retry value from the firmware
 170  * @client: pointer to client
 171  * @data: pointer to callback data structure
 172  *
 173  * Callback from Intel service layer for max retry.
 174  */
 175 static void rsu_max_retry_callback(struct stratix10_svc_client *client,
 176                                    struct stratix10_svc_cb_data *data)
 177 {
 178         struct stratix10_rsu_priv *priv = client->priv;
 179         unsigned int *max_retry = (unsigned int *)data->kaddr1;
 180
 181         if (data->status == BIT(SVC_STATUS_OK))
 182                 priv->max_retry = *max_retry;
 183         else if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
 184                 dev_warn(client->dev, "FW doesn't support max retry\n");
 185         else
 186                 dev_err(client->dev, "Failed to get max retry %lu\n",
 187                         BIT(data->status));
 188
 189         complete(&priv->completion);
 190 }
 191
 192 /**
 193  * rsu_dcmf_version_callback() - Callback from Intel service layer for getting
 194  * the DCMF version
 195  * @client: pointer to client
 196  * @data: pointer to callback data structure
 197  *
 198  * Callback from Intel service layer for DCMF version number
 199  */
 200 static void rsu_dcmf_version_callback(struct stratix10_svc_client *client,
 201                                       struct stratix10_svc_cb_data *data)
 202 {
 203         struct stratix10_rsu_priv *priv = client->priv;
 204         unsigned long long *value1 = (unsigned long long *)data->kaddr1;
 205         unsigned long long *value2 = (unsigned long long *)data->kaddr2;
 206
 207         if (data->status == BIT(SVC_STATUS_OK)) {
 208                 priv->dcmf_version.dcmf0 = FIELD_GET(RSU_DCMF0_MASK, *value1);
 209                 priv->dcmf_version.dcmf1 = FIELD_GET(RSU_DCMF1_MASK, *value1);
 210                 priv->dcmf_version.dcmf2 = FIELD_GET(RSU_DCMF2_MASK, *value2);
 211                 priv->dcmf_version.dcmf3 = FIELD_GET(RSU_DCMF3_MASK, *value2);
 212         } else
 213                 dev_err(client->dev, "failed to get DCMF version\n");
 214
 215         complete(&priv->completion);
 216 }
 217
 218 /**
 219  * rsu_send_msg() - send a message to Intel service layer
 220  * @priv: pointer to rsu private data
 221  * @command: RSU status or update command
 222  * @arg: the request argument, the bitstream address or notify status
 223  * @callback: function pointer for the callback (status or update)
 224  *
 225  * Start an Intel service layer transaction to perform the SMC call that
 226  * is necessary to get RSU boot log or set the address of bitstream to
 227  * boot after reboot.
 228  *
 229  * Returns 0 on success or -ETIMEDOUT on error.
 230  */
 231 static int rsu_send_msg(struct stratix10_rsu_priv *priv,
 232                         enum stratix10_svc_command_code command,
 233                         unsigned long arg,
 234                         rsu_callback callback)
 235 {
 236         struct stratix10_svc_client_msg msg;
 237         int ret;
 238
 239         mutex_lock(&priv->lock);
 240         reinit_completion(&priv->completion);
 241         priv->client.receive_cb = callback;
 242
 243         msg.command = command;
 244         if (arg)
 245                 msg.arg[0] = arg;
 246
 247         ret = stratix10_svc_send(priv->chan, &msg);
 248         if (ret < 0)
 249                 goto status_done;
 250
 251         ret = wait_for_completion_interruptible_timeout(&priv->completion,
 252                                                         RSU_TIMEOUT);
 253         if (!ret) {
 254                 dev_err(priv->client.dev,
 255                         "timeout waiting for SMC call\n");
 256                 ret = -ETIMEDOUT;
 257                 goto status_done;
 258         } else if (ret < 0) {
 259                 dev_err(priv->client.dev,
 260                         "error %d waiting for SMC call\n", ret);
 261                 goto status_done;
 262         } else {
 263                 ret = 0;
 264         }
 265
 266 status_done:
 267         stratix10_svc_done(priv->chan);
 268         mutex_unlock(&priv->lock);
 269         return ret;
 270 }
 271
 272 /*
 273  * This driver exposes some optional features of the Intel Stratix 10 SoC FPGA.
 274  * The sysfs interfaces exposed here are FPGA Remote System Update (RSU)
 275  * related. They allow user space software to query the configuration system
 276  * status and to request optional reboot behavior specific to Intel FPGAs.
 277  */
 278
 279 static ssize_t current_image_show(struct device *dev,
 280                                   struct device_attribute *attr, char *buf)
 281 {
 282         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 283
 284         if (!priv)
 285                 return -ENODEV;
 286
 287         return sprintf(buf, "0x%08lx\n", priv->status.current_image);
 288 }
 289
 290 static ssize_t fail_image_show(struct device *dev,
 291                                struct device_attribute *attr, char *buf)
 292 {
 293         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 294
 295         if (!priv)
 296                 return -ENODEV;
 297
 298         return sprintf(buf, "0x%08lx\n", priv->status.fail_image);
 299 }
 300
 301 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
 302                             char *buf)
 303 {
 304         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 305
 306         if (!priv)
 307                 return -ENODEV;
 308
 309         return sprintf(buf, "0x%08x\n", priv->status.version);
 310 }
 311
 312 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
 313                           char *buf)
 314 {
 315         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 316
 317         if (!priv)
 318                 return -ENODEV;
 319
 320         return sprintf(buf, "0x%08x\n", priv->status.state);
 321 }
 322
 323 static ssize_t error_location_show(struct device *dev,
 324                                    struct device_attribute *attr, char *buf)
 325 {
 326         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 327
 328         if (!priv)
 329                 return -ENODEV;
 330
 331         return sprintf(buf, "0x%08x\n", priv->status.error_location);
 332 }
 333
 334 static ssize_t error_details_show(struct device *dev,
 335                                   struct device_attribute *attr, char *buf)
 336 {
 337         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 338
 339         if (!priv)
 340                 return -ENODEV;
 341
 342         return sprintf(buf, "0x%08x\n", priv->status.error_details);
 343 }
 344
 345 static ssize_t retry_counter_show(struct device *dev,
 346                                   struct device_attribute *attr, char *buf)
 347 {
 348         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 349
 350         if (!priv)
 351                 return -ENODEV;
 352
 353         return sprintf(buf, "0x%08x\n", priv->retry_counter);
 354 }
 355
 356 static ssize_t max_retry_show(struct device *dev,
 357                               struct device_attribute *attr, char *buf)
 358 {
 359         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 360
 361         if (!priv)
 362                 return -ENODEV;
 363
 364         return sprintf(buf, "0x%08x\n", priv->max_retry);
 365 }
 366
 367 static ssize_t dcmf0_show(struct device *dev,
 368                           struct device_attribute *attr, char *buf)
 369 {
 370         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 371
 372         if (!priv)
 373                 return -ENODEV;
 374
 375         return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf0);
 376 }
 377
 378 static ssize_t dcmf1_show(struct device *dev,
 379                           struct device_attribute *attr, char *buf)
 380 {
 381         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 382
 383         if (!priv)
 384                 return -ENODEV;
 385
 386         return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf1);
 387 }
 388
 389 static ssize_t dcmf2_show(struct device *dev,
 390                           struct device_attribute *attr, char *buf)
 391 {
 392         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 393
 394         if (!priv)
 395                 return -ENODEV;
 396
 397         return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf2);
 398 }
 399
 400 static ssize_t dcmf3_show(struct device *dev,
 401                           struct device_attribute *attr, char *buf)
 402 {
 403         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 404
 405         if (!priv)
 406                 return -ENODEV;
 407
 408         return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf3);
 409 }
 410
 411 static ssize_t reboot_image_store(struct device *dev,
 412                                   struct device_attribute *attr,
 413                                   const char *buf, size_t count)
 414 {
 415         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 416         unsigned long address;
 417         int ret;
 418
 419         if (!priv)
 420                 return -ENODEV;
 421
 422         ret = kstrtoul(buf, 0, &address);
 423         if (ret)
 424                 return ret;
 425
 426         ret = rsu_send_msg(priv, COMMAND_RSU_UPDATE,
 427                            address, rsu_command_callback);
 428         if (ret) {
 429                 dev_err(dev, "Error, RSU update returned %i\n", ret);
 430                 return ret;
 431         }
 432
 433         return count;
 434 }
 435
 436 static ssize_t notify_store(struct device *dev,
 437                             struct device_attribute *attr,
 438                             const char *buf, size_t count)
 439 {
 440         struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
 441         unsigned long status;
 442         int ret;
 443
 444         if (!priv)
 445                 return -ENODEV;
 446
 447         ret = kstrtoul(buf, 0, &status);
 448         if (ret)
 449                 return ret;
 450
 451         ret = rsu_send_msg(priv, COMMAND_RSU_NOTIFY,
 452                            status, rsu_command_callback);
 453         if (ret) {
 454                 dev_err(dev, "Error, RSU notify returned %i\n", ret);
 455                 return ret;
 456         }
 457
 458         /* to get the updated state */
 459         ret = rsu_send_msg(priv, COMMAND_RSU_STATUS,
 460                            0, rsu_status_callback);
 461         if (ret) {
 462                 dev_err(dev, "Error, getting RSU status %i\n", ret);
 463                 return ret;
 464         }
 465
 466         ret = rsu_send_msg(priv, COMMAND_RSU_RETRY, 0, rsu_retry_callback);
 467         if (ret) {
 468                 dev_err(dev, "Error, getting RSU retry %i\n", ret);
 469                 return ret;
 470         }
 471
 472         return count;
 473 }
 474
 475 static DEVICE_ATTR_RO(current_image);
 476 static DEVICE_ATTR_RO(fail_image);
 477 static DEVICE_ATTR_RO(state);
 478 static DEVICE_ATTR_RO(version);
 479 static DEVICE_ATTR_RO(error_location);
 480 static DEVICE_ATTR_RO(error_details);
 481 static DEVICE_ATTR_RO(retry_counter);
 482 static DEVICE_ATTR_RO(max_retry);
 483 static DEVICE_ATTR_RO(dcmf0);
 484 static DEVICE_ATTR_RO(dcmf1);
 485 static DEVICE_ATTR_RO(dcmf2);
 486 static DEVICE_ATTR_RO(dcmf3);
 487 static DEVICE_ATTR_WO(reboot_image);
 488 static DEVICE_ATTR_WO(notify);
 489
 490 static struct attribute *rsu_attrs[] = {
 491         &dev_attr_current_image.attr,
 492         &dev_attr_fail_image.attr,
 493         &dev_attr_state.attr,
 494         &dev_attr_version.attr,
 495         &dev_attr_error_location.attr,
 496         &dev_attr_error_details.attr,
 497         &dev_attr_retry_counter.attr,
 498         &dev_attr_max_retry.attr,
 499         &dev_attr_dcmf0.attr,
 500         &dev_attr_dcmf1.attr,
 501         &dev_attr_dcmf2.attr,
 502         &dev_attr_dcmf3.attr,
 503         &dev_attr_reboot_image.attr,
 504         &dev_attr_notify.attr,
 505         NULL
 506 };
 507
 508 ATTRIBUTE_GROUPS(rsu);
 509
 510 static int stratix10_rsu_probe(struct platform_device *pdev)
 511 {
 512         struct device *dev = &pdev->dev;
 513         struct stratix10_rsu_priv *priv;
 514         int ret;
 515
 516         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 517         if (!priv)
 518                 return -ENOMEM;
 519
 520         priv->client.dev = dev;
 521         priv->client.receive_cb = NULL;
 522         priv->client.priv = priv;
 523         priv->status.current_image = 0;
 524         priv->status.fail_image = 0;
 525         priv->status.error_location = 0;
 526         priv->status.error_details = 0;
 527         priv->status.version = 0;
 528         priv->status.state = 0;
 529         priv->retry_counter = INVALID_RETRY_COUNTER;
 530         priv->dcmf_version.dcmf0 = INVALID_DCMF_VERSION;
 531         priv->dcmf_version.dcmf1 = INVALID_DCMF_VERSION;
 532         priv->dcmf_version.dcmf2 = INVALID_DCMF_VERSION;
 533         priv->dcmf_version.dcmf3 = INVALID_DCMF_VERSION;
 534         priv->max_retry = INVALID_RETRY_COUNTER;
 535
 536         mutex_init(&priv->lock);
 537         priv->chan = stratix10_svc_request_channel_byname(&priv->client,
 538                                                           SVC_CLIENT_RSU);
 539         if (IS_ERR(priv->chan)) {
 540                 dev_err(dev, "couldn't get service channel %s\n",
 541                         SVC_CLIENT_RSU);
 542                 return PTR_ERR(priv->chan);
 543         }
 544
 545         init_completion(&priv->completion);
 546         platform_set_drvdata(pdev, priv);
 547
 548         /* get the initial state from firmware */
 549         ret = rsu_send_msg(priv, COMMAND_RSU_STATUS,
 550                            0, rsu_status_callback);
 551         if (ret) {
 552                 dev_err(dev, "Error, getting RSU status %i\n", ret);
 553                 stratix10_svc_free_channel(priv->chan);
 554         }
 555
 556         /* get DCMF version from firmware */
 557         ret = rsu_send_msg(priv, COMMAND_RSU_DCMF_VERSION,
 558                            0, rsu_dcmf_version_callback);
 559         if (ret) {
 560                 dev_err(dev, "Error, getting DCMF version %i\n", ret);
 561                 stratix10_svc_free_channel(priv->chan);
 562         }
 563
 564         ret = rsu_send_msg(priv, COMMAND_RSU_RETRY, 0, rsu_retry_callback);
 565         if (ret) {
 566                 dev_err(dev, "Error, getting RSU retry %i\n", ret);
 567                 stratix10_svc_free_channel(priv->chan);
 568         }
 569
 570         ret = rsu_send_msg(priv, COMMAND_RSU_MAX_RETRY, 0,
 571                            rsu_max_retry_callback);
 572         if (ret) {
 573                 dev_err(dev, "Error, getting RSU max retry %i\n", ret);
 574                 stratix10_svc_free_channel(priv->chan);
 575         }
 576
 577         return ret;
 578 }
 579
 580 static int stratix10_rsu_remove(struct platform_device *pdev)
 581 {
 582         struct stratix10_rsu_priv *priv = platform_get_drvdata(pdev);
 583
 584         stratix10_svc_free_channel(priv->chan);
 585         return 0;
 586 }
 587
 588 static struct platform_driver stratix10_rsu_driver = {
 589         .probe = stratix10_rsu_probe,
 590         .remove = stratix10_rsu_remove,
 591         .driver = {
 592                 .name = "stratix10-rsu",
 593                 .dev_groups = rsu_groups,
 594         },
 595 };
 596
 597 module_platform_driver(stratix10_rsu_driver);
 598
 599 MODULE_LICENSE("GPL v2");
 600 MODULE_DESCRIPTION("Intel Remote System Update Driver");
 601 MODULE_AUTHOR("Richard Gong <richard.gong@intel.com>");