1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2011 Samsung Electronics Co.Ltd 4 * Authors: 5 * Seung-Woo Kim <sw0312.kim@samsung.com> 6 * Inki Dae <inki.dae@samsung.com> 7 * Joonyoung Shim <jy0922.shim@samsung.com> 8 * 9 * Based on drivers/media/video/s5p-tv/hdmi_drv.c 10 */ 11 12 #include <drm/exynos_drm.h> 13 #include <linux/clk.h> 14 #include <linux/component.h> 15 #include <linux/delay.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/hdmi.h> 18 #include <linux/i2c.h> 19 #include <linux/interrupt.h> 20 #include <linux/io.h> 21 #include <linux/irq.h> 22 #include <linux/kernel.h> 23 #include <linux/mfd/syscon.h> 24 #include <linux/of_address.h> 25 #include <linux/of_device.h> 26 #include <linux/of_graph.h> 27 #include <linux/platform_device.h> 28 #include <linux/pm_runtime.h> 29 #include <linux/regmap.h> 30 #include <linux/regulator/consumer.h> 31 #include <linux/wait.h> 32 33 #include <sound/hdmi-codec.h> 34 #include <media/cec-notifier.h> 35 36 #include <drm/drm_atomic_helper.h> 37 #include <drm/drm_bridge.h> 38 #include <drm/drm_edid.h> 39 #include <drm/drm_print.h> 40 #include <drm/drm_probe_helper.h> 41 #include <drm/drm_simple_kms_helper.h> 42 43 #include "exynos_drm_crtc.h" 44 #include "regs-hdmi.h" 45 46 #define HOTPLUG_DEBOUNCE_MS 1100 47 48 enum hdmi_type { 49 HDMI_TYPE13, 50 HDMI_TYPE14, 51 HDMI_TYPE_COUNT 52 }; 53 54 #define HDMI_MAPPED_BASE 0xffff0000 55 56 enum hdmi_mapped_regs { 57 HDMI_PHY_STATUS = HDMI_MAPPED_BASE, 58 HDMI_PHY_RSTOUT, 59 HDMI_ACR_CON, 60 HDMI_ACR_MCTS0, 61 HDMI_ACR_CTS0, 62 HDMI_ACR_N0 63 }; 64 65 static const u32 hdmi_reg_map[][HDMI_TYPE_COUNT] = { 66 { HDMI_V13_PHY_STATUS, HDMI_PHY_STATUS_0 }, 67 { HDMI_V13_PHY_RSTOUT, HDMI_V14_PHY_RSTOUT }, 68 { HDMI_V13_ACR_CON, HDMI_V14_ACR_CON }, 69 { HDMI_V13_ACR_MCTS0, HDMI_V14_ACR_MCTS0 }, 70 { HDMI_V13_ACR_CTS0, HDMI_V14_ACR_CTS0 }, 71 { HDMI_V13_ACR_N0, HDMI_V14_ACR_N0 }, 72 }; 73 74 static const char * const supply[] = { 75 "vdd", 76 "vdd_osc", 77 "vdd_pll", 78 }; 79 80 struct hdmiphy_config { 81 int pixel_clock; 82 u8 conf[32]; 83 }; 84 85 struct hdmiphy_configs { 86 int count; 87 const struct hdmiphy_config *data; 88 }; 89 90 struct string_array_spec { 91 int count; 92 const char * const *data; 93 }; 94 95 #define INIT_ARRAY_SPEC(a) { .count = ARRAY_SIZE(a), .data = a } 96 97 struct hdmi_driver_data { 98 unsigned int type; 99 unsigned int is_apb_phy:1; 100 unsigned int has_sysreg:1; 101 struct hdmiphy_configs phy_confs; 102 struct string_array_spec clk_gates; 103 /* 104 * Array of triplets (p_off, p_on, clock), where p_off and p_on are 105 * required parents of clock when HDMI-PHY is respectively off or on. 106 */ 107 struct string_array_spec clk_muxes; 108 }; 109 110 struct hdmi_audio { 111 struct platform_device *pdev; 112 struct hdmi_audio_infoframe infoframe; 113 struct hdmi_codec_params params; 114 bool mute; 115 }; 116 117 struct hdmi_context { 118 struct drm_encoder encoder; 119 struct device *dev; 120 struct drm_device *drm_dev; 121 struct drm_connector connector; 122 bool dvi_mode; 123 struct delayed_work hotplug_work; 124 struct cec_notifier *notifier; 125 const struct hdmi_driver_data *drv_data; 126 127 void __iomem *regs; 128 void __iomem *regs_hdmiphy; 129 struct i2c_client *hdmiphy_port; 130 struct i2c_adapter *ddc_adpt; 131 struct gpio_desc *hpd_gpio; 132 int irq; 133 struct regmap *pmureg; 134 struct regmap *sysreg; 135 struct clk **clk_gates; 136 struct clk **clk_muxes; 137 struct regulator_bulk_data regul_bulk[ARRAY_SIZE(supply)]; 138 struct regulator *reg_hdmi_en; 139 struct exynos_drm_clk phy_clk; 140 struct drm_bridge *bridge; 141 142 /* mutex protecting subsequent fields below */ 143 struct mutex mutex; 144 struct hdmi_audio audio; 145 bool powered; 146 }; 147 148 static inline struct hdmi_context *encoder_to_hdmi(struct drm_encoder *e) 149 { 150 return container_of(e, struct hdmi_context, encoder); 151 } 152 153 static inline struct hdmi_context *connector_to_hdmi(struct drm_connector *c) 154 { 155 return container_of(c, struct hdmi_context, connector); 156 } 157 158 static const struct hdmiphy_config hdmiphy_v13_configs[] = { 159 { 160 .pixel_clock = 27000000, 161 .conf = { 162 0x01, 0x05, 0x00, 0xD8, 0x10, 0x1C, 0x30, 0x40, 163 0x6B, 0x10, 0x02, 0x51, 0xDF, 0xF2, 0x54, 0x87, 164 0x84, 0x00, 0x30, 0x38, 0x00, 0x08, 0x10, 0xE0, 165 0x22, 0x40, 0xE3, 0x26, 0x00, 0x00, 0x00, 0x80, 166 }, 167 }, 168 { 169 .pixel_clock = 27027000, 170 .conf = { 171 0x01, 0x05, 0x00, 0xD4, 0x10, 0x9C, 0x09, 0x64, 172 0x6B, 0x10, 0x02, 0x51, 0xDF, 0xF2, 0x54, 0x87, 173 0x84, 0x00, 0x30, 0x38, 0x00, 0x08, 0x10, 0xE0, 174 0x22, 0x40, 0xE3, 0x26, 0x00, 0x00, 0x00, 0x80, 175 }, 176 }, 177 { 178 .pixel_clock = 74176000, 179 .conf = { 180 0x01, 0x05, 0x00, 0xD8, 0x10, 0x9C, 0xef, 0x5B, 181 0x6D, 0x10, 0x01, 0x51, 0xef, 0xF3, 0x54, 0xb9, 182 0x84, 0x00, 0x30, 0x38, 0x00, 0x08, 0x10, 0xE0, 183 0x22, 0x40, 0xa5, 0x26, 0x01, 0x00, 0x00, 0x80, 184 }, 185 }, 186 { 187 .pixel_clock = 74250000, 188 .conf = { 189 0x01, 0x05, 0x00, 0xd8, 0x10, 0x9c, 0xf8, 0x40, 190 0x6a, 0x10, 0x01, 0x51, 0xff, 0xf1, 0x54, 0xba, 191 0x84, 0x00, 0x10, 0x38, 0x00, 0x08, 0x10, 0xe0, 192 0x22, 0x40, 0xa4, 0x26, 0x01, 0x00, 0x00, 0x80, 193 }, 194 }, 195 { 196 .pixel_clock = 148500000, 197 .conf = { 198 0x01, 0x05, 0x00, 0xD8, 0x10, 0x9C, 0xf8, 0x40, 199 0x6A, 0x18, 0x00, 0x51, 0xff, 0xF1, 0x54, 0xba, 200 0x84, 0x00, 0x10, 0x38, 0x00, 0x08, 0x10, 0xE0, 201 0x22, 0x40, 0xa4, 0x26, 0x02, 0x00, 0x00, 0x80, 202 }, 203 }, 204 }; 205 206 static const struct hdmiphy_config hdmiphy_v14_configs[] = { 207 { 208 .pixel_clock = 25200000, 209 .conf = { 210 0x01, 0x51, 0x2A, 0x75, 0x40, 0x01, 0x00, 0x08, 211 0x82, 0x80, 0xfc, 0xd8, 0x45, 0xa0, 0xac, 0x80, 212 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 213 0x54, 0xf4, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 214 }, 215 }, 216 { 217 .pixel_clock = 27000000, 218 .conf = { 219 0x01, 0xd1, 0x22, 0x51, 0x40, 0x08, 0xfc, 0x20, 220 0x98, 0xa0, 0xcb, 0xd8, 0x45, 0xa0, 0xac, 0x80, 221 0x06, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 222 0x54, 0xe4, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 223 }, 224 }, 225 { 226 .pixel_clock = 27027000, 227 .conf = { 228 0x01, 0xd1, 0x2d, 0x72, 0x40, 0x64, 0x12, 0x08, 229 0x43, 0xa0, 0x0e, 0xd9, 0x45, 0xa0, 0xac, 0x80, 230 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 231 0x54, 0xe3, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 232 }, 233 }, 234 { 235 .pixel_clock = 36000000, 236 .conf = { 237 0x01, 0x51, 0x2d, 0x55, 0x40, 0x01, 0x00, 0x08, 238 0x82, 0x80, 0x0e, 0xd9, 0x45, 0xa0, 0xac, 0x80, 239 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 240 0x54, 0xab, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 241 }, 242 }, 243 { 244 .pixel_clock = 40000000, 245 .conf = { 246 0x01, 0x51, 0x32, 0x55, 0x40, 0x01, 0x00, 0x08, 247 0x82, 0x80, 0x2c, 0xd9, 0x45, 0xa0, 0xac, 0x80, 248 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 249 0x54, 0x9a, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 250 }, 251 }, 252 { 253 .pixel_clock = 65000000, 254 .conf = { 255 0x01, 0xd1, 0x36, 0x34, 0x40, 0x1e, 0x0a, 0x08, 256 0x82, 0xa0, 0x45, 0xd9, 0x45, 0xa0, 0xac, 0x80, 257 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 258 0x54, 0xbd, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 259 }, 260 }, 261 { 262 .pixel_clock = 71000000, 263 .conf = { 264 0x01, 0xd1, 0x3b, 0x35, 0x40, 0x0c, 0x04, 0x08, 265 0x85, 0xa0, 0x63, 0xd9, 0x45, 0xa0, 0xac, 0x80, 266 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 267 0x54, 0xad, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 268 }, 269 }, 270 { 271 .pixel_clock = 73250000, 272 .conf = { 273 0x01, 0xd1, 0x3d, 0x35, 0x40, 0x18, 0x02, 0x08, 274 0x83, 0xa0, 0x6e, 0xd9, 0x45, 0xa0, 0xac, 0x80, 275 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 276 0x54, 0xa8, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 277 }, 278 }, 279 { 280 .pixel_clock = 74176000, 281 .conf = { 282 0x01, 0xd1, 0x3e, 0x35, 0x40, 0x5b, 0xde, 0x08, 283 0x82, 0xa0, 0x73, 0xd9, 0x45, 0xa0, 0xac, 0x80, 284 0x56, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 285 0x54, 0xa6, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 286 }, 287 }, 288 { 289 .pixel_clock = 74250000, 290 .conf = { 291 0x01, 0xd1, 0x1f, 0x10, 0x40, 0x40, 0xf8, 0x08, 292 0x81, 0xa0, 0xba, 0xd8, 0x45, 0xa0, 0xac, 0x80, 293 0x3c, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 294 0x54, 0xa5, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 295 }, 296 }, 297 { 298 .pixel_clock = 83500000, 299 .conf = { 300 0x01, 0xd1, 0x23, 0x11, 0x40, 0x0c, 0xfb, 0x08, 301 0x85, 0xa0, 0xd1, 0xd8, 0x45, 0xa0, 0xac, 0x80, 302 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 303 0x54, 0x93, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 304 }, 305 }, 306 { 307 .pixel_clock = 85500000, 308 .conf = { 309 0x01, 0xd1, 0x24, 0x11, 0x40, 0x40, 0xd0, 0x08, 310 0x84, 0xa0, 0xd6, 0xd8, 0x45, 0xa0, 0xac, 0x80, 311 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 312 0x54, 0x90, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 313 }, 314 }, 315 { 316 .pixel_clock = 106500000, 317 .conf = { 318 0x01, 0xd1, 0x2c, 0x12, 0x40, 0x0c, 0x09, 0x08, 319 0x84, 0xa0, 0x0a, 0xd9, 0x45, 0xa0, 0xac, 0x80, 320 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 321 0x54, 0x73, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 322 }, 323 }, 324 { 325 .pixel_clock = 108000000, 326 .conf = { 327 0x01, 0x51, 0x2d, 0x15, 0x40, 0x01, 0x00, 0x08, 328 0x82, 0x80, 0x0e, 0xd9, 0x45, 0xa0, 0xac, 0x80, 329 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 330 0x54, 0xc7, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80, 331 }, 332 }, 333 { 334 .pixel_clock = 115500000, 335 .conf = { 336 0x01, 0xd1, 0x30, 0x12, 0x40, 0x40, 0x10, 0x08, 337 0x80, 0x80, 0x21, 0xd9, 0x45, 0xa0, 0xac, 0x80, 338 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 339 0x54, 0xaa, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80, 340 }, 341 }, 342 { 343 .pixel_clock = 119000000, 344 .conf = { 345 0x01, 0xd1, 0x32, 0x1a, 0x40, 0x30, 0xd8, 0x08, 346 0x04, 0xa0, 0x2a, 0xd9, 0x45, 0xa0, 0xac, 0x80, 347 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 348 0x54, 0x9d, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80, 349 }, 350 }, 351 { 352 .pixel_clock = 146250000, 353 .conf = { 354 0x01, 0xd1, 0x3d, 0x15, 0x40, 0x18, 0xfd, 0x08, 355 0x83, 0xa0, 0x6e, 0xd9, 0x45, 0xa0, 0xac, 0x80, 356 0x08, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 357 0x54, 0x50, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80, 358 }, 359 }, 360 { 361 .pixel_clock = 148500000, 362 .conf = { 363 0x01, 0xd1, 0x1f, 0x00, 0x40, 0x40, 0xf8, 0x08, 364 0x81, 0xa0, 0xba, 0xd8, 0x45, 0xa0, 0xac, 0x80, 365 0x3c, 0x80, 0x11, 0x04, 0x02, 0x22, 0x44, 0x86, 366 0x54, 0x4b, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80, 367 }, 368 }, 369 }; 370 371 static const struct hdmiphy_config hdmiphy_5420_configs[] = { 372 { 373 .pixel_clock = 25200000, 374 .conf = { 375 0x01, 0x52, 0x3F, 0x55, 0x40, 0x01, 0x00, 0xC8, 376 0x82, 0xC8, 0xBD, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 377 0x06, 0x80, 0x01, 0x84, 0x05, 0x02, 0x24, 0x66, 378 0x54, 0xF4, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 379 }, 380 }, 381 { 382 .pixel_clock = 27000000, 383 .conf = { 384 0x01, 0xD1, 0x22, 0x51, 0x40, 0x08, 0xFC, 0xE0, 385 0x98, 0xE8, 0xCB, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 386 0x06, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 387 0x54, 0xE4, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 388 }, 389 }, 390 { 391 .pixel_clock = 27027000, 392 .conf = { 393 0x01, 0xD1, 0x2D, 0x72, 0x40, 0x64, 0x12, 0xC8, 394 0x43, 0xE8, 0x0E, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 395 0x26, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 396 0x54, 0xE3, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 397 }, 398 }, 399 { 400 .pixel_clock = 36000000, 401 .conf = { 402 0x01, 0x51, 0x2D, 0x55, 0x40, 0x40, 0x00, 0xC8, 403 0x02, 0xC8, 0x0E, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 404 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 405 0x54, 0xAB, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 406 }, 407 }, 408 { 409 .pixel_clock = 40000000, 410 .conf = { 411 0x01, 0xD1, 0x21, 0x31, 0x40, 0x3C, 0x28, 0xC8, 412 0x87, 0xE8, 0xC8, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 413 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 414 0x54, 0x9A, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 415 }, 416 }, 417 { 418 .pixel_clock = 65000000, 419 .conf = { 420 0x01, 0xD1, 0x36, 0x34, 0x40, 0x0C, 0x04, 0xC8, 421 0x82, 0xE8, 0x45, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 422 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 423 0x54, 0xBD, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 424 }, 425 }, 426 { 427 .pixel_clock = 71000000, 428 .conf = { 429 0x01, 0xD1, 0x3B, 0x35, 0x40, 0x0C, 0x04, 0xC8, 430 0x85, 0xE8, 0x63, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 431 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 432 0x54, 0x57, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 433 }, 434 }, 435 { 436 .pixel_clock = 73250000, 437 .conf = { 438 0x01, 0xD1, 0x1F, 0x10, 0x40, 0x78, 0x8D, 0xC8, 439 0x81, 0xE8, 0xB7, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 440 0x56, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 441 0x54, 0xA8, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 442 }, 443 }, 444 { 445 .pixel_clock = 74176000, 446 .conf = { 447 0x01, 0xD1, 0x1F, 0x10, 0x40, 0x5B, 0xEF, 0xC8, 448 0x81, 0xE8, 0xB9, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 449 0x56, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 450 0x54, 0xA6, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 451 }, 452 }, 453 { 454 .pixel_clock = 74250000, 455 .conf = { 456 0x01, 0xD1, 0x1F, 0x10, 0x40, 0x40, 0xF8, 0x08, 457 0x81, 0xE8, 0xBA, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 458 0x26, 0x80, 0x09, 0x84, 0x05, 0x22, 0x24, 0x66, 459 0x54, 0xA5, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 460 }, 461 }, 462 { 463 .pixel_clock = 83500000, 464 .conf = { 465 0x01, 0xD1, 0x23, 0x11, 0x40, 0x0C, 0xFB, 0xC8, 466 0x85, 0xE8, 0xD1, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 467 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 468 0x54, 0x4A, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 469 }, 470 }, 471 { 472 .pixel_clock = 88750000, 473 .conf = { 474 0x01, 0xD1, 0x25, 0x11, 0x40, 0x18, 0xFF, 0xC8, 475 0x83, 0xE8, 0xDE, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 476 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 477 0x54, 0x45, 0x24, 0x00, 0x00, 0x00, 0x01, 0x80, 478 }, 479 }, 480 { 481 .pixel_clock = 106500000, 482 .conf = { 483 0x01, 0xD1, 0x2C, 0x12, 0x40, 0x0C, 0x09, 0xC8, 484 0x84, 0xE8, 0x0A, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 485 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 486 0x54, 0x73, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 487 }, 488 }, 489 { 490 .pixel_clock = 108000000, 491 .conf = { 492 0x01, 0x51, 0x2D, 0x15, 0x40, 0x01, 0x00, 0xC8, 493 0x82, 0xC8, 0x0E, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 494 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 495 0x54, 0xC7, 0x25, 0x03, 0x00, 0x00, 0x01, 0x80, 496 }, 497 }, 498 { 499 .pixel_clock = 115500000, 500 .conf = { 501 0x01, 0xD1, 0x30, 0x14, 0x40, 0x0C, 0x03, 0xC8, 502 0x88, 0xE8, 0x21, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 503 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 504 0x54, 0x6A, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 505 }, 506 }, 507 { 508 .pixel_clock = 146250000, 509 .conf = { 510 0x01, 0xD1, 0x3D, 0x15, 0x40, 0x18, 0xFD, 0xC8, 511 0x83, 0xE8, 0x6E, 0xD9, 0x45, 0xA0, 0xAC, 0x80, 512 0x08, 0x80, 0x09, 0x84, 0x05, 0x02, 0x24, 0x66, 513 0x54, 0x54, 0x24, 0x01, 0x00, 0x00, 0x01, 0x80, 514 }, 515 }, 516 { 517 .pixel_clock = 148500000, 518 .conf = { 519 0x01, 0xD1, 0x1F, 0x00, 0x40, 0x40, 0xF8, 0x08, 520 0x81, 0xE8, 0xBA, 0xD8, 0x45, 0xA0, 0xAC, 0x80, 521 0x26, 0x80, 0x09, 0x84, 0x05, 0x22, 0x24, 0x66, 522 0x54, 0x4B, 0x25, 0x03, 0x00, 0x80, 0x01, 0x80, 523 }, 524 }, 525 }; 526 527 static const struct hdmiphy_config hdmiphy_5433_configs[] = { 528 { 529 .pixel_clock = 27000000, 530 .conf = { 531 0x01, 0x51, 0x2d, 0x75, 0x01, 0x00, 0x88, 0x02, 532 0x72, 0x50, 0x44, 0x8c, 0x27, 0x00, 0x7c, 0xac, 533 0xd6, 0x2b, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 534 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 535 }, 536 }, 537 { 538 .pixel_clock = 27027000, 539 .conf = { 540 0x01, 0x51, 0x2d, 0x72, 0x64, 0x09, 0x88, 0xc3, 541 0x71, 0x50, 0x44, 0x8c, 0x27, 0x00, 0x7c, 0xac, 542 0xd6, 0x2b, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 543 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 544 }, 545 }, 546 { 547 .pixel_clock = 40000000, 548 .conf = { 549 0x01, 0x51, 0x32, 0x55, 0x01, 0x00, 0x88, 0x02, 550 0x4d, 0x50, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 551 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 552 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 553 }, 554 }, 555 { 556 .pixel_clock = 50000000, 557 .conf = { 558 0x01, 0x51, 0x34, 0x40, 0x64, 0x09, 0x88, 0xc3, 559 0x3d, 0x50, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 560 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 561 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 562 }, 563 }, 564 { 565 .pixel_clock = 65000000, 566 .conf = { 567 0x01, 0x51, 0x36, 0x31, 0x40, 0x10, 0x04, 0xc6, 568 0x2e, 0xe8, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 569 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 570 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 571 }, 572 }, 573 { 574 .pixel_clock = 74176000, 575 .conf = { 576 0x01, 0x51, 0x3E, 0x35, 0x5B, 0xDE, 0x88, 0x42, 577 0x53, 0x51, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 578 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 579 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 580 }, 581 }, 582 { 583 .pixel_clock = 74250000, 584 .conf = { 585 0x01, 0x51, 0x3E, 0x35, 0x40, 0xF0, 0x88, 0xC2, 586 0x52, 0x51, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 587 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 588 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 589 }, 590 }, 591 { 592 .pixel_clock = 108000000, 593 .conf = { 594 0x01, 0x51, 0x2d, 0x15, 0x01, 0x00, 0x88, 0x02, 595 0x72, 0x52, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 596 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 597 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 598 }, 599 }, 600 { 601 .pixel_clock = 148500000, 602 .conf = { 603 0x01, 0x51, 0x1f, 0x00, 0x40, 0xf8, 0x88, 0xc1, 604 0x52, 0x52, 0x24, 0x0c, 0x24, 0x0f, 0x7c, 0xa5, 605 0xd4, 0x2b, 0x87, 0x00, 0x00, 0x04, 0x00, 0x30, 606 0x08, 0x10, 0x01, 0x01, 0x48, 0x4a, 0x00, 0x40, 607 }, 608 }, 609 { 610 .pixel_clock = 297000000, 611 .conf = { 612 0x01, 0x51, 0x3E, 0x05, 0x40, 0xF0, 0x88, 0xC2, 613 0x52, 0x53, 0x44, 0x8C, 0x27, 0x00, 0x7C, 0xAC, 614 0xD6, 0x2B, 0x67, 0x00, 0x00, 0x04, 0x00, 0x30, 615 0x08, 0x10, 0x01, 0x01, 0x48, 0x40, 0x00, 0x40, 616 }, 617 }, 618 }; 619 620 static const char * const hdmi_clk_gates4[] = { 621 "hdmi", "sclk_hdmi" 622 }; 623 624 static const char * const hdmi_clk_muxes4[] = { 625 "sclk_pixel", "sclk_hdmiphy", "mout_hdmi" 626 }; 627 628 static const char * const hdmi_clk_gates5433[] = { 629 "hdmi_pclk", "hdmi_i_pclk", "i_tmds_clk", "i_pixel_clk", "i_spdif_clk" 630 }; 631 632 static const char * const hdmi_clk_muxes5433[] = { 633 "oscclk", "tmds_clko", "tmds_clko_user", 634 "oscclk", "pixel_clko", "pixel_clko_user" 635 }; 636 637 static const struct hdmi_driver_data exynos4210_hdmi_driver_data = { 638 .type = HDMI_TYPE13, 639 .phy_confs = INIT_ARRAY_SPEC(hdmiphy_v13_configs), 640 .clk_gates = INIT_ARRAY_SPEC(hdmi_clk_gates4), 641 .clk_muxes = INIT_ARRAY_SPEC(hdmi_clk_muxes4), 642 }; 643 644 static const struct hdmi_driver_data exynos4212_hdmi_driver_data = { 645 .type = HDMI_TYPE14, 646 .phy_confs = INIT_ARRAY_SPEC(hdmiphy_v14_configs), 647 .clk_gates = INIT_ARRAY_SPEC(hdmi_clk_gates4), 648 .clk_muxes = INIT_ARRAY_SPEC(hdmi_clk_muxes4), 649 }; 650 651 static const struct hdmi_driver_data exynos5420_hdmi_driver_data = { 652 .type = HDMI_TYPE14, 653 .is_apb_phy = 1, 654 .phy_confs = INIT_ARRAY_SPEC(hdmiphy_5420_configs), 655 .clk_gates = INIT_ARRAY_SPEC(hdmi_clk_gates4), 656 .clk_muxes = INIT_ARRAY_SPEC(hdmi_clk_muxes4), 657 }; 658 659 static const struct hdmi_driver_data exynos5433_hdmi_driver_data = { 660 .type = HDMI_TYPE14, 661 .is_apb_phy = 1, 662 .has_sysreg = 1, 663 .phy_confs = INIT_ARRAY_SPEC(hdmiphy_5433_configs), 664 .clk_gates = INIT_ARRAY_SPEC(hdmi_clk_gates5433), 665 .clk_muxes = INIT_ARRAY_SPEC(hdmi_clk_muxes5433), 666 }; 667 668 static inline u32 hdmi_map_reg(struct hdmi_context *hdata, u32 reg_id) 669 { 670 if ((reg_id & 0xffff0000) == HDMI_MAPPED_BASE) 671 return hdmi_reg_map[reg_id & 0xffff][hdata->drv_data->type]; 672 return reg_id; 673 } 674 675 static inline u32 hdmi_reg_read(struct hdmi_context *hdata, u32 reg_id) 676 { 677 return readl(hdata->regs + hdmi_map_reg(hdata, reg_id)); 678 } 679 680 static inline void hdmi_reg_writeb(struct hdmi_context *hdata, 681 u32 reg_id, u8 value) 682 { 683 writel(value, hdata->regs + hdmi_map_reg(hdata, reg_id)); 684 } 685 686 static inline void hdmi_reg_writev(struct hdmi_context *hdata, u32 reg_id, 687 int bytes, u32 val) 688 { 689 reg_id = hdmi_map_reg(hdata, reg_id); 690 691 while (--bytes >= 0) { 692 writel(val & 0xff, hdata->regs + reg_id); 693 val >>= 8; 694 reg_id += 4; 695 } 696 } 697 698 static inline void hdmi_reg_write_buf(struct hdmi_context *hdata, u32 reg_id, 699 u8 *buf, int size) 700 { 701 for (reg_id = hdmi_map_reg(hdata, reg_id); size; --size, reg_id += 4) 702 writel(*buf++, hdata->regs + reg_id); 703 } 704 705 static inline void hdmi_reg_writemask(struct hdmi_context *hdata, 706 u32 reg_id, u32 value, u32 mask) 707 { 708 u32 old; 709 710 reg_id = hdmi_map_reg(hdata, reg_id); 711 old = readl(hdata->regs + reg_id); 712 value = (value & mask) | (old & ~mask); 713 writel(value, hdata->regs + reg_id); 714 } 715 716 static int hdmiphy_reg_write_buf(struct hdmi_context *hdata, 717 u32 reg_offset, const u8 *buf, u32 len) 718 { 719 if ((reg_offset + len) > 32) 720 return -EINVAL; 721 722 if (hdata->hdmiphy_port) { 723 int ret; 724 725 ret = i2c_master_send(hdata->hdmiphy_port, buf, len); 726 if (ret == len) 727 return 0; 728 return ret; 729 } else { 730 int i; 731 for (i = 0; i < len; i++) 732 writel(buf[i], hdata->regs_hdmiphy + 733 ((reg_offset + i)<<2)); 734 return 0; 735 } 736 } 737 738 static int hdmi_clk_enable_gates(struct hdmi_context *hdata) 739 { 740 int i, ret; 741 742 for (i = 0; i < hdata->drv_data->clk_gates.count; ++i) { 743 ret = clk_prepare_enable(hdata->clk_gates[i]); 744 if (!ret) 745 continue; 746 747 dev_err(hdata->dev, "Cannot enable clock '%s', %d\n", 748 hdata->drv_data->clk_gates.data[i], ret); 749 while (i--) 750 clk_disable_unprepare(hdata->clk_gates[i]); 751 return ret; 752 } 753 754 return 0; 755 } 756 757 static void hdmi_clk_disable_gates(struct hdmi_context *hdata) 758 { 759 int i = hdata->drv_data->clk_gates.count; 760 761 while (i--) 762 clk_disable_unprepare(hdata->clk_gates[i]); 763 } 764 765 static int hdmi_clk_set_parents(struct hdmi_context *hdata, bool to_phy) 766 { 767 struct device *dev = hdata->dev; 768 int ret = 0; 769 int i; 770 771 for (i = 0; i < hdata->drv_data->clk_muxes.count; i += 3) { 772 struct clk **c = &hdata->clk_muxes[i]; 773 774 ret = clk_set_parent(c[2], c[to_phy]); 775 if (!ret) 776 continue; 777 778 dev_err(dev, "Cannot set clock parent of '%s' to '%s', %d\n", 779 hdata->drv_data->clk_muxes.data[i + 2], 780 hdata->drv_data->clk_muxes.data[i + to_phy], ret); 781 } 782 783 return ret; 784 } 785 786 static int hdmi_audio_infoframe_apply(struct hdmi_context *hdata) 787 { 788 struct hdmi_audio_infoframe *infoframe = &hdata->audio.infoframe; 789 u8 buf[HDMI_INFOFRAME_SIZE(AUDIO)]; 790 int len; 791 792 len = hdmi_audio_infoframe_pack(infoframe, buf, sizeof(buf)); 793 if (len < 0) 794 return len; 795 796 hdmi_reg_writeb(hdata, HDMI_AUI_CON, HDMI_AUI_CON_EVERY_VSYNC); 797 hdmi_reg_write_buf(hdata, HDMI_AUI_HEADER0, buf, len); 798 799 return 0; 800 } 801 802 static void hdmi_reg_infoframes(struct hdmi_context *hdata) 803 { 804 struct drm_display_mode *m = &hdata->encoder.crtc->state->mode; 805 union hdmi_infoframe frm; 806 u8 buf[25]; 807 int ret; 808 809 if (hdata->dvi_mode) { 810 hdmi_reg_writeb(hdata, HDMI_AVI_CON, 811 HDMI_AVI_CON_DO_NOT_TRANSMIT); 812 hdmi_reg_writeb(hdata, HDMI_VSI_CON, 813 HDMI_VSI_CON_DO_NOT_TRANSMIT); 814 hdmi_reg_writeb(hdata, HDMI_AUI_CON, HDMI_AUI_CON_NO_TRAN); 815 return; 816 } 817 818 ret = drm_hdmi_avi_infoframe_from_display_mode(&frm.avi, 819 &hdata->connector, m); 820 if (!ret) 821 ret = hdmi_avi_infoframe_pack(&frm.avi, buf, sizeof(buf)); 822 if (ret > 0) { 823 hdmi_reg_writeb(hdata, HDMI_AVI_CON, HDMI_AVI_CON_EVERY_VSYNC); 824 hdmi_reg_write_buf(hdata, HDMI_AVI_HEADER0, buf, ret); 825 } else { 826 DRM_INFO("%s: invalid AVI infoframe (%d)\n", __func__, ret); 827 } 828 829 ret = drm_hdmi_vendor_infoframe_from_display_mode(&frm.vendor.hdmi, 830 &hdata->connector, m); 831 if (!ret) 832 ret = hdmi_vendor_infoframe_pack(&frm.vendor.hdmi, buf, 833 sizeof(buf)); 834 if (ret > 0) { 835 hdmi_reg_writeb(hdata, HDMI_VSI_CON, HDMI_VSI_CON_EVERY_VSYNC); 836 hdmi_reg_write_buf(hdata, HDMI_VSI_HEADER0, buf, 3); 837 hdmi_reg_write_buf(hdata, HDMI_VSI_DATA(0), buf + 3, ret - 3); 838 } 839 840 hdmi_audio_infoframe_apply(hdata); 841 } 842 843 static enum drm_connector_status hdmi_detect(struct drm_connector *connector, 844 bool force) 845 { 846 struct hdmi_context *hdata = connector_to_hdmi(connector); 847 848 if (gpiod_get_value(hdata->hpd_gpio)) 849 return connector_status_connected; 850 851 cec_notifier_set_phys_addr(hdata->notifier, CEC_PHYS_ADDR_INVALID); 852 return connector_status_disconnected; 853 } 854 855 static void hdmi_connector_destroy(struct drm_connector *connector) 856 { 857 struct hdmi_context *hdata = connector_to_hdmi(connector); 858 859 cec_notifier_conn_unregister(hdata->notifier); 860 861 drm_connector_unregister(connector); 862 drm_connector_cleanup(connector); 863 } 864 865 static const struct drm_connector_funcs hdmi_connector_funcs = { 866 .fill_modes = drm_helper_probe_single_connector_modes, 867 .detect = hdmi_detect, 868 .destroy = hdmi_connector_destroy, 869 .reset = drm_atomic_helper_connector_reset, 870 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 871 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 872 }; 873 874 static int hdmi_get_modes(struct drm_connector *connector) 875 { 876 struct hdmi_context *hdata = connector_to_hdmi(connector); 877 struct edid *edid; 878 int ret; 879 880 if (!hdata->ddc_adpt) 881 return -ENODEV; 882 883 edid = drm_get_edid(connector, hdata->ddc_adpt); 884 if (!edid) 885 return -ENODEV; 886 887 hdata->dvi_mode = !drm_detect_hdmi_monitor(edid); 888 DRM_DEV_DEBUG_KMS(hdata->dev, "%s : width[%d] x height[%d]\n", 889 (hdata->dvi_mode ? "dvi monitor" : "hdmi monitor"), 890 edid->width_cm, edid->height_cm); 891 892 drm_connector_update_edid_property(connector, edid); 893 cec_notifier_set_phys_addr_from_edid(hdata->notifier, edid); 894 895 ret = drm_add_edid_modes(connector, edid); 896 897 kfree(edid); 898 899 return ret; 900 } 901 902 static int hdmi_find_phy_conf(struct hdmi_context *hdata, u32 pixel_clock) 903 { 904 const struct hdmiphy_configs *confs = &hdata->drv_data->phy_confs; 905 int i; 906 907 for (i = 0; i < confs->count; i++) 908 if (confs->data[i].pixel_clock == pixel_clock) 909 return i; 910 911 DRM_DEV_DEBUG_KMS(hdata->dev, "Could not find phy config for %d\n", 912 pixel_clock); 913 return -EINVAL; 914 } 915 916 static int hdmi_mode_valid(struct drm_connector *connector, 917 struct drm_display_mode *mode) 918 { 919 struct hdmi_context *hdata = connector_to_hdmi(connector); 920 int ret; 921 922 DRM_DEV_DEBUG_KMS(hdata->dev, 923 "xres=%d, yres=%d, refresh=%d, intl=%d clock=%d\n", 924 mode->hdisplay, mode->vdisplay, mode->vrefresh, 925 (mode->flags & DRM_MODE_FLAG_INTERLACE) ? true : 926 false, mode->clock * 1000); 927 928 ret = hdmi_find_phy_conf(hdata, mode->clock * 1000); 929 if (ret < 0) 930 return MODE_BAD; 931 932 return MODE_OK; 933 } 934 935 static const struct drm_connector_helper_funcs hdmi_connector_helper_funcs = { 936 .get_modes = hdmi_get_modes, 937 .mode_valid = hdmi_mode_valid, 938 }; 939 940 static int hdmi_create_connector(struct drm_encoder *encoder) 941 { 942 struct hdmi_context *hdata = encoder_to_hdmi(encoder); 943 struct drm_connector *connector = &hdata->connector; 944 struct cec_connector_info conn_info; 945 int ret; 946 947 connector->interlace_allowed = true; 948 connector->polled = DRM_CONNECTOR_POLL_HPD; 949 950 ret = drm_connector_init_with_ddc(hdata->drm_dev, connector, 951 &hdmi_connector_funcs, 952 DRM_MODE_CONNECTOR_HDMIA, 953 hdata->ddc_adpt); 954 if (ret) { 955 DRM_DEV_ERROR(hdata->dev, 956 "Failed to initialize connector with drm\n"); 957 return ret; 958 } 959 960 drm_connector_helper_add(connector, &hdmi_connector_helper_funcs); 961 drm_connector_attach_encoder(connector, encoder); 962 963 if (hdata->bridge) { 964 ret = drm_bridge_attach(encoder, hdata->bridge, NULL, 0); 965 if (ret) 966 DRM_DEV_ERROR(hdata->dev, "Failed to attach bridge\n"); 967 } 968 969 cec_fill_conn_info_from_drm(&conn_info, connector); 970 971 hdata->notifier = cec_notifier_conn_register(hdata->dev, NULL, 972 &conn_info); 973 if (!hdata->notifier) { 974 ret = -ENOMEM; 975 DRM_DEV_ERROR(hdata->dev, "Failed to allocate CEC notifier\n"); 976 } 977 978 return ret; 979 } 980 981 static bool hdmi_mode_fixup(struct drm_encoder *encoder, 982 const struct drm_display_mode *mode, 983 struct drm_display_mode *adjusted_mode) 984 { 985 struct drm_device *dev = encoder->dev; 986 struct drm_connector *connector; 987 struct drm_display_mode *m; 988 struct drm_connector_list_iter conn_iter; 989 int mode_ok; 990 991 drm_mode_set_crtcinfo(adjusted_mode, 0); 992 993 drm_connector_list_iter_begin(dev, &conn_iter); 994 drm_for_each_connector_iter(connector, &conn_iter) { 995 if (connector->encoder == encoder) 996 break; 997 } 998 if (connector) 999 drm_connector_get(connector); 1000 drm_connector_list_iter_end(&conn_iter); 1001 1002 if (!connector) 1003 return true; 1004 1005 mode_ok = hdmi_mode_valid(connector, adjusted_mode); 1006 1007 if (mode_ok == MODE_OK) 1008 goto cleanup; 1009 1010 /* 1011 * Find the most suitable mode and copy it to adjusted_mode. 1012 */ 1013 list_for_each_entry(m, &connector->modes, head) { 1014 mode_ok = hdmi_mode_valid(connector, m); 1015 1016 if (mode_ok == MODE_OK) { 1017 DRM_INFO("desired mode doesn't exist so\n"); 1018 DRM_INFO("use the most suitable mode among modes.\n"); 1019 1020 DRM_DEV_DEBUG_KMS(dev->dev, 1021 "Adjusted Mode: [%d]x[%d] [%d]Hz\n", 1022 m->hdisplay, m->vdisplay, 1023 m->vrefresh); 1024 1025 drm_mode_copy(adjusted_mode, m); 1026 break; 1027 } 1028 } 1029 1030 cleanup: 1031 drm_connector_put(connector); 1032 1033 return true; 1034 } 1035 1036 static void hdmi_reg_acr(struct hdmi_context *hdata, u32 freq) 1037 { 1038 u32 n, cts; 1039 1040 cts = (freq % 9) ? 27000 : 30000; 1041 n = 128 * freq / (27000000 / cts); 1042 1043 hdmi_reg_writev(hdata, HDMI_ACR_N0, 3, n); 1044 hdmi_reg_writev(hdata, HDMI_ACR_MCTS0, 3, cts); 1045 hdmi_reg_writev(hdata, HDMI_ACR_CTS0, 3, cts); 1046 hdmi_reg_writeb(hdata, HDMI_ACR_CON, 4); 1047 } 1048 1049 static void hdmi_audio_config(struct hdmi_context *hdata) 1050 { 1051 u32 bit_ch = 1; 1052 u32 data_num, val; 1053 int i; 1054 1055 switch (hdata->audio.params.sample_width) { 1056 case 20: 1057 data_num = 2; 1058 break; 1059 case 24: 1060 data_num = 3; 1061 break; 1062 default: 1063 data_num = 1; 1064 bit_ch = 0; 1065 break; 1066 } 1067 1068 hdmi_reg_acr(hdata, hdata->audio.params.sample_rate); 1069 1070 hdmi_reg_writeb(hdata, HDMI_I2S_MUX_CON, HDMI_I2S_IN_DISABLE 1071 | HDMI_I2S_AUD_I2S | HDMI_I2S_CUV_I2S_ENABLE 1072 | HDMI_I2S_MUX_ENABLE); 1073 1074 hdmi_reg_writeb(hdata, HDMI_I2S_MUX_CH, HDMI_I2S_CH0_EN 1075 | HDMI_I2S_CH1_EN | HDMI_I2S_CH2_EN); 1076 1077 hdmi_reg_writeb(hdata, HDMI_I2S_MUX_CUV, HDMI_I2S_CUV_RL_EN); 1078 hdmi_reg_writeb(hdata, HDMI_I2S_CLK_CON, HDMI_I2S_CLK_DIS); 1079 hdmi_reg_writeb(hdata, HDMI_I2S_CLK_CON, HDMI_I2S_CLK_EN); 1080 1081 val = hdmi_reg_read(hdata, HDMI_I2S_DSD_CON) | 0x01; 1082 hdmi_reg_writeb(hdata, HDMI_I2S_DSD_CON, val); 1083 1084 /* Configuration I2S input ports. Configure I2S_PIN_SEL_0~4 */ 1085 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_0, HDMI_I2S_SEL_SCLK(5) 1086 | HDMI_I2S_SEL_LRCK(6)); 1087 1088 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_1, HDMI_I2S_SEL_SDATA1(3) 1089 | HDMI_I2S_SEL_SDATA0(4)); 1090 1091 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_2, HDMI_I2S_SEL_SDATA3(1) 1092 | HDMI_I2S_SEL_SDATA2(2)); 1093 1094 hdmi_reg_writeb(hdata, HDMI_I2S_PIN_SEL_3, HDMI_I2S_SEL_DSD(0)); 1095 1096 /* I2S_CON_1 & 2 */ 1097 hdmi_reg_writeb(hdata, HDMI_I2S_CON_1, HDMI_I2S_SCLK_FALLING_EDGE 1098 | HDMI_I2S_L_CH_LOW_POL); 1099 hdmi_reg_writeb(hdata, HDMI_I2S_CON_2, HDMI_I2S_MSB_FIRST_MODE 1100 | HDMI_I2S_SET_BIT_CH(bit_ch) 1101 | HDMI_I2S_SET_SDATA_BIT(data_num) 1102 | HDMI_I2S_BASIC_FORMAT); 1103 1104 /* Configuration of the audio channel status registers */ 1105 for (i = 0; i < HDMI_I2S_CH_ST_MAXNUM; i++) 1106 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST(i), 1107 hdata->audio.params.iec.status[i]); 1108 1109 hdmi_reg_writeb(hdata, HDMI_I2S_CH_ST_CON, HDMI_I2S_CH_STATUS_RELOAD); 1110 } 1111 1112 static void hdmi_audio_control(struct hdmi_context *hdata) 1113 { 1114 bool enable = !hdata->audio.mute; 1115 1116 if (hdata->dvi_mode) 1117 return; 1118 1119 hdmi_reg_writeb(hdata, HDMI_AUI_CON, enable ? 1120 HDMI_AVI_CON_EVERY_VSYNC : HDMI_AUI_CON_NO_TRAN); 1121 hdmi_reg_writemask(hdata, HDMI_CON_0, enable ? 1122 HDMI_ASP_EN : HDMI_ASP_DIS, HDMI_ASP_MASK); 1123 } 1124 1125 static void hdmi_start(struct hdmi_context *hdata, bool start) 1126 { 1127 struct drm_display_mode *m = &hdata->encoder.crtc->state->mode; 1128 u32 val = start ? HDMI_TG_EN : 0; 1129 1130 if (m->flags & DRM_MODE_FLAG_INTERLACE) 1131 val |= HDMI_FIELD_EN; 1132 1133 hdmi_reg_writemask(hdata, HDMI_CON_0, val, HDMI_EN); 1134 hdmi_reg_writemask(hdata, HDMI_TG_CMD, val, HDMI_TG_EN | HDMI_FIELD_EN); 1135 } 1136 1137 static void hdmi_conf_init(struct hdmi_context *hdata) 1138 { 1139 /* disable HPD interrupts from HDMI IP block, use GPIO instead */ 1140 hdmi_reg_writemask(hdata, HDMI_INTC_CON, 0, HDMI_INTC_EN_GLOBAL | 1141 HDMI_INTC_EN_HPD_PLUG | HDMI_INTC_EN_HPD_UNPLUG); 1142 1143 /* choose HDMI mode */ 1144 hdmi_reg_writemask(hdata, HDMI_MODE_SEL, 1145 HDMI_MODE_HDMI_EN, HDMI_MODE_MASK); 1146 /* apply video pre-amble and guard band in HDMI mode only */ 1147 hdmi_reg_writeb(hdata, HDMI_CON_2, 0); 1148 /* disable bluescreen */ 1149 hdmi_reg_writemask(hdata, HDMI_CON_0, 0, HDMI_BLUE_SCR_EN); 1150 1151 if (hdata->dvi_mode) { 1152 hdmi_reg_writemask(hdata, HDMI_MODE_SEL, 1153 HDMI_MODE_DVI_EN, HDMI_MODE_MASK); 1154 hdmi_reg_writeb(hdata, HDMI_CON_2, 1155 HDMI_VID_PREAMBLE_DIS | HDMI_GUARD_BAND_DIS); 1156 } 1157 1158 if (hdata->drv_data->type == HDMI_TYPE13) { 1159 /* choose bluescreen (fecal) color */ 1160 hdmi_reg_writeb(hdata, HDMI_V13_BLUE_SCREEN_0, 0x12); 1161 hdmi_reg_writeb(hdata, HDMI_V13_BLUE_SCREEN_1, 0x34); 1162 hdmi_reg_writeb(hdata, HDMI_V13_BLUE_SCREEN_2, 0x56); 1163 1164 /* enable AVI packet every vsync, fixes purple line problem */ 1165 hdmi_reg_writeb(hdata, HDMI_V13_AVI_CON, 0x02); 1166 /* force RGB, look to CEA-861-D, table 7 for more detail */ 1167 hdmi_reg_writeb(hdata, HDMI_V13_AVI_BYTE(0), 0 << 5); 1168 hdmi_reg_writemask(hdata, HDMI_CON_1, 0x10 << 5, 0x11 << 5); 1169 1170 hdmi_reg_writeb(hdata, HDMI_V13_SPD_CON, 0x02); 1171 hdmi_reg_writeb(hdata, HDMI_V13_AUI_CON, 0x02); 1172 hdmi_reg_writeb(hdata, HDMI_V13_ACR_CON, 0x04); 1173 } else { 1174 hdmi_reg_infoframes(hdata); 1175 1176 /* enable AVI packet every vsync, fixes purple line problem */ 1177 hdmi_reg_writemask(hdata, HDMI_CON_1, 2, 3 << 5); 1178 } 1179 } 1180 1181 static void hdmiphy_wait_for_pll(struct hdmi_context *hdata) 1182 { 1183 int tries; 1184 1185 for (tries = 0; tries < 10; ++tries) { 1186 u32 val = hdmi_reg_read(hdata, HDMI_PHY_STATUS); 1187 1188 if (val & HDMI_PHY_STATUS_READY) { 1189 DRM_DEV_DEBUG_KMS(hdata->dev, 1190 "PLL stabilized after %d tries\n", 1191 tries); 1192 return; 1193 } 1194 usleep_range(10, 20); 1195 } 1196 1197 DRM_DEV_ERROR(hdata->dev, "PLL could not reach steady state\n"); 1198 } 1199 1200 static void hdmi_v13_mode_apply(struct hdmi_context *hdata) 1201 { 1202 struct drm_display_mode *m = &hdata->encoder.crtc->state->mode; 1203 unsigned int val; 1204 1205 hdmi_reg_writev(hdata, HDMI_H_BLANK_0, 2, m->htotal - m->hdisplay); 1206 hdmi_reg_writev(hdata, HDMI_V13_H_V_LINE_0, 3, 1207 (m->htotal << 12) | m->vtotal); 1208 1209 val = (m->flags & DRM_MODE_FLAG_NVSYNC) ? 1 : 0; 1210 hdmi_reg_writev(hdata, HDMI_VSYNC_POL, 1, val); 1211 1212 val = (m->flags & DRM_MODE_FLAG_INTERLACE) ? 1 : 0; 1213 hdmi_reg_writev(hdata, HDMI_INT_PRO_MODE, 1, val); 1214 1215 val = (m->hsync_start - m->hdisplay - 2); 1216 val |= ((m->hsync_end - m->hdisplay - 2) << 10); 1217 val |= ((m->flags & DRM_MODE_FLAG_NHSYNC) ? 1 : 0)<<20; 1218 hdmi_reg_writev(hdata, HDMI_V13_H_SYNC_GEN_0, 3, val); 1219 1220 /* 1221 * Quirk requirement for exynos HDMI IP design, 1222 * 2 pixels less than the actual calculation for hsync_start 1223 * and end. 1224 */ 1225 1226 /* Following values & calculations differ for different type of modes */ 1227 if (m->flags & DRM_MODE_FLAG_INTERLACE) { 1228 val = ((m->vsync_end - m->vdisplay) / 2); 1229 val |= ((m->vsync_start - m->vdisplay) / 2) << 12; 1230 hdmi_reg_writev(hdata, HDMI_V13_V_SYNC_GEN_1_0, 3, val); 1231 1232 val = m->vtotal / 2; 1233 val |= ((m->vtotal - m->vdisplay) / 2) << 11; 1234 hdmi_reg_writev(hdata, HDMI_V13_V_BLANK_0, 3, val); 1235 1236 val = (m->vtotal + 1237 ((m->vsync_end - m->vsync_start) * 4) + 5) / 2; 1238 val |= m->vtotal << 11; 1239 hdmi_reg_writev(hdata, HDMI_V13_V_BLANK_F_0, 3, val); 1240 1241 val = ((m->vtotal / 2) + 7); 1242 val |= ((m->vtotal / 2) + 2) << 12; 1243 hdmi_reg_writev(hdata, HDMI_V13_V_SYNC_GEN_2_0, 3, val); 1244 1245 val = ((m->htotal / 2) + (m->hsync_start - m->hdisplay)); 1246 val |= ((m->htotal / 2) + 1247 (m->hsync_start - m->hdisplay)) << 12; 1248 hdmi_reg_writev(hdata, HDMI_V13_V_SYNC_GEN_3_0, 3, val); 1249 1250 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST_L, 2, 1251 (m->vtotal - m->vdisplay) / 2); 1252 hdmi_reg_writev(hdata, HDMI_TG_VACT_SZ_L, 2, m->vdisplay / 2); 1253 1254 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST2_L, 2, 0x249); 1255 } else { 1256 val = m->vtotal; 1257 val |= (m->vtotal - m->vdisplay) << 11; 1258 hdmi_reg_writev(hdata, HDMI_V13_V_BLANK_0, 3, val); 1259 1260 hdmi_reg_writev(hdata, HDMI_V13_V_BLANK_F_0, 3, 0); 1261 1262 val = (m->vsync_end - m->vdisplay); 1263 val |= ((m->vsync_start - m->vdisplay) << 12); 1264 hdmi_reg_writev(hdata, HDMI_V13_V_SYNC_GEN_1_0, 3, val); 1265 1266 hdmi_reg_writev(hdata, HDMI_V13_V_SYNC_GEN_2_0, 3, 0x1001); 1267 hdmi_reg_writev(hdata, HDMI_V13_V_SYNC_GEN_3_0, 3, 0x1001); 1268 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST_L, 2, 1269 m->vtotal - m->vdisplay); 1270 hdmi_reg_writev(hdata, HDMI_TG_VACT_SZ_L, 2, m->vdisplay); 1271 } 1272 1273 hdmi_reg_writev(hdata, HDMI_TG_H_FSZ_L, 2, m->htotal); 1274 hdmi_reg_writev(hdata, HDMI_TG_HACT_ST_L, 2, m->htotal - m->hdisplay); 1275 hdmi_reg_writev(hdata, HDMI_TG_HACT_SZ_L, 2, m->hdisplay); 1276 hdmi_reg_writev(hdata, HDMI_TG_V_FSZ_L, 2, m->vtotal); 1277 } 1278 1279 static void hdmi_v14_mode_apply(struct hdmi_context *hdata) 1280 { 1281 struct drm_display_mode *m = &hdata->encoder.crtc->state->mode; 1282 struct drm_display_mode *am = 1283 &hdata->encoder.crtc->state->adjusted_mode; 1284 int hquirk = 0; 1285 1286 /* 1287 * In case video mode coming from CRTC differs from requested one HDMI 1288 * sometimes is able to almost properly perform conversion - only 1289 * first line is distorted. 1290 */ 1291 if ((m->vdisplay != am->vdisplay) && 1292 (m->hdisplay == 1280 || m->hdisplay == 1024 || m->hdisplay == 1366)) 1293 hquirk = 258; 1294 1295 hdmi_reg_writev(hdata, HDMI_H_BLANK_0, 2, m->htotal - m->hdisplay); 1296 hdmi_reg_writev(hdata, HDMI_V_LINE_0, 2, m->vtotal); 1297 hdmi_reg_writev(hdata, HDMI_H_LINE_0, 2, m->htotal); 1298 hdmi_reg_writev(hdata, HDMI_HSYNC_POL, 1, 1299 (m->flags & DRM_MODE_FLAG_NHSYNC) ? 1 : 0); 1300 hdmi_reg_writev(hdata, HDMI_VSYNC_POL, 1, 1301 (m->flags & DRM_MODE_FLAG_NVSYNC) ? 1 : 0); 1302 hdmi_reg_writev(hdata, HDMI_INT_PRO_MODE, 1, 1303 (m->flags & DRM_MODE_FLAG_INTERLACE) ? 1 : 0); 1304 1305 /* 1306 * Quirk requirement for exynos 5 HDMI IP design, 1307 * 2 pixels less than the actual calculation for hsync_start 1308 * and end. 1309 */ 1310 1311 /* Following values & calculations differ for different type of modes */ 1312 if (m->flags & DRM_MODE_FLAG_INTERLACE) { 1313 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_BEF_2_0, 2, 1314 (m->vsync_end - m->vdisplay) / 2); 1315 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_BEF_1_0, 2, 1316 (m->vsync_start - m->vdisplay) / 2); 1317 hdmi_reg_writev(hdata, HDMI_V2_BLANK_0, 2, m->vtotal / 2); 1318 hdmi_reg_writev(hdata, HDMI_V1_BLANK_0, 2, 1319 (m->vtotal - m->vdisplay) / 2); 1320 hdmi_reg_writev(hdata, HDMI_V_BLANK_F0_0, 2, 1321 m->vtotal - m->vdisplay / 2); 1322 hdmi_reg_writev(hdata, HDMI_V_BLANK_F1_0, 2, m->vtotal); 1323 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_2_0, 2, 1324 (m->vtotal / 2) + 7); 1325 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_1_0, 2, 1326 (m->vtotal / 2) + 2); 1327 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_2_0, 2, 1328 (m->htotal / 2) + (m->hsync_start - m->hdisplay)); 1329 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_1_0, 2, 1330 (m->htotal / 2) + (m->hsync_start - m->hdisplay)); 1331 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST_L, 2, 1332 (m->vtotal - m->vdisplay) / 2); 1333 hdmi_reg_writev(hdata, HDMI_TG_VACT_SZ_L, 2, m->vdisplay / 2); 1334 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST2_L, 2, 1335 m->vtotal - m->vdisplay / 2); 1336 hdmi_reg_writev(hdata, HDMI_TG_VSYNC2_L, 2, 1337 (m->vtotal / 2) + 1); 1338 hdmi_reg_writev(hdata, HDMI_TG_VSYNC_BOT_HDMI_L, 2, 1339 (m->vtotal / 2) + 1); 1340 hdmi_reg_writev(hdata, HDMI_TG_FIELD_BOT_HDMI_L, 2, 1341 (m->vtotal / 2) + 1); 1342 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST3_L, 2, 0x0); 1343 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST4_L, 2, 0x0); 1344 } else { 1345 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_BEF_2_0, 2, 1346 m->vsync_end - m->vdisplay); 1347 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_BEF_1_0, 2, 1348 m->vsync_start - m->vdisplay); 1349 hdmi_reg_writev(hdata, HDMI_V2_BLANK_0, 2, m->vtotal); 1350 hdmi_reg_writev(hdata, HDMI_V1_BLANK_0, 2, 1351 m->vtotal - m->vdisplay); 1352 hdmi_reg_writev(hdata, HDMI_V_BLANK_F0_0, 2, 0xffff); 1353 hdmi_reg_writev(hdata, HDMI_V_BLANK_F1_0, 2, 0xffff); 1354 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_2_0, 2, 0xffff); 1355 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_1_0, 2, 0xffff); 1356 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_2_0, 2, 0xffff); 1357 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_1_0, 2, 0xffff); 1358 hdmi_reg_writev(hdata, HDMI_TG_VACT_ST_L, 2, 1359 m->vtotal - m->vdisplay); 1360 hdmi_reg_writev(hdata, HDMI_TG_VACT_SZ_L, 2, m->vdisplay); 1361 } 1362 1363 hdmi_reg_writev(hdata, HDMI_H_SYNC_START_0, 2, 1364 m->hsync_start - m->hdisplay - 2); 1365 hdmi_reg_writev(hdata, HDMI_H_SYNC_END_0, 2, 1366 m->hsync_end - m->hdisplay - 2); 1367 hdmi_reg_writev(hdata, HDMI_VACT_SPACE_1_0, 2, 0xffff); 1368 hdmi_reg_writev(hdata, HDMI_VACT_SPACE_2_0, 2, 0xffff); 1369 hdmi_reg_writev(hdata, HDMI_VACT_SPACE_3_0, 2, 0xffff); 1370 hdmi_reg_writev(hdata, HDMI_VACT_SPACE_4_0, 2, 0xffff); 1371 hdmi_reg_writev(hdata, HDMI_VACT_SPACE_5_0, 2, 0xffff); 1372 hdmi_reg_writev(hdata, HDMI_VACT_SPACE_6_0, 2, 0xffff); 1373 hdmi_reg_writev(hdata, HDMI_V_BLANK_F2_0, 2, 0xffff); 1374 hdmi_reg_writev(hdata, HDMI_V_BLANK_F3_0, 2, 0xffff); 1375 hdmi_reg_writev(hdata, HDMI_V_BLANK_F4_0, 2, 0xffff); 1376 hdmi_reg_writev(hdata, HDMI_V_BLANK_F5_0, 2, 0xffff); 1377 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_3_0, 2, 0xffff); 1378 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_4_0, 2, 0xffff); 1379 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_5_0, 2, 0xffff); 1380 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_6_0, 2, 0xffff); 1381 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_3_0, 2, 0xffff); 1382 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_4_0, 2, 0xffff); 1383 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_5_0, 2, 0xffff); 1384 hdmi_reg_writev(hdata, HDMI_V_SYNC_LINE_AFT_PXL_6_0, 2, 0xffff); 1385 1386 hdmi_reg_writev(hdata, HDMI_TG_H_FSZ_L, 2, m->htotal); 1387 hdmi_reg_writev(hdata, HDMI_TG_HACT_ST_L, 2, 1388 m->htotal - m->hdisplay - hquirk); 1389 hdmi_reg_writev(hdata, HDMI_TG_HACT_SZ_L, 2, m->hdisplay + hquirk); 1390 hdmi_reg_writev(hdata, HDMI_TG_V_FSZ_L, 2, m->vtotal); 1391 if (hdata->drv_data == &exynos5433_hdmi_driver_data) 1392 hdmi_reg_writeb(hdata, HDMI_TG_DECON_EN, 1); 1393 } 1394 1395 static void hdmi_mode_apply(struct hdmi_context *hdata) 1396 { 1397 if (hdata->drv_data->type == HDMI_TYPE13) 1398 hdmi_v13_mode_apply(hdata); 1399 else 1400 hdmi_v14_mode_apply(hdata); 1401 1402 hdmi_start(hdata, true); 1403 } 1404 1405 static void hdmiphy_conf_reset(struct hdmi_context *hdata) 1406 { 1407 hdmi_reg_writemask(hdata, HDMI_CORE_RSTOUT, 0, 1); 1408 usleep_range(10000, 12000); 1409 hdmi_reg_writemask(hdata, HDMI_CORE_RSTOUT, ~0, 1); 1410 usleep_range(10000, 12000); 1411 hdmi_reg_writemask(hdata, HDMI_PHY_RSTOUT, ~0, HDMI_PHY_SW_RSTOUT); 1412 usleep_range(10000, 12000); 1413 hdmi_reg_writemask(hdata, HDMI_PHY_RSTOUT, 0, HDMI_PHY_SW_RSTOUT); 1414 usleep_range(10000, 12000); 1415 } 1416 1417 static void hdmiphy_enable_mode_set(struct hdmi_context *hdata, bool enable) 1418 { 1419 u8 v = enable ? HDMI_PHY_ENABLE_MODE_SET : HDMI_PHY_DISABLE_MODE_SET; 1420 1421 if (hdata->drv_data == &exynos5433_hdmi_driver_data) 1422 writel(v, hdata->regs_hdmiphy + HDMIPHY5433_MODE_SET_DONE); 1423 } 1424 1425 static void hdmiphy_conf_apply(struct hdmi_context *hdata) 1426 { 1427 struct drm_display_mode *m = &hdata->encoder.crtc->state->mode; 1428 int ret; 1429 const u8 *phy_conf; 1430 1431 ret = hdmi_find_phy_conf(hdata, m->clock * 1000); 1432 if (ret < 0) { 1433 DRM_DEV_ERROR(hdata->dev, "failed to find hdmiphy conf\n"); 1434 return; 1435 } 1436 phy_conf = hdata->drv_data->phy_confs.data[ret].conf; 1437 1438 hdmi_clk_set_parents(hdata, false); 1439 1440 hdmiphy_conf_reset(hdata); 1441 1442 hdmiphy_enable_mode_set(hdata, true); 1443 ret = hdmiphy_reg_write_buf(hdata, 0, phy_conf, 32); 1444 if (ret) { 1445 DRM_DEV_ERROR(hdata->dev, "failed to configure hdmiphy\n"); 1446 return; 1447 } 1448 hdmiphy_enable_mode_set(hdata, false); 1449 hdmi_clk_set_parents(hdata, true); 1450 usleep_range(10000, 12000); 1451 hdmiphy_wait_for_pll(hdata); 1452 } 1453 1454 /* Should be called with hdata->mutex mutex held */ 1455 static void hdmi_conf_apply(struct hdmi_context *hdata) 1456 { 1457 hdmi_start(hdata, false); 1458 hdmi_conf_init(hdata); 1459 hdmi_audio_config(hdata); 1460 hdmi_mode_apply(hdata); 1461 hdmi_audio_control(hdata); 1462 } 1463 1464 static void hdmi_set_refclk(struct hdmi_context *hdata, bool on) 1465 { 1466 if (!hdata->sysreg) 1467 return; 1468 1469 regmap_update_bits(hdata->sysreg, EXYNOS5433_SYSREG_DISP_HDMI_PHY, 1470 SYSREG_HDMI_REFCLK_INT_CLK, on ? ~0 : 0); 1471 } 1472 1473 /* Should be called with hdata->mutex mutex held. */ 1474 static void hdmiphy_enable(struct hdmi_context *hdata) 1475 { 1476 if (hdata->powered) 1477 return; 1478 1479 pm_runtime_get_sync(hdata->dev); 1480 1481 if (regulator_bulk_enable(ARRAY_SIZE(supply), hdata->regul_bulk)) 1482 DRM_DEV_DEBUG_KMS(hdata->dev, 1483 "failed to enable regulator bulk\n"); 1484 1485 regmap_update_bits(hdata->pmureg, PMU_HDMI_PHY_CONTROL, 1486 PMU_HDMI_PHY_ENABLE_BIT, 1); 1487 1488 hdmi_set_refclk(hdata, true); 1489 1490 hdmi_reg_writemask(hdata, HDMI_PHY_CON_0, 0, HDMI_PHY_POWER_OFF_EN); 1491 1492 hdmiphy_conf_apply(hdata); 1493 1494 hdata->powered = true; 1495 } 1496 1497 /* Should be called with hdata->mutex mutex held. */ 1498 static void hdmiphy_disable(struct hdmi_context *hdata) 1499 { 1500 if (!hdata->powered) 1501 return; 1502 1503 hdmi_reg_writemask(hdata, HDMI_CON_0, 0, HDMI_EN); 1504 1505 hdmi_reg_writemask(hdata, HDMI_PHY_CON_0, ~0, HDMI_PHY_POWER_OFF_EN); 1506 1507 hdmi_set_refclk(hdata, false); 1508 1509 regmap_update_bits(hdata->pmureg, PMU_HDMI_PHY_CONTROL, 1510 PMU_HDMI_PHY_ENABLE_BIT, 0); 1511 1512 regulator_bulk_disable(ARRAY_SIZE(supply), hdata->regul_bulk); 1513 1514 pm_runtime_put_sync(hdata->dev); 1515 1516 hdata->powered = false; 1517 } 1518 1519 static void hdmi_enable(struct drm_encoder *encoder) 1520 { 1521 struct hdmi_context *hdata = encoder_to_hdmi(encoder); 1522 1523 mutex_lock(&hdata->mutex); 1524 1525 hdmiphy_enable(hdata); 1526 hdmi_conf_apply(hdata); 1527 1528 mutex_unlock(&hdata->mutex); 1529 } 1530 1531 static void hdmi_disable(struct drm_encoder *encoder) 1532 { 1533 struct hdmi_context *hdata = encoder_to_hdmi(encoder); 1534 1535 mutex_lock(&hdata->mutex); 1536 1537 if (hdata->powered) { 1538 /* 1539 * The SFRs of VP and Mixer are updated by Vertical Sync of 1540 * Timing generator which is a part of HDMI so the sequence 1541 * to disable TV Subsystem should be as following, 1542 * VP -> Mixer -> HDMI 1543 * 1544 * To achieve such sequence HDMI is disabled together with 1545 * HDMI PHY, via pipe clock callback. 1546 */ 1547 mutex_unlock(&hdata->mutex); 1548 cancel_delayed_work(&hdata->hotplug_work); 1549 if (hdata->notifier) 1550 cec_notifier_phys_addr_invalidate(hdata->notifier); 1551 return; 1552 } 1553 1554 mutex_unlock(&hdata->mutex); 1555 } 1556 1557 static const struct drm_encoder_helper_funcs exynos_hdmi_encoder_helper_funcs = { 1558 .mode_fixup = hdmi_mode_fixup, 1559 .enable = hdmi_enable, 1560 .disable = hdmi_disable, 1561 }; 1562 1563 static void hdmi_audio_shutdown(struct device *dev, void *data) 1564 { 1565 struct hdmi_context *hdata = dev_get_drvdata(dev); 1566 1567 mutex_lock(&hdata->mutex); 1568 1569 hdata->audio.mute = true; 1570 1571 if (hdata->powered) 1572 hdmi_audio_control(hdata); 1573 1574 mutex_unlock(&hdata->mutex); 1575 } 1576 1577 static int hdmi_audio_hw_params(struct device *dev, void *data, 1578 struct hdmi_codec_daifmt *daifmt, 1579 struct hdmi_codec_params *params) 1580 { 1581 struct hdmi_context *hdata = dev_get_drvdata(dev); 1582 1583 if (daifmt->fmt != HDMI_I2S || daifmt->bit_clk_inv || 1584 daifmt->frame_clk_inv || daifmt->bit_clk_master || 1585 daifmt->frame_clk_master) { 1586 dev_err(dev, "%s: Bad flags %d %d %d %d\n", __func__, 1587 daifmt->bit_clk_inv, daifmt->frame_clk_inv, 1588 daifmt->bit_clk_master, 1589 daifmt->frame_clk_master); 1590 return -EINVAL; 1591 } 1592 1593 mutex_lock(&hdata->mutex); 1594 1595 hdata->audio.params = *params; 1596 1597 if (hdata->powered) { 1598 hdmi_audio_config(hdata); 1599 hdmi_audio_infoframe_apply(hdata); 1600 } 1601 1602 mutex_unlock(&hdata->mutex); 1603 1604 return 0; 1605 } 1606 1607 static int hdmi_audio_mute(struct device *dev, void *data, 1608 bool mute, int direction) 1609 { 1610 struct hdmi_context *hdata = dev_get_drvdata(dev); 1611 1612 mutex_lock(&hdata->mutex); 1613 1614 hdata->audio.mute = mute; 1615 1616 if (hdata->powered) 1617 hdmi_audio_control(hdata); 1618 1619 mutex_unlock(&hdata->mutex); 1620 1621 return 0; 1622 } 1623 1624 static int hdmi_audio_get_eld(struct device *dev, void *data, uint8_t *buf, 1625 size_t len) 1626 { 1627 struct hdmi_context *hdata = dev_get_drvdata(dev); 1628 struct drm_connector *connector = &hdata->connector; 1629 1630 memcpy(buf, connector->eld, min(sizeof(connector->eld), len)); 1631 1632 return 0; 1633 } 1634 1635 static const struct hdmi_codec_ops audio_codec_ops = { 1636 .hw_params = hdmi_audio_hw_params, 1637 .audio_shutdown = hdmi_audio_shutdown, 1638 .mute_stream = hdmi_audio_mute, 1639 .get_eld = hdmi_audio_get_eld, 1640 .no_capture_mute = 1, 1641 }; 1642 1643 static int hdmi_register_audio_device(struct hdmi_context *hdata) 1644 { 1645 struct hdmi_codec_pdata codec_data = { 1646 .ops = &audio_codec_ops, 1647 .max_i2s_channels = 6, 1648 .i2s = 1, 1649 }; 1650 1651 hdata->audio.pdev = platform_device_register_data( 1652 hdata->dev, HDMI_CODEC_DRV_NAME, PLATFORM_DEVID_AUTO, 1653 &codec_data, sizeof(codec_data)); 1654 1655 return PTR_ERR_OR_ZERO(hdata->audio.pdev); 1656 } 1657 1658 static void hdmi_hotplug_work_func(struct work_struct *work) 1659 { 1660 struct hdmi_context *hdata; 1661 1662 hdata = container_of(work, struct hdmi_context, hotplug_work.work); 1663 1664 if (hdata->drm_dev) 1665 drm_helper_hpd_irq_event(hdata->drm_dev); 1666 } 1667 1668 static irqreturn_t hdmi_irq_thread(int irq, void *arg) 1669 { 1670 struct hdmi_context *hdata = arg; 1671 1672 mod_delayed_work(system_wq, &hdata->hotplug_work, 1673 msecs_to_jiffies(HOTPLUG_DEBOUNCE_MS)); 1674 1675 return IRQ_HANDLED; 1676 } 1677 1678 static int hdmi_clks_get(struct hdmi_context *hdata, 1679 const struct string_array_spec *names, 1680 struct clk **clks) 1681 { 1682 struct device *dev = hdata->dev; 1683 int i; 1684 1685 for (i = 0; i < names->count; ++i) { 1686 struct clk *clk = devm_clk_get(dev, names->data[i]); 1687 1688 if (IS_ERR(clk)) { 1689 int ret = PTR_ERR(clk); 1690 1691 dev_err(dev, "Cannot get clock %s, %d\n", 1692 names->data[i], ret); 1693 1694 return ret; 1695 } 1696 1697 clks[i] = clk; 1698 } 1699 1700 return 0; 1701 } 1702 1703 static int hdmi_clk_init(struct hdmi_context *hdata) 1704 { 1705 const struct hdmi_driver_data *drv_data = hdata->drv_data; 1706 int count = drv_data->clk_gates.count + drv_data->clk_muxes.count; 1707 struct device *dev = hdata->dev; 1708 struct clk **clks; 1709 int ret; 1710 1711 if (!count) 1712 return 0; 1713 1714 clks = devm_kcalloc(dev, count, sizeof(*clks), GFP_KERNEL); 1715 if (!clks) 1716 return -ENOMEM; 1717 1718 hdata->clk_gates = clks; 1719 hdata->clk_muxes = clks + drv_data->clk_gates.count; 1720 1721 ret = hdmi_clks_get(hdata, &drv_data->clk_gates, hdata->clk_gates); 1722 if (ret) 1723 return ret; 1724 1725 return hdmi_clks_get(hdata, &drv_data->clk_muxes, hdata->clk_muxes); 1726 } 1727 1728 1729 static void hdmiphy_clk_enable(struct exynos_drm_clk *clk, bool enable) 1730 { 1731 struct hdmi_context *hdata = container_of(clk, struct hdmi_context, 1732 phy_clk); 1733 mutex_lock(&hdata->mutex); 1734 1735 if (enable) 1736 hdmiphy_enable(hdata); 1737 else 1738 hdmiphy_disable(hdata); 1739 1740 mutex_unlock(&hdata->mutex); 1741 } 1742 1743 static int hdmi_bridge_init(struct hdmi_context *hdata) 1744 { 1745 struct device *dev = hdata->dev; 1746 struct device_node *ep, *np; 1747 1748 ep = of_graph_get_endpoint_by_regs(dev->of_node, 1, -1); 1749 if (!ep) 1750 return 0; 1751 1752 np = of_graph_get_remote_port_parent(ep); 1753 of_node_put(ep); 1754 if (!np) { 1755 DRM_DEV_ERROR(dev, "failed to get remote port parent"); 1756 return -EINVAL; 1757 } 1758 1759 hdata->bridge = of_drm_find_bridge(np); 1760 of_node_put(np); 1761 1762 if (!hdata->bridge) 1763 return -EPROBE_DEFER; 1764 1765 return 0; 1766 } 1767 1768 static int hdmi_resources_init(struct hdmi_context *hdata) 1769 { 1770 struct device *dev = hdata->dev; 1771 int i, ret; 1772 1773 DRM_DEV_DEBUG_KMS(dev, "HDMI resource init\n"); 1774 1775 hdata->hpd_gpio = devm_gpiod_get(dev, "hpd", GPIOD_IN); 1776 if (IS_ERR(hdata->hpd_gpio)) { 1777 DRM_DEV_ERROR(dev, "cannot get hpd gpio property\n"); 1778 return PTR_ERR(hdata->hpd_gpio); 1779 } 1780 1781 hdata->irq = gpiod_to_irq(hdata->hpd_gpio); 1782 if (hdata->irq < 0) { 1783 DRM_DEV_ERROR(dev, "failed to get GPIO irq\n"); 1784 return hdata->irq; 1785 } 1786 1787 ret = hdmi_clk_init(hdata); 1788 if (ret) 1789 return ret; 1790 1791 ret = hdmi_clk_set_parents(hdata, false); 1792 if (ret) 1793 return ret; 1794 1795 for (i = 0; i < ARRAY_SIZE(supply); ++i) 1796 hdata->regul_bulk[i].supply = supply[i]; 1797 1798 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(supply), hdata->regul_bulk); 1799 if (ret) { 1800 if (ret != -EPROBE_DEFER) 1801 DRM_DEV_ERROR(dev, "failed to get regulators\n"); 1802 return ret; 1803 } 1804 1805 hdata->reg_hdmi_en = devm_regulator_get_optional(dev, "hdmi-en"); 1806 1807 if (PTR_ERR(hdata->reg_hdmi_en) != -ENODEV) 1808 if (IS_ERR(hdata->reg_hdmi_en)) 1809 return PTR_ERR(hdata->reg_hdmi_en); 1810 1811 return hdmi_bridge_init(hdata); 1812 } 1813 1814 static const struct of_device_id hdmi_match_types[] = { 1815 { 1816 .compatible = "samsung,exynos4210-hdmi", 1817 .data = &exynos4210_hdmi_driver_data, 1818 }, { 1819 .compatible = "samsung,exynos4212-hdmi", 1820 .data = &exynos4212_hdmi_driver_data, 1821 }, { 1822 .compatible = "samsung,exynos5420-hdmi", 1823 .data = &exynos5420_hdmi_driver_data, 1824 }, { 1825 .compatible = "samsung,exynos5433-hdmi", 1826 .data = &exynos5433_hdmi_driver_data, 1827 }, { 1828 /* end node */ 1829 } 1830 }; 1831 MODULE_DEVICE_TABLE (of, hdmi_match_types); 1832 1833 static int hdmi_bind(struct device *dev, struct device *master, void *data) 1834 { 1835 struct drm_device *drm_dev = data; 1836 struct hdmi_context *hdata = dev_get_drvdata(dev); 1837 struct drm_encoder *encoder = &hdata->encoder; 1838 struct exynos_drm_crtc *crtc; 1839 int ret; 1840 1841 hdata->drm_dev = drm_dev; 1842 1843 hdata->phy_clk.enable = hdmiphy_clk_enable; 1844 1845 drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_TMDS); 1846 1847 drm_encoder_helper_add(encoder, &exynos_hdmi_encoder_helper_funcs); 1848 1849 ret = exynos_drm_set_possible_crtcs(encoder, EXYNOS_DISPLAY_TYPE_HDMI); 1850 if (ret < 0) 1851 return ret; 1852 1853 crtc = exynos_drm_crtc_get_by_type(drm_dev, EXYNOS_DISPLAY_TYPE_HDMI); 1854 crtc->pipe_clk = &hdata->phy_clk; 1855 1856 ret = hdmi_create_connector(encoder); 1857 if (ret) { 1858 DRM_DEV_ERROR(dev, "failed to create connector ret = %d\n", 1859 ret); 1860 drm_encoder_cleanup(encoder); 1861 return ret; 1862 } 1863 1864 return 0; 1865 } 1866 1867 static void hdmi_unbind(struct device *dev, struct device *master, void *data) 1868 { 1869 } 1870 1871 static const struct component_ops hdmi_component_ops = { 1872 .bind = hdmi_bind, 1873 .unbind = hdmi_unbind, 1874 }; 1875 1876 static int hdmi_get_ddc_adapter(struct hdmi_context *hdata) 1877 { 1878 const char *compatible_str = "samsung,exynos4210-hdmiddc"; 1879 struct device_node *np; 1880 struct i2c_adapter *adpt; 1881 1882 np = of_find_compatible_node(NULL, NULL, compatible_str); 1883 if (np) 1884 np = of_get_next_parent(np); 1885 else 1886 np = of_parse_phandle(hdata->dev->of_node, "ddc", 0); 1887 1888 if (!np) { 1889 DRM_DEV_ERROR(hdata->dev, 1890 "Failed to find ddc node in device tree\n"); 1891 return -ENODEV; 1892 } 1893 1894 adpt = of_find_i2c_adapter_by_node(np); 1895 of_node_put(np); 1896 1897 if (!adpt) { 1898 DRM_INFO("Failed to get ddc i2c adapter by node\n"); 1899 return -EPROBE_DEFER; 1900 } 1901 1902 hdata->ddc_adpt = adpt; 1903 1904 return 0; 1905 } 1906 1907 static int hdmi_get_phy_io(struct hdmi_context *hdata) 1908 { 1909 const char *compatible_str = "samsung,exynos4212-hdmiphy"; 1910 struct device_node *np; 1911 int ret = 0; 1912 1913 np = of_find_compatible_node(NULL, NULL, compatible_str); 1914 if (!np) { 1915 np = of_parse_phandle(hdata->dev->of_node, "phy", 0); 1916 if (!np) { 1917 DRM_DEV_ERROR(hdata->dev, 1918 "Failed to find hdmiphy node in device tree\n"); 1919 return -ENODEV; 1920 } 1921 } 1922 1923 if (hdata->drv_data->is_apb_phy) { 1924 hdata->regs_hdmiphy = of_iomap(np, 0); 1925 if (!hdata->regs_hdmiphy) { 1926 DRM_DEV_ERROR(hdata->dev, 1927 "failed to ioremap hdmi phy\n"); 1928 ret = -ENOMEM; 1929 goto out; 1930 } 1931 } else { 1932 hdata->hdmiphy_port = of_find_i2c_device_by_node(np); 1933 if (!hdata->hdmiphy_port) { 1934 DRM_INFO("Failed to get hdmi phy i2c client\n"); 1935 ret = -EPROBE_DEFER; 1936 goto out; 1937 } 1938 } 1939 1940 out: 1941 of_node_put(np); 1942 return ret; 1943 } 1944 1945 static int hdmi_probe(struct platform_device *pdev) 1946 { 1947 struct hdmi_audio_infoframe *audio_infoframe; 1948 struct device *dev = &pdev->dev; 1949 struct hdmi_context *hdata; 1950 struct resource *res; 1951 int ret; 1952 1953 hdata = devm_kzalloc(dev, sizeof(struct hdmi_context), GFP_KERNEL); 1954 if (!hdata) 1955 return -ENOMEM; 1956 1957 hdata->drv_data = of_device_get_match_data(dev); 1958 1959 platform_set_drvdata(pdev, hdata); 1960 1961 hdata->dev = dev; 1962 1963 mutex_init(&hdata->mutex); 1964 1965 ret = hdmi_resources_init(hdata); 1966 if (ret) { 1967 if (ret != -EPROBE_DEFER) 1968 DRM_DEV_ERROR(dev, "hdmi_resources_init failed\n"); 1969 return ret; 1970 } 1971 1972 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1973 hdata->regs = devm_ioremap_resource(dev, res); 1974 if (IS_ERR(hdata->regs)) { 1975 ret = PTR_ERR(hdata->regs); 1976 return ret; 1977 } 1978 1979 ret = hdmi_get_ddc_adapter(hdata); 1980 if (ret) 1981 return ret; 1982 1983 ret = hdmi_get_phy_io(hdata); 1984 if (ret) 1985 goto err_ddc; 1986 1987 INIT_DELAYED_WORK(&hdata->hotplug_work, hdmi_hotplug_work_func); 1988 1989 ret = devm_request_threaded_irq(dev, hdata->irq, NULL, 1990 hdmi_irq_thread, IRQF_TRIGGER_RISING | 1991 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 1992 "hdmi", hdata); 1993 if (ret) { 1994 DRM_DEV_ERROR(dev, "failed to register hdmi interrupt\n"); 1995 goto err_hdmiphy; 1996 } 1997 1998 hdata->pmureg = syscon_regmap_lookup_by_phandle(dev->of_node, 1999 "samsung,syscon-phandle"); 2000 if (IS_ERR(hdata->pmureg)) { 2001 DRM_DEV_ERROR(dev, "syscon regmap lookup failed.\n"); 2002 ret = -EPROBE_DEFER; 2003 goto err_hdmiphy; 2004 } 2005 2006 if (hdata->drv_data->has_sysreg) { 2007 hdata->sysreg = syscon_regmap_lookup_by_phandle(dev->of_node, 2008 "samsung,sysreg-phandle"); 2009 if (IS_ERR(hdata->sysreg)) { 2010 DRM_DEV_ERROR(dev, "sysreg regmap lookup failed.\n"); 2011 ret = -EPROBE_DEFER; 2012 goto err_hdmiphy; 2013 } 2014 } 2015 2016 if (!IS_ERR(hdata->reg_hdmi_en)) { 2017 ret = regulator_enable(hdata->reg_hdmi_en); 2018 if (ret) { 2019 DRM_DEV_ERROR(dev, 2020 "failed to enable hdmi-en regulator\n"); 2021 goto err_hdmiphy; 2022 } 2023 } 2024 2025 pm_runtime_enable(dev); 2026 2027 audio_infoframe = &hdata->audio.infoframe; 2028 hdmi_audio_infoframe_init(audio_infoframe); 2029 audio_infoframe->coding_type = HDMI_AUDIO_CODING_TYPE_STREAM; 2030 audio_infoframe->sample_size = HDMI_AUDIO_SAMPLE_SIZE_STREAM; 2031 audio_infoframe->sample_frequency = HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM; 2032 audio_infoframe->channels = 2; 2033 2034 ret = hdmi_register_audio_device(hdata); 2035 if (ret) 2036 goto err_rpm_disable; 2037 2038 ret = component_add(&pdev->dev, &hdmi_component_ops); 2039 if (ret) 2040 goto err_unregister_audio; 2041 2042 return ret; 2043 2044 err_unregister_audio: 2045 platform_device_unregister(hdata->audio.pdev); 2046 2047 err_rpm_disable: 2048 pm_runtime_disable(dev); 2049 if (!IS_ERR(hdata->reg_hdmi_en)) 2050 regulator_disable(hdata->reg_hdmi_en); 2051 err_hdmiphy: 2052 if (hdata->hdmiphy_port) 2053 put_device(&hdata->hdmiphy_port->dev); 2054 if (hdata->regs_hdmiphy) 2055 iounmap(hdata->regs_hdmiphy); 2056 err_ddc: 2057 put_device(&hdata->ddc_adpt->dev); 2058 2059 return ret; 2060 } 2061 2062 static int hdmi_remove(struct platform_device *pdev) 2063 { 2064 struct hdmi_context *hdata = platform_get_drvdata(pdev); 2065 2066 cancel_delayed_work_sync(&hdata->hotplug_work); 2067 2068 component_del(&pdev->dev, &hdmi_component_ops); 2069 platform_device_unregister(hdata->audio.pdev); 2070 2071 pm_runtime_disable(&pdev->dev); 2072 2073 if (!IS_ERR(hdata->reg_hdmi_en)) 2074 regulator_disable(hdata->reg_hdmi_en); 2075 2076 if (hdata->hdmiphy_port) 2077 put_device(&hdata->hdmiphy_port->dev); 2078 2079 if (hdata->regs_hdmiphy) 2080 iounmap(hdata->regs_hdmiphy); 2081 2082 put_device(&hdata->ddc_adpt->dev); 2083 2084 mutex_destroy(&hdata->mutex); 2085 2086 return 0; 2087 } 2088 2089 static int __maybe_unused exynos_hdmi_suspend(struct device *dev) 2090 { 2091 struct hdmi_context *hdata = dev_get_drvdata(dev); 2092 2093 hdmi_clk_disable_gates(hdata); 2094 2095 return 0; 2096 } 2097 2098 static int __maybe_unused exynos_hdmi_resume(struct device *dev) 2099 { 2100 struct hdmi_context *hdata = dev_get_drvdata(dev); 2101 int ret; 2102 2103 ret = hdmi_clk_enable_gates(hdata); 2104 if (ret < 0) 2105 return ret; 2106 2107 return 0; 2108 } 2109 2110 static const struct dev_pm_ops exynos_hdmi_pm_ops = { 2111 SET_RUNTIME_PM_OPS(exynos_hdmi_suspend, exynos_hdmi_resume, NULL) 2112 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 2113 pm_runtime_force_resume) 2114 }; 2115 2116 struct platform_driver hdmi_driver = { 2117 .probe = hdmi_probe, 2118 .remove = hdmi_remove, 2119 .driver = { 2120 .name = "exynos-hdmi", 2121 .owner = THIS_MODULE, 2122 .pm = &exynos_hdmi_pm_ops, 2123 .of_match_table = hdmi_match_types, 2124 }, 2125 }; 2126