drivers/gpu/drm/panel/panel-seiko-43wvf1g.c

   1 // SPDX-License-Identifier: GPL-2.0
   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>
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/gpio/consumer.h>
  11 #include <linux/media-bus-format.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/regulator/consumer.h>
  16
  17 #include <video/display_timing.h>
  18 #include <video/videomode.h>
  19
  20 #include <drm/drm_crtc.h>
  21 #include <drm/drm_device.h>
  22 #include <drm/drm_panel.h>
  23
  24 struct seiko_panel_desc {
  25         const struct drm_display_mode *modes;
  26         unsigned int num_modes;
  27         const struct display_timing *timings;
  28         unsigned int num_timings;
  29
  30         unsigned int bpc;
  31
  32         /**
  33          * @width: width (in millimeters) of the panel's active display area
  34          * @height: height (in millimeters) of the panel's active display area
  35          */
  36         struct {
  37                 unsigned int width;
  38                 unsigned int height;
  39         } size;
  40
  41         u32 bus_format;
  42         u32 bus_flags;
  43 };
  44
  45 struct seiko_panel {
  46         struct drm_panel base;
  47         const struct seiko_panel_desc *desc;
  48         struct regulator *dvdd;
  49         struct regulator *avdd;
  50         struct gpio_desc *enable_gpio;
  51 };
  52
  53 static inline struct seiko_panel *to_seiko_panel(struct drm_panel *panel)
  54 {
  55         return container_of(panel, struct seiko_panel, base);
  56 }
  57
  58 static int seiko_panel_get_fixed_modes(struct seiko_panel *panel,
  59                                        struct drm_connector *connector)
  60 {
  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(connector->dev);
  73                 if (!mode) {
  74                         dev_err(panel->base.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(connector->dev, m);
  94                 if (!mode) {
  95                         dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n",
  96                                 m->hdisplay, m->vdisplay,
  97                                 drm_mode_vrefresh(m));
  98                         continue;
  99                 }
 100
 101                 mode->type |= DRM_MODE_TYPE_DRIVER;
 102
 103                 if (panel->desc->num_modes == 1)
 104                         mode->type |= DRM_MODE_TYPE_PREFERRED;
 105
 106                 drm_mode_set_name(mode);
 107
 108                 drm_mode_probed_add(connector, mode);
 109                 num++;
 110         }
 111
 112         connector->display_info.bpc = panel->desc->bpc;
 113         connector->display_info.width_mm = panel->desc->size.width;
 114         connector->display_info.height_mm = panel->desc->size.height;
 115         if (panel->desc->bus_format)
 116                 drm_display_info_set_bus_formats(&connector->display_info,
 117                                                  &panel->desc->bus_format, 1);
 118         connector->display_info.bus_flags = panel->desc->bus_flags;
 119
 120         return num;
 121 }
 122
 123 static int seiko_panel_unprepare(struct drm_panel *panel)
 124 {
 125         struct seiko_panel *p = to_seiko_panel(panel);
 126
 127         gpiod_set_value_cansleep(p->enable_gpio, 0);
 128
 129         regulator_disable(p->avdd);
 130
 131         /* Add a 100ms delay as per the panel datasheet */
 132         msleep(100);
 133
 134         regulator_disable(p->dvdd);
 135
 136         return 0;
 137 }
 138
 139 static int seiko_panel_prepare(struct drm_panel *panel)
 140 {
 141         struct seiko_panel *p = to_seiko_panel(panel);
 142         int err;
 143
 144         err = regulator_enable(p->dvdd);
 145         if (err < 0) {
 146                 dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
 147                 return err;
 148         }
 149
 150         /* Add a 100ms delay as per the panel datasheet */
 151         msleep(100);
 152
 153         err = regulator_enable(p->avdd);
 154         if (err < 0) {
 155                 dev_err(panel->dev, "failed to enable avdd: %d\n", err);
 156                 goto disable_dvdd;
 157         }
 158
 159         gpiod_set_value_cansleep(p->enable_gpio, 1);
 160
 161         return 0;
 162
 163 disable_dvdd:
 164         regulator_disable(p->dvdd);
 165         return err;
 166 }
 167
 168 static int seiko_panel_get_modes(struct drm_panel *panel,
 169                                  struct drm_connector *connector)
 170 {
 171         struct seiko_panel *p = to_seiko_panel(panel);
 172
 173         /* add hard-coded panel modes */
 174         return seiko_panel_get_fixed_modes(p, connector);
 175 }
 176
 177 static int seiko_panel_get_timings(struct drm_panel *panel,
 178                                     unsigned int num_timings,
 179                                     struct display_timing *timings)
 180 {
 181         struct seiko_panel *p = to_seiko_panel(panel);
 182         unsigned int i;
 183
 184         if (p->desc->num_timings < num_timings)
 185                 num_timings = p->desc->num_timings;
 186
 187         if (timings)
 188                 for (i = 0; i < num_timings; i++)
 189                         timings[i] = p->desc->timings[i];
 190
 191         return p->desc->num_timings;
 192 }
 193
 194 static const struct drm_panel_funcs seiko_panel_funcs = {
 195         .unprepare = seiko_panel_unprepare,
 196         .prepare = seiko_panel_prepare,
 197         .get_modes = seiko_panel_get_modes,
 198         .get_timings = seiko_panel_get_timings,
 199 };
 200
 201 static int seiko_panel_probe(struct device *dev,
 202                                         const struct seiko_panel_desc *desc)
 203 {
 204         struct seiko_panel *panel;
 205         int err;
 206
 207         panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
 208         if (!panel)
 209                 return -ENOMEM;
 210
 211         panel->desc = desc;
 212
 213         panel->dvdd = devm_regulator_get(dev, "dvdd");
 214         if (IS_ERR(panel->dvdd))
 215                 return PTR_ERR(panel->dvdd);
 216
 217         panel->avdd = devm_regulator_get(dev, "avdd");
 218         if (IS_ERR(panel->avdd))
 219                 return PTR_ERR(panel->avdd);
 220
 221         panel->enable_gpio = devm_gpiod_get_optional(dev, "enable",
 222                                                      GPIOD_OUT_LOW);
 223         if (IS_ERR(panel->enable_gpio))
 224                 return dev_err_probe(dev, PTR_ERR(panel->enable_gpio),
 225                                      "failed to request GPIO\n");
 226
 227         drm_panel_init(&panel->base, dev, &seiko_panel_funcs,
 228                        DRM_MODE_CONNECTOR_DPI);
 229
 230         err = drm_panel_of_backlight(&panel->base);
 231         if (err)
 232                 return err;
 233
 234         drm_panel_add(&panel->base);
 235
 236         dev_set_drvdata(dev, panel);
 237
 238         return 0;
 239 }
 240
 241 static void seiko_panel_remove(struct platform_device *pdev)
 242 {
 243         struct seiko_panel *panel = platform_get_drvdata(pdev);
 244
 245         drm_panel_remove(&panel->base);
 246 }
 247
 248 static const struct display_timing seiko_43wvf1g_timing = {
 249         .pixelclock = { 33500000, 33500000, 33500000 },
 250         .hactive = { 800, 800, 800 },
 251         .hfront_porch = {  164, 164, 164 },
 252         .hback_porch = { 89, 89, 89 },
 253         .hsync_len = { 10, 10, 10 },
 254         .vactive = { 480, 480, 480 },
 255         .vfront_porch = { 10, 10, 10 },
 256         .vback_porch = { 23, 23, 23 },
 257         .vsync_len = { 10, 10, 10 },
 258         .flags = DISPLAY_FLAGS_DE_LOW,
 259 };
 260
 261 static const struct seiko_panel_desc seiko_43wvf1g = {
 262         .timings = &seiko_43wvf1g_timing,
 263         .num_timings = 1,
 264         .bpc = 8,
 265         .size = {
 266                 .width = 93,
 267                 .height = 57,
 268         },
 269         .bus_format = MEDIA_BUS_FMT_RGB888_1X24,
 270         .bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE,
 271 };
 272
 273 static const struct of_device_id platform_of_match[] = {
 274         {
 275                 .compatible = "sii,43wvf1g",
 276                 .data = &seiko_43wvf1g,
 277         }, {
 278                 /* sentinel */
 279         }
 280 };
 281 MODULE_DEVICE_TABLE(of, platform_of_match);
 282
 283 static int seiko_panel_platform_probe(struct platform_device *pdev)
 284 {
 285         const struct of_device_id *id;
 286
 287         id = of_match_node(platform_of_match, pdev->dev.of_node);
 288         if (!id)
 289                 return -ENODEV;
 290
 291         return seiko_panel_probe(&pdev->dev, id->data);
 292 }
 293
 294 static struct platform_driver seiko_panel_platform_driver = {
 295         .driver = {
 296                 .name = "seiko_panel",
 297                 .of_match_table = platform_of_match,
 298         },
 299         .probe = seiko_panel_platform_probe,
 300         .remove = seiko_panel_remove,
 301 };
 302 module_platform_driver(seiko_panel_platform_driver);
 303
 304 MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
 305 MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
 306 MODULE_LICENSE("GPL v2");