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 mei_schedule_stall_timer(dev); 830 831 return 0; 832 } 833 834 /** 835 * mei_cl_irq_disconnect - processes close related operation from 836 * interrupt thread context - send disconnect request 837 * 838 * @cl: client 839 * @cb: callback block. 840 * @cmpl_list: complete list. 841 * 842 * Return: 0, OK; otherwise, error. 843 */ 844 int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb, 845 struct mei_cl_cb *cmpl_list) 846 { 847 struct mei_device *dev = cl->dev; 848 u32 msg_slots; 849 int slots; 850 int ret; 851 852 msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request)); 853 slots = mei_hbuf_empty_slots(dev); 854 855 if (slots < msg_slots) 856 return -EMSGSIZE; 857 858 ret = mei_cl_send_disconnect(cl, cb); 859 if (ret) 860 list_move_tail(&cb->list, &cmpl_list->list); 861 862 return ret; 863 } 864 865 /** 866 * __mei_cl_disconnect - disconnect host client from the me one 867 * internal function runtime pm has to be already acquired 868 * 869 * @cl: host client 870 * 871 * Return: 0 on success, <0 on failure. 872 */ 873 static int __mei_cl_disconnect(struct mei_cl *cl) 874 { 875 struct mei_device *dev; 876 struct mei_cl_cb *cb; 877 int rets; 878 879 dev = cl->dev; 880 881 cl->state = MEI_FILE_DISCONNECTING; 882 883 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL); 884 if (!cb) { 885 rets = -ENOMEM; 886 goto out; 887 } 888 889 if (mei_hbuf_acquire(dev)) { 890 rets = mei_cl_send_disconnect(cl, cb); 891 if (rets) { 892 cl_err(dev, cl, "failed to disconnect.\n"); 893 goto out; 894 } 895 } 896 897 mutex_unlock(&dev->device_lock); 898 wait_event_timeout(cl->wait, 899 cl->state == MEI_FILE_DISCONNECT_REPLY || 900 cl->state == MEI_FILE_DISCONNECTED, 901 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT)); 902 mutex_lock(&dev->device_lock); 903 904 rets = cl->status; 905 if (cl->state != MEI_FILE_DISCONNECT_REPLY && 906 cl->state != MEI_FILE_DISCONNECTED) { 907 cl_dbg(dev, cl, "timeout on disconnect from FW client.\n"); 908 rets = -ETIME; 909 } 910 911 out: 912 /* we disconnect also on error */ 913 mei_cl_set_disconnected(cl); 914 if (!rets) 915 cl_dbg(dev, cl, "successfully disconnected from FW client.\n"); 916 917 mei_io_cb_free(cb); 918 return rets; 919 } 920 921 /** 922 * mei_cl_disconnect - disconnect host client from the me one 923 * 924 * @cl: host client 925 * 926 * Locking: called under "dev->device_lock" lock 927 * 928 * Return: 0 on success, <0 on failure. 929 */ 930 int mei_cl_disconnect(struct mei_cl *cl) 931 { 932 struct mei_device *dev; 933 int rets; 934 935 if (WARN_ON(!cl || !cl->dev)) 936 return -ENODEV; 937 938 dev = cl->dev; 939 940 cl_dbg(dev, cl, "disconnecting"); 941 942 if (!mei_cl_is_connected(cl)) 943 return 0; 944 945 if (mei_cl_is_fixed_address(cl)) { 946 mei_cl_set_disconnected(cl); 947 return 0; 948 } 949 950 rets = pm_runtime_get(dev->dev); 951 if (rets < 0 && rets != -EINPROGRESS) { 952 pm_runtime_put_noidle(dev->dev); 953 cl_err(dev, cl, "rpm: get failed %d\n", rets); 954 return rets; 955 } 956 957 rets = __mei_cl_disconnect(cl); 958 959 cl_dbg(dev, cl, "rpm: autosuspend\n"); 960 pm_runtime_mark_last_busy(dev->dev); 961 pm_runtime_put_autosuspend(dev->dev); 962 963 return rets; 964 } 965 966 967 /** 968 * mei_cl_is_other_connecting - checks if other 969 * client with the same me client id is connecting 970 * 971 * @cl: private data of the file object 972 * 973 * Return: true if other client is connected, false - otherwise. 974 */ 975 static bool mei_cl_is_other_connecting(struct mei_cl *cl) 976 { 977 struct mei_device *dev; 978 struct mei_cl_cb *cb; 979 980 dev = cl->dev; 981 982 list_for_each_entry(cb, &dev->ctrl_rd_list.list, list) { 983 if (cb->fop_type == MEI_FOP_CONNECT && 984 mei_cl_me_id(cl) == mei_cl_me_id(cb->cl)) 985 return true; 986 } 987 988 return false; 989 } 990 991 /** 992 * mei_cl_send_connect - send connect request 993 * 994 * @cl: host client 995 * @cb: callback block 996 * 997 * Return: 0, OK; otherwise, error. 998 */ 999 static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb) 1000 { 1001 struct mei_device *dev; 1002 int ret; 1003 1004 dev = cl->dev; 1005 1006 ret = mei_hbm_cl_connect_req(dev, cl); 1007 cl->status = ret; 1008 if (ret) { 1009 cl->state = MEI_FILE_DISCONNECT_REPLY; 1010 return ret; 1011 } 1012 1013 list_move_tail(&cb->list, &dev->ctrl_rd_list.list); 1014 cl->timer_count = MEI_CONNECT_TIMEOUT; 1015 mei_schedule_stall_timer(dev); 1016 return 0; 1017 } 1018 1019 /** 1020 * mei_cl_irq_connect - send connect request in irq_thread context 1021 * 1022 * @cl: host client 1023 * @cb: callback block 1024 * @cmpl_list: complete list 1025 * 1026 * Return: 0, OK; otherwise, error. 1027 */ 1028 int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb, 1029 struct mei_cl_cb *cmpl_list) 1030 { 1031 struct mei_device *dev = cl->dev; 1032 u32 msg_slots; 1033 int slots; 1034 int rets; 1035 1036 msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request)); 1037 slots = mei_hbuf_empty_slots(dev); 1038 1039 if (mei_cl_is_other_connecting(cl)) 1040 return 0; 1041 1042 if (slots < msg_slots) 1043 return -EMSGSIZE; 1044 1045 rets = mei_cl_send_connect(cl, cb); 1046 if (rets) 1047 list_move_tail(&cb->list, &cmpl_list->list); 1048 1049 return rets; 1050 } 1051 1052 /** 1053 * mei_cl_connect - connect host client to the me one 1054 * 1055 * @cl: host client 1056 * @me_cl: me client 1057 * @fp: pointer to file structure 1058 * 1059 * Locking: called under "dev->device_lock" lock 1060 * 1061 * Return: 0 on success, <0 on failure. 1062 */ 1063 int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl, 1064 const struct file *fp) 1065 { 1066 struct mei_device *dev; 1067 struct mei_cl_cb *cb; 1068 int rets; 1069 1070 if (WARN_ON(!cl || !cl->dev || !me_cl)) 1071 return -ENODEV; 1072 1073 dev = cl->dev; 1074 1075 rets = mei_cl_set_connecting(cl, me_cl); 1076 if (rets) 1077 return rets; 1078 1079 if (mei_cl_is_fixed_address(cl)) { 1080 cl->state = MEI_FILE_CONNECTED; 1081 return 0; 1082 } 1083 1084 rets = pm_runtime_get(dev->dev); 1085 if (rets < 0 && rets != -EINPROGRESS) { 1086 pm_runtime_put_noidle(dev->dev); 1087 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1088 goto nortpm; 1089 } 1090 1091 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp); 1092 if (!cb) { 1093 rets = -ENOMEM; 1094 goto out; 1095 } 1096 1097 /* run hbuf acquire last so we don't have to undo */ 1098 if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) { 1099 rets = mei_cl_send_connect(cl, cb); 1100 if (rets) 1101 goto out; 1102 } 1103 1104 mutex_unlock(&dev->device_lock); 1105 wait_event_timeout(cl->wait, 1106 (cl->state == MEI_FILE_CONNECTED || 1107 cl->state == MEI_FILE_DISCONNECTED || 1108 cl->state == MEI_FILE_DISCONNECT_REQUIRED || 1109 cl->state == MEI_FILE_DISCONNECT_REPLY), 1110 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT)); 1111 mutex_lock(&dev->device_lock); 1112 1113 if (!mei_cl_is_connected(cl)) { 1114 if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) { 1115 mei_io_list_flush(&dev->ctrl_rd_list, cl); 1116 mei_io_list_flush(&dev->ctrl_wr_list, cl); 1117 /* ignore disconnect return valuue; 1118 * in case of failure reset will be invoked 1119 */ 1120 __mei_cl_disconnect(cl); 1121 rets = -EFAULT; 1122 goto out; 1123 } 1124 1125 /* timeout or something went really wrong */ 1126 if (!cl->status) 1127 cl->status = -EFAULT; 1128 } 1129 1130 rets = cl->status; 1131 out: 1132 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1133 pm_runtime_mark_last_busy(dev->dev); 1134 pm_runtime_put_autosuspend(dev->dev); 1135 1136 mei_io_cb_free(cb); 1137 1138 nortpm: 1139 if (!mei_cl_is_connected(cl)) 1140 mei_cl_set_disconnected(cl); 1141 1142 return rets; 1143 } 1144 1145 /** 1146 * mei_cl_alloc_linked - allocate and link host client 1147 * 1148 * @dev: the device structure 1149 * 1150 * Return: cl on success ERR_PTR on failure 1151 */ 1152 struct mei_cl *mei_cl_alloc_linked(struct mei_device *dev) 1153 { 1154 struct mei_cl *cl; 1155 int ret; 1156 1157 cl = mei_cl_allocate(dev); 1158 if (!cl) { 1159 ret = -ENOMEM; 1160 goto err; 1161 } 1162 1163 ret = mei_cl_link(cl); 1164 if (ret) 1165 goto err; 1166 1167 return cl; 1168 err: 1169 kfree(cl); 1170 return ERR_PTR(ret); 1171 } 1172 1173 /** 1174 * mei_cl_tx_flow_ctrl_creds - checks flow_control credits for cl. 1175 * 1176 * @cl: host client 1177 * 1178 * Return: 1 if tx_flow_ctrl_creds >0, 0 - otherwise. 1179 */ 1180 static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl) 1181 { 1182 if (WARN_ON(!cl || !cl->me_cl)) 1183 return -EINVAL; 1184 1185 if (cl->tx_flow_ctrl_creds > 0) 1186 return 1; 1187 1188 if (mei_cl_is_fixed_address(cl)) 1189 return 1; 1190 1191 if (mei_cl_is_single_recv_buf(cl)) { 1192 if (cl->me_cl->tx_flow_ctrl_creds > 0) 1193 return 1; 1194 } 1195 return 0; 1196 } 1197 1198 /** 1199 * mei_cl_tx_flow_ctrl_creds_reduce - reduces transmit flow control credits 1200 * for a client 1201 * 1202 * @cl: host client 1203 * 1204 * Return: 1205 * 0 on success 1206 * -EINVAL when ctrl credits are <= 0 1207 */ 1208 static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl) 1209 { 1210 if (WARN_ON(!cl || !cl->me_cl)) 1211 return -EINVAL; 1212 1213 if (mei_cl_is_fixed_address(cl)) 1214 return 0; 1215 1216 if (mei_cl_is_single_recv_buf(cl)) { 1217 if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0)) 1218 return -EINVAL; 1219 cl->me_cl->tx_flow_ctrl_creds--; 1220 } else { 1221 if (WARN_ON(cl->tx_flow_ctrl_creds <= 0)) 1222 return -EINVAL; 1223 cl->tx_flow_ctrl_creds--; 1224 } 1225 return 0; 1226 } 1227 1228 /** 1229 * mei_cl_notify_fop2req - convert fop to proper request 1230 * 1231 * @fop: client notification start response command 1232 * 1233 * Return: MEI_HBM_NOTIFICATION_START/STOP 1234 */ 1235 u8 mei_cl_notify_fop2req(enum mei_cb_file_ops fop) 1236 { 1237 if (fop == MEI_FOP_NOTIFY_START) 1238 return MEI_HBM_NOTIFICATION_START; 1239 else 1240 return MEI_HBM_NOTIFICATION_STOP; 1241 } 1242 1243 /** 1244 * mei_cl_notify_req2fop - convert notification request top file operation type 1245 * 1246 * @req: hbm notification request type 1247 * 1248 * Return: MEI_FOP_NOTIFY_START/STOP 1249 */ 1250 enum mei_cb_file_ops mei_cl_notify_req2fop(u8 req) 1251 { 1252 if (req == MEI_HBM_NOTIFICATION_START) 1253 return MEI_FOP_NOTIFY_START; 1254 else 1255 return MEI_FOP_NOTIFY_STOP; 1256 } 1257 1258 /** 1259 * mei_cl_irq_notify - send notification request in irq_thread context 1260 * 1261 * @cl: client 1262 * @cb: callback block. 1263 * @cmpl_list: complete list. 1264 * 1265 * Return: 0 on such and error otherwise. 1266 */ 1267 int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb, 1268 struct mei_cl_cb *cmpl_list) 1269 { 1270 struct mei_device *dev = cl->dev; 1271 u32 msg_slots; 1272 int slots; 1273 int ret; 1274 bool request; 1275 1276 msg_slots = mei_data2slots(sizeof(struct hbm_client_connect_request)); 1277 slots = mei_hbuf_empty_slots(dev); 1278 1279 if (slots < msg_slots) 1280 return -EMSGSIZE; 1281 1282 request = mei_cl_notify_fop2req(cb->fop_type); 1283 ret = mei_hbm_cl_notify_req(dev, cl, request); 1284 if (ret) { 1285 cl->status = ret; 1286 list_move_tail(&cb->list, &cmpl_list->list); 1287 return ret; 1288 } 1289 1290 list_move_tail(&cb->list, &dev->ctrl_rd_list.list); 1291 return 0; 1292 } 1293 1294 /** 1295 * mei_cl_notify_request - send notification stop/start request 1296 * 1297 * @cl: host client 1298 * @fp: associate request with file 1299 * @request: 1 for start or 0 for stop 1300 * 1301 * Locking: called under "dev->device_lock" lock 1302 * 1303 * Return: 0 on such and error otherwise. 1304 */ 1305 int mei_cl_notify_request(struct mei_cl *cl, 1306 const struct file *fp, u8 request) 1307 { 1308 struct mei_device *dev; 1309 struct mei_cl_cb *cb; 1310 enum mei_cb_file_ops fop_type; 1311 int rets; 1312 1313 if (WARN_ON(!cl || !cl->dev)) 1314 return -ENODEV; 1315 1316 dev = cl->dev; 1317 1318 if (!dev->hbm_f_ev_supported) { 1319 cl_dbg(dev, cl, "notifications not supported\n"); 1320 return -EOPNOTSUPP; 1321 } 1322 1323 rets = pm_runtime_get(dev->dev); 1324 if (rets < 0 && rets != -EINPROGRESS) { 1325 pm_runtime_put_noidle(dev->dev); 1326 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1327 return rets; 1328 } 1329 1330 fop_type = mei_cl_notify_req2fop(request); 1331 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp); 1332 if (!cb) { 1333 rets = -ENOMEM; 1334 goto out; 1335 } 1336 1337 if (mei_hbuf_acquire(dev)) { 1338 if (mei_hbm_cl_notify_req(dev, cl, request)) { 1339 rets = -ENODEV; 1340 goto out; 1341 } 1342 list_move_tail(&cb->list, &dev->ctrl_rd_list.list); 1343 } 1344 1345 mutex_unlock(&dev->device_lock); 1346 wait_event_timeout(cl->wait, 1347 cl->notify_en == request || !mei_cl_is_connected(cl), 1348 mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT)); 1349 mutex_lock(&dev->device_lock); 1350 1351 if (cl->notify_en != request && !cl->status) 1352 cl->status = -EFAULT; 1353 1354 rets = cl->status; 1355 1356 out: 1357 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1358 pm_runtime_mark_last_busy(dev->dev); 1359 pm_runtime_put_autosuspend(dev->dev); 1360 1361 mei_io_cb_free(cb); 1362 return rets; 1363 } 1364 1365 /** 1366 * mei_cl_notify - raise notification 1367 * 1368 * @cl: host client 1369 * 1370 * Locking: called under "dev->device_lock" lock 1371 */ 1372 void mei_cl_notify(struct mei_cl *cl) 1373 { 1374 struct mei_device *dev; 1375 1376 if (!cl || !cl->dev) 1377 return; 1378 1379 dev = cl->dev; 1380 1381 if (!cl->notify_en) 1382 return; 1383 1384 cl_dbg(dev, cl, "notify event"); 1385 cl->notify_ev = true; 1386 if (!mei_cl_bus_notify_event(cl)) 1387 wake_up_interruptible(&cl->ev_wait); 1388 1389 if (cl->ev_async) 1390 kill_fasync(&cl->ev_async, SIGIO, POLL_PRI); 1391 1392 } 1393 1394 /** 1395 * mei_cl_notify_get - get or wait for notification event 1396 * 1397 * @cl: host client 1398 * @block: this request is blocking 1399 * @notify_ev: true if notification event was received 1400 * 1401 * Locking: called under "dev->device_lock" lock 1402 * 1403 * Return: 0 on such and error otherwise. 1404 */ 1405 int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev) 1406 { 1407 struct mei_device *dev; 1408 int rets; 1409 1410 *notify_ev = false; 1411 1412 if (WARN_ON(!cl || !cl->dev)) 1413 return -ENODEV; 1414 1415 dev = cl->dev; 1416 1417 if (!mei_cl_is_connected(cl)) 1418 return -ENODEV; 1419 1420 if (cl->notify_ev) 1421 goto out; 1422 1423 if (!block) 1424 return -EAGAIN; 1425 1426 mutex_unlock(&dev->device_lock); 1427 rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev); 1428 mutex_lock(&dev->device_lock); 1429 1430 if (rets < 0) 1431 return rets; 1432 1433 out: 1434 *notify_ev = cl->notify_ev; 1435 cl->notify_ev = false; 1436 return 0; 1437 } 1438 1439 /** 1440 * mei_cl_read_start - the start read client message function. 1441 * 1442 * @cl: host client 1443 * @length: number of bytes to read 1444 * @fp: pointer to file structure 1445 * 1446 * Return: 0 on success, <0 on failure. 1447 */ 1448 int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp) 1449 { 1450 struct mei_device *dev; 1451 struct mei_cl_cb *cb; 1452 int rets; 1453 1454 if (WARN_ON(!cl || !cl->dev)) 1455 return -ENODEV; 1456 1457 dev = cl->dev; 1458 1459 if (!mei_cl_is_connected(cl)) 1460 return -ENODEV; 1461 1462 if (!mei_me_cl_is_active(cl->me_cl)) { 1463 cl_err(dev, cl, "no such me client\n"); 1464 return -ENOTTY; 1465 } 1466 1467 if (mei_cl_is_fixed_address(cl) || cl == &dev->iamthif_cl) 1468 return 0; 1469 1470 /* HW currently supports only one pending read */ 1471 if (cl->rx_flow_ctrl_creds) 1472 return -EBUSY; 1473 1474 cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp); 1475 if (!cb) 1476 return -ENOMEM; 1477 1478 rets = pm_runtime_get(dev->dev); 1479 if (rets < 0 && rets != -EINPROGRESS) { 1480 pm_runtime_put_noidle(dev->dev); 1481 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1482 goto nortpm; 1483 } 1484 1485 rets = 0; 1486 if (mei_hbuf_acquire(dev)) { 1487 rets = mei_hbm_cl_flow_control_req(dev, cl); 1488 if (rets < 0) 1489 goto out; 1490 1491 list_move_tail(&cb->list, &cl->rd_pending); 1492 } 1493 cl->rx_flow_ctrl_creds++; 1494 1495 out: 1496 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1497 pm_runtime_mark_last_busy(dev->dev); 1498 pm_runtime_put_autosuspend(dev->dev); 1499 nortpm: 1500 if (rets) 1501 mei_io_cb_free(cb); 1502 1503 return rets; 1504 } 1505 1506 /** 1507 * mei_cl_irq_write - write a message to device 1508 * from the interrupt thread context 1509 * 1510 * @cl: client 1511 * @cb: callback block. 1512 * @cmpl_list: complete list. 1513 * 1514 * Return: 0, OK; otherwise error. 1515 */ 1516 int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb, 1517 struct mei_cl_cb *cmpl_list) 1518 { 1519 struct mei_device *dev; 1520 struct mei_msg_data *buf; 1521 struct mei_msg_hdr mei_hdr; 1522 size_t len; 1523 u32 msg_slots; 1524 int slots; 1525 int rets; 1526 bool first_chunk; 1527 1528 if (WARN_ON(!cl || !cl->dev)) 1529 return -ENODEV; 1530 1531 dev = cl->dev; 1532 1533 buf = &cb->buf; 1534 1535 first_chunk = cb->buf_idx == 0; 1536 1537 rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1; 1538 if (rets < 0) 1539 return rets; 1540 1541 if (rets == 0) { 1542 cl_dbg(dev, cl, "No flow control credentials: not sending.\n"); 1543 return 0; 1544 } 1545 1546 slots = mei_hbuf_empty_slots(dev); 1547 len = buf->size - cb->buf_idx; 1548 msg_slots = mei_data2slots(len); 1549 1550 mei_hdr.host_addr = mei_cl_host_addr(cl); 1551 mei_hdr.me_addr = mei_cl_me_id(cl); 1552 mei_hdr.reserved = 0; 1553 mei_hdr.internal = cb->internal; 1554 1555 if (slots >= msg_slots) { 1556 mei_hdr.length = len; 1557 mei_hdr.msg_complete = 1; 1558 /* Split the message only if we can write the whole host buffer */ 1559 } else if (slots == dev->hbuf_depth) { 1560 msg_slots = slots; 1561 len = (slots * sizeof(u32)) - sizeof(struct mei_msg_hdr); 1562 mei_hdr.length = len; 1563 mei_hdr.msg_complete = 0; 1564 } else { 1565 /* wait for next time the host buffer is empty */ 1566 return 0; 1567 } 1568 1569 cl_dbg(dev, cl, "buf: size = %zu idx = %zu\n", 1570 cb->buf.size, cb->buf_idx); 1571 1572 rets = mei_write_message(dev, &mei_hdr, buf->data + cb->buf_idx); 1573 if (rets) { 1574 cl->status = rets; 1575 list_move_tail(&cb->list, &cmpl_list->list); 1576 return rets; 1577 } 1578 1579 cl->status = 0; 1580 cl->writing_state = MEI_WRITING; 1581 cb->buf_idx += mei_hdr.length; 1582 cb->completed = mei_hdr.msg_complete == 1; 1583 1584 if (first_chunk) { 1585 if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) 1586 return -EIO; 1587 } 1588 1589 if (mei_hdr.msg_complete) 1590 list_move_tail(&cb->list, &dev->write_waiting_list.list); 1591 1592 return 0; 1593 } 1594 1595 /** 1596 * mei_cl_write - submit a write cb to mei device 1597 * assumes device_lock is locked 1598 * 1599 * @cl: host client 1600 * @cb: write callback with filled data 1601 * @blocking: block until completed 1602 * 1603 * Return: number of bytes sent on success, <0 on failure. 1604 */ 1605 int mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, bool blocking) 1606 { 1607 struct mei_device *dev; 1608 struct mei_msg_data *buf; 1609 struct mei_msg_hdr mei_hdr; 1610 int size; 1611 int rets; 1612 1613 1614 if (WARN_ON(!cl || !cl->dev)) 1615 return -ENODEV; 1616 1617 if (WARN_ON(!cb)) 1618 return -EINVAL; 1619 1620 dev = cl->dev; 1621 1622 buf = &cb->buf; 1623 size = buf->size; 1624 1625 cl_dbg(dev, cl, "size=%d\n", size); 1626 1627 rets = pm_runtime_get(dev->dev); 1628 if (rets < 0 && rets != -EINPROGRESS) { 1629 pm_runtime_put_noidle(dev->dev); 1630 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1631 goto free; 1632 } 1633 1634 cb->buf_idx = 0; 1635 cl->writing_state = MEI_IDLE; 1636 1637 mei_hdr.host_addr = mei_cl_host_addr(cl); 1638 mei_hdr.me_addr = mei_cl_me_id(cl); 1639 mei_hdr.reserved = 0; 1640 mei_hdr.msg_complete = 0; 1641 mei_hdr.internal = cb->internal; 1642 1643 rets = mei_cl_tx_flow_ctrl_creds(cl); 1644 if (rets < 0) 1645 goto err; 1646 1647 if (rets == 0) { 1648 cl_dbg(dev, cl, "No flow control credentials: not sending.\n"); 1649 rets = size; 1650 goto out; 1651 } 1652 if (!mei_hbuf_acquire(dev)) { 1653 cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n"); 1654 rets = size; 1655 goto out; 1656 } 1657 1658 /* Check for a maximum length */ 1659 if (size > mei_hbuf_max_len(dev)) { 1660 mei_hdr.length = mei_hbuf_max_len(dev); 1661 mei_hdr.msg_complete = 0; 1662 } else { 1663 mei_hdr.length = size; 1664 mei_hdr.msg_complete = 1; 1665 } 1666 1667 rets = mei_write_message(dev, &mei_hdr, buf->data); 1668 if (rets) 1669 goto err; 1670 1671 rets = mei_cl_tx_flow_ctrl_creds_reduce(cl); 1672 if (rets) 1673 goto err; 1674 1675 cl->writing_state = MEI_WRITING; 1676 cb->buf_idx = mei_hdr.length; 1677 cb->completed = mei_hdr.msg_complete == 1; 1678 1679 out: 1680 if (mei_hdr.msg_complete) 1681 list_add_tail(&cb->list, &dev->write_waiting_list.list); 1682 else 1683 list_add_tail(&cb->list, &dev->write_list.list); 1684 1685 cb = NULL; 1686 if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) { 1687 1688 mutex_unlock(&dev->device_lock); 1689 rets = wait_event_interruptible(cl->tx_wait, 1690 cl->writing_state == MEI_WRITE_COMPLETE || 1691 (!mei_cl_is_connected(cl))); 1692 mutex_lock(&dev->device_lock); 1693 /* wait_event_interruptible returns -ERESTARTSYS */ 1694 if (rets) { 1695 if (signal_pending(current)) 1696 rets = -EINTR; 1697 goto err; 1698 } 1699 if (cl->writing_state != MEI_WRITE_COMPLETE) { 1700 rets = -EFAULT; 1701 goto err; 1702 } 1703 } 1704 1705 rets = size; 1706 err: 1707 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1708 pm_runtime_mark_last_busy(dev->dev); 1709 pm_runtime_put_autosuspend(dev->dev); 1710 free: 1711 mei_io_cb_free(cb); 1712 1713 return rets; 1714 } 1715 1716 1717 /** 1718 * mei_cl_complete - processes completed operation for a client 1719 * 1720 * @cl: private data of the file object. 1721 * @cb: callback block. 1722 */ 1723 void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb) 1724 { 1725 struct mei_device *dev = cl->dev; 1726 1727 switch (cb->fop_type) { 1728 case MEI_FOP_WRITE: 1729 mei_io_cb_free(cb); 1730 cl->writing_state = MEI_WRITE_COMPLETE; 1731 if (waitqueue_active(&cl->tx_wait)) { 1732 wake_up_interruptible(&cl->tx_wait); 1733 } else { 1734 pm_runtime_mark_last_busy(dev->dev); 1735 pm_request_autosuspend(dev->dev); 1736 } 1737 break; 1738 1739 case MEI_FOP_READ: 1740 list_add_tail(&cb->list, &cl->rd_completed); 1741 if (!mei_cl_is_fixed_address(cl) && 1742 !WARN_ON(!cl->rx_flow_ctrl_creds)) 1743 cl->rx_flow_ctrl_creds--; 1744 if (!mei_cl_bus_rx_event(cl)) 1745 wake_up_interruptible(&cl->rx_wait); 1746 break; 1747 1748 case MEI_FOP_CONNECT: 1749 case MEI_FOP_DISCONNECT: 1750 case MEI_FOP_NOTIFY_STOP: 1751 case MEI_FOP_NOTIFY_START: 1752 if (waitqueue_active(&cl->wait)) 1753 wake_up(&cl->wait); 1754 1755 break; 1756 case MEI_FOP_DISCONNECT_RSP: 1757 mei_io_cb_free(cb); 1758 mei_cl_set_disconnected(cl); 1759 break; 1760 default: 1761 BUG_ON(0); 1762 } 1763 } 1764 1765 1766 /** 1767 * mei_cl_all_disconnect - disconnect forcefully all connected clients 1768 * 1769 * @dev: mei device 1770 */ 1771 void mei_cl_all_disconnect(struct mei_device *dev) 1772 { 1773 struct mei_cl *cl; 1774 1775 list_for_each_entry(cl, &dev->file_list, link) 1776 mei_cl_set_disconnected(cl); 1777 } 1778