kernel/drivers/misc/mei/amthif.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/kernel.h>
  18 #include <linux/fs.h>
  19 #include <linux/errno.h>
  20 #include <linux/types.h>
  21 #include <linux/fcntl.h>
  22 #include <linux/ioctl.h>
  23 #include <linux/cdev.h>
  24 #include <linux/list.h>
  25 #include <linux/delay.h>
  26 #include <linux/sched.h>
  27 #include <linux/uuid.h>
  28 #include <linux/jiffies.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/slab.h>
  31
  32 #include <linux/mei.h>
  33
  34 #include "mei_dev.h"
  35 #include "hbm.h"
  36 #include "client.h"
  37
  38 const uuid_le mei_amthif_guid  = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d,
  39                                          0xac, 0xa8, 0x46, 0xe0,
  40                                          0xff, 0x65, 0x81, 0x4c);
  41
  42 /**
  43  * mei_amthif_reset_params - initializes mei device iamthif
  44  *
  45  * @dev: the device structure
  46  */
  47 void mei_amthif_reset_params(struct mei_device *dev)
  48 {
  49         /* reset iamthif parameters. */
  50         dev->iamthif_current_cb = NULL;
  51         dev->iamthif_canceled = false;
  52         dev->iamthif_state = MEI_IAMTHIF_IDLE;
  53         dev->iamthif_timer = 0;
  54         dev->iamthif_stall_timer = 0;
  55         dev->iamthif_open_count = 0;
  56 }
  57
  58 /**
  59  * mei_amthif_host_init - mei initialization amthif client.
  60  *
  61  * @dev: the device structure
  62  * @me_cl: me client
  63  *
  64  * Return: 0 on success, <0 on failure.
  65  */
  66 int mei_amthif_host_init(struct mei_device *dev, struct mei_me_client *me_cl)
  67 {
  68         struct mei_cl *cl = &dev->iamthif_cl;
  69         int ret;
  70
  71         dev->iamthif_state = MEI_IAMTHIF_IDLE;
  72
  73         mei_cl_init(cl, dev);
  74
  75         ret = mei_cl_link(cl, MEI_IAMTHIF_HOST_CLIENT_ID);
  76         if (ret < 0) {
  77                 dev_err(dev->dev, "amthif: failed cl_link %d\n", ret);
  78                 return ret;
  79         }
  80
  81         ret = mei_cl_connect(cl, me_cl, NULL);
  82
  83         dev->iamthif_state = MEI_IAMTHIF_IDLE;
  84
  85         return ret;
  86 }
  87
  88 /**
  89  * mei_amthif_find_read_list_entry - finds a amthilist entry for current file
  90  *
  91  * @dev: the device structure
  92  * @file: pointer to file object
  93  *
  94  * Return:   returned a list entry on success, NULL on failure.
  95  */
  96 struct mei_cl_cb *mei_amthif_find_read_list_entry(struct mei_device *dev,
  97                                                 struct file *file)
  98 {
  99         struct mei_cl_cb *cb;
 100
 101         list_for_each_entry(cb, &dev->amthif_rd_complete_list.list, list)
 102                 if (cb->file_object == file)
 103                         return cb;
 104         return NULL;
 105 }
 106
 107
 108 /**
 109  * mei_amthif_read - read data from AMTHIF client
 110  *
 111  * @dev: the device structure
 112  * @file: pointer to file object
 113  * @ubuf: pointer to user data in user space
 114  * @length: data length to read
 115  * @offset: data read offset
 116  *
 117  * Locking: called under "dev->device_lock" lock
 118  *
 119  * Return:
 120  *  returned data length on success,
 121  *  zero if no data to read,
 122  *  negative on failure.
 123  */
 124 int mei_amthif_read(struct mei_device *dev, struct file *file,
 125                char __user *ubuf, size_t length, loff_t *offset)
 126 {
 127         struct mei_cl *cl = file->private_data;
 128         struct mei_cl_cb *cb;
 129         unsigned long timeout;
 130         int rets;
 131         int wait_ret;
 132
 133         /* Only possible if we are in timeout */
 134         if (!cl) {
 135                 dev_err(dev->dev, "bad file ext.\n");
 136                 return -ETIME;
 137         }
 138
 139         dev_dbg(dev->dev, "checking amthif data\n");
 140         cb = mei_amthif_find_read_list_entry(dev, file);
 141
 142         /* Check for if we can block or not*/
 143         if (cb == NULL && file->f_flags & O_NONBLOCK)
 144                 return -EAGAIN;
 145
 146
 147         dev_dbg(dev->dev, "waiting for amthif data\n");
 148         while (cb == NULL) {
 149                 /* unlock the Mutex */
 150                 mutex_unlock(&dev->device_lock);
 151
 152                 wait_ret = wait_event_interruptible(dev->iamthif_cl.wait,
 153                         (cb = mei_amthif_find_read_list_entry(dev, file)));
 154
 155                 /* Locking again the Mutex */
 156                 mutex_lock(&dev->device_lock);
 157
 158                 if (wait_ret)
 159                         return -ERESTARTSYS;
 160
 161                 dev_dbg(dev->dev, "woke up from sleep\n");
 162         }
 163
 164         if (cb->status) {
 165                 rets = cb->status;
 166                 dev_dbg(dev->dev, "read operation failed %d\n", rets);
 167                 goto free;
 168         }
 169
 170         dev_dbg(dev->dev, "Got amthif data\n");
 171         dev->iamthif_timer = 0;
 172
 173         timeout = cb->read_time +
 174                 mei_secs_to_jiffies(MEI_IAMTHIF_READ_TIMER);
 175         dev_dbg(dev->dev, "amthif timeout = %lud\n",
 176                         timeout);
 177
 178         if  (time_after(jiffies, timeout)) {
 179                 dev_dbg(dev->dev, "amthif Time out\n");
 180                 /* 15 sec for the message has expired */
 181                 list_del_init(&cb->list);
 182                 rets = -ETIME;
 183                 goto free;
 184         }
 185         /* if the whole message will fit remove it from the list */
 186         if (cb->buf_idx >= *offset && length >= (cb->buf_idx - *offset))
 187                 list_del_init(&cb->list);
 188         else if (cb->buf_idx > 0 && cb->buf_idx <= *offset) {
 189                 /* end of the message has been reached */
 190                 list_del_init(&cb->list);
 191                 rets = 0;
 192                 goto free;
 193         }
 194                 /* else means that not full buffer will be read and do not
 195                  * remove message from deletion list
 196                  */
 197
 198         dev_dbg(dev->dev, "amthif cb->buf size - %d\n",
 199             cb->buf.size);
 200         dev_dbg(dev->dev, "amthif cb->buf_idx - %lu\n", cb->buf_idx);
 201
 202         /* length is being truncated to PAGE_SIZE, however,
 203          * the buf_idx may point beyond */
 204         length = min_t(size_t, length, (cb->buf_idx - *offset));
 205
 206         if (copy_to_user(ubuf, cb->buf.data + *offset, length)) {
 207                 dev_dbg(dev->dev, "failed to copy data to userland\n");
 208                 rets = -EFAULT;
 209         } else {
 210                 rets = length;
 211                 if ((*offset + length) < cb->buf_idx) {
 212                         *offset += length;
 213                         goto out;
 214                 }
 215         }
 216 free:
 217         dev_dbg(dev->dev, "free amthif cb memory.\n");
 218         *offset = 0;
 219         mei_io_cb_free(cb);
 220 out:
 221         return rets;
 222 }
 223
 224 /**
 225  * mei_amthif_read_start - queue message for sending read credential
 226  *
 227  * @cl: host client
 228  * @file: file pointer of message recipient
 229  *
 230  * Return: 0 on success, <0 on failure.
 231  */
 232 static int mei_amthif_read_start(struct mei_cl *cl, struct file *file)
 233 {
 234         struct mei_device *dev = cl->dev;
 235         struct mei_cl_cb *cb;
 236         int rets;
 237
 238         cb = mei_io_cb_init(cl, MEI_FOP_READ, file);
 239         if (!cb) {
 240                 rets = -ENOMEM;
 241                 goto err;
 242         }
 243
 244         rets = mei_io_cb_alloc_buf(cb, mei_cl_mtu(cl));
 245         if (rets)
 246                 goto err;
 247
 248         list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
 249
 250         dev->iamthif_state = MEI_IAMTHIF_READING;
 251         dev->iamthif_file_object = cb->file_object;
 252         dev->iamthif_current_cb = cb;
 253
 254         return 0;
 255 err:
 256         mei_io_cb_free(cb);
 257         return rets;
 258 }
 259
 260 /**
 261  * mei_amthif_send_cmd - send amthif command to the ME
 262  *
 263  * @cl: the host client
 264  * @cb: mei call back struct
 265  *
 266  * Return: 0 on success, <0 on failure.
 267  */
 268 static int mei_amthif_send_cmd(struct mei_cl *cl, struct mei_cl_cb *cb)
 269 {
 270         struct mei_device *dev;
 271         int ret;
 272
 273         if (!cl->dev || !cb)
 274                 return -ENODEV;
 275
 276         dev = cl->dev;
 277
 278         dev->iamthif_state = MEI_IAMTHIF_WRITING;
 279         dev->iamthif_current_cb = cb;
 280         dev->iamthif_file_object = cb->file_object;
 281         dev->iamthif_canceled = false;
 282
 283         ret = mei_cl_write(cl, cb, false);
 284         if (ret < 0)
 285                 return ret;
 286
 287         if (cb->completed)
 288                 cb->status = mei_amthif_read_start(cl, cb->file_object);
 289
 290         return 0;
 291 }
 292
 293 /**
 294  * mei_amthif_run_next_cmd - send next amt command from queue
 295  *
 296  * @dev: the device structure
 297  *
 298  * Return: 0 on success, <0 on failure.
 299  */
 300 int mei_amthif_run_next_cmd(struct mei_device *dev)
 301 {
 302         struct mei_cl *cl = &dev->iamthif_cl;
 303         struct mei_cl_cb *cb;
 304
 305         dev->iamthif_canceled = false;
 306         dev->iamthif_state = MEI_IAMTHIF_IDLE;
 307         dev->iamthif_timer = 0;
 308         dev->iamthif_file_object = NULL;
 309
 310         dev_dbg(dev->dev, "complete amthif cmd_list cb.\n");
 311
 312         cb = list_first_entry_or_null(&dev->amthif_cmd_list.list,
 313                                         typeof(*cb), list);
 314         if (!cb)
 315                 return 0;
 316
 317         list_del_init(&cb->list);
 318         return mei_amthif_send_cmd(cl, cb);
 319 }
 320
 321 /**
 322  * mei_amthif_write - write amthif data to amthif client
 323  *
 324  * @cl: host client
 325  * @cb: mei call back struct
 326  *
 327  * Return: 0 on success, <0 on failure.
 328  */
 329 int mei_amthif_write(struct mei_cl *cl, struct mei_cl_cb *cb)
 330 {
 331
 332         struct mei_device *dev;
 333
 334         if (WARN_ON(!cl || !cl->dev))
 335                 return -ENODEV;
 336
 337         if (WARN_ON(!cb))
 338                 return -EINVAL;
 339
 340         dev = cl->dev;
 341
 342         list_add_tail(&cb->list, &dev->amthif_cmd_list.list);
 343         return mei_amthif_run_next_cmd(dev);
 344 }
 345
 346 /**
 347  * mei_amthif_poll - the amthif poll function
 348  *
 349  * @dev: the device structure
 350  * @file: pointer to file structure
 351  * @wait: pointer to poll_table structure
 352  *
 353  * Return: poll mask
 354  *
 355  * Locking: called under "dev->device_lock" lock
 356  */
 357
 358 unsigned int mei_amthif_poll(struct mei_device *dev,
 359                 struct file *file, poll_table *wait)
 360 {
 361         unsigned int mask = 0;
 362
 363         poll_wait(file, &dev->iamthif_cl.wait, wait);
 364
 365         if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE &&
 366             dev->iamthif_file_object == file) {
 367
 368                 mask |= POLLIN | POLLRDNORM;
 369                 mei_amthif_run_next_cmd(dev);
 370         }
 371
 372         return mask;
 373 }
 374
 375
 376
 377 /**
 378  * mei_amthif_irq_write - write iamthif command in irq thread context.
 379  *
 380  * @cl: private data of the file object.
 381  * @cb: callback block.
 382  * @cmpl_list: complete list.
 383  *
 384  * Return: 0, OK; otherwise, error.
 385  */
 386 int mei_amthif_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
 387                          struct mei_cl_cb *cmpl_list)
 388 {
 389         int ret;
 390
 391         ret = mei_cl_irq_write(cl, cb, cmpl_list);
 392         if (ret)
 393                 return ret;
 394
 395         if (cb->completed)
 396                 cb->status = mei_amthif_read_start(cl, cb->file_object);
 397
 398         return 0;
 399 }
 400
 401 /**
 402  * mei_amthif_irq_read_msg - read routine after ISR to
 403  *                      handle the read amthif message
 404  *
 405  * @cl: mei client
 406  * @mei_hdr: header of amthif message
 407  * @cmpl_list: completed callbacks list
 408  *
 409  * Return: -ENODEV if cb is NULL 0 otherwise; error message is in cb->status
 410  */
 411 int mei_amthif_irq_read_msg(struct mei_cl *cl,
 412                             struct mei_msg_hdr *mei_hdr,
 413                             struct mei_cl_cb *cmpl_list)
 414 {
 415         struct mei_device *dev;
 416         int ret;
 417
 418         dev = cl->dev;
 419
 420         if (dev->iamthif_state != MEI_IAMTHIF_READING) {
 421                 mei_irq_discard_msg(dev, mei_hdr);
 422                 return 0;
 423         }
 424
 425         ret = mei_cl_irq_read_msg(cl, mei_hdr, cmpl_list);
 426         if (ret)
 427                 return ret;
 428
 429         if (!mei_hdr->msg_complete)
 430                 return 0;
 431
 432         dev_dbg(dev->dev, "completed amthif read.\n ");
 433         dev->iamthif_current_cb = NULL;
 434         dev->iamthif_stall_timer = 0;
 435
 436         return 0;
 437 }
 438
 439 /**
 440  * mei_amthif_complete - complete amthif callback.
 441  *
 442  * @dev: the device structure.
 443  * @cb: callback block.
 444  */
 445 void mei_amthif_complete(struct mei_device *dev, struct mei_cl_cb *cb)
 446 {
 447
 448         if (cb->fop_type == MEI_FOP_WRITE) {
 449                 if (!cb->status) {
 450                         dev->iamthif_stall_timer = MEI_IAMTHIF_STALL_TIMER;
 451                         mei_io_cb_free(cb);
 452                         return;
 453                 }
 454                 /*
 455                  * in case of error enqueue the write cb to complete read list
 456                  * so it can be propagated to the reader
 457                  */
 458                 list_add_tail(&cb->list, &dev->amthif_rd_complete_list.list);
 459                 wake_up_interruptible(&dev->iamthif_cl.wait);
 460                 return;
 461         }
 462
 463         if (!dev->iamthif_canceled) {
 464                 dev->iamthif_state = MEI_IAMTHIF_READ_COMPLETE;
 465                 dev->iamthif_stall_timer = 0;
 466                 list_add_tail(&cb->list, &dev->amthif_rd_complete_list.list);
 467                 dev_dbg(dev->dev, "amthif read completed\n");
 468                 dev->iamthif_timer = jiffies;
 469                 dev_dbg(dev->dev, "dev->iamthif_timer = %ld\n",
 470                         dev->iamthif_timer);
 471         } else {
 472                 mei_amthif_run_next_cmd(dev);
 473         }
 474
 475         dev_dbg(dev->dev, "completing amthif call back.\n");
 476         wake_up_interruptible(&dev->iamthif_cl.wait);
 477 }
 478
 479 /**
 480  * mei_clear_list - removes all callbacks associated with file
 481  *              from mei_cb_list
 482  *
 483  * @dev: device structure.
 484  * @file: file structure
 485  * @mei_cb_list: callbacks list
 486  *
 487  * mei_clear_list is called to clear resources associated with file
 488  * when application calls close function or Ctrl-C was pressed
 489  *
 490  * Return: true if callback removed from the list, false otherwise
 491  */
 492 static bool mei_clear_list(struct mei_device *dev,
 493                 const struct file *file, struct list_head *mei_cb_list)
 494 {
 495         struct mei_cl *cl = &dev->iamthif_cl;
 496         struct mei_cl_cb *cb, *next;
 497         bool removed = false;
 498
 499         /* list all list member */
 500         list_for_each_entry_safe(cb, next, mei_cb_list, list) {
 501                 /* check if list member associated with a file */
 502                 if (file == cb->file_object) {
 503                         /* check if cb equal to current iamthif cb */
 504                         if (dev->iamthif_current_cb == cb) {
 505                                 dev->iamthif_current_cb = NULL;
 506                                 /* send flow control to iamthif client */
 507                                 mei_hbm_cl_flow_control_req(dev, cl);
 508                         }
 509                         /* free all allocated buffers */
 510                         mei_io_cb_free(cb);
 511                         removed = true;
 512                 }
 513         }
 514         return removed;
 515 }
 516
 517 /**
 518  * mei_clear_lists - removes all callbacks associated with file
 519  *
 520  * @dev: device structure
 521  * @file: file structure
 522  *
 523  * mei_clear_lists is called to clear resources associated with file
 524  * when application calls close function or Ctrl-C was pressed
 525  *
 526  * Return: true if callback removed from the list, false otherwise
 527  */
 528 static bool mei_clear_lists(struct mei_device *dev, struct file *file)
 529 {
 530         bool removed = false;
 531
 532         /* remove callbacks associated with a file */
 533         mei_clear_list(dev, file, &dev->amthif_cmd_list.list);
 534         if (mei_clear_list(dev, file, &dev->amthif_rd_complete_list.list))
 535                 removed = true;
 536
 537         mei_clear_list(dev, file, &dev->ctrl_rd_list.list);
 538
 539         if (mei_clear_list(dev, file, &dev->ctrl_wr_list.list))
 540                 removed = true;
 541
 542         if (mei_clear_list(dev, file, &dev->write_waiting_list.list))
 543                 removed = true;
 544
 545         if (mei_clear_list(dev, file, &dev->write_list.list))
 546                 removed = true;
 547
 548         /* check if iamthif_current_cb not NULL */
 549         if (dev->iamthif_current_cb && !removed) {
 550                 /* check file and iamthif current cb association */
 551                 if (dev->iamthif_current_cb->file_object == file) {
 552                         /* remove cb */
 553                         mei_io_cb_free(dev->iamthif_current_cb);
 554                         dev->iamthif_current_cb = NULL;
 555                         removed = true;
 556                 }
 557         }
 558         return removed;
 559 }
 560
 561 /**
 562 * mei_amthif_release - the release function
 563 *
 564 *  @dev: device structure
 565 *  @file: pointer to file structure
 566 *
 567 *  Return: 0 on success, <0 on error
 568 */
 569 int mei_amthif_release(struct mei_device *dev, struct file *file)
 570 {
 571         if (dev->iamthif_open_count > 0)
 572                 dev->iamthif_open_count--;
 573
 574         if (dev->iamthif_file_object == file &&
 575             dev->iamthif_state != MEI_IAMTHIF_IDLE) {
 576
 577                 dev_dbg(dev->dev, "amthif canceled iamthif state %d\n",
 578                     dev->iamthif_state);
 579                 dev->iamthif_canceled = true;
 580                 if (dev->iamthif_state == MEI_IAMTHIF_READ_COMPLETE) {
 581                         dev_dbg(dev->dev, "run next amthif iamthif cb\n");
 582                         mei_amthif_run_next_cmd(dev);
 583                 }
 584         }
 585
 586         if (mei_clear_lists(dev, file))
 587                 dev->iamthif_state = MEI_IAMTHIF_IDLE;
 588
 589         return 0;
 590 }