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
 325 static struct device_attribute ishtp_cl_dev_attrs[] = {
 326         __ATTR_RO(modalias),
 327         __ATTR_NULL,
 328 };
 329
 330 static int ishtp_cl_uevent(struct device *dev, struct kobj_uevent_env *env)
 331 {
 332         if (add_uevent_var(env, "MODALIAS=ishtp:%s", dev_name(dev)))
 333                 return -ENOMEM;
 334         return 0;
 335 }
 336
 337 static const struct dev_pm_ops ishtp_cl_bus_dev_pm_ops = {
 338         /* Suspend callbacks */
 339         .suspend = ishtp_cl_device_suspend,
 340         .resume = ishtp_cl_device_resume,
 341         /* Hibernate callbacks */
 342         .freeze = ishtp_cl_device_suspend,
 343         .thaw = ishtp_cl_device_resume,
 344         .restore = ishtp_cl_device_resume,
 345 };
 346
 347 static struct bus_type ishtp_cl_bus_type = {
 348         .name           = "ishtp",
 349         .dev_attrs      = ishtp_cl_dev_attrs,
 350         .probe          = ishtp_cl_device_probe,
 351         .remove         = ishtp_cl_device_remove,
 352         .pm             = &ishtp_cl_bus_dev_pm_ops,
 353         .uevent         = ishtp_cl_uevent,
 354 };
 355
 356 static void ishtp_cl_dev_release(struct device *dev)
 357 {
 358         kfree(to_ishtp_cl_device(dev));
 359 }
 360
 361 static struct device_type ishtp_cl_device_type = {
 362         .release        = ishtp_cl_dev_release,
 363 };
 364
 365 /**
 366  * ishtp_bus_add_device() - Function to create device on bus
 367  * @dev:        ishtp device
 368  * @uuid:       uuid of the client
 369  * @name:       Name of the client
 370  *
 371  * Allocate ISHTP bus client device, attach it to uuid
 372  * and register with ISHTP bus.
 373  *
 374  * Return: ishtp_cl_device pointer or NULL on failure
 375  */
 376 static struct ishtp_cl_device *ishtp_bus_add_device(struct ishtp_device *dev,
 377                                                     uuid_le uuid, char *name)
 378 {
 379         struct ishtp_cl_device *device;
 380         int status;
 381         unsigned long flags;
 382
 383         spin_lock_irqsave(&dev->device_list_lock, flags);
 384         list_for_each_entry(device, &dev->device_list, device_link) {
 385                 if (!strcmp(name, dev_name(&device->dev))) {
 386                         device->fw_client = &dev->fw_clients[
 387                                 dev->fw_client_presentation_num - 1];
 388                         spin_unlock_irqrestore(&dev->device_list_lock, flags);
 389                         ishtp_cl_device_reset(device);
 390                         return device;
 391                 }
 392         }
 393         spin_unlock_irqrestore(&dev->device_list_lock, flags);
 394
 395         device = kzalloc(sizeof(struct ishtp_cl_device), GFP_KERNEL);
 396         if (!device)
 397                 return NULL;
 398
 399         device->dev.parent = dev->devc;
 400         device->dev.bus = &ishtp_cl_bus_type;
 401         device->dev.type = &ishtp_cl_device_type;
 402         device->ishtp_dev = dev;
 403
 404         device->fw_client =
 405                 &dev->fw_clients[dev->fw_client_presentation_num - 1];
 406
 407         dev_set_name(&device->dev, "%s", name);
 408
 409         spin_lock_irqsave(&dev->device_list_lock, flags);
 410         list_add_tail(&device->device_link, &dev->device_list);
 411         spin_unlock_irqrestore(&dev->device_list_lock, flags);
 412
 413         status = device_register(&device->dev);
 414         if (status) {
 415                 spin_lock_irqsave(&dev->device_list_lock, flags);
 416                 list_del(&device->device_link);
 417                 spin_unlock_irqrestore(&dev->device_list_lock, flags);
 418                 dev_err(dev->devc, "Failed to register ISHTP client device\n");
 419                 kfree(device);
 420                 return NULL;
 421         }
 422
 423         ishtp_device_ready = true;
 424
 425         return device;
 426 }
 427
 428 /**
 429  * ishtp_bus_remove_device() - Function to relase device on bus
 430  * @device:     client device instance
 431  *
 432  * This is a counterpart of ishtp_bus_add_device.
 433  * Device is unregistered.
 434  * the device structure is freed in 'ishtp_cl_dev_release' function
 435  * Called only during error in pci driver init path.
 436  */
 437 static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
 438 {
 439         device_unregister(&device->dev);
 440 }
 441
 442 /**
 443  * __ishtp_cl_driver_register() - Client driver register
 444  * @driver:     the client driver instance
 445  * @owner:      Owner of this driver module
 446  *
 447  * Once a client driver is probed, it created a client
 448  * instance and registers with the bus.
 449  *
 450  * Return: Return value of driver_register or -ENODEV if not ready
 451  */
 452 int __ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
 453                                struct module *owner)
 454 {
 455         int err;
 456
 457         if (!ishtp_device_ready)
 458                 return -ENODEV;
 459
 460         driver->driver.name = driver->name;
 461         driver->driver.owner = owner;
 462         driver->driver.bus = &ishtp_cl_bus_type;
 463
 464         err = driver_register(&driver->driver);
 465         if (err)
 466                 return err;
 467
 468         return 0;
 469 }
 470 EXPORT_SYMBOL(__ishtp_cl_driver_register);
 471
 472 /**
 473  * ishtp_cl_driver_unregister() - Client driver unregister
 474  * @driver:     the client driver instance
 475  *
 476  * Unregister client during device removal process.
 477  */
 478 void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver)
 479 {
 480         driver_unregister(&driver->driver);
 481 }
 482 EXPORT_SYMBOL(ishtp_cl_driver_unregister);
 483
 484 /**
 485  * ishtp_bus_event_work() - event work function
 486  * @work:       work struct pointer
 487  *
 488  * Once an event is received for a client this work
 489  * function is called. If the device has registered a
 490  * callback then the callback is called.
 491  */
 492 static void ishtp_bus_event_work(struct work_struct *work)
 493 {
 494         struct ishtp_cl_device *device;
 495
 496         device = container_of(work, struct ishtp_cl_device, event_work);
 497
 498         if (device->event_cb)
 499                 device->event_cb(device);
 500 }
 501
 502 /**
 503  * ishtp_cl_bus_rx_event() - schedule event work
 504  * @device:     client device instance
 505  *
 506  * Once an event is received for a client this schedules
 507  * a work function to process.
 508  */
 509 void ishtp_cl_bus_rx_event(struct ishtp_cl_device *device)
 510 {
 511         if (!device || !device->event_cb)
 512                 return;
 513
 514         if (device->event_cb)
 515                 schedule_work(&device->event_work);
 516 }
 517
 518 /**
 519  * ishtp_register_event_cb() - Register callback
 520  * @device:     client device instance
 521  * @event_cb:   Event processor for an client
 522  *
 523  * Register a callback for events, called from client driver
 524  *
 525  * Return: Return 0 or -EALREADY if already registered
 526  */
 527 int ishtp_register_event_cb(struct ishtp_cl_device *device,
 528         void (*event_cb)(struct ishtp_cl_device *))
 529 {
 530         if (device->event_cb)
 531                 return -EALREADY;
 532
 533         device->event_cb = event_cb;
 534         INIT_WORK(&device->event_work, ishtp_bus_event_work);
 535
 536         return 0;
 537 }
 538 EXPORT_SYMBOL(ishtp_register_event_cb);
 539
 540 /**
 541  * ishtp_get_device() - update usage count for the device
 542  * @cl_device:  client device instance
 543  *
 544  * Increment the usage count. The device can't be deleted
 545  */
 546 void ishtp_get_device(struct ishtp_cl_device *cl_device)
 547 {
 548         cl_device->reference_count++;
 549 }
 550 EXPORT_SYMBOL(ishtp_get_device);
 551
 552 /**
 553  * ishtp_put_device() - decrement usage count for the device
 554  * @cl_device:  client device instance
 555  *
 556  * Decrement the usage count. The device can be deleted is count = 0
 557  */
 558 void ishtp_put_device(struct ishtp_cl_device *cl_device)
 559 {
 560         cl_device->reference_count--;
 561 }
 562 EXPORT_SYMBOL(ishtp_put_device);
 563
 564 /**
 565  * ishtp_bus_new_client() - Create a new client
 566  * @dev:        ISHTP device instance
 567  *
 568  * Once bus protocol enumerates a client, this is called
 569  * to add a device for the client.
 570  *
 571  * Return: 0 on success or error code on failure
 572  */
 573 int ishtp_bus_new_client(struct ishtp_device *dev)
 574 {
 575         int     i;
 576         char    *dev_name;
 577         struct ishtp_cl_device  *cl_device;
 578         uuid_le device_uuid;
 579
 580         /*
 581          * For all reported clients, create an unconnected client and add its
 582          * device to ISHTP bus.
 583          * If appropriate driver has loaded, this will trigger its probe().
 584          * Otherwise, probe() will be called when driver is loaded
 585          */
 586         i = dev->fw_client_presentation_num - 1;
 587         device_uuid = dev->fw_clients[i].props.protocol_name;
 588         dev_name = kasprintf(GFP_KERNEL,
 589                 "{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 590                 device_uuid.b[3], device_uuid.b[2], device_uuid.b[1],
 591                 device_uuid.b[0], device_uuid.b[5], device_uuid.b[4],
 592                 device_uuid.b[7], device_uuid.b[6], device_uuid.b[8],
 593                 device_uuid.b[9], device_uuid.b[10], device_uuid.b[11],
 594                 device_uuid.b[12], device_uuid.b[13], device_uuid.b[14],
 595                 device_uuid.b[15]);
 596         if (!dev_name)
 597                 return  -ENOMEM;
 598
 599         cl_device = ishtp_bus_add_device(dev, device_uuid, dev_name);
 600         if (!cl_device) {
 601                 kfree(dev_name);
 602                 return  -ENOENT;
 603         }
 604
 605         kfree(dev_name);
 606
 607         return  0;
 608 }
 609
 610 /**
 611  * ishtp_cl_device_bind() - bind a device
 612  * @cl:         ishtp client device
 613  *
 614  * Binds connected ishtp_cl to ISHTP bus device
 615  *
 616  * Return: 0 on success or fault code
 617  */
 618 int ishtp_cl_device_bind(struct ishtp_cl *cl)
 619 {
 620         struct ishtp_cl_device  *cl_device;
 621         unsigned long flags;
 622         int     rv;
 623
 624         if (!cl->fw_client_id || cl->state != ISHTP_CL_CONNECTED)
 625                 return  -EFAULT;
 626
 627         rv = -ENOENT;
 628         spin_lock_irqsave(&cl->dev->device_list_lock, flags);
 629         list_for_each_entry(cl_device, &cl->dev->device_list,
 630                         device_link) {
 631                 if (cl_device->fw_client->client_id == cl->fw_client_id) {
 632                         cl->device = cl_device;
 633                         rv = 0;
 634                         break;
 635                 }
 636         }
 637         spin_unlock_irqrestore(&cl->dev->device_list_lock, flags);
 638         return  rv;
 639 }
 640
 641 /**
 642  * ishtp_bus_remove_all_clients() - Remove all clients
 643  * @ishtp_dev:          ishtp device
 644  * @warm_reset:         Reset due to FW reset dure to errors or S3 suspend
 645  *
 646  * This is part of reset/remove flow. This function the main processing
 647  * only targets error processing, if the FW has forced reset or
 648  * error to remove connected clients. When warm reset the client devices are
 649  * not removed.
 650  */
 651 void ishtp_bus_remove_all_clients(struct ishtp_device *ishtp_dev,
 652                                   bool warm_reset)
 653 {
 654         struct ishtp_cl_device  *cl_device, *n;
 655         struct ishtp_cl *cl;
 656         unsigned long   flags;
 657
 658         spin_lock_irqsave(&ishtp_dev->cl_list_lock, flags);
 659         list_for_each_entry(cl, &ishtp_dev->cl_list, link) {
 660                 cl->state = ISHTP_CL_DISCONNECTED;
 661
 662                 /*
 663                  * Wake any pending process. The waiter would check dev->state
 664                  * and determine that it's not enabled already,
 665                  * and will return error to its caller
 666                  */
 667                 wake_up_interruptible(&cl->wait_ctrl_res);
 668
 669                 /* Disband any pending read/write requests and free rb */
 670                 ishtp_cl_flush_queues(cl);
 671
 672                 /* Remove all free and in_process rings, both Rx and Tx */
 673                 ishtp_cl_free_rx_ring(cl);
 674                 ishtp_cl_free_tx_ring(cl);
 675
 676                 /*
 677                  * Free client and ISHTP bus client device structures
 678                  * don't free host client because it is part of the OS fd
 679                  * structure
 680                  */
 681         }
 682         spin_unlock_irqrestore(&ishtp_dev->cl_list_lock, flags);
 683
 684         /* Release DMA buffers for client messages */
 685         ishtp_cl_free_dma_buf(ishtp_dev);
 686
 687         /* remove bus clients */
 688         spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
 689         list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list,
 690                                  device_link) {
 691                 if (warm_reset && cl_device->reference_count)
 692                         continue;
 693
 694                 list_del(&cl_device->device_link);
 695                 spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
 696                 ishtp_bus_remove_device(cl_device);
 697                 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
 698         }
 699         spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
 700
 701         /* Free all client structures */
 702         spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags);
 703         kfree(ishtp_dev->fw_clients);
 704         ishtp_dev->fw_clients = NULL;
 705         ishtp_dev->fw_clients_num = 0;
 706         ishtp_dev->fw_client_presentation_num = 0;
 707         ishtp_dev->fw_client_index = 0;
 708         bitmap_zero(ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX);
 709         spin_unlock_irqrestore(&ishtp_dev->fw_clients_lock, flags);
 710 }
 711 EXPORT_SYMBOL(ishtp_bus_remove_all_clients);
 712
 713 /**
 714  * ishtp_reset_handler() - IPC reset handler
 715  * @dev:        ishtp device
 716  *
 717  * ISHTP Handler for IPC_RESET notification
 718  */
 719 void ishtp_reset_handler(struct ishtp_device *dev)
 720 {
 721         unsigned long   flags;
 722
 723         /* Handle FW-initiated reset */
 724         dev->dev_state = ISHTP_DEV_RESETTING;
 725
 726         /* Clear BH processing queue - no further HBMs */
 727         spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
 728         dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0;
 729         spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
 730
 731         /* Handle ISH FW reset against upper layers */
 732         ishtp_bus_remove_all_clients(dev, true);
 733 }
 734 EXPORT_SYMBOL(ishtp_reset_handler);
 735
 736 /**
 737  * ishtp_reset_compl_handler() - Reset completion handler
 738  * @dev:        ishtp device
 739  *
 740  * ISHTP handler for IPC_RESET sequence completion to start
 741  * host message bus start protocol sequence.
 742  */
 743 void ishtp_reset_compl_handler(struct ishtp_device *dev)
 744 {
 745         dev->dev_state = ISHTP_DEV_INIT_CLIENTS;
 746         dev->hbm_state = ISHTP_HBM_START;
 747         ishtp_hbm_start_req(dev);
 748 }
 749 EXPORT_SYMBOL(ishtp_reset_compl_handler);
 750
 751 /**
 752  * ishtp_use_dma_transfer() - Function to use DMA
 753  *
 754  * This interface is used to enable usage of DMA
 755  *
 756  * Return non zero if DMA can be enabled
 757  */
 758 int ishtp_use_dma_transfer(void)
 759 {
 760         return ishtp_use_dma;
 761 }
 762
 763 /**
 764  * ishtp_bus_register() - Function to register bus
 765  *
 766  * This register ishtp bus
 767  *
 768  * Return: Return output of bus_register
 769  */
 770 static int  __init ishtp_bus_register(void)
 771 {
 772         return bus_register(&ishtp_cl_bus_type);
 773 }
 774
 775 /**
 776  * ishtp_bus_unregister() - Function to unregister bus
 777  *
 778  * This unregister ishtp bus
 779  */
 780 static void __exit ishtp_bus_unregister(void)
 781 {
 782         bus_unregister(&ishtp_cl_bus_type);
 783 }
 784
 785 module_init(ishtp_bus_register);
 786 module_exit(ishtp_bus_unregister);
 787
 788 MODULE_LICENSE("GPL");