diff options
Diffstat (limited to 'drivers/gpu/drm/bridge')
-rw-r--r-- | drivers/gpu/drm/bridge/Kconfig | 10 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/Makefile | 2 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/cadence/cdns-hdmi-core.c | 47 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/dumb-vga-dac.c | 7 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/lt8912.c | 684 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/sn65dsi83/Kconfig | 7 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/sn65dsi83/Makefile | 2 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.c | 388 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.h | 55 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_drv.c | 408 | ||||
-rw-r--r-- | drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_timing.h | 33 |
11 files changed, 1634 insertions, 9 deletions
diff --git a/drivers/gpu/drm/bridge/Kconfig b/drivers/gpu/drm/bridge/Kconfig index 8b2e5d975590..02aef36b5dde 100644 --- a/drivers/gpu/drm/bridge/Kconfig +++ b/drivers/gpu/drm/bridge/Kconfig @@ -74,6 +74,14 @@ config DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW to DP++. This is used with the i.MX6 imx-ldb driver. You are likely to say N here. +config DRM_LONTIUM_LT8912 + tristate "Lontium LT8912 MIPI-DSI to LVDS and HDMI/MHL bridge" + depends on OF + select DRM_KMS_HELPER + select REGMAP_I2C + help + Lontium LT8912 MIPI-DSI to LVDS and HDMI/MHL bridge chip driver. + config DRM_SEC_MIPI_DSIM tristate "Samsung MIPI DSIM Bridge" depends on OF @@ -178,6 +186,8 @@ source "drivers/gpu/drm/bridge/cadence/Kconfig" source "drivers/gpu/drm/bridge/synopsys/Kconfig" +source "drivers/gpu/drm/bridge/sn65dsi83/Kconfig" + config DRM_ITE_IT6263 tristate "ITE IT6263 LVDS/HDMI bridge" depends on OF diff --git a/drivers/gpu/drm/bridge/Makefile b/drivers/gpu/drm/bridge/Makefile index 7c755b93a3c5..59b755e690af 100644 --- a/drivers/gpu/drm/bridge/Makefile +++ b/drivers/gpu/drm/bridge/Makefile @@ -5,6 +5,7 @@ obj-$(CONFIG_DRM_DUMB_VGA_DAC) += dumb-vga-dac.o obj-$(CONFIG_DRM_FSL_IMX_LVDS_BRIDGE) += fsl-imx-ldb.o obj-$(CONFIG_DRM_LVDS_ENCODER) += lvds-encoder.o obj-$(CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW) += megachips-stdpxxxx-ge-b850v3-fw.o +obj-$(CONFIG_DRM_LONTIUM_LT8912) += lt8912.o obj-$(CONFIG_DRM_NXP_PTN3460) += nxp-ptn3460.o obj-$(CONFIG_DRM_PARADE_PS8622) += parade-ps8622.o obj-$(CONFIG_DRM_SIL_SII8620) += sil-sii8620.o @@ -22,3 +23,4 @@ obj-y += cadence/ obj-y += synopsys/ obj-$(CONFIG_DRM_ITE_IT6263) += it6263.o obj-$(CONFIG_DRM_SEC_MIPI_DSIM) += sec-dsim.o +obj-$(CONFIG_DRM_I2C_SN65DSI83) += sn65dsi83/ diff --git a/drivers/gpu/drm/bridge/cadence/cdns-hdmi-core.c b/drivers/gpu/drm/bridge/cadence/cdns-hdmi-core.c index 73a7d0a04f21..067290b3b3ad 100644 --- a/drivers/gpu/drm/bridge/cadence/cdns-hdmi-core.c +++ b/drivers/gpu/drm/bridge/cadence/cdns-hdmi-core.c @@ -226,6 +226,7 @@ void cdns_hdmi_mode_set(struct cdns_mhdp_device *mhdp) static enum drm_connector_status cdns_hdmi_connector_detect(struct drm_connector *connector, bool force) { + struct edid *edid; struct cdns_mhdp_device *mhdp = container_of(connector, struct cdns_mhdp_device, connector.base); @@ -233,15 +234,21 @@ cdns_hdmi_connector_detect(struct drm_connector *connector, bool force) hpd = cdns_mhdp_read_hpd(mhdp); - if (hpd == 1) + if (hpd == 1) { /* Cable Connected */ return connector_status_connected; - else if (hpd == 0) + } else if (hpd == 0) { /* Cable Disconnedted */ return connector_status_disconnected; - else { + } else if (mhdp->ddc) { + edid = drm_get_edid(connector, mhdp->ddc); + if (drm_edid_is_valid(edid)) + return connector_status_connected; + else + return connector_status_disconnected; + } else { /* Cable status unknown */ - DRM_INFO("Unknow cable status, hdp=%u\n", hpd); + DRM_INFO("Unknow cable status, hpd=%u\n", hpd); return connector_status_unknown; } } @@ -253,8 +260,15 @@ static int cdns_hdmi_connector_get_modes(struct drm_connector *connector) int num_modes = 0; struct edid *edid; - edid = drm_do_get_edid(&mhdp->connector.base, - cdns_hdmi_get_edid_block, mhdp); + /* + * Check if optional regular DDC I2C bus should be used. + * Fall-back to using IP/firmware integrated one. + */ + if (mhdp->ddc) + edid = drm_get_edid(&mhdp->connector.base, mhdp->ddc); + else + edid = drm_do_get_edid(&mhdp->connector.base, + cdns_hdmi_get_edid_block, mhdp); if (edid) { dev_info(mhdp->dev, "%x,%x,%x,%x,%x,%x,%x,%x\n", edid->header[0], edid->header[1], @@ -374,9 +388,12 @@ cdns_hdmi_bridge_mode_valid(struct drm_bridge *bridge, if (mode->hdisplay > 3840 || mode->vdisplay > 2160) return MODE_BAD_HVALUE; - vic = drm_match_cea_mode(mode); - if (vic == 0) - return MODE_BAD; + /* imx8mq-hdmi does not support non CEA modes */ + if (!strncmp("imx8mq-hdmi", mhdp->plat_data->plat_name, 11)) { + vic = drm_match_cea_mode(mode); + if (vic == 0) + return MODE_BAD; + } mhdp->valid_mode = mode; ret = cdns_mhdp_plat_call(mhdp, phy_video_valid); @@ -503,6 +520,7 @@ static irqreturn_t cdns_hdmi_irq_thread(int irq, void *data) static void cdns_hdmi_parse_dt(struct cdns_mhdp_device *mhdp) { struct device_node *of_node = mhdp->dev->of_node; + struct device_node *ddc_phandle; int ret; ret = of_property_read_u32(of_node, "lane-mapping", &mhdp->lane_mapping); @@ -511,6 +529,17 @@ static void cdns_hdmi_parse_dt(struct cdns_mhdp_device *mhdp) dev_warn(mhdp->dev, "Failed to get lane_mapping - using default 0xc6\n"); } dev_info(mhdp->dev, "lane-mapping 0x%02x\n", mhdp->lane_mapping); + + /* get optional regular DDC I2C bus */ + ddc_phandle = of_parse_phandle(of_node, "ddc-i2c-bus", 0); + if (ddc_phandle) { + mhdp->ddc = of_get_i2c_adapter_by_node(ddc_phandle); + if (mhdp->ddc) + dev_info(mhdp->dev, "Connector's ddc i2c bus found\n"); + else + ret = -EPROBE_DEFER; + of_node_put(ddc_phandle); + } } static int __cdns_hdmi_probe(struct platform_device *pdev, diff --git a/drivers/gpu/drm/bridge/dumb-vga-dac.c b/drivers/gpu/drm/bridge/dumb-vga-dac.c index 7aa789c35882..83ba7ba78f35 100644 --- a/drivers/gpu/drm/bridge/dumb-vga-dac.c +++ b/drivers/gpu/drm/bridge/dumb-vga-dac.c @@ -79,6 +79,13 @@ dumb_vga_connector_detect(struct drm_connector *connector, bool force) struct dumb_vga *vga = drm_connector_to_dumb_vga(connector); /* + * If I2C bus for DDC is not defined, asume that the cable + * is always connected. + */ + if (PTR_ERR(vga->ddc) == -ENODEV) + return connector_status_connected; + + /* * Even if we have an I2C bus, we can't assume that the cable * is disconnected if drm_probe_ddc fails. Some cables don't * wire the DDC pins, or the I2C bus might not be working at diff --git a/drivers/gpu/drm/bridge/lt8912.c b/drivers/gpu/drm/bridge/lt8912.c new file mode 100644 index 000000000000..aa407d09d319 --- /dev/null +++ b/drivers/gpu/drm/bridge/lt8912.c @@ -0,0 +1,684 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2018 Rockchip Electronics Co. Ltd. + * Copyright 2019 Toradex AG + */ + +#include <linux/kernel.h> +#include <linux/delay.h> +#include <linux/gpio.h> +#include <linux/gpio/consumer.h> +#include <linux/i2c.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/of_irq.h> +#include <linux/of_graph.h> +#include <linux/regmap.h> +#include <video/of_display_timing.h> +#include <video/videomode.h> + +#include <drm/drmP.h> +#include <drm/drm_of.h> +#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h> +#include <drm/drm_probe_helper.h> +#include <drm/drm_panel.h> +#include <drm/drm_mipi_dsi.h> + +struct lt8912 { + struct drm_bridge bridge; + struct drm_connector connector; + struct drm_display_mode mode; + struct device *dev; + struct mipi_dsi_device *dsi; + struct device_node *host_node; + u8 num_dsi_lanes; + u8 channel_id; + unsigned int irq; + u8 sink_is_hdmi; + struct regmap *regmap[3]; + struct gpio_desc *hpd_gpio; + struct gpio_desc *reset_n; + struct i2c_adapter *ddc; /* optional regular DDC I2C bus */ +}; + +static int lt8912_attach_dsi(struct lt8912 *lt); + +static inline struct lt8912 *bridge_to_lt8912(struct drm_bridge *b) +{ + return container_of(b, struct lt8912, bridge); +} + +static inline struct lt8912 *connector_to_lt8912(struct drm_connector *c) +{ + return container_of(c, struct lt8912, connector); +} + +/* LT8912 MIPI to HDMI & LVDS REG setting - 20180115.txt */ +static void lt8912_init(struct lt8912 *lt) +{ + u8 lanes = lt->dsi->lanes; + const struct drm_display_mode *mode = <->mode; + u32 hactive, hfp, hsync, hbp, vfp, vsync, vbp, htotal, vtotal; + unsigned int hsync_activehigh, vsync_activehigh, reg; + unsigned int version[2]; + + dev_info(lt->dev, DRM_MODE_FMT "\n", DRM_MODE_ARG(mode)); + /* TODO: lvds output init */ + + hactive = mode->hdisplay; + hfp = mode->hsync_start - mode->hdisplay; + hsync = mode->hsync_end - mode->hsync_start; + hsync_activehigh = !!(mode->flags & DRM_MODE_FLAG_PHSYNC); + hbp = mode->htotal - mode->hsync_end; + vfp = mode->vsync_start - mode->vdisplay; + vsync = mode->vsync_end - mode->vsync_start; + vsync_activehigh = !!(mode->flags & DRM_MODE_FLAG_PVSYNC); + vbp = mode->vtotal - mode->vsync_end; + htotal = mode->htotal; + vtotal = mode->vtotal; + + regmap_read(lt->regmap[0], 0x00, &version[0]); + regmap_read(lt->regmap[0], 0x01, &version[1]); + + dev_info(lt->dev, "LT8912 ID: %02x, %02x\n", + version[0], version[1]); + + /* DigitalClockEn */ + regmap_write(lt->regmap[0], 0x08, 0xff); + regmap_write(lt->regmap[0], 0x09, 0xff); + regmap_write(lt->regmap[0], 0x0a, 0xff); + regmap_write(lt->regmap[0], 0x0b, 0x7c); + regmap_write(lt->regmap[0], 0x0c, 0xff); + + /* TxAnalog */ + regmap_write(lt->regmap[0], 0x31, 0xa1); + regmap_write(lt->regmap[0], 0x32, 0xa1); + regmap_write(lt->regmap[0], 0x33, 0x03); + regmap_write(lt->regmap[0], 0x37, 0x00); + regmap_write(lt->regmap[0], 0x38, 0x22); + regmap_write(lt->regmap[0], 0x60, 0x82); + + /* CbusAnalog */ + regmap_write(lt->regmap[0], 0x39, 0x45); + regmap_write(lt->regmap[0], 0x3a, 0x00); + regmap_write(lt->regmap[0], 0x3b, 0x00); + + /* HDMIPllAnalog */ + regmap_write(lt->regmap[0], 0x44, 0x31); + regmap_write(lt->regmap[0], 0x55, 0x44); + regmap_write(lt->regmap[0], 0x57, 0x01); + regmap_write(lt->regmap[0], 0x5a, 0x02); + + /* MIPIAnalog */ + regmap_write(lt->regmap[0], 0x3e, 0xce); + regmap_write(lt->regmap[0], 0x3f, 0xd4); + regmap_write(lt->regmap[0], 0x41, 0x3c); + + /* MipiBasicSet */ + regmap_write(lt->regmap[1], 0x12, 0x04); + regmap_write(lt->regmap[1], 0x13, lanes % 4); + regmap_write(lt->regmap[1], 0x14, 0x00); + + regmap_write(lt->regmap[1], 0x15, 0x00); + regmap_write(lt->regmap[1], 0x1a, 0x03); + regmap_write(lt->regmap[1], 0x1b, 0x03); + + /* MIPIDig */ + regmap_write(lt->regmap[1], 0x10, 0x01); + regmap_write(lt->regmap[1], 0x11, 0x0a); + regmap_write(lt->regmap[1], 0x18, hsync); + regmap_write(lt->regmap[1], 0x19, vsync); + regmap_write(lt->regmap[1], 0x1c, hactive % 0x100); + regmap_write(lt->regmap[1], 0x1d, hactive >> 8); + + regmap_write(lt->regmap[1], 0x2f, 0x0c); + + regmap_write(lt->regmap[1], 0x34, htotal % 0x100); + regmap_write(lt->regmap[1], 0x35, htotal >> 8); + regmap_write(lt->regmap[1], 0x36, vtotal % 0x100); + regmap_write(lt->regmap[1], 0x37, vtotal >> 8); + regmap_write(lt->regmap[1], 0x38, vbp % 0x100); + regmap_write(lt->regmap[1], 0x39, vbp >> 8); + regmap_write(lt->regmap[1], 0x3a, vfp % 0x100); + regmap_write(lt->regmap[1], 0x3b, vfp >> 8); + regmap_write(lt->regmap[1], 0x3c, hbp % 0x100); + regmap_write(lt->regmap[1], 0x3d, hbp >> 8); + regmap_write(lt->regmap[1], 0x3e, hfp % 0x100); + regmap_write(lt->regmap[1], 0x3f, hfp >> 8); + regmap_read(lt->regmap[0], 0xab, ®); + reg &= 0xfc; + reg |= (hsync_activehigh < 1) | vsync_activehigh; + regmap_write(lt->regmap[0], 0xab, reg); + + /* DDSConfig */ + regmap_write(lt->regmap[1], 0x4e, 0x6a); + regmap_write(lt->regmap[1], 0x4f, 0xad); + regmap_write(lt->regmap[1], 0x50, 0xf3); + regmap_write(lt->regmap[1], 0x51, 0x80); + + regmap_write(lt->regmap[1], 0x1f, 0x5e); + regmap_write(lt->regmap[1], 0x20, 0x01); + regmap_write(lt->regmap[1], 0x21, 0x2c); + regmap_write(lt->regmap[1], 0x22, 0x01); + regmap_write(lt->regmap[1], 0x23, 0xfa); + regmap_write(lt->regmap[1], 0x24, 0x00); + regmap_write(lt->regmap[1], 0x25, 0xc8); + regmap_write(lt->regmap[1], 0x26, 0x00); + regmap_write(lt->regmap[1], 0x27, 0x5e); + regmap_write(lt->regmap[1], 0x28, 0x01); + regmap_write(lt->regmap[1], 0x29, 0x2c); + regmap_write(lt->regmap[1], 0x2a, 0x01); + regmap_write(lt->regmap[1], 0x2b, 0xfa); + regmap_write(lt->regmap[1], 0x2c, 0x00); + regmap_write(lt->regmap[1], 0x2d, 0xc8); + regmap_write(lt->regmap[1], 0x2e, 0x00); + regmap_write(lt->regmap[1], 0x42, 0x64); + regmap_write(lt->regmap[1], 0x43, 0x00); + regmap_write(lt->regmap[1], 0x44, 0x04); + regmap_write(lt->regmap[1], 0x45, 0x00); + regmap_write(lt->regmap[1], 0x46, 0x59); + regmap_write(lt->regmap[1], 0x47, 0x00); + regmap_write(lt->regmap[1], 0x48, 0xf2); + regmap_write(lt->regmap[1], 0x49, 0x06); + regmap_write(lt->regmap[1], 0x4a, 0x00); + regmap_write(lt->regmap[1], 0x4b, 0x72); + regmap_write(lt->regmap[1], 0x4c, 0x45); + regmap_write(lt->regmap[1], 0x4d, 0x00); + regmap_write(lt->regmap[1], 0x52, 0x08); + regmap_write(lt->regmap[1], 0x53, 0x00); + regmap_write(lt->regmap[1], 0x54, 0xb2); + regmap_write(lt->regmap[1], 0x55, 0x00); + regmap_write(lt->regmap[1], 0x56, 0xe4); + regmap_write(lt->regmap[1], 0x57, 0x0d); + regmap_write(lt->regmap[1], 0x58, 0x00); + regmap_write(lt->regmap[1], 0x59, 0xe4); + regmap_write(lt->regmap[1], 0x5a, 0x8a); + regmap_write(lt->regmap[1], 0x5b, 0x00); + regmap_write(lt->regmap[1], 0x5c, 0x34); + regmap_write(lt->regmap[1], 0x1e, 0x4f); + regmap_write(lt->regmap[1], 0x51, 0x00); + + regmap_write(lt->regmap[0], 0xb2, lt->sink_is_hdmi); + + /* Audio Disable */ + regmap_write(lt->regmap[2], 0x06, 0x00); + regmap_write(lt->regmap[2], 0x07, 0x00); + + regmap_write(lt->regmap[2], 0x34, 0xd2); + + regmap_write(lt->regmap[2], 0x3c, 0x41); + + /* MIPIRxLogicRes */ + regmap_write(lt->regmap[0], 0x03, 0x7f); + usleep_range(10000, 20000); + regmap_write(lt->regmap[0], 0x03, 0xff); + + regmap_write(lt->regmap[1], 0x51, 0x80); + usleep_range(10000, 20000); + regmap_write(lt->regmap[1], 0x51, 0x00); +} + +static void lt8912_wakeup(struct lt8912 *lt) +{ + gpiod_direction_output(lt->reset_n, 1); + msleep(120); + gpiod_direction_output(lt->reset_n, 0); + + regmap_write(lt->regmap[0], 0x08,0xff); /* enable clk gating */ + regmap_write(lt->regmap[0], 0x41,0x3c); /* MIPI Rx Power On */ + regmap_write(lt->regmap[0], 0x05,0xfb); /* DDS logical reset */ + regmap_write(lt->regmap[0], 0x05,0xff); + regmap_write(lt->regmap[0], 0x03,0x7f); /* MIPI RX logical reset */ + usleep_range(10000, 20000); + regmap_write(lt->regmap[0], 0x03,0xff); + regmap_write(lt->regmap[0], 0x32,0xa1); + regmap_write(lt->regmap[0], 0x33,0x03); +} + +static void lt8912_sleep(struct lt8912 *lt) +{ + regmap_write(lt->regmap[0], 0x32,0xa0); + regmap_write(lt->regmap[0], 0x33,0x00); /* Disable HDMI output. */ + regmap_write(lt->regmap[0], 0x41,0x3d); /* MIPI Rx Power Down. */ + regmap_write(lt->regmap[0], 0x08,0x00); /* diable DDS clk. */ + + gpiod_direction_output(lt->reset_n, 1); +} + +static enum drm_connector_status +lt8912_connector_detect(struct drm_connector *connector, bool force) +{ + struct lt8912 *lt = connector_to_lt8912(connector); + enum drm_connector_status hpd, hpd_last; + int timeout = 0; + + hpd = connector_status_unknown; + do { + hpd_last = hpd; + hpd = gpiod_get_value_cansleep(lt->hpd_gpio) ? + connector_status_connected : connector_status_disconnected; + msleep(20); + timeout += 20; + } while((hpd_last != hpd) && (timeout < 500)); + + return hpd; +} + +static const struct drm_connector_funcs lt8912_connector_funcs = { + .detect = lt8912_connector_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = drm_connector_cleanup, + .reset = drm_atomic_helper_connector_reset, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +static irqreturn_t lt8912_hpd_irq_thread(int irq, void *arg) +{ + struct lt8912 *lt = arg; + struct drm_connector *connector = <->connector; + + drm_helper_hpd_irq_event(connector->dev); + + return IRQ_HANDLED; +} + +static struct drm_encoder * +lt8912_connector_best_encoder(struct drm_connector *connector) +{ + struct lt8912 *lt = connector_to_lt8912(connector); + + return lt->bridge.encoder; +} + +static int lt8912_connector_get_modes(struct drm_connector *connector) +{ + struct lt8912 *lt = connector_to_lt8912(connector); + struct edid *edid; + struct display_timings *timings; + u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24; + int i, ret, num_modes = 0; + + /* Check if optional DDC I2C bus should be used. */ + if (lt->ddc) { + edid = drm_get_edid(connector, lt->ddc); + if (edid) { + drm_connector_update_edid_property(connector, + edid); + num_modes = drm_add_edid_modes(connector, edid); + lt->sink_is_hdmi = !!drm_detect_hdmi_monitor(edid); + kfree(edid); + } + if (num_modes == 0) { + dev_warn(lt->dev, "failed to get display timings from EDID\n"); + return 0; + } + } else { /* if not EDID, use dtb timings */ + timings = of_get_display_timings(lt->dev->of_node); + + if (timings->num_timings == 0) { + dev_err(lt->dev, "failed to get display timings from dtb\n"); + return 0; + } + + for (i = 0; i < timings->num_timings; i++) { + struct drm_display_mode *mode; + struct videomode vm; + + if (videomode_from_timings(timings, &vm, i)) { + continue; + } + + mode = drm_mode_create(connector->dev); + drm_display_mode_from_videomode(&vm, mode); + mode->type = DRM_MODE_TYPE_DRIVER; + + if (timings->native_mode == i) + mode->type |= DRM_MODE_TYPE_PREFERRED; + + drm_mode_set_name(mode); + drm_mode_probed_add(connector, mode); + num_modes++; + } + if (num_modes == 0) { + dev_err(lt->dev, "failed to get display modes from dtb\n"); + return 0; + } + } + + connector->display_info.bus_flags = DRM_BUS_FLAG_DE_LOW | + DRM_BUS_FLAG_PIXDATA_NEGEDGE; + ret = drm_display_info_set_bus_formats(&connector->display_info, + &bus_format, 1); + + if (ret) + return ret; + + return num_modes; +} + +static enum drm_mode_status lt8912_connector_mode_valid(struct drm_connector *connector, + struct drm_display_mode *mode) +{ + if (mode->clock > 150000) + return MODE_CLOCK_HIGH; + + if (mode->hdisplay > 1920) + return MODE_BAD_HVALUE; + + if (mode->vdisplay > 1080) + return MODE_BAD_VVALUE; + + return MODE_OK; +} + +static const struct drm_connector_helper_funcs lt8912_connector_helper_funcs = { + .get_modes = lt8912_connector_get_modes, + .best_encoder = lt8912_connector_best_encoder, + .mode_valid = lt8912_connector_mode_valid, +}; + +static void lt8912_bridge_post_disable(struct drm_bridge *bridge) +{ + struct lt8912 *lt = bridge_to_lt8912(bridge); + lt8912_sleep(lt); +} + +static void lt8912_bridge_enable(struct drm_bridge *bridge) +{ + struct lt8912 *lt = bridge_to_lt8912(bridge); + lt8912_init(lt); +} + +static void lt8912_bridge_pre_enable(struct drm_bridge *bridge) +{ + struct lt8912 *lt = bridge_to_lt8912(bridge); + lt8912_wakeup(lt); +} + +static void lt8912_bridge_mode_set(struct drm_bridge *bridge, + const struct drm_display_mode *mode, + const struct drm_display_mode *adj) +{ + struct lt8912 *lt = bridge_to_lt8912(bridge); + + drm_mode_copy(<->mode, adj); +} + +static int lt8912_bridge_attach(struct drm_bridge *bridge) +{ + struct lt8912 *lt = bridge_to_lt8912(bridge); + struct drm_connector *connector = <->connector; + int ret; + + connector->polled = DRM_CONNECTOR_POLL_HPD; + + ret = drm_connector_init(bridge->dev, connector, + <8912_connector_funcs, + DRM_MODE_CONNECTOR_HDMIA); + if (ret) { + dev_err(lt->dev, "failed to initialize connector\n"); + return ret; + } + + drm_connector_helper_add(connector, <8912_connector_helper_funcs); + drm_connector_attach_encoder(connector, bridge->encoder); + + ret = lt8912_attach_dsi(lt); + + enable_irq(lt->irq); + + return ret; +} + +static const struct drm_bridge_funcs lt8912_bridge_funcs = { + .attach = lt8912_bridge_attach, + .mode_set = lt8912_bridge_mode_set, + .pre_enable = lt8912_bridge_pre_enable, + .enable = lt8912_bridge_enable, + .post_disable = lt8912_bridge_post_disable, +}; + +static const struct regmap_config lt8912_regmap_config = { + .reg_bits = 8, + .val_bits = 8, + .max_register = 0xff, +}; + +static int lt8912_i2c_init(struct lt8912 *lt, + struct i2c_client *client) +{ + struct i2c_board_info info[] = { + { I2C_BOARD_INFO("lt8912p0", 0x48), }, + { I2C_BOARD_INFO("lt8912p1", 0x49), }, + { I2C_BOARD_INFO("lt8912p2", 0x4a), } + }; + struct regmap *regmap; + unsigned int i; + int ret; + + if (!lt || !client) + return -ENODEV; + + for (i = 0; i < ARRAY_SIZE(info); i++) { + if (i > 0 ) { + client = i2c_new_dummy(client->adapter, info[i].addr); + if (!client) + return -ENODEV; + } + regmap = devm_regmap_init_i2c(client, <8912_regmap_config); + if (IS_ERR(regmap)) { + ret = PTR_ERR(regmap); + dev_err(lt->dev, + "Failed to initialize regmap: %d\n", ret); + return ret; + } + + lt->regmap[i] = regmap; + } + + return 0; +} + +int lt8912_attach_dsi(struct lt8912 *lt) +{ + struct device *dev = lt->dev; + struct mipi_dsi_host *host; + struct mipi_dsi_device *dsi; + int ret = 0; + const struct mipi_dsi_device_info info = { .type = "lt8912", + .channel = lt->channel_id, + .node = NULL, + }; + + host = of_find_mipi_dsi_host_by_node(lt->host_node); + if (!host) { + dev_err(dev, "failed to find dsi host\n"); + return -EPROBE_DEFER; + } + + dsi = mipi_dsi_device_register_full(host, &info); + if (IS_ERR(dsi)) { + dev_err(dev, "failed to create dsi device\n"); + ret = PTR_ERR(dsi); + goto err_dsi_device; + } + + lt->dsi = dsi; + + dsi->lanes = lt->num_dsi_lanes; + dsi->format = MIPI_DSI_FMT_RGB888; + dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST | + MIPI_DSI_MODE_LPM | MIPI_DSI_MODE_EOT_PACKET; + + ret = mipi_dsi_attach(dsi); + if (ret < 0) { + dev_err(dev, "failed to attach dsi to host\n"); + goto err_dsi_attach; + } + + return 0; + +err_dsi_attach: + mipi_dsi_device_unregister(dsi); +err_dsi_device: + return ret; +} + +void lt8912_detach_dsi(struct lt8912 *lt) +{ + mipi_dsi_detach(lt->dsi); + mipi_dsi_device_unregister(lt->dsi); +} + + +static int lt8912_probe(struct i2c_client *i2c, const struct i2c_device_id *id) +{ + struct device *dev = &i2c->dev; + struct lt8912 *lt; + struct device_node *ddc_phandle; + struct device_node *endpoint; + unsigned int irq_flags; + int ret; + + static int initialize_it = 1; + + if(!initialize_it) { + initialize_it = 1; + return -EPROBE_DEFER; + } + + lt = devm_kzalloc(dev, sizeof(*lt), GFP_KERNEL); + if (!lt) + return -ENOMEM; + + lt->dev = dev; + + /* get optional regular DDC I2C bus */ + ddc_phandle = of_parse_phandle(dev->of_node, "ddc-i2c-bus", 0); + if (ddc_phandle) { + lt->ddc = of_get_i2c_adapter_by_node(ddc_phandle); + if (!(lt->ddc)) + ret = -EPROBE_DEFER; + of_node_put(ddc_phandle); + } + + lt->hpd_gpio = devm_gpiod_get(dev, "hpd", GPIOD_IN); + if (IS_ERR(lt->hpd_gpio)) { + dev_err(dev, "failed to get hpd gpio\n"); + return ret; + } + + lt->irq = gpiod_to_irq(lt->hpd_gpio); + if (lt->irq == -ENXIO) { + dev_err(dev, "failed to get hpd irq\n"); + return -ENODEV; + } + if (lt->irq < 0) { + dev_err(dev, "failed to get hpd irq, %i\n", lt->irq); + return lt->irq; + } + irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT; + ret = devm_request_threaded_irq(dev, lt->irq, + NULL, + lt8912_hpd_irq_thread, + irq_flags, "lt8912_hpd", lt); + if (ret) { + dev_err(dev, "failed to request irq\n"); + return -ENODEV; + } + + disable_irq(lt->irq); + + lt->reset_n = devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS); + if (IS_ERR(lt->reset_n)) { + ret = PTR_ERR(lt->reset_n); + dev_err(dev, "failed to request reset GPIO: %d\n", ret); + return ret; + } + + ret = lt8912_i2c_init(lt, i2c); + if (ret) + return ret; + + /* TODO: interrupt handing */ + + lt->num_dsi_lanes = 4; + lt->channel_id = 1; + + endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); + if (!endpoint) + return -ENODEV; + + lt->host_node = of_graph_get_remote_port_parent(endpoint); + if (!lt->host_node) { + of_node_put(endpoint); + return -ENODEV; + } + + of_node_put(endpoint); + of_node_put(lt->host_node); + + lt->bridge.funcs = <8912_bridge_funcs; + lt->bridge.of_node = dev->of_node; + drm_bridge_add(<->bridge); + + return 0; +} + +static int lt8912_remove(struct i2c_client *i2c) +{ + struct lt8912 *lt = i2c_get_clientdata(i2c); + + lt8912_sleep(lt); + mipi_dsi_detach(lt->dsi); + drm_bridge_remove(<->bridge); + + return 0; +} + +static const struct i2c_device_id lt8912_i2c_ids[] = { + { "lt8912", 0 }, + { } +}; + +static const struct of_device_id lt8912_of_match[] = { + { .compatible = "lontium,lt8912" }, + {} +}; +MODULE_DEVICE_TABLE(of, lt8912_of_match); + +static struct mipi_dsi_driver lt8912_driver = { + .driver.name = "lt8912", +}; + +static struct i2c_driver lt8912_i2c_driver = { + .driver = { + .name = "lt8912", + .of_match_table = lt8912_of_match, + }, + .id_table = lt8912_i2c_ids, + .probe = lt8912_probe, + .remove = lt8912_remove, +}; + +static int __init lt8912_i2c_drv_init(void) +{ + mipi_dsi_driver_register(<8912_driver); + + return i2c_add_driver(<8912_i2c_driver); +} +module_init(lt8912_i2c_drv_init); + +static void __exit lt8912_i2c_exit(void) +{ + i2c_del_driver(<8912_i2c_driver); + + mipi_dsi_driver_unregister(<8912_driver); +} +module_exit(lt8912_i2c_exit); + +MODULE_AUTHOR("Wyon Bi <bivvy.bi@rock-chips.com>"); +MODULE_DESCRIPTION("Lontium LT8912 MIPI-DSI to LVDS and HDMI/MHL bridge"); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/gpu/drm/bridge/sn65dsi83/Kconfig b/drivers/gpu/drm/bridge/sn65dsi83/Kconfig new file mode 100644 index 000000000000..1d8f37f689d3 --- /dev/null +++ b/drivers/gpu/drm/bridge/sn65dsi83/Kconfig @@ -0,0 +1,7 @@ +config DRM_I2C_SN65DSI83 + bool "SN65DSI83 mipi dsi to lvds bridge" + depends on OF + select DRM_MIPI_DSI + default y + help + Support for the sn65dsi83 MIPI DSI to LVDS bridge diff --git a/drivers/gpu/drm/bridge/sn65dsi83/Makefile b/drivers/gpu/drm/bridge/sn65dsi83/Makefile new file mode 100644 index 000000000000..dee7f493b323 --- /dev/null +++ b/drivers/gpu/drm/bridge/sn65dsi83/Makefile @@ -0,0 +1,2 @@ +sn65dsi83-objs := sn65dsi83_drv.o sn65dsi83_brg.o +obj-$(CONFIG_DRM_I2C_SN65DSI83) := sn65dsi83.o diff --git a/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.c b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.c new file mode 100644 index 000000000000..f4a7713635d6 --- /dev/null +++ b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.c @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2018 CopuLab Ltd. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include <linux/i2c.h> +#include <linux/device.h> +#include <linux/gpio/consumer.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/of_device.h> +#include <linux/of_graph.h> +#include <linux/slab.h> + +#include <drm/drmP.h> +#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h> +#include <drm/drm_edid.h> +#include <drm/drm_mipi_dsi.h> +#include <drm/drm_connector.h> +#include <video/mipi_display.h> +#include <video/of_videomode.h> +#include <video/videomode.h> + +#include "sn65dsi83_brg.h" + +/* Register addresses */ + +#define SN65DSI83_SOFT_RESET 0x09 +#define SN65DSI83_CORE_PLL 0x0A + #define LVDS_CLK_RANGE_SHIFT 1 + #define HS_CLK_SRC_SHIFT 0 + +#define SN65DSI83_PLL_DIV 0x0B + #define DSI_CLK_DIV_SHIFT 3 + +#define SN65DSI83_PLL_EN 0x0D +#define SN65DSI83_DSI_CFG 0x10 + #define CHA_DSI_LANES_SHIFT 3 + +#define SN65DSI83_DSI_EQ 0x11 +#define SN65DSI83_CHA_DSI_CLK_RNG 0x12 +#define SN65DSI83_CHB_DSI_CLK_RNG 0x13 +#define SN65DSI83_LVDS_MODE 0x18 + #define DE_NEG_POLARITY_SHIFT 7 + #define HS_NEG_POLARITY_SHIFT 6 + #define VS_NEG_POLARITY_SHIFT 5 + #define LVDS_LINK_CFG_SHIFT 4 + #define CHA_24BPP_MODE_SHIFT 3 + #define CHA_24BPP_FMT1_SHIFT 1 + +#define SN65DSI83_LVDS_SIGN 0x19 +#define SN65DSI83_LVDS_TERM 0x1A +#define SN65DSI83_LVDS_CM_ADJ 0x1B +#define SN65DSI83_CHA_LINE_LEN_LO 0x20 +#define SN65DSI83_CHA_LINE_LEN_HI 0x21 +#define SN65DSI83_CHB_LINE_LEN_LO 0x22 +#define SN65DSI83_CHB_LINE_LEN_HI 0x23 +#define SN65DSI83_CHA_VERT_LINES_LO 0x24 +#define SN65DSI83_CHA_VERT_LINES_HI 0x25 +#define SN65DSI83_CHB_VERT_LINES_LO 0x26 +#define SN65DSI83_CHB_VERT_LINES_HI 0x27 +#define SN65DSI83_CHA_SYNC_DELAY_LO 0x28 +#define SN65DSI83_CHA_SYNC_DELAY_HI 0x29 +#define SN65DSI83_CHB_SYNC_DELAY_LO 0x2A +#define SN65DSI83_CHB_SYNC_DELAY_HI 0x2B +#define SN65DSI83_CHA_HSYNC_WIDTH_LO 0x2C +#define SN65DSI83_CHA_HSYNC_WIDTH_HI 0x2D +#define SN65DSI83_CHB_HSYNC_WIDTH_LO 0x2E +#define SN65DSI83_CHB_HSYNC_WIDTH_HI 0x2F +#define SN65DSI83_CHA_VSYNC_WIDTH_LO 0x30 +#define SN65DSI83_CHA_VSYNC_WIDTH_HI 0x31 +#define SN65DSI83_CHB_VSYNC_WIDTH_LO 0x32 +#define SN65DSI83_CHB_VSYNC_WIDTH_HI 0x33 +#define SN65DSI83_CHA_HORZ_BACKPORCH 0x34 +#define SN65DSI83_CHB_HORZ_BACKPORCH 0x35 +#define SN65DSI83_CHA_VERT_BACKPORCH 0x36 +#define SN65DSI83_CHB_VERT_BACKPORCH 0x37 +#define SN65DSI83_CHA_HORZ_FRONTPORCH 0x38 +#define SN65DSI83_CHB_HORZ_FRONTPORCH 0x39 +#define SN65DSI83_CHA_VERT_FRONTPORCH 0x3A +#define SN65DSI83_CHB_VERT_FRONTPORCH 0x3B +#define SN65DSI83_CHA_ERR 0xE5 +#define SN65DSI83_TEST_PATTERN 0x3C +#define SN65DSI83_REG_3D 0x3D +#define SN65DSI83_REG_3E 0x3E + +static int sn65dsi83_brg_power_on(struct sn65dsi83_brg *brg) +{ + dev_info(&brg->client->dev,"%s\n",__func__); + gpiod_set_value_cansleep(brg->gpio_enable, 1); + /* Wait for 1ms for the internal voltage regulator to stabilize */ + msleep(1); + + return 0; +} + +static void sn65dsi83_brg_power_off(struct sn65dsi83_brg *brg) +{ + dev_info(&brg->client->dev,"%s\n",__func__); + gpiod_set_value_cansleep(brg->gpio_enable, 0); + /* + * The EN pin must be held low for at least 10 ms + * before being asserted high + */ + msleep(10); +} + +static int sn65dsi83_write(struct i2c_client *client, u8 reg, u8 val) +{ + int ret; + + ret = i2c_smbus_write_byte_data(client, reg, val); + + if (ret) + dev_err(&client->dev, "failed to write at 0x%02x", reg); + + dev_dbg(&client->dev, "%s: write reg 0x%02x data 0x%02x", __func__, reg, val); + + return ret; +} +#define SN65DSI83_WRITE(reg,val) sn65dsi83_write(client, (reg) , (val)) + +static int sn65dsi83_read(struct i2c_client *client, u8 reg) +{ + int ret; + + dev_info(&client->dev, "client 0x%p", client); + ret = i2c_smbus_read_byte_data(client, reg); + + if (ret < 0) { + dev_err(&client->dev, "failed reading at 0x%02x", reg); + return ret; + } + + dev_dbg(&client->dev, "%s: read reg 0x%02x data 0x%02x", __func__, reg, ret); + + return ret; +} +#define SN65DSI83_READ(reg) sn65dsi83_read(client, (reg)) + +static int sn65dsi83_brg_start_stream(struct sn65dsi83_brg *brg) +{ + int regval; + struct i2c_client *client = I2C_CLIENT(brg); + + dev_info(&client->dev,"%s\n",__func__); + /* Set the PLL_EN bit (CSR 0x0D.0) */ + SN65DSI83_WRITE(SN65DSI83_PLL_EN, 0x1); + /* Wait for the PLL_LOCK bit to be set (CSR 0x0A.7) */ + msleep(200); + + /* Perform SW reset to apply changes */ + SN65DSI83_WRITE(SN65DSI83_SOFT_RESET, 0x01); + + /* Read CHA Error register */ + regval = SN65DSI83_READ(SN65DSI83_CHA_ERR); + dev_info(&client->dev, "CHA (0x%02x) = 0x%02x", + SN65DSI83_CHA_ERR, regval); + + return 0; +} + +static void sn65dsi83_brg_stop_stream(struct sn65dsi83_brg *brg) +{ + struct i2c_client *client = I2C_CLIENT(brg); + dev_info(&client->dev,"%s\n",__func__); + /* Clear the PLL_EN bit (CSR 0x0D.0) */ + SN65DSI83_WRITE(SN65DSI83_PLL_EN, 0x00); +} + +static int sn65dsi83_calk_clk_range(int min_regval, int max_regval, + unsigned long min_clk, unsigned long inc, + unsigned long target_clk) +{ + int regval = min_regval; + unsigned long clk = min_clk; + + while (regval <= max_regval) { + if ((clk <= target_clk) && (target_clk < (clk + inc))) + return regval; + + regval++; + clk += inc; + } + + return -1; +} + +#define ABS(X) ((X) < 0 ? (-1 * (X)) : (X)) +static int sn65dsi83_calk_div(int min_regval, int max_regval, int min_div, + int inc, unsigned long source_clk, + unsigned long target_clk) +{ + int regval = min_regval; + int div = min_div; + unsigned long curr_delta; + unsigned long prev_delta = ABS(DIV_ROUND_UP(source_clk, div) - + target_clk); + + while (regval <= max_regval) { + curr_delta = ABS(DIV_ROUND_UP(source_clk, div) - target_clk); + if (curr_delta > prev_delta) + return --regval; + + regval++; + div += inc; + } + + return -1; +} + +static int sn65dsi83_brg_configure(struct sn65dsi83_brg *brg) +{ + int regval = 0; + struct i2c_client *client = I2C_CLIENT(brg); + struct videomode *vm = VM(brg); + + u32 dsi_clk = (((PIXCLK * BPP(brg)) / DSI_LANES(brg)) >> 1); + + dev_info(&client->dev, "DSI clock [ %u ] Hz\n",dsi_clk); + dev_info(&client->dev, "GeoMetry [ %d x %d ] Hz\n",HACTIVE,VACTIVE); + + /* Reset PLL_EN and SOFT_RESET registers */ + SN65DSI83_WRITE(SN65DSI83_SOFT_RESET,0x00); + SN65DSI83_WRITE(SN65DSI83_PLL_EN,0x00); + + /* LVDS clock setup */ + if ((25000000 <= PIXCLK) && (PIXCLK < 37500000)) + regval = 0; + else + regval = sn65dsi83_calk_clk_range(0x01, 0x05, 37500000, 25000000, + PIXCLK); + + if (regval < 0) { + dev_err(&client->dev, "failed to configure LVDS clock"); + return -EINVAL; + } + + regval = (regval << LVDS_CLK_RANGE_SHIFT); + regval |= (1 << HS_CLK_SRC_SHIFT); /* Use DSI clock */ + SN65DSI83_WRITE(SN65DSI83_CORE_PLL,regval); + + /* DSI clock range */ + regval = sn65dsi83_calk_clk_range(0x08, 0x64, 40000000, 5000000, dsi_clk); + if (regval < 0) { + dev_err(&client->dev, "failed to configure DSI clock range\n"); + return -EINVAL; + } + SN65DSI83_WRITE(SN65DSI83_CHA_DSI_CLK_RNG,regval); + + /* DSI clock divider */ + regval = sn65dsi83_calk_div(0x0, 0x18, 1, 1, dsi_clk, PIXCLK); + if (regval < 0) { + dev_err(&client->dev, "failed to calculate DSI clock divider"); + return -EINVAL; + } + + regval = regval << DSI_CLK_DIV_SHIFT; + SN65DSI83_WRITE(SN65DSI83_PLL_DIV,regval); + + /* Configure DSI_LANES */ + regval = SN65DSI83_READ(SN65DSI83_DSI_CFG); + regval &= ~(3 << CHA_DSI_LANES_SHIFT); + regval |= ((4 - DSI_LANES(brg)) << CHA_DSI_LANES_SHIFT); + SN65DSI83_WRITE(SN65DSI83_DSI_CFG,regval); + + /* CHA_DSI_DATA_EQ - No Equalization */ + /* CHA_DSI_CLK_EQ - No Equalization */ + SN65DSI83_WRITE(SN65DSI83_DSI_EQ,0x00); + + /* Video formats */ + regval = 0; + if (FLAGS & DISPLAY_FLAGS_HSYNC_LOW) + regval |= (1 << HS_NEG_POLARITY_SHIFT); + + if (FLAGS & DISPLAY_FLAGS_VSYNC_LOW) + regval |= (1 << VS_NEG_POLARITY_SHIFT); + + if (FLAGS & DISPLAY_FLAGS_DE_LOW) + regval |= (1 << DE_NEG_POLARITY_SHIFT); + + if (BPP(brg) == 24) + regval |= (1 << CHA_24BPP_MODE_SHIFT); + + if (FORMAT(brg) == 1) + regval |= (1 << CHA_24BPP_FMT1_SHIFT); + + regval |= (1 << LVDS_LINK_CFG_SHIFT); + SN65DSI83_WRITE(SN65DSI83_LVDS_MODE,regval); + + /* Voltage and pins */ + SN65DSI83_WRITE(SN65DSI83_LVDS_SIGN,0x00); + SN65DSI83_WRITE(SN65DSI83_LVDS_TERM,0x03); + SN65DSI83_WRITE(SN65DSI83_LVDS_CM_ADJ,0x00); + + /* Configure sync delay to minimal allowed value */ + SN65DSI83_WRITE(SN65DSI83_CHA_SYNC_DELAY_LO,0x21); + SN65DSI83_WRITE(SN65DSI83_CHA_SYNC_DELAY_HI,0x00); + + /* Geometry */ + SN65DSI83_WRITE(SN65DSI83_CHA_LINE_LEN_LO,LOW(HACTIVE)); + SN65DSI83_WRITE(SN65DSI83_CHA_LINE_LEN_HI,HIGH(HACTIVE)); + + SN65DSI83_WRITE(SN65DSI83_CHA_VERT_LINES_LO,LOW(VACTIVE)); + SN65DSI83_WRITE(SN65DSI83_CHA_VERT_LINES_HI,HIGH(VACTIVE)); + + SN65DSI83_WRITE(SN65DSI83_CHA_HSYNC_WIDTH_LO,LOW(HPW)); + SN65DSI83_WRITE(SN65DSI83_CHA_HSYNC_WIDTH_HI,HIGH(HPW)); + + SN65DSI83_WRITE(SN65DSI83_CHA_VSYNC_WIDTH_LO,LOW(VPW)); + SN65DSI83_WRITE(SN65DSI83_CHA_VSYNC_WIDTH_HI,HIGH(VPW)); + + SN65DSI83_WRITE(SN65DSI83_CHA_HORZ_BACKPORCH,LOW(HBP)); + SN65DSI83_WRITE(SN65DSI83_CHA_VERT_BACKPORCH,LOW(VBP)); + + SN65DSI83_WRITE(SN65DSI83_CHA_HORZ_FRONTPORCH,LOW(HFP)); + SN65DSI83_WRITE(SN65DSI83_CHA_VERT_FRONTPORCH,LOW(VFP)); + + SN65DSI83_WRITE(SN65DSI83_TEST_PATTERN,0x00); + SN65DSI83_WRITE(SN65DSI83_REG_3D,0x00); + SN65DSI83_WRITE(SN65DSI83_REG_3E,0x00); + + /* mute channel B */ + SN65DSI83_WRITE(SN65DSI83_CHB_DSI_CLK_RNG, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_LINE_LEN_LO, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_LINE_LEN_HI, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_VERT_LINES_LO, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_VERT_LINES_HI, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_SYNC_DELAY_LO, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_SYNC_DELAY_HI, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_HSYNC_WIDTH_LO, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_HSYNC_WIDTH_HI, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_VSYNC_WIDTH_LO, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_VSYNC_WIDTH_HI, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_HORZ_BACKPORCH, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_VERT_BACKPORCH, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_HORZ_FRONTPORCH, 0x00); + SN65DSI83_WRITE(SN65DSI83_CHB_VERT_FRONTPORCH, 0x00); + return 0; +} + +static int sn65dsi83_brg_setup(struct sn65dsi83_brg *brg) +{ + struct i2c_client *client = I2C_CLIENT(brg); + dev_info(&client->dev,"%s\n",__func__); + sn65dsi83_brg_power_on(brg); + return sn65dsi83_brg_configure(brg); +} + +static int sn65dsi83_brg_reset(struct sn65dsi83_brg *brg) +{ + /* Soft Reset reg value at power on should be 0x00 */ + struct i2c_client *client = I2C_CLIENT(brg); + int ret = SN65DSI83_READ(SN65DSI83_SOFT_RESET); + dev_info(&client->dev,"%s\n",__func__); + if (ret != 0x00) { + dev_err(&client->dev,"Failed to reset the device"); + return -ENODEV; + } + return 0; +} + +static struct sn65dsi83_brg_funcs brg_func = { + .power_on = sn65dsi83_brg_power_on, + .power_off = sn65dsi83_brg_power_off, + .setup = sn65dsi83_brg_setup, + .reset = sn65dsi83_brg_reset, + .start_stream = sn65dsi83_brg_start_stream, + .stop_stream = sn65dsi83_brg_stop_stream, +}; + +static struct sn65dsi83_brg brg = { + .funcs = &brg_func, +}; + +struct sn65dsi83_brg *sn65dsi83_brg_get(void) { + return &brg; +} diff --git a/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.h b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.h new file mode 100644 index 000000000000..9f23df8afedc --- /dev/null +++ b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_brg.h @@ -0,0 +1,55 @@ +#ifndef _SN65DSI83_BRG_H__ +#define _SN65DSI83_BRG_H__ + +#include <linux/i2c.h> +#include <linux/gpio/consumer.h> +#include <video/videomode.h> + +struct sn65dsi83_brg; +struct sn65dsi83_brg_funcs { + int (*power_on)(struct sn65dsi83_brg *sn65dsi8383_brg); + void (*power_off)(struct sn65dsi83_brg *sn65dsi8383_brg); + int (*reset)(struct sn65dsi83_brg *sn65dsi8383_brg); + int (*setup)(struct sn65dsi83_brg *sn65dsi8383_brg); + int (*start_stream)(struct sn65dsi83_brg *sn65dsi8383_brg); + void (*stop_stream)(struct sn65dsi83_brg *sn65dsi8383_brg); +}; + +struct sn65dsi83_brg { + struct i2c_client *client; + struct gpio_desc *gpio_enable; + /* Bridge Panel Parameters */ + struct videomode vm; + u32 width_mm; + u32 height_mm; + u32 format; + u32 bpp; + + u8 num_dsi_lanes; + struct sn65dsi83_brg_funcs *funcs; +}; +struct sn65dsi83_brg *sn65dsi83_brg_get(void); + +#define I2C_DEVICE(A) &(A)->client->dev +#define I2C_CLIENT(A) (A)->client +#define VM(A) &(A)->vm +#define BPP(A) (A)->bpp +#define FORMAT(A) (A)->format +#define DSI_LANES(A) (A)->num_dsi_lanes + +/* The caller has to have a vm structure defined */ +#define PIXCLK vm->pixelclock +#define HACTIVE vm->hactive +#define HFP vm->hfront_porch +#define HBP vm->hback_porch +#define HPW vm->hsync_len +#define VACTIVE vm->vactive +#define VFP vm->vfront_porch +#define VBP vm->vback_porch +#define VPW vm->vsync_len +#define FLAGS vm->flags + +#define HIGH(A) (((A) >> 8) & 0xFF) +#define LOW(A) ((A) & 0xFF) + +#endif /* _SN65DSI83_BRG_H__ */ diff --git a/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_drv.c b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_drv.c new file mode 100644 index 000000000000..ec7d62cc3275 --- /dev/null +++ b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_drv.c @@ -0,0 +1,408 @@ +/* + * Licensed under the GPL-2. + */ + +#include <linux/device.h> +#include <linux/gpio/consumer.h> +#include <linux/module.h> +#include <linux/of.h> +#include <linux/of_device.h> +#include <linux/of_graph.h> +#include <linux/slab.h> + +#include <drm/drmP.h> +#include <drm/drm_atomic.h> +#include <drm/drm_atomic_helper.h> +#include <drm/drm_edid.h> +#include <drm/drm_mipi_dsi.h> +#include <drm/drm_connector.h> +#include <drm/drm_crtc_helper.h> +#include <video/mipi_display.h> +#include <video/of_videomode.h> +#include <video/videomode.h> + +#include "sn65dsi83_timing.h" +#include "sn65dsi83_brg.h" + +struct sn65dsi83 { + u8 channel_id; + enum drm_connector_status status; + bool powered; + struct drm_display_mode curr_mode; + struct drm_bridge bridge; + struct drm_connector connector; + struct device_node *host_node; + struct mipi_dsi_device *dsi; + struct sn65dsi83_brg *brg; +}; + +static int sn65dsi83_attach_dsi(struct sn65dsi83 *sn65dsi83); +#define DRM_DEVICE(A) A->dev->dev +/* Connector funcs */ +static struct sn65dsi83 *connector_to_sn65dsi83(struct drm_connector *connector) +{ + return container_of(connector, struct sn65dsi83, connector); +} + +static int sn65dsi83_connector_get_modes(struct drm_connector *connector) +{ + struct sn65dsi83 *sn65dsi83 = connector_to_sn65dsi83(connector); + struct sn65dsi83_brg *brg = sn65dsi83->brg; + struct device *dev = connector->dev->dev; + struct drm_display_mode *mode; + u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24; + u32 *bus_flags = &connector->display_info.bus_flags; + int ret; + + dev_info(dev, "%s\n",__func__); + mode = drm_mode_create(connector->dev); + if (!mode) { + DRM_DEV_ERROR(dev, "Failed to create display mode!\n"); + return 0; + } + + drm_display_mode_from_videomode(&brg->vm, mode); + mode->width_mm = brg->width_mm; + mode->height_mm = brg->height_mm; + mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED; + + drm_mode_probed_add(connector, mode); + drm_connector_list_update(connector); + + connector->display_info.width_mm = mode->width_mm; + connector->display_info.height_mm = mode->height_mm; + + if (brg->vm.flags & DISPLAY_FLAGS_DE_HIGH) + *bus_flags |= DRM_BUS_FLAG_DE_HIGH; + if (brg->vm.flags & DISPLAY_FLAGS_DE_LOW) + *bus_flags |= DRM_BUS_FLAG_DE_LOW; + if (brg->vm.flags & DISPLAY_FLAGS_PIXDATA_NEGEDGE) + *bus_flags |= DRM_BUS_FLAG_PIXDATA_NEGEDGE; + if (brg->vm.flags & DISPLAY_FLAGS_PIXDATA_POSEDGE) + *bus_flags |= DRM_BUS_FLAG_PIXDATA_POSEDGE; + + ret = drm_display_info_set_bus_formats(&connector->display_info, + &bus_format, 1); + if (ret) + return ret; + + return 1; +} + +static enum drm_mode_status +sn65dsi83_connector_mode_valid(struct drm_connector *connector, + struct drm_display_mode *mode) +{ + struct sn65dsi83 *sn65dsi83 = connector_to_sn65dsi83(connector); + struct device *dev = connector->dev->dev; + if (mode->clock > ( sn65dsi83->brg->vm.pixelclock / 1000 )) + return MODE_CLOCK_HIGH; + + dev_info(dev, "%s: mode: %d*%d@%d is valid\n",__func__, + mode->hdisplay,mode->vdisplay,mode->clock); + return MODE_OK; +} + +static struct drm_connector_helper_funcs sn65dsi83_connector_helper_funcs = { + .get_modes = sn65dsi83_connector_get_modes, + .mode_valid = sn65dsi83_connector_mode_valid, +}; + +static enum drm_connector_status +sn65dsi83_connector_detect(struct drm_connector *connector, bool force) +{ + struct sn65dsi83 *sn65dsi83 = connector_to_sn65dsi83(connector); + struct device *dev = connector->dev->dev; + enum drm_connector_status status; + dev_info(dev, "%s\n",__func__); + + status = connector_status_connected; + sn65dsi83->status = status; + return status; +} + +int drm_helper_probe_single_connector_modes(struct drm_connector *connector, + uint32_t maxX, uint32_t maxY); + +static struct drm_connector_funcs sn65dsi83_connector_funcs = { + .dpms = drm_helper_connector_dpms, + .fill_modes = drm_helper_probe_single_connector_modes, + .detect = sn65dsi83_connector_detect, + .destroy = drm_connector_cleanup, + .reset = drm_atomic_helper_connector_reset, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +/* Bridge funcs */ +static struct sn65dsi83 *bridge_to_sn65dsi83(struct drm_bridge *bridge) +{ + return container_of(bridge, struct sn65dsi83, bridge); +} + +static void sn65dsi83_bridge_enable(struct drm_bridge *bridge) +{ + struct sn65dsi83 *sn65dsi83 = bridge_to_sn65dsi83(bridge); + dev_info(DRM_DEVICE(bridge),"%s\n",__func__); + sn65dsi83->brg->funcs->setup(sn65dsi83->brg); + sn65dsi83->brg->funcs->start_stream(sn65dsi83->brg); +} + +static void sn65dsi83_bridge_disable(struct drm_bridge *bridge) +{ + struct sn65dsi83 *sn65dsi83 = bridge_to_sn65dsi83(bridge); + dev_info(DRM_DEVICE(bridge),"%s\n",__func__); + sn65dsi83->brg->funcs->stop_stream(sn65dsi83->brg); + sn65dsi83->brg->funcs->power_off(sn65dsi83->brg); +} + +static void sn65dsi83_bridge_mode_set(struct drm_bridge *bridge, + const struct drm_display_mode *mode, + const struct drm_display_mode *adj_mode) +{ + struct sn65dsi83 *sn65dsi83 = bridge_to_sn65dsi83(bridge); + dev_info(DRM_DEVICE(bridge), "%s: mode: %d*%d@%d\n",__func__, + mode->hdisplay,mode->vdisplay,mode->clock); + drm_mode_copy(&sn65dsi83->curr_mode, adj_mode); +} + +static int sn65dsi83_bridge_attach(struct drm_bridge *bridge) +{ + struct sn65dsi83 *sn65dsi83 = bridge_to_sn65dsi83(bridge); + int ret; + + dev_info(DRM_DEVICE(bridge),"%s\n",__func__); + if (!bridge->encoder) { + DRM_ERROR("Parent encoder object not found"); + return -ENODEV; + } + + sn65dsi83->connector.polled = DRM_CONNECTOR_POLL_CONNECT; + + ret = drm_connector_init(bridge->dev, &sn65dsi83->connector, + &sn65dsi83_connector_funcs, + DRM_MODE_CONNECTOR_DSI); + if (ret) { + DRM_ERROR("Failed to initialize connector with drm\n"); + return ret; + } + drm_connector_helper_add(&sn65dsi83->connector, + &sn65dsi83_connector_helper_funcs); + drm_connector_attach_encoder(&sn65dsi83->connector, bridge->encoder); + + ret = sn65dsi83_attach_dsi(sn65dsi83); + + return ret; +} + +static struct drm_bridge_funcs sn65dsi83_bridge_funcs = { + .enable = sn65dsi83_bridge_enable, + .disable = sn65dsi83_bridge_disable, + .mode_set = sn65dsi83_bridge_mode_set, + .attach = sn65dsi83_bridge_attach, +}; + +static int sn65dsi83_parse_dt(struct device_node *np, + struct sn65dsi83 *sn65dsi83) +{ + struct device *dev = &sn65dsi83->brg->client->dev; + u32 num_lanes = 2, bpp = 24, format = 2, width = 149, height = 93; + struct device_node *endpoint; + + endpoint = of_graph_get_next_endpoint(np, NULL); + if (!endpoint) + return -ENODEV; + + sn65dsi83->host_node = of_graph_get_remote_port_parent(endpoint); + if (!sn65dsi83->host_node) { + of_node_put(endpoint); + return -ENODEV; + } + + of_property_read_u32(np, "ti,dsi-lanes", &num_lanes); + of_property_read_u32(np, "ti,lvds-format", &format); + of_property_read_u32(np, "ti,lvds-bpp", &bpp); + of_property_read_u32(np, "ti,width-mm", &width); + of_property_read_u32(np, "ti,height-mm", &height); + + if (num_lanes < 1 || num_lanes > 4) { + dev_err(dev, "Invalid dsi-lanes: %d\n", num_lanes); + return -EINVAL; + } + sn65dsi83->brg->num_dsi_lanes = num_lanes; + + sn65dsi83->brg->gpio_enable = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW); + if (IS_ERR(sn65dsi83->brg->gpio_enable)) { + dev_err(dev, "failed to parse enable gpio"); + return PTR_ERR(sn65dsi83->brg->gpio_enable); + } + + sn65dsi83->brg->format = format; + sn65dsi83->brg->bpp = bpp; + + sn65dsi83->brg->width_mm = width; + sn65dsi83->brg->height_mm = height; + + /* Read default timing if there is not device tree node for */ + if ((of_get_videomode(np, &sn65dsi83->brg->vm, 0)) < 0) + videomode_from_timing(&panel_default_timing, &sn65dsi83->brg->vm); + + of_node_put(endpoint); + of_node_put(sn65dsi83->host_node); + + return 0; +} + +static int sn65dsi83_probe(struct i2c_client *i2c, + const struct i2c_device_id *id) +{ + struct sn65dsi83 *sn65dsi83; + struct device *dev = &i2c->dev; + int ret; + + dev_info(dev,"%s\n",__func__); + if (!dev->of_node) + return -EINVAL; + + sn65dsi83 = devm_kzalloc(dev, sizeof(*sn65dsi83), GFP_KERNEL); + if (!sn65dsi83) + return -ENOMEM; + + /* Initialize it before DT parser */ + sn65dsi83->brg = sn65dsi83_brg_get(); + sn65dsi83->brg->client = i2c; + + sn65dsi83->powered = false; + sn65dsi83->status = connector_status_disconnected; + + i2c_set_clientdata(i2c, sn65dsi83); + + ret = sn65dsi83_parse_dt(dev->of_node, sn65dsi83); + if (ret) + return ret; + + sn65dsi83->brg->funcs->power_off(sn65dsi83->brg); + sn65dsi83->brg->funcs->power_on(sn65dsi83->brg); + ret = sn65dsi83->brg->funcs->reset(sn65dsi83->brg); + if (ret != 0x00) { + dev_err(dev, "Failed to reset the device"); + return -ENODEV; + } + sn65dsi83->brg->funcs->power_off(sn65dsi83->brg); + + + sn65dsi83->bridge.funcs = &sn65dsi83_bridge_funcs; + sn65dsi83->bridge.of_node = dev->of_node; + + drm_bridge_add(&sn65dsi83->bridge); + + return ret; +} + +static int sn65dsi83_attach_dsi(struct sn65dsi83 *sn65dsi83) +{ + struct device *dev = &sn65dsi83->brg->client->dev; + struct mipi_dsi_host *host; + struct mipi_dsi_device *dsi; + int ret = 0; + const struct mipi_dsi_device_info info = { .type = "sn65dsi83", + .channel = 0, + .node = NULL, + }; + + dev_info(dev, "%s\n",__func__); + host = of_find_mipi_dsi_host_by_node(sn65dsi83->host_node); + if (!host) { + dev_err(dev, "failed to find dsi host\n"); + return -EPROBE_DEFER; + } + + dsi = mipi_dsi_device_register_full(host, &info); + if (IS_ERR(dsi)) { + dev_err(dev, "failed to create dsi device\n"); + ret = PTR_ERR(dsi); + return -ENODEV; + } + + sn65dsi83->dsi = dsi; + + dsi->lanes = sn65dsi83->brg->num_dsi_lanes; + dsi->format = MIPI_DSI_FMT_RGB888; + dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_BURST; + + ret = mipi_dsi_attach(dsi); + if (ret < 0) { + dev_err(dev, "failed to attach dsi to host\n"); + mipi_dsi_device_unregister(dsi); + } + + return ret; +} + +static void sn65dsi83_detach_dsi(struct sn65dsi83 *sn65dsi83) +{ + struct device *dev = &sn65dsi83->brg->client->dev; + dev_info(dev, "%s\n",__func__); + mipi_dsi_detach(sn65dsi83->dsi); + mipi_dsi_device_unregister(sn65dsi83->dsi); +} + +static int sn65dsi83_remove(struct i2c_client *i2c) +{ + struct sn65dsi83 *sn65dsi83 = i2c_get_clientdata(i2c); + struct device *dev = &sn65dsi83->brg->client->dev; + dev_info(dev, "%s\n",__func__); + + sn65dsi83_detach_dsi(sn65dsi83); + drm_bridge_remove(&sn65dsi83->bridge); + + return 0; +} + +static const struct i2c_device_id sn65dsi83_i2c_ids[] = { + { "sn65dsi83", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, sn65dsi83_i2c_ids); + +static const struct of_device_id sn65dsi83_of_ids[] = { + { .compatible = "ti,sn65dsi83" }, + { } +}; +MODULE_DEVICE_TABLE(of, sn65dsi83_of_ids); + +static struct mipi_dsi_driver sn65dsi83_dsi_driver = { + .driver.name = "sn65dsi83", +}; + +static struct i2c_driver sn65dsi83_driver = { + .driver = { + .name = "sn65dsi83", + .of_match_table = sn65dsi83_of_ids, + }, + .id_table = sn65dsi83_i2c_ids, + .probe = sn65dsi83_probe, + .remove = sn65dsi83_remove, +}; + +static int __init sn65dsi83_init(void) +{ + if (IS_ENABLED(CONFIG_DRM_MIPI_DSI)) + mipi_dsi_driver_register(&sn65dsi83_dsi_driver); + + return i2c_add_driver(&sn65dsi83_driver); +} +module_init(sn65dsi83_init); + +static void __exit sn65dsi83_exit(void) +{ + i2c_del_driver(&sn65dsi83_driver); + + if (IS_ENABLED(CONFIG_DRM_MIPI_DSI)) + mipi_dsi_driver_unregister(&sn65dsi83_dsi_driver); +} +module_exit(sn65dsi83_exit); + +MODULE_AUTHOR("CompuLab <compulab@compula.co.il>"); +MODULE_DESCRIPTION("SN65DSI bridge driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_timing.h b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_timing.h new file mode 100644 index 000000000000..e9bb6633c376 --- /dev/null +++ b/drivers/gpu/drm/bridge/sn65dsi83/sn65dsi83_timing.h @@ -0,0 +1,33 @@ +#ifndef __SN65DSI83_TIMING_H__ +#define __SN65DSI83_TIMING_H__ + +/* Default Video Parameters */ +#define PIXCLK_INIT 62500000 + +#define HACTIVE_INIT 1280 +#define HPW_INIT 2 +#define HBP_INIT 6 +#define HFP_INIT 5 + +#define VACTIVE_INIT 800 +#define VPW_INIT 1 +#define VBP_INIT 2 +#define VFP_INIT 3 + +static const struct display_timing panel_default_timing = { + .pixelclock = { PIXCLK_INIT, PIXCLK_INIT, PIXCLK_INIT }, + .hactive = { HACTIVE_INIT, HACTIVE_INIT, HACTIVE_INIT }, + .hfront_porch = { HFP_INIT, HFP_INIT, HFP_INIT }, + .hsync_len = { HPW_INIT, HPW_INIT, HPW_INIT }, + .hback_porch = { HBP_INIT, HBP_INIT, HBP_INIT }, + .vactive = { VACTIVE_INIT, VACTIVE_INIT, VACTIVE_INIT }, + .vfront_porch = { VFP_INIT, VFP_INIT, VFP_INIT }, + .vsync_len = { VPW_INIT, VPW_INIT, VPW_INIT }, + .vback_porch = { VBP_INIT, VBP_INIT, VBP_INIT }, + .flags = DISPLAY_FLAGS_HSYNC_LOW | + DISPLAY_FLAGS_VSYNC_LOW | + DISPLAY_FLAGS_DE_LOW | + DISPLAY_FLAGS_PIXDATA_NEGEDGE, +}; + +#endif /* __SN65DSI83_TIMING_H__ */ |