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/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
 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
 366 MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
 367 MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
 368 MODULE_LICENSE("GPL v2");