change otg to host mode

hc

2024-05-11 04dd17822334871b23ea2862f7798fb0e0007777

 u-boot/drivers/video/drm/rockchip_panel.c
old mode 100644new mode 100755
..
..
@@ -12,6 +12,7 @@
12
12
 #include <malloc.h>
13
13
 #include <video.h>
14
14
 #include <backlight.h>
15
+#include <spi.h>
15
16
 #include <asm/gpio.h>
16
17
 #include <dm/device.h>
17
18
 #include <dm/read.h>
..
..
@@ -45,6 +46,7 @@
45
46
 	bool power_invert;
46
47
 	u32 bus_format;
47
48
 	unsigned int bpc;
49
+	unsigned int lvds_index;
48
50
 
49
51
 	struct {
50
52
 		unsigned int prepare;
..
..
@@ -64,8 +66,18 @@
64
66
 	bool enabled;
65
67
 	struct udevice *power_supply;
66
68
 	struct udevice *backlight;
69
+	struct spi_slave *spi_slave;
67
70
 	struct gpio_desc enable_gpio;
68
71
 	struct gpio_desc reset_gpio;
72
+	struct gpio_desc edp_bl_on;
73
+	struct gpio_desc edp_bl_en;
74
+	struct gpio_desc vcc_5v;
75
+	struct gpio_desc vddio_mipi;
76
+
77
+	struct gpio_desc lvds_gpio0;
78
+	struct gpio_desc lvds_gpio1;
79
+	struct gpio_desc lvds_gpio2;
80
+	struct gpio_desc lvds_gpio3;
69
81
 
70
82
 	int cmd_type;
71
83
 	struct gpio_desc spi_sdi_gpio;
..
..
@@ -187,24 +199,48 @@
187
199
 {
188
200
 	struct rockchip_panel_priv *priv = dev_get_priv(panel->dev);
189
201
 	int i;
202
+	int ret;
190
203
 
191
204
 	if (!cmds)
192
205
 		return -EINVAL;
193
206
 
207
+	if (priv->spi_slave) {
208
+		ret = spi_claim_bus(priv->spi_slave);
209
+		if (ret) {
210
+			printf("%s: Failed to claim spi bus: %d\n", __func__, ret);
211
+			return -EINVAL;
212
+		}
213
+	}
214
+
194
215
 	for (i = 0; i < cmds->cmd_cnt; i++) {
195
216
 		struct rockchip_cmd_desc *desc = &cmds->cmds[i];
196
217
 		int value = 0;
218
+		u16 mask = 0;
219
+		u16 data = 0;
197
220
 
198
-		if (desc->header.payload_length == 2)
199
-			value = (desc->payload[0] << 8) | desc->payload[1];
200
-		else
201
-			value = desc->payload[0];
202
-		rockchip_panel_write_spi_cmds(priv,
203
-					      desc->header.data_type, value);
221
+		if (priv->spi_slave) {
222
+			mask = desc->header.data_type ? 0x100 : 0;
223
+			data = (mask | desc->payload[0]) << 7;;
224
+			data = ((data & 0xff) << 8) | (data >> 8);
225
+			value = mask | desc->payload[0];
226
+			ret = spi_xfer(priv->spi_slave, 9, &data, NULL, SPI_XFER_ONCE);
227
+			if (ret)
228
+				printf("%s: Failed to xfer spi cmd 0x%x: %d\n",
229
+				       __func__, desc->payload[0], ret);
230
+		} else {
231
+			if (desc->header.payload_length == 2)
232
+				value = (desc->payload[0] << 8) | desc->payload[1];
233
+			else
234
+				value = desc->payload[0];
235
+			rockchip_panel_write_spi_cmds(priv, desc->header.data_type, value);
236
+		}
204
237
 
205
238
 		if (desc->header.delay_ms)
206
239
 			mdelay(desc->header.delay_ms);
207
240
 	}
241
+
242
+	if (priv->spi_slave)
243
+		spi_release_bus(priv->spi_slave);
208
244
 
209
245
 	return 0;
210
246
 }
..
..
@@ -275,9 +311,57 @@
275
311
 
276
312
 	if (priv->prepared)
277
313
 		return;
314
+	/*mipi */
315
+	if (dm_gpio_is_valid(&priv->vddio_mipi))
316
+               dm_gpio_set_value(&priv->vddio_mipi, 1);
317
+        mdelay(20);
318
+
319
+        if (dm_gpio_is_valid(&priv->vcc_5v))
320
+                dm_gpio_set_value(&priv->vcc_5v, 1);
321
+
322
+        ret = dm_gpio_get_value(&priv->vcc_5v);
323
+                printf("troy test get vcc_5v : %d \n",ret);
324
+        ret = dm_gpio_get_value(&priv->vddio_mipi);
325
+                printf("troy test get vddio-mipi : %d \n",ret);
326
+        /*mipi end*/
327
+	
328
+	/*7511 LVDS IO Control start*/
329
+	printk("nodka_lvds_index = %d\n",plat->lvds_index);
330
+	
331
+	ret = plat->lvds_index  & 1;
332
+	if (dm_gpio_is_valid(&priv->lvds_gpio0))
333
+	dm_gpio_set_value(&priv->lvds_gpio0, ret);
334
+	ret = dm_gpio_get_value(&priv->lvds_gpio0);
335
+	printf("lvds_gpio0 : %d\n",ret);
336
+
337
+	ret = plat->lvds_index >> 1 & 1;
338
+	if (dm_gpio_is_valid(&priv->lvds_gpio1))
339
+	dm_gpio_set_value(&priv->lvds_gpio1, ret);
340
+	ret = dm_gpio_get_value(&priv->lvds_gpio1);
341
+	printf("lvds_gpio1 : %d\n",ret);
342
+	
343
+	ret = plat->lvds_index >> 2 & 1;
344
+	if (dm_gpio_is_valid(&priv->lvds_gpio2))
345
+	dm_gpio_set_value(&priv->lvds_gpio2, ret);
346
+	ret = dm_gpio_get_value(&priv->lvds_gpio2);
347
+	printf("lvds_gpio2 : %d\n",ret);
348
+	
349
+	ret = plat->lvds_index >> 3 & 1;
350
+	if (dm_gpio_is_valid(&priv->lvds_gpio3))
351
+	dm_gpio_set_value(&priv->lvds_gpio3, ret);
352
+	ret = dm_gpio_get_value(&priv->lvds_gpio3);
353
+	printf("lvds_gpio3 : %d\n",ret);
354
+	mdelay(100);
355
+/*7511 LVDS IO Control end*/
278
356
 
279
357
 	if (priv->power_supply)
280
358
 		regulator_set_enable(priv->power_supply, !plat->power_invert);
359
+	
360
+	if (dm_gpio_is_valid(&priv->edp_bl_on))
361
+		dm_gpio_set_value(&priv->edp_bl_on, 1);
362
+		
363
+	if (dm_gpio_is_valid(&priv->edp_bl_en))
364
+		dm_gpio_set_value(&priv->edp_bl_en, 1);
281
365
 
282
366
 	if (dm_gpio_is_valid(&priv->enable_gpio))
283
367
 		dm_gpio_set_value(&priv->enable_gpio, 1);
..
..
@@ -290,10 +374,12 @@
290
374
 
291
375
 	if (plat->delay.reset)
292
376
 		mdelay(plat->delay.reset);
293
-
377
+	mdelay(50);
294
378
 	if (dm_gpio_is_valid(&priv->reset_gpio))
295
379
 		dm_gpio_set_value(&priv->reset_gpio, 0);
296
380
 
381
+	mdelay(200);
382
+	
297
383
 	if (plat->delay.init)
298
384
 		mdelay(plat->delay.init);
299
385
 
..
..
@@ -407,6 +493,7 @@
407
493
 	plat->delay.disable = dev_read_u32_default(dev, "disable-delay-ms", 0);
408
494
 	plat->delay.init = dev_read_u32_default(dev, "init-delay-ms", 0);
409
495
 	plat->delay.reset = dev_read_u32_default(dev, "reset-delay-ms", 0);
496
+	plat->lvds_index = dev_read_u32_default(dev, "nodka-lvds", 0);
410
497
 
411
498
 	plat->bus_format = dev_read_u32_default(dev, "bus-format",
412
499
 						MEDIA_BUS_FMT_RBG888_1X24);
..
..
@@ -457,6 +544,34 @@
457
544
 	int ret;
458
545
 	const char *cmd_type;
459
546
 
547
+	ret = gpio_request_by_name(dev, "vcc-5v-gpio", 0,
548
+                                   &priv->vcc_5v, GPIOD_IS_OUT);
549
+        if (ret && ret != -ENOENT) {
550
+                printf("%s: Cannot get vcc-5v-gpio: %d\n", __func__, ret);
551
+                return ret;
552
+        }
553
+
554
+        ret = gpio_request_by_name(dev, "vddio-mipi", 0,
555
+                                   &priv->vddio_mipi, GPIOD_IS_OUT);
556
+        if (ret && ret != -ENOENT) {
557
+                printf("%s: Cannot get vddio-mipi: %d\n", __func__, ret);
558
+                return ret;
559
+	}
560
+
561
+	ret = gpio_request_by_name(dev, "edp-bl-gpios", 0,
562
+				   &priv->edp_bl_on, GPIOD_IS_OUT);
563
+	if (ret && ret != -ENOENT) {
564
+		printf("%s: Cannot get enable GPIO: %d\n", __func__, ret);
565
+		return ret;
566
+	}
567
+
568
+	ret = gpio_request_by_name(dev, "edp-bl-en", 0,
569
+				   &priv->edp_bl_en, GPIOD_IS_OUT);
570
+	if (ret && ret != -ENOENT) {
571
+		printf("%s: Cannot get enable GPIO: %d\n", __func__, ret);
572
+		return ret;
573
+	}
574
+	
460
575
 	ret = gpio_request_by_name(dev, "enable-gpios", 0,
461
576
 				   &priv->enable_gpio, GPIOD_IS_OUT);
462
577
 	if (ret && ret != -ENOENT) {
..
..
@@ -468,6 +583,34 @@
468
583
 				   &priv->reset_gpio, GPIOD_IS_OUT);
469
584
 	if (ret && ret != -ENOENT) {
470
585
 		printf("%s: Cannot get reset GPIO: %d\n", __func__, ret);
586
+		return ret;
587
+	}
588
+	
589
+	ret = gpio_request_by_name(dev, "lvds-gpio0", 0,
590
+				   &priv->lvds_gpio0, GPIOD_IS_OUT);
591
+	if (ret && ret != -ENOENT) {
592
+		printf("%s: Cannot get lvds-gpio0: %d\n", __func__, ret);
593
+		return ret;
594
+	}
595
+
596
+	ret = gpio_request_by_name(dev, "lvds-gpio1", 0,
597
+				   &priv->lvds_gpio1, GPIOD_IS_OUT);
598
+	if (ret && ret != -ENOENT) {
599
+		printf("%s: Cannot get lvds-gpio1: %d\n", __func__, ret);
600
+		return ret;
601
+	}
602
+	
603
+	ret = gpio_request_by_name(dev, "lvds-gpio2", 0,
604
+				   &priv->lvds_gpio2, GPIOD_IS_OUT);
605
+	if (ret && ret != -ENOENT) {
606
+		printf("%s: Cannot get lvds-gpio2: %d\n", __func__, ret);
607
+		return ret;
608
+	}
609
+	
610
+	ret = gpio_request_by_name(dev, "lvds-gpio3", 0,
611
+				   &priv->lvds_gpio3, GPIOD_IS_OUT);
612
+	if (ret && ret != -ENOENT) {
613
+		printf("%s: Cannot get lvds-gpio3: %d\n", __func__, ret);
471
614
 		return ret;
472
615
 	}
473
616
 
..
..
@@ -492,31 +635,47 @@
492
635
 		priv->cmd_type = get_panel_cmd_type(cmd_type);
493
636
 
494
637
 	if (priv->cmd_type == CMD_TYPE_SPI) {
495
-		ret = gpio_request_by_name(dev, "spi-sdi-gpios", 0,
496
-					   &priv->spi_sdi_gpio, GPIOD_IS_OUT);
497
-		if (ret && ret != -ENOENT) {
498
-			printf("%s: Cannot get spi sdi GPIO: %d\n",
499
-			       __func__, ret);
500
-			return ret;
638
+		ofnode parent = ofnode_get_parent(dev->node);
639
+
640
+		if (ofnode_valid(parent)) {
641
+			struct dm_spi_slave_platdata *plat = dev_get_parent_platdata(dev);
642
+			struct udevice *spi = dev_get_parent(dev);
643
+
644
+			if (spi->seq < 0) {
645
+				printf("%s: Failed to get spi bus num\n", __func__);
646
+				return -EINVAL;
647
+			}
648
+
649
+			priv->spi_slave = spi_setup_slave(spi->seq, plat->cs, plat->max_hz,
650
+							  plat->mode);
651
+			if (!priv->spi_slave) {
652
+				printf("%s: Failed to setup spi slave: %d\n", __func__, ret);
653
+				return -EINVAL;
654
+			}
655
+		} else {
656
+			ret = gpio_request_by_name(dev, "spi-sdi-gpios", 0,
657
+						   &priv->spi_sdi_gpio, GPIOD_IS_OUT);
658
+			if (ret && ret != -ENOENT) {
659
+				printf("%s: Cannot get spi sdi GPIO: %d\n", __func__, ret);
660
+				return ret;
661
+			}
662
+			ret = gpio_request_by_name(dev, "spi-scl-gpios", 0,
663
+						   &priv->spi_scl_gpio, GPIOD_IS_OUT);
664
+			if (ret && ret != -ENOENT) {
665
+				printf("%s: Cannot get spi scl GPIO: %d\n", __func__, ret);
666
+				return ret;
667
+			}
668
+			ret = gpio_request_by_name(dev, "spi-cs-gpios", 0,
669
+						   &priv->spi_cs_gpio, GPIOD_IS_OUT);
670
+			if (ret && ret != -ENOENT) {
671
+				printf("%s: Cannot get spi cs GPIO: %d\n", __func__, ret);
672
+				return ret;
673
+			}
674
+			dm_gpio_set_value(&priv->spi_sdi_gpio, 1);
675
+			dm_gpio_set_value(&priv->spi_scl_gpio, 1);
676
+			dm_gpio_set_value(&priv->spi_cs_gpio, 1);
677
+			dm_gpio_set_value(&priv->reset_gpio, 0);
501
678
 		}
502
-		ret = gpio_request_by_name(dev, "spi-scl-gpios", 0,
503
-					   &priv->spi_scl_gpio, GPIOD_IS_OUT);
504
-		if (ret && ret != -ENOENT) {
505
-			printf("%s: Cannot get spi scl GPIO: %d\n",
506
-			       __func__, ret);
507
-			return ret;
508
-		}
509
-		ret = gpio_request_by_name(dev, "spi-cs-gpios", 0,
510
-					   &priv->spi_cs_gpio, GPIOD_IS_OUT);
511
-		if (ret && ret != -ENOENT) {
512
-			printf("%s: Cannot get spi cs GPIO: %d\n",
513
-			       __func__, ret);
514
-			return ret;
515
-		}
516
-		dm_gpio_set_value(&priv->spi_sdi_gpio, 1);
517
-		dm_gpio_set_value(&priv->spi_scl_gpio, 1);
518
-		dm_gpio_set_value(&priv->spi_cs_gpio, 1);
519
-		dm_gpio_set_value(&priv->reset_gpio, 0);
520
679
 	}
521
680
 
522
681
 	panel = calloc(1, sizeof(*panel));
..
..
@@ -535,6 +694,7 @@
535
694
 static const struct udevice_id rockchip_panel_ids[] = {
536
695
 	{ .compatible = "simple-panel", },
537
696
 	{ .compatible = "simple-panel-dsi", },
697
+	{ .compatible = "simple-panel-spi", },
538
698
 	{}
539
699
 };
540
700