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                 memset(&dev->wr_ext_msg, 0, sizeof(dev->wr_ext_msg));
 120         }
 121
 122
 123         dev->me_clients_num = 0;
 124         dev->rd_msg_hdr = 0;
 125         dev->wd_pending = false;
 126
 127         if (ret) {
 128                 dev_err(&dev->pdev->dev, "hw_reset failed ret = %d\n", ret);
 129                 return ret;
 130         }
 131
 132         if (state == MEI_DEV_POWER_DOWN) {
 133                 dev_dbg(&dev->pdev->dev, "powering down: end of reset\n");
 134                 dev->dev_state = MEI_DEV_DISABLED;
 135                 return 0;
 136         }
 137
 138         ret = mei_hw_start(dev);
 139         if (ret) {
 140                 dev_err(&dev->pdev->dev, "hw_start failed ret = %d\n", ret);
 141                 return ret;
 142         }
 143
 144         dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n");
 145
 146         dev->dev_state = MEI_DEV_INIT_CLIENTS;
 147         ret = mei_hbm_start_req(dev);
 148         if (ret) {
 149                 dev_err(&dev->pdev->dev, "hbm_start failed ret = %d\n", ret);
 150                 dev->dev_state = MEI_DEV_RESETTING;
 151                 return ret;
 152         }
 153
 154         return 0;
 155 }
 156 EXPORT_SYMBOL_GPL(mei_reset);
 157
 158 /**
 159  * mei_start - initializes host and fw to start work.
 160  *
 161  * @dev: the device structure
 162  *
 163  * returns 0 on success, <0 on failure.
 164  */
 165 int mei_start(struct mei_device *dev)
 166 {
 167         int ret;
 168         mutex_lock(&dev->device_lock);
 169
 170         /* acknowledge interrupt and stop interrupts */
 171         mei_clear_interrupts(dev);
 172
 173         mei_hw_config(dev);
 174
 175         dev_dbg(&dev->pdev->dev, "reset in start the mei device.\n");
 176
 177         dev->reset_count = 0;
 178         do {
 179                 dev->dev_state = MEI_DEV_INITIALIZING;
 180                 ret = mei_reset(dev);
 181
 182                 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 183                         dev_err(&dev->pdev->dev, "reset failed ret = %d", ret);
 184                         goto err;
 185                 }
 186         } while (ret);
 187
 188         /* we cannot start the device w/o hbm start message completed */
 189         if (dev->dev_state == MEI_DEV_DISABLED) {
 190                 dev_err(&dev->pdev->dev, "reset failed");
 191                 goto err;
 192         }
 193
 194         if (mei_hbm_start_wait(dev)) {
 195                 dev_err(&dev->pdev->dev, "HBM haven't started");
 196                 goto err;
 197         }
 198
 199         if (!mei_host_is_ready(dev)) {
 200                 dev_err(&dev->pdev->dev, "host is not ready.\n");
 201                 goto err;
 202         }
 203
 204         if (!mei_hw_is_ready(dev)) {
 205                 dev_err(&dev->pdev->dev, "ME is not ready.\n");
 206                 goto err;
 207         }
 208
 209         if (!mei_hbm_version_is_supported(dev)) {
 210                 dev_dbg(&dev->pdev->dev, "MEI start failed.\n");
 211                 goto err;
 212         }
 213
 214         dev_dbg(&dev->pdev->dev, "link layer has been established.\n");
 215
 216         mutex_unlock(&dev->device_lock);
 217         return 0;
 218 err:
 219         dev_err(&dev->pdev->dev, "link layer initialization failed.\n");
 220         dev->dev_state = MEI_DEV_DISABLED;
 221         mutex_unlock(&dev->device_lock);
 222         return -ENODEV;
 223 }
 224 EXPORT_SYMBOL_GPL(mei_start);
 225
 226 /**
 227  * mei_restart - restart device after suspend
 228  *
 229  * @dev: the device structure
 230  *
 231  * returns 0 on success or -ENODEV if the restart hasn't succeeded
 232  */
 233 int mei_restart(struct mei_device *dev)
 234 {
 235         int err;
 236
 237         mutex_lock(&dev->device_lock);
 238
 239         mei_clear_interrupts(dev);
 240
 241         dev->dev_state = MEI_DEV_POWER_UP;
 242         dev->reset_count = 0;
 243
 244         err = mei_reset(dev);
 245
 246         mutex_unlock(&dev->device_lock);
 247
 248         if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) {
 249                 dev_err(&dev->pdev->dev, "device disabled = %d\n", err);
 250                 return -ENODEV;
 251         }
 252
 253         /* try to start again */
 254         if (err)
 255                 schedule_work(&dev->reset_work);
 256
 257
 258         return 0;
 259 }
 260 EXPORT_SYMBOL_GPL(mei_restart);
 261
 262 static void mei_reset_work(struct work_struct *work)
 263 {
 264         struct mei_device *dev =
 265                 container_of(work, struct mei_device,  reset_work);
 266         int ret;
 267
 268         mutex_lock(&dev->device_lock);
 269
 270         ret = mei_reset(dev);
 271
 272         mutex_unlock(&dev->device_lock);
 273
 274         if (dev->dev_state == MEI_DEV_DISABLED) {
 275                 dev_err(&dev->pdev->dev, "device disabled = %d\n", ret);
 276                 return;
 277         }
 278
 279         /* retry reset in case of failure */
 280         if (ret)
 281                 schedule_work(&dev->reset_work);
 282 }
 283
 284 void mei_stop(struct mei_device *dev)
 285 {
 286         dev_dbg(&dev->pdev->dev, "stopping the device.\n");
 287
 288         mei_cancel_work(dev);
 289
 290         mei_nfc_host_exit(dev);
 291
 292         mutex_lock(&dev->device_lock);
 293
 294         mei_wd_stop(dev);
 295
 296         dev->dev_state = MEI_DEV_POWER_DOWN;
 297         mei_reset(dev);
 298
 299         mutex_unlock(&dev->device_lock);
 300
 301         mei_watchdog_unregister(dev);
 302 }
 303 EXPORT_SYMBOL_GPL(mei_stop);
 304
 305
 306
 307 void mei_device_init(struct mei_device *dev)
 308 {
 309         /* setup our list array */
 310         INIT_LIST_HEAD(&dev->file_list);
 311         INIT_LIST_HEAD(&dev->device_list);
 312         mutex_init(&dev->device_lock);
 313         init_waitqueue_head(&dev->wait_hw_ready);
 314         init_waitqueue_head(&dev->wait_recvd_msg);
 315         init_waitqueue_head(&dev->wait_stop_wd);
 316         dev->dev_state = MEI_DEV_INITIALIZING;
 317         dev->reset_count = 0;
 318
 319         mei_io_list_init(&dev->read_list);
 320         mei_io_list_init(&dev->write_list);
 321         mei_io_list_init(&dev->write_waiting_list);
 322         mei_io_list_init(&dev->ctrl_wr_list);
 323         mei_io_list_init(&dev->ctrl_rd_list);
 324
 325         INIT_DELAYED_WORK(&dev->timer_work, mei_timer);
 326         INIT_WORK(&dev->init_work, mei_host_client_init);
 327         INIT_WORK(&dev->reset_work, mei_reset_work);
 328
 329         INIT_LIST_HEAD(&dev->wd_cl.link);
 330         INIT_LIST_HEAD(&dev->iamthif_cl.link);
 331         mei_io_list_init(&dev->amthif_cmd_list);
 332         mei_io_list_init(&dev->amthif_rd_complete_list);
 333
 334         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 335         dev->open_handle_count = 0;
 336
 337         /*
 338          * Reserving the first client ID
 339          * 0: Reserved for MEI Bus Message communications
 340          */
 341         bitmap_set(dev->host_clients_map, 0, 1);
 342 }
 343 EXPORT_SYMBOL_GPL(mei_device_init);
 344