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_POWERING_DOWN);
 307         mutex_unlock(&dev->device_lock);
 308         mei_cl_bus_remove_devices(dev);
 309         mutex_lock(&dev->device_lock);
 310         mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
 311         mutex_unlock(&dev->device_lock);
 312
 313         mei_cancel_work(dev);
 314
 315         mei_clear_interrupts(dev);
 316         mei_synchronize_irq(dev);
 317
 318         mutex_lock(&dev->device_lock);
 319
 320         mei_reset(dev);
 321         /* move device to disabled state unconditionally */
 322         mei_set_devstate(dev, MEI_DEV_DISABLED);
 323
 324         mutex_unlock(&dev->device_lock);
 325 }
 326 EXPORT_SYMBOL_GPL(mei_stop);
 327
 328 /**
 329  * mei_write_is_idle - check if the write queues are idle
 330  *
 331  * @dev: the device structure
 332  *
 333  * Return: true of there is no pending write
 334  */
 335 bool mei_write_is_idle(struct mei_device *dev)
 336 {
 337         bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
 338                 list_empty(&dev->ctrl_wr_list) &&
 339                 list_empty(&dev->write_list)   &&
 340                 list_empty(&dev->write_waiting_list));
 341
 342         dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
 343                 idle,
 344                 mei_dev_state_str(dev->dev_state),
 345                 list_empty(&dev->ctrl_wr_list),
 346                 list_empty(&dev->write_list),
 347                 list_empty(&dev->write_waiting_list));
 348
 349         return idle;
 350 }
 351 EXPORT_SYMBOL_GPL(mei_write_is_idle);
 352
 353 /**
 354  * mei_device_init  -- initialize mei_device structure
 355  *
 356  * @dev: the mei device
 357  * @device: the device structure
 358  * @hw_ops: hw operations
 359  */
 360 void mei_device_init(struct mei_device *dev,
 361                      struct device *device,
 362                      const struct mei_hw_ops *hw_ops)
 363 {
 364         /* setup our list array */
 365         INIT_LIST_HEAD(&dev->file_list);
 366         INIT_LIST_HEAD(&dev->device_list);
 367         INIT_LIST_HEAD(&dev->me_clients);
 368         mutex_init(&dev->device_lock);
 369         init_rwsem(&dev->me_clients_rwsem);
 370         mutex_init(&dev->cl_bus_lock);
 371         init_waitqueue_head(&dev->wait_hw_ready);
 372         init_waitqueue_head(&dev->wait_pg);
 373         init_waitqueue_head(&dev->wait_hbm_start);
 374         dev->dev_state = MEI_DEV_INITIALIZING;
 375         dev->reset_count = 0;
 376
 377         INIT_LIST_HEAD(&dev->write_list);
 378         INIT_LIST_HEAD(&dev->write_waiting_list);
 379         INIT_LIST_HEAD(&dev->ctrl_wr_list);
 380         INIT_LIST_HEAD(&dev->ctrl_rd_list);
 381         dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT;
 382
 383         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 384         INIT_WORK(&dev->reset_work, mei_reset_work);
 385         INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
 386
 387         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 388         dev->open_handle_count = 0;
 389
 390         /*
 391          * Reserving the first client ID
 392          * 0: Reserved for MEI Bus Message communications
 393          */
 394         bitmap_set(dev->host_clients_map, 0, 1);
 395
 396         dev->pg_event = MEI_PG_EVENT_IDLE;
 397         dev->ops      = hw_ops;
 398         dev->dev      = device;
 399 }
 400 EXPORT_SYMBOL_GPL(mei_device_init);
 401