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