1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Driver for the Samsung S6E3FA7 panel.
  4 *
  5 * Copyright (c) 2022-2024, The Linux Foundation. All rights reserved.
  6 * Generated with linux-mdss-dsi-panel-driver-generator from vendor device tree:
  7 * Copyright (c) 2013, The Linux Foundation. All rights reserved.
  8 */
  9
 10#include <linux/backlight.h>
 11#include <linux/delay.h>
 12#include <linux/gpio/consumer.h>
 13#include <linux/module.h>
 14#include <linux/of.h>
 15
 16#include <video/mipi_display.h>
 17
 18#include <drm/drm_mipi_dsi.h>
 19#include <drm/drm_modes.h>
 20#include <drm/drm_panel.h>
 21
 22struct s6e3fa7_panel {
 23	struct drm_panel panel;
 24	struct mipi_dsi_device *dsi;
 25	struct gpio_desc *reset_gpio;
 26};
 27
 28static inline struct s6e3fa7_panel *to_s6e3fa7_panel(struct drm_panel *panel)
 29{
 30	return container_of(panel, struct s6e3fa7_panel, panel);
 31}
 32
 33static void s6e3fa7_panel_reset(struct s6e3fa7_panel *ctx)
 34{
 35	gpiod_set_value_cansleep(ctx->reset_gpio, 1);
 36	usleep_range(1000, 2000);
 37	gpiod_set_value_cansleep(ctx->reset_gpio, 0);
 38	usleep_range(10000, 11000);
 39}
 40
 41static int s6e3fa7_panel_on(struct mipi_dsi_device *dsi)
 42{
 43	struct mipi_dsi_multi_context dsi_ctx = { .dsi = dsi };
 44
 45	mipi_dsi_dcs_exit_sleep_mode_multi(&dsi_ctx);
 46	mipi_dsi_msleep(&dsi_ctx, 120);
 47	mipi_dsi_dcs_set_tear_on_multi(&dsi_ctx, MIPI_DSI_DCS_TEAR_MODE_VBLANK);
 48
 49	mipi_dsi_dcs_write_seq_multi(&dsi_ctx, 0xf0, 0x5a, 0x5a);
 50	mipi_dsi_dcs_write_seq_multi(&dsi_ctx, 0xf4,
 51				     0xbb, 0x23, 0x19, 0x3a, 0x9f, 0x0f, 0x09, 0xc0,
 52				     0x00, 0xb4, 0x37, 0x70, 0x79, 0x69);
 53	mipi_dsi_dcs_write_seq_multi(&dsi_ctx, 0xf0, 0xa5, 0xa5);
 54	mipi_dsi_dcs_write_seq_multi(&dsi_ctx, MIPI_DCS_WRITE_CONTROL_DISPLAY, 0x20);
 55
 56	mipi_dsi_dcs_set_display_on_multi(&dsi_ctx);
 57
 58	return dsi_ctx.accum_err;
 59}
 60
 61static int s6e3fa7_panel_prepare(struct drm_panel *panel)
 62{
 63	struct s6e3fa7_panel *ctx = to_s6e3fa7_panel(panel);
 64	int ret;
 65
 66	s6e3fa7_panel_reset(ctx);
 67
 68	ret = s6e3fa7_panel_on(ctx->dsi);
 69	if (ret < 0)
 70		gpiod_set_value_cansleep(ctx->reset_gpio, 1);
 71
 72	return ret;
 73}
 74
 75static int s6e3fa7_panel_unprepare(struct drm_panel *panel)
 76{
 77	struct s6e3fa7_panel *ctx = to_s6e3fa7_panel(panel);
 78
 79	gpiod_set_value_cansleep(ctx->reset_gpio, 1);
 80
 81	return 0;
 82}
 83
 84static int s6e3fa7_panel_disable(struct drm_panel *panel)
 85{
 86	struct s6e3fa7_panel *ctx = to_s6e3fa7_panel(panel);
 87	struct mipi_dsi_device *dsi = ctx->dsi;
 88	struct mipi_dsi_multi_context dsi_ctx = { .dsi = dsi };
 89
 90	mipi_dsi_dcs_set_display_off_multi(&dsi_ctx);
 91	mipi_dsi_dcs_enter_sleep_mode_multi(&dsi_ctx);
 92	mipi_dsi_msleep(&dsi_ctx, 120);
 93
 94	return dsi_ctx.accum_err;
 95}
 96
 97static const struct drm_display_mode s6e3fa7_panel_mode = {
 98	.clock = (1080 + 32 + 32 + 78) * (2220 + 32 + 4 + 78) * 60 / 1000,
 99	.hdisplay = 1080,
100	.hsync_start = 1080 + 32,
101	.hsync_end = 1080 + 32 + 32,
102	.htotal = 1080 + 32 + 32 + 78,
103	.vdisplay = 2220,
104	.vsync_start = 2220 + 32,
105	.vsync_end = 2220 + 32 + 4,
106	.vtotal = 2220 + 32 + 4 + 78,
107	.width_mm = 62,
108	.height_mm = 127,
109};
110
111static int s6e3fa7_panel_get_modes(struct drm_panel *panel,
112				 struct drm_connector *connector)
113{
114	struct drm_display_mode *mode;
115
116	mode = drm_mode_duplicate(connector->dev, &s6e3fa7_panel_mode);
117	if (!mode)
118		return -ENOMEM;
119
120	drm_mode_set_name(mode);
121
122	mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
123	connector->display_info.width_mm = mode->width_mm;
124	connector->display_info.height_mm = mode->height_mm;
125	drm_mode_probed_add(connector, mode);
126
127	return 1;
128}
129
130static const struct drm_panel_funcs s6e3fa7_panel_funcs = {
131	.prepare = s6e3fa7_panel_prepare,
132	.unprepare = s6e3fa7_panel_unprepare,
133	.disable = s6e3fa7_panel_disable,
134	.get_modes = s6e3fa7_panel_get_modes,
135};
136
137static int s6e3fa7_panel_bl_update_status(struct backlight_device *bl)
138{
139	struct mipi_dsi_device *dsi = bl_get_data(bl);
140	u16 brightness = backlight_get_brightness(bl);
141	int ret;
142
143	ret = mipi_dsi_dcs_set_display_brightness_large(dsi, brightness);
144	if (ret < 0)
145		return ret;
146
147	return 0;
148}
149
150static int s6e3fa7_panel_bl_get_brightness(struct backlight_device *bl)
151{
152	struct mipi_dsi_device *dsi = bl_get_data(bl);
153	u16 brightness;
154	int ret;
155
156	ret = mipi_dsi_dcs_get_display_brightness_large(dsi, &brightness);
157	if (ret < 0)
158		return ret;
159
160	return brightness;
161}
162
163static const struct backlight_ops s6e3fa7_panel_bl_ops = {
164	.update_status = s6e3fa7_panel_bl_update_status,
165	.get_brightness = s6e3fa7_panel_bl_get_brightness,
166};
167
168static struct backlight_device *
169s6e3fa7_panel_create_backlight(struct mipi_dsi_device *dsi)
170{
171	struct device *dev = &dsi->dev;
172	const struct backlight_properties props = {
173		.type = BACKLIGHT_RAW,
174		.brightness = 1023,
175		.max_brightness = 1023,
176	};
177
178	return devm_backlight_device_register(dev, dev_name(dev), dev, dsi,
179					      &s6e3fa7_panel_bl_ops, &props);
180}
181
182static int s6e3fa7_panel_probe(struct mipi_dsi_device *dsi)
183{
184	struct device *dev = &dsi->dev;
185	struct s6e3fa7_panel *ctx;
186	int ret;
187
188	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
189	if (!ctx)
190		return -ENOMEM;
191
192	ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
193	if (IS_ERR(ctx->reset_gpio))
194		return dev_err_probe(dev, PTR_ERR(ctx->reset_gpio),
195				     "Failed to get reset-gpios\n");
196
197	ctx->dsi = dsi;
198	mipi_dsi_set_drvdata(dsi, ctx);
199
200	dsi->lanes = 4;
201	dsi->format = MIPI_DSI_FMT_RGB888;
202	dsi->mode_flags = MIPI_DSI_MODE_VIDEO_BURST |
203			  MIPI_DSI_CLOCK_NON_CONTINUOUS | MIPI_DSI_MODE_LPM;
204
205	drm_panel_init(&ctx->panel, dev, &s6e3fa7_panel_funcs,
206		       DRM_MODE_CONNECTOR_DSI);
207	ctx->panel.prepare_prev_first = true;
208
209	ctx->panel.backlight = s6e3fa7_panel_create_backlight(dsi);
210	if (IS_ERR(ctx->panel.backlight))
211		return dev_err_probe(dev, PTR_ERR(ctx->panel.backlight),
212				     "Failed to create backlight\n");
213
214	drm_panel_add(&ctx->panel);
215
216	ret = mipi_dsi_attach(dsi);
217	if (ret < 0) {
218		dev_err(dev, "Failed to attach to DSI host: %d\n", ret);
219		drm_panel_remove(&ctx->panel);
220		return ret;
221	}
222
223	return 0;
224}
225
226static void s6e3fa7_panel_remove(struct mipi_dsi_device *dsi)
227{
228	struct s6e3fa7_panel *ctx = mipi_dsi_get_drvdata(dsi);
229	int ret;
230
231	ret = mipi_dsi_detach(dsi);
232	if (ret < 0)
233		dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret);
234
235	drm_panel_remove(&ctx->panel);
236}
237
238static const struct of_device_id s6e3fa7_panel_of_match[] = {
239	{ .compatible = "samsung,s6e3fa7-ams559nk06" },
240	{ /* sentinel */ }
241};
242MODULE_DEVICE_TABLE(of, s6e3fa7_panel_of_match);
243
244static struct mipi_dsi_driver s6e3fa7_panel_driver = {
245	.probe = s6e3fa7_panel_probe,
246	.remove = s6e3fa7_panel_remove,
247	.driver = {
248		.name = "panel-samsung-s6e3fa7",
249		.of_match_table = s6e3fa7_panel_of_match,
250	},
251};
252module_mipi_dsi_driver(s6e3fa7_panel_driver);
253
254MODULE_AUTHOR("Richard Acayan <mailingradian@gmail.com>");
255MODULE_DESCRIPTION("DRM driver for Samsung S6E3FA7 command mode DSI panel");
256MODULE_LICENSE("GPL");