drivers/misc/mei/client.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/pci.h>
  18 #include <linux/sched.h>
  19 #include <linux/wait.h>
  20 #include <linux/delay.h>
  21
  22 #include <linux/mei.h>
  23
  24 #include "mei_dev.h"
  25 #include "hbm.h"
  26 #include "client.h"
  27
  28 /**
  29  * mei_me_cl_by_uuid - locate index of me client
  30  *
  31  * @dev: mei device
  32  * returns me client index or -ENOENT if not found
  33  */
  34 int mei_me_cl_by_uuid(const struct mei_device *dev, const uuid_le *uuid)
  35 {
  36         int i, res = -ENOENT;
  37
  38         for (i = 0; i < dev->me_clients_num; ++i)
  39                 if (uuid_le_cmp(*uuid,
  40                                 dev->me_clients[i].props.protocol_name) == 0) {
  41                         res = i;
  42                         break;
  43                 }
  44
  45         return res;
  46 }
  47
  48
  49 /**
  50  * mei_me_cl_by_id return index to me_clients for client_id
  51  *
  52  * @dev: the device structure
  53  * @client_id: me client id
  54  *
  55  * Locking: called under "dev->device_lock" lock
  56  *
  57  * returns index on success, -ENOENT on failure.
  58  */
  59
  60 int mei_me_cl_by_id(struct mei_device *dev, u8 client_id)
  61 {
  62         int i;
  63         for (i = 0; i < dev->me_clients_num; i++)
  64                 if (dev->me_clients[i].client_id == client_id)
  65                         break;
  66         if (WARN_ON(dev->me_clients[i].client_id != client_id))
  67                 return -ENOENT;
  68
  69         if (i == dev->me_clients_num)
  70                 return -ENOENT;
  71
  72         return i;
  73 }
  74
  75
  76 /**
  77  * mei_io_list_flush - removes list entry belonging to cl.
  78  *
  79  * @list:  An instance of our list structure
  80  * @cl: host client
  81  */
  82 void mei_io_list_flush(struct mei_cl_cb *list, struct mei_cl *cl)
  83 {
  84         struct mei_cl_cb *cb;
  85         struct mei_cl_cb *next;
  86
  87         list_for_each_entry_safe(cb, next, &list->list, list) {
  88                 if (cb->cl && mei_cl_cmp_id(cl, cb->cl))
  89                         list_del(&cb->list);
  90         }
  91 }
  92
  93 /**
  94  * mei_io_cb_free - free mei_cb_private related memory
  95  *
  96  * @cb: mei callback struct
  97  */
  98 void mei_io_cb_free(struct mei_cl_cb *cb)
  99 {
 100         if (cb == NULL)
 101                 return;
 102
 103         kfree(cb->request_buffer.data);
 104         kfree(cb->response_buffer.data);
 105         kfree(cb);
 106 }
 107
 108 /**
 109  * mei_io_cb_init - allocate and initialize io callback
 110  *
 111  * @cl - mei client
 112  * @fp: pointer to file structure
 113  *
 114  * returns mei_cl_cb pointer or NULL;
 115  */
 116 struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl, struct file *fp)
 117 {
 118         struct mei_cl_cb *cb;
 119
 120         cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
 121         if (!cb)
 122                 return NULL;
 123
 124         mei_io_list_init(cb);
 125
 126         cb->file_object = fp;
 127         cb->cl = cl;
 128         cb->buf_idx = 0;
 129         return cb;
 130 }
 131
 132 /**
 133  * mei_io_cb_alloc_req_buf - allocate request buffer
 134  *
 135  * @cb: io callback structure
 136  * @length: size of the buffer
 137  *
 138  * returns 0 on success
 139  *         -EINVAL if cb is NULL
 140  *         -ENOMEM if allocation failed
 141  */
 142 int mei_io_cb_alloc_req_buf(struct mei_cl_cb *cb, size_t length)
 143 {
 144         if (!cb)
 145                 return -EINVAL;
 146
 147         if (length == 0)
 148                 return 0;
 149
 150         cb->request_buffer.data = kmalloc(length, GFP_KERNEL);
 151         if (!cb->request_buffer.data)
 152                 return -ENOMEM;
 153         cb->request_buffer.size = length;
 154         return 0;
 155 }
 156 /**
 157  * mei_io_cb_alloc_resp_buf - allocate respose buffer
 158  *
 159  * @cb: io callback structure
 160  * @length: size of the buffer
 161  *
 162  * returns 0 on success
 163  *         -EINVAL if cb is NULL
 164  *         -ENOMEM if allocation failed
 165  */
 166 int mei_io_cb_alloc_resp_buf(struct mei_cl_cb *cb, size_t length)
 167 {
 168         if (!cb)
 169                 return -EINVAL;
 170
 171         if (length == 0)
 172                 return 0;
 173
 174         cb->response_buffer.data = kmalloc(length, GFP_KERNEL);
 175         if (!cb->response_buffer.data)
 176                 return -ENOMEM;
 177         cb->response_buffer.size = length;
 178         return 0;
 179 }
 180
 181
 182
 183 /**
 184  * mei_cl_flush_queues - flushes queue lists belonging to cl.
 185  *
 186  * @cl: host client
 187  */
 188 int mei_cl_flush_queues(struct mei_cl *cl)
 189 {
 190         struct mei_device *dev;
 191
 192         if (WARN_ON(!cl || !cl->dev))
 193                 return -EINVAL;
 194
 195         dev = cl->dev;
 196
 197         cl_dbg(dev, cl, "remove list entry belonging to cl\n");
 198         mei_io_list_flush(&cl->dev->read_list, cl);
 199         mei_io_list_flush(&cl->dev->write_list, cl);
 200         mei_io_list_flush(&cl->dev->write_waiting_list, cl);
 201         mei_io_list_flush(&cl->dev->ctrl_wr_list, cl);
 202         mei_io_list_flush(&cl->dev->ctrl_rd_list, cl);
 203         mei_io_list_flush(&cl->dev->amthif_cmd_list, cl);
 204         mei_io_list_flush(&cl->dev->amthif_rd_complete_list, cl);
 205         return 0;
 206 }
 207
 208
 209 /**
 210  * mei_cl_init - initializes intialize cl.
 211  *
 212  * @cl: host client to be initialized
 213  * @dev: mei device
 214  */
 215 void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)
 216 {
 217         memset(cl, 0, sizeof(struct mei_cl));
 218         init_waitqueue_head(&cl->wait);
 219         init_waitqueue_head(&cl->rx_wait);
 220         init_waitqueue_head(&cl->tx_wait);
 221         INIT_LIST_HEAD(&cl->link);
 222         INIT_LIST_HEAD(&cl->device_link);
 223         cl->reading_state = MEI_IDLE;
 224         cl->writing_state = MEI_IDLE;
 225         cl->dev = dev;
 226 }
 227
 228 /**
 229  * mei_cl_allocate - allocates cl  structure and sets it up.
 230  *
 231  * @dev: mei device
 232  * returns  The allocated file or NULL on failure
 233  */
 234 struct mei_cl *mei_cl_allocate(struct mei_device *dev)
 235 {
 236         struct mei_cl *cl;
 237
 238         cl = kmalloc(sizeof(struct mei_cl), GFP_KERNEL);
 239         if (!cl)
 240                 return NULL;
 241
 242         mei_cl_init(cl, dev);
 243
 244         return cl;
 245 }
 246
 247 /**
 248  * mei_cl_find_read_cb - find this cl's callback in the read list
 249  *
 250  * @cl: host client
 251  *
 252  * returns cb on success, NULL on error
 253  */
 254 struct mei_cl_cb *mei_cl_find_read_cb(struct mei_cl *cl)
 255 {
 256         struct mei_device *dev = cl->dev;
 257         struct mei_cl_cb *cb = NULL;
 258         struct mei_cl_cb *next = NULL;
 259
 260         list_for_each_entry_safe(cb, next, &dev->read_list.list, list)
 261                 if (mei_cl_cmp_id(cl, cb->cl))
 262                         return cb;
 263         return NULL;
 264 }
 265
 266 /** mei_cl_link: allocte host id in the host map
 267  *
 268  * @cl - host client
 269  * @id - fixed host id or -1 for genereting one
 270  *
 271  * returns 0 on success
 272  *      -EINVAL on incorrect values
 273  *      -ENONET if client not found
 274  */
 275 int mei_cl_link(struct mei_cl *cl, int id)
 276 {
 277         struct mei_device *dev;
 278
 279         if (WARN_ON(!cl || !cl->dev))
 280                 return -EINVAL;
 281
 282         dev = cl->dev;
 283
 284         /* If Id is not asigned get one*/
 285         if (id == MEI_HOST_CLIENT_ID_ANY)
 286                 id = find_first_zero_bit(dev->host_clients_map,
 287                                         MEI_CLIENTS_MAX);
 288
 289         if (id >= MEI_CLIENTS_MAX) {
 290                 dev_err(&dev->pdev->dev, "id exceded %d", MEI_CLIENTS_MAX) ;
 291                 return -ENOENT;
 292         }
 293
 294         if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) {
 295                 dev_err(&dev->pdev->dev, "open_handle_count exceded %d",
 296                         MEI_MAX_OPEN_HANDLE_COUNT);
 297                 return -ENOENT;
 298         }
 299
 300         dev->open_handle_count++;
 301
 302         cl->host_client_id = id;
 303         list_add_tail(&cl->link, &dev->file_list);
 304
 305         set_bit(id, dev->host_clients_map);
 306
 307         cl->state = MEI_FILE_INITIALIZING;
 308
 309         cl_dbg(dev, cl, "link cl\n");
 310         return 0;
 311 }
 312
 313 /**
 314  * mei_cl_unlink - remove me_cl from the list
 315  *
 316  * @cl: host client
 317  */
 318 int mei_cl_unlink(struct mei_cl *cl)
 319 {
 320         struct mei_device *dev;
 321         struct mei_cl *pos, *next;
 322
 323         /* don't shout on error exit path */
 324         if (!cl)
 325                 return 0;
 326
 327         /* wd and amthif might not be initialized */
 328         if (!cl->dev)
 329                 return 0;
 330
 331         dev = cl->dev;
 332
 333         list_for_each_entry_safe(pos, next, &dev->file_list, link) {
 334                 if (cl->host_client_id == pos->host_client_id) {
 335                         cl_dbg(dev, cl, "remove host client = %d, ME client = %d\n",
 336                                 pos->host_client_id, pos->me_client_id);
 337                         list_del_init(&pos->link);
 338                         break;
 339                 }
 340         }
 341         return 0;
 342 }
 343
 344
 345 void mei_host_client_init(struct work_struct *work)
 346 {
 347         struct mei_device *dev = container_of(work,
 348                                               struct mei_device, init_work);
 349         struct mei_client_properties *client_props;
 350         int i;
 351
 352         mutex_lock(&dev->device_lock);
 353
 354         bitmap_zero(dev->host_clients_map, MEI_CLIENTS_MAX);
 355         dev->open_handle_count = 0;
 356
 357         /*
 358          * Reserving the first three client IDs
 359          * 0: Reserved for MEI Bus Message communications
 360          * 1: Reserved for Watchdog
 361          * 2: Reserved for AMTHI
 362          */
 363         bitmap_set(dev->host_clients_map, 0, 3);
 364
 365         for (i = 0; i < dev->me_clients_num; i++) {
 366                 client_props = &dev->me_clients[i].props;
 367
 368                 if (!uuid_le_cmp(client_props->protocol_name, mei_amthif_guid))
 369                         mei_amthif_host_init(dev);
 370                 else if (!uuid_le_cmp(client_props->protocol_name, mei_wd_guid))
 371                         mei_wd_host_init(dev);
 372                 else if (!uuid_le_cmp(client_props->protocol_name, mei_nfc_guid))
 373                         mei_nfc_host_init(dev);
 374
 375         }
 376
 377         dev->dev_state = MEI_DEV_ENABLED;
 378
 379         mutex_unlock(&dev->device_lock);
 380 }
 381
 382
 383 /**
 384  * mei_cl_disconnect - disconnect host clinet form the me one
 385  *
 386  * @cl: host client
 387  *
 388  * Locking: called under "dev->device_lock" lock
 389  *
 390  * returns 0 on success, <0 on failure.
 391  */
 392 int mei_cl_disconnect(struct mei_cl *cl)
 393 {
 394         struct mei_device *dev;
 395         struct mei_cl_cb *cb;
 396         int rets, err;
 397
 398         if (WARN_ON(!cl || !cl->dev))
 399                 return -ENODEV;
 400
 401         dev = cl->dev;
 402
 403         cl_dbg(dev, cl, "disconnecting");
 404
 405         if (cl->state != MEI_FILE_DISCONNECTING)
 406                 return 0;
 407
 408         cb = mei_io_cb_init(cl, NULL);
 409         if (!cb)
 410                 return -ENOMEM;
 411
 412         cb->fop_type = MEI_FOP_CLOSE;
 413         if (dev->hbuf_is_ready) {
 414                 dev->hbuf_is_ready = false;
 415                 if (mei_hbm_cl_disconnect_req(dev, cl)) {
 416                         rets = -ENODEV;
 417                         cl_err(dev, cl, "failed to disconnect.\n");
 418                         goto free;
 419                 }
 420                 mdelay(10); /* Wait for hardware disconnection ready */
 421                 list_add_tail(&cb->list, &dev->ctrl_rd_list.list);
 422         } else {
 423                 cl_dbg(dev, cl, "add disconnect cb to control write list\n");
 424                 list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
 425
 426         }
 427         mutex_unlock(&dev->device_lock);
 428
 429         err = wait_event_timeout(dev->wait_recvd_msg,
 430                         MEI_FILE_DISCONNECTED == cl->state,
 431                         mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
 432
 433         mutex_lock(&dev->device_lock);
 434         if (MEI_FILE_DISCONNECTED == cl->state) {
 435                 rets = 0;
 436                 cl_dbg(dev, cl, "successfully disconnected from FW client.\n");
 437         } else {
 438                 rets = -ENODEV;
 439                 if (MEI_FILE_DISCONNECTED != cl->state)
 440                         cl_err(dev, cl, "wrong status client disconnect.\n");
 441
 442                 if (err)
 443                         cl_dbg(dev, cl, "wait failed disconnect err=%08x\n",
 444                                         err);
 445
 446                 cl_err(dev, cl, "failed to disconnect from FW client.\n");
 447         }
 448
 449         mei_io_list_flush(&dev->ctrl_rd_list, cl);
 450         mei_io_list_flush(&dev->ctrl_wr_list, cl);
 451 free:
 452         mei_io_cb_free(cb);
 453         return rets;
 454 }
 455
 456
 457 /**
 458  * mei_cl_is_other_connecting - checks if other
 459  *    client with the same me client id is connecting
 460  *
 461  * @cl: private data of the file object
 462  *
 463  * returns ture if other client is connected, 0 - otherwise.
 464  */
 465 bool mei_cl_is_other_connecting(struct mei_cl *cl)
 466 {
 467         struct mei_device *dev;
 468         struct mei_cl *pos;
 469         struct mei_cl *next;
 470
 471         if (WARN_ON(!cl || !cl->dev))
 472                 return false;
 473
 474         dev = cl->dev;
 475
 476         list_for_each_entry_safe(pos, next, &dev->file_list, link) {
 477                 if ((pos->state == MEI_FILE_CONNECTING) &&
 478                     (pos != cl) && cl->me_client_id == pos->me_client_id)
 479                         return true;
 480
 481         }
 482
 483         return false;
 484 }
 485
 486 /**
 487  * mei_cl_connect - connect host clinet to the me one
 488  *
 489  * @cl: host client
 490  *
 491  * Locking: called under "dev->device_lock" lock
 492  *
 493  * returns 0 on success, <0 on failure.
 494  */
 495 int mei_cl_connect(struct mei_cl *cl, struct file *file)
 496 {
 497         struct mei_device *dev;
 498         struct mei_cl_cb *cb;
 499         int rets;
 500
 501         if (WARN_ON(!cl || !cl->dev))
 502                 return -ENODEV;
 503
 504         dev = cl->dev;
 505
 506         cb = mei_io_cb_init(cl, file);
 507         if (!cb) {
 508                 rets = -ENOMEM;
 509                 goto out;
 510         }
 511
 512         cb->fop_type = MEI_FOP_IOCTL;
 513
 514         if (dev->hbuf_is_ready && !mei_cl_is_other_connecting(cl)) {
 515                 dev->hbuf_is_ready = false;
 516
 517                 if (mei_hbm_cl_connect_req(dev, cl)) {
 518                         rets = -ENODEV;
 519                         goto out;
 520                 }
 521                 cl->timer_count = MEI_CONNECT_TIMEOUT;
 522                 list_add_tail(&cb->list, &dev->ctrl_rd_list.list);
 523         } else {
 524                 list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
 525         }
 526
 527         mutex_unlock(&dev->device_lock);
 528         rets = wait_event_timeout(dev->wait_recvd_msg,
 529                                  (cl->state == MEI_FILE_CONNECTED ||
 530                                   cl->state == MEI_FILE_DISCONNECTED),
 531                                  mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
 532         mutex_lock(&dev->device_lock);
 533
 534         if (cl->state != MEI_FILE_CONNECTED) {
 535                 rets = -EFAULT;
 536
 537                 mei_io_list_flush(&dev->ctrl_rd_list, cl);
 538                 mei_io_list_flush(&dev->ctrl_wr_list, cl);
 539                 goto out;
 540         }
 541
 542         rets = cl->status;
 543
 544 out:
 545         mei_io_cb_free(cb);
 546         return rets;
 547 }
 548
 549 /**
 550  * mei_cl_flow_ctrl_creds - checks flow_control credits for cl.
 551  *
 552  * @cl: private data of the file object
 553  *
 554  * returns 1 if mei_flow_ctrl_creds >0, 0 - otherwise.
 555  *      -ENOENT if mei_cl is not present
 556  *      -EINVAL if single_recv_buf == 0
 557  */
 558 int mei_cl_flow_ctrl_creds(struct mei_cl *cl)
 559 {
 560         struct mei_device *dev;
 561         int i;
 562
 563         if (WARN_ON(!cl || !cl->dev))
 564                 return -EINVAL;
 565
 566         dev = cl->dev;
 567
 568         if (!dev->me_clients_num)
 569                 return 0;
 570
 571         if (cl->mei_flow_ctrl_creds > 0)
 572                 return 1;
 573
 574         for (i = 0; i < dev->me_clients_num; i++) {
 575                 struct mei_me_client  *me_cl = &dev->me_clients[i];
 576                 if (me_cl->client_id == cl->me_client_id) {
 577                         if (me_cl->mei_flow_ctrl_creds) {
 578                                 if (WARN_ON(me_cl->props.single_recv_buf == 0))
 579                                         return -EINVAL;
 580                                 return 1;
 581                         } else {
 582                                 return 0;
 583                         }
 584                 }
 585         }
 586         return -ENOENT;
 587 }
 588
 589 /**
 590  * mei_cl_flow_ctrl_reduce - reduces flow_control.
 591  *
 592  * @cl: private data of the file object
 593  *
 594  * @returns
 595  *      0 on success
 596  *      -ENOENT when me client is not found
 597  *      -EINVAL when ctrl credits are <= 0
 598  */
 599 int mei_cl_flow_ctrl_reduce(struct mei_cl *cl)
 600 {
 601         struct mei_device *dev;
 602         int i;
 603
 604         if (WARN_ON(!cl || !cl->dev))
 605                 return -EINVAL;
 606
 607         dev = cl->dev;
 608
 609         if (!dev->me_clients_num)
 610                 return -ENOENT;
 611
 612         for (i = 0; i < dev->me_clients_num; i++) {
 613                 struct mei_me_client  *me_cl = &dev->me_clients[i];
 614                 if (me_cl->client_id == cl->me_client_id) {
 615                         if (me_cl->props.single_recv_buf != 0) {
 616                                 if (WARN_ON(me_cl->mei_flow_ctrl_creds <= 0))
 617                                         return -EINVAL;
 618                                 dev->me_clients[i].mei_flow_ctrl_creds--;
 619                         } else {
 620                                 if (WARN_ON(cl->mei_flow_ctrl_creds <= 0))
 621                                         return -EINVAL;
 622                                 cl->mei_flow_ctrl_creds--;
 623                         }
 624                         return 0;
 625                 }
 626         }
 627         return -ENOENT;
 628 }
 629
 630 /**
 631  * mei_cl_read_start - the start read client message function.
 632  *
 633  * @cl: host client
 634  *
 635  * returns 0 on success, <0 on failure.
 636  */
 637 int mei_cl_read_start(struct mei_cl *cl, size_t length)
 638 {
 639         struct mei_device *dev;
 640         struct mei_cl_cb *cb;
 641         int rets;
 642         int i;
 643
 644         if (WARN_ON(!cl || !cl->dev))
 645                 return -ENODEV;
 646
 647         dev = cl->dev;
 648
 649         if (!mei_cl_is_connected(cl))
 650                 return -ENODEV;
 651
 652         if (cl->read_cb) {
 653                 cl_dbg(dev, cl, "read is pending.\n");
 654                 return -EBUSY;
 655         }
 656         i = mei_me_cl_by_id(dev, cl->me_client_id);
 657         if (i < 0) {
 658                 cl_err(dev, cl, "no such me client %d\n", cl->me_client_id);
 659                 return  -ENODEV;
 660         }
 661
 662         cb = mei_io_cb_init(cl, NULL);
 663         if (!cb)
 664                 return -ENOMEM;
 665
 666         /* always allocate at least client max message */
 667         length = max_t(size_t, length, dev->me_clients[i].props.max_msg_length);
 668         rets = mei_io_cb_alloc_resp_buf(cb, length);
 669         if (rets)
 670                 goto err;
 671
 672         cb->fop_type = MEI_FOP_READ;
 673         cl->read_cb = cb;
 674         if (dev->hbuf_is_ready) {
 675                 dev->hbuf_is_ready = false;
 676                 if (mei_hbm_cl_flow_control_req(dev, cl)) {
 677                         cl_err(dev, cl, "flow control send failed\n");
 678                         rets = -ENODEV;
 679                         goto err;
 680                 }
 681                 list_add_tail(&cb->list, &dev->read_list.list);
 682         } else {
 683                 list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
 684         }
 685         return rets;
 686 err:
 687         mei_io_cb_free(cb);
 688         return rets;
 689 }
 690
 691 /**
 692  * mei_cl_irq_write_complete - write a message to device
 693  *      from the interrupt thread context
 694  *
 695  * @cl: client
 696  * @cb: callback block.
 697  * @slots: free slots.
 698  * @cmpl_list: complete list.
 699  *
 700  * returns 0, OK; otherwise error.
 701  */
 702 int mei_cl_irq_write_complete(struct mei_cl *cl, struct mei_cl_cb *cb,
 703                                      s32 *slots, struct mei_cl_cb *cmpl_list)
 704 {
 705         struct mei_device *dev;
 706         struct mei_msg_data *buf;
 707         struct mei_msg_hdr mei_hdr;
 708         size_t len;
 709         u32 msg_slots;
 710         int rets;
 711
 712
 713         if (WARN_ON(!cl || !cl->dev))
 714                 return -ENODEV;
 715
 716         dev = cl->dev;
 717
 718         buf = &cb->request_buffer;
 719
 720         rets = mei_cl_flow_ctrl_creds(cl);
 721         if (rets < 0)
 722                 return rets;
 723
 724         if (rets == 0) {
 725                 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
 726                 return 0;
 727         }
 728
 729         len = buf->size - cb->buf_idx;
 730         msg_slots = mei_data2slots(len);
 731
 732         mei_hdr.host_addr = cl->host_client_id;
 733         mei_hdr.me_addr = cl->me_client_id;
 734         mei_hdr.reserved = 0;
 735
 736         if (*slots >= msg_slots) {
 737                 mei_hdr.length = len;
 738                 mei_hdr.msg_complete = 1;
 739         /* Split the message only if we can write the whole host buffer */
 740         } else if (*slots == dev->hbuf_depth) {
 741                 msg_slots = *slots;
 742                 len = (*slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
 743                 mei_hdr.length = len;
 744                 mei_hdr.msg_complete = 0;
 745         } else {
 746                 /* wait for next time the host buffer is empty */
 747                 return 0;
 748         }
 749
 750         cl_dbg(dev, cl, "buf: size = %d idx = %lu\n",
 751                         cb->request_buffer.size, cb->buf_idx);
 752
 753         *slots -=  msg_slots;
 754         rets = mei_write_message(dev, &mei_hdr, buf->data + cb->buf_idx);
 755         if (rets) {
 756                 cl->status = rets;
 757                 list_move_tail(&cb->list, &cmpl_list->list);
 758                 return rets;
 759         }
 760
 761         cl->status = 0;
 762         cl->writing_state = MEI_WRITING;
 763         cb->buf_idx += mei_hdr.length;
 764
 765         if (mei_hdr.msg_complete) {
 766                 if (mei_cl_flow_ctrl_reduce(cl))
 767                         return -EIO;
 768                 list_move_tail(&cb->list, &dev->write_waiting_list.list);
 769         }
 770
 771         return 0;
 772 }
 773
 774 /**
 775  * mei_cl_write - submit a write cb to mei device
 776         assumes device_lock is locked
 777  *
 778  * @cl: host client
 779  * @cl: write callback with filled data
 780  *
 781  * returns numbe of bytes sent on success, <0 on failure.
 782  */
 783 int mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, bool blocking)
 784 {
 785         struct mei_device *dev;
 786         struct mei_msg_data *buf;
 787         struct mei_msg_hdr mei_hdr;
 788         int rets;
 789
 790
 791         if (WARN_ON(!cl || !cl->dev))
 792                 return -ENODEV;
 793
 794         if (WARN_ON(!cb))
 795                 return -EINVAL;
 796
 797         dev = cl->dev;
 798
 799
 800         buf = &cb->request_buffer;
 801
 802         cl_dbg(dev, cl, "mei_cl_write %d\n", buf->size);
 803
 804
 805         cb->fop_type = MEI_FOP_WRITE;
 806
 807         rets = mei_cl_flow_ctrl_creds(cl);
 808         if (rets < 0)
 809                 goto err;
 810
 811         /* Host buffer is not ready, we queue the request */
 812         if (rets == 0 || !dev->hbuf_is_ready) {
 813                 cb->buf_idx = 0;
 814                 /* unseting complete will enqueue the cb for write */
 815                 mei_hdr.msg_complete = 0;
 816                 rets = buf->size;
 817                 goto out;
 818         }
 819
 820         dev->hbuf_is_ready = false;
 821
 822         /* Check for a maximum length */
 823         if (buf->size > mei_hbuf_max_len(dev)) {
 824                 mei_hdr.length = mei_hbuf_max_len(dev);
 825                 mei_hdr.msg_complete = 0;
 826         } else {
 827                 mei_hdr.length = buf->size;
 828                 mei_hdr.msg_complete = 1;
 829         }
 830
 831         mei_hdr.host_addr = cl->host_client_id;
 832         mei_hdr.me_addr = cl->me_client_id;
 833         mei_hdr.reserved = 0;
 834
 835
 836         rets = mei_write_message(dev, &mei_hdr, buf->data);
 837         if (rets)
 838                 goto err;
 839
 840         cl->writing_state = MEI_WRITING;
 841         cb->buf_idx = mei_hdr.length;
 842
 843         rets = buf->size;
 844 out:
 845         if (mei_hdr.msg_complete) {
 846                 if (mei_cl_flow_ctrl_reduce(cl)) {
 847                         rets = -ENODEV;
 848                         goto err;
 849                 }
 850                 list_add_tail(&cb->list, &dev->write_waiting_list.list);
 851         } else {
 852                 list_add_tail(&cb->list, &dev->write_list.list);
 853         }
 854
 855
 856         if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {
 857
 858                 mutex_unlock(&dev->device_lock);
 859                 if (wait_event_interruptible(cl->tx_wait,
 860                         cl->writing_state == MEI_WRITE_COMPLETE)) {
 861                                 if (signal_pending(current))
 862                                         rets = -EINTR;
 863                                 else
 864                                         rets = -ERESTARTSYS;
 865                 }
 866                 mutex_lock(&dev->device_lock);
 867         }
 868 err:
 869         return rets;
 870 }
 871
 872
 873 /**
 874  * mei_cl_complete - processes completed operation for a client
 875  *
 876  * @cl: private data of the file object.
 877  * @cb: callback block.
 878  */
 879 void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
 880 {
 881         if (cb->fop_type == MEI_FOP_WRITE) {
 882                 mei_io_cb_free(cb);
 883                 cb = NULL;
 884                 cl->writing_state = MEI_WRITE_COMPLETE;
 885                 if (waitqueue_active(&cl->tx_wait))
 886                         wake_up_interruptible(&cl->tx_wait);
 887
 888         } else if (cb->fop_type == MEI_FOP_READ &&
 889                         MEI_READING == cl->reading_state) {
 890                 cl->reading_state = MEI_READ_COMPLETE;
 891                 if (waitqueue_active(&cl->rx_wait))
 892                         wake_up_interruptible(&cl->rx_wait);
 893                 else
 894                         mei_cl_bus_rx_event(cl);
 895
 896         }
 897 }
 898
 899
 900 /**
 901  * mei_cl_all_disconnect - disconnect forcefully all connected clients
 902  *
 903  * @dev - mei device
 904  */
 905
 906 void mei_cl_all_disconnect(struct mei_device *dev)
 907 {
 908         struct mei_cl *cl, *next;
 909
 910         list_for_each_entry_safe(cl, next, &dev->file_list, link) {
 911                 cl->state = MEI_FILE_DISCONNECTED;
 912                 cl->mei_flow_ctrl_creds = 0;
 913                 cl->read_cb = NULL;
 914                 cl->timer_count = 0;
 915         }
 916 }
 917
 918
 919 /**
 920  * mei_cl_all_wakeup  - wake up all readers and writers they can be interrupted
 921  *
 922  * @dev  - mei device
 923  */
 924 void mei_cl_all_wakeup(struct mei_device *dev)
 925 {
 926         struct mei_cl *cl, *next;
 927         list_for_each_entry_safe(cl, next, &dev->file_list, link) {
 928                 if (waitqueue_active(&cl->rx_wait)) {
 929                         cl_dbg(dev, cl, "Waking up reading client!\n");
 930                         wake_up_interruptible(&cl->rx_wait);
 931                 }
 932                 if (waitqueue_active(&cl->tx_wait)) {
 933                         cl_dbg(dev, cl, "Waking up writing client!\n");
 934                         wake_up_interruptible(&cl->tx_wait);
 935                 }
 936         }
 937 }
 938
 939 /**
 940  * mei_cl_all_write_clear - clear all pending writes
 941
 942  * @dev - mei device
 943  */
 944 void mei_cl_all_write_clear(struct mei_device *dev)
 945 {
 946         struct mei_cl_cb *cb, *next;
 947
 948         list_for_each_entry_safe(cb, next, &dev->write_list.list, list) {
 949                 list_del(&cb->list);
 950                 mei_io_cb_free(cb);
 951         }
 952 }
 953
 954