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
38static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
39{
40	return of_driver_match_device(dev, drv);
41}
42
43static 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
54static 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
60static 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
68static const struct device_type mipi_dsi_device_type = {
69	.release = mipi_dsi_dev_release,
70};
71
72static 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
90static 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
99static struct mipi_dsi_device *
100of_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
141int mipi_dsi_host_register(struct mipi_dsi_host *host)
142{
143	struct device_node *node;
144
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;
149		of_mipi_dsi_device_add(host, node);
150	}
151
152	return 0;
153}
154EXPORT_SYMBOL(mipi_dsi_host_register);
155
156static 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
165void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
166{
167	device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
168}
169EXPORT_SYMBOL(mipi_dsi_host_unregister);
170
171/**
172 * mipi_dsi_attach - attach a DSI device to its DSI host
173 * @dsi: DSI peripheral
174 */
175int 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}
184EXPORT_SYMBOL(mipi_dsi_attach);
185
186/**
187 * mipi_dsi_detach - detach a DSI device from its DSI host
188 * @dsi: DSI peripheral
189 */
190int 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}
199EXPORT_SYMBOL(mipi_dsi_detach);
200
201/**
202 * mipi_dsi_dcs_write - send DCS write command
203 * @dsi: DSI device
204 * @data: pointer to the command followed by parameters
205 * @len: length of @data
206 */
207ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, const void *data,
208			    size_t len)
209{
210	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
211	struct mipi_dsi_msg msg = {
212		.channel = dsi->channel,
213		.tx_buf = data,
214		.tx_len = len
215	};
216
217	if (!ops || !ops->transfer)
218		return -ENOSYS;
219
220	switch (len) {
221	case 0:
222		return -EINVAL;
223	case 1:
224		msg.type = MIPI_DSI_DCS_SHORT_WRITE;
225		break;
226	case 2:
227		msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
228		break;
229	default:
230		msg.type = MIPI_DSI_DCS_LONG_WRITE;
231		break;
232	}
233
234	if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
235		msg.flags = MIPI_DSI_MSG_USE_LPM;
236
237	return ops->transfer(dsi->host, &msg);
238}
239EXPORT_SYMBOL(mipi_dsi_dcs_write);
240
241/**
242 * mipi_dsi_dcs_read - send DCS read request command
243 * @dsi: DSI device
244 * @cmd: DCS read command
245 * @data: pointer to read buffer
246 * @len: length of @data
247 *
248 * Function returns number of read bytes or error code.
249 */
250ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
251			  size_t len)
252{
253	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
254	struct mipi_dsi_msg msg = {
255		.channel = dsi->channel,
256		.type = MIPI_DSI_DCS_READ,
257		.tx_buf = &cmd,
258		.tx_len = 1,
259		.rx_buf = data,
260		.rx_len = len
261	};
262
263	if (!ops || !ops->transfer)
264		return -ENOSYS;
265
266	if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
267		msg.flags = MIPI_DSI_MSG_USE_LPM;
268
269	return ops->transfer(dsi->host, &msg);
270}
271EXPORT_SYMBOL(mipi_dsi_dcs_read);
272
273static int mipi_dsi_drv_probe(struct device *dev)
274{
275	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
276	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
277
278	return drv->probe(dsi);
279}
280
281static int mipi_dsi_drv_remove(struct device *dev)
282{
283	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
284	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
285
286	return drv->remove(dsi);
287}
288
289static void mipi_dsi_drv_shutdown(struct device *dev)
290{
291	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
292	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
293
294	drv->shutdown(dsi);
295}
296
297/**
298 * mipi_dsi_driver_register - register a driver for DSI devices
299 * @drv: DSI driver structure
300 */
301int mipi_dsi_driver_register(struct mipi_dsi_driver *drv)
302{
303	drv->driver.bus = &mipi_dsi_bus_type;
304	if (drv->probe)
305		drv->driver.probe = mipi_dsi_drv_probe;
306	if (drv->remove)
307		drv->driver.remove = mipi_dsi_drv_remove;
308	if (drv->shutdown)
309		drv->driver.shutdown = mipi_dsi_drv_shutdown;
310
311	return driver_register(&drv->driver);
312}
313EXPORT_SYMBOL(mipi_dsi_driver_register);
314
315/**
316 * mipi_dsi_driver_unregister - unregister a driver for DSI devices
317 * @drv: DSI driver structure
318 */
319void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
320{
321	driver_unregister(&drv->driver);
322}
323EXPORT_SYMBOL(mipi_dsi_driver_unregister);
324
325static int __init mipi_dsi_bus_init(void)
326{
327	return bus_register(&mipi_dsi_bus_type);
328}
329postcore_initcall(mipi_dsi_bus_init);
330
331MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
332MODULE_DESCRIPTION("MIPI DSI Bus");
333MODULE_LICENSE("GPL and additional rights");
334