1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright (c) 2003-2022, Intel Corporation. All rights reserved. 4 * Intel Management Engine Interface (Intel MEI) Linux driver 5 */ 6 7#include <linux/sched/signal.h> 8#include <linux/wait.h> 9#include <linux/delay.h> 10#include <linux/slab.h> 11#include <linux/pm_runtime.h> 12#include <linux/dma-mapping.h> 13 14#include <linux/mei.h> 15 16#include "mei_dev.h" 17#include "hbm.h" 18#include "client.h" 19 20/** 21 * mei_me_cl_init - initialize me client 22 * 23 * @me_cl: me client 24 */ 25void mei_me_cl_init(struct mei_me_client *me_cl) 26{ 27 INIT_LIST_HEAD(&me_cl->list); 28 kref_init(&me_cl->refcnt); 29} 30 31/** 32 * mei_me_cl_get - increases me client refcount 33 * 34 * @me_cl: me client 35 * 36 * Locking: called under "dev->device_lock" lock 37 * 38 * Return: me client or NULL 39 */ 40struct mei_me_client *mei_me_cl_get(struct mei_me_client *me_cl) 41{ 42 if (me_cl && kref_get_unless_zero(&me_cl->refcnt)) 43 return me_cl; 44 45 return NULL; 46} 47 48/** 49 * mei_me_cl_release - free me client 50 * 51 * @ref: me_client refcount 52 * 53 * Locking: called under "dev->device_lock" lock 54 */ 55static void mei_me_cl_release(struct kref *ref) 56{ 57 struct mei_me_client *me_cl = 58 container_of(ref, struct mei_me_client, refcnt); 59 60 kfree(me_cl); 61} 62 63/** 64 * mei_me_cl_put - decrease me client refcount and free client if necessary 65 * 66 * @me_cl: me client 67 * 68 * Locking: called under "dev->device_lock" lock 69 */ 70void mei_me_cl_put(struct mei_me_client *me_cl) 71{ 72 if (me_cl) 73 kref_put(&me_cl->refcnt, mei_me_cl_release); 74} 75 76/** 77 * __mei_me_cl_del - delete me client from the list and decrease 78 * reference counter 79 * 80 * @dev: mei device 81 * @me_cl: me client 82 * 83 * Locking: dev->me_clients_rwsem 84 */ 85static void __mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl) 86{ 87 if (!me_cl) 88 return; 89 90 list_del_init(&me_cl->list); 91 mei_me_cl_put(me_cl); 92} 93 94/** 95 * mei_me_cl_del - delete me client from the list and decrease 96 * reference counter 97 * 98 * @dev: mei device 99 * @me_cl: me client 100 */ 101void mei_me_cl_del(struct mei_device *dev, struct mei_me_client *me_cl) 102{ 103 down_write(&dev->me_clients_rwsem); 104 __mei_me_cl_del(dev, me_cl); 105 up_write(&dev->me_clients_rwsem); 106} 107 108/** 109 * mei_me_cl_add - add me client to the list 110 * 111 * @dev: mei device 112 * @me_cl: me client 113 */ 114void mei_me_cl_add(struct mei_device *dev, struct mei_me_client *me_cl) 115{ 116 down_write(&dev->me_clients_rwsem); 117 list_add(&me_cl->list, &dev->me_clients); 118 up_write(&dev->me_clients_rwsem); 119} 120 121/** 122 * __mei_me_cl_by_uuid - locate me client by uuid 123 * increases ref count 124 * 125 * @dev: mei device 126 * @uuid: me client uuid 127 * 128 * Return: me client or NULL if not found 129 * 130 * Locking: dev->me_clients_rwsem 131 */ 132static struct mei_me_client *__mei_me_cl_by_uuid(struct mei_device *dev, 133 const uuid_le *uuid) 134{ 135 struct mei_me_client *me_cl; 136 const uuid_le *pn; 137 138 WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem)); 139 140 list_for_each_entry(me_cl, &dev->me_clients, list) { 141 pn = &me_cl->props.protocol_name; 142 if (uuid_le_cmp(*uuid, *pn) == 0) 143 return mei_me_cl_get(me_cl); 144 } 145 146 return NULL; 147} 148 149/** 150 * mei_me_cl_by_uuid - locate me client by uuid 151 * increases ref count 152 * 153 * @dev: mei device 154 * @uuid: me client uuid 155 * 156 * Return: me client or NULL if not found 157 * 158 * Locking: dev->me_clients_rwsem 159 */ 160struct mei_me_client *mei_me_cl_by_uuid(struct mei_device *dev, 161 const uuid_le *uuid) 162{ 163 struct mei_me_client *me_cl; 164 165 down_read(&dev->me_clients_rwsem); 166 me_cl = __mei_me_cl_by_uuid(dev, uuid); 167 up_read(&dev->me_clients_rwsem); 168 169 return me_cl; 170} 171 172/** 173 * mei_me_cl_by_id - locate me client by client id 174 * increases ref count 175 * 176 * @dev: the device structure 177 * @client_id: me client id 178 * 179 * Return: me client or NULL if not found 180 * 181 * Locking: dev->me_clients_rwsem 182 */ 183struct mei_me_client *mei_me_cl_by_id(struct mei_device *dev, u8 client_id) 184{ 185 186 struct mei_me_client *__me_cl, *me_cl = NULL; 187 188 down_read(&dev->me_clients_rwsem); 189 list_for_each_entry(__me_cl, &dev->me_clients, list) { 190 if (__me_cl->client_id == client_id) { 191 me_cl = mei_me_cl_get(__me_cl); 192 break; 193 } 194 } 195 up_read(&dev->me_clients_rwsem); 196 197 return me_cl; 198} 199 200/** 201 * __mei_me_cl_by_uuid_id - locate me client by client id and uuid 202 * increases ref count 203 * 204 * @dev: the device structure 205 * @uuid: me client uuid 206 * @client_id: me client id 207 * 208 * Return: me client or null if not found 209 * 210 * Locking: dev->me_clients_rwsem 211 */ 212static struct mei_me_client *__mei_me_cl_by_uuid_id(struct mei_device *dev, 213 const uuid_le *uuid, u8 client_id) 214{ 215 struct mei_me_client *me_cl; 216 const uuid_le *pn; 217 218 WARN_ON(!rwsem_is_locked(&dev->me_clients_rwsem)); 219 220 list_for_each_entry(me_cl, &dev->me_clients, list) { 221 pn = &me_cl->props.protocol_name; 222 if (uuid_le_cmp(*uuid, *pn) == 0 && 223 me_cl->client_id == client_id) 224 return mei_me_cl_get(me_cl); 225 } 226 227 return NULL; 228} 229 230 231/** 232 * mei_me_cl_by_uuid_id - locate me client by client id and uuid 233 * increases ref count 234 * 235 * @dev: the device structure 236 * @uuid: me client uuid 237 * @client_id: me client id 238 * 239 * Return: me client or null if not found 240 */ 241struct mei_me_client *mei_me_cl_by_uuid_id(struct mei_device *dev, 242 const uuid_le *uuid, u8 client_id) 243{ 244 struct mei_me_client *me_cl; 245 246 down_read(&dev->me_clients_rwsem); 247 me_cl = __mei_me_cl_by_uuid_id(dev, uuid, client_id); 248 up_read(&dev->me_clients_rwsem); 249 250 return me_cl; 251} 252 253/** 254 * mei_me_cl_rm_by_uuid - remove all me clients matching uuid 255 * 256 * @dev: the device structure 257 * @uuid: me client uuid 258 * 259 * Locking: called under "dev->device_lock" lock 260 */ 261void mei_me_cl_rm_by_uuid(struct mei_device *dev, const uuid_le *uuid) 262{ 263 struct mei_me_client *me_cl; 264 265 dev_dbg(dev->dev, "remove %pUl\n", uuid); 266 267 down_write(&dev->me_clients_rwsem); 268 me_cl = __mei_me_cl_by_uuid(dev, uuid); 269 __mei_me_cl_del(dev, me_cl); 270 mei_me_cl_put(me_cl); 271 up_write(&dev->me_clients_rwsem); 272} 273 274/** 275 * mei_me_cl_rm_by_uuid_id - remove all me clients matching client id 276 * 277 * @dev: the device structure 278 * @uuid: me client uuid 279 * @id: me client id 280 * 281 * Locking: called under "dev->device_lock" lock 282 */ 283void mei_me_cl_rm_by_uuid_id(struct mei_device *dev, const uuid_le *uuid, u8 id) 284{ 285 struct mei_me_client *me_cl; 286 287 dev_dbg(dev->dev, "remove %pUl %d\n", uuid, id); 288 289 down_write(&dev->me_clients_rwsem); 290 me_cl = __mei_me_cl_by_uuid_id(dev, uuid, id); 291 __mei_me_cl_del(dev, me_cl); 292 mei_me_cl_put(me_cl); 293 up_write(&dev->me_clients_rwsem); 294} 295 296/** 297 * mei_me_cl_rm_all - remove all me clients 298 * 299 * @dev: the device structure 300 * 301 * Locking: called under "dev->device_lock" lock 302 */ 303void mei_me_cl_rm_all(struct mei_device *dev) 304{ 305 struct mei_me_client *me_cl, *next; 306 307 down_write(&dev->me_clients_rwsem); 308 list_for_each_entry_safe(me_cl, next, &dev->me_clients, list) 309 __mei_me_cl_del(dev, me_cl); 310 up_write(&dev->me_clients_rwsem); 311} 312 313/** 314 * mei_io_cb_free - free mei_cb_private related memory 315 * 316 * @cb: mei callback struct 317 */ 318void mei_io_cb_free(struct mei_cl_cb *cb) 319{ 320 if (cb == NULL) 321 return; 322 323 list_del(&cb->list); 324 kfree(cb->buf.data); 325 kfree(cb->ext_hdr); 326 kfree(cb); 327} 328 329/** 330 * mei_tx_cb_enqueue - queue tx callback 331 * 332 * @cb: mei callback struct 333 * @head: an instance of list to queue on 334 * 335 * Locking: called under "dev->device_lock" lock 336 */ 337static inline void mei_tx_cb_enqueue(struct mei_cl_cb *cb, 338 struct list_head *head) 339{ 340 list_add_tail(&cb->list, head); 341 cb->cl->tx_cb_queued++; 342} 343 344/** 345 * mei_tx_cb_dequeue - dequeue tx callback 346 * 347 * @cb: mei callback struct to dequeue and free 348 * 349 * Locking: called under "dev->device_lock" lock 350 */ 351static inline void mei_tx_cb_dequeue(struct mei_cl_cb *cb) 352{ 353 if (!WARN_ON(cb->cl->tx_cb_queued == 0)) 354 cb->cl->tx_cb_queued--; 355 356 mei_io_cb_free(cb); 357} 358 359/** 360 * mei_cl_set_read_by_fp - set pending_read flag to vtag struct for given fp 361 * 362 * @cl: mei client 363 * @fp: pointer to file structure 364 * 365 * Locking: called under "dev->device_lock" lock 366 */ 367static void mei_cl_set_read_by_fp(const struct mei_cl *cl, 368 const struct file *fp) 369{ 370 struct mei_cl_vtag *cl_vtag; 371 372 list_for_each_entry(cl_vtag, &cl->vtag_map, list) { 373 if (cl_vtag->fp == fp) { 374 cl_vtag->pending_read = true; 375 return; 376 } 377 } 378} 379 380/** 381 * mei_io_cb_init - allocate and initialize io callback 382 * 383 * @cl: mei client 384 * @type: operation type 385 * @fp: pointer to file structure 386 * 387 * Return: mei_cl_cb pointer or NULL; 388 */ 389static struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl, 390 enum mei_cb_file_ops type, 391 const struct file *fp) 392{ 393 struct mei_cl_cb *cb; 394 395 cb = kzalloc(sizeof(*cb), GFP_KERNEL); 396 if (!cb) 397 return NULL; 398 399 INIT_LIST_HEAD(&cb->list); 400 cb->fp = fp; 401 cb->cl = cl; 402 cb->buf_idx = 0; 403 cb->fop_type = type; 404 cb->vtag = 0; 405 cb->ext_hdr = NULL; 406 407 return cb; 408} 409 410/** 411 * mei_io_list_flush_cl - removes cbs belonging to the cl. 412 * 413 * @head: an instance of our list structure 414 * @cl: host client 415 */ 416static void mei_io_list_flush_cl(struct list_head *head, 417 const struct mei_cl *cl) 418{ 419 struct mei_cl_cb *cb, *next; 420 421 list_for_each_entry_safe(cb, next, head, list) { 422 if (cl == cb->cl) { 423 list_del_init(&cb->list); 424 if (cb->fop_type == MEI_FOP_READ) 425 mei_io_cb_free(cb); 426 } 427 } 428} 429 430/** 431 * mei_io_tx_list_free_cl - removes cb belonging to the cl and free them 432 * 433 * @head: An instance of our list structure 434 * @cl: host client 435 * @fp: file pointer (matching cb file object), may be NULL 436 */ 437static void mei_io_tx_list_free_cl(struct list_head *head, 438 const struct mei_cl *cl, 439 const struct file *fp) 440{ 441 struct mei_cl_cb *cb, *next; 442 443 list_for_each_entry_safe(cb, next, head, list) { 444 if (cl == cb->cl && (!fp || fp == cb->fp)) 445 mei_tx_cb_dequeue(cb); 446 } 447} 448 449/** 450 * mei_io_list_free_fp - free cb from a list that matches file pointer 451 * 452 * @head: io list 453 * @fp: file pointer (matching cb file object), may be NULL 454 */ 455static void mei_io_list_free_fp(struct list_head *head, const struct file *fp) 456{ 457 struct mei_cl_cb *cb, *next; 458 459 list_for_each_entry_safe(cb, next, head, list) 460 if (!fp || fp == cb->fp) 461 mei_io_cb_free(cb); 462} 463 464/** 465 * mei_cl_free_pending - free pending cb 466 * 467 * @cl: host client 468 */ 469static void mei_cl_free_pending(struct mei_cl *cl) 470{ 471 struct mei_cl_cb *cb; 472 473 cb = list_first_entry_or_null(&cl->rd_pending, struct mei_cl_cb, list); 474 mei_io_cb_free(cb); 475} 476 477/** 478 * mei_cl_alloc_cb - a convenient wrapper for allocating read cb 479 * 480 * @cl: host client 481 * @length: size of the buffer 482 * @fop_type: operation type 483 * @fp: associated file pointer (might be NULL) 484 * 485 * Return: cb on success and NULL on failure 486 */ 487struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length, 488 enum mei_cb_file_ops fop_type, 489 const struct file *fp) 490{ 491 struct mei_cl_cb *cb; 492 493 cb = mei_io_cb_init(cl, fop_type, fp); 494 if (!cb) 495 return NULL; 496 497 if (length == 0) 498 return cb; 499 500 cb->buf.data = kmalloc(roundup(length, MEI_SLOT_SIZE), GFP_KERNEL); 501 if (!cb->buf.data) { 502 mei_io_cb_free(cb); 503 return NULL; 504 } 505 cb->buf.size = length; 506 507 return cb; 508} 509 510/** 511 * mei_cl_enqueue_ctrl_wr_cb - a convenient wrapper for allocating 512 * and enqueuing of the control commands cb 513 * 514 * @cl: host client 515 * @length: size of the buffer 516 * @fop_type: operation type 517 * @fp: associated file pointer (might be NULL) 518 * 519 * Return: cb on success and NULL on failure 520 * Locking: called under "dev->device_lock" lock 521 */ 522struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length, 523 enum mei_cb_file_ops fop_type, 524 const struct file *fp) 525{ 526 struct mei_cl_cb *cb; 527 528 /* for RX always allocate at least client's mtu */ 529 if (length) 530 length = max_t(size_t, length, mei_cl_mtu(cl)); 531 532 cb = mei_cl_alloc_cb(cl, length, fop_type, fp); 533 if (!cb) 534 return NULL; 535 536 list_add_tail(&cb->list, &cl->dev->ctrl_wr_list); 537 return cb; 538} 539 540/** 541 * mei_cl_read_cb - find this cl's callback in the read list 542 * for a specific file 543 * 544 * @cl: host client 545 * @fp: file pointer (matching cb file object), may be NULL 546 * 547 * Return: cb on success, NULL if cb is not found 548 */ 549struct mei_cl_cb *mei_cl_read_cb(struct mei_cl *cl, const struct file *fp) 550{ 551 struct mei_cl_cb *cb; 552 struct mei_cl_cb *ret_cb = NULL; 553 554 spin_lock(&cl->rd_completed_lock); 555 list_for_each_entry(cb, &cl->rd_completed, list) 556 if (!fp || fp == cb->fp) { 557 ret_cb = cb; 558 break; 559 } 560 spin_unlock(&cl->rd_completed_lock); 561 return ret_cb; 562} 563 564/** 565 * mei_cl_flush_queues - flushes queue lists belonging to cl. 566 * 567 * @cl: host client 568 * @fp: file pointer (matching cb file object), may be NULL 569 * 570 * Return: 0 on success, -EINVAL if cl or cl->dev is NULL. 571 */ 572int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp) 573{ 574 struct mei_device *dev; 575 576 if (WARN_ON(!cl || !cl->dev)) 577 return -EINVAL; 578 579 dev = cl->dev; 580 581 cl_dbg(dev, cl, "remove list entry belonging to cl\n"); 582 mei_io_tx_list_free_cl(&cl->dev->write_list, cl, fp); 583 mei_io_tx_list_free_cl(&cl->dev->write_waiting_list, cl, fp); 584 /* free pending and control cb only in final flush */ 585 if (!fp) { 586 mei_io_list_flush_cl(&cl->dev->ctrl_wr_list, cl); 587 mei_io_list_flush_cl(&cl->dev->ctrl_rd_list, cl); 588 mei_cl_free_pending(cl); 589 } 590 spin_lock(&cl->rd_completed_lock); 591 mei_io_list_free_fp(&cl->rd_completed, fp); 592 spin_unlock(&cl->rd_completed_lock); 593 594 return 0; 595} 596 597/** 598 * mei_cl_init - initializes cl. 599 * 600 * @cl: host client to be initialized 601 * @dev: mei device 602 */ 603static void mei_cl_init(struct mei_cl *cl, struct mei_device *dev) 604{ 605 memset(cl, 0, sizeof(*cl)); 606 init_waitqueue_head(&cl->wait); 607 init_waitqueue_head(&cl->rx_wait); 608 init_waitqueue_head(&cl->tx_wait); 609 init_waitqueue_head(&cl->ev_wait); 610 INIT_LIST_HEAD(&cl->vtag_map); 611 spin_lock_init(&cl->rd_completed_lock); 612 INIT_LIST_HEAD(&cl->rd_completed); 613 INIT_LIST_HEAD(&cl->rd_pending); 614 INIT_LIST_HEAD(&cl->link); 615 cl->writing_state = MEI_IDLE; 616 cl->state = MEI_FILE_UNINITIALIZED; 617 cl->dev = dev; 618} 619 620/** 621 * mei_cl_allocate - allocates cl structure and sets it up. 622 * 623 * @dev: mei device 624 * Return: The allocated file or NULL on failure 625 */ 626struct mei_cl *mei_cl_allocate(struct mei_device *dev) 627{ 628 struct mei_cl *cl; 629 630 cl = kmalloc(sizeof(*cl), GFP_KERNEL); 631 if (!cl) 632 return NULL; 633 634 mei_cl_init(cl, dev); 635 636 return cl; 637} 638 639/** 640 * mei_cl_link - allocate host id in the host map 641 * 642 * @cl: host client 643 * 644 * Return: 0 on success 645 * -EINVAL on incorrect values 646 * -EMFILE if open count exceeded. 647 */ 648int mei_cl_link(struct mei_cl *cl) 649{ 650 struct mei_device *dev; 651 int id; 652 653 if (WARN_ON(!cl || !cl->dev)) 654 return -EINVAL; 655 656 dev = cl->dev; 657 658 id = find_first_zero_bit(dev->host_clients_map, MEI_CLIENTS_MAX); 659 if (id >= MEI_CLIENTS_MAX) { 660 dev_err(dev->dev, "id exceeded %d", MEI_CLIENTS_MAX); 661 return -EMFILE; 662 } 663 664 if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) { 665 dev_err(dev->dev, "open_handle_count exceeded %d", 666 MEI_MAX_OPEN_HANDLE_COUNT); 667 return -EMFILE; 668 } 669 670 dev->open_handle_count++; 671 672 cl->host_client_id = id; 673 list_add_tail(&cl->link, &dev->file_list); 674 675 set_bit(id, dev->host_clients_map); 676 677 cl->state = MEI_FILE_INITIALIZING; 678 679 cl_dbg(dev, cl, "link cl\n"); 680 return 0; 681} 682 683/** 684 * mei_cl_unlink - remove host client from the list 685 * 686 * @cl: host client 687 * 688 * Return: always 0 689 */ 690int mei_cl_unlink(struct mei_cl *cl) 691{ 692 struct mei_device *dev; 693 694 /* don't shout on error exit path */ 695 if (!cl) 696 return 0; 697 698 if (WARN_ON(!cl->dev)) 699 return 0; 700 701 dev = cl->dev; 702 703 cl_dbg(dev, cl, "unlink client"); 704 705 if (cl->state == MEI_FILE_UNINITIALIZED) 706 return 0; 707 708 if (dev->open_handle_count > 0) 709 dev->open_handle_count--; 710 711 /* never clear the 0 bit */ 712 if (cl->host_client_id) 713 clear_bit(cl->host_client_id, dev->host_clients_map); 714 715 list_del_init(&cl->link); 716 717 cl->state = MEI_FILE_UNINITIALIZED; 718 cl->writing_state = MEI_IDLE; 719 720 WARN_ON(!list_empty(&cl->rd_completed) || 721 !list_empty(&cl->rd_pending) || 722 !list_empty(&cl->link)); 723 724 return 0; 725} 726 727void mei_host_client_init(struct mei_device *dev) 728{ 729 mei_set_devstate(dev, MEI_DEV_ENABLED); 730 dev->reset_count = 0; 731 732 schedule_work(&dev->bus_rescan_work); 733 734 pm_runtime_mark_last_busy(dev->dev); 735 dev_dbg(dev->dev, "rpm: autosuspend\n"); 736 pm_request_autosuspend(dev->dev); 737} 738 739/** 740 * mei_hbuf_acquire - try to acquire host buffer 741 * 742 * @dev: the device structure 743 * Return: true if host buffer was acquired 744 */ 745bool mei_hbuf_acquire(struct mei_device *dev) 746{ 747 if (mei_pg_state(dev) == MEI_PG_ON || 748 mei_pg_in_transition(dev)) { 749 dev_dbg(dev->dev, "device is in pg\n"); 750 return false; 751 } 752 753 if (!dev->hbuf_is_ready) { 754 dev_dbg(dev->dev, "hbuf is not ready\n"); 755 return false; 756 } 757 758 dev->hbuf_is_ready = false; 759 760 return true; 761} 762 763/** 764 * mei_cl_wake_all - wake up readers, writers and event waiters so 765 * they can be interrupted 766 * 767 * @cl: host client 768 */ 769static void mei_cl_wake_all(struct mei_cl *cl) 770{ 771 struct mei_device *dev = cl->dev; 772 773 /* synchronized under device mutex */ 774 if (waitqueue_active(&cl->rx_wait)) { 775 cl_dbg(dev, cl, "Waking up reading client!\n"); 776 wake_up_interruptible(&cl->rx_wait); 777 } 778 /* synchronized under device mutex */ 779 if (waitqueue_active(&cl->tx_wait)) { 780 cl_dbg(dev, cl, "Waking up writing client!\n"); 781 wake_up_interruptible(&cl->tx_wait); 782 } 783 /* synchronized under device mutex */ 784 if (waitqueue_active(&cl->ev_wait)) { 785 cl_dbg(dev, cl, "Waking up waiting for event clients!\n"); 786 wake_up_interruptible(&cl->ev_wait); 787 } 788 /* synchronized under device mutex */ 789 if (waitqueue_active(&cl->wait)) { 790 cl_dbg(dev, cl, "Waking up ctrl write clients!\n"); 791 wake_up(&cl->wait); 792 } 793} 794 795/** 796 * mei_cl_set_disconnected - set disconnected state and clear 797 * associated states and resources 798 * 799 * @cl: host client 800 */ 801static void mei_cl_set_disconnected(struct mei_cl *cl) 802{ 803 struct mei_device *dev = cl->dev; 804 805 if (cl->state == MEI_FILE_DISCONNECTED || 806 cl->state <= MEI_FILE_INITIALIZING) 807 return; 808 809 cl->state = MEI_FILE_DISCONNECTED; 810 mei_io_tx_list_free_cl(&dev->write_list, cl, NULL); 811 mei_io_tx_list_free_cl(&dev->write_waiting_list, cl, NULL); 812 mei_io_list_flush_cl(&dev->ctrl_rd_list, cl); 813 mei_io_list_flush_cl(&dev->ctrl_wr_list, cl); 814 mei_cl_wake_all(cl); 815 cl->rx_flow_ctrl_creds = 0; 816 cl->tx_flow_ctrl_creds = 0; 817 cl->timer_count = 0; 818 819 if (!cl->me_cl) 820 return; 821 822 if (!WARN_ON(cl->me_cl->connect_count == 0)) 823 cl->me_cl->connect_count--; 824 825 if (cl->me_cl->connect_count == 0) 826 cl->me_cl->tx_flow_ctrl_creds = 0; 827 828 mei_me_cl_put(cl->me_cl); 829 cl->me_cl = NULL; 830} 831 832static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl) 833{ 834 if (!mei_me_cl_get(me_cl)) 835 return -ENOENT; 836 837 /* only one connection is allowed for fixed address clients */ 838 if (me_cl->props.fixed_address) { 839 if (me_cl->connect_count) { 840 mei_me_cl_put(me_cl); 841 return -EBUSY; 842 } 843 } 844 845 cl->me_cl = me_cl; 846 cl->state = MEI_FILE_CONNECTING; 847 cl->me_cl->connect_count++; 848 849 return 0; 850} 851 852/* 853 * mei_cl_send_disconnect - send disconnect request 854 * 855 * @cl: host client 856 * @cb: callback block 857 * 858 * Return: 0, OK; otherwise, error. 859 */ 860static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb) 861{ 862 struct mei_device *dev; 863 int ret; 864 865 dev = cl->dev; 866 867 ret = mei_hbm_cl_disconnect_req(dev, cl); 868 cl->status = ret; 869 if (ret) { 870 cl->state = MEI_FILE_DISCONNECT_REPLY; 871 return ret; 872 } 873 874 list_move_tail(&cb->list, &dev->ctrl_rd_list); 875 cl->timer_count = dev->timeouts.connect; 876 mei_schedule_stall_timer(dev); 877 878 return 0; 879} 880 881/** 882 * mei_cl_irq_disconnect - processes close related operation from 883 * interrupt thread context - send disconnect request 884 * 885 * @cl: client 886 * @cb: callback block. 887 * @cmpl_list: complete list. 888 * 889 * Return: 0, OK; otherwise, error. 890 */ 891int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb, 892 struct list_head *cmpl_list) 893{ 894 struct mei_device *dev = cl->dev; 895 u32 msg_slots; 896 int slots; 897 int ret; 898 899 msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request)); 900 slots = mei_hbuf_empty_slots(dev); 901 if (slots < 0) 902 return -EOVERFLOW; 903 904 if ((u32)slots < msg_slots) 905 return -EMSGSIZE; 906 907 ret = mei_cl_send_disconnect(cl, cb); 908 if (ret) 909 list_move_tail(&cb->list, cmpl_list); 910 911 return ret; 912} 913 914/** 915 * __mei_cl_disconnect - disconnect host client from the me one 916 * internal function runtime pm has to be already acquired 917 * 918 * @cl: host client 919 * 920 * Return: 0 on success, <0 on failure. 921 */ 922static int __mei_cl_disconnect(struct mei_cl *cl) 923{ 924 struct mei_device *dev; 925 struct mei_cl_cb *cb; 926 int rets; 927 928 dev = cl->dev; 929 930 cl->state = MEI_FILE_DISCONNECTING; 931 932 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL); 933 if (!cb) { 934 rets = -ENOMEM; 935 goto out; 936 } 937 938 if (mei_hbuf_acquire(dev)) { 939 rets = mei_cl_send_disconnect(cl, cb); 940 if (rets) { 941 cl_err(dev, cl, "failed to disconnect.\n"); 942 goto out; 943 } 944 } 945 946 mutex_unlock(&dev->device_lock); 947 wait_event_timeout(cl->wait, 948 cl->state == MEI_FILE_DISCONNECT_REPLY || 949 cl->state == MEI_FILE_DISCONNECTED, 950 dev->timeouts.cl_connect); 951 mutex_lock(&dev->device_lock); 952 953 rets = cl->status; 954 if (cl->state != MEI_FILE_DISCONNECT_REPLY && 955 cl->state != MEI_FILE_DISCONNECTED) { 956 cl_dbg(dev, cl, "timeout on disconnect from FW client.\n"); 957 rets = -ETIME; 958 } 959 960out: 961 /* we disconnect also on error */ 962 mei_cl_set_disconnected(cl); 963 if (!rets) 964 cl_dbg(dev, cl, "successfully disconnected from FW client.\n"); 965 966 mei_io_cb_free(cb); 967 return rets; 968} 969 970/** 971 * mei_cl_disconnect - disconnect host client from the me one 972 * 973 * @cl: host client 974 * 975 * Locking: called under "dev->device_lock" lock 976 * 977 * Return: 0 on success, <0 on failure. 978 */ 979int mei_cl_disconnect(struct mei_cl *cl) 980{ 981 struct mei_device *dev; 982 int rets; 983 984 if (WARN_ON(!cl || !cl->dev)) 985 return -ENODEV; 986 987 dev = cl->dev; 988 989 cl_dbg(dev, cl, "disconnecting"); 990 991 if (!mei_cl_is_connected(cl)) 992 return 0; 993 994 if (mei_cl_is_fixed_address(cl)) { 995 mei_cl_set_disconnected(cl); 996 return 0; 997 } 998 999 if (dev->dev_state == MEI_DEV_POWERING_DOWN || 1000 dev->dev_state == MEI_DEV_POWER_DOWN) { 1001 cl_dbg(dev, cl, "Device is powering down, don't bother with disconnection\n"); 1002 mei_cl_set_disconnected(cl); 1003 return 0; 1004 } 1005 1006 rets = pm_runtime_get(dev->dev); 1007 if (rets < 0 && rets != -EINPROGRESS) { 1008 pm_runtime_put_noidle(dev->dev); 1009 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1010 return rets; 1011 } 1012 1013 rets = __mei_cl_disconnect(cl); 1014 1015 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1016 pm_runtime_mark_last_busy(dev->dev); 1017 pm_runtime_put_autosuspend(dev->dev); 1018 1019 return rets; 1020} 1021 1022 1023/** 1024 * mei_cl_is_other_connecting - checks if other 1025 * client with the same me client id is connecting 1026 * 1027 * @cl: private data of the file object 1028 * 1029 * Return: true if other client is connected, false - otherwise. 1030 */ 1031static bool mei_cl_is_other_connecting(struct mei_cl *cl) 1032{ 1033 struct mei_device *dev; 1034 struct mei_cl_cb *cb; 1035 1036 dev = cl->dev; 1037 1038 list_for_each_entry(cb, &dev->ctrl_rd_list, list) { 1039 if (cb->fop_type == MEI_FOP_CONNECT && 1040 mei_cl_me_id(cl) == mei_cl_me_id(cb->cl)) 1041 return true; 1042 } 1043 1044 return false; 1045} 1046 1047/** 1048 * mei_cl_send_connect - send connect request 1049 * 1050 * @cl: host client 1051 * @cb: callback block 1052 * 1053 * Return: 0, OK; otherwise, error. 1054 */ 1055static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb) 1056{ 1057 struct mei_device *dev; 1058 int ret; 1059 1060 dev = cl->dev; 1061 1062 ret = mei_hbm_cl_connect_req(dev, cl); 1063 cl->status = ret; 1064 if (ret) { 1065 cl->state = MEI_FILE_DISCONNECT_REPLY; 1066 return ret; 1067 } 1068 1069 list_move_tail(&cb->list, &dev->ctrl_rd_list); 1070 cl->timer_count = dev->timeouts.connect; 1071 mei_schedule_stall_timer(dev); 1072 return 0; 1073} 1074 1075/** 1076 * mei_cl_irq_connect - send connect request in irq_thread context 1077 * 1078 * @cl: host client 1079 * @cb: callback block 1080 * @cmpl_list: complete list 1081 * 1082 * Return: 0, OK; otherwise, error. 1083 */ 1084int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb, 1085 struct list_head *cmpl_list) 1086{ 1087 struct mei_device *dev = cl->dev; 1088 u32 msg_slots; 1089 int slots; 1090 int rets; 1091 1092 if (mei_cl_is_other_connecting(cl)) 1093 return 0; 1094 1095 msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request)); 1096 slots = mei_hbuf_empty_slots(dev); 1097 if (slots < 0) 1098 return -EOVERFLOW; 1099 1100 if ((u32)slots < msg_slots) 1101 return -EMSGSIZE; 1102 1103 rets = mei_cl_send_connect(cl, cb); 1104 if (rets) 1105 list_move_tail(&cb->list, cmpl_list); 1106 1107 return rets; 1108} 1109 1110/** 1111 * mei_cl_connect - connect host client to the me one 1112 * 1113 * @cl: host client 1114 * @me_cl: me client 1115 * @fp: pointer to file structure 1116 * 1117 * Locking: called under "dev->device_lock" lock 1118 * 1119 * Return: 0 on success, <0 on failure. 1120 */ 1121int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl, 1122 const struct file *fp) 1123{ 1124 struct mei_device *dev; 1125 struct mei_cl_cb *cb; 1126 int rets; 1127 1128 if (WARN_ON(!cl || !cl->dev || !me_cl)) 1129 return -ENODEV; 1130 1131 dev = cl->dev; 1132 1133 rets = mei_cl_set_connecting(cl, me_cl); 1134 if (rets) 1135 goto nortpm; 1136 1137 if (mei_cl_is_fixed_address(cl)) { 1138 cl->state = MEI_FILE_CONNECTED; 1139 rets = 0; 1140 goto nortpm; 1141 } 1142 1143 rets = pm_runtime_get(dev->dev); 1144 if (rets < 0 && rets != -EINPROGRESS) { 1145 pm_runtime_put_noidle(dev->dev); 1146 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1147 goto nortpm; 1148 } 1149 1150 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp); 1151 if (!cb) { 1152 rets = -ENOMEM; 1153 goto out; 1154 } 1155 1156 /* run hbuf acquire last so we don't have to undo */ 1157 if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) { 1158 rets = mei_cl_send_connect(cl, cb); 1159 if (rets) 1160 goto out; 1161 } 1162 1163 mutex_unlock(&dev->device_lock); 1164 wait_event_timeout(cl->wait, 1165 (cl->state == MEI_FILE_CONNECTED || 1166 cl->state == MEI_FILE_DISCONNECTED || 1167 cl->state == MEI_FILE_DISCONNECT_REQUIRED || 1168 cl->state == MEI_FILE_DISCONNECT_REPLY), 1169 dev->timeouts.cl_connect); 1170 mutex_lock(&dev->device_lock); 1171 1172 if (!mei_cl_is_connected(cl)) { 1173 if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) { 1174 mei_io_list_flush_cl(&dev->ctrl_rd_list, cl); 1175 mei_io_list_flush_cl(&dev->ctrl_wr_list, cl); 1176 /* ignore disconnect return valuue; 1177 * in case of failure reset will be invoked 1178 */ 1179 __mei_cl_disconnect(cl); 1180 rets = -EFAULT; 1181 goto out; 1182 } 1183 1184 /* timeout or something went really wrong */ 1185 if (!cl->status) 1186 cl->status = -EFAULT; 1187 } 1188 1189 rets = cl->status; 1190out: 1191 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1192 pm_runtime_mark_last_busy(dev->dev); 1193 pm_runtime_put_autosuspend(dev->dev); 1194 1195 mei_io_cb_free(cb); 1196 1197nortpm: 1198 if (!mei_cl_is_connected(cl)) 1199 mei_cl_set_disconnected(cl); 1200 1201 return rets; 1202} 1203 1204/** 1205 * mei_cl_alloc_linked - allocate and link host client 1206 * 1207 * @dev: the device structure 1208 * 1209 * Return: cl on success ERR_PTR on failure 1210 */ 1211struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev) 1212{ 1213 struct mei_cl *cl; 1214 int ret; 1215 1216 cl = mei_cl_allocate(dev); 1217 if (!cl) { 1218 ret = -ENOMEM; 1219 goto err; 1220 } 1221 1222 ret = mei_cl_link(cl); 1223 if (ret) 1224 goto err; 1225 1226 return cl; 1227err: 1228 kfree(cl); 1229 return ERR_PTR(ret); 1230} 1231 1232/** 1233 * mei_cl_tx_flow_ctrl_creds - checks flow_control credits for cl. 1234 * 1235 * @cl: host client 1236 * 1237 * Return: 1 if tx_flow_ctrl_creds >0, 0 - otherwise. 1238 */ 1239static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl) 1240{ 1241 if (WARN_ON(!cl || !cl->me_cl)) 1242 return -EINVAL; 1243 1244 if (cl->tx_flow_ctrl_creds > 0) 1245 return 1; 1246 1247 if (mei_cl_is_fixed_address(cl)) 1248 return 1; 1249 1250 if (mei_cl_is_single_recv_buf(cl)) { 1251 if (cl->me_cl->tx_flow_ctrl_creds > 0) 1252 return 1; 1253 } 1254 return 0; 1255} 1256 1257/** 1258 * mei_cl_tx_flow_ctrl_creds_reduce - reduces transmit flow control credits 1259 * for a client 1260 * 1261 * @cl: host client 1262 * 1263 * Return: 1264 * 0 on success 1265 * -EINVAL when ctrl credits are <= 0 1266 */ 1267static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl) 1268{ 1269 if (WARN_ON(!cl || !cl->me_cl)) 1270 return -EINVAL; 1271 1272 if (mei_cl_is_fixed_address(cl)) 1273 return 0; 1274 1275 if (mei_cl_is_single_recv_buf(cl)) { 1276 if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0)) 1277 return -EINVAL; 1278 cl->me_cl->tx_flow_ctrl_creds--; 1279 } else { 1280 if (WARN_ON(cl->tx_flow_ctrl_creds <= 0)) 1281 return -EINVAL; 1282 cl->tx_flow_ctrl_creds--; 1283 } 1284 return 0; 1285} 1286 1287/** 1288 * mei_cl_vtag_alloc - allocate and fill the vtag structure 1289 * 1290 * @fp: pointer to file structure 1291 * @vtag: vm tag 1292 * 1293 * Return: 1294 * * Pointer to allocated struct - on success 1295 * * ERR_PTR(-ENOMEM) on memory allocation failure 1296 */ 1297struct mei_cl_vtag *mei_cl_vtag_alloc(struct file *fp, u8 vtag) 1298{ 1299 struct mei_cl_vtag *cl_vtag; 1300 1301 cl_vtag = kzalloc(sizeof(*cl_vtag), GFP_KERNEL); 1302 if (!cl_vtag) 1303 return ERR_PTR(-ENOMEM); 1304 1305 INIT_LIST_HEAD(&cl_vtag->list); 1306 cl_vtag->vtag = vtag; 1307 cl_vtag->fp = fp; 1308 1309 return cl_vtag; 1310} 1311 1312/** 1313 * mei_cl_fp_by_vtag - obtain the file pointer by vtag 1314 * 1315 * @cl: host client 1316 * @vtag: virtual tag 1317 * 1318 * Return: 1319 * * A file pointer - on success 1320 * * ERR_PTR(-ENOENT) if vtag is not found in the client vtag list 1321 */ 1322const struct file *mei_cl_fp_by_vtag(const struct mei_cl *cl, u8 vtag) 1323{ 1324 struct mei_cl_vtag *vtag_l; 1325 1326 list_for_each_entry(vtag_l, &cl->vtag_map, list) 1327 /* The client on bus has one fixed fp */ 1328 if ((cl->cldev && mei_cldev_enabled(cl->cldev)) || 1329 vtag_l->vtag == vtag) 1330 return vtag_l->fp; 1331 1332 return ERR_PTR(-ENOENT); 1333} 1334 1335/** 1336 * mei_cl_reset_read_by_vtag - reset pending_read flag by given vtag 1337 * 1338 * @cl: host client 1339 * @vtag: vm tag 1340 */ 1341static void mei_cl_reset_read_by_vtag(const struct mei_cl *cl, u8 vtag) 1342{ 1343 struct mei_cl_vtag *vtag_l; 1344 1345 list_for_each_entry(vtag_l, &cl->vtag_map, list) { 1346 /* The client on bus has one fixed vtag map */ 1347 if ((cl->cldev && mei_cldev_enabled(cl->cldev)) || 1348 vtag_l->vtag == vtag) { 1349 vtag_l->pending_read = false; 1350 break; 1351 } 1352 } 1353} 1354 1355/** 1356 * mei_cl_read_vtag_add_fc - add flow control for next pending reader 1357 * in the vtag list 1358 * 1359 * @cl: host client 1360 */ 1361static void mei_cl_read_vtag_add_fc(struct mei_cl *cl) 1362{ 1363 struct mei_cl_vtag *cl_vtag; 1364 1365 list_for_each_entry(cl_vtag, &cl->vtag_map, list) { 1366 if (cl_vtag->pending_read) { 1367 if (mei_cl_enqueue_ctrl_wr_cb(cl, 1368 mei_cl_mtu(cl), 1369 MEI_FOP_READ, 1370 cl_vtag->fp)) 1371 cl->rx_flow_ctrl_creds++; 1372 break; 1373 } 1374 } 1375} 1376 1377/** 1378 * mei_cl_vt_support_check - check if client support vtags 1379 * 1380 * @cl: host client 1381 * 1382 * Return: 1383 * * 0 - supported, or not connected at all 1384 * * -EOPNOTSUPP - vtags are not supported by client 1385 */ 1386int mei_cl_vt_support_check(const struct mei_cl *cl) 1387{ 1388 struct mei_device *dev = cl->dev; 1389 1390 if (!dev->hbm_f_vt_supported) 1391 return -EOPNOTSUPP; 1392 1393 if (!cl->me_cl) 1394 return 0; 1395 1396 return cl->me_cl->props.vt_supported ? 0 : -EOPNOTSUPP; 1397} 1398 1399/** 1400 * mei_cl_add_rd_completed - add read completed callback to list with lock 1401 * and vtag check 1402 * 1403 * @cl: host client 1404 * @cb: callback block 1405 * 1406 */ 1407void mei_cl_add_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb) 1408{ 1409 const struct file *fp; 1410 1411 if (!mei_cl_vt_support_check(cl)) { 1412 fp = mei_cl_fp_by_vtag(cl, cb->vtag); 1413 if (IS_ERR(fp)) { 1414 /* client already disconnected, discarding */ 1415 mei_io_cb_free(cb); 1416 return; 1417 } 1418 cb->fp = fp; 1419 mei_cl_reset_read_by_vtag(cl, cb->vtag); 1420 mei_cl_read_vtag_add_fc(cl); 1421 } 1422 1423 spin_lock(&cl->rd_completed_lock); 1424 list_add_tail(&cb->list, &cl->rd_completed); 1425 spin_unlock(&cl->rd_completed_lock); 1426} 1427 1428/** 1429 * mei_cl_del_rd_completed - free read completed callback with lock 1430 * 1431 * @cl: host client 1432 * @cb: callback block 1433 * 1434 */ 1435void mei_cl_del_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb) 1436{ 1437 spin_lock(&cl->rd_completed_lock); 1438 mei_io_cb_free(cb); 1439 spin_unlock(&cl->rd_completed_lock); 1440} 1441 1442/** 1443 * mei_cl_notify_fop2req - convert fop to proper request 1444 * 1445 * @fop: client notification start response command 1446 * 1447 * Return: MEI_HBM_NOTIFICATION_START/STOP 1448 */ 1449u8 mei_cl_notify_fop2req(enum mei_cb_file_ops fop) 1450{ 1451 if (fop == MEI_FOP_NOTIFY_START) 1452 return MEI_HBM_NOTIFICATION_START; 1453 else 1454 return MEI_HBM_NOTIFICATION_STOP; 1455} 1456 1457/** 1458 * mei_cl_notify_req2fop - convert notification request top file operation type 1459 * 1460 * @req: hbm notification request type 1461 * 1462 * Return: MEI_FOP_NOTIFY_START/STOP 1463 */ 1464enum mei_cb_file_ops mei_cl_notify_req2fop(u8 req) 1465{ 1466 if (req == MEI_HBM_NOTIFICATION_START) 1467 return MEI_FOP_NOTIFY_START; 1468 else 1469 return MEI_FOP_NOTIFY_STOP; 1470} 1471 1472/** 1473 * mei_cl_irq_notify - send notification request in irq_thread context 1474 * 1475 * @cl: client 1476 * @cb: callback block. 1477 * @cmpl_list: complete list. 1478 * 1479 * Return: 0 on such and error otherwise. 1480 */ 1481int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb, 1482 struct list_head *cmpl_list) 1483{ 1484 struct mei_device *dev = cl->dev; 1485 u32 msg_slots; 1486 int slots; 1487 int ret; 1488 bool request; 1489 1490 msg_slots = mei_hbm2slots(sizeof(struct hbm_client_connect_request)); 1491 slots = mei_hbuf_empty_slots(dev); 1492 if (slots < 0) 1493 return -EOVERFLOW; 1494 1495 if ((u32)slots < msg_slots) 1496 return -EMSGSIZE; 1497 1498 request = mei_cl_notify_fop2req(cb->fop_type); 1499 ret = mei_hbm_cl_notify_req(dev, cl, request); 1500 if (ret) { 1501 cl->status = ret; 1502 list_move_tail(&cb->list, cmpl_list); 1503 return ret; 1504 } 1505 1506 list_move_tail(&cb->list, &dev->ctrl_rd_list); 1507 return 0; 1508} 1509 1510/** 1511 * mei_cl_notify_request - send notification stop/start request 1512 * 1513 * @cl: host client 1514 * @fp: associate request with file 1515 * @request: 1 for start or 0 for stop 1516 * 1517 * Locking: called under "dev->device_lock" lock 1518 * 1519 * Return: 0 on such and error otherwise. 1520 */ 1521int mei_cl_notify_request(struct mei_cl *cl, 1522 const struct file *fp, u8 request) 1523{ 1524 struct mei_device *dev; 1525 struct mei_cl_cb *cb; 1526 enum mei_cb_file_ops fop_type; 1527 int rets; 1528 1529 if (WARN_ON(!cl || !cl->dev)) 1530 return -ENODEV; 1531 1532 dev = cl->dev; 1533 1534 if (!dev->hbm_f_ev_supported) { 1535 cl_dbg(dev, cl, "notifications not supported\n"); 1536 return -EOPNOTSUPP; 1537 } 1538 1539 if (!mei_cl_is_connected(cl)) 1540 return -ENODEV; 1541 1542 rets = pm_runtime_get(dev->dev); 1543 if (rets < 0 && rets != -EINPROGRESS) { 1544 pm_runtime_put_noidle(dev->dev); 1545 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1546 return rets; 1547 } 1548 1549 fop_type = mei_cl_notify_req2fop(request); 1550 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp); 1551 if (!cb) { 1552 rets = -ENOMEM; 1553 goto out; 1554 } 1555 1556 if (mei_hbuf_acquire(dev)) { 1557 if (mei_hbm_cl_notify_req(dev, cl, request)) { 1558 rets = -ENODEV; 1559 goto out; 1560 } 1561 list_move_tail(&cb->list, &dev->ctrl_rd_list); 1562 } 1563 1564 mutex_unlock(&dev->device_lock); 1565 wait_event_timeout(cl->wait, 1566 cl->notify_en == request || 1567 cl->status || 1568 !mei_cl_is_connected(cl), 1569 dev->timeouts.cl_connect); 1570 mutex_lock(&dev->device_lock); 1571 1572 if (cl->notify_en != request && !cl->status) 1573 cl->status = -EFAULT; 1574 1575 rets = cl->status; 1576 1577out: 1578 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1579 pm_runtime_mark_last_busy(dev->dev); 1580 pm_runtime_put_autosuspend(dev->dev); 1581 1582 mei_io_cb_free(cb); 1583 return rets; 1584} 1585 1586/** 1587 * mei_cl_notify - raise notification 1588 * 1589 * @cl: host client 1590 * 1591 * Locking: called under "dev->device_lock" lock 1592 */ 1593void mei_cl_notify(struct mei_cl *cl) 1594{ 1595 struct mei_device *dev; 1596 1597 if (!cl || !cl->dev) 1598 return; 1599 1600 dev = cl->dev; 1601 1602 if (!cl->notify_en) 1603 return; 1604 1605 cl_dbg(dev, cl, "notify event"); 1606 cl->notify_ev = true; 1607 if (!mei_cl_bus_notify_event(cl)) 1608 wake_up_interruptible(&cl->ev_wait); 1609 1610 if (cl->ev_async) 1611 kill_fasync(&cl->ev_async, SIGIO, POLL_PRI); 1612 1613} 1614 1615/** 1616 * mei_cl_notify_get - get or wait for notification event 1617 * 1618 * @cl: host client 1619 * @block: this request is blocking 1620 * @notify_ev: true if notification event was received 1621 * 1622 * Locking: called under "dev->device_lock" lock 1623 * 1624 * Return: 0 on such and error otherwise. 1625 */ 1626int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev) 1627{ 1628 struct mei_device *dev; 1629 int rets; 1630 1631 *notify_ev = false; 1632 1633 if (WARN_ON(!cl || !cl->dev)) 1634 return -ENODEV; 1635 1636 dev = cl->dev; 1637 1638 if (!dev->hbm_f_ev_supported) { 1639 cl_dbg(dev, cl, "notifications not supported\n"); 1640 return -EOPNOTSUPP; 1641 } 1642 1643 if (!mei_cl_is_connected(cl)) 1644 return -ENODEV; 1645 1646 if (cl->notify_ev) 1647 goto out; 1648 1649 if (!block) 1650 return -EAGAIN; 1651 1652 mutex_unlock(&dev->device_lock); 1653 rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev); 1654 mutex_lock(&dev->device_lock); 1655 1656 if (rets < 0) 1657 return rets; 1658 1659out: 1660 *notify_ev = cl->notify_ev; 1661 cl->notify_ev = false; 1662 return 0; 1663} 1664 1665/** 1666 * mei_cl_read_start - the start read client message function. 1667 * 1668 * @cl: host client 1669 * @length: number of bytes to read 1670 * @fp: pointer to file structure 1671 * 1672 * Return: 0 on success, <0 on failure. 1673 */ 1674int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp) 1675{ 1676 struct mei_device *dev; 1677 struct mei_cl_cb *cb; 1678 int rets; 1679 1680 if (WARN_ON(!cl || !cl->dev)) 1681 return -ENODEV; 1682 1683 dev = cl->dev; 1684 1685 if (!mei_cl_is_connected(cl)) 1686 return -ENODEV; 1687 1688 if (!mei_me_cl_is_active(cl->me_cl)) { 1689 cl_err(dev, cl, "no such me client\n"); 1690 return -ENOTTY; 1691 } 1692 1693 if (mei_cl_is_fixed_address(cl)) 1694 return 0; 1695 1696 /* HW currently supports only one pending read */ 1697 if (cl->rx_flow_ctrl_creds) { 1698 mei_cl_set_read_by_fp(cl, fp); 1699 return -EBUSY; 1700 } 1701 1702 cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp); 1703 if (!cb) 1704 return -ENOMEM; 1705 1706 mei_cl_set_read_by_fp(cl, fp); 1707 1708 rets = pm_runtime_get(dev->dev); 1709 if (rets < 0 && rets != -EINPROGRESS) { 1710 pm_runtime_put_noidle(dev->dev); 1711 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1712 goto nortpm; 1713 } 1714 1715 rets = 0; 1716 if (mei_hbuf_acquire(dev)) { 1717 rets = mei_hbm_cl_flow_control_req(dev, cl); 1718 if (rets < 0) 1719 goto out; 1720 1721 list_move_tail(&cb->list, &cl->rd_pending); 1722 } 1723 cl->rx_flow_ctrl_creds++; 1724 1725out: 1726 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1727 pm_runtime_mark_last_busy(dev->dev); 1728 pm_runtime_put_autosuspend(dev->dev); 1729nortpm: 1730 if (rets) 1731 mei_io_cb_free(cb); 1732 1733 return rets; 1734} 1735 1736static inline u8 mei_ext_hdr_set_vtag(void *ext, u8 vtag) 1737{ 1738 struct mei_ext_hdr_vtag *vtag_hdr = ext; 1739 1740 vtag_hdr->hdr.type = MEI_EXT_HDR_VTAG; 1741 vtag_hdr->hdr.length = mei_data2slots(sizeof(*vtag_hdr)); 1742 vtag_hdr->vtag = vtag; 1743 vtag_hdr->reserved = 0; 1744 return vtag_hdr->hdr.length; 1745} 1746 1747static inline bool mei_ext_hdr_is_gsc(struct mei_ext_hdr *ext) 1748{ 1749 return ext && ext->type == MEI_EXT_HDR_GSC; 1750} 1751 1752static inline u8 mei_ext_hdr_set_gsc(struct mei_ext_hdr *ext, struct mei_ext_hdr *gsc_hdr) 1753{ 1754 memcpy(ext, gsc_hdr, mei_ext_hdr_len(gsc_hdr)); 1755 return ext->length; 1756} 1757 1758/** 1759 * mei_msg_hdr_init - allocate and initialize mei message header 1760 * 1761 * @cb: message callback structure 1762 * 1763 * Return: a pointer to initialized header or ERR_PTR on failure 1764 */ 1765static struct mei_msg_hdr *mei_msg_hdr_init(const struct mei_cl_cb *cb) 1766{ 1767 size_t hdr_len; 1768 struct mei_ext_meta_hdr *meta; 1769 struct mei_msg_hdr *mei_hdr; 1770 bool is_ext, is_hbm, is_gsc, is_vtag; 1771 struct mei_ext_hdr *next_ext; 1772 1773 if (!cb) 1774 return ERR_PTR(-EINVAL); 1775 1776 /* Extended header for vtag is attached only on the first fragment */ 1777 is_vtag = (cb->vtag && cb->buf_idx == 0); 1778 is_hbm = cb->cl->me_cl->client_id == 0; 1779 is_gsc = ((!is_hbm) && cb->cl->dev->hbm_f_gsc_supported && mei_ext_hdr_is_gsc(cb->ext_hdr)); 1780 is_ext = is_vtag || is_gsc; 1781 1782 /* Compute extended header size */ 1783 hdr_len = sizeof(*mei_hdr); 1784 1785 if (!is_ext) 1786 goto setup_hdr; 1787 1788 hdr_len += sizeof(*meta); 1789 if (is_vtag) 1790 hdr_len += sizeof(struct mei_ext_hdr_vtag); 1791 1792 if (is_gsc) 1793 hdr_len += mei_ext_hdr_len(cb->ext_hdr); 1794 1795setup_hdr: 1796 mei_hdr = kzalloc(hdr_len, GFP_KERNEL); 1797 if (!mei_hdr) 1798 return ERR_PTR(-ENOMEM); 1799 1800 mei_hdr->host_addr = mei_cl_host_addr(cb->cl); 1801 mei_hdr->me_addr = mei_cl_me_id(cb->cl); 1802 mei_hdr->internal = cb->internal; 1803 mei_hdr->extended = is_ext; 1804 1805 if (!is_ext) 1806 goto out; 1807 1808 meta = (struct mei_ext_meta_hdr *)mei_hdr->extension; 1809 meta->size = 0; 1810 next_ext = (struct mei_ext_hdr *)meta->hdrs; 1811 if (is_vtag) { 1812 meta->count++; 1813 meta->size += mei_ext_hdr_set_vtag(next_ext, cb->vtag); 1814 next_ext = mei_ext_next(next_ext); 1815 } 1816 1817 if (is_gsc) { 1818 meta->count++; 1819 meta->size += mei_ext_hdr_set_gsc(next_ext, cb->ext_hdr); 1820 next_ext = mei_ext_next(next_ext); 1821 } 1822 1823out: 1824 mei_hdr->length = hdr_len - sizeof(*mei_hdr); 1825 return mei_hdr; 1826} 1827 1828/** 1829 * mei_cl_irq_write - write a message to device 1830 * from the interrupt thread context 1831 * 1832 * @cl: client 1833 * @cb: callback block. 1834 * @cmpl_list: complete list. 1835 * 1836 * Return: 0, OK; otherwise error. 1837 */ 1838int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb, 1839 struct list_head *cmpl_list) 1840{ 1841 struct mei_device *dev; 1842 struct mei_msg_data *buf; 1843 struct mei_msg_hdr *mei_hdr = NULL; 1844 size_t hdr_len; 1845 size_t hbuf_len, dr_len; 1846 size_t buf_len = 0; 1847 size_t data_len; 1848 int hbuf_slots; 1849 u32 dr_slots; 1850 u32 dma_len; 1851 int rets; 1852 bool first_chunk; 1853 const void *data = NULL; 1854 1855 if (WARN_ON(!cl || !cl->dev)) 1856 return -ENODEV; 1857 1858 dev = cl->dev; 1859 1860 buf = &cb->buf; 1861 1862 first_chunk = cb->buf_idx == 0; 1863 1864 rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1; 1865 if (rets < 0) 1866 goto err; 1867 1868 if (rets == 0) { 1869 cl_dbg(dev, cl, "No flow control credentials: not sending.\n"); 1870 return 0; 1871 } 1872 1873 if (buf->data) { 1874 buf_len = buf->size - cb->buf_idx; 1875 data = buf->data + cb->buf_idx; 1876 } 1877 hbuf_slots = mei_hbuf_empty_slots(dev); 1878 if (hbuf_slots < 0) { 1879 rets = -EOVERFLOW; 1880 goto err; 1881 } 1882 1883 hbuf_len = mei_slots2data(hbuf_slots) & MEI_MSG_MAX_LEN_MASK; 1884 dr_slots = mei_dma_ring_empty_slots(dev); 1885 dr_len = mei_slots2data(dr_slots); 1886 1887 mei_hdr = mei_msg_hdr_init(cb); 1888 if (IS_ERR(mei_hdr)) { 1889 rets = PTR_ERR(mei_hdr); 1890 mei_hdr = NULL; 1891 goto err; 1892 } 1893 1894 hdr_len = sizeof(*mei_hdr) + mei_hdr->length; 1895 1896 /** 1897 * Split the message only if we can write the whole host buffer 1898 * otherwise wait for next time the host buffer is empty. 1899 */ 1900 if (hdr_len + buf_len <= hbuf_len) { 1901 data_len = buf_len; 1902 mei_hdr->msg_complete = 1; 1903 } else if (dr_slots && hbuf_len >= hdr_len + sizeof(dma_len)) { 1904 mei_hdr->dma_ring = 1; 1905 if (buf_len > dr_len) 1906 buf_len = dr_len; 1907 else 1908 mei_hdr->msg_complete = 1; 1909 1910 data_len = sizeof(dma_len); 1911 dma_len = buf_len; 1912 data = &dma_len; 1913 } else if ((u32)hbuf_slots == mei_hbuf_depth(dev)) { 1914 buf_len = hbuf_len - hdr_len; 1915 data_len = buf_len; 1916 } else { 1917 kfree(mei_hdr); 1918 return 0; 1919 } 1920 mei_hdr->length += data_len; 1921 1922 if (mei_hdr->dma_ring && buf->data) 1923 mei_dma_ring_write(dev, buf->data + cb->buf_idx, buf_len); 1924 rets = mei_write_message(dev, mei_hdr, hdr_len, data, data_len); 1925 1926 if (rets) 1927 goto err; 1928 1929 cl->status = 0; 1930 cl->writing_state = MEI_WRITING; 1931 cb->buf_idx += buf_len; 1932 1933 if (first_chunk) { 1934 if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) { 1935 rets = -EIO; 1936 goto err; 1937 } 1938 } 1939 1940 if (mei_hdr->msg_complete) 1941 list_move_tail(&cb->list, &dev->write_waiting_list); 1942 1943 kfree(mei_hdr); 1944 return 0; 1945 1946err: 1947 kfree(mei_hdr); 1948 cl->status = rets; 1949 list_move_tail(&cb->list, cmpl_list); 1950 return rets; 1951} 1952 1953/** 1954 * mei_cl_write - submit a write cb to mei device 1955 * assumes device_lock is locked 1956 * 1957 * @cl: host client 1958 * @cb: write callback with filled data 1959 * @timeout: send timeout in milliseconds. 1960 * effective only for blocking writes: the cb->blocking is set. 1961 * set timeout to the MAX_SCHEDULE_TIMEOUT to maixum allowed wait. 1962 * 1963 * Return: number of bytes sent on success, <0 on failure. 1964 */ 1965ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, unsigned long timeout) 1966{ 1967 struct mei_device *dev; 1968 struct mei_msg_data *buf; 1969 struct mei_msg_hdr *mei_hdr = NULL; 1970 size_t hdr_len; 1971 size_t hbuf_len, dr_len; 1972 size_t buf_len; 1973 size_t data_len; 1974 int hbuf_slots; 1975 u32 dr_slots; 1976 u32 dma_len; 1977 ssize_t rets; 1978 bool blocking; 1979 const void *data; 1980 1981 if (WARN_ON(!cl || !cl->dev)) 1982 return -ENODEV; 1983 1984 if (WARN_ON(!cb)) 1985 return -EINVAL; 1986 1987 dev = cl->dev; 1988 1989 buf = &cb->buf; 1990 buf_len = buf->size; 1991 1992 cl_dbg(dev, cl, "buf_len=%zd\n", buf_len); 1993 1994 blocking = cb->blocking; 1995 data = buf->data; 1996 1997 rets = pm_runtime_get(dev->dev); 1998 if (rets < 0 && rets != -EINPROGRESS) { 1999 pm_runtime_put_noidle(dev->dev); 2000 cl_err(dev, cl, "rpm: get failed %zd\n", rets); 2001 goto free; 2002 } 2003 2004 cb->buf_idx = 0; 2005 cl->writing_state = MEI_IDLE; 2006 2007 2008 rets = mei_cl_tx_flow_ctrl_creds(cl); 2009 if (rets < 0) 2010 goto err; 2011 2012 mei_hdr = mei_msg_hdr_init(cb); 2013 if (IS_ERR(mei_hdr)) { 2014 rets = PTR_ERR(mei_hdr); 2015 mei_hdr = NULL; 2016 goto err; 2017 } 2018 2019 hdr_len = sizeof(*mei_hdr) + mei_hdr->length; 2020 2021 if (rets == 0) { 2022 cl_dbg(dev, cl, "No flow control credentials: not sending.\n"); 2023 rets = buf_len; 2024 goto out; 2025 } 2026 2027 if (!mei_hbuf_acquire(dev)) { 2028 cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n"); 2029 rets = buf_len; 2030 goto out; 2031 } 2032 2033 hbuf_slots = mei_hbuf_empty_slots(dev); 2034 if (hbuf_slots < 0) { 2035 buf_len = -EOVERFLOW; 2036 goto out; 2037 } 2038 2039 hbuf_len = mei_slots2data(hbuf_slots) & MEI_MSG_MAX_LEN_MASK; 2040 dr_slots = mei_dma_ring_empty_slots(dev); 2041 dr_len = mei_slots2data(dr_slots); 2042 2043 if (hdr_len + buf_len <= hbuf_len) { 2044 data_len = buf_len; 2045 mei_hdr->msg_complete = 1; 2046 } else if (dr_slots && hbuf_len >= hdr_len + sizeof(dma_len)) { 2047 mei_hdr->dma_ring = 1; 2048 if (buf_len > dr_len) 2049 buf_len = dr_len; 2050 else 2051 mei_hdr->msg_complete = 1; 2052 2053 data_len = sizeof(dma_len); 2054 dma_len = buf_len; 2055 data = &dma_len; 2056 } else { 2057 buf_len = hbuf_len - hdr_len; 2058 data_len = buf_len; 2059 } 2060 2061 mei_hdr->length += data_len; 2062 2063 if (mei_hdr->dma_ring && buf->data) 2064 mei_dma_ring_write(dev, buf->data, buf_len); 2065 rets = mei_write_message(dev, mei_hdr, hdr_len, data, data_len); 2066 2067 if (rets) 2068 goto err; 2069 2070 rets = mei_cl_tx_flow_ctrl_creds_reduce(cl); 2071 if (rets) 2072 goto err; 2073 2074 cl->writing_state = MEI_WRITING; 2075 cb->buf_idx = buf_len; 2076 /* restore return value */ 2077 buf_len = buf->size; 2078 2079out: 2080 if (mei_hdr->msg_complete) 2081 mei_tx_cb_enqueue(cb, &dev->write_waiting_list); 2082 else 2083 mei_tx_cb_enqueue(cb, &dev->write_list); 2084 2085 cb = NULL; 2086 if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) { 2087 2088 mutex_unlock(&dev->device_lock); 2089 rets = wait_event_interruptible_timeout(cl->tx_wait, 2090 cl->writing_state == MEI_WRITE_COMPLETE || 2091 (!mei_cl_is_connected(cl)), 2092 msecs_to_jiffies(timeout)); 2093 mutex_lock(&dev->device_lock); 2094 /* clean all queue on timeout as something fatal happened */ 2095 if (rets == 0) { 2096 rets = -ETIME; 2097 mei_io_tx_list_free_cl(&dev->write_list, cl, NULL); 2098 mei_io_tx_list_free_cl(&dev->write_waiting_list, cl, NULL); 2099 } 2100 /* wait_event_interruptible returns -ERESTARTSYS */ 2101 if (rets > 0) 2102 rets = 0; 2103 if (rets) { 2104 if (signal_pending(current)) 2105 rets = -EINTR; 2106 goto err; 2107 } 2108 if (cl->writing_state != MEI_WRITE_COMPLETE) { 2109 rets = -EFAULT; 2110 goto err; 2111 } 2112 } 2113 2114 rets = buf_len; 2115err: 2116 cl_dbg(dev, cl, "rpm: autosuspend\n"); 2117 pm_runtime_mark_last_busy(dev->dev); 2118 pm_runtime_put_autosuspend(dev->dev); 2119free: 2120 mei_io_cb_free(cb); 2121 2122 kfree(mei_hdr); 2123 2124 return rets; 2125} 2126 2127/** 2128 * mei_cl_complete - processes completed operation for a client 2129 * 2130 * @cl: private data of the file object. 2131 * @cb: callback block. 2132 */ 2133void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb) 2134{ 2135 struct mei_device *dev = cl->dev; 2136 2137 switch (cb->fop_type) { 2138 case MEI_FOP_WRITE: 2139 mei_tx_cb_dequeue(cb); 2140 cl->writing_state = MEI_WRITE_COMPLETE; 2141 if (waitqueue_active(&cl->tx_wait)) { 2142 wake_up_interruptible(&cl->tx_wait); 2143 } else { 2144 pm_runtime_mark_last_busy(dev->dev); 2145 pm_request_autosuspend(dev->dev); 2146 } 2147 break; 2148 2149 case MEI_FOP_READ: 2150 mei_cl_add_rd_completed(cl, cb); 2151 if (!mei_cl_is_fixed_address(cl) && 2152 !WARN_ON(!cl->rx_flow_ctrl_creds)) 2153 cl->rx_flow_ctrl_creds--; 2154 if (!mei_cl_bus_rx_event(cl)) 2155 wake_up_interruptible(&cl->rx_wait); 2156 break; 2157 2158 case MEI_FOP_CONNECT: 2159 case MEI_FOP_DISCONNECT: 2160 case MEI_FOP_NOTIFY_STOP: 2161 case MEI_FOP_NOTIFY_START: 2162 case MEI_FOP_DMA_MAP: 2163 case MEI_FOP_DMA_UNMAP: 2164 if (waitqueue_active(&cl->wait)) 2165 wake_up(&cl->wait); 2166 2167 break; 2168 case MEI_FOP_DISCONNECT_RSP: 2169 mei_io_cb_free(cb); 2170 mei_cl_set_disconnected(cl); 2171 break; 2172 default: 2173 BUG_ON(0); 2174 } 2175} 2176 2177 2178/** 2179 * mei_cl_all_disconnect - disconnect forcefully all connected clients 2180 * 2181 * @dev: mei device 2182 */ 2183void mei_cl_all_disconnect(struct mei_device *dev) 2184{ 2185 struct mei_cl *cl; 2186 2187 list_for_each_entry(cl, &dev->file_list, link) 2188 mei_cl_set_disconnected(cl); 2189} 2190EXPORT_SYMBOL_GPL(mei_cl_all_disconnect); 2191 2192static struct mei_cl *mei_cl_dma_map_find(struct mei_device *dev, u8 buffer_id) 2193{ 2194 struct mei_cl *cl; 2195 2196 list_for_each_entry(cl, &dev->file_list, link) 2197 if (cl->dma.buffer_id == buffer_id) 2198 return cl; 2199 return NULL; 2200} 2201 2202/** 2203 * mei_cl_irq_dma_map - send client dma map request in irq_thread context 2204 * 2205 * @cl: client 2206 * @cb: callback block. 2207 * @cmpl_list: complete list. 2208 * 2209 * Return: 0 on such and error otherwise. 2210 */ 2211int mei_cl_irq_dma_map(struct mei_cl *cl, struct mei_cl_cb *cb, 2212 struct list_head *cmpl_list) 2213{ 2214 struct mei_device *dev = cl->dev; 2215 u32 msg_slots; 2216 int slots; 2217 int ret; 2218 2219 msg_slots = mei_hbm2slots(sizeof(struct hbm_client_dma_map_request)); 2220 slots = mei_hbuf_empty_slots(dev); 2221 if (slots < 0) 2222 return -EOVERFLOW; 2223 2224 if ((u32)slots < msg_slots) 2225 return -EMSGSIZE; 2226 2227 ret = mei_hbm_cl_dma_map_req(dev, cl); 2228 if (ret) { 2229 cl->status = ret; 2230 list_move_tail(&cb->list, cmpl_list); 2231 return ret; 2232 } 2233 2234 list_move_tail(&cb->list, &dev->ctrl_rd_list); 2235 return 0; 2236} 2237 2238/** 2239 * mei_cl_irq_dma_unmap - send client dma unmap request in irq_thread context 2240 * 2241 * @cl: client 2242 * @cb: callback block. 2243 * @cmpl_list: complete list. 2244 * 2245 * Return: 0 on such and error otherwise. 2246 */ 2247int mei_cl_irq_dma_unmap(struct mei_cl *cl, struct mei_cl_cb *cb, 2248 struct list_head *cmpl_list) 2249{ 2250 struct mei_device *dev = cl->dev; 2251 u32 msg_slots; 2252 int slots; 2253 int ret; 2254 2255 msg_slots = mei_hbm2slots(sizeof(struct hbm_client_dma_unmap_request)); 2256 slots = mei_hbuf_empty_slots(dev); 2257 if (slots < 0) 2258 return -EOVERFLOW; 2259 2260 if ((u32)slots < msg_slots) 2261 return -EMSGSIZE; 2262 2263 ret = mei_hbm_cl_dma_unmap_req(dev, cl); 2264 if (ret) { 2265 cl->status = ret; 2266 list_move_tail(&cb->list, cmpl_list); 2267 return ret; 2268 } 2269 2270 list_move_tail(&cb->list, &dev->ctrl_rd_list); 2271 return 0; 2272} 2273 2274static int mei_cl_dma_alloc(struct mei_cl *cl, u8 buf_id, size_t size) 2275{ 2276 cl->dma.vaddr = dmam_alloc_coherent(cl->dev->dev, size, 2277 &cl->dma.daddr, GFP_KERNEL); 2278 if (!cl->dma.vaddr) 2279 return -ENOMEM; 2280 2281 cl->dma.buffer_id = buf_id; 2282 cl->dma.size = size; 2283 2284 return 0; 2285} 2286 2287static void mei_cl_dma_free(struct mei_cl *cl) 2288{ 2289 cl->dma.buffer_id = 0; 2290 dmam_free_coherent(cl->dev->dev, 2291 cl->dma.size, cl->dma.vaddr, cl->dma.daddr); 2292 cl->dma.size = 0; 2293 cl->dma.vaddr = NULL; 2294 cl->dma.daddr = 0; 2295} 2296 2297/** 2298 * mei_cl_dma_alloc_and_map - send client dma map request 2299 * 2300 * @cl: host client 2301 * @fp: pointer to file structure 2302 * @buffer_id: id of the mapped buffer 2303 * @size: size of the buffer 2304 * 2305 * Locking: called under "dev->device_lock" lock 2306 * 2307 * Return: 2308 * * -ENODEV 2309 * * -EINVAL 2310 * * -EOPNOTSUPP 2311 * * -EPROTO 2312 * * -ENOMEM; 2313 */ 2314int mei_cl_dma_alloc_and_map(struct mei_cl *cl, const struct file *fp, 2315 u8 buffer_id, size_t size) 2316{ 2317 struct mei_device *dev; 2318 struct mei_cl_cb *cb; 2319 int rets; 2320 2321 if (WARN_ON(!cl || !cl->dev)) 2322 return -ENODEV; 2323 2324 dev = cl->dev; 2325 2326 if (!dev->hbm_f_cd_supported) { 2327 cl_dbg(dev, cl, "client dma is not supported\n"); 2328 return -EOPNOTSUPP; 2329 } 2330 2331 if (buffer_id == 0) 2332 return -EINVAL; 2333 2334 if (mei_cl_is_connected(cl)) 2335 return -EPROTO; 2336 2337 if (cl->dma_mapped) 2338 return -EPROTO; 2339 2340 if (mei_cl_dma_map_find(dev, buffer_id)) { 2341 cl_dbg(dev, cl, "client dma with id %d is already allocated\n", 2342 cl->dma.buffer_id); 2343 return -EPROTO; 2344 } 2345 2346 rets = pm_runtime_get(dev->dev); 2347 if (rets < 0 && rets != -EINPROGRESS) { 2348 pm_runtime_put_noidle(dev->dev); 2349 cl_err(dev, cl, "rpm: get failed %d\n", rets); 2350 return rets; 2351 } 2352 2353 rets = mei_cl_dma_alloc(cl, buffer_id, size); 2354 if (rets) { 2355 pm_runtime_put_noidle(dev->dev); 2356 return rets; 2357 } 2358 2359 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DMA_MAP, fp); 2360 if (!cb) { 2361 rets = -ENOMEM; 2362 goto out; 2363 } 2364 2365 if (mei_hbuf_acquire(dev)) { 2366 if (mei_hbm_cl_dma_map_req(dev, cl)) { 2367 rets = -ENODEV; 2368 goto out; 2369 } 2370 list_move_tail(&cb->list, &dev->ctrl_rd_list); 2371 } 2372 2373 cl->status = 0; 2374 2375 mutex_unlock(&dev->device_lock); 2376 wait_event_timeout(cl->wait, 2377 cl->dma_mapped || cl->status, 2378 dev->timeouts.cl_connect); 2379 mutex_lock(&dev->device_lock); 2380 2381 if (!cl->dma_mapped && !cl->status) 2382 cl->status = -EFAULT; 2383 2384 rets = cl->status; 2385 2386out: 2387 if (rets) 2388 mei_cl_dma_free(cl); 2389 2390 cl_dbg(dev, cl, "rpm: autosuspend\n"); 2391 pm_runtime_mark_last_busy(dev->dev); 2392 pm_runtime_put_autosuspend(dev->dev); 2393 2394 mei_io_cb_free(cb); 2395 return rets; 2396} 2397 2398/** 2399 * mei_cl_dma_unmap - send client dma unmap request 2400 * 2401 * @cl: host client 2402 * @fp: pointer to file structure 2403 * 2404 * Locking: called under "dev->device_lock" lock 2405 * 2406 * Return: 0 on such and error otherwise. 2407 */ 2408int mei_cl_dma_unmap(struct mei_cl *cl, const struct file *fp) 2409{ 2410 struct mei_device *dev; 2411 struct mei_cl_cb *cb; 2412 int rets; 2413 2414 if (WARN_ON(!cl || !cl->dev)) 2415 return -ENODEV; 2416 2417 dev = cl->dev; 2418 2419 if (!dev->hbm_f_cd_supported) { 2420 cl_dbg(dev, cl, "client dma is not supported\n"); 2421 return -EOPNOTSUPP; 2422 } 2423 2424 /* do not allow unmap for connected client */ 2425 if (mei_cl_is_connected(cl)) 2426 return -EPROTO; 2427 2428 if (!cl->dma_mapped) 2429 return -EPROTO; 2430 2431 rets = pm_runtime_get(dev->dev); 2432 if (rets < 0 && rets != -EINPROGRESS) { 2433 pm_runtime_put_noidle(dev->dev); 2434 cl_err(dev, cl, "rpm: get failed %d\n", rets); 2435 return rets; 2436 } 2437 2438 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DMA_UNMAP, fp); 2439 if (!cb) { 2440 rets = -ENOMEM; 2441 goto out; 2442 } 2443 2444 if (mei_hbuf_acquire(dev)) { 2445 if (mei_hbm_cl_dma_unmap_req(dev, cl)) { 2446 rets = -ENODEV; 2447 goto out; 2448 } 2449 list_move_tail(&cb->list, &dev->ctrl_rd_list); 2450 } 2451 2452 cl->status = 0; 2453 2454 mutex_unlock(&dev->device_lock); 2455 wait_event_timeout(cl->wait, 2456 !cl->dma_mapped || cl->status, 2457 dev->timeouts.cl_connect); 2458 mutex_lock(&dev->device_lock); 2459 2460 if (cl->dma_mapped && !cl->status) 2461 cl->status = -EFAULT; 2462 2463 rets = cl->status; 2464 2465 if (!rets) 2466 mei_cl_dma_free(cl); 2467out: 2468 cl_dbg(dev, cl, "rpm: autosuspend\n"); 2469 pm_runtime_mark_last_busy(dev->dev); 2470 pm_runtime_put_autosuspend(dev->dev); 2471 2472 mei_io_cb_free(cb); 2473 return rets; 2474} 2475