drivers/media/i2c/adv7511-v4l2.c

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

DEFINITIONS
