2 * Copyright 2016 Linaro Ltd.
3 * Copyright 2016 ZTE Corporation.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
11 #include <linux/clk.h>
12 #include <linux/component.h>
13 #include <linux/delay.h>
14 #include <linux/err.h>
15 #include <linux/hdmi.h>
16 #include <linux/irq.h>
17 #include <linux/mfd/syscon.h>
18 #include <linux/module.h>
19 #include <linux/mutex.h>
20 #include <linux/of_device.h>
22 #include <drm/drm_atomic_helper.h>
23 #include <drm/drm_crtc_helper.h>
24 #include <drm/drm_edid.h>
25 #include <drm/drm_of.h>
28 #include <sound/hdmi-codec.h>
30 #include "zx_hdmi_regs.h"
33 #define ZX_HDMI_INFOFRAME_SIZE 31
34 #define DDC_SEGMENT_ADDR 0x30
37 struct i2c_adapter adap
;
42 struct drm_connector connector
;
43 struct drm_encoder encoder
;
44 struct zx_hdmi_i2c
*ddc
;
46 struct drm_device
*drm
;
53 struct platform_device
*audio_pdev
;
56 #define to_zx_hdmi(x) container_of(x, struct zx_hdmi, x)
58 static inline u8
hdmi_readb(struct zx_hdmi
*hdmi
, u16 offset
)
60 return readl_relaxed(hdmi
->mmio
+ offset
* 4);
63 static inline void hdmi_writeb(struct zx_hdmi
*hdmi
, u16 offset
, u8 val
)
65 writel_relaxed(val
, hdmi
->mmio
+ offset
* 4);
68 static inline void hdmi_writeb_mask(struct zx_hdmi
*hdmi
, u16 offset
,
73 tmp
= hdmi_readb(hdmi
, offset
);
74 tmp
= (tmp
& ~mask
) | (val
& mask
);
75 hdmi_writeb(hdmi
, offset
, tmp
);
78 static int zx_hdmi_infoframe_trans(struct zx_hdmi
*hdmi
,
79 union hdmi_infoframe
*frame
, u8 fsel
)
81 u8 buffer
[ZX_HDMI_INFOFRAME_SIZE
];
85 hdmi_writeb(hdmi
, TPI_INFO_FSEL
, fsel
);
87 num
= hdmi_infoframe_pack(frame
, buffer
, ZX_HDMI_INFOFRAME_SIZE
);
89 DRM_DEV_ERROR(hdmi
->dev
, "failed to pack infoframe: %d\n", num
);
93 for (i
= 0; i
< num
; i
++)
94 hdmi_writeb(hdmi
, TPI_INFO_B0
+ i
, buffer
[i
]);
96 hdmi_writeb_mask(hdmi
, TPI_INFO_EN
, TPI_INFO_TRANS_RPT
,
98 hdmi_writeb_mask(hdmi
, TPI_INFO_EN
, TPI_INFO_TRANS_EN
,
104 static int zx_hdmi_config_video_vsi(struct zx_hdmi
*hdmi
,
105 struct drm_display_mode
*mode
)
107 union hdmi_infoframe frame
;
110 ret
= drm_hdmi_vendor_infoframe_from_display_mode(&frame
.vendor
.hdmi
,
114 DRM_DEV_ERROR(hdmi
->dev
, "failed to get vendor infoframe: %d\n",
119 return zx_hdmi_infoframe_trans(hdmi
, &frame
, FSEL_VSIF
);
122 static int zx_hdmi_config_video_avi(struct zx_hdmi
*hdmi
,
123 struct drm_display_mode
*mode
)
125 union hdmi_infoframe frame
;
128 ret
= drm_hdmi_avi_infoframe_from_display_mode(&frame
.avi
, mode
, false);
130 DRM_DEV_ERROR(hdmi
->dev
, "failed to get avi infoframe: %d\n",
135 /* We always use YUV444 for HDMI output. */
136 frame
.avi
.colorspace
= HDMI_COLORSPACE_YUV444
;
138 return zx_hdmi_infoframe_trans(hdmi
, &frame
, FSEL_AVI
);
141 static void zx_hdmi_encoder_mode_set(struct drm_encoder
*encoder
,
142 struct drm_display_mode
*mode
,
143 struct drm_display_mode
*adj_mode
)
145 struct zx_hdmi
*hdmi
= to_zx_hdmi(encoder
);
147 if (hdmi
->sink_is_hdmi
) {
148 zx_hdmi_config_video_avi(hdmi
, mode
);
149 zx_hdmi_config_video_vsi(hdmi
, mode
);
153 static void zx_hdmi_phy_start(struct zx_hdmi
*hdmi
)
155 /* Copy from ZTE BSP code */
156 hdmi_writeb(hdmi
, 0x222, 0x0);
157 hdmi_writeb(hdmi
, 0x224, 0x4);
158 hdmi_writeb(hdmi
, 0x909, 0x0);
159 hdmi_writeb(hdmi
, 0x7b0, 0x90);
160 hdmi_writeb(hdmi
, 0x7b1, 0x00);
161 hdmi_writeb(hdmi
, 0x7b2, 0xa7);
162 hdmi_writeb(hdmi
, 0x7b8, 0xaa);
163 hdmi_writeb(hdmi
, 0x7b2, 0xa7);
164 hdmi_writeb(hdmi
, 0x7b3, 0x0f);
165 hdmi_writeb(hdmi
, 0x7b4, 0x0f);
166 hdmi_writeb(hdmi
, 0x7b5, 0x55);
167 hdmi_writeb(hdmi
, 0x7b7, 0x03);
168 hdmi_writeb(hdmi
, 0x7b9, 0x12);
169 hdmi_writeb(hdmi
, 0x7ba, 0x32);
170 hdmi_writeb(hdmi
, 0x7bc, 0x68);
171 hdmi_writeb(hdmi
, 0x7be, 0x40);
172 hdmi_writeb(hdmi
, 0x7bf, 0x84);
173 hdmi_writeb(hdmi
, 0x7c1, 0x0f);
174 hdmi_writeb(hdmi
, 0x7c8, 0x02);
175 hdmi_writeb(hdmi
, 0x7c9, 0x03);
176 hdmi_writeb(hdmi
, 0x7ca, 0x40);
177 hdmi_writeb(hdmi
, 0x7dc, 0x31);
178 hdmi_writeb(hdmi
, 0x7e2, 0x04);
179 hdmi_writeb(hdmi
, 0x7e0, 0x06);
180 hdmi_writeb(hdmi
, 0x7cb, 0x68);
181 hdmi_writeb(hdmi
, 0x7f9, 0x02);
182 hdmi_writeb(hdmi
, 0x7b6, 0x02);
183 hdmi_writeb(hdmi
, 0x7f3, 0x0);
186 static void zx_hdmi_hw_enable(struct zx_hdmi
*hdmi
)
189 hdmi_writeb_mask(hdmi
, CLKPWD
, CLKPWD_PDIDCK
, CLKPWD_PDIDCK
);
191 /* Enable HDMI for TX */
192 hdmi_writeb_mask(hdmi
, FUNC_SEL
, FUNC_HDMI_EN
, FUNC_HDMI_EN
);
194 /* Enable deep color packet */
195 hdmi_writeb_mask(hdmi
, P2T_CTRL
, P2T_DC_PKT_EN
, P2T_DC_PKT_EN
);
197 /* Enable HDMI/MHL mode for output */
198 hdmi_writeb_mask(hdmi
, TEST_TXCTRL
, TEST_TXCTRL_HDMI_MODE
,
199 TEST_TXCTRL_HDMI_MODE
);
201 /* Configure reg_qc_sel */
202 hdmi_writeb(hdmi
, HDMICTL4
, 0x3);
204 /* Enable interrupt */
205 hdmi_writeb_mask(hdmi
, INTR1_MASK
, INTR1_MONITOR_DETECT
,
206 INTR1_MONITOR_DETECT
);
209 zx_hdmi_phy_start(hdmi
);
212 static void zx_hdmi_hw_disable(struct zx_hdmi
*hdmi
)
214 /* Disable interrupt */
215 hdmi_writeb_mask(hdmi
, INTR1_MASK
, INTR1_MONITOR_DETECT
, 0);
217 /* Disable deep color packet */
218 hdmi_writeb_mask(hdmi
, P2T_CTRL
, P2T_DC_PKT_EN
, P2T_DC_PKT_EN
);
220 /* Disable HDMI for TX */
221 hdmi_writeb_mask(hdmi
, FUNC_SEL
, FUNC_HDMI_EN
, 0);
224 hdmi_writeb_mask(hdmi
, CLKPWD
, CLKPWD_PDIDCK
, 0);
227 static void zx_hdmi_encoder_enable(struct drm_encoder
*encoder
)
229 struct zx_hdmi
*hdmi
= to_zx_hdmi(encoder
);
231 clk_prepare_enable(hdmi
->cec_clk
);
232 clk_prepare_enable(hdmi
->osc_clk
);
233 clk_prepare_enable(hdmi
->xclk
);
235 zx_hdmi_hw_enable(hdmi
);
237 vou_inf_enable(VOU_HDMI
, encoder
->crtc
);
240 static void zx_hdmi_encoder_disable(struct drm_encoder
*encoder
)
242 struct zx_hdmi
*hdmi
= to_zx_hdmi(encoder
);
244 vou_inf_disable(VOU_HDMI
, encoder
->crtc
);
246 zx_hdmi_hw_disable(hdmi
);
248 clk_disable_unprepare(hdmi
->xclk
);
249 clk_disable_unprepare(hdmi
->osc_clk
);
250 clk_disable_unprepare(hdmi
->cec_clk
);
253 static const struct drm_encoder_helper_funcs zx_hdmi_encoder_helper_funcs
= {
254 .enable
= zx_hdmi_encoder_enable
,
255 .disable
= zx_hdmi_encoder_disable
,
256 .mode_set
= zx_hdmi_encoder_mode_set
,
259 static const struct drm_encoder_funcs zx_hdmi_encoder_funcs
= {
260 .destroy
= drm_encoder_cleanup
,
263 static int zx_hdmi_connector_get_modes(struct drm_connector
*connector
)
265 struct zx_hdmi
*hdmi
= to_zx_hdmi(connector
);
269 edid
= drm_get_edid(connector
, &hdmi
->ddc
->adap
);
273 hdmi
->sink_is_hdmi
= drm_detect_hdmi_monitor(edid
);
274 hdmi
->sink_has_audio
= drm_detect_monitor_audio(edid
);
275 drm_connector_update_edid_property(connector
, edid
);
276 ret
= drm_add_edid_modes(connector
, edid
);
282 static enum drm_mode_status
283 zx_hdmi_connector_mode_valid(struct drm_connector
*connector
,
284 struct drm_display_mode
*mode
)
289 static struct drm_connector_helper_funcs zx_hdmi_connector_helper_funcs
= {
290 .get_modes
= zx_hdmi_connector_get_modes
,
291 .mode_valid
= zx_hdmi_connector_mode_valid
,
294 static enum drm_connector_status
295 zx_hdmi_connector_detect(struct drm_connector
*connector
, bool force
)
297 struct zx_hdmi
*hdmi
= to_zx_hdmi(connector
);
299 return (hdmi_readb(hdmi
, TPI_HPD_RSEN
) & TPI_HPD_CONNECTION
) ?
300 connector_status_connected
: connector_status_disconnected
;
303 static const struct drm_connector_funcs zx_hdmi_connector_funcs
= {
304 .fill_modes
= drm_helper_probe_single_connector_modes
,
305 .detect
= zx_hdmi_connector_detect
,
306 .destroy
= drm_connector_cleanup
,
307 .reset
= drm_atomic_helper_connector_reset
,
308 .atomic_duplicate_state
= drm_atomic_helper_connector_duplicate_state
,
309 .atomic_destroy_state
= drm_atomic_helper_connector_destroy_state
,
312 static int zx_hdmi_register(struct drm_device
*drm
, struct zx_hdmi
*hdmi
)
314 struct drm_encoder
*encoder
= &hdmi
->encoder
;
316 encoder
->possible_crtcs
= VOU_CRTC_MASK
;
318 drm_encoder_init(drm
, encoder
, &zx_hdmi_encoder_funcs
,
319 DRM_MODE_ENCODER_TMDS
, NULL
);
320 drm_encoder_helper_add(encoder
, &zx_hdmi_encoder_helper_funcs
);
322 hdmi
->connector
.polled
= DRM_CONNECTOR_POLL_HPD
;
324 drm_connector_init(drm
, &hdmi
->connector
, &zx_hdmi_connector_funcs
,
325 DRM_MODE_CONNECTOR_HDMIA
);
326 drm_connector_helper_add(&hdmi
->connector
,
327 &zx_hdmi_connector_helper_funcs
);
329 drm_mode_connector_attach_encoder(&hdmi
->connector
, encoder
);
334 static irqreturn_t
zx_hdmi_irq_thread(int irq
, void *dev_id
)
336 struct zx_hdmi
*hdmi
= dev_id
;
338 drm_helper_hpd_irq_event(hdmi
->connector
.dev
);
343 static irqreturn_t
zx_hdmi_irq_handler(int irq
, void *dev_id
)
345 struct zx_hdmi
*hdmi
= dev_id
;
348 lstat
= hdmi_readb(hdmi
, L1_INTR_STAT
);
350 /* Monitor detect/HPD interrupt */
351 if (lstat
& L1_INTR_STAT_INTR1
) {
354 stat
= hdmi_readb(hdmi
, INTR1_STAT
);
355 hdmi_writeb(hdmi
, INTR1_STAT
, stat
);
357 if (stat
& INTR1_MONITOR_DETECT
)
358 return IRQ_WAKE_THREAD
;
364 static int zx_hdmi_audio_startup(struct device
*dev
, void *data
)
366 struct zx_hdmi
*hdmi
= dev_get_drvdata(dev
);
367 struct drm_encoder
*encoder
= &hdmi
->encoder
;
369 vou_inf_hdmi_audio_sel(encoder
->crtc
, VOU_HDMI_AUD_SPDIF
);
374 static void zx_hdmi_audio_shutdown(struct device
*dev
, void *data
)
376 struct zx_hdmi
*hdmi
= dev_get_drvdata(dev
);
378 /* Disable audio input */
379 hdmi_writeb_mask(hdmi
, AUD_EN
, AUD_IN_EN
, 0);
382 static inline int zx_hdmi_audio_get_n(unsigned int fs
)
386 if (fs
&& (fs
% 44100) == 0)
387 n
= 6272 * (fs
/ 44100);
394 static int zx_hdmi_audio_hw_params(struct device
*dev
,
396 struct hdmi_codec_daifmt
*daifmt
,
397 struct hdmi_codec_params
*params
)
399 struct zx_hdmi
*hdmi
= dev_get_drvdata(dev
);
400 struct hdmi_audio_infoframe
*cea
= ¶ms
->cea
;
401 union hdmi_infoframe frame
;
404 /* We only support spdif for now */
405 if (daifmt
->fmt
!= HDMI_SPDIF
) {
406 DRM_DEV_ERROR(hdmi
->dev
, "invalid daifmt %d\n", daifmt
->fmt
);
410 switch (params
->sample_width
) {
412 hdmi_writeb_mask(hdmi
, TPI_AUD_CONFIG
, SPDIF_SAMPLE_SIZE_MASK
,
413 SPDIF_SAMPLE_SIZE_16BIT
);
416 hdmi_writeb_mask(hdmi
, TPI_AUD_CONFIG
, SPDIF_SAMPLE_SIZE_MASK
,
417 SPDIF_SAMPLE_SIZE_20BIT
);
420 hdmi_writeb_mask(hdmi
, TPI_AUD_CONFIG
, SPDIF_SAMPLE_SIZE_MASK
,
421 SPDIF_SAMPLE_SIZE_24BIT
);
424 DRM_DEV_ERROR(hdmi
->dev
, "invalid sample width %d\n",
425 params
->sample_width
);
429 /* CTS is calculated by hardware, and we only need to take care of N */
430 n
= zx_hdmi_audio_get_n(params
->sample_rate
);
431 hdmi_writeb(hdmi
, N_SVAL1
, n
& 0xff);
432 hdmi_writeb(hdmi
, N_SVAL2
, (n
>> 8) & 0xff);
433 hdmi_writeb(hdmi
, N_SVAL3
, (n
>> 16) & 0xf);
435 /* Enable spdif mode */
436 hdmi_writeb_mask(hdmi
, AUD_MODE
, SPDIF_EN
, SPDIF_EN
);
438 /* Enable audio input */
439 hdmi_writeb_mask(hdmi
, AUD_EN
, AUD_IN_EN
, AUD_IN_EN
);
441 memcpy(&frame
.audio
, cea
, sizeof(*cea
));
443 return zx_hdmi_infoframe_trans(hdmi
, &frame
, FSEL_AUDIO
);
446 static int zx_hdmi_audio_digital_mute(struct device
*dev
, void *data
,
449 struct zx_hdmi
*hdmi
= dev_get_drvdata(dev
);
452 hdmi_writeb_mask(hdmi
, TPI_AUD_CONFIG
, TPI_AUD_MUTE
,
455 hdmi_writeb_mask(hdmi
, TPI_AUD_CONFIG
, TPI_AUD_MUTE
, 0);
460 static int zx_hdmi_audio_get_eld(struct device
*dev
, void *data
,
461 uint8_t *buf
, size_t len
)
463 struct zx_hdmi
*hdmi
= dev_get_drvdata(dev
);
464 struct drm_connector
*connector
= &hdmi
->connector
;
466 memcpy(buf
, connector
->eld
, min(sizeof(connector
->eld
), len
));
471 static const struct hdmi_codec_ops zx_hdmi_codec_ops
= {
472 .audio_startup
= zx_hdmi_audio_startup
,
473 .hw_params
= zx_hdmi_audio_hw_params
,
474 .audio_shutdown
= zx_hdmi_audio_shutdown
,
475 .digital_mute
= zx_hdmi_audio_digital_mute
,
476 .get_eld
= zx_hdmi_audio_get_eld
,
479 static struct hdmi_codec_pdata zx_hdmi_codec_pdata
= {
480 .ops
= &zx_hdmi_codec_ops
,
484 static int zx_hdmi_audio_register(struct zx_hdmi
*hdmi
)
486 struct platform_device
*pdev
;
488 pdev
= platform_device_register_data(hdmi
->dev
, HDMI_CODEC_DRV_NAME
,
490 &zx_hdmi_codec_pdata
,
491 sizeof(zx_hdmi_codec_pdata
));
493 return PTR_ERR(pdev
);
495 hdmi
->audio_pdev
= pdev
;
500 static int zx_hdmi_i2c_read(struct zx_hdmi
*hdmi
, struct i2c_msg
*msg
)
507 /* Bits [9:8] of bytes */
508 hdmi_writeb(hdmi
, ZX_DDC_DIN_CNT2
, (len
>> 8) & 0xff);
509 /* Bits [7:0] of bytes */
510 hdmi_writeb(hdmi
, ZX_DDC_DIN_CNT1
, len
& 0xff);
513 hdmi_writeb_mask(hdmi
, ZX_DDC_CMD
, DDC_CMD_MASK
, DDC_CMD_CLEAR_FIFO
);
515 /* Kick off the read */
516 hdmi_writeb_mask(hdmi
, ZX_DDC_CMD
, DDC_CMD_MASK
,
517 DDC_CMD_SEQUENTIAL_READ
);
522 /* FIFO needs some time to get ready */
523 usleep_range(500, 1000);
525 cnt
= hdmi_readb(hdmi
, ZX_DDC_DOUT_CNT
) & DDC_DOUT_CNT_MASK
;
528 DRM_DEV_ERROR(hdmi
->dev
,
529 "DDC FIFO read timed out!");
535 for (i
= 0; i
< cnt
; i
++)
536 *buf
++ = hdmi_readb(hdmi
, ZX_DDC_DATA
);
543 static int zx_hdmi_i2c_write(struct zx_hdmi
*hdmi
, struct i2c_msg
*msg
)
546 * The DDC I2C adapter is only for reading EDID data, so we assume
547 * that the write to this adapter must be the EDID data offset.
549 if ((msg
->len
!= 1) ||
550 ((msg
->addr
!= DDC_ADDR
) && (msg
->addr
!= DDC_SEGMENT_ADDR
)))
553 if (msg
->addr
== DDC_SEGMENT_ADDR
)
554 hdmi_writeb(hdmi
, ZX_DDC_SEGM
, msg
->addr
<< 1);
555 else if (msg
->addr
== DDC_ADDR
)
556 hdmi_writeb(hdmi
, ZX_DDC_ADDR
, msg
->addr
<< 1);
558 hdmi_writeb(hdmi
, ZX_DDC_OFFSET
, msg
->buf
[0]);
563 static int zx_hdmi_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
,
566 struct zx_hdmi
*hdmi
= i2c_get_adapdata(adap
);
567 struct zx_hdmi_i2c
*ddc
= hdmi
->ddc
;
570 mutex_lock(&ddc
->lock
);
572 /* Enable DDC master access */
573 hdmi_writeb_mask(hdmi
, TPI_DDC_MASTER_EN
, HW_DDC_MASTER
, HW_DDC_MASTER
);
575 for (i
= 0; i
< num
; i
++) {
576 DRM_DEV_DEBUG(hdmi
->dev
,
577 "xfer: num: %d/%d, len: %d, flags: %#x\n",
578 i
+ 1, num
, msgs
[i
].len
, msgs
[i
].flags
);
580 if (msgs
[i
].flags
& I2C_M_RD
)
581 ret
= zx_hdmi_i2c_read(hdmi
, &msgs
[i
]);
583 ret
= zx_hdmi_i2c_write(hdmi
, &msgs
[i
]);
592 /* Disable DDC master access */
593 hdmi_writeb_mask(hdmi
, TPI_DDC_MASTER_EN
, HW_DDC_MASTER
, 0);
595 mutex_unlock(&ddc
->lock
);
600 static u32
zx_hdmi_i2c_func(struct i2c_adapter
*adapter
)
602 return I2C_FUNC_I2C
| I2C_FUNC_SMBUS_EMUL
;
605 static const struct i2c_algorithm zx_hdmi_algorithm
= {
606 .master_xfer
= zx_hdmi_i2c_xfer
,
607 .functionality
= zx_hdmi_i2c_func
,
610 static int zx_hdmi_ddc_register(struct zx_hdmi
*hdmi
)
612 struct i2c_adapter
*adap
;
613 struct zx_hdmi_i2c
*ddc
;
616 ddc
= devm_kzalloc(hdmi
->dev
, sizeof(*ddc
), GFP_KERNEL
);
621 mutex_init(&ddc
->lock
);
624 adap
->owner
= THIS_MODULE
;
625 adap
->class = I2C_CLASS_DDC
;
626 adap
->dev
.parent
= hdmi
->dev
;
627 adap
->algo
= &zx_hdmi_algorithm
;
628 snprintf(adap
->name
, sizeof(adap
->name
), "zx hdmi i2c");
630 ret
= i2c_add_adapter(adap
);
632 DRM_DEV_ERROR(hdmi
->dev
, "failed to add I2C adapter: %d\n",
637 i2c_set_adapdata(adap
, hdmi
);
642 static int zx_hdmi_bind(struct device
*dev
, struct device
*master
, void *data
)
644 struct platform_device
*pdev
= to_platform_device(dev
);
645 struct drm_device
*drm
= data
;
646 struct resource
*res
;
647 struct zx_hdmi
*hdmi
;
651 hdmi
= devm_kzalloc(dev
, sizeof(*hdmi
), GFP_KERNEL
);
658 dev_set_drvdata(dev
, hdmi
);
660 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
661 hdmi
->mmio
= devm_ioremap_resource(dev
, res
);
662 if (IS_ERR(hdmi
->mmio
)) {
663 ret
= PTR_ERR(hdmi
->mmio
);
664 DRM_DEV_ERROR(dev
, "failed to remap hdmi region: %d\n", ret
);
668 irq
= platform_get_irq(pdev
, 0);
672 hdmi
->cec_clk
= devm_clk_get(hdmi
->dev
, "osc_cec");
673 if (IS_ERR(hdmi
->cec_clk
)) {
674 ret
= PTR_ERR(hdmi
->cec_clk
);
675 DRM_DEV_ERROR(dev
, "failed to get cec_clk: %d\n", ret
);
679 hdmi
->osc_clk
= devm_clk_get(hdmi
->dev
, "osc_clk");
680 if (IS_ERR(hdmi
->osc_clk
)) {
681 ret
= PTR_ERR(hdmi
->osc_clk
);
682 DRM_DEV_ERROR(dev
, "failed to get osc_clk: %d\n", ret
);
686 hdmi
->xclk
= devm_clk_get(hdmi
->dev
, "xclk");
687 if (IS_ERR(hdmi
->xclk
)) {
688 ret
= PTR_ERR(hdmi
->xclk
);
689 DRM_DEV_ERROR(dev
, "failed to get xclk: %d\n", ret
);
693 ret
= zx_hdmi_ddc_register(hdmi
);
695 DRM_DEV_ERROR(dev
, "failed to register ddc: %d\n", ret
);
699 ret
= zx_hdmi_audio_register(hdmi
);
701 DRM_DEV_ERROR(dev
, "failed to register audio: %d\n", ret
);
705 ret
= zx_hdmi_register(drm
, hdmi
);
707 DRM_DEV_ERROR(dev
, "failed to register hdmi: %d\n", ret
);
711 ret
= devm_request_threaded_irq(dev
, irq
, zx_hdmi_irq_handler
,
712 zx_hdmi_irq_thread
, IRQF_SHARED
,
713 dev_name(dev
), hdmi
);
715 DRM_DEV_ERROR(dev
, "failed to request threaded irq: %d\n", ret
);
722 static void zx_hdmi_unbind(struct device
*dev
, struct device
*master
,
725 struct zx_hdmi
*hdmi
= dev_get_drvdata(dev
);
727 hdmi
->connector
.funcs
->destroy(&hdmi
->connector
);
728 hdmi
->encoder
.funcs
->destroy(&hdmi
->encoder
);
730 if (hdmi
->audio_pdev
)
731 platform_device_unregister(hdmi
->audio_pdev
);
734 static const struct component_ops zx_hdmi_component_ops
= {
735 .bind
= zx_hdmi_bind
,
736 .unbind
= zx_hdmi_unbind
,
739 static int zx_hdmi_probe(struct platform_device
*pdev
)
741 return component_add(&pdev
->dev
, &zx_hdmi_component_ops
);
744 static int zx_hdmi_remove(struct platform_device
*pdev
)
746 component_del(&pdev
->dev
, &zx_hdmi_component_ops
);
750 static const struct of_device_id zx_hdmi_of_match
[] = {
751 { .compatible
= "zte,zx296718-hdmi", },
754 MODULE_DEVICE_TABLE(of
, zx_hdmi_of_match
);
756 struct platform_driver zx_hdmi_driver
= {
757 .probe
= zx_hdmi_probe
,
758 .remove
= zx_hdmi_remove
,
761 .of_match_table
= zx_hdmi_of_match
,