[deliverable/linux.git] / include / linux / hsi / 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
 */
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__ */
Commit	Line	Data
a056ab8c CC	1	/*
	2	* HSI core header file.
	3	*
	4	* Copyright (C) 2010 Nokia Corporation. All rights reserved.
	5	*
	6	* Contact: Carlos Chinea <carlos.chinea@nokia.com>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* version 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	20	* 02110-1301 USA
	21	*/
	22
	23	#ifndef __LINUX_HSI_H__
	24	#define __LINUX_HSI_H__
	25
	26	#include <linux/device.h>
	27	#include <linux/mutex.h>
	28	#include <linux/scatterlist.h>
a056ab8c CC	29	#include <linux/list.h>
a056ab8c CC	30	#include <linux/module.h>
ec1c56ff	31	#include <linux/notifier.h>
a056ab8c CC	32
	33	/* HSI message ttype */
	34	#define HSI_MSG_READ 0
	35	#define HSI_MSG_WRITE 1
	36
	37	/* HSI configuration values */
	38	enum {
	39	HSI_MODE_STREAM = 1,
	40	HSI_MODE_FRAME,
	41	};
	42
	43	enum {
	44	HSI_FLOW_SYNC, /* Synchronized flow */
	45	HSI_FLOW_PIPE, /* Pipelined flow */
	46	};
	47
	48	enum {
	49	HSI_ARB_RR, /* Round-robin arbitration */
	50	HSI_ARB_PRIO, /* Channel priority arbitration */
	51	};
	52
	53	#define HSI_MAX_CHANNELS 16
	54
	55	/* HSI message status codes */
	56	enum {
	57	HSI_STATUS_COMPLETED, /* Message transfer is completed */
	58	HSI_STATUS_PENDING, /* Message pending to be read/write (POLL) */
	59	HSI_STATUS_PROCEEDING, /* Message transfer is ongoing */
	60	HSI_STATUS_QUEUED, /* Message waiting to be served */
	61	HSI_STATUS_ERROR, /* Error when message transfer was ongoing */
	62	};
	63
	64	/* HSI port event codes */
	65	enum {
	66	HSI_EVENT_START_RX,
	67	HSI_EVENT_STOP_RX,
	68	};
	69
a088cf16 SR	70	/**
	71	* struct hsi_channel - channel resource used by the hsi clients
	72	* @id: Channel number
	73	* @name: Channel name
	74	*/
	75	struct hsi_channel {
	76	unsigned int id;
	77	const char *name;
	78	};
	79
a056ab8c CC	80	/**
	81	* struct hsi_config - Configuration for RX/TX HSI modules
	82	* @mode: Bit transmission mode (STREAM or FRAME)
a088cf16 SR	83	* @channels: Channel resources used by the client
	84	* @num_channels: Number of channel resources
	85	* @num_hw_channels: Number of channels the transceiver is configured for [1..16]
a056ab8c CC	86	* @speed: Max bit transmission speed (Kbit/s)
	87	* @flow: RX flow type (SYNCHRONIZED or PIPELINE)
	88	* @arb_mode: Arbitration mode for TX frame (Round robin, priority)
	89	*/
	90	struct hsi_config {
a088cf16 SR	91	unsigned int mode;
	92	struct hsi_channel *channels;
	93	unsigned int num_channels;
	94	unsigned int num_hw_channels;
	95	unsigned int speed;
a056ab8c CC	96	union {
	97	unsigned int flow; /* RX only */
	98	unsigned int arb_mode; /* TX only */
	99	};
	100	};
	101
	102	/**
	103	* struct hsi_board_info - HSI client board info
	104	* @name: Name for the HSI device
	105	* @hsi_id: HSI controller id where the client sits
	106	* @port: Port number in the controller where the client sits
	107	* @tx_cfg: HSI TX configuration
	108	* @rx_cfg: HSI RX configuration
	109	* @platform_data: Platform related data
	110	* @archdata: Architecture-dependent device data
	111	*/
	112	struct hsi_board_info {
	113	const char *name;
	114	unsigned int hsi_id;
	115	unsigned int port;
	116	struct hsi_config tx_cfg;
	117	struct hsi_config rx_cfg;
	118	void *platform_data;
	119	struct dev_archdata *archdata;
	120	};
	121
	122	#ifdef CONFIG_HSI_BOARDINFO
	123	extern int hsi_register_board_info(struct hsi_board_info const *info,
	124	unsigned int len);
	125	#else
	126	static inline int hsi_register_board_info(struct hsi_board_info const *info,
	127	unsigned int len)
	128	{
	129	return 0;
	130	}
	131	#endif /* CONFIG_HSI_BOARDINFO */
	132
	133	/**
	134	* struct hsi_client - HSI client attached to an HSI port
	135	* @device: Driver model representation of the device
	136	* @tx_cfg: HSI TX configuration
	137	* @rx_cfg: HSI RX configuration
a056ab8c CC	138	*/
	139	struct hsi_client {
	140	struct device device;
	141	struct hsi_config tx_cfg;
	142	struct hsi_config rx_cfg;
a056ab8c	143	/* private: */
ec1c56ff	144	void (ehandler)(struct hsi_client , unsigned long);
a056ab8c	145	unsigned int pclaimed:1;
ec1c56ff	146	struct notifier_block nb;
a056ab8c CC	147	};
	148
	149	#define to_hsi_client(dev) container_of(dev, struct hsi_client, device)
	150
	151	static inline void hsi_client_set_drvdata(struct hsi_client cl, void data)
	152	{
	153	dev_set_drvdata(&cl->device, data);
	154	}
	155
	156	static inline void hsi_client_drvdata(struct hsi_client cl)
	157	{
	158	return dev_get_drvdata(&cl->device);
	159	}
	160
ec1c56ff CC	161	int hsi_register_port_event(struct hsi_client *cl,
	162	void (handler)(struct hsi_client , unsigned long));
	163	int hsi_unregister_port_event(struct hsi_client *cl);
	164
a056ab8c CC	165	/**
	166	* struct hsi_client_driver - Driver associated to an HSI client
	167	* @driver: Driver model representation of the driver
	168	*/
	169	struct hsi_client_driver {
	170	struct device_driver driver;
	171	};
	172
	173	#define to_hsi_client_driver(drv) container_of(drv, struct hsi_client_driver,\
	174	driver)
	175
	176	int hsi_register_client_driver(struct hsi_client_driver *drv);
	177
	178	static inline void hsi_unregister_client_driver(struct hsi_client_driver *drv)
	179	{
	180	driver_unregister(&drv->driver);
	181	}
	182
	183	/**
	184	* struct hsi_msg - HSI message descriptor
	185	* @link: Free to use by the current descriptor owner
	186	* @cl: HSI device client that issues the transfer
	187	* @sgt: Head of the scatterlist array
	188	* @context: Client context data associated to the transfer
	189	* @complete: Transfer completion callback
	190	* @destructor: Destructor to free resources when flushing
	191	* @status: Status of the transfer when completed
e227867f	192	* @actual_len: Actual length of data transferred on completion
a056ab8c CC	193	* @channel: Channel were to TX/RX the message
	194	* @ttype: Transfer type (TX if set, RX otherwise)
	195	* @break_frame: if true HSI will send/receive a break frame. Data buffers are
	196	* ignored in the request.
	197	*/
	198	struct hsi_msg {
	199	struct list_head link;
	200	struct hsi_client *cl;
	201	struct sg_table sgt;
	202	void *context;
	203
	204	void (complete)(struct hsi_msg msg);
	205	void (destructor)(struct hsi_msg msg);
	206
	207	int status;
	208	unsigned int actual_len;
	209	unsigned int channel;
	210	unsigned int ttype:1;
	211	unsigned int break_frame:1;
	212	};
	213
	214	struct hsi_msg *hsi_alloc_msg(unsigned int n_frag, gfp_t flags);
	215	void hsi_free_msg(struct hsi_msg *msg);
	216
	217	/**
	218	* struct hsi_port - HSI port device
	219	* @device: Driver model representation of the device
	220	* @tx_cfg: Current TX path configuration
	221	* @rx_cfg: Current RX path configuration
	222	* @num: Port number
	223	* @shared: Set when port can be shared by different clients
	224	* @claimed: Reference count of clients which claimed the port
	225	* @lock: Serialize port claim
	226	* @async: Asynchronous transfer callback
	227	* @setup: Callback to set the HSI client configuration
	228	* @flush: Callback to clean the HW state and destroy all pending transfers
	229	* @start_tx: Callback to inform that a client wants to TX data
	230	* @stop_tx: Callback to inform that a client no longer wishes to TX data
	231	* @release: Callback to inform that a client no longer uses the port
ec1c56ff	232	* @n_head: Notifier chain for signaling port events to the clients.
a056ab8c CC	233	*/
	234	struct hsi_port {
	235	struct device device;
	236	struct hsi_config tx_cfg;
	237	struct hsi_config rx_cfg;
	238	unsigned int num;
	239	unsigned int shared:1;
	240	int claimed;
	241	struct mutex lock;
	242	int (async)(struct hsi_msg msg);
	243	int (setup)(struct hsi_client cl);
	244	int (flush)(struct hsi_client cl);
	245	int (start_tx)(struct hsi_client cl);
	246	int (stop_tx)(struct hsi_client cl);
	247	int (release)(struct hsi_client cl);
ec1c56ff CC	248	/* private */
ec1c56ff CC	249	struct atomic_notifier_head n_head;
a056ab8c CC	250	};
	251
	252	#define to_hsi_port(dev) container_of(dev, struct hsi_port, device)
	253	#define hsi_get_port(cl) to_hsi_port((cl)->device.parent)
	254
ec1c56ff	255	int hsi_event(struct hsi_port *port, unsigned long event);
a056ab8c CC	256	int hsi_claim_port(struct hsi_client *cl, unsigned int share);
	257	void hsi_release_port(struct hsi_client *cl);
	258
	259	static inline int hsi_port_claimed(struct hsi_client *cl)
	260	{
	261	return cl->pclaimed;
	262	}
	263
	264	static inline void hsi_port_set_drvdata(struct hsi_port port, void data)
	265	{
	266	dev_set_drvdata(&port->device, data);
	267	}
	268
	269	static inline void hsi_port_drvdata(struct hsi_port port)
	270	{
	271	return dev_get_drvdata(&port->device);
	272	}
	273
	274	/**
	275	* struct hsi_controller - HSI controller device
	276	* @device: Driver model representation of the device
	277	* @owner: Pointer to the module owning the controller
	278	* @id: HSI controller ID
	279	* @num_ports: Number of ports in the HSI controller
	280	* @port: Array of HSI ports
	281	*/
	282	struct hsi_controller {
	283	struct device device;
	284	struct module *owner;
	285	unsigned int id;
	286	unsigned int num_ports;
5a218ceb	287	struct hsi_port **port;
a056ab8c CC	288	};
	289
	290	#define to_hsi_controller(dev) container_of(dev, struct hsi_controller, device)
	291
	292	struct hsi_controller *hsi_alloc_controller(unsigned int n_ports, gfp_t flags);
5a218ceb	293	void hsi_put_controller(struct hsi_controller *hsi);
a056ab8c CC	294	int hsi_register_controller(struct hsi_controller *hsi);
a056ab8c CC	295	void hsi_unregister_controller(struct hsi_controller *hsi);
84914510 SR	296	struct hsi_client hsi_new_client(struct hsi_port port,
	297	struct hsi_board_info *info);
	298	int hsi_remove_client(struct device dev, void data);
a0bf37ed	299	void hsi_port_unregister_clients(struct hsi_port *port);
a056ab8c	300
a2aa2473 SR	301	#ifdef CONFIG_OF
	302	void hsi_add_clients_from_dt(struct hsi_port *port,
	303	struct device_node *clients);
	304	#else
	305	static inline void hsi_add_clients_from_dt(struct hsi_port *port,
	306	struct device_node *clients)
	307	{
	308	return;
	309	}
	310	#endif
	311
a056ab8c CC	312	static inline void hsi_controller_set_drvdata(struct hsi_controller *hsi,
	313	void *data)
	314	{
	315	dev_set_drvdata(&hsi->device, data);
	316	}
	317
	318	static inline void hsi_controller_drvdata(struct hsi_controller hsi)
	319	{
	320	return dev_get_drvdata(&hsi->device);
	321	}
	322
	323	static inline struct hsi_port hsi_find_port_num(struct hsi_controller hsi,
	324	unsigned int num)
	325	{
5a218ceb	326	return (num < hsi->num_ports) ? hsi->port[num] : NULL;
a056ab8c CC	327	}
	328
	329	/*
	330	* API for HSI clients
	331	*/
	332	int hsi_async(struct hsi_client cl, struct hsi_msg msg);
	333
a088cf16 SR	334	int hsi_get_channel_id_by_name(struct hsi_client cl, char name);
a088cf16 SR	335
a056ab8c CC	336	/**
	337	* hsi_id - Get HSI controller ID associated to a client
	338	* @cl: Pointer to a HSI client
	339	*
	340	* Return the controller id where the client is attached to
	341	*/
	342	static inline unsigned int hsi_id(struct hsi_client *cl)
	343	{
	344	return to_hsi_controller(cl->device.parent->parent)->id;
	345	}
	346
	347	/**
	348	* hsi_port_id - Gets the port number a client is attached to
	349	* @cl: Pointer to HSI client
	350	*
	351	* Return the port number associated to the client
	352	*/
	353	static inline unsigned int hsi_port_id(struct hsi_client *cl)
	354	{
	355	return to_hsi_port(cl->device.parent)->num;
	356	}
	357
	358	/**
	359	* hsi_setup - Configure the client's port
	360	* @cl: Pointer to the HSI client
	361	*
	362	* When sharing ports, clients should either relay on a single
	363	* client setup or have the same setup for all of them.
	364	*
	365	* Return -errno on failure, 0 on success
	366	*/
	367	static inline int hsi_setup(struct hsi_client *cl)
	368	{
	369	if (!hsi_port_claimed(cl))
	370	return -EACCES;
	371	return hsi_get_port(cl)->setup(cl);
	372	}
	373
	374	/**
	375	* hsi_flush - Flush all pending transactions on the client's port
	376	* @cl: Pointer to the HSI client
	377	*
	378	* This function will destroy all pending hsi_msg in the port and reset
	379	* the HW port so it is ready to receive and transmit from a clean state.
	380	*
	381	* Return -errno on failure, 0 on success
	382	*/
	383	static inline int hsi_flush(struct hsi_client *cl)
	384	{
	385	if (!hsi_port_claimed(cl))
	386	return -EACCES;
	387	return hsi_get_port(cl)->flush(cl);
	388	}
	389
	390	/**
	391	* hsi_async_read - Submit a read transfer
	392	* @cl: Pointer to the HSI client
	393	* @msg: HSI message descriptor of the transfer
	394	*
	395	* Return -errno on failure, 0 on success
	396	*/
	397	static inline int hsi_async_read(struct hsi_client cl, struct hsi_msg msg)
	398	{
	399	msg->ttype = HSI_MSG_READ;
400	return hsi_async(cl, msg);
401	}
402
403	/**
404	* hsi_async_write - Submit a write transfer
405	* @cl: Pointer to the HSI client
406	* @msg: HSI message descriptor of the transfer
407	*
408	* Return -errno on failure, 0 on success
409	*/
410	static inline int hsi_async_write(struct hsi_client cl, struct hsi_msg msg)
411	{
412	msg->ttype = HSI_MSG_WRITE;
413	return hsi_async(cl, msg);
414	}
415
416	/**
417	* hsi_start_tx - Signal the port that the client wants to start a TX
418	* @cl: Pointer to the HSI client
419	*
420	* Return -errno on failure, 0 on success
421	*/
422	static inline int hsi_start_tx(struct hsi_client *cl)
423	{
424	if (!hsi_port_claimed(cl))
425	return -EACCES;
426	return hsi_get_port(cl)->start_tx(cl);
427	}
428
429	/**
430	* hsi_stop_tx - Signal the port that the client no longer wants to transmit
431	* @cl: Pointer to the HSI client
432	*
433	* Return -errno on failure, 0 on success
434	*/
435	static inline int hsi_stop_tx(struct hsi_client *cl)
436	{
437	if (!hsi_port_claimed(cl))
438	return -EACCES;
439	return hsi_get_port(cl)->stop_tx(cl);
440	}
441	#endif /* __LINUX_HSI_H__ */