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
19static int ishtp_use_dma;
20module_param_named(ishtp_use_dma, ishtp_use_dma, int, 0600);
21MODULE_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)
25static 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 */
36void 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}
69EXPORT_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 */
84int 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 */
113int ishtp_write_message(struct ishtp_device *dev, struct ishtp_msg_hdr *hdr,
114 void *buf)
115{
116 return ishtp_send_msg(dev, hdr, msg: 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 */
128int 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(u1: uuid, u2: &dev->fw_clients[i].props.protocol_name))
134 return i;
135 }
136 return -ENOENT;
137}
138EXPORT_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 */
149struct 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(lock: &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}
163EXPORT_SYMBOL(ishtp_fw_cl_get_client);
164
165/**
166 * ishtp_get_fw_client_id() - Get fw client id
167 * @fw_client: firmware client used to fetch the ID
168 *
169 * This interface is used to reset HW get FW client id.
170 *
171 * Return: firmware client id.
172 */
173int ishtp_get_fw_client_id(struct ishtp_fw_client *fw_client)
174{
175 return fw_client->client_id;
176}
177EXPORT_SYMBOL(ishtp_get_fw_client_id);
178
179/**
180 * ishtp_fw_cl_by_id() - return index to fw_clients for client_id
181 * @dev: the ishtp device structure
182 * @client_id: fw client id to search
183 *
184 * Search firmware client using client id.
185 *
186 * Return: index on success, -ENOENT on failure.
187 */
188int ishtp_fw_cl_by_id(struct ishtp_device *dev, uint8_t client_id)
189{
190 int i, res = -ENOENT;
191 unsigned long flags;
192
193 spin_lock_irqsave(&dev->fw_clients_lock, flags);
194 for (i = 0; i < dev->fw_clients_num; i++) {
195 if (dev->fw_clients[i].client_id == client_id) {
196 res = i;
197 break;
198 }
199 }
200 spin_unlock_irqrestore(lock: &dev->fw_clients_lock, flags);
201
202 return res;
203}
204
205/**
206 * ishtp_cl_device_probe() - Bus probe() callback
207 * @dev: the device structure
208 *
209 * This is a bus probe callback and calls the drive probe function.
210 *
211 * Return: Return value from driver probe() call.
212 */
213static int ishtp_cl_device_probe(struct device *dev)
214{
215 struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
216 struct ishtp_cl_driver *driver;
217
218 if (!device)
219 return 0;
220
221 driver = to_ishtp_cl_driver(dev->driver);
222 if (!driver || !driver->probe)
223 return -ENODEV;
224
225 return driver->probe(device);
226}
227
228/**
229 * ishtp_cl_bus_match() - Bus match() callback
230 * @dev: the device structure
231 * @drv: the driver structure
232 *
233 * This is a bus match callback, called when a new ishtp_cl_device is
234 * registered during ishtp bus client enumeration. Use the guid_t in
235 * drv and dev to decide whether they match or not.
236 *
237 * Return: 1 if dev & drv matches, 0 otherwise.
238 */
239static int ishtp_cl_bus_match(struct device *dev, struct device_driver *drv)
240{
241 struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
242 struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv);
243
244 return(device->fw_client ? guid_equal(u1: &driver->id[0].guid,
245 u2: &device->fw_client->props.protocol_name) : 0);
246}
247
248/**
249 * ishtp_cl_device_remove() - Bus remove() callback
250 * @dev: the device structure
251 *
252 * This is a bus remove callback and calls the drive remove function.
253 * Since the ISH driver model supports only built in, this is
254 * primarily can be called during pci driver init failure.
255 *
256 * Return: Return value from driver remove() call.
257 */
258static void ishtp_cl_device_remove(struct device *dev)
259{
260 struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
261 struct ishtp_cl_driver *driver = to_ishtp_cl_driver(dev->driver);
262
263 if (device->event_cb) {
264 device->event_cb = NULL;
265 cancel_work_sync(work: &device->event_work);
266 }
267
268 if (driver->remove)
269 driver->remove(device);
270}
271
272/**
273 * ishtp_cl_device_suspend() - Bus suspend callback
274 * @dev: device
275 *
276 * Called during device suspend process.
277 *
278 * Return: Return value from driver suspend() call.
279 */
280static int ishtp_cl_device_suspend(struct device *dev)
281{
282 struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
283 struct ishtp_cl_driver *driver;
284 int ret = 0;
285
286 if (!device)
287 return 0;
288
289 driver = to_ishtp_cl_driver(dev->driver);
290 if (driver && driver->driver.pm) {
291 if (driver->driver.pm->suspend)
292 ret = driver->driver.pm->suspend(dev);
293 }
294
295 return ret;
296}
297
298/**
299 * ishtp_cl_device_resume() - Bus resume callback
300 * @dev: device
301 *
302 * Called during device resume process.
303 *
304 * Return: Return value from driver resume() call.
305 */
306static int ishtp_cl_device_resume(struct device *dev)
307{
308 struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
309 struct ishtp_cl_driver *driver;
310 int ret = 0;
311
312 if (!device)
313 return 0;
314
315 driver = to_ishtp_cl_driver(dev->driver);
316 if (driver && driver->driver.pm) {
317 if (driver->driver.pm->resume)
318 ret = driver->driver.pm->resume(dev);
319 }
320
321 return ret;
322}
323
324/**
325 * ishtp_cl_device_reset() - Reset callback
326 * @device: ishtp client device instance
327 *
328 * This is a callback when HW reset is done and the device need
329 * reinit.
330 *
331 * Return: Return value from driver reset() call.
332 */
333static int ishtp_cl_device_reset(struct ishtp_cl_device *device)
334{
335 struct ishtp_cl_driver *driver;
336 int ret = 0;
337
338 device->event_cb = NULL;
339 cancel_work_sync(work: &device->event_work);
340
341 driver = to_ishtp_cl_driver(device->dev.driver);
342 if (driver && driver->reset)
343 ret = driver->reset(device);
344
345 return ret;
346}
347
348static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
349 char *buf)
350{
351 int len;
352
353 len = snprintf(buf, PAGE_SIZE, ISHTP_MODULE_PREFIX "%s\n", dev_name(dev));
354 return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
355}
356static DEVICE_ATTR_RO(modalias);
357
358static struct attribute *ishtp_cl_dev_attrs[] = {
359 &dev_attr_modalias.attr,
360 NULL,
361};
362ATTRIBUTE_GROUPS(ishtp_cl_dev);
363
364static int ishtp_cl_uevent(const struct device *dev, struct kobj_uevent_env *env)
365{
366 if (add_uevent_var(env, format: "MODALIAS=" ISHTP_MODULE_PREFIX "%s", dev_name(dev)))
367 return -ENOMEM;
368 return 0;
369}
370
371static const struct dev_pm_ops ishtp_cl_bus_dev_pm_ops = {
372 /* Suspend callbacks */
373 .suspend = ishtp_cl_device_suspend,
374 .resume = ishtp_cl_device_resume,
375 /* Hibernate callbacks */
376 .freeze = ishtp_cl_device_suspend,
377 .thaw = ishtp_cl_device_resume,
378 .restore = ishtp_cl_device_resume,
379};
380
381static const struct bus_type ishtp_cl_bus_type = {
382 .name = "ishtp",
383 .dev_groups = ishtp_cl_dev_groups,
384 .probe = ishtp_cl_device_probe,
385 .match = ishtp_cl_bus_match,
386 .remove = ishtp_cl_device_remove,
387 .pm = &ishtp_cl_bus_dev_pm_ops,
388 .uevent = ishtp_cl_uevent,
389};
390
391static void ishtp_cl_dev_release(struct device *dev)
392{
393 kfree(to_ishtp_cl_device(dev));
394}
395
396static const struct device_type ishtp_cl_device_type = {
397 .release = ishtp_cl_dev_release,
398};
399
400/**
401 * ishtp_bus_add_device() - Function to create device on bus
402 * @dev: ishtp device
403 * @uuid: uuid of the client
404 * @name: Name of the client
405 *
406 * Allocate ISHTP bus client device, attach it to uuid
407 * and register with ISHTP bus.
408 *
409 * Return: ishtp_cl_device pointer or NULL on failure
410 */
411static struct ishtp_cl_device *ishtp_bus_add_device(struct ishtp_device *dev,
412 guid_t uuid, char *name)
413{
414 struct ishtp_cl_device *device;
415 int status;
416 unsigned long flags;
417
418 spin_lock_irqsave(&dev->device_list_lock, flags);
419 list_for_each_entry(device, &dev->device_list, device_link) {
420 if (!strcmp(name, dev_name(dev: &device->dev))) {
421 device->fw_client = &dev->fw_clients[
422 dev->fw_client_presentation_num - 1];
423 spin_unlock_irqrestore(lock: &dev->device_list_lock, flags);
424 ishtp_cl_device_reset(device);
425 return device;
426 }
427 }
428 spin_unlock_irqrestore(lock: &dev->device_list_lock, flags);
429
430 device = kzalloc(size: sizeof(struct ishtp_cl_device), GFP_KERNEL);
431 if (!device)
432 return NULL;
433
434 device->dev.parent = dev->devc;
435 device->dev.bus = &ishtp_cl_bus_type;
436 device->dev.type = &ishtp_cl_device_type;
437 device->ishtp_dev = dev;
438
439 device->fw_client =
440 &dev->fw_clients[dev->fw_client_presentation_num - 1];
441
442 dev_set_name(dev: &device->dev, name: "%s", name);
443
444 spin_lock_irqsave(&dev->device_list_lock, flags);
445 list_add_tail(new: &device->device_link, head: &dev->device_list);
446 spin_unlock_irqrestore(lock: &dev->device_list_lock, flags);
447
448 status = device_register(dev: &device->dev);
449 if (status) {
450 spin_lock_irqsave(&dev->device_list_lock, flags);
451 list_del(entry: &device->device_link);
452 spin_unlock_irqrestore(lock: &dev->device_list_lock, flags);
453 dev_err(dev->devc, "Failed to register ISHTP client device\n");
454 put_device(dev: &device->dev);
455 return NULL;
456 }
457
458 ishtp_device_ready = true;
459
460 return device;
461}
462
463/**
464 * ishtp_bus_remove_device() - Function to relase device on bus
465 * @device: client device instance
466 *
467 * This is a counterpart of ishtp_bus_add_device.
468 * Device is unregistered.
469 * the device structure is freed in 'ishtp_cl_dev_release' function
470 * Called only during error in pci driver init path.
471 */
472static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
473{
474 device_unregister(dev: &device->dev);
475}
476
477/**
478 * ishtp_cl_driver_register() - Client driver register
479 * @driver: the client driver instance
480 * @owner: Owner of this driver module
481 *
482 * Once a client driver is probed, it created a client
483 * instance and registers with the bus.
484 *
485 * Return: Return value of driver_register or -ENODEV if not ready
486 */
487int ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
488 struct module *owner)
489{
490 if (!ishtp_device_ready)
491 return -ENODEV;
492
493 driver->driver.name = driver->name;
494 driver->driver.owner = owner;
495 driver->driver.bus = &ishtp_cl_bus_type;
496
497 return driver_register(drv: &driver->driver);
498}
499EXPORT_SYMBOL(ishtp_cl_driver_register);
500
501/**
502 * ishtp_cl_driver_unregister() - Client driver unregister
503 * @driver: the client driver instance
504 *
505 * Unregister client during device removal process.
506 */
507void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver)
508{
509 driver_unregister(drv: &driver->driver);
510}
511EXPORT_SYMBOL(ishtp_cl_driver_unregister);
512
513/**
514 * ishtp_bus_event_work() - event work function
515 * @work: work struct pointer
516 *
517 * Once an event is received for a client this work
518 * function is called. If the device has registered a
519 * callback then the callback is called.
520 */
521static void ishtp_bus_event_work(struct work_struct *work)
522{
523 struct ishtp_cl_device *device;
524
525 device = container_of(work, struct ishtp_cl_device, event_work);
526
527 if (device->event_cb)
528 device->event_cb(device);
529}
530
531/**
532 * ishtp_cl_bus_rx_event() - schedule event work
533 * @device: client device instance
534 *
535 * Once an event is received for a client this schedules
536 * a work function to process.
537 */
538void ishtp_cl_bus_rx_event(struct ishtp_cl_device *device)
539{
540 if (!device || !device->event_cb)
541 return;
542
543 if (device->event_cb)
544 schedule_work(work: &device->event_work);
545}
546
547/**
548 * ishtp_register_event_cb() - Register callback
549 * @device: client device instance
550 * @event_cb: Event processor for an client
551 *
552 * Register a callback for events, called from client driver
553 *
554 * Return: Return 0 or -EALREADY if already registered
555 */
556int ishtp_register_event_cb(struct ishtp_cl_device *device,
557 void (*event_cb)(struct ishtp_cl_device *))
558{
559 if (device->event_cb)
560 return -EALREADY;
561
562 device->event_cb = event_cb;
563 INIT_WORK(&device->event_work, ishtp_bus_event_work);
564
565 return 0;
566}
567EXPORT_SYMBOL(ishtp_register_event_cb);
568
569/**
570 * ishtp_get_device() - update usage count for the device
571 * @cl_device: client device instance
572 *
573 * Increment the usage count. The device can't be deleted
574 */
575void ishtp_get_device(struct ishtp_cl_device *cl_device)
576{
577 cl_device->reference_count++;
578}
579EXPORT_SYMBOL(ishtp_get_device);
580
581/**
582 * ishtp_put_device() - decrement usage count for the device
583 * @cl_device: client device instance
584 *
585 * Decrement the usage count. The device can be deleted is count = 0
586 */
587void ishtp_put_device(struct ishtp_cl_device *cl_device)
588{
589 cl_device->reference_count--;
590}
591EXPORT_SYMBOL(ishtp_put_device);
592
593/**
594 * ishtp_set_drvdata() - set client driver data
595 * @cl_device: client device instance
596 * @data: driver data need to be set
597 *
598 * Set client driver data to cl_device->driver_data.
599 */
600void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data)
601{
602 cl_device->driver_data = data;
603}
604EXPORT_SYMBOL(ishtp_set_drvdata);
605
606/**
607 * ishtp_get_drvdata() - get client driver data
608 * @cl_device: client device instance
609 *
610 * Get client driver data from cl_device->driver_data.
611 *
612 * Return: pointer of driver data
613 */
614void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device)
615{
616 return cl_device->driver_data;
617}
618EXPORT_SYMBOL(ishtp_get_drvdata);
619
620/**
621 * ishtp_dev_to_cl_device() - get ishtp_cl_device instance from device instance
622 * @device: device instance
623 *
624 * Get ish_cl_device instance which embeds device instance in it.
625 *
626 * Return: pointer to ishtp_cl_device instance
627 */
628struct ishtp_cl_device *ishtp_dev_to_cl_device(struct device *device)
629{
630 return to_ishtp_cl_device(device);
631}
632EXPORT_SYMBOL(ishtp_dev_to_cl_device);
633
634/**
635 * ishtp_bus_new_client() - Create a new client
636 * @dev: ISHTP device instance
637 *
638 * Once bus protocol enumerates a client, this is called
639 * to add a device for the client.
640 *
641 * Return: 0 on success or error code on failure
642 */
643int ishtp_bus_new_client(struct ishtp_device *dev)
644{
645 int i;
646 char *dev_name;
647 struct ishtp_cl_device *cl_device;
648 guid_t device_uuid;
649
650 /*
651 * For all reported clients, create an unconnected client and add its
652 * device to ISHTP bus.
653 * If appropriate driver has loaded, this will trigger its probe().
654 * Otherwise, probe() will be called when driver is loaded
655 */
656 i = dev->fw_client_presentation_num - 1;
657 device_uuid = dev->fw_clients[i].props.protocol_name;
658 dev_name = kasprintf(GFP_KERNEL, fmt: "{%pUL}", &device_uuid);
659 if (!dev_name)
660 return -ENOMEM;
661
662 cl_device = ishtp_bus_add_device(dev, uuid: device_uuid, name: dev_name);
663 if (!cl_device) {
664 kfree(objp: dev_name);
665 return -ENOENT;
666 }
667
668 kfree(objp: dev_name);
669
670 return 0;
671}
672
673/**
674 * ishtp_cl_device_bind() - bind a device
675 * @cl: ishtp client device
676 *
677 * Binds connected ishtp_cl to ISHTP bus device
678 *
679 * Return: 0 on success or fault code
680 */
681int ishtp_cl_device_bind(struct ishtp_cl *cl)
682{
683 struct ishtp_cl_device *cl_device;
684 unsigned long flags;
685 int rv;
686
687 if (!cl->fw_client_id || cl->state != ISHTP_CL_CONNECTED)
688 return -EFAULT;
689
690 rv = -ENOENT;
691 spin_lock_irqsave(&cl->dev->device_list_lock, flags);
692 list_for_each_entry(cl_device, &cl->dev->device_list,
693 device_link) {
694 if (cl_device->fw_client &&
695 cl_device->fw_client->client_id == cl->fw_client_id) {
696 cl->device = cl_device;
697 rv = 0;
698 break;
699 }
700 }
701 spin_unlock_irqrestore(lock: &cl->dev->device_list_lock, flags);
702 return rv;
703}
704
705/**
706 * ishtp_bus_remove_all_clients() - Remove all clients
707 * @ishtp_dev: ishtp device
708 * @warm_reset: Reset due to FW reset dure to errors or S3 suspend
709 *
710 * This is part of reset/remove flow. This function the main processing
711 * only targets error processing, if the FW has forced reset or
712 * error to remove connected clients. When warm reset the client devices are
713 * not removed.
714 */
715void ishtp_bus_remove_all_clients(struct ishtp_device *ishtp_dev,
716 bool warm_reset)
717{
718 struct ishtp_cl_device *cl_device, *n;
719 struct ishtp_cl *cl;
720 unsigned long flags;
721
722 spin_lock_irqsave(&ishtp_dev->cl_list_lock, flags);
723 list_for_each_entry(cl, &ishtp_dev->cl_list, link) {
724 cl->state = ISHTP_CL_DISCONNECTED;
725 if (warm_reset && cl->device->reference_count)
726 continue;
727
728 /*
729 * Wake any pending process. The waiter would check dev->state
730 * and determine that it's not enabled already,
731 * and will return error to its caller
732 */
733 wake_up_interruptible(&cl->wait_ctrl_res);
734
735 /* Disband any pending read/write requests and free rb */
736 ishtp_cl_flush_queues(cl);
737
738 /* Remove all free and in_process rings, both Rx and Tx */
739 ishtp_cl_free_rx_ring(cl);
740 ishtp_cl_free_tx_ring(cl);
741
742 /*
743 * Free client and ISHTP bus client device structures
744 * don't free host client because it is part of the OS fd
745 * structure
746 */
747 }
748 spin_unlock_irqrestore(lock: &ishtp_dev->cl_list_lock, flags);
749
750 /* Release DMA buffers for client messages */
751 ishtp_cl_free_dma_buf(dev: ishtp_dev);
752
753 /* remove bus clients */
754 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
755 list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list,
756 device_link) {
757 cl_device->fw_client = NULL;
758 if (warm_reset && cl_device->reference_count)
759 continue;
760
761 list_del(entry: &cl_device->device_link);
762 spin_unlock_irqrestore(lock: &ishtp_dev->device_list_lock, flags);
763 ishtp_bus_remove_device(device: cl_device);
764 spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
765 }
766 spin_unlock_irqrestore(lock: &ishtp_dev->device_list_lock, flags);
767
768 /* Free all client structures */
769 spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags);
770 kfree(objp: ishtp_dev->fw_clients);
771 ishtp_dev->fw_clients = NULL;
772 ishtp_dev->fw_clients_num = 0;
773 ishtp_dev->fw_client_presentation_num = 0;
774 ishtp_dev->fw_client_index = 0;
775 bitmap_zero(dst: ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX);
776 spin_unlock_irqrestore(lock: &ishtp_dev->fw_clients_lock, flags);
777}
778EXPORT_SYMBOL(ishtp_bus_remove_all_clients);
779
780/**
781 * ishtp_reset_handler() - IPC reset handler
782 * @dev: ishtp device
783 *
784 * ISHTP Handler for IPC_RESET notification
785 */
786void ishtp_reset_handler(struct ishtp_device *dev)
787{
788 unsigned long flags;
789
790 /* Handle FW-initiated reset */
791 dev->dev_state = ISHTP_DEV_RESETTING;
792
793 /* Clear BH processing queue - no further HBMs */
794 spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
795 dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0;
796 spin_unlock_irqrestore(lock: &dev->rd_msg_spinlock, flags);
797
798 /* Handle ISH FW reset against upper layers */
799 ishtp_bus_remove_all_clients(dev, true);
800}
801EXPORT_SYMBOL(ishtp_reset_handler);
802
803/**
804 * ishtp_reset_compl_handler() - Reset completion handler
805 * @dev: ishtp device
806 *
807 * ISHTP handler for IPC_RESET sequence completion to start
808 * host message bus start protocol sequence.
809 */
810void ishtp_reset_compl_handler(struct ishtp_device *dev)
811{
812 dev->dev_state = ISHTP_DEV_INIT_CLIENTS;
813 dev->hbm_state = ISHTP_HBM_START;
814 ishtp_hbm_start_req(dev);
815}
816EXPORT_SYMBOL(ishtp_reset_compl_handler);
817
818/**
819 * ishtp_use_dma_transfer() - Function to use DMA
820 *
821 * This interface is used to enable usage of DMA
822 *
823 * Return non zero if DMA can be enabled
824 */
825int ishtp_use_dma_transfer(void)
826{
827 return ishtp_use_dma;
828}
829
830/**
831 * ishtp_device() - Return device pointer
832 * @device: ISH-TP client device instance
833 *
834 * This interface is used to return device pointer from ishtp_cl_device
835 * instance.
836 *
837 * Return: device *.
838 */
839struct device *ishtp_device(struct ishtp_cl_device *device)
840{
841 return &device->dev;
842}
843EXPORT_SYMBOL(ishtp_device);
844
845/**
846 * ishtp_wait_resume() - Wait for IPC resume
847 *
848 * Wait for IPC resume
849 *
850 * Return: resume complete or not
851 */
852bool ishtp_wait_resume(struct ishtp_device *dev)
853{
854 /* 50ms to get resume response */
855 #define WAIT_FOR_RESUME_ACK_MS 50
856
857 /* Waiting to get resume response */
858 if (dev->resume_flag)
859 wait_event_interruptible_timeout(dev->resume_wait,
860 !dev->resume_flag,
861 msecs_to_jiffies(WAIT_FOR_RESUME_ACK_MS));
862
863 return (!dev->resume_flag);
864}
865EXPORT_SYMBOL_GPL(ishtp_wait_resume);
866
867/**
868 * ishtp_get_pci_device() - Return PCI device dev pointer
869 * This interface is used to return PCI device pointer
870 * from ishtp_cl_device instance.
871 * @device: ISH-TP client device instance
872 *
873 * Return: device *.
874 */
875struct device *ishtp_get_pci_device(struct ishtp_cl_device *device)
876{
877 return device->ishtp_dev->devc;
878}
879EXPORT_SYMBOL(ishtp_get_pci_device);
880
881/**
882 * ishtp_trace_callback() - Return trace callback
883 * @cl_device: ISH-TP client device instance
884 *
885 * This interface is used to return trace callback function pointer.
886 *
887 * Return: *ishtp_print_log()
888 */
889ishtp_print_log ishtp_trace_callback(struct ishtp_cl_device *cl_device)
890{
891 return cl_device->ishtp_dev->print_log;
892}
893EXPORT_SYMBOL(ishtp_trace_callback);
894
895/**
896 * ish_hw_reset() - Call HW reset IPC callback
897 * @dev: ISHTP device instance
898 *
899 * This interface is used to reset HW in case of error.
900 *
901 * Return: value from IPC hw_reset callback
902 */
903int ish_hw_reset(struct ishtp_device *dev)
904{
905 return dev->ops->hw_reset(dev);
906}
907EXPORT_SYMBOL(ish_hw_reset);
908
909/**
910 * ishtp_bus_register() - Function to register bus
911 *
912 * This register ishtp bus
913 *
914 * Return: Return output of bus_register
915 */
916static int __init ishtp_bus_register(void)
917{
918 return bus_register(bus: &ishtp_cl_bus_type);
919}
920
921/**
922 * ishtp_bus_unregister() - Function to unregister bus
923 *
924 * This unregister ishtp bus
925 */
926static void __exit ishtp_bus_unregister(void)
927{
928 bus_unregister(bus: &ishtp_cl_bus_type);
929}
930
931module_init(ishtp_bus_register);
932module_exit(ishtp_bus_unregister);
933
934MODULE_LICENSE("GPL");
935

source code of linux/drivers/hid/intel-ish-hid/ishtp/bus.c