drivers/media/i2c/adv7511.c

   1 /*
   2  * Analog Devices ADV7511 HDMI Transmitter Device Driver
   3  *
   4  * Copyright 2013 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
   5  *
   6  * This program is free software; you may redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; version 2 of the License.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  11  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  12  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  13  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  14  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  15  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  16  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  17  * SOFTWARE.
  18  */
  19
  20
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/slab.h>
  24 #include <linux/i2c.h>
  25 #include <linux/delay.h>
  26 #include <linux/videodev2.h>
  27 #include <linux/gpio.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/v4l2-dv-timings.h>
  30 #include <media/v4l2-device.h>
  31 #include <media/v4l2-common.h>
  32 #include <media/v4l2-ctrls.h>
  33 #include <media/v4l2-dv-timings.h>
  34 #include <media/adv7511.h>
  35
  36 static int debug;
  37 module_param(debug, int, 0644);
  38 MODULE_PARM_DESC(debug, "debug level (0-2)");
  39
  40 MODULE_DESCRIPTION("Analog Devices ADV7511 HDMI Transmitter Device Driver");
  41 MODULE_AUTHOR("Hans Verkuil");
  42 MODULE_LICENSE("GPL");
  43
  44 #define MASK_ADV7511_EDID_RDY_INT   0x04
  45 #define MASK_ADV7511_MSEN_INT       0x40
  46 #define MASK_ADV7511_HPD_INT        0x80
  47
  48 #define MASK_ADV7511_HPD_DETECT     0x40
  49 #define MASK_ADV7511_MSEN_DETECT    0x20
  50 #define MASK_ADV7511_EDID_RDY       0x10
  51
  52 #define EDID_MAX_RETRIES (8)
  53 #define EDID_DELAY 250
  54 #define EDID_MAX_SEGM 8
  55
  56 #define ADV7511_MAX_WIDTH 1920
  57 #define ADV7511_MAX_HEIGHT 1200
  58 #define ADV7511_MIN_PIXELCLOCK 20000000
  59 #define ADV7511_MAX_PIXELCLOCK 225000000
  60
  61 /*
  62 **********************************************************************
  63 *
  64 *  Arrays with configuration parameters for the ADV7511
  65 *
  66 **********************************************************************
  67 */
  68
  69 struct i2c_reg_value {
  70         unsigned char reg;
  71         unsigned char value;
  72 };
  73
  74 struct adv7511_state_edid {
  75         /* total number of blocks */
  76         u32 blocks;
  77         /* Number of segments read */
  78         u32 segments;
  79         uint8_t data[EDID_MAX_SEGM * 256];
  80         /* Number of EDID read retries left */
  81         unsigned read_retries;
  82         bool complete;
  83 };
  84
  85 struct adv7511_state {
  86         struct adv7511_platform_data pdata;
  87         struct v4l2_subdev sd;
  88         struct media_pad pad;
  89         struct v4l2_ctrl_handler hdl;
  90         int chip_revision;
  91         uint8_t i2c_edid_addr;
  92         uint8_t i2c_cec_addr;
  93         /* Is the adv7511 powered on? */
  94         bool power_on;
  95         /* Did we receive hotplug and rx-sense signals? */
  96         bool have_monitor;
  97         /* timings from s_dv_timings */
  98         struct v4l2_dv_timings dv_timings;
  99         /* controls */
 100         struct v4l2_ctrl *hdmi_mode_ctrl;
 101         struct v4l2_ctrl *hotplug_ctrl;
 102         struct v4l2_ctrl *rx_sense_ctrl;
 103         struct v4l2_ctrl *have_edid0_ctrl;
 104         struct v4l2_ctrl *rgb_quantization_range_ctrl;
 105         struct i2c_client *i2c_edid;
 106         struct adv7511_state_edid edid;
 107         /* Running counter of the number of detected EDIDs (for debugging) */
 108         unsigned edid_detect_counter;
 109         struct workqueue_struct *work_queue;
 110         struct delayed_work edid_handler; /* work entry */
 111 };
 112
 113 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd);
 114 static bool adv7511_check_edid_status(struct v4l2_subdev *sd);
 115 static void adv7511_setup(struct v4l2_subdev *sd);
 116 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq);
 117 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq);
 118
 119
 120 static const struct v4l2_dv_timings_cap adv7511_timings_cap = {
 121         .type = V4L2_DV_BT_656_1120,
 122         /* keep this initialization for compatibility with GCC < 4.4.6 */
 123         .reserved = { 0 },
 124         V4L2_INIT_BT_TIMINGS(0, ADV7511_MAX_WIDTH, 0, ADV7511_MAX_HEIGHT,
 125                 ADV7511_MIN_PIXELCLOCK, ADV7511_MAX_PIXELCLOCK,
 126                 V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT |
 127                         V4L2_DV_BT_STD_GTF | V4L2_DV_BT_STD_CVT,
 128                 V4L2_DV_BT_CAP_PROGRESSIVE | V4L2_DV_BT_CAP_REDUCED_BLANKING |
 129                         V4L2_DV_BT_CAP_CUSTOM)
 130 };
 131
 132 static inline struct adv7511_state *get_adv7511_state(struct v4l2_subdev *sd)
 133 {
 134         return container_of(sd, struct adv7511_state, sd);
 135 }
 136
 137 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
 138 {
 139         return &container_of(ctrl->handler, struct adv7511_state, hdl)->sd;
 140 }
 141
 142 /* ------------------------ I2C ----------------------------------------------- */
 143
 144 static s32 adv_smbus_read_byte_data_check(struct i2c_client *client,
 145                                           u8 command, bool check)
 146 {
 147         union i2c_smbus_data data;
 148
 149         if (!i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 150                             I2C_SMBUS_READ, command,
 151                             I2C_SMBUS_BYTE_DATA, &data))
 152                 return data.byte;
 153         if (check)
 154                 v4l_err(client, "error reading %02x, %02x\n",
 155                         client->addr, command);
 156         return -1;
 157 }
 158
 159 static s32 adv_smbus_read_byte_data(struct i2c_client *client, u8 command)
 160 {
 161         int i;
 162         for (i = 0; i < 3; i++) {
 163                 int ret = adv_smbus_read_byte_data_check(client, command, true);
 164                 if (ret >= 0) {
 165                         if (i)
 166                                 v4l_err(client, "read ok after %d retries\n", i);
 167                         return ret;
 168                 }
 169         }
 170         v4l_err(client, "read failed\n");
 171         return -1;
 172 }
 173
 174 static int adv7511_rd(struct v4l2_subdev *sd, u8 reg)
 175 {
 176         struct i2c_client *client = v4l2_get_subdevdata(sd);
 177
 178         return adv_smbus_read_byte_data(client, reg);
 179 }
 180
 181 static int adv7511_wr(struct v4l2_subdev *sd, u8 reg, u8 val)
 182 {
 183         struct i2c_client *client = v4l2_get_subdevdata(sd);
 184         int ret;
 185         int i;
 186
 187         for (i = 0; i < 3; i++) {
 188                 ret = i2c_smbus_write_byte_data(client, reg, val);
 189                 if (ret == 0)
 190                         return 0;
 191         }
 192         v4l2_err(sd, "%s: i2c write error\n", __func__);
 193         return ret;
 194 }
 195
 196 /* To set specific bits in the register, a clear-mask is given (to be AND-ed),
 197    and then the value-mask (to be OR-ed). */
 198 static inline void adv7511_wr_and_or(struct v4l2_subdev *sd, u8 reg, uint8_t clr_mask, uint8_t val_mask)
 199 {
 200         adv7511_wr(sd, reg, (adv7511_rd(sd, reg) & clr_mask) | val_mask);
 201 }
 202
 203 static int adv_smbus_read_i2c_block_data(struct i2c_client *client,
 204                                          u8 command, unsigned length, u8 *values)
 205 {
 206         union i2c_smbus_data data;
 207         int ret;
 208
 209         if (length > I2C_SMBUS_BLOCK_MAX)
 210                 length = I2C_SMBUS_BLOCK_MAX;
 211         data.block[0] = length;
 212
 213         ret = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 214                              I2C_SMBUS_READ, command,
 215                              I2C_SMBUS_I2C_BLOCK_DATA, &data);
 216         memcpy(values, data.block + 1, length);
 217         return ret;
 218 }
 219
 220 static inline void adv7511_edid_rd(struct v4l2_subdev *sd, uint16_t len, uint8_t *buf)
 221 {
 222         struct adv7511_state *state = get_adv7511_state(sd);
 223         int i;
 224         int err = 0;
 225
 226         v4l2_dbg(1, debug, sd, "%s:\n", __func__);
 227
 228         for (i = 0; !err && i < len; i += I2C_SMBUS_BLOCK_MAX)
 229                 err = adv_smbus_read_i2c_block_data(state->i2c_edid, i,
 230                                                     I2C_SMBUS_BLOCK_MAX, buf + i);
 231         if (err)
 232                 v4l2_err(sd, "%s: i2c read error\n", __func__);
 233 }
 234
 235 static inline bool adv7511_have_hotplug(struct v4l2_subdev *sd)
 236 {
 237         return adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT;
 238 }
 239
 240 static inline bool adv7511_have_rx_sense(struct v4l2_subdev *sd)
 241 {
 242         return adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT;
 243 }
 244
 245 static void adv7511_csc_conversion_mode(struct v4l2_subdev *sd, uint8_t mode)
 246 {
 247         adv7511_wr_and_or(sd, 0x18, 0x9f, (mode & 0x3)<<5);
 248 }
 249
 250 static void adv7511_csc_coeff(struct v4l2_subdev *sd,
 251                               u16 A1, u16 A2, u16 A3, u16 A4,
 252                               u16 B1, u16 B2, u16 B3, u16 B4,
 253                               u16 C1, u16 C2, u16 C3, u16 C4)
 254 {
 255         /* A */
 256         adv7511_wr_and_or(sd, 0x18, 0xe0, A1>>8);
 257         adv7511_wr(sd, 0x19, A1);
 258         adv7511_wr_and_or(sd, 0x1A, 0xe0, A2>>8);
 259         adv7511_wr(sd, 0x1B, A2);
 260         adv7511_wr_and_or(sd, 0x1c, 0xe0, A3>>8);
 261         adv7511_wr(sd, 0x1d, A3);
 262         adv7511_wr_and_or(sd, 0x1e, 0xe0, A4>>8);
 263         adv7511_wr(sd, 0x1f, A4);
 264
 265         /* B */
 266         adv7511_wr_and_or(sd, 0x20, 0xe0, B1>>8);
 267         adv7511_wr(sd, 0x21, B1);
 268         adv7511_wr_and_or(sd, 0x22, 0xe0, B2>>8);
 269         adv7511_wr(sd, 0x23, B2);
 270         adv7511_wr_and_or(sd, 0x24, 0xe0, B3>>8);
 271         adv7511_wr(sd, 0x25, B3);
 272         adv7511_wr_and_or(sd, 0x26, 0xe0, B4>>8);
 273         adv7511_wr(sd, 0x27, B4);
 274
 275         /* C */
 276         adv7511_wr_and_or(sd, 0x28, 0xe0, C1>>8);
 277         adv7511_wr(sd, 0x29, C1);
 278         adv7511_wr_and_or(sd, 0x2A, 0xe0, C2>>8);
 279         adv7511_wr(sd, 0x2B, C2);
 280         adv7511_wr_and_or(sd, 0x2C, 0xe0, C3>>8);
 281         adv7511_wr(sd, 0x2D, C3);
 282         adv7511_wr_and_or(sd, 0x2E, 0xe0, C4>>8);
 283         adv7511_wr(sd, 0x2F, C4);
 284 }
 285
 286 static void adv7511_csc_rgb_full2limit(struct v4l2_subdev *sd, bool enable)
 287 {
 288         if (enable) {
 289                 uint8_t csc_mode = 0;
 290                 adv7511_csc_conversion_mode(sd, csc_mode);
 291                 adv7511_csc_coeff(sd,
 292                                   4096-564, 0, 0, 256,
 293                                   0, 4096-564, 0, 256,
 294                                   0, 0, 4096-564, 256);
 295                 /* enable CSC */
 296                 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x80);
 297                 /* AVI infoframe: Limited range RGB (16-235) */
 298                 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x04);
 299         } else {
 300                 /* disable CSC */
 301                 adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
 302                 /* AVI infoframe: Full range RGB (0-255) */
 303                 adv7511_wr_and_or(sd, 0x57, 0xf3, 0x08);
 304         }
 305 }
 306
 307 static void adv7511_set_IT_content_AVI_InfoFrame(struct v4l2_subdev *sd)
 308 {
 309         struct adv7511_state *state = get_adv7511_state(sd);
 310         if (state->dv_timings.bt.standards & V4L2_DV_BT_STD_CEA861) {
 311                 /* CEA format, not IT  */
 312                 adv7511_wr_and_or(sd, 0x57, 0x7f, 0x00);
 313         } else {
 314                 /* IT format */
 315                 adv7511_wr_and_or(sd, 0x57, 0x7f, 0x80);
 316         }
 317 }
 318
 319 static int adv7511_set_rgb_quantization_mode(struct v4l2_subdev *sd, struct v4l2_ctrl *ctrl)
 320 {
 321         switch (ctrl->val) {
 322         default:
 323                 return -EINVAL;
 324                 break;
 325         case V4L2_DV_RGB_RANGE_AUTO: {
 326                 /* automatic */
 327                 struct adv7511_state *state = get_adv7511_state(sd);
 328
 329                 if (state->dv_timings.bt.standards & V4L2_DV_BT_STD_CEA861) {
 330                         /* cea format, RGB limited range (16-235) */
 331                         adv7511_csc_rgb_full2limit(sd, true);
 332                 } else {
 333                         /* not cea format, RGB full range (0-255) */
 334                         adv7511_csc_rgb_full2limit(sd, false);
 335                 }
 336         }
 337                 break;
 338         case V4L2_DV_RGB_RANGE_LIMITED:
 339                 /* RGB limited range (16-235) */
 340                 adv7511_csc_rgb_full2limit(sd, true);
 341                 break;
 342         case V4L2_DV_RGB_RANGE_FULL:
 343                 /* RGB full range (0-255) */
 344                 adv7511_csc_rgb_full2limit(sd, false);
 345                 break;
 346         }
 347         return 0;
 348 }
 349
 350 /* ------------------------------ CTRL OPS ------------------------------ */
 351
 352 static int adv7511_s_ctrl(struct v4l2_ctrl *ctrl)
 353 {
 354         struct v4l2_subdev *sd = to_sd(ctrl);
 355         struct adv7511_state *state = get_adv7511_state(sd);
 356
 357         v4l2_dbg(1, debug, sd, "%s: ctrl id: %d, ctrl->val %d\n", __func__, ctrl->id, ctrl->val);
 358
 359         if (state->hdmi_mode_ctrl == ctrl) {
 360                 /* Set HDMI or DVI-D */
 361                 adv7511_wr_and_or(sd, 0xaf, 0xfd, ctrl->val == V4L2_DV_TX_MODE_HDMI ? 0x02 : 0x00);
 362                 return 0;
 363         }
 364         if (state->rgb_quantization_range_ctrl == ctrl)
 365                 return adv7511_set_rgb_quantization_mode(sd, ctrl);
 366
 367         return -EINVAL;
 368 }
 369
 370 static const struct v4l2_ctrl_ops adv7511_ctrl_ops = {
 371         .s_ctrl = adv7511_s_ctrl,
 372 };
 373
 374 /* ---------------------------- CORE OPS ------------------------------------------- */
 375
 376 #ifdef CONFIG_VIDEO_ADV_DEBUG
 377 static void adv7511_inv_register(struct v4l2_subdev *sd)
 378 {
 379         v4l2_info(sd, "0x000-0x0ff: Main Map\n");
 380 }
 381
 382 static int adv7511_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
 383 {
 384         reg->size = 1;
 385         switch (reg->reg >> 8) {
 386         case 0:
 387                 reg->val = adv7511_rd(sd, reg->reg & 0xff);
 388                 break;
 389         default:
 390                 v4l2_info(sd, "Register %03llx not supported\n", reg->reg);
 391                 adv7511_inv_register(sd);
 392                 break;
 393         }
 394         return 0;
 395 }
 396
 397 static int adv7511_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
 398 {
 399         switch (reg->reg >> 8) {
 400         case 0:
 401                 adv7511_wr(sd, reg->reg & 0xff, reg->val & 0xff);
 402                 break;
 403         default:
 404                 v4l2_info(sd, "Register %03llx not supported\n", reg->reg);
 405                 adv7511_inv_register(sd);
 406                 break;
 407         }
 408         return 0;
 409 }
 410 #endif
 411
 412 static int adv7511_log_status(struct v4l2_subdev *sd)
 413 {
 414         struct adv7511_state *state = get_adv7511_state(sd);
 415         struct adv7511_state_edid *edid = &state->edid;
 416
 417         static const char * const states[] = {
 418                 "in reset",
 419                 "reading EDID",
 420                 "idle",
 421                 "initializing HDCP",
 422                 "HDCP enabled",
 423                 "initializing HDCP repeater",
 424                 "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"
 425         };
 426         static const char * const errors[] = {
 427                 "no error",
 428                 "bad receiver BKSV",
 429                 "Ri mismatch",
 430                 "Pj mismatch",
 431                 "i2c error",
 432                 "timed out",
 433                 "max repeater cascade exceeded",
 434                 "hash check failed",
 435                 "too many devices",
 436                 "9", "A", "B", "C", "D", "E", "F"
 437         };
 438
 439         v4l2_info(sd, "power %s\n", state->power_on ? "on" : "off");
 440         v4l2_info(sd, "%s hotplug, %s Rx Sense, %s EDID (%d block(s))\n",
 441                   (adv7511_rd(sd, 0x42) & MASK_ADV7511_HPD_DETECT) ? "detected" : "no",
 442                   (adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT) ? "detected" : "no",
 443                   edid->segments ? "found" : "no",
 444                   edid->blocks);
 445         v4l2_info(sd, "%s output %s\n",
 446                   (adv7511_rd(sd, 0xaf) & 0x02) ?
 447                   "HDMI" : "DVI-D",
 448                   (adv7511_rd(sd, 0xa1) & 0x3c) ?
 449                   "disabled" : "enabled");
 450         v4l2_info(sd, "state: %s, error: %s, detect count: %u, msk/irq: %02x/%02x\n",
 451                           states[adv7511_rd(sd, 0xc8) & 0xf],
 452                           errors[adv7511_rd(sd, 0xc8) >> 4], state->edid_detect_counter,
 453                           adv7511_rd(sd, 0x94), adv7511_rd(sd, 0x96));
 454         v4l2_info(sd, "RGB quantization: %s range\n", adv7511_rd(sd, 0x18) & 0x80 ? "limited" : "full");
 455         if (state->dv_timings.type == V4L2_DV_BT_656_1120)
 456                 v4l2_print_dv_timings(sd->name, "timings: ",
 457                                 &state->dv_timings, false);
 458         else
 459                 v4l2_info(sd, "no timings set\n");
 460         v4l2_info(sd, "i2c edid addr: 0x%x\n", state->i2c_edid_addr);
 461         v4l2_info(sd, "i2c cec addr: 0x%x\n", state->i2c_cec_addr);
 462         return 0;
 463 }
 464
 465 /* Power up/down adv7511 */
 466 static int adv7511_s_power(struct v4l2_subdev *sd, int on)
 467 {
 468         struct adv7511_state *state = get_adv7511_state(sd);
 469         const int retries = 20;
 470         int i;
 471
 472         v4l2_dbg(1, debug, sd, "%s: power %s\n", __func__, on ? "on" : "off");
 473
 474         state->power_on = on;
 475
 476         if (!on) {
 477                 /* Power down */
 478                 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
 479                 return true;
 480         }
 481
 482         /* Power up */
 483         /* The adv7511 does not always come up immediately.
 484            Retry multiple times. */
 485         for (i = 0; i < retries; i++) {
 486                 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x0);
 487                 if ((adv7511_rd(sd, 0x41) & 0x40) == 0)
 488                         break;
 489                 adv7511_wr_and_or(sd, 0x41, 0xbf, 0x40);
 490                 msleep(10);
 491         }
 492         if (i == retries) {
 493                 v4l2_dbg(1, debug, sd, "%s: failed to powerup the adv7511!\n", __func__);
 494                 adv7511_s_power(sd, 0);
 495                 return false;
 496         }
 497         if (i > 1)
 498                 v4l2_dbg(1, debug, sd, "%s: needed %d retries to powerup the adv7511\n", __func__, i);
 499
 500         /* Reserved registers that must be set */
 501         adv7511_wr(sd, 0x98, 0x03);
 502         adv7511_wr_and_or(sd, 0x9a, 0xfe, 0x70);
 503         adv7511_wr(sd, 0x9c, 0x30);
 504         adv7511_wr_and_or(sd, 0x9d, 0xfc, 0x01);
 505         adv7511_wr(sd, 0xa2, 0xa4);
 506         adv7511_wr(sd, 0xa3, 0xa4);
 507         adv7511_wr(sd, 0xe0, 0xd0);
 508         adv7511_wr(sd, 0xf9, 0x00);
 509
 510         adv7511_wr(sd, 0x43, state->i2c_edid_addr);
 511
 512         /* Set number of attempts to read the EDID */
 513         adv7511_wr(sd, 0xc9, 0xf);
 514         return true;
 515 }
 516
 517 /* Enable interrupts */
 518 static void adv7511_set_isr(struct v4l2_subdev *sd, bool enable)
 519 {
 520         uint8_t irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT;
 521         uint8_t irqs_rd;
 522         int retries = 100;
 523
 524         v4l2_dbg(2, debug, sd, "%s: %s\n", __func__, enable ? "enable" : "disable");
 525
 526         /* The datasheet says that the EDID ready interrupt should be
 527            disabled if there is no hotplug. */
 528         if (!enable)
 529                 irqs = 0;
 530         else if (adv7511_have_hotplug(sd))
 531                 irqs |= MASK_ADV7511_EDID_RDY_INT;
 532
 533         /*
 534          * This i2c write can fail (approx. 1 in 1000 writes). But it
 535          * is essential that this register is correct, so retry it
 536          * multiple times.
 537          *
 538          * Note that the i2c write does not report an error, but the readback
 539          * clearly shows the wrong value.
 540          */
 541         do {
 542                 adv7511_wr(sd, 0x94, irqs);
 543                 irqs_rd = adv7511_rd(sd, 0x94);
 544         } while (retries-- && irqs_rd != irqs);
 545
 546         if (irqs_rd == irqs)
 547                 return;
 548         v4l2_err(sd, "Could not set interrupts: hw failure?\n");
 549 }
 550
 551 /* Interrupt handler */
 552 static int adv7511_isr(struct v4l2_subdev *sd, u32 status, bool *handled)
 553 {
 554         uint8_t irq_status;
 555
 556         /* disable interrupts to prevent a race condition */
 557         adv7511_set_isr(sd, false);
 558         irq_status = adv7511_rd(sd, 0x96);
 559         /* clear detected interrupts */
 560         adv7511_wr(sd, 0x96, irq_status);
 561
 562         v4l2_dbg(1, debug, sd, "%s: irq 0x%x\n", __func__, irq_status);
 563
 564         if (irq_status & (MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT))
 565                 adv7511_check_monitor_present_status(sd);
 566         if (irq_status & MASK_ADV7511_EDID_RDY_INT)
 567                 adv7511_check_edid_status(sd);
 568
 569         /* enable interrupts */
 570         adv7511_set_isr(sd, true);
 571
 572         if (handled)
 573                 *handled = true;
 574         return 0;
 575 }
 576
 577 static int adv7511_get_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid)
 578 {
 579         struct adv7511_state *state = get_adv7511_state(sd);
 580
 581         if (edid->pad != 0)
 582                 return -EINVAL;
 583         if ((edid->blocks == 0) || (edid->blocks > 256))
 584                 return -EINVAL;
 585         if (!edid->edid)
 586                 return -EINVAL;
 587         if (!state->edid.segments) {
 588                 v4l2_dbg(1, debug, sd, "EDID segment 0 not found\n");
 589                 return -ENODATA;
 590         }
 591         if (edid->start_block >= state->edid.segments * 2)
 592                 return -E2BIG;
 593         if ((edid->blocks + edid->start_block) >= state->edid.segments * 2)
 594                 edid->blocks = state->edid.segments * 2 - edid->start_block;
 595
 596         memcpy(edid->edid, &state->edid.data[edid->start_block * 128],
 597                         128 * edid->blocks);
 598         return 0;
 599 }
 600
 601 static const struct v4l2_subdev_pad_ops adv7511_pad_ops = {
 602         .get_edid = adv7511_get_edid,
 603 };
 604
 605 static const struct v4l2_subdev_core_ops adv7511_core_ops = {
 606         .log_status = adv7511_log_status,
 607 #ifdef CONFIG_VIDEO_ADV_DEBUG
 608         .g_register = adv7511_g_register,
 609         .s_register = adv7511_s_register,
 610 #endif
 611         .s_power = adv7511_s_power,
 612         .interrupt_service_routine = adv7511_isr,
 613 };
 614
 615 /* ------------------------------ VIDEO OPS ------------------------------ */
 616
 617 /* Enable/disable adv7511 output */
 618 static int adv7511_s_stream(struct v4l2_subdev *sd, int enable)
 619 {
 620         struct adv7511_state *state = get_adv7511_state(sd);
 621
 622         v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
 623         adv7511_wr_and_or(sd, 0xa1, ~0x3c, (enable ? 0 : 0x3c));
 624         if (enable) {
 625                 adv7511_check_monitor_present_status(sd);
 626         } else {
 627                 adv7511_s_power(sd, 0);
 628                 state->have_monitor = false;
 629         }
 630         return 0;
 631 }
 632
 633 static int adv7511_s_dv_timings(struct v4l2_subdev *sd,
 634                                struct v4l2_dv_timings *timings)
 635 {
 636         struct adv7511_state *state = get_adv7511_state(sd);
 637
 638         v4l2_dbg(1, debug, sd, "%s:\n", __func__);
 639
 640         /* quick sanity check */
 641         if (!v4l2_valid_dv_timings(timings, &adv7511_timings_cap, NULL, NULL))
 642                 return -EINVAL;
 643
 644         /* Fill the optional fields .standards and .flags in struct v4l2_dv_timings
 645            if the format is one of the CEA or DMT timings. */
 646         v4l2_find_dv_timings_cap(timings, &adv7511_timings_cap, 0, NULL, NULL);
 647
 648         timings->bt.flags &= ~V4L2_DV_FL_REDUCED_FPS;
 649
 650         /* save timings */
 651         state->dv_timings = *timings;
 652
 653         /* update quantization range based on new dv_timings */
 654         adv7511_set_rgb_quantization_mode(sd, state->rgb_quantization_range_ctrl);
 655
 656         /* update AVI infoframe */
 657         adv7511_set_IT_content_AVI_InfoFrame(sd);
 658
 659         return 0;
 660 }
 661
 662 static int adv7511_g_dv_timings(struct v4l2_subdev *sd,
 663                                 struct v4l2_dv_timings *timings)
 664 {
 665         struct adv7511_state *state = get_adv7511_state(sd);
 666
 667         v4l2_dbg(1, debug, sd, "%s:\n", __func__);
 668
 669         if (!timings)
 670                 return -EINVAL;
 671
 672         *timings = state->dv_timings;
 673
 674         return 0;
 675 }
 676
 677 static int adv7511_enum_dv_timings(struct v4l2_subdev *sd,
 678                                    struct v4l2_enum_dv_timings *timings)
 679 {
 680         return v4l2_enum_dv_timings_cap(timings, &adv7511_timings_cap, NULL, NULL);
 681 }
 682
 683 static int adv7511_dv_timings_cap(struct v4l2_subdev *sd,
 684                                   struct v4l2_dv_timings_cap *cap)
 685 {
 686         *cap = adv7511_timings_cap;
 687         return 0;
 688 }
 689
 690 static const struct v4l2_subdev_video_ops adv7511_video_ops = {
 691         .s_stream = adv7511_s_stream,
 692         .s_dv_timings = adv7511_s_dv_timings,
 693         .g_dv_timings = adv7511_g_dv_timings,
 694         .enum_dv_timings = adv7511_enum_dv_timings,
 695         .dv_timings_cap = adv7511_dv_timings_cap,
 696 };
 697
 698 /* ------------------------------ AUDIO OPS ------------------------------ */
 699 static int adv7511_s_audio_stream(struct v4l2_subdev *sd, int enable)
 700 {
 701         v4l2_dbg(1, debug, sd, "%s: %sable\n", __func__, (enable ? "en" : "dis"));
 702
 703         if (enable)
 704                 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x80);
 705         else
 706                 adv7511_wr_and_or(sd, 0x4b, 0x3f, 0x40);
 707
 708         return 0;
 709 }
 710
 711 static int adv7511_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
 712 {
 713         u32 N;
 714
 715         switch (freq) {
 716         case 32000:  N = 4096;  break;
 717         case 44100:  N = 6272;  break;
 718         case 48000:  N = 6144;  break;
 719         case 88200:  N = 12544; break;
 720         case 96000:  N = 12288; break;
 721         case 176400: N = 25088; break;
 722         case 192000: N = 24576; break;
 723         default:
 724                 return -EINVAL;
 725         }
 726
 727         /* Set N (used with CTS to regenerate the audio clock) */
 728         adv7511_wr(sd, 0x01, (N >> 16) & 0xf);
 729         adv7511_wr(sd, 0x02, (N >> 8) & 0xff);
 730         adv7511_wr(sd, 0x03, N & 0xff);
 731
 732         return 0;
 733 }
 734
 735 static int adv7511_s_i2s_clock_freq(struct v4l2_subdev *sd, u32 freq)
 736 {
 737         u32 i2s_sf;
 738
 739         switch (freq) {
 740         case 32000:  i2s_sf = 0x30; break;
 741         case 44100:  i2s_sf = 0x00; break;
 742         case 48000:  i2s_sf = 0x20; break;
 743         case 88200:  i2s_sf = 0x80; break;
 744         case 96000:  i2s_sf = 0xa0; break;
 745         case 176400: i2s_sf = 0xc0; break;
 746         case 192000: i2s_sf = 0xe0; break;
 747         default:
 748                 return -EINVAL;
 749         }
 750
 751         /* Set sampling frequency for I2S audio to 48 kHz */
 752         adv7511_wr_and_or(sd, 0x15, 0xf, i2s_sf);
 753
 754         return 0;
 755 }
 756
 757 static int adv7511_s_routing(struct v4l2_subdev *sd, u32 input, u32 output, u32 config)
 758 {
 759         /* Only 2 channels in use for application */
 760         adv7511_wr_and_or(sd, 0x73, 0xf8, 0x1);
 761         /* Speaker mapping */
 762         adv7511_wr(sd, 0x76, 0x00);
 763
 764         /* 16 bit audio word length */
 765         adv7511_wr_and_or(sd, 0x14, 0xf0, 0x02);
 766
 767         return 0;
 768 }
 769
 770 static const struct v4l2_subdev_audio_ops adv7511_audio_ops = {
 771         .s_stream = adv7511_s_audio_stream,
 772         .s_clock_freq = adv7511_s_clock_freq,
 773         .s_i2s_clock_freq = adv7511_s_i2s_clock_freq,
 774         .s_routing = adv7511_s_routing,
 775 };
 776
 777 /* --------------------- SUBDEV OPS --------------------------------------- */
 778
 779 static const struct v4l2_subdev_ops adv7511_ops = {
 780         .core  = &adv7511_core_ops,
 781         .pad  = &adv7511_pad_ops,
 782         .video = &adv7511_video_ops,
 783         .audio = &adv7511_audio_ops,
 784 };
 785
 786 /* ----------------------------------------------------------------------- */
 787 static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, uint8_t *buf)
 788 {
 789         if (debug >= lvl) {
 790                 int i, j;
 791                 v4l2_dbg(lvl, debug, sd, "edid segment %d\n", segment);
 792                 for (i = 0; i < 256; i += 16) {
 793                         u8 b[128];
 794                         u8 *bp = b;
 795                         if (i == 128)
 796                                 v4l2_dbg(lvl, debug, sd, "\n");
 797                         for (j = i; j < i + 16; j++) {
 798                                 sprintf(bp, "0x%02x, ", buf[j]);
 799                                 bp += 6;
 800                         }
 801                         bp[0] = '\0';
 802                         v4l2_dbg(lvl, debug, sd, "%s\n", b);
 803                 }
 804         }
 805 }
 806
 807 static void adv7511_edid_handler(struct work_struct *work)
 808 {
 809         struct delayed_work *dwork = to_delayed_work(work);
 810         struct adv7511_state *state = container_of(dwork, struct adv7511_state, edid_handler);
 811         struct v4l2_subdev *sd = &state->sd;
 812         struct adv7511_edid_detect ed;
 813
 814         v4l2_dbg(1, debug, sd, "%s:\n", __func__);
 815
 816         if (adv7511_check_edid_status(sd)) {
 817                 /* Return if we received the EDID. */
 818                 return;
 819         }
 820
 821         if (adv7511_have_hotplug(sd)) {
 822                 /* We must retry reading the EDID several times, it is possible
 823                  * that initially the EDID couldn't be read due to i2c errors
 824                  * (DVI connectors are particularly prone to this problem). */
 825                 if (state->edid.read_retries) {
 826                         state->edid.read_retries--;
 827                         v4l2_dbg(1, debug, sd, "%s: edid read failed\n", __func__);
 828                         state->have_monitor = false;
 829                         adv7511_s_power(sd, false);
 830                         adv7511_s_power(sd, true);
 831                         queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
 832                         return;
 833                 }
 834         }
 835
 836         /* We failed to read the EDID, so send an event for this. */
 837         ed.present = false;
 838         ed.segment = adv7511_rd(sd, 0xc4);
 839         v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
 840         v4l2_dbg(1, debug, sd, "%s: no edid found\n", __func__);
 841 }
 842
 843 static void adv7511_audio_setup(struct v4l2_subdev *sd)
 844 {
 845         v4l2_dbg(1, debug, sd, "%s\n", __func__);
 846
 847         adv7511_s_i2s_clock_freq(sd, 48000);
 848         adv7511_s_clock_freq(sd, 48000);
 849         adv7511_s_routing(sd, 0, 0, 0);
 850 }
 851
 852 /* Configure hdmi transmitter. */
 853 static void adv7511_setup(struct v4l2_subdev *sd)
 854 {
 855         struct adv7511_state *state = get_adv7511_state(sd);
 856         v4l2_dbg(1, debug, sd, "%s\n", __func__);
 857
 858         /* Input format: RGB 4:4:4 */
 859         adv7511_wr_and_or(sd, 0x15, 0xf0, 0x0);
 860         /* Output format: RGB 4:4:4 */
 861         adv7511_wr_and_or(sd, 0x16, 0x7f, 0x0);
 862         /* 1st order interpolation 4:2:2 -> 4:4:4 up conversion, Aspect ratio: 16:9 */
 863         adv7511_wr_and_or(sd, 0x17, 0xf9, 0x06);
 864         /* Disable pixel repetition */
 865         adv7511_wr_and_or(sd, 0x3b, 0x9f, 0x0);
 866         /* Disable CSC */
 867         adv7511_wr_and_or(sd, 0x18, 0x7f, 0x0);
 868         /* Output format: RGB 4:4:4, Active Format Information is valid,
 869          * underscanned */
 870         adv7511_wr_and_or(sd, 0x55, 0x9c, 0x12);
 871         /* AVI Info frame packet enable, Audio Info frame disable */
 872         adv7511_wr_and_or(sd, 0x44, 0xe7, 0x10);
 873         /* Colorimetry, Active format aspect ratio: same as picure. */
 874         adv7511_wr(sd, 0x56, 0xa8);
 875         /* No encryption */
 876         adv7511_wr_and_or(sd, 0xaf, 0xed, 0x0);
 877
 878         /* Positive clk edge capture for input video clock */
 879         adv7511_wr_and_or(sd, 0xba, 0x1f, 0x60);
 880
 881         adv7511_audio_setup(sd);
 882
 883         v4l2_ctrl_handler_setup(&state->hdl);
 884 }
 885
 886 static void adv7511_notify_monitor_detect(struct v4l2_subdev *sd)
 887 {
 888         struct adv7511_monitor_detect mdt;
 889         struct adv7511_state *state = get_adv7511_state(sd);
 890
 891         mdt.present = state->have_monitor;
 892         v4l2_subdev_notify(sd, ADV7511_MONITOR_DETECT, (void *)&mdt);
 893 }
 894
 895 static void adv7511_check_monitor_present_status(struct v4l2_subdev *sd)
 896 {
 897         struct adv7511_state *state = get_adv7511_state(sd);
 898         /* read hotplug and rx-sense state */
 899         uint8_t status = adv7511_rd(sd, 0x42);
 900
 901         v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
 902                          __func__,
 903                          status,
 904                          status & MASK_ADV7511_HPD_DETECT ? ", hotplug" : "",
 905                          status & MASK_ADV7511_MSEN_DETECT ? ", rx-sense" : "");
 906
 907         /* update read only ctrls */
 908         v4l2_ctrl_s_ctrl(state->hotplug_ctrl, adv7511_have_hotplug(sd) ? 0x1 : 0x0);
 909         v4l2_ctrl_s_ctrl(state->rx_sense_ctrl, adv7511_have_rx_sense(sd) ? 0x1 : 0x0);
 910         v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, state->edid.segments ? 0x1 : 0x0);
 911
 912         if ((status & MASK_ADV7511_HPD_DETECT) && ((status & MASK_ADV7511_MSEN_DETECT) || state->edid.segments)) {
 913                 v4l2_dbg(1, debug, sd, "%s: hotplug and (rx-sense or edid)\n", __func__);
 914                 if (!state->have_monitor) {
 915                         v4l2_dbg(1, debug, sd, "%s: monitor detected\n", __func__);
 916                         state->have_monitor = true;
 917                         adv7511_set_isr(sd, true);
 918                         if (!adv7511_s_power(sd, true)) {
 919                                 v4l2_dbg(1, debug, sd, "%s: monitor detected, powerup failed\n", __func__);
 920                                 return;
 921                         }
 922                         adv7511_setup(sd);
 923                         adv7511_notify_monitor_detect(sd);
 924                         state->edid.read_retries = EDID_MAX_RETRIES;
 925                         queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
 926                 }
 927         } else if (status & MASK_ADV7511_HPD_DETECT) {
 928                 v4l2_dbg(1, debug, sd, "%s: hotplug detected\n", __func__);
 929                 state->edid.read_retries = EDID_MAX_RETRIES;
 930                 queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
 931         } else if (!(status & MASK_ADV7511_HPD_DETECT)) {
 932                 v4l2_dbg(1, debug, sd, "%s: hotplug not detected\n", __func__);
 933                 if (state->have_monitor) {
 934                         v4l2_dbg(1, debug, sd, "%s: monitor not detected\n", __func__);
 935                         state->have_monitor = false;
 936                         adv7511_notify_monitor_detect(sd);
 937                 }
 938                 adv7511_s_power(sd, false);
 939                 memset(&state->edid, 0, sizeof(struct adv7511_state_edid));
 940         }
 941 }
 942
 943 static bool edid_block_verify_crc(uint8_t *edid_block)
 944 {
 945         int i;
 946         uint8_t sum = 0;
 947
 948         for (i = 0; i < 128; i++)
 949                 sum += *(edid_block + i);
 950         return (sum == 0);
 951 }
 952
 953 static bool edid_segment_verify_crc(struct v4l2_subdev *sd, u32 segment)
 954 {
 955         struct adv7511_state *state = get_adv7511_state(sd);
 956         u32 blocks = state->edid.blocks;
 957         uint8_t *data = state->edid.data;
 958
 959         if (edid_block_verify_crc(&data[segment * 256])) {
 960                 if ((segment + 1) * 2 <= blocks)
 961                         return edid_block_verify_crc(&data[segment * 256 + 128]);
 962                 return true;
 963         }
 964         return false;
 965 }
 966
 967 static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
 968 {
 969         struct adv7511_state *state = get_adv7511_state(sd);
 970         uint8_t edidRdy = adv7511_rd(sd, 0xc5);
 971
 972         v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
 973                          __func__, EDID_MAX_RETRIES - state->edid.read_retries);
 974
 975         if (state->edid.complete)
 976                 return true;
 977
 978         if (edidRdy & MASK_ADV7511_EDID_RDY) {
 979                 int segment = adv7511_rd(sd, 0xc4);
 980                 struct adv7511_edid_detect ed;
 981
 982                 if (segment >= EDID_MAX_SEGM) {
 983                         v4l2_err(sd, "edid segment number too big\n");
 984                         return false;
 985                 }
 986                 v4l2_dbg(1, debug, sd, "%s: got segment %d\n", __func__, segment);
 987                 adv7511_edid_rd(sd, 256, &state->edid.data[segment * 256]);
 988                 adv7511_dbg_dump_edid(2, debug, sd, segment, &state->edid.data[segment * 256]);
 989                 if (segment == 0) {
 990                         state->edid.blocks = state->edid.data[0x7e] + 1;
 991                         v4l2_dbg(1, debug, sd, "%s: %d blocks in total\n", __func__, state->edid.blocks);
 992                 }
 993                 if (!edid_segment_verify_crc(sd, segment)) {
 994                         /* edid crc error, force reread of edid segment */
 995                         v4l2_dbg(1, debug, sd, "%s: edid crc error\n", __func__);
 996                         state->have_monitor = false;
 997                         adv7511_s_power(sd, false);
 998                         adv7511_s_power(sd, true);
 999                         return false;
1000                 }
1001                 /* one more segment read ok */
1002                 state->edid.segments = segment + 1;
1003                 if (((state->edid.data[0x7e] >> 1) + 1) > state->edid.segments) {
1004                         /* Request next EDID segment */
1005                         v4l2_dbg(1, debug, sd, "%s: request segment %d\n", __func__, state->edid.segments);
1006                         adv7511_wr(sd, 0xc9, 0xf);
1007                         adv7511_wr(sd, 0xc4, state->edid.segments);
1008                         state->edid.read_retries = EDID_MAX_RETRIES;
1009                         queue_delayed_work(state->work_queue, &state->edid_handler, EDID_DELAY);
1010                         return false;
1011                 }
1012
1013                 v4l2_dbg(1, debug, sd, "%s: edid complete with %d segment(s)\n", __func__, state->edid.segments);
1014                 state->edid.complete = true;
1015
1016                 /* report when we have all segments
1017                    but report only for segment 0
1018                  */
1019                 ed.present = true;
1020                 ed.segment = 0;
1021                 state->edid_detect_counter++;
1022                 v4l2_ctrl_s_ctrl(state->have_edid0_ctrl, state->edid.segments ? 0x1 : 0x0);
1023                 v4l2_subdev_notify(sd, ADV7511_EDID_DETECT, (void *)&ed);
1024                 return ed.present;
1025         }
1026
1027         return false;
1028 }
1029
1030 /* ----------------------------------------------------------------------- */
1031 /* Setup ADV7511 */
1032 static void adv7511_init_setup(struct v4l2_subdev *sd)
1033 {
1034         struct adv7511_state *state = get_adv7511_state(sd);
1035         struct adv7511_state_edid *edid = &state->edid;
1036
1037         v4l2_dbg(1, debug, sd, "%s\n", __func__);
1038
1039         /* clear all interrupts */
1040         adv7511_wr(sd, 0x96, 0xff);
1041         memset(edid, 0, sizeof(struct adv7511_state_edid));
1042         state->have_monitor = false;
1043         adv7511_set_isr(sd, false);
1044         adv7511_s_stream(sd, false);
1045         adv7511_s_audio_stream(sd, false);
1046 }
1047
1048 static int adv7511_probe(struct i2c_client *client, const struct i2c_device_id *id)
1049 {
1050         struct adv7511_state *state;
1051         struct adv7511_platform_data *pdata = client->dev.platform_data;
1052         struct v4l2_ctrl_handler *hdl;
1053         struct v4l2_subdev *sd;
1054         u8 chip_id[2];
1055         int err = -EIO;
1056
1057         /* Check if the adapter supports the needed features */
1058         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1059                 return -EIO;
1060
1061         state = devm_kzalloc(&client->dev, sizeof(struct adv7511_state), GFP_KERNEL);
1062         if (!state)
1063                 return -ENOMEM;
1064
1065         /* Platform data */
1066         if (!pdata) {
1067                 v4l_err(client, "No platform data!\n");
1068                 return -ENODEV;
1069         }
1070         memcpy(&state->pdata, pdata, sizeof(state->pdata));
1071
1072         sd = &state->sd;
1073
1074         v4l2_dbg(1, debug, sd, "detecting adv7511 client on address 0x%x\n",
1075                          client->addr << 1);
1076
1077         v4l2_i2c_subdev_init(sd, client, &adv7511_ops);
1078
1079         hdl = &state->hdl;
1080         v4l2_ctrl_handler_init(hdl, 10);
1081         /* add in ascending ID order */
1082         state->hdmi_mode_ctrl = v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1083                         V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1084                         0, V4L2_DV_TX_MODE_DVI_D);
1085         state->hotplug_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1086                         V4L2_CID_DV_TX_HOTPLUG, 0, 1, 0, 0);
1087         state->rx_sense_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1088                         V4L2_CID_DV_TX_RXSENSE, 0, 1, 0, 0);
1089         state->have_edid0_ctrl = v4l2_ctrl_new_std(hdl, NULL,
1090                         V4L2_CID_DV_TX_EDID_PRESENT, 0, 1, 0, 0);
1091         state->rgb_quantization_range_ctrl =
1092                 v4l2_ctrl_new_std_menu(hdl, &adv7511_ctrl_ops,
1093                         V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1094                         0, V4L2_DV_RGB_RANGE_AUTO);
1095         sd->ctrl_handler = hdl;
1096         if (hdl->error) {
1097                 err = hdl->error;
1098                 goto err_hdl;
1099         }
1100         state->hdmi_mode_ctrl->is_private = true;
1101         state->hotplug_ctrl->is_private = true;
1102         state->rx_sense_ctrl->is_private = true;
1103         state->have_edid0_ctrl->is_private = true;
1104         state->rgb_quantization_range_ctrl->is_private = true;
1105
1106         state->pad.flags = MEDIA_PAD_FL_SINK;
1107         err = media_entity_init(&sd->entity, 1, &state->pad, 0);
1108         if (err)
1109                 goto err_hdl;
1110
1111         /* EDID and CEC i2c addr */
1112         state->i2c_edid_addr = state->pdata.i2c_edid << 1;
1113         state->i2c_cec_addr = state->pdata.i2c_cec << 1;
1114
1115         state->chip_revision = adv7511_rd(sd, 0x0);
1116         chip_id[0] = adv7511_rd(sd, 0xf5);
1117         chip_id[1] = adv7511_rd(sd, 0xf6);
1118         if (chip_id[0] != 0x75 || chip_id[1] != 0x11) {
1119                 v4l2_err(sd, "chip_id != 0x7511, read 0x%02x%02x\n", chip_id[0], chip_id[1]);
1120                 err = -EIO;
1121                 goto err_entity;
1122         }
1123
1124         state->i2c_edid = i2c_new_dummy(client->adapter, state->i2c_edid_addr >> 1);
1125         if (state->i2c_edid == NULL) {
1126                 v4l2_err(sd, "failed to register edid i2c client\n");
1127                 err = -ENOMEM;
1128                 goto err_entity;
1129         }
1130
1131         adv7511_wr(sd, 0xe2, 0x01); /* power down cec section */
1132         state->work_queue = create_singlethread_workqueue(sd->name);
1133         if (state->work_queue == NULL) {
1134                 v4l2_err(sd, "could not create workqueue\n");
1135                 err = -ENOMEM;
1136                 goto err_unreg_cec;
1137         }
1138
1139         INIT_DELAYED_WORK(&state->edid_handler, adv7511_edid_handler);
1140
1141         adv7511_init_setup(sd);
1142         adv7511_set_isr(sd, true);
1143         adv7511_check_monitor_present_status(sd);
1144
1145         v4l2_info(sd, "%s found @ 0x%x (%s)\n", client->name,
1146                           client->addr << 1, client->adapter->name);
1147         return 0;
1148
1149 err_unreg_cec:
1150         i2c_unregister_device(state->i2c_edid);
1151 err_entity:
1152         media_entity_cleanup(&sd->entity);
1153 err_hdl:
1154         v4l2_ctrl_handler_free(&state->hdl);
1155         return err;
1156 }
1157
1158 /* ----------------------------------------------------------------------- */
1159
1160 static int adv7511_remove(struct i2c_client *client)
1161 {
1162         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1163         struct adv7511_state *state = get_adv7511_state(sd);
1164
1165         state->chip_revision = -1;
1166
1167         v4l2_dbg(1, debug, sd, "%s removed @ 0x%x (%s)\n", client->name,
1168                  client->addr << 1, client->adapter->name);
1169
1170         adv7511_init_setup(sd);
1171         cancel_delayed_work(&state->edid_handler);
1172         i2c_unregister_device(state->i2c_edid);
1173         destroy_workqueue(state->work_queue);
1174         v4l2_device_unregister_subdev(sd);
1175         media_entity_cleanup(&sd->entity);
1176         v4l2_ctrl_handler_free(sd->ctrl_handler);
1177         return 0;
1178 }
1179
1180 /* ----------------------------------------------------------------------- */
1181
1182 static struct i2c_device_id adv7511_id[] = {
1183         { "adv7511", 0 },
1184         { }
1185 };
1186 MODULE_DEVICE_TABLE(i2c, adv7511_id);
1187
1188 static struct i2c_driver adv7511_driver = {
1189         .driver = {
1190                 .owner = THIS_MODULE,
1191                 .name = "adv7511",
1192         },
1193         .probe = adv7511_probe,
1194         .remove = adv7511_remove,
1195         .id_table = adv7511_id,
1196 };
1197
1198 module_i2c_driver(adv7511_driver);