drm/panel/panel-sharp-lq101r1sx01.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (C) 2014 NVIDIA Corporation
0004  */
0005
0006 #include <linux/delay.h>
0007 #include <linux/gpio/consumer.h>
0008 #include <linux/module.h>
0009 #include <linux/of.h>
0010 #include <linux/regulator/consumer.h>
0011
0012 #include <video/mipi_display.h>
0013
0014 #include <drm/drm_crtc.h>
0015 #include <drm/drm_device.h>
0016 #include <drm/drm_mipi_dsi.h>
0017 #include <drm/drm_panel.h>
0018
0019 struct sharp_panel {
0020     struct drm_panel base;
0021     /* the datasheet refers to them as DSI-LINK1 and DSI-LINK2 */
0022     struct mipi_dsi_device *link1;
0023     struct mipi_dsi_device *link2;
0024
0025     struct regulator *supply;
0026
0027     bool prepared;
0028     bool enabled;
0029
0030     const struct drm_display_mode *mode;
0031 };
0032
0033 static inline struct sharp_panel *to_sharp_panel(struct drm_panel *panel)
0034 {
0035     return container_of(panel, struct sharp_panel, base);
0036 }
0037
0038 static void sharp_wait_frames(struct sharp_panel *sharp, unsigned int frames)
0039 {
0040     unsigned int refresh = drm_mode_vrefresh(sharp->mode);
0041
0042     if (WARN_ON(frames > refresh))
0043         return;
0044
0045     msleep(1000 / (refresh / frames));
0046 }
0047
0048 static int sharp_panel_write(struct sharp_panel *sharp, u16 offset, u8 value)
0049 {
0050     u8 payload[3] = { offset >> 8, offset & 0xff, value };
0051     struct mipi_dsi_device *dsi = sharp->link1;
0052     ssize_t err;
0053
0054     err = mipi_dsi_generic_write(dsi, payload, sizeof(payload));
0055     if (err < 0) {
0056         dev_err(&dsi->dev, "failed to write %02x to %04x: %zd\n",
0057             value, offset, err);
0058         return err;
0059     }
0060
0061     err = mipi_dsi_dcs_nop(dsi);
0062     if (err < 0) {
0063         dev_err(&dsi->dev, "failed to send DCS nop: %zd\n", err);
0064         return err;
0065     }
0066
0067     usleep_range(10, 20);
0068
0069     return 0;
0070 }
0071
0072 static __maybe_unused int sharp_panel_read(struct sharp_panel *sharp,
0073                        u16 offset, u8 *value)
0074 {
0075     ssize_t err;
0076
0077     cpu_to_be16s(&offset);
0078
0079     err = mipi_dsi_generic_read(sharp->link1, &offset, sizeof(offset),
0080                     value, sizeof(*value));
0081     if (err < 0)
0082         dev_err(&sharp->link1->dev, "failed to read from %04x: %zd\n",
0083             offset, err);
0084
0085     return err;
0086 }
0087
0088 static int sharp_panel_disable(struct drm_panel *panel)
0089 {
0090     struct sharp_panel *sharp = to_sharp_panel(panel);
0091
0092     if (!sharp->enabled)
0093         return 0;
0094
0095     sharp->enabled = false;
0096
0097     return 0;
0098 }
0099
0100 static int sharp_panel_unprepare(struct drm_panel *panel)
0101 {
0102     struct sharp_panel *sharp = to_sharp_panel(panel);
0103     int err;
0104
0105     if (!sharp->prepared)
0106         return 0;
0107
0108     sharp_wait_frames(sharp, 4);
0109
0110     err = mipi_dsi_dcs_set_display_off(sharp->link1);
0111     if (err < 0)
0112         dev_err(panel->dev, "failed to set display off: %d\n", err);
0113
0114     err = mipi_dsi_dcs_enter_sleep_mode(sharp->link1);
0115     if (err < 0)
0116         dev_err(panel->dev, "failed to enter sleep mode: %d\n", err);
0117
0118     msleep(120);
0119
0120     regulator_disable(sharp->supply);
0121
0122     sharp->prepared = false;
0123
0124     return 0;
0125 }
0126
0127 static int sharp_setup_symmetrical_split(struct mipi_dsi_device *left,
0128                      struct mipi_dsi_device *right,
0129                      const struct drm_display_mode *mode)
0130 {
0131     int err;
0132
0133     err = mipi_dsi_dcs_set_column_address(left, 0, mode->hdisplay / 2 - 1);
0134     if (err < 0) {
0135         dev_err(&left->dev, "failed to set column address: %d\n", err);
0136         return err;
0137     }
0138
0139     err = mipi_dsi_dcs_set_page_address(left, 0, mode->vdisplay - 1);
0140     if (err < 0) {
0141         dev_err(&left->dev, "failed to set page address: %d\n", err);
0142         return err;
0143     }
0144
0145     err = mipi_dsi_dcs_set_column_address(right, mode->hdisplay / 2,
0146                           mode->hdisplay - 1);
0147     if (err < 0) {
0148         dev_err(&right->dev, "failed to set column address: %d\n", err);
0149         return err;
0150     }
0151
0152     err = mipi_dsi_dcs_set_page_address(right, 0, mode->vdisplay - 1);
0153     if (err < 0) {
0154         dev_err(&right->dev, "failed to set page address: %d\n", err);
0155         return err;
0156     }
0157
0158     return 0;
0159 }
0160
0161 static int sharp_panel_prepare(struct drm_panel *panel)
0162 {
0163     struct sharp_panel *sharp = to_sharp_panel(panel);
0164     u8 format = MIPI_DCS_PIXEL_FMT_24BIT;
0165     int err;
0166
0167     if (sharp->prepared)
0168         return 0;
0169
0170     err = regulator_enable(sharp->supply);
0171     if (err < 0)
0172         return err;
0173
0174     /*
0175      * According to the datasheet, the panel needs around 10 ms to fully
0176      * power up. At least another 120 ms is required before exiting sleep
0177      * mode to make sure the panel is ready. Throw in another 20 ms for
0178      * good measure.
0179      */
0180     msleep(150);
0181
0182     err = mipi_dsi_dcs_exit_sleep_mode(sharp->link1);
0183     if (err < 0) {
0184         dev_err(panel->dev, "failed to exit sleep mode: %d\n", err);
0185         goto poweroff;
0186     }
0187
0188     /*
0189      * The MIPI DCS specification mandates this delay only between the
0190      * exit_sleep_mode and enter_sleep_mode commands, so it isn't strictly
0191      * necessary here.
0192      */
0193     /*
0194     msleep(120);
0195     */
0196
0197     /* set left-right mode */
0198     err = sharp_panel_write(sharp, 0x1000, 0x2a);
0199     if (err < 0) {
0200         dev_err(panel->dev, "failed to set left-right mode: %d\n", err);
0201         goto poweroff;
0202     }
0203
0204     /* enable command mode */
0205     err = sharp_panel_write(sharp, 0x1001, 0x01);
0206     if (err < 0) {
0207         dev_err(panel->dev, "failed to enable command mode: %d\n", err);
0208         goto poweroff;
0209     }
0210
0211     err = mipi_dsi_dcs_set_pixel_format(sharp->link1, format);
0212     if (err < 0) {
0213         dev_err(panel->dev, "failed to set pixel format: %d\n", err);
0214         goto poweroff;
0215     }
0216
0217     /*
0218      * TODO: The device supports both left-right and even-odd split
0219      * configurations, but this driver currently supports only the left-
0220      * right split. To support a different mode a mechanism needs to be
0221      * put in place to communicate the configuration back to the DSI host
0222      * controller.
0223      */
0224     err = sharp_setup_symmetrical_split(sharp->link1, sharp->link2,
0225                         sharp->mode);
0226     if (err < 0) {
0227         dev_err(panel->dev, "failed to set up symmetrical split: %d\n",
0228             err);
0229         goto poweroff;
0230     }
0231
0232     err = mipi_dsi_dcs_set_display_on(sharp->link1);
0233     if (err < 0) {
0234         dev_err(panel->dev, "failed to set display on: %d\n", err);
0235         goto poweroff;
0236     }
0237
0238     sharp->prepared = true;
0239
0240     /* wait for 6 frames before continuing */
0241     sharp_wait_frames(sharp, 6);
0242
0243     return 0;
0244
0245 poweroff:
0246     regulator_disable(sharp->supply);
0247     return err;
0248 }
0249
0250 static int sharp_panel_enable(struct drm_panel *panel)
0251 {
0252     struct sharp_panel *sharp = to_sharp_panel(panel);
0253
0254     if (sharp->enabled)
0255         return 0;
0256
0257     sharp->enabled = true;
0258
0259     return 0;
0260 }
0261
0262 static const struct drm_display_mode default_mode = {
0263     .clock = 278000,
0264     .hdisplay = 2560,
0265     .hsync_start = 2560 + 128,
0266     .hsync_end = 2560 + 128 + 64,
0267     .htotal = 2560 + 128 + 64 + 64,
0268     .vdisplay = 1600,
0269     .vsync_start = 1600 + 4,
0270     .vsync_end = 1600 + 4 + 8,
0271     .vtotal = 1600 + 4 + 8 + 32,
0272 };
0273
0274 static int sharp_panel_get_modes(struct drm_panel *panel,
0275                  struct drm_connector *connector)
0276 {
0277     struct drm_display_mode *mode;
0278
0279     mode = drm_mode_duplicate(connector->dev, &default_mode);
0280     if (!mode) {
0281         dev_err(panel->dev, "failed to add mode %ux%ux@%u\n",
0282             default_mode.hdisplay, default_mode.vdisplay,
0283             drm_mode_vrefresh(&default_mode));
0284         return -ENOMEM;
0285     }
0286
0287     drm_mode_set_name(mode);
0288
0289     drm_mode_probed_add(connector, mode);
0290
0291     connector->display_info.width_mm = 217;
0292     connector->display_info.height_mm = 136;
0293
0294     return 1;
0295 }
0296
0297 static const struct drm_panel_funcs sharp_panel_funcs = {
0298     .disable = sharp_panel_disable,
0299     .unprepare = sharp_panel_unprepare,
0300     .prepare = sharp_panel_prepare,
0301     .enable = sharp_panel_enable,
0302     .get_modes = sharp_panel_get_modes,
0303 };
0304
0305 static const struct of_device_id sharp_of_match[] = {
0306     { .compatible = "sharp,lq101r1sx01", },
0307     { }
0308 };
0309 MODULE_DEVICE_TABLE(of, sharp_of_match);
0310
0311 static int sharp_panel_add(struct sharp_panel *sharp)
0312 {
0313     int ret;
0314
0315     sharp->mode = &default_mode;
0316
0317     sharp->supply = devm_regulator_get(&sharp->link1->dev, "power");
0318     if (IS_ERR(sharp->supply))
0319         return PTR_ERR(sharp->supply);
0320
0321     drm_panel_init(&sharp->base, &sharp->link1->dev, &sharp_panel_funcs,
0322                DRM_MODE_CONNECTOR_DSI);
0323
0324     ret = drm_panel_of_backlight(&sharp->base);
0325     if (ret)
0326         return ret;
0327
0328     drm_panel_add(&sharp->base);
0329
0330     return 0;
0331 }
0332
0333 static void sharp_panel_del(struct sharp_panel *sharp)
0334 {
0335     if (sharp->base.dev)
0336         drm_panel_remove(&sharp->base);
0337
0338     if (sharp->link2)
0339         put_device(&sharp->link2->dev);
0340 }
0341
0342 static int sharp_panel_probe(struct mipi_dsi_device *dsi)
0343 {
0344     struct mipi_dsi_device *secondary = NULL;
0345     struct sharp_panel *sharp;
0346     struct device_node *np;
0347     int err;
0348
0349     dsi->lanes = 4;
0350     dsi->format = MIPI_DSI_FMT_RGB888;
0351     dsi->mode_flags = MIPI_DSI_MODE_LPM;
0352
0353     /* Find DSI-LINK1 */
0354     np = of_parse_phandle(dsi->dev.of_node, "link2", 0);
0355     if (np) {
0356         secondary = of_find_mipi_dsi_device_by_node(np);
0357         of_node_put(np);
0358
0359         if (!secondary)
0360             return -EPROBE_DEFER;
0361     }
0362
0363     /* register a panel for only the DSI-LINK1 interface */
0364     if (secondary) {
0365         sharp = devm_kzalloc(&dsi->dev, sizeof(*sharp), GFP_KERNEL);
0366         if (!sharp) {
0367             put_device(&secondary->dev);
0368             return -ENOMEM;
0369         }
0370
0371         mipi_dsi_set_drvdata(dsi, sharp);
0372
0373         sharp->link2 = secondary;
0374         sharp->link1 = dsi;
0375
0376         err = sharp_panel_add(sharp);
0377         if (err < 0) {
0378             put_device(&secondary->dev);
0379             return err;
0380         }
0381     }
0382
0383     err = mipi_dsi_attach(dsi);
0384     if (err < 0) {
0385         if (secondary)
0386             sharp_panel_del(sharp);
0387
0388         return err;
0389     }
0390
0391     return 0;
0392 }
0393
0394 static int sharp_panel_remove(struct mipi_dsi_device *dsi)
0395 {
0396     struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
0397     int err;
0398
0399     /* only detach from host for the DSI-LINK2 interface */
0400     if (!sharp) {
0401         mipi_dsi_detach(dsi);
0402         return 0;
0403     }
0404
0405     err = drm_panel_disable(&sharp->base);
0406     if (err < 0)
0407         dev_err(&dsi->dev, "failed to disable panel: %d\n", err);
0408
0409     err = mipi_dsi_detach(dsi);
0410     if (err < 0)
0411         dev_err(&dsi->dev, "failed to detach from DSI host: %d\n", err);
0412
0413     sharp_panel_del(sharp);
0414
0415     return 0;
0416 }
0417
0418 static void sharp_panel_shutdown(struct mipi_dsi_device *dsi)
0419 {
0420     struct sharp_panel *sharp = mipi_dsi_get_drvdata(dsi);
0421
0422     /* nothing to do for DSI-LINK2 */
0423     if (!sharp)
0424         return;
0425
0426     drm_panel_disable(&sharp->base);
0427 }
0428
0429 static struct mipi_dsi_driver sharp_panel_driver = {
0430     .driver = {
0431         .name = "panel-sharp-lq101r1sx01",
0432         .of_match_table = sharp_of_match,
0433     },
0434     .probe = sharp_panel_probe,
0435     .remove = sharp_panel_remove,
0436     .shutdown = sharp_panel_shutdown,
0437 };
0438 module_mipi_dsi_driver(sharp_panel_driver);
0439
0440 MODULE_AUTHOR("Thierry Reding <treding@nvidia.com>");
0441 MODULE_DESCRIPTION("Sharp LQ101R1SX01 panel driver");
0442 MODULE_LICENSE("GPL v2");