drm/panel/panel-samsung-sofef00.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /* Copyright (c) 2020 Caleb Connolly <caleb@connolly.tech>
0003  * Generated with linux-mdss-dsi-panel-driver-generator from vendor device tree:
0004  * Copyright (c) 2020, The Linux Foundation. All rights reserved.
0005  */
0006
0007 #include <linux/delay.h>
0008 #include <linux/gpio/consumer.h>
0009 #include <linux/module.h>
0010 #include <linux/of.h>
0011 #include <linux/of_device.h>
0012 #include <linux/regulator/consumer.h>
0013 #include <linux/swab.h>
0014 #include <linux/backlight.h>
0015
0016 #include <video/mipi_display.h>
0017
0018 #include <drm/drm_mipi_dsi.h>
0019 #include <drm/drm_modes.h>
0020 #include <drm/drm_panel.h>
0021
0022 struct sofef00_panel {
0023     struct drm_panel panel;
0024     struct mipi_dsi_device *dsi;
0025     struct regulator *supply;
0026     struct gpio_desc *reset_gpio;
0027     const struct drm_display_mode *mode;
0028     bool prepared;
0029 };
0030
0031 static inline
0032 struct sofef00_panel *to_sofef00_panel(struct drm_panel *panel)
0033 {
0034     return container_of(panel, struct sofef00_panel, panel);
0035 }
0036
0037 #define dsi_dcs_write_seq(dsi, seq...) do {             \
0038         static const u8 d[] = { seq };              \
0039         int ret;                        \
0040         ret = mipi_dsi_dcs_write_buffer(dsi, d, ARRAY_SIZE(d)); \
0041         if (ret < 0)                        \
0042             return ret;                 \
0043     } while (0)
0044
0045 static void sofef00_panel_reset(struct sofef00_panel *ctx)
0046 {
0047     gpiod_set_value_cansleep(ctx->reset_gpio, 0);
0048     usleep_range(5000, 6000);
0049     gpiod_set_value_cansleep(ctx->reset_gpio, 1);
0050     usleep_range(2000, 3000);
0051     gpiod_set_value_cansleep(ctx->reset_gpio, 0);
0052     usleep_range(12000, 13000);
0053 }
0054
0055 static int sofef00_panel_on(struct sofef00_panel *ctx)
0056 {
0057     struct mipi_dsi_device *dsi = ctx->dsi;
0058     struct device *dev = &dsi->dev;
0059     int ret;
0060
0061     dsi->mode_flags |= MIPI_DSI_MODE_LPM;
0062
0063     ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
0064     if (ret < 0) {
0065         dev_err(dev, "Failed to exit sleep mode: %d\n", ret);
0066         return ret;
0067     }
0068     usleep_range(10000, 11000);
0069
0070     dsi_dcs_write_seq(dsi, 0xf0, 0x5a, 0x5a);
0071
0072     ret = mipi_dsi_dcs_set_tear_on(dsi, MIPI_DSI_DCS_TEAR_MODE_VBLANK);
0073     if (ret < 0) {
0074         dev_err(dev, "Failed to set tear on: %d\n", ret);
0075         return ret;
0076     }
0077
0078     dsi_dcs_write_seq(dsi, 0xf0, 0xa5, 0xa5);
0079     dsi_dcs_write_seq(dsi, 0xf0, 0x5a, 0x5a);
0080     dsi_dcs_write_seq(dsi, 0xb0, 0x07);
0081     dsi_dcs_write_seq(dsi, 0xb6, 0x12);
0082     dsi_dcs_write_seq(dsi, 0xf0, 0xa5, 0xa5);
0083     dsi_dcs_write_seq(dsi, MIPI_DCS_WRITE_CONTROL_DISPLAY, 0x20);
0084     dsi_dcs_write_seq(dsi, MIPI_DCS_WRITE_POWER_SAVE, 0x00);
0085
0086     ret = mipi_dsi_dcs_set_display_on(dsi);
0087     if (ret < 0) {
0088         dev_err(dev, "Failed to set display on: %d\n", ret);
0089         return ret;
0090     }
0091
0092     return 0;
0093 }
0094
0095 static int sofef00_panel_off(struct sofef00_panel *ctx)
0096 {
0097     struct mipi_dsi_device *dsi = ctx->dsi;
0098     struct device *dev = &dsi->dev;
0099     int ret;
0100
0101     dsi->mode_flags &= ~MIPI_DSI_MODE_LPM;
0102
0103     ret = mipi_dsi_dcs_set_display_off(dsi);
0104     if (ret < 0) {
0105         dev_err(dev, "Failed to set display off: %d\n", ret);
0106         return ret;
0107     }
0108     msleep(40);
0109
0110     ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
0111     if (ret < 0) {
0112         dev_err(dev, "Failed to enter sleep mode: %d\n", ret);
0113         return ret;
0114     }
0115     msleep(160);
0116
0117     return 0;
0118 }
0119
0120 static int sofef00_panel_prepare(struct drm_panel *panel)
0121 {
0122     struct sofef00_panel *ctx = to_sofef00_panel(panel);
0123     struct device *dev = &ctx->dsi->dev;
0124     int ret;
0125
0126     if (ctx->prepared)
0127         return 0;
0128
0129     ret = regulator_enable(ctx->supply);
0130     if (ret < 0) {
0131         dev_err(dev, "Failed to enable regulator: %d\n", ret);
0132         return ret;
0133     }
0134
0135     sofef00_panel_reset(ctx);
0136
0137     ret = sofef00_panel_on(ctx);
0138     if (ret < 0) {
0139         dev_err(dev, "Failed to initialize panel: %d\n", ret);
0140         gpiod_set_value_cansleep(ctx->reset_gpio, 1);
0141         return ret;
0142     }
0143
0144     ctx->prepared = true;
0145     return 0;
0146 }
0147
0148 static int sofef00_panel_unprepare(struct drm_panel *panel)
0149 {
0150     struct sofef00_panel *ctx = to_sofef00_panel(panel);
0151     struct device *dev = &ctx->dsi->dev;
0152     int ret;
0153
0154     if (!ctx->prepared)
0155         return 0;
0156
0157     ret = sofef00_panel_off(ctx);
0158     if (ret < 0)
0159         dev_err(dev, "Failed to un-initialize panel: %d\n", ret);
0160
0161     regulator_disable(ctx->supply);
0162
0163     ctx->prepared = false;
0164     return 0;
0165 }
0166
0167 static const struct drm_display_mode enchilada_panel_mode = {
0168     .clock = (1080 + 112 + 16 + 36) * (2280 + 36 + 8 + 12) * 60 / 1000,
0169     .hdisplay = 1080,
0170     .hsync_start = 1080 + 112,
0171     .hsync_end = 1080 + 112 + 16,
0172     .htotal = 1080 + 112 + 16 + 36,
0173     .vdisplay = 2280,
0174     .vsync_start = 2280 + 36,
0175     .vsync_end = 2280 + 36 + 8,
0176     .vtotal = 2280 + 36 + 8 + 12,
0177     .width_mm = 68,
0178     .height_mm = 145,
0179 };
0180
0181 static const struct drm_display_mode fajita_panel_mode = {
0182     .clock = (1080 + 72 + 16 + 36) * (2340 + 32 + 4 + 18) * 60 / 1000,
0183     .hdisplay = 1080,
0184     .hsync_start = 1080 + 72,
0185     .hsync_end = 1080 + 72 + 16,
0186     .htotal = 1080 + 72 + 16 + 36,
0187     .vdisplay = 2340,
0188     .vsync_start = 2340 + 32,
0189     .vsync_end = 2340 + 32 + 4,
0190     .vtotal = 2340 + 32 + 4 + 18,
0191     .width_mm = 68,
0192     .height_mm = 145,
0193 };
0194
0195 static int sofef00_panel_get_modes(struct drm_panel *panel, struct drm_connector *connector)
0196 {
0197     struct drm_display_mode *mode;
0198     struct sofef00_panel *ctx = to_sofef00_panel(panel);
0199
0200     mode = drm_mode_duplicate(connector->dev, ctx->mode);
0201     if (!mode)
0202         return -ENOMEM;
0203
0204     drm_mode_set_name(mode);
0205
0206     mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
0207     connector->display_info.width_mm = mode->width_mm;
0208     connector->display_info.height_mm = mode->height_mm;
0209     drm_mode_probed_add(connector, mode);
0210
0211     return 1;
0212 }
0213
0214 static const struct drm_panel_funcs sofef00_panel_panel_funcs = {
0215     .prepare = sofef00_panel_prepare,
0216     .unprepare = sofef00_panel_unprepare,
0217     .get_modes = sofef00_panel_get_modes,
0218 };
0219
0220 static int sofef00_panel_bl_update_status(struct backlight_device *bl)
0221 {
0222     struct mipi_dsi_device *dsi = bl_get_data(bl);
0223     int err;
0224     u16 brightness;
0225
0226     brightness = (u16)backlight_get_brightness(bl);
0227     // This panel needs the high and low bytes swapped for the brightness value
0228     brightness = __swab16(brightness);
0229
0230     err = mipi_dsi_dcs_set_display_brightness(dsi, brightness);
0231     if (err < 0)
0232         return err;
0233
0234     return 0;
0235 }
0236
0237 static const struct backlight_ops sofef00_panel_bl_ops = {
0238     .update_status = sofef00_panel_bl_update_status,
0239 };
0240
0241 static struct backlight_device *
0242 sofef00_create_backlight(struct mipi_dsi_device *dsi)
0243 {
0244     struct device *dev = &dsi->dev;
0245     const struct backlight_properties props = {
0246         .type = BACKLIGHT_PLATFORM,
0247         .brightness = 1023,
0248         .max_brightness = 1023,
0249     };
0250
0251     return devm_backlight_device_register(dev, dev_name(dev), dev, dsi,
0252                           &sofef00_panel_bl_ops, &props);
0253 }
0254
0255 static int sofef00_panel_probe(struct mipi_dsi_device *dsi)
0256 {
0257     struct device *dev = &dsi->dev;
0258     struct sofef00_panel *ctx;
0259     int ret;
0260
0261     ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
0262     if (!ctx)
0263         return -ENOMEM;
0264
0265     ctx->mode = of_device_get_match_data(dev);
0266
0267     if (!ctx->mode) {
0268         dev_err(dev, "Missing device mode\n");
0269         return -ENODEV;
0270     }
0271
0272     ctx->supply = devm_regulator_get(dev, "vddio");
0273     if (IS_ERR(ctx->supply))
0274         return dev_err_probe(dev, PTR_ERR(ctx->supply),
0275                      "Failed to get vddio regulator\n");
0276
0277     ctx->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
0278     if (IS_ERR(ctx->reset_gpio))
0279         return dev_err_probe(dev, PTR_ERR(ctx->reset_gpio),
0280                      "Failed to get reset-gpios\n");
0281
0282     ctx->dsi = dsi;
0283     mipi_dsi_set_drvdata(dsi, ctx);
0284
0285     dsi->lanes = 4;
0286     dsi->format = MIPI_DSI_FMT_RGB888;
0287
0288     drm_panel_init(&ctx->panel, dev, &sofef00_panel_panel_funcs,
0289                DRM_MODE_CONNECTOR_DSI);
0290
0291     ctx->panel.backlight = sofef00_create_backlight(dsi);
0292     if (IS_ERR(ctx->panel.backlight))
0293         return dev_err_probe(dev, PTR_ERR(ctx->panel.backlight),
0294                      "Failed to create backlight\n");
0295
0296     drm_panel_add(&ctx->panel);
0297
0298     ret = mipi_dsi_attach(dsi);
0299     if (ret < 0) {
0300         dev_err(dev, "Failed to attach to DSI host: %d\n", ret);
0301         drm_panel_remove(&ctx->panel);
0302         return ret;
0303     }
0304
0305     return 0;
0306 }
0307
0308 static int sofef00_panel_remove(struct mipi_dsi_device *dsi)
0309 {
0310     struct sofef00_panel *ctx = mipi_dsi_get_drvdata(dsi);
0311     int ret;
0312
0313     ret = mipi_dsi_detach(dsi);
0314     if (ret < 0)
0315         dev_err(&dsi->dev, "Failed to detach from DSI host: %d\n", ret);
0316
0317     drm_panel_remove(&ctx->panel);
0318
0319     return 0;
0320 }
0321
0322 static const struct of_device_id sofef00_panel_of_match[] = {
0323     { // OnePlus 6 / enchilada
0324         .compatible = "samsung,sofef00",
0325         .data = &enchilada_panel_mode,
0326     },
0327     { // OnePlus 6T / fajita
0328         .compatible = "samsung,s6e3fc2x01",
0329         .data = &fajita_panel_mode,
0330     },
0331     { /* sentinel */ }
0332 };
0333 MODULE_DEVICE_TABLE(of, sofef00_panel_of_match);
0334
0335 static struct mipi_dsi_driver sofef00_panel_driver = {
0336     .probe = sofef00_panel_probe,
0337     .remove = sofef00_panel_remove,
0338     .driver = {
0339         .name = "panel-oneplus6",
0340         .of_match_table = sofef00_panel_of_match,
0341     },
0342 };
0343
0344 module_mipi_dsi_driver(sofef00_panel_driver);
0345
0346 MODULE_AUTHOR("Caleb Connolly <caleb@connolly.tech>");
0347 MODULE_DESCRIPTION("DRM driver for Samsung AMOLED DSI panels found in OnePlus 6/6T phones");
0348 MODULE_LICENSE("GPL v2");