#include <linux/seq_file.h>
#endif
-//#define EDP_BIST_MODE
-
+/*#define EDP_BIST_MODE*/
+/*#define SW_LT*/
static struct rk32_edp *rk32_edp;
static int rk32_edp_clk_enable(struct rk32_edp *edp)
{
if (!edp->clk_on) {
- clk_enable(edp->pd);
- clk_enable(edp->pclk);
- clk_enable(edp->clk_edp);
- clk_enable(edp->clk_24m);
+ clk_prepare_enable(edp->pd);
+ clk_prepare_enable(edp->pclk);
+ clk_prepare_enable(edp->clk_edp);
+ clk_prepare_enable(edp->clk_24m);
edp->clk_on = true;
}
static int rk32_edp_clk_disable(struct rk32_edp *edp)
{
if (edp->clk_on) {
- clk_disable(edp->pclk);
- clk_disable(edp->clk_edp);
- clk_disable(edp->clk_24m);
- clk_disable(edp->pd);
+ clk_disable_unprepare(edp->pclk);
+ clk_disable_unprepare(edp->clk_edp);
+ clk_disable_unprepare(edp->clk_24m);
+ clk_disable_unprepare(edp->pd);
edp->clk_on = false;
}
static int rk32_edp_pre_init(void)
{
u32 val;
- val = GRF_EDP_REF_CLK_SEL_INTER |
- (GRF_EDP_REF_CLK_SEL_INTER << 16);
+ val = GRF_EDP_REF_CLK_SEL_INTER | (GRF_EDP_REF_CLK_SEL_INTER << 16);
writel_relaxed(val, RK_GRF_VIRT + RK3288_GRF_SOC_CON12);
val = 0x80008000;
{
struct rk_screen *screen = &edp->screen;
u32 val = 0;
-
- screen->lcdc_id = 1;
+
+ rk_fb_get_prmry_screen(screen);
if (screen->lcdc_id == 1) /*select lcdc*/
val = EDP_SEL_VOP_LIT | (EDP_SEL_VOP_LIT << 16);
else
val = EDP_SEL_VOP_LIT << 16;
writel_relaxed(val, RK_GRF_VIRT + RK3288_GRF_SOC_CON6);
-
rk32_edp_reset(edp);
rk32_edp_init_refclk(edp);
rk32_edp_init_interrupt(edp);
-
rk32_edp_enable_sw_function(edp);
-
rk32_edp_init_analog_func(edp);
-
rk32_edp_init_hpd(edp);
rk32_edp_init_aux(edp);
return 0;
}
+#if 0
static int rk32_edp_detect_hpd(struct rk32_edp *edp)
{
int timeout_loop = 0;
return 0;
}
-
+#endif
static int rk32_edp_read_edid(struct rk32_edp *edp)
{
unsigned char edid[EDID_LENGTH * 2];
*/
/* Read Extension Flag, Number of 128-byte EDID extension blocks */
- retval = rk32_edp_read_byte_from_i2c(edp, EDID_ADDR, EDID_EXTENSION_FLAG,
- &extend_block);
+ retval = rk32_edp_read_byte_from_i2c(edp,
+ EDID_ADDR, EDID_EXTENSION_FLAG, &extend_block);
if (retval < 0) {
dev_err(edp->dev, "EDID extension flag failed!\n");
return -EIO;
dev_dbg(edp->dev, "EDID data includes a single extension!\n");
/* Read EDID data */
- retval = rk32_edp_read_bytes_from_i2c(edp, EDID_ADDR, EDID_HEADER,
- EDID_LENGTH, &edid[EDID_HEADER]);
+ retval = rk32_edp_read_bytes_from_i2c(edp,
+ EDID_ADDR, EDID_HEADER,
+ EDID_LENGTH, &edid[EDID_HEADER]);
if (retval != 0) {
dev_err(edp->dev, "EDID Read failed!\n");
return -EIO;
}
/* Read additional EDID data */
- retval = rk32_edp_read_bytes_from_i2c(edp, EDID_ADDR, EDID_LENGTH,
- EDID_LENGTH, &edid[EDID_LENGTH]);
+ retval = rk32_edp_read_bytes_from_i2c(edp,
+ EDID_ADDR, EDID_LENGTH,
+ EDID_LENGTH, &edid[EDID_LENGTH]);
if (retval != 0) {
dev_err(edp->dev, "EDID Read failed!\n");
return -EIO;
return 0;
}
- retval = rk32_edp_read_byte_from_dpcd(edp, DPCD_TEST_REQUEST,
- &test_vector);
+ retval = rk32_edp_read_byte_from_dpcd(edp,
+ DPCD_TEST_REQUEST, &test_vector);
if (retval < 0) {
dev_err(edp->dev, "DPCD EDID Read failed!\n");
return retval;
dev_info(edp->dev, "EDID data does not include any extensions.\n");
/* Read EDID data */
- retval = rk32_edp_read_bytes_from_i2c(edp, EDID_ADDR, EDID_HEADER,
- EDID_LENGTH, &edid[EDID_HEADER]);
+ retval = rk32_edp_read_bytes_from_i2c(edp,
+ EDID_ADDR, EDID_HEADER,
+ EDID_LENGTH, &edid[EDID_HEADER]);
if (retval != 0) {
dev_err(edp->dev, "EDID Read failed!\n");
return -EIO;
return 0;
}
- retval = rk32_edp_read_byte_from_dpcd(edp,DPCD_TEST_REQUEST,
- &test_vector);
+ retval = rk32_edp_read_byte_from_dpcd(edp,
+ DPCD_TEST_REQUEST, &test_vector);
if (retval < 0) {
dev_err(edp->dev, "DPCD EDID Read failed!\n");
return retval;
return 0;
}
+#if 0
static int rk32_edp_handle_edid(struct rk32_edp *edp)
{
u8 buf[12];
if (retval < 0)
return retval;
- for (i=0 ;i < 12; i++)
+ for (i = 0; i < 12; i++)
dev_info(edp->dev, "%d:>>0x%02x\n", i, buf[i]);
/* Read EDID */
for (i = 0; i < 3; i++) {
return retval;
}
+
static int rk32_edp_enable_rx_to_enhanced_mode(struct rk32_edp *edp,
bool enable)
{
}*/
}
+
static int rk32_edp_is_enhanced_mode_available(struct rk32_edp *edp)
{
u8 data;
return DPCD_ENHANCED_FRAME_CAP(data);
}
+
static void rk32_edp_disable_rx_zmux(struct rk32_edp *edp)
{
/*rk32_edp_write_byte_to_dpcd(edp,
return 0;
}
+#endif
+#if defined(SW_LT)
static int rk32_edp_training_pattern_dis(struct rk32_edp *edp)
{
int retval;
rk32_edp_reduce_link_rate(edp);
return -EIO;
}
-
+#endif
static int rk32_edp_get_max_rx_bandwidth(struct rk32_edp *edp,
u8 *bandwidth)
{
*/
rk32_edp_reset_macro(edp);
-
- retval = rk32_edp_get_max_rx_bandwidth(edp, &edp->link_train.link_rate);
- retval = rk32_edp_get_max_rx_lane_count(edp, &edp->link_train.lane_count);
+
+ retval = rk32_edp_get_max_rx_bandwidth(edp,
+ &edp->link_train.link_rate);
+ retval = rk32_edp_get_max_rx_lane_count(edp,
+ &edp->link_train.lane_count);
dev_info(edp->dev, "max link rate:%d.%dGps max number of lanes:%d\n",
edp->link_train.link_rate * 27/100,
edp->link_train.link_rate*27%100,
edp->link_train.lane_count);
-
+
if ((edp->link_train.link_rate != LINK_RATE_1_62GBPS) &&
(edp->link_train.link_rate != LINK_RATE_2_70GBPS)) {
dev_warn(edp->dev, "Rx Max Link Rate is abnormal :%x !"
}
rk32_edp_analog_power_ctr(edp, 1);
-
+
return 0;
}
+#if defined(SW_LT)
static int rk32_edp_sw_link_training(struct rk32_edp *edp)
{
int retval = 0;
return retval;
}
-
+#else
static int rk32_edp_hw_link_training(struct rk32_edp *edp)
{
u32 cnt = 50;
mdelay(1);
val = rk32_edp_wait_hw_lt_done(edp);
}
-
+
val = rk32_edp_get_hw_lt_status(edp);
if (val)
dev_err(edp->dev, "hw lt err:%d\n", val);
return val;
-
+
}
+#endif
+
static int rk32_edp_set_link_train(struct rk32_edp *edp)
{
int retval;
retval = rk32_edp_init_training(edp);
if (retval < 0)
dev_err(edp->dev, "DP LT init failed!\n");
-#if 0
+#if defined(SW_LT)
retval = rk32_edp_sw_link_training(edp);
#else
retval = rk32_edp_hw_link_training(edp);
return -ETIMEDOUT;
}
- usleep_range(1, 1);
+ udelay(1);
}
/* Set to use the register calculated M/N video */
return -ETIMEDOUT;
}
- usleep_range(1000, 1000);
+ mdelay(1);
}
if (retval != 0)
return retval;
}
+#if 0
static int rk32_edp_enable_scramble(struct rk32_edp *edp, bool enable)
{
u8 data;
return 0;
}
+#endif
static irqreturn_t rk32_edp_isr(int irq, void *arg)
{
{
int ret = 0;
struct rk32_edp *edp = rk32_edp;
-
+
rk32_edp_clk_enable(edp);
rk32_edp_pre_init();
//goto out;
}
-
+
ret = rk32_edp_enable_scramble(edp, 0);
if (ret) {
dev_err(edp->dev, "unable to set scramble\n");
rk32_edp_enable_enhanced_mode(edp, 1);*/
ret = rk32_edp_set_link_train(edp);
- if (ret)
+ if (ret)
dev_err(edp->dev, "link train failed!\n");
- else
+ else
dev_info(edp->dev, "link training success.\n");
rk32_edp_set_lane_count(edp, edp->link_train.lane_count);
return ret;
-
+
}
-
-static int rk32_edp_disable(void )
+
+static int rk32_edp_disable(void)
{
struct rk32_edp *edp = rk32_edp;
rk32_edp_reset(edp);
rk32_edp_analog_power_ctr(edp, 0);
rk32_edp_clk_disable(edp);
-
+
return 0;
}
dev_err(edp->dev, "no edp device!\n");
return -ENODEV;
}
-
-
+
+
rk32_edp_read_bytes_from_dpcd(edp,
DPCD_SYMBOL_ERR_CONUT_LANE0, 12, buf);
- for (i=0;i< 12;i++) {
- seq_printf(s,"0x%02x>>0x%02x\n",0x210 + i, buf[i]);
- }
+ for (i = 0; i < 12; i++)
+ seq_printf(s, "0x%02x>>0x%02x\n", 0x210 + i, buf[i]);
return 0;
}
+static ssize_t edp_dpcd_write (struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+ return count;
+}
+
static int edp_edid_debugfs_show(struct seq_file *s, void *v)
{
- int i = 0;
- unsigned char buf[12];
struct rk32_edp *edp = s->private;
if (!edp) {
dev_err(edp->dev, "no edp device!\n");
return -ENODEV;
}
- seq_printf(s,"edid");
+ rk32_edp_read_edid(edp);
+ seq_puts(s, "edid");
return 0;
}
+static ssize_t edp_edid_write (struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+ struct rk32_edp *edp = ((struct seq_file *)file->private_data)->private;
+ if (!edp) {
+ dev_err(edp->dev, "no edp device!\n");
+ return -ENODEV;
+ }
+ rk32_edp_disable();
+ rk32_edp_enable();
+ return count;
+}
+
static int edp_reg_debugfs_show(struct seq_file *s, void *v)
{
int i = 0;
return 0;
}
+static ssize_t edp_reg_write (struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+ return count;
+}
#define EDP_DEBUG_ENTRY(name) \
static int edp_##name##_debugfs_open(struct inode *inode, struct file *file) \
.owner = THIS_MODULE, \
.open = edp_##name##_debugfs_open, \
.read = seq_read, \
+ .write = edp_##name##_write, \
.llseek = seq_lseek, \
.release = single_release, \
}
-EDP_DEBUG_ENTRY(dpcd);
+EDP_DEBUG_ENTRY(dpcd);
EDP_DEBUG_ENTRY(edid);
EDP_DEBUG_ENTRY(reg);
-
#endif
static int rk32_edp_probe(struct platform_device *pdev)
}
platform_set_drvdata(pdev, edp);
dev_set_name(edp->dev, "rk32-edp");
-
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
edp->regs = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(edp->regs)) {
return PTR_ERR(edp->regs);
}
- edp->pd = devm_clk_get(&pdev->dev,"pd_edp");
- if (IS_ERR(edp->pd)) {
+ edp->pd = devm_clk_get(&pdev->dev, "pd_edp");
+ if (IS_ERR(edp->pd))
dev_err(&pdev->dev, "cannot get pd\n");
- }
- edp->clk_edp = devm_clk_get(&pdev->dev,"clk_edp");
+ edp->clk_edp = devm_clk_get(&pdev->dev, "clk_edp");
if (IS_ERR(edp->clk_edp)) {
dev_err(&pdev->dev, "cannot get clk_edp\n");
return PTR_ERR(edp->clk_edp);
}
- edp->clk_24m = devm_clk_get(&pdev->dev,"clk_edp_24m");
+ edp->clk_24m = devm_clk_get(&pdev->dev, "clk_edp_24m");
if (IS_ERR(edp->clk_24m)) {
dev_err(&pdev->dev, "cannot get clk_edp_24m\n");
return PTR_ERR(edp->clk_24m);
}
- edp->pclk = devm_clk_get(&pdev->dev,"pclk_edp");
+ edp->pclk = devm_clk_get(&pdev->dev, "pclk_edp");
if (IS_ERR(edp->pclk)) {
dev_err(&pdev->dev, "cannot get pclk\n");
return PTR_ERR(edp->pclk);
}
- clk_prepare(edp->pd);
- clk_prepare(edp->pclk);
- clk_prepare(edp->clk_edp);
- clk_prepare(edp->clk_24m);
rk32_edp_clk_enable(edp);
if (!support_uboot_display())
rk32_edp_pre_init();
if (IS_ERR(edp->debugfs_dir)) {
dev_err(edp->dev, "failed to create debugfs dir for edp!\n");
} else {
- debugfs_create_file("dpcd", S_IRUSR,edp->debugfs_dir,
+ debugfs_create_file("dpcd", S_IRUSR, edp->debugfs_dir,
edp, &edp_dpcd_debugfs_fops);
- debugfs_create_file("edid", S_IRUSR,edp->debugfs_dir,
+ debugfs_create_file("edid", S_IRUSR, edp->debugfs_dir,
edp, &edp_edid_debugfs_fops);
- debugfs_create_file("reg", S_IRUSR,edp->debugfs_dir,
+ debugfs_create_file("reg", S_IRUSR, edp->debugfs_dir,
edp, &edp_reg_debugfs_fops);
}
-
+
#endif
dev_info(&pdev->dev, "rk32 edp driver probe success\n");