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