Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid
[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
475         return device;
476 }
477
478 /**
479  * ishtp_bus_remove_device() - Function to relase device on bus
480  * @device:     client device instance
481  *
482  * This is a counterpart of ishtp_bus_add_device.
483  * Device is unregistered.
484  * the device structure is freed in 'ishtp_cl_dev_release' function
485  * Called only during error in pci driver init path.
486  */
487 static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
488 {
489         device_unregister(&device->dev);
490 }
491
492 /**
493  * ishtp_cl_driver_register() - Client driver register
494  * @driver:     the client driver instance
495  * @owner:      Owner of this driver module
496  *
497  * Once a client driver is probed, it created a client
498  * instance and registers with the bus.
499  *
500  * Return: Return value of driver_register or -ENODEV if not ready
501  */
502 int ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
503                              struct module *owner)
504 {
505         int err;
506
507         if (!ishtp_device_ready)
508                 return -ENODEV;
509
510         driver->driver.name = driver->name;
511         driver->driver.owner = owner;
512         driver->driver.bus = &ishtp_cl_bus_type;
513
514         err = driver_register(&driver->driver);
515         if (err)
516                 return err;
517
518         return 0;
519 }
520 EXPORT_SYMBOL(ishtp_cl_driver_register);
521
522 /**
523  * ishtp_cl_driver_unregister() - Client driver unregister
524  * @driver:     the client driver instance
525  *
526  * Unregister client during device removal process.
527  */
528 void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver)
529 {
530         driver_unregister(&driver->driver);
531 }
532 EXPORT_SYMBOL(ishtp_cl_driver_unregister);
533
534 /**
535  * ishtp_bus_event_work() - event work function
536  * @work:       work struct pointer
537  *
538  * Once an event is received for a client this work
539  * function is called. If the device has registered a
540  * callback then the callback is called.
541  */
542 static void ishtp_bus_event_work(struct work_struct *work)
543 {
544         struct ishtp_cl_device *device;
545
546         device = container_of(work, struct ishtp_cl_device, event_work);
547
548         if (device->event_cb)
549                 device->event_cb(device);
550 }
551
552 /**
553  * ishtp_cl_bus_rx_event() - schedule event work
554  * @device:     client device instance
555  *
556  * Once an event is received for a client this schedules
557  * a work function to process.
558  */
559 void ishtp_cl_bus_rx_event(struct ishtp_cl_device *device)
560 {
561         if (!device || !device->event_cb)
562                 return;
563
564         if (device->event_cb)
565                 schedule_work(&device->event_work);
566 }
567
568 /**
569  * ishtp_register_event_cb() - Register callback
570  * @device:     client device instance
571  * @event_cb:   Event processor for an client
572  *
573  * Register a callback for events, called from client driver
574  *
575  * Return: Return 0 or -EALREADY if already registered
576  */
577 int ishtp_register_event_cb(struct ishtp_cl_device *device,
578         void (*event_cb)(struct ishtp_cl_device *))
579 {
580         if (device->event_cb)
581                 return -EALREADY;
582
583         device->event_cb = event_cb;
584         INIT_WORK(&device->event_work, ishtp_bus_event_work);
585
586         return 0;
587 }
588 EXPORT_SYMBOL(ishtp_register_event_cb);
589
590 /**
591  * ishtp_get_device() - update usage count for the device
592  * @cl_device:  client device instance
593  *
594  * Increment the usage count. The device can't be deleted
595  */
596 void ishtp_get_device(struct ishtp_cl_device *cl_device)
597 {
598         cl_device->reference_count++;
599 }
600 EXPORT_SYMBOL(ishtp_get_device);
601
602 /**
603  * ishtp_put_device() - decrement usage count for the device
604  * @cl_device:  client device instance
605  *
606  * Decrement the usage count. The device can be deleted is count = 0
607  */
608 void ishtp_put_device(struct ishtp_cl_device *cl_device)
609 {
610         cl_device->reference_count--;
611 }
612 EXPORT_SYMBOL(ishtp_put_device);
613
614 /**
615  * ishtp_set_drvdata() - set client driver data
616  * @cl_device:  client device instance
617  * @data:       driver data need to be set
618  *
619  * Set client driver data to cl_device->driver_data.
620  */
621 void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data)
622 {
623         cl_device->driver_data = data;
624 }
625 EXPORT_SYMBOL(ishtp_set_drvdata);
626
627 /**
628  * ishtp_get_drvdata() - get client driver data
629  * @cl_device:  client device instance
630  *
631  * Get client driver data from cl_device->driver_data.
632  *
633  * Return: pointer of driver data
634  */
635 void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device)
636 {
637         return cl_device->driver_data;
638 }
639 EXPORT_SYMBOL(ishtp_get_drvdata);
640
641 /**
642  * ishtp_dev_to_cl_device() - get ishtp_cl_device instance from device instance
643  * @device: device instance
644  *
645  * Get ish_cl_device instance which embeds device instance in it.
646  *
647  * Return: pointer to ishtp_cl_device instance
648  */
649 struct ishtp_cl_device *ishtp_dev_to_cl_device(struct device *device)
650 {
651         return to_ishtp_cl_device(device);
652 }
653 EXPORT_SYMBOL(ishtp_dev_to_cl_device);
654
655 /**
656  * ishtp_bus_new_client() - Create a new client
657  * @dev:        ISHTP device instance
658  *
659  * Once bus protocol enumerates a client, this is called
660  * to add a device for the client.
661  *
662  * Return: 0 on success or error code on failure
663  */
664 int ishtp_bus_new_client(struct ishtp_device *dev)
665 {
666         int     i;
667         char    *dev_name;
668         struct ishtp_cl_device  *cl_device;
669         guid_t  device_uuid;
670
671         /*
672          * For all reported clients, create an unconnected client and add its
673          * device to ISHTP bus.
674          * If appropriate driver has loaded, this will trigger its probe().
675          * Otherwise, probe() will be called when driver is loaded
676          */
677         i = dev->fw_client_presentation_num - 1;
678         device_uuid = dev->fw_clients[i].props.protocol_name;
679         dev_name = kasprintf(GFP_KERNEL, "{%pUL}", &device_uuid);
680         if (!dev_name)
681                 return  -ENOMEM;
682
683         cl_device = ishtp_bus_add_device(dev, device_uuid, dev_name);
684         if (!cl_device) {
685                 kfree(dev_name);
686                 return  -ENOENT;
687         }
688
689         kfree(dev_name);
690
691         return  0;
692 }
693
694 /**
695  * ishtp_cl_device_bind() - bind a device
696  * @cl:         ishtp client device
697  *
698  * Binds connected ishtp_cl to ISHTP bus device
699  *
700  * Return: 0 on success or fault code
701  */
702 int ishtp_cl_device_bind(struct ishtp_cl *cl)
703 {
704         struct ishtp_cl_device  *cl_device;
705         unsigned long flags;
706         int     rv;
707
708         if (!cl->fw_client_id || cl->state != ISHTP_CL_CONNECTED)
709                 return  -EFAULT;
710
711         rv = -ENOENT;
712         spin_lock_irqsave(&cl->dev->device_list_lock, flags);
713         list_for_each_entry(cl_device, &cl->dev->device_list,
714                         device_link) {
715                 if (cl_device->fw_client &&
716                     cl_device->fw_client->client_id == cl->fw_client_id) {
717                         cl->device = cl_device;
718                         rv = 0;
719                         break;
720                 }
721         }
722         spin_unlock_irqrestore(&cl->dev->device_list_lock, flags);
723         return  rv;
724 }
725
726 /**
727  * ishtp_bus_remove_all_clients() - Remove all clients
728  * @ishtp_dev:          ishtp device
729  * @warm_reset:         Reset due to FW reset dure to errors or S3 suspend
730  *
731  * This is part of reset/remove flow. This function the main processing
732  * only targets error processing, if the FW has forced reset or
733  * error to remove connected clients. When warm reset the client devices are
734  * not removed.
735  */
736 void ishtp_bus_remove_all_clients(struct ishtp_device *ishtp_dev,
737                                   bool warm_reset)
738 {
739         struct ishtp_cl_device  *cl_device, *n;
740         struct ishtp_cl *cl;
741         unsigned long   flags;
742
743         spin_lock_irqsave(&ishtp_dev->cl_list_lock, flags);
744         list_for_each_entry(cl, &ishtp_dev->cl_list, link) {
745                 cl->state = ISHTP_CL_DISCONNECTED;
746
747                 /*
748                  * Wake any pending process. The waiter would check dev->state
749                  * and determine that it's not enabled already,
750                  * and will return error to its caller
751                  */
752                 wake_up_interruptible(&cl->wait_ctrl_res);
753
754                 /* Disband any pending read/write requests and free rb */
755                 ishtp_cl_flush_queues(cl);
756
757                 /* Remove all free and in_process rings, both Rx and Tx */
758                 ishtp_cl_free_rx_ring(cl);
759                 ishtp_cl_free_tx_ring(cl);
760
761                 /*
762                  * Free client and ISHTP bus client device structures
763                  * don't free host client because it is part of the OS fd
764                  * structure
765                  */
766         }
767         spin_unlock_irqrestore(&ishtp_dev->cl_list_lock, flags);
768
769         /* Release DMA buffers for client messages */
770         ishtp_cl_free_dma_buf(ishtp_dev);
771
772         /* remove bus clients */
773         spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
774         list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list,
775                                  device_link) {
776                 cl_device->fw_client = NULL;
777                 if (warm_reset && cl_device->reference_count)
778                         continue;
779
780                 list_del(&cl_device->device_link);
781                 spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
782                 ishtp_bus_remove_device(cl_device);
783                 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
784         }
785         spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
786
787         /* Free all client structures */
788         spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags);
789         kfree(ishtp_dev->fw_clients);
790         ishtp_dev->fw_clients = NULL;
791         ishtp_dev->fw_clients_num = 0;
792         ishtp_dev->fw_client_presentation_num = 0;
793         ishtp_dev->fw_client_index = 0;
794         bitmap_zero(ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX);
795         spin_unlock_irqrestore(&ishtp_dev->fw_clients_lock, flags);
796 }
797 EXPORT_SYMBOL(ishtp_bus_remove_all_clients);
798
799 /**
800  * ishtp_reset_handler() - IPC reset handler
801  * @dev:        ishtp device
802  *
803  * ISHTP Handler for IPC_RESET notification
804  */
805 void ishtp_reset_handler(struct ishtp_device *dev)
806 {
807         unsigned long   flags;
808
809         /* Handle FW-initiated reset */
810         dev->dev_state = ISHTP_DEV_RESETTING;
811
812         /* Clear BH processing queue - no further HBMs */
813         spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
814         dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0;
815         spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
816
817         /* Handle ISH FW reset against upper layers */
818         ishtp_bus_remove_all_clients(dev, true);
819 }
820 EXPORT_SYMBOL(ishtp_reset_handler);
821
822 /**
823  * ishtp_reset_compl_handler() - Reset completion handler
824  * @dev:        ishtp device
825  *
826  * ISHTP handler for IPC_RESET sequence completion to start
827  * host message bus start protocol sequence.
828  */
829 void ishtp_reset_compl_handler(struct ishtp_device *dev)
830 {
831         dev->dev_state = ISHTP_DEV_INIT_CLIENTS;
832         dev->hbm_state = ISHTP_HBM_START;
833         ishtp_hbm_start_req(dev);
834 }
835 EXPORT_SYMBOL(ishtp_reset_compl_handler);
836
837 /**
838  * ishtp_use_dma_transfer() - Function to use DMA
839  *
840  * This interface is used to enable usage of DMA
841  *
842  * Return non zero if DMA can be enabled
843  */
844 int ishtp_use_dma_transfer(void)
845 {
846         return ishtp_use_dma;
847 }
848
849 /**
850  * ishtp_device() - Return device pointer
851  *
852  * This interface is used to return device pointer from ishtp_cl_device
853  * instance.
854  *
855  * Return: device *.
856  */
857 struct device *ishtp_device(struct ishtp_cl_device *device)
858 {
859         return &device->dev;
860 }
861 EXPORT_SYMBOL(ishtp_device);
862
863 /**
864  * ishtp_get_pci_device() - Return PCI device dev pointer
865  * This interface is used to return PCI device pointer
866  * from ishtp_cl_device instance.
867  *
868  * Return: device *.
869  */
870 struct device *ishtp_get_pci_device(struct ishtp_cl_device *device)
871 {
872         return device->ishtp_dev->devc;
873 }
874 EXPORT_SYMBOL(ishtp_get_pci_device);
875
876 /**
877  * ishtp_trace_callback() - Return trace callback
878  *
879  * This interface is used to return trace callback function pointer.
880  *
881  * Return: void *.
882  */
883 void *ishtp_trace_callback(struct ishtp_cl_device *cl_device)
884 {
885         return cl_device->ishtp_dev->print_log;
886 }
887 EXPORT_SYMBOL(ishtp_trace_callback);
888
889 /**
890  * ish_hw_reset() - Call HW reset IPC callback
891  *
892  * This interface is used to reset HW in case of error.
893  *
894  * Return: value from IPC hw_reset callback
895  */
896 int ish_hw_reset(struct ishtp_device *dev)
897 {
898         return dev->ops->hw_reset(dev);
899 }
900 EXPORT_SYMBOL(ish_hw_reset);
901
902 /**
903  * ishtp_bus_register() - Function to register bus
904  *
905  * This register ishtp bus
906  *
907  * Return: Return output of bus_register
908  */
909 static int  __init ishtp_bus_register(void)
910 {
911         return bus_register(&ishtp_cl_bus_type);
912 }
913
914 /**
915  * ishtp_bus_unregister() - Function to unregister bus
916  *
917  * This unregister ishtp bus
918  */
919 static void __exit ishtp_bus_unregister(void)
920 {
921         bus_unregister(&ishtp_cl_bus_type);
922 }
923
924 module_init(ishtp_bus_register);
925 module_exit(ishtp_bus_unregister);
926
927 MODULE_LICENSE("GPL");