1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Sharp LS037V7DW01 LCD Panel Driver
4  *
5  * Copyright (C) 2019 Texas Instruments Incorporated
6  *
7  * Based on the omapdrm-specific panel-sharp-ls037v7dw01 driver
8  *
9  * Copyright (C) 2013 Texas Instruments Incorporated
10  * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
11  */
12 
13 #include <linux/delay.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/regulator/consumer.h>
19 
20 #include <drm/drm_connector.h>
21 #include <drm/drm_modes.h>
22 #include <drm/drm_panel.h>
23 
24 struct ls037v7dw01_panel {
25 	struct drm_panel panel;
26 	struct platform_device *pdev;
27 
28 	struct regulator *vdd;
29 	struct gpio_desc *resb_gpio;	/* low = reset active min 20 us */
30 	struct gpio_desc *ini_gpio;	/* high = power on */
31 	struct gpio_desc *mo_gpio;	/* low = 480x640, high = 240x320 */
32 	struct gpio_desc *lr_gpio;	/* high = conventional horizontal scanning */
33 	struct gpio_desc *ud_gpio;	/* high = conventional vertical scanning */
34 };
35 
36 #define to_ls037v7dw01_device(p) \
37 	container_of(p, struct ls037v7dw01_panel, panel)
38 
39 static int ls037v7dw01_disable(struct drm_panel *panel)
40 {
41 	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
42 
43 	gpiod_set_value_cansleep(lcd->ini_gpio, 0);
44 	gpiod_set_value_cansleep(lcd->resb_gpio, 0);
45 
46 	/* Wait at least 5 vsyncs after disabling the LCD. */
47 	msleep(100);
48 
49 	return 0;
50 }
51 
52 static int ls037v7dw01_unprepare(struct drm_panel *panel)
53 {
54 	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
55 
56 	regulator_disable(lcd->vdd);
57 	return 0;
58 }
59 
60 static int ls037v7dw01_prepare(struct drm_panel *panel)
61 {
62 	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
63 	int ret;
64 
65 	ret = regulator_enable(lcd->vdd);
66 	if (ret < 0)
67 		dev_err(&lcd->pdev->dev, "%s: failed to enable regulator\n",
68 			__func__);
69 
70 	return ret;
71 }
72 
73 static int ls037v7dw01_enable(struct drm_panel *panel)
74 {
75 	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
76 
77 	/* Wait couple of vsyncs before enabling the LCD. */
78 	msleep(50);
79 
80 	gpiod_set_value_cansleep(lcd->resb_gpio, 1);
81 	gpiod_set_value_cansleep(lcd->ini_gpio, 1);
82 
83 	return 0;
84 }
85 
86 static const struct drm_display_mode ls037v7dw01_mode = {
87 	.clock = 19200,
88 	.hdisplay = 480,
89 	.hsync_start = 480 + 1,
90 	.hsync_end = 480 + 1 + 2,
91 	.htotal = 480 + 1 + 2 + 28,
92 	.vdisplay = 640,
93 	.vsync_start = 640 + 1,
94 	.vsync_end = 640 + 1 + 1,
95 	.vtotal = 640 + 1 + 1 + 1,
96 	.type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
97 	.flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
98 	.width_mm = 56,
99 	.height_mm = 75,
100 };
101 
102 static int ls037v7dw01_get_modes(struct drm_panel *panel,
103 				 struct drm_connector *connector)
104 {
105 	struct drm_display_mode *mode;
106 
107 	mode = drm_mode_duplicate(connector->dev, &ls037v7dw01_mode);
108 	if (!mode)
109 		return -ENOMEM;
110 
111 	drm_mode_set_name(mode);
112 	drm_mode_probed_add(connector, mode);
113 
114 	connector->display_info.width_mm = ls037v7dw01_mode.width_mm;
115 	connector->display_info.height_mm = ls037v7dw01_mode.height_mm;
116 	/*
117 	 * FIXME: According to the datasheet pixel data is sampled on the
118 	 * rising edge of the clock, but the code running on the SDP3430
119 	 * indicates sampling on the negative edge. This should be tested on a
120 	 * real device.
121 	 */
122 	connector->display_info.bus_flags = DRM_BUS_FLAG_DE_HIGH
123 					  | DRM_BUS_FLAG_SYNC_SAMPLE_POSEDGE
124 					  | DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE;
125 
126 	return 1;
127 }
128 
129 static const struct drm_panel_funcs ls037v7dw01_funcs = {
130 	.disable = ls037v7dw01_disable,
131 	.unprepare = ls037v7dw01_unprepare,
132 	.prepare = ls037v7dw01_prepare,
133 	.enable = ls037v7dw01_enable,
134 	.get_modes = ls037v7dw01_get_modes,
135 };
136 
137 static int ls037v7dw01_probe(struct platform_device *pdev)
138 {
139 	struct ls037v7dw01_panel *lcd;
140 
141 	lcd = devm_kzalloc(&pdev->dev, sizeof(*lcd), GFP_KERNEL);
142 	if (!lcd)
143 		return -ENOMEM;
144 
145 	platform_set_drvdata(pdev, lcd);
146 	lcd->pdev = pdev;
147 
148 	lcd->vdd = devm_regulator_get(&pdev->dev, "envdd");
149 	if (IS_ERR(lcd->vdd)) {
150 		dev_err(&pdev->dev, "failed to get regulator\n");
151 		return PTR_ERR(lcd->vdd);
152 	}
153 
154 	lcd->ini_gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW);
155 	if (IS_ERR(lcd->ini_gpio)) {
156 		dev_err(&pdev->dev, "failed to get enable gpio\n");
157 		return PTR_ERR(lcd->ini_gpio);
158 	}
159 
160 	lcd->resb_gpio = devm_gpiod_get(&pdev->dev, "reset", GPIOD_OUT_LOW);
161 	if (IS_ERR(lcd->resb_gpio)) {
162 		dev_err(&pdev->dev, "failed to get reset gpio\n");
163 		return PTR_ERR(lcd->resb_gpio);
164 	}
165 
166 	lcd->mo_gpio = devm_gpiod_get_index(&pdev->dev, "mode", 0,
167 					    GPIOD_OUT_LOW);
168 	if (IS_ERR(lcd->mo_gpio)) {
169 		dev_err(&pdev->dev, "failed to get mode[0] gpio\n");
170 		return PTR_ERR(lcd->mo_gpio);
171 	}
172 
173 	lcd->lr_gpio = devm_gpiod_get_index(&pdev->dev, "mode", 1,
174 					    GPIOD_OUT_LOW);
175 	if (IS_ERR(lcd->lr_gpio)) {
176 		dev_err(&pdev->dev, "failed to get mode[1] gpio\n");
177 		return PTR_ERR(lcd->lr_gpio);
178 	}
179 
180 	lcd->ud_gpio = devm_gpiod_get_index(&pdev->dev, "mode", 2,
181 					    GPIOD_OUT_LOW);
182 	if (IS_ERR(lcd->ud_gpio)) {
183 		dev_err(&pdev->dev, "failed to get mode[2] gpio\n");
184 		return PTR_ERR(lcd->ud_gpio);
185 	}
186 
187 	drm_panel_init(&lcd->panel, &pdev->dev, &ls037v7dw01_funcs,
188 		       DRM_MODE_CONNECTOR_DPI);
189 
190 	drm_panel_add(&lcd->panel);
191 
192 	return 0;
193 }
194 
195 static int ls037v7dw01_remove(struct platform_device *pdev)
196 {
197 	struct ls037v7dw01_panel *lcd = platform_get_drvdata(pdev);
198 
199 	drm_panel_remove(&lcd->panel);
200 	drm_panel_disable(&lcd->panel);
201 	drm_panel_unprepare(&lcd->panel);
202 
203 	return 0;
204 }
205 
206 static const struct of_device_id ls037v7dw01_of_match[] = {
207 	{ .compatible = "sharp,ls037v7dw01", },
208 	{ /* sentinel */ },
209 };
210 
211 MODULE_DEVICE_TABLE(of, ls037v7dw01_of_match);
212 
213 static struct platform_driver ls037v7dw01_driver = {
214 	.probe		= ls037v7dw01_probe,
215 	.remove		= ls037v7dw01_remove,
216 	.driver		= {
217 		.name = "panel-sharp-ls037v7dw01",
218 		.of_match_table = ls037v7dw01_of_match,
219 	},
220 };
221 
222 module_platform_driver(ls037v7dw01_driver);
223 
224 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
225 MODULE_DESCRIPTION("Sharp LS037V7DW01 Panel Driver");
226 MODULE_LICENSE("GPL");
227