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  * @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  */
173 int ishtp_get_fw_client_id(struct ishtp_fw_client *fw_client)
174 {
175 	return fw_client->client_id;
176 }
177 EXPORT_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  */
188 int 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(&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  */
213 static 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  */
239 static 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 guid_equal(&driver->id[0].guid,
245 			  &device->fw_client->props.protocol_name);
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  */
258 static 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(&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  */
280 static 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  */
306 static 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  */
333 static 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(&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 
348 static 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 }
356 static DEVICE_ATTR_RO(modalias);
357 
358 static struct attribute *ishtp_cl_dev_attrs[] = {
359 	&dev_attr_modalias.attr,
360 	NULL,
361 };
362 ATTRIBUTE_GROUPS(ishtp_cl_dev);
363 
364 static int ishtp_cl_uevent(const struct device *dev, struct kobj_uevent_env *env)
365 {
366 	if (add_uevent_var(env, "MODALIAS=" ISHTP_MODULE_PREFIX "%s", dev_name(dev)))
367 		return -ENOMEM;
368 	return 0;
369 }
370 
371 static 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 
381 static 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 
391 static void ishtp_cl_dev_release(struct device *dev)
392 {
393 	kfree(to_ishtp_cl_device(dev));
394 }
395 
396 static 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  */
411 static 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(&device->dev))) {
421 			device->fw_client = &dev->fw_clients[
422 				dev->fw_client_presentation_num - 1];
423 			spin_unlock_irqrestore(&dev->device_list_lock, flags);
424 			ishtp_cl_device_reset(device);
425 			return device;
426 		}
427 	}
428 	spin_unlock_irqrestore(&dev->device_list_lock, flags);
429 
430 	device = kzalloc(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(&device->dev, "%s", name);
443 
444 	spin_lock_irqsave(&dev->device_list_lock, flags);
445 	list_add_tail(&device->device_link, &dev->device_list);
446 	spin_unlock_irqrestore(&dev->device_list_lock, flags);
447 
448 	status = device_register(&device->dev);
449 	if (status) {
450 		spin_lock_irqsave(&dev->device_list_lock, flags);
451 		list_del(&device->device_link);
452 		spin_unlock_irqrestore(&dev->device_list_lock, flags);
453 		dev_err(dev->devc, "Failed to register ISHTP client device\n");
454 		put_device(&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  */
472 static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
473 {
474 	device_unregister(&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  */
487 int 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(&driver->driver);
498 }
499 EXPORT_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  */
507 void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver)
508 {
509 	driver_unregister(&driver->driver);
510 }
511 EXPORT_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  */
521 static 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  */
538 void 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(&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  */
556 int 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 }
567 EXPORT_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  */
575 void ishtp_get_device(struct ishtp_cl_device *cl_device)
576 {
577 	cl_device->reference_count++;
578 }
579 EXPORT_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  */
587 void ishtp_put_device(struct ishtp_cl_device *cl_device)
588 {
589 	cl_device->reference_count--;
590 }
591 EXPORT_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  */
600 void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data)
601 {
602 	cl_device->driver_data = data;
603 }
604 EXPORT_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  */
614 void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device)
615 {
616 	return cl_device->driver_data;
617 }
618 EXPORT_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  */
628 struct ishtp_cl_device *ishtp_dev_to_cl_device(struct device *device)
629 {
630 	return to_ishtp_cl_device(device);
631 }
632 EXPORT_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  */
643 int 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, "{%pUL}", &device_uuid);
659 	if (!dev_name)
660 		return	-ENOMEM;
661 
662 	cl_device = ishtp_bus_add_device(dev, device_uuid, dev_name);
663 	if (!cl_device) {
664 		kfree(dev_name);
665 		return	-ENOENT;
666 	}
667 
668 	kfree(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  */
681 int 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(&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  */
715 void 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 
726 		/*
727 		 * Wake any pending process. The waiter would check dev->state
728 		 * and determine that it's not enabled already,
729 		 * and will return error to its caller
730 		 */
731 		wake_up_interruptible(&cl->wait_ctrl_res);
732 
733 		/* Disband any pending read/write requests and free rb */
734 		ishtp_cl_flush_queues(cl);
735 
736 		/* Remove all free and in_process rings, both Rx and Tx */
737 		ishtp_cl_free_rx_ring(cl);
738 		ishtp_cl_free_tx_ring(cl);
739 
740 		/*
741 		 * Free client and ISHTP bus client device structures
742 		 * don't free host client because it is part of the OS fd
743 		 * structure
744 		 */
745 	}
746 	spin_unlock_irqrestore(&ishtp_dev->cl_list_lock, flags);
747 
748 	/* Release DMA buffers for client messages */
749 	ishtp_cl_free_dma_buf(ishtp_dev);
750 
751 	/* remove bus clients */
752 	spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
753 	list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list,
754 				 device_link) {
755 		cl_device->fw_client = NULL;
756 		if (warm_reset && cl_device->reference_count)
757 			continue;
758 
759 		list_del(&cl_device->device_link);
760 		spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
761 		ishtp_bus_remove_device(cl_device);
762 		spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
763 	}
764 	spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
765 
766 	/* Free all client structures */
767 	spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags);
768 	kfree(ishtp_dev->fw_clients);
769 	ishtp_dev->fw_clients = NULL;
770 	ishtp_dev->fw_clients_num = 0;
771 	ishtp_dev->fw_client_presentation_num = 0;
772 	ishtp_dev->fw_client_index = 0;
773 	bitmap_zero(ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX);
774 	spin_unlock_irqrestore(&ishtp_dev->fw_clients_lock, flags);
775 }
776 EXPORT_SYMBOL(ishtp_bus_remove_all_clients);
777 
778 /**
779  * ishtp_reset_handler() - IPC reset handler
780  * @dev:	ishtp device
781  *
782  * ISHTP Handler for IPC_RESET notification
783  */
784 void ishtp_reset_handler(struct ishtp_device *dev)
785 {
786 	unsigned long	flags;
787 
788 	/* Handle FW-initiated reset */
789 	dev->dev_state = ISHTP_DEV_RESETTING;
790 
791 	/* Clear BH processing queue - no further HBMs */
792 	spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
793 	dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0;
794 	spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
795 
796 	/* Handle ISH FW reset against upper layers */
797 	ishtp_bus_remove_all_clients(dev, true);
798 }
799 EXPORT_SYMBOL(ishtp_reset_handler);
800 
801 /**
802  * ishtp_reset_compl_handler() - Reset completion handler
803  * @dev:	ishtp device
804  *
805  * ISHTP handler for IPC_RESET sequence completion to start
806  * host message bus start protocol sequence.
807  */
808 void ishtp_reset_compl_handler(struct ishtp_device *dev)
809 {
810 	dev->dev_state = ISHTP_DEV_INIT_CLIENTS;
811 	dev->hbm_state = ISHTP_HBM_START;
812 	ishtp_hbm_start_req(dev);
813 }
814 EXPORT_SYMBOL(ishtp_reset_compl_handler);
815 
816 /**
817  * ishtp_use_dma_transfer() - Function to use DMA
818  *
819  * This interface is used to enable usage of DMA
820  *
821  * Return non zero if DMA can be enabled
822  */
823 int ishtp_use_dma_transfer(void)
824 {
825 	return ishtp_use_dma;
826 }
827 
828 /**
829  * ishtp_device() - Return device pointer
830  * @device: ISH-TP client device instance
831  *
832  * This interface is used to return device pointer from ishtp_cl_device
833  * instance.
834  *
835  * Return: device *.
836  */
837 struct device *ishtp_device(struct ishtp_cl_device *device)
838 {
839 	return &device->dev;
840 }
841 EXPORT_SYMBOL(ishtp_device);
842 
843 /**
844  * ishtp_wait_resume() - Wait for IPC resume
845  *
846  * Wait for IPC resume
847  *
848  * Return: resume complete or not
849  */
850 bool ishtp_wait_resume(struct ishtp_device *dev)
851 {
852 	/* 50ms to get resume response */
853 	#define WAIT_FOR_RESUME_ACK_MS		50
854 
855 	/* Waiting to get resume response */
856 	if (dev->resume_flag)
857 		wait_event_interruptible_timeout(dev->resume_wait,
858 						 !dev->resume_flag,
859 						 msecs_to_jiffies(WAIT_FOR_RESUME_ACK_MS));
860 
861 	return (!dev->resume_flag);
862 }
863 EXPORT_SYMBOL_GPL(ishtp_wait_resume);
864 
865 /**
866  * ishtp_get_pci_device() - Return PCI device dev pointer
867  * This interface is used to return PCI device pointer
868  * from ishtp_cl_device instance.
869  * @device: ISH-TP client device instance
870  *
871  * Return: device *.
872  */
873 struct device *ishtp_get_pci_device(struct ishtp_cl_device *device)
874 {
875 	return device->ishtp_dev->devc;
876 }
877 EXPORT_SYMBOL(ishtp_get_pci_device);
878 
879 /**
880  * ishtp_trace_callback() - Return trace callback
881  * @cl_device: ISH-TP client device instance
882  *
883  * This interface is used to return trace callback function pointer.
884  *
885  * Return: *ishtp_print_log()
886  */
887 ishtp_print_log ishtp_trace_callback(struct ishtp_cl_device *cl_device)
888 {
889 	return cl_device->ishtp_dev->print_log;
890 }
891 EXPORT_SYMBOL(ishtp_trace_callback);
892 
893 /**
894  * ish_hw_reset() - Call HW reset IPC callback
895  * @dev:	ISHTP device instance
896  *
897  * This interface is used to reset HW in case of error.
898  *
899  * Return: value from IPC hw_reset callback
900  */
901 int ish_hw_reset(struct ishtp_device *dev)
902 {
903 	return dev->ops->hw_reset(dev);
904 }
905 EXPORT_SYMBOL(ish_hw_reset);
906 
907 /**
908  * ishtp_bus_register() - Function to register bus
909  *
910  * This register ishtp bus
911  *
912  * Return: Return output of bus_register
913  */
914 static int  __init ishtp_bus_register(void)
915 {
916 	return bus_register(&ishtp_cl_bus_type);
917 }
918 
919 /**
920  * ishtp_bus_unregister() - Function to unregister bus
921  *
922  * This unregister ishtp bus
923  */
924 static void __exit ishtp_bus_unregister(void)
925 {
926 	bus_unregister(&ishtp_cl_bus_type);
927 }
928 
929 module_init(ishtp_bus_register);
930 module_exit(ishtp_bus_unregister);
931 
932 MODULE_LICENSE("GPL");
933