1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * ISHTP bus driver 4 * 5 * Copyright (c) 2012-2016, Intel Corporation. 6 */ 7 8 #include <linux/module.h> 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/device.h> 12 #include <linux/sched.h> 13 #include <linux/slab.h> 14 #include "bus.h" 15 #include "ishtp-dev.h" 16 #include "client.h" 17 #include "hbm.h" 18 19 static int ishtp_use_dma; 20 module_param_named(ishtp_use_dma, ishtp_use_dma, int, 0600); 21 MODULE_PARM_DESC(ishtp_use_dma, "Use DMA to send messages"); 22 23 #define to_ishtp_cl_driver(d) container_of(d, struct ishtp_cl_driver, driver) 24 #define to_ishtp_cl_device(d) container_of(d, struct ishtp_cl_device, dev) 25 static bool ishtp_device_ready; 26 27 /** 28 * ishtp_recv() - process ishtp message 29 * @dev: ishtp device 30 * 31 * If a message with valid header and size is received, then 32 * this function calls appropriate handler. The host or firmware 33 * address is zero, then they are host bus management message, 34 * otherwise they are message fo clients. 35 */ 36 void ishtp_recv(struct ishtp_device *dev) 37 { 38 uint32_t msg_hdr; 39 struct ishtp_msg_hdr *ishtp_hdr; 40 41 /* Read ISHTP header dword */ 42 msg_hdr = dev->ops->ishtp_read_hdr(dev); 43 if (!msg_hdr) 44 return; 45 46 dev->ops->sync_fw_clock(dev); 47 48 ishtp_hdr = (struct ishtp_msg_hdr *)&msg_hdr; 49 dev->ishtp_msg_hdr = msg_hdr; 50 51 /* Sanity check: ISHTP frag. length in header */ 52 if (ishtp_hdr->length > dev->mtu) { 53 dev_err(dev->devc, 54 "ISHTP hdr - bad length: %u; dropped [%08X]\n", 55 (unsigned int)ishtp_hdr->length, msg_hdr); 56 return; 57 } 58 59 /* ISHTP bus message */ 60 if (!ishtp_hdr->host_addr && !ishtp_hdr->fw_addr) 61 recv_hbm(dev, ishtp_hdr); 62 /* ISHTP fixed-client message */ 63 else if (!ishtp_hdr->host_addr) 64 recv_fixed_cl_msg(dev, ishtp_hdr); 65 else 66 /* ISHTP client message */ 67 recv_ishtp_cl_msg(dev, ishtp_hdr); 68 } 69 EXPORT_SYMBOL(ishtp_recv); 70 71 /** 72 * ishtp_send_msg() - Send ishtp message 73 * @dev: ishtp device 74 * @hdr: Message header 75 * @msg: Message contents 76 * @ipc_send_compl: completion callback 77 * @ipc_send_compl_prm: completion callback parameter 78 * 79 * Send a multi fragment message via IPC. After sending the first fragment 80 * the completion callback is called to schedule transmit of next fragment. 81 * 82 * Return: This returns IPC send message status. 83 */ 84 int ishtp_send_msg(struct ishtp_device *dev, struct ishtp_msg_hdr *hdr, 85 void *msg, void(*ipc_send_compl)(void *), 86 void *ipc_send_compl_prm) 87 { 88 unsigned char ipc_msg[IPC_FULL_MSG_SIZE]; 89 uint32_t drbl_val; 90 91 drbl_val = dev->ops->ipc_get_header(dev, hdr->length + 92 sizeof(struct ishtp_msg_hdr), 93 1); 94 95 memcpy(ipc_msg, &drbl_val, sizeof(uint32_t)); 96 memcpy(ipc_msg + sizeof(uint32_t), hdr, sizeof(uint32_t)); 97 memcpy(ipc_msg + 2 * sizeof(uint32_t), msg, hdr->length); 98 return dev->ops->write(dev, ipc_send_compl, ipc_send_compl_prm, 99 ipc_msg, 2 * sizeof(uint32_t) + hdr->length); 100 } 101 102 /** 103 * ishtp_write_message() - Send ishtp single fragment message 104 * @dev: ishtp device 105 * @hdr: Message header 106 * @buf: message data 107 * 108 * Send a single fragment message via IPC. This returns IPC send message 109 * status. 110 * 111 * Return: This returns IPC send message status. 112 */ 113 int ishtp_write_message(struct ishtp_device *dev, struct ishtp_msg_hdr *hdr, 114 void *buf) 115 { 116 return ishtp_send_msg(dev, hdr, buf, NULL, NULL); 117 } 118 119 /** 120 * ishtp_fw_cl_by_uuid() - locate index of fw client 121 * @dev: ishtp device 122 * @uuid: uuid of the client to search 123 * 124 * Search firmware client using UUID. 125 * 126 * Return: fw client index or -ENOENT if not found 127 */ 128 int ishtp_fw_cl_by_uuid(struct ishtp_device *dev, const guid_t *uuid) 129 { 130 unsigned int i; 131 132 for (i = 0; i < dev->fw_clients_num; ++i) { 133 if (guid_equal(uuid, &dev->fw_clients[i].props.protocol_name)) 134 return i; 135 } 136 return -ENOENT; 137 } 138 EXPORT_SYMBOL(ishtp_fw_cl_by_uuid); 139 140 /** 141 * ishtp_fw_cl_get_client() - return client information to client 142 * @dev: the ishtp device structure 143 * @uuid: uuid of the client to search 144 * 145 * Search firmware client using UUID and reture related client information. 146 * 147 * Return: pointer of client information on success, NULL on failure. 148 */ 149 struct ishtp_fw_client *ishtp_fw_cl_get_client(struct ishtp_device *dev, 150 const guid_t *uuid) 151 { 152 int i; 153 unsigned long flags; 154 155 spin_lock_irqsave(&dev->fw_clients_lock, flags); 156 i = ishtp_fw_cl_by_uuid(dev, uuid); 157 spin_unlock_irqrestore(&dev->fw_clients_lock, flags); 158 if (i < 0 || dev->fw_clients[i].props.fixed_address) 159 return NULL; 160 161 return &dev->fw_clients[i]; 162 } 163 EXPORT_SYMBOL(ishtp_fw_cl_get_client); 164 165 /** 166 * ishtp_get_fw_client_id() - Get fw client id 167 * 168 * This interface is used to reset HW get FW client id. 169 * 170 * Return: firmware client id. 171 */ 172 int ishtp_get_fw_client_id(struct ishtp_fw_client *fw_client) 173 { 174 return fw_client->client_id; 175 } 176 EXPORT_SYMBOL(ishtp_get_fw_client_id); 177 178 /** 179 * ishtp_fw_cl_by_id() - return index to fw_clients for client_id 180 * @dev: the ishtp device structure 181 * @client_id: fw client id to search 182 * 183 * Search firmware client using client id. 184 * 185 * Return: index on success, -ENOENT on failure. 186 */ 187 int ishtp_fw_cl_by_id(struct ishtp_device *dev, uint8_t client_id) 188 { 189 int i, res = -ENOENT; 190 unsigned long flags; 191 192 spin_lock_irqsave(&dev->fw_clients_lock, flags); 193 for (i = 0; i < dev->fw_clients_num; i++) { 194 if (dev->fw_clients[i].client_id == client_id) { 195 res = i; 196 break; 197 } 198 } 199 spin_unlock_irqrestore(&dev->fw_clients_lock, flags); 200 201 return res; 202 } 203 204 /** 205 * ishtp_cl_device_probe() - Bus probe() callback 206 * @dev: the device structure 207 * 208 * This is a bus probe callback and calls the drive probe function. 209 * 210 * Return: Return value from driver probe() call. 211 */ 212 static int ishtp_cl_device_probe(struct device *dev) 213 { 214 struct ishtp_cl_device *device = to_ishtp_cl_device(dev); 215 struct ishtp_cl_driver *driver; 216 217 if (!device) 218 return 0; 219 220 driver = to_ishtp_cl_driver(dev->driver); 221 if (!driver || !driver->probe) 222 return -ENODEV; 223 224 return driver->probe(device); 225 } 226 227 /** 228 * ishtp_cl_bus_match() - Bus match() callback 229 * @dev: the device structure 230 * @drv: the driver structure 231 * 232 * This is a bus match callback, called when a new ishtp_cl_device is 233 * registered during ishtp bus client enumeration. Use the guid_t in 234 * drv and dev to decide whether they match or not. 235 * 236 * Return: 1 if dev & drv matches, 0 otherwise. 237 */ 238 static int ishtp_cl_bus_match(struct device *dev, struct device_driver *drv) 239 { 240 struct ishtp_cl_device *device = to_ishtp_cl_device(dev); 241 struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv); 242 243 return guid_equal(driver->guid, 244 &device->fw_client->props.protocol_name); 245 } 246 247 /** 248 * ishtp_cl_device_remove() - Bus remove() callback 249 * @dev: the device structure 250 * 251 * This is a bus remove callback and calls the drive remove function. 252 * Since the ISH driver model supports only built in, this is 253 * primarily can be called during pci driver init failure. 254 * 255 * Return: Return value from driver remove() call. 256 */ 257 static int ishtp_cl_device_remove(struct device *dev) 258 { 259 struct ishtp_cl_device *device = to_ishtp_cl_device(dev); 260 struct ishtp_cl_driver *driver; 261 262 if (!device || !dev->driver) 263 return 0; 264 265 if (device->event_cb) { 266 device->event_cb = NULL; 267 cancel_work_sync(&device->event_work); 268 } 269 270 driver = to_ishtp_cl_driver(dev->driver); 271 if (!driver->remove) { 272 dev->driver = NULL; 273 274 return 0; 275 } 276 277 return driver->remove(device); 278 } 279 280 /** 281 * ishtp_cl_device_suspend() - Bus suspend callback 282 * @dev: device 283 * 284 * Called during device suspend process. 285 * 286 * Return: Return value from driver suspend() call. 287 */ 288 static int ishtp_cl_device_suspend(struct device *dev) 289 { 290 struct ishtp_cl_device *device = to_ishtp_cl_device(dev); 291 struct ishtp_cl_driver *driver; 292 int ret = 0; 293 294 if (!device) 295 return 0; 296 297 driver = to_ishtp_cl_driver(dev->driver); 298 if (driver && driver->driver.pm) { 299 if (driver->driver.pm->suspend) 300 ret = driver->driver.pm->suspend(dev); 301 } 302 303 return ret; 304 } 305 306 /** 307 * ishtp_cl_device_resume() - Bus resume callback 308 * @dev: device 309 * 310 * Called during device resume process. 311 * 312 * Return: Return value from driver resume() call. 313 */ 314 static int ishtp_cl_device_resume(struct device *dev) 315 { 316 struct ishtp_cl_device *device = to_ishtp_cl_device(dev); 317 struct ishtp_cl_driver *driver; 318 int ret = 0; 319 320 if (!device) 321 return 0; 322 323 /* 324 * When ISH needs hard reset, it is done asynchrnously, hence bus 325 * resume will be called before full ISH resume 326 */ 327 if (device->ishtp_dev->resume_flag) 328 return 0; 329 330 driver = to_ishtp_cl_driver(dev->driver); 331 if (driver && driver->driver.pm) { 332 if (driver->driver.pm->resume) 333 ret = driver->driver.pm->resume(dev); 334 } 335 336 return ret; 337 } 338 339 /** 340 * ishtp_cl_device_reset() - Reset callback 341 * @device: ishtp client device instance 342 * 343 * This is a callback when HW reset is done and the device need 344 * reinit. 345 * 346 * Return: Return value from driver reset() call. 347 */ 348 static int ishtp_cl_device_reset(struct ishtp_cl_device *device) 349 { 350 struct ishtp_cl_driver *driver; 351 int ret = 0; 352 353 device->event_cb = NULL; 354 cancel_work_sync(&device->event_work); 355 356 driver = to_ishtp_cl_driver(device->dev.driver); 357 if (driver && driver->reset) 358 ret = driver->reset(device); 359 360 return ret; 361 } 362 363 static ssize_t modalias_show(struct device *dev, struct device_attribute *a, 364 char *buf) 365 { 366 int len; 367 368 len = snprintf(buf, PAGE_SIZE, "ishtp:%s\n", dev_name(dev)); 369 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len; 370 } 371 static DEVICE_ATTR_RO(modalias); 372 373 static struct attribute *ishtp_cl_dev_attrs[] = { 374 &dev_attr_modalias.attr, 375 NULL, 376 }; 377 ATTRIBUTE_GROUPS(ishtp_cl_dev); 378 379 static int ishtp_cl_uevent(struct device *dev, struct kobj_uevent_env *env) 380 { 381 if (add_uevent_var(env, "MODALIAS=ishtp:%s", dev_name(dev))) 382 return -ENOMEM; 383 return 0; 384 } 385 386 static const struct dev_pm_ops ishtp_cl_bus_dev_pm_ops = { 387 /* Suspend callbacks */ 388 .suspend = ishtp_cl_device_suspend, 389 .resume = ishtp_cl_device_resume, 390 /* Hibernate callbacks */ 391 .freeze = ishtp_cl_device_suspend, 392 .thaw = ishtp_cl_device_resume, 393 .restore = ishtp_cl_device_resume, 394 }; 395 396 static struct bus_type ishtp_cl_bus_type = { 397 .name = "ishtp", 398 .dev_groups = ishtp_cl_dev_groups, 399 .probe = ishtp_cl_device_probe, 400 .match = ishtp_cl_bus_match, 401 .remove = ishtp_cl_device_remove, 402 .pm = &ishtp_cl_bus_dev_pm_ops, 403 .uevent = ishtp_cl_uevent, 404 }; 405 406 static void ishtp_cl_dev_release(struct device *dev) 407 { 408 kfree(to_ishtp_cl_device(dev)); 409 } 410 411 static const struct device_type ishtp_cl_device_type = { 412 .release = ishtp_cl_dev_release, 413 }; 414 415 /** 416 * ishtp_bus_add_device() - Function to create device on bus 417 * @dev: ishtp device 418 * @uuid: uuid of the client 419 * @name: Name of the client 420 * 421 * Allocate ISHTP bus client device, attach it to uuid 422 * and register with ISHTP bus. 423 * 424 * Return: ishtp_cl_device pointer or NULL on failure 425 */ 426 static struct ishtp_cl_device *ishtp_bus_add_device(struct ishtp_device *dev, 427 guid_t uuid, char *name) 428 { 429 struct ishtp_cl_device *device; 430 int status; 431 unsigned long flags; 432 433 spin_lock_irqsave(&dev->device_list_lock, flags); 434 list_for_each_entry(device, &dev->device_list, device_link) { 435 if (!strcmp(name, dev_name(&device->dev))) { 436 device->fw_client = &dev->fw_clients[ 437 dev->fw_client_presentation_num - 1]; 438 spin_unlock_irqrestore(&dev->device_list_lock, flags); 439 ishtp_cl_device_reset(device); 440 return device; 441 } 442 } 443 spin_unlock_irqrestore(&dev->device_list_lock, flags); 444 445 device = kzalloc(sizeof(struct ishtp_cl_device), GFP_KERNEL); 446 if (!device) 447 return NULL; 448 449 device->dev.parent = dev->devc; 450 device->dev.bus = &ishtp_cl_bus_type; 451 device->dev.type = &ishtp_cl_device_type; 452 device->ishtp_dev = dev; 453 454 device->fw_client = 455 &dev->fw_clients[dev->fw_client_presentation_num - 1]; 456 457 dev_set_name(&device->dev, "%s", name); 458 459 spin_lock_irqsave(&dev->device_list_lock, flags); 460 list_add_tail(&device->device_link, &dev->device_list); 461 spin_unlock_irqrestore(&dev->device_list_lock, flags); 462 463 status = device_register(&device->dev); 464 if (status) { 465 spin_lock_irqsave(&dev->device_list_lock, flags); 466 list_del(&device->device_link); 467 spin_unlock_irqrestore(&dev->device_list_lock, flags); 468 dev_err(dev->devc, "Failed to register ISHTP client device\n"); 469 put_device(&device->dev); 470 return NULL; 471 } 472 473 ishtp_device_ready = true; 474 dev_set_drvdata(&device->dev, device); 475 476 return device; 477 } 478 479 /** 480 * ishtp_bus_remove_device() - Function to relase device on bus 481 * @device: client device instance 482 * 483 * This is a counterpart of ishtp_bus_add_device. 484 * Device is unregistered. 485 * the device structure is freed in 'ishtp_cl_dev_release' function 486 * Called only during error in pci driver init path. 487 */ 488 static void ishtp_bus_remove_device(struct ishtp_cl_device *device) 489 { 490 device_unregister(&device->dev); 491 } 492 493 /** 494 * ishtp_cl_driver_register() - Client driver register 495 * @driver: the client driver instance 496 * @owner: Owner of this driver module 497 * 498 * Once a client driver is probed, it created a client 499 * instance and registers with the bus. 500 * 501 * Return: Return value of driver_register or -ENODEV if not ready 502 */ 503 int ishtp_cl_driver_register(struct ishtp_cl_driver *driver, 504 struct module *owner) 505 { 506 int err; 507 508 if (!ishtp_device_ready) 509 return -ENODEV; 510 511 driver->driver.name = driver->name; 512 driver->driver.owner = owner; 513 driver->driver.bus = &ishtp_cl_bus_type; 514 515 err = driver_register(&driver->driver); 516 if (err) 517 return err; 518 519 return 0; 520 } 521 EXPORT_SYMBOL(ishtp_cl_driver_register); 522 523 /** 524 * ishtp_cl_driver_unregister() - Client driver unregister 525 * @driver: the client driver instance 526 * 527 * Unregister client during device removal process. 528 */ 529 void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver) 530 { 531 driver_unregister(&driver->driver); 532 } 533 EXPORT_SYMBOL(ishtp_cl_driver_unregister); 534 535 /** 536 * ishtp_bus_event_work() - event work function 537 * @work: work struct pointer 538 * 539 * Once an event is received for a client this work 540 * function is called. If the device has registered a 541 * callback then the callback is called. 542 */ 543 static void ishtp_bus_event_work(struct work_struct *work) 544 { 545 struct ishtp_cl_device *device; 546 547 device = container_of(work, struct ishtp_cl_device, event_work); 548 549 if (device->event_cb) 550 device->event_cb(device); 551 } 552 553 /** 554 * ishtp_cl_bus_rx_event() - schedule event work 555 * @device: client device instance 556 * 557 * Once an event is received for a client this schedules 558 * a work function to process. 559 */ 560 void ishtp_cl_bus_rx_event(struct ishtp_cl_device *device) 561 { 562 if (!device || !device->event_cb) 563 return; 564 565 if (device->event_cb) 566 schedule_work(&device->event_work); 567 } 568 569 /** 570 * ishtp_register_event_cb() - Register callback 571 * @device: client device instance 572 * @event_cb: Event processor for an client 573 * 574 * Register a callback for events, called from client driver 575 * 576 * Return: Return 0 or -EALREADY if already registered 577 */ 578 int ishtp_register_event_cb(struct ishtp_cl_device *device, 579 void (*event_cb)(struct ishtp_cl_device *)) 580 { 581 if (device->event_cb) 582 return -EALREADY; 583 584 device->event_cb = event_cb; 585 INIT_WORK(&device->event_work, ishtp_bus_event_work); 586 587 return 0; 588 } 589 EXPORT_SYMBOL(ishtp_register_event_cb); 590 591 /** 592 * ishtp_get_device() - update usage count for the device 593 * @cl_device: client device instance 594 * 595 * Increment the usage count. The device can't be deleted 596 */ 597 void ishtp_get_device(struct ishtp_cl_device *cl_device) 598 { 599 cl_device->reference_count++; 600 } 601 EXPORT_SYMBOL(ishtp_get_device); 602 603 /** 604 * ishtp_put_device() - decrement usage count for the device 605 * @cl_device: client device instance 606 * 607 * Decrement the usage count. The device can be deleted is count = 0 608 */ 609 void ishtp_put_device(struct ishtp_cl_device *cl_device) 610 { 611 cl_device->reference_count--; 612 } 613 EXPORT_SYMBOL(ishtp_put_device); 614 615 /** 616 * ishtp_set_drvdata() - set client driver data 617 * @cl_device: client device instance 618 * @data: driver data need to be set 619 * 620 * Set client driver data to cl_device->driver_data. 621 */ 622 void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data) 623 { 624 cl_device->driver_data = data; 625 } 626 EXPORT_SYMBOL(ishtp_set_drvdata); 627 628 /** 629 * ishtp_get_drvdata() - get client driver data 630 * @cl_device: client device instance 631 * 632 * Get client driver data from cl_device->driver_data. 633 * 634 * Return: pointer of driver data 635 */ 636 void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device) 637 { 638 return cl_device->driver_data; 639 } 640 EXPORT_SYMBOL(ishtp_get_drvdata); 641 642 /** 643 * ishtp_bus_new_client() - Create a new client 644 * @dev: ISHTP device instance 645 * 646 * Once bus protocol enumerates a client, this is called 647 * to add a device for the client. 648 * 649 * Return: 0 on success or error code on failure 650 */ 651 int ishtp_bus_new_client(struct ishtp_device *dev) 652 { 653 int i; 654 char *dev_name; 655 struct ishtp_cl_device *cl_device; 656 guid_t device_uuid; 657 658 /* 659 * For all reported clients, create an unconnected client and add its 660 * device to ISHTP bus. 661 * If appropriate driver has loaded, this will trigger its probe(). 662 * Otherwise, probe() will be called when driver is loaded 663 */ 664 i = dev->fw_client_presentation_num - 1; 665 device_uuid = dev->fw_clients[i].props.protocol_name; 666 dev_name = kasprintf(GFP_KERNEL, "{%pUL}", &device_uuid); 667 if (!dev_name) 668 return -ENOMEM; 669 670 cl_device = ishtp_bus_add_device(dev, device_uuid, dev_name); 671 if (!cl_device) { 672 kfree(dev_name); 673 return -ENOENT; 674 } 675 676 kfree(dev_name); 677 678 return 0; 679 } 680 681 /** 682 * ishtp_cl_device_bind() - bind a device 683 * @cl: ishtp client device 684 * 685 * Binds connected ishtp_cl to ISHTP bus device 686 * 687 * Return: 0 on success or fault code 688 */ 689 int ishtp_cl_device_bind(struct ishtp_cl *cl) 690 { 691 struct ishtp_cl_device *cl_device; 692 unsigned long flags; 693 int rv; 694 695 if (!cl->fw_client_id || cl->state != ISHTP_CL_CONNECTED) 696 return -EFAULT; 697 698 rv = -ENOENT; 699 spin_lock_irqsave(&cl->dev->device_list_lock, flags); 700 list_for_each_entry(cl_device, &cl->dev->device_list, 701 device_link) { 702 if (cl_device->fw_client && 703 cl_device->fw_client->client_id == cl->fw_client_id) { 704 cl->device = cl_device; 705 rv = 0; 706 break; 707 } 708 } 709 spin_unlock_irqrestore(&cl->dev->device_list_lock, flags); 710 return rv; 711 } 712 713 /** 714 * ishtp_bus_remove_all_clients() - Remove all clients 715 * @ishtp_dev: ishtp device 716 * @warm_reset: Reset due to FW reset dure to errors or S3 suspend 717 * 718 * This is part of reset/remove flow. This function the main processing 719 * only targets error processing, if the FW has forced reset or 720 * error to remove connected clients. When warm reset the client devices are 721 * not removed. 722 */ 723 void ishtp_bus_remove_all_clients(struct ishtp_device *ishtp_dev, 724 bool warm_reset) 725 { 726 struct ishtp_cl_device *cl_device, *n; 727 struct ishtp_cl *cl; 728 unsigned long flags; 729 730 spin_lock_irqsave(&ishtp_dev->cl_list_lock, flags); 731 list_for_each_entry(cl, &ishtp_dev->cl_list, link) { 732 cl->state = ISHTP_CL_DISCONNECTED; 733 734 /* 735 * Wake any pending process. The waiter would check dev->state 736 * and determine that it's not enabled already, 737 * and will return error to its caller 738 */ 739 wake_up_interruptible(&cl->wait_ctrl_res); 740 741 /* Disband any pending read/write requests and free rb */ 742 ishtp_cl_flush_queues(cl); 743 744 /* Remove all free and in_process rings, both Rx and Tx */ 745 ishtp_cl_free_rx_ring(cl); 746 ishtp_cl_free_tx_ring(cl); 747 748 /* 749 * Free client and ISHTP bus client device structures 750 * don't free host client because it is part of the OS fd 751 * structure 752 */ 753 } 754 spin_unlock_irqrestore(&ishtp_dev->cl_list_lock, flags); 755 756 /* Release DMA buffers for client messages */ 757 ishtp_cl_free_dma_buf(ishtp_dev); 758 759 /* remove bus clients */ 760 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags); 761 list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list, 762 device_link) { 763 cl_device->fw_client = NULL; 764 if (warm_reset && cl_device->reference_count) 765 continue; 766 767 list_del(&cl_device->device_link); 768 spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags); 769 ishtp_bus_remove_device(cl_device); 770 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags); 771 } 772 spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags); 773 774 /* Free all client structures */ 775 spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags); 776 kfree(ishtp_dev->fw_clients); 777 ishtp_dev->fw_clients = NULL; 778 ishtp_dev->fw_clients_num = 0; 779 ishtp_dev->fw_client_presentation_num = 0; 780 ishtp_dev->fw_client_index = 0; 781 bitmap_zero(ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX); 782 spin_unlock_irqrestore(&ishtp_dev->fw_clients_lock, flags); 783 } 784 EXPORT_SYMBOL(ishtp_bus_remove_all_clients); 785 786 /** 787 * ishtp_reset_handler() - IPC reset handler 788 * @dev: ishtp device 789 * 790 * ISHTP Handler for IPC_RESET notification 791 */ 792 void ishtp_reset_handler(struct ishtp_device *dev) 793 { 794 unsigned long flags; 795 796 /* Handle FW-initiated reset */ 797 dev->dev_state = ISHTP_DEV_RESETTING; 798 799 /* Clear BH processing queue - no further HBMs */ 800 spin_lock_irqsave(&dev->rd_msg_spinlock, flags); 801 dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0; 802 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags); 803 804 /* Handle ISH FW reset against upper layers */ 805 ishtp_bus_remove_all_clients(dev, true); 806 } 807 EXPORT_SYMBOL(ishtp_reset_handler); 808 809 /** 810 * ishtp_reset_compl_handler() - Reset completion handler 811 * @dev: ishtp device 812 * 813 * ISHTP handler for IPC_RESET sequence completion to start 814 * host message bus start protocol sequence. 815 */ 816 void ishtp_reset_compl_handler(struct ishtp_device *dev) 817 { 818 dev->dev_state = ISHTP_DEV_INIT_CLIENTS; 819 dev->hbm_state = ISHTP_HBM_START; 820 ishtp_hbm_start_req(dev); 821 } 822 EXPORT_SYMBOL(ishtp_reset_compl_handler); 823 824 /** 825 * ishtp_use_dma_transfer() - Function to use DMA 826 * 827 * This interface is used to enable usage of DMA 828 * 829 * Return non zero if DMA can be enabled 830 */ 831 int ishtp_use_dma_transfer(void) 832 { 833 return ishtp_use_dma; 834 } 835 836 /** 837 * ishtp_device() - Return device pointer 838 * 839 * This interface is used to return device pointer from ishtp_cl_device 840 * instance. 841 * 842 * Return: device *. 843 */ 844 struct device *ishtp_device(struct ishtp_cl_device *device) 845 { 846 return &device->dev; 847 } 848 EXPORT_SYMBOL(ishtp_device); 849 850 /** 851 * ishtp_get_pci_device() - Return PCI device dev pointer 852 * This interface is used to return PCI device pointer 853 * from ishtp_cl_device instance. 854 * 855 * Return: device *. 856 */ 857 struct device *ishtp_get_pci_device(struct ishtp_cl_device *device) 858 { 859 return device->ishtp_dev->devc; 860 } 861 EXPORT_SYMBOL(ishtp_get_pci_device); 862 863 /** 864 * ishtp_trace_callback() - Return trace callback 865 * 866 * This interface is used to return trace callback function pointer. 867 * 868 * Return: void *. 869 */ 870 void *ishtp_trace_callback(struct ishtp_cl_device *cl_device) 871 { 872 return cl_device->ishtp_dev->print_log; 873 } 874 EXPORT_SYMBOL(ishtp_trace_callback); 875 876 /** 877 * ish_hw_reset() - Call HW reset IPC callback 878 * 879 * This interface is used to reset HW in case of error. 880 * 881 * Return: value from IPC hw_reset callback 882 */ 883 int ish_hw_reset(struct ishtp_device *dev) 884 { 885 return dev->ops->hw_reset(dev); 886 } 887 EXPORT_SYMBOL(ish_hw_reset); 888 889 /** 890 * ishtp_bus_register() - Function to register bus 891 * 892 * This register ishtp bus 893 * 894 * Return: Return output of bus_register 895 */ 896 static int __init ishtp_bus_register(void) 897 { 898 return bus_register(&ishtp_cl_bus_type); 899 } 900 901 /** 902 * ishtp_bus_unregister() - Function to unregister bus 903 * 904 * This unregister ishtp bus 905 */ 906 static void __exit ishtp_bus_unregister(void) 907 { 908 bus_unregister(&ishtp_cl_bus_type); 909 } 910 911 module_init(ishtp_bus_register); 912 module_exit(ishtp_bus_unregister); 913 914 MODULE_LICENSE("GPL"); 915