drivers/misc/mei/init.c

   1 /*
   2  *
   3  * Intel Management Engine Interface (Intel MEI) Linux driver
   4  * Copyright (c) 2003-2012, Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16
  17 #include <linux/export.h>
  18 #include <linux/pci.h>
  19 #include <linux/sched.h>
  20 #include <linux/wait.h>
  21 #include <linux/delay.h>
  22
  23 #include <linux/mei.h>
  24
  25 #include "mei_dev.h"
  26 #include "hbm.h"
  27 #include "client.h"
  28
  29 const char *mei_dev_state_str(int state)
  30 {
  31 #define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state
  32         switch (state) {
  33         MEI_DEV_STATE(INITIALIZING);
  34         MEI_DEV_STATE(INIT_CLIENTS);
  35         MEI_DEV_STATE(ENABLED);
  36         MEI_DEV_STATE(RESETTING);
  37         MEI_DEV_STATE(DISABLED);
  38         MEI_DEV_STATE(POWER_DOWN);
  39         MEI_DEV_STATE(POWER_UP);
  40         default:
  41                 return "unknown";
  42         }
  43 #undef MEI_DEV_STATE
  44 }
  45
  46
  47 /**
  48  * mei_cancel_work. Cancel mei background jobs
  49  *
  50  * @dev: the device structure
  51  *
  52  * returns 0 on success or < 0 if the reset hasn't succeeded
  53  */
  54 void mei_cancel_work(struct mei_device *dev)
  55 {
  56         cancel_work_sync(&dev->init_work);
  57         cancel_work_sync(&dev->reset_work);
  58
  59         cancel_delayed_work(&dev->timer_work);
  60 }
  61 EXPORT_SYMBOL_GPL(mei_cancel_work);
  62
  63 /**
  64  * mei_reset - resets host and fw.
  65  *
  66  * @dev: the device structure
  67  */
  68 int mei_reset(struct mei_device *dev)
  69 {
  70         enum mei_dev_state state = dev->dev_state;
  71         bool interrupts_enabled;
  72         int ret;
  73
  74         if (state != MEI_DEV_INITIALIZING &&
  75             state != MEI_DEV_DISABLED &&
  76             state != MEI_DEV_POWER_DOWN &&
  77             state != MEI_DEV_POWER_UP) {
  78                 struct mei_fw_status fw_status;
  79                 mei_fw_status(dev, &fw_status);
  80                 dev_warn(&dev->pdev->dev,
  81                         "unexpected reset: dev_state = %s " FW_STS_FMT "\n",
  82                         mei_dev_state_str(state), FW_STS_PRM(fw_status));
  83         }
  84
  85         /* we're already in reset, cancel the init timer
  86          * if the reset was called due the hbm protocol error
  87          * we need to call it before hw start
  88          * so the hbm watchdog won't kick in
  89          */
  90         mei_hbm_idle(dev);
  91
  92         /* enter reset flow */
  93         interrupts_enabled = state != MEI_DEV_POWER_DOWN;
  94         dev->dev_state = MEI_DEV_RESETTING;
  95
  96         dev->reset_count++;
  97         if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
  98                 dev_err(&dev->pdev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
  99                 dev->dev_state = MEI_DEV_DISABLED;
 100                 return -ENODEV;
 101         }
 102
 103         ret = mei_hw_reset(dev, interrupts_enabled);
 104         /* fall through and remove the sw state even if hw reset has failed */
 105
 106         /* no need to clean up software state in case of power up */
 107         if (state != MEI_DEV_INITIALIZING &&
 108             state != MEI_DEV_POWER_UP) {
 109
 110                 /* remove all waiting requests */
 111                 mei_cl_all_write_clear(dev);
 112
 113                 mei_cl_all_disconnect(dev);
 114
 115                 /* wake up all readers and writers so they can be interrupted */
 116                 mei_cl_all_wakeup(dev);
 117
 118                 /* remove entry if already in list */
 119                 dev_dbg(&dev->pdev->dev, "remove iamthif and wd from the file list.\n");
 120                 mei_cl_unlink(&dev->wd_cl);
 121                 mei_cl_unlink(&dev->iamthif_cl);
 122                 mei_amthif_reset_params(dev);
 123         }
 124
 125         mei_hbm_reset(dev);
 126
 127         dev->rd_msg_hdr = 0;
 128         dev->wd_pending = false;
 129
 130         if (ret) {
 131                 dev_err(&dev->pdev->dev, "hw_reset failed ret = %d\n", ret);
 132                 return ret;
 133         }
 134
 135         if (state == MEI_DEV_POWER_DOWN) {
 136                 dev_dbg(&dev->pdev->dev, "powering down: end of reset\n");
 137                 dev->dev_state = MEI_DEV_DISABLED;
 138                 return 0;
 139         }
 140
 141         ret = mei_hw_start(dev);
 142         if (ret) {
 143                 dev_err(&dev->pdev->dev, "hw_start failed ret = %d\n", ret);
 144                 return ret;
 145         }
 146
 147         dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n");
 148
 149         dev->dev_state = MEI_DEV_INIT_CLIENTS;
 150         ret = mei_hbm_start_req(dev);
 151         if (ret) {
 152                 dev_err(&dev->pdev->dev, "hbm_start failed ret = %d\n", ret);
 153                 dev->dev_state = MEI_DEV_RESETTING;
 154                 return ret;
 155         }
 156
 157         return 0;
 158 }
 159 EXPORT_SYMBOL_GPL(mei_reset);
 160
 161 /**
 162  * mei_start - initializes host and fw to start work.
 163  *
 164  * @dev: the device structure
 165  *
 166  * returns 0 on success, <0 on failure.
 167  */
 168 int mei_start(struct mei_device *dev)
 169 {
 170         int ret;
 171         mutex_lock(&dev->device_lock);
 172
 173         /* acknowledge interrupt and stop interrupts */
 174         mei_clear_interrupts(dev);
 175
 176         mei_hw_config(dev);
 177
 178         dev_dbg(&dev->pdev->dev, "reset in start the mei device.\n");
 179
 180         dev->reset_count = 0;
 181         do {
 182                 dev->dev_state = MEI_DEV_INITIALIZING;
 183                 ret = mei_reset(dev);
 184
 185                 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 186                         dev_err(&dev->pdev->dev, "reset failed ret = %d", ret);
 187                         goto err;
 188                 }
 189         } while (ret);
 190
 191         /* we cannot start the device w/o hbm start message completed */
 192         if (dev->dev_state == MEI_DEV_DISABLED) {
 193                 dev_err(&dev->pdev->dev, "reset failed");
 194                 goto err;
 195         }
 196
 197         if (mei_hbm_start_wait(dev)) {
 198                 dev_err(&dev->pdev->dev, "HBM haven't started");
 199                 goto err;
 200         }
 201
 202         if (!mei_host_is_ready(dev)) {
 203                 dev_err(&dev->pdev->dev, "host is not ready.\n");
 204                 goto err;
 205         }
 206
 207         if (!mei_hw_is_ready(dev)) {
 208                 dev_err(&dev->pdev->dev, "ME is not ready.\n");
 209                 goto err;
 210         }
 211
 212         if (!mei_hbm_version_is_supported(dev)) {
 213                 dev_dbg(&dev->pdev->dev, "MEI start failed.\n");
 214                 goto err;
 215         }
 216
 217         dev_dbg(&dev->pdev->dev, "link layer has been established.\n");
 218
 219         mutex_unlock(&dev->device_lock);
 220         return 0;
 221 err:
 222         dev_err(&dev->pdev->dev, "link layer initialization failed.\n");
 223         dev->dev_state = MEI_DEV_DISABLED;
 224         mutex_unlock(&dev->device_lock);
 225         return -ENODEV;
 226 }
 227 EXPORT_SYMBOL_GPL(mei_start);
 228
 229 /**
 230  * mei_restart - restart device after suspend
 231  *
 232  * @dev: the device structure
 233  *
 234  * returns 0 on success or -ENODEV if the restart hasn't succeeded
 235  */
 236 int mei_restart(struct mei_device *dev)
 237 {
 238         int err;
 239
 240         mutex_lock(&dev->device_lock);
 241
 242         mei_clear_interrupts(dev);
 243
 244         dev->dev_state = MEI_DEV_POWER_UP;
 245         dev->reset_count = 0;
 246
 247         err = mei_reset(dev);
 248
 249         mutex_unlock(&dev->device_lock);
 250
 251         if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 252                 dev_err(&dev->pdev->dev, "device disabled = %d\n", err);
 253                 return -ENODEV;
 254         }
 255
 256         /* try to start again */
 257         if (err)
 258                 schedule_work(&dev->reset_work);
 259
 260
 261         return 0;
 262 }
 263 EXPORT_SYMBOL_GPL(mei_restart);
 264
 265 static void mei_reset_work(struct work_struct *work)
 266 {
 267         struct mei_device *dev =
 268                 container_of(work, struct mei_device,  reset_work);
 269         int ret;
 270
 271         mutex_lock(&dev->device_lock);
 272
 273         ret = mei_reset(dev);
 274
 275         mutex_unlock(&dev->device_lock);
 276
 277         if (dev->dev_state == MEI_DEV_DISABLED) {
 278                 dev_err(&dev->pdev->dev, "device disabled = %d\n", ret);
 279                 return;
 280         }
 281
 282         /* retry reset in case of failure */
 283         if (ret)
 284                 schedule_work(&dev->reset_work);
 285 }
 286
 287 void mei_stop(struct mei_device *dev)
 288 {
 289         dev_dbg(&dev->pdev->dev, "stopping the device.\n");
 290
 291         mei_cancel_work(dev);
 292
 293         mei_nfc_host_exit(dev);
 294
 295         mei_cl_bus_remove_devices(dev);
 296
 297         mutex_lock(&dev->device_lock);
 298
 299         mei_wd_stop(dev);
 300
 301         dev->dev_state = MEI_DEV_POWER_DOWN;
 302         mei_reset(dev);
 303
 304         mutex_unlock(&dev->device_lock);
 305
 306         mei_watchdog_unregister(dev);
 307 }
 308 EXPORT_SYMBOL_GPL(mei_stop);
 309
 310 /**
 311  * mei_write_is_idle - check if the write queues are idle
 312  *
 313  * @dev: the device structure
 314  *
 315  * returns true of there is no pending write
 316  */
 317 bool mei_write_is_idle(struct mei_device *dev)
 318 {
 319         bool idle = (dev->dev_state == MEI_DEV_ENABLED &&
 320                 list_empty(&dev->ctrl_wr_list.list) &&
 321                 list_empty(&dev->write_list.list));
 322
 323         dev_dbg(&dev->pdev->dev, "write pg: is idle[%d] state=%s ctrl=%d write=%d\n",
 324                 idle,
 325                 mei_dev_state_str(dev->dev_state),
 326                 list_empty(&dev->ctrl_wr_list.list),
 327                 list_empty(&dev->write_list.list));
 328
 329         return idle;
 330 }
 331 EXPORT_SYMBOL_GPL(mei_write_is_idle);
 332
 333 int mei_fw_status(struct mei_device *dev, struct mei_fw_status *fw_status)
 334 {
 335         int i;
 336         const struct mei_fw_status *fw_src = &dev->cfg->fw_status;
 337
 338         if (!fw_status)
 339                 return -EINVAL;
 340
 341         fw_status->count = fw_src->count;
 342         for (i = 0; i < fw_src->count && i < MEI_FW_STATUS_MAX; i++) {
 343                 int ret;
 344                 ret = pci_read_config_dword(dev->pdev,
 345                         fw_src->status[i], &fw_status->status[i]);
 346                 if (ret)
 347                         return ret;
 348         }
 349
 350         return 0;
 351 }
 352 EXPORT_SYMBOL_GPL(mei_fw_status);
 353
 354 void mei_device_init(struct mei_device *dev, const struct mei_cfg *cfg)
 355 {
 356         /* setup our list array */
 357         INIT_LIST_HEAD(&dev->file_list);
 358         INIT_LIST_HEAD(&dev->device_list);
 359         mutex_init(&dev->device_lock);
 360         init_waitqueue_head(&dev->wait_hw_ready);
 361         init_waitqueue_head(&dev->wait_pg);
 362         init_waitqueue_head(&dev->wait_recvd_msg);
 363         init_waitqueue_head(&dev->wait_stop_wd);
 364         dev->dev_state = MEI_DEV_INITIALIZING;
 365         dev->reset_count = 0;
 366
 367         mei_io_list_init(&dev->read_list);
 368         mei_io_list_init(&dev->write_list);
 369         mei_io_list_init(&dev->write_waiting_list);
 370         mei_io_list_init(&dev->ctrl_wr_list);
 371         mei_io_list_init(&dev->ctrl_rd_list);
 372
 373         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 374         INIT_WORK(&dev->init_work, mei_host_client_init);
 375         INIT_WORK(&dev->reset_work, mei_reset_work);
 376
 377         INIT_LIST_HEAD(&dev->wd_cl.link);
 378         INIT_LIST_HEAD(&dev->iamthif_cl.link);
 379         mei_io_list_init(&dev->amthif_cmd_list);
 380         mei_io_list_init(&dev->amthif_rd_complete_list);
 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->cfg      = cfg;
 393 }
 394 EXPORT_SYMBOL_GPL(mei_device_init);
 395