Pileus Git - ~andy/linux/blob - drivers/misc/mei/wd.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 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/moduleparam.h>
  19 #include <linux/device.h>
  20 #include <linux/pci.h>
  21 #include <linux/sched.h>
  22 #include <linux/watchdog.h>
  23
  24 #include <linux/mei.h>
  25
  26 #include "mei_dev.h"
  27 #include "hbm.h"
  28 #include "hw-me.h"
  29 #include "client.h"
  30
  31 static const u8 mei_start_wd_params[] = { 0x02, 0x12, 0x13, 0x10 };
  32 static const u8 mei_stop_wd_params[] = { 0x02, 0x02, 0x14, 0x10 };
  33
  34 const u8 mei_wd_state_independence_msg[3][4] = {
  35         {0x05, 0x02, 0x51, 0x10},
  36         {0x05, 0x02, 0x52, 0x10},
  37         {0x07, 0x02, 0x01, 0x10}
  38 };
  39
  40 /*
  41  * AMT Watchdog Device
  42  */
  43 #define INTEL_AMT_WATCHDOG_ID "INTCAMT"
  44
  45 /* UUIDs for AMT F/W clients */
  46 const uuid_le mei_wd_guid = UUID_LE(0x05B79A6F, 0x4628, 0x4D7F, 0x89,
  47                                                 0x9D, 0xA9, 0x15, 0x14, 0xCB,
  48                                                 0x32, 0xAB);
  49
  50 static void mei_wd_set_start_timeout(struct mei_device *dev, u16 timeout)
  51 {
  52         dev_dbg(&dev->pdev->dev, "wd: set timeout=%d.\n", timeout);
  53         memcpy(dev->wd_data, mei_start_wd_params, MEI_WD_HDR_SIZE);
  54         memcpy(dev->wd_data + MEI_WD_HDR_SIZE, &timeout, sizeof(u16));
  55 }
  56
  57 /**
  58  * mei_wd_host_init - connect to the watchdog client
  59  *
  60  * @dev: the device structure
  61  * returns -ENENT if wd client cannot be found
  62  *         -EIO if write has failed
  63  *         0 on success
  64  */
  65 int mei_wd_host_init(struct mei_device *dev)
  66 {
  67         struct mei_cl *cl = &dev->wd_cl;
  68         int i;
  69         int ret;
  70
  71         mei_cl_init(cl, dev);
  72
  73         dev->wd_timeout = MEI_WD_DEFAULT_TIMEOUT;
  74         dev->wd_state = MEI_WD_IDLE;
  75
  76
  77         /* check for valid client id */
  78         i = mei_me_cl_by_uuid(dev, &mei_wd_guid);
  79         if (i < 0) {
  80                 dev_info(&dev->pdev->dev, "wd: failed to find the client\n");
  81                 return -ENOENT;
  82         }
  83
  84         cl->me_client_id = dev->me_clients[i].client_id;
  85
  86         ret = mei_cl_link(cl, MEI_WD_HOST_CLIENT_ID);
  87
  88         if (ret < 0) {
  89                 dev_info(&dev->pdev->dev, "wd: failed link client\n");
  90                 return -ENOENT;
  91         }
  92
  93         cl->state = MEI_FILE_CONNECTING;
  94
  95         if (mei_hbm_cl_connect_req(dev, cl)) {
  96                 dev_err(&dev->pdev->dev, "wd: failed to connect to the client\n");
  97                 cl->state = MEI_FILE_DISCONNECTED;
  98                 cl->host_client_id = 0;
  99                 return -EIO;
 100         }
 101         cl->timer_count = MEI_CONNECT_TIMEOUT;
 102
 103         return 0;
 104 }
 105
 106 /**
 107  * mei_wd_send - sends watch dog message to fw.
 108  *
 109  * @dev: the device structure
 110  *
 111  * returns 0 if success,
 112  *      -EIO when message send fails
 113  *      -EINVAL when invalid message is to be sent
 114  */
 115 int mei_wd_send(struct mei_device *dev)
 116 {
 117         struct mei_msg_hdr hdr;
 118
 119         hdr.host_addr = dev->wd_cl.host_client_id;
 120         hdr.me_addr = dev->wd_cl.me_client_id;
 121         hdr.msg_complete = 1;
 122         hdr.reserved = 0;
 123
 124         if (!memcmp(dev->wd_data, mei_start_wd_params, MEI_WD_HDR_SIZE))
 125                 hdr.length = MEI_WD_START_MSG_SIZE;
 126         else if (!memcmp(dev->wd_data, mei_stop_wd_params, MEI_WD_HDR_SIZE))
 127                 hdr.length = MEI_WD_STOP_MSG_SIZE;
 128         else
 129                 return -EINVAL;
 130
 131         return mei_write_message(dev, &hdr, dev->wd_data);
 132 }
 133
 134 /**
 135  * mei_wd_stop - sends watchdog stop message to fw.
 136  *
 137  * @dev: the device structure
 138  * @preserve: indicate if to keep the timeout value
 139  *
 140  * returns 0 if success,
 141  *      -EIO when message send fails
 142  *      -EINVAL when invalid message is to be sent
 143  */
 144 int mei_wd_stop(struct mei_device *dev)
 145 {
 146         int ret;
 147
 148         if (dev->wd_cl.state != MEI_FILE_CONNECTED ||
 149             dev->wd_state != MEI_WD_RUNNING)
 150                 return 0;
 151
 152         memcpy(dev->wd_data, mei_stop_wd_params, MEI_WD_STOP_MSG_SIZE);
 153
 154         dev->wd_state = MEI_WD_STOPPING;
 155
 156         ret = mei_cl_flow_ctrl_creds(&dev->wd_cl);
 157         if (ret < 0)
 158                 goto out;
 159
 160         if (ret && dev->hbuf_is_ready) {
 161                 ret = 0;
 162                 dev->hbuf_is_ready = false;
 163
 164                 if (!mei_wd_send(dev)) {
 165                         ret = mei_cl_flow_ctrl_reduce(&dev->wd_cl);
 166                         if (ret)
 167                                 goto out;
 168                 } else {
 169                         dev_err(&dev->pdev->dev, "wd: send stop failed\n");
 170                 }
 171
 172                 dev->wd_pending = false;
 173         } else {
 174                 dev->wd_pending = true;
 175         }
 176
 177         mutex_unlock(&dev->device_lock);
 178
 179         ret = wait_event_interruptible_timeout(dev->wait_stop_wd,
 180                                         dev->wd_state == MEI_WD_IDLE,
 181                                         msecs_to_jiffies(MEI_WD_STOP_TIMEOUT));
 182         mutex_lock(&dev->device_lock);
 183         if (dev->wd_state == MEI_WD_IDLE) {
 184                 dev_dbg(&dev->pdev->dev, "wd: stop completed ret=%d.\n", ret);
 185                 ret = 0;
 186         } else {
 187                 if (!ret)
 188                         ret = -ETIMEDOUT;
 189                 dev_warn(&dev->pdev->dev,
 190                         "wd: stop failed to complete ret=%d.\n", ret);
 191         }
 192
 193 out:
 194         return ret;
 195 }
 196
 197 /*
 198  * mei_wd_ops_start - wd start command from the watchdog core.
 199  *
 200  * @wd_dev - watchdog device struct
 201  *
 202  * returns 0 if success, negative errno code for failure
 203  */
 204 static int mei_wd_ops_start(struct watchdog_device *wd_dev)
 205 {
 206         int err = -ENODEV;
 207         struct mei_device *dev;
 208
 209         dev = watchdog_get_drvdata(wd_dev);
 210         if (!dev)
 211                 return -ENODEV;
 212
 213         mutex_lock(&dev->device_lock);
 214
 215         if (dev->dev_state != MEI_DEV_ENABLED) {
 216                 dev_dbg(&dev->pdev->dev,
 217                         "wd: dev_state != MEI_DEV_ENABLED  dev_state = %s\n",
 218                         mei_dev_state_str(dev->dev_state));
 219                 goto end_unlock;
 220         }
 221
 222         if (dev->wd_cl.state != MEI_FILE_CONNECTED)     {
 223                 dev_dbg(&dev->pdev->dev,
 224                         "MEI Driver is not connected to Watchdog Client\n");
 225                 goto end_unlock;
 226         }
 227
 228         mei_wd_set_start_timeout(dev, dev->wd_timeout);
 229
 230         err = 0;
 231 end_unlock:
 232         mutex_unlock(&dev->device_lock);
 233         return err;
 234 }
 235
 236 /*
 237  * mei_wd_ops_stop -  wd stop command from the watchdog core.
 238  *
 239  * @wd_dev - watchdog device struct
 240  *
 241  * returns 0 if success, negative errno code for failure
 242  */
 243 static int mei_wd_ops_stop(struct watchdog_device *wd_dev)
 244 {
 245         struct mei_device *dev;
 246
 247         dev = watchdog_get_drvdata(wd_dev);
 248         if (!dev)
 249                 return -ENODEV;
 250
 251         mutex_lock(&dev->device_lock);
 252         mei_wd_stop(dev);
 253         mutex_unlock(&dev->device_lock);
 254
 255         return 0;
 256 }
 257
 258 /*
 259  * mei_wd_ops_ping - wd ping command from the watchdog core.
 260  *
 261  * @wd_dev - watchdog device struct
 262  *
 263  * returns 0 if success, negative errno code for failure
 264  */
 265 static int mei_wd_ops_ping(struct watchdog_device *wd_dev)
 266 {
 267         int ret = 0;
 268         struct mei_device *dev;
 269
 270         dev = watchdog_get_drvdata(wd_dev);
 271         if (!dev)
 272                 return -ENODEV;
 273
 274         mutex_lock(&dev->device_lock);
 275
 276         if (dev->wd_cl.state != MEI_FILE_CONNECTED) {
 277                 dev_err(&dev->pdev->dev, "wd: not connected.\n");
 278                 ret = -ENODEV;
 279                 goto end;
 280         }
 281
 282         dev->wd_state = MEI_WD_RUNNING;
 283
 284         /* Check if we can send the ping to HW*/
 285         if (dev->hbuf_is_ready && mei_cl_flow_ctrl_creds(&dev->wd_cl) > 0) {
 286
 287                 dev->hbuf_is_ready = false;
 288                 dev_dbg(&dev->pdev->dev, "wd: sending ping\n");
 289
 290                 if (mei_wd_send(dev)) {
 291                         dev_err(&dev->pdev->dev, "wd: send failed.\n");
 292                         ret = -EIO;
 293                         goto end;
 294                 }
 295
 296                 if (mei_cl_flow_ctrl_reduce(&dev->wd_cl)) {
 297                         dev_err(&dev->pdev->dev,
 298                                 "wd: mei_cl_flow_ctrl_reduce() failed.\n");
 299                         ret = -EIO;
 300                         goto end;
 301                 }
 302
 303         } else {
 304                 dev->wd_pending = true;
 305         }
 306
 307 end:
 308         mutex_unlock(&dev->device_lock);
 309         return ret;
 310 }
 311
 312 /*
 313  * mei_wd_ops_set_timeout - wd set timeout command from the watchdog core.
 314  *
 315  * @wd_dev - watchdog device struct
 316  * @timeout - timeout value to set
 317  *
 318  * returns 0 if success, negative errno code for failure
 319  */
 320 static int mei_wd_ops_set_timeout(struct watchdog_device *wd_dev, unsigned int timeout)
 321 {
 322         struct mei_device *dev;
 323
 324         dev = watchdog_get_drvdata(wd_dev);
 325         if (!dev)
 326                 return -ENODEV;
 327
 328         /* Check Timeout value */
 329         if (timeout < MEI_WD_MIN_TIMEOUT || timeout > MEI_WD_MAX_TIMEOUT)
 330                 return -EINVAL;
 331
 332         mutex_lock(&dev->device_lock);
 333
 334         dev->wd_timeout = timeout;
 335         wd_dev->timeout = timeout;
 336         mei_wd_set_start_timeout(dev, dev->wd_timeout);
 337
 338         mutex_unlock(&dev->device_lock);
 339
 340         return 0;
 341 }
 342
 343 /*
 344  * Watchdog Device structs
 345  */
 346 static const struct watchdog_ops wd_ops = {
 347                 .owner = THIS_MODULE,
 348                 .start = mei_wd_ops_start,
 349                 .stop = mei_wd_ops_stop,
 350                 .ping = mei_wd_ops_ping,
 351                 .set_timeout = mei_wd_ops_set_timeout,
 352 };
 353 static const struct watchdog_info wd_info = {
 354                 .identity = INTEL_AMT_WATCHDOG_ID,
 355                 .options = WDIOF_KEEPALIVEPING |
 356                            WDIOF_SETTIMEOUT |
 357                            WDIOF_ALARMONLY,
 358 };
 359
 360 static struct watchdog_device amt_wd_dev = {
 361                 .info = &wd_info,
 362                 .ops = &wd_ops,
 363                 .timeout = MEI_WD_DEFAULT_TIMEOUT,
 364                 .min_timeout = MEI_WD_MIN_TIMEOUT,
 365                 .max_timeout = MEI_WD_MAX_TIMEOUT,
 366 };
 367
 368
 369 void mei_watchdog_register(struct mei_device *dev)
 370 {
 371         if (watchdog_register_device(&amt_wd_dev)) {
 372                 dev_err(&dev->pdev->dev,
 373                         "wd: unable to register watchdog device.\n");
 374                 return;
 375         }
 376
 377         dev_dbg(&dev->pdev->dev,
 378                 "wd: successfully register watchdog interface.\n");
 379         watchdog_set_drvdata(&amt_wd_dev, dev);
 380 }
 381
 382 void mei_watchdog_unregister(struct mei_device *dev)
 383 {
 384         if (watchdog_get_drvdata(&amt_wd_dev) == NULL)
 385                 return;
 386
 387         watchdog_set_drvdata(&amt_wd_dev, NULL);
 388         watchdog_unregister_device(&amt_wd_dev);
 389 }
 390