imx6 lvds 代码分析

查看imx6 kernel中lvds设备和驱动的初始化过程。

相关文档:
  arm/arm/mach-mx6/board-mx6q_sabresd.c

  kernel/drivers/video/mxc/ldb.c

设备初始化

arm/arm/mach-mx6/board-mx6q_sabresd.c
MACHINE_START(MX6Q_SABRESD, "Freescale i.MX 6Quad/DualLite/Solo Sabre-SD Board")
    /* Maintainer: Freescale Semiconductor, Inc. */
    .boot_params = MX6_PHYS_OFFSET + 0x100,
    .fixup = fixup_mxc_board,
    .map_io = mx6_map_io,
    .init_irq = mx6_init_irq,
    .init_machine = mx6_sabresd_board_init,    ----------+
    .timer = &mx6_sabresd_timer,                         |
    .reserve = mx6q_sabresd_reserve,                     |
MACHINE_END                                              |
                                                         |
// board-mx6q_sabresd.c                                  |
static void __init mx6_sabresd_board_init(void)      <---+
{                            ------------------------------+
    ......                  /                              |
    imx6q_add_ipuv3(0, &ipu_data[0]);          ---+        |   // ipu
                                                  |        |
    imx6q_add_ldb(&ldb_data);            ----------------------------+   //ldb
    ......                                        |        |         |
}                                                 |        |         |
                                                  V        |         |
#define imx6q_add_ipuv3(id, pdata) \                       |         |
    imx_add_ipuv3(id, &imx6q_ipuv3_data[id], pdata)        |         |
                                                           |         |
struct platform_device *__init imx_add_ipuv3(              |         |
        const int id,                                      |         |
        const struct imx_ipuv3_data *data,                 |         |
        struct imx_ipuv3_platform_data *pdata)             |         |
{                                                          |         |
    struct resource res[] = {                              |         |
        {                                                  |         |
            .start = data->iobase,                         |         |
            .end = data->iobase + data->iosize - 1,        |         |
            .flags = IORESOURCE_MEM,                       |         |
        }, {                                               |         |
            .start = data->irq_err,                        |         |
            .end = data->irq_err,                          |         |
            .flags = IORESOURCE_IRQ,                       |         |
        }, {                                               |         |
            .start = data->irq,                            |         |
            .end = data->irq,                              |         |
            .flags = IORESOURCE_IRQ,                       |         |
        },                                                 |         |
    };                                                     |         |
                                                           |         |
    pdata->init = data->init;                              |         |
    pdata->pg = data->pg;                                  |         |
                                                           |         |
    return imx_add_platform_device_dmamask("imx-ipuv3", id,|         |
            res, ARRAY_SIZE(res), pdata, sizeof(*pdata),   |         |
            DMA_BIT_MASK(32));                             |         |
}                                                          |         |
                                                           |         |
static struct imx_ipuv3_platform_data ipu_data[] = {    <--+         |
    {                                                                |
    .rev = 4,                                                        |
    .csi_clk[0] = "clko_clk",                                        |
    .bypass_reset = false,                                           |
    }, {                                                             |
    .rev = 4,                                                        |
    .csi_clk[0] = "clko_clk",                                        |
    .bypass_reset = false,                                           |
    },                                                               |
};                                                                   |
                                                                     |
#define imx6q_add_ldb(pdata) \                         <-------------+
    imx_add_ldb(&imx6q_ldb_data, pdata);                             |
                                                                     |
struct platform_device *__init imx_add_ldb(                          |
        const struct imx_ldb_data *data,                             |
        struct fsl_mxc_ldb_platform_data *pdata)                     |
{                                                                    |
    struct resource res[] = {                                        |
        {                                                            |
            .start = data->iobase,                                   |
            .end = data->iobase + data->iosize - 1,                  |
            .flags = IORESOURCE_MEM,                                 |
        },                                                           |
    };                                                               |
                                                                     |
    return imx_add_platform_device("mxc_ldb", -1,                    |
            res, ARRAY_SIZE(res), pdata, sizeof(*pdata));            |
}                                                                    |
                                                                     |
static struct fsl_mxc_ldb_platform_data ldb_data = {          <------+
    .ipu_id = 0,
    .disp_id = 1,
    .ext_ref = 1,
    .mode = LDB_SEP1,
    .sec_ipu_id = 0,
    .sec_disp_id = 0,
};

驱动初始化

kernel/drivers/video/mxc/ldb.c

static int __init ldb_init(void)
{
    return platform_driver_register(&mxcldb_driver);      -----+
}                                                              |
                                                               |
static struct platform_driver mxcldb_driver = {            <---+
    .driver = {
           .name = "mxc_ldb",
           },
    .probe = ldb_probe,                              -----+
    .remove = ldb_remove,                                 |
    .suspend = ldb_suspend,                               |
    .resume = ldb_resume,                                 |
};                                                        |
                                                          |
static int ldb_probe(struct platform_device *pdev)    <---+
{
    int ret = 0;
    struct ldb_data *ldb;

    ldb = kzalloc(sizeof(struct ldb_data), GFP_KERNEL);
    if (!ldb) {
        ret = -ENOMEM;
        goto alloc_failed;
    }
                                              +------------------+
    ldb->pdev = pdev;                         |                  |
    ldb->disp_ldb = mxc_dispdrv_register(&ldb_drv);              |
    mxc_dispdrv_setdata(ldb->disp_ldb, ldb);                     |
                                                                 |
    dev_set_drvdata(&pdev->dev, ldb);                            |
                                                                 |
    /*                                                           |
     * Disable HannStar touch panel CABC function,               |
     * this function turns the panel's backlight automatically   |
     * according to the content shown on the panel which         |
     * may cause annoying unstable backlight issue.              |
     *                                                           |
     */                                                          |
                                                                 |
alloc_failed:                                                    |
    return ret;                                                  |
}                                                                |
                                                                 |
                                                                 |
static struct mxc_dispdrv_driver ldb_drv = {             <-------+
    .name     = DISPDRV_LDB,
    .init     = ldb_disp_init,           ----------------------+
    .deinit    = ldb_disp_deinit,                              |
    .setup = ldb_disp_setup,             ----------------------------------------------+
};                                                             |                       |
                                                               |                       |
static int ldb_disp_init(struct mxc_dispdrv_handle *disp,   <--+                       |
    struct mxc_dispdrv_setting *setting)                                               |
{                                                                                      |
    int ret = 0, i;                                                                    |
    struct ldb_data *ldb = mxc_dispdrv_getdata(disp);                                  |
    struct fsl_mxc_ldb_platform_data *plat_data = ldb->pdev->dev.platform_data;        |
    struct i2c_client *i2c_dev;                                                        |
    struct resource *res;                                                              |
    uint32_t base_addr;                                                                |
    uint32_t reg, setting_idx;                                                         |
    uint32_t ch_mask = 0, ch_val = 0;                                                  |
    int lvds_channel = 0;                                                              |
    uint32_t ipu_id, disp_id;                                                          |
                                                                                       |
    /* if input format not valid, make RGB666 as default*/                             |
    if (!valid_mode(setting->if_fmt)) {                                                |
        dev_warn(&ldb->pdev->dev, "Input pixel format not valid"                       |
                    " use default RGB666\n");                                          |
        setting->if_fmt = IPU_PIX_FMT_RGB666;                                          |
    }                                                                                  |
    //初始化                                                                           |
    if (!ldb->inited) {                                                                |
        char di_clk[] = "ipu1_di0_clk";                                                |
        char ldb_clk[] = "ldb_di0_clk";                                                |
                                                                                       |
        setting_idx = 0;                                                               |
        res = platform_get_resource(ldb->pdev, IORESOURCE_MEM, 0);                     |
        if (IS_ERR(res))                                                               |
            return -ENOMEM;                                                            |
                                                                                       |
        base_addr = res->start;                                                        |
        ldb->reg = ioremap(base_addr, res->end - res->start + 1);                      |
        ldb->control_reg = ldb->reg + 2;                                               |
        ldb->gpr3_reg = ldb->reg + 3;                                                  |
                                                                                       |
        ldb->lvds_bg_reg = regulator_get(&ldb->pdev->dev, plat_data->lvds_bg_reg);     |
        if (!IS_ERR(ldb->lvds_bg_reg)) {                                               |
            regulator_set_voltage(ldb->lvds_bg_reg, 2500000, 2500000);                 |
            regulator_enable(ldb->lvds_bg_reg);                                        |
        }                                                                              |
                                                                                       |
        /* ipu selected by platform data setting */                                    |
        setting->dev_id = plat_data->ipu_id;                                           |
                                                                                       |
        reg = readl(ldb->control_reg);                                                 |
        //ldb参考电阻选择                                                              |
        /* refrence resistor select */                                                 |
        reg &= ~LDB_BGREF_RMODE_MASK;                                                  |
        if (plat_data->ext_ref)                                                        |
            reg |= LDB_BGREF_RMODE_EXT;                                                |
        else                                                                           |
            reg |= LDB_BGREF_RMODE_INT;                                                |
        //使用SPWG标准对数据进行映射                                                   |
        /* TODO: now only use SPWG data mapping for both channel */                    |
        reg &= ~(LDB_BIT_MAP_CH0_MASK | LDB_BIT_MAP_CH1_MASK);                         |
        reg |= LDB_BIT_MAP_CH0_SPWG | LDB_BIT_MAP_CH1_SPWG;                            |
                                                                                       |
        /* channel mode setting */                                                     |
        reg &= ~(LDB_CH0_MODE_MASK | LDB_CH1_MODE_MASK);                               |
        reg &= ~(LDB_DATA_WIDTH_CH0_MASK | LDB_DATA_WIDTH_CH1_MASK);                   |
        //指定数据宽度,24bit或者18bit                                                 |
        if (bits_per_pixel(setting->if_fmt) == 24)                                     |
            reg |= LDB_DATA_WIDTH_CH0_24 | LDB_DATA_WIDTH_CH1_24;                      |
        else                                                                           |
            reg |= LDB_DATA_WIDTH_CH0_18 | LDB_DATA_WIDTH_CH1_18;                      |
                                                                                       |
        if (g_ldb_mode)                                                                |
            ldb->mode = g_ldb_mode;                                                    |
        else                                                                           |
            ldb->mode = plat_data->mode;                                               |
        //single mode                                                                  |
        if ((ldb->mode == LDB_SIN0) || (ldb->mode == LDB_SIN1)) {                      |
            ret = ldb->mode - LDB_SIN0;                                                |
            if (plat_data->disp_id != ret) {                                           |
                dev_warn(&ldb->pdev->dev,                                              |
                    "change IPU DI%d to IPU DI%d for LDB "                             |
                    "channel%d.\n",                                                    |
                    plat_data->disp_id, ret, ret);                                     |
                plat_data->disp_id = ret;                                              |
            }                                                                          |
        // separate mode                                                               |
        } else if (((ldb->mode == LDB_SEP0) || (ldb->mode == LDB_SEP1))                |
                && (cpu_is_mx6q() || cpu_is_mx6dl())) {                                |
            if (plat_data->disp_id == plat_data->sec_disp_id) {                        |
                dev_err(&ldb->pdev->dev,                                               |
                    "For LVDS separate mode,"                                          |
                    "two DIs should be different!\n");                                 |
                return -EINVAL;                                                        |
            }                                                                          |
                                                                                       |
            if (((!plat_data->disp_id) && (ldb->mode == LDB_SEP1))                     |
                || ((plat_data->disp_id) &&                                            |
                    (ldb->mode == LDB_SEP0))) {                                        |
                dev_dbg(&ldb->pdev->dev,                                               |
                    "LVDS separate mode:"                                              |
                    "swap DI configuration!\n");                                       |
                ipu_id = plat_data->ipu_id;                                            |
                disp_id = plat_data->disp_id;                                          |
                plat_data->ipu_id = plat_data->sec_ipu_id;                             |
                plat_data->disp_id = plat_data->sec_disp_id;                           |
                plat_data->sec_ipu_id = ipu_id;                                        |
                plat_data->sec_disp_id = disp_id;                                      |
            }                                                                          |
        }                                                                              |
        // split mode                                                                  |
        if (ldb->mode == LDB_SPL_DI0) {                                                |
            reg |= LDB_SPLIT_MODE_EN | LDB_CH0_MODE_EN_TO_DI0                          |
                | LDB_CH1_MODE_EN_TO_DI0;                                              |
            setting->disp_id = 0;                                                      |
        } else if (ldb->mode == LDB_SPL_DI1) {                                         |
            reg |= LDB_SPLIT_MODE_EN | LDB_CH0_MODE_EN_TO_DI1                          |
                | LDB_CH1_MODE_EN_TO_DI1;                                              |
            setting->disp_id = 1;                                                      |
        } else if (ldb->mode == LDB_DUL_DI0) {                                         |
            reg &= ~LDB_SPLIT_MODE_EN;                                                 |
            reg |= LDB_CH0_MODE_EN_TO_DI0 | LDB_CH1_MODE_EN_TO_DI0;                    |
            setting->disp_id = 0;                                                      |
        } else if (ldb->mode == LDB_DUL_DI1) {                                         |
            reg &= ~LDB_SPLIT_MODE_EN;                                                 |
            reg |= LDB_CH0_MODE_EN_TO_DI1 | LDB_CH1_MODE_EN_TO_DI1;                    |
            setting->disp_id = 1;                                                      |
        } else if (ldb->mode == LDB_SIN0) {                                            |
            reg &= ~LDB_SPLIT_MODE_EN;                                                 |
            setting->disp_id = plat_data->disp_id;                                     |
            if (setting->disp_id == 0)                                                 |
                reg |= LDB_CH0_MODE_EN_TO_DI0;                                         |
            else                                                                       |
                reg |= LDB_CH0_MODE_EN_TO_DI1;                                         |
            ch_mask = LDB_CH0_MODE_MASK;                                               |
            ch_val = reg & LDB_CH0_MODE_MASK;                                          |
        } else if (ldb->mode == LDB_SIN1) {                                            |
            reg &= ~LDB_SPLIT_MODE_EN;                                                 |
            setting->disp_id = plat_data->disp_id;                                     |
            if (setting->disp_id == 0)                                                 |
                reg |= LDB_CH1_MODE_EN_TO_DI0;                                         |
            else                                                                       |
                reg |= LDB_CH1_MODE_EN_TO_DI1;                                         |
            ch_mask = LDB_CH1_MODE_MASK;                                               |
            ch_val = reg & LDB_CH1_MODE_MASK;                                          |
        } else { /* separate mode*/                                                    |
        // dual mode                                                                   |
            setting->disp_id = plat_data->disp_id;                                     |
                                                                                       |
            /* first output is LVDS0 or LVDS1 */                                       |
            if (ldb->mode == LDB_SEP0)                                                 |
                lvds_channel = 0;                                                      |
            else                                                                       |
                lvds_channel = 1;                                                      |
                                                                                       |
            reg &= ~LDB_SPLIT_MODE_EN;                                                 |
                                                                                       |
            if ((lvds_channel == 0) && (setting->disp_id == 0))                        |
                reg |= LDB_CH0_MODE_EN_TO_DI0;                                         |
            else if ((lvds_channel == 0) && (setting->disp_id == 1))                   |
                reg |= LDB_CH0_MODE_EN_TO_DI1;                                         |
            else if ((lvds_channel == 1) && (setting->disp_id == 0))                   |
                reg |= LDB_CH1_MODE_EN_TO_DI0;                                         |
            else                                                                       |
                reg |= LDB_CH1_MODE_EN_TO_DI1;                                         |
            ch_mask = lvds_channel ? LDB_CH1_MODE_MASK :                               |
                    LDB_CH0_MODE_MASK;                                                 |
            ch_val = reg & ch_mask;                                                    |
                                                                                       |
            if (bits_per_pixel(setting->if_fmt) == 24) {                               |
                if (lvds_channel == 0)                                                 |
                    reg &= ~LDB_DATA_WIDTH_CH1_24;                                     |
                else                                                                   |
                    reg &= ~LDB_DATA_WIDTH_CH0_24;                                     |
            } else {                                                                   |
                if (lvds_channel == 0)                                                 |
                    reg &= ~LDB_DATA_WIDTH_CH1_18;                                     |
                else                                                                   |
                    reg &= ~LDB_DATA_WIDTH_CH0_18;                                     |
            }                                                                          |
        }                                                                              |
                                                                                       |
        writel(reg, ldb->control_reg);                                                 |
        if (ldb->mode <  LDB_SIN0) {                                                   |
            ch_mask = LDB_CH0_MODE_MASK | LDB_CH1_MODE_MASK;                           |
            ch_val = reg & (LDB_CH0_MODE_MASK | LDB_CH1_MODE_MASK);                    |
        }                                                                              |
                                                                                       |
        /* clock setting */                                                            |
        if ((cpu_is_mx6q() || cpu_is_mx6dl()) &&                                       |
            ((ldb->mode == LDB_SEP0) || (ldb->mode == LDB_SEP1)))                      |
            ldb_clk[6] += lvds_channel;                                                |
        else                                                                           |
            ldb_clk[6] += setting->disp_id;                                            |
        ldb->setting[setting_idx].ldb_di_clk = clk_get(&ldb->pdev->dev,                |
                                ldb_clk);                                              |
        if (IS_ERR(ldb->setting[setting_idx].ldb_di_clk)) {                            |
            dev_err(&ldb->pdev->dev, "get ldb clk0 failed\n");                         |
            iounmap(ldb->reg);                                                         |
            return PTR_ERR(ldb->setting[setting_idx].ldb_di_clk);                      |
        }                                                                              |
        di_clk[3] += setting->dev_id;                                                  |
        di_clk[7] += setting->disp_id;                                                 |
        ldb->setting[setting_idx].di_clk = clk_get(&ldb->pdev->dev,                    |
                                di_clk);                                               |
        if (IS_ERR(ldb->setting[setting_idx].di_clk)) {                                |
            dev_err(&ldb->pdev->dev, "get di clk0 failed\n");                          |
            iounmap(ldb->reg);                                                         |
            return PTR_ERR(ldb->setting[setting_idx].di_clk);                          |
        }                                                                              |
                                                                                       |
        dev_dbg(&ldb->pdev->dev, "ldb_clk to di clk: %s -> %s\n", ldb_clk, di_clk);    |
                                                                                       |
        /* fb notifier for clk setting */                                              |
        ldb->nb.notifier_call = ldb_fb_event,                                          |
        ret = fb_register_client(&ldb->nb);                                            |
        if (ret < 0) {                                                                 |
            iounmap(ldb->reg);                                                         |
            return ret;                                                                |
        }                                                                              |
                                                                                       |
        ldb->inited = true;                                                            |
                                                                                       |
        i2c_dev = ldb_i2c_client[lvds_channel];                                        |
                                                                                       |
    } else { /* second time for separate mode */                                       |
        char di_clk[] = "ipu1_di0_clk";                                                |
        char ldb_clk[] = "ldb_di0_clk";                                                |
                                                                                       |
        if ((ldb->mode == LDB_SPL_DI0) ||                                              |
            (ldb->mode == LDB_SPL_DI1) ||                                              |
            (ldb->mode == LDB_DUL_DI0) ||                                              |
            (ldb->mode == LDB_DUL_DI1) ||                                              |
            (ldb->mode == LDB_SIN0) ||                                                 |
            (ldb->mode == LDB_SIN1)) {                                                 |
            dev_err(&ldb->pdev->dev, "for second ldb disp"                             |
                    "ldb mode should in separate mode\n");                             |
            return -EINVAL;                                                            |
        }                                                                              |
                                                                                       |
        setting_idx = 1;                                                               |
        if (cpu_is_mx6q() || cpu_is_mx6dl()) {                                         |
            setting->dev_id = plat_data->sec_ipu_id;                                   |
            setting->disp_id = plat_data->sec_disp_id;                                 |
        } else {                                                                       |
            setting->dev_id = plat_data->ipu_id;                                       |
            setting->disp_id = !plat_data->disp_id;                                    |
        }                                                                              |
        if (setting->disp_id == ldb->setting[0].di) {                                  |
            dev_err(&ldb->pdev->dev, "Err: for second ldb disp in"                     |
                "separate mode, DI should be different!\n");                           |
            return -EINVAL;                                                            |
        }                                                                              |
                                                                                       |
        /* second output is LVDS0 or LVDS1 */                                          |
        if (ldb->mode == LDB_SEP0)                                                     |
            lvds_channel = 1;                                                          |
        else                                                                           |
            lvds_channel = 0;                                                          |
                                                                                       |
        reg = readl(ldb->control_reg);                                                 |
        if ((lvds_channel == 0) && (setting->disp_id == 0))                            |
            reg |= LDB_CH0_MODE_EN_TO_DI0;                                             |
        else if ((lvds_channel == 0) && (setting->disp_id == 1))                       |
            reg |= LDB_CH0_MODE_EN_TO_DI1;                                             |
        else if ((lvds_channel == 1) && (setting->disp_id == 0))                       |
            reg |= LDB_CH1_MODE_EN_TO_DI0;                                             |
        else                                                                           |
            reg |= LDB_CH1_MODE_EN_TO_DI1;                                             |
        ch_mask = lvds_channel ?  LDB_CH1_MODE_MASK :                                  |
                LDB_CH0_MODE_MASK;                                                     |
        ch_val = reg & ch_mask;                                                        |
                                                                                       |
        if (bits_per_pixel(setting->if_fmt) == 24) {                                   |
            if (lvds_channel == 0)                                                     |
                reg |= LDB_DATA_WIDTH_CH0_24;                                          |
            else                                                                       |
                reg |= LDB_DATA_WIDTH_CH1_24;                                          |
        } else {                                                                       |
            if (lvds_channel == 0)                                                     |
                reg |= LDB_DATA_WIDTH_CH0_18;                                          |
            else                                                                       |
                reg |= LDB_DATA_WIDTH_CH1_18;                                          |
        }                                                                              |
        writel(reg, ldb->control_reg);                                                 |
                                                                                       |
        /* clock setting */                                                            |
        if (cpu_is_mx6q() || cpu_is_mx6dl())                                           |
            ldb_clk[6] += lvds_channel;                                                |
        else                                                                           |
            ldb_clk[6] += setting->disp_id;                                            |
        ldb->setting[setting_idx].ldb_di_clk = clk_get(&ldb->pdev->dev,                |
                                ldb_clk);                                              |
        if (IS_ERR(ldb->setting[setting_idx].ldb_di_clk)) {                            |
            dev_err(&ldb->pdev->dev, "get ldb clk1 failed\n");                         |
            return PTR_ERR(ldb->setting[setting_idx].ldb_di_clk);                      |
        }                                                                              |
        di_clk[3] += setting->dev_id;                                                  |
        di_clk[7] += setting->disp_id;                                                 |
        ldb->setting[setting_idx].di_clk = clk_get(&ldb->pdev->dev,                    |
                                di_clk);                                               |
        if (IS_ERR(ldb->setting[setting_idx].di_clk)) {                                |
            dev_err(&ldb->pdev->dev, "get di clk1 failed\n");                          |
            return PTR_ERR(ldb->setting[setting_idx].di_clk);                          |
        }                                                                              |
                                                                                       |
        i2c_dev = ldb_i2c_client[lvds_channel];                                        |
                                                                                       |
        dev_dbg(&ldb->pdev->dev, "ldb_clk to di clk: %s -> %s\n", ldb_clk, di_clk);    |
    }                                                                                  |
                                                                                       |
    if (i2c_dev)                                                                       |
        mxc_dispdrv_setdev(ldb->disp_ldb, &i2c_dev->dev);                              |
    else                                                                               |
        mxc_dispdrv_setdev(ldb->disp_ldb, NULL);                                       |
                                                                                       |
    ldb->setting[setting_idx].ch_mask = ch_mask;                                       |
    ldb->setting[setting_idx].ch_val = ch_val;                                         |
                                                                                       |
    if (cpu_is_mx6q() || cpu_is_mx6dl())                                               |
        ldb_ipu_ldb_route(setting->dev_id, setting->disp_id, ldb);          -----------------+
                                                                                       |     |
    /*                                                                                 |     |
     * ldb_di0_clk -> ipux_di0_clk                                                     |     |
     * ldb_di1_clk -> ipux_di1_clk                                                     |     |
     */                                                                                |     |
    clk_set_parent(ldb->setting[setting_idx].di_clk,                                   |     |
            ldb->setting[setting_idx].ldb_di_clk);                                     |     |
                                                                                       |     |
    /* must use spec video mode defined by driver */                                   |     |
    ret = fb_find_mode(&setting->fbi->var, setting->fbi, setting->dft_mode_str,        |     |
                ldb_modedb, ldb_modedb_sz, NULL, setting->default_bpp);                |     |
    if (ret != 1)                                                                      |     |
        fb_videomode_to_var(&setting->fbi->var, &ldb_modedb[0]);                       |     |
                                                                                       |     |
    INIT_LIST_HEAD(&setting->fbi->modelist);                                           |     |
    for (i = 0; i < ldb_modedb_sz; i++) {                                              |     |
        struct fb_videomode m;                                                         |     |
        fb_var_to_videomode(&m, &setting->fbi->var);                                   |     |
        if (fb_mode_is_equal(&m, &ldb_modedb[i])) {                                    |     |
            fb_add_videomode(&ldb_modedb[i],                                           |     |
                    &setting->fbi->modelist);                                          |     |
            break;                                                                     |     |
        }                                                                              |     |
    }                                                                                  |     |
                                                                                       |     |
    /* get screen size in edid */                                                      |     |
    if (i2c_dev) {                                                                     |     |
        ret = mxc_ldb_edidread(i2c_dev);                                               |     |
        if (ret > 0) {                                                                 |     |
            fb_edid_to_monspecs(&g_edid[lvds_channel][0],                              |     |
                        &setting->fbi->monspecs);                                      |     |
            /* centimeter to millimeter */                                             |     |
            setting->fbi->var.width =                                                  |     |
                    setting->fbi->monspecs.max_x * 10;                                 |     |
            setting->fbi->var.height =                                                 |     |
                    setting->fbi->monspecs.max_y * 10;                                 |     |
        } else {                                                                       |     |
            /* ignore i2c access failure */                                            |     |
            ret = 0;                                                                   |     |
        }                                                                              |     |
    }                                                                                  |     |
                                                                                       |     |
    /* save current ldb setting for fb notifier */                                     |     |
    ldb->setting[setting_idx].active = true;                                           |     |
    ldb->setting[setting_idx].ipu = setting->dev_id;                                   |     |
    ldb->setting[setting_idx].di = setting->disp_id;                                   |     |
    return ret;                                                                        |     |
}                                                                                      |     |
                                                                                       |     |
static int ldb_disp_setup(struct mxc_dispdrv_handle *disp, struct fb_info *fbi)   <----+     |
{                                                                                            |
    uint32_t reg, val;                                                                       |
    uint32_t pixel_clk, rounded_pixel_clk;                                                   |
    struct clk *ldb_clk_parent;                                                              |
    struct ldb_data *ldb = mxc_dispdrv_getdata(disp);                                        |
    int setting_idx, di;                                                                     |
                                                                                             |
    setting_idx = find_ldb_setting(ldb, fbi);                                                |
    if (setting_idx < 0)                                                                     |
        return setting_idx;                                                                  |
                                                                                             |
    di = ldb->setting[setting_idx].di;                                                       |
                                                                                             |
    /* restore channel mode setting */                                                       |
    val = readl(ldb->control_reg);                                                           |
    val |= ldb->setting[setting_idx].ch_val;                                                 |
    writel(val, ldb->control_reg);                                                           |
    dev_dbg(&ldb->pdev->dev, "LDB setup, control reg:0x%x\n",                                |
            readl(ldb->control_reg));                                                        |
    //设置vsync信号的极性
    /* vsync setup */                                                                        |
    reg = readl(ldb->control_reg);                                                           |
    if (fbi->var.sync & FB_SYNC_VERT_HIGH_ACT) {                                             |
        if (di == 0)                                                                         |
            reg = (reg & ~LDB_DI0_VS_POL_MASK)                                               |
                | LDB_DI0_VS_POL_ACT_HIGH;                                                   |
        else                                                                                 |
            reg = (reg & ~LDB_DI1_VS_POL_MASK)                                               |
                | LDB_DI1_VS_POL_ACT_HIGH;                                                   |
    } else {                                                                                 |
        if (di == 0)                                                                         |
            reg = (reg & ~LDB_DI0_VS_POL_MASK)                                               |
                | LDB_DI0_VS_POL_ACT_LOW;                                                    |
        else                                                                                 |
            reg = (reg & ~LDB_DI1_VS_POL_MASK)                                               |
                | LDB_DI1_VS_POL_ACT_LOW;                                                    |
    }                                                                                        |
    writel(reg, ldb->control_reg);                                                           |
                                                                                             |
    /* clk setup */                                                                          |
    //时钟关闭                                                                               |
    if (ldb->setting[setting_idx].clk_en)                                                    |
        clk_disable(ldb->setting[setting_idx].ldb_di_clk);                                   |
    pixel_clk = (PICOS2KHZ(fbi->var.pixclock)) * 1000UL;                                     |
    ldb_clk_parent = clk_get_parent(ldb->setting[setting_idx].ldb_di_clk);                   |
    if ((ldb->mode == LDB_SPL_DI0) || (ldb->mode == LDB_SPL_DI1))                            |
        clk_set_rate(ldb_clk_parent, pixel_clk * 7 / 2);                                     |
    else                                                                                     |
        clk_set_rate(ldb_clk_parent, pixel_clk * 7);                                         |
    rounded_pixel_clk = clk_round_rate(ldb->setting[setting_idx].ldb_di_clk,                 |
            pixel_clk);                                                                      |
    clk_set_rate(ldb->setting[setting_idx].ldb_di_clk, rounded_pixel_clk);                   |
    //时钟使能                                                                               |
    clk_enable(ldb->setting[setting_idx].ldb_di_clk);                                        |
    if (!ldb->setting[setting_idx].clk_en)                                                   |
        ldb->setting[setting_idx].clk_en = true;                                             |
                                                                                             |
    return 0;                                                                                |
}                                                                                            |
                                                                                             |
#define LVDS_MUX_CTL_WIDTH    2                                                              |
#define LVDS_MUX_CTL_MASK    3                                                               |
#define LVDS0_MUX_CTL_OFFS    6                                                              |
#define LVDS1_MUX_CTL_OFFS    8                                                              |
#define LVDS0_MUX_CTL_MASK    (LVDS_MUX_CTL_MASK << 6)                                       |
#define LVDS1_MUX_CTL_MASK    (LVDS_MUX_CTL_MASK << 8)                                       |
#define ROUTE_IPU_DI(ipu, di)    (((ipu << 1) | di) & LVDS_MUX_CTL_MASK)                     |
static int ldb_ipu_ldb_route(int ipu, int di, struct ldb_data *ldb)              <-----------+
{
    uint32_t reg;
    int channel;
    int shift;
    int mode = ldb->mode;
    //IOMUXC_GPR3
    reg = readl(ldb->gpr3_reg);
    if (mode < LDB_SIN0) {
        reg &= ~(LVDS0_MUX_CTL_MASK | LVDS1_MUX_CTL_MASK);
        reg |= (ROUTE_IPU_DI(ipu, di) << LVDS0_MUX_CTL_OFFS) |
            (ROUTE_IPU_DI(ipu, di) << LVDS1_MUX_CTL_OFFS);
        dev_dbg(&ldb->pdev->dev,
            "Dual/Split mode both channels route to IPU%d-DI%d\n",
            ipu, di);
    } else if ((mode == LDB_SIN0) || (mode == LDB_SIN1)) {
        reg &= ~(LVDS0_MUX_CTL_MASK | LVDS1_MUX_CTL_MASK);      //选择lvds源
        channel = mode - LDB_SIN0;
        shift = LVDS0_MUX_CTL_OFFS + channel * LVDS_MUX_CTL_WIDTH;
        reg |= ROUTE_IPU_DI(ipu, di) << shift;
        dev_dbg(&ldb->pdev->dev,
            "Single mode channel %d route to IPU%d-DI%d\n",
                channel, ipu, di);
    } else {
        static bool first = true;

        if (first) {
            if (mode == LDB_SEP0) {
                reg &= ~LVDS0_MUX_CTL_MASK;
                channel = 0;
            } else {
                reg &= ~LVDS1_MUX_CTL_MASK;
                channel = 1;
            }
            first = false;
        } else {
            if (mode == LDB_SEP0) {
                reg &= ~LVDS1_MUX_CTL_MASK;
                channel = 1;
            } else {
                reg &= ~LVDS0_MUX_CTL_MASK;
                channel = 0;
            }
        }

        shift = LVDS0_MUX_CTL_OFFS + channel * LVDS_MUX_CTL_WIDTH;
        reg |= ROUTE_IPU_DI(ipu, di) << shift;

        dev_dbg(&ldb->pdev->dev,
            "Separate mode channel %d route to IPU%d-DI%d\n",
            channel, ipu, di);
    }
    writel(reg, ldb->gpr3_reg);

    return 0;
}

Author

Tony Liu

2016-8-31, Shenzhen

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值