2014-03-13 17:44:14 +07:00
|
|
|
/*
|
|
|
|
* HDMI driver for OMAP5
|
|
|
|
*
|
2017-12-06 03:29:31 +07:00
|
|
|
* Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/
|
2014-03-13 17:44:14 +07:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Yong Zhi
|
|
|
|
* Mythri pk
|
|
|
|
* Archit Taneja <archit@ti.com>
|
|
|
|
* Tomi Valkeinen <tomi.valkeinen@ti.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU General Public License 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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define DSS_SUBSYS_NAME "HDMI"
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/pm_runtime.h>
|
|
|
|
#include <linux/clk.h>
|
|
|
|
#include <linux/gpio.h>
|
|
|
|
#include <linux/regulator/consumer.h>
|
OMAPDSS: componentize omapdss
omapdss kernel module contains drivers for multiple devices, one for
each DSS submodule. The probing we have at the moment is a mess, and
doesn't give us proper deferred probing nor ensure that all the devices
are probed before omapfb/omapdrm start using omapdss.
This patch solves the mess by using the component system for DSS
submodules.
The changes to all DSS submodules (dispc, dpi, dsi, hdmi4/5, rfbi, sdi,
venc) are the same: probe & remove functions are changed to bind &
unbind, and new probe & remove functions are added which call
component_add/del.
The dss_core driver (dss.c) acts as a component master. Adding and
matching the components is simple: all dss device's child devices are
added as components.
However, we do have some dependencies between the drivers. The order in
which they should be probed is reflected by the list in core.c
(dss_output_drv_reg_funcs). The drivers are registered in that order,
which causes the components to be added in that order, which makes the
components to be bound in that order. This feels a bit fragile, and we
probably should improve the code to manage binds in random order.
However, for now, this works fine.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
2015-06-04 19:22:23 +07:00
|
|
|
#include <linux/component.h>
|
2016-03-18 14:02:18 +07:00
|
|
|
#include <linux/of.h>
|
2017-03-22 20:26:08 +07:00
|
|
|
#include <linux/of_graph.h>
|
2014-05-23 20:20:46 +07:00
|
|
|
#include <sound/omap-hdmi-audio.h>
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2016-05-27 18:40:49 +07:00
|
|
|
#include "omapdss.h"
|
2014-03-13 17:44:14 +07:00
|
|
|
#include "hdmi5_core.h"
|
|
|
|
#include "dss.h"
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static int hdmi_runtime_get(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
DSSDBG("hdmi_runtime_get\n");
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = pm_runtime_get_sync(&hdmi->pdev->dev);
|
2014-03-13 17:44:14 +07:00
|
|
|
WARN_ON(r < 0);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static void hdmi_runtime_put(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
DSSDBG("hdmi_runtime_put\n");
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = pm_runtime_put_sync(&hdmi->pdev->dev);
|
2014-03-13 17:44:14 +07:00
|
|
|
WARN_ON(r < 0 && r != -ENOSYS);
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t hdmi_irq_handler(int irq, void *data)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = data;
|
|
|
|
struct hdmi_wp_data *wp = &hdmi->wp;
|
2014-03-13 17:44:14 +07:00
|
|
|
u32 irqstatus;
|
|
|
|
|
|
|
|
irqstatus = hdmi_wp_get_irqstatus(wp);
|
|
|
|
hdmi_wp_set_irqstatus(wp, irqstatus);
|
|
|
|
|
|
|
|
if ((irqstatus & HDMI_IRQ_LINK_CONNECT) &&
|
|
|
|
irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
|
|
|
|
u32 v;
|
|
|
|
/*
|
|
|
|
* If we get both connect and disconnect interrupts at the same
|
|
|
|
* time, turn off the PHY, clear interrupts, and restart, which
|
|
|
|
* raises connect interrupt if a cable is connected, or nothing
|
|
|
|
* if cable is not connected.
|
|
|
|
*/
|
|
|
|
|
|
|
|
hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_OFF);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We always get bogus CONNECT & DISCONNECT interrupts when
|
|
|
|
* setting the PHY to LDOON. To ignore those, we force the RXDET
|
|
|
|
* line to 0 until the PHY power state has been changed.
|
|
|
|
*/
|
2018-02-13 19:00:46 +07:00
|
|
|
v = hdmi_read_reg(hdmi->phy.base, HDMI_TXPHY_PAD_CFG_CTRL);
|
2014-03-13 17:44:14 +07:00
|
|
|
v = FLD_MOD(v, 1, 15, 15); /* FORCE_RXDET_HIGH */
|
|
|
|
v = FLD_MOD(v, 0, 14, 7); /* RXDET_LINE */
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_write_reg(hdmi->phy.base, HDMI_TXPHY_PAD_CFG_CTRL, v);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
hdmi_wp_set_irqstatus(wp, HDMI_IRQ_LINK_CONNECT |
|
|
|
|
HDMI_IRQ_LINK_DISCONNECT);
|
|
|
|
|
|
|
|
hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
REG_FLD_MOD(hdmi->phy.base, HDMI_TXPHY_PAD_CFG_CTRL, 0, 15, 15);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
} else if (irqstatus & HDMI_IRQ_LINK_CONNECT) {
|
|
|
|
hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_TXON);
|
|
|
|
} else if (irqstatus & HDMI_IRQ_LINK_DISCONNECT) {
|
|
|
|
hdmi_wp_set_phy_pwr(wp, HDMI_PHYPWRCMD_LDOON);
|
|
|
|
}
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static int hdmi_power_on_core(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = regulator_enable(hdmi->vdda_reg);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_runtime_get(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
goto err_runtime_get;
|
|
|
|
|
|
|
|
/* Make selection of HDMI in DSS */
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_select_hdmi_venc_clk_source(hdmi->dss, DSS_HDMI_M_PCLK);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi->core_enabled = true;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_runtime_get:
|
2018-02-13 19:00:46 +07:00
|
|
|
regulator_disable(hdmi->vdda_reg);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static void hdmi_power_off_core(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi->core_enabled = false;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_runtime_put(hdmi);
|
|
|
|
regulator_disable(hdmi->vdda_reg);
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static int hdmi_power_on_full(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
int r;
|
2016-09-22 18:07:04 +07:00
|
|
|
struct videomode *vm;
|
2014-10-22 19:02:17 +07:00
|
|
|
struct dss_pll_clock_info hdmi_cinfo = { 0 };
|
2018-02-11 20:07:34 +07:00
|
|
|
unsigned int pc;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_power_on_core(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
vm = &hdmi->cfg.vm;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2016-09-22 18:07:04 +07:00
|
|
|
DSSDBG("hdmi_power_on hactive= %d vactive = %d\n", vm->hactive,
|
|
|
|
vm->vactive);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2016-09-22 18:07:04 +07:00
|
|
|
pc = vm->pixelclock;
|
|
|
|
if (vm->flags & DISPLAY_FLAGS_DOUBLECLK)
|
2016-01-13 23:41:33 +07:00
|
|
|
pc *= 2;
|
|
|
|
|
2016-05-18 15:15:21 +07:00
|
|
|
/* DSS_HDMI_TCLK is bitclk / 10 */
|
|
|
|
pc *= 10;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_pll_calc_b(&hdmi->pll.pll, clk_get_rate(hdmi->pll.pll.clkin),
|
2016-05-18 14:45:20 +07:00
|
|
|
pc, &hdmi_cinfo);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
/* disable and clear irqs */
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_clear_irqenable(&hdmi->wp, 0xffffffff);
|
|
|
|
hdmi_wp_set_irqstatus(&hdmi->wp,
|
|
|
|
hdmi_wp_get_irqstatus(&hdmi->wp));
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = dss_pll_enable(&hdmi->pll.pll);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r) {
|
2014-10-16 20:01:51 +07:00
|
|
|
DSSERR("Failed to enable PLL\n");
|
2014-03-13 17:44:14 +07:00
|
|
|
goto err_pll_enable;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = dss_pll_set_config(&hdmi->pll.pll, &hdmi_cinfo);
|
2014-10-16 20:01:51 +07:00
|
|
|
if (r) {
|
|
|
|
DSSERR("Failed to configure PLL\n");
|
|
|
|
goto err_pll_cfg;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_phy_configure(&hdmi->phy, hdmi_cinfo.clkdco,
|
2014-10-22 19:02:17 +07:00
|
|
|
hdmi_cinfo.clkout[0]);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r) {
|
|
|
|
DSSDBG("Failed to start PHY\n");
|
|
|
|
goto err_phy_cfg;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_wp_set_phy_pwr(&hdmi->wp, HDMI_PHYPWRCMD_LDOON);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
goto err_phy_pwr;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi5_configure(&hdmi->core, &hdmi->wp, &hdmi->cfg);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
/* tv size */
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_mgr_set_timings(&hdmi->output, vm);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = dss_mgr_enable(&hdmi->output);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
goto err_mgr_enable;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_wp_video_start(&hdmi->wp);
|
2015-03-24 20:46:35 +07:00
|
|
|
if (r)
|
|
|
|
goto err_vid_enable;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_set_irqenable(&hdmi->wp,
|
2014-03-13 17:44:14 +07:00
|
|
|
HDMI_IRQ_LINK_CONNECT | HDMI_IRQ_LINK_DISCONNECT);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_vid_enable:
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_mgr_disable(&hdmi->output);
|
2015-03-24 20:46:35 +07:00
|
|
|
err_mgr_enable:
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_set_phy_pwr(&hdmi->wp, HDMI_PHYPWRCMD_OFF);
|
2014-03-13 17:44:14 +07:00
|
|
|
err_phy_pwr:
|
|
|
|
err_phy_cfg:
|
2014-10-16 20:01:51 +07:00
|
|
|
err_pll_cfg:
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_pll_disable(&hdmi->pll.pll);
|
2014-03-13 17:44:14 +07:00
|
|
|
err_pll_enable:
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_power_off_core(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static void hdmi_power_off_full(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_clear_irqenable(&hdmi->wp, 0xffffffff);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_video_stop(&hdmi->wp);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_mgr_disable(&hdmi->output);
|
2015-03-24 20:46:35 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_set_phy_pwr(&hdmi->wp, HDMI_PHYPWRCMD_OFF);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
dss_pll_disable(&hdmi->pll.pll);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_power_off_core(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_display_check_timing(struct omap_dss_device *dssdev,
|
2016-09-22 18:07:04 +07:00
|
|
|
struct videomode *vm)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
|
|
|
|
|
|
|
if (!dispc_mgr_timings_ok(hdmi->dss->dispc, dssdev->dispc_channel, vm))
|
2014-03-13 17:44:14 +07:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_display_set_timing(struct omap_dss_device *dssdev,
|
2016-09-22 18:07:04 +07:00
|
|
|
struct videomode *vm)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
|
|
|
|
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi->cfg.vm = *vm;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
dispc_set_tv_pclk(hdmi->dss->dispc, vm->pixelclock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:29 +07:00
|
|
|
static int hdmi_dump_regs(struct seq_file *s, void *p)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = s->private;
|
|
|
|
|
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
if (hdmi_runtime_get(hdmi)) {
|
|
|
|
mutex_unlock(&hdmi->lock);
|
2018-02-13 19:00:29 +07:00
|
|
|
return 0;
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_wp_dump(&hdmi->wp, s);
|
|
|
|
hdmi_pll_dump(&hdmi->pll, s);
|
|
|
|
hdmi_phy_dump(&hdmi->phy, s);
|
|
|
|
hdmi5_core_dump(&hdmi->core, s);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_runtime_put(hdmi);
|
|
|
|
mutex_unlock(&hdmi->lock);
|
2018-02-13 19:00:29 +07:00
|
|
|
return 0;
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static int read_edid(struct omap_hdmi *hdmi, u8 *buf, int len)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
int idlemode;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_runtime_get(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
BUG_ON(r);
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
idlemode = REG_GET(hdmi->wp.base, HDMI_WP_SYSCONFIG, 3, 2);
|
2014-03-13 17:44:14 +07:00
|
|
|
/* No-idle mode */
|
2018-02-13 19:00:46 +07:00
|
|
|
REG_FLD_MOD(hdmi->wp.base, HDMI_WP_SYSCONFIG, 1, 3, 2);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi5_read_edid(&hdmi->core, buf, len);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
REG_FLD_MOD(hdmi->wp.base, HDMI_WP_SYSCONFIG, idlemode, 3, 2);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_runtime_put(hdmi);
|
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2015-08-28 21:21:46 +07:00
|
|
|
static void hdmi_start_audio_stream(struct omap_hdmi *hd)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
REG_FLD_MOD(hd->wp.base, HDMI_WP_SYSCONFIG, 1, 3, 2);
|
2015-08-28 21:21:46 +07:00
|
|
|
hdmi_wp_audio_enable(&hd->wp, true);
|
|
|
|
hdmi_wp_audio_core_req_enable(&hd->wp, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_stop_audio_stream(struct omap_hdmi *hd)
|
|
|
|
{
|
|
|
|
hdmi_wp_audio_core_req_enable(&hd->wp, false);
|
|
|
|
hdmi_wp_audio_enable(&hd->wp, false);
|
|
|
|
REG_FLD_MOD(hd->wp.base, HDMI_WP_SYSCONFIG, hd->wp_idlemode, 3, 2);
|
|
|
|
}
|
|
|
|
|
2014-03-13 17:44:14 +07:00
|
|
|
static int hdmi_display_enable(struct omap_dss_device *dssdev)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
2015-08-28 21:21:46 +07:00
|
|
|
unsigned long flags;
|
2014-03-13 17:44:14 +07:00
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
DSSDBG("ENTER hdmi_display_enable\n");
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
if (!dssdev->dispc_channel_connected) {
|
2014-03-13 17:44:14 +07:00
|
|
|
DSSERR("failed to enable display: no output/manager\n");
|
|
|
|
r = -ENODEV;
|
|
|
|
goto err0;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_power_on_full(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r) {
|
|
|
|
DSSERR("failed to power on device\n");
|
|
|
|
goto err0;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
if (hdmi->audio_configured) {
|
|
|
|
r = hdmi5_audio_config(&hdmi->core, &hdmi->wp,
|
|
|
|
&hdmi->audio_config,
|
|
|
|
hdmi->cfg.vm.pixelclock);
|
2015-08-28 21:21:46 +07:00
|
|
|
if (r) {
|
|
|
|
DSSERR("Error restoring audio configuration: %d", r);
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi->audio_abort_cb(&hdmi->pdev->dev);
|
|
|
|
hdmi->audio_configured = false;
|
2015-08-28 21:21:46 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
spin_lock_irqsave(&hdmi->audio_playing_lock, flags);
|
|
|
|
if (hdmi->audio_configured && hdmi->audio_playing)
|
|
|
|
hdmi_start_audio_stream(hdmi);
|
|
|
|
hdmi->display_enabled = true;
|
|
|
|
spin_unlock_irqrestore(&hdmi->audio_playing_lock, flags);
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err0:
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_display_disable(struct omap_dss_device *dssdev)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
2015-08-28 21:21:46 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-03-13 17:44:14 +07:00
|
|
|
DSSDBG("Enter hdmi_display_disable\n");
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
spin_lock_irqsave(&hdmi->audio_playing_lock, flags);
|
|
|
|
hdmi_stop_audio_stream(hdmi);
|
|
|
|
hdmi->display_enabled = false;
|
|
|
|
spin_unlock_irqrestore(&hdmi->audio_playing_lock, flags);
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_power_off_full(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static int hdmi_core_enable(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
|
|
|
|
DSSDBG("ENTER omapdss_hdmi_core_enable\n");
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_power_on_core(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r) {
|
|
|
|
DSSERR("failed to power on device\n");
|
|
|
|
goto err0;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err0:
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static void hdmi_core_disable(struct omap_hdmi *hdmi)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
|
|
|
DSSDBG("Enter omapdss_hdmi_core_disable\n");
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_lock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_power_off_core(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_unlock(&hdmi->lock);
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_connect(struct omap_dss_device *dssdev,
|
|
|
|
struct omap_dss_device *dst)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
2018-03-05 04:55:56 +07:00
|
|
|
r = dss_mgr_connect(dssdev);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = omapdss_output_set_device(dssdev, dst);
|
|
|
|
if (r) {
|
|
|
|
DSSERR("failed to connect output to new device: %s\n",
|
|
|
|
dst->name);
|
2018-03-05 04:55:56 +07:00
|
|
|
dss_mgr_disconnect(dssdev);
|
2014-03-13 17:44:14 +07:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_disconnect(struct omap_dss_device *dssdev,
|
|
|
|
struct omap_dss_device *dst)
|
|
|
|
{
|
|
|
|
omapdss_output_unset_device(dssdev);
|
|
|
|
|
2018-03-05 04:55:56 +07:00
|
|
|
dss_mgr_disconnect(dssdev);
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_read_edid(struct omap_dss_device *dssdev,
|
|
|
|
u8 *edid, int len)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
2014-03-13 17:44:14 +07:00
|
|
|
bool need_enable;
|
|
|
|
int r;
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
need_enable = hdmi->core_enabled == false;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
if (need_enable) {
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_core_enable(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = read_edid(hdmi, edid, len);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
if (need_enable)
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_core_disable(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-06-18 18:21:55 +07:00
|
|
|
static int hdmi_set_infoframe(struct omap_dss_device *dssdev,
|
|
|
|
const struct hdmi_avi_infoframe *avi)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
|
|
|
|
|
|
|
hdmi->cfg.infoframe = *avi;
|
2014-06-18 18:21:55 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_set_hdmi_mode(struct omap_dss_device *dssdev,
|
|
|
|
bool hdmi_mode)
|
|
|
|
{
|
2018-02-13 19:00:46 +07:00
|
|
|
struct omap_hdmi *hdmi = dssdev_to_hdmi(dssdev);
|
|
|
|
|
|
|
|
hdmi->cfg.hdmi_dvi_mode = hdmi_mode ? HDMI_HDMI : HDMI_DVI;
|
2014-06-18 18:21:55 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-28 20:58:13 +07:00
|
|
|
static const struct omap_dss_device_ops hdmi_ops = {
|
2014-03-13 17:44:14 +07:00
|
|
|
.connect = hdmi_connect,
|
|
|
|
.disconnect = hdmi_disconnect,
|
|
|
|
|
|
|
|
.enable = hdmi_display_enable,
|
|
|
|
.disable = hdmi_display_disable,
|
|
|
|
|
|
|
|
.check_timings = hdmi_display_check_timing,
|
|
|
|
.set_timings = hdmi_display_set_timing,
|
|
|
|
|
2018-02-28 20:58:13 +07:00
|
|
|
.hdmi = {
|
|
|
|
.read_edid = hdmi_read_edid,
|
|
|
|
.set_infoframe = hdmi_set_infoframe,
|
|
|
|
.set_hdmi_mode = hdmi_set_hdmi_mode,
|
|
|
|
},
|
2014-03-13 17:44:14 +07:00
|
|
|
};
|
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
/* -----------------------------------------------------------------------------
|
|
|
|
* Audio Callbacks
|
|
|
|
*/
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2014-05-23 20:20:46 +07:00
|
|
|
static int hdmi_audio_startup(struct device *dev,
|
|
|
|
void (*abort_cb)(struct device *dev))
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hd = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
mutex_lock(&hd->lock);
|
|
|
|
|
2017-03-16 17:05:04 +07:00
|
|
|
WARN_ON(hd->audio_abort_cb != NULL);
|
2014-05-23 20:20:46 +07:00
|
|
|
|
|
|
|
hd->audio_abort_cb = abort_cb;
|
|
|
|
|
|
|
|
mutex_unlock(&hd->lock);
|
|
|
|
|
2017-03-16 17:05:04 +07:00
|
|
|
return 0;
|
2014-05-23 20:20:46 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_audio_shutdown(struct device *dev)
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hd = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
mutex_lock(&hd->lock);
|
|
|
|
hd->audio_abort_cb = NULL;
|
2015-08-28 21:21:46 +07:00
|
|
|
hd->audio_configured = false;
|
|
|
|
hd->audio_playing = false;
|
2014-05-23 20:20:46 +07:00
|
|
|
mutex_unlock(&hd->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_audio_start(struct device *dev)
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hd = dev_get_drvdata(dev);
|
2015-08-28 21:21:46 +07:00
|
|
|
unsigned long flags;
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2015-08-28 21:21:46 +07:00
|
|
|
spin_lock_irqsave(&hd->audio_playing_lock, flags);
|
2014-10-23 17:07:05 +07:00
|
|
|
|
2017-03-16 17:05:04 +07:00
|
|
|
if (hd->display_enabled) {
|
|
|
|
if (!hdmi_mode_has_audio(&hd->cfg))
|
|
|
|
DSSERR("%s: Video mode does not support audio\n",
|
|
|
|
__func__);
|
2015-08-28 21:21:46 +07:00
|
|
|
hdmi_start_audio_stream(hd);
|
2017-03-16 17:05:04 +07:00
|
|
|
}
|
2015-08-28 21:21:46 +07:00
|
|
|
hd->audio_playing = true;
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2015-08-28 21:21:46 +07:00
|
|
|
spin_unlock_irqrestore(&hd->audio_playing_lock, flags);
|
2014-05-23 20:20:46 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi_audio_stop(struct device *dev)
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hd = dev_get_drvdata(dev);
|
2015-08-28 21:21:46 +07:00
|
|
|
unsigned long flags;
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2017-03-16 17:05:04 +07:00
|
|
|
if (!hdmi_mode_has_audio(&hd->cfg))
|
|
|
|
DSSERR("%s: Video mode does not support audio\n", __func__);
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2015-08-28 21:21:46 +07:00
|
|
|
spin_lock_irqsave(&hd->audio_playing_lock, flags);
|
|
|
|
|
|
|
|
if (hd->display_enabled)
|
|
|
|
hdmi_stop_audio_stream(hd);
|
|
|
|
hd->audio_playing = false;
|
2014-10-23 17:07:05 +07:00
|
|
|
|
2015-08-28 21:21:46 +07:00
|
|
|
spin_unlock_irqrestore(&hd->audio_playing_lock, flags);
|
2014-05-23 20:20:46 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_audio_config(struct device *dev,
|
|
|
|
struct omap_dss_audio *dss_audio)
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hd = dev_get_drvdata(dev);
|
2018-03-29 17:40:36 +07:00
|
|
|
int ret = 0;
|
2014-05-23 20:20:46 +07:00
|
|
|
|
|
|
|
mutex_lock(&hd->lock);
|
|
|
|
|
2017-03-16 17:05:04 +07:00
|
|
|
if (hd->display_enabled) {
|
|
|
|
ret = hdmi5_audio_config(&hd->core, &hd->wp, dss_audio,
|
|
|
|
hd->cfg.vm.pixelclock);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2014-05-23 20:20:46 +07:00
|
|
|
}
|
|
|
|
|
2017-03-16 17:05:04 +07:00
|
|
|
hd->audio_configured = true;
|
|
|
|
hd->audio_config = *dss_audio;
|
2014-05-23 20:20:46 +07:00
|
|
|
out:
|
|
|
|
mutex_unlock(&hd->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct omap_hdmi_audio_ops hdmi_audio_ops = {
|
|
|
|
.audio_startup = hdmi_audio_startup,
|
|
|
|
.audio_shutdown = hdmi_audio_shutdown,
|
|
|
|
.audio_start = hdmi_audio_start,
|
|
|
|
.audio_stop = hdmi_audio_stop,
|
|
|
|
.audio_config = hdmi_audio_config,
|
|
|
|
};
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
static int hdmi_audio_register(struct omap_hdmi *hdmi)
|
2014-05-23 20:20:46 +07:00
|
|
|
{
|
|
|
|
struct omap_hdmi_audio_pdata pdata = {
|
2018-02-13 19:00:46 +07:00
|
|
|
.dev = &hdmi->pdev->dev,
|
2017-08-11 20:49:04 +07:00
|
|
|
.version = 5,
|
2018-02-13 19:00:46 +07:00
|
|
|
.audio_dma_addr = hdmi_wp_get_audio_dma_addr(&hdmi->wp),
|
2014-05-23 20:20:46 +07:00
|
|
|
.ops = &hdmi_audio_ops,
|
|
|
|
};
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi->audio_pdev = platform_device_register_data(
|
|
|
|
&hdmi->pdev->dev, "omap-hdmi-audio", PLATFORM_DEVID_AUTO,
|
2014-05-23 20:20:46 +07:00
|
|
|
&pdata, sizeof(pdata));
|
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
if (IS_ERR(hdmi->audio_pdev))
|
|
|
|
return PTR_ERR(hdmi->audio_pdev);
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi_runtime_get(hdmi);
|
|
|
|
hdmi->wp_idlemode =
|
|
|
|
REG_GET(hdmi->wp.base, HDMI_WP_SYSCONFIG, 3, 2);
|
|
|
|
hdmi_runtime_put(hdmi);
|
2015-08-28 21:21:46 +07:00
|
|
|
|
2014-05-23 20:20:46 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
/* -----------------------------------------------------------------------------
|
|
|
|
* Component Bind & Unbind
|
|
|
|
*/
|
|
|
|
|
OMAPDSS: componentize omapdss
omapdss kernel module contains drivers for multiple devices, one for
each DSS submodule. The probing we have at the moment is a mess, and
doesn't give us proper deferred probing nor ensure that all the devices
are probed before omapfb/omapdrm start using omapdss.
This patch solves the mess by using the component system for DSS
submodules.
The changes to all DSS submodules (dispc, dpi, dsi, hdmi4/5, rfbi, sdi,
venc) are the same: probe & remove functions are changed to bind &
unbind, and new probe & remove functions are added which call
component_add/del.
The dss_core driver (dss.c) acts as a component master. Adding and
matching the components is simple: all dss device's child devices are
added as components.
However, we do have some dependencies between the drivers. The order in
which they should be probed is reflected by the list in core.c
(dss_output_drv_reg_funcs). The drivers are registered in that order,
which causes the components to be added in that order, which makes the
components to be bound in that order. This feels a bit fragile, and we
probably should improve the code to manage binds in random order.
However, for now, this works fine.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
2015-06-04 19:22:23 +07:00
|
|
|
static int hdmi5_bind(struct device *dev, struct device *master, void *data)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-02-13 19:00:21 +07:00
|
|
|
struct dss_device *dss = dss_get_device(master);
|
2018-03-03 23:52:59 +07:00
|
|
|
struct omap_hdmi *hdmi = dev_get_drvdata(dev);
|
2014-03-13 17:44:14 +07:00
|
|
|
int r;
|
2018-03-03 23:52:59 +07:00
|
|
|
|
|
|
|
hdmi->dss = dss;
|
|
|
|
|
|
|
|
r = hdmi_pll_init(dss, hdmi->pdev, &hdmi->pll, &hdmi->wp);
|
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = hdmi_audio_register(hdmi);
|
|
|
|
if (r) {
|
|
|
|
DSSERR("Registering HDMI audio failed %d\n", r);
|
|
|
|
goto err_pll_uninit;
|
|
|
|
}
|
|
|
|
|
|
|
|
hdmi->debugfs = dss_debugfs_create_file(dss, "hdmi", hdmi_dump_regs,
|
|
|
|
hdmi);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_pll_uninit:
|
|
|
|
hdmi_pll_uninit(&hdmi->pll);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi5_unbind(struct device *dev, struct device *master, void *data)
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hdmi = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
dss_debugfs_remove_file(hdmi->debugfs);
|
|
|
|
|
|
|
|
if (hdmi->audio_pdev)
|
|
|
|
platform_device_unregister(hdmi->audio_pdev);
|
|
|
|
|
|
|
|
hdmi_pll_uninit(&hdmi->pll);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct component_ops hdmi5_component_ops = {
|
|
|
|
.bind = hdmi5_bind,
|
|
|
|
.unbind = hdmi5_unbind,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
|
|
* Probe & Remove, Suspend & Resume
|
|
|
|
*/
|
|
|
|
|
2018-03-03 03:13:06 +07:00
|
|
|
static int hdmi5_init_output(struct omap_hdmi *hdmi)
|
2018-03-03 23:52:59 +07:00
|
|
|
{
|
|
|
|
struct omap_dss_device *out = &hdmi->output;
|
|
|
|
|
|
|
|
out->dev = &hdmi->pdev->dev;
|
|
|
|
out->id = OMAP_DSS_OUTPUT_HDMI;
|
|
|
|
out->output_type = OMAP_DISPLAY_TYPE_HDMI;
|
|
|
|
out->name = "hdmi.0";
|
|
|
|
out->dispc_channel = OMAP_DSS_CHANNEL_DIGIT;
|
|
|
|
out->ops = &hdmi_ops;
|
|
|
|
out->owner = THIS_MODULE;
|
|
|
|
out->of_ports = BIT(0);
|
|
|
|
|
2018-03-03 03:13:06 +07:00
|
|
|
out->next = omapdss_of_find_connected_device(out->dev->of_node, 0);
|
|
|
|
if (IS_ERR(out->next)) {
|
|
|
|
if (PTR_ERR(out->next) != -EPROBE_DEFER)
|
|
|
|
dev_err(out->dev, "failed to find video sink\n");
|
|
|
|
return PTR_ERR(out->next);
|
|
|
|
}
|
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
omapdss_device_register(out);
|
2018-03-03 03:13:06 +07:00
|
|
|
|
|
|
|
return 0;
|
2018-03-03 23:52:59 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hdmi5_uninit_output(struct omap_hdmi *hdmi)
|
|
|
|
{
|
|
|
|
struct omap_dss_device *out = &hdmi->output;
|
|
|
|
|
2018-03-03 03:13:06 +07:00
|
|
|
if (out->next)
|
|
|
|
omapdss_device_put(out->next);
|
2018-03-03 23:52:59 +07:00
|
|
|
omapdss_device_unregister(out);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi5_probe_of(struct omap_hdmi *hdmi)
|
|
|
|
{
|
|
|
|
struct platform_device *pdev = hdmi->pdev;
|
|
|
|
struct device_node *node = pdev->dev.of_node;
|
|
|
|
struct device_node *ep;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
ep = of_graph_get_endpoint_by_regs(node, 0, 0);
|
|
|
|
if (!ep)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
r = hdmi_parse_lanes_of(pdev, ep, &hdmi->phy);
|
|
|
|
of_node_put(ep);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi5_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct omap_hdmi *hdmi;
|
2014-03-13 17:44:14 +07:00
|
|
|
int irq;
|
2018-03-03 23:52:59 +07:00
|
|
|
int r;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi = kzalloc(sizeof(*hdmi), GFP_KERNEL);
|
|
|
|
if (!hdmi)
|
|
|
|
return -ENOMEM;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
hdmi->pdev = pdev;
|
2018-03-03 23:52:59 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
dev_set_drvdata(&pdev->dev, hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
mutex_init(&hdmi->lock);
|
|
|
|
spin_lock_init(&hdmi->audio_playing_lock);
|
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
r = hdmi5_probe_of(hdmi);
|
2017-05-07 04:42:26 +07:00
|
|
|
if (r)
|
2018-02-13 19:00:46 +07:00
|
|
|
goto err_free;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_wp_init(pdev, &hdmi->wp, 5);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
2018-02-13 19:00:46 +07:00
|
|
|
goto err_free;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi_phy_init(pdev, &hdmi->phy, 5);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
2018-03-03 23:52:59 +07:00
|
|
|
goto err_free;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
r = hdmi5_core_init(pdev, &hdmi->core);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r)
|
2018-03-03 23:52:59 +07:00
|
|
|
goto err_free;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
irq = platform_get_irq(pdev, 0);
|
|
|
|
if (irq < 0) {
|
|
|
|
DSSERR("platform_get_irq failed\n");
|
2014-10-22 19:02:17 +07:00
|
|
|
r = -ENODEV;
|
2018-03-03 23:52:59 +07:00
|
|
|
goto err_free;
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
r = devm_request_threaded_irq(&pdev->dev, irq,
|
|
|
|
NULL, hdmi_irq_handler,
|
2018-02-13 19:00:46 +07:00
|
|
|
IRQF_ONESHOT, "OMAP HDMI", hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r) {
|
|
|
|
DSSERR("HDMI IRQ request failed\n");
|
2018-03-03 23:52:59 +07:00
|
|
|
goto err_free;
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-03-05 05:10:55 +07:00
|
|
|
hdmi->vdda_reg = devm_regulator_get(&pdev->dev, "vdda");
|
|
|
|
if (IS_ERR(hdmi->vdda_reg)) {
|
|
|
|
r = PTR_ERR(hdmi->vdda_reg);
|
|
|
|
if (r != -EPROBE_DEFER)
|
|
|
|
DSSERR("can't get VDDA regulator\n");
|
|
|
|
goto err_free;
|
|
|
|
}
|
|
|
|
|
2014-03-13 17:44:14 +07:00
|
|
|
pm_runtime_enable(&pdev->dev);
|
|
|
|
|
2018-03-03 03:13:06 +07:00
|
|
|
r = hdmi5_init_output(hdmi);
|
|
|
|
if (r)
|
|
|
|
goto err_pm_disable;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
r = component_add(&pdev->dev, &hdmi5_component_ops);
|
|
|
|
if (r)
|
2018-03-03 02:38:21 +07:00
|
|
|
goto err_uninit_output;
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
return 0;
|
2018-02-13 19:00:46 +07:00
|
|
|
|
2018-03-03 02:38:21 +07:00
|
|
|
err_uninit_output:
|
2018-03-03 23:52:59 +07:00
|
|
|
hdmi5_uninit_output(hdmi);
|
2018-03-03 03:13:06 +07:00
|
|
|
err_pm_disable:
|
2018-03-03 02:38:21 +07:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2018-02-13 19:00:46 +07:00
|
|
|
err_free:
|
|
|
|
kfree(hdmi);
|
2014-10-22 19:02:17 +07:00
|
|
|
return r;
|
2014-03-13 17:44:14 +07:00
|
|
|
}
|
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
static int hdmi5_remove(struct platform_device *pdev)
|
2014-03-13 17:44:14 +07:00
|
|
|
{
|
2018-03-03 23:52:59 +07:00
|
|
|
struct omap_hdmi *hdmi = platform_get_drvdata(pdev);
|
OMAPDSS: componentize omapdss
omapdss kernel module contains drivers for multiple devices, one for
each DSS submodule. The probing we have at the moment is a mess, and
doesn't give us proper deferred probing nor ensure that all the devices
are probed before omapfb/omapdrm start using omapdss.
This patch solves the mess by using the component system for DSS
submodules.
The changes to all DSS submodules (dispc, dpi, dsi, hdmi4/5, rfbi, sdi,
venc) are the same: probe & remove functions are changed to bind &
unbind, and new probe & remove functions are added which call
component_add/del.
The dss_core driver (dss.c) acts as a component master. Adding and
matching the components is simple: all dss device's child devices are
added as components.
However, we do have some dependencies between the drivers. The order in
which they should be probed is reflected by the list in core.c
(dss_output_drv_reg_funcs). The drivers are registered in that order,
which causes the components to be added in that order, which makes the
components to be bound in that order. This feels a bit fragile, and we
probably should improve the code to manage binds in random order.
However, for now, this works fine.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
2015-06-04 19:22:23 +07:00
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
component_del(&pdev->dev, &hdmi5_component_ops);
|
2014-05-23 20:20:46 +07:00
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
hdmi5_uninit_output(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
2018-03-03 23:52:59 +07:00
|
|
|
pm_runtime_disable(&pdev->dev);
|
2014-10-22 19:02:17 +07:00
|
|
|
|
2018-02-13 19:00:46 +07:00
|
|
|
kfree(hdmi);
|
2014-03-13 17:44:14 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_runtime_suspend(struct device *dev)
|
|
|
|
{
|
2018-02-13 19:00:42 +07:00
|
|
|
struct omap_hdmi *hdmi = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
dispc_runtime_put(hdmi->dss->dispc);
|
2014-03-13 17:44:14 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hdmi_runtime_resume(struct device *dev)
|
|
|
|
{
|
2018-02-13 19:00:42 +07:00
|
|
|
struct omap_hdmi *hdmi = dev_get_drvdata(dev);
|
2014-03-13 17:44:14 +07:00
|
|
|
int r;
|
|
|
|
|
2018-02-13 19:00:42 +07:00
|
|
|
r = dispc_runtime_get(hdmi->dss->dispc);
|
2014-03-13 17:44:14 +07:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct dev_pm_ops hdmi_pm_ops = {
|
|
|
|
.runtime_suspend = hdmi_runtime_suspend,
|
|
|
|
.runtime_resume = hdmi_runtime_resume,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct of_device_id hdmi_of_match[] = {
|
|
|
|
{ .compatible = "ti,omap5-hdmi", },
|
2014-12-31 16:26:18 +07:00
|
|
|
{ .compatible = "ti,dra7-hdmi", },
|
2014-03-13 17:44:14 +07:00
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
2017-12-06 03:29:32 +07:00
|
|
|
struct platform_driver omapdss_hdmi5hw_driver = {
|
OMAPDSS: componentize omapdss
omapdss kernel module contains drivers for multiple devices, one for
each DSS submodule. The probing we have at the moment is a mess, and
doesn't give us proper deferred probing nor ensure that all the devices
are probed before omapfb/omapdrm start using omapdss.
This patch solves the mess by using the component system for DSS
submodules.
The changes to all DSS submodules (dispc, dpi, dsi, hdmi4/5, rfbi, sdi,
venc) are the same: probe & remove functions are changed to bind &
unbind, and new probe & remove functions are added which call
component_add/del.
The dss_core driver (dss.c) acts as a component master. Adding and
matching the components is simple: all dss device's child devices are
added as components.
However, we do have some dependencies between the drivers. The order in
which they should be probed is reflected by the list in core.c
(dss_output_drv_reg_funcs). The drivers are registered in that order,
which causes the components to be added in that order, which makes the
components to be bound in that order. This feels a bit fragile, and we
probably should improve the code to manage binds in random order.
However, for now, this works fine.
Signed-off-by: Tomi Valkeinen <tomi.valkeinen@ti.com>
Acked-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
2015-06-04 19:22:23 +07:00
|
|
|
.probe = hdmi5_probe,
|
|
|
|
.remove = hdmi5_remove,
|
2014-03-13 17:44:14 +07:00
|
|
|
.driver = {
|
|
|
|
.name = "omapdss_hdmi5",
|
|
|
|
.pm = &hdmi_pm_ops,
|
|
|
|
.of_match_table = hdmi_of_match,
|
2014-10-16 13:54:25 +07:00
|
|
|
.suppress_bind_attrs = true,
|
2014-03-13 17:44:14 +07:00
|
|
|
},
|
|
|
|
};
|