drivers/misc/mei/init.c

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