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