[deliverable/linux.git] / drivers / gpu / drm / drm_mipi_dsi.c

/*
 * MIPI DSI Bus
 *
 * Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd.
 * Andrzej Hajda <a.hajda@samsung.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <drm/drm_mipi_dsi.h>

#include <linux/device.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>

#include <video/mipi_display.h>

static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
{
	return of_driver_match_device(dev, drv);
}

static const struct dev_pm_ops mipi_dsi_device_pm_ops = {
	.runtime_suspend = pm_generic_runtime_suspend,
	.runtime_resume = pm_generic_runtime_resume,
	.suspend = pm_generic_suspend,
	.resume = pm_generic_resume,
	.freeze = pm_generic_freeze,
	.thaw = pm_generic_thaw,
	.poweroff = pm_generic_poweroff,
	.restore = pm_generic_restore,
};

static struct bus_type mipi_dsi_bus_type = {
	.name = "mipi-dsi",
	.match = mipi_dsi_device_match,
	.pm = &mipi_dsi_device_pm_ops,
};

static void mipi_dsi_dev_release(struct device *dev)
{
	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);

	of_node_put(dev->of_node);
	kfree(dsi);
}

static const struct device_type mipi_dsi_device_type = {
	.release = mipi_dsi_dev_release,
};

static struct mipi_dsi_device *mipi_dsi_device_alloc(struct mipi_dsi_host *host)
{
	struct mipi_dsi_device *dsi;

	dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
	if (!dsi)
		return ERR_PTR(-ENOMEM);

	dsi->host = host;
	dsi->dev.bus = &mipi_dsi_bus_type;
	dsi->dev.parent = host->dev;
	dsi->dev.type = &mipi_dsi_device_type;

	device_initialize(&dsi->dev);

	return dsi;
}

static int mipi_dsi_device_add(struct mipi_dsi_device *dsi)
{
	struct mipi_dsi_host *host = dsi->host;

	dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev),  dsi->channel);

	return device_add(&dsi->dev);
}

static struct mipi_dsi_device *
of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
{
	struct mipi_dsi_device *dsi;
	struct device *dev = host->dev;
	int ret;
	u32 reg;

	ret = of_property_read_u32(node, "reg", &reg);
	if (ret) {
		dev_err(dev, "device node %s has no valid reg property: %d\n",
			node->full_name, ret);
		return ERR_PTR(-EINVAL);
	}

	if (reg > 3) {
		dev_err(dev, "device node %s has invalid reg property: %u\n",
			node->full_name, reg);
		return ERR_PTR(-EINVAL);
	}

	dsi = mipi_dsi_device_alloc(host);
	if (IS_ERR(dsi)) {
		dev_err(dev, "failed to allocate DSI device %s: %ld\n",
			node->full_name, PTR_ERR(dsi));
		return dsi;
	}

	dsi->dev.of_node = of_node_get(node);
	dsi->channel = reg;

	ret = mipi_dsi_device_add(dsi);
	if (ret) {
		dev_err(dev, "failed to add DSI device %s: %d\n",
			node->full_name, ret);
		kfree(dsi);
		return ERR_PTR(ret);
	}

	return dsi;
}

int mipi_dsi_host_register(struct mipi_dsi_host *host)
{
	struct device_node *node;

	for_each_available_child_of_node(host->dev->of_node, node) {
		/* skip nodes without reg property */
		if (!of_find_property(node, "reg", NULL))
			continue;
		of_mipi_dsi_device_add(host, node);
	}

	return 0;
}
EXPORT_SYMBOL(mipi_dsi_host_register);

static int mipi_dsi_remove_device_fn(struct device *dev, void *priv)
{
	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);

	device_unregister(&dsi->dev);

	return 0;
}

void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
{
	device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
}
EXPORT_SYMBOL(mipi_dsi_host_unregister);

/**
 * mipi_dsi_attach - attach a DSI device to its DSI host
 * @dsi: DSI peripheral
 */
int mipi_dsi_attach(struct mipi_dsi_device *dsi)
{
	const struct mipi_dsi_host_ops *ops = dsi->host->ops;

	if (!ops || !ops->attach)
		return -ENOSYS;

	return ops->attach(dsi->host, dsi);
}
EXPORT_SYMBOL(mipi_dsi_attach);

/**
 * mipi_dsi_detach - detach a DSI device from its DSI host
 * @dsi: DSI peripheral
 */
int mipi_dsi_detach(struct mipi_dsi_device *dsi)
{
	const struct mipi_dsi_host_ops *ops = dsi->host->ops;

	if (!ops || !ops->detach)
		return -ENOSYS;

	return ops->detach(dsi->host, dsi);
}
EXPORT_SYMBOL(mipi_dsi_detach);

static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
					struct mipi_dsi_msg *msg)
{
	const struct mipi_dsi_host_ops *ops = dsi->host->ops;

	if (!ops || !ops->transfer)
		return -ENOSYS;

	if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
		msg->flags |= MIPI_DSI_MSG_USE_LPM;

	return ops->transfer(dsi->host, msg);
}

/**
 * mipi_dsi_packet_format_is_short - check if a packet is of the short format
 * @type: MIPI DSI data type of the packet
 *
 * Return: true if the packet for the given data type is a short packet, false
 * otherwise.
 */
bool mipi_dsi_packet_format_is_short(u8 type)
{
	switch (type) {
	case MIPI_DSI_V_SYNC_START:
	case MIPI_DSI_V_SYNC_END:
	case MIPI_DSI_H_SYNC_START:
	case MIPI_DSI_H_SYNC_END:
	case MIPI_DSI_END_OF_TRANSMISSION:
	case MIPI_DSI_COLOR_MODE_OFF:
	case MIPI_DSI_COLOR_MODE_ON:
	case MIPI_DSI_SHUTDOWN_PERIPHERAL:
	case MIPI_DSI_TURN_ON_PERIPHERAL:
	case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
	case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
	case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
	case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
	case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
	case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
	case MIPI_DSI_DCS_SHORT_WRITE:
	case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
	case MIPI_DSI_DCS_READ:
	case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
		return true;
	}

	return false;
}
EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);

/**
 * mipi_dsi_packet_format_is_long - check if a packet is of the long format
 * @type: MIPI DSI data type of the packet
 *
 * Return: true if the packet for the given data type is a long packet, false
 * otherwise.
 */
bool mipi_dsi_packet_format_is_long(u8 type)
{
	switch (type) {
	case MIPI_DSI_NULL_PACKET:
	case MIPI_DSI_BLANKING_PACKET:
	case MIPI_DSI_GENERIC_LONG_WRITE:
	case MIPI_DSI_DCS_LONG_WRITE:
	case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
	case MIPI_DSI_PACKED_PIXEL_STREAM_30:
	case MIPI_DSI_PACKED_PIXEL_STREAM_36:
	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
	case MIPI_DSI_PACKED_PIXEL_STREAM_16:
	case MIPI_DSI_PACKED_PIXEL_STREAM_18:
	case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
	case MIPI_DSI_PACKED_PIXEL_STREAM_24:
		return true;
	}

	return false;
}
EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);

/**
 * mipi_dsi_create_packet - create a packet from a message according to the
 *     DSI protocol
 * @packet: pointer to a DSI packet structure
 * @msg: message to translate into a packet
 *
 * Return: 0 on success or a negative error code on failure.
 */
int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
			   const struct mipi_dsi_msg *msg)
{
	const u8 *tx = msg->tx_buf;

	if (!packet || !msg)
		return -EINVAL;

	/* do some minimum sanity checking */
	if (!mipi_dsi_packet_format_is_short(msg->type) &&
	    !mipi_dsi_packet_format_is_long(msg->type))
		return -EINVAL;

	if (msg->channel > 3)
		return -EINVAL;

	memset(packet, 0, sizeof(*packet));
	packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f);

	/* TODO: compute ECC if hardware support is not available */

	/*
	 * Long write packets contain the word count in header bytes 1 and 2.
	 * The payload follows the header and is word count bytes long.
	 *
	 * Short write packets encode up to two parameters in header bytes 1
	 * and 2.
	 */
	if (mipi_dsi_packet_format_is_long(msg->type)) {
		packet->header[1] = (msg->tx_len >> 0) & 0xff;
		packet->header[2] = (msg->tx_len >> 8) & 0xff;

		packet->payload_length = msg->tx_len;
		packet->payload = tx;
	} else {
		packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
		packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
	}

	packet->size = sizeof(packet->header) + packet->payload_length;

	return 0;
}
EXPORT_SYMBOL(mipi_dsi_create_packet);

/**
 * mipi_dsi_dcs_write - send DCS write command
 * @dsi: DSI device
 * @data: pointer to the command followed by parameters
 * @len: length of @data
 */
ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, const void *data,
			    size_t len)
{
	struct mipi_dsi_msg msg = {
		.channel = dsi->channel,
		.tx_buf = data,
		.tx_len = len
	};

	switch (len) {
	case 0:
		return -EINVAL;
	case 1:
		msg.type = MIPI_DSI_DCS_SHORT_WRITE;
		break;
	case 2:
		msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
		break;
	default:
		msg.type = MIPI_DSI_DCS_LONG_WRITE;
		break;
	}

	return mipi_dsi_device_transfer(dsi, &msg);
}
EXPORT_SYMBOL(mipi_dsi_dcs_write);

/**
 * mipi_dsi_dcs_read - send DCS read request command
 * @dsi: DSI device
 * @cmd: DCS read command
 * @data: pointer to read buffer
 * @len: length of @data
 *
 * Function returns number of read bytes or error code.
 */
ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
			  size_t len)
{
	struct mipi_dsi_msg msg = {
		.channel = dsi->channel,
		.type = MIPI_DSI_DCS_READ,
		.tx_buf = &cmd,
		.tx_len = 1,
		.rx_buf = data,
		.rx_len = len
	};

	return mipi_dsi_device_transfer(dsi, &msg);
}
EXPORT_SYMBOL(mipi_dsi_dcs_read);

static int mipi_dsi_drv_probe(struct device *dev)
{
	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);

	return drv->probe(dsi);
}

static int mipi_dsi_drv_remove(struct device *dev)
{
	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);

	return drv->remove(dsi);
}

static void mipi_dsi_drv_shutdown(struct device *dev)
{
	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);

	drv->shutdown(dsi);
}

/**
 * mipi_dsi_driver_register - register a driver for DSI devices
 * @drv: DSI driver structure
 */
int mipi_dsi_driver_register(struct mipi_dsi_driver *drv)
{
	drv->driver.bus = &mipi_dsi_bus_type;
	if (drv->probe)
		drv->driver.probe = mipi_dsi_drv_probe;
	if (drv->remove)
		drv->driver.remove = mipi_dsi_drv_remove;
	if (drv->shutdown)
		drv->driver.shutdown = mipi_dsi_drv_shutdown;

	return driver_register(&drv->driver);
}
EXPORT_SYMBOL(mipi_dsi_driver_register);

/**
 * mipi_dsi_driver_unregister - unregister a driver for DSI devices
 * @drv: DSI driver structure
 */
void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
{
	driver_unregister(&drv->driver);
}
EXPORT_SYMBOL(mipi_dsi_driver_unregister);

static int __init mipi_dsi_bus_init(void)
{
	return bus_register(&mipi_dsi_bus_type);
}
postcore_initcall(mipi_dsi_bus_init);

MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
MODULE_DESCRIPTION("MIPI DSI Bus");
MODULE_LICENSE("GPL and additional rights");
Commit	Line	Data
068a0023 AH	1	/*
	2	* MIPI DSI Bus
	3	*
	4	* Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd.
	5	* Andrzej Hajda <a.hajda@samsung.com>
	6	*
	7	* Permission is hereby granted, free of charge, to any person obtaining a
	8	* copy of this software and associated documentation files (the
	9	* "Software"), to deal in the Software without restriction, including
	10	* without limitation the rights to use, copy, modify, merge, publish,
	11	* distribute, sub license, and/or sell copies of the Software, and to
	12	* permit persons to whom the Software is furnished to do so, subject to
	13	* the following conditions:
	14	*
	15	* The above copyright notice and this permission notice (including the
	16	* next paragraph) shall be included in all copies or substantial portions
	17	* of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
	22	* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
	23	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	24	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	25	* USE OR OTHER DEALINGS IN THE SOFTWARE.
	26	*/
	27
	28	#include <drm/drm_mipi_dsi.h>
	29
	30	#include <linux/device.h>
	31	#include <linux/module.h>
	32	#include <linux/of_device.h>
	33	#include <linux/pm_runtime.h>
	34	#include <linux/slab.h>
	35
	36	#include <video/mipi_display.h>
	37
	38	static int mipi_dsi_device_match(struct device dev, struct device_driver drv)
	39	{
	40	return of_driver_match_device(dev, drv);
	41	}
	42
	43	static const struct dev_pm_ops mipi_dsi_device_pm_ops = {
	44	.runtime_suspend = pm_generic_runtime_suspend,
	45	.runtime_resume = pm_generic_runtime_resume,
	46	.suspend = pm_generic_suspend,
	47	.resume = pm_generic_resume,
	48	.freeze = pm_generic_freeze,
	49	.thaw = pm_generic_thaw,
	50	.poweroff = pm_generic_poweroff,
	51	.restore = pm_generic_restore,
	52	};
	53
	54	static struct bus_type mipi_dsi_bus_type = {
	55	.name = "mipi-dsi",
	56	.match = mipi_dsi_device_match,
	57	.pm = &mipi_dsi_device_pm_ops,
	58	};
	59
	60	static void mipi_dsi_dev_release(struct device *dev)
	61	{
	62	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
	63
	64	of_node_put(dev->of_node);
65	kfree(dsi);
66	}
67
68	static const struct device_type mipi_dsi_device_type = {
69	.release = mipi_dsi_dev_release,
70	};
71
72	static struct mipi_dsi_device mipi_dsi_device_alloc(struct mipi_dsi_host host)
73	{
74	struct mipi_dsi_device *dsi;
75
76	dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
77	if (!dsi)
78	return ERR_PTR(-ENOMEM);
79
80	dsi->host = host;
81	dsi->dev.bus = &mipi_dsi_bus_type;
82	dsi->dev.parent = host->dev;
83	dsi->dev.type = &mipi_dsi_device_type;
84
85	device_initialize(&dsi->dev);
86
87	return dsi;
88	}
89
90	static int mipi_dsi_device_add(struct mipi_dsi_device *dsi)
91	{
92	struct mipi_dsi_host *host = dsi->host;
93
94	dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev), dsi->channel);
95
96	return device_add(&dsi->dev);
97	}
98
99	static struct mipi_dsi_device *
100	of_mipi_dsi_device_add(struct mipi_dsi_host host, struct device_node node)
101	{
102	struct mipi_dsi_device *dsi;
103	struct device *dev = host->dev;
104	int ret;
105	u32 reg;
106
107	ret = of_property_read_u32(node, "reg", &reg);
108	if (ret) {
109	dev_err(dev, "device node %s has no valid reg property: %d\n",
110	node->full_name, ret);
111	return ERR_PTR(-EINVAL);
112	}
113
114	if (reg > 3) {
115	dev_err(dev, "device node %s has invalid reg property: %u\n",
116	node->full_name, reg);
117	return ERR_PTR(-EINVAL);
118	}
119
120	dsi = mipi_dsi_device_alloc(host);
121	if (IS_ERR(dsi)) {
122	dev_err(dev, "failed to allocate DSI device %s: %ld\n",
123	node->full_name, PTR_ERR(dsi));
124	return dsi;
125	}
126
127	dsi->dev.of_node = of_node_get(node);
128	dsi->channel = reg;
129
130	ret = mipi_dsi_device_add(dsi);
131	if (ret) {
132	dev_err(dev, "failed to add DSI device %s: %d\n",
133	node->full_name, ret);
134	kfree(dsi);
135	return ERR_PTR(ret);
136	}
137
138	return dsi;
139	}
140
141	int mipi_dsi_host_register(struct mipi_dsi_host *host)
142	{
143	struct device_node *node;
144
e49640da AH	145	for_each_available_child_of_node(host->dev->of_node, node) {
	146	/* skip nodes without reg property */
	147	if (!of_find_property(node, "reg", NULL))
	148	continue;
068a0023	149	of_mipi_dsi_device_add(host, node);
e49640da	150	}
068a0023 AH	151
	152	return 0;
	153	}
	154	EXPORT_SYMBOL(mipi_dsi_host_register);
	155
	156	static int mipi_dsi_remove_device_fn(struct device dev, void priv)
	157	{
	158	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
	159
	160	device_unregister(&dsi->dev);
	161
	162	return 0;
	163	}
	164
	165	void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
	166	{
	167	device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
	168	}
	169	EXPORT_SYMBOL(mipi_dsi_host_unregister);
	170
	171	/**
	172	* mipi_dsi_attach - attach a DSI device to its DSI host
	173	* @dsi: DSI peripheral
	174	*/
	175	int mipi_dsi_attach(struct mipi_dsi_device *dsi)
	176	{
	177	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
	178
	179	if (!ops \|\| !ops->attach)
	180	return -ENOSYS;
	181
	182	return ops->attach(dsi->host, dsi);
	183	}
	184	EXPORT_SYMBOL(mipi_dsi_attach);
	185
	186	/**
	187	* mipi_dsi_detach - detach a DSI device from its DSI host
	188	* @dsi: DSI peripheral
	189	*/
	190	int mipi_dsi_detach(struct mipi_dsi_device *dsi)
	191	{
	192	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
	193
	194	if (!ops \|\| !ops->detach)
	195	return -ENOSYS;
	196
	197	return ops->detach(dsi->host, dsi);
	198	}
	199	EXPORT_SYMBOL(mipi_dsi_detach);
	200
9eb491f3 TR	201	static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
	202	struct mipi_dsi_msg *msg)
	203	{
	204	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
	205
	206	if (!ops \|\| !ops->transfer)
	207	return -ENOSYS;
	208
	209	if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
	210	msg->flags \|= MIPI_DSI_MSG_USE_LPM;
	211
	212	return ops->transfer(dsi->host, msg);
	213	}
	214
02acb76d TR	215	/**
	216	* mipi_dsi_packet_format_is_short - check if a packet is of the short format
	217	* @type: MIPI DSI data type of the packet
	218	*
	219	* Return: true if the packet for the given data type is a short packet, false
	220	* otherwise.
	221	*/
	222	bool mipi_dsi_packet_format_is_short(u8 type)
	223	{
	224	switch (type) {
	225	case MIPI_DSI_V_SYNC_START:
	226	case MIPI_DSI_V_SYNC_END:
	227	case MIPI_DSI_H_SYNC_START:
	228	case MIPI_DSI_H_SYNC_END:
	229	case MIPI_DSI_END_OF_TRANSMISSION:
	230	case MIPI_DSI_COLOR_MODE_OFF:
	231	case MIPI_DSI_COLOR_MODE_ON:
	232	case MIPI_DSI_SHUTDOWN_PERIPHERAL:
	233	case MIPI_DSI_TURN_ON_PERIPHERAL:
	234	case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
	235	case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
	236	case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
	237	case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
	238	case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
	239	case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
	240	case MIPI_DSI_DCS_SHORT_WRITE:
	241	case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
	242	case MIPI_DSI_DCS_READ:
	243	case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
	244	return true;
	245	}
	246
	247	return false;
	248	}
	249	EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);
	250
	251	/**
	252	* mipi_dsi_packet_format_is_long - check if a packet is of the long format
	253	* @type: MIPI DSI data type of the packet
	254	*
	255	* Return: true if the packet for the given data type is a long packet, false
	256	* otherwise.
	257	*/
	258	bool mipi_dsi_packet_format_is_long(u8 type)
	259	{
	260	switch (type) {
	261	case MIPI_DSI_NULL_PACKET:
	262	case MIPI_DSI_BLANKING_PACKET:
	263	case MIPI_DSI_GENERIC_LONG_WRITE:
	264	case MIPI_DSI_DCS_LONG_WRITE:
	265	case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
	266	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
	267	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
	268	case MIPI_DSI_PACKED_PIXEL_STREAM_30:
	269	case MIPI_DSI_PACKED_PIXEL_STREAM_36:
	270	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
	271	case MIPI_DSI_PACKED_PIXEL_STREAM_16:
	272	case MIPI_DSI_PACKED_PIXEL_STREAM_18:
	273	case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
	274	case MIPI_DSI_PACKED_PIXEL_STREAM_24:
	275	return true;
	276	}
	277
	278	return false;
279	}
280	EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);
281
a52879e8 TR	282	/**
	283	* mipi_dsi_create_packet - create a packet from a message according to the
	284	* DSI protocol
	285	* @packet: pointer to a DSI packet structure
	286	* @msg: message to translate into a packet
	287	*
	288	* Return: 0 on success or a negative error code on failure.
	289	*/
	290	int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
	291	const struct mipi_dsi_msg *msg)
	292	{
	293	const u8 *tx = msg->tx_buf;
	294
	295	if (!packet \|\| !msg)
	296	return -EINVAL;
	297
	298	/* do some minimum sanity checking */
	299	if (!mipi_dsi_packet_format_is_short(msg->type) &&
	300	!mipi_dsi_packet_format_is_long(msg->type))
	301	return -EINVAL;
	302
	303	if (msg->channel > 3)
	304	return -EINVAL;
	305
	306	memset(packet, 0, sizeof(*packet));
	307	packet->header[0] = ((msg->channel & 0x3) << 6) \| (msg->type & 0x3f);
	308
	309	/* TODO: compute ECC if hardware support is not available */
	310
	311	/*
	312	* Long write packets contain the word count in header bytes 1 and 2.
	313	* The payload follows the header and is word count bytes long.
	314	*
	315	* Short write packets encode up to two parameters in header bytes 1
	316	* and 2.
	317	*/
	318	if (mipi_dsi_packet_format_is_long(msg->type)) {
	319	packet->header[1] = (msg->tx_len >> 0) & 0xff;
	320	packet->header[2] = (msg->tx_len >> 8) & 0xff;
	321
	322	packet->payload_length = msg->tx_len;
	323	packet->payload = tx;
	324	} else {
	325	packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
	326	packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
	327	}
	328
	329	packet->size = sizeof(packet->header) + packet->payload_length;
	330
	331	return 0;
	332	}
	333	EXPORT_SYMBOL(mipi_dsi_create_packet);
	334
068a0023 AH	335	/**
	336	* mipi_dsi_dcs_write - send DCS write command
	337	* @dsi: DSI device
068a0023 AH	338	* @data: pointer to the command followed by parameters
	339	* @len: length of @data
	340	*/
3c523d7d TR	341	ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device dsi, const void data,
3c523d7d TR	342	size_t len)
068a0023	343	{
068a0023	344	struct mipi_dsi_msg msg = {
3c523d7d	345	.channel = dsi->channel,
068a0023 AH	346	.tx_buf = data,
	347	.tx_len = len
	348	};
	349
068a0023 AH	350	switch (len) {
	351	case 0:
	352	return -EINVAL;
	353	case 1:
	354	msg.type = MIPI_DSI_DCS_SHORT_WRITE;
	355	break;
	356	case 2:
	357	msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
	358	break;
	359	default:
	360	msg.type = MIPI_DSI_DCS_LONG_WRITE;
	361	break;
	362	}
	363
9eb491f3	364	return mipi_dsi_device_transfer(dsi, &msg);
068a0023 AH	365	}
	366	EXPORT_SYMBOL(mipi_dsi_dcs_write);
	367
	368	/**
	369	* mipi_dsi_dcs_read - send DCS read request command
	370	* @dsi: DSI device
068a0023 AH	371	* @cmd: DCS read command
	372	* @data: pointer to read buffer
	373	* @len: length of @data
	374	*
	375	* Function returns number of read bytes or error code.
	376	*/
3c523d7d TR	377	ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device dsi, u8 cmd, void data,
3c523d7d TR	378	size_t len)
068a0023	379	{
068a0023	380	struct mipi_dsi_msg msg = {
3c523d7d	381	.channel = dsi->channel,
068a0023 AH	382	.type = MIPI_DSI_DCS_READ,
	383	.tx_buf = &cmd,
	384	.tx_len = 1,
	385	.rx_buf = data,
	386	.rx_len = len
	387	};
	388
9eb491f3	389	return mipi_dsi_device_transfer(dsi, &msg);
068a0023 AH	390	}
	391	EXPORT_SYMBOL(mipi_dsi_dcs_read);
	392
	393	static int mipi_dsi_drv_probe(struct device *dev)
	394	{
	395	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
	396	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
	397
	398	return drv->probe(dsi);
	399	}
	400
	401	static int mipi_dsi_drv_remove(struct device *dev)
	402	{
	403	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
	404	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
	405
	406	return drv->remove(dsi);
	407	}
	408
d1621803 TR	409	static void mipi_dsi_drv_shutdown(struct device *dev)
	410	{
	411	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
	412	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
	413
	414	drv->shutdown(dsi);
	415	}
	416
068a0023 AH	417	/**
	418	* mipi_dsi_driver_register - register a driver for DSI devices
	419	* @drv: DSI driver structure
	420	*/
	421	int mipi_dsi_driver_register(struct mipi_dsi_driver *drv)
	422	{
	423	drv->driver.bus = &mipi_dsi_bus_type;
	424	if (drv->probe)
	425	drv->driver.probe = mipi_dsi_drv_probe;
	426	if (drv->remove)
	427	drv->driver.remove = mipi_dsi_drv_remove;
d1621803 TR	428	if (drv->shutdown)
d1621803 TR	429	drv->driver.shutdown = mipi_dsi_drv_shutdown;
068a0023 AH	430
	431	return driver_register(&drv->driver);
	432	}
	433	EXPORT_SYMBOL(mipi_dsi_driver_register);
	434
	435	/**
	436	* mipi_dsi_driver_unregister - unregister a driver for DSI devices
	437	* @drv: DSI driver structure
	438	*/
	439	void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
	440	{
	441	driver_unregister(&drv->driver);
	442	}
	443	EXPORT_SYMBOL(mipi_dsi_driver_unregister);
	444
	445	static int __init mipi_dsi_bus_init(void)
	446	{
	447	return bus_register(&mipi_dsi_bus_type);
	448	}
	449	postcore_initcall(mipi_dsi_bus_init);
	450
	451	MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
	452	MODULE_DESCRIPTION("MIPI DSI Bus");
	453	MODULE_LICENSE("GPL and additional rights");