1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Analog Devices ADV7511 HDMI Transmitter Device Driver 4 * 5 * Copyright 2013 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 6 */ 7 8 /* 9 * This file is named adv7511-v4l2.c so it doesn't conflict with the Analog 10 * Device ADV7511 (config fragment CONFIG_DRM_I2C_ADV7511). 11 */ 12 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 #include <linux/i2c.h> 18 #include <linux/delay.h> 19 #include <linux/videodev2.h> 20 #include <linux/gpio.h> 21 #include <linux/workqueue.h> 22 #include <linux/hdmi.h> 23 #include <linux/v4l2-dv-timings.h> 24 #include <media/v4l2-device.h> 25 #include <media/v4l2-common.h> 26 #include <media/v4l2-ctrls.h> 27 #include <media/v4l2-dv-timings.h> 28 #include <media/i2c/adv7511.h> 29 #include <media/cec.h> 30 31 static int debug; 32 module_param(debug, int, 0644); 33 MODULE_PARM_DESC(debug, "debug level (0-2)"); 34 35 MODULE_DESCRIPTION("Analog Devices ADV7511 HDMI Transmitter Device Driver"); 36 MODULE_AUTHOR("Hans Verkuil"); 37 MODULE_LICENSE("GPL v2"); 38 39 #define MASK_ADV7511_EDID_RDY_INT 0x04 40 #define MASK_ADV7511_MSEN_INT 0x40 41 #define MASK_ADV7511_HPD_INT 0x80 42 43 #define MASK_ADV7511_HPD_DETECT 0x40 44 #define MASK_ADV7511_MSEN_DETECT 0x20 45 #define MASK_ADV7511_EDID_RDY 0x10 46 47 #define EDID_MAX_RETRIES (8) 48 #define EDID_DELAY 250 49 #define EDID_MAX_SEGM 8 50 51 #define ADV7511_MAX_WIDTH 1920 52 #define ADV7511_MAX_HEIGHT 1200 53 #define ADV7511_MIN_PIXELCLOCK 20000000 54 #define ADV7511_MAX_PIXELCLOCK 225000000 55 56 #define ADV7511_MAX_ADDRS (3) 57 58 /* 59 ********************************************************************** 60 * 61 * Arrays with configuration parameters for the ADV7511 62 * 63 ********************************************************************** 64 */ 65 66 struct i2c_reg_value { 67 unsigned char reg; 68 unsigned char value; 69 }; 70 71 struct adv7511_state_edid { 72 /* total number of blocks */ 73 u32 blocks; 74 /* Number of segments read */ 75 u32 segments; 76 u8 data[EDID_MAX_SEGM * 256]; 77 /* Number of EDID read retries left */ 78 unsigned read_retries; 79 bool complete; 80 }; 81 82 struct adv7511_state { 83 struct adv7511_platform_data pdata; 84 struct v4l2_subdev sd; 85 struct media_pad pad; 86 struct v4l2_ctrl_handler hdl; 87 int chip_revision; 88 u8 i2c_edid_addr; 89 u8 i2c_pktmem_addr; 90 u8 i2c_cec_addr; 91 92 struct i2c_client *i2c_cec; 93 struct cec_adapter *cec_adap; 94 u8 cec_addr[ADV7511_MAX_ADDRS]; 95 u8 cec_valid_addrs; 96 bool cec_enabled_adap; 97 98 /* Is the adv7511 powered on? */ 99 bool power_on; 100 /* Did we receive hotplug and rx-sense signals? */ 101 bool have_monitor; 102 bool enabled_irq; 103 /* timings from s_dv_timings */ 104 struct v4l2_dv_timings dv_timings; 105 u32 fmt_code; 106 u32 colorspace; 107 u32 ycbcr_enc; 108 u32 quantization; 109 u32 xfer_func; 110 u32 content_type; 111 /* controls */ 112 struct v4l2_ctrl *hdmi_mode_ctrl; 113 struct v4l2_ctrl *hotplug_ctrl; 114 struct v4l2_ctrl *rx_sense_ctrl; 115 struct v4l2_ctrl *have_edid0_ctrl; 116 struct v4l2_ctrl *rgb_quantization_range_ctrl; 117 struct v4l2_ctrl *content_type_ctrl; 118 struct i2c_client *i2c_edid; 119 struct i2c_client *i2c_pktmem; 120 struct adv7511_state_edid edid; 121 /* Running counter of the number of detected EDIDs (for debugging) */ 122 unsigned edid_detect_counter; 123 struct workqueue_struct *work_queue; 124 struct delayed_work edid_handler; /* work entry */ 125 }; 126 127 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd); 128 static bool adv7511_check_edid_status(struct v4l2_subdev *sd); 129 static void adv7511_setup(struct v4l2_subdev *sd); 130 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq); 131 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq); 132 133 134 static const struct v4l2_dv_timings_cap adv7511_timings_cap = { 135 .type = V4L2_DV_BT_656_1120, 136 /* keep this initialization for compatibility with GCC < 4.4.6 */ 137 .reserved = { 0 }, 138 V4L2_INIT_BT_TIMINGS(640, ADV7511_MAX_WIDTH, 350, ADV7511_MAX_HEIGHT, 139 ADV7511_MIN_PIXELCLOCK, ADV7511_MAX_PIXELCLOCK, 140 V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT | 141 V4L2_DV_BT_STD_GTF | V4L2_DV_BT_STD_CVT, 142 V4L2_DV_BT_CAP_PROGRESSIVE | V4L2_DV_BT_CAP_REDUCED_BLANKING | 143 V4L2_DV_BT_CAP_CUSTOM) 144 }; 145 146 static inline struct adv7511_state *get_adv7511_state(struct v4l2_subdev *sd) 147 { 148 return container_of(sd, struct adv7511_state, sd); 149 } 150 151 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl) 152 { 153 return &container_of(ctrl->handler, struct adv7511_state, hdl)->sd; 154 } 155 156 /* ------------------------ I2C ----------------------------------------------- */ 157 158 static s32 adv_smbus_read_byte_data_check(struct i2c_client *client, 159 u8 command, bool check) 160 { 161 union i2c_smbus_data data; 162 163 if (!i2c_smbus_xfer(client->adapter, client->addr, client->flags, 164 I2C_SMBUS_READ, command, 165 I2C_SMBUS_BYTE_DATA, &data)) 166 return data.byte; 167 if (check) 168 v4l_err(client, "error reading %02x, %02x\n", 169 client->addr, command); 170 return -1; 171 } 172 173 static s32 adv_smbus_read_byte_data(struct i2c_client *client, u8 command) 174 { 175 int i; 176 for (i = 0; i < 3; i++) { 177 int ret = adv_smbus_read_byte_data_check(client, command, true); 178 if (ret >= 0) { 179 if (i) 180 v4l_err(client, "read ok after %d retries\n", i); 181 return ret; 182 } 183 } 184 v4l_err(client, "read failed\n"); 185 return -1; 186 } 187 188 static int adv7511_rd(struct v4l2_subdev *sd, u8 reg) 189 { 190 struct i2c_client *client = v4l2_get_subdevdata(sd); 191 192 return adv_smbus_read_byte_data(client, reg); 193 } 194 195 static int adv7511_wr(struct v4l2_subdev *sd, u8 reg, u8 val) 196 { 197 struct i2c_client *client = v4l2_get_subdevdata(sd); 198 int ret; 199 int i; 200 201 for (i = 0; i < 3; i++) { 202 ret = i2c_smbus_write_byte_data(client, reg, val); 203 if (ret == 0) 204 return 0; 205 } 206 v4l2_err(sd, "%s: i2c write error\n", __func__); 207 return ret; 208 } 209 210 /* To set specific bits in the register, a clear-mask is given (to be AND-ed), 211 and then the value-mask (to be OR-ed). */ 212 static inline void adv7511_wr_and_or(struct v4l2_subdev *sd, u8 reg, u8 clr_mask, u8 val_mask) 213 { 214 adv7511_wr(sd, reg, (adv7511_rd(sd, reg) & clr_mask) | val_mask); 215 } 216 217 static int adv_smbus_read_i2c_block_data(struct i2c_client *client, 218 u8 command, unsigned length, u8 *values) 219 { 220 union i2c_smbus_data data; 221 int ret; 222 223 if (length > I2C_SMBUS_BLOCK_MAX) 224 length = I2C_SMBUS_BLOCK_MAX; 225 data.block[0] = length; 226 227 ret = i2c_smbus_xfer(client->adapter, client->addr, client->flags, 228 I2C_SMBUS_READ, command, 229 I2C_SMBUS_I2C_BLOCK_DATA, &data); 230 memcpy(values, data.block + 1, length); 231 return ret; 232 } 233 234 static void adv7511_edid_rd(struct v4l2_subdev *sd, uint16_t len, uint8_t *buf) 235 { 236 struct adv7511_state *state = get_adv7511_state(sd); 237 int i; 238 int err = 0; 239 240 v4l2_dbg(1, debug, sd, "%s:\n", __func__); 241 242 for (i = 0; !err && i < len; i += I2C_SMBUS_BLOCK_MAX) 243 err = adv_smbus_read_i2c_block_data(state->i2c_edid, i, 244 I2C_SMBUS_BLOCK_MAX, buf + i); 245 if (err) 246 v4l2_err(sd, "%s: i2c read error\n", __func__); 247 } 248 249 static inline int adv7511_cec_read(struct v4l2_subdev *sd, u8 reg) 250 { 251 struct adv7511_state *state = get_adv7511_state(sd); 252 253 return i2c_smbus_read_byte_data(state->i2c_cec, reg); 254 } 255 256 static int adv7511_cec_write(struct v4l2_subdev *sd, u8 reg, u8 val) 257 { 258 struct adv7511_state *state = get_adv7511_state(sd); 259 int ret; 260 int i; 261 262 for (i = 0; i < 3; i++) { 263 ret = i2c_smbus_write_byte_data(state->i2c_cec, reg, val); 264 if (ret == 0) 265 return 0; 266 } 267 v4l2_err(sd, "%s: I2C Write Problem\n", __func__); 268 return ret; 269 } 270 271 static inline int adv7511_cec_write_and_or(struct v4l2_subdev *sd, u8 reg, u8 mask, 272 u8 val) 273 { 274 return adv7511_cec_write(sd, reg, (adv7511_cec_read(sd, reg) & mask) | val); 275 } 276 277 static int adv7511_pktmem_rd(struct v4l2_subdev *sd, u8 reg) 278 { 279 struct adv7511_state *state = get_adv7511_state(sd); 280 281 return adv_smbus_read_byte_data(state->i2c_pktmem, reg); 282 } 283 284 static int adv7511_pktmem_wr(struct v4l2_subdev *sd, u8 reg, u8 val) 285 { 286 struct adv7511_state *state = get_adv7511_state(sd); 287 int ret; 288 int i; 289 290 for (i = 0; i < 3; i++) { 291 ret = i2c_smbus_write_byte_data(state->i2c_pktmem, reg, val); 292 if (ret == 0) 293 return 0; 294 } 295 v4l2_err(sd, "%s: i2c write error\n", __func__); 296 return ret; 297 } 298 299 /* To set specific bits in the register, a clear-mask is given (to be AND-ed), 300 and then the value-mask (to be OR-ed). */ 301 static inline void adv7511_pktmem_wr_and_or(struct v4l2_subdev *sd, u8 reg, u8 clr_mask, u8 val_mask) 302 { 303 adv7511_pktmem_wr(sd, reg, (adv7511_pktmem_rd(sd, reg) & clr_mask) | val_mask); 304 } 305 306 static inline bool adv7511_have_hotplug(struct v4l2_subdev *sd) 307 { 308 return adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT; 309 } 310 311 static inline bool adv7511_have_rx_sense(struct v4l2_subdev *sd) 312 { 313 return adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT; 314 } 315 316 static void adv7511_csc_conversion_mode(struct v4l2_subdev *sd, u8 mode) 317 { 318 adv7511_wr_and_or(sd, 0x18, 0x9f, (mode & 0x3)<<5); 319 } 320 321 static void adv7511_csc_coeff(struct v4l2_subdev *sd, 322 u16 A1, u16 A2, u16 A3, u16 A4, 323 u16 B1, u16 B2, u16 B3, u16 B4, 324 u16 C1, u16 C2, u16 C3, u16 C4) 325 { 326 /* A */ 327 adv7511_wr_and_or(sd, 0x18, 0xe0, A1>>8); 328 adv7511_wr(sd, 0x19, A1); 329 adv7511_wr_and_or(sd, 0x1A, 0xe0, A2>>8); 330 adv7511_wr(sd, 0x1B, A2); 331 adv7511_wr_and_or(sd, 0x1c, 0xe0, A3>>8); 332 adv7511_wr(sd, 0x1d, A3); 333 adv7511_wr_and_or(sd, 0x1e, 0xe0, A4>>8); 334 adv7511_wr(sd, 0x1f, A4); 335 336 /* B */ 337 adv7511_wr_and_or(sd, 0x20, 0xe0, B1>>8); 338 adv7511_wr(sd, 0x21, B1); 339 adv7511_wr_and_or(sd, 0x22, 0xe0, B2>>8); 340 adv7511_wr(sd, 0x23, B2); 341 adv7511_wr_and_or(sd, 0x24, 0xe0, B3>>8); 342 adv7511_wr(sd, 0x25, B3); 343 adv7511_wr_and_or(sd, 0x26, 0xe0, B4>>8); 344 adv7511_wr(sd, 0x27, B4); 345 346 /* C */ 347 adv7511_wr_and_or(sd, 0x28, 0xe0, C1>>8); 348 adv7511_wr(sd, 0x29, C1); 349 adv7511_wr_and_or(sd, 0x2A, 0xe0, C2>>8); 350 adv7511_wr(sd, 0x2B, C2); 351 adv7511_wr_and_or(sd, 0x2C, 0xe0, C3>>8); 352 adv7511_wr(sd, 0x2D, C3); 353 adv7511_wr_and_or(sd, 0x2E, 0xe0, C4>>8); 354 adv7511_wr(sd, 0x2F, C4); 355 } 356 357 static void adv7511_csc_rgb_full2limit(struct v4l2_subdev *sd, bool enable) 358 { 359 if (enable) { 360 u8 csc_mode = 0; 361 adv7511_csc_conversion_mode(sd, csc_mode); 362 adv7511_csc_coeff(sd, 363 4096-564, 0, 0, 256, 364 0, 4096-564, 0, 256, 365 0, 0, 4096-564, 256); 366 /* enable CSC */ 367 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x80); 368 /* AVI infoframe: Limited range RGB (16-235) */ 369 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x04); 370 } else { 371 /* disable CSC */ 372 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0); 373 /* AVI infoframe: Full range RGB (0-255) */ 374 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x08); 375 } 376 } 377 378 static void adv7511_set_rgb_quantization_mode(struct v4l2_subdev *sd, struct v4l2_ctrl *ctrl) 379 { 380 struct adv7511_state *state = get_adv7511_state(sd); 381 382 /* Only makes sense for RGB formats */ 383 if (state->fmt_code != MEDIA_BUS_FMT_RGB888_1X24) { 384 /* so just keep quantization */ 385 adv7511_csc_rgb_full2limit(sd, false); 386 return; 387 } 388 389 switch (ctrl->val) { 390 case V4L2_DV_RGB_RANGE_AUTO: 391 /* automatic */ 392 if (state->dv_timings.bt.flags & V4L2_DV_FL_IS_CE_VIDEO) { 393 /* CE format, RGB limited range (16-235) */ 394 adv7511_csc_rgb_full2limit(sd, true); 395 } else { 396 /* not CE format, RGB full range (0-255) */ 397 adv7511_csc_rgb_full2limit(sd, false); 398 } 399 break; 400 case V4L2_DV_RGB_RANGE_LIMITED: 401 /* RGB limited range (16-235) */ 402 adv7511_csc_rgb_full2limit(sd, true); 403 break; 404 case V4L2_DV_RGB_RANGE_FULL: 405 /* RGB full range (0-255) */ 406 adv7511_csc_rgb_full2limit(sd, false); 407 break; 408 } 409 } 410 411 /* ------------------------------ CTRL OPS ------------------------------ */ 412 413 static int adv7511_s_ctrl(struct v4l2_ctrl *ctrl) 414 { 415 struct v4l2_subdev *sd = to_sd(ctrl); 416 struct adv7511_state *state = get_adv7511_state(sd); 417 418 v4l2_dbg(1, debug, sd, "%s: ctrl id: %d, ctrl->val %d\n", __func__, ctrl->id, ctrl->val); 419 420 if (state->hdmi_mode_ctrl == ctrl) { 421 /* Set HDMI or DVI-D */ 422 adv7511_wr_and_or(sd, 0xaf, 0xfd, ctrl->val == V4L2_DV_TX_MODE_HDMI ? 0x02 : 0x00); 423 return 0; 424 } 425 if (state->rgb_quantization_range_ctrl == ctrl) { 426 adv7511_set_rgb_quantization_mode(sd, ctrl); 427 return 0; 428 } 429 if (state->content_type_ctrl == ctrl) { 430 u8 itc, cn; 431 432 state->content_type = ctrl->val; 433 itc = state->content_type != V4L2_DV_IT_CONTENT_TYPE_NO_ITC; 434 cn = itc ? state->content_type : V4L2_DV_IT_CONTENT_TYPE_GRAPHICS; 435 adv7511_wr_and_or(sd, 0x57, 0x7f, itc << 7); 436 adv7511_wr_and_or(sd, 0x59, 0xcf, cn << 4); 437 return 0; 438 } 439 440 return -EINVAL; 441 } 442 443 static const struct v4l2_ctrl_ops adv7511_ctrl_ops = { 444 .s_ctrl = adv7511_s_ctrl, 445 }; 446 447 /* ---------------------------- CORE OPS ------------------------------------------- */ 448 449 #ifdef CONFIG_VIDEO_ADV_DEBUG 450 static void adv7511_inv_register(struct v4l2_subdev *sd) 451 { 452 struct adv7511_state *state = get_adv7511_state(sd); 453 454 v4l2_info(sd, "0x000-0x0ff: Main Map\n"); 455 if (state->i2c_cec) 456 v4l2_info(sd, "0x100-0x1ff: CEC Map\n"); 457 } 458 459 static int adv7511_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg) 460 { 461 struct adv7511_state *state = get_adv7511_state(sd); 462 463 reg->size = 1; 464 switch (reg->reg >> 8) { 465 case 0: 466 reg->val = adv7511_rd(sd, reg->reg & 0xff); 467 break; 468 case 1: 469 if (state->i2c_cec) { 470 reg->val = adv7511_cec_read(sd, reg->reg & 0xff); 471 break; 472 } 473 fallthrough; 474 default: 475 v4l2_info(sd, "Register %03llx not supported\n", reg->reg); 476 adv7511_inv_register(sd); 477 break; 478 } 479 return 0; 480 } 481 482 static int adv7511_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg) 483 { 484 struct adv7511_state *state = get_adv7511_state(sd); 485 486 switch (reg->reg >> 8) { 487 case 0: 488 adv7511_wr(sd, reg->reg & 0xff, reg->val & 0xff); 489 break; 490 case 1: 491 if (state->i2c_cec) { 492 adv7511_cec_write(sd, reg->reg & 0xff, reg->val & 0xff); 493 break; 494 } 495 fallthrough; 496 default: 497 v4l2_info(sd, "Register %03llx not supported\n", reg->reg); 498 adv7511_inv_register(sd); 499 break; 500 } 501 return 0; 502 } 503 #endif 504 505 struct adv7511_cfg_read_infoframe { 506 const char *desc; 507 u8 present_reg; 508 u8 present_mask; 509 u8 header[3]; 510 u16 payload_addr; 511 }; 512 513 static u8 hdmi_infoframe_checksum(u8 *ptr, size_t size) 514 { 515 u8 csum = 0; 516 size_t i; 517 518 /* compute checksum */ 519 for (i = 0; i < size; i++) 520 csum += ptr[i]; 521 522 return 256 - csum; 523 } 524 525 static void log_infoframe(struct v4l2_subdev *sd, const struct adv7511_cfg_read_infoframe *cri) 526 { 527 struct i2c_client *client = v4l2_get_subdevdata(sd); 528 struct device *dev = &client->dev; 529 union hdmi_infoframe frame; 530 u8 buffer[32]; 531 u8 len; 532 int i; 533 534 if (!(adv7511_rd(sd, cri->present_reg) & cri->present_mask)) { 535 v4l2_info(sd, "%s infoframe not transmitted\n", cri->desc); 536 return; 537 } 538 539 memcpy(buffer, cri->header, sizeof(cri->header)); 540 541 len = buffer[2]; 542 543 if (len + 4 > sizeof(buffer)) { 544 v4l2_err(sd, "%s: invalid %s infoframe length %d\n", __func__, cri->desc, len); 545 return; 546 } 547 548 if (cri->payload_addr >= 0x100) { 549 for (i = 0; i < len; i++) 550 buffer[i + 4] = adv7511_pktmem_rd(sd, cri->payload_addr + i - 0x100); 551 } else { 552 for (i = 0; i < len; i++) 553 buffer[i + 4] = adv7511_rd(sd, cri->payload_addr + i); 554 } 555 buffer[3] = 0; 556 buffer[3] = hdmi_infoframe_checksum(buffer, len + 4); 557 558 if (hdmi_infoframe_unpack(&frame, buffer, sizeof(buffer)) < 0) { 559 v4l2_err(sd, "%s: unpack of %s infoframe failed\n", __func__, cri->desc); 560 return; 561 } 562 563 hdmi_infoframe_log(KERN_INFO, dev, &frame); 564 } 565 566 static void adv7511_log_infoframes(struct v4l2_subdev *sd) 567 { 568 static const struct adv7511_cfg_read_infoframe cri[] = { 569 { "AVI", 0x44, 0x10, { 0x82, 2, 13 }, 0x55 }, 570 { "Audio", 0x44, 0x08, { 0x84, 1, 10 }, 0x73 }, 571 { "SDP", 0x40, 0x40, { 0x83, 1, 25 }, 0x103 }, 572 }; 573 int i; 574 575 for (i = 0; i < ARRAY_SIZE(cri); i++) 576 log_infoframe(sd, &cri[i]); 577 } 578 579 static int adv7511_log_status(struct v4l2_subdev *sd) 580 { 581 struct adv7511_state *state = get_adv7511_state(sd); 582 struct adv7511_state_edid *edid = &state->edid; 583 int i; 584 585 static const char * const states[] = { 586 "in reset", 587 "reading EDID", 588 "idle", 589 "initializing HDCP", 590 "HDCP enabled", 591 "initializing HDCP repeater", 592 "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" 593 }; 594 static const char * const errors[] = { 595 "no error", 596 "bad receiver BKSV", 597 "Ri mismatch", 598 "Pj mismatch", 599 "i2c error", 600 "timed out", 601 "max repeater cascade exceeded", 602 "hash check failed", 603 "too many devices", 604 "9", "A", "B", "C", "D", "E", "F" 605 }; 606 607 v4l2_info(sd, "power %s\n", state->power_on ? "on" : "off"); 608 v4l2_info(sd, "%s hotplug, %s Rx Sense, %s EDID (%d block(s))\n", 609 (adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT) ? "detected" : "no", 610 (adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT) ? "detected" : "no", 611 edid->segments ? "found" : "no", 612 edid->blocks); 613 v4l2_info(sd, "%s output %s\n", 614 (adv7511_rd(sd, 0xaf) & 0x02) ? 615 "HDMI" : "DVI-D", 616 (adv7511_rd(sd, 0xa1) & 0x3c) ? 617 "disabled" : "enabled"); 618 v4l2_info(sd, "state: %s, error: %s, detect count: %u, msk/irq: %02x/%02x\n", 619 states[adv7511_rd(sd, 0xc8) & 0xf], 620 errors[adv7511_rd(sd, 0xc8) >> 4], state->edid_detect_counter, 621 adv7511_rd(sd, 0x94), adv7511_rd(sd, 0x96)); 622 v4l2_info(sd, "RGB quantization: %s range\n", adv7511_rd(sd, 0x18) & 0x80 ? "limited" : "full"); 623 if (adv7511_rd(sd, 0xaf) & 0x02) { 624 /* HDMI only */ 625 u8 manual_cts = adv7511_rd(sd, 0x0a) & 0x80; 626 u32 N = (adv7511_rd(sd, 0x01) & 0xf) << 16 | 627 adv7511_rd(sd, 0x02) << 8 | 628 adv7511_rd(sd, 0x03); 629 u8 vic_detect = adv7511_rd(sd, 0x3e) >> 2; 630 u8 vic_sent = adv7511_rd(sd, 0x3d) & 0x3f; 631 u32 CTS; 632 633 if (manual_cts) 634 CTS = (adv7511_rd(sd, 0x07) & 0xf) << 16 | 635 adv7511_rd(sd, 0x08) << 8 | 636 adv7511_rd(sd, 0x09); 637 else 638 CTS = (adv7511_rd(sd, 0x04) & 0xf) << 16 | 639 adv7511_rd(sd, 0x05) << 8 | 640 adv7511_rd(sd, 0x06); 641 v4l2_info(sd, "CTS %s mode: N %d, CTS %d\n", 642 manual_cts ? "manual" : "automatic", N, CTS); 643 v4l2_info(sd, "VIC: detected %d, sent %d\n", 644 vic_detect, vic_sent); 645 adv7511_log_infoframes(sd); 646 } 647 if (state->dv_timings.type == V4L2_DV_BT_656_1120) 648 v4l2_print_dv_timings(sd->name, "timings: ", 649 &state->dv_timings, false); 650 else 651 v4l2_info(sd, "no timings set\n"); 652 v4l2_info(sd, "i2c edid addr: 0x%x\n", state->i2c_edid_addr); 653 654 if (state->i2c_cec == NULL) 655 return 0; 656 657 v4l2_info(sd, "i2c cec addr: 0x%x\n", state->i2c_cec_addr); 658 659 v4l2_info(sd, "CEC: %s\n", state->cec_enabled_adap ? 660 "enabled" : "disabled"); 661 if (state->cec_enabled_adap) { 662 for (i = 0; i < ADV7511_MAX_ADDRS; i++) { 663 bool is_valid = state->cec_valid_addrs & (1 << i); 664 665 if (is_valid) 666 v4l2_info(sd, "CEC Logical Address: 0x%x\n", 667 state->cec_addr[i]); 668 } 669 } 670 v4l2_info(sd, "i2c pktmem addr: 0x%x\n", state->i2c_pktmem_addr); 671 return 0; 672 } 673 674 /* Power up/down adv7511 */ 675 static int adv7511_s_power(struct v4l2_subdev *sd, int on) 676 { 677 struct adv7511_state *state = get_adv7511_state(sd); 678 const int retries = 20; 679 int i; 680 681 v4l2_dbg(1, debug, sd, "%s: power %s\n", __func__, on ? "on" : "off"); 682 683 state->power_on = on; 684 685 if (!on) { 686 /* Power down */ 687 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40); 688 return true; 689 } 690 691 /* Power up */ 692 /* The adv7511 does not always come up immediately. 693 Retry multiple times. */ 694 for (i = 0; i < retries; i++) { 695 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x0); 696 if ((adv7511_rd(sd, 0x41) & 0x40) == 0) 697 break; 698 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40); 699 msleep(10); 700 } 701 if (i == retries) { 702 v4l2_dbg(1, debug, sd, "%s: failed to powerup the adv7511!\n", __func__); 703 adv7511_s_power(sd, 0); 704 return false; 705 } 706 if (i > 1) 707 v4l2_dbg(1, debug, sd, "%s: needed %d retries to powerup the adv7511\n", __func__, i); 708 709 /* Reserved registers that must be set */ 710 adv7511_wr(sd, 0x98, 0x03); 711 adv7511_wr_and_or(sd, 0x9a, 0xfe, 0x70); 712 adv7511_wr(sd, 0x9c, 0x30); 713 adv7511_wr_and_or(sd, 0x9d, 0xfc, 0x01); 714 adv7511_wr(sd, 0xa2, 0xa4); 715 adv7511_wr(sd, 0xa3, 0xa4); 716 adv7511_wr(sd, 0xe0, 0xd0); 717 adv7511_wr(sd, 0xf9, 0x00); 718 719 adv7511_wr(sd, 0x43, state->i2c_edid_addr); 720 adv7511_wr(sd, 0x45, state->i2c_pktmem_addr); 721 722 /* Set number of attempts to read the EDID */ 723 adv7511_wr(sd, 0xc9, 0xf); 724 return true; 725 } 726 727 #if IS_ENABLED(CONFIG_VIDEO_ADV7511_CEC) 728 static int adv7511_cec_adap_enable(struct cec_adapter *adap, bool enable) 729 { 730 struct adv7511_state *state = cec_get_drvdata(adap); 731 struct v4l2_subdev *sd = &state->sd; 732 733 if (state->i2c_cec == NULL) 734 return -EIO; 735 736 if (!state->cec_enabled_adap && enable) { 737 /* power up cec section */ 738 adv7511_cec_write_and_or(sd, 0x4e, 0xfc, 0x01); 739 /* legacy mode and clear all rx buffers */ 740 adv7511_cec_write(sd, 0x4a, 0x00); 741 adv7511_cec_write(sd, 0x4a, 0x07); 742 adv7511_cec_write_and_or(sd, 0x11, 0xfe, 0); /* initially disable tx */ 743 /* enabled irqs: */ 744 /* tx: ready */ 745 /* tx: arbitration lost */ 746 /* tx: retry timeout */ 747 /* rx: ready 1 */ 748 if (state->enabled_irq) 749 adv7511_wr_and_or(sd, 0x95, 0xc0, 0x39); 750 } else if (state->cec_enabled_adap && !enable) { 751 if (state->enabled_irq) 752 adv7511_wr_and_or(sd, 0x95, 0xc0, 0x00); 753 /* disable address mask 1-3 */ 754 adv7511_cec_write_and_or(sd, 0x4b, 0x8f, 0x00); 755 /* power down cec section */ 756 adv7511_cec_write_and_or(sd, 0x4e, 0xfc, 0x00); 757 state->cec_valid_addrs = 0; 758 } 759 state->cec_enabled_adap = enable; 760 return 0; 761 } 762 763 static int adv7511_cec_adap_log_addr(struct cec_adapter *adap, u8 addr) 764 { 765 struct adv7511_state *state = cec_get_drvdata(adap); 766 struct v4l2_subdev *sd = &state->sd; 767 unsigned int i, free_idx = ADV7511_MAX_ADDRS; 768 769 if (!state->cec_enabled_adap) 770 return addr == CEC_LOG_ADDR_INVALID ? 0 : -EIO; 771 772 if (addr == CEC_LOG_ADDR_INVALID) { 773 adv7511_cec_write_and_or(sd, 0x4b, 0x8f, 0); 774 state->cec_valid_addrs = 0; 775 return 0; 776 } 777 778 for (i = 0; i < ADV7511_MAX_ADDRS; i++) { 779 bool is_valid = state->cec_valid_addrs & (1 << i); 780 781 if (free_idx == ADV7511_MAX_ADDRS && !is_valid) 782 free_idx = i; 783 if (is_valid && state->cec_addr[i] == addr) 784 return 0; 785 } 786 if (i == ADV7511_MAX_ADDRS) { 787 i = free_idx; 788 if (i == ADV7511_MAX_ADDRS) 789 return -ENXIO; 790 } 791 state->cec_addr[i] = addr; 792 state->cec_valid_addrs |= 1 << i; 793 794 switch (i) { 795 case 0: 796 /* enable address mask 0 */ 797 adv7511_cec_write_and_or(sd, 0x4b, 0xef, 0x10); 798 /* set address for mask 0 */ 799 adv7511_cec_write_and_or(sd, 0x4c, 0xf0, addr); 800 break; 801 case 1: 802 /* enable address mask 1 */ 803 adv7511_cec_write_and_or(sd, 0x4b, 0xdf, 0x20); 804 /* set address for mask 1 */ 805 adv7511_cec_write_and_or(sd, 0x4c, 0x0f, addr << 4); 806 break; 807 case 2: 808 /* enable address mask 2 */ 809 adv7511_cec_write_and_or(sd, 0x4b, 0xbf, 0x40); 810 /* set address for mask 1 */ 811 adv7511_cec_write_and_or(sd, 0x4d, 0xf0, addr); 812 break; 813 } 814 return 0; 815 } 816 817 static int adv7511_cec_adap_transmit(struct cec_adapter *adap, u8 attempts, 818 u32 signal_free_time, struct cec_msg *msg) 819 { 820 struct adv7511_state *state = cec_get_drvdata(adap); 821 struct v4l2_subdev *sd = &state->sd; 822 u8 len = msg->len; 823 unsigned int i; 824 825 v4l2_dbg(1, debug, sd, "%s: len %d\n", __func__, len); 826 827 if (len > 16) { 828 v4l2_err(sd, "%s: len exceeded 16 (%d)\n", __func__, len); 829 return -EINVAL; 830 } 831 832 /* 833 * The number of retries is the number of attempts - 1, but retry 834 * at least once. It's not clear if a value of 0 is allowed, so 835 * let's do at least one retry. 836 */ 837 adv7511_cec_write_and_or(sd, 0x12, ~0x70, max(1, attempts - 1) << 4); 838 839 /* clear cec tx irq status */ 840 adv7511_wr(sd, 0x97, 0x38); 841 842 /* write data */ 843 for (i = 0; i < len; i++) 844 adv7511_cec_write(sd, i, msg->msg[i]); 845 846 /* set length (data + header) */ 847 adv7511_cec_write(sd, 0x10, len); 848 /* start transmit, enable tx */ 849 adv7511_cec_write(sd, 0x11, 0x01); 850 return 0; 851 } 852 853 static void adv_cec_tx_raw_status(struct v4l2_subdev *sd, u8 tx_raw_status) 854 { 855 struct adv7511_state *state = get_adv7511_state(sd); 856 857 if ((adv7511_cec_read(sd, 0x11) & 0x01) == 0) { 858 v4l2_dbg(1, debug, sd, "%s: tx raw: tx disabled\n", __func__); 859 return; 860 } 861 862 if (tx_raw_status & 0x10) { 863 v4l2_dbg(1, debug, sd, 864 "%s: tx raw: arbitration lost\n", __func__); 865 cec_transmit_done(state->cec_adap, CEC_TX_STATUS_ARB_LOST, 866 1, 0, 0, 0); 867 return; 868 } 869 if (tx_raw_status & 0x08) { 870 u8 status; 871 u8 nack_cnt; 872 u8 low_drive_cnt; 873 874 v4l2_dbg(1, debug, sd, "%s: tx raw: retry failed\n", __func__); 875 /* 876 * We set this status bit since this hardware performs 877 * retransmissions. 878 */ 879 status = CEC_TX_STATUS_MAX_RETRIES; 880 nack_cnt = adv7511_cec_read(sd, 0x14) & 0xf; 881 if (nack_cnt) 882 status |= CEC_TX_STATUS_NACK; 883 low_drive_cnt = adv7511_cec_read(sd, 0x14) >> 4; 884 if (low_drive_cnt) 885 status |= CEC_TX_STATUS_LOW_DRIVE; 886 cec_transmit_done(state->cec_adap, status, 887 0, nack_cnt, low_drive_cnt, 0); 888 return; 889 } 890 if (tx_raw_status & 0x20) { 891 v4l2_dbg(1, debug, sd, "%s: tx raw: ready ok\n", __func__); 892 cec_transmit_done(state->cec_adap, CEC_TX_STATUS_OK, 0, 0, 0, 0); 893 return; 894 } 895 } 896 897 static const struct cec_adap_ops adv7511_cec_adap_ops = { 898 .adap_enable = adv7511_cec_adap_enable, 899 .adap_log_addr = adv7511_cec_adap_log_addr, 900 .adap_transmit = adv7511_cec_adap_transmit, 901 }; 902 #endif 903 904 /* Enable interrupts */ 905 static void adv7511_set_isr(struct v4l2_subdev *sd, bool enable) 906 { 907 struct adv7511_state *state = get_adv7511_state(sd); 908 u8 irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT; 909 u8 irqs_rd; 910 int retries = 100; 911 912 v4l2_dbg(2, debug, sd, "%s: %s\n", __func__, enable ? "enable" : "disable"); 913 914 if (state->enabled_irq == enable) 915 return; 916 state->enabled_irq = enable; 917 918 /* The datasheet says that the EDID ready interrupt should be 919 disabled if there is no hotplug. */ 920 if (!enable) 921 irqs = 0; 922 else if (adv7511_have_hotplug(sd)) 923 irqs |= MASK_ADV7511_EDID_RDY_INT; 924 925 /* 926 * This i2c write can fail (approx. 1 in 1000 writes). But it 927 * is essential that this register is correct, so retry it 928 * multiple times. 929 * 930 * Note that the i2c write does not report an error, but the readback 931 * clearly shows the wrong value. 932 */ 933 do { 934 adv7511_wr(sd, 0x94, irqs); 935 irqs_rd = adv7511_rd(sd, 0x94); 936 } while (retries-- && irqs_rd != irqs); 937 938 if (irqs_rd != irqs) 939 v4l2_err(sd, "Could not set interrupts: hw failure?\n"); 940 941 adv7511_wr_and_or(sd, 0x95, 0xc0, 942 (state->cec_enabled_adap && enable) ? 0x39 : 0x00); 943 } 944 945 /* Interrupt handler */ 946 static int adv7511_isr(struct v4l2_subdev *sd, u32 status, bool *handled) 947 { 948 u8 irq_status; 949 u8 cec_irq; 950 951 /* disable interrupts to prevent a race condition */ 952 adv7511_set_isr(sd, false); 953 irq_status = adv7511_rd(sd, 0x96); 954 cec_irq = adv7511_rd(sd, 0x97); 955 /* clear detected interrupts */ 956 adv7511_wr(sd, 0x96, irq_status); 957 adv7511_wr(sd, 0x97, cec_irq); 958 959 v4l2_dbg(1, debug, sd, "%s: irq 0x%x, cec-irq 0x%x\n", __func__, 960 irq_status, cec_irq); 961 962 if (irq_status & (MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT)) 963 adv7511_check_monitor_present_status(sd); 964 if (irq_status & MASK_ADV7511_EDID_RDY_INT) 965 adv7511_check_edid_status(sd); 966 967 #if IS_ENABLED(CONFIG_VIDEO_ADV7511_CEC) 968 if (cec_irq & 0x38) 969 adv_cec_tx_raw_status(sd, cec_irq); 970 971 if (cec_irq & 1) { 972 struct adv7511_state *state = get_adv7511_state(sd); 973 struct cec_msg msg; 974 975 msg.len = adv7511_cec_read(sd, 0x25) & 0x1f; 976 977 v4l2_dbg(1, debug, sd, "%s: cec msg len %d\n", __func__, 978 msg.len); 979 980 if (msg.len > 16) 981 msg.len = 16; 982 983 if (msg.len) { 984 u8 i; 985 986 for (i = 0; i < msg.len; i++) 987 msg.msg[i] = adv7511_cec_read(sd, i + 0x15); 988 989 adv7511_cec_write(sd, 0x4a, 0); /* toggle to re-enable rx 1 */ 990 adv7511_cec_write(sd, 0x4a, 1); 991 cec_received_msg(state->cec_adap, &msg); 992 } 993 } 994 #endif 995 996 /* enable interrupts */ 997 adv7511_set_isr(sd, true); 998 999 if (handled) 1000 *handled = true; 1001 return 0; 1002 } 1003 1004 static const struct v4l2_subdev_core_ops adv7511_core_ops = { 1005 .log_status = adv7511_log_status, 1006 #ifdef CONFIG_VIDEO_ADV_DEBUG 1007 .g_register = adv7511_g_register, 1008 .s_register = adv7511_s_register, 1009 #endif 1010 .s_power = adv7511_s_power, 1011 .interrupt_service_routine = adv7511_isr, 1012 }; 1013 1014 /* ------------------------------ VIDEO OPS ------------------------------ */ 1015 1016 /* Enable/disable adv7511 output */ 1017 static int adv7511_s_stream(struct v4l2_subdev *sd, int enable) 1018 { 1019 struct adv7511_state *state = get_adv7511_state(sd); 1020 1021 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis")); 1022 adv7511_wr_and_or(sd, 0xa1, ~0x3c, (enable ? 0 : 0x3c)); 1023 if (enable) { 1024 adv7511_check_monitor_present_status(sd); 1025 } else { 1026 adv7511_s_power(sd, 0); 1027 state->have_monitor = false; 1028 } 1029 return 0; 1030 } 1031 1032 static int adv7511_s_dv_timings(struct v4l2_subdev *sd, 1033 struct v4l2_dv_timings *timings) 1034 { 1035 struct adv7511_state *state = get_adv7511_state(sd); 1036 struct v4l2_bt_timings *bt = &timings->bt; 1037 u32 fps; 1038 1039 v4l2_dbg(1, debug, sd, "%s:\n", __func__); 1040 1041 /* quick sanity check */ 1042 if (!v4l2_valid_dv_timings(timings, &adv7511_timings_cap, NULL, NULL)) 1043 return -EINVAL; 1044 1045 /* Fill the optional fields .standards and .flags in struct v4l2_dv_timings 1046 if the format is one of the CEA or DMT timings. */ 1047 v4l2_find_dv_timings_cap(timings, &adv7511_timings_cap, 0, NULL, NULL); 1048 1049 /* save timings */ 1050 state->dv_timings = *timings; 1051 1052 /* set h/vsync polarities */ 1053 adv7511_wr_and_or(sd, 0x17, 0x9f, 1054 ((bt->polarities & V4L2_DV_VSYNC_POS_POL) ? 0 : 0x40) | 1055 ((bt->polarities & V4L2_DV_HSYNC_POS_POL) ? 0 : 0x20)); 1056 1057 fps = (u32)bt->pixelclock / (V4L2_DV_BT_FRAME_WIDTH(bt) * V4L2_DV_BT_FRAME_HEIGHT(bt)); 1058 switch (fps) { 1059 case 24: 1060 adv7511_wr_and_or(sd, 0xfb, 0xf9, 1 << 1); 1061 break; 1062 case 25: 1063 adv7511_wr_and_or(sd, 0xfb, 0xf9, 2 << 1); 1064 break; 1065 case 30: 1066 adv7511_wr_and_or(sd, 0xfb, 0xf9, 3 << 1); 1067 break; 1068 default: 1069 adv7511_wr_and_or(sd, 0xfb, 0xf9, 0); 1070 break; 1071 } 1072 1073 /* update quantization range based on new dv_timings */ 1074 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl); 1075 1076 return 0; 1077 } 1078 1079 static int adv7511_g_dv_timings(struct v4l2_subdev *sd, 1080 struct v4l2_dv_timings *timings) 1081 { 1082 struct adv7511_state *state = get_adv7511_state(sd); 1083 1084 v4l2_dbg(1, debug, sd, "%s:\n", __func__); 1085 1086 if (!timings) 1087 return -EINVAL; 1088 1089 *timings = state->dv_timings; 1090 1091 return 0; 1092 } 1093 1094 static int adv7511_enum_dv_timings(struct v4l2_subdev *sd, 1095 struct v4l2_enum_dv_timings *timings) 1096 { 1097 if (timings->pad != 0) 1098 return -EINVAL; 1099 1100 return v4l2_enum_dv_timings_cap(timings, &adv7511_timings_cap, NULL, NULL); 1101 } 1102 1103 static int adv7511_dv_timings_cap(struct v4l2_subdev *sd, 1104 struct v4l2_dv_timings_cap *cap) 1105 { 1106 if (cap->pad != 0) 1107 return -EINVAL; 1108 1109 *cap = adv7511_timings_cap; 1110 return 0; 1111 } 1112 1113 static const struct v4l2_subdev_video_ops adv7511_video_ops = { 1114 .s_stream = adv7511_s_stream, 1115 .s_dv_timings = adv7511_s_dv_timings, 1116 .g_dv_timings = adv7511_g_dv_timings, 1117 }; 1118 1119 /* ------------------------------ AUDIO OPS ------------------------------ */ 1120 static int adv7511_s_audio_stream(struct v4l2_subdev *sd, int enable) 1121 { 1122 v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis")); 1123 1124 if (enable) 1125 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x80); 1126 else 1127 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x40); 1128 1129 return 0; 1130 } 1131 1132 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq) 1133 { 1134 u32 N; 1135 1136 switch (freq) { 1137 case 32000: N = 4096; break; 1138 case 44100: N = 6272; break; 1139 case 48000: N = 6144; break; 1140 case 88200: N = 12544; break; 1141 case 96000: N = 12288; break; 1142 case 176400: N = 25088; break; 1143 case 192000: N = 24576; break; 1144 default: 1145 return -EINVAL; 1146 } 1147 1148 /* Set N (used with CTS to regenerate the audio clock) */ 1149 adv7511_wr(sd, 0x01, (N >> 16) & 0xf); 1150 adv7511_wr(sd, 0x02, (N >> 8) & 0xff); 1151 adv7511_wr(sd, 0x03, N & 0xff); 1152 1153 return 0; 1154 } 1155 1156 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq) 1157 { 1158 u32 i2s_sf; 1159 1160 switch (freq) { 1161 case 32000: i2s_sf = 0x30; break; 1162 case 44100: i2s_sf = 0x00; break; 1163 case 48000: i2s_sf = 0x20; break; 1164 case 88200: i2s_sf = 0x80; break; 1165 case 96000: i2s_sf = 0xa0; break; 1166 case 176400: i2s_sf = 0xc0; break; 1167 case 192000: i2s_sf = 0xe0; break; 1168 default: 1169 return -EINVAL; 1170 } 1171 1172 /* Set sampling frequency for I2S audio to 48 kHz */ 1173 adv7511_wr_and_or(sd, 0x15, 0xf, i2s_sf); 1174 1175 return 0; 1176 } 1177 1178 static int adv7511_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, u32 config) 1179 { 1180 /* Only 2 channels in use for application */ 1181 adv7511_wr_and_or(sd, 0x73, 0xf8, 0x1); 1182 /* Speaker mapping */ 1183 adv7511_wr(sd, 0x76, 0x00); 1184 1185 /* 16 bit audio word length */ 1186 adv7511_wr_and_or(sd, 0x14, 0xf0, 0x02); 1187 1188 return 0; 1189 } 1190 1191 static const struct v4l2_subdev_audio_ops adv7511_audio_ops = { 1192 .s_stream = adv7511_s_audio_stream, 1193 .s_clock_freq = adv7511_s_clock_freq, 1194 .s_i2s_clock_freq = adv7511_s_i2s_clock_freq, 1195 .s_routing = adv7511_s_routing, 1196 }; 1197 1198 /* ---------------------------- PAD OPS ------------------------------------- */ 1199 1200 static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_edid *edid) 1201 { 1202 struct adv7511_state *state = get_adv7511_state(sd); 1203 1204 memset(edid->reserved, 0, sizeof(edid->reserved)); 1205 1206 if (edid->pad != 0) 1207 return -EINVAL; 1208 1209 if (edid->start_block == 0 && edid->blocks == 0) { 1210 edid->blocks = state->edid.segments * 2; 1211 return 0; 1212 } 1213 1214 if (state->edid.segments == 0) 1215 return -ENODATA; 1216 1217 if (edid->start_block >= state->edid.segments * 2) 1218 return -EINVAL; 1219 1220 if (edid->start_block + edid->blocks > state->edid.segments * 2) 1221 edid->blocks = state->edid.segments * 2 - edid->start_block; 1222 1223 memcpy(edid->edid, &state->edid.data[edid->start_block * 128], 1224 128 * edid->blocks); 1225 1226 return 0; 1227 } 1228 1229 static int adv7511_enum_mbus_code(struct v4l2_subdev *sd, 1230 struct v4l2_subdev_pad_config *cfg, 1231 struct v4l2_subdev_mbus_code_enum *code) 1232 { 1233 if (code->pad != 0) 1234 return -EINVAL; 1235 1236 switch (code->index) { 1237 case 0: 1238 code->code = MEDIA_BUS_FMT_RGB888_1X24; 1239 break; 1240 case 1: 1241 code->code = MEDIA_BUS_FMT_YUYV8_1X16; 1242 break; 1243 case 2: 1244 code->code = MEDIA_BUS_FMT_UYVY8_1X16; 1245 break; 1246 default: 1247 return -EINVAL; 1248 } 1249 return 0; 1250 } 1251 1252 static void adv7511_fill_format(struct adv7511_state *state, 1253 struct v4l2_mbus_framefmt *format) 1254 { 1255 format->width = state->dv_timings.bt.width; 1256 format->height = state->dv_timings.bt.height; 1257 format->field = V4L2_FIELD_NONE; 1258 } 1259 1260 static int adv7511_get_fmt(struct v4l2_subdev *sd, 1261 struct v4l2_subdev_pad_config *cfg, 1262 struct v4l2_subdev_format *format) 1263 { 1264 struct adv7511_state *state = get_adv7511_state(sd); 1265 1266 if (format->pad != 0) 1267 return -EINVAL; 1268 1269 memset(&format->format, 0, sizeof(format->format)); 1270 adv7511_fill_format(state, &format->format); 1271 1272 if (format->which == V4L2_SUBDEV_FORMAT_TRY) { 1273 struct v4l2_mbus_framefmt *fmt; 1274 1275 fmt = v4l2_subdev_get_try_format(sd, cfg, format->pad); 1276 format->format.code = fmt->code; 1277 format->format.colorspace = fmt->colorspace; 1278 format->format.ycbcr_enc = fmt->ycbcr_enc; 1279 format->format.quantization = fmt->quantization; 1280 format->format.xfer_func = fmt->xfer_func; 1281 } else { 1282 format->format.code = state->fmt_code; 1283 format->format.colorspace = state->colorspace; 1284 format->format.ycbcr_enc = state->ycbcr_enc; 1285 format->format.quantization = state->quantization; 1286 format->format.xfer_func = state->xfer_func; 1287 } 1288 1289 return 0; 1290 } 1291 1292 static int adv7511_set_fmt(struct v4l2_subdev *sd, 1293 struct v4l2_subdev_pad_config *cfg, 1294 struct v4l2_subdev_format *format) 1295 { 1296 struct adv7511_state *state = get_adv7511_state(sd); 1297 /* 1298 * Bitfield namings come the CEA-861-F standard, table 8 "Auxiliary 1299 * Video Information (AVI) InfoFrame Format" 1300 * 1301 * c = Colorimetry 1302 * ec = Extended Colorimetry 1303 * y = RGB or YCbCr 1304 * q = RGB Quantization Range 1305 * yq = YCC Quantization Range 1306 */ 1307 u8 c = HDMI_COLORIMETRY_NONE; 1308 u8 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601; 1309 u8 y = HDMI_COLORSPACE_RGB; 1310 u8 q = HDMI_QUANTIZATION_RANGE_DEFAULT; 1311 u8 yq = HDMI_YCC_QUANTIZATION_RANGE_LIMITED; 1312 u8 itc = state->content_type != V4L2_DV_IT_CONTENT_TYPE_NO_ITC; 1313 u8 cn = itc ? state->content_type : V4L2_DV_IT_CONTENT_TYPE_GRAPHICS; 1314 1315 if (format->pad != 0) 1316 return -EINVAL; 1317 switch (format->format.code) { 1318 case MEDIA_BUS_FMT_UYVY8_1X16: 1319 case MEDIA_BUS_FMT_YUYV8_1X16: 1320 case MEDIA_BUS_FMT_RGB888_1X24: 1321 break; 1322 default: 1323 return -EINVAL; 1324 } 1325 1326 adv7511_fill_format(state, &format->format); 1327 if (format->which == V4L2_SUBDEV_FORMAT_TRY) { 1328 struct v4l2_mbus_framefmt *fmt; 1329 1330 fmt = v4l2_subdev_get_try_format(sd, cfg, format->pad); 1331 fmt->code = format->format.code; 1332 fmt->colorspace = format->format.colorspace; 1333 fmt->ycbcr_enc = format->format.ycbcr_enc; 1334 fmt->quantization = format->format.quantization; 1335 fmt->xfer_func = format->format.xfer_func; 1336 return 0; 1337 } 1338 1339 switch (format->format.code) { 1340 case MEDIA_BUS_FMT_UYVY8_1X16: 1341 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x01); 1342 adv7511_wr_and_or(sd, 0x16, 0x03, 0xb8); 1343 y = HDMI_COLORSPACE_YUV422; 1344 break; 1345 case MEDIA_BUS_FMT_YUYV8_1X16: 1346 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x01); 1347 adv7511_wr_and_or(sd, 0x16, 0x03, 0xbc); 1348 y = HDMI_COLORSPACE_YUV422; 1349 break; 1350 case MEDIA_BUS_FMT_RGB888_1X24: 1351 default: 1352 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x00); 1353 adv7511_wr_and_or(sd, 0x16, 0x03, 0x00); 1354 break; 1355 } 1356 state->fmt_code = format->format.code; 1357 state->colorspace = format->format.colorspace; 1358 state->ycbcr_enc = format->format.ycbcr_enc; 1359 state->quantization = format->format.quantization; 1360 state->xfer_func = format->format.xfer_func; 1361 1362 switch (format->format.colorspace) { 1363 case V4L2_COLORSPACE_OPRGB: 1364 c = HDMI_COLORIMETRY_EXTENDED; 1365 ec = y ? HDMI_EXTENDED_COLORIMETRY_OPYCC_601 : 1366 HDMI_EXTENDED_COLORIMETRY_OPRGB; 1367 break; 1368 case V4L2_COLORSPACE_SMPTE170M: 1369 c = y ? HDMI_COLORIMETRY_ITU_601 : HDMI_COLORIMETRY_NONE; 1370 if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_XV601) { 1371 c = HDMI_COLORIMETRY_EXTENDED; 1372 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601; 1373 } 1374 break; 1375 case V4L2_COLORSPACE_REC709: 1376 c = y ? HDMI_COLORIMETRY_ITU_709 : HDMI_COLORIMETRY_NONE; 1377 if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_XV709) { 1378 c = HDMI_COLORIMETRY_EXTENDED; 1379 ec = HDMI_EXTENDED_COLORIMETRY_XV_YCC_709; 1380 } 1381 break; 1382 case V4L2_COLORSPACE_SRGB: 1383 c = y ? HDMI_COLORIMETRY_EXTENDED : HDMI_COLORIMETRY_NONE; 1384 ec = y ? HDMI_EXTENDED_COLORIMETRY_S_YCC_601 : 1385 HDMI_EXTENDED_COLORIMETRY_XV_YCC_601; 1386 break; 1387 case V4L2_COLORSPACE_BT2020: 1388 c = HDMI_COLORIMETRY_EXTENDED; 1389 if (y && format->format.ycbcr_enc == V4L2_YCBCR_ENC_BT2020_CONST_LUM) 1390 ec = 5; /* Not yet available in hdmi.h */ 1391 else 1392 ec = 6; /* Not yet available in hdmi.h */ 1393 break; 1394 default: 1395 break; 1396 } 1397 1398 /* 1399 * CEA-861-F says that for RGB formats the YCC range must match the 1400 * RGB range, although sources should ignore the YCC range. 1401 * 1402 * The RGB quantization range shouldn't be non-zero if the EDID doesn't 1403 * have the Q bit set in the Video Capabilities Data Block, however this 1404 * isn't checked at the moment. The assumption is that the application 1405 * knows the EDID and can detect this. 1406 * 1407 * The same is true for the YCC quantization range: non-standard YCC 1408 * quantization ranges should only be sent if the EDID has the YQ bit 1409 * set in the Video Capabilities Data Block. 1410 */ 1411 switch (format->format.quantization) { 1412 case V4L2_QUANTIZATION_FULL_RANGE: 1413 q = y ? HDMI_QUANTIZATION_RANGE_DEFAULT : 1414 HDMI_QUANTIZATION_RANGE_FULL; 1415 yq = q ? q - 1 : HDMI_YCC_QUANTIZATION_RANGE_FULL; 1416 break; 1417 case V4L2_QUANTIZATION_LIM_RANGE: 1418 q = y ? HDMI_QUANTIZATION_RANGE_DEFAULT : 1419 HDMI_QUANTIZATION_RANGE_LIMITED; 1420 yq = q ? q - 1 : HDMI_YCC_QUANTIZATION_RANGE_LIMITED; 1421 break; 1422 } 1423 1424 adv7511_wr_and_or(sd, 0x4a, 0xbf, 0); 1425 adv7511_wr_and_or(sd, 0x55, 0x9f, y << 5); 1426 adv7511_wr_and_or(sd, 0x56, 0x3f, c << 6); 1427 adv7511_wr_and_or(sd, 0x57, 0x83, (ec << 4) | (q << 2) | (itc << 7)); 1428 adv7511_wr_and_or(sd, 0x59, 0x0f, (yq << 6) | (cn << 4)); 1429 adv7511_wr_and_or(sd, 0x4a, 0xff, 1); 1430 adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl); 1431 1432 return 0; 1433 } 1434 1435 static const struct v4l2_subdev_pad_ops adv7511_pad_ops = { 1436 .get_edid = adv7511_get_edid, 1437 .enum_mbus_code = adv7511_enum_mbus_code, 1438 .get_fmt = adv7511_get_fmt, 1439 .set_fmt = adv7511_set_fmt, 1440 .enum_dv_timings = adv7511_enum_dv_timings, 1441 .dv_timings_cap = adv7511_dv_timings_cap, 1442 }; 1443 1444 /* --------------------- SUBDEV OPS --------------------------------------- */ 1445 1446 static const struct v4l2_subdev_ops adv7511_ops = { 1447 .core = &adv7511_core_ops, 1448 .pad = &adv7511_pad_ops, 1449 .video = &adv7511_video_ops, 1450 .audio = &adv7511_audio_ops, 1451 }; 1452 1453 /* ----------------------------------------------------------------------- */ 1454 static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, u8 *buf) 1455 { 1456 if (debug >= lvl) { 1457 int i, j; 1458 v4l2_dbg(lvl, debug, sd, "edid segment %d\n", segment); 1459 for (i = 0; i < 256; i += 16) { 1460 u8 b[128]; 1461 u8 *bp = b; 1462 if (i == 128) 1463 v4l2_dbg(lvl, debug, sd, "\n"); 1464 for (j = i; j < i + 16; j++) { 1465 sprintf(bp, "0x%02x, ", buf[j]); 1466 bp += 6; 1467 } 1468 bp[0] = '\0'; 1469 v4l2_dbg(lvl, debug, sd, "%s\n", b); 1470 } 1471 } 1472 } 1473 1474 static void adv7511_notify_no_edid(struct v4l2_subdev *sd) 1475 { 1476 struct adv7511_state *state = get_adv7511_state(sd); 1477 struct adv7511_edid_detect ed; 1478 1479 /* We failed to read the EDID, so send an event for this. */ 1480 ed.present = false; 1481 ed.segment = adv7511_rd(sd, 0xc4); 1482 ed.phys_addr = CEC_PHYS_ADDR_INVALID; 1483 cec_s_phys_addr(state->cec_adap, ed.phys_addr, false); 1484 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed); 1485 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x0); 1486 } 1487 1488 static void adv7511_edid_handler(struct work_struct *work) 1489 { 1490 struct delayed_work *dwork = to_delayed_work(work); 1491 struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler); 1492 struct v4l2_subdev *sd = &state->sd; 1493 1494 v4l2_dbg(1, debug, sd, "%s:\n", __func__); 1495 1496 if (adv7511_check_edid_status(sd)) { 1497 /* Return if we received the EDID. */ 1498 return; 1499 } 1500 1501 if (adv7511_have_hotplug(sd)) { 1502 /* We must retry reading the EDID several times, it is possible 1503 * that initially the EDID couldn't be read due to i2c errors 1504 * (DVI connectors are particularly prone to this problem). */ 1505 if (state->edid.read_retries) { 1506 state->edid.read_retries--; 1507 v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__); 1508 state->have_monitor = false; 1509 adv7511_s_power(sd, false); 1510 adv7511_s_power(sd, true); 1511 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY); 1512 return; 1513 } 1514 } 1515 1516 /* We failed to read the EDID, so send an event for this. */ 1517 adv7511_notify_no_edid(sd); 1518 v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__); 1519 } 1520 1521 static void adv7511_audio_setup(struct v4l2_subdev *sd) 1522 { 1523 v4l2_dbg(1, debug, sd, "%s\n", __func__); 1524 1525 adv7511_s_i2s_clock_freq(sd, 48000); 1526 adv7511_s_clock_freq(sd, 48000); 1527 adv7511_s_routing(sd, 0, 0, 0); 1528 } 1529 1530 /* Configure hdmi transmitter. */ 1531 static void adv7511_setup(struct v4l2_subdev *sd) 1532 { 1533 struct adv7511_state *state = get_adv7511_state(sd); 1534 v4l2_dbg(1, debug, sd, "%s\n", __func__); 1535 1536 /* Input format: RGB 4:4:4 */ 1537 adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0); 1538 /* Output format: RGB 4:4:4 */ 1539 adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0); 1540 /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */ 1541 adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06); 1542 /* Disable pixel repetition */ 1543 adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0); 1544 /* Disable CSC */ 1545 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0); 1546 /* Output format: RGB 4:4:4, Active Format Information is valid, 1547 * underscanned */ 1548 adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12); 1549 /* AVI Info frame packet enable, Audio Info frame disable */ 1550 adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10); 1551 /* Colorimetry, Active format aspect ratio: same as picure. */ 1552 adv7511_wr(sd, 0x56, 0xa8); 1553 /* No encryption */ 1554 adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0); 1555 1556 /* Positive clk edge capture for input video clock */ 1557 adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60); 1558 1559 adv7511_audio_setup(sd); 1560 1561 v4l2_ctrl_handler_setup(&state->hdl); 1562 } 1563 1564 static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd) 1565 { 1566 struct adv7511_monitor_detect mdt; 1567 struct adv7511_state *state = get_adv7511_state(sd); 1568 1569 mdt.present = state->have_monitor; 1570 v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt); 1571 } 1572 1573 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd) 1574 { 1575 struct adv7511_state *state = get_adv7511_state(sd); 1576 /* read hotplug and rx-sense state */ 1577 u8 status = adv7511_rd(sd, 0x42); 1578 1579 v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n", 1580 __func__, 1581 status, 1582 status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "", 1583 status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : ""); 1584 1585 /* update read only ctrls */ 1586 v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0); 1587 v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0); 1588 1589 if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) { 1590 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__); 1591 if (!state->have_monitor) { 1592 v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__); 1593 state->have_monitor = true; 1594 adv7511_set_isr(sd, true); 1595 if (!adv7511_s_power(sd, true)) { 1596 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__); 1597 return; 1598 } 1599 adv7511_setup(sd); 1600 adv7511_notify_monitor_detect(sd); 1601 state->edid.read_retries = EDID_MAX_RETRIES; 1602 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY); 1603 } 1604 } else if (status & MASK_ADV7511_HPD_DETECT) { 1605 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__); 1606 state->edid.read_retries = EDID_MAX_RETRIES; 1607 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY); 1608 } else if (!(status & MASK_ADV7511_HPD_DETECT)) { 1609 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__); 1610 if (state->have_monitor) { 1611 v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__); 1612 state->have_monitor = false; 1613 adv7511_notify_monitor_detect(sd); 1614 } 1615 adv7511_s_power(sd, false); 1616 memset(&state->edid, 0, sizeof(struct adv7511_state_edid)); 1617 adv7511_notify_no_edid(sd); 1618 } 1619 } 1620 1621 static bool edid_block_verify_crc(u8 *edid_block) 1622 { 1623 u8 sum = 0; 1624 int i; 1625 1626 for (i = 0; i < 128; i++) 1627 sum += edid_block[i]; 1628 return sum == 0; 1629 } 1630 1631 static bool edid_verify_crc(struct v4l2_subdev *sd, u32 segment) 1632 { 1633 struct adv7511_state *state = get_adv7511_state(sd); 1634 u32 blocks = state->edid.blocks; 1635 u8 *data = state->edid.data; 1636 1637 if (!edid_block_verify_crc(&data[segment * 256])) 1638 return false; 1639 if ((segment + 1) * 2 <= blocks) 1640 return edid_block_verify_crc(&data[segment * 256 + 128]); 1641 return true; 1642 } 1643 1644 static bool edid_verify_header(struct v4l2_subdev *sd, u32 segment) 1645 { 1646 static const u8 hdmi_header[] = { 1647 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 1648 }; 1649 struct adv7511_state *state = get_adv7511_state(sd); 1650 u8 *data = state->edid.data; 1651 1652 if (segment != 0) 1653 return true; 1654 return !memcmp(data, hdmi_header, sizeof(hdmi_header)); 1655 } 1656 1657 static bool adv7511_check_edid_status(struct v4l2_subdev *sd) 1658 { 1659 struct adv7511_state *state = get_adv7511_state(sd); 1660 u8 edidRdy = adv7511_rd(sd, 0xc5); 1661 1662 v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n", 1663 __func__, EDID_MAX_RETRIES - state->edid.read_retries); 1664 1665 if (state->edid.complete) 1666 return true; 1667 1668 if (edidRdy & MASK_ADV7511_EDID_RDY) { 1669 int segment = adv7511_rd(sd, 0xc4); 1670 struct adv7511_edid_detect ed; 1671 1672 if (segment >= EDID_MAX_SEGM) { 1673 v4l2_err(sd, "edid segment number too big\n"); 1674 return false; 1675 } 1676 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment); 1677 adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]); 1678 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]); 1679 if (segment == 0) { 1680 state->edid.blocks = state->edid.data[0x7e] + 1; 1681 v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n", __func__, state->edid.blocks); 1682 } 1683 if (!edid_verify_crc(sd, segment) || 1684 !edid_verify_header(sd, segment)) { 1685 /* edid crc error, force reread of edid segment */ 1686 v4l2_err(sd, "%s: edid crc or header error\n", __func__); 1687 state->have_monitor = false; 1688 adv7511_s_power(sd, false); 1689 adv7511_s_power(sd, true); 1690 return false; 1691 } 1692 /* one more segment read ok */ 1693 state->edid.segments = segment + 1; 1694 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, 0x1); 1695 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) { 1696 /* Request next EDID segment */ 1697 v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments); 1698 adv7511_wr(sd, 0xc9, 0xf); 1699 adv7511_wr(sd, 0xc4, state->edid.segments); 1700 state->edid.read_retries = EDID_MAX_RETRIES; 1701 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY); 1702 return false; 1703 } 1704 1705 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments); 1706 state->edid.complete = true; 1707 ed.phys_addr = cec_get_edid_phys_addr(state->edid.data, 1708 state->edid.segments * 256, 1709 NULL); 1710 /* report when we have all segments 1711 but report only for segment 0 1712 */ 1713 ed.present = true; 1714 ed.segment = 0; 1715 state->edid_detect_counter++; 1716 cec_s_phys_addr(state->cec_adap, ed.phys_addr, false); 1717 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed); 1718 return ed.present; 1719 } 1720 1721 return false; 1722 } 1723 1724 static int adv7511_registered(struct v4l2_subdev *sd) 1725 { 1726 struct adv7511_state *state = get_adv7511_state(sd); 1727 struct i2c_client *client = v4l2_get_subdevdata(sd); 1728 int err; 1729 1730 err = cec_register_adapter(state->cec_adap, &client->dev); 1731 if (err) 1732 cec_delete_adapter(state->cec_adap); 1733 return err; 1734 } 1735 1736 static void adv7511_unregistered(struct v4l2_subdev *sd) 1737 { 1738 struct adv7511_state *state = get_adv7511_state(sd); 1739 1740 cec_unregister_adapter(state->cec_adap); 1741 } 1742 1743 static const struct v4l2_subdev_internal_ops adv7511_int_ops = { 1744 .registered = adv7511_registered, 1745 .unregistered = adv7511_unregistered, 1746 }; 1747 1748 /* ----------------------------------------------------------------------- */ 1749 /* Setup ADV7511 */ 1750 static void adv7511_init_setup(struct v4l2_subdev *sd) 1751 { 1752 struct adv7511_state *state = get_adv7511_state(sd); 1753 struct adv7511_state_edid *edid = &state->edid; 1754 u32 cec_clk = state->pdata.cec_clk; 1755 u8 ratio; 1756 1757 v4l2_dbg(1, debug, sd, "%s\n", __func__); 1758 1759 /* clear all interrupts */ 1760 adv7511_wr(sd, 0x96, 0xff); 1761 adv7511_wr(sd, 0x97, 0xff); 1762 /* 1763 * Stop HPD from resetting a lot of registers. 1764 * It might leave the chip in a partly un-initialized state, 1765 * in particular with regards to hotplug bounces. 1766 */ 1767 adv7511_wr_and_or(sd, 0xd6, 0x3f, 0xc0); 1768 memset(edid, 0, sizeof(struct adv7511_state_edid)); 1769 state->have_monitor = false; 1770 adv7511_set_isr(sd, false); 1771 adv7511_s_stream(sd, false); 1772 adv7511_s_audio_stream(sd, false); 1773 1774 if (state->i2c_cec == NULL) 1775 return; 1776 1777 v4l2_dbg(1, debug, sd, "%s: cec_clk %d\n", __func__, cec_clk); 1778 1779 /* cec soft reset */ 1780 adv7511_cec_write(sd, 0x50, 0x01); 1781 adv7511_cec_write(sd, 0x50, 0x00); 1782 1783 /* legacy mode */ 1784 adv7511_cec_write(sd, 0x4a, 0x00); 1785 adv7511_cec_write(sd, 0x4a, 0x07); 1786 1787 if (cec_clk % 750000 != 0) 1788 v4l2_err(sd, "%s: cec_clk %d, not multiple of 750 Khz\n", 1789 __func__, cec_clk); 1790 1791 ratio = (cec_clk / 750000) - 1; 1792 adv7511_cec_write(sd, 0x4e, ratio << 2); 1793 } 1794 1795 static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id) 1796 { 1797 struct adv7511_state *state; 1798 struct adv7511_platform_data *pdata = client->dev.platform_data; 1799 struct v4l2_ctrl_handler *hdl; 1800 struct v4l2_subdev *sd; 1801 u8 chip_id[2]; 1802 int err = -EIO; 1803 1804 /* Check if the adapter supports the needed features */ 1805 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1806 return -EIO; 1807 1808 state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL); 1809 if (!state) 1810 return -ENOMEM; 1811 1812 /* Platform data */ 1813 if (!pdata) { 1814 v4l_err(client, "No platform data!\n"); 1815 return -ENODEV; 1816 } 1817 memcpy(&state->pdata, pdata, sizeof(state->pdata)); 1818 state->fmt_code = MEDIA_BUS_FMT_RGB888_1X24; 1819 state->colorspace = V4L2_COLORSPACE_SRGB; 1820 1821 sd = &state->sd; 1822 1823 v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n", 1824 client->addr << 1); 1825 1826 v4l2_i2c_subdev_init(sd, client, &adv7511_ops); 1827 sd->internal_ops = &adv7511_int_ops; 1828 1829 hdl = &state->hdl; 1830 v4l2_ctrl_handler_init(hdl, 10); 1831 /* add in ascending ID order */ 1832 state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops, 1833 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI, 1834 0, V4L2_DV_TX_MODE_DVI_D); 1835 state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL, 1836 V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0); 1837 state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL, 1838 V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0); 1839 state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL, 1840 V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0); 1841 state->rgb_quantization_range_ctrl = 1842 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops, 1843 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL, 1844 0, V4L2_DV_RGB_RANGE_AUTO); 1845 state->content_type_ctrl = 1846 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops, 1847 V4L2_CID_DV_TX_IT_CONTENT_TYPE, V4L2_DV_IT_CONTENT_TYPE_NO_ITC, 1848 0, V4L2_DV_IT_CONTENT_TYPE_NO_ITC); 1849 sd->ctrl_handler = hdl; 1850 if (hdl->error) { 1851 err = hdl->error; 1852 goto err_hdl; 1853 } 1854 state->pad.flags = MEDIA_PAD_FL_SINK; 1855 sd->entity.function = MEDIA_ENT_F_DV_ENCODER; 1856 err = media_entity_pads_init(&sd->entity, 1, &state->pad); 1857 if (err) 1858 goto err_hdl; 1859 1860 /* EDID and CEC i2c addr */ 1861 state->i2c_edid_addr = state->pdata.i2c_edid << 1; 1862 state->i2c_cec_addr = state->pdata.i2c_cec << 1; 1863 state->i2c_pktmem_addr = state->pdata.i2c_pktmem << 1; 1864 1865 state->chip_revision = adv7511_rd(sd, 0x0); 1866 chip_id[0] = adv7511_rd(sd, 0xf5); 1867 chip_id[1] = adv7511_rd(sd, 0xf6); 1868 if (chip_id[0] != 0x75 || chip_id[1] != 0x11) { 1869 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0], 1870 chip_id[1]); 1871 err = -EIO; 1872 goto err_entity; 1873 } 1874 1875 state->i2c_edid = i2c_new_dummy_device(client->adapter, 1876 state->i2c_edid_addr >> 1); 1877 if (IS_ERR(state->i2c_edid)) { 1878 v4l2_err(sd, "failed to register edid i2c client\n"); 1879 err = PTR_ERR(state->i2c_edid); 1880 goto err_entity; 1881 } 1882 1883 adv7511_wr(sd, 0xe1, state->i2c_cec_addr); 1884 if (state->pdata.cec_clk < 3000000 || 1885 state->pdata.cec_clk > 100000000) { 1886 v4l2_err(sd, "%s: cec_clk %u outside range, disabling cec\n", 1887 __func__, state->pdata.cec_clk); 1888 state->pdata.cec_clk = 0; 1889 } 1890 1891 if (state->pdata.cec_clk) { 1892 state->i2c_cec = i2c_new_dummy_device(client->adapter, 1893 state->i2c_cec_addr >> 1); 1894 if (IS_ERR(state->i2c_cec)) { 1895 v4l2_err(sd, "failed to register cec i2c client\n"); 1896 err = PTR_ERR(state->i2c_cec); 1897 goto err_unreg_edid; 1898 } 1899 adv7511_wr(sd, 0xe2, 0x00); /* power up cec section */ 1900 } else { 1901 adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */ 1902 } 1903 1904 state->i2c_pktmem = i2c_new_dummy_device(client->adapter, state->i2c_pktmem_addr >> 1); 1905 if (IS_ERR(state->i2c_pktmem)) { 1906 v4l2_err(sd, "failed to register pktmem i2c client\n"); 1907 err = PTR_ERR(state->i2c_pktmem); 1908 goto err_unreg_cec; 1909 } 1910 1911 state->work_queue = create_singlethread_workqueue(sd->name); 1912 if (state->work_queue == NULL) { 1913 v4l2_err(sd, "could not create workqueue\n"); 1914 err = -ENOMEM; 1915 goto err_unreg_pktmem; 1916 } 1917 1918 INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler); 1919 1920 adv7511_init_setup(sd); 1921 1922 #if IS_ENABLED(CONFIG_VIDEO_ADV7511_CEC) 1923 state->cec_adap = cec_allocate_adapter(&adv7511_cec_adap_ops, 1924 state, dev_name(&client->dev), CEC_CAP_DEFAULTS, 1925 ADV7511_MAX_ADDRS); 1926 err = PTR_ERR_OR_ZERO(state->cec_adap); 1927 if (err) { 1928 destroy_workqueue(state->work_queue); 1929 goto err_unreg_pktmem; 1930 } 1931 #endif 1932 1933 adv7511_set_isr(sd, true); 1934 adv7511_check_monitor_present_status(sd); 1935 1936 v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name, 1937 client->addr << 1, client->adapter->name); 1938 return 0; 1939 1940 err_unreg_pktmem: 1941 i2c_unregister_device(state->i2c_pktmem); 1942 err_unreg_cec: 1943 i2c_unregister_device(state->i2c_cec); 1944 err_unreg_edid: 1945 i2c_unregister_device(state->i2c_edid); 1946 err_entity: 1947 media_entity_cleanup(&sd->entity); 1948 err_hdl: 1949 v4l2_ctrl_handler_free(&state->hdl); 1950 return err; 1951 } 1952 1953 /* ----------------------------------------------------------------------- */ 1954 1955 static int adv7511_remove(struct i2c_client *client) 1956 { 1957 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1958 struct adv7511_state *state = get_adv7511_state(sd); 1959 1960 state->chip_revision = -1; 1961 1962 v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name, 1963 client->addr << 1, client->adapter->name); 1964 1965 adv7511_set_isr(sd, false); 1966 adv7511_init_setup(sd); 1967 cancel_delayed_work(&state->edid_handler); 1968 i2c_unregister_device(state->i2c_edid); 1969 i2c_unregister_device(state->i2c_cec); 1970 i2c_unregister_device(state->i2c_pktmem); 1971 destroy_workqueue(state->work_queue); 1972 v4l2_device_unregister_subdev(sd); 1973 media_entity_cleanup(&sd->entity); 1974 v4l2_ctrl_handler_free(sd->ctrl_handler); 1975 return 0; 1976 } 1977 1978 /* ----------------------------------------------------------------------- */ 1979 1980 static const struct i2c_device_id adv7511_id[] = { 1981 { "adv7511-v4l2", 0 }, 1982 { } 1983 }; 1984 MODULE_DEVICE_TABLE(i2c, adv7511_id); 1985 1986 static struct i2c_driver adv7511_driver = { 1987 .driver = { 1988 .name = "adv7511-v4l2", 1989 }, 1990 .probe = adv7511_probe, 1991 .remove = adv7511_remove, 1992 .id_table = adv7511_id, 1993 }; 1994 1995 module_i2c_driver(adv7511_driver); 1996