drivers/misc/mei/init.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2012-2018, 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         mei_hw_config(dev);
 194
 195         dev_dbg(dev->dev, "reset in start the mei device.\n");
 196
 197         dev->reset_count = 0;
 198         do {
 199                 mei_set_devstate(dev, MEI_DEV_INITIALIZING);
 200                 ret = mei_reset(dev);
 201
 202                 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 203                         dev_err(dev->dev, "reset failed ret = %d", ret);
 204                         goto err;
 205                 }
 206         } while (ret);
 207
 208         if (mei_hbm_start_wait(dev)) {
 209                 dev_err(dev->dev, "HBM haven't started");
 210                 goto err;
 211         }
 212
 213         if (!mei_host_is_ready(dev)) {
 214                 dev_err(dev->dev, "host is not ready.\n");
 215                 goto err;
 216         }
 217
 218         if (!mei_hw_is_ready(dev)) {
 219                 dev_err(dev->dev, "ME is not ready.\n");
 220                 goto err;
 221         }
 222
 223         if (!mei_hbm_version_is_supported(dev)) {
 224                 dev_dbg(dev->dev, "MEI start failed.\n");
 225                 goto err;
 226         }
 227
 228         dev_dbg(dev->dev, "link layer has been established.\n");
 229
 230         mutex_unlock(&dev->device_lock);
 231         return 0;
 232 err:
 233         dev_err(dev->dev, "link layer initialization failed.\n");
 234         mei_set_devstate(dev, MEI_DEV_DISABLED);
 235         mutex_unlock(&dev->device_lock);
 236         return -ENODEV;
 237 }
 238 EXPORT_SYMBOL_GPL(mei_start);
 239
 240 /**
 241  * mei_restart - restart device after suspend
 242  *
 243  * @dev: the device structure
 244  *
 245  * Return: 0 on success or -ENODEV if the restart hasn't succeeded
 246  */
 247 int mei_restart(struct mei_device *dev)
 248 {
 249         int err;
 250
 251         mutex_lock(&dev->device_lock);
 252
 253         mei_set_devstate(dev, MEI_DEV_POWER_UP);
 254         dev->reset_count = 0;
 255
 256         err = mei_reset(dev);
 257
 258         mutex_unlock(&dev->device_lock);
 259
 260         if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 261                 dev_err(dev->dev, "device disabled = %d\n", err);
 262                 return -ENODEV;
 263         }
 264
 265         /* try to start again */
 266         if (err)
 267                 schedule_work(&dev->reset_work);
 268
 269
 270         return 0;
 271 }
 272 EXPORT_SYMBOL_GPL(mei_restart);
 273
 274 static void mei_reset_work(struct work_struct *work)
 275 {
 276         struct mei_device *dev =
 277                 container_of(work, struct mei_device,  reset_work);
 278         int ret;
 279
 280         mei_clear_interrupts(dev);
 281         mei_synchronize_irq(dev);
 282
 283         mutex_lock(&dev->device_lock);
 284
 285         ret = mei_reset(dev);
 286
 287         mutex_unlock(&dev->device_lock);
 288
 289         if (dev->dev_state == MEI_DEV_DISABLED) {
 290                 dev_err(dev->dev, "device disabled = %d\n", ret);
 291                 return;
 292         }
 293
 294         /* retry reset in case of failure */
 295         if (ret)
 296                 schedule_work(&dev->reset_work);
 297 }
 298
 299 void mei_stop(struct mei_device *dev)
 300 {
 301         dev_dbg(dev->dev, "stopping the device.\n");
 302
 303         mutex_lock(&dev->device_lock);
 304         mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
 305         mutex_unlock(&dev->device_lock);
 306         mei_cl_bus_remove_devices(dev);
 307
 308         mei_cancel_work(dev);
 309
 310         mei_clear_interrupts(dev);
 311         mei_synchronize_irq(dev);
 312
 313         mutex_lock(&dev->device_lock);
 314
 315         mei_reset(dev);
 316         /* move device to disabled state unconditionally */
 317         mei_set_devstate(dev, MEI_DEV_DISABLED);
 318
 319         mutex_unlock(&dev->device_lock);
 320 }
 321 EXPORT_SYMBOL_GPL(mei_stop);
 322
 323 /**
 324  * mei_write_is_idle - check if the write queues are idle
 325  *
 326  * @dev: the device structure
 327  *
 328  * Return: true of there is no pending write
 329  */
 330 bool mei_write_is_idle(struct mei_device *dev)
 331 {
 332         bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
 333                 list_empty(&dev->ctrl_wr_list) &&
 334                 list_empty(&dev->write_list)   &&
 335                 list_empty(&dev->write_waiting_list));
 336
 337         dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n",
 338                 idle,
 339                 mei_dev_state_str(dev->dev_state),
 340                 list_empty(&dev->ctrl_wr_list),
 341                 list_empty(&dev->write_list),
 342                 list_empty(&dev->write_waiting_list));
 343
 344         return idle;
 345 }
 346 EXPORT_SYMBOL_GPL(mei_write_is_idle);
 347
 348 /**
 349  * mei_device_init  -- initialize mei_device structure
 350  *
 351  * @dev: the mei device
 352  * @device: the device structure
 353  * @hw_ops: hw operations
 354  */
 355 void mei_device_init(struct mei_device *dev,
 356                      struct device *device,
 357                      const struct mei_hw_ops *hw_ops)
 358 {
 359         /* setup our list array */
 360         INIT_LIST_HEAD(&dev->file_list);
 361         INIT_LIST_HEAD(&dev->device_list);
 362         INIT_LIST_HEAD(&dev->me_clients);
 363         mutex_init(&dev->device_lock);
 364         init_rwsem(&dev->me_clients_rwsem);
 365         mutex_init(&dev->cl_bus_lock);
 366         init_waitqueue_head(&dev->wait_hw_ready);
 367         init_waitqueue_head(&dev->wait_pg);
 368         init_waitqueue_head(&dev->wait_hbm_start);
 369         dev->dev_state = MEI_DEV_INITIALIZING;
 370         dev->reset_count = 0;
 371
 372         INIT_LIST_HEAD(&dev->write_list);
 373         INIT_LIST_HEAD(&dev->write_waiting_list);
 374         INIT_LIST_HEAD(&dev->ctrl_wr_list);
 375         INIT_LIST_HEAD(&dev->ctrl_rd_list);
 376         dev->tx_queue_limit = MEI_TX_QUEUE_LIMIT_DEFAULT;
 377
 378         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 379         INIT_WORK(&dev->reset_work, mei_reset_work);
 380         INIT_WORK(&dev->bus_rescan_work, mei_cl_bus_rescan_work);
 381
 382         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 383         dev->open_handle_count = 0;
 384
 385         /*
 386          * Reserving the first client ID
 387          * 0: Reserved for MEI Bus Message communications
 388          */
 389         bitmap_set(dev->host_clients_map, 0, 1);
 390
 391         dev->pg_event = MEI_PG_EVENT_IDLE;
 392         dev->ops      = hw_ops;
 393         dev->dev      = device;
 394 }
 395 EXPORT_SYMBOL_GPL(mei_device_init);
 396