cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

panel-sharp-ls037v7dw01.c (5973B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Sharp LS037V7DW01 LCD Panel Driver
      4 *
      5 * Copyright (C) 2019 Texas Instruments Incorporated
      6 *
      7 * Based on the omapdrm-specific panel-sharp-ls037v7dw01 driver
      8 *
      9 * Copyright (C) 2013 Texas Instruments Incorporated
     10 * Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
     11 */
     12
     13#include <linux/delay.h>
     14#include <linux/gpio/consumer.h>
     15#include <linux/module.h>
     16#include <linux/of.h>
     17#include <linux/platform_device.h>
     18#include <linux/regulator/consumer.h>
     19
     20#include <drm/drm_connector.h>
     21#include <drm/drm_modes.h>
     22#include <drm/drm_panel.h>
     23
     24struct ls037v7dw01_panel {
     25	struct drm_panel panel;
     26	struct platform_device *pdev;
     27
     28	struct regulator *vdd;
     29	struct gpio_desc *resb_gpio;	/* low = reset active min 20 us */
     30	struct gpio_desc *ini_gpio;	/* high = power on */
     31	struct gpio_desc *mo_gpio;	/* low = 480x640, high = 240x320 */
     32	struct gpio_desc *lr_gpio;	/* high = conventional horizontal scanning */
     33	struct gpio_desc *ud_gpio;	/* high = conventional vertical scanning */
     34};
     35
     36#define to_ls037v7dw01_device(p) \
     37	container_of(p, struct ls037v7dw01_panel, panel)
     38
     39static int ls037v7dw01_disable(struct drm_panel *panel)
     40{
     41	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
     42
     43	gpiod_set_value_cansleep(lcd->ini_gpio, 0);
     44	gpiod_set_value_cansleep(lcd->resb_gpio, 0);
     45
     46	/* Wait at least 5 vsyncs after disabling the LCD. */
     47	msleep(100);
     48
     49	return 0;
     50}
     51
     52static int ls037v7dw01_unprepare(struct drm_panel *panel)
     53{
     54	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
     55
     56	regulator_disable(lcd->vdd);
     57	return 0;
     58}
     59
     60static int ls037v7dw01_prepare(struct drm_panel *panel)
     61{
     62	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
     63	int ret;
     64
     65	ret = regulator_enable(lcd->vdd);
     66	if (ret < 0)
     67		dev_err(&lcd->pdev->dev, "%s: failed to enable regulator\n",
     68			__func__);
     69
     70	return ret;
     71}
     72
     73static int ls037v7dw01_enable(struct drm_panel *panel)
     74{
     75	struct ls037v7dw01_panel *lcd = to_ls037v7dw01_device(panel);
     76
     77	/* Wait couple of vsyncs before enabling the LCD. */
     78	msleep(50);
     79
     80	gpiod_set_value_cansleep(lcd->resb_gpio, 1);
     81	gpiod_set_value_cansleep(lcd->ini_gpio, 1);
     82
     83	return 0;
     84}
     85
     86static const struct drm_display_mode ls037v7dw01_mode = {
     87	.clock = 19200,
     88	.hdisplay = 480,
     89	.hsync_start = 480 + 1,
     90	.hsync_end = 480 + 1 + 2,
     91	.htotal = 480 + 1 + 2 + 28,
     92	.vdisplay = 640,
     93	.vsync_start = 640 + 1,
     94	.vsync_end = 640 + 1 + 1,
     95	.vtotal = 640 + 1 + 1 + 1,
     96	.type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
     97	.flags = DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC,
     98	.width_mm = 56,
     99	.height_mm = 75,
    100};
    101
    102static int ls037v7dw01_get_modes(struct drm_panel *panel,
    103				 struct drm_connector *connector)
    104{
    105	struct drm_display_mode *mode;
    106
    107	mode = drm_mode_duplicate(connector->dev, &ls037v7dw01_mode);
    108	if (!mode)
    109		return -ENOMEM;
    110
    111	drm_mode_set_name(mode);
    112	drm_mode_probed_add(connector, mode);
    113
    114	connector->display_info.width_mm = ls037v7dw01_mode.width_mm;
    115	connector->display_info.height_mm = ls037v7dw01_mode.height_mm;
    116	/*
    117	 * FIXME: According to the datasheet pixel data is sampled on the
    118	 * rising edge of the clock, but the code running on the SDP3430
    119	 * indicates sampling on the negative edge. This should be tested on a
    120	 * real device.
    121	 */
    122	connector->display_info.bus_flags = DRM_BUS_FLAG_DE_HIGH
    123					  | DRM_BUS_FLAG_SYNC_SAMPLE_POSEDGE
    124					  | DRM_BUS_FLAG_PIXDATA_SAMPLE_NEGEDGE;
    125
    126	return 1;
    127}
    128
    129static const struct drm_panel_funcs ls037v7dw01_funcs = {
    130	.disable = ls037v7dw01_disable,
    131	.unprepare = ls037v7dw01_unprepare,
    132	.prepare = ls037v7dw01_prepare,
    133	.enable = ls037v7dw01_enable,
    134	.get_modes = ls037v7dw01_get_modes,
    135};
    136
    137static int ls037v7dw01_probe(struct platform_device *pdev)
    138{
    139	struct ls037v7dw01_panel *lcd;
    140
    141	lcd = devm_kzalloc(&pdev->dev, sizeof(*lcd), GFP_KERNEL);
    142	if (!lcd)
    143		return -ENOMEM;
    144
    145	platform_set_drvdata(pdev, lcd);
    146	lcd->pdev = pdev;
    147
    148	lcd->vdd = devm_regulator_get(&pdev->dev, "envdd");
    149	if (IS_ERR(lcd->vdd))
    150		return dev_err_probe(&pdev->dev, PTR_ERR(lcd->vdd),
    151				     "failed to get regulator\n");
    152
    153	lcd->ini_gpio = devm_gpiod_get(&pdev->dev, "enable", GPIOD_OUT_LOW);
    154	if (IS_ERR(lcd->ini_gpio))
    155		return dev_err_probe(&pdev->dev, PTR_ERR(lcd->ini_gpio),
    156				     "failed to get enable gpio\n");
    157
    158	lcd->resb_gpio = devm_gpiod_get(&pdev->dev, "reset", GPIOD_OUT_LOW);
    159	if (IS_ERR(lcd->resb_gpio))
    160		return dev_err_probe(&pdev->dev, PTR_ERR(lcd->resb_gpio),
    161				     "failed to get reset gpio\n");
    162
    163	lcd->mo_gpio = devm_gpiod_get_index(&pdev->dev, "mode", 0,
    164					    GPIOD_OUT_LOW);
    165	if (IS_ERR(lcd->mo_gpio)) {
    166		dev_err(&pdev->dev, "failed to get mode[0] gpio\n");
    167		return PTR_ERR(lcd->mo_gpio);
    168	}
    169
    170	lcd->lr_gpio = devm_gpiod_get_index(&pdev->dev, "mode", 1,
    171					    GPIOD_OUT_LOW);
    172	if (IS_ERR(lcd->lr_gpio)) {
    173		dev_err(&pdev->dev, "failed to get mode[1] gpio\n");
    174		return PTR_ERR(lcd->lr_gpio);
    175	}
    176
    177	lcd->ud_gpio = devm_gpiod_get_index(&pdev->dev, "mode", 2,
    178					    GPIOD_OUT_LOW);
    179	if (IS_ERR(lcd->ud_gpio)) {
    180		dev_err(&pdev->dev, "failed to get mode[2] gpio\n");
    181		return PTR_ERR(lcd->ud_gpio);
    182	}
    183
    184	drm_panel_init(&lcd->panel, &pdev->dev, &ls037v7dw01_funcs,
    185		       DRM_MODE_CONNECTOR_DPI);
    186
    187	drm_panel_add(&lcd->panel);
    188
    189	return 0;
    190}
    191
    192static int ls037v7dw01_remove(struct platform_device *pdev)
    193{
    194	struct ls037v7dw01_panel *lcd = platform_get_drvdata(pdev);
    195
    196	drm_panel_remove(&lcd->panel);
    197	drm_panel_disable(&lcd->panel);
    198	drm_panel_unprepare(&lcd->panel);
    199
    200	return 0;
    201}
    202
    203static const struct of_device_id ls037v7dw01_of_match[] = {
    204	{ .compatible = "sharp,ls037v7dw01", },
    205	{ /* sentinel */ },
    206};
    207
    208MODULE_DEVICE_TABLE(of, ls037v7dw01_of_match);
    209
    210static struct platform_driver ls037v7dw01_driver = {
    211	.probe		= ls037v7dw01_probe,
    212	.remove		= ls037v7dw01_remove,
    213	.driver		= {
    214		.name = "panel-sharp-ls037v7dw01",
    215		.of_match_table = ls037v7dw01_of_match,
    216	},
    217};
    218
    219module_platform_driver(ls037v7dw01_driver);
    220
    221MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
    222MODULE_DESCRIPTION("Sharp LS037V7DW01 Panel Driver");
    223MODULE_LICENSE("GPL");