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