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 /**
  93  * mei_reset - resets host and fw.
  94  *
  95  * @dev: the device structure
  96  *
  97  * Return: 0 on success or < 0 if the reset hasn't succeeded
  98  */
  99 int mei_reset(struct mei_device *dev)
 100 {
 101         enum mei_dev_state state = dev->dev_state;
 102         bool interrupts_enabled;
 103         int ret;
 104
 105         if (state != MEI_DEV_INITIALIZING &&
 106             state != MEI_DEV_DISABLED &&
 107             state != MEI_DEV_POWER_DOWN &&
 108             state != MEI_DEV_POWER_UP) {
 109                 char fw_sts_str[MEI_FW_STATUS_STR_SZ];
 110
 111                 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ);
 112                 dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n",
 113                          mei_dev_state_str(state), fw_sts_str);
 114         }
 115
 116         mei_clear_interrupts(dev);
 117
 118         /* we're already in reset, cancel the init timer
 119          * if the reset was called due the hbm protocol error
 120          * we need to call it before hw start
 121          * so the hbm watchdog won't kick in
 122          */
 123         mei_hbm_idle(dev);
 124
 125         /* enter reset flow */
 126         interrupts_enabled = state != MEI_DEV_POWER_DOWN;
 127         mei_set_devstate(dev, MEI_DEV_RESETTING);
 128
 129         dev->reset_count++;
 130         if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
 131                 dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
 132                 mei_set_devstate(dev, MEI_DEV_DISABLED);
 133                 return -ENODEV;
 134         }
 135
 136         ret = mei_hw_reset(dev, interrupts_enabled);
 137         /* fall through and remove the sw state even if hw reset has failed */
 138
 139         /* no need to clean up software state in case of power up */
 140         if (state != MEI_DEV_INITIALIZING && state != MEI_DEV_POWER_UP)
 141                 mei_cl_all_disconnect(dev);
 142
 143         mei_hbm_reset(dev);
 144
 145         /* clean stale FW version */
 146         dev->fw_ver_received = 0;
 147
 148         memset(dev->rd_msg_hdr, 0, sizeof(dev->rd_msg_hdr));
 149
 150         if (ret) {
 151                 dev_err(dev->dev, "hw_reset failed ret = %d\n", ret);
 152                 return ret;
 153         }
 154
 155         if (state == MEI_DEV_POWER_DOWN) {
 156                 dev_dbg(dev->dev, "powering down: end of reset\n");
 157                 mei_set_devstate(dev, MEI_DEV_DISABLED);
 158                 return 0;
 159         }
 160
 161         ret = mei_hw_start(dev);
 162         if (ret) {
 163                 char fw_sts_str[MEI_FW_STATUS_STR_SZ];
 164
 165                 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ);
 166                 dev_err(dev->dev, "hw_start failed ret = %d fw status = %s\n", ret, fw_sts_str);
 167                 return ret;
 168         }
 169
 170         if (dev->dev_state != MEI_DEV_RESETTING) {
 171                 dev_dbg(dev->dev, "wrong state = %d on link start\n", dev->dev_state);
 172                 return 0;
 173         }
 174
 175         dev_dbg(dev->dev, "link is established start sending messages.\n");
 176
 177         mei_set_devstate(dev, MEI_DEV_INIT_CLIENTS);
 178         ret = mei_hbm_start_req(dev);
 179         if (ret) {
 180                 dev_err(dev->dev, "hbm_start failed ret = %d\n", ret);
 181                 mei_set_devstate(dev, MEI_DEV_RESETTING);
 182                 return ret;
 183         }
 184
 185         return 0;
 186 }
 187 EXPORT_SYMBOL_GPL(mei_reset);
 188
 189 /**
 190  * mei_start - initializes host and fw to start work.
 191  *
 192  * @dev: the device structure
 193  *
 194  * Return: 0 on success, <0 on failure.
 195  */
 196 int mei_start(struct mei_device *dev)
 197 {
 198         int ret;
 199
 200         mutex_lock(&dev->device_lock);
 201
 202         /* acknowledge interrupt and stop interrupts */
 203         mei_clear_interrupts(dev);
 204
 205         ret = mei_hw_config(dev);
 206         if (ret)
 207                 goto err;
 208
 209         dev_dbg(dev->dev, "reset in start the mei device.\n");
 210
 211         dev->reset_count = 0;
 212         do {
 213                 mei_set_devstate(dev, MEI_DEV_INITIALIZING);
 214                 ret = mei_reset(dev);
 215
 216                 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 217                         dev_err(dev->dev, "reset failed ret = %d", ret);
 218                         goto err;
 219                 }
 220         } while (ret);
 221
 222         if (mei_hbm_start_wait(dev)) {
 223                 dev_err(dev->dev, "HBM haven't started");
 224                 goto err;
 225         }
 226
 227         if (!mei_hbm_version_is_supported(dev)) {
 228                 dev_dbg(dev->dev, "MEI start failed.\n");
 229                 goto err;
 230         }
 231
 232         dev_dbg(dev->dev, "link layer has been established.\n");
 233
 234         mutex_unlock(&dev->device_lock);
 235         return 0;
 236 err:
 237         dev_err(dev->dev, "link layer initialization failed.\n");
 238         mei_set_devstate(dev, MEI_DEV_DISABLED);
 239         mutex_unlock(&dev->device_lock);
 240         return -ENODEV;
 241 }
 242 EXPORT_SYMBOL_GPL(mei_start);
 243
 244 /**
 245  * mei_restart - restart device after suspend
 246  *
 247  * @dev: the device structure
 248  *
 249  * Return: 0 on success or -ENODEV if the restart hasn't succeeded
 250  */
 251 int mei_restart(struct mei_device *dev)
 252 {
 253         int err;
 254
 255         mutex_lock(&dev->device_lock);
 256
 257         mei_set_devstate(dev, MEI_DEV_POWER_UP);
 258         dev->reset_count = 0;
 259
 260         err = mei_reset(dev);
 261
 262         mutex_unlock(&dev->device_lock);
 263
 264         if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 265                 dev_err(dev->dev, "device disabled = %d\n", err);
 266                 return -ENODEV;
 267         }
 268
 269         /* try to start again */
 270         if (err)
 271                 schedule_work(&dev->reset_work);
 272
 273
 274         return 0;
 275 }
 276 EXPORT_SYMBOL_GPL(mei_restart);
 277
 278 static void mei_reset_work(struct work_struct *work)
 279 {
 280         struct mei_device *dev =
 281                 container_of(work, struct mei_device,  reset_work);
 282         int ret;
 283
 284         mei_clear_interrupts(dev);
 285         mei_synchronize_irq(dev);
 286
 287         mutex_lock(&dev->device_lock);
 288
 289         ret = mei_reset(dev);
 290
 291         mutex_unlock(&dev->device_lock);
 292
 293         if (dev->dev_state == MEI_DEV_DISABLED) {
 294                 dev_err(dev->dev, "device disabled = %d\n", ret);
 295                 return;
 296         }
 297
 298         /* retry reset in case of failure */
 299         if (ret)
 300                 schedule_work(&dev->reset_work);
 301 }
 302
 303 void mei_stop(struct mei_device *dev)
 304 {
 305         dev_dbg(dev->dev, "stopping the device.\n");
 306
 307         mutex_lock(&dev->device_lock);
 308         mei_set_devstate(dev, MEI_DEV_POWERING_DOWN);
 309         mutex_unlock(&dev->device_lock);
 310         mei_cl_bus_remove_devices(dev);
 311         mutex_lock(&dev->device_lock);
 312         mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
 313         mutex_unlock(&dev->device_lock);
 314
 315         mei_cancel_work(dev);
 316
 317         mei_clear_interrupts(dev);
 318         mei_synchronize_irq(dev);
 319         /* to catch HW-initiated reset */
 320         mei_cancel_work(dev);
 321
 322         mutex_lock(&dev->device_lock);
 323
 324         mei_reset(dev);
 325         /* move device to disabled state unconditionally */
 326         mei_set_devstate(dev, MEI_DEV_DISABLED);
 327
 328         mutex_unlock(&dev->device_lock);
 329 }
 330 EXPORT_SYMBOL_GPL(mei_stop);
 331
 332 /**
 333  * mei_write_is_idle - check if the write queues are idle
 334  *
 335  * @dev: the device structure
 336  *
 337  * Return: true of there is no pending write
 338  */
 339 bool mei_write_is_idle(struct mei_device *dev)
 340 {
 341         bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
 342                 list_empty(&dev->ctrl_wr_list) &&
 343                 list_empty(&dev->write_list)   &&
 344                 list_empty(&dev->write_waiting_list));
 345
 346         dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
 347                 idle,
 348                 mei_dev_state_str(dev->dev_state),
 349                 list_empty(&dev->ctrl_wr_list),
 350                 list_empty(&dev->write_list),
 351                 list_empty(&dev->write_waiting_list));
 352
 353         return idle;
 354 }
 355 EXPORT_SYMBOL_GPL(mei_write_is_idle);
 356
 357 /**
 358  * mei_device_init - initialize mei_device structure
 359  *
 360  * @dev: the mei device
 361  * @device: the device structure
 362  * @slow_fw: configure longer timeouts as FW is slow
 363  * @hw_ops: hw operations
 364  */
 365 void mei_device_init(struct mei_device *dev,
 366                      struct device *device,
 367                      bool slow_fw,
 368                      const struct mei_hw_ops *hw_ops)
 369 {
 370         /* setup our list array */
 371         INIT_LIST_HEAD(&dev->file_list);
 372         INIT_LIST_HEAD(&dev->device_list);
 373         INIT_LIST_HEAD(&dev->me_clients);
 374         mutex_init(&dev->device_lock);
 375         init_rwsem(&dev->me_clients_rwsem);
 376         mutex_init(&dev->cl_bus_lock);
 377         init_waitqueue_head(&dev->wait_hw_ready);
 378         init_waitqueue_head(&dev->wait_pg);
 379         init_waitqueue_head(&dev->wait_hbm_start);
 380         dev->dev_state = MEI_DEV_INITIALIZING;
 381         dev->reset_count = 0;
 382
 383         INIT_LIST_HEAD(&dev->write_list);
 384         INIT_LIST_HEAD(&dev->write_waiting_list);
 385         INIT_LIST_HEAD(&dev->ctrl_wr_list);
 386         INIT_LIST_HEAD(&dev->ctrl_rd_list);
 387         dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT;
 388
 389         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 390         INIT_WORK(&dev->reset_work, mei_reset_work);
 391         INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
 392
 393         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 394         dev->open_handle_count = 0;
 395
 396         dev->pxp_mode = MEI_DEV_PXP_DEFAULT;
 397
 398         /*
 399          * Reserving the first client ID
 400          * 0: Reserved for MEI Bus Message communications
 401          */
 402         bitmap_set(dev->host_clients_map, 0, 1);
 403
 404         dev->pg_event = MEI_PG_EVENT_IDLE;
 405         dev->ops      = hw_ops;
 406         dev->dev      = device;
 407
 408         dev->timeouts.hw_ready = mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT);
 409         dev->timeouts.connect = MEI_CONNECT_TIMEOUT;
 410         dev->timeouts.client_init = MEI_CLIENTS_INIT_TIMEOUT;
 411         dev->timeouts.pgi = mei_secs_to_jiffies(MEI_PGI_TIMEOUT);
 412         dev->timeouts.d0i3 = mei_secs_to_jiffies(MEI_D0I3_TIMEOUT);
 413         if (slow_fw) {
 414                 dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT_SLOW);
 415                 dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT_SLOW);
 416                 dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT_SLOW);
 417         } else {
 418                 dev->timeouts.cl_connect = mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT);
 419                 dev->timeouts.hbm = mei_secs_to_jiffies(MEI_HBM_TIMEOUT);
 420                 dev->timeouts.mkhi_recv = msecs_to_jiffies(MKHI_RCV_TIMEOUT);
 421         }
 422 }
 423 EXPORT_SYMBOL_GPL(mei_device_init);
 424