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/sched/signal.h>
  18 #include <linux/wait.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/pm_runtime.h>
  22
  23 #include <linux/mei.h>
  24
  25 #include "mei_dev.h"
  26 #include "hbm.h"
  27 #include "client.h"
  28
  29 /**
  30  * mei_me_cl_init - initialize me client
  31  *
  32  * @me_cl: me client
  33  */
  34 void mei_me_cl_init(struct mei_me_client *me_cl)
  35 {
  36         INIT_LIST_HEAD(&me_cl->list);
  37         kref_init(&me_cl->refcnt);
  38 }
  39
  40 /**
  41  * mei_me_cl_get - increases me client refcount
  42  *
  43  * @me_cl: me client
  44  *
  45  * Locking: called under "dev->device_lock" lock
  46  *
  47  * Return: me client or NULL
  48  */
  49 struct mei_me_client *mei_me_cl_get(struct mei_me_client *me_cl)
  50 {
  51         if (me_cl && kref_get_unless_zero(&me_cl->refcnt))
  52                 return me_cl;
  53
  54         return NULL;
  55 }
  56
  57 /**
  58  * mei_me_cl_release - free me client
  59  *
  60  * Locking: called under "dev->device_lock" lock
  61  *
  62  * @ref: me_client refcount
  63  */
  64 static void mei_me_cl_release(struct kref *ref)
  65 {
  66         struct mei_me_client *me_cl =
  67                 container_of(ref, struct mei_me_client, refcnt);
  68
  69         kfree(me_cl);
  70 }
  71
  72 /**
  73  * mei_me_cl_put - decrease me client refcount and free client if necessary
  74  *
  75  * Locking: called under "dev->device_lock" lock
  76  *
  77  * @me_cl: me client
  78  */
  79 void mei_me_cl_put(struct mei_me_client *me_cl)
  80 {
  81         if (me_cl)
  82                 kref_put(&me_cl->refcnt, mei_me_cl_release);
  83 }
  84
  85 /**
  86  * __mei_me_cl_del  - delete me client from the list and decrease
  87  *     reference counter
  88  *
  89  * @dev: mei device
  90  * @me_cl: me client
  91  *
  92  * Locking: dev->me_clients_rwsem
  93  */
  94 static void __mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl)
  95 {
  96         if (!me_cl)
  97                 return;
  98
  99         list_del_init(&me_cl->list);
 100         mei_me_cl_put(me_cl);
 101 }
 102
 103 /**
 104  * mei_me_cl_del - delete me client from the list and decrease
 105  *     reference counter
 106  *
 107  * @dev: mei device
 108  * @me_cl: me client
 109  */
 110 void mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl)
 111 {
 112         down_write(&dev->me_clients_rwsem);
 113         __mei_me_cl_del(dev, me_cl);
 114         up_write(&dev->me_clients_rwsem);
 115 }
 116
 117 /**
 118  * mei_me_cl_add - add me client to the list
 119  *
 120  * @dev: mei device
 121  * @me_cl: me client
 122  */
 123 void mei_me_cl_add(struct mei_device *dev, struct mei_me_client *me_cl)
 124 {
 125         down_write(&dev->me_clients_rwsem);
 126         list_add(&me_cl->list, &dev->me_clients);
 127         up_write(&dev->me_clients_rwsem);
 128 }
 129
 130 /**
 131  * __mei_me_cl_by_uuid - locate me client by uuid
 132  *      increases ref count
 133  *
 134  * @dev: mei device
 135  * @uuid: me client uuid
 136  *
 137  * Return: me client or NULL if not found
 138  *
 139  * Locking: dev->me_clients_rwsem
 140  */
 141 static struct mei_me_client *__mei_me_cl_by_uuid(struct mei_device *dev,
 142                                         const uuid_le *uuid)
 143 {
 144         struct mei_me_client *me_cl;
 145         const uuid_le *pn;
 146
 147         WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
 148
 149         list_for_each_entry(me_cl, &dev->me_clients, list) {
 150                 pn = &me_cl->props.protocol_name;
 151                 if (uuid_le_cmp(*uuid, *pn) == 0)
 152                         return mei_me_cl_get(me_cl);
 153         }
 154
 155         return NULL;
 156 }
 157
 158 /**
 159  * mei_me_cl_by_uuid - locate me client by uuid
 160  *      increases ref count
 161  *
 162  * @dev: mei device
 163  * @uuid: me client uuid
 164  *
 165  * Return: me client or NULL if not found
 166  *
 167  * Locking: dev->me_clients_rwsem
 168  */
 169 struct mei_me_client *mei_me_cl_by_uuid(struct mei_device *dev,
 170                                         const uuid_le *uuid)
 171 {
 172         struct mei_me_client *me_cl;
 173
 174         down_read(&dev->me_clients_rwsem);
 175         me_cl = __mei_me_cl_by_uuid(dev, uuid);
 176         up_read(&dev->me_clients_rwsem);
 177
 178         return me_cl;
 179 }
 180
 181 /**
 182  * mei_me_cl_by_id - locate me client by client id
 183  *      increases ref count
 184  *
 185  * @dev: the device structure
 186  * @client_id: me client id
 187  *
 188  * Return: me client or NULL if not found
 189  *
 190  * Locking: dev->me_clients_rwsem
 191  */
 192 struct mei_me_client *mei_me_cl_by_id(struct mei_device *dev, u8 client_id)
 193 {
 194
 195         struct mei_me_client *__me_cl, *me_cl = NULL;
 196
 197         down_read(&dev->me_clients_rwsem);
 198         list_for_each_entry(__me_cl, &dev->me_clients, list) {
 199                 if (__me_cl->client_id == client_id) {
 200                         me_cl = mei_me_cl_get(__me_cl);
 201                         break;
 202                 }
 203         }
 204         up_read(&dev->me_clients_rwsem);
 205
 206         return me_cl;
 207 }
 208
 209 /**
 210  * __mei_me_cl_by_uuid_id - locate me client by client id and uuid
 211  *      increases ref count
 212  *
 213  * @dev: the device structure
 214  * @uuid: me client uuid
 215  * @client_id: me client id
 216  *
 217  * Return: me client or null if not found
 218  *
 219  * Locking: dev->me_clients_rwsem
 220  */
 221 static struct mei_me_client *__mei_me_cl_by_uuid_id(struct mei_device *dev,
 222                                            const uuid_le *uuid, u8 client_id)
 223 {
 224         struct mei_me_client *me_cl;
 225         const uuid_le *pn;
 226
 227         WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem));
 228
 229         list_for_each_entry(me_cl, &dev->me_clients, list) {
 230                 pn = &me_cl->props.protocol_name;
 231                 if (uuid_le_cmp(*uuid, *pn) == 0 &&
 232                     me_cl->client_id == client_id)
 233                         return mei_me_cl_get(me_cl);
 234         }
 235
 236         return NULL;
 237 }
 238
 239
 240 /**
 241  * mei_me_cl_by_uuid_id - locate me client by client id and uuid
 242  *      increases ref count
 243  *
 244  * @dev: the device structure
 245  * @uuid: me client uuid
 246  * @client_id: me client id
 247  *
 248  * Return: me client or null if not found
 249  */
 250 struct mei_me_client *mei_me_cl_by_uuid_id(struct mei_device *dev,
 251                                            const uuid_le *uuid, u8 client_id)
 252 {
 253         struct mei_me_client *me_cl;
 254
 255         down_read(&dev->me_clients_rwsem);
 256         me_cl = __mei_me_cl_by_uuid_id(dev, uuid, client_id);
 257         up_read(&dev->me_clients_rwsem);
 258
 259         return me_cl;
 260 }
 261
 262 /**
 263  * mei_me_cl_rm_by_uuid - remove all me clients matching uuid
 264  *
 265  * @dev: the device structure
 266  * @uuid: me client uuid
 267  *
 268  * Locking: called under "dev->device_lock" lock
 269  */
 270 void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid)
 271 {
 272         struct mei_me_client *me_cl;
 273
 274         dev_dbg(dev->dev, "remove %pUl\n", uuid);
 275
 276         down_write(&dev->me_clients_rwsem);
 277         me_cl = __mei_me_cl_by_uuid(dev, uuid);
 278         __mei_me_cl_del(dev, me_cl);
 279         mei_me_cl_put(me_cl);
 280         up_write(&dev->me_clients_rwsem);
 281 }
 282
 283 /**
 284  * mei_me_cl_rm_by_uuid_id - remove all me clients matching client id
 285  *
 286  * @dev: the device structure
 287  * @uuid: me client uuid
 288  * @id: me client id
 289  *
 290  * Locking: called under "dev->device_lock" lock
 291  */
 292 void mei_me_cl_rm_by_uuid_id(struct mei_device *dev, const uuid_le *uuid, u8 id)
 293 {
 294         struct mei_me_client *me_cl;
 295
 296         dev_dbg(dev->dev, "remove %pUl %d\n", uuid, id);
 297
 298         down_write(&dev->me_clients_rwsem);
 299         me_cl = __mei_me_cl_by_uuid_id(dev, uuid, id);
 300         __mei_me_cl_del(dev, me_cl);
 301         mei_me_cl_put(me_cl);
 302         up_write(&dev->me_clients_rwsem);
 303 }
 304
 305 /**
 306  * mei_me_cl_rm_all - remove all me clients
 307  *
 308  * @dev: the device structure
 309  *
 310  * Locking: called under "dev->device_lock" lock
 311  */
 312 void mei_me_cl_rm_all(struct mei_device *dev)
 313 {
 314         struct mei_me_client *me_cl, *next;
 315
 316         down_write(&dev->me_clients_rwsem);
 317         list_for_each_entry_safe(me_cl, next, &dev->me_clients, list)
 318                 __mei_me_cl_del(dev, me_cl);
 319         up_write(&dev->me_clients_rwsem);
 320 }
 321
 322 /**
 323  * mei_cl_cmp_id - tells if the clients are the same
 324  *
 325  * @cl1: host client 1
 326  * @cl2: host client 2
 327  *
 328  * Return: true  - if the clients has same host and me ids
 329  *         false - otherwise
 330  */
 331 static inline bool mei_cl_cmp_id(const struct mei_cl *cl1,
 332                                 const struct mei_cl *cl2)
 333 {
 334         return cl1 && cl2 &&
 335                 (cl1->host_client_id == cl2->host_client_id) &&
 336                 (mei_cl_me_id(cl1) == mei_cl_me_id(cl2));
 337 }
 338
 339 /**
 340  * mei_io_cb_free - free mei_cb_private related memory
 341  *
 342  * @cb: mei callback struct
 343  */
 344 void mei_io_cb_free(struct mei_cl_cb *cb)
 345 {
 346         if (cb == NULL)
 347                 return;
 348
 349         list_del(&cb->list);
 350         kfree(cb->buf.data);
 351         kfree(cb);
 352 }
 353
 354 /**
 355  * mei_tx_cb_queue - queue tx callback
 356  *
 357  * Locking: called under "dev->device_lock" lock
 358  *
 359  * @cb: mei callback struct
 360  * @head: an instance of list to queue on
 361  */
 362 static inline void mei_tx_cb_enqueue(struct mei_cl_cb *cb,
 363                                      struct list_head *head)
 364 {
 365         list_add_tail(&cb->list, head);
 366         cb->cl->tx_cb_queued++;
 367 }
 368
 369 /**
 370  * mei_tx_cb_dequeue - dequeue tx callback
 371  *
 372  * Locking: called under "dev->device_lock" lock
 373  *
 374  * @cb: mei callback struct to dequeue and free
 375  */
 376 static inline void mei_tx_cb_dequeue(struct mei_cl_cb *cb)
 377 {
 378         if (!WARN_ON(cb->cl->tx_cb_queued == 0))
 379                 cb->cl->tx_cb_queued--;
 380
 381         mei_io_cb_free(cb);
 382 }
 383
 384 /**
 385  * mei_io_cb_init - allocate and initialize io callback
 386  *
 387  * @cl: mei client
 388  * @type: operation type
 389  * @fp: pointer to file structure
 390  *
 391  * Return: mei_cl_cb pointer or NULL;
 392  */
 393 static struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl,
 394                                         enum mei_cb_file_ops type,
 395                                         const struct file *fp)
 396 {
 397         struct mei_cl_cb *cb;
 398
 399         cb = kzalloc(sizeof(struct mei_cl_cb), GFP_KERNEL);
 400         if (!cb)
 401                 return NULL;
 402
 403         INIT_LIST_HEAD(&cb->list);
 404         cb->fp = fp;
 405         cb->cl = cl;
 406         cb->buf_idx = 0;
 407         cb->fop_type = type;
 408         return cb;
 409 }
 410
 411 /**
 412  * mei_io_list_flush_cl - removes cbs belonging to the cl.
 413  *
 414  * @head:  an instance of our list structure
 415  * @cl:    host client
 416  */
 417 static void mei_io_list_flush_cl(struct list_head *head,
 418                                  const struct mei_cl *cl)
 419 {
 420         struct mei_cl_cb *cb, *next;
 421
 422         list_for_each_entry_safe(cb, next, head, list) {
 423                 if (mei_cl_cmp_id(cl, cb->cl))
 424                         list_del_init(&cb->list);
 425         }
 426 }
 427
 428 /**
 429  * mei_io_tx_list_free_cl - removes cb belonging to the cl and free them
 430  *
 431  * @head: An instance of our list structure
 432  * @cl: host client
 433  */
 434 static void mei_io_tx_list_free_cl(struct list_head *head,
 435                                    const struct mei_cl *cl)
 436 {
 437         struct mei_cl_cb *cb, *next;
 438
 439         list_for_each_entry_safe(cb, next, head, list) {
 440                 if (mei_cl_cmp_id(cl, cb->cl))
 441                         mei_tx_cb_dequeue(cb);
 442         }
 443 }
 444
 445 /**
 446  * mei_io_list_free_fp - free cb from a list that matches file pointer
 447  *
 448  * @head: io list
 449  * @fp: file pointer (matching cb file object), may be NULL
 450  */
 451 static void mei_io_list_free_fp(struct list_head *head, const struct file *fp)
 452 {
 453         struct mei_cl_cb *cb, *next;
 454
 455         list_for_each_entry_safe(cb, next, head, list)
 456                 if (!fp || fp == cb->fp)
 457                         mei_io_cb_free(cb);
 458 }
 459
 460 /**
 461  * mei_cl_alloc_cb - a convenient wrapper for allocating read cb
 462  *
 463  * @cl: host client
 464  * @length: size of the buffer
 465  * @fop_type: operation type
 466  * @fp: associated file pointer (might be NULL)
 467  *
 468  * Return: cb on success and NULL on failure
 469  */
 470 struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,
 471                                   enum mei_cb_file_ops fop_type,
 472                                   const struct file *fp)
 473 {
 474         struct mei_cl_cb *cb;
 475
 476         cb = mei_io_cb_init(cl, fop_type, fp);
 477         if (!cb)
 478                 return NULL;
 479
 480         if (length == 0)
 481                 return cb;
 482
 483         cb->buf.data = kmalloc(length, GFP_KERNEL);
 484         if (!cb->buf.data) {
 485                 mei_io_cb_free(cb);
 486                 return NULL;
 487         }
 488         cb->buf.size = length;
 489
 490         return cb;
 491 }
 492
 493 /**
 494  * mei_cl_enqueue_ctrl_wr_cb - a convenient wrapper for allocating
 495  *     and enqueuing of the control commands cb
 496  *
 497  * @cl: host client
 498  * @length: size of the buffer
 499  * @fop_type: operation type
 500  * @fp: associated file pointer (might be NULL)
 501  *
 502  * Return: cb on success and NULL on failure
 503  * Locking: called under "dev->device_lock" lock
 504  */
 505 struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,
 506                                             enum mei_cb_file_ops fop_type,
 507                                             const struct file *fp)
 508 {
 509         struct mei_cl_cb *cb;
 510
 511         /* for RX always allocate at least client's mtu */
 512         if (length)
 513                 length = max_t(size_t, length, mei_cl_mtu(cl));
 514
 515         cb = mei_cl_alloc_cb(cl, length, fop_type, fp);
 516         if (!cb)
 517                 return NULL;
 518
 519         list_add_tail(&cb->list, &cl->dev->ctrl_wr_list);
 520         return cb;
 521 }
 522
 523 /**
 524  * mei_cl_read_cb - find this cl's callback in the read list
 525  *     for a specific file
 526  *
 527  * @cl: host client
 528  * @fp: file pointer (matching cb file object), may be NULL
 529  *
 530  * Return: cb on success, NULL if cb is not found
 531  */
 532 struct mei_cl_cb *mei_cl_read_cb(const struct mei_cl *cl, const struct file *fp)
 533 {
 534         struct mei_cl_cb *cb;
 535
 536         list_for_each_entry(cb, &cl->rd_completed, list)
 537                 if (!fp || fp == cb->fp)
 538                         return cb;
 539
 540         return NULL;
 541 }
 542
 543 /**
 544  * mei_cl_flush_queues - flushes queue lists belonging to cl.
 545  *
 546  * @cl: host client
 547  * @fp: file pointer (matching cb file object), may be NULL
 548  *
 549  * Return: 0 on success, -EINVAL if cl or cl->dev is NULL.
 550  */
 551 int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp)
 552 {
 553         struct mei_device *dev;
 554
 555         if (WARN_ON(!cl || !cl->dev))
 556                 return -EINVAL;
 557
 558         dev = cl->dev;
 559
 560         cl_dbg(dev, cl, "remove list entry belonging to cl\n");
 561         mei_io_tx_list_free_cl(&cl->dev->write_list, cl);
 562         mei_io_tx_list_free_cl(&cl->dev->write_waiting_list, cl);
 563         mei_io_list_flush_cl(&cl->dev->ctrl_wr_list, cl);
 564         mei_io_list_flush_cl(&cl->dev->ctrl_rd_list, cl);
 565         mei_io_list_free_fp(&cl->rd_pending, fp);
 566         mei_io_list_free_fp(&cl->rd_completed, fp);
 567
 568         return 0;
 569 }
 570
 571 /**
 572  * mei_cl_init - initializes cl.
 573  *
 574  * @cl: host client to be initialized
 575  * @dev: mei device
 576  */
 577 static void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)
 578 {
 579         memset(cl, 0, sizeof(struct mei_cl));
 580         init_waitqueue_head(&cl->wait);
 581         init_waitqueue_head(&cl->rx_wait);
 582         init_waitqueue_head(&cl->tx_wait);
 583         init_waitqueue_head(&cl->ev_wait);
 584         INIT_LIST_HEAD(&cl->rd_completed);
 585         INIT_LIST_HEAD(&cl->rd_pending);
 586         INIT_LIST_HEAD(&cl->link);
 587         cl->writing_state = MEI_IDLE;
 588         cl->state = MEI_FILE_UNINITIALIZED;
 589         cl->dev = dev;
 590 }
 591
 592 /**
 593  * mei_cl_allocate - allocates cl  structure and sets it up.
 594  *
 595  * @dev: mei device
 596  * Return:  The allocated file or NULL on failure
 597  */
 598 struct mei_cl *mei_cl_allocate(struct mei_device *dev)
 599 {
 600         struct mei_cl *cl;
 601
 602         cl = kmalloc(sizeof(struct mei_cl), GFP_KERNEL);
 603         if (!cl)
 604                 return NULL;
 605
 606         mei_cl_init(cl, dev);
 607
 608         return cl;
 609 }
 610
 611 /**
 612  * mei_cl_link - allocate host id in the host map
 613  *
 614  * @cl: host client
 615  *
 616  * Return: 0 on success
 617  *      -EINVAL on incorrect values
 618  *      -EMFILE if open count exceeded.
 619  */
 620 int mei_cl_link(struct mei_cl *cl)
 621 {
 622         struct mei_device *dev;
 623         int id;
 624
 625         if (WARN_ON(!cl || !cl->dev))
 626                 return -EINVAL;
 627
 628         dev = cl->dev;
 629
 630         id = find_first_zero_bit(dev->host_clients_map, MEI_CLIENTS_MAX);
 631         if (id >= MEI_CLIENTS_MAX) {
 632                 dev_err(dev->dev, "id exceeded %d", MEI_CLIENTS_MAX);
 633                 return -EMFILE;
 634         }
 635
 636         if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) {
 637                 dev_err(dev->dev, "open_handle_count exceeded %d",
 638                         MEI_MAX_OPEN_HANDLE_COUNT);
 639                 return -EMFILE;
 640         }
 641
 642         dev->open_handle_count++;
 643
 644         cl->host_client_id = id;
 645         list_add_tail(&cl->link, &dev->file_list);
 646
 647         set_bit(id, dev->host_clients_map);
 648
 649         cl->state = MEI_FILE_INITIALIZING;
 650
 651         cl_dbg(dev, cl, "link cl\n");
 652         return 0;
 653 }
 654
 655 /**
 656  * mei_cl_unlink - remove host client from the list
 657  *
 658  * @cl: host client
 659  *
 660  * Return: always 0
 661  */
 662 int mei_cl_unlink(struct mei_cl *cl)
 663 {
 664         struct mei_device *dev;
 665
 666         /* don't shout on error exit path */
 667         if (!cl)
 668                 return 0;
 669
 670         if (WARN_ON(!cl->dev))
 671                 return 0;
 672
 673         dev = cl->dev;
 674
 675         cl_dbg(dev, cl, "unlink client");
 676
 677         if (dev->open_handle_count > 0)
 678                 dev->open_handle_count--;
 679
 680         /* never clear the 0 bit */
 681         if (cl->host_client_id)
 682                 clear_bit(cl->host_client_id, dev->host_clients_map);
 683
 684         list_del_init(&cl->link);
 685
 686         cl->state = MEI_FILE_UNINITIALIZED;
 687         cl->writing_state = MEI_IDLE;
 688
 689         WARN_ON(!list_empty(&cl->rd_completed) ||
 690                 !list_empty(&cl->rd_pending) ||
 691                 !list_empty(&cl->link));
 692
 693         return 0;
 694 }
 695
 696 void mei_host_client_init(struct mei_device *dev)
 697 {
 698         dev->dev_state = MEI_DEV_ENABLED;
 699         dev->reset_count = 0;
 700
 701         schedule_work(&dev->bus_rescan_work);
 702
 703         pm_runtime_mark_last_busy(dev->dev);
 704         dev_dbg(dev->dev, "rpm: autosuspend\n");
 705         pm_request_autosuspend(dev->dev);
 706 }
 707
 708 /**
 709  * mei_hbuf_acquire - try to acquire host buffer
 710  *
 711  * @dev: the device structure
 712  * Return: true if host buffer was acquired
 713  */
 714 bool mei_hbuf_acquire(struct mei_device *dev)
 715 {
 716         if (mei_pg_state(dev) == MEI_PG_ON ||
 717             mei_pg_in_transition(dev)) {
 718                 dev_dbg(dev->dev, "device is in pg\n");
 719                 return false;
 720         }
 721
 722         if (!dev->hbuf_is_ready) {
 723                 dev_dbg(dev->dev, "hbuf is not ready\n");
 724                 return false;
 725         }
 726
 727         dev->hbuf_is_ready = false;
 728
 729         return true;
 730 }
 731
 732 /**
 733  * mei_cl_wake_all - wake up readers, writers and event waiters so
 734  *                 they can be interrupted
 735  *
 736  * @cl: host client
 737  */
 738 static void mei_cl_wake_all(struct mei_cl *cl)
 739 {
 740         struct mei_device *dev = cl->dev;
 741
 742         /* synchronized under device mutex */
 743         if (waitqueue_active(&cl->rx_wait)) {
 744                 cl_dbg(dev, cl, "Waking up reading client!\n");
 745                 wake_up_interruptible(&cl->rx_wait);
 746         }
 747         /* synchronized under device mutex */
 748         if (waitqueue_active(&cl->tx_wait)) {
 749                 cl_dbg(dev, cl, "Waking up writing client!\n");
 750                 wake_up_interruptible(&cl->tx_wait);
 751         }
 752         /* synchronized under device mutex */
 753         if (waitqueue_active(&cl->ev_wait)) {
 754                 cl_dbg(dev, cl, "Waking up waiting for event clients!\n");
 755                 wake_up_interruptible(&cl->ev_wait);
 756         }
 757         /* synchronized under device mutex */
 758         if (waitqueue_active(&cl->wait)) {
 759                 cl_dbg(dev, cl, "Waking up ctrl write clients!\n");
 760                 wake_up(&cl->wait);
 761         }
 762 }
 763
 764 /**
 765  * mei_cl_set_disconnected - set disconnected state and clear
 766  *   associated states and resources
 767  *
 768  * @cl: host client
 769  */
 770 static void mei_cl_set_disconnected(struct mei_cl *cl)
 771 {
 772         struct mei_device *dev = cl->dev;
 773
 774         if (cl->state == MEI_FILE_DISCONNECTED ||
 775             cl->state <= MEI_FILE_INITIALIZING)
 776                 return;
 777
 778         cl->state = MEI_FILE_DISCONNECTED;
 779         mei_io_tx_list_free_cl(&dev->write_list, cl);
 780         mei_io_tx_list_free_cl(&dev->write_waiting_list, cl);
 781         mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);
 782         mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);
 783         mei_cl_wake_all(cl);
 784         cl->rx_flow_ctrl_creds = 0;
 785         cl->tx_flow_ctrl_creds = 0;
 786         cl->timer_count = 0;
 787
 788         if (!cl->me_cl)
 789                 return;
 790
 791         if (!WARN_ON(cl->me_cl->connect_count == 0))
 792                 cl->me_cl->connect_count--;
 793
 794         if (cl->me_cl->connect_count == 0)
 795                 cl->me_cl->tx_flow_ctrl_creds = 0;
 796
 797         mei_me_cl_put(cl->me_cl);
 798         cl->me_cl = NULL;
 799 }
 800
 801 static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl)
 802 {
 803         if (!mei_me_cl_get(me_cl))
 804                 return -ENOENT;
 805
 806         /* only one connection is allowed for fixed address clients */
 807         if (me_cl->props.fixed_address) {
 808                 if (me_cl->connect_count) {
 809                         mei_me_cl_put(me_cl);
 810                         return -EBUSY;
 811                 }
 812         }
 813
 814         cl->me_cl = me_cl;
 815         cl->state = MEI_FILE_CONNECTING;
 816         cl->me_cl->connect_count++;
 817
 818         return 0;
 819 }
 820
 821 /*
 822  * mei_cl_send_disconnect - send disconnect request
 823  *
 824  * @cl: host client
 825  * @cb: callback block
 826  *
 827  * Return: 0, OK; otherwise, error.
 828  */
 829 static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb)
 830 {
 831         struct mei_device *dev;
 832         int ret;
 833
 834         dev = cl->dev;
 835
 836         ret = mei_hbm_cl_disconnect_req(dev, cl);
 837         cl->status = ret;
 838         if (ret) {
 839                 cl->state = MEI_FILE_DISCONNECT_REPLY;
 840                 return ret;
 841         }
 842
 843         list_move_tail(&cb->list, &dev->ctrl_rd_list);
 844         cl->timer_count = MEI_CONNECT_TIMEOUT;
 845         mei_schedule_stall_timer(dev);
 846
 847         return 0;
 848 }
 849
 850 /**
 851  * mei_cl_irq_disconnect - processes close related operation from
 852  *      interrupt thread context - send disconnect request
 853  *
 854  * @cl: client
 855  * @cb: callback block.
 856  * @cmpl_list: complete list.
 857  *
 858  * Return: 0, OK; otherwise, error.
 859  */
 860 int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,
 861                           struct list_head *cmpl_list)
 862 {
 863         struct mei_device *dev = cl->dev;
 864         u32 msg_slots;
 865         int slots;
 866         int ret;
 867
 868         msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request));
 869         slots = mei_hbuf_empty_slots(dev);
 870         if (slots < 0)
 871                 return -EOVERFLOW;
 872
 873         if ((u32)slots < msg_slots)
 874                 return -EMSGSIZE;
 875
 876         ret = mei_cl_send_disconnect(cl, cb);
 877         if (ret)
 878                 list_move_tail(&cb->list, cmpl_list);
 879
 880         return ret;
 881 }
 882
 883 /**
 884  * __mei_cl_disconnect - disconnect host client from the me one
 885  *     internal function runtime pm has to be already acquired
 886  *
 887  * @cl: host client
 888  *
 889  * Return: 0 on success, <0 on failure.
 890  */
 891 static int __mei_cl_disconnect(struct mei_cl *cl)
 892 {
 893         struct mei_device *dev;
 894         struct mei_cl_cb *cb;
 895         int rets;
 896
 897         dev = cl->dev;
 898
 899         cl->state = MEI_FILE_DISCONNECTING;
 900
 901         cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL);
 902         if (!cb) {
 903                 rets = -ENOMEM;
 904                 goto out;
 905         }
 906
 907         if (mei_hbuf_acquire(dev)) {
 908                 rets = mei_cl_send_disconnect(cl, cb);
 909                 if (rets) {
 910                         cl_err(dev, cl, "failed to disconnect.\n");
 911                         goto out;
 912                 }
 913         }
 914
 915         mutex_unlock(&dev->device_lock);
 916         wait_event_timeout(cl->wait,
 917                            cl->state == MEI_FILE_DISCONNECT_REPLY ||
 918                            cl->state == MEI_FILE_DISCONNECTED,
 919                            mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
 920         mutex_lock(&dev->device_lock);
 921
 922         rets = cl->status;
 923         if (cl->state != MEI_FILE_DISCONNECT_REPLY &&
 924             cl->state != MEI_FILE_DISCONNECTED) {
 925                 cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");
 926                 rets = -ETIME;
 927         }
 928
 929 out:
 930         /* we disconnect also on error */
 931         mei_cl_set_disconnected(cl);
 932         if (!rets)
 933                 cl_dbg(dev, cl, "successfully disconnected from FW client.\n");
 934
 935         mei_io_cb_free(cb);
 936         return rets;
 937 }
 938
 939 /**
 940  * mei_cl_disconnect - disconnect host client from the me one
 941  *
 942  * @cl: host client
 943  *
 944  * Locking: called under "dev->device_lock" lock
 945  *
 946  * Return: 0 on success, <0 on failure.
 947  */
 948 int mei_cl_disconnect(struct mei_cl *cl)
 949 {
 950         struct mei_device *dev;
 951         int rets;
 952
 953         if (WARN_ON(!cl || !cl->dev))
 954                 return -ENODEV;
 955
 956         dev = cl->dev;
 957
 958         cl_dbg(dev, cl, "disconnecting");
 959
 960         if (!mei_cl_is_connected(cl))
 961                 return 0;
 962
 963         if (mei_cl_is_fixed_address(cl)) {
 964                 mei_cl_set_disconnected(cl);
 965                 return 0;
 966         }
 967
 968         if (dev->dev_state == MEI_DEV_POWER_DOWN) {
 969                 cl_dbg(dev, cl, "Device is powering down, don't bother with disconnection\n");
 970                 mei_cl_set_disconnected(cl);
 971                 return 0;
 972         }
 973
 974         rets = pm_runtime_get(dev->dev);
 975         if (rets < 0 && rets != -EINPROGRESS) {
 976                 pm_runtime_put_noidle(dev->dev);
 977                 cl_err(dev, cl, "rpm: get failed %d\n", rets);
 978                 return rets;
 979         }
 980
 981         rets = __mei_cl_disconnect(cl);
 982
 983         cl_dbg(dev, cl, "rpm: autosuspend\n");
 984         pm_runtime_mark_last_busy(dev->dev);
 985         pm_runtime_put_autosuspend(dev->dev);
 986
 987         return rets;
 988 }
 989
 990
 991 /**
 992  * mei_cl_is_other_connecting - checks if other
 993  *    client with the same me client id is connecting
 994  *
 995  * @cl: private data of the file object
 996  *
 997  * Return: true if other client is connected, false - otherwise.
 998  */
 999 static bool mei_cl_is_other_connecting(struct mei_cl *cl)
1000 {
1001         struct mei_device *dev;
1002         struct mei_cl_cb *cb;
1003
1004         dev = cl->dev;
1005
1006         list_for_each_entry(cb, &dev->ctrl_rd_list, list) {
1007                 if (cb->fop_type == MEI_FOP_CONNECT &&
1008                     mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))
1009                         return true;
1010         }
1011
1012         return false;
1013 }
1014
1015 /**
1016  * mei_cl_send_connect - send connect request
1017  *
1018  * @cl: host client
1019  * @cb: callback block
1020  *
1021  * Return: 0, OK; otherwise, error.
1022  */
1023 static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb)
1024 {
1025         struct mei_device *dev;
1026         int ret;
1027
1028         dev = cl->dev;
1029
1030         ret = mei_hbm_cl_connect_req(dev, cl);
1031         cl->status = ret;
1032         if (ret) {
1033                 cl->state = MEI_FILE_DISCONNECT_REPLY;
1034                 return ret;
1035         }
1036
1037         list_move_tail(&cb->list, &dev->ctrl_rd_list);
1038         cl->timer_count = MEI_CONNECT_TIMEOUT;
1039         mei_schedule_stall_timer(dev);
1040         return 0;
1041 }
1042
1043 /**
1044  * mei_cl_irq_connect - send connect request in irq_thread context
1045  *
1046  * @cl: host client
1047  * @cb: callback block
1048  * @cmpl_list: complete list
1049  *
1050  * Return: 0, OK; otherwise, error.
1051  */
1052 int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,
1053                        struct list_head *cmpl_list)
1054 {
1055         struct mei_device *dev = cl->dev;
1056         u32 msg_slots;
1057         int slots;
1058         int rets;
1059
1060         if (mei_cl_is_other_connecting(cl))
1061                 return 0;
1062
1063         msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request));
1064         slots = mei_hbuf_empty_slots(dev);
1065         if (slots < 0)
1066                 return -EOVERFLOW;
1067
1068         if ((u32)slots < msg_slots)
1069                 return -EMSGSIZE;
1070
1071         rets = mei_cl_send_connect(cl, cb);
1072         if (rets)
1073                 list_move_tail(&cb->list, cmpl_list);
1074
1075         return rets;
1076 }
1077
1078 /**
1079  * mei_cl_connect - connect host client to the me one
1080  *
1081  * @cl: host client
1082  * @me_cl: me client
1083  * @fp: pointer to file structure
1084  *
1085  * Locking: called under "dev->device_lock" lock
1086  *
1087  * Return: 0 on success, <0 on failure.
1088  */
1089 int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
1090                    const struct file *fp)
1091 {
1092         struct mei_device *dev;
1093         struct mei_cl_cb *cb;
1094         int rets;
1095
1096         if (WARN_ON(!cl || !cl->dev || !me_cl))
1097                 return -ENODEV;
1098
1099         dev = cl->dev;
1100
1101         rets = mei_cl_set_connecting(cl, me_cl);
1102         if (rets)
1103                 goto nortpm;
1104
1105         if (mei_cl_is_fixed_address(cl)) {
1106                 cl->state = MEI_FILE_CONNECTED;
1107                 rets = 0;
1108                 goto nortpm;
1109         }
1110
1111         rets = pm_runtime_get(dev->dev);
1112         if (rets < 0 && rets != -EINPROGRESS) {
1113                 pm_runtime_put_noidle(dev->dev);
1114                 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1115                 goto nortpm;
1116         }
1117
1118         cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp);
1119         if (!cb) {
1120                 rets = -ENOMEM;
1121                 goto out;
1122         }
1123
1124         /* run hbuf acquire last so we don't have to undo */
1125         if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) {
1126                 rets = mei_cl_send_connect(cl, cb);
1127                 if (rets)
1128                         goto out;
1129         }
1130
1131         mutex_unlock(&dev->device_lock);
1132         wait_event_timeout(cl->wait,
1133                         (cl->state == MEI_FILE_CONNECTED ||
1134                          cl->state == MEI_FILE_DISCONNECTED ||
1135                          cl->state == MEI_FILE_DISCONNECT_REQUIRED ||
1136                          cl->state == MEI_FILE_DISCONNECT_REPLY),
1137                         mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
1138         mutex_lock(&dev->device_lock);
1139
1140         if (!mei_cl_is_connected(cl)) {
1141                 if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) {
1142                         mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);
1143                         mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);
1144                          /* ignore disconnect return valuue;
1145                           * in case of failure reset will be invoked
1146                           */
1147                         __mei_cl_disconnect(cl);
1148                         rets = -EFAULT;
1149                         goto out;
1150                 }
1151
1152                 /* timeout or something went really wrong */
1153                 if (!cl->status)
1154                         cl->status = -EFAULT;
1155         }
1156
1157         rets = cl->status;
1158 out:
1159         cl_dbg(dev, cl, "rpm: autosuspend\n");
1160         pm_runtime_mark_last_busy(dev->dev);
1161         pm_runtime_put_autosuspend(dev->dev);
1162
1163         mei_io_cb_free(cb);
1164
1165 nortpm:
1166         if (!mei_cl_is_connected(cl))
1167                 mei_cl_set_disconnected(cl);
1168
1169         return rets;
1170 }
1171
1172 /**
1173  * mei_cl_alloc_linked - allocate and link host client
1174  *
1175  * @dev: the device structure
1176  *
1177  * Return: cl on success ERR_PTR on failure
1178  */
1179 struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev)
1180 {
1181         struct mei_cl *cl;
1182         int ret;
1183
1184         cl = mei_cl_allocate(dev);
1185         if (!cl) {
1186                 ret = -ENOMEM;
1187                 goto err;
1188         }
1189
1190         ret = mei_cl_link(cl);
1191         if (ret)
1192                 goto err;
1193
1194         return cl;
1195 err:
1196         kfree(cl);
1197         return ERR_PTR(ret);
1198 }
1199
1200 /**
1201  * mei_cl_tx_flow_ctrl_creds - checks flow_control credits for cl.
1202  *
1203  * @cl: host client
1204  *
1205  * Return: 1 if tx_flow_ctrl_creds >0, 0 - otherwise.
1206  */
1207 static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl)
1208 {
1209         if (WARN_ON(!cl || !cl->me_cl))
1210                 return -EINVAL;
1211
1212         if (cl->tx_flow_ctrl_creds > 0)
1213                 return 1;
1214
1215         if (mei_cl_is_fixed_address(cl))
1216                 return 1;
1217
1218         if (mei_cl_is_single_recv_buf(cl)) {
1219                 if (cl->me_cl->tx_flow_ctrl_creds > 0)
1220                         return 1;
1221         }
1222         return 0;
1223 }
1224
1225 /**
1226  * mei_cl_tx_flow_ctrl_creds_reduce - reduces transmit flow control credits
1227  *   for a client
1228  *
1229  * @cl: host client
1230  *
1231  * Return:
1232  *      0 on success
1233  *      -EINVAL when ctrl credits are <= 0
1234  */
1235 static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl)
1236 {
1237         if (WARN_ON(!cl || !cl->me_cl))
1238                 return -EINVAL;
1239
1240         if (mei_cl_is_fixed_address(cl))
1241                 return 0;
1242
1243         if (mei_cl_is_single_recv_buf(cl)) {
1244                 if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0))
1245                         return -EINVAL;
1246                 cl->me_cl->tx_flow_ctrl_creds--;
1247         } else {
1248                 if (WARN_ON(cl->tx_flow_ctrl_creds <= 0))
1249                         return -EINVAL;
1250                 cl->tx_flow_ctrl_creds--;
1251         }
1252         return 0;
1253 }
1254
1255 /**
1256  *  mei_cl_notify_fop2req - convert fop to proper request
1257  *
1258  * @fop: client notification start response command
1259  *
1260  * Return:  MEI_HBM_NOTIFICATION_START/STOP
1261  */
1262 u8 mei_cl_notify_fop2req(enum mei_cb_file_ops fop)
1263 {
1264         if (fop == MEI_FOP_NOTIFY_START)
1265                 return MEI_HBM_NOTIFICATION_START;
1266         else
1267                 return MEI_HBM_NOTIFICATION_STOP;
1268 }
1269
1270 /**
1271  *  mei_cl_notify_req2fop - convert notification request top file operation type
1272  *
1273  * @req: hbm notification request type
1274  *
1275  * Return:  MEI_FOP_NOTIFY_START/STOP
1276  */
1277 enum mei_cb_file_ops mei_cl_notify_req2fop(u8 req)
1278 {
1279         if (req == MEI_HBM_NOTIFICATION_START)
1280                 return MEI_FOP_NOTIFY_START;
1281         else
1282                 return MEI_FOP_NOTIFY_STOP;
1283 }
1284
1285 /**
1286  * mei_cl_irq_notify - send notification request in irq_thread context
1287  *
1288  * @cl: client
1289  * @cb: callback block.
1290  * @cmpl_list: complete list.
1291  *
1292  * Return: 0 on such and error otherwise.
1293  */
1294 int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,
1295                       struct list_head *cmpl_list)
1296 {
1297         struct mei_device *dev = cl->dev;
1298         u32 msg_slots;
1299         int slots;
1300         int ret;
1301         bool request;
1302
1303         msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request));
1304         slots = mei_hbuf_empty_slots(dev);
1305         if (slots < 0)
1306                 return -EOVERFLOW;
1307
1308         if ((u32)slots < msg_slots)
1309                 return -EMSGSIZE;
1310
1311         request = mei_cl_notify_fop2req(cb->fop_type);
1312         ret = mei_hbm_cl_notify_req(dev, cl, request);
1313         if (ret) {
1314                 cl->status = ret;
1315                 list_move_tail(&cb->list, cmpl_list);
1316                 return ret;
1317         }
1318
1319         list_move_tail(&cb->list, &dev->ctrl_rd_list);
1320         return 0;
1321 }
1322
1323 /**
1324  * mei_cl_notify_request - send notification stop/start request
1325  *
1326  * @cl: host client
1327  * @fp: associate request with file
1328  * @request: 1 for start or 0 for stop
1329  *
1330  * Locking: called under "dev->device_lock" lock
1331  *
1332  * Return: 0 on such and error otherwise.
1333  */
1334 int mei_cl_notify_request(struct mei_cl *cl,
1335                           const struct file *fp, u8 request)
1336 {
1337         struct mei_device *dev;
1338         struct mei_cl_cb *cb;
1339         enum mei_cb_file_ops fop_type;
1340         int rets;
1341
1342         if (WARN_ON(!cl || !cl->dev))
1343                 return -ENODEV;
1344
1345         dev = cl->dev;
1346
1347         if (!dev->hbm_f_ev_supported) {
1348                 cl_dbg(dev, cl, "notifications not supported\n");
1349                 return -EOPNOTSUPP;
1350         }
1351
1352         if (!mei_cl_is_connected(cl))
1353                 return -ENODEV;
1354
1355         rets = pm_runtime_get(dev->dev);
1356         if (rets < 0 && rets != -EINPROGRESS) {
1357                 pm_runtime_put_noidle(dev->dev);
1358                 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1359                 return rets;
1360         }
1361
1362         fop_type = mei_cl_notify_req2fop(request);
1363         cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp);
1364         if (!cb) {
1365                 rets = -ENOMEM;
1366                 goto out;
1367         }
1368
1369         if (mei_hbuf_acquire(dev)) {
1370                 if (mei_hbm_cl_notify_req(dev, cl, request)) {
1371                         rets = -ENODEV;
1372                         goto out;
1373                 }
1374                 list_move_tail(&cb->list, &dev->ctrl_rd_list);
1375         }
1376
1377         mutex_unlock(&dev->device_lock);
1378         wait_event_timeout(cl->wait,
1379                            cl->notify_en == request || !mei_cl_is_connected(cl),
1380                            mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
1381         mutex_lock(&dev->device_lock);
1382
1383         if (cl->notify_en != request && !cl->status)
1384                 cl->status = -EFAULT;
1385
1386         rets = cl->status;
1387
1388 out:
1389         cl_dbg(dev, cl, "rpm: autosuspend\n");
1390         pm_runtime_mark_last_busy(dev->dev);
1391         pm_runtime_put_autosuspend(dev->dev);
1392
1393         mei_io_cb_free(cb);
1394         return rets;
1395 }
1396
1397 /**
1398  * mei_cl_notify - raise notification
1399  *
1400  * @cl: host client
1401  *
1402  * Locking: called under "dev->device_lock" lock
1403  */
1404 void mei_cl_notify(struct mei_cl *cl)
1405 {
1406         struct mei_device *dev;
1407
1408         if (!cl || !cl->dev)
1409                 return;
1410
1411         dev = cl->dev;
1412
1413         if (!cl->notify_en)
1414                 return;
1415
1416         cl_dbg(dev, cl, "notify event");
1417         cl->notify_ev = true;
1418         if (!mei_cl_bus_notify_event(cl))
1419                 wake_up_interruptible(&cl->ev_wait);
1420
1421         if (cl->ev_async)
1422                 kill_fasync(&cl->ev_async, SIGIO, POLL_PRI);
1423
1424 }
1425
1426 /**
1427  * mei_cl_notify_get - get or wait for notification event
1428  *
1429  * @cl: host client
1430  * @block: this request is blocking
1431  * @notify_ev: true if notification event was received
1432  *
1433  * Locking: called under "dev->device_lock" lock
1434  *
1435  * Return: 0 on such and error otherwise.
1436  */
1437 int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev)
1438 {
1439         struct mei_device *dev;
1440         int rets;
1441
1442         *notify_ev = false;
1443
1444         if (WARN_ON(!cl || !cl->dev))
1445                 return -ENODEV;
1446
1447         dev = cl->dev;
1448
1449         if (!dev->hbm_f_ev_supported) {
1450                 cl_dbg(dev, cl, "notifications not supported\n");
1451                 return -EOPNOTSUPP;
1452         }
1453
1454         if (!mei_cl_is_connected(cl))
1455                 return -ENODEV;
1456
1457         if (cl->notify_ev)
1458                 goto out;
1459
1460         if (!block)
1461                 return -EAGAIN;
1462
1463         mutex_unlock(&dev->device_lock);
1464         rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev);
1465         mutex_lock(&dev->device_lock);
1466
1467         if (rets < 0)
1468                 return rets;
1469
1470 out:
1471         *notify_ev = cl->notify_ev;
1472         cl->notify_ev = false;
1473         return 0;
1474 }
1475
1476 /**
1477  * mei_cl_read_start - the start read client message function.
1478  *
1479  * @cl: host client
1480  * @length: number of bytes to read
1481  * @fp: pointer to file structure
1482  *
1483  * Return: 0 on success, <0 on failure.
1484  */
1485 int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp)
1486 {
1487         struct mei_device *dev;
1488         struct mei_cl_cb *cb;
1489         int rets;
1490
1491         if (WARN_ON(!cl || !cl->dev))
1492                 return -ENODEV;
1493
1494         dev = cl->dev;
1495
1496         if (!mei_cl_is_connected(cl))
1497                 return -ENODEV;
1498
1499         if (!mei_me_cl_is_active(cl->me_cl)) {
1500                 cl_err(dev, cl, "no such me client\n");
1501                 return  -ENOTTY;
1502         }
1503
1504         if (mei_cl_is_fixed_address(cl))
1505                 return 0;
1506
1507         /* HW currently supports only one pending read */
1508         if (cl->rx_flow_ctrl_creds)
1509                 return -EBUSY;
1510
1511         cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp);
1512         if (!cb)
1513                 return -ENOMEM;
1514
1515         rets = pm_runtime_get(dev->dev);
1516         if (rets < 0 && rets != -EINPROGRESS) {
1517                 pm_runtime_put_noidle(dev->dev);
1518                 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1519                 goto nortpm;
1520         }
1521
1522         rets = 0;
1523         if (mei_hbuf_acquire(dev)) {
1524                 rets = mei_hbm_cl_flow_control_req(dev, cl);
1525                 if (rets < 0)
1526                         goto out;
1527
1528                 list_move_tail(&cb->list, &cl->rd_pending);
1529         }
1530         cl->rx_flow_ctrl_creds++;
1531
1532 out:
1533         cl_dbg(dev, cl, "rpm: autosuspend\n");
1534         pm_runtime_mark_last_busy(dev->dev);
1535         pm_runtime_put_autosuspend(dev->dev);
1536 nortpm:
1537         if (rets)
1538                 mei_io_cb_free(cb);
1539
1540         return rets;
1541 }
1542
1543 /**
1544  * mei_msg_hdr_init - initialize mei message header
1545  *
1546  * @mei_hdr: mei message header
1547  * @cb: message callback structure
1548  */
1549 static void mei_msg_hdr_init(struct mei_msg_hdr *mei_hdr, struct mei_cl_cb *cb)
1550 {
1551         mei_hdr->host_addr = mei_cl_host_addr(cb->cl);
1552         mei_hdr->me_addr = mei_cl_me_id(cb->cl);
1553         mei_hdr->length = 0;
1554         mei_hdr->reserved = 0;
1555         mei_hdr->msg_complete = 0;
1556         mei_hdr->dma_ring = 0;
1557         mei_hdr->internal = cb->internal;
1558 }
1559
1560 /**
1561  * mei_cl_irq_write - write a message to device
1562  *      from the interrupt thread context
1563  *
1564  * @cl: client
1565  * @cb: callback block.
1566  * @cmpl_list: complete list.
1567  *
1568  * Return: 0, OK; otherwise error.
1569  */
1570 int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
1571                      struct list_head *cmpl_list)
1572 {
1573         struct mei_device *dev;
1574         struct mei_msg_data *buf;
1575         struct mei_msg_hdr mei_hdr;
1576         size_t hdr_len = sizeof(mei_hdr);
1577         size_t len;
1578         size_t hbuf_len;
1579         int hbuf_slots;
1580         int rets;
1581         bool first_chunk;
1582
1583         if (WARN_ON(!cl || !cl->dev))
1584                 return -ENODEV;
1585
1586         dev = cl->dev;
1587
1588         buf = &cb->buf;
1589
1590         first_chunk = cb->buf_idx == 0;
1591
1592         rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1;
1593         if (rets < 0)
1594                 goto err;
1595
1596         if (rets == 0) {
1597                 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
1598                 return 0;
1599         }
1600
1601         len = buf->size - cb->buf_idx;
1602         hbuf_slots = mei_hbuf_empty_slots(dev);
1603         if (hbuf_slots < 0) {
1604                 rets = -EOVERFLOW;
1605                 goto err;
1606         }
1607
1608         hbuf_len = mei_slots2data(hbuf_slots);
1609
1610         mei_msg_hdr_init(&mei_hdr, cb);
1611
1612         /**
1613          * Split the message only if we can write the whole host buffer
1614          * otherwise wait for next time the host buffer is empty.
1615          */
1616         if (len + hdr_len <= hbuf_len) {
1617                 mei_hdr.length = len;
1618                 mei_hdr.msg_complete = 1;
1619         } else if ((u32)hbuf_slots == mei_hbuf_depth(dev)) {
1620                 mei_hdr.length = hbuf_len - hdr_len;
1621         } else {
1622                 return 0;
1623         }
1624
1625         cl_dbg(dev, cl, "buf: size = %zu idx = %zu\n",
1626                         cb->buf.size, cb->buf_idx);
1627
1628         rets = mei_write_message(dev, &mei_hdr, hdr_len,
1629                                  buf->data + cb->buf_idx, mei_hdr.length);
1630         if (rets)
1631                 goto err;
1632
1633         cl->status = 0;
1634         cl->writing_state = MEI_WRITING;
1635         cb->buf_idx += mei_hdr.length;
1636
1637         if (first_chunk) {
1638                 if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) {
1639                         rets = -EIO;
1640                         goto err;
1641                 }
1642         }
1643
1644         if (mei_hdr.msg_complete)
1645                 list_move_tail(&cb->list, &dev->write_waiting_list);
1646
1647         return 0;
1648
1649 err:
1650         cl->status = rets;
1651         list_move_tail(&cb->list, cmpl_list);
1652         return rets;
1653 }
1654
1655 /**
1656  * mei_cl_write - submit a write cb to mei device
1657  *      assumes device_lock is locked
1658  *
1659  * @cl: host client
1660  * @cb: write callback with filled data
1661  *
1662  * Return: number of bytes sent on success, <0 on failure.
1663  */
1664 ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb)
1665 {
1666         struct mei_device *dev;
1667         struct mei_msg_data *buf;
1668         struct mei_msg_hdr mei_hdr;
1669         size_t hdr_len = sizeof(mei_hdr);
1670         size_t len;
1671         size_t hbuf_len;
1672         int hbuf_slots;
1673         ssize_t rets;
1674         bool blocking;
1675
1676         if (WARN_ON(!cl || !cl->dev))
1677                 return -ENODEV;
1678
1679         if (WARN_ON(!cb))
1680                 return -EINVAL;
1681
1682         dev = cl->dev;
1683
1684         buf = &cb->buf;
1685         len = buf->size;
1686         blocking = cb->blocking;
1687
1688         cl_dbg(dev, cl, "len=%zd\n", len);
1689
1690         rets = pm_runtime_get(dev->dev);
1691         if (rets < 0 && rets != -EINPROGRESS) {
1692                 pm_runtime_put_noidle(dev->dev);
1693                 cl_err(dev, cl, "rpm: get failed %zd\n", rets);
1694                 goto free;
1695         }
1696
1697         cb->buf_idx = 0;
1698         cl->writing_state = MEI_IDLE;
1699
1700
1701         rets = mei_cl_tx_flow_ctrl_creds(cl);
1702         if (rets < 0)
1703                 goto err;
1704
1705         mei_msg_hdr_init(&mei_hdr, cb);
1706
1707         if (rets == 0) {
1708                 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
1709                 rets = len;
1710                 goto out;
1711         }
1712
1713         if (!mei_hbuf_acquire(dev)) {
1714                 cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n");
1715                 rets = len;
1716                 goto out;
1717         }
1718
1719         hbuf_slots = mei_hbuf_empty_slots(dev);
1720         if (hbuf_slots < 0) {
1721                 rets = -EOVERFLOW;
1722                 goto out;
1723         }
1724
1725         hbuf_len = mei_slots2data(hbuf_slots);
1726
1727         if (len + hdr_len <= hbuf_len) {
1728                 mei_hdr.length = len;
1729                 mei_hdr.msg_complete = 1;
1730         } else {
1731                 mei_hdr.length = hbuf_len - hdr_len;
1732         }
1733
1734         rets = mei_write_message(dev, &mei_hdr, hdr_len,
1735                                  buf->data, mei_hdr.length);
1736         if (rets)
1737                 goto err;
1738
1739         rets = mei_cl_tx_flow_ctrl_creds_reduce(cl);
1740         if (rets)
1741                 goto err;
1742
1743         cl->writing_state = MEI_WRITING;
1744         cb->buf_idx = mei_hdr.length;
1745
1746 out:
1747         if (mei_hdr.msg_complete)
1748                 mei_tx_cb_enqueue(cb, &dev->write_waiting_list);
1749         else
1750                 mei_tx_cb_enqueue(cb, &dev->write_list);
1751
1752         cb = NULL;
1753         if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {
1754
1755                 mutex_unlock(&dev->device_lock);
1756                 rets = wait_event_interruptible(cl->tx_wait,
1757                                 cl->writing_state == MEI_WRITE_COMPLETE ||
1758                                 (!mei_cl_is_connected(cl)));
1759                 mutex_lock(&dev->device_lock);
1760                 /* wait_event_interruptible returns -ERESTARTSYS */
1761                 if (rets) {
1762                         if (signal_pending(current))
1763                                 rets = -EINTR;
1764                         goto err;
1765                 }
1766                 if (cl->writing_state != MEI_WRITE_COMPLETE) {
1767                         rets = -EFAULT;
1768                         goto err;
1769                 }
1770         }
1771
1772         rets = len;
1773 err:
1774         cl_dbg(dev, cl, "rpm: autosuspend\n");
1775         pm_runtime_mark_last_busy(dev->dev);
1776         pm_runtime_put_autosuspend(dev->dev);
1777 free:
1778         mei_io_cb_free(cb);
1779
1780         return rets;
1781 }
1782
1783
1784 /**
1785  * mei_cl_complete - processes completed operation for a client
1786  *
1787  * @cl: private data of the file object.
1788  * @cb: callback block.
1789  */
1790 void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
1791 {
1792         struct mei_device *dev = cl->dev;
1793
1794         switch (cb->fop_type) {
1795         case MEI_FOP_WRITE:
1796                 mei_tx_cb_dequeue(cb);
1797                 cl->writing_state = MEI_WRITE_COMPLETE;
1798                 if (waitqueue_active(&cl->tx_wait)) {
1799                         wake_up_interruptible(&cl->tx_wait);
1800                 } else {
1801                         pm_runtime_mark_last_busy(dev->dev);
1802                         pm_request_autosuspend(dev->dev);
1803                 }
1804                 break;
1805
1806         case MEI_FOP_READ:
1807                 list_add_tail(&cb->list, &cl->rd_completed);
1808                 if (!mei_cl_is_fixed_address(cl) &&
1809                     !WARN_ON(!cl->rx_flow_ctrl_creds))
1810                         cl->rx_flow_ctrl_creds--;
1811                 if (!mei_cl_bus_rx_event(cl))
1812                         wake_up_interruptible(&cl->rx_wait);
1813                 break;
1814
1815         case MEI_FOP_CONNECT:
1816         case MEI_FOP_DISCONNECT:
1817         case MEI_FOP_NOTIFY_STOP:
1818         case MEI_FOP_NOTIFY_START:
1819                 if (waitqueue_active(&cl->wait))
1820                         wake_up(&cl->wait);
1821
1822                 break;
1823         case MEI_FOP_DISCONNECT_RSP:
1824                 mei_io_cb_free(cb);
1825                 mei_cl_set_disconnected(cl);
1826                 break;
1827         default:
1828                 BUG_ON(0);
1829         }
1830 }
1831
1832
1833 /**
1834  * mei_cl_all_disconnect - disconnect forcefully all connected clients
1835  *
1836  * @dev: mei device
1837  */
1838 void mei_cl_all_disconnect(struct mei_device *dev)
1839 {
1840         struct mei_cl *cl;
1841
1842         list_for_each_entry(cl, &dev->file_list, link)
1843                 mei_cl_set_disconnected(cl);
1844 }