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,const struct device_driver * drv)51 static int mipi_dsi_device_match(struct device *dev, const 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 const 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 dev_err(host->dev, "modalias failure on %pOF\n", node);
166 return ERR_PTR(-EINVAL);
167 }
168
169 ret = of_property_read_u32(node, "reg", ®);
170 if (ret) {
171 dev_err(host->dev, "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 dev_err(host->dev, "invalid mipi_dsi_device_info pointer\n");
210 return ERR_PTR(-EINVAL);
211 }
212
213 if (info->channel > 3) {
214 dev_err(host->dev, "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 dev_err(host->dev, "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 dev_err(host->dev, "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 * This function is deprecated. Use mipi_dsi_turn_on_peripheral_multi() instead.
607 *
608 * Return: 0 on success or a negative error code on failure.
609 */
mipi_dsi_turn_on_peripheral(struct mipi_dsi_device * dsi)610 int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi)
611 {
612 struct mipi_dsi_msg msg = {
613 .channel = dsi->channel,
614 .type = MIPI_DSI_TURN_ON_PERIPHERAL,
615 .tx_buf = (u8 [2]) { 0, 0 },
616 .tx_len = 2,
617 };
618 int ret = mipi_dsi_device_transfer(dsi, &msg);
619
620 return (ret < 0) ? ret : 0;
621 }
622 EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral);
623
624 /*
625 * mipi_dsi_set_maximum_return_packet_size() - specify the maximum size of
626 * the payload in a long packet transmitted from the peripheral back to the
627 * host processor
628 * @dsi: DSI peripheral device
629 * @value: the maximum size of the payload
630 *
631 * Return: 0 on success or a negative error code on failure.
632 */
mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device * dsi,u16 value)633 int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi,
634 u16 value)
635 {
636 u8 tx[2] = { value & 0xff, value >> 8 };
637 struct mipi_dsi_msg msg = {
638 .channel = dsi->channel,
639 .type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
640 .tx_len = sizeof(tx),
641 .tx_buf = tx,
642 };
643 int ret = mipi_dsi_device_transfer(dsi, &msg);
644
645 return (ret < 0) ? ret : 0;
646 }
647 EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size);
648
649 /**
650 * mipi_dsi_compression_mode_ext() - enable/disable DSC on the peripheral
651 * @dsi: DSI peripheral device
652 * @enable: Whether to enable or disable the DSC
653 * @algo: Selected compression algorithm
654 * @pps_selector: Select PPS from the table of pre-stored or uploaded PPS entries
655 *
656 * Enable or disable Display Stream Compression on the peripheral.
657 * This function is deprecated. Use mipi_dsi_compression_mode_ext_multi() instead.
658 *
659 * Return: 0 on success or a negative error code on failure.
660 */
mipi_dsi_compression_mode_ext(struct mipi_dsi_device * dsi,bool enable,enum mipi_dsi_compression_algo algo,unsigned int pps_selector)661 int mipi_dsi_compression_mode_ext(struct mipi_dsi_device *dsi, bool enable,
662 enum mipi_dsi_compression_algo algo,
663 unsigned int pps_selector)
664 {
665 u8 tx[2] = { };
666 struct mipi_dsi_msg msg = {
667 .channel = dsi->channel,
668 .type = MIPI_DSI_COMPRESSION_MODE,
669 .tx_len = sizeof(tx),
670 .tx_buf = tx,
671 };
672 int ret;
673
674 if (algo > 3 || pps_selector > 3)
675 return -EINVAL;
676
677 tx[0] = (enable << 0) |
678 (algo << 1) |
679 (pps_selector << 4);
680
681 ret = mipi_dsi_device_transfer(dsi, &msg);
682
683 return (ret < 0) ? ret : 0;
684 }
685 EXPORT_SYMBOL(mipi_dsi_compression_mode_ext);
686
687 /**
688 * mipi_dsi_compression_mode() - enable/disable DSC on the peripheral
689 * @dsi: DSI peripheral device
690 * @enable: Whether to enable or disable the DSC
691 *
692 * Enable or disable Display Stream Compression on the peripheral using the
693 * default Picture Parameter Set and VESA DSC 1.1 algorithm.
694 *
695 * Return: 0 on success or a negative error code on failure.
696 */
mipi_dsi_compression_mode(struct mipi_dsi_device * dsi,bool enable)697 int mipi_dsi_compression_mode(struct mipi_dsi_device *dsi, bool enable)
698 {
699 return mipi_dsi_compression_mode_ext(dsi, enable, MIPI_DSI_COMPRESSION_DSC, 0);
700 }
701 EXPORT_SYMBOL(mipi_dsi_compression_mode);
702
703 /**
704 * mipi_dsi_picture_parameter_set() - transmit the DSC PPS to the peripheral
705 * @dsi: DSI peripheral device
706 * @pps: VESA DSC 1.1 Picture Parameter Set
707 *
708 * Transmit the VESA DSC 1.1 Picture Parameter Set to the peripheral.
709 * This function is deprecated. Use mipi_dsi_picture_parameter_set_multi() instead.
710 *
711 * Return: 0 on success or a negative error code on failure.
712 */
mipi_dsi_picture_parameter_set(struct mipi_dsi_device * dsi,const struct drm_dsc_picture_parameter_set * pps)713 int mipi_dsi_picture_parameter_set(struct mipi_dsi_device *dsi,
714 const struct drm_dsc_picture_parameter_set *pps)
715 {
716 struct mipi_dsi_msg msg = {
717 .channel = dsi->channel,
718 .type = MIPI_DSI_PICTURE_PARAMETER_SET,
719 .tx_len = sizeof(*pps),
720 .tx_buf = pps,
721 };
722 int ret = mipi_dsi_device_transfer(dsi, &msg);
723
724 return (ret < 0) ? ret : 0;
725 }
726 EXPORT_SYMBOL(mipi_dsi_picture_parameter_set);
727
728 /**
729 * mipi_dsi_generic_write() - transmit data using a generic write packet
730 * @dsi: DSI peripheral device
731 * @payload: buffer containing the payload
732 * @size: size of payload buffer
733 *
734 * This function will automatically choose the right data type depending on
735 * the payload length.
736 *
737 * Return: The number of bytes transmitted on success or a negative error code
738 * on failure.
739 */
mipi_dsi_generic_write(struct mipi_dsi_device * dsi,const void * payload,size_t size)740 ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload,
741 size_t size)
742 {
743 struct mipi_dsi_msg msg = {
744 .channel = dsi->channel,
745 .tx_buf = payload,
746 .tx_len = size
747 };
748
749 switch (size) {
750 case 0:
751 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM;
752 break;
753
754 case 1:
755 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM;
756 break;
757
758 case 2:
759 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM;
760 break;
761
762 default:
763 msg.type = MIPI_DSI_GENERIC_LONG_WRITE;
764 break;
765 }
766
767 return mipi_dsi_device_transfer(dsi, &msg);
768 }
769 EXPORT_SYMBOL(mipi_dsi_generic_write);
770
771 /**
772 * mipi_dsi_generic_write_chatty() - mipi_dsi_generic_write() w/ an error log
773 * @dsi: DSI peripheral device
774 * @payload: buffer containing the payload
775 * @size: size of payload buffer
776 *
777 * Like mipi_dsi_generic_write() but includes a dev_err()
778 * call for you and returns 0 upon success, not the number of bytes sent.
779 *
780 * Return: 0 on success or a negative error code on failure.
781 */
mipi_dsi_generic_write_chatty(struct mipi_dsi_device * dsi,const void * payload,size_t size)782 int mipi_dsi_generic_write_chatty(struct mipi_dsi_device *dsi,
783 const void *payload, size_t size)
784 {
785 struct device *dev = &dsi->dev;
786 ssize_t ret;
787
788 ret = mipi_dsi_generic_write(dsi, payload, size);
789 if (ret < 0) {
790 dev_err(dev, "sending generic data %*ph failed: %zd\n",
791 (int)size, payload, ret);
792 return ret;
793 }
794
795 return 0;
796 }
797 EXPORT_SYMBOL(mipi_dsi_generic_write_chatty);
798
799 /**
800 * mipi_dsi_generic_write_multi() - mipi_dsi_generic_write_chatty() w/ accum_err
801 * @ctx: Context for multiple DSI transactions
802 * @payload: buffer containing the payload
803 * @size: size of payload buffer
804 *
805 * Like mipi_dsi_generic_write_chatty() but deals with errors in a way that
806 * makes it convenient to make several calls in a row.
807 */
mipi_dsi_generic_write_multi(struct mipi_dsi_multi_context * ctx,const void * payload,size_t size)808 void mipi_dsi_generic_write_multi(struct mipi_dsi_multi_context *ctx,
809 const void *payload, size_t size)
810 {
811 struct mipi_dsi_device *dsi = ctx->dsi;
812 struct device *dev = &dsi->dev;
813 ssize_t ret;
814
815 if (ctx->accum_err)
816 return;
817
818 ret = mipi_dsi_generic_write(dsi, payload, size);
819 if (ret < 0) {
820 ctx->accum_err = ret;
821 dev_err(dev, "sending generic data %*ph failed: %d\n",
822 (int)size, payload, ctx->accum_err);
823 }
824 }
825 EXPORT_SYMBOL(mipi_dsi_generic_write_multi);
826
827 /**
828 * mipi_dsi_generic_read() - receive data using a generic read packet
829 * @dsi: DSI peripheral device
830 * @params: buffer containing the request parameters
831 * @num_params: number of request parameters
832 * @data: buffer in which to return the received data
833 * @size: size of receive buffer
834 *
835 * This function will automatically choose the right data type depending on
836 * the number of parameters passed in.
837 *
838 * Return: The number of bytes successfully read or a negative error code on
839 * failure.
840 */
mipi_dsi_generic_read(struct mipi_dsi_device * dsi,const void * params,size_t num_params,void * data,size_t size)841 ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params,
842 size_t num_params, void *data, size_t size)
843 {
844 struct mipi_dsi_msg msg = {
845 .channel = dsi->channel,
846 .tx_len = num_params,
847 .tx_buf = params,
848 .rx_len = size,
849 .rx_buf = data
850 };
851
852 switch (num_params) {
853 case 0:
854 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM;
855 break;
856
857 case 1:
858 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM;
859 break;
860
861 case 2:
862 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM;
863 break;
864
865 default:
866 return -EINVAL;
867 }
868
869 return mipi_dsi_device_transfer(dsi, &msg);
870 }
871 EXPORT_SYMBOL(mipi_dsi_generic_read);
872
873 /**
874 * mipi_dsi_dcs_write_buffer() - transmit a DCS command with payload
875 * @dsi: DSI peripheral device
876 * @data: buffer containing data to be transmitted
877 * @len: size of transmission buffer
878 *
879 * This function will automatically choose the right data type depending on
880 * the command payload length.
881 *
882 * Return: The number of bytes successfully transmitted or a negative error
883 * code on failure.
884 */
mipi_dsi_dcs_write_buffer(struct mipi_dsi_device * dsi,const void * data,size_t len)885 ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi,
886 const void *data, size_t len)
887 {
888 struct mipi_dsi_msg msg = {
889 .channel = dsi->channel,
890 .tx_buf = data,
891 .tx_len = len
892 };
893
894 switch (len) {
895 case 0:
896 return -EINVAL;
897
898 case 1:
899 msg.type = MIPI_DSI_DCS_SHORT_WRITE;
900 break;
901
902 case 2:
903 msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
904 break;
905
906 default:
907 msg.type = MIPI_DSI_DCS_LONG_WRITE;
908 break;
909 }
910
911 return mipi_dsi_device_transfer(dsi, &msg);
912 }
913 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer);
914
915 /**
916 * mipi_dsi_dcs_write_buffer_chatty - mipi_dsi_dcs_write_buffer() w/ an error log
917 * @dsi: DSI peripheral device
918 * @data: buffer containing data to be transmitted
919 * @len: size of transmission buffer
920 *
921 * Like mipi_dsi_dcs_write_buffer() but includes a dev_err()
922 * call for you and returns 0 upon success, not the number of bytes sent.
923 *
924 * Return: 0 on success or a negative error code on failure.
925 */
mipi_dsi_dcs_write_buffer_chatty(struct mipi_dsi_device * dsi,const void * data,size_t len)926 int mipi_dsi_dcs_write_buffer_chatty(struct mipi_dsi_device *dsi,
927 const void *data, size_t len)
928 {
929 struct device *dev = &dsi->dev;
930 ssize_t ret;
931
932 ret = mipi_dsi_dcs_write_buffer(dsi, data, len);
933 if (ret < 0) {
934 dev_err(dev, "sending dcs data %*ph failed: %zd\n",
935 (int)len, data, ret);
936 return ret;
937 }
938
939 return 0;
940 }
941 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer_chatty);
942
943 /**
944 * mipi_dsi_dcs_write_buffer_multi - mipi_dsi_dcs_write_buffer_chatty() w/ accum_err
945 * @ctx: Context for multiple DSI transactions
946 * @data: buffer containing data to be transmitted
947 * @len: size of transmission buffer
948 *
949 * Like mipi_dsi_dcs_write_buffer_chatty() but deals with errors in a way that
950 * makes it convenient to make several calls in a row.
951 */
mipi_dsi_dcs_write_buffer_multi(struct mipi_dsi_multi_context * ctx,const void * data,size_t len)952 void mipi_dsi_dcs_write_buffer_multi(struct mipi_dsi_multi_context *ctx,
953 const void *data, size_t len)
954 {
955 struct mipi_dsi_device *dsi = ctx->dsi;
956 struct device *dev = &dsi->dev;
957 ssize_t ret;
958
959 if (ctx->accum_err)
960 return;
961
962 ret = mipi_dsi_dcs_write_buffer(dsi, data, len);
963 if (ret < 0) {
964 ctx->accum_err = ret;
965 dev_err(dev, "sending dcs data %*ph failed: %d\n",
966 (int)len, data, ctx->accum_err);
967 }
968 }
969 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer_multi);
970
971 /**
972 * mipi_dsi_dcs_write() - send DCS write command
973 * @dsi: DSI peripheral device
974 * @cmd: DCS command
975 * @data: buffer containing the command payload
976 * @len: command payload length
977 *
978 * This function will automatically choose the right data type depending on
979 * the command payload length.
980 *
981 * Return: The number of bytes successfully transmitted or a negative error
982 * code on failure.
983 */
mipi_dsi_dcs_write(struct mipi_dsi_device * dsi,u8 cmd,const void * data,size_t len)984 ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd,
985 const void *data, size_t len)
986 {
987 ssize_t err;
988 size_t size;
989 u8 stack_tx[8];
990 u8 *tx;
991
992 size = 1 + len;
993 if (len > ARRAY_SIZE(stack_tx) - 1) {
994 tx = kmalloc(size, GFP_KERNEL);
995 if (!tx)
996 return -ENOMEM;
997 } else {
998 tx = stack_tx;
999 }
1000
1001 /* concatenate the DCS command byte and the payload */
1002 tx[0] = cmd;
1003 if (data)
1004 memcpy(&tx[1], data, len);
1005
1006 err = mipi_dsi_dcs_write_buffer(dsi, tx, size);
1007
1008 if (tx != stack_tx)
1009 kfree(tx);
1010
1011 return err;
1012 }
1013 EXPORT_SYMBOL(mipi_dsi_dcs_write);
1014
1015 /**
1016 * mipi_dsi_dcs_read() - send DCS read request command
1017 * @dsi: DSI peripheral device
1018 * @cmd: DCS command
1019 * @data: buffer in which to receive data
1020 * @len: size of receive buffer
1021 *
1022 * Return: The number of bytes read or a negative error code on failure.
1023 */
mipi_dsi_dcs_read(struct mipi_dsi_device * dsi,u8 cmd,void * data,size_t len)1024 ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
1025 size_t len)
1026 {
1027 struct mipi_dsi_msg msg = {
1028 .channel = dsi->channel,
1029 .type = MIPI_DSI_DCS_READ,
1030 .tx_buf = &cmd,
1031 .tx_len = 1,
1032 .rx_buf = data,
1033 .rx_len = len
1034 };
1035
1036 return mipi_dsi_device_transfer(dsi, &msg);
1037 }
1038 EXPORT_SYMBOL(mipi_dsi_dcs_read);
1039
1040 /**
1041 * mipi_dsi_dcs_nop() - send DCS nop packet
1042 * @dsi: DSI peripheral device
1043 *
1044 * This function is deprecated. Use mipi_dsi_dcs_nop_multi() instead.
1045 *
1046 * Return: 0 on success or a negative error code on failure.
1047 */
mipi_dsi_dcs_nop(struct mipi_dsi_device * dsi)1048 int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi)
1049 {
1050 ssize_t err;
1051
1052 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0);
1053 if (err < 0)
1054 return err;
1055
1056 return 0;
1057 }
1058 EXPORT_SYMBOL(mipi_dsi_dcs_nop);
1059
1060 /**
1061 * mipi_dsi_dcs_soft_reset() - perform a software reset of the display module
1062 * @dsi: DSI peripheral device
1063 *
1064 * This function is deprecated. Use mipi_dsi_dcs_soft_reset_multi() instead.
1065 *
1066 * Return: 0 on success or a negative error code on failure.
1067 */
mipi_dsi_dcs_soft_reset(struct mipi_dsi_device * dsi)1068 int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi)
1069 {
1070 ssize_t err;
1071
1072 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
1073 if (err < 0)
1074 return err;
1075
1076 return 0;
1077 }
1078 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset);
1079
1080 /**
1081 * mipi_dsi_dcs_get_power_mode() - query the display module's current power
1082 * mode
1083 * @dsi: DSI peripheral device
1084 * @mode: return location for the current power mode
1085 *
1086 * Return: 0 on success or a negative error code on failure.
1087 */
mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device * dsi,u8 * mode)1088 int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode)
1089 {
1090 ssize_t err;
1091
1092 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode,
1093 sizeof(*mode));
1094 if (err <= 0) {
1095 if (err == 0)
1096 err = -ENODATA;
1097
1098 return err;
1099 }
1100
1101 return 0;
1102 }
1103 EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode);
1104
1105 /**
1106 * mipi_dsi_dcs_get_pixel_format() - gets the pixel format for the RGB image
1107 * data used by the interface
1108 * @dsi: DSI peripheral device
1109 * @format: return location for the pixel format
1110 *
1111 * Return: 0 on success or a negative error code on failure.
1112 */
mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device * dsi,u8 * format)1113 int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format)
1114 {
1115 ssize_t err;
1116
1117 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format,
1118 sizeof(*format));
1119 if (err <= 0) {
1120 if (err == 0)
1121 err = -ENODATA;
1122
1123 return err;
1124 }
1125
1126 return 0;
1127 }
1128 EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format);
1129
1130 /**
1131 * mipi_dsi_dcs_enter_sleep_mode() - disable all unnecessary blocks inside the
1132 * display module except interface communication
1133 * @dsi: DSI peripheral device
1134 *
1135 * This function is deprecated. Use mipi_dsi_dcs_enter_sleep_mode_multi() instead.
1136 *
1137 * Return: 0 on success or a negative error code on failure.
1138 */
mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device * dsi)1139 int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi)
1140 {
1141 ssize_t err;
1142
1143 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0);
1144 if (err < 0)
1145 return err;
1146
1147 return 0;
1148 }
1149 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode);
1150
1151 /**
1152 * mipi_dsi_dcs_exit_sleep_mode() - enable all blocks inside the display
1153 * module
1154 * @dsi: DSI peripheral device
1155 *
1156 * This function is deprecated. Use mipi_dsi_dcs_exit_sleep_mode_multi() instead.
1157 *
1158 * Return: 0 on success or a negative error code on failure.
1159 */
mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device * dsi)1160 int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi)
1161 {
1162 ssize_t err;
1163
1164 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0);
1165 if (err < 0)
1166 return err;
1167
1168 return 0;
1169 }
1170 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode);
1171
1172 /**
1173 * mipi_dsi_dcs_set_display_off() - stop displaying the image data on the
1174 * display device
1175 * @dsi: DSI peripheral device
1176 *
1177 * This function is deprecated. Use mipi_dsi_dcs_set_display_off_multi() instead.
1178 *
1179 * Return: 0 on success or a negative error code on failure.
1180 */
mipi_dsi_dcs_set_display_off(struct mipi_dsi_device * dsi)1181 int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi)
1182 {
1183 ssize_t err;
1184
1185 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0);
1186 if (err < 0)
1187 return err;
1188
1189 return 0;
1190 }
1191 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off);
1192
1193 /**
1194 * mipi_dsi_dcs_set_display_on() - start displaying the image data on the
1195 * display device
1196 * @dsi: DSI peripheral device
1197 *
1198 * This function is deprecated. Use mipi_dsi_dcs_set_display_on_multi() instead.
1199 *
1200 * Return: 0 on success or a negative error code on failure
1201 */
mipi_dsi_dcs_set_display_on(struct mipi_dsi_device * dsi)1202 int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi)
1203 {
1204 ssize_t err;
1205
1206 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0);
1207 if (err < 0)
1208 return err;
1209
1210 return 0;
1211 }
1212 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on);
1213
1214 /**
1215 * mipi_dsi_dcs_set_column_address() - define the column extent of the frame
1216 * memory accessed by the host processor
1217 * @dsi: DSI peripheral device
1218 * @start: first column of frame memory
1219 * @end: last column of frame memory
1220 *
1221 * This function is deprecated. Use mipi_dsi_dcs_set_column_address_multi()
1222 * instead.
1223 *
1224 * Return: 0 on success or a negative error code on failure.
1225 */
mipi_dsi_dcs_set_column_address(struct mipi_dsi_device * dsi,u16 start,u16 end)1226 int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
1227 u16 end)
1228 {
1229 u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
1230 ssize_t err;
1231
1232 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload,
1233 sizeof(payload));
1234 if (err < 0)
1235 return err;
1236
1237 return 0;
1238 }
1239 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address);
1240
1241 /**
1242 * mipi_dsi_dcs_set_page_address() - define the page extent of the frame
1243 * memory accessed by the host processor
1244 * @dsi: DSI peripheral device
1245 * @start: first page of frame memory
1246 * @end: last page of frame memory
1247 *
1248 * This function is deprecated. Use mipi_dsi_dcs_set_page_address_multi()
1249 * instead.
1250 *
1251 * Return: 0 on success or a negative error code on failure.
1252 */
mipi_dsi_dcs_set_page_address(struct mipi_dsi_device * dsi,u16 start,u16 end)1253 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
1254 u16 end)
1255 {
1256 u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
1257 ssize_t err;
1258
1259 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload,
1260 sizeof(payload));
1261 if (err < 0)
1262 return err;
1263
1264 return 0;
1265 }
1266 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address);
1267
1268 /**
1269 * mipi_dsi_dcs_set_tear_on() - turn on the display module's Tearing Effect
1270 * output signal on the TE signal line.
1271 * @dsi: DSI peripheral device
1272 * @mode: the Tearing Effect Output Line mode
1273 *
1274 * This function is deprecated. Use mipi_dsi_dcs_set_tear_on_multi() instead.
1275 *
1276 * Return: 0 on success or a negative error code on failure
1277 */
mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device * dsi,enum mipi_dsi_dcs_tear_mode mode)1278 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
1279 enum mipi_dsi_dcs_tear_mode mode)
1280 {
1281 u8 value = mode;
1282 ssize_t err;
1283
1284 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value,
1285 sizeof(value));
1286 if (err < 0)
1287 return err;
1288
1289 return 0;
1290 }
1291 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on);
1292
1293 /**
1294 * mipi_dsi_dcs_set_pixel_format() - sets the pixel format for the RGB image
1295 * data used by the interface
1296 * @dsi: DSI peripheral device
1297 * @format: pixel format
1298 *
1299 * This function is deprecated. Use mipi_dsi_dcs_set_pixel_format_multi()
1300 * instead.
1301 *
1302 * Return: 0 on success or a negative error code on failure.
1303 */
mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device * dsi,u8 format)1304 int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format)
1305 {
1306 ssize_t err;
1307
1308 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format,
1309 sizeof(format));
1310 if (err < 0)
1311 return err;
1312
1313 return 0;
1314 }
1315 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format);
1316
1317 /**
1318 * mipi_dsi_dcs_set_tear_scanline() - set the scanline to use as trigger for
1319 * the Tearing Effect output signal of the display module
1320 * @dsi: DSI peripheral device
1321 * @scanline: scanline to use as trigger
1322 *
1323 * This function is deprecated. Use mipi_dsi_dcs_set_tear_scanline_multi()
1324 * instead.
1325 *
1326 * Return: 0 on success or a negative error code on failure
1327 */
mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device * dsi,u16 scanline)1328 int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline)
1329 {
1330 u8 payload[2] = { scanline >> 8, scanline & 0xff };
1331 ssize_t err;
1332
1333 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_SCANLINE, payload,
1334 sizeof(payload));
1335 if (err < 0)
1336 return err;
1337
1338 return 0;
1339 }
1340 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline);
1341
1342 /**
1343 * mipi_dsi_dcs_set_display_brightness() - sets the brightness value of the
1344 * display
1345 * @dsi: DSI peripheral device
1346 * @brightness: brightness value
1347 *
1348 * This function is deprecated. Use mipi_dsi_dcs_set_display_brightness_multi()
1349 * instead.
1350 *
1351 * Return: 0 on success or a negative error code on failure.
1352 */
mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device * dsi,u16 brightness)1353 int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi,
1354 u16 brightness)
1355 {
1356 u8 payload[2] = { brightness & 0xff, brightness >> 8 };
1357 ssize_t err;
1358
1359 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
1360 payload, sizeof(payload));
1361 if (err < 0)
1362 return err;
1363
1364 return 0;
1365 }
1366 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness);
1367
1368 /**
1369 * mipi_dsi_dcs_get_display_brightness() - gets the current brightness value
1370 * of the display
1371 * @dsi: DSI peripheral device
1372 * @brightness: brightness value
1373 *
1374 * Return: 0 on success or a negative error code on failure.
1375 */
mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device * dsi,u16 * brightness)1376 int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi,
1377 u16 *brightness)
1378 {
1379 ssize_t err;
1380
1381 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
1382 brightness, sizeof(*brightness));
1383 if (err <= 0) {
1384 if (err == 0)
1385 err = -ENODATA;
1386
1387 return err;
1388 }
1389
1390 return 0;
1391 }
1392 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness);
1393
1394 /**
1395 * mipi_dsi_dcs_set_display_brightness_large() - sets the 16-bit brightness value
1396 * of the display
1397 * @dsi: DSI peripheral device
1398 * @brightness: brightness value
1399 *
1400 * Return: 0 on success or a negative error code on failure.
1401 */
mipi_dsi_dcs_set_display_brightness_large(struct mipi_dsi_device * dsi,u16 brightness)1402 int mipi_dsi_dcs_set_display_brightness_large(struct mipi_dsi_device *dsi,
1403 u16 brightness)
1404 {
1405 u8 payload[2] = { brightness >> 8, brightness & 0xff };
1406 ssize_t err;
1407
1408 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
1409 payload, sizeof(payload));
1410 if (err < 0)
1411 return err;
1412
1413 return 0;
1414 }
1415 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness_large);
1416
1417 /**
1418 * mipi_dsi_dcs_get_display_brightness_large() - gets the current 16-bit
1419 * brightness value of the display
1420 * @dsi: DSI peripheral device
1421 * @brightness: brightness value
1422 *
1423 * Return: 0 on success or a negative error code on failure.
1424 */
mipi_dsi_dcs_get_display_brightness_large(struct mipi_dsi_device * dsi,u16 * brightness)1425 int mipi_dsi_dcs_get_display_brightness_large(struct mipi_dsi_device *dsi,
1426 u16 *brightness)
1427 {
1428 u8 brightness_be[2];
1429 ssize_t err;
1430
1431 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
1432 brightness_be, sizeof(brightness_be));
1433 if (err <= 0) {
1434 if (err == 0)
1435 err = -ENODATA;
1436
1437 return err;
1438 }
1439
1440 *brightness = (brightness_be[0] << 8) | brightness_be[1];
1441
1442 return 0;
1443 }
1444 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness_large);
1445
1446 /**
1447 * mipi_dsi_picture_parameter_set_multi() - transmit the DSC PPS to the peripheral
1448 * @ctx: Context for multiple DSI transactions
1449 * @pps: VESA DSC 1.1 Picture Parameter Set
1450 *
1451 * Like mipi_dsi_picture_parameter_set() but deals with errors in a way that
1452 * makes it convenient to make several calls in a row.
1453 */
mipi_dsi_picture_parameter_set_multi(struct mipi_dsi_multi_context * ctx,const struct drm_dsc_picture_parameter_set * pps)1454 void mipi_dsi_picture_parameter_set_multi(struct mipi_dsi_multi_context *ctx,
1455 const struct drm_dsc_picture_parameter_set *pps)
1456 {
1457 struct mipi_dsi_device *dsi = ctx->dsi;
1458 struct device *dev = &dsi->dev;
1459 ssize_t ret;
1460
1461 if (ctx->accum_err)
1462 return;
1463
1464 ret = mipi_dsi_picture_parameter_set(dsi, pps);
1465 if (ret < 0) {
1466 ctx->accum_err = ret;
1467 dev_err(dev, "sending PPS failed: %d\n",
1468 ctx->accum_err);
1469 }
1470 }
1471 EXPORT_SYMBOL(mipi_dsi_picture_parameter_set_multi);
1472
1473 /**
1474 * mipi_dsi_compression_mode_ext_multi() - enable/disable DSC on the peripheral
1475 * @ctx: Context for multiple DSI transactions
1476 * @enable: Whether to enable or disable the DSC
1477 * @algo: Selected compression algorithm
1478 * @pps_selector: Select PPS from the table of pre-stored or uploaded PPS entries
1479 *
1480 * Like mipi_dsi_compression_mode_ext() but deals with errors in a way that
1481 * makes it convenient to make several calls in a row.
1482 */
mipi_dsi_compression_mode_ext_multi(struct mipi_dsi_multi_context * ctx,bool enable,enum mipi_dsi_compression_algo algo,unsigned int pps_selector)1483 void mipi_dsi_compression_mode_ext_multi(struct mipi_dsi_multi_context *ctx,
1484 bool enable,
1485 enum mipi_dsi_compression_algo algo,
1486 unsigned int pps_selector)
1487 {
1488 struct mipi_dsi_device *dsi = ctx->dsi;
1489 struct device *dev = &dsi->dev;
1490 ssize_t ret;
1491
1492 if (ctx->accum_err)
1493 return;
1494
1495 ret = mipi_dsi_compression_mode_ext(dsi, enable, algo, pps_selector);
1496 if (ret < 0) {
1497 ctx->accum_err = ret;
1498 dev_err(dev, "sending COMPRESSION_MODE failed: %d\n",
1499 ctx->accum_err);
1500 }
1501 }
1502 EXPORT_SYMBOL(mipi_dsi_compression_mode_ext_multi);
1503
1504 /**
1505 * mipi_dsi_compression_mode_multi() - enable/disable DSC on the peripheral
1506 * @ctx: Context for multiple DSI transactions
1507 * @enable: Whether to enable or disable the DSC
1508 *
1509 * Enable or disable Display Stream Compression on the peripheral using the
1510 * default Picture Parameter Set and VESA DSC 1.1 algorithm.
1511 */
mipi_dsi_compression_mode_multi(struct mipi_dsi_multi_context * ctx,bool enable)1512 void mipi_dsi_compression_mode_multi(struct mipi_dsi_multi_context *ctx,
1513 bool enable)
1514 {
1515 return mipi_dsi_compression_mode_ext_multi(ctx, enable,
1516 MIPI_DSI_COMPRESSION_DSC, 0);
1517 }
1518 EXPORT_SYMBOL(mipi_dsi_compression_mode_multi);
1519
1520 /**
1521 * mipi_dsi_dcs_nop_multi() - send DCS NOP packet
1522 * @ctx: Context for multiple DSI transactions
1523 *
1524 * Like mipi_dsi_dcs_nop() but deals with errors in a way that
1525 * makes it convenient to make several calls in a row.
1526 */
mipi_dsi_dcs_nop_multi(struct mipi_dsi_multi_context * ctx)1527 void mipi_dsi_dcs_nop_multi(struct mipi_dsi_multi_context *ctx)
1528 {
1529 struct mipi_dsi_device *dsi = ctx->dsi;
1530 struct device *dev = &dsi->dev;
1531 ssize_t ret;
1532
1533 if (ctx->accum_err)
1534 return;
1535
1536 ret = mipi_dsi_dcs_nop(dsi);
1537 if (ret < 0) {
1538 ctx->accum_err = ret;
1539 dev_err(dev, "sending DCS NOP failed: %d\n",
1540 ctx->accum_err);
1541 }
1542 }
1543 EXPORT_SYMBOL(mipi_dsi_dcs_nop_multi);
1544
1545 /**
1546 * mipi_dsi_dcs_enter_sleep_mode_multi() - send DCS ENTER_SLEEP_MODE packet
1547 * @ctx: Context for multiple DSI transactions
1548 *
1549 * Like mipi_dsi_dcs_enter_sleep_mode() but deals with errors in a way that
1550 * makes it convenient to make several calls in a row.
1551 */
mipi_dsi_dcs_enter_sleep_mode_multi(struct mipi_dsi_multi_context * ctx)1552 void mipi_dsi_dcs_enter_sleep_mode_multi(struct mipi_dsi_multi_context *ctx)
1553 {
1554 struct mipi_dsi_device *dsi = ctx->dsi;
1555 struct device *dev = &dsi->dev;
1556 ssize_t ret;
1557
1558 if (ctx->accum_err)
1559 return;
1560
1561 ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
1562 if (ret < 0) {
1563 ctx->accum_err = ret;
1564 dev_err(dev, "sending DCS ENTER_SLEEP_MODE failed: %d\n",
1565 ctx->accum_err);
1566 }
1567 }
1568 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode_multi);
1569
1570 /**
1571 * mipi_dsi_dcs_exit_sleep_mode_multi() - send DCS EXIT_SLEEP_MODE packet
1572 * @ctx: Context for multiple DSI transactions
1573 *
1574 * Like mipi_dsi_dcs_exit_sleep_mode() but deals with errors in a way that
1575 * makes it convenient to make several calls in a row.
1576 */
mipi_dsi_dcs_exit_sleep_mode_multi(struct mipi_dsi_multi_context * ctx)1577 void mipi_dsi_dcs_exit_sleep_mode_multi(struct mipi_dsi_multi_context *ctx)
1578 {
1579 struct mipi_dsi_device *dsi = ctx->dsi;
1580 struct device *dev = &dsi->dev;
1581 ssize_t ret;
1582
1583 if (ctx->accum_err)
1584 return;
1585
1586 ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
1587 if (ret < 0) {
1588 ctx->accum_err = ret;
1589 dev_err(dev, "sending DCS EXIT_SLEEP_MODE failed: %d\n",
1590 ctx->accum_err);
1591 }
1592 }
1593 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode_multi);
1594
1595 /**
1596 * mipi_dsi_dcs_set_display_off_multi() - send DCS SET_DISPLAY_OFF packet
1597 * @ctx: Context for multiple DSI transactions
1598 *
1599 * Like mipi_dsi_dcs_set_display_off() but deals with errors in a way that
1600 * makes it convenient to make several calls in a row.
1601 */
mipi_dsi_dcs_set_display_off_multi(struct mipi_dsi_multi_context * ctx)1602 void mipi_dsi_dcs_set_display_off_multi(struct mipi_dsi_multi_context *ctx)
1603 {
1604 struct mipi_dsi_device *dsi = ctx->dsi;
1605 struct device *dev = &dsi->dev;
1606 ssize_t ret;
1607
1608 if (ctx->accum_err)
1609 return;
1610
1611 ret = mipi_dsi_dcs_set_display_off(dsi);
1612 if (ret < 0) {
1613 ctx->accum_err = ret;
1614 dev_err(dev, "sending DCS SET_DISPLAY_OFF failed: %d\n",
1615 ctx->accum_err);
1616 }
1617 }
1618 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off_multi);
1619
1620 /**
1621 * mipi_dsi_dcs_set_display_on_multi() - send DCS SET_DISPLAY_ON packet
1622 * @ctx: Context for multiple DSI transactions
1623 *
1624 * Like mipi_dsi_dcs_set_display_on() but deals with errors in a way that
1625 * makes it convenient to make several calls in a row.
1626 */
mipi_dsi_dcs_set_display_on_multi(struct mipi_dsi_multi_context * ctx)1627 void mipi_dsi_dcs_set_display_on_multi(struct mipi_dsi_multi_context *ctx)
1628 {
1629 struct mipi_dsi_device *dsi = ctx->dsi;
1630 struct device *dev = &dsi->dev;
1631 ssize_t ret;
1632
1633 if (ctx->accum_err)
1634 return;
1635
1636 ret = mipi_dsi_dcs_set_display_on(dsi);
1637 if (ret < 0) {
1638 ctx->accum_err = ret;
1639 dev_err(dev, "sending DCS SET_DISPLAY_ON failed: %d\n",
1640 ctx->accum_err);
1641 }
1642 }
1643 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on_multi);
1644
1645 /**
1646 * mipi_dsi_dcs_set_tear_on_multi() - send DCS SET_TEAR_ON packet
1647 * @ctx: Context for multiple DSI transactions
1648 * @mode: the Tearing Effect Output Line mode
1649 *
1650 * Like mipi_dsi_dcs_set_tear_on() but deals with errors in a way that
1651 * makes it convenient to make several calls in a row.
1652 */
mipi_dsi_dcs_set_tear_on_multi(struct mipi_dsi_multi_context * ctx,enum mipi_dsi_dcs_tear_mode mode)1653 void mipi_dsi_dcs_set_tear_on_multi(struct mipi_dsi_multi_context *ctx,
1654 enum mipi_dsi_dcs_tear_mode mode)
1655 {
1656 struct mipi_dsi_device *dsi = ctx->dsi;
1657 struct device *dev = &dsi->dev;
1658 ssize_t ret;
1659
1660 if (ctx->accum_err)
1661 return;
1662
1663 ret = mipi_dsi_dcs_set_tear_on(dsi, mode);
1664 if (ret < 0) {
1665 ctx->accum_err = ret;
1666 dev_err(dev, "sending DCS SET_TEAR_ON failed: %d\n",
1667 ctx->accum_err);
1668 }
1669 }
1670 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on_multi);
1671
1672 /**
1673 * mipi_dsi_turn_on_peripheral_multi() - sends a Turn On Peripheral command
1674 * @ctx: Context for multiple DSI transactions
1675 *
1676 * Like mipi_dsi_turn_on_peripheral() but deals with errors in a way that
1677 * makes it convenient to make several calls in a row.
1678 */
mipi_dsi_turn_on_peripheral_multi(struct mipi_dsi_multi_context * ctx)1679 void mipi_dsi_turn_on_peripheral_multi(struct mipi_dsi_multi_context *ctx)
1680 {
1681 struct mipi_dsi_device *dsi = ctx->dsi;
1682 struct device *dev = &dsi->dev;
1683 int ret;
1684
1685 if (ctx->accum_err)
1686 return;
1687
1688 ret = mipi_dsi_turn_on_peripheral(dsi);
1689 if (ret < 0) {
1690 ctx->accum_err = ret;
1691 dev_err(dev, "Failed to turn on peripheral: %d\n",
1692 ctx->accum_err);
1693 }
1694 }
1695 EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral_multi);
1696
1697 /**
1698 * mipi_dsi_dcs_set_tear_off_multi() - turn off the display module's Tearing Effect
1699 * output signal on the TE signal line
1700 * @ctx: Context for multiple DSI transactions
1701 */
mipi_dsi_dcs_set_tear_off_multi(struct mipi_dsi_multi_context * ctx)1702 void mipi_dsi_dcs_set_tear_off_multi(struct mipi_dsi_multi_context *ctx)
1703 {
1704 struct mipi_dsi_device *dsi = ctx->dsi;
1705 struct device *dev = &dsi->dev;
1706 ssize_t err;
1707
1708 if (ctx->accum_err)
1709 return;
1710
1711 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0);
1712 if (err < 0) {
1713 ctx->accum_err = err;
1714 dev_err(dev, "Failed to set tear off: %d\n",
1715 ctx->accum_err);
1716 }
1717 }
1718 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off_multi);
1719
1720 /**
1721 * mipi_dsi_dcs_soft_reset_multi() - perform a software reset of the display module
1722 * @ctx: Context for multiple DSI transactions
1723 *
1724 * Like mipi_dsi_dcs_soft_reset() but deals with errors in a way that
1725 * makes it convenient to make several calls in a row.
1726 */
mipi_dsi_dcs_soft_reset_multi(struct mipi_dsi_multi_context * ctx)1727 void mipi_dsi_dcs_soft_reset_multi(struct mipi_dsi_multi_context *ctx)
1728 {
1729 struct mipi_dsi_device *dsi = ctx->dsi;
1730 struct device *dev = &dsi->dev;
1731 int ret;
1732
1733 if (ctx->accum_err)
1734 return;
1735
1736 ret = mipi_dsi_dcs_soft_reset(dsi);
1737 if (ret < 0) {
1738 ctx->accum_err = ret;
1739 dev_err(dev, "Failed to mipi_dsi_dcs_soft_reset: %d\n",
1740 ctx->accum_err);
1741 }
1742 }
1743 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset_multi);
1744
1745 /**
1746 * mipi_dsi_dcs_set_display_brightness_multi() - sets the brightness value of
1747 * the display
1748 * @ctx: Context for multiple DSI transactions
1749 * @brightness: brightness value
1750 *
1751 * Like mipi_dsi_dcs_set_display_brightness() but deals with errors in a way that
1752 * makes it convenient to make several calls in a row.
1753 */
mipi_dsi_dcs_set_display_brightness_multi(struct mipi_dsi_multi_context * ctx,u16 brightness)1754 void mipi_dsi_dcs_set_display_brightness_multi(struct mipi_dsi_multi_context *ctx,
1755 u16 brightness)
1756 {
1757 struct mipi_dsi_device *dsi = ctx->dsi;
1758 struct device *dev = &dsi->dev;
1759 int ret;
1760
1761 if (ctx->accum_err)
1762 return;
1763
1764 ret = mipi_dsi_dcs_set_display_brightness(dsi, brightness);
1765 if (ret < 0) {
1766 ctx->accum_err = ret;
1767 dev_err(dev, "Failed to write display brightness: %d\n",
1768 ctx->accum_err);
1769 }
1770 }
1771 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness_multi);
1772
1773 /**
1774 * mipi_dsi_dcs_set_pixel_format_multi() - sets the pixel format for the RGB image
1775 * data used by the interface
1776 * @ctx: Context for multiple DSI transactions
1777 * @format: pixel format
1778 *
1779 * Like mipi_dsi_dcs_set_pixel_format() but deals with errors in a way that
1780 * makes it convenient to make several calls in a row.
1781 */
mipi_dsi_dcs_set_pixel_format_multi(struct mipi_dsi_multi_context * ctx,u8 format)1782 void mipi_dsi_dcs_set_pixel_format_multi(struct mipi_dsi_multi_context *ctx,
1783 u8 format)
1784 {
1785 struct mipi_dsi_device *dsi = ctx->dsi;
1786 struct device *dev = &dsi->dev;
1787 int ret;
1788
1789 if (ctx->accum_err)
1790 return;
1791
1792 ret = mipi_dsi_dcs_set_pixel_format(dsi, format);
1793 if (ret < 0) {
1794 ctx->accum_err = ret;
1795 dev_err(dev, "Failed to set pixel format: %d\n",
1796 ctx->accum_err);
1797 }
1798 }
1799 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format_multi);
1800
1801 /**
1802 * mipi_dsi_dcs_set_column_address_multi() - define the column extent of the
1803 * frame memory accessed by the host processor
1804 * @ctx: Context for multiple DSI transactions
1805 * @start: first column of frame memory
1806 * @end: last column of frame memory
1807 *
1808 * Like mipi_dsi_dcs_set_column_address() but deals with errors in a way that
1809 * makes it convenient to make several calls in a row.
1810 */
mipi_dsi_dcs_set_column_address_multi(struct mipi_dsi_multi_context * ctx,u16 start,u16 end)1811 void mipi_dsi_dcs_set_column_address_multi(struct mipi_dsi_multi_context *ctx,
1812 u16 start, u16 end)
1813 {
1814 struct mipi_dsi_device *dsi = ctx->dsi;
1815 struct device *dev = &dsi->dev;
1816 int ret;
1817
1818 if (ctx->accum_err)
1819 return;
1820
1821 ret = mipi_dsi_dcs_set_column_address(dsi, start, end);
1822 if (ret < 0) {
1823 ctx->accum_err = ret;
1824 dev_err(dev, "Failed to set column address: %d\n",
1825 ctx->accum_err);
1826 }
1827 }
1828 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address_multi);
1829
1830 /**
1831 * mipi_dsi_dcs_set_page_address_multi() - define the page extent of the
1832 * frame memory accessed by the host processor
1833 * @ctx: Context for multiple DSI transactions
1834 * @start: first page of frame memory
1835 * @end: last page of frame memory
1836 *
1837 * Like mipi_dsi_dcs_set_page_address() but deals with errors in a way that
1838 * makes it convenient to make several calls in a row.
1839 */
mipi_dsi_dcs_set_page_address_multi(struct mipi_dsi_multi_context * ctx,u16 start,u16 end)1840 void mipi_dsi_dcs_set_page_address_multi(struct mipi_dsi_multi_context *ctx,
1841 u16 start, u16 end)
1842 {
1843 struct mipi_dsi_device *dsi = ctx->dsi;
1844 struct device *dev = &dsi->dev;
1845 int ret;
1846
1847 if (ctx->accum_err)
1848 return;
1849
1850 ret = mipi_dsi_dcs_set_page_address(dsi, start, end);
1851 if (ret < 0) {
1852 ctx->accum_err = ret;
1853 dev_err(dev, "Failed to set page address: %d\n",
1854 ctx->accum_err);
1855 }
1856 }
1857 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address_multi);
1858
1859 /**
1860 * mipi_dsi_dcs_set_tear_scanline_multi() - set the scanline to use as trigger for
1861 * the Tearing Effect output signal of the display module
1862 * @ctx: Context for multiple DSI transactions
1863 * @scanline: scanline to use as trigger
1864 *
1865 * Like mipi_dsi_dcs_set_tear_scanline() but deals with errors in a way that
1866 * makes it convenient to make several calls in a row.
1867 */
mipi_dsi_dcs_set_tear_scanline_multi(struct mipi_dsi_multi_context * ctx,u16 scanline)1868 void mipi_dsi_dcs_set_tear_scanline_multi(struct mipi_dsi_multi_context *ctx,
1869 u16 scanline)
1870 {
1871 struct mipi_dsi_device *dsi = ctx->dsi;
1872 struct device *dev = &dsi->dev;
1873 int ret;
1874
1875 if (ctx->accum_err)
1876 return;
1877
1878 ret = mipi_dsi_dcs_set_tear_scanline(dsi, scanline);
1879 if (ret < 0) {
1880 ctx->accum_err = ret;
1881 dev_err(dev, "Failed to set tear scanline: %d\n",
1882 ctx->accum_err);
1883 }
1884 }
1885 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline_multi);
1886
mipi_dsi_drv_probe(struct device * dev)1887 static int mipi_dsi_drv_probe(struct device *dev)
1888 {
1889 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1890 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1891
1892 return drv->probe(dsi);
1893 }
1894
mipi_dsi_drv_remove(struct device * dev)1895 static int mipi_dsi_drv_remove(struct device *dev)
1896 {
1897 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1898 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1899
1900 drv->remove(dsi);
1901
1902 return 0;
1903 }
1904
mipi_dsi_drv_shutdown(struct device * dev)1905 static void mipi_dsi_drv_shutdown(struct device *dev)
1906 {
1907 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1908 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1909
1910 drv->shutdown(dsi);
1911 }
1912
1913 /**
1914 * mipi_dsi_driver_register_full() - register a driver for DSI devices
1915 * @drv: DSI driver structure
1916 * @owner: owner module
1917 *
1918 * Return: 0 on success or a negative error code on failure.
1919 */
mipi_dsi_driver_register_full(struct mipi_dsi_driver * drv,struct module * owner)1920 int mipi_dsi_driver_register_full(struct mipi_dsi_driver *drv,
1921 struct module *owner)
1922 {
1923 drv->driver.bus = &mipi_dsi_bus_type;
1924 drv->driver.owner = owner;
1925
1926 if (drv->probe)
1927 drv->driver.probe = mipi_dsi_drv_probe;
1928 if (drv->remove)
1929 drv->driver.remove = mipi_dsi_drv_remove;
1930 if (drv->shutdown)
1931 drv->driver.shutdown = mipi_dsi_drv_shutdown;
1932
1933 return driver_register(&drv->driver);
1934 }
1935 EXPORT_SYMBOL(mipi_dsi_driver_register_full);
1936
1937 /**
1938 * mipi_dsi_driver_unregister() - unregister a driver for DSI devices
1939 * @drv: DSI driver structure
1940 *
1941 * Return: 0 on success or a negative error code on failure.
1942 */
mipi_dsi_driver_unregister(struct mipi_dsi_driver * drv)1943 void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
1944 {
1945 driver_unregister(&drv->driver);
1946 }
1947 EXPORT_SYMBOL(mipi_dsi_driver_unregister);
1948
mipi_dsi_bus_init(void)1949 static int __init mipi_dsi_bus_init(void)
1950 {
1951 return bus_register(&mipi_dsi_bus_type);
1952 }
1953 postcore_initcall(mipi_dsi_bus_init);
1954
1955 MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
1956 MODULE_DESCRIPTION("MIPI DSI Bus");
1957 MODULE_LICENSE("GPL and additional rights");
1958