drivers/media/i2c/bt819.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  bt819 - BT819A VideoStream Decoder (Rockwell Part)
   4  *
   5  * Copyright (C) 1999 Mike Bernson <mike@mlb.org>
   6  * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
   7  *
   8  * Modifications for LML33/DC10plus unified driver
   9  * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
  10  *
  11  * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
  12  *    - moved over to linux>=2.4.x i2c protocol (9/9/2002)
  13  *
  14  * This code was modify/ported from the saa7111 driver written
  15  * by Dave Perks.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/types.h>
  20 #include <linux/ioctl.h>
  21 #include <linux/delay.h>
  22 #include <linux/i2c.h>
  23 #include <linux/videodev2.h>
  24 #include <linux/slab.h>
  25 #include <media/v4l2-device.h>
  26 #include <media/v4l2-ctrls.h>
  27 #include <media/i2c/bt819.h>
  28
  29 MODULE_DESCRIPTION("Brooktree-819 video decoder driver");
  30 MODULE_AUTHOR("Mike Bernson & Dave Perks");
  31 MODULE_LICENSE("GPL");
  32
  33 static int debug;
  34 module_param(debug, int, 0);
  35 MODULE_PARM_DESC(debug, "Debug level (0-1)");
  36
  37
  38 /* ----------------------------------------------------------------------- */
  39
  40 struct bt819 {
  41         struct v4l2_subdev sd;
  42         struct v4l2_ctrl_handler hdl;
  43         unsigned char reg[32];
  44
  45         v4l2_std_id norm;
  46         int input;
  47         int enable;
  48 };
  49
  50 static inline struct bt819 *to_bt819(struct v4l2_subdev *sd)
  51 {
  52         return container_of(sd, struct bt819, sd);
  53 }
  54
  55 static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
  56 {
  57         return &container_of(ctrl->handler, struct bt819, hdl)->sd;
  58 }
  59
  60 struct timing {
  61         int hactive;
  62         int hdelay;
  63         int vactive;
  64         int vdelay;
  65         int hscale;
  66         int vscale;
  67 };
  68
  69 /* for values, see the bt819 datasheet */
  70 static struct timing timing_data[] = {
  71         {864 - 24, 20, 625 - 2, 1, 0x0504, 0x0000},
  72         {858 - 24, 20, 525 - 2, 1, 0x00f8, 0x0000},
  73 };
  74
  75 /* ----------------------------------------------------------------------- */
  76
  77 static inline int bt819_write(struct bt819 *decoder, u8 reg, u8 value)
  78 {
  79         struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
  80
  81         decoder->reg[reg] = value;
  82         return i2c_smbus_write_byte_data(client, reg, value);
  83 }
  84
  85 static inline int bt819_setbit(struct bt819 *decoder, u8 reg, u8 bit, u8 value)
  86 {
  87         return bt819_write(decoder, reg,
  88                 (decoder->reg[reg] & ~(1 << bit)) | (value ? (1 << bit) : 0));
  89 }
  90
  91 static int bt819_write_block(struct bt819 *decoder, const u8 *data, unsigned int len)
  92 {
  93         struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
  94         int ret = -1;
  95         u8 reg;
  96
  97         /* the bt819 has an autoincrement function, use it if
  98          * the adapter understands raw I2C */
  99         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 100                 /* do raw I2C, not smbus compatible */
 101                 u8 block_data[32];
 102                 int block_len;
 103
 104                 while (len >= 2) {
 105                         block_len = 0;
 106                         block_data[block_len++] = reg = data[0];
 107                         do {
 108                                 block_data[block_len++] =
 109                                     decoder->reg[reg++] = data[1];
 110                                 len -= 2;
 111                                 data += 2;
 112                         } while (len >= 2 && data[0] == reg && block_len < 32);
 113                         ret = i2c_master_send(client, block_data, block_len);
 114                         if (ret < 0)
 115                                 break;
 116                 }
 117         } else {
 118                 /* do some slow I2C emulation kind of thing */
 119                 while (len >= 2) {
 120                         reg = *data++;
 121                         ret = bt819_write(decoder, reg, *data++);
 122                         if (ret < 0)
 123                                 break;
 124                         len -= 2;
 125                 }
 126         }
 127
 128         return ret;
 129 }
 130
 131 static inline int bt819_read(struct bt819 *decoder, u8 reg)
 132 {
 133         struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
 134
 135         return i2c_smbus_read_byte_data(client, reg);
 136 }
 137
 138 static int bt819_init(struct v4l2_subdev *sd)
 139 {
 140         static unsigned char init[] = {
 141                 /*0x1f, 0x00,*/     /* Reset */
 142                 0x01, 0x59,     /* 0x01 input format */
 143                 0x02, 0x00,     /* 0x02 temporal decimation */
 144                 0x03, 0x12,     /* 0x03 Cropping msb */
 145                 0x04, 0x16,     /* 0x04 Vertical Delay, lsb */
 146                 0x05, 0xe0,     /* 0x05 Vertical Active lsb */
 147                 0x06, 0x80,     /* 0x06 Horizontal Delay lsb */
 148                 0x07, 0xd0,     /* 0x07 Horizontal Active lsb */
 149                 0x08, 0x00,     /* 0x08 Horizontal Scaling msb */
 150                 0x09, 0xf8,     /* 0x09 Horizontal Scaling lsb */
 151                 0x0a, 0x00,     /* 0x0a Brightness control */
 152                 0x0b, 0x30,     /* 0x0b Miscellaneous control */
 153                 0x0c, 0xd8,     /* 0x0c Luma Gain lsb */
 154                 0x0d, 0xfe,     /* 0x0d Chroma Gain (U) lsb */
 155                 0x0e, 0xb4,     /* 0x0e Chroma Gain (V) msb */
 156                 0x0f, 0x00,     /* 0x0f Hue control */
 157                 0x12, 0x04,     /* 0x12 Output Format */
 158                 0x13, 0x20,     /* 0x13 Vertical Scaling msb 0x00
 159                                            chroma comb OFF, line drop scaling, interlace scaling
 160                                            BUG? Why does turning the chroma comb on screw up color?
 161                                            Bug in the bt819 stepping on my board?
 162                                         */
 163                 0x14, 0x00,     /* 0x14 Vertical Scaling lsb */
 164                 0x16, 0x07,     /* 0x16 Video Timing Polarity
 165                                            ACTIVE=active low
 166                                            FIELD: high=odd,
 167                                            vreset=active high,
 168                                            hreset=active high */
 169                 0x18, 0x68,     /* 0x18 AGC Delay */
 170                 0x19, 0x5d,     /* 0x19 Burst Gate Delay */
 171                 0x1a, 0x80,     /* 0x1a ADC Interface */
 172         };
 173
 174         struct bt819 *decoder = to_bt819(sd);
 175         struct timing *timing = &timing_data[(decoder->norm & V4L2_STD_525_60) ? 1 : 0];
 176
 177         init[0x03 * 2 - 1] =
 178             (((timing->vdelay >> 8) & 0x03) << 6) |
 179             (((timing->vactive >> 8) & 0x03) << 4) |
 180             (((timing->hdelay >> 8) & 0x03) << 2) |
 181             ((timing->hactive >> 8) & 0x03);
 182         init[0x04 * 2 - 1] = timing->vdelay & 0xff;
 183         init[0x05 * 2 - 1] = timing->vactive & 0xff;
 184         init[0x06 * 2 - 1] = timing->hdelay & 0xff;
 185         init[0x07 * 2 - 1] = timing->hactive & 0xff;
 186         init[0x08 * 2 - 1] = timing->hscale >> 8;
 187         init[0x09 * 2 - 1] = timing->hscale & 0xff;
 188         /* 0x15 in array is address 0x19 */
 189         init[0x15 * 2 - 1] = (decoder->norm & V4L2_STD_625_50) ? 115 : 93;      /* Chroma burst delay */
 190         /* reset */
 191         bt819_write(decoder, 0x1f, 0x00);
 192         mdelay(1);
 193
 194         /* init */
 195         return bt819_write_block(decoder, init, sizeof(init));
 196 }
 197
 198 /* ----------------------------------------------------------------------- */
 199
 200 static int bt819_status(struct v4l2_subdev *sd, u32 *pstatus, v4l2_std_id *pstd)
 201 {
 202         struct bt819 *decoder = to_bt819(sd);
 203         int status = bt819_read(decoder, 0x00);
 204         int res = V4L2_IN_ST_NO_SIGNAL;
 205         v4l2_std_id std = pstd ? *pstd : V4L2_STD_ALL;
 206
 207         if ((status & 0x80))
 208                 res = 0;
 209         else
 210                 std = V4L2_STD_UNKNOWN;
 211
 212         if ((status & 0x10))
 213                 std &= V4L2_STD_PAL;
 214         else
 215                 std &= V4L2_STD_NTSC;
 216         if (pstd)
 217                 *pstd = std;
 218         if (pstatus)
 219                 *pstatus = res;
 220
 221         v4l2_dbg(1, debug, sd, "get status %x\n", status);
 222         return 0;
 223 }
 224
 225 static int bt819_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
 226 {
 227         return bt819_status(sd, NULL, std);
 228 }
 229
 230 static int bt819_g_input_status(struct v4l2_subdev *sd, u32 *status)
 231 {
 232         return bt819_status(sd, status, NULL);
 233 }
 234
 235 static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
 236 {
 237         struct bt819 *decoder = to_bt819(sd);
 238         struct timing *timing = NULL;
 239
 240         v4l2_dbg(1, debug, sd, "set norm %llx\n", (unsigned long long)std);
 241
 242         if (sd->v4l2_dev == NULL || sd->v4l2_dev->notify == NULL)
 243                 v4l2_err(sd, "no notify found!\n");
 244
 245         if (std & V4L2_STD_NTSC) {
 246                 v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
 247                 bt819_setbit(decoder, 0x01, 0, 1);
 248                 bt819_setbit(decoder, 0x01, 1, 0);
 249                 bt819_setbit(decoder, 0x01, 5, 0);
 250                 bt819_write(decoder, 0x18, 0x68);
 251                 bt819_write(decoder, 0x19, 0x5d);
 252                 /* bt819_setbit(decoder, 0x1a,  5, 1); */
 253                 timing = &timing_data[1];
 254         } else if (std & V4L2_STD_PAL) {
 255                 v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
 256                 bt819_setbit(decoder, 0x01, 0, 1);
 257                 bt819_setbit(decoder, 0x01, 1, 1);
 258                 bt819_setbit(decoder, 0x01, 5, 1);
 259                 bt819_write(decoder, 0x18, 0x7f);
 260                 bt819_write(decoder, 0x19, 0x72);
 261                 /* bt819_setbit(decoder, 0x1a,  5, 0); */
 262                 timing = &timing_data[0];
 263         } else {
 264                 v4l2_dbg(1, debug, sd, "unsupported norm %llx\n",
 265                                 (unsigned long long)std);
 266                 return -EINVAL;
 267         }
 268         bt819_write(decoder, 0x03,
 269                         (((timing->vdelay >> 8) & 0x03) << 6) |
 270                         (((timing->vactive >> 8) & 0x03) << 4) |
 271                         (((timing->hdelay >> 8) & 0x03) << 2) |
 272                         ((timing->hactive >> 8) & 0x03));
 273         bt819_write(decoder, 0x04, timing->vdelay & 0xff);
 274         bt819_write(decoder, 0x05, timing->vactive & 0xff);
 275         bt819_write(decoder, 0x06, timing->hdelay & 0xff);
 276         bt819_write(decoder, 0x07, timing->hactive & 0xff);
 277         bt819_write(decoder, 0x08, (timing->hscale >> 8) & 0xff);
 278         bt819_write(decoder, 0x09, timing->hscale & 0xff);
 279         decoder->norm = std;
 280         v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
 281         return 0;
 282 }
 283
 284 static int bt819_s_routing(struct v4l2_subdev *sd,
 285                            u32 input, u32 output, u32 config)
 286 {
 287         struct bt819 *decoder = to_bt819(sd);
 288
 289         v4l2_dbg(1, debug, sd, "set input %x\n", input);
 290
 291         if (input > 7)
 292                 return -EINVAL;
 293
 294         if (sd->v4l2_dev == NULL || sd->v4l2_dev->notify == NULL)
 295                 v4l2_err(sd, "no notify found!\n");
 296
 297         if (decoder->input != input) {
 298                 v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
 299                 decoder->input = input;
 300                 /* select mode */
 301                 if (decoder->input == 0) {
 302                         bt819_setbit(decoder, 0x0b, 6, 0);
 303                         bt819_setbit(decoder, 0x1a, 1, 1);
 304                 } else {
 305                         bt819_setbit(decoder, 0x0b, 6, 1);
 306                         bt819_setbit(decoder, 0x1a, 1, 0);
 307                 }
 308                 v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
 309         }
 310         return 0;
 311 }
 312
 313 static int bt819_s_stream(struct v4l2_subdev *sd, int enable)
 314 {
 315         struct bt819 *decoder = to_bt819(sd);
 316
 317         v4l2_dbg(1, debug, sd, "enable output %x\n", enable);
 318
 319         if (decoder->enable != enable) {
 320                 decoder->enable = enable;
 321                 bt819_setbit(decoder, 0x16, 7, !enable);
 322         }
 323         return 0;
 324 }
 325
 326 static int bt819_s_ctrl(struct v4l2_ctrl *ctrl)
 327 {
 328         struct v4l2_subdev *sd = to_sd(ctrl);
 329         struct bt819 *decoder = to_bt819(sd);
 330         int temp;
 331
 332         switch (ctrl->id) {
 333         case V4L2_CID_BRIGHTNESS:
 334                 bt819_write(decoder, 0x0a, ctrl->val);
 335                 break;
 336
 337         case V4L2_CID_CONTRAST:
 338                 bt819_write(decoder, 0x0c, ctrl->val & 0xff);
 339                 bt819_setbit(decoder, 0x0b, 2, ((ctrl->val >> 8) & 0x01));
 340                 break;
 341
 342         case V4L2_CID_SATURATION:
 343                 bt819_write(decoder, 0x0d, (ctrl->val >> 7) & 0xff);
 344                 bt819_setbit(decoder, 0x0b, 1, ((ctrl->val >> 15) & 0x01));
 345
 346                 /* Ratio between U gain and V gain must stay the same as
 347                    the ratio between the default U and V gain values. */
 348                 temp = (ctrl->val * 180) / 254;
 349                 bt819_write(decoder, 0x0e, (temp >> 7) & 0xff);
 350                 bt819_setbit(decoder, 0x0b, 0, (temp >> 15) & 0x01);
 351                 break;
 352
 353         case V4L2_CID_HUE:
 354                 bt819_write(decoder, 0x0f, ctrl->val);
 355                 break;
 356
 357         default:
 358                 return -EINVAL;
 359         }
 360         return 0;
 361 }
 362
 363 /* ----------------------------------------------------------------------- */
 364
 365 static const struct v4l2_ctrl_ops bt819_ctrl_ops = {
 366         .s_ctrl = bt819_s_ctrl,
 367 };
 368
 369 static const struct v4l2_subdev_video_ops bt819_video_ops = {
 370         .s_std = bt819_s_std,
 371         .s_routing = bt819_s_routing,
 372         .s_stream = bt819_s_stream,
 373         .querystd = bt819_querystd,
 374         .g_input_status = bt819_g_input_status,
 375 };
 376
 377 static const struct v4l2_subdev_ops bt819_ops = {
 378         .video = &bt819_video_ops,
 379 };
 380
 381 /* ----------------------------------------------------------------------- */
 382
 383 static int bt819_probe(struct i2c_client *client,
 384                         const struct i2c_device_id *id)
 385 {
 386         int i, ver;
 387         struct bt819 *decoder;
 388         struct v4l2_subdev *sd;
 389         const char *name;
 390
 391         /* Check if the adapter supports the needed features */
 392         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 393                 return -ENODEV;
 394
 395         decoder = devm_kzalloc(&client->dev, sizeof(*decoder), GFP_KERNEL);
 396         if (decoder == NULL)
 397                 return -ENOMEM;
 398         sd = &decoder->sd;
 399         v4l2_i2c_subdev_init(sd, client, &bt819_ops);
 400
 401         ver = bt819_read(decoder, 0x17);
 402         switch (ver & 0xf0) {
 403         case 0x70:
 404                 name = "bt819a";
 405                 break;
 406         case 0x60:
 407                 name = "bt817a";
 408                 break;
 409         case 0x20:
 410                 name = "bt815a";
 411                 break;
 412         default:
 413                 v4l2_dbg(1, debug, sd,
 414                         "unknown chip version 0x%02x\n", ver);
 415                 return -ENODEV;
 416         }
 417
 418         v4l_info(client, "%s found @ 0x%x (%s)\n", name,
 419                         client->addr << 1, client->adapter->name);
 420
 421         decoder->norm = V4L2_STD_NTSC;
 422         decoder->input = 0;
 423         decoder->enable = 1;
 424
 425         i = bt819_init(sd);
 426         if (i < 0)
 427                 v4l2_dbg(1, debug, sd, "init status %d\n", i);
 428
 429         v4l2_ctrl_handler_init(&decoder->hdl, 4);
 430         v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
 431                         V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
 432         v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
 433                         V4L2_CID_CONTRAST, 0, 511, 1, 0xd8);
 434         v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
 435                         V4L2_CID_SATURATION, 0, 511, 1, 0xfe);
 436         v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
 437                         V4L2_CID_HUE, -128, 127, 1, 0);
 438         sd->ctrl_handler = &decoder->hdl;
 439         if (decoder->hdl.error) {
 440                 int err = decoder->hdl.error;
 441
 442                 v4l2_ctrl_handler_free(&decoder->hdl);
 443                 return err;
 444         }
 445         v4l2_ctrl_handler_setup(&decoder->hdl);
 446         return 0;
 447 }
 448
 449 static int bt819_remove(struct i2c_client *client)
 450 {
 451         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 452         struct bt819 *decoder = to_bt819(sd);
 453
 454         v4l2_device_unregister_subdev(sd);
 455         v4l2_ctrl_handler_free(&decoder->hdl);
 456         return 0;
 457 }
 458
 459 /* ----------------------------------------------------------------------- */
 460
 461 static const struct i2c_device_id bt819_id[] = {
 462         { "bt819a", 0 },
 463         { "bt817a", 0 },
 464         { "bt815a", 0 },
 465         { }
 466 };
 467 MODULE_DEVICE_TABLE(i2c, bt819_id);
 468
 469 static struct i2c_driver bt819_driver = {
 470         .driver = {
 471                 .name   = "bt819",
 472         },
 473         .probe          = bt819_probe,
 474         .remove         = bt819_remove,
 475         .id_table       = bt819_id,
 476 };
 477
 478 module_i2c_driver(bt819_driver);