1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2012 Texas Instruments 4 * Author: Rob Clark <robdclark@gmail.com> 5 */ 6 7 #include <linux/component.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/hdmi.h> 10 #include <linux/i2c.h> 11 #include <linux/module.h> 12 #include <linux/platform_data/tda9950.h> 13 #include <linux/irq.h> 14 #include <sound/asoundef.h> 15 #include <sound/hdmi-codec.h> 16 17 #include <drm/drm_atomic_helper.h> 18 #include <drm/drm_bridge.h> 19 #include <drm/drm_edid.h> 20 #include <drm/drm_of.h> 21 #include <drm/drm_print.h> 22 #include <drm/drm_probe_helper.h> 23 #include <drm/drm_simple_kms_helper.h> 24 #include <drm/i2c/tda998x.h> 25 26 #include <media/cec-notifier.h> 27 28 #define DBG(fmt, ...) DRM_DEBUG(fmt"\n", ##__VA_ARGS__) 29 30 enum { 31 AUDIO_ROUTE_I2S, 32 AUDIO_ROUTE_SPDIF, 33 AUDIO_ROUTE_NUM 34 }; 35 36 struct tda998x_audio_route { 37 u8 ena_aclk; 38 u8 mux_ap; 39 u8 aip_clksel; 40 }; 41 42 struct tda998x_audio_settings { 43 const struct tda998x_audio_route *route; 44 struct hdmi_audio_infoframe cea; 45 unsigned int sample_rate; 46 u8 status[5]; 47 u8 ena_ap; 48 u8 i2s_format; 49 u8 cts_n; 50 }; 51 52 struct tda998x_priv { 53 struct i2c_client *cec; 54 struct i2c_client *hdmi; 55 struct mutex mutex; 56 u16 rev; 57 u8 cec_addr; 58 u8 current_page; 59 bool is_on; 60 bool supports_infoframes; 61 bool sink_has_audio; 62 enum hdmi_quantization_range rgb_quant_range; 63 u8 vip_cntrl_0; 64 u8 vip_cntrl_1; 65 u8 vip_cntrl_2; 66 unsigned long tmds_clock; 67 struct tda998x_audio_settings audio; 68 69 struct platform_device *audio_pdev; 70 struct mutex audio_mutex; 71 72 struct mutex edid_mutex; 73 wait_queue_head_t wq_edid; 74 volatile int wq_edid_wait; 75 76 struct work_struct detect_work; 77 struct timer_list edid_delay_timer; 78 wait_queue_head_t edid_delay_waitq; 79 bool edid_delay_active; 80 81 struct drm_encoder encoder; 82 struct drm_bridge bridge; 83 struct drm_connector connector; 84 85 u8 audio_port_enable[AUDIO_ROUTE_NUM]; 86 struct tda9950_glue cec_glue; 87 struct gpio_desc *calib; 88 struct cec_notifier *cec_notify; 89 }; 90 91 #define conn_to_tda998x_priv(x) \ 92 container_of(x, struct tda998x_priv, connector) 93 #define enc_to_tda998x_priv(x) \ 94 container_of(x, struct tda998x_priv, encoder) 95 #define bridge_to_tda998x_priv(x) \ 96 container_of(x, struct tda998x_priv, bridge) 97 98 /* The TDA9988 series of devices use a paged register scheme.. to simplify 99 * things we encode the page # in upper bits of the register #. To read/ 100 * write a given register, we need to make sure CURPAGE register is set 101 * appropriately. Which implies reads/writes are not atomic. Fun! 102 */ 103 104 #define REG(page, addr) (((page) << 8) | (addr)) 105 #define REG2ADDR(reg) ((reg) & 0xff) 106 #define REG2PAGE(reg) (((reg) >> 8) & 0xff) 107 108 #define REG_CURPAGE 0xff /* write */ 109 110 111 /* Page 00h: General Control */ 112 #define REG_VERSION_LSB REG(0x00, 0x00) /* read */ 113 #define REG_MAIN_CNTRL0 REG(0x00, 0x01) /* read/write */ 114 # define MAIN_CNTRL0_SR (1 << 0) 115 # define MAIN_CNTRL0_DECS (1 << 1) 116 # define MAIN_CNTRL0_DEHS (1 << 2) 117 # define MAIN_CNTRL0_CECS (1 << 3) 118 # define MAIN_CNTRL0_CEHS (1 << 4) 119 # define MAIN_CNTRL0_SCALER (1 << 7) 120 #define REG_VERSION_MSB REG(0x00, 0x02) /* read */ 121 #define REG_SOFTRESET REG(0x00, 0x0a) /* write */ 122 # define SOFTRESET_AUDIO (1 << 0) 123 # define SOFTRESET_I2C_MASTER (1 << 1) 124 #define REG_DDC_DISABLE REG(0x00, 0x0b) /* read/write */ 125 #define REG_CCLK_ON REG(0x00, 0x0c) /* read/write */ 126 #define REG_I2C_MASTER REG(0x00, 0x0d) /* read/write */ 127 # define I2C_MASTER_DIS_MM (1 << 0) 128 # define I2C_MASTER_DIS_FILT (1 << 1) 129 # define I2C_MASTER_APP_STRT_LAT (1 << 2) 130 #define REG_FEAT_POWERDOWN REG(0x00, 0x0e) /* read/write */ 131 # define FEAT_POWERDOWN_PREFILT BIT(0) 132 # define FEAT_POWERDOWN_CSC BIT(1) 133 # define FEAT_POWERDOWN_SPDIF (1 << 3) 134 #define REG_INT_FLAGS_0 REG(0x00, 0x0f) /* read/write */ 135 #define REG_INT_FLAGS_1 REG(0x00, 0x10) /* read/write */ 136 #define REG_INT_FLAGS_2 REG(0x00, 0x11) /* read/write */ 137 # define INT_FLAGS_2_EDID_BLK_RD (1 << 1) 138 #define REG_ENA_ACLK REG(0x00, 0x16) /* read/write */ 139 #define REG_ENA_VP_0 REG(0x00, 0x18) /* read/write */ 140 #define REG_ENA_VP_1 REG(0x00, 0x19) /* read/write */ 141 #define REG_ENA_VP_2 REG(0x00, 0x1a) /* read/write */ 142 #define REG_ENA_AP REG(0x00, 0x1e) /* read/write */ 143 #define REG_VIP_CNTRL_0 REG(0x00, 0x20) /* write */ 144 # define VIP_CNTRL_0_MIRR_A (1 << 7) 145 # define VIP_CNTRL_0_SWAP_A(x) (((x) & 7) << 4) 146 # define VIP_CNTRL_0_MIRR_B (1 << 3) 147 # define VIP_CNTRL_0_SWAP_B(x) (((x) & 7) << 0) 148 #define REG_VIP_CNTRL_1 REG(0x00, 0x21) /* write */ 149 # define VIP_CNTRL_1_MIRR_C (1 << 7) 150 # define VIP_CNTRL_1_SWAP_C(x) (((x) & 7) << 4) 151 # define VIP_CNTRL_1_MIRR_D (1 << 3) 152 # define VIP_CNTRL_1_SWAP_D(x) (((x) & 7) << 0) 153 #define REG_VIP_CNTRL_2 REG(0x00, 0x22) /* write */ 154 # define VIP_CNTRL_2_MIRR_E (1 << 7) 155 # define VIP_CNTRL_2_SWAP_E(x) (((x) & 7) << 4) 156 # define VIP_CNTRL_2_MIRR_F (1 << 3) 157 # define VIP_CNTRL_2_SWAP_F(x) (((x) & 7) << 0) 158 #define REG_VIP_CNTRL_3 REG(0x00, 0x23) /* write */ 159 # define VIP_CNTRL_3_X_TGL (1 << 0) 160 # define VIP_CNTRL_3_H_TGL (1 << 1) 161 # define VIP_CNTRL_3_V_TGL (1 << 2) 162 # define VIP_CNTRL_3_EMB (1 << 3) 163 # define VIP_CNTRL_3_SYNC_DE (1 << 4) 164 # define VIP_CNTRL_3_SYNC_HS (1 << 5) 165 # define VIP_CNTRL_3_DE_INT (1 << 6) 166 # define VIP_CNTRL_3_EDGE (1 << 7) 167 #define REG_VIP_CNTRL_4 REG(0x00, 0x24) /* write */ 168 # define VIP_CNTRL_4_BLC(x) (((x) & 3) << 0) 169 # define VIP_CNTRL_4_BLANKIT(x) (((x) & 3) << 2) 170 # define VIP_CNTRL_4_CCIR656 (1 << 4) 171 # define VIP_CNTRL_4_656_ALT (1 << 5) 172 # define VIP_CNTRL_4_TST_656 (1 << 6) 173 # define VIP_CNTRL_4_TST_PAT (1 << 7) 174 #define REG_VIP_CNTRL_5 REG(0x00, 0x25) /* write */ 175 # define VIP_CNTRL_5_CKCASE (1 << 0) 176 # define VIP_CNTRL_5_SP_CNT(x) (((x) & 3) << 1) 177 #define REG_MUX_AP REG(0x00, 0x26) /* read/write */ 178 # define MUX_AP_SELECT_I2S 0x64 179 # define MUX_AP_SELECT_SPDIF 0x40 180 #define REG_MUX_VP_VIP_OUT REG(0x00, 0x27) /* read/write */ 181 #define REG_MAT_CONTRL REG(0x00, 0x80) /* write */ 182 # define MAT_CONTRL_MAT_SC(x) (((x) & 3) << 0) 183 # define MAT_CONTRL_MAT_BP (1 << 2) 184 #define REG_VIDFORMAT REG(0x00, 0xa0) /* write */ 185 #define REG_REFPIX_MSB REG(0x00, 0xa1) /* write */ 186 #define REG_REFPIX_LSB REG(0x00, 0xa2) /* write */ 187 #define REG_REFLINE_MSB REG(0x00, 0xa3) /* write */ 188 #define REG_REFLINE_LSB REG(0x00, 0xa4) /* write */ 189 #define REG_NPIX_MSB REG(0x00, 0xa5) /* write */ 190 #define REG_NPIX_LSB REG(0x00, 0xa6) /* write */ 191 #define REG_NLINE_MSB REG(0x00, 0xa7) /* write */ 192 #define REG_NLINE_LSB REG(0x00, 0xa8) /* write */ 193 #define REG_VS_LINE_STRT_1_MSB REG(0x00, 0xa9) /* write */ 194 #define REG_VS_LINE_STRT_1_LSB REG(0x00, 0xaa) /* write */ 195 #define REG_VS_PIX_STRT_1_MSB REG(0x00, 0xab) /* write */ 196 #define REG_VS_PIX_STRT_1_LSB REG(0x00, 0xac) /* write */ 197 #define REG_VS_LINE_END_1_MSB REG(0x00, 0xad) /* write */ 198 #define REG_VS_LINE_END_1_LSB REG(0x00, 0xae) /* write */ 199 #define REG_VS_PIX_END_1_MSB REG(0x00, 0xaf) /* write */ 200 #define REG_VS_PIX_END_1_LSB REG(0x00, 0xb0) /* write */ 201 #define REG_VS_LINE_STRT_2_MSB REG(0x00, 0xb1) /* write */ 202 #define REG_VS_LINE_STRT_2_LSB REG(0x00, 0xb2) /* write */ 203 #define REG_VS_PIX_STRT_2_MSB REG(0x00, 0xb3) /* write */ 204 #define REG_VS_PIX_STRT_2_LSB REG(0x00, 0xb4) /* write */ 205 #define REG_VS_LINE_END_2_MSB REG(0x00, 0xb5) /* write */ 206 #define REG_VS_LINE_END_2_LSB REG(0x00, 0xb6) /* write */ 207 #define REG_VS_PIX_END_2_MSB REG(0x00, 0xb7) /* write */ 208 #define REG_VS_PIX_END_2_LSB REG(0x00, 0xb8) /* write */ 209 #define REG_HS_PIX_START_MSB REG(0x00, 0xb9) /* write */ 210 #define REG_HS_PIX_START_LSB REG(0x00, 0xba) /* write */ 211 #define REG_HS_PIX_STOP_MSB REG(0x00, 0xbb) /* write */ 212 #define REG_HS_PIX_STOP_LSB REG(0x00, 0xbc) /* write */ 213 #define REG_VWIN_START_1_MSB REG(0x00, 0xbd) /* write */ 214 #define REG_VWIN_START_1_LSB REG(0x00, 0xbe) /* write */ 215 #define REG_VWIN_END_1_MSB REG(0x00, 0xbf) /* write */ 216 #define REG_VWIN_END_1_LSB REG(0x00, 0xc0) /* write */ 217 #define REG_VWIN_START_2_MSB REG(0x00, 0xc1) /* write */ 218 #define REG_VWIN_START_2_LSB REG(0x00, 0xc2) /* write */ 219 #define REG_VWIN_END_2_MSB REG(0x00, 0xc3) /* write */ 220 #define REG_VWIN_END_2_LSB REG(0x00, 0xc4) /* write */ 221 #define REG_DE_START_MSB REG(0x00, 0xc5) /* write */ 222 #define REG_DE_START_LSB REG(0x00, 0xc6) /* write */ 223 #define REG_DE_STOP_MSB REG(0x00, 0xc7) /* write */ 224 #define REG_DE_STOP_LSB REG(0x00, 0xc8) /* write */ 225 #define REG_TBG_CNTRL_0 REG(0x00, 0xca) /* write */ 226 # define TBG_CNTRL_0_TOP_TGL (1 << 0) 227 # define TBG_CNTRL_0_TOP_SEL (1 << 1) 228 # define TBG_CNTRL_0_DE_EXT (1 << 2) 229 # define TBG_CNTRL_0_TOP_EXT (1 << 3) 230 # define TBG_CNTRL_0_FRAME_DIS (1 << 5) 231 # define TBG_CNTRL_0_SYNC_MTHD (1 << 6) 232 # define TBG_CNTRL_0_SYNC_ONCE (1 << 7) 233 #define REG_TBG_CNTRL_1 REG(0x00, 0xcb) /* write */ 234 # define TBG_CNTRL_1_H_TGL (1 << 0) 235 # define TBG_CNTRL_1_V_TGL (1 << 1) 236 # define TBG_CNTRL_1_TGL_EN (1 << 2) 237 # define TBG_CNTRL_1_X_EXT (1 << 3) 238 # define TBG_CNTRL_1_H_EXT (1 << 4) 239 # define TBG_CNTRL_1_V_EXT (1 << 5) 240 # define TBG_CNTRL_1_DWIN_DIS (1 << 6) 241 #define REG_ENABLE_SPACE REG(0x00, 0xd6) /* write */ 242 #define REG_HVF_CNTRL_0 REG(0x00, 0xe4) /* write */ 243 # define HVF_CNTRL_0_SM (1 << 7) 244 # define HVF_CNTRL_0_RWB (1 << 6) 245 # define HVF_CNTRL_0_PREFIL(x) (((x) & 3) << 2) 246 # define HVF_CNTRL_0_INTPOL(x) (((x) & 3) << 0) 247 #define REG_HVF_CNTRL_1 REG(0x00, 0xe5) /* write */ 248 # define HVF_CNTRL_1_FOR (1 << 0) 249 # define HVF_CNTRL_1_YUVBLK (1 << 1) 250 # define HVF_CNTRL_1_VQR(x) (((x) & 3) << 2) 251 # define HVF_CNTRL_1_PAD(x) (((x) & 3) << 4) 252 # define HVF_CNTRL_1_SEMI_PLANAR (1 << 6) 253 #define REG_RPT_CNTRL REG(0x00, 0xf0) /* write */ 254 # define RPT_CNTRL_REPEAT(x) ((x) & 15) 255 #define REG_I2S_FORMAT REG(0x00, 0xfc) /* read/write */ 256 # define I2S_FORMAT_PHILIPS (0 << 0) 257 # define I2S_FORMAT_LEFT_J (2 << 0) 258 # define I2S_FORMAT_RIGHT_J (3 << 0) 259 #define REG_AIP_CLKSEL REG(0x00, 0xfd) /* write */ 260 # define AIP_CLKSEL_AIP_SPDIF (0 << 3) 261 # define AIP_CLKSEL_AIP_I2S (1 << 3) 262 # define AIP_CLKSEL_FS_ACLK (0 << 0) 263 # define AIP_CLKSEL_FS_MCLK (1 << 0) 264 # define AIP_CLKSEL_FS_FS64SPDIF (2 << 0) 265 266 /* Page 02h: PLL settings */ 267 #define REG_PLL_SERIAL_1 REG(0x02, 0x00) /* read/write */ 268 # define PLL_SERIAL_1_SRL_FDN (1 << 0) 269 # define PLL_SERIAL_1_SRL_IZ(x) (((x) & 3) << 1) 270 # define PLL_SERIAL_1_SRL_MAN_IZ (1 << 6) 271 #define REG_PLL_SERIAL_2 REG(0x02, 0x01) /* read/write */ 272 # define PLL_SERIAL_2_SRL_NOSC(x) ((x) << 0) 273 # define PLL_SERIAL_2_SRL_PR(x) (((x) & 0xf) << 4) 274 #define REG_PLL_SERIAL_3 REG(0x02, 0x02) /* read/write */ 275 # define PLL_SERIAL_3_SRL_CCIR (1 << 0) 276 # define PLL_SERIAL_3_SRL_DE (1 << 2) 277 # define PLL_SERIAL_3_SRL_PXIN_SEL (1 << 4) 278 #define REG_SERIALIZER REG(0x02, 0x03) /* read/write */ 279 #define REG_BUFFER_OUT REG(0x02, 0x04) /* read/write */ 280 #define REG_PLL_SCG1 REG(0x02, 0x05) /* read/write */ 281 #define REG_PLL_SCG2 REG(0x02, 0x06) /* read/write */ 282 #define REG_PLL_SCGN1 REG(0x02, 0x07) /* read/write */ 283 #define REG_PLL_SCGN2 REG(0x02, 0x08) /* read/write */ 284 #define REG_PLL_SCGR1 REG(0x02, 0x09) /* read/write */ 285 #define REG_PLL_SCGR2 REG(0x02, 0x0a) /* read/write */ 286 #define REG_AUDIO_DIV REG(0x02, 0x0e) /* read/write */ 287 # define AUDIO_DIV_SERCLK_1 0 288 # define AUDIO_DIV_SERCLK_2 1 289 # define AUDIO_DIV_SERCLK_4 2 290 # define AUDIO_DIV_SERCLK_8 3 291 # define AUDIO_DIV_SERCLK_16 4 292 # define AUDIO_DIV_SERCLK_32 5 293 #define REG_SEL_CLK REG(0x02, 0x11) /* read/write */ 294 # define SEL_CLK_SEL_CLK1 (1 << 0) 295 # define SEL_CLK_SEL_VRF_CLK(x) (((x) & 3) << 1) 296 # define SEL_CLK_ENA_SC_CLK (1 << 3) 297 #define REG_ANA_GENERAL REG(0x02, 0x12) /* read/write */ 298 299 300 /* Page 09h: EDID Control */ 301 #define REG_EDID_DATA_0 REG(0x09, 0x00) /* read */ 302 /* next 127 successive registers are the EDID block */ 303 #define REG_EDID_CTRL REG(0x09, 0xfa) /* read/write */ 304 #define REG_DDC_ADDR REG(0x09, 0xfb) /* read/write */ 305 #define REG_DDC_OFFS REG(0x09, 0xfc) /* read/write */ 306 #define REG_DDC_SEGM_ADDR REG(0x09, 0xfd) /* read/write */ 307 #define REG_DDC_SEGM REG(0x09, 0xfe) /* read/write */ 308 309 310 /* Page 10h: information frames and packets */ 311 #define REG_IF1_HB0 REG(0x10, 0x20) /* read/write */ 312 #define REG_IF2_HB0 REG(0x10, 0x40) /* read/write */ 313 #define REG_IF3_HB0 REG(0x10, 0x60) /* read/write */ 314 #define REG_IF4_HB0 REG(0x10, 0x80) /* read/write */ 315 #define REG_IF5_HB0 REG(0x10, 0xa0) /* read/write */ 316 317 318 /* Page 11h: audio settings and content info packets */ 319 #define REG_AIP_CNTRL_0 REG(0x11, 0x00) /* read/write */ 320 # define AIP_CNTRL_0_RST_FIFO (1 << 0) 321 # define AIP_CNTRL_0_SWAP (1 << 1) 322 # define AIP_CNTRL_0_LAYOUT (1 << 2) 323 # define AIP_CNTRL_0_ACR_MAN (1 << 5) 324 # define AIP_CNTRL_0_RST_CTS (1 << 6) 325 #define REG_CA_I2S REG(0x11, 0x01) /* read/write */ 326 # define CA_I2S_CA_I2S(x) (((x) & 31) << 0) 327 # define CA_I2S_HBR_CHSTAT (1 << 6) 328 #define REG_LATENCY_RD REG(0x11, 0x04) /* read/write */ 329 #define REG_ACR_CTS_0 REG(0x11, 0x05) /* read/write */ 330 #define REG_ACR_CTS_1 REG(0x11, 0x06) /* read/write */ 331 #define REG_ACR_CTS_2 REG(0x11, 0x07) /* read/write */ 332 #define REG_ACR_N_0 REG(0x11, 0x08) /* read/write */ 333 #define REG_ACR_N_1 REG(0x11, 0x09) /* read/write */ 334 #define REG_ACR_N_2 REG(0x11, 0x0a) /* read/write */ 335 #define REG_CTS_N REG(0x11, 0x0c) /* read/write */ 336 # define CTS_N_K(x) (((x) & 7) << 0) 337 # define CTS_N_M(x) (((x) & 3) << 4) 338 #define REG_ENC_CNTRL REG(0x11, 0x0d) /* read/write */ 339 # define ENC_CNTRL_RST_ENC (1 << 0) 340 # define ENC_CNTRL_RST_SEL (1 << 1) 341 # define ENC_CNTRL_CTL_CODE(x) (((x) & 3) << 2) 342 #define REG_DIP_FLAGS REG(0x11, 0x0e) /* read/write */ 343 # define DIP_FLAGS_ACR (1 << 0) 344 # define DIP_FLAGS_GC (1 << 1) 345 #define REG_DIP_IF_FLAGS REG(0x11, 0x0f) /* read/write */ 346 # define DIP_IF_FLAGS_IF1 (1 << 1) 347 # define DIP_IF_FLAGS_IF2 (1 << 2) 348 # define DIP_IF_FLAGS_IF3 (1 << 3) 349 # define DIP_IF_FLAGS_IF4 (1 << 4) 350 # define DIP_IF_FLAGS_IF5 (1 << 5) 351 #define REG_CH_STAT_B(x) REG(0x11, 0x14 + (x)) /* read/write */ 352 353 354 /* Page 12h: HDCP and OTP */ 355 #define REG_TX3 REG(0x12, 0x9a) /* read/write */ 356 #define REG_TX4 REG(0x12, 0x9b) /* read/write */ 357 # define TX4_PD_RAM (1 << 1) 358 #define REG_TX33 REG(0x12, 0xb8) /* read/write */ 359 # define TX33_HDMI (1 << 1) 360 361 362 /* Page 13h: Gamut related metadata packets */ 363 364 365 366 /* CEC registers: (not paged) 367 */ 368 #define REG_CEC_INTSTATUS 0xee /* read */ 369 # define CEC_INTSTATUS_CEC (1 << 0) 370 # define CEC_INTSTATUS_HDMI (1 << 1) 371 #define REG_CEC_CAL_XOSC_CTRL1 0xf2 372 # define CEC_CAL_XOSC_CTRL1_ENA_CAL BIT(0) 373 #define REG_CEC_DES_FREQ2 0xf5 374 # define CEC_DES_FREQ2_DIS_AUTOCAL BIT(7) 375 #define REG_CEC_CLK 0xf6 376 # define CEC_CLK_FRO 0x11 377 #define REG_CEC_FRO_IM_CLK_CTRL 0xfb /* read/write */ 378 # define CEC_FRO_IM_CLK_CTRL_GHOST_DIS (1 << 7) 379 # define CEC_FRO_IM_CLK_CTRL_ENA_OTP (1 << 6) 380 # define CEC_FRO_IM_CLK_CTRL_IMCLK_SEL (1 << 1) 381 # define CEC_FRO_IM_CLK_CTRL_FRO_DIV (1 << 0) 382 #define REG_CEC_RXSHPDINTENA 0xfc /* read/write */ 383 #define REG_CEC_RXSHPDINT 0xfd /* read */ 384 # define CEC_RXSHPDINT_RXSENS BIT(0) 385 # define CEC_RXSHPDINT_HPD BIT(1) 386 #define REG_CEC_RXSHPDLEV 0xfe /* read */ 387 # define CEC_RXSHPDLEV_RXSENS (1 << 0) 388 # define CEC_RXSHPDLEV_HPD (1 << 1) 389 390 #define REG_CEC_ENAMODS 0xff /* read/write */ 391 # define CEC_ENAMODS_EN_CEC_CLK (1 << 7) 392 # define CEC_ENAMODS_DIS_FRO (1 << 6) 393 # define CEC_ENAMODS_DIS_CCLK (1 << 5) 394 # define CEC_ENAMODS_EN_RXSENS (1 << 2) 395 # define CEC_ENAMODS_EN_HDMI (1 << 1) 396 # define CEC_ENAMODS_EN_CEC (1 << 0) 397 398 399 /* Device versions: */ 400 #define TDA9989N2 0x0101 401 #define TDA19989 0x0201 402 #define TDA19989N2 0x0202 403 #define TDA19988 0x0301 404 405 static void 406 cec_write(struct tda998x_priv *priv, u16 addr, u8 val) 407 { 408 u8 buf[] = {addr, val}; 409 struct i2c_msg msg = { 410 .addr = priv->cec_addr, 411 .len = 2, 412 .buf = buf, 413 }; 414 int ret; 415 416 ret = i2c_transfer(priv->hdmi->adapter, &msg, 1); 417 if (ret < 0) 418 dev_err(&priv->hdmi->dev, "Error %d writing to cec:0x%x\n", 419 ret, addr); 420 } 421 422 static u8 423 cec_read(struct tda998x_priv *priv, u8 addr) 424 { 425 u8 val; 426 struct i2c_msg msg[2] = { 427 { 428 .addr = priv->cec_addr, 429 .len = 1, 430 .buf = &addr, 431 }, { 432 .addr = priv->cec_addr, 433 .flags = I2C_M_RD, 434 .len = 1, 435 .buf = &val, 436 }, 437 }; 438 int ret; 439 440 ret = i2c_transfer(priv->hdmi->adapter, msg, ARRAY_SIZE(msg)); 441 if (ret < 0) { 442 dev_err(&priv->hdmi->dev, "Error %d reading from cec:0x%x\n", 443 ret, addr); 444 val = 0; 445 } 446 447 return val; 448 } 449 450 static void cec_enamods(struct tda998x_priv *priv, u8 mods, bool enable) 451 { 452 int val = cec_read(priv, REG_CEC_ENAMODS); 453 454 if (val < 0) 455 return; 456 457 if (enable) 458 val |= mods; 459 else 460 val &= ~mods; 461 462 cec_write(priv, REG_CEC_ENAMODS, val); 463 } 464 465 static void tda998x_cec_set_calibration(struct tda998x_priv *priv, bool enable) 466 { 467 if (enable) { 468 u8 val; 469 470 cec_write(priv, 0xf3, 0xc0); 471 cec_write(priv, 0xf4, 0xd4); 472 473 /* Enable automatic calibration mode */ 474 val = cec_read(priv, REG_CEC_DES_FREQ2); 475 val &= ~CEC_DES_FREQ2_DIS_AUTOCAL; 476 cec_write(priv, REG_CEC_DES_FREQ2, val); 477 478 /* Enable free running oscillator */ 479 cec_write(priv, REG_CEC_CLK, CEC_CLK_FRO); 480 cec_enamods(priv, CEC_ENAMODS_DIS_FRO, false); 481 482 cec_write(priv, REG_CEC_CAL_XOSC_CTRL1, 483 CEC_CAL_XOSC_CTRL1_ENA_CAL); 484 } else { 485 cec_write(priv, REG_CEC_CAL_XOSC_CTRL1, 0); 486 } 487 } 488 489 /* 490 * Calibration for the internal oscillator: we need to set calibration mode, 491 * and then pulse the IRQ line low for a 10ms ± 1% period. 492 */ 493 static void tda998x_cec_calibration(struct tda998x_priv *priv) 494 { 495 struct gpio_desc *calib = priv->calib; 496 497 mutex_lock(&priv->edid_mutex); 498 if (priv->hdmi->irq > 0) 499 disable_irq(priv->hdmi->irq); 500 gpiod_direction_output(calib, 1); 501 tda998x_cec_set_calibration(priv, true); 502 503 local_irq_disable(); 504 gpiod_set_value(calib, 0); 505 mdelay(10); 506 gpiod_set_value(calib, 1); 507 local_irq_enable(); 508 509 tda998x_cec_set_calibration(priv, false); 510 gpiod_direction_input(calib); 511 if (priv->hdmi->irq > 0) 512 enable_irq(priv->hdmi->irq); 513 mutex_unlock(&priv->edid_mutex); 514 } 515 516 static int tda998x_cec_hook_init(void *data) 517 { 518 struct tda998x_priv *priv = data; 519 struct gpio_desc *calib; 520 521 calib = gpiod_get(&priv->hdmi->dev, "nxp,calib", GPIOD_ASIS); 522 if (IS_ERR(calib)) { 523 dev_warn(&priv->hdmi->dev, "failed to get calibration gpio: %ld\n", 524 PTR_ERR(calib)); 525 return PTR_ERR(calib); 526 } 527 528 priv->calib = calib; 529 530 return 0; 531 } 532 533 static void tda998x_cec_hook_exit(void *data) 534 { 535 struct tda998x_priv *priv = data; 536 537 gpiod_put(priv->calib); 538 priv->calib = NULL; 539 } 540 541 static int tda998x_cec_hook_open(void *data) 542 { 543 struct tda998x_priv *priv = data; 544 545 cec_enamods(priv, CEC_ENAMODS_EN_CEC_CLK | CEC_ENAMODS_EN_CEC, true); 546 tda998x_cec_calibration(priv); 547 548 return 0; 549 } 550 551 static void tda998x_cec_hook_release(void *data) 552 { 553 struct tda998x_priv *priv = data; 554 555 cec_enamods(priv, CEC_ENAMODS_EN_CEC_CLK | CEC_ENAMODS_EN_CEC, false); 556 } 557 558 static int 559 set_page(struct tda998x_priv *priv, u16 reg) 560 { 561 if (REG2PAGE(reg) != priv->current_page) { 562 struct i2c_client *client = priv->hdmi; 563 u8 buf[] = { 564 REG_CURPAGE, REG2PAGE(reg) 565 }; 566 int ret = i2c_master_send(client, buf, sizeof(buf)); 567 if (ret < 0) { 568 dev_err(&client->dev, "%s %04x err %d\n", __func__, 569 reg, ret); 570 return ret; 571 } 572 573 priv->current_page = REG2PAGE(reg); 574 } 575 return 0; 576 } 577 578 static int 579 reg_read_range(struct tda998x_priv *priv, u16 reg, char *buf, int cnt) 580 { 581 struct i2c_client *client = priv->hdmi; 582 u8 addr = REG2ADDR(reg); 583 int ret; 584 585 mutex_lock(&priv->mutex); 586 ret = set_page(priv, reg); 587 if (ret < 0) 588 goto out; 589 590 ret = i2c_master_send(client, &addr, sizeof(addr)); 591 if (ret < 0) 592 goto fail; 593 594 ret = i2c_master_recv(client, buf, cnt); 595 if (ret < 0) 596 goto fail; 597 598 goto out; 599 600 fail: 601 dev_err(&client->dev, "Error %d reading from 0x%x\n", ret, reg); 602 out: 603 mutex_unlock(&priv->mutex); 604 return ret; 605 } 606 607 #define MAX_WRITE_RANGE_BUF 32 608 609 static void 610 reg_write_range(struct tda998x_priv *priv, u16 reg, u8 *p, int cnt) 611 { 612 struct i2c_client *client = priv->hdmi; 613 /* This is the maximum size of the buffer passed in */ 614 u8 buf[MAX_WRITE_RANGE_BUF + 1]; 615 int ret; 616 617 if (cnt > MAX_WRITE_RANGE_BUF) { 618 dev_err(&client->dev, "Fixed write buffer too small (%d)\n", 619 MAX_WRITE_RANGE_BUF); 620 return; 621 } 622 623 buf[0] = REG2ADDR(reg); 624 memcpy(&buf[1], p, cnt); 625 626 mutex_lock(&priv->mutex); 627 ret = set_page(priv, reg); 628 if (ret < 0) 629 goto out; 630 631 ret = i2c_master_send(client, buf, cnt + 1); 632 if (ret < 0) 633 dev_err(&client->dev, "Error %d writing to 0x%x\n", ret, reg); 634 out: 635 mutex_unlock(&priv->mutex); 636 } 637 638 static int 639 reg_read(struct tda998x_priv *priv, u16 reg) 640 { 641 u8 val = 0; 642 int ret; 643 644 ret = reg_read_range(priv, reg, &val, sizeof(val)); 645 if (ret < 0) 646 return ret; 647 return val; 648 } 649 650 static void 651 reg_write(struct tda998x_priv *priv, u16 reg, u8 val) 652 { 653 struct i2c_client *client = priv->hdmi; 654 u8 buf[] = {REG2ADDR(reg), val}; 655 int ret; 656 657 mutex_lock(&priv->mutex); 658 ret = set_page(priv, reg); 659 if (ret < 0) 660 goto out; 661 662 ret = i2c_master_send(client, buf, sizeof(buf)); 663 if (ret < 0) 664 dev_err(&client->dev, "Error %d writing to 0x%x\n", ret, reg); 665 out: 666 mutex_unlock(&priv->mutex); 667 } 668 669 static void 670 reg_write16(struct tda998x_priv *priv, u16 reg, u16 val) 671 { 672 struct i2c_client *client = priv->hdmi; 673 u8 buf[] = {REG2ADDR(reg), val >> 8, val}; 674 int ret; 675 676 mutex_lock(&priv->mutex); 677 ret = set_page(priv, reg); 678 if (ret < 0) 679 goto out; 680 681 ret = i2c_master_send(client, buf, sizeof(buf)); 682 if (ret < 0) 683 dev_err(&client->dev, "Error %d writing to 0x%x\n", ret, reg); 684 out: 685 mutex_unlock(&priv->mutex); 686 } 687 688 static void 689 reg_set(struct tda998x_priv *priv, u16 reg, u8 val) 690 { 691 int old_val; 692 693 old_val = reg_read(priv, reg); 694 if (old_val >= 0) 695 reg_write(priv, reg, old_val | val); 696 } 697 698 static void 699 reg_clear(struct tda998x_priv *priv, u16 reg, u8 val) 700 { 701 int old_val; 702 703 old_val = reg_read(priv, reg); 704 if (old_val >= 0) 705 reg_write(priv, reg, old_val & ~val); 706 } 707 708 static void 709 tda998x_reset(struct tda998x_priv *priv) 710 { 711 /* reset audio and i2c master: */ 712 reg_write(priv, REG_SOFTRESET, SOFTRESET_AUDIO | SOFTRESET_I2C_MASTER); 713 msleep(50); 714 reg_write(priv, REG_SOFTRESET, 0); 715 msleep(50); 716 717 /* reset transmitter: */ 718 reg_set(priv, REG_MAIN_CNTRL0, MAIN_CNTRL0_SR); 719 reg_clear(priv, REG_MAIN_CNTRL0, MAIN_CNTRL0_SR); 720 721 /* PLL registers common configuration */ 722 reg_write(priv, REG_PLL_SERIAL_1, 0x00); 723 reg_write(priv, REG_PLL_SERIAL_2, PLL_SERIAL_2_SRL_NOSC(1)); 724 reg_write(priv, REG_PLL_SERIAL_3, 0x00); 725 reg_write(priv, REG_SERIALIZER, 0x00); 726 reg_write(priv, REG_BUFFER_OUT, 0x00); 727 reg_write(priv, REG_PLL_SCG1, 0x00); 728 reg_write(priv, REG_AUDIO_DIV, AUDIO_DIV_SERCLK_8); 729 reg_write(priv, REG_SEL_CLK, SEL_CLK_SEL_CLK1 | SEL_CLK_ENA_SC_CLK); 730 reg_write(priv, REG_PLL_SCGN1, 0xfa); 731 reg_write(priv, REG_PLL_SCGN2, 0x00); 732 reg_write(priv, REG_PLL_SCGR1, 0x5b); 733 reg_write(priv, REG_PLL_SCGR2, 0x00); 734 reg_write(priv, REG_PLL_SCG2, 0x10); 735 736 /* Write the default value MUX register */ 737 reg_write(priv, REG_MUX_VP_VIP_OUT, 0x24); 738 } 739 740 /* 741 * The TDA998x has a problem when trying to read the EDID close to a 742 * HPD assertion: it needs a delay of 100ms to avoid timing out while 743 * trying to read EDID data. 744 * 745 * However, tda998x_connector_get_modes() may be called at any moment 746 * after tda998x_connector_detect() indicates that we are connected, so 747 * we need to delay probing modes in tda998x_connector_get_modes() after 748 * we have seen a HPD inactive->active transition. This code implements 749 * that delay. 750 */ 751 static void tda998x_edid_delay_done(struct timer_list *t) 752 { 753 struct tda998x_priv *priv = from_timer(priv, t, edid_delay_timer); 754 755 priv->edid_delay_active = false; 756 wake_up(&priv->edid_delay_waitq); 757 schedule_work(&priv->detect_work); 758 } 759 760 static void tda998x_edid_delay_start(struct tda998x_priv *priv) 761 { 762 priv->edid_delay_active = true; 763 mod_timer(&priv->edid_delay_timer, jiffies + HZ/10); 764 } 765 766 static int tda998x_edid_delay_wait(struct tda998x_priv *priv) 767 { 768 return wait_event_killable(priv->edid_delay_waitq, !priv->edid_delay_active); 769 } 770 771 /* 772 * We need to run the KMS hotplug event helper outside of our threaded 773 * interrupt routine as this can call back into our get_modes method, 774 * which will want to make use of interrupts. 775 */ 776 static void tda998x_detect_work(struct work_struct *work) 777 { 778 struct tda998x_priv *priv = 779 container_of(work, struct tda998x_priv, detect_work); 780 struct drm_device *dev = priv->connector.dev; 781 782 if (dev) 783 drm_kms_helper_hotplug_event(dev); 784 } 785 786 /* 787 * only 2 interrupts may occur: screen plug/unplug and EDID read 788 */ 789 static irqreturn_t tda998x_irq_thread(int irq, void *data) 790 { 791 struct tda998x_priv *priv = data; 792 u8 sta, cec, lvl, flag0, flag1, flag2; 793 bool handled = false; 794 795 sta = cec_read(priv, REG_CEC_INTSTATUS); 796 if (sta & CEC_INTSTATUS_HDMI) { 797 cec = cec_read(priv, REG_CEC_RXSHPDINT); 798 lvl = cec_read(priv, REG_CEC_RXSHPDLEV); 799 flag0 = reg_read(priv, REG_INT_FLAGS_0); 800 flag1 = reg_read(priv, REG_INT_FLAGS_1); 801 flag2 = reg_read(priv, REG_INT_FLAGS_2); 802 DRM_DEBUG_DRIVER( 803 "tda irq sta %02x cec %02x lvl %02x f0 %02x f1 %02x f2 %02x\n", 804 sta, cec, lvl, flag0, flag1, flag2); 805 806 if (cec & CEC_RXSHPDINT_HPD) { 807 if (lvl & CEC_RXSHPDLEV_HPD) { 808 tda998x_edid_delay_start(priv); 809 } else { 810 schedule_work(&priv->detect_work); 811 cec_notifier_phys_addr_invalidate( 812 priv->cec_notify); 813 } 814 815 handled = true; 816 } 817 818 if ((flag2 & INT_FLAGS_2_EDID_BLK_RD) && priv->wq_edid_wait) { 819 priv->wq_edid_wait = 0; 820 wake_up(&priv->wq_edid); 821 handled = true; 822 } 823 } 824 825 return IRQ_RETVAL(handled); 826 } 827 828 static void 829 tda998x_write_if(struct tda998x_priv *priv, u8 bit, u16 addr, 830 union hdmi_infoframe *frame) 831 { 832 u8 buf[MAX_WRITE_RANGE_BUF]; 833 ssize_t len; 834 835 len = hdmi_infoframe_pack(frame, buf, sizeof(buf)); 836 if (len < 0) { 837 dev_err(&priv->hdmi->dev, 838 "hdmi_infoframe_pack() type=0x%02x failed: %zd\n", 839 frame->any.type, len); 840 return; 841 } 842 843 reg_clear(priv, REG_DIP_IF_FLAGS, bit); 844 reg_write_range(priv, addr, buf, len); 845 reg_set(priv, REG_DIP_IF_FLAGS, bit); 846 } 847 848 static void tda998x_write_aif(struct tda998x_priv *priv, 849 const struct hdmi_audio_infoframe *cea) 850 { 851 union hdmi_infoframe frame; 852 853 frame.audio = *cea; 854 855 tda998x_write_if(priv, DIP_IF_FLAGS_IF4, REG_IF4_HB0, &frame); 856 } 857 858 static void 859 tda998x_write_avi(struct tda998x_priv *priv, const struct drm_display_mode *mode) 860 { 861 union hdmi_infoframe frame; 862 863 drm_hdmi_avi_infoframe_from_display_mode(&frame.avi, 864 &priv->connector, mode); 865 frame.avi.quantization_range = HDMI_QUANTIZATION_RANGE_FULL; 866 drm_hdmi_avi_infoframe_quant_range(&frame.avi, &priv->connector, mode, 867 priv->rgb_quant_range); 868 869 tda998x_write_if(priv, DIP_IF_FLAGS_IF2, REG_IF2_HB0, &frame); 870 } 871 872 static void tda998x_write_vsi(struct tda998x_priv *priv, 873 const struct drm_display_mode *mode) 874 { 875 union hdmi_infoframe frame; 876 877 if (drm_hdmi_vendor_infoframe_from_display_mode(&frame.vendor.hdmi, 878 &priv->connector, 879 mode)) 880 reg_clear(priv, REG_DIP_IF_FLAGS, DIP_IF_FLAGS_IF1); 881 else 882 tda998x_write_if(priv, DIP_IF_FLAGS_IF1, REG_IF1_HB0, &frame); 883 } 884 885 /* Audio support */ 886 887 static const struct tda998x_audio_route tda998x_audio_route[AUDIO_ROUTE_NUM] = { 888 [AUDIO_ROUTE_I2S] = { 889 .ena_aclk = 1, 890 .mux_ap = MUX_AP_SELECT_I2S, 891 .aip_clksel = AIP_CLKSEL_AIP_I2S | AIP_CLKSEL_FS_ACLK, 892 }, 893 [AUDIO_ROUTE_SPDIF] = { 894 .ena_aclk = 0, 895 .mux_ap = MUX_AP_SELECT_SPDIF, 896 .aip_clksel = AIP_CLKSEL_AIP_SPDIF | AIP_CLKSEL_FS_FS64SPDIF, 897 }, 898 }; 899 900 /* Configure the TDA998x audio data and clock routing. */ 901 static int tda998x_derive_routing(struct tda998x_priv *priv, 902 struct tda998x_audio_settings *s, 903 unsigned int route) 904 { 905 s->route = &tda998x_audio_route[route]; 906 s->ena_ap = priv->audio_port_enable[route]; 907 if (s->ena_ap == 0) { 908 dev_err(&priv->hdmi->dev, "no audio configuration found\n"); 909 return -EINVAL; 910 } 911 912 return 0; 913 } 914 915 /* 916 * The audio clock divisor register controls a divider producing Audio_Clk_Out 917 * from SERclk by dividing it by 2^n where 0 <= n <= 5. We don't know what 918 * Audio_Clk_Out or SERclk are. We guess SERclk is the same as TMDS clock. 919 * 920 * It seems that Audio_Clk_Out must be the smallest value that is greater 921 * than 128*fs, otherwise audio does not function. There is some suggestion 922 * that 126*fs is a better value. 923 */ 924 static u8 tda998x_get_adiv(struct tda998x_priv *priv, unsigned int fs) 925 { 926 unsigned long min_audio_clk = fs * 128; 927 unsigned long ser_clk = priv->tmds_clock * 1000; 928 u8 adiv; 929 930 for (adiv = AUDIO_DIV_SERCLK_32; adiv != AUDIO_DIV_SERCLK_1; adiv--) 931 if (ser_clk > min_audio_clk << adiv) 932 break; 933 934 dev_dbg(&priv->hdmi->dev, 935 "ser_clk=%luHz fs=%uHz min_aclk=%luHz adiv=%d\n", 936 ser_clk, fs, min_audio_clk, adiv); 937 938 return adiv; 939 } 940 941 /* 942 * In auto-CTS mode, the TDA998x uses a "measured time stamp" counter to 943 * generate the CTS value. It appears that the "measured time stamp" is 944 * the number of TDMS clock cycles within a number of audio input clock 945 * cycles defined by the k and N parameters defined below, in a similar 946 * way to that which is set out in the CTS generation in the HDMI spec. 947 * 948 * tmdsclk ----> mts -> /m ---> CTS 949 * ^ 950 * sclk -> /k -> /N 951 * 952 * CTS = mts / m, where m is 2^M. 953 * /k is a divider based on the K value below, K+1 for K < 4, or 8 for K >= 4 954 * /N is a divider based on the HDMI specified N value. 955 * 956 * This produces the following equation: 957 * CTS = tmds_clock * k * N / (sclk * m) 958 * 959 * When combined with the sink-side equation, and realising that sclk is 960 * bclk_ratio * fs, we end up with: 961 * k = m * bclk_ratio / 128. 962 * 963 * Note: S/PDIF always uses a bclk_ratio of 64. 964 */ 965 static int tda998x_derive_cts_n(struct tda998x_priv *priv, 966 struct tda998x_audio_settings *settings, 967 unsigned int ratio) 968 { 969 switch (ratio) { 970 case 16: 971 settings->cts_n = CTS_N_M(3) | CTS_N_K(0); 972 break; 973 case 32: 974 settings->cts_n = CTS_N_M(3) | CTS_N_K(1); 975 break; 976 case 48: 977 settings->cts_n = CTS_N_M(3) | CTS_N_K(2); 978 break; 979 case 64: 980 settings->cts_n = CTS_N_M(3) | CTS_N_K(3); 981 break; 982 case 128: 983 settings->cts_n = CTS_N_M(0) | CTS_N_K(0); 984 break; 985 default: 986 dev_err(&priv->hdmi->dev, "unsupported bclk ratio %ufs\n", 987 ratio); 988 return -EINVAL; 989 } 990 return 0; 991 } 992 993 static void tda998x_audio_mute(struct tda998x_priv *priv, bool on) 994 { 995 if (on) { 996 reg_set(priv, REG_SOFTRESET, SOFTRESET_AUDIO); 997 reg_clear(priv, REG_SOFTRESET, SOFTRESET_AUDIO); 998 reg_set(priv, REG_AIP_CNTRL_0, AIP_CNTRL_0_RST_FIFO); 999 } else { 1000 reg_clear(priv, REG_AIP_CNTRL_0, AIP_CNTRL_0_RST_FIFO); 1001 } 1002 } 1003 1004 static void tda998x_configure_audio(struct tda998x_priv *priv) 1005 { 1006 const struct tda998x_audio_settings *settings = &priv->audio; 1007 u8 buf[6], adiv; 1008 u32 n; 1009 1010 /* If audio is not configured, there is nothing to do. */ 1011 if (settings->ena_ap == 0) 1012 return; 1013 1014 adiv = tda998x_get_adiv(priv, settings->sample_rate); 1015 1016 /* Enable audio ports */ 1017 reg_write(priv, REG_ENA_AP, settings->ena_ap); 1018 reg_write(priv, REG_ENA_ACLK, settings->route->ena_aclk); 1019 reg_write(priv, REG_MUX_AP, settings->route->mux_ap); 1020 reg_write(priv, REG_I2S_FORMAT, settings->i2s_format); 1021 reg_write(priv, REG_AIP_CLKSEL, settings->route->aip_clksel); 1022 reg_clear(priv, REG_AIP_CNTRL_0, AIP_CNTRL_0_LAYOUT | 1023 AIP_CNTRL_0_ACR_MAN); /* auto CTS */ 1024 reg_write(priv, REG_CTS_N, settings->cts_n); 1025 reg_write(priv, REG_AUDIO_DIV, adiv); 1026 1027 /* 1028 * This is the approximate value of N, which happens to be 1029 * the recommended values for non-coherent clocks. 1030 */ 1031 n = 128 * settings->sample_rate / 1000; 1032 1033 /* Write the CTS and N values */ 1034 buf[0] = 0x44; 1035 buf[1] = 0x42; 1036 buf[2] = 0x01; 1037 buf[3] = n; 1038 buf[4] = n >> 8; 1039 buf[5] = n >> 16; 1040 reg_write_range(priv, REG_ACR_CTS_0, buf, 6); 1041 1042 /* Reset CTS generator */ 1043 reg_set(priv, REG_AIP_CNTRL_0, AIP_CNTRL_0_RST_CTS); 1044 reg_clear(priv, REG_AIP_CNTRL_0, AIP_CNTRL_0_RST_CTS); 1045 1046 /* Write the channel status 1047 * The REG_CH_STAT_B-registers skip IEC958 AES2 byte, because 1048 * there is a separate register for each I2S wire. 1049 */ 1050 buf[0] = settings->status[0]; 1051 buf[1] = settings->status[1]; 1052 buf[2] = settings->status[3]; 1053 buf[3] = settings->status[4]; 1054 reg_write_range(priv, REG_CH_STAT_B(0), buf, 4); 1055 1056 tda998x_audio_mute(priv, true); 1057 msleep(20); 1058 tda998x_audio_mute(priv, false); 1059 1060 tda998x_write_aif(priv, &settings->cea); 1061 } 1062 1063 static int tda998x_audio_hw_params(struct device *dev, void *data, 1064 struct hdmi_codec_daifmt *daifmt, 1065 struct hdmi_codec_params *params) 1066 { 1067 struct tda998x_priv *priv = dev_get_drvdata(dev); 1068 unsigned int bclk_ratio; 1069 bool spdif = daifmt->fmt == HDMI_SPDIF; 1070 int ret; 1071 struct tda998x_audio_settings audio = { 1072 .sample_rate = params->sample_rate, 1073 .cea = params->cea, 1074 }; 1075 1076 memcpy(audio.status, params->iec.status, 1077 min(sizeof(audio.status), sizeof(params->iec.status))); 1078 1079 switch (daifmt->fmt) { 1080 case HDMI_I2S: 1081 audio.i2s_format = I2S_FORMAT_PHILIPS; 1082 break; 1083 case HDMI_LEFT_J: 1084 audio.i2s_format = I2S_FORMAT_LEFT_J; 1085 break; 1086 case HDMI_RIGHT_J: 1087 audio.i2s_format = I2S_FORMAT_RIGHT_J; 1088 break; 1089 case HDMI_SPDIF: 1090 audio.i2s_format = 0; 1091 break; 1092 default: 1093 dev_err(dev, "%s: Invalid format %d\n", __func__, daifmt->fmt); 1094 return -EINVAL; 1095 } 1096 1097 if (!spdif && 1098 (daifmt->bit_clk_inv || daifmt->frame_clk_inv || 1099 daifmt->bit_clk_provider || daifmt->frame_clk_provider)) { 1100 dev_err(dev, "%s: Bad flags %d %d %d %d\n", __func__, 1101 daifmt->bit_clk_inv, daifmt->frame_clk_inv, 1102 daifmt->bit_clk_provider, 1103 daifmt->frame_clk_provider); 1104 return -EINVAL; 1105 } 1106 1107 ret = tda998x_derive_routing(priv, &audio, AUDIO_ROUTE_I2S + spdif); 1108 if (ret < 0) 1109 return ret; 1110 1111 bclk_ratio = spdif ? 64 : params->sample_width * 2; 1112 ret = tda998x_derive_cts_n(priv, &audio, bclk_ratio); 1113 if (ret < 0) 1114 return ret; 1115 1116 mutex_lock(&priv->audio_mutex); 1117 priv->audio = audio; 1118 if (priv->supports_infoframes && priv->sink_has_audio) 1119 tda998x_configure_audio(priv); 1120 mutex_unlock(&priv->audio_mutex); 1121 1122 return 0; 1123 } 1124 1125 static void tda998x_audio_shutdown(struct device *dev, void *data) 1126 { 1127 struct tda998x_priv *priv = dev_get_drvdata(dev); 1128 1129 mutex_lock(&priv->audio_mutex); 1130 1131 reg_write(priv, REG_ENA_AP, 0); 1132 priv->audio.ena_ap = 0; 1133 1134 mutex_unlock(&priv->audio_mutex); 1135 } 1136 1137 static int tda998x_audio_mute_stream(struct device *dev, void *data, 1138 bool enable, int direction) 1139 { 1140 struct tda998x_priv *priv = dev_get_drvdata(dev); 1141 1142 mutex_lock(&priv->audio_mutex); 1143 1144 tda998x_audio_mute(priv, enable); 1145 1146 mutex_unlock(&priv->audio_mutex); 1147 return 0; 1148 } 1149 1150 static int tda998x_audio_get_eld(struct device *dev, void *data, 1151 uint8_t *buf, size_t len) 1152 { 1153 struct tda998x_priv *priv = dev_get_drvdata(dev); 1154 1155 mutex_lock(&priv->audio_mutex); 1156 memcpy(buf, priv->connector.eld, 1157 min(sizeof(priv->connector.eld), len)); 1158 mutex_unlock(&priv->audio_mutex); 1159 1160 return 0; 1161 } 1162 1163 static const struct hdmi_codec_ops audio_codec_ops = { 1164 .hw_params = tda998x_audio_hw_params, 1165 .audio_shutdown = tda998x_audio_shutdown, 1166 .mute_stream = tda998x_audio_mute_stream, 1167 .get_eld = tda998x_audio_get_eld, 1168 .no_capture_mute = 1, 1169 }; 1170 1171 static int tda998x_audio_codec_init(struct tda998x_priv *priv, 1172 struct device *dev) 1173 { 1174 struct hdmi_codec_pdata codec_data = { 1175 .ops = &audio_codec_ops, 1176 .max_i2s_channels = 2, 1177 .no_i2s_capture = 1, 1178 .no_spdif_capture = 1, 1179 }; 1180 1181 if (priv->audio_port_enable[AUDIO_ROUTE_I2S]) 1182 codec_data.i2s = 1; 1183 if (priv->audio_port_enable[AUDIO_ROUTE_SPDIF]) 1184 codec_data.spdif = 1; 1185 1186 priv->audio_pdev = platform_device_register_data( 1187 dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, 1188 &codec_data, sizeof(codec_data)); 1189 1190 return PTR_ERR_OR_ZERO(priv->audio_pdev); 1191 } 1192 1193 /* DRM connector functions */ 1194 1195 static enum drm_connector_status 1196 tda998x_connector_detect(struct drm_connector *connector, bool force) 1197 { 1198 struct tda998x_priv *priv = conn_to_tda998x_priv(connector); 1199 u8 val = cec_read(priv, REG_CEC_RXSHPDLEV); 1200 1201 return (val & CEC_RXSHPDLEV_HPD) ? connector_status_connected : 1202 connector_status_disconnected; 1203 } 1204 1205 static void tda998x_connector_destroy(struct drm_connector *connector) 1206 { 1207 drm_connector_cleanup(connector); 1208 } 1209 1210 static const struct drm_connector_funcs tda998x_connector_funcs = { 1211 .reset = drm_atomic_helper_connector_reset, 1212 .fill_modes = drm_helper_probe_single_connector_modes, 1213 .detect = tda998x_connector_detect, 1214 .destroy = tda998x_connector_destroy, 1215 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 1216 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 1217 }; 1218 1219 static int read_edid_block(void *data, u8 *buf, unsigned int blk, size_t length) 1220 { 1221 struct tda998x_priv *priv = data; 1222 u8 offset, segptr; 1223 int ret, i; 1224 1225 offset = (blk & 1) ? 128 : 0; 1226 segptr = blk / 2; 1227 1228 mutex_lock(&priv->edid_mutex); 1229 1230 reg_write(priv, REG_DDC_ADDR, 0xa0); 1231 reg_write(priv, REG_DDC_OFFS, offset); 1232 reg_write(priv, REG_DDC_SEGM_ADDR, 0x60); 1233 reg_write(priv, REG_DDC_SEGM, segptr); 1234 1235 /* enable reading EDID: */ 1236 priv->wq_edid_wait = 1; 1237 reg_write(priv, REG_EDID_CTRL, 0x1); 1238 1239 /* flag must be cleared by sw: */ 1240 reg_write(priv, REG_EDID_CTRL, 0x0); 1241 1242 /* wait for block read to complete: */ 1243 if (priv->hdmi->irq) { 1244 i = wait_event_timeout(priv->wq_edid, 1245 !priv->wq_edid_wait, 1246 msecs_to_jiffies(100)); 1247 if (i < 0) { 1248 dev_err(&priv->hdmi->dev, "read edid wait err %d\n", i); 1249 ret = i; 1250 goto failed; 1251 } 1252 } else { 1253 for (i = 100; i > 0; i--) { 1254 msleep(1); 1255 ret = reg_read(priv, REG_INT_FLAGS_2); 1256 if (ret < 0) 1257 goto failed; 1258 if (ret & INT_FLAGS_2_EDID_BLK_RD) 1259 break; 1260 } 1261 } 1262 1263 if (i == 0) { 1264 dev_err(&priv->hdmi->dev, "read edid timeout\n"); 1265 ret = -ETIMEDOUT; 1266 goto failed; 1267 } 1268 1269 ret = reg_read_range(priv, REG_EDID_DATA_0, buf, length); 1270 if (ret != length) { 1271 dev_err(&priv->hdmi->dev, "failed to read edid block %d: %d\n", 1272 blk, ret); 1273 goto failed; 1274 } 1275 1276 ret = 0; 1277 1278 failed: 1279 mutex_unlock(&priv->edid_mutex); 1280 return ret; 1281 } 1282 1283 static int tda998x_connector_get_modes(struct drm_connector *connector) 1284 { 1285 struct tda998x_priv *priv = conn_to_tda998x_priv(connector); 1286 const struct drm_edid *drm_edid; 1287 int n; 1288 1289 /* 1290 * If we get killed while waiting for the HPD timeout, return 1291 * no modes found: we are not in a restartable path, so we 1292 * can't handle signals gracefully. 1293 */ 1294 if (tda998x_edid_delay_wait(priv)) 1295 return 0; 1296 1297 if (priv->rev == TDA19988) 1298 reg_clear(priv, REG_TX4, TX4_PD_RAM); 1299 1300 drm_edid = drm_edid_read_custom(connector, read_edid_block, priv); 1301 1302 if (priv->rev == TDA19988) 1303 reg_set(priv, REG_TX4, TX4_PD_RAM); 1304 1305 drm_edid_connector_update(connector, drm_edid); 1306 cec_notifier_set_phys_addr(priv->cec_notify, 1307 connector->display_info.source_physical_address); 1308 1309 if (!drm_edid) { 1310 dev_warn(&priv->hdmi->dev, "failed to read EDID\n"); 1311 return 0; 1312 } 1313 1314 mutex_lock(&priv->audio_mutex); 1315 n = drm_edid_connector_add_modes(connector); 1316 priv->sink_has_audio = connector->display_info.has_audio; 1317 mutex_unlock(&priv->audio_mutex); 1318 1319 drm_edid_free(drm_edid); 1320 1321 return n; 1322 } 1323 1324 static struct drm_encoder * 1325 tda998x_connector_best_encoder(struct drm_connector *connector) 1326 { 1327 struct tda998x_priv *priv = conn_to_tda998x_priv(connector); 1328 1329 return priv->bridge.encoder; 1330 } 1331 1332 static 1333 const struct drm_connector_helper_funcs tda998x_connector_helper_funcs = { 1334 .get_modes = tda998x_connector_get_modes, 1335 .best_encoder = tda998x_connector_best_encoder, 1336 }; 1337 1338 static int tda998x_connector_init(struct tda998x_priv *priv, 1339 struct drm_device *drm) 1340 { 1341 struct drm_connector *connector = &priv->connector; 1342 int ret; 1343 1344 connector->interlace_allowed = 1; 1345 1346 if (priv->hdmi->irq) 1347 connector->polled = DRM_CONNECTOR_POLL_HPD; 1348 else 1349 connector->polled = DRM_CONNECTOR_POLL_CONNECT | 1350 DRM_CONNECTOR_POLL_DISCONNECT; 1351 1352 drm_connector_helper_add(connector, &tda998x_connector_helper_funcs); 1353 ret = drm_connector_init(drm, connector, &tda998x_connector_funcs, 1354 DRM_MODE_CONNECTOR_HDMIA); 1355 if (ret) 1356 return ret; 1357 1358 drm_connector_attach_encoder(&priv->connector, 1359 priv->bridge.encoder); 1360 1361 return 0; 1362 } 1363 1364 /* DRM bridge functions */ 1365 1366 static int tda998x_bridge_attach(struct drm_bridge *bridge, 1367 enum drm_bridge_attach_flags flags) 1368 { 1369 struct tda998x_priv *priv = bridge_to_tda998x_priv(bridge); 1370 1371 if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR) { 1372 DRM_ERROR("Fix bridge driver to make connector optional!"); 1373 return -EINVAL; 1374 } 1375 1376 return tda998x_connector_init(priv, bridge->dev); 1377 } 1378 1379 static void tda998x_bridge_detach(struct drm_bridge *bridge) 1380 { 1381 struct tda998x_priv *priv = bridge_to_tda998x_priv(bridge); 1382 1383 drm_connector_cleanup(&priv->connector); 1384 } 1385 1386 static enum drm_mode_status tda998x_bridge_mode_valid(struct drm_bridge *bridge, 1387 const struct drm_display_info *info, 1388 const struct drm_display_mode *mode) 1389 { 1390 /* TDA19988 dotclock can go up to 165MHz */ 1391 struct tda998x_priv *priv = bridge_to_tda998x_priv(bridge); 1392 1393 if (mode->clock > ((priv->rev == TDA19988) ? 165000 : 150000)) 1394 return MODE_CLOCK_HIGH; 1395 if (mode->htotal >= BIT(13)) 1396 return MODE_BAD_HVALUE; 1397 if (mode->vtotal >= BIT(11)) 1398 return MODE_BAD_VVALUE; 1399 return MODE_OK; 1400 } 1401 1402 static void tda998x_bridge_enable(struct drm_bridge *bridge) 1403 { 1404 struct tda998x_priv *priv = bridge_to_tda998x_priv(bridge); 1405 1406 if (!priv->is_on) { 1407 /* enable video ports, audio will be enabled later */ 1408 reg_write(priv, REG_ENA_VP_0, 0xff); 1409 reg_write(priv, REG_ENA_VP_1, 0xff); 1410 reg_write(priv, REG_ENA_VP_2, 0xff); 1411 /* set muxing after enabling ports: */ 1412 reg_write(priv, REG_VIP_CNTRL_0, priv->vip_cntrl_0); 1413 reg_write(priv, REG_VIP_CNTRL_1, priv->vip_cntrl_1); 1414 reg_write(priv, REG_VIP_CNTRL_2, priv->vip_cntrl_2); 1415 1416 priv->is_on = true; 1417 } 1418 } 1419 1420 static void tda998x_bridge_disable(struct drm_bridge *bridge) 1421 { 1422 struct tda998x_priv *priv = bridge_to_tda998x_priv(bridge); 1423 1424 if (priv->is_on) { 1425 /* disable video ports */ 1426 reg_write(priv, REG_ENA_VP_0, 0x00); 1427 reg_write(priv, REG_ENA_VP_1, 0x00); 1428 reg_write(priv, REG_ENA_VP_2, 0x00); 1429 1430 priv->is_on = false; 1431 } 1432 } 1433 1434 static void tda998x_bridge_mode_set(struct drm_bridge *bridge, 1435 const struct drm_display_mode *mode, 1436 const struct drm_display_mode *adjusted_mode) 1437 { 1438 struct tda998x_priv *priv = bridge_to_tda998x_priv(bridge); 1439 unsigned long tmds_clock; 1440 u16 ref_pix, ref_line, n_pix, n_line; 1441 u16 hs_pix_s, hs_pix_e; 1442 u16 vs1_pix_s, vs1_pix_e, vs1_line_s, vs1_line_e; 1443 u16 vs2_pix_s, vs2_pix_e, vs2_line_s, vs2_line_e; 1444 u16 vwin1_line_s, vwin1_line_e; 1445 u16 vwin2_line_s, vwin2_line_e; 1446 u16 de_pix_s, de_pix_e; 1447 u8 reg, div, rep, sel_clk; 1448 1449 /* 1450 * Since we are "computer" like, our source invariably produces 1451 * full-range RGB. If the monitor supports full-range, then use 1452 * it, otherwise reduce to limited-range. 1453 */ 1454 priv->rgb_quant_range = 1455 priv->connector.display_info.rgb_quant_range_selectable ? 1456 HDMI_QUANTIZATION_RANGE_FULL : 1457 drm_default_rgb_quant_range(adjusted_mode); 1458 1459 /* 1460 * Internally TDA998x is using ITU-R BT.656 style sync but 1461 * we get VESA style sync. TDA998x is using a reference pixel 1462 * relative to ITU to sync to the input frame and for output 1463 * sync generation. Currently, we are using reference detection 1464 * from HS/VS, i.e. REFPIX/REFLINE denote frame start sync point 1465 * which is position of rising VS with coincident rising HS. 1466 * 1467 * Now there is some issues to take care of: 1468 * - HDMI data islands require sync-before-active 1469 * - TDA998x register values must be > 0 to be enabled 1470 * - REFLINE needs an additional offset of +1 1471 * - REFPIX needs an addtional offset of +1 for UYUV and +3 for RGB 1472 * 1473 * So we add +1 to all horizontal and vertical register values, 1474 * plus an additional +3 for REFPIX as we are using RGB input only. 1475 */ 1476 n_pix = mode->htotal; 1477 n_line = mode->vtotal; 1478 1479 hs_pix_e = mode->hsync_end - mode->hdisplay; 1480 hs_pix_s = mode->hsync_start - mode->hdisplay; 1481 de_pix_e = mode->htotal; 1482 de_pix_s = mode->htotal - mode->hdisplay; 1483 ref_pix = 3 + hs_pix_s; 1484 1485 /* 1486 * Attached LCD controllers may generate broken sync. Allow 1487 * those to adjust the position of the rising VS edge by adding 1488 * HSKEW to ref_pix. 1489 */ 1490 if (adjusted_mode->flags & DRM_MODE_FLAG_HSKEW) 1491 ref_pix += adjusted_mode->hskew; 1492 1493 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) == 0) { 1494 ref_line = 1 + mode->vsync_start - mode->vdisplay; 1495 vwin1_line_s = mode->vtotal - mode->vdisplay - 1; 1496 vwin1_line_e = vwin1_line_s + mode->vdisplay; 1497 vs1_pix_s = vs1_pix_e = hs_pix_s; 1498 vs1_line_s = mode->vsync_start - mode->vdisplay; 1499 vs1_line_e = vs1_line_s + 1500 mode->vsync_end - mode->vsync_start; 1501 vwin2_line_s = vwin2_line_e = 0; 1502 vs2_pix_s = vs2_pix_e = 0; 1503 vs2_line_s = vs2_line_e = 0; 1504 } else { 1505 ref_line = 1 + (mode->vsync_start - mode->vdisplay)/2; 1506 vwin1_line_s = (mode->vtotal - mode->vdisplay)/2; 1507 vwin1_line_e = vwin1_line_s + mode->vdisplay/2; 1508 vs1_pix_s = vs1_pix_e = hs_pix_s; 1509 vs1_line_s = (mode->vsync_start - mode->vdisplay)/2; 1510 vs1_line_e = vs1_line_s + 1511 (mode->vsync_end - mode->vsync_start)/2; 1512 vwin2_line_s = vwin1_line_s + mode->vtotal/2; 1513 vwin2_line_e = vwin2_line_s + mode->vdisplay/2; 1514 vs2_pix_s = vs2_pix_e = hs_pix_s + mode->htotal/2; 1515 vs2_line_s = vs1_line_s + mode->vtotal/2 ; 1516 vs2_line_e = vs2_line_s + 1517 (mode->vsync_end - mode->vsync_start)/2; 1518 } 1519 1520 /* 1521 * Select pixel repeat depending on the double-clock flag 1522 * (which means we have to repeat each pixel once.) 1523 */ 1524 rep = mode->flags & DRM_MODE_FLAG_DBLCLK ? 1 : 0; 1525 sel_clk = SEL_CLK_ENA_SC_CLK | SEL_CLK_SEL_CLK1 | 1526 SEL_CLK_SEL_VRF_CLK(rep ? 2 : 0); 1527 1528 /* the TMDS clock is scaled up by the pixel repeat */ 1529 tmds_clock = mode->clock * (1 + rep); 1530 1531 /* 1532 * The divisor is power-of-2. The TDA9983B datasheet gives 1533 * this as ranges of Msample/s, which is 10x the TMDS clock: 1534 * 0 - 800 to 1500 Msample/s 1535 * 1 - 400 to 800 Msample/s 1536 * 2 - 200 to 400 Msample/s 1537 * 3 - as 2 above 1538 */ 1539 for (div = 0; div < 3; div++) 1540 if (80000 >> div <= tmds_clock) 1541 break; 1542 1543 mutex_lock(&priv->audio_mutex); 1544 1545 priv->tmds_clock = tmds_clock; 1546 1547 /* mute the audio FIFO: */ 1548 reg_set(priv, REG_AIP_CNTRL_0, AIP_CNTRL_0_RST_FIFO); 1549 1550 /* set HDMI HDCP mode off: */ 1551 reg_write(priv, REG_TBG_CNTRL_1, TBG_CNTRL_1_DWIN_DIS); 1552 reg_clear(priv, REG_TX33, TX33_HDMI); 1553 reg_write(priv, REG_ENC_CNTRL, ENC_CNTRL_CTL_CODE(0)); 1554 1555 /* no pre-filter or interpolator: */ 1556 reg_write(priv, REG_HVF_CNTRL_0, HVF_CNTRL_0_PREFIL(0) | 1557 HVF_CNTRL_0_INTPOL(0)); 1558 reg_set(priv, REG_FEAT_POWERDOWN, FEAT_POWERDOWN_PREFILT); 1559 reg_write(priv, REG_VIP_CNTRL_5, VIP_CNTRL_5_SP_CNT(0)); 1560 reg_write(priv, REG_VIP_CNTRL_4, VIP_CNTRL_4_BLANKIT(0) | 1561 VIP_CNTRL_4_BLC(0)); 1562 1563 reg_clear(priv, REG_PLL_SERIAL_1, PLL_SERIAL_1_SRL_MAN_IZ); 1564 reg_clear(priv, REG_PLL_SERIAL_3, PLL_SERIAL_3_SRL_CCIR | 1565 PLL_SERIAL_3_SRL_DE); 1566 reg_write(priv, REG_SERIALIZER, 0); 1567 reg_write(priv, REG_HVF_CNTRL_1, HVF_CNTRL_1_VQR(0)); 1568 1569 reg_write(priv, REG_RPT_CNTRL, RPT_CNTRL_REPEAT(rep)); 1570 reg_write(priv, REG_SEL_CLK, sel_clk); 1571 reg_write(priv, REG_PLL_SERIAL_2, PLL_SERIAL_2_SRL_NOSC(div) | 1572 PLL_SERIAL_2_SRL_PR(rep)); 1573 1574 /* set color matrix according to output rgb quant range */ 1575 if (priv->rgb_quant_range == HDMI_QUANTIZATION_RANGE_LIMITED) { 1576 static u8 tda998x_full_to_limited_range[] = { 1577 MAT_CONTRL_MAT_SC(2), 1578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 1579 0x03, 0x6f, 0x00, 0x00, 0x00, 0x00, 1580 0x00, 0x00, 0x03, 0x6f, 0x00, 0x00, 1581 0x00, 0x00, 0x00, 0x00, 0x03, 0x6f, 1582 0x00, 0x40, 0x00, 0x40, 0x00, 0x40 1583 }; 1584 reg_clear(priv, REG_FEAT_POWERDOWN, FEAT_POWERDOWN_CSC); 1585 reg_write_range(priv, REG_MAT_CONTRL, 1586 tda998x_full_to_limited_range, 1587 sizeof(tda998x_full_to_limited_range)); 1588 } else { 1589 reg_write(priv, REG_MAT_CONTRL, MAT_CONTRL_MAT_BP | 1590 MAT_CONTRL_MAT_SC(1)); 1591 reg_set(priv, REG_FEAT_POWERDOWN, FEAT_POWERDOWN_CSC); 1592 } 1593 1594 /* set BIAS tmds value: */ 1595 reg_write(priv, REG_ANA_GENERAL, 0x09); 1596 1597 /* 1598 * Sync on rising HSYNC/VSYNC 1599 */ 1600 reg = VIP_CNTRL_3_SYNC_HS; 1601 1602 /* 1603 * TDA19988 requires high-active sync at input stage, 1604 * so invert low-active sync provided by master encoder here 1605 */ 1606 if (mode->flags & DRM_MODE_FLAG_NHSYNC) 1607 reg |= VIP_CNTRL_3_H_TGL; 1608 if (mode->flags & DRM_MODE_FLAG_NVSYNC) 1609 reg |= VIP_CNTRL_3_V_TGL; 1610 reg_write(priv, REG_VIP_CNTRL_3, reg); 1611 1612 reg_write(priv, REG_VIDFORMAT, 0x00); 1613 reg_write16(priv, REG_REFPIX_MSB, ref_pix); 1614 reg_write16(priv, REG_REFLINE_MSB, ref_line); 1615 reg_write16(priv, REG_NPIX_MSB, n_pix); 1616 reg_write16(priv, REG_NLINE_MSB, n_line); 1617 reg_write16(priv, REG_VS_LINE_STRT_1_MSB, vs1_line_s); 1618 reg_write16(priv, REG_VS_PIX_STRT_1_MSB, vs1_pix_s); 1619 reg_write16(priv, REG_VS_LINE_END_1_MSB, vs1_line_e); 1620 reg_write16(priv, REG_VS_PIX_END_1_MSB, vs1_pix_e); 1621 reg_write16(priv, REG_VS_LINE_STRT_2_MSB, vs2_line_s); 1622 reg_write16(priv, REG_VS_PIX_STRT_2_MSB, vs2_pix_s); 1623 reg_write16(priv, REG_VS_LINE_END_2_MSB, vs2_line_e); 1624 reg_write16(priv, REG_VS_PIX_END_2_MSB, vs2_pix_e); 1625 reg_write16(priv, REG_HS_PIX_START_MSB, hs_pix_s); 1626 reg_write16(priv, REG_HS_PIX_STOP_MSB, hs_pix_e); 1627 reg_write16(priv, REG_VWIN_START_1_MSB, vwin1_line_s); 1628 reg_write16(priv, REG_VWIN_END_1_MSB, vwin1_line_e); 1629 reg_write16(priv, REG_VWIN_START_2_MSB, vwin2_line_s); 1630 reg_write16(priv, REG_VWIN_END_2_MSB, vwin2_line_e); 1631 reg_write16(priv, REG_DE_START_MSB, de_pix_s); 1632 reg_write16(priv, REG_DE_STOP_MSB, de_pix_e); 1633 1634 if (priv->rev == TDA19988) { 1635 /* let incoming pixels fill the active space (if any) */ 1636 reg_write(priv, REG_ENABLE_SPACE, 0x00); 1637 } 1638 1639 /* 1640 * Always generate sync polarity relative to input sync and 1641 * revert input stage toggled sync at output stage 1642 */ 1643 reg = TBG_CNTRL_1_DWIN_DIS | TBG_CNTRL_1_TGL_EN; 1644 if (mode->flags & DRM_MODE_FLAG_NHSYNC) 1645 reg |= TBG_CNTRL_1_H_TGL; 1646 if (mode->flags & DRM_MODE_FLAG_NVSYNC) 1647 reg |= TBG_CNTRL_1_V_TGL; 1648 reg_write(priv, REG_TBG_CNTRL_1, reg); 1649 1650 /* must be last register set: */ 1651 reg_write(priv, REG_TBG_CNTRL_0, 0); 1652 1653 /* CEA-861B section 6 says that: 1654 * CEA version 1 (CEA-861) has no support for infoframes. 1655 * CEA version 2 (CEA-861A) supports version 1 AVI infoframes, 1656 * and optional basic audio. 1657 * CEA version 3 (CEA-861B) supports version 1 and 2 AVI infoframes, 1658 * and optional digital audio, with audio infoframes. 1659 * 1660 * Since we only support generation of version 2 AVI infoframes, 1661 * ignore CEA version 2 and below (iow, behave as if we're a 1662 * CEA-861 source.) 1663 */ 1664 priv->supports_infoframes = priv->connector.display_info.cea_rev >= 3; 1665 1666 if (priv->supports_infoframes) { 1667 /* We need to turn HDMI HDCP stuff on to get audio through */ 1668 reg &= ~TBG_CNTRL_1_DWIN_DIS; 1669 reg_write(priv, REG_TBG_CNTRL_1, reg); 1670 reg_write(priv, REG_ENC_CNTRL, ENC_CNTRL_CTL_CODE(1)); 1671 reg_set(priv, REG_TX33, TX33_HDMI); 1672 1673 tda998x_write_avi(priv, adjusted_mode); 1674 tda998x_write_vsi(priv, adjusted_mode); 1675 1676 if (priv->sink_has_audio) 1677 tda998x_configure_audio(priv); 1678 } 1679 1680 mutex_unlock(&priv->audio_mutex); 1681 } 1682 1683 static const struct drm_bridge_funcs tda998x_bridge_funcs = { 1684 .attach = tda998x_bridge_attach, 1685 .detach = tda998x_bridge_detach, 1686 .mode_valid = tda998x_bridge_mode_valid, 1687 .disable = tda998x_bridge_disable, 1688 .mode_set = tda998x_bridge_mode_set, 1689 .enable = tda998x_bridge_enable, 1690 }; 1691 1692 /* I2C driver functions */ 1693 1694 static int tda998x_get_audio_ports(struct tda998x_priv *priv, 1695 struct device_node *np) 1696 { 1697 const u32 *port_data; 1698 u32 size; 1699 int i; 1700 1701 port_data = of_get_property(np, "audio-ports", &size); 1702 if (!port_data) 1703 return 0; 1704 1705 size /= sizeof(u32); 1706 if (size > 2 * ARRAY_SIZE(priv->audio_port_enable) || size % 2 != 0) { 1707 dev_err(&priv->hdmi->dev, 1708 "Bad number of elements in audio-ports dt-property\n"); 1709 return -EINVAL; 1710 } 1711 1712 size /= 2; 1713 1714 for (i = 0; i < size; i++) { 1715 unsigned int route; 1716 u8 afmt = be32_to_cpup(&port_data[2*i]); 1717 u8 ena_ap = be32_to_cpup(&port_data[2*i+1]); 1718 1719 switch (afmt) { 1720 case AFMT_I2S: 1721 route = AUDIO_ROUTE_I2S; 1722 break; 1723 case AFMT_SPDIF: 1724 route = AUDIO_ROUTE_SPDIF; 1725 break; 1726 default: 1727 dev_err(&priv->hdmi->dev, 1728 "Bad audio format %u\n", afmt); 1729 return -EINVAL; 1730 } 1731 1732 if (!ena_ap) { 1733 dev_err(&priv->hdmi->dev, "invalid zero port config\n"); 1734 continue; 1735 } 1736 1737 if (priv->audio_port_enable[route]) { 1738 dev_err(&priv->hdmi->dev, 1739 "%s format already configured\n", 1740 route == AUDIO_ROUTE_SPDIF ? "SPDIF" : "I2S"); 1741 return -EINVAL; 1742 } 1743 1744 priv->audio_port_enable[route] = ena_ap; 1745 } 1746 return 0; 1747 } 1748 1749 static int tda998x_set_config(struct tda998x_priv *priv, 1750 const struct tda998x_encoder_params *p) 1751 { 1752 priv->vip_cntrl_0 = VIP_CNTRL_0_SWAP_A(p->swap_a) | 1753 (p->mirr_a ? VIP_CNTRL_0_MIRR_A : 0) | 1754 VIP_CNTRL_0_SWAP_B(p->swap_b) | 1755 (p->mirr_b ? VIP_CNTRL_0_MIRR_B : 0); 1756 priv->vip_cntrl_1 = VIP_CNTRL_1_SWAP_C(p->swap_c) | 1757 (p->mirr_c ? VIP_CNTRL_1_MIRR_C : 0) | 1758 VIP_CNTRL_1_SWAP_D(p->swap_d) | 1759 (p->mirr_d ? VIP_CNTRL_1_MIRR_D : 0); 1760 priv->vip_cntrl_2 = VIP_CNTRL_2_SWAP_E(p->swap_e) | 1761 (p->mirr_e ? VIP_CNTRL_2_MIRR_E : 0) | 1762 VIP_CNTRL_2_SWAP_F(p->swap_f) | 1763 (p->mirr_f ? VIP_CNTRL_2_MIRR_F : 0); 1764 1765 if (p->audio_params.format != AFMT_UNUSED) { 1766 unsigned int ratio, route; 1767 bool spdif = p->audio_params.format == AFMT_SPDIF; 1768 1769 route = AUDIO_ROUTE_I2S + spdif; 1770 1771 priv->audio.route = &tda998x_audio_route[route]; 1772 priv->audio.cea = p->audio_params.cea; 1773 priv->audio.sample_rate = p->audio_params.sample_rate; 1774 memcpy(priv->audio.status, p->audio_params.status, 1775 min(sizeof(priv->audio.status), 1776 sizeof(p->audio_params.status))); 1777 priv->audio.ena_ap = p->audio_params.config; 1778 priv->audio.i2s_format = I2S_FORMAT_PHILIPS; 1779 1780 ratio = spdif ? 64 : p->audio_params.sample_width * 2; 1781 return tda998x_derive_cts_n(priv, &priv->audio, ratio); 1782 } 1783 1784 return 0; 1785 } 1786 1787 static void tda998x_destroy(struct device *dev) 1788 { 1789 struct tda998x_priv *priv = dev_get_drvdata(dev); 1790 1791 drm_bridge_remove(&priv->bridge); 1792 1793 /* disable all IRQs and free the IRQ handler */ 1794 cec_write(priv, REG_CEC_RXSHPDINTENA, 0); 1795 reg_clear(priv, REG_INT_FLAGS_2, INT_FLAGS_2_EDID_BLK_RD); 1796 1797 if (priv->audio_pdev) 1798 platform_device_unregister(priv->audio_pdev); 1799 1800 if (priv->hdmi->irq) 1801 free_irq(priv->hdmi->irq, priv); 1802 1803 del_timer_sync(&priv->edid_delay_timer); 1804 cancel_work_sync(&priv->detect_work); 1805 1806 i2c_unregister_device(priv->cec); 1807 1808 cec_notifier_conn_unregister(priv->cec_notify); 1809 } 1810 1811 static int tda998x_create(struct device *dev) 1812 { 1813 struct i2c_client *client = to_i2c_client(dev); 1814 struct device_node *np = client->dev.of_node; 1815 struct i2c_board_info cec_info; 1816 struct tda998x_priv *priv; 1817 u32 video; 1818 int rev_lo, rev_hi, ret; 1819 1820 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 1821 if (!priv) 1822 return -ENOMEM; 1823 1824 dev_set_drvdata(dev, priv); 1825 1826 mutex_init(&priv->mutex); /* protect the page access */ 1827 mutex_init(&priv->audio_mutex); /* protect access from audio thread */ 1828 mutex_init(&priv->edid_mutex); 1829 INIT_LIST_HEAD(&priv->bridge.list); 1830 init_waitqueue_head(&priv->edid_delay_waitq); 1831 timer_setup(&priv->edid_delay_timer, tda998x_edid_delay_done, 0); 1832 INIT_WORK(&priv->detect_work, tda998x_detect_work); 1833 1834 priv->vip_cntrl_0 = VIP_CNTRL_0_SWAP_A(2) | VIP_CNTRL_0_SWAP_B(3); 1835 priv->vip_cntrl_1 = VIP_CNTRL_1_SWAP_C(0) | VIP_CNTRL_1_SWAP_D(1); 1836 priv->vip_cntrl_2 = VIP_CNTRL_2_SWAP_E(4) | VIP_CNTRL_2_SWAP_F(5); 1837 1838 /* CEC I2C address bound to TDA998x I2C addr by configuration pins */ 1839 priv->cec_addr = 0x34 + (client->addr & 0x03); 1840 priv->current_page = 0xff; 1841 priv->hdmi = client; 1842 1843 /* wake up the device: */ 1844 cec_write(priv, REG_CEC_ENAMODS, 1845 CEC_ENAMODS_EN_RXSENS | CEC_ENAMODS_EN_HDMI); 1846 1847 tda998x_reset(priv); 1848 1849 /* read version: */ 1850 rev_lo = reg_read(priv, REG_VERSION_LSB); 1851 if (rev_lo < 0) { 1852 dev_err(dev, "failed to read version: %d\n", rev_lo); 1853 return rev_lo; 1854 } 1855 1856 rev_hi = reg_read(priv, REG_VERSION_MSB); 1857 if (rev_hi < 0) { 1858 dev_err(dev, "failed to read version: %d\n", rev_hi); 1859 return rev_hi; 1860 } 1861 1862 priv->rev = rev_lo | rev_hi << 8; 1863 1864 /* mask off feature bits: */ 1865 priv->rev &= ~0x30; /* not-hdcp and not-scalar bit */ 1866 1867 switch (priv->rev) { 1868 case TDA9989N2: 1869 dev_info(dev, "found TDA9989 n2"); 1870 break; 1871 case TDA19989: 1872 dev_info(dev, "found TDA19989"); 1873 break; 1874 case TDA19989N2: 1875 dev_info(dev, "found TDA19989 n2"); 1876 break; 1877 case TDA19988: 1878 dev_info(dev, "found TDA19988"); 1879 break; 1880 default: 1881 dev_err(dev, "found unsupported device: %04x\n", priv->rev); 1882 return -ENXIO; 1883 } 1884 1885 /* after reset, enable DDC: */ 1886 reg_write(priv, REG_DDC_DISABLE, 0x00); 1887 1888 /* set clock on DDC channel: */ 1889 reg_write(priv, REG_TX3, 39); 1890 1891 /* if necessary, disable multi-master: */ 1892 if (priv->rev == TDA19989) 1893 reg_set(priv, REG_I2C_MASTER, I2C_MASTER_DIS_MM); 1894 1895 cec_write(priv, REG_CEC_FRO_IM_CLK_CTRL, 1896 CEC_FRO_IM_CLK_CTRL_GHOST_DIS | CEC_FRO_IM_CLK_CTRL_IMCLK_SEL); 1897 1898 /* ensure interrupts are disabled */ 1899 cec_write(priv, REG_CEC_RXSHPDINTENA, 0); 1900 1901 /* clear pending interrupts */ 1902 cec_read(priv, REG_CEC_RXSHPDINT); 1903 reg_read(priv, REG_INT_FLAGS_0); 1904 reg_read(priv, REG_INT_FLAGS_1); 1905 reg_read(priv, REG_INT_FLAGS_2); 1906 1907 /* initialize the optional IRQ */ 1908 if (client->irq) { 1909 unsigned long irq_flags; 1910 1911 /* init read EDID waitqueue and HDP work */ 1912 init_waitqueue_head(&priv->wq_edid); 1913 1914 irq_flags = 1915 irqd_get_trigger_type(irq_get_irq_data(client->irq)); 1916 1917 priv->cec_glue.irq_flags = irq_flags; 1918 1919 irq_flags |= IRQF_SHARED | IRQF_ONESHOT; 1920 ret = request_threaded_irq(client->irq, NULL, 1921 tda998x_irq_thread, irq_flags, 1922 "tda998x", priv); 1923 if (ret) { 1924 dev_err(dev, "failed to request IRQ#%u: %d\n", 1925 client->irq, ret); 1926 goto err_irq; 1927 } 1928 1929 /* enable HPD irq */ 1930 cec_write(priv, REG_CEC_RXSHPDINTENA, CEC_RXSHPDLEV_HPD); 1931 } 1932 1933 priv->cec_notify = cec_notifier_conn_register(dev, NULL, NULL); 1934 if (!priv->cec_notify) { 1935 ret = -ENOMEM; 1936 goto fail; 1937 } 1938 1939 priv->cec_glue.parent = dev; 1940 priv->cec_glue.data = priv; 1941 priv->cec_glue.init = tda998x_cec_hook_init; 1942 priv->cec_glue.exit = tda998x_cec_hook_exit; 1943 priv->cec_glue.open = tda998x_cec_hook_open; 1944 priv->cec_glue.release = tda998x_cec_hook_release; 1945 1946 /* 1947 * Some TDA998x are actually two I2C devices merged onto one piece 1948 * of silicon: TDA9989 and TDA19989 combine the HDMI transmitter 1949 * with a slightly modified TDA9950 CEC device. The CEC device 1950 * is at the TDA9950 address, with the address pins strapped across 1951 * to the TDA998x address pins. Hence, it always has the same 1952 * offset. 1953 */ 1954 memset(&cec_info, 0, sizeof(cec_info)); 1955 strscpy(cec_info.type, "tda9950", sizeof(cec_info.type)); 1956 cec_info.addr = priv->cec_addr; 1957 cec_info.platform_data = &priv->cec_glue; 1958 cec_info.irq = client->irq; 1959 1960 priv->cec = i2c_new_client_device(client->adapter, &cec_info); 1961 if (IS_ERR(priv->cec)) { 1962 ret = PTR_ERR(priv->cec); 1963 goto fail; 1964 } 1965 1966 /* enable EDID read irq: */ 1967 reg_set(priv, REG_INT_FLAGS_2, INT_FLAGS_2_EDID_BLK_RD); 1968 1969 if (np) { 1970 /* get the device tree parameters */ 1971 ret = of_property_read_u32(np, "video-ports", &video); 1972 if (ret == 0) { 1973 priv->vip_cntrl_0 = video >> 16; 1974 priv->vip_cntrl_1 = video >> 8; 1975 priv->vip_cntrl_2 = video; 1976 } 1977 1978 ret = tda998x_get_audio_ports(priv, np); 1979 if (ret) 1980 goto fail; 1981 1982 if (priv->audio_port_enable[AUDIO_ROUTE_I2S] || 1983 priv->audio_port_enable[AUDIO_ROUTE_SPDIF]) 1984 tda998x_audio_codec_init(priv, &client->dev); 1985 } else if (dev->platform_data) { 1986 ret = tda998x_set_config(priv, dev->platform_data); 1987 if (ret) 1988 goto fail; 1989 } 1990 1991 priv->bridge.funcs = &tda998x_bridge_funcs; 1992 #ifdef CONFIG_OF 1993 priv->bridge.of_node = dev->of_node; 1994 #endif 1995 1996 drm_bridge_add(&priv->bridge); 1997 1998 return 0; 1999 2000 fail: 2001 tda998x_destroy(dev); 2002 err_irq: 2003 return ret; 2004 } 2005 2006 /* DRM encoder functions */ 2007 2008 static int tda998x_encoder_init(struct device *dev, struct drm_device *drm) 2009 { 2010 struct tda998x_priv *priv = dev_get_drvdata(dev); 2011 u32 crtcs = 0; 2012 int ret; 2013 2014 if (dev->of_node) 2015 crtcs = drm_of_find_possible_crtcs(drm, dev->of_node); 2016 2017 /* If no CRTCs were found, fall back to our old behaviour */ 2018 if (crtcs == 0) { 2019 dev_warn(dev, "Falling back to first CRTC\n"); 2020 crtcs = 1 << 0; 2021 } 2022 2023 priv->encoder.possible_crtcs = crtcs; 2024 2025 ret = drm_simple_encoder_init(drm, &priv->encoder, 2026 DRM_MODE_ENCODER_TMDS); 2027 if (ret) 2028 goto err_encoder; 2029 2030 ret = drm_bridge_attach(&priv->encoder, &priv->bridge, NULL, 0); 2031 if (ret) 2032 goto err_bridge; 2033 2034 return 0; 2035 2036 err_bridge: 2037 drm_encoder_cleanup(&priv->encoder); 2038 err_encoder: 2039 return ret; 2040 } 2041 2042 static int tda998x_bind(struct device *dev, struct device *master, void *data) 2043 { 2044 struct drm_device *drm = data; 2045 2046 return tda998x_encoder_init(dev, drm); 2047 } 2048 2049 static void tda998x_unbind(struct device *dev, struct device *master, 2050 void *data) 2051 { 2052 struct tda998x_priv *priv = dev_get_drvdata(dev); 2053 2054 drm_encoder_cleanup(&priv->encoder); 2055 } 2056 2057 static const struct component_ops tda998x_ops = { 2058 .bind = tda998x_bind, 2059 .unbind = tda998x_unbind, 2060 }; 2061 2062 static int 2063 tda998x_probe(struct i2c_client *client) 2064 { 2065 int ret; 2066 2067 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 2068 dev_warn(&client->dev, "adapter does not support I2C\n"); 2069 return -EIO; 2070 } 2071 2072 ret = tda998x_create(&client->dev); 2073 if (ret) 2074 return ret; 2075 2076 ret = component_add(&client->dev, &tda998x_ops); 2077 if (ret) 2078 tda998x_destroy(&client->dev); 2079 return ret; 2080 } 2081 2082 static void tda998x_remove(struct i2c_client *client) 2083 { 2084 component_del(&client->dev, &tda998x_ops); 2085 tda998x_destroy(&client->dev); 2086 } 2087 2088 #ifdef CONFIG_OF 2089 static const struct of_device_id tda998x_dt_ids[] = { 2090 { .compatible = "nxp,tda998x", }, 2091 { } 2092 }; 2093 MODULE_DEVICE_TABLE(of, tda998x_dt_ids); 2094 #endif 2095 2096 static const struct i2c_device_id tda998x_ids[] = { 2097 { "tda998x", 0 }, 2098 { } 2099 }; 2100 MODULE_DEVICE_TABLE(i2c, tda998x_ids); 2101 2102 static struct i2c_driver tda998x_driver = { 2103 .probe = tda998x_probe, 2104 .remove = tda998x_remove, 2105 .driver = { 2106 .name = "tda998x", 2107 .of_match_table = of_match_ptr(tda998x_dt_ids), 2108 }, 2109 .id_table = tda998x_ids, 2110 }; 2111 2112 module_i2c_driver(tda998x_driver); 2113 2114 MODULE_AUTHOR("Rob Clark <robdclark@gmail.com"); 2115 MODULE_DESCRIPTION("NXP Semiconductors TDA998X HDMI Encoder"); 2116 MODULE_LICENSE("GPL"); 2117