drm/omap: displays: Remove unused panel drivers (45f16c82) · Commits · 戴 / test

drivers/gpu/drm/omapdrm/displays/Kconfig

+0 −38

Original line number	Diff line number	Diff line
		@@ -29,42 +29,4 @@ config DRM_OMAP_PANEL_DSI_CM
		help
		Driver for generic DSI command mode panels.

		config DRM_OMAP_PANEL_SONY_ACX565AKM
		tristate "ACX565AKM Panel"
		depends on SPI && BACKLIGHT_CLASS_DEVICE
		help
		This is the LCD panel used on Nokia N900

		config DRM_OMAP_PANEL_LGPHILIPS_LB035Q02
		tristate "LG.Philips LB035Q02 LCD Panel"
		depends on SPI
		help
		LCD Panel used on the Gumstix Overo Palo35

		config DRM_OMAP_PANEL_SHARP_LS037V7DW01
		tristate "Sharp LS037V7DW01 LCD Panel"
		depends on BACKLIGHT_CLASS_DEVICE
		help
		LCD Panel used in TI's SDP3430 and EVM boards

		config DRM_OMAP_PANEL_TPO_TD028TTEC1
		tristate "TPO TD028TTEC1 LCD Panel"
		depends on SPI
		help
		LCD panel used in Openmoko.

		config DRM_OMAP_PANEL_TPO_TD043MTEA1
		tristate "TPO TD043MTEA1 LCD Panel"
		depends on SPI
		help
		LCD Panel used in OMAP3 Pandora

		config DRM_OMAP_PANEL_NEC_NL8048HL11
		tristate "NEC NL8048HL11 Panel"
		depends on SPI
		depends on BACKLIGHT_CLASS_DEVICE
		help
		This NEC NL8048HL11 panel is TFT LCD used in the
		Zoom2/3/3630 sdp boards.

		endmenu

drivers/gpu/drm/omapdrm/displays/Makefile

+0 −6

Original line number	Diff line number	Diff line
		@@ -4,9 +4,3 @@ obj-$(CONFIG_DRM_OMAP_ENCODER_TPD12S015) += encoder-tpd12s015.o
		obj-$(CONFIG_DRM_OMAP_CONNECTOR_HDMI) += connector-hdmi.o
		obj-$(CONFIG_DRM_OMAP_CONNECTOR_ANALOG_TV) += connector-analog-tv.o
		obj-$(CONFIG_DRM_OMAP_PANEL_DSI_CM) += panel-dsi-cm.o
		obj-$(CONFIG_DRM_OMAP_PANEL_SONY_ACX565AKM) += panel-sony-acx565akm.o
		obj-$(CONFIG_DRM_OMAP_PANEL_LGPHILIPS_LB035Q02) += panel-lgphilips-lb035q02.o
		obj-$(CONFIG_DRM_OMAP_PANEL_SHARP_LS037V7DW01) += panel-sharp-ls037v7dw01.o
		obj-$(CONFIG_DRM_OMAP_PANEL_TPO_TD028TTEC1) += panel-tpo-td028ttec1.o
		obj-$(CONFIG_DRM_OMAP_PANEL_TPO_TD043MTEA1) += panel-tpo-td043mtea1.o
		obj-$(CONFIG_DRM_OMAP_PANEL_NEC_NL8048HL11) += panel-nec-nl8048hl11.o

drivers/gpu/drm/omapdrm/displays/panel-lgphilips-lb035q02.c

deleted100644 → 0

+0 −251

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* LG.Philips LB035Q02 LCD Panel driver
		*
		* Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
		* Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
		* Based on a driver by: Steve Sakoman <steve@sakoman.com>
		*/

		#include <linux/module.h>
		#include <linux/delay.h>
		#include <linux/spi/spi.h>
		#include <linux/mutex.h>
		#include <linux/gpio.h>
		#include <linux/gpio/consumer.h>

		#include "../dss/omapdss.h"

		static const struct videomode lb035q02_vm = {
		.hactive = 320,
		.vactive = 240,

		.pixelclock = 6500000,

		.hsync_len = 2,
		.hfront_porch = 20,
		.hback_porch = 68,

		.vsync_len = 2,
		.vfront_porch = 4,
		.vback_porch = 18,

		.flags = DISPLAY_FLAGS_HSYNC_LOW \| DISPLAY_FLAGS_VSYNC_LOW,
		};

		struct panel_drv_data {
		struct omap_dss_device dssdev;

		struct spi_device *spi;

		struct videomode vm;

		struct gpio_desc *enable_gpio;
		};

		#define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)

		static int lb035q02_write_reg(struct spi_device *spi, u8 reg, u16 val)
		{
		struct spi_message msg;
		struct spi_transfer index_xfer = {
		.len = 3,
		.cs_change = 1,
		};
		struct spi_transfer value_xfer = {
		.len = 3,
		};
		u8 buffer[16];

		spi_message_init(&msg);

		/* register index */
		buffer[0] = 0x70;
		buffer[1] = 0x00;
		buffer[2] = reg & 0x7f;
		index_xfer.tx_buf = buffer;
		spi_message_add_tail(&index_xfer, &msg);

		/* register value */
		buffer[4] = 0x72;
		buffer[5] = val >> 8;
		buffer[6] = val;
		value_xfer.tx_buf = buffer + 4;
		spi_message_add_tail(&value_xfer, &msg);

		return spi_sync(spi, &msg);
		}

		static void init_lb035q02_panel(struct spi_device *spi)
		{
		/* Init sequence from page 28 of the lb035q02 spec */
		lb035q02_write_reg(spi, 0x01, 0x6300);
		lb035q02_write_reg(spi, 0x02, 0x0200);
		lb035q02_write_reg(spi, 0x03, 0x0177);
		lb035q02_write_reg(spi, 0x04, 0x04c7);
		lb035q02_write_reg(spi, 0x05, 0xffc0);
		lb035q02_write_reg(spi, 0x06, 0xe806);
		lb035q02_write_reg(spi, 0x0a, 0x4008);
		lb035q02_write_reg(spi, 0x0b, 0x0000);
		lb035q02_write_reg(spi, 0x0d, 0x0030);
		lb035q02_write_reg(spi, 0x0e, 0x2800);
		lb035q02_write_reg(spi, 0x0f, 0x0000);
		lb035q02_write_reg(spi, 0x16, 0x9f80);
		lb035q02_write_reg(spi, 0x17, 0x0a0f);
		lb035q02_write_reg(spi, 0x1e, 0x00c1);
		lb035q02_write_reg(spi, 0x30, 0x0300);
		lb035q02_write_reg(spi, 0x31, 0x0007);
		lb035q02_write_reg(spi, 0x32, 0x0000);
		lb035q02_write_reg(spi, 0x33, 0x0000);
		lb035q02_write_reg(spi, 0x34, 0x0707);
		lb035q02_write_reg(spi, 0x35, 0x0004);
		lb035q02_write_reg(spi, 0x36, 0x0302);
		lb035q02_write_reg(spi, 0x37, 0x0202);
		lb035q02_write_reg(spi, 0x3a, 0x0a0d);
		lb035q02_write_reg(spi, 0x3b, 0x0806);
		}

		static int lb035q02_connect(struct omap_dss_device *src,
		struct omap_dss_device *dst)
		{
		struct panel_drv_data *ddata = to_panel_data(dst);

		init_lb035q02_panel(ddata->spi);

		return 0;
		}

		static void lb035q02_disconnect(struct omap_dss_device *src,
		struct omap_dss_device *dst)
		{
		}

		static void lb035q02_enable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		if (ddata->enable_gpio)
		gpiod_set_value_cansleep(ddata->enable_gpio, 1);
		}

		static void lb035q02_disable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		if (ddata->enable_gpio)
		gpiod_set_value_cansleep(ddata->enable_gpio, 0);
		}

		static int lb035q02_get_modes(struct omap_dss_device *dssdev,
		struct drm_connector *connector)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		return omapdss_display_get_modes(connector, &ddata->vm);
		}

		static const struct omap_dss_device_ops lb035q02_ops = {
		.connect = lb035q02_connect,
		.disconnect = lb035q02_disconnect,

		.enable = lb035q02_enable,
		.disable = lb035q02_disable,

		.get_modes = lb035q02_get_modes,
		};

		static int lb035q02_probe_of(struct spi_device *spi)
		{
		struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
		struct gpio_desc *gpio;

		gpio = devm_gpiod_get(&spi->dev, "enable", GPIOD_OUT_LOW);
		if (IS_ERR(gpio)) {
		dev_err(&spi->dev, "failed to parse enable gpio\n");
		return PTR_ERR(gpio);
		}

		ddata->enable_gpio = gpio;

		return 0;
		}

		static int lb035q02_panel_spi_probe(struct spi_device *spi)
		{
		struct panel_drv_data *ddata;
		struct omap_dss_device *dssdev;
		int r;

		ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL);
		if (ddata == NULL)
		return -ENOMEM;

		dev_set_drvdata(&spi->dev, ddata);

		ddata->spi = spi;

		r = lb035q02_probe_of(spi);
		if (r)
		return r;

		ddata->vm = lb035q02_vm;

		dssdev = &ddata->dssdev;
		dssdev->dev = &spi->dev;
		dssdev->ops = &lb035q02_ops;
		dssdev->type = OMAP_DISPLAY_TYPE_DPI;
		dssdev->display = true;
		dssdev->owner = THIS_MODULE;
		dssdev->of_ports = BIT(0);
		dssdev->ops_flags = OMAP_DSS_DEVICE_OP_MODES;

		/*
		* Note: According to the panel documentation:
		* DE is active LOW
		* DATA needs to be driven on the FALLING edge
		*/
		dssdev->bus_flags = DRM_BUS_FLAG_DE_HIGH
		\| DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE
		\| DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE;

		omapdss_display_init(dssdev);
		omapdss_device_register(dssdev);

		return 0;
		}

		static int lb035q02_panel_spi_remove(struct spi_device *spi)
		{
		struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
		struct omap_dss_device *dssdev = &ddata->dssdev;

		omapdss_device_unregister(dssdev);

		lb035q02_disable(dssdev);

		return 0;
		}

		static const struct of_device_id lb035q02_of_match[] = {
		{ .compatible = "omapdss,lgphilips,lb035q02", },
		{},
		};

		MODULE_DEVICE_TABLE(of, lb035q02_of_match);

		static struct spi_driver lb035q02_spi_driver = {
		.probe = lb035q02_panel_spi_probe,
		.remove = lb035q02_panel_spi_remove,
		.driver = {
		.name = "panel_lgphilips_lb035q02",
		.of_match_table = lb035q02_of_match,
		.suppress_bind_attrs = true,
		},
		};

		module_spi_driver(lb035q02_spi_driver);

		MODULE_ALIAS("spi:lgphilips,lb035q02");
		MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
		MODULE_DESCRIPTION("LG.Philips LB035Q02 LCD Panel driver");
		MODULE_LICENSE("GPL");

drivers/gpu/drm/omapdrm/displays/panel-nec-nl8048hl11.c

deleted100644 → 0

+0 −271

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/*
		* NEC NL8048HL11 Panel driver
		*
		* Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com/
		* Author: Erik Gilling <konkers@android.com>
		* Converted to new DSS device model: Tomi Valkeinen <tomi.valkeinen@ti.com>
		*/

		#include <linux/delay.h>
		#include <linux/gpio/consumer.h>
		#include <linux/module.h>
		#include <linux/spi/spi.h>

		#include "../dss/omapdss.h"

		struct panel_drv_data {
		struct omap_dss_device dssdev;

		struct videomode vm;

		struct gpio_desc *res_gpio;

		struct spi_device *spi;
		};

		#define LCD_XRES 800
		#define LCD_YRES 480
		/*
		* NEC PIX Clock Ratings
		* MIN:21.8MHz TYP:23.8MHz MAX:25.7MHz
		*/
		#define LCD_PIXEL_CLOCK 23800000

		static const struct {
		unsigned char addr;
		unsigned char dat;
		} nec_8048_init_seq[] = {
		{ 3, 0x01 }, { 0, 0x00 }, { 1, 0x01 }, { 4, 0x00 }, { 5, 0x14 },
		{ 6, 0x24 }, { 16, 0xD7 }, { 17, 0x00 }, { 18, 0x00 }, { 19, 0x55 },
		{ 20, 0x01 }, { 21, 0x70 }, { 22, 0x1E }, { 23, 0x25 }, { 24, 0x25 },
		{ 25, 0x02 }, { 26, 0x02 }, { 27, 0xA0 }, { 32, 0x2F }, { 33, 0x0F },
		{ 34, 0x0F }, { 35, 0x0F }, { 36, 0x0F }, { 37, 0x0F }, { 38, 0x0F },
		{ 39, 0x00 }, { 40, 0x02 }, { 41, 0x02 }, { 42, 0x02 }, { 43, 0x0F },
		{ 44, 0x0F }, { 45, 0x0F }, { 46, 0x0F }, { 47, 0x0F }, { 48, 0x0F },
		{ 49, 0x0F }, { 50, 0x00 }, { 51, 0x02 }, { 52, 0x02 }, { 53, 0x02 },
		{ 80, 0x0C }, { 83, 0x42 }, { 84, 0x42 }, { 85, 0x41 }, { 86, 0x14 },
		{ 89, 0x88 }, { 90, 0x01 }, { 91, 0x00 }, { 92, 0x02 }, { 93, 0x0C },
		{ 94, 0x1C }, { 95, 0x27 }, { 98, 0x49 }, { 99, 0x27 }, { 102, 0x76 },
		{ 103, 0x27 }, { 112, 0x01 }, { 113, 0x0E }, { 114, 0x02 },
		{ 115, 0x0C }, { 118, 0x0C }, { 121, 0x30 }, { 130, 0x00 },
		{ 131, 0x00 }, { 132, 0xFC }, { 134, 0x00 }, { 136, 0x00 },
		{ 138, 0x00 }, { 139, 0x00 }, { 140, 0x00 }, { 141, 0xFC },
		{ 143, 0x00 }, { 145, 0x00 }, { 147, 0x00 }, { 148, 0x00 },
		{ 149, 0x00 }, { 150, 0xFC }, { 152, 0x00 }, { 154, 0x00 },
		{ 156, 0x00 }, { 157, 0x00 }, { 2, 0x00 },
		};

		static const struct videomode nec_8048_panel_vm = {
		.hactive = LCD_XRES,
		.vactive = LCD_YRES,
		.pixelclock = LCD_PIXEL_CLOCK,
		.hfront_porch = 6,
		.hsync_len = 1,
		.hback_porch = 4,
		.vfront_porch = 3,
		.vsync_len = 1,
		.vback_porch = 4,

		.flags = DISPLAY_FLAGS_HSYNC_LOW \| DISPLAY_FLAGS_VSYNC_LOW,
		};

		#define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)

		static int nec_8048_spi_send(struct spi_device *spi, unsigned char reg_addr,
		unsigned char reg_data)
		{
		int ret = 0;
		unsigned int cmd = 0, data = 0;

		cmd = 0x0000 \| reg_addr; /* register address write */
		data = 0x0100 \| reg_data; /* register data write */
		data = (cmd << 16) \| data;

		ret = spi_write(spi, (unsigned char *)&data, 4);
		if (ret)
		pr_err("error in spi_write %x\n", data);

		return ret;
		}

		static int init_nec_8048_wvga_lcd(struct spi_device *spi)
		{
		unsigned int i;
		/* Initialization Sequence */
		/* nec_8048_spi_send(spi, REG, VAL) */
		for (i = 0; i < (ARRAY_SIZE(nec_8048_init_seq) - 1); i++)
		nec_8048_spi_send(spi, nec_8048_init_seq[i].addr,
		nec_8048_init_seq[i].dat);
		udelay(20);
		nec_8048_spi_send(spi, nec_8048_init_seq[i].addr,
		nec_8048_init_seq[i].dat);
		return 0;
		}

		static int nec_8048_connect(struct omap_dss_device *src,
		struct omap_dss_device *dst)
		{
		return 0;
		}

		static void nec_8048_disconnect(struct omap_dss_device *src,
		struct omap_dss_device *dst)
		{
		}

		static void nec_8048_enable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		gpiod_set_value_cansleep(ddata->res_gpio, 1);
		}

		static void nec_8048_disable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		gpiod_set_value_cansleep(ddata->res_gpio, 0);
		}

		static int nec_8048_get_modes(struct omap_dss_device *dssdev,
		struct drm_connector *connector)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		return omapdss_display_get_modes(connector, &ddata->vm);
		}

		static const struct omap_dss_device_ops nec_8048_ops = {
		.connect = nec_8048_connect,
		.disconnect = nec_8048_disconnect,

		.enable = nec_8048_enable,
		.disable = nec_8048_disable,

		.get_modes = nec_8048_get_modes,
		};

		static int nec_8048_probe(struct spi_device *spi)
		{
		struct panel_drv_data *ddata;
		struct omap_dss_device *dssdev;
		struct gpio_desc *gpio;
		int r;

		dev_dbg(&spi->dev, "%s\n", __func__);

		spi->mode = SPI_MODE_0;
		spi->bits_per_word = 32;

		r = spi_setup(spi);
		if (r < 0) {
		dev_err(&spi->dev, "spi_setup failed: %d\n", r);
		return r;
		}

		init_nec_8048_wvga_lcd(spi);

		ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL);
		if (ddata == NULL)
		return -ENOMEM;

		dev_set_drvdata(&spi->dev, ddata);

		ddata->spi = spi;

		gpio = devm_gpiod_get(&spi->dev, "reset", GPIOD_OUT_LOW);
		if (IS_ERR(gpio)) {
		dev_err(&spi->dev, "failed to get reset gpio\n");
		return PTR_ERR(gpio);
		}

		ddata->res_gpio = gpio;

		ddata->vm = nec_8048_panel_vm;

		dssdev = &ddata->dssdev;
		dssdev->dev = &spi->dev;
		dssdev->ops = &nec_8048_ops;
		dssdev->type = OMAP_DISPLAY_TYPE_DPI;
		dssdev->display = true;
		dssdev->owner = THIS_MODULE;
		dssdev->of_ports = BIT(0);
		dssdev->ops_flags = OMAP_DSS_DEVICE_OP_MODES;
		dssdev->bus_flags = DRM_BUS_FLAG_DE_HIGH
		\| DRM_BUS_FLAG_SYNC_DRIVE_POSEDGE
		\| DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE;

		omapdss_display_init(dssdev);
		omapdss_device_register(dssdev);

		return 0;
		}

		static int nec_8048_remove(struct spi_device *spi)
		{
		struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev);
		struct omap_dss_device *dssdev = &ddata->dssdev;

		dev_dbg(&ddata->spi->dev, "%s\n", __func__);

		omapdss_device_unregister(dssdev);

		nec_8048_disable(dssdev);

		return 0;
		}

		#ifdef CONFIG_PM_SLEEP
		static int nec_8048_suspend(struct device *dev)
		{
		struct spi_device *spi = to_spi_device(dev);

		nec_8048_spi_send(spi, 2, 0x01);
		mdelay(40);

		return 0;
		}

		static int nec_8048_resume(struct device *dev)
		{
		struct spi_device *spi = to_spi_device(dev);

		/* reinitialize the panel */
		spi_setup(spi);
		nec_8048_spi_send(spi, 2, 0x00);
		init_nec_8048_wvga_lcd(spi);

		return 0;
		}
		static SIMPLE_DEV_PM_OPS(nec_8048_pm_ops, nec_8048_suspend,
		nec_8048_resume);
		#define NEC_8048_PM_OPS (&nec_8048_pm_ops)
		#else
		#define NEC_8048_PM_OPS NULL
		#endif

		static const struct of_device_id nec_8048_of_match[] = {
		{ .compatible = "omapdss,nec,nl8048hl11", },
		{},
		};

		MODULE_DEVICE_TABLE(of, nec_8048_of_match);

		static struct spi_driver nec_8048_driver = {
		.driver = {
		.name = "panel-nec-nl8048hl11",
		.pm = NEC_8048_PM_OPS,
		.of_match_table = nec_8048_of_match,
		.suppress_bind_attrs = true,
		},
		.probe = nec_8048_probe,
		.remove = nec_8048_remove,
		};

		module_spi_driver(nec_8048_driver);

		MODULE_ALIAS("spi:nec,nl8048hl11");
		MODULE_AUTHOR("Erik Gilling <konkers@android.com>");
		MODULE_DESCRIPTION("NEC-NL8048HL11 Driver");
		MODULE_LICENSE("GPL");

drivers/gpu/drm/omapdrm/displays/panel-sharp-ls037v7dw01.c

deleted100644 → 0

+0 −262

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* LCD panel driver for Sharp LS037V7DW01
		*
		* Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/
		* Author: Tomi Valkeinen <tomi.valkeinen@ti.com>
		*/

		#include <linux/delay.h>
		#include <linux/gpio/consumer.h>
		#include <linux/module.h>
		#include <linux/of.h>
		#include <linux/platform_device.h>
		#include <linux/slab.h>
		#include <linux/regulator/consumer.h>

		#include "../dss/omapdss.h"

		struct panel_drv_data {
		struct omap_dss_device dssdev;
		struct regulator *vcc;

		struct videomode vm;

		struct gpio_desc resb_gpio; / low = reset active min 20 us */
		struct gpio_desc ini_gpio; / high = power on */
		struct gpio_desc mo_gpio; / low = 480x640, high = 240x320 */
		struct gpio_desc lr_gpio; / high = conventional horizontal scanning */
		struct gpio_desc ud_gpio; / high = conventional vertical scanning */
		};

		static const struct videomode sharp_ls_vm = {
		.hactive = 480,
		.vactive = 640,

		.pixelclock = 19200000,

		.hsync_len = 2,
		.hfront_porch = 1,
		.hback_porch = 28,

		.vsync_len = 1,
		.vfront_porch = 1,
		.vback_porch = 1,

		.flags = DISPLAY_FLAGS_HSYNC_LOW \| DISPLAY_FLAGS_VSYNC_LOW,
		};

		#define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev)

		static int sharp_ls_connect(struct omap_dss_device *src,
		struct omap_dss_device *dst)
		{
		return 0;
		}

		static void sharp_ls_disconnect(struct omap_dss_device *src,
		struct omap_dss_device *dst)
		{
		}

		static void sharp_ls_pre_enable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);
		int r;

		if (ddata->vcc) {
		r = regulator_enable(ddata->vcc);
		if (r)
		dev_err(dssdev->dev, "%s: failed to enable regulator\n",
		__func__);
		}
		}

		static void sharp_ls_enable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		/* wait couple of vsyncs until enabling the LCD */
		msleep(50);

		if (ddata->resb_gpio)
		gpiod_set_value_cansleep(ddata->resb_gpio, 1);

		if (ddata->ini_gpio)
		gpiod_set_value_cansleep(ddata->ini_gpio, 1);
		}

		static void sharp_ls_disable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		if (ddata->ini_gpio)
		gpiod_set_value_cansleep(ddata->ini_gpio, 0);

		if (ddata->resb_gpio)
		gpiod_set_value_cansleep(ddata->resb_gpio, 0);

		/* wait at least 5 vsyncs after disabling the LCD */
		msleep(100);
		}

		static void sharp_ls_post_disable(struct omap_dss_device *dssdev)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		if (ddata->vcc)
		regulator_disable(ddata->vcc);
		}

		static int sharp_ls_get_modes(struct omap_dss_device *dssdev,
		struct drm_connector *connector)
		{
		struct panel_drv_data *ddata = to_panel_data(dssdev);

		return omapdss_display_get_modes(connector, &ddata->vm);
		}

		static const struct omap_dss_device_ops sharp_ls_ops = {
		.connect = sharp_ls_connect,
		.disconnect = sharp_ls_disconnect,

		.pre_enable = sharp_ls_pre_enable,
		.enable = sharp_ls_enable,
		.disable = sharp_ls_disable,
		.post_disable = sharp_ls_post_disable,

		.get_modes = sharp_ls_get_modes,
		};

		static int sharp_ls_get_gpio_of(struct device *dev, int index, int val,
		const char desc, struct gpio_desc *gpiod)
		{
		struct gpio_desc *gd;

		*gpiod = NULL;

		gd = devm_gpiod_get_index(dev, desc, index, GPIOD_OUT_LOW);
		if (IS_ERR(gd))
		return PTR_ERR(gd);

		*gpiod = gd;
		return 0;
		}

		static int sharp_ls_probe_of(struct platform_device *pdev)
		{
		struct panel_drv_data *ddata = platform_get_drvdata(pdev);
		int r;

		ddata->vcc = devm_regulator_get(&pdev->dev, "envdd");
		if (IS_ERR(ddata->vcc)) {
		dev_err(&pdev->dev, "failed to get regulator\n");
		return PTR_ERR(ddata->vcc);
		}

		/* lcd INI */
		r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "enable", &ddata->ini_gpio);
		if (r)
		return r;

		/* lcd RESB */
		r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "reset", &ddata->resb_gpio);
		if (r)
		return r;

		/* lcd MO */
		r = sharp_ls_get_gpio_of(&pdev->dev, 0, 0, "mode", &ddata->mo_gpio);
		if (r)
		return r;

		/* lcd LR */
		r = sharp_ls_get_gpio_of(&pdev->dev, 1, 1, "mode", &ddata->lr_gpio);
		if (r)
		return r;

		/* lcd UD */
		r = sharp_ls_get_gpio_of(&pdev->dev, 2, 1, "mode", &ddata->ud_gpio);
		if (r)
		return r;

		return 0;
		}

		static int sharp_ls_probe(struct platform_device *pdev)
		{
		struct panel_drv_data *ddata;
		struct omap_dss_device *dssdev;
		int r;

		ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
		if (ddata == NULL)
		return -ENOMEM;

		platform_set_drvdata(pdev, ddata);

		r = sharp_ls_probe_of(pdev);
		if (r)
		return r;

		ddata->vm = sharp_ls_vm;

		dssdev = &ddata->dssdev;
		dssdev->dev = &pdev->dev;
		dssdev->ops = &sharp_ls_ops;
		dssdev->type = OMAP_DISPLAY_TYPE_DPI;
		dssdev->display = true;
		dssdev->owner = THIS_MODULE;
		dssdev->of_ports = BIT(0);
		dssdev->ops_flags = OMAP_DSS_DEVICE_OP_MODES;

		/*
		* Note: According to the panel documentation:
		* DATA needs to be driven on the FALLING edge
		*/
		dssdev->bus_flags = DRM_BUS_FLAG_DE_HIGH
		\| DRM_BUS_FLAG_SYNC_DRIVE_NEGEDGE
		\| DRM_BUS_FLAG_PIXDATA_DRIVE_POSEDGE;

		omapdss_display_init(dssdev);
		omapdss_device_register(dssdev);

		return 0;
		}

		static int __exit sharp_ls_remove(struct platform_device *pdev)
		{
		struct panel_drv_data *ddata = platform_get_drvdata(pdev);
		struct omap_dss_device *dssdev = &ddata->dssdev;

		omapdss_device_unregister(dssdev);

		if (omapdss_device_is_enabled(dssdev)) {
		sharp_ls_disable(dssdev);
		sharp_ls_post_disable(dssdev);
		}

		return 0;
		}

		static const struct of_device_id sharp_ls_of_match[] = {
		{ .compatible = "omapdss,sharp,ls037v7dw01", },
		{},
		};

		MODULE_DEVICE_TABLE(of, sharp_ls_of_match);

		static struct platform_driver sharp_ls_driver = {
		.probe = sharp_ls_probe,
		.remove = __exit_p(sharp_ls_remove),
		.driver = {
		.name = "panel-sharp-ls037v7dw01",
		.of_match_table = sharp_ls_of_match,
		.suppress_bind_attrs = true,
		},
		};

		module_platform_driver(sharp_ls_driver);

		MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>");
		MODULE_DESCRIPTION("Sharp LS037V7DW01 Panel Driver");
		MODULE_LICENSE("GPL");

Admin message