jenna
/
kernel_samsung_sm7125
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
762308 Commits
5 Branches
0 Tags
1.2 GiB
 
 
 
Tag: Branch: Tree: fourteen
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'fourteen'
${ noResults }
kernel_samsung_sm7125/drivers/gpu/drm/bridge/lt9611.c

2326 lines
52 KiB
Raw Permalink Blame History

/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* 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.
*
*/
#define pr_fmt(fmt) "%s: " fmt, __func__
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/component.h>
#include <linux/workqueue.h>
#include <linux/of_gpio.h>
#include <linux/of_graph.h>
#include <linux/of_irq.h>
#include <linux/regulator/consumer.h>
#include <linux/hdmi.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_crtc_helper.h>
#define CFG_HPD_INTERRUPTS BIT(0)
#define CFG_EDID_INTERRUPTS BIT(1)
#define CFG_CEC_INTERRUPTS BIT(2)
#define CFG_VID_CHK_INTERRUPTS BIT(3)
#define EDID_SEG_SIZE 256
#define READ_BUF_MAX_SIZE 9
#define WRITE_BUF_MAX_SIZE 2
#define HPD_UEVENT_BUFFER_SIZE 30
struct lt9611_reg_cfg {
u8 reg;
u8 val;
int sleep_in_ms;
};
struct lt9611_vreg {
struct regulator *vreg; /* vreg handle */
char vreg_name[32];
int min_voltage;
int max_voltage;
int enable_load;
int disable_load;
int pre_on_sleep;
int post_on_sleep;
int pre_off_sleep;
int post_off_sleep;
};
struct lt9611_video_cfg {
u32 h_active;
u32 h_front_porch;
u32 h_pulse_width;
u32 h_back_porch;
bool h_polarity;
u32 v_active;
u32 v_front_porch;
u32 v_pulse_width;
u32 v_back_porch;
bool v_polarity;
u32 pclk_khz;
bool interlaced;
u32 vic;
enum hdmi_picture_aspect ar;
u32 num_of_lanes;
u32 num_of_intfs;
u8 scaninfo;
};
struct lt9611 {
struct device *dev;
struct drm_bridge bridge;
struct device_node *host_node;
struct mipi_dsi_device *dsi;
struct drm_connector connector;
u8 i2c_addr;
int irq;
bool ac_mode;
u32 irq_gpio;
u32 reset_gpio;
u32 hdmi_ps_gpio;
u32 hdmi_en_gpio;
unsigned int num_vreg;
struct lt9611_vreg *vreg_config;
struct i2c_client *i2c_client;
enum drm_connector_status status;
bool power_on;
bool regulator_on;
/* get display modes from device tree */
bool non_pluggable;
u32 num_of_modes;
struct list_head mode_list;
struct drm_display_mode curr_mode;
struct lt9611_video_cfg video_cfg;
struct workqueue_struct *wq;
struct work_struct work;
u8 edid_buf[EDID_SEG_SIZE];
u8 i2c_wbuf[WRITE_BUF_MAX_SIZE];
u8 i2c_rbuf[READ_BUF_MAX_SIZE];
bool hdmi_mode;
};
static struct lt9611_reg_cfg lt9611_init_setup[] = {
/* LT9611_System_Init */
{0xFF, 0x81, 0},
{0x01, 0x18, 0}, /* sel xtal clock */
/* timer for frequency meter */
{0xff, 0x82, 0},
{0x1b, 0x69, 0}, /*timer 2*/
{0x1c, 0x78, 0},
{0xcb, 0x69, 0}, /*timer 1 */
{0xcc, 0x78, 0},
/* irq init */
{0xff, 0x82, 0},
{0x51, 0x01, 0},
{0x58, 0x0a, 0}, /* hpd irq */
{0x59, 0x80, 0}, /* hpd debounce width */
{0x9e, 0xf7, 0}, /* video check irq */
/* power consumption for work */
{0xff, 0x80, 0},
{0x04, 0xf0, 0},
{0x06, 0xf0, 0},
{0x0a, 0x80, 0},
{0x0b, 0x40, 0},
{0x0d, 0xef, 0},
{0x11, 0xfa, 0},
};
struct lt9611_timing_info {
u16 xres;
u16 yres;
u8 bpp;
u8 fps;
u8 lanes;
u8 intfs;
};
static struct lt9611_timing_info lt9611_supp_timing_cfg[] = {
{3840, 2160, 24, 30, 4, 2}, /* 3840x2160 24bit 30Hz 4Lane 2ports */
{1920, 1080, 24, 60, 4, 1}, /* 1080P 24bit 60Hz 4lane 1port */
{1920, 1080, 24, 30, 3, 1}, /* 1080P 24bit 30Hz 3lane 1port */
{1920, 1080, 24, 24, 3, 1},
{720, 480, 24, 60, 2, 1},
{720, 576, 24, 50, 2, 1},
{640, 480, 24, 60, 2, 1},
{0xffff, 0xffff, 0xff, 0xff, 0xff},
};
static void lt9611_hpd_work(struct work_struct *work)
{
struct drm_device *dev = NULL;
char name[HPD_UEVENT_BUFFER_SIZE], status[HPD_UEVENT_BUFFER_SIZE];
char *envp[5];
struct lt9611 *pdata = container_of(work, struct lt9611, work);
if (!pdata)
return;
dev = pdata->connector.dev;
pdata->connector.status =
pdata->connector.funcs->detect(&pdata->connector, true);
scnprintf(name, HPD_UEVENT_BUFFER_SIZE, "name=%s",
pdata->connector.name);
scnprintf(status, HPD_UEVENT_BUFFER_SIZE, "status=%s",
drm_get_connector_status_name(pdata->connector.status));
pr_debug("[%s]:[%s]\n", name, status);
envp[0] = name;
envp[1] = status;
envp[2] = NULL;
envp[3] = NULL;
envp[4] = NULL;
kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE,
envp);
}
static void lt9611_device_power_ctl(struct lt9611 *pdata, bool on_off);
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_write(struct lt9611 *pdata, u8 reg, u8 val)
{
struct i2c_client *client = pdata->i2c_client;
struct i2c_msg msg = {
.addr = client->addr,
.flags = 0,
.len = 2,
.buf = pdata->i2c_wbuf,
};
pdata->i2c_wbuf[0] = reg;
pdata->i2c_wbuf[1] = val;
if (i2c_transfer(client->adapter, &msg, 1) < 1) {
pr_err("i2c write failed\n");
return -EIO;
}
return 0;
}
static int lt9611_read(struct lt9611 *pdata, u8 reg, char *buf, u32 size)
{
struct i2c_client *client = pdata->i2c_client;
struct i2c_msg msg[2] = {
{
.addr = client->addr,
.flags = 0,
.len = 1,
.buf = pdata->i2c_wbuf,
},
{
.addr = client->addr,
.flags = I2C_M_RD,
.len = size,
.buf = pdata->i2c_rbuf,
}
};
pdata->i2c_wbuf[0] = reg;
if (i2c_transfer(client->adapter, msg, 2) != 2) {
pr_err("i2c read failed\n");
return -EIO;
}
memcpy(buf, pdata->i2c_rbuf, size);
return 0;
}
static int lt9611_write_array(struct lt9611 *pdata,
struct lt9611_reg_cfg *cfg, int size)
{
int ret = 0;
int i;
size = size / sizeof(struct lt9611_reg_cfg);
for (i = 0; i < size; i++) {
ret = lt9611_write(pdata, cfg[i].reg, cfg[i].val);
if (ret != 0) {
pr_err("reg writes failed. Last write %02X to %02X\n",
cfg[i].val, cfg[i].reg);
goto w_regs_fail;
}
if (cfg[i].sleep_in_ms)
msleep(cfg[i].sleep_in_ms);
}
w_regs_fail:
if (ret != 0)
pr_err("exiting with ret = %d after %d writes\n", ret, i);
return ret;
}
static int lt9611_parse_dt_modes(struct device_node *np,
struct list_head *head,
u32 *num_of_modes)
{
int rc = 0;
struct drm_display_mode *mode;
u32 mode_count = 0;
struct device_node *node = NULL;
struct device_node *root_node = NULL;
u32 h_front_porch, h_pulse_width, h_back_porch;
u32 v_front_porch, v_pulse_width, v_back_porch;
bool h_active_high, v_active_high;
u32 flags = 0;
root_node = of_get_child_by_name(np, "lt,customize-modes");
if (!root_node) {
root_node = of_parse_phandle(np, "lt,customize-modes", 0);
if (!root_node) {
pr_info("No entry present for lt,customize-modes");
goto end;
}
}
for_each_child_of_node(root_node, node) {
rc = 0;
mode = kzalloc(sizeof(*mode), GFP_KERNEL);
if (!mode) {
pr_err("Out of memory\n");
rc = -ENOMEM;
continue;
}
rc = of_property_read_u32(node, "lt,mode-h-active",
&mode->hdisplay);
if (rc) {
pr_err("failed to read h-active, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-h-front-porch",
&h_front_porch);
if (rc) {
pr_err("failed to read h-front-porch, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-h-pulse-width",
&h_pulse_width);
if (rc) {
pr_err("failed to read h-pulse-width, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-h-back-porch",
&h_back_porch);
if (rc) {
pr_err("failed to read h-back-porch, rc=%d\n", rc);
goto fail;
}
h_active_high = of_property_read_bool(node,
"lt,mode-h-active-high");
rc = of_property_read_u32(node, "lt,mode-v-active",
&mode->vdisplay);
if (rc) {
pr_err("failed to read v-active, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-v-front-porch",
&v_front_porch);
if (rc) {
pr_err("failed to read v-front-porch, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-v-pulse-width",
&v_pulse_width);
if (rc) {
pr_err("failed to read v-pulse-width, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-v-back-porch",
&v_back_porch);
if (rc) {
pr_err("failed to read v-back-porch, rc=%d\n", rc);
goto fail;
}
v_active_high = of_property_read_bool(node,
"lt,mode-v-active-high");
rc = of_property_read_u32(node, "lt,mode-refresh-rate",
&mode->vrefresh);
if (rc) {
pr_err("failed to read refresh-rate, rc=%d\n", rc);
goto fail;
}
rc = of_property_read_u32(node, "lt,mode-clock-in-khz",
&mode->clock);
if (rc) {
pr_err("failed to read clock, rc=%d\n", rc);
goto fail;
}
mode->hsync_start = mode->hdisplay + h_front_porch;
mode->hsync_end = mode->hsync_start + h_pulse_width;
mode->htotal = mode->hsync_end + h_back_porch;
mode->vsync_start = mode->vdisplay + v_front_porch;
mode->vsync_end = mode->vsync_start + v_pulse_width;
mode->vtotal = mode->vsync_end + v_back_porch;
if (h_active_high)
flags |= DRM_MODE_FLAG_PHSYNC;
else
flags |= DRM_MODE_FLAG_NHSYNC;
if (v_active_high)
flags |= DRM_MODE_FLAG_PVSYNC;
else
flags |= DRM_MODE_FLAG_NVSYNC;
mode->flags = flags;
if (!rc) {
mode_count++;
list_add_tail(&mode->head, head);
}
drm_mode_set_name(mode);
pr_debug("mode[%s] h[%d,%d,%d,%d] v[%d,%d,%d,%d] %d %x %dkHZ\n",
mode->name, mode->hdisplay, mode->hsync_start,
mode->hsync_end, mode->htotal, mode->vdisplay,
mode->vsync_start, mode->vsync_end, mode->vtotal,
mode->vrefresh, mode->flags, mode->clock);
fail:
if (rc) {
kfree(mode);
continue;
}
}
if (num_of_modes)
*num_of_modes = mode_count;
end:
return rc;
}
static int lt9611_parse_dt(struct device *dev,
struct lt9611 *pdata)
{
struct device_node *np = dev->of_node;
struct device_node *end_node;
int ret = 0;
end_node = of_graph_get_endpoint_by_regs(dev->of_node, 0, 0);
if (!end_node) {
pr_err("remote endpoint not found\n");
return -ENODEV;
}
pdata->host_node = of_graph_get_remote_port_parent(end_node);
of_node_put(end_node);
if (!pdata->host_node) {
pr_err("remote node not found\n");
return -ENODEV;
}
of_node_put(pdata->host_node);
pdata->irq_gpio =
of_get_named_gpio(np, "lt,irq-gpio", 0);
if (!gpio_is_valid(pdata->irq_gpio)) {
pr_err("irq gpio not specified\n");
ret = -EINVAL;
}
pr_debug("irq_gpio=%d\n", pdata->irq_gpio);
pdata->reset_gpio =
of_get_named_gpio(np, "lt,reset-gpio", 0);
if (!gpio_is_valid(pdata->reset_gpio)) {
pr_err("reset gpio not specified\n");
ret = -EINVAL;
}
pr_debug("reset_gpio=%d\n", pdata->reset_gpio);
pdata->hdmi_ps_gpio =
of_get_named_gpio(np, "lt,hdmi-ps-gpio", 0);
if (!gpio_is_valid(pdata->hdmi_ps_gpio))
pr_debug("hdmi ps gpio not specified\n");
else
pr_debug("hdmi_ps_gpio=%d\n", pdata->hdmi_ps_gpio);
pdata->hdmi_en_gpio =
of_get_named_gpio(np, "lt,hdmi-en-gpio", 0);
if (!gpio_is_valid(pdata->hdmi_en_gpio))
pr_debug("hdmi en gpio not specified\n");
else
pr_debug("hdmi_en_gpio=%d\n", pdata->hdmi_en_gpio);
pdata->ac_mode = of_property_read_bool(np, "lt,ac-mode");
pr_debug("ac_mode=%d\n", pdata->ac_mode);
pdata->non_pluggable = of_property_read_bool(np, "lt,non-pluggable");
pr_debug("non_pluggable = %d\n", pdata->non_pluggable);
if (pdata->non_pluggable) {
INIT_LIST_HEAD(&pdata->mode_list);
ret = lt9611_parse_dt_modes(np,
&pdata->mode_list, &pdata->num_of_modes);
}
return ret;
}
static int lt9611_gpio_configure(struct lt9611 *pdata, bool on)
{
int ret = 0;
if (on) {
ret = gpio_request(pdata->reset_gpio,
"lt9611-reset-gpio");
if (ret) {
pr_err("lt9611 reset gpio request failed\n");
goto error;
}
ret = gpio_direction_output(pdata->reset_gpio, 0);
if (ret) {
pr_err("lt9611 reset gpio direction failed\n");
goto reset_error;
}
if (gpio_is_valid(pdata->hdmi_en_gpio)) {
ret = gpio_request(pdata->hdmi_en_gpio,
"lt9611-hdmi-en-gpio");
if (ret) {
pr_err("lt9611 hdmi en gpio request failed\n");
goto reset_error;
}
ret = gpio_direction_output(pdata->hdmi_en_gpio, 1);
if (ret) {
pr_err("lt9611 hdmi en gpio direction failed\n");
goto hdmi_en_error;
}
}
if (gpio_is_valid(pdata->hdmi_ps_gpio)) {
ret = gpio_request(pdata->hdmi_ps_gpio,
"lt9611-hdmi-ps-gpio");
if (ret) {
pr_err("lt9611 hdmi ps gpio request failed\n");
goto hdmi_en_error;
}
ret = gpio_direction_input(pdata->hdmi_ps_gpio);
if (ret) {
pr_err("lt9611 hdmi ps gpio direction failed\n");
goto hdmi_ps_error;
}
}
ret = gpio_request(pdata->irq_gpio, "lt9611-irq-gpio");
if (ret) {
pr_err("lt9611 irq gpio request failed\n");
goto hdmi_ps_error;
}
ret = gpio_direction_input(pdata->irq_gpio);
if (ret) {
pr_err("lt9611 irq gpio direction failed\n");
goto irq_error;
}
} else {
gpio_free(pdata->irq_gpio);
if (gpio_is_valid(pdata->hdmi_ps_gpio))
gpio_free(pdata->hdmi_ps_gpio);
if (gpio_is_valid(pdata->hdmi_en_gpio))
gpio_free(pdata->hdmi_en_gpio);
gpio_free(pdata->reset_gpio);
}
return ret;
irq_error:
gpio_free(pdata->irq_gpio);
hdmi_ps_error:
if (gpio_is_valid(pdata->hdmi_ps_gpio))
gpio_free(pdata->hdmi_ps_gpio);
hdmi_en_error:
if (gpio_is_valid(pdata->hdmi_en_gpio))
gpio_free(pdata->hdmi_en_gpio);
reset_error:
gpio_free(pdata->reset_gpio);
error:
return ret;
}
static int lt9611_read_device_rev(struct lt9611 *pdata)
{
u8 rev = 0;
int ret = 0;
lt9611_write(pdata, 0xff, 0x80);
lt9611_write(pdata, 0xee, 0x01);
ret = lt9611_read(pdata, 0x02, &rev, 1);
if (ret == 0)
pr_info("LT9611 revision: 0x%x\n", rev);
return ret;
}
static int lt9611_mipi_input_analog(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
struct lt9611_reg_cfg reg_cfg[] = {
{0xff, 0x81, 0},
{0x06, 0x40, 0}, /*port A rx current*/
{0x0a, 0xfe, 0}, /*port A ldo voltage set*/
{0x0b, 0xbf, 0}, /*enable port A lprx*/
{0x11, 0x40, 0}, /*port B rx current*/
{0x15, 0xfe, 0}, /*port B ldo voltage set*/
{0x16, 0xbf, 0}, /*enable port B lprx*/
{0x1c, 0x03, 0}, /*PortA clk lane no-LP mode*/
{0x20, 0x03, 0}, /*PortB clk lane with-LP mode*/
};
if (!pdata || !cfg) {
pr_err("invalid input\n");
return -EINVAL;
}
lt9611_write_array(pdata, reg_cfg, sizeof(reg_cfg));
return 0;
}
static int lt9611_mipi_input_digital(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
u8 lanes = 0;
u8 ports = 0;
struct lt9611_reg_cfg reg_cfg[] = {
{0xff, 0x82, 0},
{0x4f, 0x80, 0},
{0x50, 0x10, 0},
{0xff, 0x83, 0},
{0x02, 0x0a, 0},
{0x06, 0x0a, 0},
};
if (!pdata || !cfg) {
pr_err("invalid input\n");
return -EINVAL;
}
lanes = cfg->num_of_lanes;
ports = cfg->num_of_intfs;
lt9611_write(pdata, 0xff, 0x83);
if (lanes == 4)
lt9611_write(pdata, 0x00, 0x00);
else if (lanes < 4)
lt9611_write(pdata, 0x00, lanes);
else {
pr_err("invalid lane count\n");
return -EINVAL;
}
if (ports == 1)
lt9611_write(pdata, 0x0a, 0x00);
else if (ports == 2)
lt9611_write(pdata, 0x0a, 0x03);
else {
pr_err("invalid port count\n");
return -EINVAL;
}
lt9611_write_array(pdata, reg_cfg, sizeof(reg_cfg));
return 0;
}
static void lt9611_mipi_video_setup(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
u32 h_total, h_act, hpw, hfp, hss;
u32 v_total, v_act, vpw, vfp, vss;
if (!pdata || !cfg) {
pr_err("invalid input\n");
return;
}
h_total = cfg->h_active + cfg->h_front_porch +
cfg->h_pulse_width + cfg->h_back_porch;
v_total = cfg->v_active + cfg->v_front_porch +
cfg->v_pulse_width + cfg->v_back_porch;
h_act = cfg->h_active;
hpw = cfg->h_pulse_width;
hfp = cfg->h_front_porch;
hss = cfg->h_pulse_width + cfg->h_back_porch;
v_act = cfg->v_active;
vpw = cfg->v_pulse_width;
vfp = cfg->v_front_porch;
vss = cfg->v_pulse_width + cfg->v_back_porch;
pr_debug("h_total=%d, h_active=%d, hfp=%d, hpw=%d, hbp=%d\n",
h_total, cfg->h_active, cfg->h_front_porch,
cfg->h_pulse_width, cfg->h_back_porch);
pr_debug("v_total=%d, v_active=%d, vfp=%d, vpw=%d, vbp=%d\n",
v_total, cfg->v_active, cfg->v_front_porch,
cfg->v_pulse_width, cfg->v_back_porch);
lt9611_write(pdata, 0xff, 0x83);
lt9611_write(pdata, 0x0d, (u8)(v_total / 256));
lt9611_write(pdata, 0x0e, (u8)(v_total % 256));
lt9611_write(pdata, 0x0f, (u8)(v_act / 256));
lt9611_write(pdata, 0x10, (u8)(v_act % 256));
lt9611_write(pdata, 0x11, (u8)(h_total / 256));
lt9611_write(pdata, 0x12, (u8)(h_total % 256));
lt9611_write(pdata, 0x13, (u8)(h_act / 256));
lt9611_write(pdata, 0x14, (u8)(h_act % 256));
lt9611_write(pdata, 0x15, (u8)(vpw % 256));
lt9611_write(pdata, 0x16, (u8)(hpw % 256));
lt9611_write(pdata, 0x17, (u8)(vfp % 256));
lt9611_write(pdata, 0x18, (u8)(vss % 256));
lt9611_write(pdata, 0x19, (u8)(hfp % 256));
lt9611_write(pdata, 0x1a, (u8)(hss / 256));
lt9611_write(pdata, 0x1b, (u8)(hss % 256));
}
static int lt9611_pcr_setup(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
u32 h_act = 0;
struct lt9611_reg_cfg reg_cfg[] = {
{0xff, 0x83, 0},
{0x0b, 0x01, 0},
{0x0c, 0x10, 0},
{0x48, 0x00, 0},
{0x49, 0x81, 0},
/* stage 1 */
{0x21, 0x4a, 0},
{0x24, 0x71, 0},
{0x25, 0x30, 0},
{0x2a, 0x01, 0},
/* stage 2 */
{0x4a, 0x40, 0},
{0x1d, 0x10, 0},
/* MK limit */
{0x2d, 0x38, 0},
{0x31, 0x08, 0},
};
if (!pdata || !cfg) {
pr_err("invalid input\n");
return -EINVAL;
}
lt9611_write_array(pdata, reg_cfg, sizeof(reg_cfg));
h_act = cfg->h_active;
if (h_act == 1920) {
lt9611_write(pdata, 0x26, 0x37);
} else if (h_act == 3840) {
lt9611_write(pdata, 0x0b, 0x03);
lt9611_write(pdata, 0x0c, 0xd0);
lt9611_write(pdata, 0x48, 0x03);
lt9611_write(pdata, 0x49, 0xe0);
lt9611_write(pdata, 0x24, 0x72);
lt9611_write(pdata, 0x25, 0x00);
lt9611_write(pdata, 0x2a, 0x01);
lt9611_write(pdata, 0x4a, 0x10);
lt9611_write(pdata, 0x1d, 0x10);
lt9611_write(pdata, 0x26, 0x37);
} else if (h_act == 640) {
lt9611_write(pdata, 0x26, 0x14);
}
/* pcr rst */
lt9611_write(pdata, 0xff, 0x80);
lt9611_write(pdata, 0x11, 0x5a);
lt9611_write(pdata, 0x11, 0xfa);
return 0;
}
static int lt9611_pll_setup(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
u32 pclk = 0;
struct lt9611_reg_cfg reg_cfg[] = {
/* txpll init */
{0xff, 0x81, 0},
{0x23, 0x40, 0},
{0x24, 0x64, 0},
{0x25, 0x80, 0},
{0x26, 0x55, 0},
{0x2c, 0x37, 0},
{0x2f, 0x01, 0},
{0x26, 0x55, 0},
{0x27, 0x66, 0},
{0x28, 0x88, 0},
};
if (!pdata || !cfg) {
pr_err("invalid input\n");
return -EINVAL;
}
pclk = cfg->pclk_khz;
lt9611_write_array(pdata, reg_cfg, sizeof(reg_cfg));
if (pclk > 150000)
lt9611_write(pdata, 0x2d, 0x88);
else if (pclk > 70000)
lt9611_write(pdata, 0x2d, 0x99);
else
lt9611_write(pdata, 0x2d, 0xaa);
lt9611_write(pdata, 0xff, 0x82);
pclk = pclk / 2;
lt9611_write(pdata, 0xe3, pclk/65536); /* pclk[19:16] */
pclk = pclk % 65536;
lt9611_write(pdata, 0xe4, pclk/256); /* pclk[15:8] */
lt9611_write(pdata, 0xe5, pclk%256); /* pclk[7:0] */
lt9611_write(pdata, 0xde, 0x20);
lt9611_write(pdata, 0xde, 0xe0);
lt9611_write(pdata, 0xff, 0x80);
lt9611_write(pdata, 0x16, 0xf1);
lt9611_write(pdata, 0x16, 0xf3);
return 0;
}
static int lt9611_video_check(struct lt9611 *pdata)
{
int ret = 0;
u32 v_total, v_act, h_act_a, h_act_b, h_total_sysclk;
u8 temp = 0;
if (!pdata) {
pr_err("invalid input\n");
return -EINVAL;
}
/* top module video check */
lt9611_write(pdata, 0xff, 0x82);
/* v_act */
ret = lt9611_read(pdata, 0x82, &temp, 1);
if (ret)
goto end;
v_act = temp << 8;
ret = lt9611_read(pdata, 0x83, &temp, 1);
if (ret)
goto end;
v_act = v_act + temp;
/* v_total */
ret = lt9611_read(pdata, 0x6c, &temp, 1);
if (ret)
goto end;
v_total = temp << 8;
ret = lt9611_read(pdata, 0x6d, &temp, 1);
if (ret)
goto end;
v_total = v_total + temp;
/* h_total_sysclk */
ret = lt9611_read(pdata, 0x86, &temp, 1);
if (ret)
goto end;
h_total_sysclk = temp << 8;
ret = lt9611_read(pdata, 0x87, &temp, 1);
if (ret)
goto end;
h_total_sysclk = h_total_sysclk + temp;
/* h_act_a */
lt9611_write(pdata, 0xff, 0x83);
ret = lt9611_read(pdata, 0x82, &temp, 1);
if (ret)
goto end;
h_act_a = temp << 8;
ret = lt9611_read(pdata, 0x83, &temp, 1);
if (ret)
goto end;
h_act_a = (h_act_a + temp)/3;
/* h_act_b */
lt9611_write(pdata, 0xff, 0x83);
ret = lt9611_read(pdata, 0x86, &temp, 1);
if (ret)
goto end;
h_act_b = temp << 8;
ret = lt9611_read(pdata, 0x87, &temp, 1);
if (ret)
goto end;
h_act_b = (h_act_b + temp)/3;
pr_info("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:
pr_err("read video check error\n");
return ret;
}
static int lt9611_hdmi_tx_digital(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
int ret = -EINVAL;
u32 checksum, vic;
if (!pdata || !cfg) {
pr_err("invalid input\n");
return ret;
}
vic = cfg->vic;
checksum = 0x46 - vic;
lt9611_write(pdata, 0xff, 0x84);
lt9611_write(pdata, 0x43, checksum);
lt9611_write(pdata, 0x44, 0x84);
lt9611_write(pdata, 0x47, vic);
lt9611_write(pdata, 0xff, 0x82);
lt9611_write(pdata, 0xd6, 0x8c);
lt9611_write(pdata, 0xd7, 0x04);
return ret;
}
static int lt9611_hdmi_tx_phy(struct lt9611 *pdata,
struct lt9611_video_cfg *cfg)
{
int ret = -EINVAL;
struct lt9611_reg_cfg reg_cfg[] = {
{0xff, 0x81, 0},
{0x30, 0x6a, 0},
{0x31, 0x44, 0}, /* HDMI DC mode */
{0x32, 0x4a, 0},
{0x33, 0x0b, 0},
{0x34, 0x00, 0},
{0x35, 0x00, 0},
{0x36, 0x00, 0},
{0x37, 0x44, 0},
{0x3f, 0x0f, 0},
{0x40, 0xa0, 0},
{0x41, 0xa0, 0},
{0x42, 0xa0, 0},
{0x43, 0xa0, 0},
{0x44, 0x0a, 0},
};
if (!pdata || !cfg) {
pr_err("invalid input\n");
return ret;
}
/* HDMI AC mode */
if (pdata->ac_mode)
reg_cfg[2].val = 0x73;
lt9611_write_array(pdata, reg_cfg, sizeof(reg_cfg));
return ret;
}
static void lt9611_hdmi_output_enable(struct lt9611 *pdata)
{
lt9611_write(pdata, 0xff, 0x81);
lt9611_write(pdata, 0x30, 0xea);
}
static void lt9611_hdmi_output_disable(struct lt9611 *pdata)
{
lt9611_write(pdata, 0xff, 0x81);
lt9611_write(pdata, 0x30, 0x6a);
}
static irqreturn_t lt9611_irq_thread_handler(int irq, void *dev_id)
{
struct lt9611 *pdata = dev_id;
u8 irq_flag0 = 0;
u8 irq_flag3 = 0;
lt9611_write(pdata, 0xff, 0x82);
lt9611_read(pdata, 0x0f, &irq_flag3, 1);
lt9611_read(pdata, 0x0c, &irq_flag0, 1);
/* hpd changed low */
if (irq_flag3 & BIT(7)) {
pr_info("hdmi cable disconnected\n");
lt9611_write(pdata, 0xff, 0x82); /* irq 3 clear flag */
lt9611_write(pdata, 0x07, 0xbf);
lt9611_write(pdata, 0x07, 0x3f);
}
/* hpd changed high */
if (irq_flag3 & BIT(6)) {
pr_info("hdmi cable connected\n");
lt9611_write(pdata, 0xff, 0x82); /* irq 3 clear flag */
lt9611_write(pdata, 0x07, 0x7f);
lt9611_write(pdata, 0x07, 0x3f);
}
/* video input changed */
if (irq_flag0 & BIT(0)) {
pr_info("video input changed\n");
lt9611_write(pdata, 0xff, 0x82); /* irq 0 clear flag */
lt9611_write(pdata, 0x9e, 0xff);
lt9611_write(pdata, 0x9e, 0xf7);
lt9611_write(pdata, 0x04, 0xff);
lt9611_write(pdata, 0x04, 0xfe);
}
if (irq_flag3 & (BIT(6) | BIT(7)))
queue_work(pdata->wq, &pdata->work);
return IRQ_HANDLED;
}
static int lt9611_enable_interrupts(struct lt9611 *pdata, int interrupts)
{
int ret = 0;
u8 reg_val = 0;
u8 init_reg_val;
if (!pdata) {
pr_err("invalid input\n");
goto end;
}
if (interrupts & CFG_VID_CHK_INTERRUPTS) {
lt9611_write(pdata, 0xff, 0x82);
lt9611_read(pdata, 0x00, &reg_val, 1);
if (reg_val & 0x01) {
init_reg_val = reg_val & 0xfe;
pr_debug("enabling video check interrupts\n");
lt9611_write(pdata, 0x00, init_reg_val);
}
lt9611_write(pdata, 0x04, 0xff); /* clear */
lt9611_write(pdata, 0x04, 0xfe);
}
if (interrupts & CFG_HPD_INTERRUPTS) {
lt9611_write(pdata, 0xff, 0x82);
lt9611_read(pdata, 0x03, &reg_val, 1);
if (reg_val & 0xc0) { //reg_val | 0xc0???
init_reg_val = reg_val & 0x3f;
pr_debug("enabling hpd interrupts\n");
lt9611_write(pdata, 0x03, init_reg_val);
}
lt9611_write(pdata, 0x07, 0xff); //clear
lt9611_write(pdata, 0x07, 0x3f);
}
end:
return ret;
}
static void lt9611_pcr_mk_debug(struct lt9611 *pdata)
{
u8 m = 0, k1 = 0, k2 = 0, k3 = 0;
lt9611_write(pdata, 0xff, 0x83);
lt9611_read(pdata, 0xb4, &m, 1);
lt9611_read(pdata, 0xb5, &k1, 1);
lt9611_read(pdata, 0xb6, &k2, 1);
lt9611_read(pdata, 0xb7, &k3, 1);
pr_info("pcr mk:0x%x 0x%x 0x%x 0x%x\n",
m, k1, k2, k3);
}
static void lt9611_sleep_setup(struct lt9611 *pdata)
{
struct lt9611_reg_cfg sleep_setup[] = {
{0xff, 0x80, 0}, //register I2C addr
{0x24, 0x76, 0},
{0x23, 0x01, 0},
{0xff, 0x81, 0}, //set addr pin as output
{0x57, 0x03, 0},
{0x49, 0x0b, 0},
{0xff, 0x81, 0}, //anlog power down
{0x51, 0x30, 0}, //disable IRQ
{0x02, 0x48, 0}, //MIPI Rx power down
{0x23, 0x80, 0},
{0x30, 0x00, 0},
{0x00, 0x01, 0}, //bandgap power down
{0x01, 0x00, 0}, //system clk power down
};
pr_err("sleep\n");
lt9611_write_array(pdata, sleep_setup, sizeof(sleep_setup));
}
static int lt9611_power_on(struct lt9611 *pdata, bool on)
{
int ret = 0;
pr_debug("power_on: on=%d\n", on);
if (on && !pdata->power_on) {
lt9611_write_array(pdata, lt9611_init_setup,
sizeof(lt9611_init_setup));
ret = lt9611_enable_interrupts(pdata, CFG_HPD_INTERRUPTS);
if (ret) {
pr_err("Failed to enable HPD intr %d\n", ret);
return ret;
}
pdata->power_on = true;
} else if (!on) {
lt9611_write(pdata, 0xff, 0x81);
lt9611_write(pdata, 0x30, 0x6a);
pdata->power_on = false;
}
return ret;
}
static int lt9611_video_on(struct lt9611 *pdata, bool on)
{
int ret = 0;
struct lt9611_video_cfg *cfg = &pdata->video_cfg;
pr_debug("on=%d\n", on);
if (on) {
lt9611_mipi_input_analog(pdata, cfg);
lt9611_mipi_input_digital(pdata, cfg);
lt9611_pll_setup(pdata, cfg);
lt9611_mipi_video_setup(pdata, cfg);
lt9611_pcr_setup(pdata, cfg);
lt9611_hdmi_tx_digital(pdata, cfg);
lt9611_hdmi_tx_phy(pdata, cfg);
msleep(500);
lt9611_video_check(pdata);
lt9611_hdmi_output_enable(pdata);
} else {
lt9611_hdmi_output_disable(pdata);
}
return ret;
}
static void lt9611_mipi_byte_clk_debug(struct lt9611 *pdata)
{
u8 reg_val = 0;
u32 byte_clk;
/* port A byte clk meter */
lt9611_write(pdata, 0xff, 0x82);
lt9611_write(pdata, 0xc7, 0x03); /* port A */
msleep(50);
lt9611_read(pdata, 0xcd, &reg_val, 1);
if ((reg_val & 0x60) == 0x60) {
byte_clk = (reg_val & 0x0f) * 65536;
lt9611_read(pdata, 0xce, &reg_val, 1);
byte_clk = byte_clk + reg_val * 256;
lt9611_read(pdata, 0xcf, &reg_val, 1);
byte_clk = byte_clk + reg_val;
pr_info("port A byte clk = %d khz,\n", byte_clk);
} else
pr_info("port A byte clk unstable\n");
/* port B byte clk meter */
lt9611_write(pdata, 0xff, 0x82);
lt9611_write(pdata, 0xc7, 0x04); /* port B */
msleep(50);
lt9611_read(pdata, 0xcd, &reg_val, 1);
if ((reg_val & 0x60) == 0x60) {
byte_clk = (reg_val & 0x0f) * 65536;
lt9611_read(pdata, 0xce, &reg_val, 1);
byte_clk = byte_clk + reg_val * 256;
lt9611_read(pdata, 0xcf, &reg_val, 1);
byte_clk = byte_clk + reg_val;
pr_info("port B byte clk = %d khz,\n", byte_clk);
} else
pr_info("port B byte clk unstable\n");
}
static void lt9611_reset(struct lt9611 *pdata, bool on_off)
{
if (on_off) {
gpio_set_value(pdata->reset_gpio, 1);
msleep(20);
gpio_set_value(pdata->reset_gpio, 0);
msleep(20);
gpio_set_value(pdata->reset_gpio, 1);
msleep(20);
} else
gpio_set_value(pdata->reset_gpio, 0);
}
static void lt9611_assert_5v(struct lt9611 *pdata, bool on_off)
{
if (!gpio_is_valid(pdata->hdmi_en_gpio))
return;
if (on_off)
gpio_set_value(pdata->hdmi_en_gpio, 1);
else
gpio_set_value(pdata->hdmi_en_gpio, 0);
msleep(20);
}
static int lt9611_config_vreg(struct device *dev,
struct lt9611_vreg *in_vreg, int num_vreg, bool config)
{
int i = 0, rc = 0;
struct lt9611_vreg *curr_vreg = NULL;
if (!in_vreg || !num_vreg)
return rc;
if (config) {
for (i = 0; i < num_vreg; i++) {
curr_vreg = &in_vreg[i];
curr_vreg->vreg = regulator_get(dev,
curr_vreg->vreg_name);
rc = PTR_RET(curr_vreg->vreg);
if (rc) {
pr_err("%s get failed. rc=%d\n",
curr_vreg->vreg_name, rc);
curr_vreg->vreg = NULL;
goto vreg_get_fail;
}
rc = regulator_set_voltage(
curr_vreg->vreg,
curr_vreg->min_voltage,
curr_vreg->max_voltage);
if (rc < 0) {
pr_err("%s set vltg fail\n",
curr_vreg->vreg_name);
goto vreg_set_voltage_fail;
}
}
} else {
for (i = num_vreg-1; i >= 0; i--) {
curr_vreg = &in_vreg[i];
if (curr_vreg->vreg) {
regulator_set_voltage(curr_vreg->vreg,
0, curr_vreg->max_voltage);
regulator_put(curr_vreg->vreg);
curr_vreg->vreg = NULL;
}
}
}
return 0;
vreg_unconfig:
regulator_set_load(curr_vreg->vreg, 0);
vreg_set_voltage_fail:
regulator_put(curr_vreg->vreg);
curr_vreg->vreg = NULL;
vreg_get_fail:
for (i--; i >= 0; i--) {
curr_vreg = &in_vreg[i];
goto vreg_unconfig;
}
return rc;
}
static int lt9611_get_dt_supply(struct device *dev,
struct lt9611 *pdata)
{
int i = 0, rc = 0;
u32 tmp = 0;
struct device_node *of_node = NULL, *supply_root_node = NULL;
struct device_node *supply_node = NULL;
if (!dev || !pdata) {
pr_err("invalid input param dev:%pK pdata:%pK\n", dev, pdata);
return -EINVAL;
}
of_node = dev->of_node;
pdata->num_vreg = 0;
supply_root_node = of_get_child_by_name(of_node,
"lt,supply-entries");
if (!supply_root_node) {
pr_info("no supply entry present\n");
return 0;
}
pdata->num_vreg = of_get_available_child_count(supply_root_node);
if (pdata->num_vreg == 0) {
pr_info("no vreg present\n");
return 0;
}
pr_debug("vreg found. count=%d\n", pdata->num_vreg);
pdata->vreg_config = devm_kzalloc(dev, sizeof(struct lt9611_vreg) *
pdata->num_vreg, GFP_KERNEL);
if (!pdata->vreg_config)
return -ENOMEM;
for_each_available_child_of_node(supply_root_node, supply_node) {
const char *st = NULL;
rc = of_property_read_string(supply_node,
"lt,supply-name", &st);
if (rc) {
pr_err("error reading name. rc=%d\n", rc);
goto error;
}
strlcpy(pdata->vreg_config[i].vreg_name, st,
sizeof(pdata->vreg_config[i].vreg_name));
rc = of_property_read_u32(supply_node,
"lt,supply-min-voltage", &tmp);
if (rc) {
pr_err("error reading min volt. rc=%d\n", rc);
goto error;
}
pdata->vreg_config[i].min_voltage = tmp;
rc = of_property_read_u32(supply_node,
"lt,supply-max-voltage", &tmp);
if (rc) {
pr_err("error reading max volt. rc=%d\n", rc);
goto error;
}
pdata->vreg_config[i].max_voltage = tmp;
rc = of_property_read_u32(supply_node,
"lt,supply-enable-load", &tmp);
if (rc)
pr_debug("no supply enable load value. rc=%d\n", rc);
pdata->vreg_config[i].enable_load = (!rc ? tmp : 0);
rc = of_property_read_u32(supply_node,
"lt,supply-disable-load", &tmp);
if (rc)
pr_debug("no supply disable load value. rc=%d\n", rc);
pdata->vreg_config[i].disable_load = (!rc ? tmp : 0);
rc = of_property_read_u32(supply_node,
"lt,supply-pre-on-sleep", &tmp);
if (rc)
pr_debug("no supply pre on sleep value. rc=%d\n", rc);
pdata->vreg_config[i].pre_on_sleep = (!rc ? tmp : 0);
rc = of_property_read_u32(supply_node,
"lt,supply-pre-off-sleep", &tmp);
if (rc)
pr_debug("no supply pre off sleep value. rc=%d\n", rc);
pdata->vreg_config[i].pre_off_sleep = (!rc ? tmp : 0);
rc = of_property_read_u32(supply_node,
"lt,supply-post-on-sleep", &tmp);
if (rc)
pr_debug("no supply post on sleep value. rc=%d\n", rc);
pdata->vreg_config[i].post_on_sleep = (!rc ? tmp : 0);
rc = of_property_read_u32(supply_node,
"lt,supply-post-off-sleep", &tmp);
if (rc)
pr_debug("no supply post off sleep value. rc=%d\n", rc);
pdata->vreg_config[i].post_off_sleep = (!rc ? tmp : 0);
pr_debug("%s min=%d, max=%d, enable=%d, disable=%d, preonsleep=%d, postonsleep=%d, preoffsleep=%d, postoffsleep=%d\n",
pdata->vreg_config[i].vreg_name,
pdata->vreg_config[i].min_voltage,
pdata->vreg_config[i].max_voltage,
pdata->vreg_config[i].enable_load,
pdata->vreg_config[i].disable_load,
pdata->vreg_config[i].pre_on_sleep,
pdata->vreg_config[i].post_on_sleep,
pdata->vreg_config[i].pre_off_sleep,
pdata->vreg_config[i].post_off_sleep);
++i;
rc = 0;
}
rc = lt9611_config_vreg(dev,
pdata->vreg_config, pdata->num_vreg, true);
if (rc)
goto error;
return rc;
error:
if (pdata->vreg_config) {
devm_kfree(dev, pdata->vreg_config);
pdata->vreg_config = NULL;
pdata->num_vreg = 0;
}
return rc;
}
static void lt9611_put_dt_supply(struct device *dev,
struct lt9611 *pdata)
{
if (!dev || !pdata) {
pr_err("invalid input param dev:%pK pdata:%pK\n", dev, pdata);
return;
}
lt9611_config_vreg(dev,
pdata->vreg_config, pdata->num_vreg, false);
if (pdata->vreg_config) {
devm_kfree(dev, pdata->vreg_config);
pdata->vreg_config = NULL;
}
pdata->num_vreg = 0;
}
static int lt9611_enable_vreg(struct lt9611 *pdata, int enable)
{
int i = 0, rc = 0;
bool need_sleep;
struct lt9611_vreg *in_vreg = pdata->vreg_config;
int num_vreg = pdata->num_vreg;
if (enable) {
for (i = 0; i < num_vreg; i++) {
rc = PTR_RET(in_vreg[i].vreg);
if (rc) {
pr_err("%s regulator error. rc=%d\n",
in_vreg[i].vreg_name, rc);
goto vreg_set_opt_mode_fail;
}
need_sleep = !regulator_is_enabled(in_vreg[i].vreg);
if (in_vreg[i].pre_on_sleep && need_sleep)
usleep_range(in_vreg[i].pre_on_sleep * 1000,
in_vreg[i].pre_on_sleep * 1000);
rc = regulator_set_load(in_vreg[i].vreg,
in_vreg[i].enable_load);
if (rc < 0) {
pr_err("%s set opt m fail\n",
in_vreg[i].vreg_name);
goto vreg_set_opt_mode_fail;
}
rc = regulator_enable(in_vreg[i].vreg);
if (in_vreg[i].post_on_sleep && need_sleep)
usleep_range(in_vreg[i].post_on_sleep * 1000,
in_vreg[i].post_on_sleep * 1000);
if (rc < 0) {
pr_err("%s enable failed\n",
in_vreg[i].vreg_name);
goto disable_vreg;
}
}
} else {
for (i = num_vreg-1; i >= 0; i--) {
if (in_vreg[i].pre_off_sleep)
usleep_range(in_vreg[i].pre_off_sleep * 1000,
in_vreg[i].pre_off_sleep * 1000);
regulator_set_load(in_vreg[i].vreg,
in_vreg[i].disable_load);
regulator_disable(in_vreg[i].vreg);
if (in_vreg[i].post_off_sleep)
usleep_range(in_vreg[i].post_off_sleep * 1000,
in_vreg[i].post_off_sleep * 1000);
}
}
return rc;
disable_vreg:
regulator_set_load(in_vreg[i].vreg, in_vreg[i].disable_load);
vreg_set_opt_mode_fail:
for (i--; i >= 0; i--) {
if (in_vreg[i].pre_off_sleep)
usleep_range(in_vreg[i].pre_off_sleep * 1000,
in_vreg[i].pre_off_sleep * 1000);
regulator_set_load(in_vreg[i].vreg,
in_vreg[i].disable_load);
regulator_disable(in_vreg[i].vreg);
if (in_vreg[i].post_off_sleep)
usleep_range(in_vreg[i].post_off_sleep * 1000,
in_vreg[i].post_off_sleep * 1000);
}
return rc;
}
static struct lt9611_timing_info *lt9611_get_supported_timing(
struct drm_display_mode *mode)
{
int i = 0;
while (lt9611_supp_timing_cfg[i].xres != 0xffff) {
if (lt9611_supp_timing_cfg[i].xres == mode->hdisplay &&
lt9611_supp_timing_cfg[i].yres == mode->vdisplay &&
lt9611_supp_timing_cfg[i].fps ==
drm_mode_vrefresh(mode)) {
return &lt9611_supp_timing_cfg[i];
}
i++;
}
return NULL;
}
/* TODO: intf/lane number needs info from both DSI host and client */
static int lt9611_get_intf_num(struct lt9611 *pdata,
struct drm_display_mode *mode)
{
int num_of_intfs = 0;
struct lt9611_timing_info *timing =
lt9611_get_supported_timing(mode);
if (timing)
num_of_intfs = timing->intfs;
else {
pr_err("interface number not defined by bridge chip\n");
num_of_intfs = 0;
}
return num_of_intfs;
}
static int lt9611_get_lane_num(struct lt9611 *pdata,
struct drm_display_mode *mode)
{
int num_of_lanes = 0;
struct lt9611_timing_info *timing =
lt9611_get_supported_timing(mode);
if (timing)
num_of_lanes = timing->lanes;
else {
pr_err("lane number not defined by bridge chip\n");
num_of_lanes = 0;
}
return num_of_lanes;
}
static void lt9611_get_video_cfg(struct lt9611 *pdata,
struct drm_display_mode *mode,
struct lt9611_video_cfg *video_cfg)
{
int rc = 0;
struct hdmi_avi_infoframe avi_frame;
memset(&avi_frame, 0, sizeof(avi_frame));
video_cfg->h_active = mode->hdisplay;
video_cfg->v_active = mode->vdisplay;
video_cfg->h_front_porch = mode->hsync_start - mode->hdisplay;
video_cfg->v_front_porch = mode->vsync_start - mode->vdisplay;
video_cfg->h_back_porch = mode->htotal - mode->hsync_end;
video_cfg->v_back_porch = mode->vtotal - mode->vsync_end;
video_cfg->h_pulse_width = mode->hsync_end - mode->hsync_start;
video_cfg->v_pulse_width = mode->vsync_end - mode->vsync_start;
video_cfg->pclk_khz = mode->clock;
video_cfg->h_polarity = !!(mode->flags & DRM_MODE_FLAG_PHSYNC);
video_cfg->v_polarity = !!(mode->flags & DRM_MODE_FLAG_PVSYNC);
video_cfg->num_of_lanes = lt9611_get_lane_num(pdata, mode);
video_cfg->num_of_intfs = lt9611_get_intf_num(pdata, mode);
pr_debug("video=h[%d,%d,%d,%d] v[%d,%d,%d,%d] pclk=%d lane=%d intf=%d\n",
video_cfg->h_active, video_cfg->h_front_porch,
video_cfg->h_pulse_width, video_cfg->h_back_porch,
video_cfg->v_active, video_cfg->v_front_porch,
video_cfg->v_pulse_width, video_cfg->v_back_porch,
video_cfg->pclk_khz, video_cfg->num_of_lanes,
video_cfg->num_of_intfs);
rc = drm_hdmi_avi_infoframe_from_display_mode(&avi_frame, mode, false);
if (rc) {
pr_err("get avi frame failed ret=%d\n", rc);
} else {
video_cfg->scaninfo = avi_frame.scan_mode;
video_cfg->ar = avi_frame.picture_aspect;
video_cfg->vic = avi_frame.video_code;
pr_debug("scaninfo=%d ar=%d vic=%d\n",
video_cfg->scaninfo, video_cfg->ar, video_cfg->vic);
}
}
/* connector funcs */
static enum drm_connector_status
lt9611_connector_detect(struct drm_connector *connector, bool force)
{
struct lt9611 *pdata = connector_to_lt9611(connector);
if (!pdata->non_pluggable || force) {
u8 reg_val = 0;
int connected = 0;
lt9611_write(pdata, 0xff, 0x82);
lt9611_read(pdata, 0x5e, &reg_val, 1);
connected = (reg_val & BIT(2));
pr_debug("connected = %x\n", connected);
pdata->status = connected ? connector_status_connected :
connector_status_disconnected;
} else
pdata->status = connector_status_connected;
return pdata->status;
}
static int lt9611_read_edid(struct lt9611 *pdata)
{
int ret = 0;
u8 i, j;
u8 temp = 0;
if (!pdata) {
pr_err("invalid input\n");
return -EINVAL;
}
memset(pdata->edid_buf, 0, EDID_SEG_SIZE);
lt9611_write(pdata, 0xff, 0x85);
lt9611_write(pdata, 0x03, 0xc9);
lt9611_write(pdata, 0x04, 0xa0); /* 0xA0 is EDID device address */
lt9611_write(pdata, 0x05, 0x00); /* 0x00 is EDID offset address */
lt9611_write(pdata, 0x06, 0x20); /* length for read */
lt9611_write(pdata, 0x14, 0x7f);
for (i = 0 ; i < 8 ; i++) {
lt9611_write(pdata, 0x05, i * 32); /* offset address */
lt9611_write(pdata, 0x07, 0x36);
lt9611_write(pdata, 0x07, 0x31);
lt9611_write(pdata, 0x07, 0x37);
usleep_range(5000, 10000);
lt9611_read(pdata, 0x40, &temp, 1);
if (temp & 0x02) { /*KEY_DDC_ACCS_DONE=1*/
for (j = 0; j < 32; j++) {
lt9611_read(pdata, 0x83,
&(pdata->edid_buf[i*32+j]), 1);
}
} else if (temp & 0x50) { /* DDC No Ack or Abitration lost */
pr_err("read edid failed: no ack\n");
ret = -EIO;
goto end;
} else {
pr_err("read edid failed: access not done\n");
ret = -EIO;
goto end;
}
}
pr_debug("read edid succeeded, checksum = 0x%x\n",
pdata->edid_buf[255]);
end:
lt9611_write(pdata, 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 *pdata = data;
int ret = 0;
pr_debug("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(pdata);
if (ret) {
pr_err("edid read failed\n");
return ret;
}
}
if (block % 2 == 0)
memcpy(buf, pdata->edid_buf, len);
else
memcpy(buf, pdata->edid_buf + 128, len);
return 0;
}
static void lt9611_set_preferred_mode(struct drm_connector *connector)
{
struct lt9611 *pdata = connector_to_lt9611(connector);
struct drm_display_mode *mode;
const char *string;
/* use specified mode as preferred */
if (!of_property_read_string(pdata->dev->of_node,
"lt,preferred-mode", &string)) {
list_for_each_entry(mode, &connector->probed_modes, head) {
if (!strcmp(mode->name, string))
mode->type |= DRM_MODE_TYPE_PREFERRED;
}
}
}
static int lt9611_connector_get_modes(struct drm_connector *connector)
{
struct lt9611 *pdata = connector_to_lt9611(connector);
struct drm_display_mode *mode, *m;
unsigned int count = 0;
pr_debug("get modes\n");
if (pdata->non_pluggable) {
list_for_each_entry(mode, &pdata->mode_list, head) {
m = drm_mode_duplicate(connector->dev, mode);
if (!m) {
pr_err("failed to add hdmi mode %dx%d\n",
mode->hdisplay, mode->vdisplay);
break;
}
drm_mode_probed_add(connector, m);
}
count = pdata->num_of_modes;
} else {
struct edid *edid;
if (!pdata->power_on)
lt9611_power_on(pdata, true);
edid = drm_do_get_edid(connector, lt9611_get_edid_block, pdata);
drm_mode_connector_update_edid_property(connector, edid);
count = drm_add_edid_modes(connector, edid);
pdata->hdmi_mode = drm_detect_hdmi_monitor(edid);
pr_debug("hdmi_mode = %d\n", pdata->hdmi_mode);
kfree(edid);
}
lt9611_set_preferred_mode(connector);
return count;
}
static enum drm_mode_status lt9611_connector_mode_valid(
struct drm_connector *connector, struct drm_display_mode *mode)
{
struct lt9611_timing_info *timing =
lt9611_get_supported_timing(mode);
return timing ? MODE_OK : MODE_BAD;
}
/* bridge funcs */
static void lt9611_bridge_enable(struct drm_bridge *bridge)
{
struct lt9611 *pdata = bridge_to_lt9611(bridge);
pr_debug("bridge enable\n");
if (lt9611_power_on(pdata, true)) {
pr_err("power on failed\n");
return;
}
if (lt9611_video_on(pdata, true)) {
pr_err("video on failed\n");
return;
}
}
static void lt9611_bridge_disable(struct drm_bridge *bridge)
{
struct lt9611 *pdata = bridge_to_lt9611(bridge);
pr_debug("bridge disable\n");
if (lt9611_video_on(pdata, false)) {
pr_err("video on failed\n");
return;
}
if (lt9611_power_on(pdata, false)) {
pr_err("power on failed\n");
return;
}
}
static void lt9611_bridge_mode_set(struct drm_bridge *bridge,
struct drm_display_mode *mode,
struct drm_display_mode *adj_mode)
{
struct lt9611 *pdata = bridge_to_lt9611(bridge);
struct lt9611_video_cfg *video_cfg = &pdata->video_cfg;
int ret = 0;
pr_debug("bridge mode_set: hdisplay=%d, vdisplay=%d, vrefresh=%d, clock=%d\n",
adj_mode->hdisplay, adj_mode->vdisplay,
adj_mode->vrefresh, adj_mode->clock);
drm_mode_copy(&pdata->curr_mode, adj_mode);
memset(video_cfg, 0, sizeof(struct lt9611_video_cfg));
lt9611_get_video_cfg(pdata, adj_mode, video_cfg);
/* TODO: update intf number of host */
if (video_cfg->num_of_lanes != pdata->dsi->lanes) {
mipi_dsi_detach(pdata->dsi);
pdata->dsi->lanes = video_cfg->num_of_lanes;
ret = mipi_dsi_attach(pdata->dsi);
if (ret)
pr_err("failed to change host lanes\n");
}
}
static const struct drm_connector_helper_funcs lt9611_connector_helper_funcs = {
.get_modes = lt9611_connector_get_modes,
.mode_valid = lt9611_connector_mode_valid,
};
static const struct drm_connector_funcs lt9611_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 int lt9611_bridge_attach(struct drm_bridge *bridge)
{
struct mipi_dsi_host *host;
struct mipi_dsi_device *dsi;
struct lt9611 *pdata = bridge_to_lt9611(bridge);
int ret;
const struct mipi_dsi_device_info info = { .type = "lt9611",
.channel = 0,
.node = NULL,
};
pr_debug("bridge attach\n");
if (!bridge->encoder) {
DRM_ERROR("Parent encoder object not found");
return -ENODEV;
}
ret = drm_connector_init(bridge->dev, &pdata->connector,
&lt9611_connector_funcs,
DRM_MODE_CONNECTOR_HDMIA);
if (ret) {
DRM_ERROR("Failed to initialize connector: %d\n", ret);
return ret;
}
drm_connector_helper_add(&pdata->connector,
&lt9611_connector_helper_funcs);
ret = drm_connector_register(&pdata->connector);
if (ret) {
DRM_ERROR("Failed to register connector: %d\n", ret);
return ret;
}
pdata->connector.polled = DRM_CONNECTOR_POLL_CONNECT;
ret = drm_mode_connector_attach_encoder(&pdata->connector,
bridge->encoder);
if (ret) {
DRM_ERROR("Failed to link up connector to encoder: %d\n", ret);
return ret;
}
host = of_find_mipi_dsi_host_by_node(pdata->host_node);
if (!host) {
pr_err("failed to find dsi host\n");
return -EPROBE_DEFER;
}
dsi = mipi_dsi_device_register_full(host, &info);
if (IS_ERR(dsi)) {
pr_err("failed to create dsi device\n");
ret = PTR_ERR(dsi);
goto err_dsi_device;
}
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 | MIPI_DSI_MODE_VIDEO_BLLP |
MIPI_DSI_MODE_VIDEO_EOF_BLLP;
ret = mipi_dsi_attach(dsi);
if (ret < 0) {
pr_err("failed to attach dsi to host\n");
goto err_dsi_attach;
}
pdata->dsi = dsi;
return 0;
err_dsi_attach:
mipi_dsi_device_unregister(dsi);
err_dsi_device:
return ret;
}
static void lt9611_bridge_pre_enable(struct drm_bridge *bridge)
{
struct lt9611 *pdata = bridge_to_lt9611(bridge);
pr_debug("bridge pre_enable\n");
lt9611_reset(pdata, true);
lt9611_write(pdata, 0xff, 0x80);
lt9611_write(pdata, 0xee, 0x01);
}
static bool lt9611_bridge_mode_fixup(struct drm_bridge *bridge,
const struct drm_display_mode *mode,
struct drm_display_mode *adjusted_mode)
{
pr_debug("bridge mode_fixup\n");
return true;
}
static void lt9611_bridge_post_disable(struct drm_bridge *bridge)
{
struct lt9611 *pdata = bridge_to_lt9611(bridge);
pr_debug("bridge post_disable\n");
lt9611_sleep_setup(pdata);
}
static const struct drm_bridge_funcs lt9611_bridge_funcs = {
.attach = lt9611_bridge_attach,
.mode_fixup = lt9611_bridge_mode_fixup,
.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,
};
/* sysfs */
static int lt9611_dump_debug_info(struct lt9611 *pdata)
{
if (!pdata->power_on) {
pr_err("device is not power on\n");
return -EINVAL;
}
lt9611_video_check(pdata);
lt9611_pcr_mk_debug(pdata);
lt9611_mipi_byte_clk_debug(pdata);
lt9611_read_edid(pdata);
return 0;
}
static ssize_t lt9611_dump_info_wta_attr(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct lt9611 *pdata = dev_get_drvdata(dev);
if (!pdata) {
pr_err("pdata is NULL\n");
return -EINVAL;
}
lt9611_dump_debug_info(pdata);
return count;
}
static DEVICE_ATTR(dump_info, 0200, NULL, lt9611_dump_info_wta_attr);
static struct attribute *lt9611_sysfs_attrs[] = {
&dev_attr_dump_info.attr,
NULL,
};
static struct attribute_group lt9611_sysfs_attr_grp = {
.attrs = lt9611_sysfs_attrs,
};
static int lt9611_sysfs_init(struct device *dev)
{
int rc = 0;
if (!dev) {
pr_err("%s: Invalid params\n", __func__);
return -EINVAL;
}
rc = sysfs_create_group(&dev->kobj, &lt9611_sysfs_attr_grp);
if (rc)
pr_err("%s: sysfs group creation failed %d\n", __func__, rc);
return rc;
}
static void lt9611_sysfs_remove(struct device *dev)
{
if (!dev) {
pr_err("%s: Invalid params\n", __func__);
return;
}
sysfs_remove_group(&dev->kobj, &lt9611_sysfs_attr_grp);
}
static int lt9611_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct lt9611 *pdata;
int ret = 0;
if (!client || !client->dev.of_node) {
pr_err("invalid input\n");
return -EINVAL;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("device doesn't support I2C\n");
return -ENODEV;
}
pdata = devm_kzalloc(&client->dev,
sizeof(struct lt9611), GFP_KERNEL);
if (!pdata)
return -ENOMEM;
ret = lt9611_parse_dt(&client->dev, pdata);
if (ret) {
pr_err("failed to parse device tree\n");
goto err_dt_parse;
}
ret = lt9611_get_dt_supply(&client->dev, pdata);
if (ret) {
pr_err("failed to get dt supply\n");
goto err_dt_parse;
}
pdata->dev = &client->dev;
pdata->i2c_client = client;
pr_debug("I2C address is %x\n", client->addr);
ret = lt9611_gpio_configure(pdata, true);
if (ret) {
pr_err("failed to configure GPIOs\n");
goto err_dt_supply;
}
lt9611_assert_5v(pdata, true);
ret = lt9611_enable_vreg(pdata, true);
if (ret) {
pr_err("failed to enable vreg\n");
goto err_dt_supply;
}
lt9611_reset(pdata, true);
pdata->regulator_on = true;
ret = lt9611_read_device_rev(pdata);
if (ret) {
pr_err("failed to read chip rev\n");
goto err_i2c_prog;
}
pdata->irq = gpio_to_irq(pdata->irq_gpio);
ret = request_threaded_irq(pdata->irq, NULL, lt9611_irq_thread_handler,
IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lt9611", pdata);
if (ret) {
pr_err("failed to request irq\n");
goto err_i2c_prog;
}
i2c_set_clientdata(client, pdata);
dev_set_drvdata(&client->dev, pdata);
ret = lt9611_sysfs_init(&client->dev);
if (ret) {
pr_err("sysfs init failed\n");
goto err_sysfs_init;
}
#if IS_ENABLED(CONFIG_OF)
pdata->bridge.of_node = client->dev.of_node;
#endif
pdata->bridge.funcs = &lt9611_bridge_funcs;
/*pdata->bridge.of_node = client->dev.of_node;*/
drm_bridge_add(&pdata->bridge);
pdata->wq = create_singlethread_workqueue("lt9611_wk");
if (!pdata->wq) {
pr_err("Error creating lt9611 wq\n");
return -ENOMEM;
}
INIT_WORK(&pdata->work, lt9611_hpd_work);
return 0;
err_sysfs_init:
disable_irq(pdata->irq);
free_irq(pdata->irq, pdata);
err_i2c_prog:
lt9611_gpio_configure(pdata, false);
err_dt_supply:
lt9611_put_dt_supply(&client->dev, pdata);
err_dt_parse:
devm_kfree(&client->dev, pdata);
return ret;
}
static int lt9611_remove(struct i2c_client *client)
{
int ret = -EINVAL;
struct lt9611 *pdata = i2c_get_clientdata(client);
struct drm_display_mode *mode, *n;
if (!pdata)
goto end;
mipi_dsi_detach(pdata->dsi);
mipi_dsi_device_unregister(pdata->dsi);
drm_bridge_remove(&pdata->bridge);
lt9611_sysfs_remove(&client->dev);
disable_irq(pdata->irq);
free_irq(pdata->irq, pdata);
ret = lt9611_gpio_configure(pdata, false);
lt9611_put_dt_supply(&client->dev, pdata);
if (pdata->non_pluggable) {
list_for_each_entry_safe(mode, n, &pdata->mode_list, head) {
list_del(&mode->head);
kfree(mode);
}
}
if (pdata->wq)
destroy_workqueue(pdata->wq);
devm_kfree(&client->dev, pdata);
end:
return ret;
}
static void lt9611_device_power_ctl(struct lt9611 *pdata, bool on_off)
{
int ret = 0;
lt9611_assert_5v(pdata, on_off);
ret = lt9611_enable_vreg(pdata, on_off);
if (ret)
pr_err("failed to set vreg state %d\n", on_off);
lt9611_reset(pdata, on_off);
}
#ifdef CONFIG_PM_SLEEP
static int lt9611_suspend(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct lt9611 *pdata = i2c_get_clientdata(client);
if (pdata->regulator_on) {
disable_irq(pdata->irq);
lt9611_device_power_ctl(pdata, false);
pdata->regulator_on = false;
}
return 0;
}
static int lt9611_resume(struct device *dev)
{
struct i2c_client *client = to_i2c_client(dev);
struct lt9611 *pdata = i2c_get_clientdata(client);
if (!pdata->regulator_on) {
lt9611_device_power_ctl(pdata, true);
enable_irq(pdata->irq);
pdata->regulator_on = true;
}
return 0;
}
static const struct dev_pm_ops lt9611_pm = {
SET_SYSTEM_SLEEP_PM_OPS(lt9611_suspend, lt9611_resume)
};
#endif
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",
.owner = THIS_MODULE,
#ifdef CONFIG_OF
.of_match_table = lt9611_match_table,
#endif
#ifdef CONFIG_PM_SLEEP
.pm = &lt9611_pm,
#endif
},
.probe = lt9611_probe,
.remove = lt9611_remove,
.id_table = lt9611_id,
};
static int __init lt9611_init(void)
{
return i2c_add_driver(&lt9611_driver);
}
static void __exit lt9611_exit(void)
{
i2c_del_driver(&lt9611_driver);
}
module_init(lt9611_init);
module_exit(lt9611_exit);