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