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_drm_panel_alloc(dev, struct seiko_panel, base, 208 &seiko_panel_funcs, 209 DRM_MODE_CONNECTOR_DPI); 210 if (IS_ERR(panel)) 211 return PTR_ERR(panel); 212 213 panel->desc = desc; 214 215 panel->dvdd = devm_regulator_get(dev, "dvdd"); 216 if (IS_ERR(panel->dvdd)) 217 return PTR_ERR(panel->dvdd); 218 219 panel->avdd = devm_regulator_get(dev, "avdd"); 220 if (IS_ERR(panel->avdd)) 221 return PTR_ERR(panel->avdd); 222 223 panel->enable_gpio = devm_gpiod_get_optional(dev, "enable", 224 GPIOD_OUT_LOW); 225 if (IS_ERR(panel->enable_gpio)) 226 return dev_err_probe(dev, PTR_ERR(panel->enable_gpio), 227 "failed to request GPIO\n"); 228 229 err = drm_panel_of_backlight(&panel->base); 230 if (err) 231 return err; 232 233 drm_panel_add(&panel->base); 234 235 dev_set_drvdata(dev, panel); 236 237 return 0; 238 } 239 240 static void seiko_panel_remove(struct platform_device *pdev) 241 { 242 struct seiko_panel *panel = platform_get_drvdata(pdev); 243 244 drm_panel_remove(&panel->base); 245 } 246 247 static const struct display_timing seiko_43wvf1g_timing = { 248 .pixelclock = { 33500000, 33500000, 33500000 }, 249 .hactive = { 800, 800, 800 }, 250 .hfront_porch = { 164, 164, 164 }, 251 .hback_porch = { 89, 89, 89 }, 252 .hsync_len = { 10, 10, 10 }, 253 .vactive = { 480, 480, 480 }, 254 .vfront_porch = { 10, 10, 10 }, 255 .vback_porch = { 23, 23, 23 }, 256 .vsync_len = { 10, 10, 10 }, 257 .flags = DISPLAY_FLAGS_DE_LOW, 258 }; 259 260 static const struct seiko_panel_desc seiko_43wvf1g = { 261 .timings = &seiko_43wvf1g_timing, 262 .num_timings = 1, 263 .bpc = 8, 264 .size = { 265 .width = 93, 266 .height = 57, 267 }, 268 .bus_format = MEDIA_BUS_FMT_RGB888_1X24, 269 .bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE, 270 }; 271 272 static const struct of_device_id platform_of_match[] = { 273 { 274 .compatible = "sii,43wvf1g", 275 .data = &seiko_43wvf1g, 276 }, { 277 /* sentinel */ 278 } 279 }; 280 MODULE_DEVICE_TABLE(of, platform_of_match); 281 282 static int seiko_panel_platform_probe(struct platform_device *pdev) 283 { 284 const struct of_device_id *id; 285 286 id = of_match_node(platform_of_match, pdev->dev.of_node); 287 if (!id) 288 return -ENODEV; 289 290 return seiko_panel_probe(&pdev->dev, id->data); 291 } 292 293 static struct platform_driver seiko_panel_platform_driver = { 294 .driver = { 295 .name = "seiko_panel", 296 .of_match_table = platform_of_match, 297 }, 298 .probe = seiko_panel_platform_probe, 299 .remove = seiko_panel_remove, 300 }; 301 module_platform_driver(seiko_panel_platform_driver); 302 303 MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>"); 304 MODULE_DESCRIPTION("Seiko 43WVF1G panel driver"); 305 MODULE_LICENSE("GPL v2"); 306