include/linux/hsi/hsi.h - kernel/bruno - Git at Google

 /*
  * HSI core header file.
  *
  * Copyright (C) 2010 Nokia Corporation. All rights reserved.
  *
  * Contact: Carlos Chinea <carlos.chinea@nokia.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA
  */

 #ifndef __LINUX_HSI_H__
 #define __LINUX_HSI_H__

 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/scatterlist.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/notifier.h>

 /* HSI message ttype */
 #define HSI_MSG_READ	0
 #define HSI_MSG_WRITE	1

 /* HSI configuration values */
 enum {
 	HSI_MODE_STREAM	= 1,
 	HSI_MODE_FRAME,
 };

 enum {
 	HSI_FLOW_SYNC,	/* Synchronized flow */
 	HSI_FLOW_PIPE,	/* Pipelined flow */
 };

 enum {
 	HSI_ARB_RR,	/* Round-robin arbitration */
 	HSI_ARB_PRIO,	/* Channel priority arbitration */
 };

 #define HSI_MAX_CHANNELS	16

 /* HSI message status codes */
 enum {
 	HSI_STATUS_COMPLETED,	/* Message transfer is completed */
 	HSI_STATUS_PENDING,	/* Message pending to be read/write (POLL) */
 	HSI_STATUS_PROCEEDING,	/* Message transfer is ongoing */
 	HSI_STATUS_QUEUED,	/* Message waiting to be served */
 	HSI_STATUS_ERROR,	/* Error when message transfer was ongoing */
 };

 /* HSI port event codes */
 enum {
 	HSI_EVENT_START_RX,
 	HSI_EVENT_STOP_RX,
 };

 /**
  * struct hsi_channel - channel resource used by the hsi clients
  * @id: Channel number
  * @name: Channel name
  */
 struct hsi_channel {
 	unsigned int	id;
 	const char	*name;
 };

 /**
  * struct hsi_config - Configuration for RX/TX HSI modules
  * @mode: Bit transmission mode (STREAM or FRAME)
  * @channels: Channel resources used by the client
  * @num_channels: Number of channel resources
  * @num_hw_channels: Number of channels the transceiver is configured for [1..16]
  * @speed: Max bit transmission speed (Kbit/s)
  * @flow: RX flow type (SYNCHRONIZED or PIPELINE)
  * @arb_mode: Arbitration mode for TX frame (Round robin, priority)
  */
 struct hsi_config {
 	unsigned int		mode;
 	struct hsi_channel	*channels;
 	unsigned int		num_channels;
 	unsigned int		num_hw_channels;
 	unsigned int		speed;
 	union {
 		unsigned int	flow;		/* RX only */
 		unsigned int	arb_mode;	/* TX only */
 	};
 };

 /**
  * struct hsi_board_info - HSI client board info
  * @name: Name for the HSI device
  * @hsi_id: HSI controller id where the client sits
  * @port: Port number in the controller where the client sits
  * @tx_cfg: HSI TX configuration
  * @rx_cfg: HSI RX configuration
  * @platform_data: Platform related data
  * @archdata: Architecture-dependent device data
  */
 struct hsi_board_info {
 	const char		*name;
 	unsigned int		hsi_id;
 	unsigned int		port;
 	struct hsi_config	tx_cfg;
 	struct hsi_config	rx_cfg;
 	void			*platform_data;
 	struct dev_archdata	*archdata;
 };

 #ifdef CONFIG_HSI_BOARDINFO
 extern int hsi_register_board_info(struct hsi_board_info const *info,
 							unsigned int len);
 #else
 static inline int hsi_register_board_info(struct hsi_board_info const *info,
 							unsigned int len)
 {
 	return 0;
 }
 #endif /* CONFIG_HSI_BOARDINFO */

 /**
  * struct hsi_client - HSI client attached to an HSI port
  * @device: Driver model representation of the device
  * @tx_cfg: HSI TX configuration
  * @rx_cfg: HSI RX configuration
  * @e_handler: Callback for handling port events (RX Wake High/Low)
  * @pclaimed: Keeps tracks if the clients claimed its associated HSI port
  * @nb: Notifier block for port events
  */
 struct hsi_client {
 	struct device		device;
 	struct hsi_config	tx_cfg;
 	struct hsi_config	rx_cfg;
 	/* private: */
 	void			(*ehandler)(struct hsi_client *, unsigned long);
 	unsigned int		pclaimed:1;
 	struct notifier_block	nb;
 };

 #define to_hsi_client(dev) container_of(dev, struct hsi_client, device)

 static inline void hsi_client_set_drvdata(struct hsi_client *cl, void *data)
 {
 	dev_set_drvdata(&cl->device, data);
 }

 static inline void *hsi_client_drvdata(struct hsi_client *cl)
 {
 	return dev_get_drvdata(&cl->device);
 }

 int hsi_register_port_event(struct hsi_client *cl,
 			void (*handler)(struct hsi_client *, unsigned long));
 int hsi_unregister_port_event(struct hsi_client *cl);

 /**
  * struct hsi_client_driver - Driver associated to an HSI client
  * @driver: Driver model representation of the driver
  */
 struct hsi_client_driver {
 	struct device_driver	driver;
 };

 #define to_hsi_client_driver(drv) container_of(drv, struct hsi_client_driver,\
 									driver)

 int hsi_register_client_driver(struct hsi_client_driver *drv);

 static inline void hsi_unregister_client_driver(struct hsi_client_driver *drv)
 {
 	driver_unregister(&drv->driver);
 }

 /**
  * struct hsi_msg - HSI message descriptor
  * @link: Free to use by the current descriptor owner
  * @cl: HSI device client that issues the transfer
  * @sgt: Head of the scatterlist array
  * @context: Client context data associated to the transfer
  * @complete: Transfer completion callback
  * @destructor: Destructor to free resources when flushing
  * @status: Status of the transfer when completed
  * @actual_len: Actual length of data transferred on completion
  * @channel: Channel were to TX/RX the message
  * @ttype: Transfer type (TX if set, RX otherwise)
  * @break_frame: if true HSI will send/receive a break frame. Data buffers are
  *		ignored in the request.
  */
 struct hsi_msg {
 	struct list_head	link;
 	struct hsi_client	*cl;
 	struct sg_table		sgt;
 	void			*context;

 	void			(*complete)(struct hsi_msg *msg);
 	void			(*destructor)(struct hsi_msg *msg);

 	int			status;
 	unsigned int		actual_len;
 	unsigned int		channel;
 	unsigned int		ttype:1;
 	unsigned int		break_frame:1;
 };

 struct hsi_msg *hsi_alloc_msg(unsigned int n_frag, gfp_t flags);
 void hsi_free_msg(struct hsi_msg *msg);

 /**
  * struct hsi_port - HSI port device
  * @device: Driver model representation of the device
  * @tx_cfg: Current TX path configuration
  * @rx_cfg: Current RX path configuration
  * @num: Port number
  * @shared: Set when port can be shared by different clients
  * @claimed: Reference count of clients which claimed the port
  * @lock: Serialize port claim
  * @async: Asynchronous transfer callback
  * @setup: Callback to set the HSI client configuration
  * @flush: Callback to clean the HW state and destroy all pending transfers
  * @start_tx: Callback to inform that a client wants to TX data
  * @stop_tx: Callback to inform that a client no longer wishes to TX data
  * @release: Callback to inform that a client no longer uses the port
  * @n_head: Notifier chain for signaling port events to the clients.
  */
 struct hsi_port {
 	struct device			device;
 	struct hsi_config		tx_cfg;
 	struct hsi_config		rx_cfg;
 	unsigned int			num;
 	unsigned int			shared:1;
 	int				claimed;
 	struct mutex			lock;
 	int				(*async)(struct hsi_msg *msg);
 	int				(*setup)(struct hsi_client *cl);
 	int				(*flush)(struct hsi_client *cl);
 	int				(*start_tx)(struct hsi_client *cl);
 	int				(*stop_tx)(struct hsi_client *cl);
 	int				(*release)(struct hsi_client *cl);
 	/* private */
 	struct atomic_notifier_head	n_head;
 };

 #define to_hsi_port(dev) container_of(dev, struct hsi_port, device)
 #define hsi_get_port(cl) to_hsi_port((cl)->device.parent)

 int hsi_event(struct hsi_port *port, unsigned long event);
 int hsi_claim_port(struct hsi_client *cl, unsigned int share);
 void hsi_release_port(struct hsi_client *cl);

 static inline int hsi_port_claimed(struct hsi_client *cl)
 {
 	return cl->pclaimed;
 }

 static inline void hsi_port_set_drvdata(struct hsi_port *port, void *data)
 {
 	dev_set_drvdata(&port->device, data);
 }

 static inline void *hsi_port_drvdata(struct hsi_port *port)
 {
 	return dev_get_drvdata(&port->device);
 }

 /**
  * struct hsi_controller - HSI controller device
  * @device: Driver model representation of the device
  * @owner: Pointer to the module owning the controller
  * @id: HSI controller ID
  * @num_ports: Number of ports in the HSI controller
  * @port: Array of HSI ports
  */
 struct hsi_controller {
 	struct device		device;
 	struct module		*owner;
 	unsigned int		id;
 	unsigned int		num_ports;
 	struct hsi_port		**port;
 };

 #define to_hsi_controller(dev) container_of(dev, struct hsi_controller, device)

 struct hsi_controller *hsi_alloc_controller(unsigned int n_ports, gfp_t flags);
 void hsi_put_controller(struct hsi_controller *hsi);
 int hsi_register_controller(struct hsi_controller *hsi);
 void hsi_unregister_controller(struct hsi_controller *hsi);
 struct hsi_client *hsi_new_client(struct hsi_port *port,
 						struct hsi_board_info *info);
 int hsi_remove_client(struct device *dev, void *data);
 void hsi_port_unregister_clients(struct hsi_port *port);

 #ifdef CONFIG_OF
 void hsi_add_clients_from_dt(struct hsi_port *port,
 			     struct device_node *clients);
 #else
 static inline void hsi_add_clients_from_dt(struct hsi_port *port,
 					   struct device_node *clients)
 {
 	return;
 }
 #endif

 static inline void hsi_controller_set_drvdata(struct hsi_controller *hsi,
 								void *data)
 {
 	dev_set_drvdata(&hsi->device, data);
 }

 static inline void *hsi_controller_drvdata(struct hsi_controller *hsi)
 {
 	return dev_get_drvdata(&hsi->device);
 }

 static inline struct hsi_port *hsi_find_port_num(struct hsi_controller *hsi,
 							unsigned int num)
 {
 	return (num < hsi->num_ports) ? hsi->port[num] : NULL;
 }

 /*
  * API for HSI clients
  */
 int hsi_async(struct hsi_client *cl, struct hsi_msg *msg);

 int hsi_get_channel_id_by_name(struct hsi_client *cl, char *name);

 /**
  * hsi_id - Get HSI controller ID associated to a client
  * @cl: Pointer to a HSI client
  *
  * Return the controller id where the client is attached to
  */
 static inline unsigned int hsi_id(struct hsi_client *cl)
 {
 	return	to_hsi_controller(cl->device.parent->parent)->id;
 }

 /**
  * hsi_port_id - Gets the port number a client is attached to
  * @cl: Pointer to HSI client
  *
  * Return the port number associated to the client
  */
 static inline unsigned int hsi_port_id(struct hsi_client *cl)
 {
 	return	to_hsi_port(cl->device.parent)->num;
 }

 /**
  * hsi_setup - Configure the client's port
  * @cl: Pointer to the HSI client
  *
  * When sharing ports, clients should either relay on a single
  * client setup or have the same setup for all of them.
  *
  * Return -errno on failure, 0 on success
  */
 static inline int hsi_setup(struct hsi_client *cl)
 {
 	if (!hsi_port_claimed(cl))
 		return -EACCES;
 	return	hsi_get_port(cl)->setup(cl);
 }

 /**
  * hsi_flush - Flush all pending transactions on the client's port
  * @cl: Pointer to the HSI client
  *
  * This function will destroy all pending hsi_msg in the port and reset
  * the HW port so it is ready to receive and transmit from a clean state.
  *
  * Return -errno on failure, 0 on success
  */
 static inline int hsi_flush(struct hsi_client *cl)
 {
 	if (!hsi_port_claimed(cl))
 		return -EACCES;
 	return hsi_get_port(cl)->flush(cl);
 }

 /**
  * hsi_async_read - Submit a read transfer
  * @cl: Pointer to the HSI client
  * @msg: HSI message descriptor of the transfer
  *
  * Return -errno on failure, 0 on success
  */
 static inline int hsi_async_read(struct hsi_client *cl, struct hsi_msg *msg)
 {
 	msg->ttype = HSI_MSG_READ;
 	return hsi_async(cl, msg);
 }

 /**
  * hsi_async_write - Submit a write transfer
  * @cl: Pointer to the HSI client
  * @msg: HSI message descriptor of the transfer
  *
  * Return -errno on failure, 0 on success
  */
 static inline int hsi_async_write(struct hsi_client *cl, struct hsi_msg *msg)
 {
 	msg->ttype = HSI_MSG_WRITE;
 	return hsi_async(cl, msg);
 }

 /**
  * hsi_start_tx - Signal the port that the client wants to start a TX
  * @cl: Pointer to the HSI client
  *
  * Return -errno on failure, 0 on success
  */
 static inline int hsi_start_tx(struct hsi_client *cl)
 {
 	if (!hsi_port_claimed(cl))
 		return -EACCES;
 	return hsi_get_port(cl)->start_tx(cl);
 }

 /**
  * hsi_stop_tx - Signal the port that the client no longer wants to transmit
  * @cl: Pointer to the HSI client
  *
  * Return -errno on failure, 0 on success
  */
 static inline int hsi_stop_tx(struct hsi_client *cl)
 {
 	if (!hsi_port_claimed(cl))
 		return -EACCES;
 	return hsi_get_port(cl)->stop_tx(cl);
 }
 #endif /* __LINUX_HSI_H__ */
	/*
	* HSI core header file.
	*
	* Copyright (C) 2010 Nokia Corporation. All rights reserved.
	*
	* Contact: Carlos Chinea <carlos.chinea@nokia.com>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License
	* version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	* 02110-1301 USA
	*/

	#ifndef __LINUX_HSI_H__
	#define __LINUX_HSI_H__

	#include <linux/device.h>
	#include <linux/mutex.h>
	#include <linux/scatterlist.h>
	#include <linux/list.h>
	#include <linux/module.h>
	#include <linux/notifier.h>

	/* HSI message ttype */
	#define HSI_MSG_READ 0
	#define HSI_MSG_WRITE 1

	/* HSI configuration values */
	enum {
	HSI_MODE_STREAM = 1,
	HSI_MODE_FRAME,
	};

	enum {
	HSI_FLOW_SYNC, /* Synchronized flow */
	HSI_FLOW_PIPE, /* Pipelined flow */
	};

	enum {
	HSI_ARB_RR, /* Round-robin arbitration */
	HSI_ARB_PRIO, /* Channel priority arbitration */
	};

	#define HSI_MAX_CHANNELS 16

	/* HSI message status codes */
	enum {
	HSI_STATUS_COMPLETED, /* Message transfer is completed */
	HSI_STATUS_PENDING, /* Message pending to be read/write (POLL) */
	HSI_STATUS_PROCEEDING, /* Message transfer is ongoing */
	HSI_STATUS_QUEUED, /* Message waiting to be served */
	HSI_STATUS_ERROR, /* Error when message transfer was ongoing */
	};

	/* HSI port event codes */
	enum {
	HSI_EVENT_START_RX,
	HSI_EVENT_STOP_RX,
	};

	/**
	* struct hsi_channel - channel resource used by the hsi clients
	* @id: Channel number
	* @name: Channel name
	*/
	struct hsi_channel {
	unsigned int id;
	const char *name;
	};

	/**
	* struct hsi_config - Configuration for RX/TX HSI modules
	* @mode: Bit transmission mode (STREAM or FRAME)
	* @channels: Channel resources used by the client
	* @num_channels: Number of channel resources
	* @num_hw_channels: Number of channels the transceiver is configured for [1..16]
	* @speed: Max bit transmission speed (Kbit/s)
	* @flow: RX flow type (SYNCHRONIZED or PIPELINE)
	* @arb_mode: Arbitration mode for TX frame (Round robin, priority)
	*/
	struct hsi_config {
	unsigned int mode;
	struct hsi_channel *channels;
	unsigned int num_channels;
	unsigned int num_hw_channels;
	unsigned int speed;
	union {
	unsigned int flow; /* RX only */
	unsigned int arb_mode; /* TX only */
	};
	};

	/**
	* struct hsi_board_info - HSI client board info
	* @name: Name for the HSI device
	* @hsi_id: HSI controller id where the client sits
	* @port: Port number in the controller where the client sits
	* @tx_cfg: HSI TX configuration
	* @rx_cfg: HSI RX configuration
	* @platform_data: Platform related data
	* @archdata: Architecture-dependent device data
	*/
	struct hsi_board_info {
	const char *name;
	unsigned int hsi_id;
	unsigned int port;
	struct hsi_config tx_cfg;
	struct hsi_config rx_cfg;
	void *platform_data;
	struct dev_archdata *archdata;
	};

	#ifdef CONFIG_HSI_BOARDINFO
	extern int hsi_register_board_info(struct hsi_board_info const *info,
	unsigned int len);
	#else
	static inline int hsi_register_board_info(struct hsi_board_info const *info,
	unsigned int len)
	{
	return 0;
	}
	#endif /* CONFIG_HSI_BOARDINFO */

	/**
	* struct hsi_client - HSI client attached to an HSI port
	* @device: Driver model representation of the device
	* @tx_cfg: HSI TX configuration
	* @rx_cfg: HSI RX configuration
	* @e_handler: Callback for handling port events (RX Wake High/Low)
	* @pclaimed: Keeps tracks if the clients claimed its associated HSI port
	* @nb: Notifier block for port events
	*/
	struct hsi_client {
	struct device device;
	struct hsi_config tx_cfg;
	struct hsi_config rx_cfg;
	/* private: */
	void (ehandler)(struct hsi_client , unsigned long);
	unsigned int pclaimed:1;
	struct notifier_block nb;
	};

	#define to_hsi_client(dev) container_of(dev, struct hsi_client, device)

	static inline void hsi_client_set_drvdata(struct hsi_client cl, void data)
	{
	dev_set_drvdata(&cl->device, data);
	}

	static inline void hsi_client_drvdata(struct hsi_client cl)
	{
	return dev_get_drvdata(&cl->device);
	}

	int hsi_register_port_event(struct hsi_client *cl,
	void (handler)(struct hsi_client , unsigned long));
	int hsi_unregister_port_event(struct hsi_client *cl);

	/**
	* struct hsi_client_driver - Driver associated to an HSI client
	* @driver: Driver model representation of the driver
	*/
	struct hsi_client_driver {
	struct device_driver driver;
	};

	#define to_hsi_client_driver(drv) container_of(drv, struct hsi_client_driver,\
	driver)

	int hsi_register_client_driver(struct hsi_client_driver *drv);

	static inline void hsi_unregister_client_driver(struct hsi_client_driver *drv)
	{
	driver_unregister(&drv->driver);
	}

	/**
	* struct hsi_msg - HSI message descriptor
	* @link: Free to use by the current descriptor owner
	* @cl: HSI device client that issues the transfer
	* @sgt: Head of the scatterlist array
	* @context: Client context data associated to the transfer
	* @complete: Transfer completion callback
	* @destructor: Destructor to free resources when flushing
	* @status: Status of the transfer when completed
	* @actual_len: Actual length of data transferred on completion
	* @channel: Channel were to TX/RX the message
	* @ttype: Transfer type (TX if set, RX otherwise)
	* @break_frame: if true HSI will send/receive a break frame. Data buffers are
	* ignored in the request.
	*/
	struct hsi_msg {
	struct list_head link;
	struct hsi_client *cl;
	struct sg_table sgt;
	void *context;

	void (complete)(struct hsi_msg msg);
	void (destructor)(struct hsi_msg msg);

	int status;
	unsigned int actual_len;
	unsigned int channel;
	unsigned int ttype:1;
	unsigned int break_frame:1;
	};

	struct hsi_msg *hsi_alloc_msg(unsigned int n_frag, gfp_t flags);
	void hsi_free_msg(struct hsi_msg *msg);

	/**
	* struct hsi_port - HSI port device
	* @device: Driver model representation of the device
	* @tx_cfg: Current TX path configuration
	* @rx_cfg: Current RX path configuration
	* @num: Port number
	* @shared: Set when port can be shared by different clients
	* @claimed: Reference count of clients which claimed the port
	* @lock: Serialize port claim
	* @async: Asynchronous transfer callback
	* @setup: Callback to set the HSI client configuration
	* @flush: Callback to clean the HW state and destroy all pending transfers
	* @start_tx: Callback to inform that a client wants to TX data
	* @stop_tx: Callback to inform that a client no longer wishes to TX data
	* @release: Callback to inform that a client no longer uses the port
	* @n_head: Notifier chain for signaling port events to the clients.
	*/
	struct hsi_port {
	struct device device;
	struct hsi_config tx_cfg;
	struct hsi_config rx_cfg;
	unsigned int num;
	unsigned int shared:1;
	int claimed;
	struct mutex lock;
	int (async)(struct hsi_msg msg);
	int (setup)(struct hsi_client cl);
	int (flush)(struct hsi_client cl);
	int (start_tx)(struct hsi_client cl);
	int (stop_tx)(struct hsi_client cl);
	int (release)(struct hsi_client cl);
	/* private */
	struct atomic_notifier_head n_head;
	};

	#define to_hsi_port(dev) container_of(dev, struct hsi_port, device)
	#define hsi_get_port(cl) to_hsi_port((cl)->device.parent)

	int hsi_event(struct hsi_port *port, unsigned long event);
	int hsi_claim_port(struct hsi_client *cl, unsigned int share);
	void hsi_release_port(struct hsi_client *cl);

	static inline int hsi_port_claimed(struct hsi_client *cl)
	{
	return cl->pclaimed;
	}

	static inline void hsi_port_set_drvdata(struct hsi_port port, void data)
	{
	dev_set_drvdata(&port->device, data);
	}

	static inline void hsi_port_drvdata(struct hsi_port port)
	{
	return dev_get_drvdata(&port->device);
	}

	/**
	* struct hsi_controller - HSI controller device
	* @device: Driver model representation of the device
	* @owner: Pointer to the module owning the controller
	* @id: HSI controller ID
	* @num_ports: Number of ports in the HSI controller
	* @port: Array of HSI ports
	*/
	struct hsi_controller {
	struct device device;
	struct module *owner;
	unsigned int id;
	unsigned int num_ports;
	struct hsi_port **port;
	};

	#define to_hsi_controller(dev) container_of(dev, struct hsi_controller, device)

	struct hsi_controller *hsi_alloc_controller(unsigned int n_ports, gfp_t flags);
	void hsi_put_controller(struct hsi_controller *hsi);
	int hsi_register_controller(struct hsi_controller *hsi);
	void hsi_unregister_controller(struct hsi_controller *hsi);
	struct hsi_client hsi_new_client(struct hsi_port port,
	struct hsi_board_info *info);
	int hsi_remove_client(struct device dev, void data);
	void hsi_port_unregister_clients(struct hsi_port *port);

	#ifdef CONFIG_OF
	void hsi_add_clients_from_dt(struct hsi_port *port,
	struct device_node *clients);
	#else
	static inline void hsi_add_clients_from_dt(struct hsi_port *port,
	struct device_node *clients)
	{
	return;
	}
	#endif

	static inline void hsi_controller_set_drvdata(struct hsi_controller *hsi,
	void *data)
	{
	dev_set_drvdata(&hsi->device, data);
	}

	static inline void hsi_controller_drvdata(struct hsi_controller hsi)
	{
	return dev_get_drvdata(&hsi->device);
	}

	static inline struct hsi_port hsi_find_port_num(struct hsi_controller hsi,
	unsigned int num)
	{
	return (num < hsi->num_ports) ? hsi->port[num] : NULL;
	}

	/*
	* API for HSI clients
	*/
	int hsi_async(struct hsi_client cl, struct hsi_msg msg);

	int hsi_get_channel_id_by_name(struct hsi_client cl, char name);

	/**
	* hsi_id - Get HSI controller ID associated to a client
	* @cl: Pointer to a HSI client
	*
	* Return the controller id where the client is attached to
	*/
	static inline unsigned int hsi_id(struct hsi_client *cl)
	{
	return to_hsi_controller(cl->device.parent->parent)->id;
	}

	/**
	* hsi_port_id - Gets the port number a client is attached to
	* @cl: Pointer to HSI client
	*
	* Return the port number associated to the client
	*/
	static inline unsigned int hsi_port_id(struct hsi_client *cl)
	{
	return to_hsi_port(cl->device.parent)->num;
	}

	/**
	* hsi_setup - Configure the client's port
	* @cl: Pointer to the HSI client
	*
	* When sharing ports, clients should either relay on a single
	* client setup or have the same setup for all of them.
	*
	* Return -errno on failure, 0 on success
	*/
	static inline int hsi_setup(struct hsi_client *cl)
	{
	if (!hsi_port_claimed(cl))
	return -EACCES;
	return hsi_get_port(cl)->setup(cl);
	}

	/**
	* hsi_flush - Flush all pending transactions on the client's port
	* @cl: Pointer to the HSI client
	*
	* This function will destroy all pending hsi_msg in the port and reset
	* the HW port so it is ready to receive and transmit from a clean state.
	*
	* Return -errno on failure, 0 on success
	*/
	static inline int hsi_flush(struct hsi_client *cl)
	{
	if (!hsi_port_claimed(cl))
	return -EACCES;
	return hsi_get_port(cl)->flush(cl);
	}

	/**
	* hsi_async_read - Submit a read transfer
	* @cl: Pointer to the HSI client
	* @msg: HSI message descriptor of the transfer
	*
	* Return -errno on failure, 0 on success
	*/
	static inline int hsi_async_read(struct hsi_client cl, struct hsi_msg msg)
	{
	msg->ttype = HSI_MSG_READ;
	return hsi_async(cl, msg);
	}

	/**
	* hsi_async_write - Submit a write transfer
	* @cl: Pointer to the HSI client
	* @msg: HSI message descriptor of the transfer
	*
	* Return -errno on failure, 0 on success
	*/
	static inline int hsi_async_write(struct hsi_client cl, struct hsi_msg msg)
	{
	msg->ttype = HSI_MSG_WRITE;
	return hsi_async(cl, msg);
	}

	/**
	* hsi_start_tx - Signal the port that the client wants to start a TX
	* @cl: Pointer to the HSI client
	*
	* Return -errno on failure, 0 on success
	*/
	static inline int hsi_start_tx(struct hsi_client *cl)
	{
	if (!hsi_port_claimed(cl))
	return -EACCES;
	return hsi_get_port(cl)->start_tx(cl);
	}

	/**
	* hsi_stop_tx - Signal the port that the client no longer wants to transmit
	* @cl: Pointer to the HSI client
	*
	* Return -errno on failure, 0 on success
	*/
	static inline int hsi_stop_tx(struct hsi_client *cl)
	{
	if (!hsi_port_claimed(cl))
	return -EACCES;
	return hsi_get_port(cl)->stop_tx(cl);
	}
	#endif /* __LINUX_HSI_H__ */