4 * Copyright (c) 2012-2016, Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/device.h>
20 #include <linux/sched.h>
21 #include <linux/slab.h>
23 #include "ishtp-dev.h"
27 static int ishtp_use_dma
;
28 module_param_named(ishtp_use_dma
, ishtp_use_dma
, int, 0600);
29 MODULE_PARM_DESC(ishtp_use_dma
, "Use DMA to send messages");
31 #define to_ishtp_cl_driver(d) container_of(d, struct ishtp_cl_driver, driver)
32 #define to_ishtp_cl_device(d) container_of(d, struct ishtp_cl_device, dev)
33 static bool ishtp_device_ready
;
36 * ishtp_recv() - process ishtp message
39 * If a message with valid header and size is received, then
40 * this function calls appropriate handler. The host or firmware
41 * address is zero, then they are host bus management message,
42 * otherwise they are message fo clients.
44 void ishtp_recv(struct ishtp_device
*dev
)
47 struct ishtp_msg_hdr
*ishtp_hdr
;
49 /* Read ISHTP header dword */
50 msg_hdr
= dev
->ops
->ishtp_read_hdr(dev
);
54 dev
->ops
->sync_fw_clock(dev
);
56 ishtp_hdr
= (struct ishtp_msg_hdr
*)&msg_hdr
;
57 dev
->ishtp_msg_hdr
= msg_hdr
;
59 /* Sanity check: ISHTP frag. length in header */
60 if (ishtp_hdr
->length
> dev
->mtu
) {
62 "ISHTP hdr - bad length: %u; dropped [%08X]\n",
63 (unsigned int)ishtp_hdr
->length
, msg_hdr
);
67 /* ISHTP bus message */
68 if (!ishtp_hdr
->host_addr
&& !ishtp_hdr
->fw_addr
)
69 recv_hbm(dev
, ishtp_hdr
);
70 /* ISHTP fixed-client message */
71 else if (!ishtp_hdr
->host_addr
)
72 recv_fixed_cl_msg(dev
, ishtp_hdr
);
74 /* ISHTP client message */
75 recv_ishtp_cl_msg(dev
, ishtp_hdr
);
77 EXPORT_SYMBOL(ishtp_recv
);
80 * ishtp_send_msg() - Send ishtp message
82 * @hdr: Message header
83 * @msg: Message contents
84 * @ipc_send_compl: completion callback
85 * @ipc_send_compl_prm: completion callback parameter
87 * Send a multi fragment message via IPC. After sending the first fragment
88 * the completion callback is called to schedule transmit of next fragment.
90 * Return: This returns IPC send message status.
92 int ishtp_send_msg(struct ishtp_device
*dev
, struct ishtp_msg_hdr
*hdr
,
93 void *msg
, void(*ipc_send_compl
)(void *),
94 void *ipc_send_compl_prm
)
96 unsigned char ipc_msg
[IPC_FULL_MSG_SIZE
];
99 drbl_val
= dev
->ops
->ipc_get_header(dev
, hdr
->length
+
100 sizeof(struct ishtp_msg_hdr
),
103 memcpy(ipc_msg
, &drbl_val
, sizeof(uint32_t));
104 memcpy(ipc_msg
+ sizeof(uint32_t), hdr
, sizeof(uint32_t));
105 memcpy(ipc_msg
+ 2 * sizeof(uint32_t), msg
, hdr
->length
);
106 return dev
->ops
->write(dev
, ipc_send_compl
, ipc_send_compl_prm
,
107 ipc_msg
, 2 * sizeof(uint32_t) + hdr
->length
);
111 * ishtp_write_message() - Send ishtp single fragment message
113 * @hdr: Message header
116 * Send a single fragment message via IPC. This returns IPC send message
119 * Return: This returns IPC send message status.
121 int ishtp_write_message(struct ishtp_device
*dev
, struct ishtp_msg_hdr
*hdr
,
124 return ishtp_send_msg(dev
, hdr
, buf
, NULL
, NULL
);
128 * ishtp_fw_cl_by_uuid() - locate index of fw client
130 * @uuid: uuid of the client to search
132 * Search firmware client using UUID.
134 * Return: fw client index or -ENOENT if not found
136 int ishtp_fw_cl_by_uuid(struct ishtp_device
*dev
, const uuid_le
*uuid
)
138 int i
, res
= -ENOENT
;
140 for (i
= 0; i
< dev
->fw_clients_num
; ++i
) {
141 if (uuid_le_cmp(*uuid
, dev
->fw_clients
[i
].props
.protocol_name
)
149 EXPORT_SYMBOL(ishtp_fw_cl_by_uuid
);
152 * ishtp_fw_cl_by_id() - return index to fw_clients for client_id
153 * @dev: the ishtp device structure
154 * @client_id: fw client id to search
156 * Search firmware client using client id.
158 * Return: index on success, -ENOENT on failure.
160 int ishtp_fw_cl_by_id(struct ishtp_device
*dev
, uint8_t client_id
)
162 int i
, res
= -ENOENT
;
165 spin_lock_irqsave(&dev
->fw_clients_lock
, flags
);
166 for (i
= 0; i
< dev
->fw_clients_num
; i
++) {
167 if (dev
->fw_clients
[i
].client_id
== client_id
) {
172 spin_unlock_irqrestore(&dev
->fw_clients_lock
, flags
);
178 * ishtp_cl_device_probe() - Bus probe() callback
179 * @dev: the device structure
181 * This is a bus probe callback and calls the drive probe function.
183 * Return: Return value from driver probe() call.
185 static int ishtp_cl_device_probe(struct device
*dev
)
187 struct ishtp_cl_device
*device
= to_ishtp_cl_device(dev
);
188 struct ishtp_cl_driver
*driver
;
193 driver
= to_ishtp_cl_driver(dev
->driver
);
194 if (!driver
|| !driver
->probe
)
197 return driver
->probe(device
);
201 * ishtp_cl_device_remove() - Bus remove() callback
202 * @dev: the device structure
204 * This is a bus remove callback and calls the drive remove function.
205 * Since the ISH driver model supports only built in, this is
206 * primarily can be called during pci driver init failure.
208 * Return: Return value from driver remove() call.
210 static int ishtp_cl_device_remove(struct device
*dev
)
212 struct ishtp_cl_device
*device
= to_ishtp_cl_device(dev
);
213 struct ishtp_cl_driver
*driver
;
215 if (!device
|| !dev
->driver
)
218 if (device
->event_cb
) {
219 device
->event_cb
= NULL
;
220 cancel_work_sync(&device
->event_work
);
223 driver
= to_ishtp_cl_driver(dev
->driver
);
224 if (!driver
->remove
) {
230 return driver
->remove(device
);
234 * ishtp_cl_device_suspend() - Bus suspend callback
237 * Called during device suspend process.
239 * Return: Return value from driver suspend() call.
241 static int ishtp_cl_device_suspend(struct device
*dev
)
243 struct ishtp_cl_device
*device
= to_ishtp_cl_device(dev
);
244 struct ishtp_cl_driver
*driver
;
250 driver
= to_ishtp_cl_driver(dev
->driver
);
251 if (driver
&& driver
->driver
.pm
) {
252 if (driver
->driver
.pm
->suspend
)
253 ret
= driver
->driver
.pm
->suspend(dev
);
260 * ishtp_cl_device_resume() - Bus resume callback
263 * Called during device resume process.
265 * Return: Return value from driver resume() call.
267 static int ishtp_cl_device_resume(struct device
*dev
)
269 struct ishtp_cl_device
*device
= to_ishtp_cl_device(dev
);
270 struct ishtp_cl_driver
*driver
;
277 * When ISH needs hard reset, it is done asynchrnously, hence bus
278 * resume will be called before full ISH resume
280 if (device
->ishtp_dev
->resume_flag
)
283 driver
= to_ishtp_cl_driver(dev
->driver
);
284 if (driver
&& driver
->driver
.pm
) {
285 if (driver
->driver
.pm
->resume
)
286 ret
= driver
->driver
.pm
->resume(dev
);
293 * ishtp_cl_device_reset() - Reset callback
294 * @device: ishtp client device instance
296 * This is a callback when HW reset is done and the device need
299 * Return: Return value from driver reset() call.
301 static int ishtp_cl_device_reset(struct ishtp_cl_device
*device
)
303 struct ishtp_cl_driver
*driver
;
306 device
->event_cb
= NULL
;
307 cancel_work_sync(&device
->event_work
);
309 driver
= to_ishtp_cl_driver(device
->dev
.driver
);
310 if (driver
&& driver
->reset
)
311 ret
= driver
->reset(device
);
316 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*a
,
321 len
= snprintf(buf
, PAGE_SIZE
, "ishtp:%s\n", dev_name(dev
));
322 return (len
>= PAGE_SIZE
) ? (PAGE_SIZE
- 1) : len
;
325 static struct device_attribute ishtp_cl_dev_attrs
[] = {
330 static int ishtp_cl_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
332 if (add_uevent_var(env
, "MODALIAS=ishtp:%s", dev_name(dev
)))
337 static const struct dev_pm_ops ishtp_cl_bus_dev_pm_ops
= {
338 /* Suspend callbacks */
339 .suspend
= ishtp_cl_device_suspend
,
340 .resume
= ishtp_cl_device_resume
,
341 /* Hibernate callbacks */
342 .freeze
= ishtp_cl_device_suspend
,
343 .thaw
= ishtp_cl_device_resume
,
344 .restore
= ishtp_cl_device_resume
,
347 static struct bus_type ishtp_cl_bus_type
= {
349 .dev_attrs
= ishtp_cl_dev_attrs
,
350 .probe
= ishtp_cl_device_probe
,
351 .remove
= ishtp_cl_device_remove
,
352 .pm
= &ishtp_cl_bus_dev_pm_ops
,
353 .uevent
= ishtp_cl_uevent
,
356 static void ishtp_cl_dev_release(struct device
*dev
)
358 kfree(to_ishtp_cl_device(dev
));
361 static struct device_type ishtp_cl_device_type
= {
362 .release
= ishtp_cl_dev_release
,
366 * ishtp_bus_add_device() - Function to create device on bus
368 * @uuid: uuid of the client
369 * @name: Name of the client
371 * Allocate ISHTP bus client device, attach it to uuid
372 * and register with ISHTP bus.
374 * Return: ishtp_cl_device pointer or NULL on failure
376 static struct ishtp_cl_device
*ishtp_bus_add_device(struct ishtp_device
*dev
,
377 uuid_le uuid
, char *name
)
379 struct ishtp_cl_device
*device
;
383 spin_lock_irqsave(&dev
->device_list_lock
, flags
);
384 list_for_each_entry(device
, &dev
->device_list
, device_link
) {
385 if (!strcmp(name
, dev_name(&device
->dev
))) {
386 device
->fw_client
= &dev
->fw_clients
[
387 dev
->fw_client_presentation_num
- 1];
388 spin_unlock_irqrestore(&dev
->device_list_lock
, flags
);
389 ishtp_cl_device_reset(device
);
393 spin_unlock_irqrestore(&dev
->device_list_lock
, flags
);
395 device
= kzalloc(sizeof(struct ishtp_cl_device
), GFP_KERNEL
);
399 device
->dev
.parent
= dev
->devc
;
400 device
->dev
.bus
= &ishtp_cl_bus_type
;
401 device
->dev
.type
= &ishtp_cl_device_type
;
402 device
->ishtp_dev
= dev
;
405 &dev
->fw_clients
[dev
->fw_client_presentation_num
- 1];
407 dev_set_name(&device
->dev
, "%s", name
);
409 spin_lock_irqsave(&dev
->device_list_lock
, flags
);
410 list_add_tail(&device
->device_link
, &dev
->device_list
);
411 spin_unlock_irqrestore(&dev
->device_list_lock
, flags
);
413 status
= device_register(&device
->dev
);
415 spin_lock_irqsave(&dev
->device_list_lock
, flags
);
416 list_del(&device
->device_link
);
417 spin_unlock_irqrestore(&dev
->device_list_lock
, flags
);
418 dev_err(dev
->devc
, "Failed to register ISHTP client device\n");
423 ishtp_device_ready
= true;
429 * ishtp_bus_remove_device() - Function to relase device on bus
430 * @device: client device instance
432 * This is a counterpart of ishtp_bus_add_device.
433 * Device is unregistered.
434 * the device structure is freed in 'ishtp_cl_dev_release' function
435 * Called only during error in pci driver init path.
437 static void ishtp_bus_remove_device(struct ishtp_cl_device
*device
)
439 device_unregister(&device
->dev
);
443 * __ishtp_cl_driver_register() - Client driver register
444 * @driver: the client driver instance
445 * @owner: Owner of this driver module
447 * Once a client driver is probed, it created a client
448 * instance and registers with the bus.
450 * Return: Return value of driver_register or -ENODEV if not ready
452 int __ishtp_cl_driver_register(struct ishtp_cl_driver
*driver
,
453 struct module
*owner
)
457 if (!ishtp_device_ready
)
460 driver
->driver
.name
= driver
->name
;
461 driver
->driver
.owner
= owner
;
462 driver
->driver
.bus
= &ishtp_cl_bus_type
;
464 err
= driver_register(&driver
->driver
);
470 EXPORT_SYMBOL(__ishtp_cl_driver_register
);
473 * ishtp_cl_driver_unregister() - Client driver unregister
474 * @driver: the client driver instance
476 * Unregister client during device removal process.
478 void ishtp_cl_driver_unregister(struct ishtp_cl_driver
*driver
)
480 driver_unregister(&driver
->driver
);
482 EXPORT_SYMBOL(ishtp_cl_driver_unregister
);
485 * ishtp_bus_event_work() - event work function
486 * @work: work struct pointer
488 * Once an event is received for a client this work
489 * function is called. If the device has registered a
490 * callback then the callback is called.
492 static void ishtp_bus_event_work(struct work_struct
*work
)
494 struct ishtp_cl_device
*device
;
496 device
= container_of(work
, struct ishtp_cl_device
, event_work
);
498 if (device
->event_cb
)
499 device
->event_cb(device
);
503 * ishtp_cl_bus_rx_event() - schedule event work
504 * @device: client device instance
506 * Once an event is received for a client this schedules
507 * a work function to process.
509 void ishtp_cl_bus_rx_event(struct ishtp_cl_device
*device
)
511 if (!device
|| !device
->event_cb
)
514 if (device
->event_cb
)
515 schedule_work(&device
->event_work
);
519 * ishtp_register_event_cb() - Register callback
520 * @device: client device instance
521 * @event_cb: Event processor for an client
523 * Register a callback for events, called from client driver
525 * Return: Return 0 or -EALREADY if already registered
527 int ishtp_register_event_cb(struct ishtp_cl_device
*device
,
528 void (*event_cb
)(struct ishtp_cl_device
*))
530 if (device
->event_cb
)
533 device
->event_cb
= event_cb
;
534 INIT_WORK(&device
->event_work
, ishtp_bus_event_work
);
538 EXPORT_SYMBOL(ishtp_register_event_cb
);
541 * ishtp_get_device() - update usage count for the device
542 * @cl_device: client device instance
544 * Increment the usage count. The device can't be deleted
546 void ishtp_get_device(struct ishtp_cl_device
*cl_device
)
548 cl_device
->reference_count
++;
550 EXPORT_SYMBOL(ishtp_get_device
);
553 * ishtp_put_device() - decrement usage count for the device
554 * @cl_device: client device instance
556 * Decrement the usage count. The device can be deleted is count = 0
558 void ishtp_put_device(struct ishtp_cl_device
*cl_device
)
560 cl_device
->reference_count
--;
562 EXPORT_SYMBOL(ishtp_put_device
);
565 * ishtp_bus_new_client() - Create a new client
566 * @dev: ISHTP device instance
568 * Once bus protocol enumerates a client, this is called
569 * to add a device for the client.
571 * Return: 0 on success or error code on failure
573 int ishtp_bus_new_client(struct ishtp_device
*dev
)
577 struct ishtp_cl_device
*cl_device
;
581 * For all reported clients, create an unconnected client and add its
582 * device to ISHTP bus.
583 * If appropriate driver has loaded, this will trigger its probe().
584 * Otherwise, probe() will be called when driver is loaded
586 i
= dev
->fw_client_presentation_num
- 1;
587 device_uuid
= dev
->fw_clients
[i
].props
.protocol_name
;
588 dev_name
= kasprintf(GFP_KERNEL
,
589 "{%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
590 device_uuid
.b
[3], device_uuid
.b
[2], device_uuid
.b
[1],
591 device_uuid
.b
[0], device_uuid
.b
[5], device_uuid
.b
[4],
592 device_uuid
.b
[7], device_uuid
.b
[6], device_uuid
.b
[8],
593 device_uuid
.b
[9], device_uuid
.b
[10], device_uuid
.b
[11],
594 device_uuid
.b
[12], device_uuid
.b
[13], device_uuid
.b
[14],
599 cl_device
= ishtp_bus_add_device(dev
, device_uuid
, dev_name
);
611 * ishtp_cl_device_bind() - bind a device
612 * @cl: ishtp client device
614 * Binds connected ishtp_cl to ISHTP bus device
616 * Return: 0 on success or fault code
618 int ishtp_cl_device_bind(struct ishtp_cl
*cl
)
620 struct ishtp_cl_device
*cl_device
;
624 if (!cl
->fw_client_id
|| cl
->state
!= ISHTP_CL_CONNECTED
)
628 spin_lock_irqsave(&cl
->dev
->device_list_lock
, flags
);
629 list_for_each_entry(cl_device
, &cl
->dev
->device_list
,
631 if (cl_device
->fw_client
->client_id
== cl
->fw_client_id
) {
632 cl
->device
= cl_device
;
637 spin_unlock_irqrestore(&cl
->dev
->device_list_lock
, flags
);
642 * ishtp_bus_remove_all_clients() - Remove all clients
643 * @ishtp_dev: ishtp device
644 * @warm_reset: Reset due to FW reset dure to errors or S3 suspend
646 * This is part of reset/remove flow. This function the main processing
647 * only targets error processing, if the FW has forced reset or
648 * error to remove connected clients. When warm reset the client devices are
651 void ishtp_bus_remove_all_clients(struct ishtp_device
*ishtp_dev
,
654 struct ishtp_cl_device
*cl_device
, *n
;
658 spin_lock_irqsave(&ishtp_dev
->cl_list_lock
, flags
);
659 list_for_each_entry(cl
, &ishtp_dev
->cl_list
, link
) {
660 cl
->state
= ISHTP_CL_DISCONNECTED
;
663 * Wake any pending process. The waiter would check dev->state
664 * and determine that it's not enabled already,
665 * and will return error to its caller
667 wake_up_interruptible(&cl
->wait_ctrl_res
);
669 /* Disband any pending read/write requests and free rb */
670 ishtp_cl_flush_queues(cl
);
672 /* Remove all free and in_process rings, both Rx and Tx */
673 ishtp_cl_free_rx_ring(cl
);
674 ishtp_cl_free_tx_ring(cl
);
677 * Free client and ISHTP bus client device structures
678 * don't free host client because it is part of the OS fd
682 spin_unlock_irqrestore(&ishtp_dev
->cl_list_lock
, flags
);
684 /* Release DMA buffers for client messages */
685 ishtp_cl_free_dma_buf(ishtp_dev
);
687 /* remove bus clients */
688 spin_lock_irqsave(&ishtp_dev
->device_list_lock
, flags
);
689 list_for_each_entry_safe(cl_device
, n
, &ishtp_dev
->device_list
,
691 if (warm_reset
&& cl_device
->reference_count
)
694 list_del(&cl_device
->device_link
);
695 spin_unlock_irqrestore(&ishtp_dev
->device_list_lock
, flags
);
696 ishtp_bus_remove_device(cl_device
);
697 spin_lock_irqsave(&ishtp_dev
->device_list_lock
, flags
);
699 spin_unlock_irqrestore(&ishtp_dev
->device_list_lock
, flags
);
701 /* Free all client structures */
702 spin_lock_irqsave(&ishtp_dev
->fw_clients_lock
, flags
);
703 kfree(ishtp_dev
->fw_clients
);
704 ishtp_dev
->fw_clients
= NULL
;
705 ishtp_dev
->fw_clients_num
= 0;
706 ishtp_dev
->fw_client_presentation_num
= 0;
707 ishtp_dev
->fw_client_index
= 0;
708 bitmap_zero(ishtp_dev
->fw_clients_map
, ISHTP_CLIENTS_MAX
);
709 spin_unlock_irqrestore(&ishtp_dev
->fw_clients_lock
, flags
);
711 EXPORT_SYMBOL(ishtp_bus_remove_all_clients
);
714 * ishtp_reset_handler() - IPC reset handler
717 * ISHTP Handler for IPC_RESET notification
719 void ishtp_reset_handler(struct ishtp_device
*dev
)
723 /* Handle FW-initiated reset */
724 dev
->dev_state
= ISHTP_DEV_RESETTING
;
726 /* Clear BH processing queue - no further HBMs */
727 spin_lock_irqsave(&dev
->rd_msg_spinlock
, flags
);
728 dev
->rd_msg_fifo_head
= dev
->rd_msg_fifo_tail
= 0;
729 spin_unlock_irqrestore(&dev
->rd_msg_spinlock
, flags
);
731 /* Handle ISH FW reset against upper layers */
732 ishtp_bus_remove_all_clients(dev
, true);
734 EXPORT_SYMBOL(ishtp_reset_handler
);
737 * ishtp_reset_compl_handler() - Reset completion handler
740 * ISHTP handler for IPC_RESET sequence completion to start
741 * host message bus start protocol sequence.
743 void ishtp_reset_compl_handler(struct ishtp_device
*dev
)
745 dev
->dev_state
= ISHTP_DEV_INIT_CLIENTS
;
746 dev
->hbm_state
= ISHTP_HBM_START
;
747 ishtp_hbm_start_req(dev
);
749 EXPORT_SYMBOL(ishtp_reset_compl_handler
);
752 * ishtp_use_dma_transfer() - Function to use DMA
754 * This interface is used to enable usage of DMA
756 * Return non zero if DMA can be enabled
758 int ishtp_use_dma_transfer(void)
760 return ishtp_use_dma
;
764 * ishtp_bus_register() - Function to register bus
766 * This register ishtp bus
768 * Return: Return output of bus_register
770 static int __init
ishtp_bus_register(void)
772 return bus_register(&ishtp_cl_bus_type
);
776 * ishtp_bus_unregister() - Function to unregister bus
778 * This unregister ishtp bus
780 static void __exit
ishtp_bus_unregister(void)
782 bus_unregister(&ishtp_cl_bus_type
);
785 module_init(ishtp_bus_register
);
786 module_exit(ishtp_bus_unregister
);
788 MODULE_LICENSE("GPL");