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                 dev_warn(&dev->pdev->dev, "unexpected reset: dev_state = %s\n",
  79                          mei_dev_state_str(state));
  80
  81         /* we're already in reset, cancel the init timer
  82          * if the reset was called due the hbm protocol error
  83          * we need to call it before hw start
  84          * so the hbm watchdog won't kick in
  85          */
  86         mei_hbm_idle(dev);
  87
  88         /* enter reset flow */
  89         interrupts_enabled = state != MEI_DEV_POWER_DOWN;
  90         dev->dev_state = MEI_DEV_RESETTING;
  91
  92         dev->reset_count++;
  93         if (dev->reset_count > MEI_MAX_CONSEC_RESET) {
  94                 dev_err(&dev->pdev->dev, "reset: reached maximal consecutive resets: disabling the device\n");
  95                 dev->dev_state = MEI_DEV_DISABLED;
  96                 return -ENODEV;
  97         }
  98
  99         ret = mei_hw_reset(dev, interrupts_enabled);
 100         /* fall through and remove the sw state even if hw reset has failed */
 101
 102         /* no need to clean up software state in case of power up */
 103         if (state != MEI_DEV_INITIALIZING &&
 104             state != MEI_DEV_POWER_UP) {
 105
 106                 /* remove all waiting requests */
 107                 mei_cl_all_write_clear(dev);
 108
 109                 mei_cl_all_disconnect(dev);
 110
 111                 /* wake up all readers and writers so they can be interrupted */
 112                 mei_cl_all_wakeup(dev);
 113
 114                 /* remove entry if already in list */
 115                 dev_dbg(&dev->pdev->dev, "remove iamthif and wd from the file list.\n");
 116                 mei_cl_unlink(&dev->wd_cl);
 117                 mei_cl_unlink(&dev->iamthif_cl);
 118                 mei_amthif_reset_params(dev);
 119         }
 120
 121
 122         dev->me_clients_num = 0;
 123         dev->rd_msg_hdr = 0;
 124         dev->wd_pending = false;
 125
 126         if (ret) {
 127                 dev_err(&dev->pdev->dev, "hw_reset failed ret = %d\n", ret);
 128                 return ret;
 129         }
 130
 131         if (state == MEI_DEV_POWER_DOWN) {
 132                 dev_dbg(&dev->pdev->dev, "powering down: end of reset\n");
 133                 dev->dev_state = MEI_DEV_DISABLED;
 134                 return 0;
 135         }
 136
 137         ret = mei_hw_start(dev);
 138         if (ret) {
 139                 dev_err(&dev->pdev->dev, "hw_start failed ret = %d\n", ret);
 140                 return ret;
 141         }
 142
 143         dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n");
 144
 145         dev->dev_state = MEI_DEV_INIT_CLIENTS;
 146         ret = mei_hbm_start_req(dev);
 147         if (ret) {
 148                 dev_err(&dev->pdev->dev, "hbm_start failed ret = %d\n", ret);
 149                 dev->dev_state = MEI_DEV_RESETTING;
 150                 return ret;
 151         }
 152
 153         return 0;
 154 }
 155 EXPORT_SYMBOL_GPL(mei_reset);
 156
 157 /**
 158  * mei_start - initializes host and fw to start work.
 159  *
 160  * @dev: the device structure
 161  *
 162  * returns 0 on success, <0 on failure.
 163  */
 164 int mei_start(struct mei_device *dev)
 165 {
 166         int ret;
 167         mutex_lock(&dev->device_lock);
 168
 169         /* acknowledge interrupt and stop interrupts */
 170         mei_clear_interrupts(dev);
 171
 172         mei_hw_config(dev);
 173
 174         dev_dbg(&dev->pdev->dev, "reset in start the mei device.\n");
 175
 176         dev->reset_count = 0;
 177         do {
 178                 dev->dev_state = MEI_DEV_INITIALIZING;
 179                 ret = mei_reset(dev);
 180
 181                 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 182                         dev_err(&dev->pdev->dev, "reset failed ret = %d", ret);
 183                         goto err;
 184                 }
 185         } while (ret);
 186
 187         /* we cannot start the device w/o hbm start message completed */
 188         if (dev->dev_state == MEI_DEV_DISABLED) {
 189                 dev_err(&dev->pdev->dev, "reset failed");
 190                 goto err;
 191         }
 192
 193         if (mei_hbm_start_wait(dev)) {
 194                 dev_err(&dev->pdev->dev, "HBM haven't started");
 195                 goto err;
 196         }
 197
 198         if (!mei_host_is_ready(dev)) {
 199                 dev_err(&dev->pdev->dev, "host is not ready.\n");
 200                 goto err;
 201         }
 202
 203         if (!mei_hw_is_ready(dev)) {
 204                 dev_err(&dev->pdev->dev, "ME is not ready.\n");
 205                 goto err;
 206         }
 207
 208         if (!mei_hbm_version_is_supported(dev)) {
 209                 dev_dbg(&dev->pdev->dev, "MEI start failed.\n");
 210                 goto err;
 211         }
 212
 213         dev_dbg(&dev->pdev->dev, "link layer has been established.\n");
 214
 215         mutex_unlock(&dev->device_lock);
 216         return 0;
 217 err:
 218         dev_err(&dev->pdev->dev, "link layer initialization failed.\n");
 219         dev->dev_state = MEI_DEV_DISABLED;
 220         mutex_unlock(&dev->device_lock);
 221         return -ENODEV;
 222 }
 223 EXPORT_SYMBOL_GPL(mei_start);
 224
 225 /**
 226  * mei_restart - restart device after suspend
 227  *
 228  * @dev: the device structure
 229  *
 230  * returns 0 on success or -ENODEV if the restart hasn't succeeded
 231  */
 232 int mei_restart(struct mei_device *dev)
 233 {
 234         int err;
 235
 236         mutex_lock(&dev->device_lock);
 237
 238         mei_clear_interrupts(dev);
 239
 240         dev->dev_state = MEI_DEV_POWER_UP;
 241         dev->reset_count = 0;
 242
 243         err = mei_reset(dev);
 244
 245         mutex_unlock(&dev->device_lock);
 246
 247         if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 248                 dev_err(&dev->pdev->dev, "device disabled = %d\n", err);
 249                 return -ENODEV;
 250         }
 251
 252         /* try to start again */
 253         if (err)
 254                 schedule_work(&dev->reset_work);
 255
 256
 257         return 0;
 258 }
 259 EXPORT_SYMBOL_GPL(mei_restart);
 260
 261 static void mei_reset_work(struct work_struct *work)
 262 {
 263         struct mei_device *dev =
 264                 container_of(work, struct mei_device,  reset_work);
 265         int ret;
 266
 267         mutex_lock(&dev->device_lock);
 268
 269         ret = mei_reset(dev);
 270
 271         mutex_unlock(&dev->device_lock);
 272
 273         if (dev->dev_state == MEI_DEV_DISABLED) {
 274                 dev_err(&dev->pdev->dev, "device disabled = %d\n", ret);
 275                 return;
 276         }
 277
 278         /* retry reset in case of failure */
 279         if (ret)
 280                 schedule_work(&dev->reset_work);
 281 }
 282
 283 void mei_stop(struct mei_device *dev)
 284 {
 285         dev_dbg(&dev->pdev->dev, "stopping the device.\n");
 286
 287         mei_cancel_work(dev);
 288
 289         mei_nfc_host_exit(dev);
 290
 291         mei_cl_bus_remove_devices(dev);
 292
 293         mutex_lock(&dev->device_lock);
 294
 295         mei_wd_stop(dev);
 296
 297         dev->dev_state = MEI_DEV_POWER_DOWN;
 298         mei_reset(dev);
 299
 300         mutex_unlock(&dev->device_lock);
 301
 302         mei_watchdog_unregister(dev);
 303 }
 304 EXPORT_SYMBOL_GPL(mei_stop);
 305
 306
 307
 308 void mei_device_init(struct mei_device *dev)
 309 {
 310         /* setup our list array */
 311         INIT_LIST_HEAD(&dev->file_list);
 312         INIT_LIST_HEAD(&dev->device_list);
 313         mutex_init(&dev->device_lock);
 314         init_waitqueue_head(&dev->wait_hw_ready);
 315         init_waitqueue_head(&dev->wait_recvd_msg);
 316         init_waitqueue_head(&dev->wait_stop_wd);
 317         dev->dev_state = MEI_DEV_INITIALIZING;
 318         dev->reset_count = 0;
 319
 320         mei_io_list_init(&dev->read_list);
 321         mei_io_list_init(&dev->write_list);
 322         mei_io_list_init(&dev->write_waiting_list);
 323         mei_io_list_init(&dev->ctrl_wr_list);
 324         mei_io_list_init(&dev->ctrl_rd_list);
 325
 326         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 327         INIT_WORK(&dev->init_work, mei_host_client_init);
 328         INIT_WORK(&dev->reset_work, mei_reset_work);
 329
 330         INIT_LIST_HEAD(&dev->wd_cl.link);
 331         INIT_LIST_HEAD(&dev->iamthif_cl.link);
 332         mei_io_list_init(&dev->amthif_cmd_list);
 333         mei_io_list_init(&dev->amthif_rd_complete_list);
 334
 335         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 336         dev->open_handle_count = 0;
 337
 338         /*
 339          * Reserving the first client ID
 340          * 0: Reserved for MEI Bus Message communications
 341          */
 342         bitmap_set(dev->host_clients_map, 0, 1);
 343 }
 344 EXPORT_SYMBOL_GPL(mei_device_init);
 345