1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 4 bttv - Bt848 frame grabber driver 5 6 Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de> 7 & Marcus Metzler <mocm@thp.uni-koeln.de> 8 (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org> 9 10 some v4l2 code lines are taken from Justin's bttv2 driver which is 11 (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za> 12 13 V4L1 removal from: 14 (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru> 15 16 Fixes to be fully V4L2 compliant by 17 (c) 2006 Mauro Carvalho Chehab <mchehab@kernel.org> 18 19 Cropping and overscan support 20 Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at> 21 Sponsored by OPQ Systems AB 22 23 */ 24 25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 26 27 #include <linux/init.h> 28 #include <linux/module.h> 29 #include <linux/delay.h> 30 #include <linux/slab.h> 31 #include <linux/errno.h> 32 #include <linux/fs.h> 33 #include <linux/kernel.h> 34 #include <linux/sched.h> 35 #include <linux/interrupt.h> 36 #include <linux/kdev_t.h> 37 #include "bttvp.h" 38 #include <media/v4l2-common.h> 39 #include <media/v4l2-ioctl.h> 40 #include <media/v4l2-event.h> 41 #include <media/i2c/tvaudio.h> 42 #include <media/drv-intf/msp3400.h> 43 44 #include <linux/dma-mapping.h> 45 46 #include <asm/io.h> 47 #include <asm/byteorder.h> 48 49 #include <media/i2c/saa6588.h> 50 51 #define BTTV_VERSION "0.9.19" 52 53 unsigned int bttv_num; /* number of Bt848s in use */ 54 struct bttv *bttvs[BTTV_MAX]; 55 56 unsigned int bttv_debug; 57 unsigned int bttv_verbose = 1; 58 unsigned int bttv_gpio; 59 60 /* config variables */ 61 #ifdef __BIG_ENDIAN 62 static unsigned int bigendian=1; 63 #else 64 static unsigned int bigendian; 65 #endif 66 static unsigned int radio[BTTV_MAX]; 67 static unsigned int irq_debug; 68 static unsigned int gbuffers = 8; 69 static unsigned int gbufsize = 0x208000; 70 static unsigned int reset_crop = 1; 71 72 static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 }; 73 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 }; 74 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 }; 75 static int debug_latency; 76 static int disable_ir; 77 78 static unsigned int fdsr; 79 80 /* options */ 81 static unsigned int combfilter; 82 static unsigned int lumafilter; 83 static unsigned int automute = 1; 84 static unsigned int chroma_agc; 85 static unsigned int agc_crush = 1; 86 static unsigned int whitecrush_upper = 0xCF; 87 static unsigned int whitecrush_lower = 0x7F; 88 static unsigned int vcr_hack; 89 static unsigned int irq_iswitch; 90 static unsigned int uv_ratio = 50; 91 static unsigned int full_luma_range; 92 static unsigned int coring; 93 94 /* API features (turn on/off stuff for testing) */ 95 static unsigned int v4l2 = 1; 96 97 /* insmod args */ 98 module_param(bttv_verbose, int, 0644); 99 module_param(bttv_gpio, int, 0644); 100 module_param(bttv_debug, int, 0644); 101 module_param(irq_debug, int, 0644); 102 module_param(debug_latency, int, 0644); 103 module_param(disable_ir, int, 0444); 104 105 module_param(fdsr, int, 0444); 106 module_param(gbuffers, int, 0444); 107 module_param(gbufsize, int, 0444); 108 module_param(reset_crop, int, 0444); 109 110 module_param(v4l2, int, 0644); 111 module_param(bigendian, int, 0644); 112 module_param(irq_iswitch, int, 0644); 113 module_param(combfilter, int, 0444); 114 module_param(lumafilter, int, 0444); 115 module_param(automute, int, 0444); 116 module_param(chroma_agc, int, 0444); 117 module_param(agc_crush, int, 0444); 118 module_param(whitecrush_upper, int, 0444); 119 module_param(whitecrush_lower, int, 0444); 120 module_param(vcr_hack, int, 0444); 121 module_param(uv_ratio, int, 0444); 122 module_param(full_luma_range, int, 0444); 123 module_param(coring, int, 0444); 124 125 module_param_array(radio, int, NULL, 0444); 126 module_param_array(video_nr, int, NULL, 0444); 127 module_param_array(radio_nr, int, NULL, 0444); 128 module_param_array(vbi_nr, int, NULL, 0444); 129 130 MODULE_PARM_DESC(radio, "The TV card supports radio, default is 0 (no)"); 131 MODULE_PARM_DESC(bigendian, "byte order of the framebuffer, default is native endian"); 132 MODULE_PARM_DESC(bttv_verbose, "verbose startup messages, default is 1 (yes)"); 133 MODULE_PARM_DESC(bttv_gpio, "log gpio changes, default is 0 (no)"); 134 MODULE_PARM_DESC(bttv_debug, "debug messages, default is 0 (no)"); 135 MODULE_PARM_DESC(irq_debug, "irq handler debug messages, default is 0 (no)"); 136 MODULE_PARM_DESC(disable_ir, "disable infrared remote support"); 137 MODULE_PARM_DESC(gbuffers, "number of capture buffers. range 2-32, default 8"); 138 MODULE_PARM_DESC(gbufsize, "size of the capture buffers, default is 0x208000"); 139 MODULE_PARM_DESC(reset_crop, "reset cropping parameters at open(), default is 1 (yes) for compatibility with older applications"); 140 MODULE_PARM_DESC(automute, "mute audio on bad/missing video signal, default is 1 (yes)"); 141 MODULE_PARM_DESC(chroma_agc, "enables the AGC of chroma signal, default is 0 (no)"); 142 MODULE_PARM_DESC(agc_crush, "enables the luminance AGC crush, default is 1 (yes)"); 143 MODULE_PARM_DESC(whitecrush_upper, "sets the white crush upper value, default is 207"); 144 MODULE_PARM_DESC(whitecrush_lower, "sets the white crush lower value, default is 127"); 145 MODULE_PARM_DESC(vcr_hack, "enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)"); 146 MODULE_PARM_DESC(irq_iswitch, "switch inputs in irq handler"); 147 MODULE_PARM_DESC(uv_ratio, "ratio between u and v gains, default is 50"); 148 MODULE_PARM_DESC(full_luma_range, "use the full luma range, default is 0 (no)"); 149 MODULE_PARM_DESC(coring, "set the luma coring level, default is 0 (no)"); 150 MODULE_PARM_DESC(video_nr, "video device numbers"); 151 MODULE_PARM_DESC(vbi_nr, "vbi device numbers"); 152 MODULE_PARM_DESC(radio_nr, "radio device numbers"); 153 154 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards"); 155 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr"); 156 MODULE_LICENSE("GPL"); 157 MODULE_VERSION(BTTV_VERSION); 158 159 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_USER_BTTV_BASE + 0) 160 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_USER_BTTV_BASE + 1) 161 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_USER_BTTV_BASE + 2) 162 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_USER_BTTV_BASE + 3) 163 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_USER_BTTV_BASE + 4) 164 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_USER_BTTV_BASE + 5) 165 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_USER_BTTV_BASE + 6) 166 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_USER_BTTV_BASE + 7) 167 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_USER_BTTV_BASE + 8) 168 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_USER_BTTV_BASE + 9) 169 170 /* ----------------------------------------------------------------------- */ 171 /* sysfs */ 172 173 static ssize_t card_show(struct device *cd, 174 struct device_attribute *attr, char *buf) 175 { 176 struct video_device *vfd = to_video_device(cd); 177 struct bttv *btv = video_get_drvdata(vfd); 178 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET); 179 } 180 static DEVICE_ATTR_RO(card); 181 182 /* ----------------------------------------------------------------------- */ 183 /* dvb auto-load setup */ 184 #if defined(CONFIG_MODULES) && defined(MODULE) 185 static void request_module_async(struct work_struct *work) 186 { 187 request_module("dvb-bt8xx"); 188 } 189 190 static void request_modules(struct bttv *dev) 191 { 192 INIT_WORK(&dev->request_module_wk, request_module_async); 193 schedule_work(&dev->request_module_wk); 194 } 195 196 static void flush_request_modules(struct bttv *dev) 197 { 198 flush_work(&dev->request_module_wk); 199 } 200 #else 201 #define request_modules(dev) 202 #define flush_request_modules(dev) do {} while(0) 203 #endif /* CONFIG_MODULES */ 204 205 206 /* ----------------------------------------------------------------------- */ 207 /* static data */ 208 209 /* special timing tables from conexant... */ 210 static u8 SRAM_Table[][60] = 211 { 212 /* PAL digital input over GPIO[7:0] */ 213 { 214 45, // 45 bytes following 215 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16, 216 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00, 217 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00, 218 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37, 219 0x37,0x00,0xAF,0x21,0x00 220 }, 221 /* NTSC digital input over GPIO[7:0] */ 222 { 223 51, // 51 bytes following 224 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06, 225 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00, 226 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07, 227 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6, 228 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21, 229 0x00, 230 }, 231 // TGB_NTSC392 // quartzsight 232 // This table has been modified to be used for Fusion Rev D 233 { 234 0x2A, // size of table = 42 235 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24, 236 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10, 237 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00, 238 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3, 239 0x20, 0x00 240 } 241 }; 242 243 /* minhdelayx1 first video pixel we can capture on a line and 244 hdelayx1 start of active video, both relative to rising edge of 245 /HRESET pulse (0H) in 1 / fCLKx1. 246 swidth width of active video and 247 totalwidth total line width, both in 1 / fCLKx1. 248 sqwidth total line width in square pixels. 249 vdelay start of active video in 2 * field lines relative to 250 trailing edge of /VRESET pulse (VDELAY register). 251 sheight height of active video in 2 * field lines. 252 extraheight Added to sheight for cropcap.bounds.height only 253 videostart0 ITU-R frame line number of the line corresponding 254 to vdelay in the first field. */ 255 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \ 256 vdelay, sheight, extraheight, videostart0) \ 257 .cropcap.bounds.left = minhdelayx1, \ 258 /* * 2 because vertically we count field lines times two, */ \ 259 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \ 260 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \ 261 /* 4 is a safety margin at the end of the line. */ \ 262 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \ 263 .cropcap.bounds.height = (sheight) + (extraheight) + (vdelay) - \ 264 MIN_VDELAY, \ 265 .cropcap.defrect.left = hdelayx1, \ 266 .cropcap.defrect.top = (videostart0) * 2, \ 267 .cropcap.defrect.width = swidth, \ 268 .cropcap.defrect.height = sheight, \ 269 .cropcap.pixelaspect.numerator = totalwidth, \ 270 .cropcap.pixelaspect.denominator = sqwidth, 271 272 const struct bttv_tvnorm bttv_tvnorms[] = { 273 /* PAL-BDGHI */ 274 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */ 275 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */ 276 { 277 .v4l2_id = V4L2_STD_PAL, 278 .name = "PAL", 279 .Fsc = 35468950, 280 .swidth = 924, 281 .sheight = 576, 282 .totalwidth = 1135, 283 .adelay = 0x7f, 284 .bdelay = 0x72, 285 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1), 286 .scaledtwidth = 1135, 287 .hdelayx1 = 186, 288 .hactivex1 = 924, 289 .vdelay = 0x20, 290 .vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */ 291 .sram = 0, 292 /* ITU-R frame line number of the first VBI line 293 we can capture, of the first and second field. 294 The last line is determined by cropcap.bounds. */ 295 .vbistart = { 7, 320 }, 296 CROPCAP(/* minhdelayx1 */ 68, 297 /* hdelayx1 */ 186, 298 /* Should be (768 * 1135 + 944 / 2) / 944. 299 cropcap.defrect is used for image width 300 checks, so we keep the old value 924. */ 301 /* swidth */ 924, 302 /* totalwidth */ 1135, 303 /* sqwidth */ 944, 304 /* vdelay */ 0x20, 305 /* sheight */ 576, 306 /* bt878 (and bt848?) can capture another 307 line below active video. */ 308 /* extraheight */ 2, 309 /* videostart0 */ 23) 310 },{ 311 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR, 312 .name = "NTSC", 313 .Fsc = 28636363, 314 .swidth = 768, 315 .sheight = 480, 316 .totalwidth = 910, 317 .adelay = 0x68, 318 .bdelay = 0x5d, 319 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0), 320 .scaledtwidth = 910, 321 .hdelayx1 = 128, 322 .hactivex1 = 910, 323 .vdelay = 0x1a, 324 .vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */ 325 .sram = 1, 326 .vbistart = { 10, 273 }, 327 CROPCAP(/* minhdelayx1 */ 68, 328 /* hdelayx1 */ 128, 329 /* Should be (640 * 910 + 780 / 2) / 780? */ 330 /* swidth */ 768, 331 /* totalwidth */ 910, 332 /* sqwidth */ 780, 333 /* vdelay */ 0x1a, 334 /* sheight */ 480, 335 /* extraheight */ 0, 336 /* videostart0 */ 23) 337 },{ 338 .v4l2_id = V4L2_STD_SECAM, 339 .name = "SECAM", 340 .Fsc = 35468950, 341 .swidth = 924, 342 .sheight = 576, 343 .totalwidth = 1135, 344 .adelay = 0x7f, 345 .bdelay = 0xb0, 346 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1), 347 .scaledtwidth = 1135, 348 .hdelayx1 = 186, 349 .hactivex1 = 922, 350 .vdelay = 0x20, 351 .vbipack = 255, 352 .sram = 0, /* like PAL, correct? */ 353 .vbistart = { 7, 320 }, 354 CROPCAP(/* minhdelayx1 */ 68, 355 /* hdelayx1 */ 186, 356 /* swidth */ 924, 357 /* totalwidth */ 1135, 358 /* sqwidth */ 944, 359 /* vdelay */ 0x20, 360 /* sheight */ 576, 361 /* extraheight */ 0, 362 /* videostart0 */ 23) 363 },{ 364 .v4l2_id = V4L2_STD_PAL_Nc, 365 .name = "PAL-Nc", 366 .Fsc = 28636363, 367 .swidth = 640, 368 .sheight = 576, 369 .totalwidth = 910, 370 .adelay = 0x68, 371 .bdelay = 0x5d, 372 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0), 373 .scaledtwidth = 780, 374 .hdelayx1 = 130, 375 .hactivex1 = 734, 376 .vdelay = 0x1a, 377 .vbipack = 144, 378 .sram = -1, 379 .vbistart = { 7, 320 }, 380 CROPCAP(/* minhdelayx1 */ 68, 381 /* hdelayx1 */ 130, 382 /* swidth */ (640 * 910 + 780 / 2) / 780, 383 /* totalwidth */ 910, 384 /* sqwidth */ 780, 385 /* vdelay */ 0x1a, 386 /* sheight */ 576, 387 /* extraheight */ 0, 388 /* videostart0 */ 23) 389 },{ 390 .v4l2_id = V4L2_STD_PAL_M, 391 .name = "PAL-M", 392 .Fsc = 28636363, 393 .swidth = 640, 394 .sheight = 480, 395 .totalwidth = 910, 396 .adelay = 0x68, 397 .bdelay = 0x5d, 398 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0), 399 .scaledtwidth = 780, 400 .hdelayx1 = 135, 401 .hactivex1 = 754, 402 .vdelay = 0x1a, 403 .vbipack = 144, 404 .sram = -1, 405 .vbistart = { 10, 273 }, 406 CROPCAP(/* minhdelayx1 */ 68, 407 /* hdelayx1 */ 135, 408 /* swidth */ (640 * 910 + 780 / 2) / 780, 409 /* totalwidth */ 910, 410 /* sqwidth */ 780, 411 /* vdelay */ 0x1a, 412 /* sheight */ 480, 413 /* extraheight */ 0, 414 /* videostart0 */ 23) 415 },{ 416 .v4l2_id = V4L2_STD_PAL_N, 417 .name = "PAL-N", 418 .Fsc = 35468950, 419 .swidth = 768, 420 .sheight = 576, 421 .totalwidth = 1135, 422 .adelay = 0x7f, 423 .bdelay = 0x72, 424 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1), 425 .scaledtwidth = 944, 426 .hdelayx1 = 186, 427 .hactivex1 = 922, 428 .vdelay = 0x20, 429 .vbipack = 144, 430 .sram = -1, 431 .vbistart = { 7, 320 }, 432 CROPCAP(/* minhdelayx1 */ 68, 433 /* hdelayx1 */ 186, 434 /* swidth */ (768 * 1135 + 944 / 2) / 944, 435 /* totalwidth */ 1135, 436 /* sqwidth */ 944, 437 /* vdelay */ 0x20, 438 /* sheight */ 576, 439 /* extraheight */ 0, 440 /* videostart0 */ 23) 441 },{ 442 .v4l2_id = V4L2_STD_NTSC_M_JP, 443 .name = "NTSC-JP", 444 .Fsc = 28636363, 445 .swidth = 640, 446 .sheight = 480, 447 .totalwidth = 910, 448 .adelay = 0x68, 449 .bdelay = 0x5d, 450 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0), 451 .scaledtwidth = 780, 452 .hdelayx1 = 135, 453 .hactivex1 = 754, 454 .vdelay = 0x16, 455 .vbipack = 144, 456 .sram = -1, 457 .vbistart = { 10, 273 }, 458 CROPCAP(/* minhdelayx1 */ 68, 459 /* hdelayx1 */ 135, 460 /* swidth */ (640 * 910 + 780 / 2) / 780, 461 /* totalwidth */ 910, 462 /* sqwidth */ 780, 463 /* vdelay */ 0x16, 464 /* sheight */ 480, 465 /* extraheight */ 0, 466 /* videostart0 */ 23) 467 },{ 468 /* that one hopefully works with the strange timing 469 * which video recorders produce when playing a NTSC 470 * tape on a PAL TV ... */ 471 .v4l2_id = V4L2_STD_PAL_60, 472 .name = "PAL-60", 473 .Fsc = 35468950, 474 .swidth = 924, 475 .sheight = 480, 476 .totalwidth = 1135, 477 .adelay = 0x7f, 478 .bdelay = 0x72, 479 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1), 480 .scaledtwidth = 1135, 481 .hdelayx1 = 186, 482 .hactivex1 = 924, 483 .vdelay = 0x1a, 484 .vbipack = 255, 485 .vtotal = 524, 486 .sram = -1, 487 .vbistart = { 10, 273 }, 488 CROPCAP(/* minhdelayx1 */ 68, 489 /* hdelayx1 */ 186, 490 /* swidth */ 924, 491 /* totalwidth */ 1135, 492 /* sqwidth */ 944, 493 /* vdelay */ 0x1a, 494 /* sheight */ 480, 495 /* extraheight */ 0, 496 /* videostart0 */ 23) 497 } 498 }; 499 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms); 500 501 /* ----------------------------------------------------------------------- */ 502 /* bttv format list 503 packed pixel formats must come first */ 504 static const struct bttv_format formats[] = { 505 { 506 .fourcc = V4L2_PIX_FMT_GREY, 507 .btformat = BT848_COLOR_FMT_Y8, 508 .depth = 8, 509 .flags = FORMAT_FLAGS_PACKED, 510 },{ 511 .fourcc = V4L2_PIX_FMT_HI240, 512 .btformat = BT848_COLOR_FMT_RGB8, 513 .depth = 8, 514 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER, 515 },{ 516 .fourcc = V4L2_PIX_FMT_RGB555, 517 .btformat = BT848_COLOR_FMT_RGB15, 518 .depth = 16, 519 .flags = FORMAT_FLAGS_PACKED, 520 },{ 521 .fourcc = V4L2_PIX_FMT_RGB555X, 522 .btformat = BT848_COLOR_FMT_RGB15, 523 .btswap = 0x03, /* byteswap */ 524 .depth = 16, 525 .flags = FORMAT_FLAGS_PACKED, 526 },{ 527 .fourcc = V4L2_PIX_FMT_RGB565, 528 .btformat = BT848_COLOR_FMT_RGB16, 529 .depth = 16, 530 .flags = FORMAT_FLAGS_PACKED, 531 },{ 532 .fourcc = V4L2_PIX_FMT_RGB565X, 533 .btformat = BT848_COLOR_FMT_RGB16, 534 .btswap = 0x03, /* byteswap */ 535 .depth = 16, 536 .flags = FORMAT_FLAGS_PACKED, 537 },{ 538 .fourcc = V4L2_PIX_FMT_BGR24, 539 .btformat = BT848_COLOR_FMT_RGB24, 540 .depth = 24, 541 .flags = FORMAT_FLAGS_PACKED, 542 },{ 543 .fourcc = V4L2_PIX_FMT_BGR32, 544 .btformat = BT848_COLOR_FMT_RGB32, 545 .depth = 32, 546 .flags = FORMAT_FLAGS_PACKED, 547 },{ 548 .fourcc = V4L2_PIX_FMT_RGB32, 549 .btformat = BT848_COLOR_FMT_RGB32, 550 .btswap = 0x0f, /* byte+word swap */ 551 .depth = 32, 552 .flags = FORMAT_FLAGS_PACKED, 553 },{ 554 .fourcc = V4L2_PIX_FMT_YUYV, 555 .btformat = BT848_COLOR_FMT_YUY2, 556 .depth = 16, 557 .flags = FORMAT_FLAGS_PACKED, 558 },{ 559 .fourcc = V4L2_PIX_FMT_UYVY, 560 .btformat = BT848_COLOR_FMT_YUY2, 561 .btswap = 0x03, /* byteswap */ 562 .depth = 16, 563 .flags = FORMAT_FLAGS_PACKED, 564 },{ 565 .fourcc = V4L2_PIX_FMT_YUV422P, 566 .btformat = BT848_COLOR_FMT_YCrCb422, 567 .depth = 16, 568 .flags = FORMAT_FLAGS_PLANAR, 569 .hshift = 1, 570 .vshift = 0, 571 },{ 572 .fourcc = V4L2_PIX_FMT_YUV420, 573 .btformat = BT848_COLOR_FMT_YCrCb422, 574 .depth = 12, 575 .flags = FORMAT_FLAGS_PLANAR, 576 .hshift = 1, 577 .vshift = 1, 578 },{ 579 .fourcc = V4L2_PIX_FMT_YVU420, 580 .btformat = BT848_COLOR_FMT_YCrCb422, 581 .depth = 12, 582 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb, 583 .hshift = 1, 584 .vshift = 1, 585 },{ 586 .fourcc = V4L2_PIX_FMT_YUV411P, 587 .btformat = BT848_COLOR_FMT_YCrCb411, 588 .depth = 12, 589 .flags = FORMAT_FLAGS_PLANAR, 590 .hshift = 2, 591 .vshift = 0, 592 },{ 593 .fourcc = V4L2_PIX_FMT_YUV410, 594 .btformat = BT848_COLOR_FMT_YCrCb411, 595 .depth = 9, 596 .flags = FORMAT_FLAGS_PLANAR, 597 .hshift = 2, 598 .vshift = 2, 599 },{ 600 .fourcc = V4L2_PIX_FMT_YVU410, 601 .btformat = BT848_COLOR_FMT_YCrCb411, 602 .depth = 9, 603 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb, 604 .hshift = 2, 605 .vshift = 2, 606 },{ 607 .fourcc = -1, 608 .btformat = BT848_COLOR_FMT_RAW, 609 .depth = 8, 610 .flags = FORMAT_FLAGS_RAW, 611 } 612 }; 613 static const unsigned int FORMATS = ARRAY_SIZE(formats); 614 615 /* ----------------------------------------------------------------------- */ 616 /* resource management */ 617 618 /* 619 RESOURCE_ allocated by freed by 620 621 VIDEO_READ bttv_read 1) bttv_read 2) 622 623 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF 624 VIDIOC_QBUF 1) bttv_release 625 VIDIOCMCAPTURE 1) 626 627 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF 628 VIDIOC_QBUF 1) bttv_release 629 bttv_read, bttv_poll 1) 3) 630 631 1) The resource must be allocated when we enter buffer prepare functions 632 and remain allocated while buffers are in the DMA queue. 633 2) This is a single frame read. 634 3) This is a continuous read, implies VIDIOC_STREAMON. 635 636 Note this driver permits video input and standard changes regardless if 637 resources are allocated. 638 */ 639 640 #define VBI_RESOURCES (RESOURCE_VBI) 641 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \ 642 RESOURCE_VIDEO_STREAM) 643 644 static 645 int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit) 646 { 647 int xbits; /* mutual exclusive resources */ 648 649 if (fh->resources & bit) 650 /* have it already allocated */ 651 return 1; 652 653 xbits = bit; 654 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM)) 655 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM; 656 657 /* is it free? */ 658 if (btv->resources & xbits) { 659 /* no, someone else uses it */ 660 goto fail; 661 } 662 663 if ((bit & VIDEO_RESOURCES) 664 && 0 == (btv->resources & VIDEO_RESOURCES)) { 665 /* Do crop - use current, don't - use default parameters. */ 666 __s32 top = btv->crop[!!fh->do_crop].rect.top; 667 668 if (btv->vbi_end > top) 669 goto fail; 670 671 /* We cannot capture the same line as video and VBI data. 672 Claim scan lines crop[].rect.top to bottom. */ 673 btv->crop_start = top; 674 } else if (bit & VBI_RESOURCES) { 675 __s32 end = fh->vbi_fmt.end; 676 677 if (end > btv->crop_start) 678 goto fail; 679 680 /* Claim scan lines above fh->vbi_fmt.end. */ 681 btv->vbi_end = end; 682 } 683 684 /* it's free, grab it */ 685 fh->resources |= bit; 686 btv->resources |= bit; 687 return 1; 688 689 fail: 690 return 0; 691 } 692 693 static 694 int check_btres(struct bttv_fh *fh, int bit) 695 { 696 return (fh->resources & bit); 697 } 698 699 static 700 int locked_btres(struct bttv *btv, int bit) 701 { 702 return (btv->resources & bit); 703 } 704 705 /* Call with btv->lock down. */ 706 static void 707 disclaim_vbi_lines(struct bttv *btv) 708 { 709 btv->vbi_end = 0; 710 } 711 712 /* Call with btv->lock down. */ 713 static void 714 disclaim_video_lines(struct bttv *btv) 715 { 716 const struct bttv_tvnorm *tvnorm; 717 u8 crop; 718 719 tvnorm = &bttv_tvnorms[btv->tvnorm]; 720 btv->crop_start = tvnorm->cropcap.bounds.top 721 + tvnorm->cropcap.bounds.height; 722 723 /* VBI capturing ends at VDELAY, start of video capturing, no 724 matter how many lines the VBI RISC program expects. When video 725 capturing is off, it shall no longer "preempt" VBI capturing, 726 so we set VDELAY to maximum. */ 727 crop = btread(BT848_E_CROP) | 0xc0; 728 btwrite(crop, BT848_E_CROP); 729 btwrite(0xfe, BT848_E_VDELAY_LO); 730 btwrite(crop, BT848_O_CROP); 731 btwrite(0xfe, BT848_O_VDELAY_LO); 732 } 733 734 static 735 void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits) 736 { 737 if ((fh->resources & bits) != bits) { 738 /* trying to free resources not allocated by us ... */ 739 pr_err("BUG! (btres)\n"); 740 } 741 fh->resources &= ~bits; 742 btv->resources &= ~bits; 743 744 bits = btv->resources; 745 746 if (0 == (bits & VIDEO_RESOURCES)) 747 disclaim_video_lines(btv); 748 749 if (0 == (bits & VBI_RESOURCES)) 750 disclaim_vbi_lines(btv); 751 } 752 753 /* ----------------------------------------------------------------------- */ 754 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */ 755 756 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C 757 PLL_X = Reference pre-divider (0=1, 1=2) 758 PLL_C = Post divider (0=6, 1=4) 759 PLL_I = Integer input 760 PLL_F = Fractional input 761 762 F_input = 28.636363 MHz: 763 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0 764 */ 765 766 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout) 767 { 768 unsigned char fl, fh, fi; 769 770 /* prevent overflows */ 771 fin/=4; 772 fout/=4; 773 774 fout*=12; 775 fi=fout/fin; 776 777 fout=(fout%fin)*256; 778 fh=fout/fin; 779 780 fout=(fout%fin)*256; 781 fl=fout/fin; 782 783 btwrite(fl, BT848_PLL_F_LO); 784 btwrite(fh, BT848_PLL_F_HI); 785 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI); 786 } 787 788 static void set_pll(struct bttv *btv) 789 { 790 int i; 791 792 if (!btv->pll.pll_crystal) 793 return; 794 795 if (btv->pll.pll_ofreq == btv->pll.pll_current) { 796 dprintk("%d: PLL: no change required\n", btv->c.nr); 797 return; 798 } 799 800 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) { 801 /* no PLL needed */ 802 if (btv->pll.pll_current == 0) 803 return; 804 if (bttv_verbose) 805 pr_info("%d: PLL can sleep, using XTAL (%d)\n", 806 btv->c.nr, btv->pll.pll_ifreq); 807 btwrite(0x00,BT848_TGCTRL); 808 btwrite(0x00,BT848_PLL_XCI); 809 btv->pll.pll_current = 0; 810 return; 811 } 812 813 if (bttv_verbose) 814 pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n", 815 btv->c.nr, 816 btv->pll.pll_ifreq, btv->pll.pll_ofreq); 817 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq); 818 819 for (i=0; i<10; i++) { 820 /* Let other people run while the PLL stabilizes */ 821 msleep(10); 822 823 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) { 824 btwrite(0,BT848_DSTATUS); 825 } else { 826 btwrite(0x08,BT848_TGCTRL); 827 btv->pll.pll_current = btv->pll.pll_ofreq; 828 if (bttv_verbose) 829 pr_info("PLL set ok\n"); 830 return; 831 } 832 } 833 btv->pll.pll_current = -1; 834 if (bttv_verbose) 835 pr_info("Setting PLL failed\n"); 836 return; 837 } 838 839 /* used to switch between the bt848's analog/digital video capture modes */ 840 static void bt848A_set_timing(struct bttv *btv) 841 { 842 int i, len; 843 int table_idx = bttv_tvnorms[btv->tvnorm].sram; 844 int fsc = bttv_tvnorms[btv->tvnorm].Fsc; 845 846 if (btv->input == btv->dig) { 847 dprintk("%d: load digital timing table (table_idx=%d)\n", 848 btv->c.nr,table_idx); 849 850 /* timing change...reset timing generator address */ 851 btwrite(0x00, BT848_TGCTRL); 852 btwrite(0x02, BT848_TGCTRL); 853 btwrite(0x00, BT848_TGCTRL); 854 855 len=SRAM_Table[table_idx][0]; 856 for(i = 1; i <= len; i++) 857 btwrite(SRAM_Table[table_idx][i],BT848_TGLB); 858 btv->pll.pll_ofreq = 27000000; 859 860 set_pll(btv); 861 btwrite(0x11, BT848_TGCTRL); 862 btwrite(0x41, BT848_DVSIF); 863 } else { 864 btv->pll.pll_ofreq = fsc; 865 set_pll(btv); 866 btwrite(0x0, BT848_DVSIF); 867 } 868 } 869 870 /* ----------------------------------------------------------------------- */ 871 872 static void bt848_bright(struct bttv *btv, int bright) 873 { 874 int value; 875 876 // printk("set bright: %d\n", bright); // DEBUG 877 btv->bright = bright; 878 879 /* We want -128 to 127 we get 0-65535 */ 880 value = (bright >> 8) - 128; 881 btwrite(value & 0xff, BT848_BRIGHT); 882 } 883 884 static void bt848_hue(struct bttv *btv, int hue) 885 { 886 int value; 887 888 btv->hue = hue; 889 890 /* -128 to 127 */ 891 value = (hue >> 8) - 128; 892 btwrite(value & 0xff, BT848_HUE); 893 } 894 895 static void bt848_contrast(struct bttv *btv, int cont) 896 { 897 int value,hibit; 898 899 btv->contrast = cont; 900 901 /* 0-511 */ 902 value = (cont >> 7); 903 hibit = (value >> 6) & 4; 904 btwrite(value & 0xff, BT848_CONTRAST_LO); 905 btaor(hibit, ~4, BT848_E_CONTROL); 906 btaor(hibit, ~4, BT848_O_CONTROL); 907 } 908 909 static void bt848_sat(struct bttv *btv, int color) 910 { 911 int val_u,val_v,hibits; 912 913 btv->saturation = color; 914 915 /* 0-511 for the color */ 916 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7; 917 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254; 918 hibits = (val_u >> 7) & 2; 919 hibits |= (val_v >> 8) & 1; 920 btwrite(val_u & 0xff, BT848_SAT_U_LO); 921 btwrite(val_v & 0xff, BT848_SAT_V_LO); 922 btaor(hibits, ~3, BT848_E_CONTROL); 923 btaor(hibits, ~3, BT848_O_CONTROL); 924 } 925 926 /* ----------------------------------------------------------------------- */ 927 928 static int 929 video_mux(struct bttv *btv, unsigned int input) 930 { 931 int mux,mask2; 932 933 if (input >= bttv_tvcards[btv->c.type].video_inputs) 934 return -EINVAL; 935 936 /* needed by RemoteVideo MX */ 937 mask2 = bttv_tvcards[btv->c.type].gpiomask2; 938 if (mask2) 939 gpio_inout(mask2,mask2); 940 941 if (input == btv->svhs) { 942 btor(BT848_CONTROL_COMP, BT848_E_CONTROL); 943 btor(BT848_CONTROL_COMP, BT848_O_CONTROL); 944 } else { 945 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL); 946 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL); 947 } 948 mux = bttv_muxsel(btv, input); 949 btaor(mux<<5, ~(3<<5), BT848_IFORM); 950 dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux); 951 952 /* card specific hook */ 953 if(bttv_tvcards[btv->c.type].muxsel_hook) 954 bttv_tvcards[btv->c.type].muxsel_hook (btv, input); 955 return 0; 956 } 957 958 static char *audio_modes[] = { 959 "audio: tuner", "audio: radio", "audio: extern", 960 "audio: intern", "audio: mute" 961 }; 962 963 static void 964 audio_mux_gpio(struct bttv *btv, int input, int mute) 965 { 966 int gpio_val, signal, mute_gpio; 967 968 gpio_inout(bttv_tvcards[btv->c.type].gpiomask, 969 bttv_tvcards[btv->c.type].gpiomask); 970 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC; 971 972 /* automute */ 973 mute_gpio = mute || (btv->opt_automute && (!signal || !btv->users) 974 && !btv->has_radio_tuner); 975 976 if (mute_gpio) 977 gpio_val = bttv_tvcards[btv->c.type].gpiomute; 978 else 979 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input]; 980 981 switch (btv->c.type) { 982 case BTTV_BOARD_VOODOOTV_FM: 983 case BTTV_BOARD_VOODOOTV_200: 984 gpio_val = bttv_tda9880_setnorm(btv, gpio_val); 985 break; 986 987 default: 988 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val); 989 } 990 991 if (bttv_gpio) 992 bttv_gpio_tracking(btv, audio_modes[mute_gpio ? 4 : input]); 993 } 994 995 static int 996 audio_mute(struct bttv *btv, int mute) 997 { 998 struct v4l2_ctrl *ctrl; 999 1000 audio_mux_gpio(btv, btv->audio_input, mute); 1001 1002 if (btv->sd_msp34xx) { 1003 ctrl = v4l2_ctrl_find(btv->sd_msp34xx->ctrl_handler, V4L2_CID_AUDIO_MUTE); 1004 if (ctrl) 1005 v4l2_ctrl_s_ctrl(ctrl, mute); 1006 } 1007 if (btv->sd_tvaudio) { 1008 ctrl = v4l2_ctrl_find(btv->sd_tvaudio->ctrl_handler, V4L2_CID_AUDIO_MUTE); 1009 if (ctrl) 1010 v4l2_ctrl_s_ctrl(ctrl, mute); 1011 } 1012 if (btv->sd_tda7432) { 1013 ctrl = v4l2_ctrl_find(btv->sd_tda7432->ctrl_handler, V4L2_CID_AUDIO_MUTE); 1014 if (ctrl) 1015 v4l2_ctrl_s_ctrl(ctrl, mute); 1016 } 1017 return 0; 1018 } 1019 1020 static int 1021 audio_input(struct bttv *btv, int input) 1022 { 1023 audio_mux_gpio(btv, input, btv->mute); 1024 1025 if (btv->sd_msp34xx) { 1026 u32 in; 1027 1028 /* Note: the inputs tuner/radio/extern/intern are translated 1029 to msp routings. This assumes common behavior for all msp3400 1030 based TV cards. When this assumption fails, then the 1031 specific MSP routing must be added to the card table. 1032 For now this is sufficient. */ 1033 switch (input) { 1034 case TVAUDIO_INPUT_RADIO: 1035 /* Some boards need the msp do to the radio demod */ 1036 if (btv->radio_uses_msp_demodulator) { 1037 in = MSP_INPUT_DEFAULT; 1038 break; 1039 } 1040 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1, 1041 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART); 1042 break; 1043 case TVAUDIO_INPUT_EXTERN: 1044 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1, 1045 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART); 1046 break; 1047 case TVAUDIO_INPUT_INTERN: 1048 /* Yes, this is the same input as for RADIO. I doubt 1049 if this is ever used. The only board with an INTERN 1050 input is the BTTV_BOARD_AVERMEDIA98. I wonder how 1051 that was tested. My guess is that the whole INTERN 1052 input does not work. */ 1053 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1, 1054 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART); 1055 break; 1056 case TVAUDIO_INPUT_TUNER: 1057 default: 1058 /* This is the only card that uses TUNER2, and afaik, 1059 is the only difference between the VOODOOTV_FM 1060 and VOODOOTV_200 */ 1061 if (btv->c.type == BTTV_BOARD_VOODOOTV_200) 1062 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \ 1063 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER); 1064 else 1065 in = MSP_INPUT_DEFAULT; 1066 break; 1067 } 1068 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing, 1069 in, MSP_OUTPUT_DEFAULT, 0); 1070 } 1071 if (btv->sd_tvaudio) { 1072 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing, 1073 input, 0, 0); 1074 } 1075 return 0; 1076 } 1077 1078 static void 1079 bttv_crop_calc_limits(struct bttv_crop *c) 1080 { 1081 /* Scale factor min. 1:1, max. 16:1. Min. image size 1082 48 x 32. Scaled width must be a multiple of 4. */ 1083 1084 if (1) { 1085 /* For bug compatibility with VIDIOCGCAP and image 1086 size checks in earlier driver versions. */ 1087 c->min_scaled_width = 48; 1088 c->min_scaled_height = 32; 1089 } else { 1090 c->min_scaled_width = 1091 (max_t(unsigned int, 48, c->rect.width >> 4) + 3) & ~3; 1092 c->min_scaled_height = 1093 max_t(unsigned int, 32, c->rect.height >> 4); 1094 } 1095 1096 c->max_scaled_width = c->rect.width & ~3; 1097 c->max_scaled_height = c->rect.height; 1098 } 1099 1100 static void 1101 bttv_crop_reset(struct bttv_crop *c, unsigned int norm) 1102 { 1103 c->rect = bttv_tvnorms[norm].cropcap.defrect; 1104 bttv_crop_calc_limits(c); 1105 } 1106 1107 /* Call with btv->lock down. */ 1108 static int 1109 set_tvnorm(struct bttv *btv, unsigned int norm) 1110 { 1111 const struct bttv_tvnorm *tvnorm; 1112 v4l2_std_id id; 1113 1114 BUG_ON(norm >= BTTV_TVNORMS); 1115 BUG_ON(btv->tvnorm >= BTTV_TVNORMS); 1116 1117 tvnorm = &bttv_tvnorms[norm]; 1118 1119 if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap, 1120 sizeof (tvnorm->cropcap))) { 1121 bttv_crop_reset(&btv->crop[0], norm); 1122 btv->crop[1] = btv->crop[0]; /* current = default */ 1123 1124 if (0 == (btv->resources & VIDEO_RESOURCES)) { 1125 btv->crop_start = tvnorm->cropcap.bounds.top 1126 + tvnorm->cropcap.bounds.height; 1127 } 1128 } 1129 1130 btv->tvnorm = norm; 1131 1132 btwrite(tvnorm->adelay, BT848_ADELAY); 1133 btwrite(tvnorm->bdelay, BT848_BDELAY); 1134 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH), 1135 BT848_IFORM); 1136 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE); 1137 btwrite(1, BT848_VBI_PACK_DEL); 1138 bt848A_set_timing(btv); 1139 1140 switch (btv->c.type) { 1141 case BTTV_BOARD_VOODOOTV_FM: 1142 case BTTV_BOARD_VOODOOTV_200: 1143 bttv_tda9880_setnorm(btv, gpio_read()); 1144 break; 1145 } 1146 id = tvnorm->v4l2_id; 1147 bttv_call_all(btv, video, s_std, id); 1148 1149 return 0; 1150 } 1151 1152 /* Call with btv->lock down. */ 1153 static void 1154 set_input(struct bttv *btv, unsigned int input, unsigned int norm) 1155 { 1156 unsigned long flags; 1157 1158 btv->input = input; 1159 if (irq_iswitch) { 1160 spin_lock_irqsave(&btv->s_lock,flags); 1161 if (btv->curr.frame_irq) { 1162 /* active capture -> delayed input switch */ 1163 btv->new_input = input; 1164 } else { 1165 video_mux(btv,input); 1166 } 1167 spin_unlock_irqrestore(&btv->s_lock,flags); 1168 } else { 1169 video_mux(btv,input); 1170 } 1171 btv->audio_input = (btv->tuner_type != TUNER_ABSENT && input == 0) ? 1172 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN; 1173 audio_input(btv, btv->audio_input); 1174 set_tvnorm(btv, norm); 1175 } 1176 1177 static void init_irqreg(struct bttv *btv) 1178 { 1179 /* clear status */ 1180 btwrite(0xfffffUL, BT848_INT_STAT); 1181 1182 if (bttv_tvcards[btv->c.type].no_video) { 1183 /* i2c only */ 1184 btwrite(BT848_INT_I2CDONE, 1185 BT848_INT_MASK); 1186 } else { 1187 /* full video */ 1188 btwrite((btv->triton1) | 1189 (btv->gpioirq ? BT848_INT_GPINT : 0) | 1190 BT848_INT_SCERR | 1191 (fdsr ? BT848_INT_FDSR : 0) | 1192 BT848_INT_RISCI | BT848_INT_OCERR | 1193 BT848_INT_FMTCHG|BT848_INT_HLOCK| 1194 BT848_INT_I2CDONE, 1195 BT848_INT_MASK); 1196 } 1197 } 1198 1199 static void init_bt848(struct bttv *btv) 1200 { 1201 if (bttv_tvcards[btv->c.type].no_video) { 1202 /* very basic init only */ 1203 init_irqreg(btv); 1204 return; 1205 } 1206 1207 btwrite(0x00, BT848_CAP_CTL); 1208 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL); 1209 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM); 1210 1211 /* set planar and packed mode trigger points and */ 1212 /* set rising edge of inverted GPINTR pin as irq trigger */ 1213 btwrite(BT848_GPIO_DMA_CTL_PKTP_32| 1214 BT848_GPIO_DMA_CTL_PLTP1_16| 1215 BT848_GPIO_DMA_CTL_PLTP23_16| 1216 BT848_GPIO_DMA_CTL_GPINTC| 1217 BT848_GPIO_DMA_CTL_GPINTI, 1218 BT848_GPIO_DMA_CTL); 1219 1220 btwrite(0x20, BT848_E_VSCALE_HI); 1221 btwrite(0x20, BT848_O_VSCALE_HI); 1222 1223 v4l2_ctrl_handler_setup(&btv->ctrl_handler); 1224 1225 /* interrupt */ 1226 init_irqreg(btv); 1227 } 1228 1229 static void bttv_reinit_bt848(struct bttv *btv) 1230 { 1231 unsigned long flags; 1232 1233 if (bttv_verbose) 1234 pr_info("%d: reset, reinitialize\n", btv->c.nr); 1235 spin_lock_irqsave(&btv->s_lock,flags); 1236 btv->errors=0; 1237 bttv_set_dma(btv,0); 1238 spin_unlock_irqrestore(&btv->s_lock,flags); 1239 1240 init_bt848(btv); 1241 btv->pll.pll_current = -1; 1242 set_input(btv, btv->input, btv->tvnorm); 1243 } 1244 1245 static int bttv_s_ctrl(struct v4l2_ctrl *c) 1246 { 1247 struct bttv *btv = container_of(c->handler, struct bttv, ctrl_handler); 1248 int val; 1249 1250 switch (c->id) { 1251 case V4L2_CID_BRIGHTNESS: 1252 bt848_bright(btv, c->val); 1253 break; 1254 case V4L2_CID_HUE: 1255 bt848_hue(btv, c->val); 1256 break; 1257 case V4L2_CID_CONTRAST: 1258 bt848_contrast(btv, c->val); 1259 break; 1260 case V4L2_CID_SATURATION: 1261 bt848_sat(btv, c->val); 1262 break; 1263 case V4L2_CID_COLOR_KILLER: 1264 if (c->val) { 1265 btor(BT848_SCLOOP_CKILL, BT848_E_SCLOOP); 1266 btor(BT848_SCLOOP_CKILL, BT848_O_SCLOOP); 1267 } else { 1268 btand(~BT848_SCLOOP_CKILL, BT848_E_SCLOOP); 1269 btand(~BT848_SCLOOP_CKILL, BT848_O_SCLOOP); 1270 } 1271 break; 1272 case V4L2_CID_AUDIO_MUTE: 1273 audio_mute(btv, c->val); 1274 btv->mute = c->val; 1275 break; 1276 case V4L2_CID_AUDIO_VOLUME: 1277 btv->volume_gpio(btv, c->val); 1278 break; 1279 1280 case V4L2_CID_CHROMA_AGC: 1281 val = c->val ? BT848_SCLOOP_CAGC : 0; 1282 btwrite(val, BT848_E_SCLOOP); 1283 btwrite(val, BT848_O_SCLOOP); 1284 break; 1285 case V4L2_CID_PRIVATE_COMBFILTER: 1286 btv->opt_combfilter = c->val; 1287 break; 1288 case V4L2_CID_PRIVATE_LUMAFILTER: 1289 if (c->val) { 1290 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL); 1291 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL); 1292 } else { 1293 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL); 1294 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL); 1295 } 1296 break; 1297 case V4L2_CID_PRIVATE_AUTOMUTE: 1298 btv->opt_automute = c->val; 1299 break; 1300 case V4L2_CID_PRIVATE_AGC_CRUSH: 1301 btwrite(BT848_ADC_RESERVED | 1302 (c->val ? BT848_ADC_CRUSH : 0), 1303 BT848_ADC); 1304 break; 1305 case V4L2_CID_PRIVATE_VCR_HACK: 1306 btv->opt_vcr_hack = c->val; 1307 break; 1308 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER: 1309 btwrite(c->val, BT848_WC_UP); 1310 break; 1311 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER: 1312 btwrite(c->val, BT848_WC_DOWN); 1313 break; 1314 case V4L2_CID_PRIVATE_UV_RATIO: 1315 btv->opt_uv_ratio = c->val; 1316 bt848_sat(btv, btv->saturation); 1317 break; 1318 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE: 1319 btaor((c->val << 7), ~BT848_OFORM_RANGE, BT848_OFORM); 1320 break; 1321 case V4L2_CID_PRIVATE_CORING: 1322 btaor((c->val << 5), ~BT848_OFORM_CORE32, BT848_OFORM); 1323 break; 1324 default: 1325 return -EINVAL; 1326 } 1327 return 0; 1328 } 1329 1330 /* ----------------------------------------------------------------------- */ 1331 1332 static const struct v4l2_ctrl_ops bttv_ctrl_ops = { 1333 .s_ctrl = bttv_s_ctrl, 1334 }; 1335 1336 static struct v4l2_ctrl_config bttv_ctrl_combfilter = { 1337 .ops = &bttv_ctrl_ops, 1338 .id = V4L2_CID_PRIVATE_COMBFILTER, 1339 .name = "Comb Filter", 1340 .type = V4L2_CTRL_TYPE_BOOLEAN, 1341 .min = 0, 1342 .max = 1, 1343 .step = 1, 1344 .def = 1, 1345 }; 1346 1347 static struct v4l2_ctrl_config bttv_ctrl_automute = { 1348 .ops = &bttv_ctrl_ops, 1349 .id = V4L2_CID_PRIVATE_AUTOMUTE, 1350 .name = "Auto Mute", 1351 .type = V4L2_CTRL_TYPE_BOOLEAN, 1352 .min = 0, 1353 .max = 1, 1354 .step = 1, 1355 .def = 1, 1356 }; 1357 1358 static struct v4l2_ctrl_config bttv_ctrl_lumafilter = { 1359 .ops = &bttv_ctrl_ops, 1360 .id = V4L2_CID_PRIVATE_LUMAFILTER, 1361 .name = "Luma Decimation Filter", 1362 .type = V4L2_CTRL_TYPE_BOOLEAN, 1363 .min = 0, 1364 .max = 1, 1365 .step = 1, 1366 .def = 1, 1367 }; 1368 1369 static struct v4l2_ctrl_config bttv_ctrl_agc_crush = { 1370 .ops = &bttv_ctrl_ops, 1371 .id = V4L2_CID_PRIVATE_AGC_CRUSH, 1372 .name = "AGC Crush", 1373 .type = V4L2_CTRL_TYPE_BOOLEAN, 1374 .min = 0, 1375 .max = 1, 1376 .step = 1, 1377 .def = 1, 1378 }; 1379 1380 static struct v4l2_ctrl_config bttv_ctrl_vcr_hack = { 1381 .ops = &bttv_ctrl_ops, 1382 .id = V4L2_CID_PRIVATE_VCR_HACK, 1383 .name = "VCR Hack", 1384 .type = V4L2_CTRL_TYPE_BOOLEAN, 1385 .min = 0, 1386 .max = 1, 1387 .step = 1, 1388 .def = 1, 1389 }; 1390 1391 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_lower = { 1392 .ops = &bttv_ctrl_ops, 1393 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER, 1394 .name = "Whitecrush Lower", 1395 .type = V4L2_CTRL_TYPE_INTEGER, 1396 .min = 0, 1397 .max = 255, 1398 .step = 1, 1399 .def = 0x7f, 1400 }; 1401 1402 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_upper = { 1403 .ops = &bttv_ctrl_ops, 1404 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER, 1405 .name = "Whitecrush Upper", 1406 .type = V4L2_CTRL_TYPE_INTEGER, 1407 .min = 0, 1408 .max = 255, 1409 .step = 1, 1410 .def = 0xcf, 1411 }; 1412 1413 static struct v4l2_ctrl_config bttv_ctrl_uv_ratio = { 1414 .ops = &bttv_ctrl_ops, 1415 .id = V4L2_CID_PRIVATE_UV_RATIO, 1416 .name = "UV Ratio", 1417 .type = V4L2_CTRL_TYPE_INTEGER, 1418 .min = 0, 1419 .max = 100, 1420 .step = 1, 1421 .def = 50, 1422 }; 1423 1424 static struct v4l2_ctrl_config bttv_ctrl_full_luma = { 1425 .ops = &bttv_ctrl_ops, 1426 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE, 1427 .name = "Full Luma Range", 1428 .type = V4L2_CTRL_TYPE_BOOLEAN, 1429 .min = 0, 1430 .max = 1, 1431 .step = 1, 1432 }; 1433 1434 static struct v4l2_ctrl_config bttv_ctrl_coring = { 1435 .ops = &bttv_ctrl_ops, 1436 .id = V4L2_CID_PRIVATE_CORING, 1437 .name = "Coring", 1438 .type = V4L2_CTRL_TYPE_INTEGER, 1439 .min = 0, 1440 .max = 3, 1441 .step = 1, 1442 }; 1443 1444 1445 /* ----------------------------------------------------------------------- */ 1446 1447 void bttv_gpio_tracking(struct bttv *btv, char *comment) 1448 { 1449 unsigned int outbits, data; 1450 outbits = btread(BT848_GPIO_OUT_EN); 1451 data = btread(BT848_GPIO_DATA); 1452 pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n", 1453 btv->c.nr, outbits, data & outbits, data & ~outbits, comment); 1454 } 1455 1456 static void bttv_field_count(struct bttv *btv) 1457 { 1458 int need_count = 0; 1459 1460 if (btv->users) 1461 need_count++; 1462 1463 if (need_count) { 1464 /* start field counter */ 1465 btor(BT848_INT_VSYNC,BT848_INT_MASK); 1466 } else { 1467 /* stop field counter */ 1468 btand(~BT848_INT_VSYNC,BT848_INT_MASK); 1469 btv->field_count = 0; 1470 } 1471 } 1472 1473 static const struct bttv_format* 1474 format_by_fourcc(int fourcc) 1475 { 1476 unsigned int i; 1477 1478 for (i = 0; i < FORMATS; i++) { 1479 if (-1 == formats[i].fourcc) 1480 continue; 1481 if (formats[i].fourcc == fourcc) 1482 return formats+i; 1483 } 1484 return NULL; 1485 } 1486 1487 /* ----------------------------------------------------------------------- */ 1488 /* video4linux (1) interface */ 1489 1490 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv, 1491 struct bttv_buffer *buf, 1492 const struct bttv_format *fmt, 1493 unsigned int width, unsigned int height, 1494 enum v4l2_field field) 1495 { 1496 struct bttv_fh *fh = q->priv_data; 1497 int redo_dma_risc = 0; 1498 struct bttv_crop c; 1499 int norm; 1500 int rc; 1501 1502 /* check settings */ 1503 if (NULL == fmt) 1504 return -EINVAL; 1505 if (fmt->btformat == BT848_COLOR_FMT_RAW) { 1506 width = RAW_BPL; 1507 height = RAW_LINES*2; 1508 if (width*height > buf->vb.bsize) 1509 return -EINVAL; 1510 buf->vb.size = buf->vb.bsize; 1511 1512 /* Make sure tvnorm and vbi_end remain consistent 1513 until we're done. */ 1514 1515 norm = btv->tvnorm; 1516 1517 /* In this mode capturing always starts at defrect.top 1518 (default VDELAY), ignoring cropping parameters. */ 1519 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) { 1520 return -EINVAL; 1521 } 1522 1523 c.rect = bttv_tvnorms[norm].cropcap.defrect; 1524 } else { 1525 norm = btv->tvnorm; 1526 c = btv->crop[!!fh->do_crop]; 1527 1528 if (width < c.min_scaled_width || 1529 width > c.max_scaled_width || 1530 height < c.min_scaled_height) 1531 return -EINVAL; 1532 1533 switch (field) { 1534 case V4L2_FIELD_TOP: 1535 case V4L2_FIELD_BOTTOM: 1536 case V4L2_FIELD_ALTERNATE: 1537 /* btv->crop counts frame lines. Max. scale 1538 factor is 16:1 for frames, 8:1 for fields. */ 1539 if (height * 2 > c.max_scaled_height) 1540 return -EINVAL; 1541 break; 1542 1543 default: 1544 if (height > c.max_scaled_height) 1545 return -EINVAL; 1546 break; 1547 } 1548 1549 buf->vb.size = (width * height * fmt->depth) >> 3; 1550 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) 1551 return -EINVAL; 1552 } 1553 1554 /* alloc + fill struct bttv_buffer (if changed) */ 1555 if (buf->vb.width != width || buf->vb.height != height || 1556 buf->vb.field != field || 1557 buf->tvnorm != norm || buf->fmt != fmt || 1558 buf->crop.top != c.rect.top || 1559 buf->crop.left != c.rect.left || 1560 buf->crop.width != c.rect.width || 1561 buf->crop.height != c.rect.height) { 1562 buf->vb.width = width; 1563 buf->vb.height = height; 1564 buf->vb.field = field; 1565 buf->tvnorm = norm; 1566 buf->fmt = fmt; 1567 buf->crop = c.rect; 1568 redo_dma_risc = 1; 1569 } 1570 1571 /* alloc risc memory */ 1572 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 1573 redo_dma_risc = 1; 1574 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf))) 1575 goto fail; 1576 } 1577 1578 if (redo_dma_risc) 1579 if (0 != (rc = bttv_buffer_risc(btv,buf))) 1580 goto fail; 1581 1582 buf->vb.state = VIDEOBUF_PREPARED; 1583 return 0; 1584 1585 fail: 1586 bttv_dma_free(q,btv,buf); 1587 return rc; 1588 } 1589 1590 static int 1591 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size) 1592 { 1593 struct bttv_fh *fh = q->priv_data; 1594 1595 *size = fh->fmt->depth*fh->width*fh->height >> 3; 1596 if (0 == *count) 1597 *count = gbuffers; 1598 if (*size * *count > gbuffers * gbufsize) 1599 *count = (gbuffers * gbufsize) / *size; 1600 return 0; 1601 } 1602 1603 static int 1604 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, 1605 enum v4l2_field field) 1606 { 1607 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 1608 struct bttv_fh *fh = q->priv_data; 1609 1610 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt, 1611 fh->width, fh->height, field); 1612 } 1613 1614 static void 1615 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb) 1616 { 1617 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 1618 struct bttv_fh *fh = q->priv_data; 1619 struct bttv *btv = fh->btv; 1620 1621 buf->vb.state = VIDEOBUF_QUEUED; 1622 list_add_tail(&buf->vb.queue,&btv->capture); 1623 if (!btv->curr.frame_irq) { 1624 btv->loop_irq |= 1; 1625 bttv_set_dma(btv, 0x03); 1626 } 1627 } 1628 1629 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb) 1630 { 1631 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 1632 struct bttv_fh *fh = q->priv_data; 1633 1634 bttv_dma_free(q,fh->btv,buf); 1635 } 1636 1637 static const struct videobuf_queue_ops bttv_video_qops = { 1638 .buf_setup = buffer_setup, 1639 .buf_prepare = buffer_prepare, 1640 .buf_queue = buffer_queue, 1641 .buf_release = buffer_release, 1642 }; 1643 1644 static void radio_enable(struct bttv *btv) 1645 { 1646 /* Switch to the radio tuner */ 1647 if (!btv->has_radio_tuner) { 1648 btv->has_radio_tuner = 1; 1649 bttv_call_all(btv, tuner, s_radio); 1650 btv->audio_input = TVAUDIO_INPUT_RADIO; 1651 audio_input(btv, btv->audio_input); 1652 } 1653 } 1654 1655 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id) 1656 { 1657 struct bttv_fh *fh = priv; 1658 struct bttv *btv = fh->btv; 1659 unsigned int i; 1660 1661 for (i = 0; i < BTTV_TVNORMS; i++) 1662 if (id & bttv_tvnorms[i].v4l2_id) 1663 break; 1664 if (i == BTTV_TVNORMS) 1665 return -EINVAL; 1666 btv->std = id; 1667 set_tvnorm(btv, i); 1668 return 0; 1669 } 1670 1671 static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id) 1672 { 1673 struct bttv_fh *fh = priv; 1674 struct bttv *btv = fh->btv; 1675 1676 *id = btv->std; 1677 return 0; 1678 } 1679 1680 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id) 1681 { 1682 struct bttv_fh *fh = f; 1683 struct bttv *btv = fh->btv; 1684 1685 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML) 1686 *id &= V4L2_STD_625_50; 1687 else 1688 *id &= V4L2_STD_525_60; 1689 return 0; 1690 } 1691 1692 static int bttv_enum_input(struct file *file, void *priv, 1693 struct v4l2_input *i) 1694 { 1695 struct bttv_fh *fh = priv; 1696 struct bttv *btv = fh->btv; 1697 1698 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) 1699 return -EINVAL; 1700 1701 i->type = V4L2_INPUT_TYPE_CAMERA; 1702 i->audioset = 0; 1703 1704 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) { 1705 sprintf(i->name, "Television"); 1706 i->type = V4L2_INPUT_TYPE_TUNER; 1707 i->tuner = 0; 1708 } else if (i->index == btv->svhs) { 1709 sprintf(i->name, "S-Video"); 1710 } else { 1711 sprintf(i->name, "Composite%d", i->index); 1712 } 1713 1714 if (i->index == btv->input) { 1715 __u32 dstatus = btread(BT848_DSTATUS); 1716 if (0 == (dstatus & BT848_DSTATUS_PRES)) 1717 i->status |= V4L2_IN_ST_NO_SIGNAL; 1718 if (0 == (dstatus & BT848_DSTATUS_HLOC)) 1719 i->status |= V4L2_IN_ST_NO_H_LOCK; 1720 } 1721 1722 i->std = BTTV_NORMS; 1723 return 0; 1724 } 1725 1726 static int bttv_g_input(struct file *file, void *priv, unsigned int *i) 1727 { 1728 struct bttv_fh *fh = priv; 1729 struct bttv *btv = fh->btv; 1730 1731 *i = btv->input; 1732 1733 return 0; 1734 } 1735 1736 static int bttv_s_input(struct file *file, void *priv, unsigned int i) 1737 { 1738 struct bttv_fh *fh = priv; 1739 struct bttv *btv = fh->btv; 1740 1741 if (i >= bttv_tvcards[btv->c.type].video_inputs) 1742 return -EINVAL; 1743 1744 set_input(btv, i, btv->tvnorm); 1745 return 0; 1746 } 1747 1748 static int bttv_s_tuner(struct file *file, void *priv, 1749 const struct v4l2_tuner *t) 1750 { 1751 struct bttv_fh *fh = priv; 1752 struct bttv *btv = fh->btv; 1753 1754 if (t->index) 1755 return -EINVAL; 1756 1757 bttv_call_all(btv, tuner, s_tuner, t); 1758 1759 if (btv->audio_mode_gpio) { 1760 struct v4l2_tuner copy = *t; 1761 1762 btv->audio_mode_gpio(btv, ©, 1); 1763 } 1764 return 0; 1765 } 1766 1767 static int bttv_g_frequency(struct file *file, void *priv, 1768 struct v4l2_frequency *f) 1769 { 1770 struct bttv_fh *fh = priv; 1771 struct bttv *btv = fh->btv; 1772 1773 if (f->tuner) 1774 return -EINVAL; 1775 1776 if (f->type == V4L2_TUNER_RADIO) 1777 radio_enable(btv); 1778 f->frequency = f->type == V4L2_TUNER_RADIO ? 1779 btv->radio_freq : btv->tv_freq; 1780 1781 return 0; 1782 } 1783 1784 static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f) 1785 { 1786 struct v4l2_frequency new_freq = *f; 1787 1788 bttv_call_all(btv, tuner, s_frequency, f); 1789 /* s_frequency may clamp the frequency, so get the actual 1790 frequency before assigning radio/tv_freq. */ 1791 bttv_call_all(btv, tuner, g_frequency, &new_freq); 1792 if (new_freq.type == V4L2_TUNER_RADIO) { 1793 radio_enable(btv); 1794 btv->radio_freq = new_freq.frequency; 1795 if (btv->has_tea575x) { 1796 btv->tea.freq = btv->radio_freq; 1797 snd_tea575x_set_freq(&btv->tea); 1798 } 1799 } else { 1800 btv->tv_freq = new_freq.frequency; 1801 } 1802 } 1803 1804 static int bttv_s_frequency(struct file *file, void *priv, 1805 const struct v4l2_frequency *f) 1806 { 1807 struct bttv_fh *fh = priv; 1808 struct bttv *btv = fh->btv; 1809 1810 if (f->tuner) 1811 return -EINVAL; 1812 1813 bttv_set_frequency(btv, f); 1814 return 0; 1815 } 1816 1817 static int bttv_log_status(struct file *file, void *f) 1818 { 1819 struct video_device *vdev = video_devdata(file); 1820 struct bttv_fh *fh = f; 1821 struct bttv *btv = fh->btv; 1822 1823 v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name); 1824 bttv_call_all(btv, core, log_status); 1825 return 0; 1826 } 1827 1828 #ifdef CONFIG_VIDEO_ADV_DEBUG 1829 static int bttv_g_register(struct file *file, void *f, 1830 struct v4l2_dbg_register *reg) 1831 { 1832 struct bttv_fh *fh = f; 1833 struct bttv *btv = fh->btv; 1834 1835 /* bt848 has a 12-bit register space */ 1836 reg->reg &= 0xfff; 1837 reg->val = btread(reg->reg); 1838 reg->size = 1; 1839 1840 return 0; 1841 } 1842 1843 static int bttv_s_register(struct file *file, void *f, 1844 const struct v4l2_dbg_register *reg) 1845 { 1846 struct bttv_fh *fh = f; 1847 struct bttv *btv = fh->btv; 1848 1849 /* bt848 has a 12-bit register space */ 1850 btwrite(reg->val, reg->reg & 0xfff); 1851 1852 return 0; 1853 } 1854 #endif 1855 1856 /* Given cropping boundaries b and the scaled width and height of a 1857 single field or frame, which must not exceed hardware limits, this 1858 function adjusts the cropping parameters c. */ 1859 static void 1860 bttv_crop_adjust (struct bttv_crop * c, 1861 const struct v4l2_rect * b, 1862 __s32 width, 1863 __s32 height, 1864 enum v4l2_field field) 1865 { 1866 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field); 1867 __s32 max_left; 1868 __s32 max_top; 1869 1870 if (width < c->min_scaled_width) { 1871 /* Max. hor. scale factor 16:1. */ 1872 c->rect.width = width * 16; 1873 } else if (width > c->max_scaled_width) { 1874 /* Min. hor. scale factor 1:1. */ 1875 c->rect.width = width; 1876 1877 max_left = b->left + b->width - width; 1878 max_left = min(max_left, (__s32) MAX_HDELAY); 1879 if (c->rect.left > max_left) 1880 c->rect.left = max_left; 1881 } 1882 1883 if (height < c->min_scaled_height) { 1884 /* Max. vert. scale factor 16:1, single fields 8:1. */ 1885 c->rect.height = height * 16; 1886 } else if (frame_height > c->max_scaled_height) { 1887 /* Min. vert. scale factor 1:1. 1888 Top and height count field lines times two. */ 1889 c->rect.height = (frame_height + 1) & ~1; 1890 1891 max_top = b->top + b->height - c->rect.height; 1892 if (c->rect.top > max_top) 1893 c->rect.top = max_top; 1894 } 1895 1896 bttv_crop_calc_limits(c); 1897 } 1898 1899 /* Returns an error if scaling to a frame or single field with the given 1900 width and height is not possible with the current cropping parameters 1901 and width aligned according to width_mask. If adjust_size is TRUE the 1902 function may adjust the width and/or height instead, rounding width 1903 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may 1904 also adjust the current cropping parameters to get closer to the 1905 desired image size. */ 1906 static int 1907 limit_scaled_size_lock (struct bttv_fh * fh, 1908 __s32 * width, 1909 __s32 * height, 1910 enum v4l2_field field, 1911 unsigned int width_mask, 1912 unsigned int width_bias, 1913 int adjust_size, 1914 int adjust_crop) 1915 { 1916 struct bttv *btv = fh->btv; 1917 const struct v4l2_rect *b; 1918 struct bttv_crop *c; 1919 __s32 min_width; 1920 __s32 min_height; 1921 __s32 max_width; 1922 __s32 max_height; 1923 int rc; 1924 1925 BUG_ON((int) width_mask >= 0 || 1926 width_bias >= (unsigned int) -width_mask); 1927 1928 /* Make sure tvnorm, vbi_end and the current cropping parameters 1929 remain consistent until we're done. */ 1930 1931 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 1932 1933 /* Do crop - use current, don't - use default parameters. */ 1934 c = &btv->crop[!!fh->do_crop]; 1935 1936 if (fh->do_crop 1937 && adjust_size 1938 && adjust_crop 1939 && !locked_btres(btv, VIDEO_RESOURCES)) { 1940 min_width = 48; 1941 min_height = 32; 1942 1943 /* We cannot scale up. When the scaled image is larger 1944 than crop.rect we adjust the crop.rect as required 1945 by the V4L2 spec, hence cropcap.bounds are our limit. */ 1946 max_width = min_t(unsigned int, b->width, MAX_HACTIVE); 1947 max_height = b->height; 1948 1949 /* We cannot capture the same line as video and VBI data. 1950 Note btv->vbi_end is really a minimum, see 1951 bttv_vbi_try_fmt(). */ 1952 if (btv->vbi_end > b->top) { 1953 max_height -= btv->vbi_end - b->top; 1954 rc = -EBUSY; 1955 if (min_height > max_height) 1956 goto fail; 1957 } 1958 } else { 1959 rc = -EBUSY; 1960 if (btv->vbi_end > c->rect.top) 1961 goto fail; 1962 1963 min_width = c->min_scaled_width; 1964 min_height = c->min_scaled_height; 1965 max_width = c->max_scaled_width; 1966 max_height = c->max_scaled_height; 1967 1968 adjust_crop = 0; 1969 } 1970 1971 min_width = (min_width - width_mask - 1) & width_mask; 1972 max_width = max_width & width_mask; 1973 1974 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */ 1975 /* Min. scale factor is 1:1. */ 1976 max_height >>= !V4L2_FIELD_HAS_BOTH(field); 1977 1978 if (adjust_size) { 1979 *width = clamp(*width, min_width, max_width); 1980 *height = clamp(*height, min_height, max_height); 1981 1982 /* Round after clamping to avoid overflow. */ 1983 *width = (*width + width_bias) & width_mask; 1984 1985 if (adjust_crop) { 1986 bttv_crop_adjust(c, b, *width, *height, field); 1987 1988 if (btv->vbi_end > c->rect.top) { 1989 /* Move the crop window out of the way. */ 1990 c->rect.top = btv->vbi_end; 1991 } 1992 } 1993 } else { 1994 rc = -EINVAL; 1995 if (*width < min_width || 1996 *height < min_height || 1997 *width > max_width || 1998 *height > max_height || 1999 0 != (*width & ~width_mask)) 2000 goto fail; 2001 } 2002 2003 rc = 0; /* success */ 2004 2005 fail: 2006 2007 return rc; 2008 } 2009 2010 /* ----------------------------------------------------------------------- */ 2011 2012 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh) 2013 { 2014 struct videobuf_queue* q = NULL; 2015 2016 switch (fh->type) { 2017 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2018 q = &fh->cap; 2019 break; 2020 case V4L2_BUF_TYPE_VBI_CAPTURE: 2021 q = &fh->vbi; 2022 break; 2023 default: 2024 BUG(); 2025 } 2026 return q; 2027 } 2028 2029 static int bttv_resource(struct bttv_fh *fh) 2030 { 2031 int res = 0; 2032 2033 switch (fh->type) { 2034 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2035 res = RESOURCE_VIDEO_STREAM; 2036 break; 2037 case V4L2_BUF_TYPE_VBI_CAPTURE: 2038 res = RESOURCE_VBI; 2039 break; 2040 default: 2041 BUG(); 2042 } 2043 return res; 2044 } 2045 2046 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type) 2047 { 2048 struct videobuf_queue *q = bttv_queue(fh); 2049 int res = bttv_resource(fh); 2050 2051 if (check_btres(fh,res)) 2052 return -EBUSY; 2053 if (videobuf_queue_is_busy(q)) 2054 return -EBUSY; 2055 fh->type = type; 2056 return 0; 2057 } 2058 2059 static void 2060 pix_format_set_size (struct v4l2_pix_format * f, 2061 const struct bttv_format * fmt, 2062 unsigned int width, 2063 unsigned int height) 2064 { 2065 f->width = width; 2066 f->height = height; 2067 2068 if (fmt->flags & FORMAT_FLAGS_PLANAR) { 2069 f->bytesperline = width; /* Y plane */ 2070 f->sizeimage = (width * height * fmt->depth) >> 3; 2071 } else { 2072 f->bytesperline = (width * fmt->depth) >> 3; 2073 f->sizeimage = height * f->bytesperline; 2074 } 2075 } 2076 2077 static int bttv_g_fmt_vid_cap(struct file *file, void *priv, 2078 struct v4l2_format *f) 2079 { 2080 struct bttv_fh *fh = priv; 2081 2082 pix_format_set_size(&f->fmt.pix, fh->fmt, 2083 fh->width, fh->height); 2084 f->fmt.pix.field = fh->cap.field; 2085 f->fmt.pix.pixelformat = fh->fmt->fourcc; 2086 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 2087 2088 return 0; 2089 } 2090 2091 static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt, 2092 unsigned int *width_mask, 2093 unsigned int *width_bias) 2094 { 2095 if (fmt->flags & FORMAT_FLAGS_PLANAR) { 2096 *width_mask = ~15; /* width must be a multiple of 16 pixels */ 2097 *width_bias = 8; /* nearest */ 2098 } else { 2099 *width_mask = ~3; /* width must be a multiple of 4 pixels */ 2100 *width_bias = 2; /* nearest */ 2101 } 2102 } 2103 2104 static int bttv_try_fmt_vid_cap(struct file *file, void *priv, 2105 struct v4l2_format *f) 2106 { 2107 const struct bttv_format *fmt; 2108 struct bttv_fh *fh = priv; 2109 struct bttv *btv = fh->btv; 2110 enum v4l2_field field; 2111 __s32 width, height; 2112 __s32 height2; 2113 unsigned int width_mask, width_bias; 2114 int rc; 2115 2116 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2117 if (NULL == fmt) 2118 return -EINVAL; 2119 2120 field = f->fmt.pix.field; 2121 2122 switch (field) { 2123 case V4L2_FIELD_TOP: 2124 case V4L2_FIELD_BOTTOM: 2125 case V4L2_FIELD_ALTERNATE: 2126 case V4L2_FIELD_INTERLACED: 2127 break; 2128 case V4L2_FIELD_SEQ_BT: 2129 case V4L2_FIELD_SEQ_TB: 2130 if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) { 2131 field = V4L2_FIELD_SEQ_TB; 2132 break; 2133 } 2134 fallthrough; 2135 default: /* FIELD_ANY case */ 2136 height2 = btv->crop[!!fh->do_crop].rect.height >> 1; 2137 field = (f->fmt.pix.height > height2) 2138 ? V4L2_FIELD_INTERLACED 2139 : V4L2_FIELD_BOTTOM; 2140 break; 2141 } 2142 2143 width = f->fmt.pix.width; 2144 height = f->fmt.pix.height; 2145 2146 bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias); 2147 rc = limit_scaled_size_lock(fh, &width, &height, field, 2148 width_mask, width_bias, 2149 /* adjust_size */ 1, 2150 /* adjust_crop */ 0); 2151 if (0 != rc) 2152 return rc; 2153 2154 /* update data for the application */ 2155 f->fmt.pix.field = field; 2156 pix_format_set_size(&f->fmt.pix, fmt, width, height); 2157 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 2158 2159 return 0; 2160 } 2161 2162 static int bttv_s_fmt_vid_cap(struct file *file, void *priv, 2163 struct v4l2_format *f) 2164 { 2165 int retval; 2166 const struct bttv_format *fmt; 2167 struct bttv_fh *fh = priv; 2168 struct bttv *btv = fh->btv; 2169 __s32 width, height; 2170 unsigned int width_mask, width_bias; 2171 enum v4l2_field field; 2172 2173 retval = bttv_switch_type(fh, f->type); 2174 if (0 != retval) 2175 return retval; 2176 2177 retval = bttv_try_fmt_vid_cap(file, priv, f); 2178 if (0 != retval) 2179 return retval; 2180 2181 width = f->fmt.pix.width; 2182 height = f->fmt.pix.height; 2183 field = f->fmt.pix.field; 2184 2185 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2186 bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias); 2187 retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field, 2188 width_mask, width_bias, 2189 /* adjust_size */ 1, 2190 /* adjust_crop */ 1); 2191 if (0 != retval) 2192 return retval; 2193 2194 f->fmt.pix.field = field; 2195 2196 /* update our state information */ 2197 fh->fmt = fmt; 2198 fh->cap.field = f->fmt.pix.field; 2199 fh->cap.last = V4L2_FIELD_NONE; 2200 fh->width = f->fmt.pix.width; 2201 fh->height = f->fmt.pix.height; 2202 btv->init.fmt = fmt; 2203 btv->init.width = f->fmt.pix.width; 2204 btv->init.height = f->fmt.pix.height; 2205 2206 return 0; 2207 } 2208 2209 static int bttv_querycap(struct file *file, void *priv, 2210 struct v4l2_capability *cap) 2211 { 2212 struct bttv_fh *fh = priv; 2213 struct bttv *btv = fh->btv; 2214 2215 if (0 == v4l2) 2216 return -EINVAL; 2217 2218 strscpy(cap->driver, "bttv", sizeof(cap->driver)); 2219 strscpy(cap->card, btv->video_dev.name, sizeof(cap->card)); 2220 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | 2221 V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS; 2222 if (video_is_registered(&btv->vbi_dev)) 2223 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 2224 if (video_is_registered(&btv->radio_dev)) { 2225 cap->capabilities |= V4L2_CAP_RADIO; 2226 if (btv->has_tea575x) 2227 cap->capabilities |= V4L2_CAP_HW_FREQ_SEEK; 2228 } 2229 2230 /* 2231 * No need to lock here: those vars are initialized during board 2232 * probe and remains untouched during the rest of the driver lifecycle 2233 */ 2234 if (btv->has_saa6588) 2235 cap->capabilities |= V4L2_CAP_RDS_CAPTURE; 2236 if (btv->tuner_type != TUNER_ABSENT) 2237 cap->capabilities |= V4L2_CAP_TUNER; 2238 return 0; 2239 } 2240 2241 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv, 2242 struct v4l2_fmtdesc *f) 2243 { 2244 int index = -1, i; 2245 2246 for (i = 0; i < FORMATS; i++) { 2247 if (formats[i].fourcc != -1) 2248 index++; 2249 if ((unsigned int)index == f->index) 2250 break; 2251 } 2252 if (FORMATS == i) 2253 return -EINVAL; 2254 2255 f->pixelformat = formats[i].fourcc; 2256 2257 return 0; 2258 } 2259 2260 static int bttv_reqbufs(struct file *file, void *priv, 2261 struct v4l2_requestbuffers *p) 2262 { 2263 struct bttv_fh *fh = priv; 2264 return videobuf_reqbufs(bttv_queue(fh), p); 2265 } 2266 2267 static int bttv_querybuf(struct file *file, void *priv, 2268 struct v4l2_buffer *b) 2269 { 2270 struct bttv_fh *fh = priv; 2271 return videobuf_querybuf(bttv_queue(fh), b); 2272 } 2273 2274 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2275 { 2276 struct bttv_fh *fh = priv; 2277 struct bttv *btv = fh->btv; 2278 int res = bttv_resource(fh); 2279 2280 if (!check_alloc_btres_lock(btv, fh, res)) 2281 return -EBUSY; 2282 2283 return videobuf_qbuf(bttv_queue(fh), b); 2284 } 2285 2286 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2287 { 2288 struct bttv_fh *fh = priv; 2289 return videobuf_dqbuf(bttv_queue(fh), b, 2290 file->f_flags & O_NONBLOCK); 2291 } 2292 2293 static int bttv_streamon(struct file *file, void *priv, 2294 enum v4l2_buf_type type) 2295 { 2296 struct bttv_fh *fh = priv; 2297 struct bttv *btv = fh->btv; 2298 int res = bttv_resource(fh); 2299 2300 if (!check_alloc_btres_lock(btv, fh, res)) 2301 return -EBUSY; 2302 return videobuf_streamon(bttv_queue(fh)); 2303 } 2304 2305 2306 static int bttv_streamoff(struct file *file, void *priv, 2307 enum v4l2_buf_type type) 2308 { 2309 struct bttv_fh *fh = priv; 2310 struct bttv *btv = fh->btv; 2311 int retval; 2312 int res = bttv_resource(fh); 2313 2314 2315 retval = videobuf_streamoff(bttv_queue(fh)); 2316 if (retval < 0) 2317 return retval; 2318 free_btres_lock(btv, fh, res); 2319 return 0; 2320 } 2321 2322 static int bttv_g_parm(struct file *file, void *f, 2323 struct v4l2_streamparm *parm) 2324 { 2325 struct bttv_fh *fh = f; 2326 struct bttv *btv = fh->btv; 2327 2328 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2329 return -EINVAL; 2330 parm->parm.capture.readbuffers = gbuffers; 2331 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id, 2332 &parm->parm.capture.timeperframe); 2333 2334 return 0; 2335 } 2336 2337 static int bttv_g_tuner(struct file *file, void *priv, 2338 struct v4l2_tuner *t) 2339 { 2340 struct bttv_fh *fh = priv; 2341 struct bttv *btv = fh->btv; 2342 2343 if (0 != t->index) 2344 return -EINVAL; 2345 2346 t->rxsubchans = V4L2_TUNER_SUB_MONO; 2347 t->capability = V4L2_TUNER_CAP_NORM; 2348 bttv_call_all(btv, tuner, g_tuner, t); 2349 strscpy(t->name, "Television", sizeof(t->name)); 2350 t->type = V4L2_TUNER_ANALOG_TV; 2351 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) 2352 t->signal = 0xffff; 2353 2354 if (btv->audio_mode_gpio) 2355 btv->audio_mode_gpio(btv, t, 0); 2356 2357 return 0; 2358 } 2359 2360 static int bttv_g_pixelaspect(struct file *file, void *priv, 2361 int type, struct v4l2_fract *f) 2362 { 2363 struct bttv_fh *fh = priv; 2364 struct bttv *btv = fh->btv; 2365 2366 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2367 return -EINVAL; 2368 2369 /* defrect and bounds are set via g_selection */ 2370 *f = bttv_tvnorms[btv->tvnorm].cropcap.pixelaspect; 2371 return 0; 2372 } 2373 2374 static int bttv_g_selection(struct file *file, void *f, struct v4l2_selection *sel) 2375 { 2376 struct bttv_fh *fh = f; 2377 struct bttv *btv = fh->btv; 2378 2379 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2380 return -EINVAL; 2381 2382 switch (sel->target) { 2383 case V4L2_SEL_TGT_CROP: 2384 /* 2385 * No fh->do_crop = 1; because btv->crop[1] may be 2386 * inconsistent with fh->width or fh->height and apps 2387 * do not expect a change here. 2388 */ 2389 sel->r = btv->crop[!!fh->do_crop].rect; 2390 break; 2391 case V4L2_SEL_TGT_CROP_DEFAULT: 2392 sel->r = bttv_tvnorms[btv->tvnorm].cropcap.defrect; 2393 break; 2394 case V4L2_SEL_TGT_CROP_BOUNDS: 2395 sel->r = bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2396 break; 2397 default: 2398 return -EINVAL; 2399 } 2400 2401 return 0; 2402 } 2403 2404 static int bttv_s_selection(struct file *file, void *f, struct v4l2_selection *sel) 2405 { 2406 struct bttv_fh *fh = f; 2407 struct bttv *btv = fh->btv; 2408 const struct v4l2_rect *b; 2409 int retval; 2410 struct bttv_crop c; 2411 __s32 b_left; 2412 __s32 b_top; 2413 __s32 b_right; 2414 __s32 b_bottom; 2415 2416 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2417 return -EINVAL; 2418 2419 if (sel->target != V4L2_SEL_TGT_CROP) 2420 return -EINVAL; 2421 2422 /* Make sure tvnorm, vbi_end and the current cropping 2423 parameters remain consistent until we're done. Note 2424 read() may change vbi_end in check_alloc_btres_lock(). */ 2425 retval = -EBUSY; 2426 2427 if (locked_btres(fh->btv, VIDEO_RESOURCES)) { 2428 return retval; 2429 } 2430 2431 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2432 2433 b_left = b->left; 2434 b_right = b_left + b->width; 2435 b_bottom = b->top + b->height; 2436 2437 b_top = max(b->top, btv->vbi_end); 2438 if (b_top + 32 >= b_bottom) { 2439 return retval; 2440 } 2441 2442 /* Min. scaled size 48 x 32. */ 2443 c.rect.left = clamp_t(s32, sel->r.left, b_left, b_right - 48); 2444 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY); 2445 2446 c.rect.width = clamp_t(s32, sel->r.width, 2447 48, b_right - c.rect.left); 2448 2449 c.rect.top = clamp_t(s32, sel->r.top, b_top, b_bottom - 32); 2450 /* Top and height must be a multiple of two. */ 2451 c.rect.top = (c.rect.top + 1) & ~1; 2452 2453 c.rect.height = clamp_t(s32, sel->r.height, 2454 32, b_bottom - c.rect.top); 2455 c.rect.height = (c.rect.height + 1) & ~1; 2456 2457 bttv_crop_calc_limits(&c); 2458 2459 sel->r = c.rect; 2460 2461 btv->crop[1] = c; 2462 2463 fh->do_crop = 1; 2464 2465 if (fh->width < c.min_scaled_width) { 2466 fh->width = c.min_scaled_width; 2467 btv->init.width = c.min_scaled_width; 2468 } else if (fh->width > c.max_scaled_width) { 2469 fh->width = c.max_scaled_width; 2470 btv->init.width = c.max_scaled_width; 2471 } 2472 2473 if (fh->height < c.min_scaled_height) { 2474 fh->height = c.min_scaled_height; 2475 btv->init.height = c.min_scaled_height; 2476 } else if (fh->height > c.max_scaled_height) { 2477 fh->height = c.max_scaled_height; 2478 btv->init.height = c.max_scaled_height; 2479 } 2480 2481 return 0; 2482 } 2483 2484 static ssize_t bttv_read(struct file *file, char __user *data, 2485 size_t count, loff_t *ppos) 2486 { 2487 struct bttv_fh *fh = file->private_data; 2488 int retval = 0; 2489 2490 if (fh->btv->errors) 2491 bttv_reinit_bt848(fh->btv); 2492 dprintk("%d: read count=%d type=%s\n", 2493 fh->btv->c.nr, (int)count, v4l2_type_names[fh->type]); 2494 2495 switch (fh->type) { 2496 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2497 if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) { 2498 /* VIDEO_READ in use by another fh, 2499 or VIDEO_STREAM by any fh. */ 2500 return -EBUSY; 2501 } 2502 retval = videobuf_read_one(&fh->cap, data, count, ppos, 2503 file->f_flags & O_NONBLOCK); 2504 free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ); 2505 break; 2506 case V4L2_BUF_TYPE_VBI_CAPTURE: 2507 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI)) 2508 return -EBUSY; 2509 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1, 2510 file->f_flags & O_NONBLOCK); 2511 break; 2512 default: 2513 BUG(); 2514 } 2515 return retval; 2516 } 2517 2518 static __poll_t bttv_poll(struct file *file, poll_table *wait) 2519 { 2520 struct bttv_fh *fh = file->private_data; 2521 struct bttv_buffer *buf; 2522 enum v4l2_field field; 2523 __poll_t rc = 0; 2524 __poll_t req_events = poll_requested_events(wait); 2525 2526 if (v4l2_event_pending(&fh->fh)) 2527 rc = EPOLLPRI; 2528 else if (req_events & EPOLLPRI) 2529 poll_wait(file, &fh->fh.wait, wait); 2530 2531 if (!(req_events & (EPOLLIN | EPOLLRDNORM))) 2532 return rc; 2533 2534 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) { 2535 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI)) 2536 return rc | EPOLLERR; 2537 return rc | videobuf_poll_stream(file, &fh->vbi, wait); 2538 } 2539 2540 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) { 2541 /* streaming capture */ 2542 if (list_empty(&fh->cap.stream)) 2543 return rc | EPOLLERR; 2544 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream); 2545 } else { 2546 /* read() capture */ 2547 if (NULL == fh->cap.read_buf) { 2548 /* need to capture a new frame */ 2549 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM)) 2550 return rc | EPOLLERR; 2551 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize); 2552 if (NULL == fh->cap.read_buf) 2553 return rc | EPOLLERR; 2554 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR; 2555 field = videobuf_next_field(&fh->cap); 2556 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) { 2557 kfree (fh->cap.read_buf); 2558 fh->cap.read_buf = NULL; 2559 return rc | EPOLLERR; 2560 } 2561 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf); 2562 fh->cap.read_off = 0; 2563 } 2564 buf = (struct bttv_buffer*)fh->cap.read_buf; 2565 } 2566 2567 poll_wait(file, &buf->vb.done, wait); 2568 if (buf->vb.state == VIDEOBUF_DONE || 2569 buf->vb.state == VIDEOBUF_ERROR) 2570 rc = rc | EPOLLIN|EPOLLRDNORM; 2571 return rc; 2572 } 2573 2574 static int bttv_open(struct file *file) 2575 { 2576 struct video_device *vdev = video_devdata(file); 2577 struct bttv *btv = video_drvdata(file); 2578 struct bttv_fh *fh; 2579 enum v4l2_buf_type type = 0; 2580 2581 dprintk("open dev=%s\n", video_device_node_name(vdev)); 2582 2583 if (vdev->vfl_type == VFL_TYPE_VIDEO) { 2584 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2585 } else if (vdev->vfl_type == VFL_TYPE_VBI) { 2586 type = V4L2_BUF_TYPE_VBI_CAPTURE; 2587 } else { 2588 WARN_ON(1); 2589 return -ENODEV; 2590 } 2591 2592 dprintk("%d: open called (type=%s)\n", 2593 btv->c.nr, v4l2_type_names[type]); 2594 2595 /* allocate per filehandle data */ 2596 fh = kmalloc(sizeof(*fh), GFP_KERNEL); 2597 if (unlikely(!fh)) 2598 return -ENOMEM; 2599 btv->users++; 2600 file->private_data = fh; 2601 2602 *fh = btv->init; 2603 v4l2_fh_init(&fh->fh, vdev); 2604 2605 fh->type = type; 2606 2607 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops, 2608 &btv->c.pci->dev, &btv->s_lock, 2609 V4L2_BUF_TYPE_VIDEO_CAPTURE, 2610 V4L2_FIELD_INTERLACED, 2611 sizeof(struct bttv_buffer), 2612 fh, &btv->lock); 2613 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops, 2614 &btv->c.pci->dev, &btv->s_lock, 2615 V4L2_BUF_TYPE_VBI_CAPTURE, 2616 V4L2_FIELD_SEQ_TB, 2617 sizeof(struct bttv_buffer), 2618 fh, &btv->lock); 2619 set_tvnorm(btv,btv->tvnorm); 2620 set_input(btv, btv->input, btv->tvnorm); 2621 audio_mute(btv, btv->mute); 2622 2623 /* The V4L2 spec requires one global set of cropping parameters 2624 which only change on request. These are stored in btv->crop[1]. 2625 However for compatibility with V4L apps and cropping unaware 2626 V4L2 apps we now reset the cropping parameters as seen through 2627 this fh, which is to say VIDIOC_G_SELECTION and scaling limit checks 2628 will use btv->crop[0], the default cropping parameters for the 2629 current video standard, and VIDIOC_S_FMT will not implicitly 2630 change the cropping parameters until VIDIOC_S_SELECTION has been 2631 called. */ 2632 fh->do_crop = !reset_crop; /* module parameter */ 2633 2634 /* Likewise there should be one global set of VBI capture 2635 parameters, but for compatibility with V4L apps and earlier 2636 driver versions each fh has its own parameters. */ 2637 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm); 2638 2639 bttv_field_count(btv); 2640 v4l2_fh_add(&fh->fh); 2641 return 0; 2642 } 2643 2644 static int bttv_release(struct file *file) 2645 { 2646 struct bttv_fh *fh = file->private_data; 2647 struct bttv *btv = fh->btv; 2648 2649 /* stop video capture */ 2650 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) { 2651 videobuf_streamoff(&fh->cap); 2652 free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM); 2653 } 2654 if (fh->cap.read_buf) { 2655 buffer_release(&fh->cap,fh->cap.read_buf); 2656 kfree(fh->cap.read_buf); 2657 } 2658 if (check_btres(fh, RESOURCE_VIDEO_READ)) { 2659 free_btres_lock(btv, fh, RESOURCE_VIDEO_READ); 2660 } 2661 2662 /* stop vbi capture */ 2663 if (check_btres(fh, RESOURCE_VBI)) { 2664 videobuf_stop(&fh->vbi); 2665 free_btres_lock(btv,fh,RESOURCE_VBI); 2666 } 2667 2668 /* free stuff */ 2669 2670 videobuf_mmap_free(&fh->cap); 2671 videobuf_mmap_free(&fh->vbi); 2672 file->private_data = NULL; 2673 2674 btv->users--; 2675 bttv_field_count(btv); 2676 2677 if (!btv->users) 2678 audio_mute(btv, btv->mute); 2679 2680 v4l2_fh_del(&fh->fh); 2681 v4l2_fh_exit(&fh->fh); 2682 kfree(fh); 2683 return 0; 2684 } 2685 2686 static int 2687 bttv_mmap(struct file *file, struct vm_area_struct *vma) 2688 { 2689 struct bttv_fh *fh = file->private_data; 2690 2691 dprintk("%d: mmap type=%s 0x%lx+%ld\n", 2692 fh->btv->c.nr, v4l2_type_names[fh->type], 2693 vma->vm_start, vma->vm_end - vma->vm_start); 2694 return videobuf_mmap_mapper(bttv_queue(fh),vma); 2695 } 2696 2697 static const struct v4l2_file_operations bttv_fops = 2698 { 2699 .owner = THIS_MODULE, 2700 .open = bttv_open, 2701 .release = bttv_release, 2702 .unlocked_ioctl = video_ioctl2, 2703 .read = bttv_read, 2704 .mmap = bttv_mmap, 2705 .poll = bttv_poll, 2706 }; 2707 2708 static const struct v4l2_ioctl_ops bttv_ioctl_ops = { 2709 .vidioc_querycap = bttv_querycap, 2710 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap, 2711 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap, 2712 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap, 2713 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap, 2714 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap, 2715 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap, 2716 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap, 2717 .vidioc_g_pixelaspect = bttv_g_pixelaspect, 2718 .vidioc_reqbufs = bttv_reqbufs, 2719 .vidioc_querybuf = bttv_querybuf, 2720 .vidioc_qbuf = bttv_qbuf, 2721 .vidioc_dqbuf = bttv_dqbuf, 2722 .vidioc_s_std = bttv_s_std, 2723 .vidioc_g_std = bttv_g_std, 2724 .vidioc_enum_input = bttv_enum_input, 2725 .vidioc_g_input = bttv_g_input, 2726 .vidioc_s_input = bttv_s_input, 2727 .vidioc_streamon = bttv_streamon, 2728 .vidioc_streamoff = bttv_streamoff, 2729 .vidioc_g_tuner = bttv_g_tuner, 2730 .vidioc_s_tuner = bttv_s_tuner, 2731 .vidioc_g_selection = bttv_g_selection, 2732 .vidioc_s_selection = bttv_s_selection, 2733 .vidioc_g_parm = bttv_g_parm, 2734 .vidioc_g_frequency = bttv_g_frequency, 2735 .vidioc_s_frequency = bttv_s_frequency, 2736 .vidioc_log_status = bttv_log_status, 2737 .vidioc_querystd = bttv_querystd, 2738 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2739 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2740 #ifdef CONFIG_VIDEO_ADV_DEBUG 2741 .vidioc_g_register = bttv_g_register, 2742 .vidioc_s_register = bttv_s_register, 2743 #endif 2744 }; 2745 2746 static struct video_device bttv_video_template = { 2747 .fops = &bttv_fops, 2748 .ioctl_ops = &bttv_ioctl_ops, 2749 .tvnorms = BTTV_NORMS, 2750 }; 2751 2752 /* ----------------------------------------------------------------------- */ 2753 /* radio interface */ 2754 2755 static int radio_open(struct file *file) 2756 { 2757 struct video_device *vdev = video_devdata(file); 2758 struct bttv *btv = video_drvdata(file); 2759 struct bttv_fh *fh; 2760 2761 dprintk("open dev=%s\n", video_device_node_name(vdev)); 2762 2763 dprintk("%d: open called (radio)\n", btv->c.nr); 2764 2765 /* allocate per filehandle data */ 2766 fh = kmalloc(sizeof(*fh), GFP_KERNEL); 2767 if (unlikely(!fh)) 2768 return -ENOMEM; 2769 file->private_data = fh; 2770 *fh = btv->init; 2771 v4l2_fh_init(&fh->fh, vdev); 2772 2773 btv->radio_user++; 2774 audio_mute(btv, btv->mute); 2775 2776 v4l2_fh_add(&fh->fh); 2777 2778 return 0; 2779 } 2780 2781 static int radio_release(struct file *file) 2782 { 2783 struct bttv_fh *fh = file->private_data; 2784 struct bttv *btv = fh->btv; 2785 struct saa6588_command cmd; 2786 2787 file->private_data = NULL; 2788 v4l2_fh_del(&fh->fh); 2789 v4l2_fh_exit(&fh->fh); 2790 kfree(fh); 2791 2792 btv->radio_user--; 2793 2794 bttv_call_all(btv, core, command, SAA6588_CMD_CLOSE, &cmd); 2795 2796 if (btv->radio_user == 0) 2797 btv->has_radio_tuner = 0; 2798 return 0; 2799 } 2800 2801 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 2802 { 2803 struct bttv_fh *fh = priv; 2804 struct bttv *btv = fh->btv; 2805 2806 if (0 != t->index) 2807 return -EINVAL; 2808 strscpy(t->name, "Radio", sizeof(t->name)); 2809 t->type = V4L2_TUNER_RADIO; 2810 radio_enable(btv); 2811 2812 bttv_call_all(btv, tuner, g_tuner, t); 2813 2814 if (btv->audio_mode_gpio) 2815 btv->audio_mode_gpio(btv, t, 0); 2816 2817 if (btv->has_tea575x) 2818 return snd_tea575x_g_tuner(&btv->tea, t); 2819 2820 return 0; 2821 } 2822 2823 static int radio_s_tuner(struct file *file, void *priv, 2824 const struct v4l2_tuner *t) 2825 { 2826 struct bttv_fh *fh = priv; 2827 struct bttv *btv = fh->btv; 2828 2829 if (0 != t->index) 2830 return -EINVAL; 2831 2832 radio_enable(btv); 2833 bttv_call_all(btv, tuner, s_tuner, t); 2834 return 0; 2835 } 2836 2837 static int radio_s_hw_freq_seek(struct file *file, void *priv, 2838 const struct v4l2_hw_freq_seek *a) 2839 { 2840 struct bttv_fh *fh = priv; 2841 struct bttv *btv = fh->btv; 2842 2843 if (btv->has_tea575x) 2844 return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a); 2845 2846 return -ENOTTY; 2847 } 2848 2849 static int radio_enum_freq_bands(struct file *file, void *priv, 2850 struct v4l2_frequency_band *band) 2851 { 2852 struct bttv_fh *fh = priv; 2853 struct bttv *btv = fh->btv; 2854 2855 if (btv->has_tea575x) 2856 return snd_tea575x_enum_freq_bands(&btv->tea, band); 2857 2858 return -ENOTTY; 2859 } 2860 2861 static ssize_t radio_read(struct file *file, char __user *data, 2862 size_t count, loff_t *ppos) 2863 { 2864 struct bttv_fh *fh = file->private_data; 2865 struct bttv *btv = fh->btv; 2866 struct saa6588_command cmd; 2867 2868 cmd.block_count = count / 3; 2869 cmd.nonblocking = file->f_flags & O_NONBLOCK; 2870 cmd.buffer = data; 2871 cmd.instance = file; 2872 cmd.result = -ENODEV; 2873 radio_enable(btv); 2874 2875 bttv_call_all(btv, core, command, SAA6588_CMD_READ, &cmd); 2876 2877 return cmd.result; 2878 } 2879 2880 static __poll_t radio_poll(struct file *file, poll_table *wait) 2881 { 2882 struct bttv_fh *fh = file->private_data; 2883 struct bttv *btv = fh->btv; 2884 __poll_t req_events = poll_requested_events(wait); 2885 struct saa6588_command cmd; 2886 __poll_t res = 0; 2887 2888 if (v4l2_event_pending(&fh->fh)) 2889 res = EPOLLPRI; 2890 else if (req_events & EPOLLPRI) 2891 poll_wait(file, &fh->fh.wait, wait); 2892 radio_enable(btv); 2893 cmd.instance = file; 2894 cmd.event_list = wait; 2895 cmd.poll_mask = res; 2896 bttv_call_all(btv, core, command, SAA6588_CMD_POLL, &cmd); 2897 2898 return cmd.poll_mask; 2899 } 2900 2901 static const struct v4l2_file_operations radio_fops = 2902 { 2903 .owner = THIS_MODULE, 2904 .open = radio_open, 2905 .read = radio_read, 2906 .release = radio_release, 2907 .unlocked_ioctl = video_ioctl2, 2908 .poll = radio_poll, 2909 }; 2910 2911 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2912 .vidioc_querycap = bttv_querycap, 2913 .vidioc_log_status = bttv_log_status, 2914 .vidioc_g_tuner = radio_g_tuner, 2915 .vidioc_s_tuner = radio_s_tuner, 2916 .vidioc_g_frequency = bttv_g_frequency, 2917 .vidioc_s_frequency = bttv_s_frequency, 2918 .vidioc_s_hw_freq_seek = radio_s_hw_freq_seek, 2919 .vidioc_enum_freq_bands = radio_enum_freq_bands, 2920 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2921 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2922 }; 2923 2924 static struct video_device radio_template = { 2925 .fops = &radio_fops, 2926 .ioctl_ops = &radio_ioctl_ops, 2927 }; 2928 2929 /* ----------------------------------------------------------------------- */ 2930 /* some debug code */ 2931 2932 static int bttv_risc_decode(u32 risc) 2933 { 2934 static char *instr[16] = { 2935 [ BT848_RISC_WRITE >> 28 ] = "write", 2936 [ BT848_RISC_SKIP >> 28 ] = "skip", 2937 [ BT848_RISC_WRITEC >> 28 ] = "writec", 2938 [ BT848_RISC_JUMP >> 28 ] = "jump", 2939 [ BT848_RISC_SYNC >> 28 ] = "sync", 2940 [ BT848_RISC_WRITE123 >> 28 ] = "write123", 2941 [ BT848_RISC_SKIP123 >> 28 ] = "skip123", 2942 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23", 2943 }; 2944 static int incr[16] = { 2945 [ BT848_RISC_WRITE >> 28 ] = 2, 2946 [ BT848_RISC_JUMP >> 28 ] = 2, 2947 [ BT848_RISC_SYNC >> 28 ] = 2, 2948 [ BT848_RISC_WRITE123 >> 28 ] = 5, 2949 [ BT848_RISC_SKIP123 >> 28 ] = 2, 2950 [ BT848_RISC_WRITE1S23 >> 28 ] = 3, 2951 }; 2952 static char *bits[] = { 2953 "be0", "be1", "be2", "be3/resync", 2954 "set0", "set1", "set2", "set3", 2955 "clr0", "clr1", "clr2", "clr3", 2956 "irq", "res", "eol", "sol", 2957 }; 2958 int i; 2959 2960 pr_cont("0x%08x [ %s", risc, 2961 instr[risc >> 28] ? instr[risc >> 28] : "INVALID"); 2962 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--) 2963 if (risc & (1 << (i + 12))) 2964 pr_cont(" %s", bits[i]); 2965 pr_cont(" count=%d ]\n", risc & 0xfff); 2966 return incr[risc >> 28] ? incr[risc >> 28] : 1; 2967 } 2968 2969 static void bttv_risc_disasm(struct bttv *btv, 2970 struct btcx_riscmem *risc) 2971 { 2972 unsigned int i,j,n; 2973 2974 pr_info("%s: risc disasm: %p [dma=0x%08lx]\n", 2975 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma); 2976 for (i = 0; i < (risc->size >> 2); i += n) { 2977 pr_info("%s: 0x%lx: ", 2978 btv->c.v4l2_dev.name, 2979 (unsigned long)(risc->dma + (i<<2))); 2980 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i])); 2981 for (j = 1; j < n; j++) 2982 pr_info("%s: 0x%lx: 0x%08x [ arg #%d ]\n", 2983 btv->c.v4l2_dev.name, 2984 (unsigned long)(risc->dma + ((i+j)<<2)), 2985 risc->cpu[i+j], j); 2986 if (0 == risc->cpu[i]) 2987 break; 2988 } 2989 } 2990 2991 static void bttv_print_riscaddr(struct bttv *btv) 2992 { 2993 pr_info(" main: %08llx\n", (unsigned long long)btv->main.dma); 2994 pr_info(" vbi : o=%08llx e=%08llx\n", 2995 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0, 2996 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0); 2997 pr_info(" cap : o=%08llx e=%08llx\n", 2998 btv->curr.top 2999 ? (unsigned long long)btv->curr.top->top.dma : 0, 3000 btv->curr.bottom 3001 ? (unsigned long long)btv->curr.bottom->bottom.dma : 0); 3002 bttv_risc_disasm(btv, &btv->main); 3003 } 3004 3005 /* ----------------------------------------------------------------------- */ 3006 /* irq handler */ 3007 3008 static char *irq_name[] = { 3009 "FMTCHG", // format change detected (525 vs. 625) 3010 "VSYNC", // vertical sync (new field) 3011 "HSYNC", // horizontal sync 3012 "OFLOW", // chroma/luma AGC overflow 3013 "HLOCK", // horizontal lock changed 3014 "VPRES", // video presence changed 3015 "6", "7", 3016 "I2CDONE", // hw irc operation finished 3017 "GPINT", // gpio port triggered irq 3018 "10", 3019 "RISCI", // risc instruction triggered irq 3020 "FBUS", // pixel data fifo dropped data (high pci bus latencies) 3021 "FTRGT", // pixel data fifo overrun 3022 "FDSR", // fifo data stream resyncronisation 3023 "PPERR", // parity error (data transfer) 3024 "RIPERR", // parity error (read risc instructions) 3025 "PABORT", // pci abort 3026 "OCERR", // risc instruction error 3027 "SCERR", // syncronisation error 3028 }; 3029 3030 static void bttv_print_irqbits(u32 print, u32 mark) 3031 { 3032 unsigned int i; 3033 3034 pr_cont("bits:"); 3035 for (i = 0; i < ARRAY_SIZE(irq_name); i++) { 3036 if (print & (1 << i)) 3037 pr_cont(" %s", irq_name[i]); 3038 if (mark & (1 << i)) 3039 pr_cont("*"); 3040 } 3041 } 3042 3043 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc) 3044 { 3045 pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n", 3046 btv->c.nr, 3047 (unsigned long)btv->main.dma, 3048 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]), 3049 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]), 3050 (unsigned long)rc); 3051 3052 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) { 3053 pr_notice("%d: Oh, there (temporarily?) is no input signal. Ok, then this is harmless, don't worry ;)\n", 3054 btv->c.nr); 3055 return; 3056 } 3057 pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n", 3058 btv->c.nr); 3059 pr_notice("%d: Lets try to catch the culprit red-handed ...\n", 3060 btv->c.nr); 3061 dump_stack(); 3062 } 3063 3064 static int 3065 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set) 3066 { 3067 struct bttv_buffer *item; 3068 3069 memset(set,0,sizeof(*set)); 3070 3071 /* capture request ? */ 3072 if (!list_empty(&btv->capture)) { 3073 set->frame_irq = 1; 3074 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue); 3075 if (V4L2_FIELD_HAS_TOP(item->vb.field)) 3076 set->top = item; 3077 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field)) 3078 set->bottom = item; 3079 3080 /* capture request for other field ? */ 3081 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) && 3082 (item->vb.queue.next != &btv->capture)) { 3083 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue); 3084 /* Mike Isely <isely@pobox.com> - Only check 3085 * and set up the bottom field in the logic 3086 * below. Don't ever do the top field. This 3087 * of course means that if we set up the 3088 * bottom field in the above code that we'll 3089 * actually skip a field. But that's OK. 3090 * Having processed only a single buffer this 3091 * time, then the next time around the first 3092 * available buffer should be for a top field. 3093 * That will then cause us here to set up a 3094 * top then a bottom field in the normal way. 3095 * The alternative to this understanding is 3096 * that we set up the second available buffer 3097 * as a top field, but that's out of order 3098 * since this driver always processes the top 3099 * field first - the effect will be the two 3100 * buffers being returned in the wrong order, 3101 * with the second buffer also being delayed 3102 * by one field time (owing to the fifo nature 3103 * of videobuf). Worse still, we'll be stuck 3104 * doing fields out of order now every time 3105 * until something else causes a field to be 3106 * dropped. By effectively forcing a field to 3107 * drop this way then we always get back into 3108 * sync within a single frame time. (Out of 3109 * order fields can screw up deinterlacing 3110 * algorithms.) */ 3111 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) { 3112 if (NULL == set->bottom && 3113 V4L2_FIELD_BOTTOM == item->vb.field) { 3114 set->bottom = item; 3115 } 3116 if (NULL != set->top && NULL != set->bottom) 3117 set->top_irq = 2; 3118 } 3119 } 3120 } 3121 3122 dprintk("%d: next set: top=%p bottom=%p [irq=%d,%d]\n", 3123 btv->c.nr, set->top, set->bottom, 3124 set->frame_irq, set->top_irq); 3125 return 0; 3126 } 3127 3128 static void 3129 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup, 3130 struct bttv_buffer_set *curr, unsigned int state) 3131 { 3132 u64 ts = ktime_get_ns(); 3133 3134 if (wakeup->top == wakeup->bottom) { 3135 if (NULL != wakeup->top && curr->top != wakeup->top) { 3136 if (irq_debug > 1) 3137 pr_debug("%d: wakeup: both=%p\n", 3138 btv->c.nr, wakeup->top); 3139 wakeup->top->vb.ts = ts; 3140 wakeup->top->vb.field_count = btv->field_count; 3141 wakeup->top->vb.state = state; 3142 wake_up(&wakeup->top->vb.done); 3143 } 3144 } else { 3145 if (NULL != wakeup->top && curr->top != wakeup->top) { 3146 if (irq_debug > 1) 3147 pr_debug("%d: wakeup: top=%p\n", 3148 btv->c.nr, wakeup->top); 3149 wakeup->top->vb.ts = ts; 3150 wakeup->top->vb.field_count = btv->field_count; 3151 wakeup->top->vb.state = state; 3152 wake_up(&wakeup->top->vb.done); 3153 } 3154 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) { 3155 if (irq_debug > 1) 3156 pr_debug("%d: wakeup: bottom=%p\n", 3157 btv->c.nr, wakeup->bottom); 3158 wakeup->bottom->vb.ts = ts; 3159 wakeup->bottom->vb.field_count = btv->field_count; 3160 wakeup->bottom->vb.state = state; 3161 wake_up(&wakeup->bottom->vb.done); 3162 } 3163 } 3164 } 3165 3166 static void 3167 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup, 3168 unsigned int state) 3169 { 3170 if (NULL == wakeup) 3171 return; 3172 3173 wakeup->vb.ts = ktime_get_ns(); 3174 wakeup->vb.field_count = btv->field_count; 3175 wakeup->vb.state = state; 3176 wake_up(&wakeup->vb.done); 3177 } 3178 3179 static void bttv_irq_timeout(struct timer_list *t) 3180 { 3181 struct bttv *btv = from_timer(btv, t, timeout); 3182 struct bttv_buffer_set old,new; 3183 struct bttv_buffer *ovbi; 3184 struct bttv_buffer *item; 3185 unsigned long flags; 3186 3187 if (bttv_verbose) { 3188 pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ", 3189 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total, 3190 btread(BT848_RISC_COUNT)); 3191 bttv_print_irqbits(btread(BT848_INT_STAT),0); 3192 pr_cont("\n"); 3193 } 3194 3195 spin_lock_irqsave(&btv->s_lock,flags); 3196 3197 /* deactivate stuff */ 3198 memset(&new,0,sizeof(new)); 3199 old = btv->curr; 3200 ovbi = btv->cvbi; 3201 btv->curr = new; 3202 btv->cvbi = NULL; 3203 btv->loop_irq = 0; 3204 bttv_buffer_activate_video(btv, &new); 3205 bttv_buffer_activate_vbi(btv, NULL); 3206 bttv_set_dma(btv, 0); 3207 3208 /* wake up */ 3209 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR); 3210 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR); 3211 3212 /* cancel all outstanding capture / vbi requests */ 3213 while (!list_empty(&btv->capture)) { 3214 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue); 3215 list_del(&item->vb.queue); 3216 item->vb.state = VIDEOBUF_ERROR; 3217 wake_up(&item->vb.done); 3218 } 3219 while (!list_empty(&btv->vcapture)) { 3220 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue); 3221 list_del(&item->vb.queue); 3222 item->vb.state = VIDEOBUF_ERROR; 3223 wake_up(&item->vb.done); 3224 } 3225 3226 btv->errors++; 3227 spin_unlock_irqrestore(&btv->s_lock,flags); 3228 } 3229 3230 static void 3231 bttv_irq_wakeup_top(struct bttv *btv) 3232 { 3233 struct bttv_buffer *wakeup = btv->curr.top; 3234 3235 if (NULL == wakeup) 3236 return; 3237 3238 spin_lock(&btv->s_lock); 3239 btv->curr.top_irq = 0; 3240 btv->curr.top = NULL; 3241 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0); 3242 3243 wakeup->vb.ts = ktime_get_ns(); 3244 wakeup->vb.field_count = btv->field_count; 3245 wakeup->vb.state = VIDEOBUF_DONE; 3246 wake_up(&wakeup->vb.done); 3247 spin_unlock(&btv->s_lock); 3248 } 3249 3250 static inline int is_active(struct btcx_riscmem *risc, u32 rc) 3251 { 3252 if (rc < risc->dma) 3253 return 0; 3254 if (rc > risc->dma + risc->size) 3255 return 0; 3256 return 1; 3257 } 3258 3259 static void 3260 bttv_irq_switch_video(struct bttv *btv) 3261 { 3262 struct bttv_buffer_set new; 3263 struct bttv_buffer_set old; 3264 dma_addr_t rc; 3265 3266 spin_lock(&btv->s_lock); 3267 3268 /* new buffer set */ 3269 bttv_irq_next_video(btv, &new); 3270 rc = btread(BT848_RISC_COUNT); 3271 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) || 3272 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) { 3273 btv->framedrop++; 3274 if (debug_latency) 3275 bttv_irq_debug_low_latency(btv, rc); 3276 spin_unlock(&btv->s_lock); 3277 return; 3278 } 3279 3280 /* switch over */ 3281 old = btv->curr; 3282 btv->curr = new; 3283 btv->loop_irq &= ~1; 3284 bttv_buffer_activate_video(btv, &new); 3285 bttv_set_dma(btv, 0); 3286 3287 /* switch input */ 3288 if (UNSET != btv->new_input) { 3289 video_mux(btv,btv->new_input); 3290 btv->new_input = UNSET; 3291 } 3292 3293 /* wake up finished buffers */ 3294 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE); 3295 spin_unlock(&btv->s_lock); 3296 } 3297 3298 static void 3299 bttv_irq_switch_vbi(struct bttv *btv) 3300 { 3301 struct bttv_buffer *new = NULL; 3302 struct bttv_buffer *old; 3303 u32 rc; 3304 3305 spin_lock(&btv->s_lock); 3306 3307 if (!list_empty(&btv->vcapture)) 3308 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue); 3309 old = btv->cvbi; 3310 3311 rc = btread(BT848_RISC_COUNT); 3312 if (NULL != old && (is_active(&old->top, rc) || 3313 is_active(&old->bottom, rc))) { 3314 btv->framedrop++; 3315 if (debug_latency) 3316 bttv_irq_debug_low_latency(btv, rc); 3317 spin_unlock(&btv->s_lock); 3318 return; 3319 } 3320 3321 /* switch */ 3322 btv->cvbi = new; 3323 btv->loop_irq &= ~4; 3324 bttv_buffer_activate_vbi(btv, new); 3325 bttv_set_dma(btv, 0); 3326 3327 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE); 3328 spin_unlock(&btv->s_lock); 3329 } 3330 3331 static irqreturn_t bttv_irq(int irq, void *dev_id) 3332 { 3333 u32 stat,astat; 3334 u32 dstat; 3335 int count; 3336 struct bttv *btv; 3337 int handled = 0; 3338 3339 btv=(struct bttv *)dev_id; 3340 3341 count=0; 3342 while (1) { 3343 /* get/clear interrupt status bits */ 3344 stat=btread(BT848_INT_STAT); 3345 astat=stat&btread(BT848_INT_MASK); 3346 if (!astat) 3347 break; 3348 handled = 1; 3349 btwrite(stat,BT848_INT_STAT); 3350 3351 /* get device status bits */ 3352 dstat=btread(BT848_DSTATUS); 3353 3354 if (irq_debug) { 3355 pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ", 3356 btv->c.nr, count, btv->field_count, 3357 stat>>28, btread(BT848_RISC_COUNT)); 3358 bttv_print_irqbits(stat,astat); 3359 if (stat & BT848_INT_HLOCK) 3360 pr_cont(" HLOC => %s", 3361 dstat & BT848_DSTATUS_HLOC 3362 ? "yes" : "no"); 3363 if (stat & BT848_INT_VPRES) 3364 pr_cont(" PRES => %s", 3365 dstat & BT848_DSTATUS_PRES 3366 ? "yes" : "no"); 3367 if (stat & BT848_INT_FMTCHG) 3368 pr_cont(" NUML => %s", 3369 dstat & BT848_DSTATUS_NUML 3370 ? "625" : "525"); 3371 pr_cont("\n"); 3372 } 3373 3374 if (astat&BT848_INT_VSYNC) 3375 btv->field_count++; 3376 3377 if ((astat & BT848_INT_GPINT) && btv->remote) { 3378 bttv_input_irq(btv); 3379 } 3380 3381 if (astat & BT848_INT_I2CDONE) { 3382 btv->i2c_done = stat; 3383 wake_up(&btv->i2c_queue); 3384 } 3385 3386 if ((astat & BT848_INT_RISCI) && (stat & (4<<28))) 3387 bttv_irq_switch_vbi(btv); 3388 3389 if ((astat & BT848_INT_RISCI) && (stat & (2<<28))) 3390 bttv_irq_wakeup_top(btv); 3391 3392 if ((astat & BT848_INT_RISCI) && (stat & (1<<28))) 3393 bttv_irq_switch_video(btv); 3394 3395 if ((astat & BT848_INT_HLOCK) && btv->opt_automute) 3396 /* trigger automute */ 3397 audio_mux_gpio(btv, btv->audio_input, btv->mute); 3398 3399 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) { 3400 pr_info("%d: %s%s @ %08x,", 3401 btv->c.nr, 3402 (astat & BT848_INT_SCERR) ? "SCERR" : "", 3403 (astat & BT848_INT_OCERR) ? "OCERR" : "", 3404 btread(BT848_RISC_COUNT)); 3405 bttv_print_irqbits(stat,astat); 3406 pr_cont("\n"); 3407 if (bttv_debug) 3408 bttv_print_riscaddr(btv); 3409 } 3410 if (fdsr && astat & BT848_INT_FDSR) { 3411 pr_info("%d: FDSR @ %08x\n", 3412 btv->c.nr, btread(BT848_RISC_COUNT)); 3413 if (bttv_debug) 3414 bttv_print_riscaddr(btv); 3415 } 3416 3417 count++; 3418 if (count > 4) { 3419 3420 if (count > 8 || !(astat & BT848_INT_GPINT)) { 3421 btwrite(0, BT848_INT_MASK); 3422 3423 pr_err("%d: IRQ lockup, cleared int mask [", 3424 btv->c.nr); 3425 } else { 3426 pr_err("%d: IRQ lockup, clearing GPINT from int mask [", 3427 btv->c.nr); 3428 3429 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT), 3430 BT848_INT_MASK); 3431 } 3432 3433 bttv_print_irqbits(stat,astat); 3434 3435 pr_cont("]\n"); 3436 } 3437 } 3438 btv->irq_total++; 3439 if (handled) 3440 btv->irq_me++; 3441 return IRQ_RETVAL(handled); 3442 } 3443 3444 3445 /* ----------------------------------------------------------------------- */ 3446 /* initialization */ 3447 3448 static void vdev_init(struct bttv *btv, 3449 struct video_device *vfd, 3450 const struct video_device *template, 3451 const char *type_name) 3452 { 3453 *vfd = *template; 3454 vfd->v4l2_dev = &btv->c.v4l2_dev; 3455 vfd->release = video_device_release_empty; 3456 video_set_drvdata(vfd, btv); 3457 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)", 3458 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "", 3459 type_name, bttv_tvcards[btv->c.type].name); 3460 if (btv->tuner_type == TUNER_ABSENT) { 3461 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY); 3462 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY); 3463 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER); 3464 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER); 3465 } 3466 } 3467 3468 static void bttv_unregister_video(struct bttv *btv) 3469 { 3470 video_unregister_device(&btv->video_dev); 3471 video_unregister_device(&btv->vbi_dev); 3472 video_unregister_device(&btv->radio_dev); 3473 } 3474 3475 /* register video4linux devices */ 3476 static int bttv_register_video(struct bttv *btv) 3477 { 3478 /* video */ 3479 vdev_init(btv, &btv->video_dev, &bttv_video_template, "video"); 3480 btv->video_dev.device_caps = V4L2_CAP_VIDEO_CAPTURE | 3481 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 3482 if (btv->tuner_type != TUNER_ABSENT) 3483 btv->video_dev.device_caps |= V4L2_CAP_TUNER; 3484 3485 if (video_register_device(&btv->video_dev, VFL_TYPE_VIDEO, 3486 video_nr[btv->c.nr]) < 0) 3487 goto err; 3488 pr_info("%d: registered device %s\n", 3489 btv->c.nr, video_device_node_name(&btv->video_dev)); 3490 if (device_create_file(&btv->video_dev.dev, 3491 &dev_attr_card)<0) { 3492 pr_err("%d: device_create_file 'card' failed\n", btv->c.nr); 3493 goto err; 3494 } 3495 3496 /* vbi */ 3497 vdev_init(btv, &btv->vbi_dev, &bttv_video_template, "vbi"); 3498 btv->vbi_dev.device_caps = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE | 3499 V4L2_CAP_STREAMING; 3500 if (btv->tuner_type != TUNER_ABSENT) 3501 btv->vbi_dev.device_caps |= V4L2_CAP_TUNER; 3502 3503 if (video_register_device(&btv->vbi_dev, VFL_TYPE_VBI, 3504 vbi_nr[btv->c.nr]) < 0) 3505 goto err; 3506 pr_info("%d: registered device %s\n", 3507 btv->c.nr, video_device_node_name(&btv->vbi_dev)); 3508 3509 if (!btv->has_radio) 3510 return 0; 3511 /* radio */ 3512 vdev_init(btv, &btv->radio_dev, &radio_template, "radio"); 3513 btv->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER; 3514 if (btv->has_saa6588) 3515 btv->radio_dev.device_caps |= V4L2_CAP_READWRITE | 3516 V4L2_CAP_RDS_CAPTURE; 3517 if (btv->has_tea575x) 3518 btv->radio_dev.device_caps |= V4L2_CAP_HW_FREQ_SEEK; 3519 btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler; 3520 if (video_register_device(&btv->radio_dev, VFL_TYPE_RADIO, 3521 radio_nr[btv->c.nr]) < 0) 3522 goto err; 3523 pr_info("%d: registered device %s\n", 3524 btv->c.nr, video_device_node_name(&btv->radio_dev)); 3525 3526 /* all done */ 3527 return 0; 3528 3529 err: 3530 bttv_unregister_video(btv); 3531 return -1; 3532 } 3533 3534 3535 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */ 3536 /* response on cards with no firmware is not enabled by OF */ 3537 static void pci_set_command(struct pci_dev *dev) 3538 { 3539 #if defined(__powerpc__) 3540 unsigned int cmd; 3541 3542 pci_read_config_dword(dev, PCI_COMMAND, &cmd); 3543 cmd = (cmd | PCI_COMMAND_MEMORY ); 3544 pci_write_config_dword(dev, PCI_COMMAND, cmd); 3545 #endif 3546 } 3547 3548 static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id) 3549 { 3550 struct v4l2_frequency init_freq = { 3551 .tuner = 0, 3552 .type = V4L2_TUNER_ANALOG_TV, 3553 .frequency = 980, 3554 }; 3555 int result; 3556 unsigned char lat; 3557 struct bttv *btv; 3558 struct v4l2_ctrl_handler *hdl; 3559 3560 if (bttv_num == BTTV_MAX) 3561 return -ENOMEM; 3562 pr_info("Bt8xx card found (%d)\n", bttv_num); 3563 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL); 3564 if (btv == NULL) { 3565 pr_err("out of memory\n"); 3566 return -ENOMEM; 3567 } 3568 btv->c.nr = bttv_num; 3569 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name), 3570 "bttv%d", btv->c.nr); 3571 3572 /* initialize structs / fill in defaults */ 3573 mutex_init(&btv->lock); 3574 spin_lock_init(&btv->s_lock); 3575 spin_lock_init(&btv->gpio_lock); 3576 init_waitqueue_head(&btv->i2c_queue); 3577 INIT_LIST_HEAD(&btv->c.subs); 3578 INIT_LIST_HEAD(&btv->capture); 3579 INIT_LIST_HEAD(&btv->vcapture); 3580 3581 timer_setup(&btv->timeout, bttv_irq_timeout, 0); 3582 3583 btv->i2c_rc = -1; 3584 btv->tuner_type = UNSET; 3585 btv->new_input = UNSET; 3586 btv->has_radio=radio[btv->c.nr]; 3587 3588 /* pci stuff (init, get irq/mmio, ... */ 3589 btv->c.pci = dev; 3590 btv->id = dev->device; 3591 if (pci_enable_device(dev)) { 3592 pr_warn("%d: Can't enable device\n", btv->c.nr); 3593 result = -EIO; 3594 goto free_mem; 3595 } 3596 if (dma_set_mask(&dev->dev, DMA_BIT_MASK(32))) { 3597 pr_warn("%d: No suitable DMA available\n", btv->c.nr); 3598 result = -EIO; 3599 goto free_mem; 3600 } 3601 if (!request_mem_region(pci_resource_start(dev,0), 3602 pci_resource_len(dev,0), 3603 btv->c.v4l2_dev.name)) { 3604 pr_warn("%d: can't request iomem (0x%llx)\n", 3605 btv->c.nr, 3606 (unsigned long long)pci_resource_start(dev, 0)); 3607 result = -EBUSY; 3608 goto free_mem; 3609 } 3610 pci_set_master(dev); 3611 pci_set_command(dev); 3612 3613 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev); 3614 if (result < 0) { 3615 pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr); 3616 goto fail0; 3617 } 3618 hdl = &btv->ctrl_handler; 3619 v4l2_ctrl_handler_init(hdl, 20); 3620 btv->c.v4l2_dev.ctrl_handler = hdl; 3621 v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6); 3622 3623 btv->revision = dev->revision; 3624 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); 3625 pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n", 3626 bttv_num, btv->id, btv->revision, pci_name(dev), 3627 btv->c.pci->irq, lat, 3628 (unsigned long long)pci_resource_start(dev, 0)); 3629 schedule(); 3630 3631 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000); 3632 if (NULL == btv->bt848_mmio) { 3633 pr_err("%d: ioremap() failed\n", btv->c.nr); 3634 result = -EIO; 3635 goto fail1; 3636 } 3637 3638 /* identify card */ 3639 bttv_idcard(btv); 3640 3641 /* disable irqs, register irq handler */ 3642 btwrite(0, BT848_INT_MASK); 3643 result = request_irq(btv->c.pci->irq, bttv_irq, 3644 IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv); 3645 if (result < 0) { 3646 pr_err("%d: can't get IRQ %d\n", 3647 bttv_num, btv->c.pci->irq); 3648 goto fail1; 3649 } 3650 3651 if (0 != bttv_handle_chipset(btv)) { 3652 result = -EIO; 3653 goto fail2; 3654 } 3655 3656 /* init options from insmod args */ 3657 btv->opt_combfilter = combfilter; 3658 bttv_ctrl_combfilter.def = combfilter; 3659 bttv_ctrl_lumafilter.def = lumafilter; 3660 btv->opt_automute = automute; 3661 bttv_ctrl_automute.def = automute; 3662 bttv_ctrl_agc_crush.def = agc_crush; 3663 btv->opt_vcr_hack = vcr_hack; 3664 bttv_ctrl_vcr_hack.def = vcr_hack; 3665 bttv_ctrl_whitecrush_upper.def = whitecrush_upper; 3666 bttv_ctrl_whitecrush_lower.def = whitecrush_lower; 3667 btv->opt_uv_ratio = uv_ratio; 3668 bttv_ctrl_uv_ratio.def = uv_ratio; 3669 bttv_ctrl_full_luma.def = full_luma_range; 3670 bttv_ctrl_coring.def = coring; 3671 3672 /* fill struct bttv with some useful defaults */ 3673 btv->init.btv = btv; 3674 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24); 3675 btv->init.width = 320; 3676 btv->init.height = 240; 3677 btv->input = 0; 3678 3679 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3680 V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768); 3681 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3682 V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00); 3683 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3684 V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768); 3685 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3686 V4L2_CID_COLOR_KILLER, 0, 1, 1, 0); 3687 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3688 V4L2_CID_HUE, 0, 0xff00, 0x100, 32768); 3689 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3690 V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc); 3691 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3692 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 3693 if (btv->volume_gpio) 3694 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3695 V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00); 3696 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL); 3697 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL); 3698 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL); 3699 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL); 3700 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL); 3701 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL); 3702 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL); 3703 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL); 3704 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL); 3705 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL); 3706 3707 /* initialize hardware */ 3708 if (bttv_gpio) 3709 bttv_gpio_tracking(btv,"pre-init"); 3710 3711 bttv_risc_init_main(btv); 3712 init_bt848(btv); 3713 3714 /* gpio */ 3715 btwrite(0x00, BT848_GPIO_REG_INP); 3716 btwrite(0x00, BT848_GPIO_OUT_EN); 3717 if (bttv_verbose) 3718 bttv_gpio_tracking(btv,"init"); 3719 3720 /* needs to be done before i2c is registered */ 3721 bttv_init_card1(btv); 3722 3723 /* register i2c + gpio */ 3724 init_bttv_i2c(btv); 3725 3726 /* some card-specific stuff (needs working i2c) */ 3727 bttv_init_card2(btv); 3728 bttv_init_tuner(btv); 3729 if (btv->tuner_type != TUNER_ABSENT) { 3730 bttv_set_frequency(btv, &init_freq); 3731 btv->radio_freq = 90500 * 16; /* 90.5Mhz default */ 3732 } 3733 btv->std = V4L2_STD_PAL; 3734 init_irqreg(btv); 3735 if (!bttv_tvcards[btv->c.type].no_video) 3736 v4l2_ctrl_handler_setup(hdl); 3737 if (hdl->error) { 3738 result = hdl->error; 3739 goto fail2; 3740 } 3741 /* mute device */ 3742 audio_mute(btv, 1); 3743 3744 /* register video4linux + input */ 3745 if (!bttv_tvcards[btv->c.type].no_video) { 3746 v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl, 3747 v4l2_ctrl_radio_filter, false); 3748 if (btv->radio_ctrl_handler.error) { 3749 result = btv->radio_ctrl_handler.error; 3750 goto fail2; 3751 } 3752 set_input(btv, 0, btv->tvnorm); 3753 bttv_crop_reset(&btv->crop[0], btv->tvnorm); 3754 btv->crop[1] = btv->crop[0]; /* current = default */ 3755 disclaim_vbi_lines(btv); 3756 disclaim_video_lines(btv); 3757 bttv_register_video(btv); 3758 } 3759 3760 /* add subdevices and autoload dvb-bt8xx if needed */ 3761 if (bttv_tvcards[btv->c.type].has_dvb) { 3762 bttv_sub_add_device(&btv->c, "dvb"); 3763 request_modules(btv); 3764 } 3765 3766 if (!disable_ir) { 3767 init_bttv_i2c_ir(btv); 3768 bttv_input_init(btv); 3769 } 3770 3771 /* everything is fine */ 3772 bttv_num++; 3773 return 0; 3774 3775 fail2: 3776 free_irq(btv->c.pci->irq,btv); 3777 3778 fail1: 3779 v4l2_ctrl_handler_free(&btv->ctrl_handler); 3780 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler); 3781 v4l2_device_unregister(&btv->c.v4l2_dev); 3782 3783 fail0: 3784 if (btv->bt848_mmio) 3785 iounmap(btv->bt848_mmio); 3786 release_mem_region(pci_resource_start(btv->c.pci,0), 3787 pci_resource_len(btv->c.pci,0)); 3788 pci_disable_device(btv->c.pci); 3789 3790 free_mem: 3791 bttvs[btv->c.nr] = NULL; 3792 kfree(btv); 3793 return result; 3794 } 3795 3796 static void bttv_remove(struct pci_dev *pci_dev) 3797 { 3798 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev); 3799 struct bttv *btv = to_bttv(v4l2_dev); 3800 3801 if (bttv_verbose) 3802 pr_info("%d: unloading\n", btv->c.nr); 3803 3804 if (bttv_tvcards[btv->c.type].has_dvb) 3805 flush_request_modules(btv); 3806 3807 /* shutdown everything (DMA+IRQs) */ 3808 btand(~15, BT848_GPIO_DMA_CTL); 3809 btwrite(0, BT848_INT_MASK); 3810 btwrite(~0x0, BT848_INT_STAT); 3811 btwrite(0x0, BT848_GPIO_OUT_EN); 3812 if (bttv_gpio) 3813 bttv_gpio_tracking(btv,"cleanup"); 3814 3815 /* tell gpio modules we are leaving ... */ 3816 btv->shutdown=1; 3817 bttv_input_fini(btv); 3818 bttv_sub_del_devices(&btv->c); 3819 3820 /* unregister i2c_bus + input */ 3821 fini_bttv_i2c(btv); 3822 3823 /* unregister video4linux */ 3824 bttv_unregister_video(btv); 3825 3826 /* free allocated memory */ 3827 v4l2_ctrl_handler_free(&btv->ctrl_handler); 3828 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler); 3829 btcx_riscmem_free(btv->c.pci,&btv->main); 3830 3831 /* free resources */ 3832 free_irq(btv->c.pci->irq,btv); 3833 iounmap(btv->bt848_mmio); 3834 release_mem_region(pci_resource_start(btv->c.pci,0), 3835 pci_resource_len(btv->c.pci,0)); 3836 pci_disable_device(btv->c.pci); 3837 3838 v4l2_device_unregister(&btv->c.v4l2_dev); 3839 bttvs[btv->c.nr] = NULL; 3840 kfree(btv); 3841 3842 return; 3843 } 3844 3845 static int __maybe_unused bttv_suspend(struct device *dev) 3846 { 3847 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev); 3848 struct bttv *btv = to_bttv(v4l2_dev); 3849 struct bttv_buffer_set idle; 3850 unsigned long flags; 3851 3852 dprintk("%d: suspend\n", btv->c.nr); 3853 3854 /* stop dma + irqs */ 3855 spin_lock_irqsave(&btv->s_lock,flags); 3856 memset(&idle, 0, sizeof(idle)); 3857 btv->state.video = btv->curr; 3858 btv->state.vbi = btv->cvbi; 3859 btv->state.loop_irq = btv->loop_irq; 3860 btv->curr = idle; 3861 btv->loop_irq = 0; 3862 bttv_buffer_activate_video(btv, &idle); 3863 bttv_buffer_activate_vbi(btv, NULL); 3864 bttv_set_dma(btv, 0); 3865 btwrite(0, BT848_INT_MASK); 3866 spin_unlock_irqrestore(&btv->s_lock,flags); 3867 3868 /* save bt878 state */ 3869 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN); 3870 btv->state.gpio_data = gpio_read(); 3871 3872 btv->state.disabled = 1; 3873 return 0; 3874 } 3875 3876 static int __maybe_unused bttv_resume(struct device *dev) 3877 { 3878 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev); 3879 struct bttv *btv = to_bttv(v4l2_dev); 3880 unsigned long flags; 3881 3882 dprintk("%d: resume\n", btv->c.nr); 3883 3884 btv->state.disabled = 0; 3885 3886 /* restore bt878 state */ 3887 bttv_reinit_bt848(btv); 3888 gpio_inout(0xffffff, btv->state.gpio_enable); 3889 gpio_write(btv->state.gpio_data); 3890 3891 /* restart dma */ 3892 spin_lock_irqsave(&btv->s_lock,flags); 3893 btv->curr = btv->state.video; 3894 btv->cvbi = btv->state.vbi; 3895 btv->loop_irq = btv->state.loop_irq; 3896 bttv_buffer_activate_video(btv, &btv->curr); 3897 bttv_buffer_activate_vbi(btv, btv->cvbi); 3898 bttv_set_dma(btv, 0); 3899 spin_unlock_irqrestore(&btv->s_lock,flags); 3900 return 0; 3901 } 3902 3903 static const struct pci_device_id bttv_pci_tbl[] = { 3904 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0}, 3905 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0}, 3906 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0}, 3907 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0}, 3908 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0}, 3909 {0,} 3910 }; 3911 3912 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl); 3913 3914 static SIMPLE_DEV_PM_OPS(bttv_pm_ops, 3915 bttv_suspend, 3916 bttv_resume); 3917 3918 static struct pci_driver bttv_pci_driver = { 3919 .name = "bttv", 3920 .id_table = bttv_pci_tbl, 3921 .probe = bttv_probe, 3922 .remove = bttv_remove, 3923 .driver.pm = &bttv_pm_ops, 3924 }; 3925 3926 static int __init bttv_init_module(void) 3927 { 3928 int ret; 3929 3930 bttv_num = 0; 3931 3932 pr_info("driver version %s loaded\n", BTTV_VERSION); 3933 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME) 3934 gbuffers = 2; 3935 if (gbufsize > BTTV_MAX_FBUF) 3936 gbufsize = BTTV_MAX_FBUF; 3937 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK; 3938 if (bttv_verbose) 3939 pr_info("using %d buffers with %dk (%d pages) each for capture\n", 3940 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT); 3941 3942 bttv_check_chipset(); 3943 3944 ret = bus_register(&bttv_sub_bus_type); 3945 if (ret < 0) { 3946 pr_warn("bus_register error: %d\n", ret); 3947 return ret; 3948 } 3949 ret = pci_register_driver(&bttv_pci_driver); 3950 if (ret < 0) 3951 bus_unregister(&bttv_sub_bus_type); 3952 3953 return ret; 3954 } 3955 3956 static void __exit bttv_cleanup_module(void) 3957 { 3958 pci_unregister_driver(&bttv_pci_driver); 3959 bus_unregister(&bttv_sub_bus_type); 3960 } 3961 3962 module_init(bttv_init_module); 3963 module_exit(bttv_cleanup_module); 3964