drivers/hid/intel-ish-hid/ishtp/bus.c

   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                 put_device(&device->dev);
 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 &&
 627                     cl_device->fw_client->client_id == cl->fw_client_id) {
 628                         cl->device = cl_device;
 629                         rv = 0;
 630                         break;
 631                 }
 632         }
 633         spin_unlock_irqrestore(&cl->dev->device_list_lock, flags);
 634         return  rv;
 635 }
 636
 637 /**
 638  * ishtp_bus_remove_all_clients() - Remove all clients
 639  * @ishtp_dev:          ishtp device
 640  * @warm_reset:         Reset due to FW reset dure to errors or S3 suspend
 641  *
 642  * This is part of reset/remove flow. This function the main processing
 643  * only targets error processing, if the FW has forced reset or
 644  * error to remove connected clients. When warm reset the client devices are
 645  * not removed.
 646  */
 647 void ishtp_bus_remove_all_clients(struct ishtp_device *ishtp_dev,
 648                                   bool warm_reset)
 649 {
 650         struct ishtp_cl_device  *cl_device, *n;
 651         struct ishtp_cl *cl;
 652         unsigned long   flags;
 653
 654         spin_lock_irqsave(&ishtp_dev->cl_list_lock, flags);
 655         list_for_each_entry(cl, &ishtp_dev->cl_list, link) {
 656                 cl->state = ISHTP_CL_DISCONNECTED;
 657
 658                 /*
 659                  * Wake any pending process. The waiter would check dev->state
 660                  * and determine that it's not enabled already,
 661                  * and will return error to its caller
 662                  */
 663                 wake_up_interruptible(&cl->wait_ctrl_res);
 664
 665                 /* Disband any pending read/write requests and free rb */
 666                 ishtp_cl_flush_queues(cl);
 667
 668                 /* Remove all free and in_process rings, both Rx and Tx */
 669                 ishtp_cl_free_rx_ring(cl);
 670                 ishtp_cl_free_tx_ring(cl);
 671
 672                 /*
 673                  * Free client and ISHTP bus client device structures
 674                  * don't free host client because it is part of the OS fd
 675                  * structure
 676                  */
 677         }
 678         spin_unlock_irqrestore(&ishtp_dev->cl_list_lock, flags);
 679
 680         /* Release DMA buffers for client messages */
 681         ishtp_cl_free_dma_buf(ishtp_dev);
 682
 683         /* remove bus clients */
 684         spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
 685         list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list,
 686                                  device_link) {
 687                 cl_device->fw_client = NULL;
 688                 if (warm_reset && cl_device->reference_count)
 689                         continue;
 690
 691                 list_del(&cl_device->device_link);
 692                 spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
 693                 ishtp_bus_remove_device(cl_device);
 694                 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
 695         }
 696         spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
 697
 698         /* Free all client structures */
 699         spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags);
 700         kfree(ishtp_dev->fw_clients);
 701         ishtp_dev->fw_clients = NULL;
 702         ishtp_dev->fw_clients_num = 0;
 703         ishtp_dev->fw_client_presentation_num = 0;
 704         ishtp_dev->fw_client_index = 0;
 705         bitmap_zero(ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX);
 706         spin_unlock_irqrestore(&ishtp_dev->fw_clients_lock, flags);
 707 }
 708 EXPORT_SYMBOL(ishtp_bus_remove_all_clients);
 709
 710 /**
 711  * ishtp_reset_handler() - IPC reset handler
 712  * @dev:        ishtp device
 713  *
 714  * ISHTP Handler for IPC_RESET notification
 715  */
 716 void ishtp_reset_handler(struct ishtp_device *dev)
 717 {
 718         unsigned long   flags;
 719
 720         /* Handle FW-initiated reset */
 721         dev->dev_state = ISHTP_DEV_RESETTING;
 722
 723         /* Clear BH processing queue - no further HBMs */
 724         spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
 725         dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0;
 726         spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
 727
 728         /* Handle ISH FW reset against upper layers */
 729         ishtp_bus_remove_all_clients(dev, true);
 730 }
 731 EXPORT_SYMBOL(ishtp_reset_handler);
 732
 733 /**
 734  * ishtp_reset_compl_handler() - Reset completion handler
 735  * @dev:        ishtp device
 736  *
 737  * ISHTP handler for IPC_RESET sequence completion to start
 738  * host message bus start protocol sequence.
 739  */
 740 void ishtp_reset_compl_handler(struct ishtp_device *dev)
 741 {
 742         dev->dev_state = ISHTP_DEV_INIT_CLIENTS;
 743         dev->hbm_state = ISHTP_HBM_START;
 744         ishtp_hbm_start_req(dev);
 745 }
 746 EXPORT_SYMBOL(ishtp_reset_compl_handler);
 747
 748 /**
 749  * ishtp_use_dma_transfer() - Function to use DMA
 750  *
 751  * This interface is used to enable usage of DMA
 752  *
 753  * Return non zero if DMA can be enabled
 754  */
 755 int ishtp_use_dma_transfer(void)
 756 {
 757         return ishtp_use_dma;
 758 }
 759
 760 /**
 761  * ishtp_bus_register() - Function to register bus
 762  *
 763  * This register ishtp bus
 764  *
 765  * Return: Return output of bus_register
 766  */
 767 static int  __init ishtp_bus_register(void)
 768 {
 769         return bus_register(&ishtp_cl_bus_type);
 770 }
 771
 772 /**
 773  * ishtp_bus_unregister() - Function to unregister bus
 774  *
 775  * This unregister ishtp bus
 776  */
 777 static void __exit ishtp_bus_unregister(void)
 778 {
 779         bus_unregister(&ishtp_cl_bus_type);
 780 }
 781
 782 module_init(ishtp_bus_register);
 783 module_exit(ishtp_bus_unregister);
 784
 785 MODULE_LICENSE("GPL");