1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright 2021 Google Inc. 4 * 5 * Panel driver for the Samsung ATNA33XC20 panel. This panel can't be handled 6 * by the DRM_PANEL_SIMPLE driver because its power sequencing is non-standard. 7 */ 8 9 #include <linux/backlight.h> 10 #include <linux/delay.h> 11 #include <linux/gpio/consumer.h> 12 #include <linux/iopoll.h> 13 #include <linux/module.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regulator/consumer.h> 16 17 #include <drm/drm_dp_aux_bus.h> 18 #include <drm/drm_dp_helper.h> 19 #include <drm/drm_edid.h> 20 #include <drm/drm_panel.h> 21 22 struct atana33xc20_panel { 23 struct drm_panel base; 24 bool prepared; 25 bool enabled; 26 bool el3_was_on; 27 28 bool no_hpd; 29 struct gpio_desc *hpd_gpio; 30 31 struct regulator *supply; 32 struct gpio_desc *el_on3_gpio; 33 34 struct edid *edid; 35 36 ktime_t powered_off_time; 37 ktime_t powered_on_time; 38 ktime_t el_on3_off_time; 39 }; 40 41 static inline struct atana33xc20_panel *to_atana33xc20(struct drm_panel *panel) 42 { 43 return container_of(panel, struct atana33xc20_panel, base); 44 } 45 46 static void atana33xc20_wait(ktime_t start_ktime, unsigned int min_ms) 47 { 48 ktime_t now_ktime, min_ktime; 49 50 min_ktime = ktime_add(start_ktime, ms_to_ktime(min_ms)); 51 now_ktime = ktime_get(); 52 53 if (ktime_before(now_ktime, min_ktime)) 54 msleep(ktime_to_ms(ktime_sub(min_ktime, now_ktime)) + 1); 55 } 56 57 static int atana33xc20_suspend(struct device *dev) 58 { 59 struct atana33xc20_panel *p = dev_get_drvdata(dev); 60 int ret; 61 62 /* 63 * Note 3 (Example of power off sequence in detail) in spec 64 * specifies to wait 150 ms after deasserting EL3_ON before 65 * powering off. 66 */ 67 if (p->el3_was_on) 68 atana33xc20_wait(p->el_on3_off_time, 150); 69 70 ret = regulator_disable(p->supply); 71 if (ret) 72 return ret; 73 p->powered_off_time = ktime_get(); 74 p->el3_was_on = false; 75 76 return 0; 77 } 78 79 static int atana33xc20_resume(struct device *dev) 80 { 81 struct atana33xc20_panel *p = dev_get_drvdata(dev); 82 bool hpd_asserted = false; 83 int ret; 84 85 /* T12 (Power off time) is min 500 ms */ 86 atana33xc20_wait(p->powered_off_time, 500); 87 88 ret = regulator_enable(p->supply); 89 if (ret) 90 return ret; 91 p->powered_on_time = ktime_get(); 92 93 /* 94 * Handle HPD. Note: if HPD is hooked up to a dedicated pin on the 95 * eDP controller then "no_hpd" will be false _and_ "hpd_gpio" will be 96 * NULL. It's up to the controller driver to wait for HPD after 97 * preparing the panel in that case. 98 */ 99 if (p->no_hpd) { 100 /* T3 VCC to HPD high is max 200 ms */ 101 msleep(200); 102 } else if (p->hpd_gpio) { 103 ret = readx_poll_timeout(gpiod_get_value_cansleep, p->hpd_gpio, 104 hpd_asserted, hpd_asserted, 105 1000, 200000); 106 if (!hpd_asserted) 107 dev_warn(dev, "Timeout waiting for HPD\n"); 108 } 109 110 return 0; 111 } 112 113 static int atana33xc20_disable(struct drm_panel *panel) 114 { 115 struct atana33xc20_panel *p = to_atana33xc20(panel); 116 117 /* Disabling when already disabled is a no-op */ 118 if (!p->enabled) 119 return 0; 120 121 gpiod_set_value_cansleep(p->el_on3_gpio, 0); 122 p->el_on3_off_time = ktime_get(); 123 p->enabled = false; 124 125 /* 126 * Keep track of the fact that EL_ON3 was on but we haven't power 127 * cycled yet. This lets us know that "el_on3_off_time" is recent (we 128 * don't need to worry about ktime wraparounds) and also makes it 129 * obvious if we try to enable again without a power cycle (see the 130 * warning in atana33xc20_enable()). 131 */ 132 p->el3_was_on = true; 133 134 /* 135 * Sleeping 20 ms here (after setting the GPIO) avoids a glitch when 136 * powering off. 137 */ 138 msleep(20); 139 140 return 0; 141 } 142 143 static int atana33xc20_enable(struct drm_panel *panel) 144 { 145 struct atana33xc20_panel *p = to_atana33xc20(panel); 146 147 /* Enabling when already enabled is a no-op */ 148 if (p->enabled) 149 return 0; 150 151 /* 152 * Once EL_ON3 drops we absolutely need a power cycle before the next 153 * enable or the backlight will never come on again. The code ensures 154 * this because disable() is _always_ followed by unprepare() and 155 * unprepare() forces a suspend with pm_runtime_put_sync_suspend(), 156 * but let's track just to make sure since the requirement is so 157 * non-obvious. 158 */ 159 if (WARN_ON(p->el3_was_on)) 160 return -EIO; 161 162 /* 163 * Note 2 (Example of power on sequence in detail) in spec specifies 164 * to wait 400 ms after powering on before asserting EL3_on. 165 */ 166 atana33xc20_wait(p->powered_on_time, 400); 167 168 gpiod_set_value_cansleep(p->el_on3_gpio, 1); 169 p->enabled = true; 170 171 return 0; 172 } 173 174 static int atana33xc20_unprepare(struct drm_panel *panel) 175 { 176 struct atana33xc20_panel *p = to_atana33xc20(panel); 177 int ret; 178 179 /* Unpreparing when already unprepared is a no-op */ 180 if (!p->prepared) 181 return 0; 182 183 /* 184 * Purposely do a put_sync, don't use autosuspend. The panel's tcon 185 * seems to sometimes crash when you stop giving it data and this is 186 * the best way to ensure it will come back. 187 * 188 * NOTE: we still want autosuspend for cases where we only turn on 189 * to get the EDID or otherwise send DP AUX commands to the panel. 190 */ 191 ret = pm_runtime_put_sync_suspend(panel->dev); 192 if (ret < 0) 193 return ret; 194 p->prepared = false; 195 196 return 0; 197 } 198 199 static int atana33xc20_prepare(struct drm_panel *panel) 200 { 201 struct atana33xc20_panel *p = to_atana33xc20(panel); 202 int ret; 203 204 /* Preparing when already prepared is a no-op */ 205 if (p->prepared) 206 return 0; 207 208 ret = pm_runtime_get_sync(panel->dev); 209 if (ret < 0) { 210 pm_runtime_put_autosuspend(panel->dev); 211 return ret; 212 } 213 p->prepared = true; 214 215 return 0; 216 } 217 218 static int atana33xc20_get_modes(struct drm_panel *panel, 219 struct drm_connector *connector) 220 { 221 struct atana33xc20_panel *p = to_atana33xc20(panel); 222 struct dp_aux_ep_device *aux_ep = to_dp_aux_ep_dev(panel->dev); 223 int num = 0; 224 225 pm_runtime_get_sync(panel->dev); 226 227 if (!p->edid) 228 p->edid = drm_get_edid(connector, &aux_ep->aux->ddc); 229 num = drm_add_edid_modes(connector, p->edid); 230 231 pm_runtime_mark_last_busy(panel->dev); 232 pm_runtime_put_autosuspend(panel->dev); 233 234 return num; 235 } 236 237 static const struct drm_panel_funcs atana33xc20_funcs = { 238 .disable = atana33xc20_disable, 239 .enable = atana33xc20_enable, 240 .unprepare = atana33xc20_unprepare, 241 .prepare = atana33xc20_prepare, 242 .get_modes = atana33xc20_get_modes, 243 }; 244 245 static void atana33xc20_runtime_disable(void *data) 246 { 247 pm_runtime_disable(data); 248 } 249 250 static void atana33xc20_dont_use_autosuspend(void *data) 251 { 252 pm_runtime_dont_use_autosuspend(data); 253 } 254 255 static int atana33xc20_probe(struct dp_aux_ep_device *aux_ep) 256 { 257 struct atana33xc20_panel *panel; 258 struct device *dev = &aux_ep->dev; 259 int ret; 260 261 panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL); 262 if (!panel) 263 return -ENOMEM; 264 dev_set_drvdata(dev, panel); 265 266 panel->supply = devm_regulator_get(dev, "power"); 267 if (IS_ERR(panel->supply)) 268 return dev_err_probe(dev, PTR_ERR(panel->supply), 269 "Failed to get power supply\n"); 270 271 panel->el_on3_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW); 272 if (IS_ERR(panel->el_on3_gpio)) 273 return dev_err_probe(dev, PTR_ERR(panel->el_on3_gpio), 274 "Failed to get enable GPIO\n"); 275 276 panel->no_hpd = of_property_read_bool(dev->of_node, "no-hpd"); 277 if (!panel->no_hpd) { 278 panel->hpd_gpio = devm_gpiod_get_optional(dev, "hpd", GPIOD_IN); 279 if (IS_ERR(panel->hpd_gpio)) 280 return dev_err_probe(dev, PTR_ERR(panel->hpd_gpio), 281 "Failed to get HPD GPIO\n"); 282 } 283 284 pm_runtime_enable(dev); 285 ret = devm_add_action_or_reset(dev, atana33xc20_runtime_disable, dev); 286 if (ret) 287 return ret; 288 pm_runtime_set_autosuspend_delay(dev, 1000); 289 pm_runtime_use_autosuspend(dev); 290 ret = devm_add_action_or_reset(dev, atana33xc20_dont_use_autosuspend, dev); 291 if (ret) 292 return ret; 293 294 drm_panel_init(&panel->base, dev, &atana33xc20_funcs, DRM_MODE_CONNECTOR_eDP); 295 296 pm_runtime_get_sync(dev); 297 ret = drm_panel_dp_aux_backlight(&panel->base, aux_ep->aux); 298 pm_runtime_mark_last_busy(dev); 299 pm_runtime_put_autosuspend(dev); 300 if (ret) 301 return dev_err_probe(dev, ret, 302 "failed to register dp aux backlight\n"); 303 304 drm_panel_add(&panel->base); 305 306 return 0; 307 } 308 309 static void atana33xc20_remove(struct dp_aux_ep_device *aux_ep) 310 { 311 struct device *dev = &aux_ep->dev; 312 struct atana33xc20_panel *panel = dev_get_drvdata(dev); 313 314 drm_panel_remove(&panel->base); 315 drm_panel_disable(&panel->base); 316 drm_panel_unprepare(&panel->base); 317 318 kfree(panel->edid); 319 } 320 321 static void atana33xc20_shutdown(struct dp_aux_ep_device *aux_ep) 322 { 323 struct device *dev = &aux_ep->dev; 324 struct atana33xc20_panel *panel = dev_get_drvdata(dev); 325 326 drm_panel_disable(&panel->base); 327 drm_panel_unprepare(&panel->base); 328 } 329 330 static const struct of_device_id atana33xc20_dt_match[] = { 331 { .compatible = "samsung,atna33xc20", }, 332 { /* sentinal */ } 333 }; 334 MODULE_DEVICE_TABLE(of, atana33xc20_dt_match); 335 336 static const struct dev_pm_ops atana33xc20_pm_ops = { 337 SET_RUNTIME_PM_OPS(atana33xc20_suspend, atana33xc20_resume, NULL) 338 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 339 pm_runtime_force_resume) 340 }; 341 342 static struct dp_aux_ep_driver atana33xc20_driver = { 343 .driver = { 344 .name = "samsung_atana33xc20", 345 .of_match_table = atana33xc20_dt_match, 346 .pm = &atana33xc20_pm_ops, 347 }, 348 .probe = atana33xc20_probe, 349 .remove = atana33xc20_remove, 350 .shutdown = atana33xc20_shutdown, 351 }; 352 353 static int __init atana33xc20_init(void) 354 { 355 return dp_aux_dp_driver_register(&atana33xc20_driver); 356 } 357 module_init(atana33xc20_init); 358 359 static void __exit atana33xc20_exit(void) 360 { 361 dp_aux_dp_driver_unregister(&atana33xc20_driver); 362 } 363 module_exit(atana33xc20_exit); 364 365 MODULE_DESCRIPTION("Samsung ATANA33XC20 Panel Driver"); 366 MODULE_LICENSE("GPL v2"); 367