drivers/misc/mei/init.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2012-2022, Intel Corporation. All rights reserved.
   4  * Intel Management Engine Interface (Intel MEI) Linux driver
   5  */
   6
   7 #include <linux/export.h>
   8 #include <linux/sched.h>
   9 #include <linux/wait.h>
  10 #include <linux/delay.h>
  11
  12 #include <linux/mei.h>
  13
  14 #include "mei_dev.h"
  15 #include "hbm.h"
  16 #include "client.h"
  17
  18 const char *mei_dev_state_str(int state)
  19 {
  20 #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state
  21         switch (state) {
  22         MEI_DEV_STATE(INITIALIZING);
  23         MEI_DEV_STATE(INIT_CLIENTS);
  24         MEI_DEV_STATE(ENABLED);
  25         MEI_DEV_STATE(RESETTING);
  26         MEI_DEV_STATE(DISABLED);
  27         MEI_DEV_STATE(POWERING_DOWN);
  28         MEI_DEV_STATE(POWER_DOWN);
  29         MEI_DEV_STATE(POWER_UP);
  30         default:
  31                 return "unknown";
  32         }
  33 #undef MEI_DEV_STATE
  34 }
  35
  36 const char *mei_pg_state_str(enum mei_pg_state state)
  37 {
  38 #define MEI_PG_STATE(state) case MEI_PG_##state: return #state
  39         switch (state) {
  40         MEI_PG_STATE(OFF);
  41         MEI_PG_STATE(ON);
  42         default:
  43                 return "unknown";
  44         }
  45 #undef MEI_PG_STATE
  46 }
  47
  48 /**
  49  * mei_fw_status2str - convert fw status registers to printable string
  50  *
  51  * @fw_status:  firmware status
  52  * @buf: string buffer at minimal size MEI_FW_STATUS_STR_SZ
  53  * @len: buffer len must be >= MEI_FW_STATUS_STR_SZ
  54  *
  55  * Return: number of bytes written or -EINVAL if buffer is to small
  56  */
  57 ssize_t mei_fw_status2str(struct mei_fw_status *fw_status,
  58                           char *buf, size_t len)
  59 {
  60         ssize_t cnt = 0;
  61         int i;
  62
  63         buf[0] = '\0';
  64
  65         if (len < MEI_FW_STATUS_STR_SZ)
  66                 return -EINVAL;
  67
  68         for (i = 0; i < fw_status->count; i++)
  69                 cnt += scnprintf(buf + cnt, len - cnt, "%08X ",
  70                                 fw_status->status[i]);
  71
  72         /* drop last space */
  73         buf[cnt] = '\0';
  74         return cnt;
  75 }
  76 EXPORT_SYMBOL_GPL(mei_fw_status2str);
  77
  78 /**
  79  * mei_cancel_work - Cancel mei background jobs
  80  *
  81  * @dev: the device structure
  82  */
  83 void mei_cancel_work(struct mei_device *dev)
  84 {
  85         cancel_work_sync(&dev->reset_work);
  86         cancel_work_sync(&dev->bus_rescan_work);
  87
  88         cancel_delayed_work_sync(&dev->timer_work);
  89 }
  90 EXPORT_SYMBOL_GPL(mei_cancel_work);
  91
  92 static void mei_save_fw_status(struct mei_device *dev)
  93 {
  94         struct mei_fw_status fw_status;
  95         int ret;
  96
  97         ret = mei_fw_status(dev, &fw_status);
  98         if (ret) {
  99                 dev_err(dev->dev, "failed to read firmware status: %d\n", ret);
 100                 return;
 101         }
 102
 103         dev->saved_dev_state = dev->dev_state;
 104         dev->saved_fw_status_flag = true;
 105         memcpy(&dev->saved_fw_status, &fw_status, sizeof(fw_status));
 106 }
 107
 108 /**
 109  * mei_reset - resets host and fw.
 110  *
 111  * @dev: the device structure
 112  *
 113  * Return: 0 on success or < 0 if the reset hasn't succeeded
 114  */
 115 int mei_reset(struct mei_device *dev)
 116 {
 117         enum mei_dev_state state = dev->dev_state;
 118         bool interrupts_enabled;
 119         int ret;
 120
 121         if (state != MEI_DEV_INITIALIZING &&
 122             state != MEI_DEV_DISABLED &&
 123             state != MEI_DEV_POWER_DOWN &&
 124             state != MEI_DEV_POWER_UP) {
 125                 char fw_sts_str[MEI_FW_STATUS_STR_SZ];
 126
 127                 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ);
 128                 if (kind_is_gsc(dev) || kind_is_gscfi(dev)) {
 129                         dev_dbg(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n",
 130                                 mei_dev_state_str(state), fw_sts_str);
 131                         mei_save_fw_status(dev);
 132                 } else {
 133                         dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n",
 134                                  mei_dev_state_str(state), fw_sts_str);
 135                 }
 136         }
 137
 138         mei_clear_interrupts(dev);
 139
 140         /* we're already in reset, cancel the init timer
 141          * if the reset was called due the hbm protocol error
 142          * we need to call it before hw start
 143          * so the hbm watchdog won't kick in
 144          */
 145         mei_hbm_idle(dev);
 146
 147         /* enter reset flow */
 148         interrupts_enabled = state != MEI_DEV_POWER_DOWN;
 149         mei_set_devstate(dev, MEI_DEV_RESETTING);
 150
 151         dev->reset_count++;
 152         if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
 153                 dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
 154                 mei_set_devstate(dev, MEI_DEV_DISABLED);
 155                 return -ENODEV;
 156         }
 157
 158         ret = mei_hw_reset(dev, interrupts_enabled);
 159         /* fall through and remove the sw state even if hw reset has failed */
 160
 161         /* no need to clean up software state in case of power up */
 162         if (state != MEI_DEV_INITIALIZING && state != MEI_DEV_POWER_UP)
 163                 mei_cl_all_disconnect(dev);
 164
 165         mei_hbm_reset(dev);
 166
 167         /* clean stale FW version */
 168         dev->fw_ver_received = 0;
 169
 170         memset(dev->rd_msg_hdr, 0, sizeof(dev->rd_msg_hdr));
 171
 172         if (ret) {
 173                 dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
 174                 return ret;
 175         }
 176
 177         if (state == MEI_DEV_POWER_DOWN) {
 178                 dev_dbg(dev->dev, "powering down: end of reset\n");
 179                 mei_set_devstate(dev, MEI_DEV_DISABLED);
 180                 return 0;
 181         }
 182
 183         ret = mei_hw_start(dev);
 184         if (ret) {
 185                 char fw_sts_str[MEI_FW_STATUS_STR_SZ];
 186
 187                 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ);
 188                 dev_err(dev->dev, "hw_start failed ret = %d fw status = %s\n", ret, fw_sts_str);
 189                 return ret;
 190         }
 191
 192         if (dev->dev_state != MEI_DEV_RESETTING) {
 193                 dev_dbg(dev->dev, "wrong state = %d on link start\n", dev->dev_state);
 194                 return 0;
 195         }
 196
 197         dev_dbg(dev->dev, "link is established start sending messages.\n");
 198
 199         mei_set_devstate(dev, MEI_DEV_INIT_CLIENTS);
 200         ret = mei_hbm_start_req(dev);
 201         if (ret) {
 202                 dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
 203                 mei_set_devstate(dev, MEI_DEV_RESETTING);
 204                 return ret;
 205         }
 206
 207         return 0;
 208 }
 209 EXPORT_SYMBOL_GPL(mei_reset);
 210
 211 /**
 212  * mei_start - initializes host and fw to start work.
 213  *
 214  * @dev: the device structure
 215  *
 216  * Return: 0 on success, <0 on failure.
 217  */
 218 int mei_start(struct mei_device *dev)
 219 {
 220         int ret;
 221
 222         mutex_lock(&dev->device_lock);
 223
 224         /* acknowledge interrupt and stop interrupts */
 225         mei_clear_interrupts(dev);
 226
 227         ret = mei_hw_config(dev);
 228         if (ret)
 229                 goto err;
 230
 231         dev_dbg(dev->dev, "reset in start the mei device.\n");
 232
 233         dev->reset_count = 0;
 234         do {
 235                 mei_set_devstate(dev, MEI_DEV_INITIALIZING);
 236                 ret = mei_reset(dev);
 237
 238                 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 239                         dev_err(dev->dev, "reset failed ret = %d", ret);
 240                         goto err;
 241                 }
 242         } while (ret);
 243
 244         if (mei_hbm_start_wait(dev)) {
 245                 dev_err(dev->dev, "HBM haven't started");
 246                 goto err;
 247         }
 248
 249         if (!mei_hbm_version_is_supported(dev)) {
 250                 dev_dbg(dev->dev, "MEI start failed.\n");
 251                 goto err;
 252         }
 253
 254         dev_dbg(dev->dev, "link layer has been established.\n");
 255
 256         mutex_unlock(&dev->device_lock);
 257         return 0;
 258 err:
 259         dev_err(dev->dev, "link layer initialization failed.\n");
 260         mei_set_devstate(dev, MEI_DEV_DISABLED);
 261         mutex_unlock(&dev->device_lock);
 262         return -ENODEV;
 263 }
 264 EXPORT_SYMBOL_GPL(mei_start);
 265
 266 /**
 267  * mei_restart - restart device after suspend
 268  *
 269  * @dev: the device structure
 270  *
 271  * Return: 0 on success or -ENODEV if the restart hasn't succeeded
 272  */
 273 int mei_restart(struct mei_device *dev)
 274 {
 275         int err;
 276
 277         mutex_lock(&dev->device_lock);
 278
 279         mei_set_devstate(dev, MEI_DEV_POWER_UP);
 280         dev->reset_count = 0;
 281
 282         err = mei_reset(dev);
 283
 284         mutex_unlock(&dev->device_lock);
 285
 286         if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 287                 dev_err(dev->dev, "device disabled = %d\n", err);
 288                 return -ENODEV;
 289         }
 290
 291         /* try to start again */
 292         if (err)
 293                 schedule_work(&dev->reset_work);
 294
 295
 296         return 0;
 297 }
 298 EXPORT_SYMBOL_GPL(mei_restart);
 299
 300 static void mei_reset_work(struct work_struct *work)
 301 {
 302         struct mei_device *dev =
 303                 container_of(work, struct mei_device,  reset_work);
 304         int ret;
 305
 306         mei_clear_interrupts(dev);
 307         mei_synchronize_irq(dev);
 308
 309         mutex_lock(&dev->device_lock);
 310
 311         ret = mei_reset(dev);
 312
 313         mutex_unlock(&dev->device_lock);
 314
 315         if (dev->dev_state == MEI_DEV_DISABLED) {
 316                 dev_err(dev->dev, "device disabled = %d\n", ret);
 317                 return;
 318         }
 319
 320         /* retry reset in case of failure */
 321         if (ret)
 322                 schedule_work(&dev->reset_work);
 323 }
 324
 325 void mei_stop(struct mei_device *dev)
 326 {
 327         dev_dbg(dev->dev, "stopping the device.\n");
 328
 329         mutex_lock(&dev->device_lock);
 330         mei_set_devstate(dev, MEI_DEV_POWERING_DOWN);
 331         mutex_unlock(&dev->device_lock);
 332         mei_cl_bus_remove_devices(dev);
 333         mutex_lock(&dev->device_lock);
 334         mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
 335         mutex_unlock(&dev->device_lock);
 336
 337         mei_cancel_work(dev);
 338
 339         mei_clear_interrupts(dev);
 340         mei_synchronize_irq(dev);
 341         /* to catch HW-initiated reset */
 342         mei_cancel_work(dev);
 343
 344         mutex_lock(&dev->device_lock);
 345
 346         mei_reset(dev);
 347         /* move device to disabled state unconditionally */
 348         mei_set_devstate(dev, MEI_DEV_DISABLED);
 349
 350         mutex_unlock(&dev->device_lock);
 351 }
 352 EXPORT_SYMBOL_GPL(mei_stop);
 353
 354 /**
 355  * mei_write_is_idle - check if the write queues are idle
 356  *
 357  * @dev: the device structure
 358  *
 359  * Return: true of there is no pending write
 360  */
 361 bool mei_write_is_idle(struct mei_device *dev)
 362 {
 363         bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
 364                 list_empty(&dev->ctrl_wr_list) &&
 365                 list_empty(&dev->write_list)   &&
 366                 list_empty(&dev->write_waiting_list));
 367
 368         dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
 369                 idle,
 370                 mei_dev_state_str(dev->dev_state),
 371                 list_empty(&dev->ctrl_wr_list),
 372                 list_empty(&dev->write_list),
 373                 list_empty(&dev->write_waiting_list));
 374
 375         return idle;
 376 }
 377 EXPORT_SYMBOL_GPL(mei_write_is_idle);
 378
 379 /**
 380  * mei_device_init - initialize mei_device structure
 381  *
 382  * @dev: the mei device
 383  * @device: the device structure
 384  * @slow_fw: configure longer timeouts as FW is slow
 385  * @hw_ops: hw operations
 386  */
 387 void mei_device_init(struct mei_device *dev,
 388                      struct device *device,
 389                      bool slow_fw,
 390                      const struct mei_hw_ops *hw_ops)
 391 {
 392         /* setup our list array */
 393         INIT_LIST_HEAD(&dev->file_list);
 394         INIT_LIST_HEAD(&dev->device_list);
 395         INIT_LIST_HEAD(&dev->me_clients);
 396         mutex_init(&dev->device_lock);
 397         init_rwsem(&dev->me_clients_rwsem);
 398         mutex_init(&dev->cl_bus_lock);
 399         init_waitqueue_head(&dev->wait_hw_ready);
 400         init_waitqueue_head(&dev->wait_pg);
 401         init_waitqueue_head(&dev->wait_hbm_start);
 402         dev->dev_state = MEI_DEV_INITIALIZING;
 403         dev->reset_count = 0;
 404
 405         INIT_LIST_HEAD(&dev->write_list);
 406         INIT_LIST_HEAD(&dev->write_waiting_list);
 407         INIT_LIST_HEAD(&dev->ctrl_wr_list);
 408         INIT_LIST_HEAD(&dev->ctrl_rd_list);
 409         dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT;
 410
 411         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 412         INIT_WORK(&dev->reset_work, mei_reset_work);
 413         INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
 414
 415         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 416         dev->open_handle_count = 0;
 417
 418         dev->pxp_mode = MEI_DEV_PXP_DEFAULT;
 419         dev->gsc_reset_to_pxp = MEI_DEV_RESET_TO_PXP_DEFAULT;
 420
 421         /*
 422          * Reserving the first client ID
 423          * 0: Reserved for MEI Bus Message communications
 424          */
 425         bitmap_set(dev->host_clients_map, 0, 1);
 426
 427         dev->pg_event = MEI_PG_EVENT_IDLE;
 428         dev->ops      = hw_ops;
 429         dev->dev      = device;
 430
 431         dev->timeouts.hw_ready = mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT);
 432         dev->timeouts.connect = MEI_CONNECT_TIMEOUT;
 433         dev->timeouts.client_init = MEI_CLIENTS_INIT_TIMEOUT;
 434         dev->timeouts.pgi = mei_secs_to_jiffies(MEI_PGI_TIMEOUT);
 435         dev->timeouts.d0i3 = mei_secs_to_jiffies(MEI_D0I3_TIMEOUT);
 436         if (slow_fw) {
 437                 dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT_SLOW);
 438                 dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT_SLOW);
 439                 dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT_SLOW);
 440         } else {
 441                 dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT);
 442                 dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT);
 443                 dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT);
 444         }
 445 }
 446 EXPORT_SYMBOL_GPL(mei_device_init);
 447