1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * MIPI DSI Bus
4  *
5  * Copyright (C) 2012-2013, Samsung Electronics, Co., Ltd.
6  * Copyright (C) 2019 STMicroelectronics - All Rights Reserved
7  * Andrzej Hajda <a.hajda@samsung.com>
8  *
9  * Permission is hereby granted, free of charge, to any person obtaining a
10  * copy of this software and associated documentation files (the
11  * "Software"), to deal in the Software without restriction, including
12  * without limitation the rights to use, copy, modify, merge, publish,
13  * distribute, sub license, and/or sell copies of the Software, and to
14  * permit persons to whom the Software is furnished to do so, subject to
15  * the following conditions:
16  *
17  * The above copyright notice and this permission notice (including the
18  * next paragraph) shall be included in all copies or substantial portions
19  * of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
24  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
25  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
26  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
27  * USE OR OTHER DEALINGS IN THE SOFTWARE.
28  *
29  * Mipi_dsi.c contains a set of dsi helpers.
30  * This file is inspired from the drm helper file drivers/gpu/drm/drm_mipi_dsi.c
31  * (kernel linux).
32  *
33  */
34 
35 #include <common.h>
36 #include <clk.h>
37 #include <display.h>
38 #include <dm.h>
39 #include <mipi_display.h>
40 #include <mipi_dsi.h>
41 #include <dm/devres.h>
42 
43 /**
44  * DOC: dsi helpers
45  *
46  * These functions contain some common logic and helpers to deal with MIPI DSI
47  * peripherals.
48  *
49  * Helpers are provided for a number of standard MIPI DSI command as well as a
50  * subset of the MIPI DCS command set.
51  */
52 
53 /**
54  * mipi_dsi_attach - attach a DSI device to its DSI host
55  * @dsi: DSI peripheral
56  */
mipi_dsi_attach(struct mipi_dsi_device * dsi)57 int mipi_dsi_attach(struct mipi_dsi_device *dsi)
58 {
59 	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
60 
61 	if (!ops || !ops->attach)
62 		return -ENOSYS;
63 
64 	return ops->attach(dsi->host, dsi);
65 }
66 EXPORT_SYMBOL(mipi_dsi_attach);
67 
68 /**
69  * mipi_dsi_detach - detach a DSI device from its DSI host
70  * @dsi: DSI peripheral
71  */
mipi_dsi_detach(struct mipi_dsi_device * dsi)72 int mipi_dsi_detach(struct mipi_dsi_device *dsi)
73 {
74 	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
75 
76 	if (!ops || !ops->detach)
77 		return -ENOSYS;
78 
79 	return ops->detach(dsi->host, dsi);
80 }
81 EXPORT_SYMBOL(mipi_dsi_detach);
82 
83 /**
84  * mipi_dsi_device_transfer - transfer message to a DSI device
85  * @dsi: DSI peripheral
86  * @msg: message
87  */
mipi_dsi_device_transfer(struct mipi_dsi_device * dsi,struct mipi_dsi_msg * msg)88 static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
89 					struct mipi_dsi_msg *msg)
90 {
91 	const struct mipi_dsi_host_ops *ops = dsi->host->ops;
92 
93 	if (!ops || !ops->transfer)
94 		return -ENOSYS;
95 
96 	if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
97 		msg->flags |= MIPI_DSI_MSG_USE_LPM;
98 
99 	return ops->transfer(dsi->host, msg);
100 }
101 
102 /**
103  * mipi_dsi_packet_format_is_short - check if a packet is of the short format
104  * @type: MIPI DSI data type of the packet
105  *
106  * Return: true if the packet for the given data type is a short packet, false
107  * otherwise.
108  */
mipi_dsi_packet_format_is_short(u8 type)109 bool mipi_dsi_packet_format_is_short(u8 type)
110 {
111 	switch (type) {
112 	case MIPI_DSI_V_SYNC_START:
113 	case MIPI_DSI_V_SYNC_END:
114 	case MIPI_DSI_H_SYNC_START:
115 	case MIPI_DSI_H_SYNC_END:
116 	case MIPI_DSI_END_OF_TRANSMISSION:
117 	case MIPI_DSI_COLOR_MODE_OFF:
118 	case MIPI_DSI_COLOR_MODE_ON:
119 	case MIPI_DSI_SHUTDOWN_PERIPHERAL:
120 	case MIPI_DSI_TURN_ON_PERIPHERAL:
121 	case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
122 	case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
123 	case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
124 	case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
125 	case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
126 	case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
127 	case MIPI_DSI_DCS_SHORT_WRITE:
128 	case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
129 	case MIPI_DSI_DCS_READ:
130 	case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
131 		return true;
132 	}
133 
134 	return false;
135 }
136 EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);
137 
138 /**
139  * mipi_dsi_packet_format_is_long - check if a packet is of the long format
140  * @type: MIPI DSI data type of the packet
141  *
142  * Return: true if the packet for the given data type is a long packet, false
143  * otherwise.
144  */
mipi_dsi_packet_format_is_long(u8 type)145 bool mipi_dsi_packet_format_is_long(u8 type)
146 {
147 	switch (type) {
148 	case MIPI_DSI_NULL_PACKET:
149 	case MIPI_DSI_BLANKING_PACKET:
150 	case MIPI_DSI_GENERIC_LONG_WRITE:
151 	case MIPI_DSI_DCS_LONG_WRITE:
152 	case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
153 	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
154 	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
155 	case MIPI_DSI_PACKED_PIXEL_STREAM_30:
156 	case MIPI_DSI_PACKED_PIXEL_STREAM_36:
157 	case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
158 	case MIPI_DSI_PACKED_PIXEL_STREAM_16:
159 	case MIPI_DSI_PACKED_PIXEL_STREAM_18:
160 	case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
161 	case MIPI_DSI_PACKED_PIXEL_STREAM_24:
162 		return true;
163 	}
164 
165 	return false;
166 }
167 EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);
168 
169 /**
170  * mipi_dsi_create_packet - create a packet from a message according to the
171  *     DSI protocol
172  * @packet: pointer to a DSI packet structure
173  * @msg: message to translate into a packet
174  *
175  * Return: 0 on success or a negative error code on failure.
176  */
mipi_dsi_create_packet(struct mipi_dsi_packet * packet,const struct mipi_dsi_msg * msg)177 int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
178 			   const struct mipi_dsi_msg *msg)
179 {
180 	if (!packet || !msg)
181 		return -EINVAL;
182 
183 	/* do some minimum sanity checking */
184 	if (!mipi_dsi_packet_format_is_short(msg->type) &&
185 	    !mipi_dsi_packet_format_is_long(msg->type))
186 		return -EINVAL;
187 
188 	if (msg->channel > 3)
189 		return -EINVAL;
190 
191 	memset(packet, 0, sizeof(*packet));
192 	packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f);
193 
194 	/* TODO: compute ECC if hardware support is not available */
195 
196 	/*
197 	 * Long write packets contain the word count in header bytes 1 and 2.
198 	 * The payload follows the header and is word count bytes long.
199 	 *
200 	 * Short write packets encode up to two parameters in header bytes 1
201 	 * and 2.
202 	 */
203 	if (mipi_dsi_packet_format_is_long(msg->type)) {
204 		packet->header[1] = (msg->tx_len >> 0) & 0xff;
205 		packet->header[2] = (msg->tx_len >> 8) & 0xff;
206 
207 		packet->payload_length = msg->tx_len;
208 		packet->payload = msg->tx_buf;
209 	} else {
210 		const u8 *tx = msg->tx_buf;
211 
212 		packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
213 		packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
214 	}
215 
216 	packet->size = sizeof(packet->header) + packet->payload_length;
217 
218 	return 0;
219 }
220 EXPORT_SYMBOL(mipi_dsi_create_packet);
221 
222 /**
223  * mipi_dsi_shutdown_peripheral() - sends a Shutdown Peripheral command
224  * @dsi: DSI peripheral device
225  *
226  * Return: 0 on success or a negative error code on failure.
227  */
mipi_dsi_shutdown_peripheral(struct mipi_dsi_device * dsi)228 int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi)
229 {
230 	struct mipi_dsi_msg msg = {
231 		.channel = dsi->channel,
232 		.type = MIPI_DSI_SHUTDOWN_PERIPHERAL,
233 		.tx_buf = (u8 [2]) { 0, 0 },
234 		.tx_len = 2,
235 	};
236 	int ret = mipi_dsi_device_transfer(dsi, &msg);
237 
238 	return (ret < 0) ? ret : 0;
239 }
240 EXPORT_SYMBOL(mipi_dsi_shutdown_peripheral);
241 
242 /**
243  * mipi_dsi_turn_on_peripheral() - sends a Turn On Peripheral command
244  * @dsi: DSI peripheral device
245  *
246  * Return: 0 on success or a negative error code on failure.
247  */
mipi_dsi_turn_on_peripheral(struct mipi_dsi_device * dsi)248 int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi)
249 {
250 	struct mipi_dsi_msg msg = {
251 		.channel = dsi->channel,
252 		.type = MIPI_DSI_TURN_ON_PERIPHERAL,
253 		.tx_buf = (u8 [2]) { 0, 0 },
254 		.tx_len = 2,
255 	};
256 	int ret = mipi_dsi_device_transfer(dsi, &msg);
257 
258 	return (ret < 0) ? ret : 0;
259 }
260 EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral);
261 
262 /*
263  * mipi_dsi_set_maximum_return_packet_size() - specify the maximum size of the
264  *    the payload in a long packet transmitted from the peripheral back to the
265  *    host processor
266  * @dsi: DSI peripheral device
267  * @value: the maximum size of the payload
268  *
269  * Return: 0 on success or a negative error code on failure.
270  */
mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device * dsi,u16 value)271 int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi,
272 					    u16 value)
273 {
274 	u8 tx[2] = { value & 0xff, value >> 8 };
275 	struct mipi_dsi_msg msg = {
276 		.channel = dsi->channel,
277 		.type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
278 		.tx_len = sizeof(tx),
279 		.tx_buf = tx,
280 	};
281 	int ret = mipi_dsi_device_transfer(dsi, &msg);
282 
283 	return (ret < 0) ? ret : 0;
284 }
285 EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size);
286 
287 /**
288  * mipi_dsi_generic_write() - transmit data using a generic write packet
289  * @dsi: DSI peripheral device
290  * @payload: buffer containing the payload
291  * @size: size of payload buffer
292  *
293  * This function will automatically choose the right data type depending on
294  * the payload length.
295  *
296  * Return: The number of bytes transmitted on success or a negative error code
297  * on failure.
298  */
mipi_dsi_generic_write(struct mipi_dsi_device * dsi,const void * payload,size_t size)299 ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload,
300 			       size_t size)
301 {
302 	struct mipi_dsi_msg msg = {
303 		.channel = dsi->channel,
304 		.tx_buf = payload,
305 		.tx_len = size
306 	};
307 
308 	switch (size) {
309 	case 0:
310 		msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM;
311 		break;
312 
313 	case 1:
314 		msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM;
315 		break;
316 
317 	case 2:
318 		msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM;
319 		break;
320 
321 	default:
322 		msg.type = MIPI_DSI_GENERIC_LONG_WRITE;
323 		break;
324 	}
325 
326 	return mipi_dsi_device_transfer(dsi, &msg);
327 }
328 EXPORT_SYMBOL(mipi_dsi_generic_write);
329 
330 /**
331  * mipi_dsi_generic_read() - receive data using a generic read packet
332  * @dsi: DSI peripheral device
333  * @params: buffer containing the request parameters
334  * @num_params: number of request parameters
335  * @data: buffer in which to return the received data
336  * @size: size of receive buffer
337  *
338  * This function will automatically choose the right data type depending on
339  * the number of parameters passed in.
340  *
341  * Return: The number of bytes successfully read or a negative error code on
342  * failure.
343  */
mipi_dsi_generic_read(struct mipi_dsi_device * dsi,const void * params,size_t num_params,void * data,size_t size)344 ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params,
345 			      size_t num_params, void *data, size_t size)
346 {
347 	struct mipi_dsi_msg msg = {
348 		.channel = dsi->channel,
349 		.tx_len = num_params,
350 		.tx_buf = params,
351 		.rx_len = size,
352 		.rx_buf = data
353 	};
354 
355 	switch (num_params) {
356 	case 0:
357 		msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM;
358 		break;
359 
360 	case 1:
361 		msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM;
362 		break;
363 
364 	case 2:
365 		msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM;
366 		break;
367 
368 	default:
369 		return -EINVAL;
370 	}
371 
372 	return mipi_dsi_device_transfer(dsi, &msg);
373 }
374 EXPORT_SYMBOL(mipi_dsi_generic_read);
375 
376 /**
377  * mipi_dsi_dcs_write_buffer() - transmit a DCS command with payload
378  * @dsi: DSI peripheral device
379  * @data: buffer containing data to be transmitted
380  * @len: size of transmission buffer
381  *
382  * This function will automatically choose the right data type depending on
383  * the command payload length.
384  *
385  * Return: The number of bytes successfully transmitted or a negative error
386  * code on failure.
387  */
mipi_dsi_dcs_write_buffer(struct mipi_dsi_device * dsi,const void * data,size_t len)388 ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi,
389 				  const void *data, size_t len)
390 {
391 	struct mipi_dsi_msg msg = {
392 		.channel = dsi->channel,
393 		.tx_buf = data,
394 		.tx_len = len
395 	};
396 
397 	switch (len) {
398 	case 0:
399 		return -EINVAL;
400 
401 	case 1:
402 		msg.type = MIPI_DSI_DCS_SHORT_WRITE;
403 		break;
404 
405 	case 2:
406 		msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
407 		break;
408 
409 	default:
410 		msg.type = MIPI_DSI_DCS_LONG_WRITE;
411 		break;
412 	}
413 
414 	return mipi_dsi_device_transfer(dsi, &msg);
415 }
416 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer);
417 
418 /**
419  * mipi_dsi_dcs_write() - send DCS write command
420  * @dsi: DSI peripheral device
421  * @cmd: DCS command
422  * @data: buffer containing the command payload
423  * @len: command payload length
424  *
425  * This function will automatically choose the right data type depending on
426  * the command payload length.
427  *
428  * Return: The number of bytes successfully transmitted or a negative error
429  * code on failure.
430  */
mipi_dsi_dcs_write(struct mipi_dsi_device * dsi,u8 cmd,const void * data,size_t len)431 ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd,
432 			   const void *data, size_t len)
433 {
434 	ssize_t err;
435 	size_t size;
436 	u8 *tx;
437 
438 	if (len > 0) {
439 		size = 1 + len;
440 
441 		tx = kmalloc(size, GFP_KERNEL);
442 		if (!tx)
443 			return -ENOMEM;
444 
445 		/* concatenate the DCS command byte and the payload */
446 		tx[0] = cmd;
447 		memcpy(&tx[1], data, len);
448 	} else {
449 		tx = &cmd;
450 		size = 1;
451 	}
452 
453 	err = mipi_dsi_dcs_write_buffer(dsi, tx, size);
454 
455 	if (len > 0)
456 		kfree(tx);
457 
458 	return err;
459 }
460 EXPORT_SYMBOL(mipi_dsi_dcs_write);
461 
462 /**
463  * mipi_dsi_dcs_read() - send DCS read request command
464  * @dsi: DSI peripheral device
465  * @cmd: DCS command
466  * @data: buffer in which to receive data
467  * @len: size of receive buffer
468  *
469  * Return: The number of bytes read or a negative error code on failure.
470  */
mipi_dsi_dcs_read(struct mipi_dsi_device * dsi,u8 cmd,void * data,size_t len)471 ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
472 			  size_t len)
473 {
474 	struct mipi_dsi_msg msg = {
475 		.channel = dsi->channel,
476 		.type = MIPI_DSI_DCS_READ,
477 		.tx_buf = &cmd,
478 		.tx_len = 1,
479 		.rx_buf = data,
480 		.rx_len = len
481 	};
482 
483 	return mipi_dsi_device_transfer(dsi, &msg);
484 }
485 EXPORT_SYMBOL(mipi_dsi_dcs_read);
486 
487 /**
488  * mipi_dsi_dcs_nop() - send DCS nop packet
489  * @dsi: DSI peripheral device
490  *
491  * Return: 0 on success or a negative error code on failure.
492  */
mipi_dsi_dcs_nop(struct mipi_dsi_device * dsi)493 int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi)
494 {
495 	ssize_t err;
496 
497 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0);
498 	if (err < 0)
499 		return err;
500 
501 	return 0;
502 }
503 EXPORT_SYMBOL(mipi_dsi_dcs_nop);
504 
505 /**
506  * mipi_dsi_dcs_soft_reset() - perform a software reset of the display module
507  * @dsi: DSI peripheral device
508  *
509  * Return: 0 on success or a negative error code on failure.
510  */
mipi_dsi_dcs_soft_reset(struct mipi_dsi_device * dsi)511 int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi)
512 {
513 	ssize_t err;
514 
515 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
516 	if (err < 0)
517 		return err;
518 
519 	return 0;
520 }
521 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset);
522 
523 /**
524  * mipi_dsi_dcs_get_power_mode() - query the display module's current power
525  *    mode
526  * @dsi: DSI peripheral device
527  * @mode: return location for the current power mode
528  *
529  * Return: 0 on success or a negative error code on failure.
530  */
mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device * dsi,u8 * mode)531 int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode)
532 {
533 	ssize_t err;
534 
535 	err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode,
536 				sizeof(*mode));
537 	if (err <= 0) {
538 		if (err == 0)
539 			err = -ENODATA;
540 
541 		return err;
542 	}
543 
544 	return 0;
545 }
546 EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode);
547 
548 /**
549  * mipi_dsi_dcs_get_pixel_format() - gets the pixel format for the RGB image
550  *    data used by the interface
551  * @dsi: DSI peripheral device
552  * @format: return location for the pixel format
553  *
554  * Return: 0 on success or a negative error code on failure.
555  */
mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device * dsi,u8 * format)556 int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format)
557 {
558 	ssize_t err;
559 
560 	err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format,
561 				sizeof(*format));
562 	if (err <= 0) {
563 		if (err == 0)
564 			err = -ENODATA;
565 
566 		return err;
567 	}
568 
569 	return 0;
570 }
571 EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format);
572 
573 /**
574  * mipi_dsi_dcs_enter_sleep_mode() - disable all unnecessary blocks inside the
575  *    display module except interface communication
576  * @dsi: DSI peripheral device
577  *
578  * Return: 0 on success or a negative error code on failure.
579  */
mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device * dsi)580 int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi)
581 {
582 	ssize_t err;
583 
584 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0);
585 	if (err < 0)
586 		return err;
587 
588 	return 0;
589 }
590 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode);
591 
592 /**
593  * mipi_dsi_dcs_exit_sleep_mode() - enable all blocks inside the display
594  *    module
595  * @dsi: DSI peripheral device
596  *
597  * Return: 0 on success or a negative error code on failure.
598  */
mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device * dsi)599 int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi)
600 {
601 	ssize_t err;
602 
603 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0);
604 	if (err < 0)
605 		return err;
606 
607 	return 0;
608 }
609 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode);
610 
611 /**
612  * mipi_dsi_dcs_set_display_off() - stop displaying the image data on the
613  *    display device
614  * @dsi: DSI peripheral device
615  *
616  * Return: 0 on success or a negative error code on failure.
617  */
mipi_dsi_dcs_set_display_off(struct mipi_dsi_device * dsi)618 int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi)
619 {
620 	ssize_t err;
621 
622 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0);
623 	if (err < 0)
624 		return err;
625 
626 	return 0;
627 }
628 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off);
629 
630 /**
631  * mipi_dsi_dcs_set_display_on() - start displaying the image data on the
632  *    display device
633  * @dsi: DSI peripheral device
634  *
635  * Return: 0 on success or a negative error code on failure
636  */
mipi_dsi_dcs_set_display_on(struct mipi_dsi_device * dsi)637 int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi)
638 {
639 	ssize_t err;
640 
641 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0);
642 	if (err < 0)
643 		return err;
644 
645 	return 0;
646 }
647 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on);
648 
649 /**
650  * mipi_dsi_dcs_set_column_address() - define the column extent of the frame
651  *    memory accessed by the host processor
652  * @dsi: DSI peripheral device
653  * @start: first column of frame memory
654  * @end: last column of frame memory
655  *
656  * Return: 0 on success or a negative error code on failure.
657  */
mipi_dsi_dcs_set_column_address(struct mipi_dsi_device * dsi,u16 start,u16 end)658 int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
659 				    u16 end)
660 {
661 	u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
662 	ssize_t err;
663 
664 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload,
665 				 sizeof(payload));
666 	if (err < 0)
667 		return err;
668 
669 	return 0;
670 }
671 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address);
672 
673 /**
674  * mipi_dsi_dcs_set_page_address() - define the page extent of the frame
675  *    memory accessed by the host processor
676  * @dsi: DSI peripheral device
677  * @start: first page of frame memory
678  * @end: last page of frame memory
679  *
680  * Return: 0 on success or a negative error code on failure.
681  */
mipi_dsi_dcs_set_page_address(struct mipi_dsi_device * dsi,u16 start,u16 end)682 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
683 				  u16 end)
684 {
685 	u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
686 	ssize_t err;
687 
688 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload,
689 				 sizeof(payload));
690 	if (err < 0)
691 		return err;
692 
693 	return 0;
694 }
695 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address);
696 
697 /**
698  * mipi_dsi_dcs_set_tear_off() - turn off the display module's Tearing Effect
699  *    output signal on the TE signal line
700  * @dsi: DSI peripheral device
701  *
702  * Return: 0 on success or a negative error code on failure
703  */
mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device * dsi)704 int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi)
705 {
706 	ssize_t err;
707 
708 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0);
709 	if (err < 0)
710 		return err;
711 
712 	return 0;
713 }
714 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off);
715 
716 /**
717  * mipi_dsi_dcs_set_tear_on() - turn on the display module's Tearing Effect
718  *    output signal on the TE signal line.
719  * @dsi: DSI peripheral device
720  * @mode: the Tearing Effect Output Line mode
721  *
722  * Return: 0 on success or a negative error code on failure
723  */
mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device * dsi,enum mipi_dsi_dcs_tear_mode mode)724 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
725 			     enum mipi_dsi_dcs_tear_mode mode)
726 {
727 	u8 value = mode;
728 	ssize_t err;
729 
730 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value,
731 				 sizeof(value));
732 	if (err < 0)
733 		return err;
734 
735 	return 0;
736 }
737 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on);
738 
739 /**
740  * mipi_dsi_dcs_set_pixel_format() - sets the pixel format for the RGB image
741  *    data used by the interface
742  * @dsi: DSI peripheral device
743  * @format: pixel format
744  *
745  * Return: 0 on success or a negative error code on failure.
746  */
mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device * dsi,u8 format)747 int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format)
748 {
749 	ssize_t err;
750 
751 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format,
752 				 sizeof(format));
753 	if (err < 0)
754 		return err;
755 
756 	return 0;
757 }
758 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format);
759 
760 /**
761  * mipi_dsi_dcs_set_tear_scanline() - set the scanline to use as trigger for
762  *    the Tearing Effect output signal of the display module
763  * @dsi: DSI peripheral device
764  * @scanline: scanline to use as trigger
765  *
766  * Return: 0 on success or a negative error code on failure
767  */
mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device * dsi,u16 scanline)768 int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline)
769 {
770 	u8 payload[3] = { MIPI_DCS_SET_TEAR_SCANLINE, scanline >> 8,
771 			  scanline & 0xff };
772 	ssize_t err;
773 
774 	err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
775 	if (err < 0)
776 		return err;
777 
778 	return 0;
779 }
780 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline);
781 
782 /**
783  * mipi_dsi_dcs_set_display_brightness() - sets the brightness value of the
784  *    display
785  * @dsi: DSI peripheral device
786  * @brightness: brightness value
787  *
788  * Return: 0 on success or a negative error code on failure.
789  */
mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device * dsi,u16 brightness)790 int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi,
791 					u16 brightness)
792 {
793 	u8 payload[2] = { brightness & 0xff, brightness >> 8 };
794 	ssize_t err;
795 
796 	err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
797 				 payload, sizeof(payload));
798 	if (err < 0)
799 		return err;
800 
801 	return 0;
802 }
803 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness);
804 
805 /**
806  * mipi_dsi_dcs_get_display_brightness() - gets the current brightness value
807  *    of the display
808  * @dsi: DSI peripheral device
809  * @brightness: brightness value
810  *
811  * Return: 0 on success or a negative error code on failure.
812  */
mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device * dsi,u16 * brightness)813 int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi,
814 					u16 *brightness)
815 {
816 	ssize_t err;
817 
818 	err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
819 				brightness, sizeof(*brightness));
820 	if (err <= 0) {
821 		if (err == 0)
822 			err = -ENODATA;
823 
824 		return err;
825 	}
826 
827 	return 0;
828 }
829 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness);
830