2 * Copyright (c) 2014 The Linux Foundation. All rights reserved.
3 * Copyright (C) 2013 Red Hat
4 * Author: Rob Clark <robdclark@gmail.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program. If not, see <http://www.gnu.org/licenses/>.
19 #include <linux/of_irq.h>
20 #include <linux/of_gpio.h>
22 #include <sound/hdmi-codec.h>
25 void msm_hdmi_set_mode(struct hdmi
*hdmi
, bool power_on
)
30 spin_lock_irqsave(&hdmi
->reg_lock
, flags
);
32 ctrl
|= HDMI_CTRL_ENABLE
;
33 if (!hdmi
->hdmi_mode
) {
34 ctrl
|= HDMI_CTRL_HDMI
;
35 hdmi_write(hdmi
, REG_HDMI_CTRL
, ctrl
);
36 ctrl
&= ~HDMI_CTRL_HDMI
;
38 ctrl
|= HDMI_CTRL_HDMI
;
41 ctrl
= HDMI_CTRL_HDMI
;
44 hdmi_write(hdmi
, REG_HDMI_CTRL
, ctrl
);
45 spin_unlock_irqrestore(&hdmi
->reg_lock
, flags
);
46 DBG("HDMI Core: %s, HDMI_CTRL=0x%08x",
47 power_on
? "Enable" : "Disable", ctrl
);
50 static irqreturn_t
msm_hdmi_irq(int irq
, void *dev_id
)
52 struct hdmi
*hdmi
= dev_id
;
55 msm_hdmi_connector_irq(hdmi
->connector
);
58 msm_hdmi_i2c_irq(hdmi
->i2c
);
62 msm_hdmi_hdcp_irq(hdmi
->hdcp_ctrl
);
69 static void msm_hdmi_destroy(struct hdmi
*hdmi
)
72 * at this point, hpd has been disabled,
73 * after flush workq, it's safe to deinit hdcp
76 flush_workqueue(hdmi
->workq
);
77 destroy_workqueue(hdmi
->workq
);
79 msm_hdmi_hdcp_destroy(hdmi
);
82 put_device(hdmi
->phy_dev
);
88 msm_hdmi_i2c_destroy(hdmi
->i2c
);
90 platform_set_drvdata(hdmi
->pdev
, NULL
);
93 static int msm_hdmi_get_phy(struct hdmi
*hdmi
)
95 struct platform_device
*pdev
= hdmi
->pdev
;
96 struct platform_device
*phy_pdev
;
97 struct device_node
*phy_node
;
99 phy_node
= of_parse_phandle(pdev
->dev
.of_node
, "phys", 0);
101 DRM_DEV_ERROR(&pdev
->dev
, "cannot find phy device\n");
105 phy_pdev
= of_find_device_by_node(phy_node
);
107 hdmi
->phy
= platform_get_drvdata(phy_pdev
);
109 of_node_put(phy_node
);
111 if (!phy_pdev
|| !hdmi
->phy
) {
112 DRM_DEV_ERROR(&pdev
->dev
, "phy driver is not ready\n");
113 return -EPROBE_DEFER
;
116 hdmi
->phy_dev
= get_device(&phy_pdev
->dev
);
121 /* construct hdmi at bind/probe time, grab all the resources. If
122 * we are to EPROBE_DEFER we want to do it here, rather than later
123 * at modeset_init() time
125 static struct hdmi
*msm_hdmi_init(struct platform_device
*pdev
)
127 struct hdmi_platform_config
*config
= pdev
->dev
.platform_data
;
128 struct hdmi
*hdmi
= NULL
;
129 struct resource
*res
;
132 hdmi
= devm_kzalloc(&pdev
->dev
, sizeof(*hdmi
), GFP_KERNEL
);
139 hdmi
->config
= config
;
140 spin_lock_init(&hdmi
->reg_lock
);
142 hdmi
->mmio
= msm_ioremap(pdev
, config
->mmio_name
, "HDMI");
143 if (IS_ERR(hdmi
->mmio
)) {
144 ret
= PTR_ERR(hdmi
->mmio
);
148 /* HDCP needs physical address of hdmi register */
149 res
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
,
151 hdmi
->mmio_phy_addr
= res
->start
;
153 hdmi
->qfprom_mmio
= msm_ioremap(pdev
,
154 config
->qfprom_mmio_name
, "HDMI_QFPROM");
155 if (IS_ERR(hdmi
->qfprom_mmio
)) {
156 DRM_DEV_INFO(&pdev
->dev
, "can't find qfprom resource\n");
157 hdmi
->qfprom_mmio
= NULL
;
160 hdmi
->hpd_regs
= devm_kcalloc(&pdev
->dev
,
162 sizeof(hdmi
->hpd_regs
[0]),
164 if (!hdmi
->hpd_regs
) {
168 for (i
= 0; i
< config
->hpd_reg_cnt
; i
++) {
169 struct regulator
*reg
;
171 reg
= devm_regulator_get(&pdev
->dev
,
172 config
->hpd_reg_names
[i
]);
175 DRM_DEV_ERROR(&pdev
->dev
, "failed to get hpd regulator: %s (%d)\n",
176 config
->hpd_reg_names
[i
], ret
);
180 hdmi
->hpd_regs
[i
] = reg
;
183 hdmi
->pwr_regs
= devm_kcalloc(&pdev
->dev
,
185 sizeof(hdmi
->pwr_regs
[0]),
187 if (!hdmi
->pwr_regs
) {
191 for (i
= 0; i
< config
->pwr_reg_cnt
; i
++) {
192 struct regulator
*reg
;
194 reg
= devm_regulator_get(&pdev
->dev
,
195 config
->pwr_reg_names
[i
]);
198 DRM_DEV_ERROR(&pdev
->dev
, "failed to get pwr regulator: %s (%d)\n",
199 config
->pwr_reg_names
[i
], ret
);
203 hdmi
->pwr_regs
[i
] = reg
;
206 hdmi
->hpd_clks
= devm_kcalloc(&pdev
->dev
,
208 sizeof(hdmi
->hpd_clks
[0]),
210 if (!hdmi
->hpd_clks
) {
214 for (i
= 0; i
< config
->hpd_clk_cnt
; i
++) {
217 clk
= msm_clk_get(pdev
, config
->hpd_clk_names
[i
]);
220 DRM_DEV_ERROR(&pdev
->dev
, "failed to get hpd clk: %s (%d)\n",
221 config
->hpd_clk_names
[i
], ret
);
225 hdmi
->hpd_clks
[i
] = clk
;
228 hdmi
->pwr_clks
= devm_kcalloc(&pdev
->dev
,
230 sizeof(hdmi
->pwr_clks
[0]),
232 if (!hdmi
->pwr_clks
) {
236 for (i
= 0; i
< config
->pwr_clk_cnt
; i
++) {
239 clk
= msm_clk_get(pdev
, config
->pwr_clk_names
[i
]);
242 DRM_DEV_ERROR(&pdev
->dev
, "failed to get pwr clk: %s (%d)\n",
243 config
->pwr_clk_names
[i
], ret
);
247 hdmi
->pwr_clks
[i
] = clk
;
250 pm_runtime_enable(&pdev
->dev
);
252 hdmi
->workq
= alloc_ordered_workqueue("msm_hdmi", 0);
254 hdmi
->i2c
= msm_hdmi_i2c_init(hdmi
);
255 if (IS_ERR(hdmi
->i2c
)) {
256 ret
= PTR_ERR(hdmi
->i2c
);
257 DRM_DEV_ERROR(&pdev
->dev
, "failed to get i2c: %d\n", ret
);
262 ret
= msm_hdmi_get_phy(hdmi
);
264 DRM_DEV_ERROR(&pdev
->dev
, "failed to get phy\n");
268 hdmi
->hdcp_ctrl
= msm_hdmi_hdcp_init(hdmi
);
269 if (IS_ERR(hdmi
->hdcp_ctrl
)) {
270 dev_warn(&pdev
->dev
, "failed to init hdcp: disabled\n");
271 hdmi
->hdcp_ctrl
= NULL
;
278 msm_hdmi_destroy(hdmi
);
283 /* Second part of initialization, the drm/kms level modeset_init,
284 * constructs/initializes mode objects, etc, is called from master
285 * driver (not hdmi sub-device's probe/bind!)
287 * Any resource (regulator/clk/etc) which could be missing at boot
288 * should be handled in msm_hdmi_init() so that failure happens from
289 * hdmi sub-device's probe.
291 int msm_hdmi_modeset_init(struct hdmi
*hdmi
,
292 struct drm_device
*dev
, struct drm_encoder
*encoder
)
294 struct msm_drm_private
*priv
= dev
->dev_private
;
295 struct platform_device
*pdev
= hdmi
->pdev
;
299 hdmi
->encoder
= encoder
;
301 hdmi_audio_infoframe_init(&hdmi
->audio
.infoframe
);
303 hdmi
->bridge
= msm_hdmi_bridge_init(hdmi
);
304 if (IS_ERR(hdmi
->bridge
)) {
305 ret
= PTR_ERR(hdmi
->bridge
);
306 DRM_DEV_ERROR(dev
->dev
, "failed to create HDMI bridge: %d\n", ret
);
311 hdmi
->connector
= msm_hdmi_connector_init(hdmi
);
312 if (IS_ERR(hdmi
->connector
)) {
313 ret
= PTR_ERR(hdmi
->connector
);
314 DRM_DEV_ERROR(dev
->dev
, "failed to create HDMI connector: %d\n", ret
);
315 hdmi
->connector
= NULL
;
319 hdmi
->irq
= irq_of_parse_and_map(pdev
->dev
.of_node
, 0);
322 DRM_DEV_ERROR(dev
->dev
, "failed to get irq: %d\n", ret
);
326 ret
= devm_request_irq(&pdev
->dev
, hdmi
->irq
,
327 msm_hdmi_irq
, IRQF_TRIGGER_HIGH
| IRQF_ONESHOT
,
330 DRM_DEV_ERROR(dev
->dev
, "failed to request IRQ%u: %d\n",
335 ret
= msm_hdmi_hpd_enable(hdmi
->connector
);
337 DRM_DEV_ERROR(&hdmi
->pdev
->dev
, "failed to enable HPD: %d\n", ret
);
341 encoder
->bridge
= hdmi
->bridge
;
343 priv
->bridges
[priv
->num_bridges
++] = hdmi
->bridge
;
344 priv
->connectors
[priv
->num_connectors
++] = hdmi
->connector
;
346 platform_set_drvdata(pdev
, hdmi
);
351 /* bridge is normally destroyed by drm: */
353 msm_hdmi_bridge_destroy(hdmi
->bridge
);
356 if (hdmi
->connector
) {
357 hdmi
->connector
->funcs
->destroy(hdmi
->connector
);
358 hdmi
->connector
= NULL
;
368 #define HDMI_CFG(item, entry) \
369 .item ## _names = item ##_names_ ## entry, \
370 .item ## _cnt = ARRAY_SIZE(item ## _names_ ## entry)
372 static const char *pwr_reg_names_none
[] = {};
373 static const char *hpd_reg_names_none
[] = {};
375 static struct hdmi_platform_config hdmi_tx_8660_config
;
377 static const char *hpd_reg_names_8960
[] = {"core-vdda", "hdmi-mux"};
378 static const char *hpd_clk_names_8960
[] = {"core", "master_iface", "slave_iface"};
380 static struct hdmi_platform_config hdmi_tx_8960_config
= {
381 HDMI_CFG(hpd_reg
, 8960),
382 HDMI_CFG(hpd_clk
, 8960),
385 static const char *pwr_reg_names_8x74
[] = {"core-vdda", "core-vcc"};
386 static const char *hpd_reg_names_8x74
[] = {"hpd-gdsc", "hpd-5v"};
387 static const char *pwr_clk_names_8x74
[] = {"extp", "alt_iface"};
388 static const char *hpd_clk_names_8x74
[] = {"iface", "core", "mdp_core"};
389 static unsigned long hpd_clk_freq_8x74
[] = {0, 19200000, 0};
391 static struct hdmi_platform_config hdmi_tx_8974_config
= {
392 HDMI_CFG(pwr_reg
, 8x74
),
393 HDMI_CFG(hpd_reg
, 8x74
),
394 HDMI_CFG(pwr_clk
, 8x74
),
395 HDMI_CFG(hpd_clk
, 8x74
),
396 .hpd_freq
= hpd_clk_freq_8x74
,
399 static const char *hpd_reg_names_8084
[] = {"hpd-gdsc", "hpd-5v", "hpd-5v-en"};
401 static struct hdmi_platform_config hdmi_tx_8084_config
= {
402 HDMI_CFG(pwr_reg
, 8x74
),
403 HDMI_CFG(hpd_reg
, 8084),
404 HDMI_CFG(pwr_clk
, 8x74
),
405 HDMI_CFG(hpd_clk
, 8x74
),
406 .hpd_freq
= hpd_clk_freq_8x74
,
409 static struct hdmi_platform_config hdmi_tx_8994_config
= {
410 HDMI_CFG(pwr_reg
, 8x74
),
411 HDMI_CFG(hpd_reg
, none
),
412 HDMI_CFG(pwr_clk
, 8x74
),
413 HDMI_CFG(hpd_clk
, 8x74
),
414 .hpd_freq
= hpd_clk_freq_8x74
,
417 static struct hdmi_platform_config hdmi_tx_8996_config
= {
418 HDMI_CFG(pwr_reg
, none
),
419 HDMI_CFG(hpd_reg
, none
),
420 HDMI_CFG(pwr_clk
, 8x74
),
421 HDMI_CFG(hpd_clk
, 8x74
),
422 .hpd_freq
= hpd_clk_freq_8x74
,
425 static const struct {
430 } msm_hdmi_gpio_pdata
[] = {
431 { "qcom,hdmi-tx-ddc-clk", true, 1, "HDMI_DDC_CLK" },
432 { "qcom,hdmi-tx-ddc-data", true, 1, "HDMI_DDC_DATA" },
433 { "qcom,hdmi-tx-hpd", false, 1, "HDMI_HPD" },
434 { "qcom,hdmi-tx-mux-en", true, 1, "HDMI_MUX_EN" },
435 { "qcom,hdmi-tx-mux-sel", true, 0, "HDMI_MUX_SEL" },
436 { "qcom,hdmi-tx-mux-lpm", true, 1, "HDMI_MUX_LPM" },
439 static int msm_hdmi_get_gpio(struct device_node
*of_node
, const char *name
)
443 /* try with the gpio names as in the table (downstream bindings) */
444 gpio
= of_get_named_gpio(of_node
, name
, 0);
448 /* try with the gpio names as in the upstream bindings */
449 snprintf(name2
, sizeof(name2
), "%s-gpios", name
);
450 gpio
= of_get_named_gpio(of_node
, name2
, 0);
455 * try again after stripping out the "qcom,hdmi-tx"
456 * prefix. This is mainly to match "hpd-gpios" used
457 * in the upstream bindings
459 if (sscanf(name2
, "qcom,hdmi-tx-%s", name3
))
460 gpio
= of_get_named_gpio(of_node
, name3
, 0);
464 DBG("failed to get gpio: %s (%d)", name
, gpio
);
472 * HDMI audio codec callbacks
474 static int msm_hdmi_audio_hw_params(struct device
*dev
, void *data
,
475 struct hdmi_codec_daifmt
*daifmt
,
476 struct hdmi_codec_params
*params
)
478 struct hdmi
*hdmi
= dev_get_drvdata(dev
);
480 unsigned int channel_allocation
= 0;
482 unsigned int level_shift
= 0; /* 0dB */
483 bool down_mix
= false;
485 DRM_DEV_DEBUG(dev
, "%u Hz, %d bit, %d channels\n", params
->sample_rate
,
486 params
->sample_width
, params
->cea
.channels
);
488 switch (params
->cea
.channels
) {
490 /* FR and FL speakers */
491 channel_allocation
= 0;
492 chan
= MSM_HDMI_AUDIO_CHANNEL_2
;
495 /* FC, LFE, FR and FL speakers */
496 channel_allocation
= 0x3;
497 chan
= MSM_HDMI_AUDIO_CHANNEL_4
;
500 /* RR, RL, FC, LFE, FR and FL speakers */
501 channel_allocation
= 0x0B;
502 chan
= MSM_HDMI_AUDIO_CHANNEL_6
;
505 /* FRC, FLC, RR, RL, FC, LFE, FR and FL speakers */
506 channel_allocation
= 0x1F;
507 chan
= MSM_HDMI_AUDIO_CHANNEL_8
;
513 switch (params
->sample_rate
) {
515 rate
= HDMI_SAMPLE_RATE_32KHZ
;
518 rate
= HDMI_SAMPLE_RATE_44_1KHZ
;
521 rate
= HDMI_SAMPLE_RATE_48KHZ
;
524 rate
= HDMI_SAMPLE_RATE_88_2KHZ
;
527 rate
= HDMI_SAMPLE_RATE_96KHZ
;
530 rate
= HDMI_SAMPLE_RATE_176_4KHZ
;
533 rate
= HDMI_SAMPLE_RATE_192KHZ
;
536 DRM_DEV_ERROR(dev
, "rate[%d] not supported!\n",
537 params
->sample_rate
);
541 msm_hdmi_audio_set_sample_rate(hdmi
, rate
);
542 msm_hdmi_audio_info_setup(hdmi
, 1, chan
, channel_allocation
,
543 level_shift
, down_mix
);
548 static void msm_hdmi_audio_shutdown(struct device
*dev
, void *data
)
550 struct hdmi
*hdmi
= dev_get_drvdata(dev
);
552 msm_hdmi_audio_info_setup(hdmi
, 0, 0, 0, 0, 0);
555 static const struct hdmi_codec_ops msm_hdmi_audio_codec_ops
= {
556 .hw_params
= msm_hdmi_audio_hw_params
,
557 .audio_shutdown
= msm_hdmi_audio_shutdown
,
560 static struct hdmi_codec_pdata codec_data
= {
561 .ops
= &msm_hdmi_audio_codec_ops
,
562 .max_i2s_channels
= 8,
566 static int msm_hdmi_register_audio_driver(struct hdmi
*hdmi
, struct device
*dev
)
568 hdmi
->audio_pdev
= platform_device_register_data(dev
,
573 return PTR_ERR_OR_ZERO(hdmi
->audio_pdev
);
576 static int msm_hdmi_bind(struct device
*dev
, struct device
*master
, void *data
)
578 struct drm_device
*drm
= dev_get_drvdata(master
);
579 struct msm_drm_private
*priv
= drm
->dev_private
;
580 struct hdmi_platform_config
*hdmi_cfg
;
582 struct device_node
*of_node
= dev
->of_node
;
585 hdmi_cfg
= (struct hdmi_platform_config
*)
586 of_device_get_match_data(dev
);
588 DRM_DEV_ERROR(dev
, "unknown hdmi_cfg: %pOFn\n", of_node
);
592 hdmi_cfg
->mmio_name
= "core_physical";
593 hdmi_cfg
->qfprom_mmio_name
= "qfprom_physical";
595 for (i
= 0; i
< HDMI_MAX_NUM_GPIO
; i
++) {
596 hdmi_cfg
->gpios
[i
].num
= msm_hdmi_get_gpio(of_node
,
597 msm_hdmi_gpio_pdata
[i
].name
);
598 hdmi_cfg
->gpios
[i
].output
= msm_hdmi_gpio_pdata
[i
].output
;
599 hdmi_cfg
->gpios
[i
].value
= msm_hdmi_gpio_pdata
[i
].value
;
600 hdmi_cfg
->gpios
[i
].label
= msm_hdmi_gpio_pdata
[i
].label
;
603 dev
->platform_data
= hdmi_cfg
;
605 hdmi
= msm_hdmi_init(to_platform_device(dev
));
607 return PTR_ERR(hdmi
);
610 err
= msm_hdmi_register_audio_driver(hdmi
, dev
);
612 DRM_ERROR("Failed to attach an audio codec %d\n", err
);
613 hdmi
->audio_pdev
= NULL
;
619 static void msm_hdmi_unbind(struct device
*dev
, struct device
*master
,
622 struct drm_device
*drm
= dev_get_drvdata(master
);
623 struct msm_drm_private
*priv
= drm
->dev_private
;
625 if (priv
->hdmi
->audio_pdev
)
626 platform_device_unregister(priv
->hdmi
->audio_pdev
);
628 msm_hdmi_destroy(priv
->hdmi
);
633 static const struct component_ops msm_hdmi_ops
= {
634 .bind
= msm_hdmi_bind
,
635 .unbind
= msm_hdmi_unbind
,
638 static int msm_hdmi_dev_probe(struct platform_device
*pdev
)
640 return component_add(&pdev
->dev
, &msm_hdmi_ops
);
643 static int msm_hdmi_dev_remove(struct platform_device
*pdev
)
645 component_del(&pdev
->dev
, &msm_hdmi_ops
);
649 static const struct of_device_id msm_hdmi_dt_match
[] = {
650 { .compatible
= "qcom,hdmi-tx-8996", .data
= &hdmi_tx_8996_config
},
651 { .compatible
= "qcom,hdmi-tx-8994", .data
= &hdmi_tx_8994_config
},
652 { .compatible
= "qcom,hdmi-tx-8084", .data
= &hdmi_tx_8084_config
},
653 { .compatible
= "qcom,hdmi-tx-8974", .data
= &hdmi_tx_8974_config
},
654 { .compatible
= "qcom,hdmi-tx-8960", .data
= &hdmi_tx_8960_config
},
655 { .compatible
= "qcom,hdmi-tx-8660", .data
= &hdmi_tx_8660_config
},
659 static struct platform_driver msm_hdmi_driver
= {
660 .probe
= msm_hdmi_dev_probe
,
661 .remove
= msm_hdmi_dev_remove
,
664 .of_match_table
= msm_hdmi_dt_match
,
668 void __init
msm_hdmi_register(void)
670 msm_hdmi_phy_driver_register();
671 platform_driver_register(&msm_hdmi_driver
);
674 void __exit
msm_hdmi_unregister(void)
676 platform_driver_unregister(&msm_hdmi_driver
);
677 msm_hdmi_phy_driver_unregister();