blob: c47c3328a0f44e842a8ee956bc26057a3d261d6e [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0-only
/*
* ISHTP bus driver
*
* Copyright (c) 2012-2016, Intel Corporation.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include "bus.h"
#include "ishtp-dev.h"
#include "client.h"
#include "hbm.h"
static int ishtp_use_dma;
module_param_named(ishtp_use_dma, ishtp_use_dma, int, 0600);
MODULE_PARM_DESC(ishtp_use_dma, "Use DMA to send messages");
#define to_ishtp_cl_driver(d) container_of(d, struct ishtp_cl_driver, driver)
#define to_ishtp_cl_device(d) container_of(d, struct ishtp_cl_device, dev)
static bool ishtp_device_ready;
/**
* ishtp_recv() - process ishtp message
* @dev: ishtp device
*
* If a message with valid header and size is received, then
* this function calls appropriate handler. The host or firmware
* address is zero, then they are host bus management message,
* otherwise they are message fo clients.
*/
void ishtp_recv(struct ishtp_device *dev)
{
uint32_t msg_hdr;
struct ishtp_msg_hdr *ishtp_hdr;
/* Read ISHTP header dword */
msg_hdr = dev->ops->ishtp_read_hdr(dev);
if (!msg_hdr)
return;
dev->ops->sync_fw_clock(dev);
ishtp_hdr = (struct ishtp_msg_hdr *)&msg_hdr;
dev->ishtp_msg_hdr = msg_hdr;
/* Sanity check: ISHTP frag. length in header */
if (ishtp_hdr->length > dev->mtu) {
dev_err(dev->devc,
"ISHTP hdr - bad length: %u; dropped [%08X]\n",
(unsigned int)ishtp_hdr->length, msg_hdr);
return;
}
/* ISHTP bus message */
if (!ishtp_hdr->host_addr && !ishtp_hdr->fw_addr)
recv_hbm(dev, ishtp_hdr);
/* ISHTP fixed-client message */
else if (!ishtp_hdr->host_addr)
recv_fixed_cl_msg(dev, ishtp_hdr);
else
/* ISHTP client message */
recv_ishtp_cl_msg(dev, ishtp_hdr);
}
EXPORT_SYMBOL(ishtp_recv);
/**
* ishtp_send_msg() - Send ishtp message
* @dev: ishtp device
* @hdr: Message header
* @msg: Message contents
* @ipc_send_compl: completion callback
* @ipc_send_compl_prm: completion callback parameter
*
* Send a multi fragment message via IPC. After sending the first fragment
* the completion callback is called to schedule transmit of next fragment.
*
* Return: This returns IPC send message status.
*/
int ishtp_send_msg(struct ishtp_device *dev, struct ishtp_msg_hdr *hdr,
void *msg, void(*ipc_send_compl)(void *),
void *ipc_send_compl_prm)
{
unsigned char ipc_msg[IPC_FULL_MSG_SIZE];
uint32_t drbl_val;
drbl_val = dev->ops->ipc_get_header(dev, hdr->length +
sizeof(struct ishtp_msg_hdr),
1);
memcpy(ipc_msg, &drbl_val, sizeof(uint32_t));
memcpy(ipc_msg + sizeof(uint32_t), hdr, sizeof(uint32_t));
memcpy(ipc_msg + 2 * sizeof(uint32_t), msg, hdr->length);
return dev->ops->write(dev, ipc_send_compl, ipc_send_compl_prm,
ipc_msg, 2 * sizeof(uint32_t) + hdr->length);
}
/**
* ishtp_write_message() - Send ishtp single fragment message
* @dev: ishtp device
* @hdr: Message header
* @buf: message data
*
* Send a single fragment message via IPC. This returns IPC send message
* status.
*
* Return: This returns IPC send message status.
*/
int ishtp_write_message(struct ishtp_device *dev, struct ishtp_msg_hdr *hdr,
void *buf)
{
return ishtp_send_msg(dev, hdr, buf, NULL, NULL);
}
/**
* ishtp_fw_cl_by_uuid() - locate index of fw client
* @dev: ishtp device
* @uuid: uuid of the client to search
*
* Search firmware client using UUID.
*
* Return: fw client index or -ENOENT if not found
*/
int ishtp_fw_cl_by_uuid(struct ishtp_device *dev, const guid_t *uuid)
{
unsigned int i;
for (i = 0; i < dev->fw_clients_num; ++i) {
if (guid_equal(uuid, &dev->fw_clients[i].props.protocol_name))
return i;
}
return -ENOENT;
}
EXPORT_SYMBOL(ishtp_fw_cl_by_uuid);
/**
* ishtp_fw_cl_get_client() - return client information to client
* @dev: the ishtp device structure
* @uuid: uuid of the client to search
*
* Search firmware client using UUID and reture related client information.
*
* Return: pointer of client information on success, NULL on failure.
*/
struct ishtp_fw_client *ishtp_fw_cl_get_client(struct ishtp_device *dev,
const guid_t *uuid)
{
int i;
unsigned long flags;
spin_lock_irqsave(&dev->fw_clients_lock, flags);
i = ishtp_fw_cl_by_uuid(dev, uuid);
spin_unlock_irqrestore(&dev->fw_clients_lock, flags);
if (i < 0 || dev->fw_clients[i].props.fixed_address)
return NULL;
return &dev->fw_clients[i];
}
EXPORT_SYMBOL(ishtp_fw_cl_get_client);
/**
* ishtp_get_fw_client_id() - Get fw client id
*
* This interface is used to reset HW get FW client id.
*
* Return: firmware client id.
*/
int ishtp_get_fw_client_id(struct ishtp_fw_client *fw_client)
{
return fw_client->client_id;
}
EXPORT_SYMBOL(ishtp_get_fw_client_id);
/**
* ishtp_fw_cl_by_id() - return index to fw_clients for client_id
* @dev: the ishtp device structure
* @client_id: fw client id to search
*
* Search firmware client using client id.
*
* Return: index on success, -ENOENT on failure.
*/
int ishtp_fw_cl_by_id(struct ishtp_device *dev, uint8_t client_id)
{
int i, res = -ENOENT;
unsigned long flags;
spin_lock_irqsave(&dev->fw_clients_lock, flags);
for (i = 0; i < dev->fw_clients_num; i++) {
if (dev->fw_clients[i].client_id == client_id) {
res = i;
break;
}
}
spin_unlock_irqrestore(&dev->fw_clients_lock, flags);
return res;
}
/**
* ishtp_cl_device_probe() - Bus probe() callback
* @dev: the device structure
*
* This is a bus probe callback and calls the drive probe function.
*
* Return: Return value from driver probe() call.
*/
static int ishtp_cl_device_probe(struct device *dev)
{
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver;
if (!device)
return 0;
driver = to_ishtp_cl_driver(dev->driver);
if (!driver || !driver->probe)
return -ENODEV;
return driver->probe(device);
}
/**
* ishtp_cl_bus_match() - Bus match() callback
* @dev: the device structure
* @drv: the driver structure
*
* This is a bus match callback, called when a new ishtp_cl_device is
* registered during ishtp bus client enumeration. Use the guid_t in
* drv and dev to decide whether they match or not.
*
* Return: 1 if dev & drv matches, 0 otherwise.
*/
static int ishtp_cl_bus_match(struct device *dev, struct device_driver *drv)
{
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv);
return guid_equal(driver->guid,
&device->fw_client->props.protocol_name);
}
/**
* ishtp_cl_device_remove() - Bus remove() callback
* @dev: the device structure
*
* This is a bus remove callback and calls the drive remove function.
* Since the ISH driver model supports only built in, this is
* primarily can be called during pci driver init failure.
*
* Return: Return value from driver remove() call.
*/
static int ishtp_cl_device_remove(struct device *dev)
{
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver;
if (!device || !dev->driver)
return 0;
if (device->event_cb) {
device->event_cb = NULL;
cancel_work_sync(&device->event_work);
}
driver = to_ishtp_cl_driver(dev->driver);
if (!driver->remove) {
dev->driver = NULL;
return 0;
}
return driver->remove(device);
}
/**
* ishtp_cl_device_suspend() - Bus suspend callback
* @dev: device
*
* Called during device suspend process.
*
* Return: Return value from driver suspend() call.
*/
static int ishtp_cl_device_suspend(struct device *dev)
{
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver;
int ret = 0;
if (!device)
return 0;
driver = to_ishtp_cl_driver(dev->driver);
if (driver && driver->driver.pm) {
if (driver->driver.pm->suspend)
ret = driver->driver.pm->suspend(dev);
}
return ret;
}
/**
* ishtp_cl_device_resume() - Bus resume callback
* @dev: device
*
* Called during device resume process.
*
* Return: Return value from driver resume() call.
*/
static int ishtp_cl_device_resume(struct device *dev)
{
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver;
int ret = 0;
if (!device)
return 0;
/*
* When ISH needs hard reset, it is done asynchrnously, hence bus
* resume will be called before full ISH resume
*/
if (device->ishtp_dev->resume_flag)
return 0;
driver = to_ishtp_cl_driver(dev->driver);
if (driver && driver->driver.pm) {
if (driver->driver.pm->resume)
ret = driver->driver.pm->resume(dev);
}
return ret;
}
/**
* ishtp_cl_device_reset() - Reset callback
* @device: ishtp client device instance
*
* This is a callback when HW reset is done and the device need
* reinit.
*
* Return: Return value from driver reset() call.
*/
static int ishtp_cl_device_reset(struct ishtp_cl_device *device)
{
struct ishtp_cl_driver *driver;
int ret = 0;
device->event_cb = NULL;
cancel_work_sync(&device->event_work);
driver = to_ishtp_cl_driver(device->dev.driver);
if (driver && driver->reset)
ret = driver->reset(device);
return ret;
}
static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
char *buf)
{
int len;
len = snprintf(buf, PAGE_SIZE, "ishtp:%s\n", dev_name(dev));
return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
}
static DEVICE_ATTR_RO(modalias);
static struct attribute *ishtp_cl_dev_attrs[] = {
&dev_attr_modalias.attr,
NULL,
};
ATTRIBUTE_GROUPS(ishtp_cl_dev);
static int ishtp_cl_uevent(struct device *dev, struct kobj_uevent_env *env)
{
if (add_uevent_var(env, "MODALIAS=ishtp:%s", dev_name(dev)))
return -ENOMEM;
return 0;
}
static const struct dev_pm_ops ishtp_cl_bus_dev_pm_ops = {
/* Suspend callbacks */
.suspend = ishtp_cl_device_suspend,
.resume = ishtp_cl_device_resume,
/* Hibernate callbacks */
.freeze = ishtp_cl_device_suspend,
.thaw = ishtp_cl_device_resume,
.restore = ishtp_cl_device_resume,
};
static struct bus_type ishtp_cl_bus_type = {
.name = "ishtp",
.dev_groups = ishtp_cl_dev_groups,
.probe = ishtp_cl_device_probe,
.match = ishtp_cl_bus_match,
.remove = ishtp_cl_device_remove,
.pm = &ishtp_cl_bus_dev_pm_ops,
.uevent = ishtp_cl_uevent,
};
static void ishtp_cl_dev_release(struct device *dev)
{
kfree(to_ishtp_cl_device(dev));
}
static const struct device_type ishtp_cl_device_type = {
.release = ishtp_cl_dev_release,
};
/**
* ishtp_bus_add_device() - Function to create device on bus
* @dev: ishtp device
* @uuid: uuid of the client
* @name: Name of the client
*
* Allocate ISHTP bus client device, attach it to uuid
* and register with ISHTP bus.
*
* Return: ishtp_cl_device pointer or NULL on failure
*/
static struct ishtp_cl_device *ishtp_bus_add_device(struct ishtp_device *dev,
guid_t uuid, char *name)
{
struct ishtp_cl_device *device;
int status;
unsigned long flags;
spin_lock_irqsave(&dev->device_list_lock, flags);
list_for_each_entry(device, &dev->device_list, device_link) {
if (!strcmp(name, dev_name(&device->dev))) {
device->fw_client = &dev->fw_clients[
dev->fw_client_presentation_num - 1];
spin_unlock_irqrestore(&dev->device_list_lock, flags);
ishtp_cl_device_reset(device);
return device;
}
}
spin_unlock_irqrestore(&dev->device_list_lock, flags);
device = kzalloc(sizeof(struct ishtp_cl_device), GFP_KERNEL);
if (!device)
return NULL;
device->dev.parent = dev->devc;
device->dev.bus = &ishtp_cl_bus_type;
device->dev.type = &ishtp_cl_device_type;
device->ishtp_dev = dev;
device->fw_client =
&dev->fw_clients[dev->fw_client_presentation_num - 1];
dev_set_name(&device->dev, "%s", name);
spin_lock_irqsave(&dev->device_list_lock, flags);
list_add_tail(&device->device_link, &dev->device_list);
spin_unlock_irqrestore(&dev->device_list_lock, flags);
status = device_register(&device->dev);
if (status) {
spin_lock_irqsave(&dev->device_list_lock, flags);
list_del(&device->device_link);
spin_unlock_irqrestore(&dev->device_list_lock, flags);
dev_err(dev->devc, "Failed to register ISHTP client device\n");
put_device(&device->dev);
return NULL;
}
ishtp_device_ready = true;
return device;
}
/**
* ishtp_bus_remove_device() - Function to relase device on bus
* @device: client device instance
*
* This is a counterpart of ishtp_bus_add_device.
* Device is unregistered.
* the device structure is freed in 'ishtp_cl_dev_release' function
* Called only during error in pci driver init path.
*/
static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
{
device_unregister(&device->dev);
}
/**
* ishtp_cl_driver_register() - Client driver register
* @driver: the client driver instance
* @owner: Owner of this driver module
*
* Once a client driver is probed, it created a client
* instance and registers with the bus.
*
* Return: Return value of driver_register or -ENODEV if not ready
*/
int ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
struct module *owner)
{
int err;
if (!ishtp_device_ready)
return -ENODEV;
driver->driver.name = driver->name;
driver->driver.owner = owner;
driver->driver.bus = &ishtp_cl_bus_type;
err = driver_register(&driver->driver);
if (err)
return err;
return 0;
}
EXPORT_SYMBOL(ishtp_cl_driver_register);
/**
* ishtp_cl_driver_unregister() - Client driver unregister
* @driver: the client driver instance
*
* Unregister client during device removal process.
*/
void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver)
{
driver_unregister(&driver->driver);
}
EXPORT_SYMBOL(ishtp_cl_driver_unregister);
/**
* ishtp_bus_event_work() - event work function
* @work: work struct pointer
*
* Once an event is received for a client this work
* function is called. If the device has registered a
* callback then the callback is called.
*/
static void ishtp_bus_event_work(struct work_struct *work)
{
struct ishtp_cl_device *device;
device = container_of(work, struct ishtp_cl_device, event_work);
if (device->event_cb)
device->event_cb(device);
}
/**
* ishtp_cl_bus_rx_event() - schedule event work
* @device: client device instance
*
* Once an event is received for a client this schedules
* a work function to process.
*/
void ishtp_cl_bus_rx_event(struct ishtp_cl_device *device)
{
if (!device || !device->event_cb)
return;
if (device->event_cb)
schedule_work(&device->event_work);
}
/**
* ishtp_register_event_cb() - Register callback
* @device: client device instance
* @event_cb: Event processor for an client
*
* Register a callback for events, called from client driver
*
* Return: Return 0 or -EALREADY if already registered
*/
int ishtp_register_event_cb(struct ishtp_cl_device *device,
void (*event_cb)(struct ishtp_cl_device *))
{
if (device->event_cb)
return -EALREADY;
device->event_cb = event_cb;
INIT_WORK(&device->event_work, ishtp_bus_event_work);
return 0;
}
EXPORT_SYMBOL(ishtp_register_event_cb);
/**
* ishtp_get_device() - update usage count for the device
* @cl_device: client device instance
*
* Increment the usage count. The device can't be deleted
*/
void ishtp_get_device(struct ishtp_cl_device *cl_device)
{
cl_device->reference_count++;
}
EXPORT_SYMBOL(ishtp_get_device);
/**
* ishtp_put_device() - decrement usage count for the device
* @cl_device: client device instance
*
* Decrement the usage count. The device can be deleted is count = 0
*/
void ishtp_put_device(struct ishtp_cl_device *cl_device)
{
cl_device->reference_count--;
}
EXPORT_SYMBOL(ishtp_put_device);
/**
* ishtp_set_drvdata() - set client driver data
* @cl_device: client device instance
* @data: driver data need to be set
*
* Set client driver data to cl_device->driver_data.
*/
void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data)
{
cl_device->driver_data = data;
}
EXPORT_SYMBOL(ishtp_set_drvdata);
/**
* ishtp_get_drvdata() - get client driver data
* @cl_device: client device instance
*
* Get client driver data from cl_device->driver_data.
*
* Return: pointer of driver data
*/
void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device)
{
return cl_device->driver_data;
}
EXPORT_SYMBOL(ishtp_get_drvdata);
/**
* ishtp_dev_to_cl_device() - get ishtp_cl_device instance from device instance
* @device: device instance
*
* Get ish_cl_device instance which embeds device instance in it.
*
* Return: pointer to ishtp_cl_device instance
*/
struct ishtp_cl_device *ishtp_dev_to_cl_device(struct device *device)
{
return to_ishtp_cl_device(device);
}
EXPORT_SYMBOL(ishtp_dev_to_cl_device);
/**
* ishtp_bus_new_client() - Create a new client
* @dev: ISHTP device instance
*
* Once bus protocol enumerates a client, this is called
* to add a device for the client.
*
* Return: 0 on success or error code on failure
*/
int ishtp_bus_new_client(struct ishtp_device *dev)
{
int i;
char *dev_name;
struct ishtp_cl_device *cl_device;
guid_t device_uuid;
/*
* For all reported clients, create an unconnected client and add its
* device to ISHTP bus.
* If appropriate driver has loaded, this will trigger its probe().
* Otherwise, probe() will be called when driver is loaded
*/
i = dev->fw_client_presentation_num - 1;
device_uuid = dev->fw_clients[i].props.protocol_name;
dev_name = kasprintf(GFP_KERNEL, "{%pUL}", &device_uuid);
if (!dev_name)
return -ENOMEM;
cl_device = ishtp_bus_add_device(dev, device_uuid, dev_name);
if (!cl_device) {
kfree(dev_name);
return -ENOENT;
}
kfree(dev_name);
return 0;
}
/**
* ishtp_cl_device_bind() - bind a device
* @cl: ishtp client device
*
* Binds connected ishtp_cl to ISHTP bus device
*
* Return: 0 on success or fault code
*/
int ishtp_cl_device_bind(struct ishtp_cl *cl)
{
struct ishtp_cl_device *cl_device;
unsigned long flags;
int rv;
if (!cl->fw_client_id || cl->state != ISHTP_CL_CONNECTED)
return -EFAULT;
rv = -ENOENT;
spin_lock_irqsave(&cl->dev->device_list_lock, flags);
list_for_each_entry(cl_device, &cl->dev->device_list,
device_link) {
if (cl_device->fw_client &&
cl_device->fw_client->client_id == cl->fw_client_id) {
cl->device = cl_device;
rv = 0;
break;
}
}
spin_unlock_irqrestore(&cl->dev->device_list_lock, flags);
return rv;
}
/**
* ishtp_bus_remove_all_clients() - Remove all clients
* @ishtp_dev: ishtp device
* @warm_reset: Reset due to FW reset dure to errors or S3 suspend
*
* This is part of reset/remove flow. This function the main processing
* only targets error processing, if the FW has forced reset or
* error to remove connected clients. When warm reset the client devices are
* not removed.
*/
void ishtp_bus_remove_all_clients(struct ishtp_device *ishtp_dev,
bool warm_reset)
{
struct ishtp_cl_device *cl_device, *n;
struct ishtp_cl *cl;
unsigned long flags;
spin_lock_irqsave(&ishtp_dev->cl_list_lock, flags);
list_for_each_entry(cl, &ishtp_dev->cl_list, link) {
cl->state = ISHTP_CL_DISCONNECTED;
/*
* Wake any pending process. The waiter would check dev->state
* and determine that it's not enabled already,
* and will return error to its caller
*/
wake_up_interruptible(&cl->wait_ctrl_res);
/* Disband any pending read/write requests and free rb */
ishtp_cl_flush_queues(cl);
/* Remove all free and in_process rings, both Rx and Tx */
ishtp_cl_free_rx_ring(cl);
ishtp_cl_free_tx_ring(cl);
/*
* Free client and ISHTP bus client device structures
* don't free host client because it is part of the OS fd
* structure
*/
}
spin_unlock_irqrestore(&ishtp_dev->cl_list_lock, flags);
/* Release DMA buffers for client messages */
ishtp_cl_free_dma_buf(ishtp_dev);
/* remove bus clients */
spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
list_for_each_entry_safe(cl_device, n, &ishtp_dev->device_list,
device_link) {
cl_device->fw_client = NULL;
if (warm_reset && cl_device->reference_count)
continue;
list_del(&cl_device->device_link);
spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
ishtp_bus_remove_device(cl_device);
spin_lock_irqsave(&ishtp_dev->device_list_lock, flags);
}
spin_unlock_irqrestore(&ishtp_dev->device_list_lock, flags);
/* Free all client structures */
spin_lock_irqsave(&ishtp_dev->fw_clients_lock, flags);
kfree(ishtp_dev->fw_clients);
ishtp_dev->fw_clients = NULL;
ishtp_dev->fw_clients_num = 0;
ishtp_dev->fw_client_presentation_num = 0;
ishtp_dev->fw_client_index = 0;
bitmap_zero(ishtp_dev->fw_clients_map, ISHTP_CLIENTS_MAX);
spin_unlock_irqrestore(&ishtp_dev->fw_clients_lock, flags);
}
EXPORT_SYMBOL(ishtp_bus_remove_all_clients);
/**
* ishtp_reset_handler() - IPC reset handler
* @dev: ishtp device
*
* ISHTP Handler for IPC_RESET notification
*/
void ishtp_reset_handler(struct ishtp_device *dev)
{
unsigned long flags;
/* Handle FW-initiated reset */
dev->dev_state = ISHTP_DEV_RESETTING;
/* Clear BH processing queue - no further HBMs */
spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
dev->rd_msg_fifo_head = dev->rd_msg_fifo_tail = 0;
spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
/* Handle ISH FW reset against upper layers */
ishtp_bus_remove_all_clients(dev, true);
}
EXPORT_SYMBOL(ishtp_reset_handler);
/**
* ishtp_reset_compl_handler() - Reset completion handler
* @dev: ishtp device
*
* ISHTP handler for IPC_RESET sequence completion to start
* host message bus start protocol sequence.
*/
void ishtp_reset_compl_handler(struct ishtp_device *dev)
{
dev->dev_state = ISHTP_DEV_INIT_CLIENTS;
dev->hbm_state = ISHTP_HBM_START;
ishtp_hbm_start_req(dev);
}
EXPORT_SYMBOL(ishtp_reset_compl_handler);
/**
* ishtp_use_dma_transfer() - Function to use DMA
*
* This interface is used to enable usage of DMA
*
* Return non zero if DMA can be enabled
*/
int ishtp_use_dma_transfer(void)
{
return ishtp_use_dma;
}
/**
* ishtp_device() - Return device pointer
*
* This interface is used to return device pointer from ishtp_cl_device
* instance.
*
* Return: device *.
*/
struct device *ishtp_device(struct ishtp_cl_device *device)
{
return &device->dev;
}
EXPORT_SYMBOL(ishtp_device);
/**
* ishtp_get_pci_device() - Return PCI device dev pointer
* This interface is used to return PCI device pointer
* from ishtp_cl_device instance.
*
* Return: device *.
*/
struct device *ishtp_get_pci_device(struct ishtp_cl_device *device)
{
return device->ishtp_dev->devc;
}
EXPORT_SYMBOL(ishtp_get_pci_device);
/**
* ishtp_trace_callback() - Return trace callback
*
* This interface is used to return trace callback function pointer.
*
* Return: void *.
*/
void *ishtp_trace_callback(struct ishtp_cl_device *cl_device)
{
return cl_device->ishtp_dev->print_log;
}
EXPORT_SYMBOL(ishtp_trace_callback);
/**
* ish_hw_reset() - Call HW reset IPC callback
*
* This interface is used to reset HW in case of error.
*
* Return: value from IPC hw_reset callback
*/
int ish_hw_reset(struct ishtp_device *dev)
{
return dev->ops->hw_reset(dev);
}
EXPORT_SYMBOL(ish_hw_reset);
/**
* ishtp_bus_register() - Function to register bus
*
* This register ishtp bus
*
* Return: Return output of bus_register
*/
static int __init ishtp_bus_register(void)
{
return bus_register(&ishtp_cl_bus_type);
}
/**
* ishtp_bus_unregister() - Function to unregister bus
*
* This unregister ishtp bus
*/
static void __exit ishtp_bus_unregister(void)
{
bus_unregister(&ishtp_cl_bus_type);
}
module_init(ishtp_bus_register);
module_exit(ishtp_bus_unregister);
MODULE_LICENSE("GPL");