Merge tag 'armsoc-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc
[sfrench/cifs-2.6.git] / drivers / hid / intel-ish-hid / ishtp / bus.c
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");