// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2018, The Linux Foundation. All rights reserved. * Copyright (c) 2019. Linaro Ltd */ #define DEBUG #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define EDID_SEG_SIZE 256 #define LT9611_4LANES 0 struct lt9611 { struct device *dev; struct drm_bridge bridge; struct drm_connector connector; struct regmap *regmap; struct device_node *dsi0_node; struct device_node *dsi1_node; struct mipi_dsi_device *dsi0; struct mipi_dsi_device *dsi1; bool ac_mode; struct gpio_desc *reset_gpio; struct gpio_desc *enable_gpio; bool power_on; struct regulator_bulk_data supplies[2]; struct i2c_client *client; enum drm_connector_status status; u8 edid_buf[EDID_SEG_SIZE]; u32 vic; }; static const struct regmap_config lt9611_regmap_config = { .reg_bits = 8, .val_bits = 8, .cache_type = REGCACHE_NONE, }; struct lt9611_mode { u16 hdisplay; u16 vdisplay; u8 fps; u8 lanes; u8 intfs; }; static struct lt9611_mode lt9611_modes[] = { { 3840, 2160, 30, 4, 2 }, /* 3840x2160 24bit 30Hz 4Lane 2ports */ { 1920, 1080, 60, 4, 1 }, /* 1080P 24bit 60Hz 4lane 1port */ { 1920, 1080, 30, 3, 1 }, /* 1080P 24bit 30Hz 3lane 1port */ { 1920, 1080, 24, 3, 1 }, { 720, 480, 60, 4, 1 }, { 720, 576, 50, 2, 1 }, { 640, 480, 60, 2, 1 }, }; static struct lt9611 *bridge_to_lt9611(struct drm_bridge *bridge) { return container_of(bridge, struct lt9611, bridge); } static struct lt9611 *connector_to_lt9611(struct drm_connector *connector) { return container_of(connector, struct lt9611, connector); } static int lt9611_mipi_input_analog(struct lt9611 *lt9611) { struct reg_sequence reg_cfg[] = { { 0xff, 0x81 }, { 0x06, 0x40 }, /*port A rx current*/ { 0x0a, 0xfe }, /*port A ldo voltage set*/ { 0x0b, 0xbf }, /*enable port A lprx*/ { 0x11, 0x40 }, /*port B rx current*/ { 0x15, 0xfe }, /*port B ldo voltage set*/ { 0x16, 0xbf }, /*enable port B lprx*/ { 0x1c, 0x03 }, /*PortA clk lane no-LP mode*/ { 0x20, 0x03 }, /*PortB clk lane with-LP mode*/ }; regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); return 0; } static int lt9611_mipi_input_digital(struct lt9611 *lt9611, const struct drm_display_mode *mode) { struct reg_sequence reg_cfg[] = { { 0xff, 0x82 }, { 0x4f, 0x80 }, { 0x50, 0x10 }, { 0xff, 0x83 }, { 0x02, 0x0a }, { 0x06, 0x0a }, }; regmap_write(lt9611->regmap, 0xff, 0x83); regmap_write(lt9611->regmap, 0x00, LT9611_4LANES); if (mode->hdisplay == 3840) regmap_write(lt9611->regmap, 0x0a, 0x03); else regmap_write(lt9611->regmap, 0x0a, 0x00); regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); return 0; } static void lt9611_mipi_video_setup(struct lt9611 *lt9611, const struct drm_display_mode *mode) { u32 h_total, h_act, hpw, hfp, hss; u32 v_total, v_act, vpw, vfp, vss; h_total = mode->htotal; v_total = mode->vtotal; h_act = mode->hdisplay; hpw = mode->hsync_end - mode->hsync_start; hfp = mode->hsync_start - mode->hdisplay; hss = (mode->hsync_end - mode->hsync_start) + (mode->htotal - mode->hsync_end); v_act = mode->vdisplay; vpw = mode->vsync_end - mode->vsync_start; vfp = mode->vsync_start - mode->vdisplay; vss = (mode->vsync_end - mode->vsync_start) + (mode->vtotal - mode->vsync_end); regmap_write(lt9611->regmap, 0xff, 0x83); regmap_write(lt9611->regmap, 0x0d, (u8)(v_total / 256)); regmap_write(lt9611->regmap, 0x0e, (u8)(v_total % 256)); regmap_write(lt9611->regmap, 0x0f, (u8)(v_act / 256)); regmap_write(lt9611->regmap, 0x10, (u8)(v_act % 256)); regmap_write(lt9611->regmap, 0x11, (u8)(h_total / 256)); regmap_write(lt9611->regmap, 0x12, (u8)(h_total % 256)); regmap_write(lt9611->regmap, 0x13, (u8)(h_act / 256)); regmap_write(lt9611->regmap, 0x14, (u8)(h_act % 256)); regmap_write(lt9611->regmap, 0x15, (u8)(vpw % 256)); regmap_write(lt9611->regmap, 0x16, (u8)(hpw % 256)); regmap_write(lt9611->regmap, 0x17, (u8)(vfp % 256)); regmap_write(lt9611->regmap, 0x18, (u8)(vss % 256)); regmap_write(lt9611->regmap, 0x19, (u8)(hfp % 256)); regmap_write(lt9611->regmap, 0x1a, (u8)(hss / 256)); regmap_write(lt9611->regmap, 0x1b, (u8)(hss % 256)); } static int lt9611_pcr_setup(struct lt9611 *lt9611, const struct drm_display_mode *mode) { struct reg_sequence reg_cfg[] = { { 0xff, 0x83 }, { 0x0b, 0x01 }, { 0x0c, 0x10 }, { 0x48, 0x00 }, { 0x49, 0x81 }, /* stage 1 */ { 0x21, 0x4a }, { 0x24, 0x71 }, { 0x25, 0x30 }, { 0x2a, 0x01 }, /* stage 2 */ { 0x4a, 0x40 }, { 0x1d, 0x10 }, /* MK limit */ { 0x2d, 0x38 }, { 0x31, 0x08 }, }; regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); switch (mode->hdisplay) { case 640: regmap_write(lt9611->regmap, 0x26, 0x14); break; case 1920: regmap_write(lt9611->regmap, 0x26, 0x37); break; case 3840: regmap_write(lt9611->regmap, 0x0b, 0x03); regmap_write(lt9611->regmap, 0x0c, 0xd0); regmap_write(lt9611->regmap, 0x48, 0x03); regmap_write(lt9611->regmap, 0x49, 0xe0); regmap_write(lt9611->regmap, 0x24, 0x72); regmap_write(lt9611->regmap, 0x25, 0x00); regmap_write(lt9611->regmap, 0x2a, 0x01); regmap_write(lt9611->regmap, 0x4a, 0x10); regmap_write(lt9611->regmap, 0x1d, 0x10); regmap_write(lt9611->regmap, 0x26, 0x37); break; } /* pcr rst */ regmap_write(lt9611->regmap, 0xff, 0x80); regmap_write(lt9611->regmap, 0x11, 0x5a); regmap_write(lt9611->regmap, 0x11, 0xfa); return 0; } static int lt9611_pll_setup(struct lt9611 *lt9611, const struct drm_display_mode *mode) { unsigned int pclk = mode->clock; struct reg_sequence reg_cfg[] = { /* txpll init */ { 0xff, 0x81 }, { 0x23, 0x40 }, { 0x24, 0x64 }, { 0x25, 0x80 }, { 0x26, 0x55 }, { 0x2c, 0x37 }, { 0x2f, 0x01 }, { 0x26, 0x55 }, { 0x27, 0x66 }, { 0x28, 0x88 }, }; regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); if (pclk > 150000) regmap_write(lt9611->regmap, 0x2d, 0x88); else if (pclk > 70000) regmap_write(lt9611->regmap, 0x2d, 0x99); else regmap_write(lt9611->regmap, 0x2d, 0xaa); regmap_write(lt9611->regmap, 0xff, 0x82); regmap_write(lt9611->regmap, 0xe3, pclk >> 17); /* pclk[19:16] */ regmap_write(lt9611->regmap, 0xe4, pclk >> 9); /* pclk[15:8] */ regmap_write(lt9611->regmap, 0xe5, pclk >> 1); /* pclk[7:0] */ regmap_write(lt9611->regmap, 0xde, 0x20); regmap_write(lt9611->regmap, 0xde, 0xe0); regmap_write(lt9611->regmap, 0xff, 0x80); regmap_write(lt9611->regmap, 0x16, 0xf1); regmap_write(lt9611->regmap, 0x16, 0xf3); return 0; } static int lt9611_video_check(struct lt9611 *lt9611) { u32 v_total, v_act, h_act_a, h_act_b, h_total_sysclk; unsigned int temp; int ret; /* top module video check */ regmap_write(lt9611->regmap, 0xff, 0x82); /* v_act */ ret = regmap_read(lt9611->regmap, 0x82, &temp); if (ret) goto end; v_act = temp << 8; ret = regmap_read(lt9611->regmap, 0x83, &temp); if (ret) goto end; v_act = v_act + temp; /* v_total */ ret = regmap_read(lt9611->regmap, 0x6c, &temp); if (ret) goto end; v_total = temp << 8; ret = regmap_read(lt9611->regmap, 0x6d, &temp); if (ret) goto end; v_total = v_total + temp; /* h_total_sysclk */ ret = regmap_read(lt9611->regmap, 0x86, &temp); if (ret) goto end; h_total_sysclk = temp << 8; ret = regmap_read(lt9611->regmap, 0x87, &temp); if (ret) goto end; h_total_sysclk = h_total_sysclk + temp; /* h_act_a */ regmap_write(lt9611->regmap, 0xff, 0x83); ret = regmap_read(lt9611->regmap, 0x82, &temp); if (ret) goto end; h_act_a = temp << 8; ret = regmap_read(lt9611->regmap, 0x83, &temp); if (ret) goto end; h_act_a = (h_act_a + temp)/3; /* h_act_b */ regmap_write(lt9611->regmap, 0xff, 0x83); ret = regmap_read(lt9611->regmap, 0x86, &temp); if (ret) goto end; h_act_b = temp << 8; ret = regmap_read(lt9611->regmap, 0x87, &temp); if (ret) goto end; h_act_b = (h_act_b + temp)/3; dev_info(lt9611->dev, "video check: h_act_a=%d, h_act_b=%d, v_act=%d, v_total=%d, h_total_sysclk=%d\n", h_act_a, h_act_b, v_act, v_total, h_total_sysclk); return 0; end: dev_err(lt9611->dev, "read video check error\n"); return ret; } static void lt9611_hdmi_tx_digital(struct lt9611 *lt9611) { regmap_write(lt9611->regmap, 0xff, 0x84); regmap_write(lt9611->regmap, 0x43, 0x46 - lt9611->vic); regmap_write(lt9611->regmap, 0x44, 0x84); regmap_write(lt9611->regmap, 0x47, lt9611->vic); regmap_write(lt9611->regmap, 0xff, 0x82); regmap_write(lt9611->regmap, 0xd6, 0x8c); regmap_write(lt9611->regmap, 0xd7, 0x04); } static void lt9611_hdmi_tx_phy(struct lt9611 *lt9611) { struct reg_sequence reg_cfg[] = { { 0xff, 0x81 }, { 0x30, 0x6a }, { 0x31, 0x44 }, /* HDMI DC mode */ { 0x32, 0x4a }, { 0x33, 0x0b }, { 0x34, 0x00 }, { 0x35, 0x00 }, { 0x36, 0x00 }, { 0x37, 0x44 }, { 0x3f, 0x0f }, { 0x40, 0xa0 }, { 0x41, 0xa0 }, { 0x42, 0xa0 }, { 0x43, 0xa0 }, { 0x44, 0x0a }, }; /* HDMI AC mode */ if (lt9611->ac_mode) reg_cfg[2].def = 0x73; regmap_multi_reg_write(lt9611->regmap, reg_cfg, ARRAY_SIZE(reg_cfg)); } static irqreturn_t lt9611_irq_thread_handler(int irq, void *dev_id) { struct lt9611 *lt9611 = dev_id; unsigned int irq_flag0 = 0; unsigned int irq_flag3 = 0; regmap_write(lt9611->regmap, 0xff, 0x82); regmap_read(lt9611->regmap, 0x0f, &irq_flag3); regmap_read(lt9611->regmap, 0x0c, &irq_flag0); printk(KERN_ERR "%s() irq_flag0: %#x irq_flag3: %#x\n", __func__, irq_flag0, irq_flag3); /* hpd changed low */ if (irq_flag3 & 0x80) { dev_info(lt9611->dev, "hdmi cable disconnected\n"); regmap_write(lt9611->regmap, 0xff, 0x82); /* irq 3 clear flag */ regmap_write(lt9611->regmap, 0x07, 0xbf); regmap_write(lt9611->regmap, 0x07, 0x3f); } /* hpd changed high */ if (irq_flag3 & 0x40) { dev_info(lt9611->dev, "hdmi cable connected\n"); regmap_write(lt9611->regmap, 0xff, 0x82); /* irq 3 clear flag */ regmap_write(lt9611->regmap, 0x07, 0x7f); regmap_write(lt9611->regmap, 0x07, 0x3f); } // if (irq_flag3 & 0xc0) // drm_kms_helper_hotplug_event(lt9611->bridge.dev); /* video input changed */ if (irq_flag0 & 0x01) { dev_info(lt9611->dev, "video input changed\n"); regmap_write(lt9611->regmap, 0xff, 0x82); /* irq 0 clear flag */ regmap_write(lt9611->regmap, 0x9e, 0xff); regmap_write(lt9611->regmap, 0x9e, 0xf7); regmap_write(lt9611->regmap, 0x04, 0xff); regmap_write(lt9611->regmap, 0x04, 0xfe); } return IRQ_HANDLED; } static void lt9611_enable_hpd_interrupts(struct lt9611 *lt9611) { unsigned int val; dev_dbg(lt9611->dev, "enabling hpd interrupts\n"); regmap_write(lt9611->regmap, 0xff, 0x82); regmap_read(lt9611->regmap, 0x03, &val); val &= ~0xc0; regmap_write(lt9611->regmap, 0x03, val); regmap_write(lt9611->regmap, 0x07, 0xff); //clear regmap_write(lt9611->regmap, 0x07, 0x3f); } static int lt9611_power_on(struct lt9611 *lt9611) { int ret; const struct reg_sequence seq[] = { /* LT9611_System_Init */ { 0xFF, 0x81 }, { 0x01, 0x18 }, /* sel xtal clock */ /* timer for frequency meter */ { 0xff, 0x82 }, { 0x1b, 0x69 }, /*timer 2*/ { 0x1c, 0x78 }, { 0xcb, 0x69 }, /*timer 1 */ { 0xcc, 0x78 }, /* irq init */ { 0xff, 0x82 }, { 0x51, 0x01 }, { 0x58, 0x0a }, /* hpd irq */ { 0x59, 0x80 }, /* hpd debounce width */ { 0x9e, 0xf7 }, /* video check irq */ /* power consumption for work */ { 0xff, 0x80 }, { 0x04, 0xf0 }, { 0x06, 0xf0 }, { 0x0a, 0x80 }, { 0x0b, 0x40 }, { 0x0d, 0xef }, { 0x11, 0xfa }, }; if (lt9611->power_on) return 0; dev_dbg(lt9611->dev, "power on\n"); ret = regmap_multi_reg_write(lt9611->regmap, seq, ARRAY_SIZE(seq)); if (!ret) lt9611->power_on = true; return ret; } static int lt9611_power_off(struct lt9611 *lt9611) { int ret; const struct reg_sequence off[] = { { 0xff, 0x81 }, { 0x30, 0x6a }, }; dev_dbg(lt9611->dev, "power off\n"); ret = regmap_multi_reg_write(lt9611->regmap, off, ARRAY_SIZE(off)); if (!ret) lt9611->power_on = false; return ret; } static void lt9611_i2s_init(struct lt9611 *lt9611) { const struct reg_sequence init[] = { { 0xff, 0x82 }, { 0xd6, 0x8c }, { 0xd7, 0x04 }, { 0xff, 0x84 }, { 0x06, 0x08 }, { 0x07, 0x10 }, { 0x34, 0xd4 }, }; regmap_multi_reg_write(lt9611->regmap, init, ARRAY_SIZE(init)); } static void lt9611_reset(struct lt9611 *lt9611) { gpiod_set_value_cansleep(lt9611->reset_gpio, 1); msleep(20); gpiod_set_value_cansleep(lt9611->reset_gpio, 0); msleep(20); gpiod_set_value_cansleep(lt9611->reset_gpio, 1); msleep(100); } static void lt9611_assert_5v(struct lt9611 *lt9611) { if (!lt9611->enable_gpio) return; gpiod_set_value_cansleep(lt9611->enable_gpio, 1); msleep(20); } static int lt9611_regulator_init(struct lt9611 *lt9611) { int ret; lt9611->supplies[0].supply = "vdd"; lt9611->supplies[1].supply = "vcc"; ret = devm_regulator_bulk_get(lt9611->dev, 2, lt9611->supplies); if (ret < 0) return ret; return regulator_set_load(lt9611->supplies[0].consumer, 300000); } static int lt9611_regulator_enable(struct lt9611 *lt9611) { int ret; ret = regulator_enable(lt9611->supplies[0].consumer); if (ret < 0) return ret; usleep_range(1000, 10000); ret = regulator_enable(lt9611->supplies[1].consumer); if (ret < 0) { regulator_disable(lt9611->supplies[0].consumer); return ret; } return 0; } static struct lt9611_mode *lt9611_find_mode(const struct drm_display_mode *mode) { int i; for (i = 0; i < ARRAY_SIZE(lt9611_modes); i++) { if (lt9611_modes[i].hdisplay == mode->hdisplay && lt9611_modes[i].vdisplay == mode->vdisplay && lt9611_modes[i].fps == drm_mode_vrefresh(mode)) { return <9611_modes[i]; } } return NULL; } /* connector funcs */ static enum drm_connector_status lt9611_connector_detect(struct drm_connector *connector, bool force) { struct lt9611 *lt9611 = connector_to_lt9611(connector); unsigned int reg_val = 0; int connected = 0; regmap_write(lt9611->regmap, 0xff, 0x82); regmap_read(lt9611->regmap, 0x5e, ®_val); connected = (reg_val & BIT(2)); dev_dbg(lt9611->dev, "connected = %x\n", connected); lt9611->status = connected ? connector_status_connected : connector_status_disconnected; return lt9611->status; } static int lt9611_read_edid(struct lt9611 *lt9611) { unsigned int temp; int ret = 0; int i, j; memset(lt9611->edid_buf, 0, EDID_SEG_SIZE); regmap_write(lt9611->regmap, 0xff, 0x85); regmap_write(lt9611->regmap, 0x03, 0xc9); regmap_write(lt9611->regmap, 0x04, 0xa0); /* 0xA0 is EDID device address */ regmap_write(lt9611->regmap, 0x05, 0x00); /* 0x00 is EDID offset address */ regmap_write(lt9611->regmap, 0x06, 0x20); /* length for read */ regmap_write(lt9611->regmap, 0x14, 0x7f); for (i = 0 ; i < 8 ; i++) { regmap_write(lt9611->regmap, 0x05, i * 32); /* offset address */ regmap_write(lt9611->regmap, 0x07, 0x36); regmap_write(lt9611->regmap, 0x07, 0x31); regmap_write(lt9611->regmap, 0x07, 0x37); usleep_range(5000, 10000); regmap_read(lt9611->regmap, 0x40, &temp); if (temp & 0x02) { /*KEY_DDC_ACCS_DONE=1*/ for (j = 0; j < 32; j++) { regmap_read(lt9611->regmap, 0x83, &temp); lt9611->edid_buf[i*32+j] = temp; } } else if (temp & 0x50) { /* DDC No Ack or Abitration lost */ dev_err(lt9611->dev, "read edid failed: no ack\n"); ret = -EIO; goto end; } else { dev_err(lt9611->dev, "read edid failed: access not done\n"); ret = -EIO; goto end; } } dev_dbg(lt9611->dev, "read edid succeeded, checksum = 0x%x\n", lt9611->edid_buf[255]); end: regmap_write(lt9611->regmap, 0x07, 0x1f); return ret; } /* TODO: add support for more extenstion blocks */ static int lt9611_get_edid_block(void *data, u8 *buf, unsigned int block, size_t len) { struct lt9611 *lt9611 = data; int ret; dev_dbg(lt9611->dev, "get edid block: block=%d, len=%d\n", block, (int)len); if (len > 128) return -EINVAL; /* support up to 1 extension block */ if (block > 1) return -EINVAL; if (block == 0) { /* always read 2 edid blocks once */ ret = lt9611_read_edid(lt9611); if (ret) { dev_err(lt9611->dev, "edid read failed\n"); return ret; } } if (block % 2 == 0) memcpy(buf, lt9611->edid_buf, len); else memcpy(buf, lt9611->edid_buf + 128, len); return 0; } static int lt9611_connector_get_modes(struct drm_connector *connector) { struct lt9611 *lt9611 = connector_to_lt9611(connector); unsigned int count; struct edid *edid; dev_dbg(lt9611->dev, "get modes\n"); lt9611_power_on(lt9611); edid = drm_do_get_edid(connector, lt9611_get_edid_block, lt9611); drm_connector_update_edid_property(connector, edid); count = drm_add_edid_modes(connector, edid); kfree(edid); return count; } static enum drm_mode_status lt9611_connector_mode_valid( struct drm_connector *connector, struct drm_display_mode *mode) { struct lt9611_mode *lt9611_mode = lt9611_find_mode(mode); return lt9611_mode ? MODE_OK : MODE_BAD; } /* bridge funcs */ static void lt9611_bridge_enable(struct drm_bridge *bridge) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); const struct reg_sequence on[] = { { 0xff, 0x81 }, { 0x30, 0xea }, }; dev_dbg(lt9611->dev, "bridge enable\n"); if (lt9611_power_on(lt9611)) { dev_err(lt9611->dev, "power on failed\n"); return; } dev_dbg(lt9611->dev, "video on\n"); lt9611_mipi_input_analog(lt9611); lt9611_hdmi_tx_digital(lt9611); lt9611_hdmi_tx_phy(lt9611); msleep(500); lt9611_video_check(lt9611); /* Enable HDMI output */ regmap_multi_reg_write(lt9611->regmap, on, ARRAY_SIZE(on)); } static void lt9611_bridge_disable(struct drm_bridge *bridge) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); int ret; const struct reg_sequence hdmi_off[] = { { 0xff, 0x81 }, { 0x30, 0x6a }, }; dev_dbg(lt9611->dev, "bridge disable\n"); /* Disable HDMI output */ ret = regmap_multi_reg_write(lt9611->regmap, hdmi_off, ARRAY_SIZE(hdmi_off)); if (ret) { dev_err(lt9611->dev, "video on failed\n"); return; } if (lt9611_power_off(lt9611)) { dev_err(lt9611->dev, "power on failed\n"); return; } } static struct drm_connector_helper_funcs lt9611_bridge_connector_helper_funcs = { .get_modes = lt9611_connector_get_modes, .mode_valid = lt9611_connector_mode_valid, }; static const struct drm_connector_funcs lt9611_bridge_connector_funcs = { .fill_modes = drm_helper_probe_single_connector_modes, .detect = lt9611_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, }; static struct mipi_dsi_device *lt9611_attach_dsi(struct lt9611 *lt9611, struct device_node *dsi_node) { const struct mipi_dsi_device_info info = { "lt9611", 0, NULL }; struct mipi_dsi_device *dsi; struct mipi_dsi_host *host; int ret; host = of_find_mipi_dsi_host_by_node(dsi_node); if (!host) { dev_err(lt9611->dev, "failed to find dsi host\n"); return ERR_PTR(-EPROBE_DEFER); } dsi = mipi_dsi_device_register_full(host, &info); if (IS_ERR(dsi)) { dev_err(lt9611->dev, "failed to create dsi device\n"); return dsi; } dsi->lanes = 4; dsi->format = MIPI_DSI_FMT_RGB888; dsi->mode_flags = MIPI_DSI_MODE_VIDEO | MIPI_DSI_MODE_VIDEO_SYNC_PULSE | MIPI_DSI_MODE_VIDEO_HSE; ret = mipi_dsi_attach(dsi); if (ret < 0) { dev_err(lt9611->dev, "failed to attach dsi to host\n"); mipi_dsi_device_unregister(dsi); return ERR_PTR(ret); } return dsi; } static int lt9611_bridge_attach(struct drm_bridge *bridge) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); int ret; dev_dbg(lt9611->dev, "bridge attach\n"); ret = drm_connector_init(bridge->dev, <9611->connector, <9611_bridge_connector_funcs, DRM_MODE_CONNECTOR_HDMIA); if (ret) { DRM_ERROR("Failed to initialize connector with drm\n"); return ret; } drm_connector_helper_add(<9611->connector, <9611_bridge_connector_helper_funcs); drm_connector_attach_encoder(<9611->connector, bridge->encoder); if (!bridge->encoder) { DRM_ERROR("Parent encoder object not found"); return -ENODEV; } /* Attach primary DSI */ lt9611->dsi0 = lt9611_attach_dsi(lt9611, lt9611->dsi0_node); if (IS_ERR(lt9611->dsi0)) return PTR_ERR(lt9611->dsi0); /* Attach secondary DSI, if specified */ if (lt9611->dsi1_node) { lt9611->dsi1 = lt9611_attach_dsi(lt9611, lt9611->dsi1_node); if (IS_ERR(lt9611->dsi1)) { ret = PTR_ERR(lt9611->dsi1); goto err_unregister_dsi0; } } return 0; err_unregister_dsi0: mipi_dsi_device_unregister(lt9611->dsi0); return ret; } static void lt9611_bridge_detach(struct drm_bridge *bridge) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); if (lt9611->dsi1) { mipi_dsi_detach(lt9611->dsi1); mipi_dsi_device_unregister(lt9611->dsi1); } mipi_dsi_detach(lt9611->dsi0); mipi_dsi_device_unregister(lt9611->dsi0); } static enum drm_mode_status lt9611_bridge_mode_valid(struct drm_bridge *bridge, const struct drm_display_mode *mode) { struct lt9611_mode *lt9611_mode = lt9611_find_mode(mode); struct lt9611 *lt9611 = bridge_to_lt9611(bridge); if (lt9611_mode->intfs > 1 && !lt9611->dsi1) return MODE_PANEL; else return MODE_OK; } static void lt9611_bridge_pre_enable(struct drm_bridge *bridge) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); dev_dbg(lt9611->dev, "bridge pre_enable\n"); regmap_write(lt9611->regmap, 0xff, 0x80); regmap_write(lt9611->regmap, 0xee, 0x01); } static void lt9611_bridge_post_disable(struct drm_bridge *bridge) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); dev_dbg(lt9611->dev, "bridge post_disable\n"); /* TODO: We still need to figure out how to best put the * hardware to sleep while still allowing hotplug * detection to work here. -jstultz */ } static void lt9611_bridge_mode_set(struct drm_bridge *bridge, const struct drm_display_mode *mode, const struct drm_display_mode *adj_mode) { struct lt9611 *lt9611 = bridge_to_lt9611(bridge); struct hdmi_avi_infoframe avi_frame; int ret; dev_dbg(lt9611->dev, "bridge mode_set: hdisplay=%d, vdisplay=%d, vrefresh=%d, clock=%d\n", adj_mode->hdisplay, adj_mode->vdisplay, adj_mode->vrefresh, adj_mode->clock); lt9611_mipi_input_digital(lt9611, mode); lt9611_pll_setup(lt9611, mode); lt9611_mipi_video_setup(lt9611, mode); lt9611_pcr_setup(lt9611, mode); ret = drm_hdmi_avi_infoframe_from_display_mode(&avi_frame, <9611->connector, mode); if (!ret) lt9611->vic = avi_frame.video_code; } static const struct drm_bridge_funcs lt9611_bridge_funcs = { .attach = lt9611_bridge_attach, .detach = lt9611_bridge_detach, .mode_valid = lt9611_bridge_mode_valid, .pre_enable = lt9611_bridge_pre_enable, .enable = lt9611_bridge_enable, .disable = lt9611_bridge_disable, .post_disable = lt9611_bridge_post_disable, .mode_set = lt9611_bridge_mode_set, }; static int lt9611_parse_dt(struct device *dev, struct lt9611 *lt9611) { lt9611->dsi0_node = of_graph_get_remote_node(dev->of_node, 1, -1); if (!lt9611->dsi0_node) { DRM_DEV_ERROR(dev, "failed to get remote node for primary dsi\n"); return -ENODEV; } lt9611->dsi1_node = of_graph_get_remote_node(dev->of_node, 2, -1); lt9611->ac_mode = of_property_read_bool(dev->of_node, "lt,ac-mode"); dev_dbg(lt9611->dev, "ac_mode=%d\n", lt9611->ac_mode); return 0; } static int lt9611_gpio_init(struct lt9611 *lt9611) { struct device *dev = lt9611->dev; lt9611->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(lt9611->reset_gpio)) { dev_err(dev, "failed to acquire reset gpio\n"); return PTR_ERR(lt9611->reset_gpio); } lt9611->enable_gpio = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_LOW); if (IS_ERR(lt9611->enable_gpio)) { dev_err(dev, "failed to acquire enable gpio\n"); return PTR_ERR(lt9611->enable_gpio); } return 0; } static int lt9611_read_device_rev(struct lt9611 *lt9611) { unsigned int rev; int ret; regmap_write(lt9611->regmap, 0xff, 0x80); regmap_write(lt9611->regmap, 0xee, 0x01); ret = regmap_read(lt9611->regmap, 0x02, &rev); if (ret) dev_err(lt9611->dev, "failed to read revision: %d\n", ret); dev_info(lt9611->dev, "LT9611 revsion: 0x%x\n", rev); return ret; } static int lt9611_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct lt9611 *lt9611; struct device *dev = &client->dev; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(dev, "device doesn't support I2C\n"); return -ENODEV; } lt9611 = devm_kzalloc(dev, sizeof(*lt9611), GFP_KERNEL); if (!lt9611) return -ENOMEM; lt9611->dev = &client->dev; lt9611->client = client; lt9611->regmap = devm_regmap_init_i2c(client, <9611_regmap_config); if (IS_ERR(lt9611->regmap)) { DRM_ERROR("regmap i2c init failed\n"); return PTR_ERR(lt9611->regmap); } ret = lt9611_parse_dt(&client->dev, lt9611); if (ret) { dev_err(dev, "failed to parse device tree\n"); return ret; } ret = lt9611_gpio_init(lt9611); if (ret < 0) return ret; ret = lt9611_regulator_init(lt9611); if (ret < 0) return ret; lt9611_assert_5v(lt9611); ret = lt9611_regulator_enable(lt9611); if (ret) return ret; lt9611_reset(lt9611); ret = lt9611_read_device_rev(lt9611); if (ret) { dev_err(dev, "failed to read chip rev\n"); goto err_disable_regulators; } lt9611_i2s_init(lt9611); ret = devm_request_threaded_irq(dev, client->irq, NULL, lt9611_irq_thread_handler, IRQF_ONESHOT, "lt9611", lt9611); if (ret) { dev_err(dev, "failed to request irq\n"); goto err_disable_regulators; } i2c_set_clientdata(client, lt9611); lt9611->bridge.funcs = <9611_bridge_funcs; lt9611->bridge.of_node = client->dev.of_node; drm_bridge_add(<9611->bridge); lt9611_enable_hpd_interrupts(lt9611); return 0; err_disable_regulators: regulator_bulk_disable(ARRAY_SIZE(lt9611->supplies), lt9611->supplies); of_node_put(lt9611->dsi0_node); of_node_put(lt9611->dsi1_node); return ret; } static int lt9611_remove(struct i2c_client *client) { struct lt9611 *lt9611 = i2c_get_clientdata(client); disable_irq(client->irq); drm_bridge_remove(<9611->bridge); regulator_bulk_disable(ARRAY_SIZE(lt9611->supplies), lt9611->supplies); of_node_put(lt9611->dsi0_node); of_node_put(lt9611->dsi1_node); return 0; } static struct i2c_device_id lt9611_id[] = { { "lt,lt9611", 0}, {} }; static const struct of_device_id lt9611_match_table[] = { {.compatible = "lt,lt9611"}, {} }; MODULE_DEVICE_TABLE(of, lt9611_match_table); static struct i2c_driver lt9611_driver = { .driver = { .name = "lt9611", .of_match_table = lt9611_match_table, }, .probe = lt9611_probe, .remove = lt9611_remove, .id_table = lt9611_id, }; module_i2c_driver(lt9611_driver); MODULE_LICENSE("GPL v2");