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