612 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * TPO TD043MTEA1 Panel driver4 *5 * Author: Gražvydas Ignotas <notasas@gmail.com>6 * Converted to new DSS device model: Tomi Valkeinen <tomi.valkeinen@ti.com>7 */8 9#include <linux/module.h>10#include <linux/delay.h>11#include <linux/spi/spi.h>12#include <linux/regulator/consumer.h>13#include <linux/gpio/consumer.h>14#include <linux/err.h>15#include <linux/slab.h>16 17#include <video/omapfb_dss.h>18 19#define TPO_R02_MODE(x) ((x) & 7)20#define TPO_R02_MODE_800x480 721#define TPO_R02_NCLK_RISING BIT(3)22#define TPO_R02_HSYNC_HIGH BIT(4)23#define TPO_R02_VSYNC_HIGH BIT(5)24 25#define TPO_R03_NSTANDBY BIT(0)26#define TPO_R03_EN_CP_CLK BIT(1)27#define TPO_R03_EN_VGL_PUMP BIT(2)28#define TPO_R03_EN_PWM BIT(3)29#define TPO_R03_DRIVING_CAP_100 BIT(4)30#define TPO_R03_EN_PRE_CHARGE BIT(6)31#define TPO_R03_SOFTWARE_CTL BIT(7)32 33#define TPO_R04_NFLIP_H BIT(0)34#define TPO_R04_NFLIP_V BIT(1)35#define TPO_R04_CP_CLK_FREQ_1H BIT(2)36#define TPO_R04_VGL_FREQ_1H BIT(4)37 38#define TPO_R03_VAL_NORMAL (TPO_R03_NSTANDBY | TPO_R03_EN_CP_CLK | \39 TPO_R03_EN_VGL_PUMP | TPO_R03_EN_PWM | \40 TPO_R03_DRIVING_CAP_100 | TPO_R03_EN_PRE_CHARGE | \41 TPO_R03_SOFTWARE_CTL)42 43#define TPO_R03_VAL_STANDBY (TPO_R03_DRIVING_CAP_100 | \44 TPO_R03_EN_PRE_CHARGE | TPO_R03_SOFTWARE_CTL)45 46static const u16 tpo_td043_def_gamma[12] = {47 105, 315, 381, 431, 490, 537, 579, 686, 780, 837, 880, 102348};49 50struct panel_drv_data {51 struct omap_dss_device dssdev;52 struct omap_dss_device *in;53 54 struct omap_video_timings videomode;55 56 int data_lines;57 58 struct spi_device *spi;59 struct regulator *vcc_reg;60 struct gpio_desc *reset_gpio;61 u16 gamma[12];62 u32 mode;63 u32 hmirror:1;64 u32 vmirror:1;65 u32 powered_on:1;66 u32 spi_suspended:1;67 u32 power_on_resume:1;68};69 70static const struct omap_video_timings tpo_td043_timings = {71 .x_res = 800,72 .y_res = 480,73 74 .pixelclock = 36000000,75 76 .hsw = 1,77 .hfp = 68,78 .hbp = 214,79 80 .vsw = 1,81 .vfp = 39,82 .vbp = 34,83 84 .vsync_level = OMAPDSS_SIG_ACTIVE_LOW,85 .hsync_level = OMAPDSS_SIG_ACTIVE_LOW,86 .data_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE,87 .de_level = OMAPDSS_SIG_ACTIVE_HIGH,88 .sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,89};90 91#define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)92 93static int tpo_td043_write(struct spi_device *spi, u8 addr, u8 data)94{95 struct spi_message m;96 struct spi_transfer xfer;97 u16 w;98 int r;99 100 spi_message_init(&m);101 102 memset(&xfer, 0, sizeof(xfer));103 104 w = ((u16)addr << 10) | (1 << 8) | data;105 xfer.tx_buf = &w;106 xfer.bits_per_word = 16;107 xfer.len = 2;108 spi_message_add_tail(&xfer, &m);109 110 r = spi_sync(spi, &m);111 if (r < 0)112 dev_warn(&spi->dev, "failed to write to LCD reg (%d)\n", r);113 return r;114}115 116static void tpo_td043_write_gamma(struct spi_device *spi, u16 gamma[12])117{118 u8 i, val;119 120 /* gamma bits [9:8] */121 for (val = i = 0; i < 4; i++)122 val |= (gamma[i] & 0x300) >> ((i + 1) * 2);123 tpo_td043_write(spi, 0x11, val);124 125 for (val = i = 0; i < 4; i++)126 val |= (gamma[i+4] & 0x300) >> ((i + 1) * 2);127 tpo_td043_write(spi, 0x12, val);128 129 for (val = i = 0; i < 4; i++)130 val |= (gamma[i+8] & 0x300) >> ((i + 1) * 2);131 tpo_td043_write(spi, 0x13, val);132 133 /* gamma bits [7:0] */134 for (val = i = 0; i < 12; i++)135 tpo_td043_write(spi, 0x14 + i, gamma[i] & 0xff);136}137 138static int tpo_td043_write_mirror(struct spi_device *spi, bool h, bool v)139{140 u8 reg4 = TPO_R04_NFLIP_H | TPO_R04_NFLIP_V |141 TPO_R04_CP_CLK_FREQ_1H | TPO_R04_VGL_FREQ_1H;142 if (h)143 reg4 &= ~TPO_R04_NFLIP_H;144 if (v)145 reg4 &= ~TPO_R04_NFLIP_V;146 147 return tpo_td043_write(spi, 4, reg4);148}149 150static int tpo_td043_set_hmirror(struct omap_dss_device *dssdev, bool enable)151{152 struct panel_drv_data *ddata = dev_get_drvdata(dssdev->dev);153 154 ddata->hmirror = enable;155 return tpo_td043_write_mirror(ddata->spi, ddata->hmirror,156 ddata->vmirror);157}158 159static bool tpo_td043_get_hmirror(struct omap_dss_device *dssdev)160{161 struct panel_drv_data *ddata = dev_get_drvdata(dssdev->dev);162 163 return ddata->hmirror;164}165 166static ssize_t tpo_td043_vmirror_show(struct device *dev,167 struct device_attribute *attr, char *buf)168{169 struct panel_drv_data *ddata = dev_get_drvdata(dev);170 171 return sysfs_emit(buf, "%d\n", ddata->vmirror);172}173 174static ssize_t tpo_td043_vmirror_store(struct device *dev,175 struct device_attribute *attr, const char *buf, size_t count)176{177 struct panel_drv_data *ddata = dev_get_drvdata(dev);178 int val;179 int ret;180 181 ret = kstrtoint(buf, 0, &val);182 if (ret < 0)183 return ret;184 185 val = !!val;186 187 ret = tpo_td043_write_mirror(ddata->spi, ddata->hmirror, val);188 if (ret < 0)189 return ret;190 191 ddata->vmirror = val;192 193 return count;194}195 196static ssize_t tpo_td043_mode_show(struct device *dev,197 struct device_attribute *attr, char *buf)198{199 struct panel_drv_data *ddata = dev_get_drvdata(dev);200 201 return sysfs_emit(buf, "%d\n", ddata->mode);202}203 204static ssize_t tpo_td043_mode_store(struct device *dev,205 struct device_attribute *attr, const char *buf, size_t count)206{207 struct panel_drv_data *ddata = dev_get_drvdata(dev);208 long val;209 int ret;210 211 ret = kstrtol(buf, 0, &val);212 if (ret != 0 || val & ~7)213 return -EINVAL;214 215 ddata->mode = val;216 217 val |= TPO_R02_NCLK_RISING;218 tpo_td043_write(ddata->spi, 2, val);219 220 return count;221}222 223static ssize_t tpo_td043_gamma_show(struct device *dev,224 struct device_attribute *attr, char *buf)225{226 struct panel_drv_data *ddata = dev_get_drvdata(dev);227 ssize_t len = 0;228 int i;229 230 for (i = 0; i < ARRAY_SIZE(ddata->gamma); i++)231 len += sysfs_emit_at(buf, len, "%u ", ddata->gamma[i]);232 if (len)233 buf[len - 1] = '\n';234 235 return len;236}237 238static ssize_t tpo_td043_gamma_store(struct device *dev,239 struct device_attribute *attr, const char *buf, size_t count)240{241 struct panel_drv_data *ddata = dev_get_drvdata(dev);242 unsigned int g[12];243 int ret;244 int i;245 246 ret = sscanf(buf, "%u %u %u %u %u %u %u %u %u %u %u %u",247 &g[0], &g[1], &g[2], &g[3], &g[4], &g[5],248 &g[6], &g[7], &g[8], &g[9], &g[10], &g[11]);249 250 if (ret != 12)251 return -EINVAL;252 253 for (i = 0; i < 12; i++)254 ddata->gamma[i] = g[i];255 256 tpo_td043_write_gamma(ddata->spi, ddata->gamma);257 258 return count;259}260 261static DEVICE_ATTR(vmirror, S_IRUGO | S_IWUSR,262 tpo_td043_vmirror_show, tpo_td043_vmirror_store);263static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,264 tpo_td043_mode_show, tpo_td043_mode_store);265static DEVICE_ATTR(gamma, S_IRUGO | S_IWUSR,266 tpo_td043_gamma_show, tpo_td043_gamma_store);267 268static struct attribute *tpo_td043_attrs[] = {269 &dev_attr_vmirror.attr,270 &dev_attr_mode.attr,271 &dev_attr_gamma.attr,272 NULL,273};274 275static const struct attribute_group tpo_td043_attr_group = {276 .attrs = tpo_td043_attrs,277};278 279static int tpo_td043_power_on(struct panel_drv_data *ddata)280{281 int r;282 283 if (ddata->powered_on)284 return 0;285 286 r = regulator_enable(ddata->vcc_reg);287 if (r != 0)288 return r;289 290 /* wait for panel to stabilize */291 msleep(160);292 293 gpiod_set_value_cansleep(ddata->reset_gpio, 0);294 295 tpo_td043_write(ddata->spi, 2,296 TPO_R02_MODE(ddata->mode) | TPO_R02_NCLK_RISING);297 tpo_td043_write(ddata->spi, 3, TPO_R03_VAL_NORMAL);298 tpo_td043_write(ddata->spi, 0x20, 0xf0);299 tpo_td043_write(ddata->spi, 0x21, 0xf0);300 tpo_td043_write_mirror(ddata->spi, ddata->hmirror,301 ddata->vmirror);302 tpo_td043_write_gamma(ddata->spi, ddata->gamma);303 304 ddata->powered_on = 1;305 return 0;306}307 308static void tpo_td043_power_off(struct panel_drv_data *ddata)309{310 if (!ddata->powered_on)311 return;312 313 tpo_td043_write(ddata->spi, 3,314 TPO_R03_VAL_STANDBY | TPO_R03_EN_PWM);315 316 gpiod_set_value_cansleep(ddata->reset_gpio, 1);317 318 /* wait for at least 2 vsyncs before cutting off power */319 msleep(50);320 321 tpo_td043_write(ddata->spi, 3, TPO_R03_VAL_STANDBY);322 323 regulator_disable(ddata->vcc_reg);324 325 ddata->powered_on = 0;326}327 328static int tpo_td043_connect(struct omap_dss_device *dssdev)329{330 struct panel_drv_data *ddata = to_panel_data(dssdev);331 struct omap_dss_device *in = ddata->in;332 333 if (omapdss_device_is_connected(dssdev))334 return 0;335 336 return in->ops.dpi->connect(in, dssdev);337}338 339static void tpo_td043_disconnect(struct omap_dss_device *dssdev)340{341 struct panel_drv_data *ddata = to_panel_data(dssdev);342 struct omap_dss_device *in = ddata->in;343 344 if (!omapdss_device_is_connected(dssdev))345 return;346 347 in->ops.dpi->disconnect(in, dssdev);348}349 350static int tpo_td043_enable(struct omap_dss_device *dssdev)351{352 struct panel_drv_data *ddata = to_panel_data(dssdev);353 struct omap_dss_device *in = ddata->in;354 int r;355 356 if (!omapdss_device_is_connected(dssdev))357 return -ENODEV;358 359 if (omapdss_device_is_enabled(dssdev))360 return 0;361 362 if (ddata->data_lines)363 in->ops.dpi->set_data_lines(in, ddata->data_lines);364 in->ops.dpi->set_timings(in, &ddata->videomode);365 366 r = in->ops.dpi->enable(in);367 if (r)368 return r;369 370 /*371 * If we are resuming from system suspend, SPI clocks might not be372 * enabled yet, so we'll program the LCD from SPI PM resume callback.373 */374 if (!ddata->spi_suspended) {375 r = tpo_td043_power_on(ddata);376 if (r) {377 in->ops.dpi->disable(in);378 return r;379 }380 }381 382 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;383 384 return 0;385}386 387static void tpo_td043_disable(struct omap_dss_device *dssdev)388{389 struct panel_drv_data *ddata = to_panel_data(dssdev);390 struct omap_dss_device *in = ddata->in;391 392 if (!omapdss_device_is_enabled(dssdev))393 return;394 395 in->ops.dpi->disable(in);396 397 if (!ddata->spi_suspended)398 tpo_td043_power_off(ddata);399 400 dssdev->state = OMAP_DSS_DISPLAY_DISABLED;401}402 403static void tpo_td043_set_timings(struct omap_dss_device *dssdev,404 struct omap_video_timings *timings)405{406 struct panel_drv_data *ddata = to_panel_data(dssdev);407 struct omap_dss_device *in = ddata->in;408 409 ddata->videomode = *timings;410 dssdev->panel.timings = *timings;411 412 in->ops.dpi->set_timings(in, timings);413}414 415static void tpo_td043_get_timings(struct omap_dss_device *dssdev,416 struct omap_video_timings *timings)417{418 struct panel_drv_data *ddata = to_panel_data(dssdev);419 420 *timings = ddata->videomode;421}422 423static int tpo_td043_check_timings(struct omap_dss_device *dssdev,424 struct omap_video_timings *timings)425{426 struct panel_drv_data *ddata = to_panel_data(dssdev);427 struct omap_dss_device *in = ddata->in;428 429 return in->ops.dpi->check_timings(in, timings);430}431 432static struct omap_dss_driver tpo_td043_ops = {433 .connect = tpo_td043_connect,434 .disconnect = tpo_td043_disconnect,435 436 .enable = tpo_td043_enable,437 .disable = tpo_td043_disable,438 439 .set_timings = tpo_td043_set_timings,440 .get_timings = tpo_td043_get_timings,441 .check_timings = tpo_td043_check_timings,442 443 .set_mirror = tpo_td043_set_hmirror,444 .get_mirror = tpo_td043_get_hmirror,445 446 .get_resolution = omapdss_default_get_resolution,447};448 449static int tpo_td043_probe(struct spi_device *spi)450{451 struct panel_drv_data *ddata;452 struct omap_dss_device *dssdev;453 int r;454 455 dev_dbg(&spi->dev, "%s\n", __func__);456 457 if (!spi->dev.of_node)458 return -ENODEV;459 460 spi->bits_per_word = 16;461 spi->mode = SPI_MODE_0;462 463 r = spi_setup(spi);464 if (r < 0) {465 dev_err(&spi->dev, "spi_setup failed: %d\n", r);466 return r;467 }468 469 ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL);470 if (ddata == NULL)471 return -ENOMEM;472 473 dev_set_drvdata(&spi->dev, ddata);474 475 ddata->spi = spi;476 477 ddata->in = omapdss_of_find_source_for_first_ep(spi->dev.of_node);478 r = PTR_ERR_OR_ZERO(ddata->in);479 if (r) {480 dev_err(&spi->dev, "failed to find video source: %d\n", r);481 return r;482 }483 484 ddata->mode = TPO_R02_MODE_800x480;485 memcpy(ddata->gamma, tpo_td043_def_gamma, sizeof(ddata->gamma));486 487 ddata->vcc_reg = devm_regulator_get(&spi->dev, "vcc");488 if (IS_ERR(ddata->vcc_reg)) {489 r = dev_err_probe(&spi->dev, PTR_ERR(ddata->vcc_reg),490 "failed to get LCD VCC regulator\n");491 goto err_regulator;492 }493 494 ddata->reset_gpio = devm_gpiod_get(&spi->dev, "reset", GPIOD_OUT_HIGH);495 r = PTR_ERR_OR_ZERO(ddata->reset_gpio);496 if (r) {497 dev_err(&spi->dev, "couldn't request reset GPIO\n");498 goto err_gpio_req;499 }500 501 gpiod_set_consumer_name(ddata->reset_gpio, "lcd reset");502 503 r = sysfs_create_group(&spi->dev.kobj, &tpo_td043_attr_group);504 if (r) {505 dev_err(&spi->dev, "failed to create sysfs files\n");506 goto err_sysfs;507 }508 509 ddata->videomode = tpo_td043_timings;510 511 dssdev = &ddata->dssdev;512 dssdev->dev = &spi->dev;513 dssdev->driver = &tpo_td043_ops;514 dssdev->type = OMAP_DISPLAY_TYPE_DPI;515 dssdev->owner = THIS_MODULE;516 dssdev->panel.timings = ddata->videomode;517 518 r = omapdss_register_display(dssdev);519 if (r) {520 dev_err(&spi->dev, "Failed to register panel\n");521 goto err_reg;522 }523 524 return 0;525 526err_reg:527 sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group);528err_sysfs:529err_gpio_req:530err_regulator:531 omap_dss_put_device(ddata->in);532 return r;533}534 535static void tpo_td043_remove(struct spi_device *spi)536{537 struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);538 struct omap_dss_device *dssdev = &ddata->dssdev;539 struct omap_dss_device *in = ddata->in;540 541 dev_dbg(&ddata->spi->dev, "%s\n", __func__);542 543 omapdss_unregister_display(dssdev);544 545 tpo_td043_disable(dssdev);546 tpo_td043_disconnect(dssdev);547 548 omap_dss_put_device(in);549 550 sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group);551}552 553#ifdef CONFIG_PM_SLEEP554static int tpo_td043_spi_suspend(struct device *dev)555{556 struct panel_drv_data *ddata = dev_get_drvdata(dev);557 558 dev_dbg(dev, "tpo_td043_spi_suspend, tpo %p\n", ddata);559 560 ddata->power_on_resume = ddata->powered_on;561 tpo_td043_power_off(ddata);562 ddata->spi_suspended = 1;563 564 return 0;565}566 567static int tpo_td043_spi_resume(struct device *dev)568{569 struct panel_drv_data *ddata = dev_get_drvdata(dev);570 int ret;571 572 dev_dbg(dev, "tpo_td043_spi_resume\n");573 574 if (ddata->power_on_resume) {575 ret = tpo_td043_power_on(ddata);576 if (ret)577 return ret;578 }579 ddata->spi_suspended = 0;580 581 return 0;582}583#endif584 585static SIMPLE_DEV_PM_OPS(tpo_td043_spi_pm,586 tpo_td043_spi_suspend, tpo_td043_spi_resume);587 588static const struct of_device_id tpo_td043_of_match[] = {589 { .compatible = "omapdss,tpo,td043mtea1", },590 {},591};592 593MODULE_DEVICE_TABLE(of, tpo_td043_of_match);594 595static struct spi_driver tpo_td043_spi_driver = {596 .driver = {597 .name = "panel-tpo-td043mtea1",598 .pm = &tpo_td043_spi_pm,599 .of_match_table = tpo_td043_of_match,600 .suppress_bind_attrs = true,601 },602 .probe = tpo_td043_probe,603 .remove = tpo_td043_remove,604};605 606module_spi_driver(tpo_td043_spi_driver);607 608MODULE_ALIAS("spi:tpo,td043mtea1");609MODULE_AUTHOR("Gražvydas Ignotas <notasas@gmail.com>");610MODULE_DESCRIPTION("TPO TD043MTEA1 LCD Driver");611MODULE_LICENSE("GPL");612