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