1/*
  2 * Copyright (C) 2015 Red Hat
  3 * Copyright (C) 2015 Sony Mobile Communications Inc.
  4 * Author: Werner Johansson <werner.johansson@sonymobile.com>
  5 *
  6 * Based on AUO panel driver by Rob Clark <robdclark@gmail.com>
  7 *
  8 * This program is free software; you can redistribute it and/or modify it
  9 * under the terms of the GNU General Public License version 2 as published by
 10 * the Free Software Foundation.
 11 *
 12 * This program is distributed in the hope that it will be useful, but WITHOUT
 13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 14 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 15 * more details.
 16 *
 17 * You should have received a copy of the GNU General Public License along with
 18 * this program.  If not, see <http://www.gnu.org/licenses/>.
 19 */
 20
 21#include <linux/backlight.h>
 22#include <linux/gpio/consumer.h>
 23#include <linux/module.h>
 24#include <linux/of.h>
 25#include <linux/regulator/consumer.h>
 26
 27#include <drm/drmP.h>
 28#include <drm/drm_crtc.h>
 29#include <drm/drm_mipi_dsi.h>
 30#include <drm/drm_panel.h>
 31
 32#include <video/mipi_display.h>
 33
 34struct sharp_nt_panel {
 35	struct drm_panel base;
 36	struct mipi_dsi_device *dsi;
 37
 38	struct backlight_device *backlight;
 39	struct regulator *supply;
 40	struct gpio_desc *reset_gpio;
 41
 42	bool prepared;
 43	bool enabled;
 44
 45	const struct drm_display_mode *mode;
 46};
 47
 48static inline struct sharp_nt_panel *to_sharp_nt_panel(struct drm_panel *panel)
 49{
 50	return container_of(panel, struct sharp_nt_panel, base);
 51}
 52
 53static int sharp_nt_panel_init(struct sharp_nt_panel *sharp_nt)
 54{
 55	struct mipi_dsi_device *dsi = sharp_nt->dsi;
 56	int ret;
 57
 58	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
 59
 60	ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
 61	if (ret < 0)
 62		return ret;
 63
 64	msleep(120);
 65
 66	/* Novatek two-lane operation */
 67	ret = mipi_dsi_dcs_write(dsi, 0xae, (u8[]){ 0x03 }, 1);
 68	if (ret < 0)
 69		return ret;
 70
 71	/* Set both MCU and RGB I/F to 24bpp */
 72	ret = mipi_dsi_dcs_set_pixel_format(dsi, MIPI_DCS_PIXEL_FMT_24BIT |
 73					(MIPI_DCS_PIXEL_FMT_24BIT << 4));
 74	if (ret < 0)
 75		return ret;
 76
 77	return 0;
 78}
 79
 80static int sharp_nt_panel_on(struct sharp_nt_panel *sharp_nt)
 81{
 82	struct mipi_dsi_device *dsi = sharp_nt->dsi;
 83	int ret;
 84
 85	dsi->mode_flags |= MIPI_DSI_MODE_LPM;
 86
 87	ret = mipi_dsi_dcs_set_display_on(dsi);
 88	if (ret < 0)
 89		return ret;
 90
 91	return 0;
 92}
 93
 94static int sharp_nt_panel_off(struct sharp_nt_panel *sharp_nt)
 95{
 96	struct mipi_dsi_device *dsi = sharp_nt->dsi;
 97	int ret;
 98
 99	dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
100
101	ret = mipi_dsi_dcs_set_display_off(dsi);
102	if (ret < 0)
103		return ret;
104
105	ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
106	if (ret < 0)
107		return ret;
108
109	return 0;
110}
111
112
113static int sharp_nt_panel_disable(struct drm_panel *panel)
114{
115	struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
116
117	if (!sharp_nt->enabled)
118		return 0;
119
120	if (sharp_nt->backlight) {
121		sharp_nt->backlight->props.power = FB_BLANK_POWERDOWN;
122		backlight_update_status(sharp_nt->backlight);
123	}
124
125	sharp_nt->enabled = false;
126
127	return 0;
128}
129
130static int sharp_nt_panel_unprepare(struct drm_panel *panel)
131{
132	struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
133	int ret;
134
135	if (!sharp_nt->prepared)
136		return 0;
137
138	ret = sharp_nt_panel_off(sharp_nt);
139	if (ret < 0) {
140		dev_err(panel->dev, "failed to set panel off: %d\n", ret);
141		return ret;
142	}
143
144	regulator_disable(sharp_nt->supply);
145	if (sharp_nt->reset_gpio)
146		gpiod_set_value(sharp_nt->reset_gpio, 0);
147
148	sharp_nt->prepared = false;
149
150	return 0;
151}
152
153static int sharp_nt_panel_prepare(struct drm_panel *panel)
154{
155	struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
156	int ret;
157
158	if (sharp_nt->prepared)
159		return 0;
160
161	ret = regulator_enable(sharp_nt->supply);
162	if (ret < 0)
163		return ret;
164
165	msleep(20);
166
167	if (sharp_nt->reset_gpio) {
168		gpiod_set_value(sharp_nt->reset_gpio, 1);
169		msleep(1);
170		gpiod_set_value(sharp_nt->reset_gpio, 0);
171		msleep(1);
172		gpiod_set_value(sharp_nt->reset_gpio, 1);
173		msleep(10);
174	}
175
176	ret = sharp_nt_panel_init(sharp_nt);
177	if (ret < 0) {
178		dev_err(panel->dev, "failed to init panel: %d\n", ret);
179		goto poweroff;
180	}
181
182	ret = sharp_nt_panel_on(sharp_nt);
183	if (ret < 0) {
184		dev_err(panel->dev, "failed to set panel on: %d\n", ret);
185		goto poweroff;
186	}
187
188	sharp_nt->prepared = true;
189
190	return 0;
191
192poweroff:
193	regulator_disable(sharp_nt->supply);
194	if (sharp_nt->reset_gpio)
195		gpiod_set_value(sharp_nt->reset_gpio, 0);
196	return ret;
197}
198
199static int sharp_nt_panel_enable(struct drm_panel *panel)
200{
201	struct sharp_nt_panel *sharp_nt = to_sharp_nt_panel(panel);
202
203	if (sharp_nt->enabled)
204		return 0;
205
206	if (sharp_nt->backlight) {
207		sharp_nt->backlight->props.power = FB_BLANK_UNBLANK;
208		backlight_update_status(sharp_nt->backlight);
209	}
210
211	sharp_nt->enabled = true;
212
213	return 0;
214}
215
216static const struct drm_display_mode default_mode = {
217	.clock = 41118,
218	.hdisplay = 540,
219	.hsync_start = 540 + 48,
220	.hsync_end = 540 + 48 + 80,
221	.htotal = 540 + 48 + 80 + 32,
222	.vdisplay = 960,
223	.vsync_start = 960 + 3,
224	.vsync_end = 960 + 3 + 15,
225	.vtotal = 960 + 3 + 15 + 1,
226	.vrefresh = 60,
227};
228
229static int sharp_nt_panel_get_modes(struct drm_panel *panel)
230{
231	struct drm_display_mode *mode;
232
233	mode = drm_mode_duplicate(panel->drm, &default_mode);
234	if (!mode) {
235		dev_err(panel->drm->dev, "failed to add mode %ux%ux@%u\n",
236				default_mode.hdisplay, default_mode.vdisplay,
237				default_mode.vrefresh);
238		return -ENOMEM;
239	}
240
241	drm_mode_set_name(mode);
242
243	drm_mode_probed_add(panel->connector, mode);
244
245	panel->connector->display_info.width_mm = 54;
246	panel->connector->display_info.height_mm = 95;
247
248	return 1;
249}
250
251static const struct drm_panel_funcs sharp_nt_panel_funcs = {
252	.disable = sharp_nt_panel_disable,
253	.unprepare = sharp_nt_panel_unprepare,
254	.prepare = sharp_nt_panel_prepare,
255	.enable = sharp_nt_panel_enable,
256	.get_modes = sharp_nt_panel_get_modes,
257};
258
259static int sharp_nt_panel_add(struct sharp_nt_panel *sharp_nt)
260{
261	struct device *dev = &sharp_nt->dsi->dev;
262	struct device_node *np;
263	int ret;
264
265	sharp_nt->mode = &default_mode;
266
267	sharp_nt->supply = devm_regulator_get(dev, "avdd");
268	if (IS_ERR(sharp_nt->supply))
269		return PTR_ERR(sharp_nt->supply);
270
271	sharp_nt->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
272	if (IS_ERR(sharp_nt->reset_gpio)) {
273		dev_err(dev, "cannot get reset-gpios %ld\n",
274			PTR_ERR(sharp_nt->reset_gpio));
275		sharp_nt->reset_gpio = NULL;
276	} else {
277		gpiod_set_value(sharp_nt->reset_gpio, 0);
278	}
279
280	np = of_parse_phandle(dev->of_node, "backlight", 0);
281	if (np) {
282		sharp_nt->backlight = of_find_backlight_by_node(np);
283		of_node_put(np);
284
285		if (!sharp_nt->backlight)
286			return -EPROBE_DEFER;
287	}
288
289	drm_panel_init(&sharp_nt->base);
290	sharp_nt->base.funcs = &sharp_nt_panel_funcs;
291	sharp_nt->base.dev = &sharp_nt->dsi->dev;
292
293	ret = drm_panel_add(&sharp_nt->base);
294	if (ret < 0)
295		goto put_backlight;
296
297	return 0;
298
299put_backlight:
300	if (sharp_nt->backlight)
301		put_device(&sharp_nt->backlight->dev);
302
303	return ret;
304}
305
306static void sharp_nt_panel_del(struct sharp_nt_panel *sharp_nt)
307{
308	if (sharp_nt->base.dev)
309		drm_panel_remove(&sharp_nt->base);
310
311	if (sharp_nt->backlight)
312		put_device(&sharp_nt->backlight->dev);
313}
314
315static int sharp_nt_panel_probe(struct mipi_dsi_device *dsi)
316{
317	struct sharp_nt_panel *sharp_nt;
318	int ret;
319
320	dsi->lanes = 2;
321	dsi->format = MIPI_DSI_FMT_RGB888;
322	dsi->mode_flags = MIPI_DSI_MODE_VIDEO |
323			MIPI_DSI_MODE_VIDEO_HSE |
324			MIPI_DSI_CLOCK_NON_CONTINUOUS |
325			MIPI_DSI_MODE_EOT_PACKET;
326
327	sharp_nt = devm_kzalloc(&dsi->dev, sizeof(*sharp_nt), GFP_KERNEL);
328	if (!sharp_nt)
329		return -ENOMEM;
330
331	mipi_dsi_set_drvdata(dsi, sharp_nt);
332
333	sharp_nt->dsi = dsi;
334
335	ret = sharp_nt_panel_add(sharp_nt);
336	if (ret < 0)
337		return ret;
338
339	return mipi_dsi_attach(dsi);
340}
341
342static int sharp_nt_panel_remove(struct mipi_dsi_device *dsi)
343{
344	struct sharp_nt_panel *sharp_nt = mipi_dsi_get_drvdata(dsi);
345	int ret;
346
347	ret = sharp_nt_panel_disable(&sharp_nt->base);
348	if (ret < 0)
349		dev_err(&dsi->dev, "failed to disable panel: %d\n", ret);
350
351	ret = mipi_dsi_detach(dsi);
352	if (ret < 0)
353		dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", ret);
354
355	drm_panel_detach(&sharp_nt->base);
356	sharp_nt_panel_del(sharp_nt);
357
358	return 0;
359}
360
361static void sharp_nt_panel_shutdown(struct mipi_dsi_device *dsi)
362{
363	struct sharp_nt_panel *sharp_nt = mipi_dsi_get_drvdata(dsi);
364
365	sharp_nt_panel_disable(&sharp_nt->base);
366}
367
368static const struct of_device_id sharp_nt_of_match[] = {
369	{ .compatible = "sharp,ls043t1le01-qhd", },
370	{ }
371};
372MODULE_DEVICE_TABLE(of, sharp_nt_of_match);
373
374static struct mipi_dsi_driver sharp_nt_panel_driver = {
375	.driver = {
376		.name = "panel-sharp-ls043t1le01-qhd",
377		.of_match_table = sharp_nt_of_match,
378	},
379	.probe = sharp_nt_panel_probe,
380	.remove = sharp_nt_panel_remove,
381	.shutdown = sharp_nt_panel_shutdown,
382};
383module_mipi_dsi_driver(sharp_nt_panel_driver);
384
385MODULE_AUTHOR("Werner Johansson <werner.johansson@sonymobile.com>");
386MODULE_DESCRIPTION("Sharp LS043T1LE01 NT35565-based qHD (540x960) video mode panel driver");
387MODULE_LICENSE("GPL v2");