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