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