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 <linux/device.h>
29 #include <linux/module.h>
30 #include <linux/of_device.h>
31 #include <linux/pm_runtime.h>
32 #include <linux/slab.h>
33 
34 #include <drm/display/drm_dsc.h>
35 #include <drm/drm_mipi_dsi.h>
36 #include <drm/drm_print.h>
37 
38 #include <video/mipi_display.h>
39 
40 /**
41  * DOC: dsi helpers
42  *
43  * These functions contain some common logic and helpers to deal with MIPI DSI
44  * peripherals.
45  *
46  * Helpers are provided for a number of standard MIPI DSI command as well as a
47  * subset of the MIPI DCS command set.
48  */
49 
mipi_dsi_device_match(struct device * dev,struct device_driver * drv)50 static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
51 {
52 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
53 
54 	/* attempt OF style match */
55 	if (of_driver_match_device(dev, drv))
56 		return 1;
57 
58 	/* compare DSI device and driver names */
59 	if (!strcmp(dsi->name, drv->name))
60 		return 1;
61 
62 	return 0;
63 }
64 
mipi_dsi_uevent(struct device * dev,struct kobj_uevent_env * env)65 static int mipi_dsi_uevent(struct device *dev, struct kobj_uevent_env *env)
66 {
67 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
68 	int err;
69 
70 	err = of_device_uevent_modalias(dev, env);
71 	if (err != -ENODEV)
72 		return err;
73 
74 	add_uevent_var(env, "MODALIAS=%s%s", MIPI_DSI_MODULE_PREFIX,
75 		       dsi->name);
76 
77 	return 0;
78 }
79 
80 static const struct dev_pm_ops mipi_dsi_device_pm_ops = {
81 	.runtime_suspend = pm_generic_runtime_suspend,
82 	.runtime_resume = pm_generic_runtime_resume,
83 	.suspend = pm_generic_suspend,
84 	.resume = pm_generic_resume,
85 	.freeze = pm_generic_freeze,
86 	.thaw = pm_generic_thaw,
87 	.poweroff = pm_generic_poweroff,
88 	.restore = pm_generic_restore,
89 };
90 
91 static struct bus_type mipi_dsi_bus_type = {
92 	.name = "mipi-dsi",
93 	.match = mipi_dsi_device_match,
94 	.uevent = mipi_dsi_uevent,
95 	.pm = &mipi_dsi_device_pm_ops,
96 };
97 
98 /**
99  * of_find_mipi_dsi_device_by_node() - find the MIPI DSI device matching a
100  *    device tree node
101  * @np: device tree node
102  *
103  * Return: A pointer to the MIPI DSI device corresponding to @np or NULL if no
104  *    such device exists (or has not been registered yet).
105  */
of_find_mipi_dsi_device_by_node(struct device_node * np)106 struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np)
107 {
108 	struct device *dev;
109 
110 	dev = bus_find_device_by_of_node(&mipi_dsi_bus_type, np);
111 
112 	return dev ? to_mipi_dsi_device(dev) : NULL;
113 }
114 EXPORT_SYMBOL(of_find_mipi_dsi_device_by_node);
115 
mipi_dsi_dev_release(struct device * dev)116 static void mipi_dsi_dev_release(struct device *dev)
117 {
118 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
119 
120 	of_node_put(dev->of_node);
121 	kfree(dsi);
122 }
123 
124 static const struct device_type mipi_dsi_device_type = {
125 	.release = mipi_dsi_dev_release,
126 };
127 
mipi_dsi_device_alloc(struct mipi_dsi_host * host)128 static struct mipi_dsi_device *mipi_dsi_device_alloc(struct mipi_dsi_host *host)
129 {
130 	struct mipi_dsi_device *dsi;
131 
132 	dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
133 	if (!dsi)
134 		return ERR_PTR(-ENOMEM);
135 
136 	dsi->host = host;
137 	dsi->dev.bus = &mipi_dsi_bus_type;
138 	dsi->dev.parent = host->dev;
139 	dsi->dev.type = &mipi_dsi_device_type;
140 
141 	device_initialize(&dsi->dev);
142 
143 	return dsi;
144 }
145 
mipi_dsi_device_add(struct mipi_dsi_device * dsi)146 static int mipi_dsi_device_add(struct mipi_dsi_device *dsi)
147 {
148 	struct mipi_dsi_host *host = dsi->host;
149 
150 	dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev),  dsi->channel);
151 
152 	return device_add(&dsi->dev);
153 }
154 
155 #if IS_ENABLED(CONFIG_OF)
156 static struct mipi_dsi_device *
of_mipi_dsi_device_add(struct mipi_dsi_host * host,struct device_node * node)157 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
158 {
159 	struct mipi_dsi_device_info info = { };
160 	int ret;
161 	u32 reg;
162 
163 	if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
164 		drm_err(host, "modalias failure on %pOF\n", node);
165 		return ERR_PTR(-EINVAL);
166 	}
167 
168 	ret = of_property_read_u32(node, "reg", &reg);
169 	if (ret) {
170 		drm_err(host, "device node %pOF has no valid reg property: %d\n",
171 			node, ret);
172 		return ERR_PTR(-EINVAL);
173 	}
174 
175 	info.channel = reg;
176 	info.node = of_node_get(node);
177 
178 	return mipi_dsi_device_register_full(host, &info);
179 }
180 #else
181 static struct mipi_dsi_device *
of_mipi_dsi_device_add(struct mipi_dsi_host * host,struct device_node * node)182 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
183 {
184 	return ERR_PTR(-ENODEV);
185 }
186 #endif
187 
188 /**
189  * mipi_dsi_device_register_full - create a MIPI DSI device
190  * @host: DSI host to which this device is connected
191  * @info: pointer to template containing DSI device information
192  *
193  * Create a MIPI DSI device by using the device information provided by
194  * mipi_dsi_device_info template
195  *
196  * Returns:
197  * A pointer to the newly created MIPI DSI device, or, a pointer encoded
198  * with an error
199  */
200 struct mipi_dsi_device *
mipi_dsi_device_register_full(struct mipi_dsi_host * host,const struct mipi_dsi_device_info * info)201 mipi_dsi_device_register_full(struct mipi_dsi_host *host,
202 			      const struct mipi_dsi_device_info *info)
203 {
204 	struct mipi_dsi_device *dsi;
205 	int ret;
206 
207 	if (!info) {
208 		drm_err(host, "invalid mipi_dsi_device_info pointer\n");
209 		return ERR_PTR(-EINVAL);
210 	}
211 
212 	if (info->channel > 3) {
213 		drm_err(host, "invalid virtual channel: %u\n", info->channel);
214 		return ERR_PTR(-EINVAL);
215 	}
216 
217 	dsi = mipi_dsi_device_alloc(host);
218 	if (IS_ERR(dsi)) {
219 		drm_err(host, "failed to allocate DSI device %ld\n",
220 			PTR_ERR(dsi));
221 		return dsi;
222 	}
223 
224 	dsi->dev.of_node = info->node;
225 	dsi->channel = info->channel;
226 	strlcpy(dsi->name, info->type, sizeof(dsi->name));
227 
228 	ret = mipi_dsi_device_add(dsi);
229 	if (ret) {
230 		drm_err(host, "failed to add DSI device %d\n", ret);
231 		kfree(dsi);
232 		return ERR_PTR(ret);
233 	}
234 
235 	return dsi;
236 }
237 EXPORT_SYMBOL(mipi_dsi_device_register_full);
238 
239 /**
240  * mipi_dsi_device_unregister - unregister MIPI DSI device
241  * @dsi: DSI peripheral device
242  */
mipi_dsi_device_unregister(struct mipi_dsi_device * dsi)243 void mipi_dsi_device_unregister(struct mipi_dsi_device *dsi)
244 {
245 	device_unregister(&dsi->dev);
246 }
247 EXPORT_SYMBOL(mipi_dsi_device_unregister);
248 
devm_mipi_dsi_device_unregister(void * arg)249 static void devm_mipi_dsi_device_unregister(void *arg)
250 {
251 	struct mipi_dsi_device *dsi = arg;
252 
253 	mipi_dsi_device_unregister(dsi);
254 }
255 
256 /**
257  * devm_mipi_dsi_device_register_full - create a managed MIPI DSI device
258  * @dev: device to tie the MIPI-DSI device lifetime to
259  * @host: DSI host to which this device is connected
260  * @info: pointer to template containing DSI device information
261  *
262  * Create a MIPI DSI device by using the device information provided by
263  * mipi_dsi_device_info template
264  *
265  * This is the managed version of mipi_dsi_device_register_full() which
266  * automatically calls mipi_dsi_device_unregister() when @dev is
267  * unbound.
268  *
269  * Returns:
270  * A pointer to the newly created MIPI DSI device, or, a pointer encoded
271  * with an error
272  */
273 struct mipi_dsi_device *
devm_mipi_dsi_device_register_full(struct device * dev,struct mipi_dsi_host * host,const struct mipi_dsi_device_info * info)274 devm_mipi_dsi_device_register_full(struct device *dev,
275 				   struct mipi_dsi_host *host,
276 				   const struct mipi_dsi_device_info *info)
277 {
278 	struct mipi_dsi_device *dsi;
279 	int ret;
280 
281 	dsi = mipi_dsi_device_register_full(host, info);
282 	if (IS_ERR(dsi))
283 		return dsi;
284 
285 	ret = devm_add_action_or_reset(dev,
286 				       devm_mipi_dsi_device_unregister,
287 				       dsi);
288 	if (ret)
289 		return ERR_PTR(ret);
290 
291 	return dsi;
292 }
293 EXPORT_SYMBOL_GPL(devm_mipi_dsi_device_register_full);
294 
295 static DEFINE_MUTEX(host_lock);
296 static LIST_HEAD(host_list);
297 
298 /**
299  * of_find_mipi_dsi_host_by_node() - find the MIPI DSI host matching a
300  *				     device tree node
301  * @node: device tree node
302  *
303  * Returns:
304  * A pointer to the MIPI DSI host corresponding to @node or NULL if no
305  * such device exists (or has not been registered yet).
306  */
of_find_mipi_dsi_host_by_node(struct device_node * node)307 struct mipi_dsi_host *of_find_mipi_dsi_host_by_node(struct device_node *node)
308 {
309 	struct mipi_dsi_host *host;
310 
311 	mutex_lock(&host_lock);
312 
313 	list_for_each_entry(host, &host_list, list) {
314 		if (host->dev->of_node == node) {
315 			mutex_unlock(&host_lock);
316 			return host;
317 		}
318 	}
319 
320 	mutex_unlock(&host_lock);
321 
322 	return NULL;
323 }
324 EXPORT_SYMBOL(of_find_mipi_dsi_host_by_node);
325 
mipi_dsi_host_register(struct mipi_dsi_host * host)326 int mipi_dsi_host_register(struct mipi_dsi_host *host)
327 {
328 	struct device_node *node;
329 
330 	for_each_available_child_of_node(host->dev->of_node, node) {
331 		/* skip nodes without reg property */
332 		if (!of_find_property(node, "reg", NULL))
333 			continue;
334 		of_mipi_dsi_device_add(host, node);
335 	}
336 
337 	mutex_lock(&host_lock);
338 	list_add_tail(&host->list, &host_list);
339 	mutex_unlock(&host_lock);
340 
341 	return 0;
342 }
343 EXPORT_SYMBOL(mipi_dsi_host_register);
344 
mipi_dsi_remove_device_fn(struct device * dev,void * priv)345 static int mipi_dsi_remove_device_fn(struct device *dev, void *priv)
346 {
347 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
348 
349 	mipi_dsi_detach(dsi);
350 	mipi_dsi_device_unregister(dsi);
351 
352 	return 0;
353 }
354 
mipi_dsi_host_unregister(struct mipi_dsi_host * host)355 void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
356 {
357 	device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
358 
359 	mutex_lock(&host_lock);
360 	list_del_init(&host->list);
361 	mutex_unlock(&host_lock);
362 }
363 EXPORT_SYMBOL(mipi_dsi_host_unregister);
364 
365 /**
366  * mipi_dsi_attach - attach a DSI device to its DSI host
367  * @dsi: DSI peripheral
368  */
mipi_dsi_attach(struct mipi_dsi_device * dsi)369 int mipi_dsi_attach(struct mipi_dsi_device *dsi)
370 {
371 	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
372 
373 	if (!ops || !ops->attach)
374 		return -ENOSYS;
375 
376 	return ops->attach(dsi->host, dsi);
377 }
378 EXPORT_SYMBOL(mipi_dsi_attach);
379 
380 /**
381  * mipi_dsi_detach - detach a DSI device from its DSI host
382  * @dsi: DSI peripheral
383  */
mipi_dsi_detach(struct mipi_dsi_device * dsi)384 int mipi_dsi_detach(struct mipi_dsi_device *dsi)
385 {
386 	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
387 
388 	if (!ops || !ops->detach)
389 		return -ENOSYS;
390 
391 	return ops->detach(dsi->host, dsi);
392 }
393 EXPORT_SYMBOL(mipi_dsi_detach);
394 
devm_mipi_dsi_detach(void * arg)395 static void devm_mipi_dsi_detach(void *arg)
396 {
397 	struct mipi_dsi_device *dsi = arg;
398 
399 	mipi_dsi_detach(dsi);
400 }
401 
402 /**
403  * devm_mipi_dsi_attach - Attach a MIPI-DSI device to its DSI Host
404  * @dev: device to tie the MIPI-DSI device attachment lifetime to
405  * @dsi: DSI peripheral
406  *
407  * This is the managed version of mipi_dsi_attach() which automatically
408  * calls mipi_dsi_detach() when @dev is unbound.
409  *
410  * Returns:
411  * 0 on success, a negative error code on failure.
412  */
devm_mipi_dsi_attach(struct device * dev,struct mipi_dsi_device * dsi)413 int devm_mipi_dsi_attach(struct device *dev,
414 			 struct mipi_dsi_device *dsi)
415 {
416 	int ret;
417 
418 	ret = mipi_dsi_attach(dsi);
419 	if (ret)
420 		return ret;
421 
422 	ret = devm_add_action_or_reset(dev, devm_mipi_dsi_detach, dsi);
423 	if (ret)
424 		return ret;
425 
426 	return 0;
427 }
428 EXPORT_SYMBOL_GPL(devm_mipi_dsi_attach);
429 
mipi_dsi_device_transfer(struct mipi_dsi_device * dsi,struct mipi_dsi_msg * msg)430 static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
431 					struct mipi_dsi_msg *msg)
432 {
433 	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
434 
435 	if (!ops || !ops->transfer)
436 		return -ENOSYS;
437 
438 	if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
439 		msg->flags |= MIPI_DSI_MSG_USE_LPM;
440 
441 	return ops->transfer(dsi->host, msg);
442 }
443 
444 /**
445  * mipi_dsi_packet_format_is_short - check if a packet is of the short format
446  * @type: MIPI DSI data type of the packet
447  *
448  * Return: true if the packet for the given data type is a short packet, false
449  * otherwise.
450  */
mipi_dsi_packet_format_is_short(u8 type)451 bool mipi_dsi_packet_format_is_short(u8 type)
452 {
453 	switch (type) {
454 	case MIPI_DSI_V_SYNC_START:
455 	case MIPI_DSI_V_SYNC_END:
456 	case MIPI_DSI_H_SYNC_START:
457 	case MIPI_DSI_H_SYNC_END:
458 	case MIPI_DSI_COMPRESSION_MODE:
459 	case MIPI_DSI_END_OF_TRANSMISSION:
460 	case MIPI_DSI_COLOR_MODE_OFF:
461 	case MIPI_DSI_COLOR_MODE_ON:
462 	case MIPI_DSI_SHUTDOWN_PERIPHERAL:
463 	case MIPI_DSI_TURN_ON_PERIPHERAL:
464 	case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
465 	case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
466 	case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
467 	case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
468 	case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
469 	case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
470 	case MIPI_DSI_DCS_SHORT_WRITE:
471 	case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
472 	case MIPI_DSI_DCS_READ:
473 	case MIPI_DSI_EXECUTE_QUEUE:
474 	case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
475 		return true;
476 	}
477 
478 	return false;
479 }
480 EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);
481 
482 /**
483  * mipi_dsi_packet_format_is_long - check if a packet is of the long format
484  * @type: MIPI DSI data type of the packet
485  *
486  * Return: true if the packet for the given data type is a long packet, false
487  * otherwise.
488  */
mipi_dsi_packet_format_is_long(u8 type)489 bool mipi_dsi_packet_format_is_long(u8 type)
490 {
491 	switch (type) {
492 	case MIPI_DSI_NULL_PACKET:
493 	case MIPI_DSI_BLANKING_PACKET:
494 	case MIPI_DSI_GENERIC_LONG_WRITE:
495 	case MIPI_DSI_DCS_LONG_WRITE:
496 	case MIPI_DSI_PICTURE_PARAMETER_SET:
497 	case MIPI_DSI_COMPRESSED_PIXEL_STREAM:
498 	case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
499 	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
500 	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
501 	case MIPI_DSI_PACKED_PIXEL_STREAM_30:
502 	case MIPI_DSI_PACKED_PIXEL_STREAM_36:
503 	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
504 	case MIPI_DSI_PACKED_PIXEL_STREAM_16:
505 	case MIPI_DSI_PACKED_PIXEL_STREAM_18:
506 	case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
507 	case MIPI_DSI_PACKED_PIXEL_STREAM_24:
508 		return true;
509 	}
510 
511 	return false;
512 }
513 EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);
514 
515 /**
516  * mipi_dsi_create_packet - create a packet from a message according to the
517  *     DSI protocol
518  * @packet: pointer to a DSI packet structure
519  * @msg: message to translate into a packet
520  *
521  * Return: 0 on success or a negative error code on failure.
522  */
mipi_dsi_create_packet(struct mipi_dsi_packet * packet,const struct mipi_dsi_msg * msg)523 int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
524 			   const struct mipi_dsi_msg *msg)
525 {
526 	if (!packet || !msg)
527 		return -EINVAL;
528 
529 	/* do some minimum sanity checking */
530 	if (!mipi_dsi_packet_format_is_short(msg->type) &&
531 	    !mipi_dsi_packet_format_is_long(msg->type))
532 		return -EINVAL;
533 
534 	if (msg->channel > 3)
535 		return -EINVAL;
536 
537 	memset(packet, 0, sizeof(*packet));
538 	packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f);
539 
540 	/* TODO: compute ECC if hardware support is not available */
541 
542 	/*
543 	 * Long write packets contain the word count in header bytes 1 and 2.
544 	 * The payload follows the header and is word count bytes long.
545 	 *
546 	 * Short write packets encode up to two parameters in header bytes 1
547 	 * and 2.
548 	 */
549 	if (mipi_dsi_packet_format_is_long(msg->type)) {
550 		packet->header[1] = (msg->tx_len >> 0) & 0xff;
551 		packet->header[2] = (msg->tx_len >> 8) & 0xff;
552 
553 		packet->payload_length = msg->tx_len;
554 		packet->payload = msg->tx_buf;
555 	} else {
556 		const u8 *tx = msg->tx_buf;
557 
558 		packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
559 		packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
560 	}
561 
562 	packet->size = sizeof(packet->header) + packet->payload_length;
563 
564 	return 0;
565 }
566 EXPORT_SYMBOL(mipi_dsi_create_packet);
567 
568 /**
569  * mipi_dsi_shutdown_peripheral() - sends a Shutdown Peripheral command
570  * @dsi: DSI peripheral device
571  *
572  * Return: 0 on success or a negative error code on failure.
573  */
mipi_dsi_shutdown_peripheral(struct mipi_dsi_device * dsi)574 int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi)
575 {
576 	struct mipi_dsi_msg msg = {
577 		.channel = dsi->channel,
578 		.type = MIPI_DSI_SHUTDOWN_PERIPHERAL,
579 		.tx_buf = (u8 [2]) { 0, 0 },
580 		.tx_len = 2,
581 	};
582 	int ret = mipi_dsi_device_transfer(dsi, &msg);
583 
584 	return (ret < 0) ? ret : 0;
585 }
586 EXPORT_SYMBOL(mipi_dsi_shutdown_peripheral);
587 
588 /**
589  * mipi_dsi_turn_on_peripheral() - sends a Turn On Peripheral command
590  * @dsi: DSI peripheral device
591  *
592  * Return: 0 on success or a negative error code on failure.
593  */
mipi_dsi_turn_on_peripheral(struct mipi_dsi_device * dsi)594 int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi)
595 {
596 	struct mipi_dsi_msg msg = {
597 		.channel = dsi->channel,
598 		.type = MIPI_DSI_TURN_ON_PERIPHERAL,
599 		.tx_buf = (u8 [2]) { 0, 0 },
600 		.tx_len = 2,
601 	};
602 	int ret = mipi_dsi_device_transfer(dsi, &msg);
603 
604 	return (ret < 0) ? ret : 0;
605 }
606 EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral);
607 
608 /*
609  * mipi_dsi_set_maximum_return_packet_size() - specify the maximum size of the
610  *    the payload in a long packet transmitted from the peripheral back to the
611  *    host processor
612  * @dsi: DSI peripheral device
613  * @value: the maximum size of the payload
614  *
615  * Return: 0 on success or a negative error code on failure.
616  */
mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device * dsi,u16 value)617 int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi,
618 					    u16 value)
619 {
620 	u8 tx[2] = { value & 0xff, value >> 8 };
621 	struct mipi_dsi_msg msg = {
622 		.channel = dsi->channel,
623 		.type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
624 		.tx_len = sizeof(tx),
625 		.tx_buf = tx,
626 	};
627 	int ret = mipi_dsi_device_transfer(dsi, &msg);
628 
629 	return (ret < 0) ? ret : 0;
630 }
631 EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size);
632 
633 /**
634  * mipi_dsi_compression_mode() - enable/disable DSC on the peripheral
635  * @dsi: DSI peripheral device
636  * @enable: Whether to enable or disable the DSC
637  *
638  * Enable or disable Display Stream Compression on the peripheral using the
639  * default Picture Parameter Set and VESA DSC 1.1 algorithm.
640  *
641  * Return: 0 on success or a negative error code on failure.
642  */
mipi_dsi_compression_mode(struct mipi_dsi_device * dsi,bool enable)643 ssize_t mipi_dsi_compression_mode(struct mipi_dsi_device *dsi, bool enable)
644 {
645 	/* Note: Needs updating for non-default PPS or algorithm */
646 	u8 tx[2] = { enable << 0, 0 };
647 	struct mipi_dsi_msg msg = {
648 		.channel = dsi->channel,
649 		.type = MIPI_DSI_COMPRESSION_MODE,
650 		.tx_len = sizeof(tx),
651 		.tx_buf = tx,
652 	};
653 	int ret = mipi_dsi_device_transfer(dsi, &msg);
654 
655 	return (ret < 0) ? ret : 0;
656 }
657 EXPORT_SYMBOL(mipi_dsi_compression_mode);
658 
659 /**
660  * mipi_dsi_picture_parameter_set() - transmit the DSC PPS to the peripheral
661  * @dsi: DSI peripheral device
662  * @pps: VESA DSC 1.1 Picture Parameter Set
663  *
664  * Transmit the VESA DSC 1.1 Picture Parameter Set to the peripheral.
665  *
666  * Return: 0 on success or a negative error code on failure.
667  */
mipi_dsi_picture_parameter_set(struct mipi_dsi_device * dsi,const struct drm_dsc_picture_parameter_set * pps)668 ssize_t mipi_dsi_picture_parameter_set(struct mipi_dsi_device *dsi,
669 				       const struct drm_dsc_picture_parameter_set *pps)
670 {
671 	struct mipi_dsi_msg msg = {
672 		.channel = dsi->channel,
673 		.type = MIPI_DSI_PICTURE_PARAMETER_SET,
674 		.tx_len = sizeof(*pps),
675 		.tx_buf = pps,
676 	};
677 	int ret = mipi_dsi_device_transfer(dsi, &msg);
678 
679 	return (ret < 0) ? ret : 0;
680 }
681 EXPORT_SYMBOL(mipi_dsi_picture_parameter_set);
682 
683 /**
684  * mipi_dsi_generic_write() - transmit data using a generic write packet
685  * @dsi: DSI peripheral device
686  * @payload: buffer containing the payload
687  * @size: size of payload buffer
688  *
689  * This function will automatically choose the right data type depending on
690  * the payload length.
691  *
692  * Return: The number of bytes transmitted on success or a negative error code
693  * on failure.
694  */
mipi_dsi_generic_write(struct mipi_dsi_device * dsi,const void * payload,size_t size)695 ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload,
696 			       size_t size)
697 {
698 	struct mipi_dsi_msg msg = {
699 		.channel = dsi->channel,
700 		.tx_buf = payload,
701 		.tx_len = size
702 	};
703 
704 	switch (size) {
705 	case 0:
706 		msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM;
707 		break;
708 
709 	case 1:
710 		msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM;
711 		break;
712 
713 	case 2:
714 		msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM;
715 		break;
716 
717 	default:
718 		msg.type = MIPI_DSI_GENERIC_LONG_WRITE;
719 		break;
720 	}
721 
722 	return mipi_dsi_device_transfer(dsi, &msg);
723 }
724 EXPORT_SYMBOL(mipi_dsi_generic_write);
725 
726 /**
727  * mipi_dsi_generic_read() - receive data using a generic read packet
728  * @dsi: DSI peripheral device
729  * @params: buffer containing the request parameters
730  * @num_params: number of request parameters
731  * @data: buffer in which to return the received data
732  * @size: size of receive buffer
733  *
734  * This function will automatically choose the right data type depending on
735  * the number of parameters passed in.
736  *
737  * Return: The number of bytes successfully read or a negative error code on
738  * failure.
739  */
mipi_dsi_generic_read(struct mipi_dsi_device * dsi,const void * params,size_t num_params,void * data,size_t size)740 ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params,
741 			      size_t num_params, void *data, size_t size)
742 {
743 	struct mipi_dsi_msg msg = {
744 		.channel = dsi->channel,
745 		.tx_len = num_params,
746 		.tx_buf = params,
747 		.rx_len = size,
748 		.rx_buf = data
749 	};
750 
751 	switch (num_params) {
752 	case 0:
753 		msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM;
754 		break;
755 
756 	case 1:
757 		msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM;
758 		break;
759 
760 	case 2:
761 		msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM;
762 		break;
763 
764 	default:
765 		return -EINVAL;
766 	}
767 
768 	return mipi_dsi_device_transfer(dsi, &msg);
769 }
770 EXPORT_SYMBOL(mipi_dsi_generic_read);
771 
772 /**
773  * mipi_dsi_dcs_write_buffer() - transmit a DCS command with payload
774  * @dsi: DSI peripheral device
775  * @data: buffer containing data to be transmitted
776  * @len: size of transmission buffer
777  *
778  * This function will automatically choose the right data type depending on
779  * the command payload length.
780  *
781  * Return: The number of bytes successfully transmitted or a negative error
782  * code on failure.
783  */
mipi_dsi_dcs_write_buffer(struct mipi_dsi_device * dsi,const void * data,size_t len)784 ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi,
785 				  const void *data, size_t len)
786 {
787 	struct mipi_dsi_msg msg = {
788 		.channel = dsi->channel,
789 		.tx_buf = data,
790 		.tx_len = len
791 	};
792 
793 	switch (len) {
794 	case 0:
795 		return -EINVAL;
796 
797 	case 1:
798 		msg.type = MIPI_DSI_DCS_SHORT_WRITE;
799 		break;
800 
801 	case 2:
802 		msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
803 		break;
804 
805 	default:
806 		msg.type = MIPI_DSI_DCS_LONG_WRITE;
807 		break;
808 	}
809 
810 	return mipi_dsi_device_transfer(dsi, &msg);
811 }
812 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer);
813 
814 /**
815  * mipi_dsi_dcs_write() - send DCS write command
816  * @dsi: DSI peripheral device
817  * @cmd: DCS command
818  * @data: buffer containing the command payload
819  * @len: command payload length
820  *
821  * This function will automatically choose the right data type depending on
822  * the command payload length.
823  *
824  * Return: The number of bytes successfully transmitted or a negative error
825  * code on failure.
826  */
mipi_dsi_dcs_write(struct mipi_dsi_device * dsi,u8 cmd,const void * data,size_t len)827 ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd,
828 			   const void *data, size_t len)
829 {
830 	ssize_t err;
831 	size_t size;
832 	u8 stack_tx[8];
833 	u8 *tx;
834 
835 	size = 1 + len;
836 	if (len > ARRAY_SIZE(stack_tx) - 1) {
837 		tx = kmalloc(size, GFP_KERNEL);
838 		if (!tx)
839 			return -ENOMEM;
840 	} else {
841 		tx = stack_tx;
842 	}
843 
844 	/* concatenate the DCS command byte and the payload */
845 	tx[0] = cmd;
846 	if (data)
847 		memcpy(&tx[1], data, len);
848 
849 	err = mipi_dsi_dcs_write_buffer(dsi, tx, size);
850 
851 	if (tx != stack_tx)
852 		kfree(tx);
853 
854 	return err;
855 }
856 EXPORT_SYMBOL(mipi_dsi_dcs_write);
857 
858 /**
859  * mipi_dsi_dcs_read() - send DCS read request command
860  * @dsi: DSI peripheral device
861  * @cmd: DCS command
862  * @data: buffer in which to receive data
863  * @len: size of receive buffer
864  *
865  * Return: The number of bytes read or a negative error code on failure.
866  */
mipi_dsi_dcs_read(struct mipi_dsi_device * dsi,u8 cmd,void * data,size_t len)867 ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
868 			  size_t len)
869 {
870 	struct mipi_dsi_msg msg = {
871 		.channel = dsi->channel,
872 		.type = MIPI_DSI_DCS_READ,
873 		.tx_buf = &cmd,
874 		.tx_len = 1,
875 		.rx_buf = data,
876 		.rx_len = len
877 	};
878 
879 	return mipi_dsi_device_transfer(dsi, &msg);
880 }
881 EXPORT_SYMBOL(mipi_dsi_dcs_read);
882 
883 /**
884  * mipi_dsi_dcs_nop() - send DCS nop packet
885  * @dsi: DSI peripheral device
886  *
887  * Return: 0 on success or a negative error code on failure.
888  */
mipi_dsi_dcs_nop(struct mipi_dsi_device * dsi)889 int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi)
890 {
891 	ssize_t err;
892 
893 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0);
894 	if (err < 0)
895 		return err;
896 
897 	return 0;
898 }
899 EXPORT_SYMBOL(mipi_dsi_dcs_nop);
900 
901 /**
902  * mipi_dsi_dcs_soft_reset() - perform a software reset of the display module
903  * @dsi: DSI peripheral device
904  *
905  * Return: 0 on success or a negative error code on failure.
906  */
mipi_dsi_dcs_soft_reset(struct mipi_dsi_device * dsi)907 int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi)
908 {
909 	ssize_t err;
910 
911 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
912 	if (err < 0)
913 		return err;
914 
915 	return 0;
916 }
917 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset);
918 
919 /**
920  * mipi_dsi_dcs_get_power_mode() - query the display module's current power
921  *    mode
922  * @dsi: DSI peripheral device
923  * @mode: return location for the current power mode
924  *
925  * Return: 0 on success or a negative error code on failure.
926  */
mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device * dsi,u8 * mode)927 int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode)
928 {
929 	ssize_t err;
930 
931 	err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode,
932 				sizeof(*mode));
933 	if (err <= 0) {
934 		if (err == 0)
935 			err = -ENODATA;
936 
937 		return err;
938 	}
939 
940 	return 0;
941 }
942 EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode);
943 
944 /**
945  * mipi_dsi_dcs_get_pixel_format() - gets the pixel format for the RGB image
946  *    data used by the interface
947  * @dsi: DSI peripheral device
948  * @format: return location for the pixel format
949  *
950  * Return: 0 on success or a negative error code on failure.
951  */
mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device * dsi,u8 * format)952 int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format)
953 {
954 	ssize_t err;
955 
956 	err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format,
957 				sizeof(*format));
958 	if (err <= 0) {
959 		if (err == 0)
960 			err = -ENODATA;
961 
962 		return err;
963 	}
964 
965 	return 0;
966 }
967 EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format);
968 
969 /**
970  * mipi_dsi_dcs_enter_sleep_mode() - disable all unnecessary blocks inside the
971  *    display module except interface communication
972  * @dsi: DSI peripheral device
973  *
974  * Return: 0 on success or a negative error code on failure.
975  */
mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device * dsi)976 int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi)
977 {
978 	ssize_t err;
979 
980 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0);
981 	if (err < 0)
982 		return err;
983 
984 	return 0;
985 }
986 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode);
987 
988 /**
989  * mipi_dsi_dcs_exit_sleep_mode() - enable all blocks inside the display
990  *    module
991  * @dsi: DSI peripheral device
992  *
993  * Return: 0 on success or a negative error code on failure.
994  */
mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device * dsi)995 int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi)
996 {
997 	ssize_t err;
998 
999 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0);
1000 	if (err < 0)
1001 		return err;
1002 
1003 	return 0;
1004 }
1005 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode);
1006 
1007 /**
1008  * mipi_dsi_dcs_set_display_off() - stop displaying the image data on the
1009  *    display device
1010  * @dsi: DSI peripheral device
1011  *
1012  * Return: 0 on success or a negative error code on failure.
1013  */
mipi_dsi_dcs_set_display_off(struct mipi_dsi_device * dsi)1014 int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi)
1015 {
1016 	ssize_t err;
1017 
1018 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0);
1019 	if (err < 0)
1020 		return err;
1021 
1022 	return 0;
1023 }
1024 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off);
1025 
1026 /**
1027  * mipi_dsi_dcs_set_display_on() - start displaying the image data on the
1028  *    display device
1029  * @dsi: DSI peripheral device
1030  *
1031  * Return: 0 on success or a negative error code on failure
1032  */
mipi_dsi_dcs_set_display_on(struct mipi_dsi_device * dsi)1033 int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi)
1034 {
1035 	ssize_t err;
1036 
1037 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0);
1038 	if (err < 0)
1039 		return err;
1040 
1041 	return 0;
1042 }
1043 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on);
1044 
1045 /**
1046  * mipi_dsi_dcs_set_column_address() - define the column extent of the frame
1047  *    memory accessed by the host processor
1048  * @dsi: DSI peripheral device
1049  * @start: first column of frame memory
1050  * @end: last column of frame memory
1051  *
1052  * Return: 0 on success or a negative error code on failure.
1053  */
mipi_dsi_dcs_set_column_address(struct mipi_dsi_device * dsi,u16 start,u16 end)1054 int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
1055 				    u16 end)
1056 {
1057 	u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
1058 	ssize_t err;
1059 
1060 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload,
1061 				 sizeof(payload));
1062 	if (err < 0)
1063 		return err;
1064 
1065 	return 0;
1066 }
1067 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address);
1068 
1069 /**
1070  * mipi_dsi_dcs_set_page_address() - define the page extent of the frame
1071  *    memory accessed by the host processor
1072  * @dsi: DSI peripheral device
1073  * @start: first page of frame memory
1074  * @end: last page of frame memory
1075  *
1076  * Return: 0 on success or a negative error code on failure.
1077  */
mipi_dsi_dcs_set_page_address(struct mipi_dsi_device * dsi,u16 start,u16 end)1078 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
1079 				  u16 end)
1080 {
1081 	u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
1082 	ssize_t err;
1083 
1084 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload,
1085 				 sizeof(payload));
1086 	if (err < 0)
1087 		return err;
1088 
1089 	return 0;
1090 }
1091 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address);
1092 
1093 /**
1094  * mipi_dsi_dcs_set_tear_off() - turn off the display module's Tearing Effect
1095  *    output signal on the TE signal line
1096  * @dsi: DSI peripheral device
1097  *
1098  * Return: 0 on success or a negative error code on failure
1099  */
mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device * dsi)1100 int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi)
1101 {
1102 	ssize_t err;
1103 
1104 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0);
1105 	if (err < 0)
1106 		return err;
1107 
1108 	return 0;
1109 }
1110 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off);
1111 
1112 /**
1113  * mipi_dsi_dcs_set_tear_on() - turn on the display module's Tearing Effect
1114  *    output signal on the TE signal line.
1115  * @dsi: DSI peripheral device
1116  * @mode: the Tearing Effect Output Line mode
1117  *
1118  * Return: 0 on success or a negative error code on failure
1119  */
mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device * dsi,enum mipi_dsi_dcs_tear_mode mode)1120 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
1121 			     enum mipi_dsi_dcs_tear_mode mode)
1122 {
1123 	u8 value = mode;
1124 	ssize_t err;
1125 
1126 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value,
1127 				 sizeof(value));
1128 	if (err < 0)
1129 		return err;
1130 
1131 	return 0;
1132 }
1133 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on);
1134 
1135 /**
1136  * mipi_dsi_dcs_set_pixel_format() - sets the pixel format for the RGB image
1137  *    data used by the interface
1138  * @dsi: DSI peripheral device
1139  * @format: pixel format
1140  *
1141  * Return: 0 on success or a negative error code on failure.
1142  */
mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device * dsi,u8 format)1143 int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format)
1144 {
1145 	ssize_t err;
1146 
1147 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format,
1148 				 sizeof(format));
1149 	if (err < 0)
1150 		return err;
1151 
1152 	return 0;
1153 }
1154 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format);
1155 
1156 /**
1157  * mipi_dsi_dcs_set_tear_scanline() - set the scanline to use as trigger for
1158  *    the Tearing Effect output signal of the display module
1159  * @dsi: DSI peripheral device
1160  * @scanline: scanline to use as trigger
1161  *
1162  * Return: 0 on success or a negative error code on failure
1163  */
mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device * dsi,u16 scanline)1164 int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline)
1165 {
1166 	u8 payload[2] = { scanline >> 8, scanline & 0xff };
1167 	ssize_t err;
1168 
1169 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_SCANLINE, payload,
1170 				 sizeof(payload));
1171 	if (err < 0)
1172 		return err;
1173 
1174 	return 0;
1175 }
1176 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline);
1177 
1178 /**
1179  * mipi_dsi_dcs_set_display_brightness() - sets the brightness value of the
1180  *    display
1181  * @dsi: DSI peripheral device
1182  * @brightness: brightness value
1183  *
1184  * Return: 0 on success or a negative error code on failure.
1185  */
mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device * dsi,u16 brightness)1186 int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi,
1187 					u16 brightness)
1188 {
1189 	u8 payload[2] = { brightness & 0xff, brightness >> 8 };
1190 	ssize_t err;
1191 
1192 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
1193 				 payload, sizeof(payload));
1194 	if (err < 0)
1195 		return err;
1196 
1197 	return 0;
1198 }
1199 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness);
1200 
1201 /**
1202  * mipi_dsi_dcs_get_display_brightness() - gets the current brightness value
1203  *    of the display
1204  * @dsi: DSI peripheral device
1205  * @brightness: brightness value
1206  *
1207  * Return: 0 on success or a negative error code on failure.
1208  */
mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device * dsi,u16 * brightness)1209 int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi,
1210 					u16 *brightness)
1211 {
1212 	ssize_t err;
1213 
1214 	err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
1215 				brightness, sizeof(*brightness));
1216 	if (err <= 0) {
1217 		if (err == 0)
1218 			err = -ENODATA;
1219 
1220 		return err;
1221 	}
1222 
1223 	return 0;
1224 }
1225 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness);
1226 
mipi_dsi_drv_probe(struct device * dev)1227 static int mipi_dsi_drv_probe(struct device *dev)
1228 {
1229 	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1230 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1231 
1232 	return drv->probe(dsi);
1233 }
1234 
mipi_dsi_drv_remove(struct device * dev)1235 static int mipi_dsi_drv_remove(struct device *dev)
1236 {
1237 	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1238 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1239 
1240 	drv->remove(dsi);
1241 
1242 	return 0;
1243 }
1244 
mipi_dsi_drv_shutdown(struct device * dev)1245 static void mipi_dsi_drv_shutdown(struct device *dev)
1246 {
1247 	struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1248 	struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1249 
1250 	drv->shutdown(dsi);
1251 }
1252 
1253 /**
1254  * mipi_dsi_driver_register_full() - register a driver for DSI devices
1255  * @drv: DSI driver structure
1256  * @owner: owner module
1257  *
1258  * Return: 0 on success or a negative error code on failure.
1259  */
mipi_dsi_driver_register_full(struct mipi_dsi_driver * drv,struct module * owner)1260 int mipi_dsi_driver_register_full(struct mipi_dsi_driver *drv,
1261 				  struct module *owner)
1262 {
1263 	drv->driver.bus = &mipi_dsi_bus_type;
1264 	drv->driver.owner = owner;
1265 
1266 	if (drv->probe)
1267 		drv->driver.probe = mipi_dsi_drv_probe;
1268 	if (drv->remove)
1269 		drv->driver.remove = mipi_dsi_drv_remove;
1270 	if (drv->shutdown)
1271 		drv->driver.shutdown = mipi_dsi_drv_shutdown;
1272 
1273 	return driver_register(&drv->driver);
1274 }
1275 EXPORT_SYMBOL(mipi_dsi_driver_register_full);
1276 
1277 /**
1278  * mipi_dsi_driver_unregister() - unregister a driver for DSI devices
1279  * @drv: DSI driver structure
1280  *
1281  * Return: 0 on success or a negative error code on failure.
1282  */
mipi_dsi_driver_unregister(struct mipi_dsi_driver * drv)1283 void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
1284 {
1285 	driver_unregister(&drv->driver);
1286 }
1287 EXPORT_SYMBOL(mipi_dsi_driver_unregister);
1288 
mipi_dsi_bus_init(void)1289 static int __init mipi_dsi_bus_init(void)
1290 {
1291 	return bus_register(&mipi_dsi_bus_type);
1292 }
1293 postcore_initcall(mipi_dsi_bus_init);
1294 
1295 MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
1296 MODULE_DESCRIPTION("MIPI DSI Bus");
1297 MODULE_LICENSE("GPL and additional rights");
1298