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