This source file includes following definitions.
- mipi_dsi_device_match
- mipi_dsi_uevent
- of_find_mipi_dsi_device_by_node
- mipi_dsi_dev_release
- mipi_dsi_device_alloc
- mipi_dsi_device_add
- of_mipi_dsi_device_add
- of_mipi_dsi_device_add
- mipi_dsi_device_register_full
- mipi_dsi_device_unregister
- of_find_mipi_dsi_host_by_node
- mipi_dsi_host_register
- mipi_dsi_remove_device_fn
- mipi_dsi_host_unregister
- mipi_dsi_attach
- mipi_dsi_detach
- mipi_dsi_device_transfer
- mipi_dsi_packet_format_is_short
- mipi_dsi_packet_format_is_long
- mipi_dsi_create_packet
- mipi_dsi_shutdown_peripheral
- mipi_dsi_turn_on_peripheral
- mipi_dsi_set_maximum_return_packet_size
- mipi_dsi_generic_write
- mipi_dsi_generic_read
- mipi_dsi_dcs_write_buffer
- mipi_dsi_dcs_write
- mipi_dsi_dcs_read
- mipi_dsi_dcs_nop
- mipi_dsi_dcs_soft_reset
- mipi_dsi_dcs_get_power_mode
- mipi_dsi_dcs_get_pixel_format
- mipi_dsi_dcs_enter_sleep_mode
- mipi_dsi_dcs_exit_sleep_mode
- mipi_dsi_dcs_set_display_off
- mipi_dsi_dcs_set_display_on
- mipi_dsi_dcs_set_column_address
- mipi_dsi_dcs_set_page_address
- mipi_dsi_dcs_set_tear_off
- mipi_dsi_dcs_set_tear_on
- mipi_dsi_dcs_set_pixel_format
- mipi_dsi_dcs_set_tear_scanline
- mipi_dsi_dcs_set_display_brightness
- mipi_dsi_dcs_get_display_brightness
- mipi_dsi_drv_probe
- mipi_dsi_drv_remove
- mipi_dsi_drv_shutdown
- mipi_dsi_driver_register_full
- mipi_dsi_driver_unregister
- mipi_dsi_bus_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 #include <drm/drm_mipi_dsi.h>
29
30 #include <linux/device.h>
31 #include <linux/module.h>
32 #include <linux/of_device.h>
33 #include <linux/pm_runtime.h>
34 #include <linux/slab.h>
35
36 #include <video/mipi_display.h>
37
38
39
40
41
42
43
44
45
46
47
48 static int mipi_dsi_device_match(struct device *dev, struct device_driver *drv)
49 {
50 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
51
52
53 if (of_driver_match_device(dev, drv))
54 return 1;
55
56
57 if (!strcmp(dsi->name, drv->name))
58 return 1;
59
60 return 0;
61 }
62
63 static int mipi_dsi_uevent(struct device *dev, struct kobj_uevent_env *env)
64 {
65 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
66 int err;
67
68 err = of_device_uevent_modalias(dev, env);
69 if (err != -ENODEV)
70 return err;
71
72 add_uevent_var(env, "MODALIAS=%s%s", MIPI_DSI_MODULE_PREFIX,
73 dsi->name);
74
75 return 0;
76 }
77
78 static const struct dev_pm_ops mipi_dsi_device_pm_ops = {
79 .runtime_suspend = pm_generic_runtime_suspend,
80 .runtime_resume = pm_generic_runtime_resume,
81 .suspend = pm_generic_suspend,
82 .resume = pm_generic_resume,
83 .freeze = pm_generic_freeze,
84 .thaw = pm_generic_thaw,
85 .poweroff = pm_generic_poweroff,
86 .restore = pm_generic_restore,
87 };
88
89 static struct bus_type mipi_dsi_bus_type = {
90 .name = "mipi-dsi",
91 .match = mipi_dsi_device_match,
92 .uevent = mipi_dsi_uevent,
93 .pm = &mipi_dsi_device_pm_ops,
94 };
95
96
97
98
99
100
101
102
103
104 struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np)
105 {
106 struct device *dev;
107
108 dev = bus_find_device_by_of_node(&mipi_dsi_bus_type, np);
109
110 return dev ? to_mipi_dsi_device(dev) : NULL;
111 }
112 EXPORT_SYMBOL(of_find_mipi_dsi_device_by_node);
113
114 static void mipi_dsi_dev_release(struct device *dev)
115 {
116 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
117
118 of_node_put(dev->of_node);
119 kfree(dsi);
120 }
121
122 static const struct device_type mipi_dsi_device_type = {
123 .release = mipi_dsi_dev_release,
124 };
125
126 static struct mipi_dsi_device *mipi_dsi_device_alloc(struct mipi_dsi_host *host)
127 {
128 struct mipi_dsi_device *dsi;
129
130 dsi = kzalloc(sizeof(*dsi), GFP_KERNEL);
131 if (!dsi)
132 return ERR_PTR(-ENOMEM);
133
134 dsi->host = host;
135 dsi->dev.bus = &mipi_dsi_bus_type;
136 dsi->dev.parent = host->dev;
137 dsi->dev.type = &mipi_dsi_device_type;
138
139 device_initialize(&dsi->dev);
140
141 return dsi;
142 }
143
144 static int mipi_dsi_device_add(struct mipi_dsi_device *dsi)
145 {
146 struct mipi_dsi_host *host = dsi->host;
147
148 dev_set_name(&dsi->dev, "%s.%d", dev_name(host->dev), dsi->channel);
149
150 return device_add(&dsi->dev);
151 }
152
153 #if IS_ENABLED(CONFIG_OF)
154 static struct mipi_dsi_device *
155 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
156 {
157 struct device *dev = host->dev;
158 struct mipi_dsi_device_info info = { };
159 int ret;
160 u32 reg;
161
162 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0) {
163 dev_err(dev, "modalias failure on %pOF\n", node);
164 return ERR_PTR(-EINVAL);
165 }
166
167 ret = of_property_read_u32(node, "reg", ®);
168 if (ret) {
169 dev_err(dev, "device node %pOF has no valid reg property: %d\n",
170 node, ret);
171 return ERR_PTR(-EINVAL);
172 }
173
174 info.channel = reg;
175 info.node = of_node_get(node);
176
177 return mipi_dsi_device_register_full(host, &info);
178 }
179 #else
180 static struct mipi_dsi_device *
181 of_mipi_dsi_device_add(struct mipi_dsi_host *host, struct device_node *node)
182 {
183 return ERR_PTR(-ENODEV);
184 }
185 #endif
186
187
188
189
190
191
192
193
194
195
196
197
198
199 struct mipi_dsi_device *
200 mipi_dsi_device_register_full(struct mipi_dsi_host *host,
201 const struct mipi_dsi_device_info *info)
202 {
203 struct mipi_dsi_device *dsi;
204 struct device *dev = host->dev;
205 int ret;
206
207 if (!info) {
208 dev_err(dev, "invalid mipi_dsi_device_info pointer\n");
209 return ERR_PTR(-EINVAL);
210 }
211
212 if (info->channel > 3) {
213 dev_err(dev, "invalid virtual channel: %u\n", info->channel);
214 return ERR_PTR(-EINVAL);
215 }
216
217 dsi = mipi_dsi_device_alloc(host);
218 if (IS_ERR(dsi)) {
219 dev_err(dev, "failed to allocate DSI device %ld\n",
220 PTR_ERR(dsi));
221 return dsi;
222 }
223
224 dsi->dev.of_node = info->node;
225 dsi->channel = info->channel;
226 strlcpy(dsi->name, info->type, sizeof(dsi->name));
227
228 ret = mipi_dsi_device_add(dsi);
229 if (ret) {
230 dev_err(dev, "failed to add DSI device %d\n", ret);
231 kfree(dsi);
232 return ERR_PTR(ret);
233 }
234
235 return dsi;
236 }
237 EXPORT_SYMBOL(mipi_dsi_device_register_full);
238
239
240
241
242
243 void mipi_dsi_device_unregister(struct mipi_dsi_device *dsi)
244 {
245 device_unregister(&dsi->dev);
246 }
247 EXPORT_SYMBOL(mipi_dsi_device_unregister);
248
249 static DEFINE_MUTEX(host_lock);
250 static LIST_HEAD(host_list);
251
252
253
254
255
256
257
258
259
260
261 struct mipi_dsi_host *of_find_mipi_dsi_host_by_node(struct device_node *node)
262 {
263 struct mipi_dsi_host *host;
264
265 mutex_lock(&host_lock);
266
267 list_for_each_entry(host, &host_list, list) {
268 if (host->dev->of_node == node) {
269 mutex_unlock(&host_lock);
270 return host;
271 }
272 }
273
274 mutex_unlock(&host_lock);
275
276 return NULL;
277 }
278 EXPORT_SYMBOL(of_find_mipi_dsi_host_by_node);
279
280 int mipi_dsi_host_register(struct mipi_dsi_host *host)
281 {
282 struct device_node *node;
283
284 for_each_available_child_of_node(host->dev->of_node, node) {
285
286 if (!of_find_property(node, "reg", NULL))
287 continue;
288 of_mipi_dsi_device_add(host, node);
289 }
290
291 mutex_lock(&host_lock);
292 list_add_tail(&host->list, &host_list);
293 mutex_unlock(&host_lock);
294
295 return 0;
296 }
297 EXPORT_SYMBOL(mipi_dsi_host_register);
298
299 static int mipi_dsi_remove_device_fn(struct device *dev, void *priv)
300 {
301 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
302
303 mipi_dsi_device_unregister(dsi);
304
305 return 0;
306 }
307
308 void mipi_dsi_host_unregister(struct mipi_dsi_host *host)
309 {
310 device_for_each_child(host->dev, NULL, mipi_dsi_remove_device_fn);
311
312 mutex_lock(&host_lock);
313 list_del_init(&host->list);
314 mutex_unlock(&host_lock);
315 }
316 EXPORT_SYMBOL(mipi_dsi_host_unregister);
317
318
319
320
321
322 int mipi_dsi_attach(struct mipi_dsi_device *dsi)
323 {
324 const struct mipi_dsi_host_ops *ops = dsi->host->ops;
325
326 if (!ops || !ops->attach)
327 return -ENOSYS;
328
329 return ops->attach(dsi->host, dsi);
330 }
331 EXPORT_SYMBOL(mipi_dsi_attach);
332
333
334
335
336
337 int mipi_dsi_detach(struct mipi_dsi_device *dsi)
338 {
339 const struct mipi_dsi_host_ops *ops = dsi->host->ops;
340
341 if (!ops || !ops->detach)
342 return -ENOSYS;
343
344 return ops->detach(dsi->host, dsi);
345 }
346 EXPORT_SYMBOL(mipi_dsi_detach);
347
348 static ssize_t mipi_dsi_device_transfer(struct mipi_dsi_device *dsi,
349 struct mipi_dsi_msg *msg)
350 {
351 const struct mipi_dsi_host_ops *ops = dsi->host->ops;
352
353 if (!ops || !ops->transfer)
354 return -ENOSYS;
355
356 if (dsi->mode_flags & MIPI_DSI_MODE_LPM)
357 msg->flags |= MIPI_DSI_MSG_USE_LPM;
358
359 return ops->transfer(dsi->host, msg);
360 }
361
362
363
364
365
366
367
368
369 bool mipi_dsi_packet_format_is_short(u8 type)
370 {
371 switch (type) {
372 case MIPI_DSI_V_SYNC_START:
373 case MIPI_DSI_V_SYNC_END:
374 case MIPI_DSI_H_SYNC_START:
375 case MIPI_DSI_H_SYNC_END:
376 case MIPI_DSI_END_OF_TRANSMISSION:
377 case MIPI_DSI_COLOR_MODE_OFF:
378 case MIPI_DSI_COLOR_MODE_ON:
379 case MIPI_DSI_SHUTDOWN_PERIPHERAL:
380 case MIPI_DSI_TURN_ON_PERIPHERAL:
381 case MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM:
382 case MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM:
383 case MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM:
384 case MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM:
385 case MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM:
386 case MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM:
387 case MIPI_DSI_DCS_SHORT_WRITE:
388 case MIPI_DSI_DCS_SHORT_WRITE_PARAM:
389 case MIPI_DSI_DCS_READ:
390 case MIPI_DSI_DCS_COMPRESSION_MODE:
391 case MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE:
392 return true;
393 }
394
395 return false;
396 }
397 EXPORT_SYMBOL(mipi_dsi_packet_format_is_short);
398
399
400
401
402
403
404
405
406 bool mipi_dsi_packet_format_is_long(u8 type)
407 {
408 switch (type) {
409 case MIPI_DSI_PPS_LONG_WRITE:
410 case MIPI_DSI_NULL_PACKET:
411 case MIPI_DSI_BLANKING_PACKET:
412 case MIPI_DSI_GENERIC_LONG_WRITE:
413 case MIPI_DSI_DCS_LONG_WRITE:
414 case MIPI_DSI_LOOSELY_PACKED_PIXEL_STREAM_YCBCR20:
415 case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR24:
416 case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR16:
417 case MIPI_DSI_PACKED_PIXEL_STREAM_30:
418 case MIPI_DSI_PACKED_PIXEL_STREAM_36:
419 case MIPI_DSI_PACKED_PIXEL_STREAM_YCBCR12:
420 case MIPI_DSI_PACKED_PIXEL_STREAM_16:
421 case MIPI_DSI_PACKED_PIXEL_STREAM_18:
422 case MIPI_DSI_PIXEL_STREAM_3BYTE_18:
423 case MIPI_DSI_PACKED_PIXEL_STREAM_24:
424 return true;
425 }
426
427 return false;
428 }
429 EXPORT_SYMBOL(mipi_dsi_packet_format_is_long);
430
431
432
433
434
435
436
437
438
439 int mipi_dsi_create_packet(struct mipi_dsi_packet *packet,
440 const struct mipi_dsi_msg *msg)
441 {
442 if (!packet || !msg)
443 return -EINVAL;
444
445
446 if (!mipi_dsi_packet_format_is_short(msg->type) &&
447 !mipi_dsi_packet_format_is_long(msg->type))
448 return -EINVAL;
449
450 if (msg->channel > 3)
451 return -EINVAL;
452
453 memset(packet, 0, sizeof(*packet));
454 packet->header[0] = ((msg->channel & 0x3) << 6) | (msg->type & 0x3f);
455
456
457
458
459
460
461
462
463
464
465 if (mipi_dsi_packet_format_is_long(msg->type)) {
466 packet->header[1] = (msg->tx_len >> 0) & 0xff;
467 packet->header[2] = (msg->tx_len >> 8) & 0xff;
468
469 packet->payload_length = msg->tx_len;
470 packet->payload = msg->tx_buf;
471 } else {
472 const u8 *tx = msg->tx_buf;
473
474 packet->header[1] = (msg->tx_len > 0) ? tx[0] : 0;
475 packet->header[2] = (msg->tx_len > 1) ? tx[1] : 0;
476 }
477
478 packet->size = sizeof(packet->header) + packet->payload_length;
479
480 return 0;
481 }
482 EXPORT_SYMBOL(mipi_dsi_create_packet);
483
484
485
486
487
488
489
490 int mipi_dsi_shutdown_peripheral(struct mipi_dsi_device *dsi)
491 {
492 struct mipi_dsi_msg msg = {
493 .channel = dsi->channel,
494 .type = MIPI_DSI_SHUTDOWN_PERIPHERAL,
495 .tx_buf = (u8 [2]) { 0, 0 },
496 .tx_len = 2,
497 };
498 int ret = mipi_dsi_device_transfer(dsi, &msg);
499
500 return (ret < 0) ? ret : 0;
501 }
502 EXPORT_SYMBOL(mipi_dsi_shutdown_peripheral);
503
504
505
506
507
508
509
510 int mipi_dsi_turn_on_peripheral(struct mipi_dsi_device *dsi)
511 {
512 struct mipi_dsi_msg msg = {
513 .channel = dsi->channel,
514 .type = MIPI_DSI_TURN_ON_PERIPHERAL,
515 .tx_buf = (u8 [2]) { 0, 0 },
516 .tx_len = 2,
517 };
518 int ret = mipi_dsi_device_transfer(dsi, &msg);
519
520 return (ret < 0) ? ret : 0;
521 }
522 EXPORT_SYMBOL(mipi_dsi_turn_on_peripheral);
523
524
525
526
527
528
529
530
531
532
533 int mipi_dsi_set_maximum_return_packet_size(struct mipi_dsi_device *dsi,
534 u16 value)
535 {
536 u8 tx[2] = { value & 0xff, value >> 8 };
537 struct mipi_dsi_msg msg = {
538 .channel = dsi->channel,
539 .type = MIPI_DSI_SET_MAXIMUM_RETURN_PACKET_SIZE,
540 .tx_len = sizeof(tx),
541 .tx_buf = tx,
542 };
543 int ret = mipi_dsi_device_transfer(dsi, &msg);
544
545 return (ret < 0) ? ret : 0;
546 }
547 EXPORT_SYMBOL(mipi_dsi_set_maximum_return_packet_size);
548
549
550
551
552
553
554
555
556
557
558
559
560
561 ssize_t mipi_dsi_generic_write(struct mipi_dsi_device *dsi, const void *payload,
562 size_t size)
563 {
564 struct mipi_dsi_msg msg = {
565 .channel = dsi->channel,
566 .tx_buf = payload,
567 .tx_len = size
568 };
569
570 switch (size) {
571 case 0:
572 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_0_PARAM;
573 break;
574
575 case 1:
576 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_1_PARAM;
577 break;
578
579 case 2:
580 msg.type = MIPI_DSI_GENERIC_SHORT_WRITE_2_PARAM;
581 break;
582
583 default:
584 msg.type = MIPI_DSI_GENERIC_LONG_WRITE;
585 break;
586 }
587
588 return mipi_dsi_device_transfer(dsi, &msg);
589 }
590 EXPORT_SYMBOL(mipi_dsi_generic_write);
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606 ssize_t mipi_dsi_generic_read(struct mipi_dsi_device *dsi, const void *params,
607 size_t num_params, void *data, size_t size)
608 {
609 struct mipi_dsi_msg msg = {
610 .channel = dsi->channel,
611 .tx_len = num_params,
612 .tx_buf = params,
613 .rx_len = size,
614 .rx_buf = data
615 };
616
617 switch (num_params) {
618 case 0:
619 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_0_PARAM;
620 break;
621
622 case 1:
623 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_1_PARAM;
624 break;
625
626 case 2:
627 msg.type = MIPI_DSI_GENERIC_READ_REQUEST_2_PARAM;
628 break;
629
630 default:
631 return -EINVAL;
632 }
633
634 return mipi_dsi_device_transfer(dsi, &msg);
635 }
636 EXPORT_SYMBOL(mipi_dsi_generic_read);
637
638
639
640
641
642
643
644
645
646
647
648
649
650 ssize_t mipi_dsi_dcs_write_buffer(struct mipi_dsi_device *dsi,
651 const void *data, size_t len)
652 {
653 struct mipi_dsi_msg msg = {
654 .channel = dsi->channel,
655 .tx_buf = data,
656 .tx_len = len
657 };
658
659 switch (len) {
660 case 0:
661 return -EINVAL;
662
663 case 1:
664 msg.type = MIPI_DSI_DCS_SHORT_WRITE;
665 break;
666
667 case 2:
668 msg.type = MIPI_DSI_DCS_SHORT_WRITE_PARAM;
669 break;
670
671 default:
672 msg.type = MIPI_DSI_DCS_LONG_WRITE;
673 break;
674 }
675
676 return mipi_dsi_device_transfer(dsi, &msg);
677 }
678 EXPORT_SYMBOL(mipi_dsi_dcs_write_buffer);
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693 ssize_t mipi_dsi_dcs_write(struct mipi_dsi_device *dsi, u8 cmd,
694 const void *data, size_t len)
695 {
696 ssize_t err;
697 size_t size;
698 u8 *tx;
699
700 if (len > 0) {
701 size = 1 + len;
702
703 tx = kmalloc(size, GFP_KERNEL);
704 if (!tx)
705 return -ENOMEM;
706
707
708 tx[0] = cmd;
709 memcpy(&tx[1], data, len);
710 } else {
711 tx = &cmd;
712 size = 1;
713 }
714
715 err = mipi_dsi_dcs_write_buffer(dsi, tx, size);
716
717 if (len > 0)
718 kfree(tx);
719
720 return err;
721 }
722 EXPORT_SYMBOL(mipi_dsi_dcs_write);
723
724
725
726
727
728
729
730
731
732
733 ssize_t mipi_dsi_dcs_read(struct mipi_dsi_device *dsi, u8 cmd, void *data,
734 size_t len)
735 {
736 struct mipi_dsi_msg msg = {
737 .channel = dsi->channel,
738 .type = MIPI_DSI_DCS_READ,
739 .tx_buf = &cmd,
740 .tx_len = 1,
741 .rx_buf = data,
742 .rx_len = len
743 };
744
745 return mipi_dsi_device_transfer(dsi, &msg);
746 }
747 EXPORT_SYMBOL(mipi_dsi_dcs_read);
748
749
750
751
752
753
754
755 int mipi_dsi_dcs_nop(struct mipi_dsi_device *dsi)
756 {
757 ssize_t err;
758
759 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_NOP, NULL, 0);
760 if (err < 0)
761 return err;
762
763 return 0;
764 }
765 EXPORT_SYMBOL(mipi_dsi_dcs_nop);
766
767
768
769
770
771
772
773 int mipi_dsi_dcs_soft_reset(struct mipi_dsi_device *dsi)
774 {
775 ssize_t err;
776
777 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SOFT_RESET, NULL, 0);
778 if (err < 0)
779 return err;
780
781 return 0;
782 }
783 EXPORT_SYMBOL(mipi_dsi_dcs_soft_reset);
784
785
786
787
788
789
790
791
792
793 int mipi_dsi_dcs_get_power_mode(struct mipi_dsi_device *dsi, u8 *mode)
794 {
795 ssize_t err;
796
797 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_POWER_MODE, mode,
798 sizeof(*mode));
799 if (err <= 0) {
800 if (err == 0)
801 err = -ENODATA;
802
803 return err;
804 }
805
806 return 0;
807 }
808 EXPORT_SYMBOL(mipi_dsi_dcs_get_power_mode);
809
810
811
812
813
814
815
816
817
818 int mipi_dsi_dcs_get_pixel_format(struct mipi_dsi_device *dsi, u8 *format)
819 {
820 ssize_t err;
821
822 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_PIXEL_FORMAT, format,
823 sizeof(*format));
824 if (err <= 0) {
825 if (err == 0)
826 err = -ENODATA;
827
828 return err;
829 }
830
831 return 0;
832 }
833 EXPORT_SYMBOL(mipi_dsi_dcs_get_pixel_format);
834
835
836
837
838
839
840
841
842 int mipi_dsi_dcs_enter_sleep_mode(struct mipi_dsi_device *dsi)
843 {
844 ssize_t err;
845
846 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_ENTER_SLEEP_MODE, NULL, 0);
847 if (err < 0)
848 return err;
849
850 return 0;
851 }
852 EXPORT_SYMBOL(mipi_dsi_dcs_enter_sleep_mode);
853
854
855
856
857
858
859
860
861 int mipi_dsi_dcs_exit_sleep_mode(struct mipi_dsi_device *dsi)
862 {
863 ssize_t err;
864
865 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_EXIT_SLEEP_MODE, NULL, 0);
866 if (err < 0)
867 return err;
868
869 return 0;
870 }
871 EXPORT_SYMBOL(mipi_dsi_dcs_exit_sleep_mode);
872
873
874
875
876
877
878
879
880 int mipi_dsi_dcs_set_display_off(struct mipi_dsi_device *dsi)
881 {
882 ssize_t err;
883
884 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_OFF, NULL, 0);
885 if (err < 0)
886 return err;
887
888 return 0;
889 }
890 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_off);
891
892
893
894
895
896
897
898
899 int mipi_dsi_dcs_set_display_on(struct mipi_dsi_device *dsi)
900 {
901 ssize_t err;
902
903 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_ON, NULL, 0);
904 if (err < 0)
905 return err;
906
907 return 0;
908 }
909 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_on);
910
911
912
913
914
915
916
917
918
919
920 int mipi_dsi_dcs_set_column_address(struct mipi_dsi_device *dsi, u16 start,
921 u16 end)
922 {
923 u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
924 ssize_t err;
925
926 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_COLUMN_ADDRESS, payload,
927 sizeof(payload));
928 if (err < 0)
929 return err;
930
931 return 0;
932 }
933 EXPORT_SYMBOL(mipi_dsi_dcs_set_column_address);
934
935
936
937
938
939
940
941
942
943
944 int mipi_dsi_dcs_set_page_address(struct mipi_dsi_device *dsi, u16 start,
945 u16 end)
946 {
947 u8 payload[4] = { start >> 8, start & 0xff, end >> 8, end & 0xff };
948 ssize_t err;
949
950 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PAGE_ADDRESS, payload,
951 sizeof(payload));
952 if (err < 0)
953 return err;
954
955 return 0;
956 }
957 EXPORT_SYMBOL(mipi_dsi_dcs_set_page_address);
958
959
960
961
962
963
964
965
966 int mipi_dsi_dcs_set_tear_off(struct mipi_dsi_device *dsi)
967 {
968 ssize_t err;
969
970 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_OFF, NULL, 0);
971 if (err < 0)
972 return err;
973
974 return 0;
975 }
976 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_off);
977
978
979
980
981
982
983
984
985
986 int mipi_dsi_dcs_set_tear_on(struct mipi_dsi_device *dsi,
987 enum mipi_dsi_dcs_tear_mode mode)
988 {
989 u8 value = mode;
990 ssize_t err;
991
992 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_TEAR_ON, &value,
993 sizeof(value));
994 if (err < 0)
995 return err;
996
997 return 0;
998 }
999 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_on);
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009 int mipi_dsi_dcs_set_pixel_format(struct mipi_dsi_device *dsi, u8 format)
1010 {
1011 ssize_t err;
1012
1013 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_PIXEL_FORMAT, &format,
1014 sizeof(format));
1015 if (err < 0)
1016 return err;
1017
1018 return 0;
1019 }
1020 EXPORT_SYMBOL(mipi_dsi_dcs_set_pixel_format);
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030 int mipi_dsi_dcs_set_tear_scanline(struct mipi_dsi_device *dsi, u16 scanline)
1031 {
1032 u8 payload[3] = { MIPI_DCS_SET_TEAR_SCANLINE, scanline >> 8,
1033 scanline & 0xff };
1034 ssize_t err;
1035
1036 err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
1037 if (err < 0)
1038 return err;
1039
1040 return 0;
1041 }
1042 EXPORT_SYMBOL(mipi_dsi_dcs_set_tear_scanline);
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052 int mipi_dsi_dcs_set_display_brightness(struct mipi_dsi_device *dsi,
1053 u16 brightness)
1054 {
1055 u8 payload[2] = { brightness & 0xff, brightness >> 8 };
1056 ssize_t err;
1057
1058 err = mipi_dsi_dcs_write(dsi, MIPI_DCS_SET_DISPLAY_BRIGHTNESS,
1059 payload, sizeof(payload));
1060 if (err < 0)
1061 return err;
1062
1063 return 0;
1064 }
1065 EXPORT_SYMBOL(mipi_dsi_dcs_set_display_brightness);
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075 int mipi_dsi_dcs_get_display_brightness(struct mipi_dsi_device *dsi,
1076 u16 *brightness)
1077 {
1078 ssize_t err;
1079
1080 err = mipi_dsi_dcs_read(dsi, MIPI_DCS_GET_DISPLAY_BRIGHTNESS,
1081 brightness, sizeof(*brightness));
1082 if (err <= 0) {
1083 if (err == 0)
1084 err = -ENODATA;
1085
1086 return err;
1087 }
1088
1089 return 0;
1090 }
1091 EXPORT_SYMBOL(mipi_dsi_dcs_get_display_brightness);
1092
1093 static int mipi_dsi_drv_probe(struct device *dev)
1094 {
1095 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1096 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1097
1098 return drv->probe(dsi);
1099 }
1100
1101 static int mipi_dsi_drv_remove(struct device *dev)
1102 {
1103 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1104 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1105
1106 return drv->remove(dsi);
1107 }
1108
1109 static void mipi_dsi_drv_shutdown(struct device *dev)
1110 {
1111 struct mipi_dsi_driver *drv = to_mipi_dsi_driver(dev->driver);
1112 struct mipi_dsi_device *dsi = to_mipi_dsi_device(dev);
1113
1114 drv->shutdown(dsi);
1115 }
1116
1117
1118
1119
1120
1121
1122
1123
1124 int mipi_dsi_driver_register_full(struct mipi_dsi_driver *drv,
1125 struct module *owner)
1126 {
1127 drv->driver.bus = &mipi_dsi_bus_type;
1128 drv->driver.owner = owner;
1129
1130 if (drv->probe)
1131 drv->driver.probe = mipi_dsi_drv_probe;
1132 if (drv->remove)
1133 drv->driver.remove = mipi_dsi_drv_remove;
1134 if (drv->shutdown)
1135 drv->driver.shutdown = mipi_dsi_drv_shutdown;
1136
1137 return driver_register(&drv->driver);
1138 }
1139 EXPORT_SYMBOL(mipi_dsi_driver_register_full);
1140
1141
1142
1143
1144
1145
1146
1147 void mipi_dsi_driver_unregister(struct mipi_dsi_driver *drv)
1148 {
1149 driver_unregister(&drv->driver);
1150 }
1151 EXPORT_SYMBOL(mipi_dsi_driver_unregister);
1152
1153 static int __init mipi_dsi_bus_init(void)
1154 {
1155 return bus_register(&mipi_dsi_bus_type);
1156 }
1157 postcore_initcall(mipi_dsi_bus_init);
1158
1159 MODULE_AUTHOR("Andrzej Hajda <a.hajda@samsung.com>");
1160 MODULE_DESCRIPTION("MIPI DSI Bus");
1161 MODULE_LICENSE("GPL and additional rights");