[mirror_ubuntu-disco-kernel.git] / drivers / gpu / drm / panel / panel-seiko-43wvf1g.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2017 NXP Semiconductors.
 * Author: Marco Franchi <marco.franchi@nxp.com>
 *
 * Based on Panel Simple driver by Thierry Reding <treding@nvidia.com>
 */

#include <linux/backlight.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/regulator/consumer.h>

#include <drm/drmP.h>
#include <drm/drm_crtc.h>
#include <drm/drm_panel.h>

#include <video/display_timing.h>
#include <video/videomode.h>

struct seiko_panel_desc {
	const struct drm_display_mode *modes;
	unsigned int num_modes;
	const struct display_timing *timings;
	unsigned int num_timings;

	unsigned int bpc;

	/**
	 * @width: width (in millimeters) of the panel's active display area
	 * @height: height (in millimeters) of the panel's active display area
	 */
	struct {
		unsigned int width;
		unsigned int height;
	} size;

	u32 bus_format;
	u32 bus_flags;
};

struct seiko_panel {
	struct drm_panel base;
	bool prepared;
	bool enabled;
	const struct seiko_panel_desc *desc;
	struct backlight_device *backlight;
	struct regulator *dvdd;
	struct regulator *avdd;
};

static inline struct seiko_panel *to_seiko_panel(struct drm_panel *panel)
{
	return container_of(panel, struct seiko_panel, base);
}

static int seiko_panel_get_fixed_modes(struct seiko_panel *panel)
{
	struct drm_connector *connector = panel->base.connector;
	struct drm_device *drm = panel->base.drm;
	struct drm_display_mode *mode;
	unsigned int i, num = 0;

	if (!panel->desc)
		return 0;

	for (i = 0; i < panel->desc->num_timings; i++) {
		const struct display_timing *dt = &panel->desc->timings[i];
		struct videomode vm;

		videomode_from_timing(dt, &vm);
		mode = drm_mode_create(drm);
		if (!mode) {
			dev_err(drm->dev, "failed to add mode %ux%u\n",
				dt->hactive.typ, dt->vactive.typ);
			continue;
		}

		drm_display_mode_from_videomode(&vm, mode);

		mode->type |= DRM_MODE_TYPE_DRIVER;

		if (panel->desc->num_timings == 1)
			mode->type |= DRM_MODE_TYPE_PREFERRED;

		drm_mode_probed_add(connector, mode);
		num++;
	}

	for (i = 0; i < panel->desc->num_modes; i++) {
		const struct drm_display_mode *m = &panel->desc->modes[i];

		mode = drm_mode_duplicate(drm, m);
		if (!mode) {
			dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
				m->hdisplay, m->vdisplay, m->vrefresh);
			continue;
		}

		mode->type |= DRM_MODE_TYPE_DRIVER;

		if (panel->desc->num_modes == 1)
			mode->type |= DRM_MODE_TYPE_PREFERRED;

		drm_mode_set_name(mode);

		drm_mode_probed_add(connector, mode);
		num++;
	}

	connector->display_info.bpc = panel->desc->bpc;
	connector->display_info.width_mm = panel->desc->size.width;
	connector->display_info.height_mm = panel->desc->size.height;
	if (panel->desc->bus_format)
		drm_display_info_set_bus_formats(&connector->display_info,
						 &panel->desc->bus_format, 1);
	connector->display_info.bus_flags = panel->desc->bus_flags;

	return num;
}

static int seiko_panel_disable(struct drm_panel *panel)
{
	struct seiko_panel *p = to_seiko_panel(panel);

	if (!p->enabled)
		return 0;

	if (p->backlight) {
		p->backlight->props.power = FB_BLANK_POWERDOWN;
		p->backlight->props.state |= BL_CORE_FBBLANK;
		backlight_update_status(p->backlight);
	}

	p->enabled = false;

	return 0;
}

static int seiko_panel_unprepare(struct drm_panel *panel)
{
	struct seiko_panel *p = to_seiko_panel(panel);

	if (!p->prepared)
		return 0;

	regulator_disable(p->avdd);

	/* Add a 100ms delay as per the panel datasheet */
	msleep(100);

	regulator_disable(p->dvdd);

	p->prepared = false;

	return 0;
}

static int seiko_panel_prepare(struct drm_panel *panel)
{
	struct seiko_panel *p = to_seiko_panel(panel);
	int err;

	if (p->prepared)
		return 0;

	err = regulator_enable(p->dvdd);
	if (err < 0) {
		dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
		return err;
	}

	/* Add a 100ms delay as per the panel datasheet */
	msleep(100);

	err = regulator_enable(p->avdd);
	if (err < 0) {
		dev_err(panel->dev, "failed to enable avdd: %d\n", err);
		goto disable_dvdd;
	}

	p->prepared = true;

	return 0;

disable_dvdd:
	regulator_disable(p->dvdd);
	return err;
}

static int seiko_panel_enable(struct drm_panel *panel)
{
	struct seiko_panel *p = to_seiko_panel(panel);

	if (p->enabled)
		return 0;

	if (p->backlight) {
		p->backlight->props.state &= ~BL_CORE_FBBLANK;
		p->backlight->props.power = FB_BLANK_UNBLANK;
		backlight_update_status(p->backlight);
	}

	p->enabled = true;

	return 0;
}

static int seiko_panel_get_modes(struct drm_panel *panel)
{
	struct seiko_panel *p = to_seiko_panel(panel);

	/* add hard-coded panel modes */
	return seiko_panel_get_fixed_modes(p);
}

static int seiko_panel_get_timings(struct drm_panel *panel,
				    unsigned int num_timings,
				    struct display_timing *timings)
{
	struct seiko_panel *p = to_seiko_panel(panel);
	unsigned int i;

	if (p->desc->num_timings < num_timings)
		num_timings = p->desc->num_timings;

	if (timings)
		for (i = 0; i < num_timings; i++)
			timings[i] = p->desc->timings[i];

	return p->desc->num_timings;
}

static const struct drm_panel_funcs seiko_panel_funcs = {
	.disable = seiko_panel_disable,
	.unprepare = seiko_panel_unprepare,
	.prepare = seiko_panel_prepare,
	.enable = seiko_panel_enable,
	.get_modes = seiko_panel_get_modes,
	.get_timings = seiko_panel_get_timings,
};

static int seiko_panel_probe(struct device *dev,
					const struct seiko_panel_desc *desc)
{
	struct device_node *backlight;
	struct seiko_panel *panel;
	int err;

	panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
	if (!panel)
		return -ENOMEM;

	panel->enabled = false;
	panel->prepared = false;
	panel->desc = desc;

	panel->dvdd = devm_regulator_get(dev, "dvdd");
	if (IS_ERR(panel->dvdd))
		return PTR_ERR(panel->dvdd);

	panel->avdd = devm_regulator_get(dev, "avdd");
	if (IS_ERR(panel->avdd))
		return PTR_ERR(panel->avdd);

	backlight = of_parse_phandle(dev->of_node, "backlight", 0);
	if (backlight) {
		panel->backlight = of_find_backlight_by_node(backlight);
		of_node_put(backlight);

		if (!panel->backlight)
			return -EPROBE_DEFER;
	}

	drm_panel_init(&panel->base);
	panel->base.dev = dev;
	panel->base.funcs = &seiko_panel_funcs;

	err = drm_panel_add(&panel->base);
	if (err < 0)
		return err;

	dev_set_drvdata(dev, panel);

	return 0;
}

static int seiko_panel_remove(struct platform_device *pdev)
{
	struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);

	drm_panel_remove(&panel->base);

	seiko_panel_disable(&panel->base);

	if (panel->backlight)
		put_device(&panel->backlight->dev);

	return 0;
}

static void seiko_panel_shutdown(struct platform_device *pdev)
{
	struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);

	seiko_panel_disable(&panel->base);
}

static const struct display_timing seiko_43wvf1g_timing = {
	.pixelclock = { 33500000, 33500000, 33500000 },
	.hactive = { 800, 800, 800 },
	.hfront_porch = {  164, 164, 164 },
	.hback_porch = { 89, 89, 89 },
	.hsync_len = { 10, 10, 10 },
	.vactive = { 480, 480, 480 },
	.vfront_porch = { 10, 10, 10 },
	.vback_porch = { 23, 23, 23 },
	.vsync_len = { 10, 10, 10 },
	.flags = DISPLAY_FLAGS_DE_LOW,
};

static const struct seiko_panel_desc seiko_43wvf1g = {
	.timings = &seiko_43wvf1g_timing,
	.num_timings = 1,
	.bpc = 8,
	.size = {
		.width = 93,
		.height = 57,
	},
	.bus_format = MEDIA_BUS_FMT_RGB888_1X24,
	.bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_NEGEDGE,
};

static const struct of_device_id platform_of_match[] = {
	{
		.compatible = "sii,43wvf1g",
		.data = &seiko_43wvf1g,
	}, {
		/* sentinel */
	}
};
MODULE_DEVICE_TABLE(of, platform_of_match);

static int seiko_panel_platform_probe(struct platform_device *pdev)
{
	const struct of_device_id *id;

	id = of_match_node(platform_of_match, pdev->dev.of_node);
	if (!id)
		return -ENODEV;

	return seiko_panel_probe(&pdev->dev, id->data);
}

static struct platform_driver seiko_panel_platform_driver = {
	.driver = {
		.name = "seiko_panel",
		.of_match_table = platform_of_match,
	},
	.probe = seiko_panel_platform_probe,
	.remove = seiko_panel_remove,
	.shutdown = seiko_panel_shutdown,
};
module_platform_driver(seiko_panel_platform_driver);

MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
6bf18d84	1	// SPDX-License-Identifier: GPL-2.0
043652aa MF	2	/*
	3	* Copyright (C) 2017 NXP Semiconductors.
	4	* Author: Marco Franchi <marco.franchi@nxp.com>
	5	*
	6	* Based on Panel Simple driver by Thierry Reding <treding@nvidia.com>
043652aa MF	7	*/
	8
	9	#include <linux/backlight.h>
	10	#include <linux/module.h>
	11	#include <linux/of.h>
	12	#include <linux/regulator/consumer.h>
	13
	14	#include <drm/drmP.h>
	15	#include <drm/drm_crtc.h>
	16	#include <drm/drm_panel.h>
	17
	18	#include <video/display_timing.h>
	19	#include <video/videomode.h>
	20
	21	struct seiko_panel_desc {
	22	const struct drm_display_mode *modes;
	23	unsigned int num_modes;
	24	const struct display_timing *timings;
	25	unsigned int num_timings;
	26
	27	unsigned int bpc;
	28
	29	/**
	30	* @width: width (in millimeters) of the panel's active display area
	31	* @height: height (in millimeters) of the panel's active display area
	32	*/
	33	struct {
	34	unsigned int width;
	35	unsigned int height;
	36	} size;
	37
	38	u32 bus_format;
	39	u32 bus_flags;
	40	};
	41
	42	struct seiko_panel {
	43	struct drm_panel base;
	44	bool prepared;
	45	bool enabled;
	46	const struct seiko_panel_desc *desc;
	47	struct backlight_device *backlight;
	48	struct regulator *dvdd;
	49	struct regulator *avdd;
	50	};
	51
	52	static inline struct seiko_panel to_seiko_panel(struct drm_panel panel)
	53	{
	54	return container_of(panel, struct seiko_panel, base);
	55	}
	56
	57	static int seiko_panel_get_fixed_modes(struct seiko_panel *panel)
	58	{
	59	struct drm_connector *connector = panel->base.connector;
	60	struct drm_device *drm = panel->base.drm;
	61	struct drm_display_mode *mode;
	62	unsigned int i, num = 0;
	63
	64	if (!panel->desc)
	65	return 0;
	66
	67	for (i = 0; i < panel->desc->num_timings; i++) {
	68	const struct display_timing *dt = &panel->desc->timings[i];
	69	struct videomode vm;
	70
71	videomode_from_timing(dt, &vm);
72	mode = drm_mode_create(drm);
73	if (!mode) {
74	dev_err(drm->dev, "failed to add mode %ux%u\n",
75	dt->hactive.typ, dt->vactive.typ);
76	continue;
77	}
78
79	drm_display_mode_from_videomode(&vm, mode);
80
81	mode->type \|= DRM_MODE_TYPE_DRIVER;
82
83	if (panel->desc->num_timings == 1)
84	mode->type \|= DRM_MODE_TYPE_PREFERRED;
85
86	drm_mode_probed_add(connector, mode);
87	num++;
88	}
89
90	for (i = 0; i < panel->desc->num_modes; i++) {
91	const struct drm_display_mode *m = &panel->desc->modes[i];
92
93	mode = drm_mode_duplicate(drm, m);
94	if (!mode) {
95	dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
96	m->hdisplay, m->vdisplay, m->vrefresh);
97	continue;
98	}
99
100	mode->type \|= DRM_MODE_TYPE_DRIVER;
101
102	if (panel->desc->num_modes == 1)
103	mode->type \|= DRM_MODE_TYPE_PREFERRED;
104
105	drm_mode_set_name(mode);
106
107	drm_mode_probed_add(connector, mode);
108	num++;
109	}
110
111	connector->display_info.bpc = panel->desc->bpc;
112	connector->display_info.width_mm = panel->desc->size.width;
113	connector->display_info.height_mm = panel->desc->size.height;
114	if (panel->desc->bus_format)
115	drm_display_info_set_bus_formats(&connector->display_info,
116	&panel->desc->bus_format, 1);
117	connector->display_info.bus_flags = panel->desc->bus_flags;
118
119	return num;
120	}
121
122	static int seiko_panel_disable(struct drm_panel *panel)
123	{
124	struct seiko_panel *p = to_seiko_panel(panel);
125
126	if (!p->enabled)
127	return 0;
128
129	if (p->backlight) {
130	p->backlight->props.power = FB_BLANK_POWERDOWN;
131	p->backlight->props.state \|= BL_CORE_FBBLANK;
132	backlight_update_status(p->backlight);
133	}
134
135	p->enabled = false;
136
137	return 0;
138	}
139
140	static int seiko_panel_unprepare(struct drm_panel *panel)
141	{
142	struct seiko_panel *p = to_seiko_panel(panel);
143
144	if (!p->prepared)
145	return 0;
146
147	regulator_disable(p->avdd);
148
149	/* Add a 100ms delay as per the panel datasheet */
150	msleep(100);
151
152	regulator_disable(p->dvdd);
153
154	p->prepared = false;
155
156	return 0;
157	}
158
159	static int seiko_panel_prepare(struct drm_panel *panel)
160	{
161	struct seiko_panel *p = to_seiko_panel(panel);
162	int err;
163
164	if (p->prepared)
165	return 0;
166
167	err = regulator_enable(p->dvdd);
168	if (err < 0) {
169	dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
170	return err;
171	}
172
173	/* Add a 100ms delay as per the panel datasheet */
174	msleep(100);
175
176	err = regulator_enable(p->avdd);
177	if (err < 0) {
178	dev_err(panel->dev, "failed to enable avdd: %d\n", err);
179	goto disable_dvdd;
180	}
181
182	p->prepared = true;
183
184	return 0;
185
186	disable_dvdd:
187	regulator_disable(p->dvdd);
188	return err;
189	}
190
191	static int seiko_panel_enable(struct drm_panel *panel)
192	{
193	struct seiko_panel *p = to_seiko_panel(panel);
194
195	if (p->enabled)
196	return 0;
197
198	if (p->backlight) {
199	p->backlight->props.state &= ~BL_CORE_FBBLANK;
200	p->backlight->props.power = FB_BLANK_UNBLANK;
201	backlight_update_status(p->backlight);
202	}
203
204	p->enabled = true;
205
206	return 0;
207	}
208
209	static int seiko_panel_get_modes(struct drm_panel *panel)
210	{
211	struct seiko_panel *p = to_seiko_panel(panel);
212
213	/* add hard-coded panel modes */
214	return seiko_panel_get_fixed_modes(p);
215	}
216
217	static int seiko_panel_get_timings(struct drm_panel *panel,
218	unsigned int num_timings,
219	struct display_timing *timings)
220	{
221	struct seiko_panel *p = to_seiko_panel(panel);
222	unsigned int i;
223
224	if (p->desc->num_timings < num_timings)
225	num_timings = p->desc->num_timings;
226
227	if (timings)
228	for (i = 0; i < num_timings; i++)
229	timings[i] = p->desc->timings[i];
230
231	return p->desc->num_timings;
232	}
233
234	static const struct drm_panel_funcs seiko_panel_funcs = {
235	.disable = seiko_panel_disable,
236	.unprepare = seiko_panel_unprepare,
237	.prepare = seiko_panel_prepare,
238	.enable = seiko_panel_enable,
239	.get_modes = seiko_panel_get_modes,
240	.get_timings = seiko_panel_get_timings,
241	};
242
243	static int seiko_panel_probe(struct device *dev,
244	const struct seiko_panel_desc *desc)
245	{
246	struct device_node *backlight;
247	struct seiko_panel *panel;
248	int err;
249
250	panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
251	if (!panel)
252	return -ENOMEM;
253
254	panel->enabled = false;
255	panel->prepared = false;
256	panel->desc = desc;
257
258	panel->dvdd = devm_regulator_get(dev, "dvdd");
259	if (IS_ERR(panel->dvdd))
260	return PTR_ERR(panel->dvdd);
261
262	panel->avdd = devm_regulator_get(dev, "avdd");
263	if (IS_ERR(panel->avdd))
264	return PTR_ERR(panel->avdd);
265
266	backlight = of_parse_phandle(dev->of_node, "backlight", 0);
267	if (backlight) {
268	panel->backlight = of_find_backlight_by_node(backlight);
269	of_node_put(backlight);
270
271	if (!panel->backlight)
272	return -EPROBE_DEFER;
273	}
274
275	drm_panel_init(&panel->base);
276	panel->base.dev = dev;
277	panel->base.funcs = &seiko_panel_funcs;
278
279	err = drm_panel_add(&panel->base);
280	if (err < 0)
281	return err;
282
283	dev_set_drvdata(dev, panel);
284
285	return 0;
286	}
287
288	static int seiko_panel_remove(struct platform_device *pdev)
289	{
290	struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);
291
043652aa MF	292	drm_panel_remove(&panel->base);
	293
	294	seiko_panel_disable(&panel->base);
	295
	296	if (panel->backlight)
	297	put_device(&panel->backlight->dev);
	298
	299	return 0;
	300	}
	301
	302	static void seiko_panel_shutdown(struct platform_device *pdev)
	303	{
	304	struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);
	305
	306	seiko_panel_disable(&panel->base);
	307	}
	308
	309	static const struct display_timing seiko_43wvf1g_timing = {
	310	.pixelclock = { 33500000, 33500000, 33500000 },
	311	.hactive = { 800, 800, 800 },
	312	.hfront_porch = { 164, 164, 164 },
	313	.hback_porch = { 89, 89, 89 },
	314	.hsync_len = { 10, 10, 10 },
	315	.vactive = { 480, 480, 480 },
	316	.vfront_porch = { 10, 10, 10 },
	317	.vback_porch = { 23, 23, 23 },
	318	.vsync_len = { 10, 10, 10 },
	319	.flags = DISPLAY_FLAGS_DE_LOW,
	320	};
	321
	322	static const struct seiko_panel_desc seiko_43wvf1g = {
	323	.timings = &seiko_43wvf1g_timing,
	324	.num_timings = 1,
	325	.bpc = 8,
	326	.size = {
	327	.width = 93,
	328	.height = 57,
	329	},
	330	.bus_format = MEDIA_BUS_FMT_RGB888_1X24,
	331	.bus_flags = DRM_BUS_FLAG_DE_HIGH \| DRM_BUS_FLAG_PIXDATA_NEGEDGE,
	332	};
	333
	334	static const struct of_device_id platform_of_match[] = {
	335	{
	336	.compatible = "sii,43wvf1g",
	337	.data = &seiko_43wvf1g,
	338	}, {
	339	/* sentinel */
	340	}
	341	};
	342	MODULE_DEVICE_TABLE(of, platform_of_match);
	343
	344	static int seiko_panel_platform_probe(struct platform_device *pdev)
	345	{
	346	const struct of_device_id *id;
	347
	348	id = of_match_node(platform_of_match, pdev->dev.of_node);
	349	if (!id)
	350	return -ENODEV;
	351
	352	return seiko_panel_probe(&pdev->dev, id->data);
	353	}
	354
	355	static struct platform_driver seiko_panel_platform_driver = {
356	.driver = {
357	.name = "seiko_panel",
358	.of_match_table = platform_of_match,
359	},
360	.probe = seiko_panel_platform_probe,
361	.remove = seiko_panel_remove,
362	.shutdown = seiko_panel_shutdown,
363	};
364	module_platform_driver(seiko_panel_platform_driver);
365
db2b0e5f	366	MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
043652aa MF	367	MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
043652aa MF	368	MODULE_LICENSE("GPL v2");