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