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 int check_alloc_btres_lock(struct bttv *btv, int bit) 645 { 646 int xbits; /* mutual exclusive resources */ 647 648 xbits = bit; 649 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM)) 650 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM; 651 652 /* is it free? */ 653 if (btv->resources & xbits) { 654 /* no, someone else uses it */ 655 goto fail; 656 } 657 658 if ((bit & VIDEO_RESOURCES) 659 && 0 == (btv->resources & VIDEO_RESOURCES)) { 660 /* Do crop - use current, don't - use default parameters. */ 661 __s32 top = btv->crop[!!btv->do_crop].rect.top; 662 663 if (btv->vbi_end > top) 664 goto fail; 665 666 /* We cannot capture the same line as video and VBI data. 667 Claim scan lines crop[].rect.top to bottom. */ 668 btv->crop_start = top; 669 } else if (bit & VBI_RESOURCES) { 670 __s32 end = btv->vbi_fmt.end; 671 672 if (end > btv->crop_start) 673 goto fail; 674 675 /* Claim scan lines above btv->vbi_fmt.end. */ 676 btv->vbi_end = end; 677 } 678 679 /* it's free, grab it */ 680 btv->resources |= bit; 681 return 1; 682 683 fail: 684 return 0; 685 } 686 687 static 688 int check_btres(struct bttv *btv, int bit) 689 { 690 return (btv->resources & bit); 691 } 692 693 static 694 int locked_btres(struct bttv *btv, int bit) 695 { 696 return (btv->resources & bit); 697 } 698 699 /* Call with btv->lock down. */ 700 static void 701 disclaim_vbi_lines(struct bttv *btv) 702 { 703 btv->vbi_end = 0; 704 } 705 706 /* Call with btv->lock down. */ 707 static void 708 disclaim_video_lines(struct bttv *btv) 709 { 710 const struct bttv_tvnorm *tvnorm; 711 u8 crop; 712 713 tvnorm = &bttv_tvnorms[btv->tvnorm]; 714 btv->crop_start = tvnorm->cropcap.bounds.top 715 + tvnorm->cropcap.bounds.height; 716 717 /* VBI capturing ends at VDELAY, start of video capturing, no 718 matter how many lines the VBI RISC program expects. When video 719 capturing is off, it shall no longer "preempt" VBI capturing, 720 so we set VDELAY to maximum. */ 721 crop = btread(BT848_E_CROP) | 0xc0; 722 btwrite(crop, BT848_E_CROP); 723 btwrite(0xfe, BT848_E_VDELAY_LO); 724 btwrite(crop, BT848_O_CROP); 725 btwrite(0xfe, BT848_O_VDELAY_LO); 726 } 727 728 void free_btres_lock(struct bttv *btv, int bits) 729 { 730 if ((btv->resources & bits) != bits) { 731 /* trying to free resources not allocated by us ... */ 732 pr_err("BUG! (btres)\n"); 733 } 734 btv->resources &= ~bits; 735 736 bits = btv->resources; 737 738 if (0 == (bits & VIDEO_RESOURCES)) 739 disclaim_video_lines(btv); 740 741 if (0 == (bits & VBI_RESOURCES)) 742 disclaim_vbi_lines(btv); 743 } 744 745 /* ----------------------------------------------------------------------- */ 746 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */ 747 748 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C 749 PLL_X = Reference pre-divider (0=1, 1=2) 750 PLL_C = Post divider (0=6, 1=4) 751 PLL_I = Integer input 752 PLL_F = Fractional input 753 754 F_input = 28.636363 MHz: 755 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0 756 */ 757 758 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout) 759 { 760 unsigned char fl, fh, fi; 761 762 /* prevent overflows */ 763 fin/=4; 764 fout/=4; 765 766 fout*=12; 767 fi=fout/fin; 768 769 fout=(fout%fin)*256; 770 fh=fout/fin; 771 772 fout=(fout%fin)*256; 773 fl=fout/fin; 774 775 btwrite(fl, BT848_PLL_F_LO); 776 btwrite(fh, BT848_PLL_F_HI); 777 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI); 778 } 779 780 static void set_pll(struct bttv *btv) 781 { 782 int i; 783 784 if (!btv->pll.pll_crystal) 785 return; 786 787 if (btv->pll.pll_ofreq == btv->pll.pll_current) { 788 dprintk("%d: PLL: no change required\n", btv->c.nr); 789 return; 790 } 791 792 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) { 793 /* no PLL needed */ 794 if (btv->pll.pll_current == 0) 795 return; 796 if (bttv_verbose) 797 pr_info("%d: PLL can sleep, using XTAL (%d)\n", 798 btv->c.nr, btv->pll.pll_ifreq); 799 btwrite(0x00,BT848_TGCTRL); 800 btwrite(0x00,BT848_PLL_XCI); 801 btv->pll.pll_current = 0; 802 return; 803 } 804 805 if (bttv_verbose) 806 pr_info("%d: Setting PLL: %d => %d (needs up to 100ms)\n", 807 btv->c.nr, 808 btv->pll.pll_ifreq, btv->pll.pll_ofreq); 809 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq); 810 811 for (i=0; i<10; i++) { 812 /* Let other people run while the PLL stabilizes */ 813 msleep(10); 814 815 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) { 816 btwrite(0,BT848_DSTATUS); 817 } else { 818 btwrite(0x08,BT848_TGCTRL); 819 btv->pll.pll_current = btv->pll.pll_ofreq; 820 if (bttv_verbose) 821 pr_info("PLL set ok\n"); 822 return; 823 } 824 } 825 btv->pll.pll_current = -1; 826 if (bttv_verbose) 827 pr_info("Setting PLL failed\n"); 828 return; 829 } 830 831 /* used to switch between the bt848's analog/digital video capture modes */ 832 static void bt848A_set_timing(struct bttv *btv) 833 { 834 int i, len; 835 int table_idx = bttv_tvnorms[btv->tvnorm].sram; 836 int fsc = bttv_tvnorms[btv->tvnorm].Fsc; 837 838 if (btv->input == btv->dig) { 839 dprintk("%d: load digital timing table (table_idx=%d)\n", 840 btv->c.nr,table_idx); 841 842 /* timing change...reset timing generator address */ 843 btwrite(0x00, BT848_TGCTRL); 844 btwrite(0x02, BT848_TGCTRL); 845 btwrite(0x00, BT848_TGCTRL); 846 847 len=SRAM_Table[table_idx][0]; 848 for(i = 1; i <= len; i++) 849 btwrite(SRAM_Table[table_idx][i],BT848_TGLB); 850 btv->pll.pll_ofreq = 27000000; 851 852 set_pll(btv); 853 btwrite(0x11, BT848_TGCTRL); 854 btwrite(0x41, BT848_DVSIF); 855 } else { 856 btv->pll.pll_ofreq = fsc; 857 set_pll(btv); 858 btwrite(0x0, BT848_DVSIF); 859 } 860 } 861 862 /* ----------------------------------------------------------------------- */ 863 864 static void bt848_bright(struct bttv *btv, int bright) 865 { 866 int value; 867 868 // printk("set bright: %d\n", bright); // DEBUG 869 btv->bright = bright; 870 871 /* We want -128 to 127 we get 0-65535 */ 872 value = (bright >> 8) - 128; 873 btwrite(value & 0xff, BT848_BRIGHT); 874 } 875 876 static void bt848_hue(struct bttv *btv, int hue) 877 { 878 int value; 879 880 btv->hue = hue; 881 882 /* -128 to 127 */ 883 value = (hue >> 8) - 128; 884 btwrite(value & 0xff, BT848_HUE); 885 } 886 887 static void bt848_contrast(struct bttv *btv, int cont) 888 { 889 int value,hibit; 890 891 btv->contrast = cont; 892 893 /* 0-511 */ 894 value = (cont >> 7); 895 hibit = (value >> 6) & 4; 896 btwrite(value & 0xff, BT848_CONTRAST_LO); 897 btaor(hibit, ~4, BT848_E_CONTROL); 898 btaor(hibit, ~4, BT848_O_CONTROL); 899 } 900 901 static void bt848_sat(struct bttv *btv, int color) 902 { 903 int val_u,val_v,hibits; 904 905 btv->saturation = color; 906 907 /* 0-511 for the color */ 908 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7; 909 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254; 910 hibits = (val_u >> 7) & 2; 911 hibits |= (val_v >> 8) & 1; 912 btwrite(val_u & 0xff, BT848_SAT_U_LO); 913 btwrite(val_v & 0xff, BT848_SAT_V_LO); 914 btaor(hibits, ~3, BT848_E_CONTROL); 915 btaor(hibits, ~3, BT848_O_CONTROL); 916 } 917 918 /* ----------------------------------------------------------------------- */ 919 920 static int 921 video_mux(struct bttv *btv, unsigned int input) 922 { 923 int mux,mask2; 924 925 if (input >= bttv_tvcards[btv->c.type].video_inputs) 926 return -EINVAL; 927 928 /* needed by RemoteVideo MX */ 929 mask2 = bttv_tvcards[btv->c.type].gpiomask2; 930 if (mask2) 931 gpio_inout(mask2,mask2); 932 933 if (input == btv->svhs) { 934 btor(BT848_CONTROL_COMP, BT848_E_CONTROL); 935 btor(BT848_CONTROL_COMP, BT848_O_CONTROL); 936 } else { 937 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL); 938 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL); 939 } 940 mux = bttv_muxsel(btv, input); 941 btaor(mux<<5, ~(3<<5), BT848_IFORM); 942 dprintk("%d: video mux: input=%d mux=%d\n", btv->c.nr, input, mux); 943 944 /* card specific hook */ 945 if(bttv_tvcards[btv->c.type].muxsel_hook) 946 bttv_tvcards[btv->c.type].muxsel_hook (btv, input); 947 return 0; 948 } 949 950 static char *audio_modes[] = { 951 "audio: tuner", "audio: radio", "audio: extern", 952 "audio: intern", "audio: mute" 953 }; 954 955 static void 956 audio_mux_gpio(struct bttv *btv, int input, int mute) 957 { 958 int gpio_val, signal, mute_gpio; 959 960 gpio_inout(bttv_tvcards[btv->c.type].gpiomask, 961 bttv_tvcards[btv->c.type].gpiomask); 962 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC; 963 964 /* automute */ 965 mute_gpio = mute || (btv->opt_automute && (!signal || !btv->users) 966 && !btv->has_radio_tuner); 967 968 if (mute_gpio) 969 gpio_val = bttv_tvcards[btv->c.type].gpiomute; 970 else 971 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input]; 972 973 switch (btv->c.type) { 974 case BTTV_BOARD_VOODOOTV_FM: 975 case BTTV_BOARD_VOODOOTV_200: 976 gpio_val = bttv_tda9880_setnorm(btv, gpio_val); 977 break; 978 979 default: 980 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val); 981 } 982 983 if (bttv_gpio) 984 bttv_gpio_tracking(btv, audio_modes[mute_gpio ? 4 : input]); 985 } 986 987 static int 988 audio_mute(struct bttv *btv, int mute) 989 { 990 struct v4l2_ctrl *ctrl; 991 992 audio_mux_gpio(btv, btv->audio_input, mute); 993 994 if (btv->sd_msp34xx) { 995 ctrl = v4l2_ctrl_find(btv->sd_msp34xx->ctrl_handler, V4L2_CID_AUDIO_MUTE); 996 if (ctrl) 997 v4l2_ctrl_s_ctrl(ctrl, mute); 998 } 999 if (btv->sd_tvaudio) { 1000 ctrl = v4l2_ctrl_find(btv->sd_tvaudio->ctrl_handler, V4L2_CID_AUDIO_MUTE); 1001 if (ctrl) 1002 v4l2_ctrl_s_ctrl(ctrl, mute); 1003 } 1004 if (btv->sd_tda7432) { 1005 ctrl = v4l2_ctrl_find(btv->sd_tda7432->ctrl_handler, V4L2_CID_AUDIO_MUTE); 1006 if (ctrl) 1007 v4l2_ctrl_s_ctrl(ctrl, mute); 1008 } 1009 return 0; 1010 } 1011 1012 static int 1013 audio_input(struct bttv *btv, int input) 1014 { 1015 audio_mux_gpio(btv, input, btv->mute); 1016 1017 if (btv->sd_msp34xx) { 1018 u32 in; 1019 1020 /* Note: the inputs tuner/radio/extern/intern are translated 1021 to msp routings. This assumes common behavior for all msp3400 1022 based TV cards. When this assumption fails, then the 1023 specific MSP routing must be added to the card table. 1024 For now this is sufficient. */ 1025 switch (input) { 1026 case TVAUDIO_INPUT_RADIO: 1027 /* Some boards need the msp do to the radio demod */ 1028 if (btv->radio_uses_msp_demodulator) { 1029 in = MSP_INPUT_DEFAULT; 1030 break; 1031 } 1032 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1, 1033 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART); 1034 break; 1035 case TVAUDIO_INPUT_EXTERN: 1036 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1, 1037 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART); 1038 break; 1039 case TVAUDIO_INPUT_INTERN: 1040 /* Yes, this is the same input as for RADIO. I doubt 1041 if this is ever used. The only board with an INTERN 1042 input is the BTTV_BOARD_AVERMEDIA98. I wonder how 1043 that was tested. My guess is that the whole INTERN 1044 input does not work. */ 1045 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1, 1046 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART); 1047 break; 1048 case TVAUDIO_INPUT_TUNER: 1049 default: 1050 /* This is the only card that uses TUNER2, and afaik, 1051 is the only difference between the VOODOOTV_FM 1052 and VOODOOTV_200 */ 1053 if (btv->c.type == BTTV_BOARD_VOODOOTV_200) 1054 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \ 1055 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER); 1056 else 1057 in = MSP_INPUT_DEFAULT; 1058 break; 1059 } 1060 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing, 1061 in, MSP_OUTPUT_DEFAULT, 0); 1062 } 1063 if (btv->sd_tvaudio) { 1064 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing, 1065 input, 0, 0); 1066 } 1067 return 0; 1068 } 1069 1070 static void 1071 bttv_crop_calc_limits(struct bttv_crop *c) 1072 { 1073 /* Scale factor min. 1:1, max. 16:1. Min. image size 1074 48 x 32. Scaled width must be a multiple of 4. */ 1075 1076 if (1) { 1077 /* For bug compatibility with VIDIOCGCAP and image 1078 size checks in earlier driver versions. */ 1079 c->min_scaled_width = 48; 1080 c->min_scaled_height = 32; 1081 } else { 1082 c->min_scaled_width = 1083 (max_t(unsigned int, 48, c->rect.width >> 4) + 3) & ~3; 1084 c->min_scaled_height = 1085 max_t(unsigned int, 32, c->rect.height >> 4); 1086 } 1087 1088 c->max_scaled_width = c->rect.width & ~3; 1089 c->max_scaled_height = c->rect.height; 1090 } 1091 1092 static void 1093 bttv_crop_reset(struct bttv_crop *c, unsigned int norm) 1094 { 1095 c->rect = bttv_tvnorms[norm].cropcap.defrect; 1096 bttv_crop_calc_limits(c); 1097 } 1098 1099 /* Call with btv->lock down. */ 1100 static int 1101 set_tvnorm(struct bttv *btv, unsigned int norm) 1102 { 1103 const struct bttv_tvnorm *tvnorm; 1104 v4l2_std_id id; 1105 1106 WARN_ON(norm >= BTTV_TVNORMS); 1107 WARN_ON(btv->tvnorm >= BTTV_TVNORMS); 1108 1109 tvnorm = &bttv_tvnorms[norm]; 1110 1111 if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap, 1112 sizeof (tvnorm->cropcap))) { 1113 bttv_crop_reset(&btv->crop[0], norm); 1114 btv->crop[1] = btv->crop[0]; /* current = default */ 1115 1116 if (0 == (btv->resources & VIDEO_RESOURCES)) { 1117 btv->crop_start = tvnorm->cropcap.bounds.top 1118 + tvnorm->cropcap.bounds.height; 1119 } 1120 } 1121 1122 btv->tvnorm = norm; 1123 1124 btwrite(tvnorm->adelay, BT848_ADELAY); 1125 btwrite(tvnorm->bdelay, BT848_BDELAY); 1126 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH), 1127 BT848_IFORM); 1128 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE); 1129 btwrite(1, BT848_VBI_PACK_DEL); 1130 bt848A_set_timing(btv); 1131 1132 switch (btv->c.type) { 1133 case BTTV_BOARD_VOODOOTV_FM: 1134 case BTTV_BOARD_VOODOOTV_200: 1135 bttv_tda9880_setnorm(btv, gpio_read()); 1136 break; 1137 } 1138 id = tvnorm->v4l2_id; 1139 bttv_call_all(btv, video, s_std, id); 1140 1141 return 0; 1142 } 1143 1144 /* Call with btv->lock down. */ 1145 static void 1146 set_input(struct bttv *btv, unsigned int input, unsigned int norm) 1147 { 1148 unsigned long flags; 1149 1150 btv->input = input; 1151 if (irq_iswitch) { 1152 spin_lock_irqsave(&btv->s_lock,flags); 1153 if (btv->curr.frame_irq) { 1154 /* active capture -> delayed input switch */ 1155 btv->new_input = input; 1156 } else { 1157 video_mux(btv,input); 1158 } 1159 spin_unlock_irqrestore(&btv->s_lock,flags); 1160 } else { 1161 video_mux(btv,input); 1162 } 1163 btv->audio_input = (btv->tuner_type != TUNER_ABSENT && input == 0) ? 1164 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN; 1165 audio_input(btv, btv->audio_input); 1166 set_tvnorm(btv, norm); 1167 } 1168 1169 void init_irqreg(struct bttv *btv) 1170 { 1171 /* clear status */ 1172 btwrite(0xfffffUL, BT848_INT_STAT); 1173 1174 if (bttv_tvcards[btv->c.type].no_video) { 1175 /* i2c only */ 1176 btwrite(BT848_INT_I2CDONE, 1177 BT848_INT_MASK); 1178 } else { 1179 /* full video */ 1180 btwrite((btv->triton1) | 1181 (btv->gpioirq ? BT848_INT_GPINT : 0) | 1182 BT848_INT_SCERR | 1183 (fdsr ? BT848_INT_FDSR : 0) | 1184 BT848_INT_RISCI | BT848_INT_OCERR | 1185 BT848_INT_FMTCHG|BT848_INT_HLOCK| 1186 BT848_INT_I2CDONE, 1187 BT848_INT_MASK); 1188 } 1189 } 1190 1191 static void init_bt848(struct bttv *btv) 1192 { 1193 if (bttv_tvcards[btv->c.type].no_video) { 1194 /* very basic init only */ 1195 init_irqreg(btv); 1196 return; 1197 } 1198 1199 btwrite(0x00, BT848_CAP_CTL); 1200 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL); 1201 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM); 1202 1203 /* set planar and packed mode trigger points and */ 1204 /* set rising edge of inverted GPINTR pin as irq trigger */ 1205 btwrite(BT848_GPIO_DMA_CTL_PKTP_32| 1206 BT848_GPIO_DMA_CTL_PLTP1_16| 1207 BT848_GPIO_DMA_CTL_PLTP23_16| 1208 BT848_GPIO_DMA_CTL_GPINTC| 1209 BT848_GPIO_DMA_CTL_GPINTI, 1210 BT848_GPIO_DMA_CTL); 1211 1212 btwrite(0x20, BT848_E_VSCALE_HI); 1213 btwrite(0x20, BT848_O_VSCALE_HI); 1214 1215 v4l2_ctrl_handler_setup(&btv->ctrl_handler); 1216 1217 /* interrupt */ 1218 init_irqreg(btv); 1219 } 1220 1221 static void bttv_reinit_bt848(struct bttv *btv) 1222 { 1223 unsigned long flags; 1224 1225 if (bttv_verbose) 1226 pr_info("%d: reset, reinitialize\n", btv->c.nr); 1227 spin_lock_irqsave(&btv->s_lock,flags); 1228 btv->errors=0; 1229 bttv_set_dma(btv,0); 1230 spin_unlock_irqrestore(&btv->s_lock,flags); 1231 1232 init_bt848(btv); 1233 btv->pll.pll_current = -1; 1234 set_input(btv, btv->input, btv->tvnorm); 1235 } 1236 1237 static int bttv_s_ctrl(struct v4l2_ctrl *c) 1238 { 1239 struct bttv *btv = container_of(c->handler, struct bttv, ctrl_handler); 1240 int val; 1241 1242 switch (c->id) { 1243 case V4L2_CID_BRIGHTNESS: 1244 bt848_bright(btv, c->val); 1245 break; 1246 case V4L2_CID_HUE: 1247 bt848_hue(btv, c->val); 1248 break; 1249 case V4L2_CID_CONTRAST: 1250 bt848_contrast(btv, c->val); 1251 break; 1252 case V4L2_CID_SATURATION: 1253 bt848_sat(btv, c->val); 1254 break; 1255 case V4L2_CID_COLOR_KILLER: 1256 if (c->val) { 1257 btor(BT848_SCLOOP_CKILL, BT848_E_SCLOOP); 1258 btor(BT848_SCLOOP_CKILL, BT848_O_SCLOOP); 1259 } else { 1260 btand(~BT848_SCLOOP_CKILL, BT848_E_SCLOOP); 1261 btand(~BT848_SCLOOP_CKILL, BT848_O_SCLOOP); 1262 } 1263 break; 1264 case V4L2_CID_AUDIO_MUTE: 1265 audio_mute(btv, c->val); 1266 btv->mute = c->val; 1267 break; 1268 case V4L2_CID_AUDIO_VOLUME: 1269 btv->volume_gpio(btv, c->val); 1270 break; 1271 1272 case V4L2_CID_CHROMA_AGC: 1273 val = c->val ? BT848_SCLOOP_CAGC : 0; 1274 btwrite(val, BT848_E_SCLOOP); 1275 btwrite(val, BT848_O_SCLOOP); 1276 break; 1277 case V4L2_CID_PRIVATE_COMBFILTER: 1278 btv->opt_combfilter = c->val; 1279 break; 1280 case V4L2_CID_PRIVATE_LUMAFILTER: 1281 if (c->val) { 1282 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL); 1283 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL); 1284 } else { 1285 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL); 1286 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL); 1287 } 1288 break; 1289 case V4L2_CID_PRIVATE_AUTOMUTE: 1290 btv->opt_automute = c->val; 1291 break; 1292 case V4L2_CID_PRIVATE_AGC_CRUSH: 1293 btwrite(BT848_ADC_RESERVED | 1294 (c->val ? BT848_ADC_CRUSH : 0), 1295 BT848_ADC); 1296 break; 1297 case V4L2_CID_PRIVATE_VCR_HACK: 1298 btv->opt_vcr_hack = c->val; 1299 break; 1300 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER: 1301 btwrite(c->val, BT848_WC_UP); 1302 break; 1303 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER: 1304 btwrite(c->val, BT848_WC_DOWN); 1305 break; 1306 case V4L2_CID_PRIVATE_UV_RATIO: 1307 btv->opt_uv_ratio = c->val; 1308 bt848_sat(btv, btv->saturation); 1309 break; 1310 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE: 1311 btaor((c->val << 7), ~BT848_OFORM_RANGE, BT848_OFORM); 1312 break; 1313 case V4L2_CID_PRIVATE_CORING: 1314 btaor((c->val << 5), ~BT848_OFORM_CORE32, BT848_OFORM); 1315 break; 1316 default: 1317 return -EINVAL; 1318 } 1319 return 0; 1320 } 1321 1322 /* ----------------------------------------------------------------------- */ 1323 1324 static const struct v4l2_ctrl_ops bttv_ctrl_ops = { 1325 .s_ctrl = bttv_s_ctrl, 1326 }; 1327 1328 static struct v4l2_ctrl_config bttv_ctrl_combfilter = { 1329 .ops = &bttv_ctrl_ops, 1330 .id = V4L2_CID_PRIVATE_COMBFILTER, 1331 .name = "Comb Filter", 1332 .type = V4L2_CTRL_TYPE_BOOLEAN, 1333 .min = 0, 1334 .max = 1, 1335 .step = 1, 1336 .def = 1, 1337 }; 1338 1339 static struct v4l2_ctrl_config bttv_ctrl_automute = { 1340 .ops = &bttv_ctrl_ops, 1341 .id = V4L2_CID_PRIVATE_AUTOMUTE, 1342 .name = "Auto Mute", 1343 .type = V4L2_CTRL_TYPE_BOOLEAN, 1344 .min = 0, 1345 .max = 1, 1346 .step = 1, 1347 .def = 1, 1348 }; 1349 1350 static struct v4l2_ctrl_config bttv_ctrl_lumafilter = { 1351 .ops = &bttv_ctrl_ops, 1352 .id = V4L2_CID_PRIVATE_LUMAFILTER, 1353 .name = "Luma Decimation Filter", 1354 .type = V4L2_CTRL_TYPE_BOOLEAN, 1355 .min = 0, 1356 .max = 1, 1357 .step = 1, 1358 .def = 1, 1359 }; 1360 1361 static struct v4l2_ctrl_config bttv_ctrl_agc_crush = { 1362 .ops = &bttv_ctrl_ops, 1363 .id = V4L2_CID_PRIVATE_AGC_CRUSH, 1364 .name = "AGC Crush", 1365 .type = V4L2_CTRL_TYPE_BOOLEAN, 1366 .min = 0, 1367 .max = 1, 1368 .step = 1, 1369 .def = 1, 1370 }; 1371 1372 static struct v4l2_ctrl_config bttv_ctrl_vcr_hack = { 1373 .ops = &bttv_ctrl_ops, 1374 .id = V4L2_CID_PRIVATE_VCR_HACK, 1375 .name = "VCR Hack", 1376 .type = V4L2_CTRL_TYPE_BOOLEAN, 1377 .min = 0, 1378 .max = 1, 1379 .step = 1, 1380 .def = 1, 1381 }; 1382 1383 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_lower = { 1384 .ops = &bttv_ctrl_ops, 1385 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER, 1386 .name = "Whitecrush Lower", 1387 .type = V4L2_CTRL_TYPE_INTEGER, 1388 .min = 0, 1389 .max = 255, 1390 .step = 1, 1391 .def = 0x7f, 1392 }; 1393 1394 static struct v4l2_ctrl_config bttv_ctrl_whitecrush_upper = { 1395 .ops = &bttv_ctrl_ops, 1396 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER, 1397 .name = "Whitecrush Upper", 1398 .type = V4L2_CTRL_TYPE_INTEGER, 1399 .min = 0, 1400 .max = 255, 1401 .step = 1, 1402 .def = 0xcf, 1403 }; 1404 1405 static struct v4l2_ctrl_config bttv_ctrl_uv_ratio = { 1406 .ops = &bttv_ctrl_ops, 1407 .id = V4L2_CID_PRIVATE_UV_RATIO, 1408 .name = "UV Ratio", 1409 .type = V4L2_CTRL_TYPE_INTEGER, 1410 .min = 0, 1411 .max = 100, 1412 .step = 1, 1413 .def = 50, 1414 }; 1415 1416 static struct v4l2_ctrl_config bttv_ctrl_full_luma = { 1417 .ops = &bttv_ctrl_ops, 1418 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE, 1419 .name = "Full Luma Range", 1420 .type = V4L2_CTRL_TYPE_BOOLEAN, 1421 .min = 0, 1422 .max = 1, 1423 .step = 1, 1424 }; 1425 1426 static struct v4l2_ctrl_config bttv_ctrl_coring = { 1427 .ops = &bttv_ctrl_ops, 1428 .id = V4L2_CID_PRIVATE_CORING, 1429 .name = "Coring", 1430 .type = V4L2_CTRL_TYPE_INTEGER, 1431 .min = 0, 1432 .max = 3, 1433 .step = 1, 1434 }; 1435 1436 1437 /* ----------------------------------------------------------------------- */ 1438 1439 void bttv_gpio_tracking(struct bttv *btv, char *comment) 1440 { 1441 unsigned int outbits, data; 1442 outbits = btread(BT848_GPIO_OUT_EN); 1443 data = btread(BT848_GPIO_DATA); 1444 pr_debug("%d: gpio: en=%08x, out=%08x in=%08x [%s]\n", 1445 btv->c.nr, outbits, data & outbits, data & ~outbits, comment); 1446 } 1447 1448 static const struct bttv_format* 1449 format_by_fourcc(int fourcc) 1450 { 1451 unsigned int i; 1452 1453 for (i = 0; i < FORMATS; i++) { 1454 if (-1 == formats[i].fourcc) 1455 continue; 1456 if (formats[i].fourcc == fourcc) 1457 return formats+i; 1458 } 1459 return NULL; 1460 } 1461 1462 /* ----------------------------------------------------------------------- */ 1463 /* video4linux (1) interface */ 1464 1465 static int queue_setup(struct vb2_queue *q, unsigned int *num_buffers, 1466 unsigned int *num_planes, unsigned int sizes[], 1467 struct device *alloc_devs[]) 1468 { 1469 struct bttv *btv = vb2_get_drv_priv(q); 1470 unsigned int size = btv->fmt->depth * btv->width * btv->height >> 3; 1471 1472 if (*num_planes) 1473 return sizes[0] < size ? -EINVAL : 0; 1474 *num_planes = 1; 1475 sizes[0] = size; 1476 1477 return 0; 1478 } 1479 1480 static void buf_queue(struct vb2_buffer *vb) 1481 { 1482 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1483 struct vb2_queue *vq = vb->vb2_queue; 1484 struct bttv *btv = vb2_get_drv_priv(vq); 1485 struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf); 1486 unsigned long flags; 1487 1488 spin_lock_irqsave(&btv->s_lock, flags); 1489 if (list_empty(&btv->capture)) { 1490 btv->loop_irq = BT848_RISC_VIDEO; 1491 if (vb2_is_streaming(&btv->vbiq)) 1492 btv->loop_irq |= BT848_RISC_VBI; 1493 bttv_set_dma(btv, BT848_CAP_CTL_CAPTURE_ODD | 1494 BT848_CAP_CTL_CAPTURE_EVEN); 1495 } 1496 list_add_tail(&buf->list, &btv->capture); 1497 spin_unlock_irqrestore(&btv->s_lock, flags); 1498 } 1499 1500 static int buf_prepare(struct vb2_buffer *vb) 1501 { 1502 struct vb2_queue *vq = vb->vb2_queue; 1503 struct bttv *btv = vb2_get_drv_priv(vq); 1504 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1505 struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf); 1506 unsigned int size = (btv->fmt->depth * btv->width * btv->height) >> 3; 1507 1508 if (vb2_plane_size(vb, 0) < size) 1509 return -EINVAL; 1510 vb2_set_plane_payload(vb, 0, size); 1511 1512 if (btv->field != V4L2_FIELD_ALTERNATE) { 1513 buf->vbuf.field = btv->field; 1514 } else if (btv->field_last == V4L2_FIELD_TOP) { 1515 buf->vbuf.field = V4L2_FIELD_BOTTOM; 1516 btv->field_last = V4L2_FIELD_BOTTOM; 1517 } else { 1518 buf->vbuf.field = V4L2_FIELD_TOP; 1519 btv->field_last = V4L2_FIELD_TOP; 1520 } 1521 1522 /* Allocate memory for risc struct and create the risc program. */ 1523 return bttv_buffer_risc(btv, buf); 1524 } 1525 1526 static void buf_cleanup(struct vb2_buffer *vb) 1527 { 1528 struct vb2_queue *vq = vb->vb2_queue; 1529 struct bttv *btv = vb2_get_drv_priv(vq); 1530 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); 1531 struct bttv_buffer *buf = container_of(vbuf, struct bttv_buffer, vbuf); 1532 1533 btcx_riscmem_free(btv->c.pci, &buf->top); 1534 btcx_riscmem_free(btv->c.pci, &buf->bottom); 1535 } 1536 1537 static int start_streaming(struct vb2_queue *q, unsigned int count) 1538 { 1539 int seqnr = 0; 1540 struct bttv_buffer *buf; 1541 struct bttv *btv = vb2_get_drv_priv(q); 1542 1543 if (!check_alloc_btres_lock(btv, RESOURCE_VIDEO_STREAM)) { 1544 if (btv->field_count) 1545 seqnr++; 1546 while (!list_empty(&btv->capture)) { 1547 buf = list_entry(btv->capture.next, 1548 struct bttv_buffer, list); 1549 list_del(&buf->list); 1550 buf->vbuf.sequence = (btv->field_count >> 1) + seqnr++; 1551 vb2_buffer_done(&buf->vbuf.vb2_buf, 1552 VB2_BUF_STATE_QUEUED); 1553 } 1554 return -EBUSY; 1555 } 1556 if (!vb2_is_streaming(&btv->vbiq)) { 1557 init_irqreg(btv); 1558 btv->field_count = 0; 1559 } 1560 btv->framedrop = 0; 1561 1562 return 0; 1563 } 1564 1565 static void stop_streaming(struct vb2_queue *q) 1566 { 1567 unsigned long flags; 1568 struct bttv *btv = vb2_get_drv_priv(q); 1569 1570 vb2_wait_for_all_buffers(q); 1571 spin_lock_irqsave(&btv->s_lock, flags); 1572 free_btres_lock(btv, RESOURCE_VIDEO_STREAM); 1573 if (!vb2_is_streaming(&btv->vbiq)) { 1574 /* stop field counter */ 1575 btand(~BT848_INT_VSYNC, BT848_INT_MASK); 1576 } 1577 spin_unlock_irqrestore(&btv->s_lock, flags); 1578 } 1579 1580 static const struct vb2_ops bttv_video_qops = { 1581 .queue_setup = queue_setup, 1582 .buf_queue = buf_queue, 1583 .buf_prepare = buf_prepare, 1584 .buf_cleanup = buf_cleanup, 1585 .start_streaming = start_streaming, 1586 .stop_streaming = stop_streaming, 1587 .wait_prepare = vb2_ops_wait_prepare, 1588 .wait_finish = vb2_ops_wait_finish, 1589 }; 1590 1591 static void radio_enable(struct bttv *btv) 1592 { 1593 /* Switch to the radio tuner */ 1594 if (!btv->has_radio_tuner) { 1595 btv->has_radio_tuner = 1; 1596 bttv_call_all(btv, tuner, s_radio); 1597 btv->audio_input = TVAUDIO_INPUT_RADIO; 1598 audio_input(btv, btv->audio_input); 1599 } 1600 } 1601 1602 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id) 1603 { 1604 struct bttv *btv = video_drvdata(file); 1605 unsigned int i; 1606 1607 for (i = 0; i < BTTV_TVNORMS; i++) 1608 if (id & bttv_tvnorms[i].v4l2_id) 1609 break; 1610 if (i == BTTV_TVNORMS) 1611 return -EINVAL; 1612 btv->std = id; 1613 set_tvnorm(btv, i); 1614 return 0; 1615 } 1616 1617 static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id) 1618 { 1619 struct bttv *btv = video_drvdata(file); 1620 1621 *id = btv->std; 1622 return 0; 1623 } 1624 1625 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id) 1626 { 1627 struct bttv *btv = video_drvdata(file); 1628 1629 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML) 1630 *id &= V4L2_STD_625_50; 1631 else 1632 *id &= V4L2_STD_525_60; 1633 return 0; 1634 } 1635 1636 static int bttv_enum_input(struct file *file, void *priv, 1637 struct v4l2_input *i) 1638 { 1639 struct bttv *btv = video_drvdata(file); 1640 1641 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) 1642 return -EINVAL; 1643 1644 i->type = V4L2_INPUT_TYPE_CAMERA; 1645 i->audioset = 0; 1646 1647 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) { 1648 sprintf(i->name, "Television"); 1649 i->type = V4L2_INPUT_TYPE_TUNER; 1650 i->tuner = 0; 1651 } else if (i->index == btv->svhs) { 1652 sprintf(i->name, "S-Video"); 1653 } else { 1654 sprintf(i->name, "Composite%d", i->index); 1655 } 1656 1657 if (i->index == btv->input) { 1658 __u32 dstatus = btread(BT848_DSTATUS); 1659 if (0 == (dstatus & BT848_DSTATUS_PRES)) 1660 i->status |= V4L2_IN_ST_NO_SIGNAL; 1661 if (0 == (dstatus & BT848_DSTATUS_HLOC)) 1662 i->status |= V4L2_IN_ST_NO_H_LOCK; 1663 } 1664 1665 i->std = BTTV_NORMS; 1666 return 0; 1667 } 1668 1669 static int bttv_g_input(struct file *file, void *priv, unsigned int *i) 1670 { 1671 struct bttv *btv = video_drvdata(file); 1672 1673 *i = btv->input; 1674 1675 return 0; 1676 } 1677 1678 static int bttv_s_input(struct file *file, void *priv, unsigned int i) 1679 { 1680 struct bttv *btv = video_drvdata(file); 1681 1682 if (i >= bttv_tvcards[btv->c.type].video_inputs) 1683 return -EINVAL; 1684 1685 set_input(btv, i, btv->tvnorm); 1686 return 0; 1687 } 1688 1689 static int bttv_s_tuner(struct file *file, void *priv, 1690 const struct v4l2_tuner *t) 1691 { 1692 struct bttv *btv = video_drvdata(file); 1693 1694 if (t->index) 1695 return -EINVAL; 1696 1697 bttv_call_all(btv, tuner, s_tuner, t); 1698 1699 if (btv->audio_mode_gpio) { 1700 struct v4l2_tuner copy = *t; 1701 1702 btv->audio_mode_gpio(btv, ©, 1); 1703 } 1704 return 0; 1705 } 1706 1707 static int bttv_g_frequency(struct file *file, void *priv, 1708 struct v4l2_frequency *f) 1709 { 1710 struct bttv *btv = video_drvdata(file); 1711 1712 if (f->tuner) 1713 return -EINVAL; 1714 1715 if (f->type == V4L2_TUNER_RADIO) 1716 radio_enable(btv); 1717 f->frequency = f->type == V4L2_TUNER_RADIO ? 1718 btv->radio_freq : btv->tv_freq; 1719 1720 return 0; 1721 } 1722 1723 static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f) 1724 { 1725 struct v4l2_frequency new_freq = *f; 1726 1727 bttv_call_all(btv, tuner, s_frequency, f); 1728 /* s_frequency may clamp the frequency, so get the actual 1729 frequency before assigning radio/tv_freq. */ 1730 bttv_call_all(btv, tuner, g_frequency, &new_freq); 1731 if (new_freq.type == V4L2_TUNER_RADIO) { 1732 radio_enable(btv); 1733 btv->radio_freq = new_freq.frequency; 1734 if (btv->has_tea575x) { 1735 btv->tea.freq = btv->radio_freq; 1736 snd_tea575x_set_freq(&btv->tea); 1737 } 1738 } else { 1739 btv->tv_freq = new_freq.frequency; 1740 } 1741 } 1742 1743 static int bttv_s_frequency(struct file *file, void *priv, 1744 const struct v4l2_frequency *f) 1745 { 1746 struct bttv *btv = video_drvdata(file); 1747 1748 if (f->tuner) 1749 return -EINVAL; 1750 1751 bttv_set_frequency(btv, f); 1752 return 0; 1753 } 1754 1755 static int bttv_log_status(struct file *file, void *f) 1756 { 1757 struct video_device *vdev = video_devdata(file); 1758 struct bttv *btv = video_drvdata(file); 1759 1760 v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name); 1761 bttv_call_all(btv, core, log_status); 1762 return 0; 1763 } 1764 1765 #ifdef CONFIG_VIDEO_ADV_DEBUG 1766 static int bttv_g_register(struct file *file, void *f, 1767 struct v4l2_dbg_register *reg) 1768 { 1769 struct bttv *btv = video_drvdata(file); 1770 1771 /* bt848 has a 12-bit register space */ 1772 reg->reg &= 0xfff; 1773 reg->val = btread(reg->reg); 1774 reg->size = 1; 1775 1776 return 0; 1777 } 1778 1779 static int bttv_s_register(struct file *file, void *f, 1780 const struct v4l2_dbg_register *reg) 1781 { 1782 struct bttv *btv = video_drvdata(file); 1783 1784 /* bt848 has a 12-bit register space */ 1785 btwrite(reg->val, reg->reg & 0xfff); 1786 1787 return 0; 1788 } 1789 #endif 1790 1791 /* Given cropping boundaries b and the scaled width and height of a 1792 single field or frame, which must not exceed hardware limits, this 1793 function adjusts the cropping parameters c. */ 1794 static void 1795 bttv_crop_adjust (struct bttv_crop * c, 1796 const struct v4l2_rect * b, 1797 __s32 width, 1798 __s32 height, 1799 enum v4l2_field field) 1800 { 1801 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field); 1802 __s32 max_left; 1803 __s32 max_top; 1804 1805 if (width < c->min_scaled_width) { 1806 /* Max. hor. scale factor 16:1. */ 1807 c->rect.width = width * 16; 1808 } else if (width > c->max_scaled_width) { 1809 /* Min. hor. scale factor 1:1. */ 1810 c->rect.width = width; 1811 1812 max_left = b->left + b->width - width; 1813 max_left = min(max_left, (__s32) MAX_HDELAY); 1814 if (c->rect.left > max_left) 1815 c->rect.left = max_left; 1816 } 1817 1818 if (height < c->min_scaled_height) { 1819 /* Max. vert. scale factor 16:1, single fields 8:1. */ 1820 c->rect.height = height * 16; 1821 } else if (frame_height > c->max_scaled_height) { 1822 /* Min. vert. scale factor 1:1. 1823 Top and height count field lines times two. */ 1824 c->rect.height = (frame_height + 1) & ~1; 1825 1826 max_top = b->top + b->height - c->rect.height; 1827 if (c->rect.top > max_top) 1828 c->rect.top = max_top; 1829 } 1830 1831 bttv_crop_calc_limits(c); 1832 } 1833 1834 /* Returns an error if scaling to a frame or single field with the given 1835 width and height is not possible with the current cropping parameters 1836 and width aligned according to width_mask. If adjust_size is TRUE the 1837 function may adjust the width and/or height instead, rounding width 1838 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may 1839 also adjust the current cropping parameters to get closer to the 1840 desired image size. */ 1841 static int 1842 limit_scaled_size_lock(struct bttv *btv, __s32 *width, __s32 *height, 1843 enum v4l2_field field, unsigned int width_mask, 1844 unsigned int width_bias, int adjust_size, 1845 int adjust_crop) 1846 { 1847 const struct v4l2_rect *b; 1848 struct bttv_crop *c; 1849 __s32 min_width; 1850 __s32 min_height; 1851 __s32 max_width; 1852 __s32 max_height; 1853 int rc; 1854 1855 WARN_ON((int)width_mask >= 0 || 1856 width_bias >= (unsigned int)(-width_mask)); 1857 1858 /* Make sure tvnorm, vbi_end and the current cropping parameters 1859 remain consistent until we're done. */ 1860 1861 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 1862 1863 /* Do crop - use current, don't - use default parameters. */ 1864 c = &btv->crop[!!btv->do_crop]; 1865 1866 if (btv->do_crop 1867 && adjust_size 1868 && adjust_crop 1869 && !locked_btres(btv, VIDEO_RESOURCES)) { 1870 min_width = 48; 1871 min_height = 32; 1872 1873 /* We cannot scale up. When the scaled image is larger 1874 than crop.rect we adjust the crop.rect as required 1875 by the V4L2 spec, hence cropcap.bounds are our limit. */ 1876 max_width = min_t(unsigned int, b->width, MAX_HACTIVE); 1877 max_height = b->height; 1878 1879 /* We cannot capture the same line as video and VBI data. 1880 Note btv->vbi_end is really a minimum, see 1881 bttv_vbi_try_fmt(). */ 1882 if (btv->vbi_end > b->top) { 1883 max_height -= btv->vbi_end - b->top; 1884 rc = -EBUSY; 1885 if (min_height > max_height) 1886 goto fail; 1887 } 1888 } else { 1889 rc = -EBUSY; 1890 if (btv->vbi_end > c->rect.top) 1891 goto fail; 1892 1893 min_width = c->min_scaled_width; 1894 min_height = c->min_scaled_height; 1895 max_width = c->max_scaled_width; 1896 max_height = c->max_scaled_height; 1897 1898 adjust_crop = 0; 1899 } 1900 1901 min_width = (min_width - width_mask - 1) & width_mask; 1902 max_width = max_width & width_mask; 1903 1904 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */ 1905 /* Min. scale factor is 1:1. */ 1906 max_height >>= !V4L2_FIELD_HAS_BOTH(field); 1907 1908 if (adjust_size) { 1909 *width = clamp(*width, min_width, max_width); 1910 *height = clamp(*height, min_height, max_height); 1911 1912 /* Round after clamping to avoid overflow. */ 1913 *width = (*width + width_bias) & width_mask; 1914 1915 if (adjust_crop) { 1916 bttv_crop_adjust(c, b, *width, *height, field); 1917 1918 if (btv->vbi_end > c->rect.top) { 1919 /* Move the crop window out of the way. */ 1920 c->rect.top = btv->vbi_end; 1921 } 1922 } 1923 } else { 1924 rc = -EINVAL; 1925 if (*width < min_width || 1926 *height < min_height || 1927 *width > max_width || 1928 *height > max_height || 1929 0 != (*width & ~width_mask)) 1930 goto fail; 1931 } 1932 1933 rc = 0; /* success */ 1934 1935 fail: 1936 1937 return rc; 1938 } 1939 1940 static int bttv_switch_type(struct bttv *btv, enum v4l2_buf_type type) 1941 { 1942 int res; 1943 struct vb2_queue *q; 1944 1945 switch (type) { 1946 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 1947 q = &btv->capq; 1948 res = RESOURCE_VIDEO_STREAM; 1949 break; 1950 case V4L2_BUF_TYPE_VBI_CAPTURE: 1951 q = &btv->vbiq; 1952 res = RESOURCE_VBI; 1953 break; 1954 default: 1955 WARN_ON(1); 1956 return -EINVAL; 1957 } 1958 1959 if (check_btres(btv, res)) 1960 return -EBUSY; 1961 if (vb2_is_busy(q)) 1962 return -EBUSY; 1963 btv->type = type; 1964 1965 return 0; 1966 } 1967 1968 static void 1969 pix_format_set_size (struct v4l2_pix_format * f, 1970 const struct bttv_format * fmt, 1971 unsigned int width, 1972 unsigned int height) 1973 { 1974 f->width = width; 1975 f->height = height; 1976 1977 if (fmt->flags & FORMAT_FLAGS_PLANAR) { 1978 f->bytesperline = width; /* Y plane */ 1979 f->sizeimage = (width * height * fmt->depth) >> 3; 1980 } else { 1981 f->bytesperline = (width * fmt->depth) >> 3; 1982 f->sizeimage = height * f->bytesperline; 1983 } 1984 } 1985 1986 static int bttv_g_fmt_vid_cap(struct file *file, void *priv, 1987 struct v4l2_format *f) 1988 { 1989 struct bttv *btv = video_drvdata(file); 1990 1991 pix_format_set_size(&f->fmt.pix, btv->fmt, btv->width, btv->height); 1992 f->fmt.pix.field = btv->field; 1993 f->fmt.pix.pixelformat = btv->fmt->fourcc; 1994 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1995 1996 return 0; 1997 } 1998 1999 static void bttv_get_width_mask_vid_cap(const struct bttv_format *fmt, 2000 unsigned int *width_mask, 2001 unsigned int *width_bias) 2002 { 2003 if (fmt->flags & FORMAT_FLAGS_PLANAR) { 2004 *width_mask = ~15; /* width must be a multiple of 16 pixels */ 2005 *width_bias = 8; /* nearest */ 2006 } else { 2007 *width_mask = ~3; /* width must be a multiple of 4 pixels */ 2008 *width_bias = 2; /* nearest */ 2009 } 2010 } 2011 2012 static int bttv_try_fmt_vid_cap(struct file *file, void *priv, 2013 struct v4l2_format *f) 2014 { 2015 const struct bttv_format *fmt; 2016 struct bttv *btv = video_drvdata(file); 2017 enum v4l2_field field; 2018 __s32 width, height; 2019 __s32 height2; 2020 unsigned int width_mask, width_bias; 2021 int rc; 2022 2023 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2024 if (NULL == fmt) 2025 return -EINVAL; 2026 2027 field = f->fmt.pix.field; 2028 2029 switch (field) { 2030 case V4L2_FIELD_TOP: 2031 case V4L2_FIELD_BOTTOM: 2032 case V4L2_FIELD_ALTERNATE: 2033 case V4L2_FIELD_INTERLACED: 2034 break; 2035 case V4L2_FIELD_SEQ_BT: 2036 case V4L2_FIELD_SEQ_TB: 2037 if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) { 2038 field = V4L2_FIELD_SEQ_TB; 2039 break; 2040 } 2041 fallthrough; 2042 default: /* FIELD_ANY case */ 2043 height2 = btv->crop[!!btv->do_crop].rect.height >> 1; 2044 field = (f->fmt.pix.height > height2) 2045 ? V4L2_FIELD_INTERLACED 2046 : V4L2_FIELD_BOTTOM; 2047 break; 2048 } 2049 2050 width = f->fmt.pix.width; 2051 height = f->fmt.pix.height; 2052 2053 bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias); 2054 rc = limit_scaled_size_lock(btv, &width, &height, field, width_mask, 2055 width_bias, 1, 0); 2056 if (0 != rc) 2057 return rc; 2058 2059 /* update data for the application */ 2060 f->fmt.pix.field = field; 2061 pix_format_set_size(&f->fmt.pix, fmt, width, height); 2062 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 2063 2064 return 0; 2065 } 2066 2067 static int bttv_s_fmt_vid_cap(struct file *file, void *priv, 2068 struct v4l2_format *f) 2069 { 2070 int retval; 2071 const struct bttv_format *fmt; 2072 struct bttv *btv = video_drvdata(file); 2073 __s32 width, height; 2074 unsigned int width_mask, width_bias; 2075 enum v4l2_field field; 2076 2077 retval = bttv_switch_type(btv, f->type); 2078 if (0 != retval) 2079 return retval; 2080 2081 retval = bttv_try_fmt_vid_cap(file, priv, f); 2082 if (0 != retval) 2083 return retval; 2084 2085 width = f->fmt.pix.width; 2086 height = f->fmt.pix.height; 2087 field = f->fmt.pix.field; 2088 2089 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2090 bttv_get_width_mask_vid_cap(fmt, &width_mask, &width_bias); 2091 retval = limit_scaled_size_lock(btv, &width, &height, f->fmt.pix.field, 2092 width_mask, width_bias, 1, 1); 2093 if (0 != retval) 2094 return retval; 2095 2096 f->fmt.pix.field = field; 2097 2098 /* update our state information */ 2099 btv->fmt = fmt; 2100 btv->width = f->fmt.pix.width; 2101 btv->height = f->fmt.pix.height; 2102 btv->field = f->fmt.pix.field; 2103 /* 2104 * When field is V4L2_FIELD_ALTERNATE, buffers will be either 2105 * V4L2_FIELD_TOP or V4L2_FIELD_BOTTOM depending on the value of 2106 * field_last. Initialize field_last to V4L2_FIELD_BOTTOM so that 2107 * streaming starts with a V4L2_FIELD_TOP buffer. 2108 */ 2109 btv->field_last = V4L2_FIELD_BOTTOM; 2110 2111 return 0; 2112 } 2113 2114 static int bttv_querycap(struct file *file, void *priv, 2115 struct v4l2_capability *cap) 2116 { 2117 struct bttv *btv = video_drvdata(file); 2118 2119 if (0 == v4l2) 2120 return -EINVAL; 2121 2122 strscpy(cap->driver, "bttv", sizeof(cap->driver)); 2123 strscpy(cap->card, btv->video_dev.name, sizeof(cap->card)); 2124 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE | 2125 V4L2_CAP_STREAMING | V4L2_CAP_DEVICE_CAPS; 2126 if (video_is_registered(&btv->vbi_dev)) 2127 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 2128 if (video_is_registered(&btv->radio_dev)) { 2129 cap->capabilities |= V4L2_CAP_RADIO; 2130 if (btv->has_tea575x) 2131 cap->capabilities |= V4L2_CAP_HW_FREQ_SEEK; 2132 } 2133 2134 /* 2135 * No need to lock here: those vars are initialized during board 2136 * probe and remains untouched during the rest of the driver lifecycle 2137 */ 2138 if (btv->has_saa6588) 2139 cap->capabilities |= V4L2_CAP_RDS_CAPTURE; 2140 if (btv->tuner_type != TUNER_ABSENT) 2141 cap->capabilities |= V4L2_CAP_TUNER; 2142 return 0; 2143 } 2144 2145 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv, 2146 struct v4l2_fmtdesc *f) 2147 { 2148 int index = -1, i; 2149 2150 for (i = 0; i < FORMATS; i++) { 2151 if (formats[i].fourcc != -1) 2152 index++; 2153 if ((unsigned int)index == f->index) 2154 break; 2155 } 2156 if (FORMATS == i) 2157 return -EINVAL; 2158 2159 f->pixelformat = formats[i].fourcc; 2160 2161 return 0; 2162 } 2163 2164 static int bttv_g_parm(struct file *file, void *f, 2165 struct v4l2_streamparm *parm) 2166 { 2167 struct bttv *btv = video_drvdata(file); 2168 2169 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2170 return -EINVAL; 2171 parm->parm.capture.readbuffers = gbuffers; 2172 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id, 2173 &parm->parm.capture.timeperframe); 2174 2175 return 0; 2176 } 2177 2178 static int bttv_g_tuner(struct file *file, void *priv, 2179 struct v4l2_tuner *t) 2180 { 2181 struct bttv *btv = video_drvdata(file); 2182 2183 if (0 != t->index) 2184 return -EINVAL; 2185 2186 t->rxsubchans = V4L2_TUNER_SUB_MONO; 2187 t->capability = V4L2_TUNER_CAP_NORM; 2188 bttv_call_all(btv, tuner, g_tuner, t); 2189 strscpy(t->name, "Television", sizeof(t->name)); 2190 t->type = V4L2_TUNER_ANALOG_TV; 2191 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) 2192 t->signal = 0xffff; 2193 2194 if (btv->audio_mode_gpio) 2195 btv->audio_mode_gpio(btv, t, 0); 2196 2197 return 0; 2198 } 2199 2200 static int bttv_g_pixelaspect(struct file *file, void *priv, 2201 int type, struct v4l2_fract *f) 2202 { 2203 struct bttv *btv = video_drvdata(file); 2204 2205 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2206 return -EINVAL; 2207 2208 /* defrect and bounds are set via g_selection */ 2209 *f = bttv_tvnorms[btv->tvnorm].cropcap.pixelaspect; 2210 return 0; 2211 } 2212 2213 static int bttv_g_selection(struct file *file, void *f, struct v4l2_selection *sel) 2214 { 2215 struct bttv *btv = video_drvdata(file); 2216 2217 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2218 return -EINVAL; 2219 2220 switch (sel->target) { 2221 case V4L2_SEL_TGT_CROP: 2222 sel->r = btv->crop[!!btv->do_crop].rect; 2223 break; 2224 case V4L2_SEL_TGT_CROP_DEFAULT: 2225 sel->r = bttv_tvnorms[btv->tvnorm].cropcap.defrect; 2226 break; 2227 case V4L2_SEL_TGT_CROP_BOUNDS: 2228 sel->r = bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2229 break; 2230 default: 2231 return -EINVAL; 2232 } 2233 2234 return 0; 2235 } 2236 2237 static int bttv_s_selection(struct file *file, void *f, struct v4l2_selection *sel) 2238 { 2239 struct bttv *btv = video_drvdata(file); 2240 const struct v4l2_rect *b; 2241 int retval; 2242 struct bttv_crop c; 2243 __s32 b_left; 2244 __s32 b_top; 2245 __s32 b_right; 2246 __s32 b_bottom; 2247 2248 if (sel->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2249 return -EINVAL; 2250 2251 if (sel->target != V4L2_SEL_TGT_CROP) 2252 return -EINVAL; 2253 2254 /* Make sure tvnorm, vbi_end and the current cropping 2255 parameters remain consistent until we're done. Note 2256 read() may change vbi_end in check_alloc_btres_lock(). */ 2257 retval = -EBUSY; 2258 2259 if (locked_btres(btv, VIDEO_RESOURCES)) 2260 return retval; 2261 2262 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2263 2264 b_left = b->left; 2265 b_right = b_left + b->width; 2266 b_bottom = b->top + b->height; 2267 2268 b_top = max(b->top, btv->vbi_end); 2269 if (b_top + 32 >= b_bottom) { 2270 return retval; 2271 } 2272 2273 /* Min. scaled size 48 x 32. */ 2274 c.rect.left = clamp_t(s32, sel->r.left, b_left, b_right - 48); 2275 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY); 2276 2277 c.rect.width = clamp_t(s32, sel->r.width, 2278 48, b_right - c.rect.left); 2279 2280 c.rect.top = clamp_t(s32, sel->r.top, b_top, b_bottom - 32); 2281 /* Top and height must be a multiple of two. */ 2282 c.rect.top = (c.rect.top + 1) & ~1; 2283 2284 c.rect.height = clamp_t(s32, sel->r.height, 2285 32, b_bottom - c.rect.top); 2286 c.rect.height = (c.rect.height + 1) & ~1; 2287 2288 bttv_crop_calc_limits(&c); 2289 2290 sel->r = c.rect; 2291 2292 btv->crop[1] = c; 2293 2294 btv->do_crop = 1; 2295 2296 if (btv->width < c.min_scaled_width) 2297 btv->width = c.min_scaled_width; 2298 else if (btv->width > c.max_scaled_width) 2299 btv->width = c.max_scaled_width; 2300 2301 if (btv->height < c.min_scaled_height) 2302 btv->height = c.min_scaled_height; 2303 else if (btv->height > c.max_scaled_height) 2304 btv->height = c.max_scaled_height; 2305 2306 return 0; 2307 } 2308 2309 static const struct v4l2_file_operations bttv_fops = 2310 { 2311 .owner = THIS_MODULE, 2312 .open = v4l2_fh_open, 2313 .release = vb2_fop_release, 2314 .unlocked_ioctl = video_ioctl2, 2315 .read = vb2_fop_read, 2316 .mmap = vb2_fop_mmap, 2317 .poll = vb2_fop_poll, 2318 }; 2319 2320 static const struct v4l2_ioctl_ops bttv_ioctl_ops = { 2321 .vidioc_querycap = bttv_querycap, 2322 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap, 2323 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap, 2324 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap, 2325 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap, 2326 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap, 2327 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap, 2328 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap, 2329 .vidioc_g_pixelaspect = bttv_g_pixelaspect, 2330 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2331 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2332 .vidioc_querybuf = vb2_ioctl_querybuf, 2333 .vidioc_qbuf = vb2_ioctl_qbuf, 2334 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2335 .vidioc_streamon = vb2_ioctl_streamon, 2336 .vidioc_streamoff = vb2_ioctl_streamoff, 2337 .vidioc_s_std = bttv_s_std, 2338 .vidioc_g_std = bttv_g_std, 2339 .vidioc_enum_input = bttv_enum_input, 2340 .vidioc_g_input = bttv_g_input, 2341 .vidioc_s_input = bttv_s_input, 2342 .vidioc_g_tuner = bttv_g_tuner, 2343 .vidioc_s_tuner = bttv_s_tuner, 2344 .vidioc_g_selection = bttv_g_selection, 2345 .vidioc_s_selection = bttv_s_selection, 2346 .vidioc_g_parm = bttv_g_parm, 2347 .vidioc_g_frequency = bttv_g_frequency, 2348 .vidioc_s_frequency = bttv_s_frequency, 2349 .vidioc_log_status = bttv_log_status, 2350 .vidioc_querystd = bttv_querystd, 2351 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2352 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2353 #ifdef CONFIG_VIDEO_ADV_DEBUG 2354 .vidioc_g_register = bttv_g_register, 2355 .vidioc_s_register = bttv_s_register, 2356 #endif 2357 }; 2358 2359 static struct video_device bttv_video_template = { 2360 .fops = &bttv_fops, 2361 .ioctl_ops = &bttv_ioctl_ops, 2362 .tvnorms = BTTV_NORMS, 2363 }; 2364 2365 /* ----------------------------------------------------------------------- */ 2366 /* radio interface */ 2367 2368 static int radio_open(struct file *file) 2369 { 2370 struct video_device *vdev = video_devdata(file); 2371 struct bttv *btv = video_drvdata(file); 2372 int ret = v4l2_fh_open(file); 2373 2374 if (ret) 2375 return ret; 2376 2377 dprintk("open dev=%s\n", video_device_node_name(vdev)); 2378 dprintk("%d: open called (radio)\n", btv->c.nr); 2379 2380 btv->radio_user++; 2381 audio_mute(btv, btv->mute); 2382 2383 return 0; 2384 } 2385 2386 static int radio_release(struct file *file) 2387 { 2388 struct bttv *btv = video_drvdata(file); 2389 struct saa6588_command cmd; 2390 2391 btv->radio_user--; 2392 2393 bttv_call_all(btv, core, command, SAA6588_CMD_CLOSE, &cmd); 2394 2395 if (btv->radio_user == 0) 2396 btv->has_radio_tuner = 0; 2397 2398 v4l2_fh_release(file); 2399 2400 return 0; 2401 } 2402 2403 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 2404 { 2405 struct bttv *btv = video_drvdata(file); 2406 2407 if (0 != t->index) 2408 return -EINVAL; 2409 strscpy(t->name, "Radio", sizeof(t->name)); 2410 t->type = V4L2_TUNER_RADIO; 2411 radio_enable(btv); 2412 2413 bttv_call_all(btv, tuner, g_tuner, t); 2414 2415 if (btv->audio_mode_gpio) 2416 btv->audio_mode_gpio(btv, t, 0); 2417 2418 if (btv->has_tea575x) 2419 return snd_tea575x_g_tuner(&btv->tea, t); 2420 2421 return 0; 2422 } 2423 2424 static int radio_s_tuner(struct file *file, void *priv, 2425 const struct v4l2_tuner *t) 2426 { 2427 struct bttv *btv = video_drvdata(file); 2428 2429 if (0 != t->index) 2430 return -EINVAL; 2431 2432 radio_enable(btv); 2433 bttv_call_all(btv, tuner, s_tuner, t); 2434 return 0; 2435 } 2436 2437 static int radio_s_hw_freq_seek(struct file *file, void *priv, 2438 const struct v4l2_hw_freq_seek *a) 2439 { 2440 struct bttv *btv = video_drvdata(file); 2441 2442 if (btv->has_tea575x) 2443 return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a); 2444 2445 return -ENOTTY; 2446 } 2447 2448 static int radio_enum_freq_bands(struct file *file, void *priv, 2449 struct v4l2_frequency_band *band) 2450 { 2451 struct bttv *btv = video_drvdata(file); 2452 2453 if (btv->has_tea575x) 2454 return snd_tea575x_enum_freq_bands(&btv->tea, band); 2455 2456 return -ENOTTY; 2457 } 2458 2459 static ssize_t radio_read(struct file *file, char __user *data, 2460 size_t count, loff_t *ppos) 2461 { 2462 struct bttv *btv = video_drvdata(file); 2463 struct saa6588_command cmd; 2464 2465 cmd.block_count = count / 3; 2466 cmd.nonblocking = file->f_flags & O_NONBLOCK; 2467 cmd.buffer = data; 2468 cmd.instance = file; 2469 cmd.result = -ENODEV; 2470 radio_enable(btv); 2471 2472 bttv_call_all(btv, core, command, SAA6588_CMD_READ, &cmd); 2473 2474 return cmd.result; 2475 } 2476 2477 static __poll_t radio_poll(struct file *file, poll_table *wait) 2478 { 2479 struct bttv *btv = video_drvdata(file); 2480 struct saa6588_command cmd; 2481 __poll_t rc = v4l2_ctrl_poll(file, wait); 2482 2483 radio_enable(btv); 2484 cmd.instance = file; 2485 cmd.event_list = wait; 2486 cmd.poll_mask = 0; 2487 bttv_call_all(btv, core, command, SAA6588_CMD_POLL, &cmd); 2488 2489 return rc | cmd.poll_mask; 2490 } 2491 2492 static const struct v4l2_file_operations radio_fops = 2493 { 2494 .owner = THIS_MODULE, 2495 .open = radio_open, 2496 .read = radio_read, 2497 .release = radio_release, 2498 .unlocked_ioctl = video_ioctl2, 2499 .poll = radio_poll, 2500 }; 2501 2502 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2503 .vidioc_querycap = bttv_querycap, 2504 .vidioc_log_status = bttv_log_status, 2505 .vidioc_g_tuner = radio_g_tuner, 2506 .vidioc_s_tuner = radio_s_tuner, 2507 .vidioc_g_frequency = bttv_g_frequency, 2508 .vidioc_s_frequency = bttv_s_frequency, 2509 .vidioc_s_hw_freq_seek = radio_s_hw_freq_seek, 2510 .vidioc_enum_freq_bands = radio_enum_freq_bands, 2511 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 2512 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 2513 }; 2514 2515 static struct video_device radio_template = { 2516 .fops = &radio_fops, 2517 .ioctl_ops = &radio_ioctl_ops, 2518 }; 2519 2520 /* ----------------------------------------------------------------------- */ 2521 /* some debug code */ 2522 2523 static int bttv_risc_decode(u32 risc) 2524 { 2525 static char *instr[16] = { 2526 [ BT848_RISC_WRITE >> 28 ] = "write", 2527 [ BT848_RISC_SKIP >> 28 ] = "skip", 2528 [ BT848_RISC_WRITEC >> 28 ] = "writec", 2529 [ BT848_RISC_JUMP >> 28 ] = "jump", 2530 [ BT848_RISC_SYNC >> 28 ] = "sync", 2531 [ BT848_RISC_WRITE123 >> 28 ] = "write123", 2532 [ BT848_RISC_SKIP123 >> 28 ] = "skip123", 2533 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23", 2534 }; 2535 static int incr[16] = { 2536 [ BT848_RISC_WRITE >> 28 ] = 2, 2537 [ BT848_RISC_JUMP >> 28 ] = 2, 2538 [ BT848_RISC_SYNC >> 28 ] = 2, 2539 [ BT848_RISC_WRITE123 >> 28 ] = 5, 2540 [ BT848_RISC_SKIP123 >> 28 ] = 2, 2541 [ BT848_RISC_WRITE1S23 >> 28 ] = 3, 2542 }; 2543 static char *bits[] = { 2544 "be0", "be1", "be2", "be3/resync", 2545 "set0", "set1", "set2", "set3", 2546 "clr0", "clr1", "clr2", "clr3", 2547 "irq", "res", "eol", "sol", 2548 }; 2549 int i; 2550 2551 pr_cont("0x%08x [ %s", risc, 2552 instr[risc >> 28] ? instr[risc >> 28] : "INVALID"); 2553 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--) 2554 if (risc & (1 << (i + 12))) 2555 pr_cont(" %s", bits[i]); 2556 pr_cont(" count=%d ]\n", risc & 0xfff); 2557 return incr[risc >> 28] ? incr[risc >> 28] : 1; 2558 } 2559 2560 static void bttv_risc_disasm(struct bttv *btv, 2561 struct btcx_riscmem *risc) 2562 { 2563 unsigned int i,j,n; 2564 2565 pr_info("%s: risc disasm: %p [dma=0x%08lx]\n", 2566 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma); 2567 for (i = 0; i < (risc->size >> 2); i += n) { 2568 pr_info("%s: 0x%lx: ", 2569 btv->c.v4l2_dev.name, 2570 (unsigned long)(risc->dma + (i<<2))); 2571 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i])); 2572 for (j = 1; j < n; j++) 2573 pr_info("%s: 0x%lx: 0x%08x [ arg #%d ]\n", 2574 btv->c.v4l2_dev.name, 2575 (unsigned long)(risc->dma + ((i+j)<<2)), 2576 risc->cpu[i+j], j); 2577 if (0 == risc->cpu[i]) 2578 break; 2579 } 2580 } 2581 2582 static void bttv_print_riscaddr(struct bttv *btv) 2583 { 2584 pr_info(" main: %08llx\n", (unsigned long long)btv->main.dma); 2585 pr_info(" vbi : o=%08llx e=%08llx\n", 2586 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0, 2587 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0); 2588 pr_info(" cap : o=%08llx e=%08llx\n", 2589 btv->curr.top 2590 ? (unsigned long long)btv->curr.top->top.dma : 0, 2591 btv->curr.bottom 2592 ? (unsigned long long)btv->curr.bottom->bottom.dma : 0); 2593 bttv_risc_disasm(btv, &btv->main); 2594 } 2595 2596 /* ----------------------------------------------------------------------- */ 2597 /* irq handler */ 2598 2599 static char *irq_name[] = { 2600 "FMTCHG", // format change detected (525 vs. 625) 2601 "VSYNC", // vertical sync (new field) 2602 "HSYNC", // horizontal sync 2603 "OFLOW", // chroma/luma AGC overflow 2604 "HLOCK", // horizontal lock changed 2605 "VPRES", // video presence changed 2606 "6", "7", 2607 "I2CDONE", // hw irc operation finished 2608 "GPINT", // gpio port triggered irq 2609 "10", 2610 "RISCI", // risc instruction triggered irq 2611 "FBUS", // pixel data fifo dropped data (high pci bus latencies) 2612 "FTRGT", // pixel data fifo overrun 2613 "FDSR", // fifo data stream resyncronisation 2614 "PPERR", // parity error (data transfer) 2615 "RIPERR", // parity error (read risc instructions) 2616 "PABORT", // pci abort 2617 "OCERR", // risc instruction error 2618 "SCERR", // syncronisation error 2619 }; 2620 2621 static void bttv_print_irqbits(u32 print, u32 mark) 2622 { 2623 unsigned int i; 2624 2625 pr_cont("bits:"); 2626 for (i = 0; i < ARRAY_SIZE(irq_name); i++) { 2627 if (print & (1 << i)) 2628 pr_cont(" %s", irq_name[i]); 2629 if (mark & (1 << i)) 2630 pr_cont("*"); 2631 } 2632 } 2633 2634 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc) 2635 { 2636 pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n", 2637 btv->c.nr, 2638 (unsigned long)btv->main.dma, 2639 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]), 2640 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]), 2641 (unsigned long)rc); 2642 2643 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) { 2644 pr_notice("%d: Oh, there (temporarily?) is no input signal. Ok, then this is harmless, don't worry ;)\n", 2645 btv->c.nr); 2646 return; 2647 } 2648 pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n", 2649 btv->c.nr); 2650 pr_notice("%d: Lets try to catch the culprit red-handed ...\n", 2651 btv->c.nr); 2652 dump_stack(); 2653 } 2654 2655 static int 2656 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set) 2657 { 2658 struct bttv_buffer *item; 2659 2660 memset(set,0,sizeof(*set)); 2661 2662 /* capture request ? */ 2663 if (!list_empty(&btv->capture)) { 2664 set->frame_irq = BT848_RISC_VIDEO; 2665 item = list_entry(btv->capture.next, struct bttv_buffer, list); 2666 2667 if (V4L2_FIELD_HAS_TOP(item->vbuf.field)) 2668 set->top = item; 2669 if (V4L2_FIELD_HAS_BOTTOM(item->vbuf.field)) 2670 set->bottom = item; 2671 2672 /* capture request for other field ? */ 2673 if (!V4L2_FIELD_HAS_BOTH(item->vbuf.field) && 2674 item->list.next != &btv->capture) { 2675 item = list_entry(item->list.next, 2676 struct bttv_buffer, list); 2677 /* Mike Isely <isely@pobox.com> - Only check 2678 * and set up the bottom field in the logic 2679 * below. Don't ever do the top field. This 2680 * of course means that if we set up the 2681 * bottom field in the above code that we'll 2682 * actually skip a field. But that's OK. 2683 * Having processed only a single buffer this 2684 * time, then the next time around the first 2685 * available buffer should be for a top field. 2686 * That will then cause us here to set up a 2687 * top then a bottom field in the normal way. 2688 * The alternative to this understanding is 2689 * that we set up the second available buffer 2690 * as a top field, but that's out of order 2691 * since this driver always processes the top 2692 * field first - the effect will be the two 2693 * buffers being returned in the wrong order, 2694 * with the second buffer also being delayed 2695 * by one field time (owing to the fifo nature 2696 * of videobuf). Worse still, we'll be stuck 2697 * doing fields out of order now every time 2698 * until something else causes a field to be 2699 * dropped. By effectively forcing a field to 2700 * drop this way then we always get back into 2701 * sync within a single frame time. (Out of 2702 * order fields can screw up deinterlacing 2703 * algorithms.) */ 2704 if (!V4L2_FIELD_HAS_BOTH(item->vbuf.field)) { 2705 if (!set->bottom && 2706 item->vbuf.field == V4L2_FIELD_BOTTOM) 2707 set->bottom = item; 2708 if (set->top && set->bottom) { 2709 /* 2710 * The buffer set has a top buffer and 2711 * a bottom buffer and they are not 2712 * copies of each other. 2713 */ 2714 set->top_irq = BT848_RISC_TOP; 2715 } 2716 } 2717 } 2718 } 2719 2720 dprintk("%d: next set: top=%p bottom=%p [irq=%d,%d]\n", 2721 btv->c.nr, set->top, set->bottom, 2722 set->frame_irq, set->top_irq); 2723 return 0; 2724 } 2725 2726 static void 2727 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup, 2728 struct bttv_buffer_set *curr, unsigned int state) 2729 { 2730 u64 ts = ktime_get_ns(); 2731 2732 if (wakeup->top == wakeup->bottom) { 2733 if (NULL != wakeup->top && curr->top != wakeup->top) { 2734 if (irq_debug > 1) 2735 pr_debug("%d: wakeup: both=%p\n", 2736 btv->c.nr, wakeup->top); 2737 wakeup->top->vbuf.vb2_buf.timestamp = ts; 2738 wakeup->top->vbuf.sequence = btv->field_count >> 1; 2739 vb2_buffer_done(&wakeup->top->vbuf.vb2_buf, state); 2740 if (btv->field_count == 0) 2741 btor(BT848_INT_VSYNC, BT848_INT_MASK); 2742 } 2743 } else { 2744 if (NULL != wakeup->top && curr->top != wakeup->top) { 2745 if (irq_debug > 1) 2746 pr_debug("%d: wakeup: top=%p\n", 2747 btv->c.nr, wakeup->top); 2748 wakeup->top->vbuf.vb2_buf.timestamp = ts; 2749 wakeup->top->vbuf.sequence = btv->field_count >> 1; 2750 vb2_buffer_done(&wakeup->top->vbuf.vb2_buf, state); 2751 if (btv->field_count == 0) 2752 btor(BT848_INT_VSYNC, BT848_INT_MASK); 2753 } 2754 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) { 2755 if (irq_debug > 1) 2756 pr_debug("%d: wakeup: bottom=%p\n", 2757 btv->c.nr, wakeup->bottom); 2758 wakeup->bottom->vbuf.vb2_buf.timestamp = ts; 2759 wakeup->bottom->vbuf.sequence = btv->field_count >> 1; 2760 vb2_buffer_done(&wakeup->bottom->vbuf.vb2_buf, state); 2761 if (btv->field_count == 0) 2762 btor(BT848_INT_VSYNC, BT848_INT_MASK); 2763 } 2764 } 2765 } 2766 2767 static void 2768 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup, 2769 unsigned int state) 2770 { 2771 if (NULL == wakeup) 2772 return; 2773 wakeup->vbuf.vb2_buf.timestamp = ktime_get_ns(); 2774 wakeup->vbuf.sequence = btv->field_count >> 1; 2775 vb2_buffer_done(&wakeup->vbuf.vb2_buf, state); 2776 if (btv->field_count == 0) 2777 btor(BT848_INT_VSYNC, BT848_INT_MASK); 2778 } 2779 2780 static void bttv_irq_timeout(struct timer_list *t) 2781 { 2782 struct bttv *btv = from_timer(btv, t, timeout); 2783 struct bttv_buffer_set old,new; 2784 struct bttv_buffer *ovbi; 2785 struct bttv_buffer *item; 2786 unsigned long flags; 2787 int seqnr = 0; 2788 2789 if (bttv_verbose) { 2790 pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ", 2791 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total, 2792 btread(BT848_RISC_COUNT)); 2793 bttv_print_irqbits(btread(BT848_INT_STAT),0); 2794 pr_cont("\n"); 2795 } 2796 2797 spin_lock_irqsave(&btv->s_lock,flags); 2798 2799 /* deactivate stuff */ 2800 memset(&new,0,sizeof(new)); 2801 old = btv->curr; 2802 ovbi = btv->cvbi; 2803 btv->curr = new; 2804 btv->cvbi = NULL; 2805 btv->loop_irq = 0; 2806 bttv_buffer_activate_video(btv, &new); 2807 bttv_buffer_activate_vbi(btv, NULL); 2808 bttv_set_dma(btv, 0); 2809 2810 /* wake up */ 2811 bttv_irq_wakeup_video(btv, &old, &new, VB2_BUF_STATE_DONE); 2812 bttv_irq_wakeup_vbi(btv, ovbi, VB2_BUF_STATE_DONE); 2813 2814 /* cancel all outstanding capture / vbi requests */ 2815 if (btv->field_count) 2816 seqnr++; 2817 while (!list_empty(&btv->capture)) { 2818 item = list_entry(btv->capture.next, struct bttv_buffer, list); 2819 list_del(&item->list); 2820 item->vbuf.vb2_buf.timestamp = ktime_get_ns(); 2821 item->vbuf.sequence = (btv->field_count >> 1) + seqnr++; 2822 vb2_buffer_done(&item->vbuf.vb2_buf, VB2_BUF_STATE_ERROR); 2823 } 2824 while (!list_empty(&btv->vcapture)) { 2825 item = list_entry(btv->vcapture.next, struct bttv_buffer, list); 2826 list_del(&item->list); 2827 item->vbuf.vb2_buf.timestamp = ktime_get_ns(); 2828 item->vbuf.sequence = (btv->field_count >> 1) + seqnr++; 2829 vb2_buffer_done(&item->vbuf.vb2_buf, VB2_BUF_STATE_ERROR); 2830 } 2831 2832 btv->errors++; 2833 spin_unlock_irqrestore(&btv->s_lock,flags); 2834 } 2835 2836 static void 2837 bttv_irq_wakeup_top(struct bttv *btv) 2838 { 2839 struct bttv_buffer *wakeup = btv->curr.top; 2840 2841 if (NULL == wakeup) 2842 return; 2843 2844 spin_lock(&btv->s_lock); 2845 btv->curr.top_irq = 0; 2846 btv->curr.top = NULL; 2847 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0); 2848 wakeup->vbuf.vb2_buf.timestamp = ktime_get_ns(); 2849 wakeup->vbuf.sequence = btv->field_count >> 1; 2850 vb2_buffer_done(&wakeup->vbuf.vb2_buf, VB2_BUF_STATE_DONE); 2851 if (btv->field_count == 0) 2852 btor(BT848_INT_VSYNC, BT848_INT_MASK); 2853 spin_unlock(&btv->s_lock); 2854 } 2855 2856 static inline int is_active(struct btcx_riscmem *risc, u32 rc) 2857 { 2858 if (rc < risc->dma) 2859 return 0; 2860 if (rc > risc->dma + risc->size) 2861 return 0; 2862 return 1; 2863 } 2864 2865 static void 2866 bttv_irq_switch_video(struct bttv *btv) 2867 { 2868 struct bttv_buffer_set new; 2869 struct bttv_buffer_set old; 2870 dma_addr_t rc; 2871 2872 spin_lock(&btv->s_lock); 2873 2874 /* new buffer set */ 2875 bttv_irq_next_video(btv, &new); 2876 rc = btread(BT848_RISC_COUNT); 2877 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) || 2878 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) { 2879 btv->framedrop++; 2880 if (debug_latency) 2881 bttv_irq_debug_low_latency(btv, rc); 2882 spin_unlock(&btv->s_lock); 2883 return; 2884 } 2885 2886 /* switch over */ 2887 old = btv->curr; 2888 btv->curr = new; 2889 btv->loop_irq &= ~BT848_RISC_VIDEO; 2890 bttv_buffer_activate_video(btv, &new); 2891 bttv_set_dma(btv, 0); 2892 2893 /* switch input */ 2894 if (UNSET != btv->new_input) { 2895 video_mux(btv,btv->new_input); 2896 btv->new_input = UNSET; 2897 } 2898 2899 /* wake up finished buffers */ 2900 bttv_irq_wakeup_video(btv, &old, &new, VB2_BUF_STATE_DONE); 2901 spin_unlock(&btv->s_lock); 2902 } 2903 2904 static void 2905 bttv_irq_switch_vbi(struct bttv *btv) 2906 { 2907 struct bttv_buffer *new = NULL; 2908 struct bttv_buffer *old; 2909 u32 rc; 2910 2911 spin_lock(&btv->s_lock); 2912 2913 if (!list_empty(&btv->vcapture)) 2914 new = list_entry(btv->vcapture.next, struct bttv_buffer, list); 2915 old = btv->cvbi; 2916 2917 rc = btread(BT848_RISC_COUNT); 2918 if (NULL != old && (is_active(&old->top, rc) || 2919 is_active(&old->bottom, rc))) { 2920 btv->framedrop++; 2921 if (debug_latency) 2922 bttv_irq_debug_low_latency(btv, rc); 2923 spin_unlock(&btv->s_lock); 2924 return; 2925 } 2926 2927 /* switch */ 2928 btv->cvbi = new; 2929 btv->loop_irq &= ~BT848_RISC_VBI; 2930 bttv_buffer_activate_vbi(btv, new); 2931 bttv_set_dma(btv, 0); 2932 2933 bttv_irq_wakeup_vbi(btv, old, VB2_BUF_STATE_DONE); 2934 spin_unlock(&btv->s_lock); 2935 } 2936 2937 static irqreturn_t bttv_irq(int irq, void *dev_id) 2938 { 2939 u32 stat,astat; 2940 u32 dstat; 2941 int count; 2942 struct bttv *btv; 2943 int handled = 0; 2944 2945 btv=(struct bttv *)dev_id; 2946 2947 count=0; 2948 while (1) { 2949 /* get/clear interrupt status bits */ 2950 stat=btread(BT848_INT_STAT); 2951 astat=stat&btread(BT848_INT_MASK); 2952 if (!astat) 2953 break; 2954 handled = 1; 2955 btwrite(stat,BT848_INT_STAT); 2956 2957 /* get device status bits */ 2958 dstat=btread(BT848_DSTATUS); 2959 2960 if (irq_debug) { 2961 pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ", 2962 btv->c.nr, count, btv->field_count, 2963 stat>>28, btread(BT848_RISC_COUNT)); 2964 bttv_print_irqbits(stat,astat); 2965 if (stat & BT848_INT_HLOCK) 2966 pr_cont(" HLOC => %s", 2967 dstat & BT848_DSTATUS_HLOC 2968 ? "yes" : "no"); 2969 if (stat & BT848_INT_VPRES) 2970 pr_cont(" PRES => %s", 2971 dstat & BT848_DSTATUS_PRES 2972 ? "yes" : "no"); 2973 if (stat & BT848_INT_FMTCHG) 2974 pr_cont(" NUML => %s", 2975 dstat & BT848_DSTATUS_NUML 2976 ? "625" : "525"); 2977 pr_cont("\n"); 2978 } 2979 2980 if (astat&BT848_INT_VSYNC) 2981 btv->field_count++; 2982 2983 if ((astat & BT848_INT_GPINT) && btv->remote) { 2984 bttv_input_irq(btv); 2985 } 2986 2987 if (astat & BT848_INT_I2CDONE) { 2988 btv->i2c_done = stat; 2989 wake_up(&btv->i2c_queue); 2990 } 2991 2992 if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_VBI)) 2993 bttv_irq_switch_vbi(btv); 2994 2995 if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_TOP)) 2996 bttv_irq_wakeup_top(btv); 2997 2998 if ((astat & BT848_INT_RISCI) && (stat & BT848_INT_RISCS_VIDEO)) 2999 bttv_irq_switch_video(btv); 3000 3001 if ((astat & BT848_INT_HLOCK) && btv->opt_automute) 3002 /* trigger automute */ 3003 audio_mux_gpio(btv, btv->audio_input, btv->mute); 3004 3005 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) { 3006 pr_info("%d: %s%s @ %08x,", 3007 btv->c.nr, 3008 (astat & BT848_INT_SCERR) ? "SCERR" : "", 3009 (astat & BT848_INT_OCERR) ? "OCERR" : "", 3010 btread(BT848_RISC_COUNT)); 3011 bttv_print_irqbits(stat,astat); 3012 pr_cont("\n"); 3013 if (bttv_debug) 3014 bttv_print_riscaddr(btv); 3015 } 3016 if (fdsr && astat & BT848_INT_FDSR) { 3017 pr_info("%d: FDSR @ %08x\n", 3018 btv->c.nr, btread(BT848_RISC_COUNT)); 3019 if (bttv_debug) 3020 bttv_print_riscaddr(btv); 3021 } 3022 3023 count++; 3024 if (count > 4) { 3025 3026 if (count > 8 || !(astat & BT848_INT_GPINT)) { 3027 btwrite(0, BT848_INT_MASK); 3028 3029 pr_err("%d: IRQ lockup, cleared int mask [", 3030 btv->c.nr); 3031 } else { 3032 pr_err("%d: IRQ lockup, clearing GPINT from int mask [", 3033 btv->c.nr); 3034 3035 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT), 3036 BT848_INT_MASK); 3037 } 3038 3039 bttv_print_irqbits(stat,astat); 3040 3041 pr_cont("]\n"); 3042 } 3043 } 3044 btv->irq_total++; 3045 if (handled) 3046 btv->irq_me++; 3047 return IRQ_RETVAL(handled); 3048 } 3049 3050 3051 /* ----------------------------------------------------------------------- */ 3052 /* initialization */ 3053 3054 static int vdev_init(struct bttv *btv, struct video_device *vfd, 3055 const struct video_device *template, 3056 const char *type_name) 3057 { 3058 int err; 3059 struct vb2_queue *q; 3060 *vfd = *template; 3061 vfd->v4l2_dev = &btv->c.v4l2_dev; 3062 vfd->release = video_device_release_empty; 3063 video_set_drvdata(vfd, btv); 3064 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)", 3065 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "", 3066 type_name, bttv_tvcards[btv->c.type].name); 3067 if (btv->tuner_type == TUNER_ABSENT) { 3068 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY); 3069 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY); 3070 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER); 3071 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER); 3072 } 3073 3074 if (strcmp(type_name, "radio") == 0) 3075 return 0; 3076 3077 if (strcmp(type_name, "video") == 0) { 3078 q = &btv->capq; 3079 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3080 q->ops = &bttv_video_qops; 3081 } else if (strcmp(type_name, "vbi") == 0) { 3082 q = &btv->vbiq; 3083 q->type = V4L2_BUF_TYPE_VBI_CAPTURE; 3084 q->ops = &bttv_vbi_qops; 3085 } else { 3086 return -EINVAL; 3087 } 3088 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 3089 q->io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ | VB2_DMABUF; 3090 q->mem_ops = &vb2_dma_sg_memops; 3091 q->drv_priv = btv; 3092 q->gfp_flags = __GFP_DMA32; 3093 q->buf_struct_size = sizeof(struct bttv_buffer); 3094 q->lock = &btv->lock; 3095 q->min_buffers_needed = 2; 3096 q->dev = &btv->c.pci->dev; 3097 err = vb2_queue_init(q); 3098 if (err) 3099 return err; 3100 vfd->queue = q; 3101 3102 return 0; 3103 } 3104 3105 static void bttv_unregister_video(struct bttv *btv) 3106 { 3107 video_unregister_device(&btv->video_dev); 3108 video_unregister_device(&btv->vbi_dev); 3109 video_unregister_device(&btv->radio_dev); 3110 } 3111 3112 /* register video4linux devices */ 3113 static int bttv_register_video(struct bttv *btv) 3114 { 3115 /* video */ 3116 vdev_init(btv, &btv->video_dev, &bttv_video_template, "video"); 3117 btv->video_dev.device_caps = V4L2_CAP_VIDEO_CAPTURE | 3118 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 3119 if (btv->tuner_type != TUNER_ABSENT) 3120 btv->video_dev.device_caps |= V4L2_CAP_TUNER; 3121 3122 if (video_register_device(&btv->video_dev, VFL_TYPE_VIDEO, 3123 video_nr[btv->c.nr]) < 0) 3124 goto err; 3125 pr_info("%d: registered device %s\n", 3126 btv->c.nr, video_device_node_name(&btv->video_dev)); 3127 if (device_create_file(&btv->video_dev.dev, 3128 &dev_attr_card)<0) { 3129 pr_err("%d: device_create_file 'card' failed\n", btv->c.nr); 3130 goto err; 3131 } 3132 3133 /* vbi */ 3134 vdev_init(btv, &btv->vbi_dev, &bttv_video_template, "vbi"); 3135 btv->vbi_dev.device_caps = V4L2_CAP_VBI_CAPTURE | V4L2_CAP_READWRITE | 3136 V4L2_CAP_STREAMING; 3137 if (btv->tuner_type != TUNER_ABSENT) 3138 btv->vbi_dev.device_caps |= V4L2_CAP_TUNER; 3139 3140 if (video_register_device(&btv->vbi_dev, VFL_TYPE_VBI, 3141 vbi_nr[btv->c.nr]) < 0) 3142 goto err; 3143 pr_info("%d: registered device %s\n", 3144 btv->c.nr, video_device_node_name(&btv->vbi_dev)); 3145 3146 if (!btv->has_radio) 3147 return 0; 3148 /* radio */ 3149 vdev_init(btv, &btv->radio_dev, &radio_template, "radio"); 3150 btv->radio_dev.device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER; 3151 if (btv->has_saa6588) 3152 btv->radio_dev.device_caps |= V4L2_CAP_READWRITE | 3153 V4L2_CAP_RDS_CAPTURE; 3154 if (btv->has_tea575x) 3155 btv->radio_dev.device_caps |= V4L2_CAP_HW_FREQ_SEEK; 3156 btv->radio_dev.ctrl_handler = &btv->radio_ctrl_handler; 3157 if (video_register_device(&btv->radio_dev, VFL_TYPE_RADIO, 3158 radio_nr[btv->c.nr]) < 0) 3159 goto err; 3160 pr_info("%d: registered device %s\n", 3161 btv->c.nr, video_device_node_name(&btv->radio_dev)); 3162 3163 /* all done */ 3164 return 0; 3165 3166 err: 3167 bttv_unregister_video(btv); 3168 return -1; 3169 } 3170 3171 3172 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */ 3173 /* response on cards with no firmware is not enabled by OF */ 3174 static void pci_set_command(struct pci_dev *dev) 3175 { 3176 #if defined(__powerpc__) 3177 unsigned int cmd; 3178 3179 pci_read_config_dword(dev, PCI_COMMAND, &cmd); 3180 cmd = (cmd | PCI_COMMAND_MEMORY ); 3181 pci_write_config_dword(dev, PCI_COMMAND, cmd); 3182 #endif 3183 } 3184 3185 static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id) 3186 { 3187 struct v4l2_frequency init_freq = { 3188 .tuner = 0, 3189 .type = V4L2_TUNER_ANALOG_TV, 3190 .frequency = 980, 3191 }; 3192 int result; 3193 unsigned char lat; 3194 struct bttv *btv; 3195 struct v4l2_ctrl_handler *hdl; 3196 3197 if (bttv_num == BTTV_MAX) 3198 return -ENOMEM; 3199 pr_info("Bt8xx card found (%d)\n", bttv_num); 3200 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL); 3201 if (btv == NULL) { 3202 pr_err("out of memory\n"); 3203 return -ENOMEM; 3204 } 3205 btv->c.nr = bttv_num; 3206 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name), 3207 "bttv%d", btv->c.nr); 3208 3209 /* initialize structs / fill in defaults */ 3210 mutex_init(&btv->lock); 3211 spin_lock_init(&btv->s_lock); 3212 spin_lock_init(&btv->gpio_lock); 3213 init_waitqueue_head(&btv->i2c_queue); 3214 INIT_LIST_HEAD(&btv->c.subs); 3215 INIT_LIST_HEAD(&btv->capture); 3216 INIT_LIST_HEAD(&btv->vcapture); 3217 3218 timer_setup(&btv->timeout, bttv_irq_timeout, 0); 3219 3220 btv->i2c_rc = -1; 3221 btv->tuner_type = UNSET; 3222 btv->new_input = UNSET; 3223 btv->has_radio=radio[btv->c.nr]; 3224 3225 /* pci stuff (init, get irq/mmio, ... */ 3226 btv->c.pci = dev; 3227 btv->id = dev->device; 3228 if (pci_enable_device(dev)) { 3229 pr_warn("%d: Can't enable device\n", btv->c.nr); 3230 result = -EIO; 3231 goto free_mem; 3232 } 3233 if (dma_set_mask(&dev->dev, DMA_BIT_MASK(32))) { 3234 pr_warn("%d: No suitable DMA available\n", btv->c.nr); 3235 result = -EIO; 3236 goto free_mem; 3237 } 3238 if (!request_mem_region(pci_resource_start(dev,0), 3239 pci_resource_len(dev,0), 3240 btv->c.v4l2_dev.name)) { 3241 pr_warn("%d: can't request iomem (0x%llx)\n", 3242 btv->c.nr, 3243 (unsigned long long)pci_resource_start(dev, 0)); 3244 result = -EBUSY; 3245 goto free_mem; 3246 } 3247 pci_set_master(dev); 3248 pci_set_command(dev); 3249 3250 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev); 3251 if (result < 0) { 3252 pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr); 3253 goto fail0; 3254 } 3255 hdl = &btv->ctrl_handler; 3256 v4l2_ctrl_handler_init(hdl, 20); 3257 btv->c.v4l2_dev.ctrl_handler = hdl; 3258 v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6); 3259 3260 btv->revision = dev->revision; 3261 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); 3262 pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n", 3263 bttv_num, btv->id, btv->revision, pci_name(dev), 3264 btv->c.pci->irq, lat, 3265 (unsigned long long)pci_resource_start(dev, 0)); 3266 schedule(); 3267 3268 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000); 3269 if (NULL == btv->bt848_mmio) { 3270 pr_err("%d: ioremap() failed\n", btv->c.nr); 3271 result = -EIO; 3272 goto fail1; 3273 } 3274 3275 /* identify card */ 3276 bttv_idcard(btv); 3277 3278 /* disable irqs, register irq handler */ 3279 btwrite(0, BT848_INT_MASK); 3280 result = request_irq(btv->c.pci->irq, bttv_irq, 3281 IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv); 3282 if (result < 0) { 3283 pr_err("%d: can't get IRQ %d\n", 3284 bttv_num, btv->c.pci->irq); 3285 goto fail1; 3286 } 3287 3288 if (0 != bttv_handle_chipset(btv)) { 3289 result = -EIO; 3290 goto fail2; 3291 } 3292 3293 /* init options from insmod args */ 3294 btv->opt_combfilter = combfilter; 3295 bttv_ctrl_combfilter.def = combfilter; 3296 bttv_ctrl_lumafilter.def = lumafilter; 3297 btv->opt_automute = automute; 3298 bttv_ctrl_automute.def = automute; 3299 bttv_ctrl_agc_crush.def = agc_crush; 3300 btv->opt_vcr_hack = vcr_hack; 3301 bttv_ctrl_vcr_hack.def = vcr_hack; 3302 bttv_ctrl_whitecrush_upper.def = whitecrush_upper; 3303 bttv_ctrl_whitecrush_lower.def = whitecrush_lower; 3304 btv->opt_uv_ratio = uv_ratio; 3305 bttv_ctrl_uv_ratio.def = uv_ratio; 3306 bttv_ctrl_full_luma.def = full_luma_range; 3307 bttv_ctrl_coring.def = coring; 3308 3309 /* fill struct bttv with some useful defaults */ 3310 btv->fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24); 3311 btv->width = 320; 3312 btv->height = 240; 3313 btv->field = V4L2_FIELD_INTERLACED; 3314 btv->input = 0; 3315 btv->tvnorm = 0; /* Index into bttv_tvnorms[] i.e. PAL. */ 3316 bttv_vbi_fmt_reset(&btv->vbi_fmt, btv->tvnorm); 3317 btv->vbi_count[0] = VBI_DEFLINES; 3318 btv->vbi_count[1] = VBI_DEFLINES; 3319 btv->do_crop = 0; 3320 3321 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3322 V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768); 3323 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3324 V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00); 3325 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3326 V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768); 3327 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3328 V4L2_CID_COLOR_KILLER, 0, 1, 1, 0); 3329 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3330 V4L2_CID_HUE, 0, 0xff00, 0x100, 32768); 3331 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3332 V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc); 3333 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3334 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 3335 if (btv->volume_gpio) 3336 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 3337 V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00); 3338 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL); 3339 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL); 3340 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL); 3341 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL); 3342 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL); 3343 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL); 3344 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL); 3345 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL); 3346 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL); 3347 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL); 3348 3349 /* initialize hardware */ 3350 if (bttv_gpio) 3351 bttv_gpio_tracking(btv,"pre-init"); 3352 3353 bttv_risc_init_main(btv); 3354 init_bt848(btv); 3355 3356 /* gpio */ 3357 btwrite(0x00, BT848_GPIO_REG_INP); 3358 btwrite(0x00, BT848_GPIO_OUT_EN); 3359 if (bttv_verbose) 3360 bttv_gpio_tracking(btv,"init"); 3361 3362 /* needs to be done before i2c is registered */ 3363 bttv_init_card1(btv); 3364 3365 /* register i2c + gpio */ 3366 init_bttv_i2c(btv); 3367 3368 /* some card-specific stuff (needs working i2c) */ 3369 bttv_init_card2(btv); 3370 bttv_init_tuner(btv); 3371 if (btv->tuner_type != TUNER_ABSENT) { 3372 bttv_set_frequency(btv, &init_freq); 3373 btv->radio_freq = 90500 * 16; /* 90.5Mhz default */ 3374 } 3375 btv->std = V4L2_STD_PAL; 3376 init_irqreg(btv); 3377 if (!bttv_tvcards[btv->c.type].no_video) 3378 v4l2_ctrl_handler_setup(hdl); 3379 if (hdl->error) { 3380 result = hdl->error; 3381 goto fail2; 3382 } 3383 /* mute device */ 3384 audio_mute(btv, 1); 3385 3386 /* register video4linux + input */ 3387 if (!bttv_tvcards[btv->c.type].no_video) { 3388 v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl, 3389 v4l2_ctrl_radio_filter, false); 3390 if (btv->radio_ctrl_handler.error) { 3391 result = btv->radio_ctrl_handler.error; 3392 goto fail2; 3393 } 3394 set_input(btv, btv->input, btv->tvnorm); 3395 bttv_crop_reset(&btv->crop[0], btv->tvnorm); 3396 btv->crop[1] = btv->crop[0]; /* current = default */ 3397 disclaim_vbi_lines(btv); 3398 disclaim_video_lines(btv); 3399 bttv_register_video(btv); 3400 } 3401 3402 /* add subdevices and autoload dvb-bt8xx if needed */ 3403 if (bttv_tvcards[btv->c.type].has_dvb) { 3404 bttv_sub_add_device(&btv->c, "dvb"); 3405 request_modules(btv); 3406 } 3407 3408 if (!disable_ir) { 3409 init_bttv_i2c_ir(btv); 3410 bttv_input_init(btv); 3411 } 3412 3413 /* everything is fine */ 3414 bttv_num++; 3415 return 0; 3416 3417 fail2: 3418 free_irq(btv->c.pci->irq,btv); 3419 3420 fail1: 3421 v4l2_ctrl_handler_free(&btv->ctrl_handler); 3422 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler); 3423 v4l2_device_unregister(&btv->c.v4l2_dev); 3424 3425 fail0: 3426 if (btv->bt848_mmio) 3427 iounmap(btv->bt848_mmio); 3428 release_mem_region(pci_resource_start(btv->c.pci,0), 3429 pci_resource_len(btv->c.pci,0)); 3430 pci_disable_device(btv->c.pci); 3431 3432 free_mem: 3433 bttvs[btv->c.nr] = NULL; 3434 kfree(btv); 3435 return result; 3436 } 3437 3438 static void bttv_remove(struct pci_dev *pci_dev) 3439 { 3440 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev); 3441 struct bttv *btv = to_bttv(v4l2_dev); 3442 3443 if (bttv_verbose) 3444 pr_info("%d: unloading\n", btv->c.nr); 3445 3446 if (bttv_tvcards[btv->c.type].has_dvb) 3447 flush_request_modules(btv); 3448 3449 /* shutdown everything (DMA+IRQs) */ 3450 btand(~15, BT848_GPIO_DMA_CTL); 3451 btwrite(0, BT848_INT_MASK); 3452 btwrite(~0x0, BT848_INT_STAT); 3453 btwrite(0x0, BT848_GPIO_OUT_EN); 3454 if (bttv_gpio) 3455 bttv_gpio_tracking(btv,"cleanup"); 3456 3457 /* tell gpio modules we are leaving ... */ 3458 btv->shutdown=1; 3459 bttv_input_fini(btv); 3460 bttv_sub_del_devices(&btv->c); 3461 3462 /* unregister i2c_bus + input */ 3463 fini_bttv_i2c(btv); 3464 3465 /* unregister video4linux */ 3466 bttv_unregister_video(btv); 3467 3468 /* free allocated memory */ 3469 v4l2_ctrl_handler_free(&btv->ctrl_handler); 3470 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler); 3471 btcx_riscmem_free(btv->c.pci,&btv->main); 3472 3473 /* free resources */ 3474 free_irq(btv->c.pci->irq,btv); 3475 del_timer_sync(&btv->timeout); 3476 iounmap(btv->bt848_mmio); 3477 release_mem_region(pci_resource_start(btv->c.pci,0), 3478 pci_resource_len(btv->c.pci,0)); 3479 pci_disable_device(btv->c.pci); 3480 3481 v4l2_device_unregister(&btv->c.v4l2_dev); 3482 bttvs[btv->c.nr] = NULL; 3483 kfree(btv); 3484 3485 return; 3486 } 3487 3488 static int __maybe_unused bttv_suspend(struct device *dev) 3489 { 3490 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev); 3491 struct bttv *btv = to_bttv(v4l2_dev); 3492 struct bttv_buffer_set idle; 3493 unsigned long flags; 3494 3495 dprintk("%d: suspend\n", btv->c.nr); 3496 3497 /* stop dma + irqs */ 3498 spin_lock_irqsave(&btv->s_lock,flags); 3499 memset(&idle, 0, sizeof(idle)); 3500 btv->state.video = btv->curr; 3501 btv->state.vbi = btv->cvbi; 3502 btv->state.loop_irq = btv->loop_irq; 3503 btv->curr = idle; 3504 btv->loop_irq = 0; 3505 bttv_buffer_activate_video(btv, &idle); 3506 bttv_buffer_activate_vbi(btv, NULL); 3507 bttv_set_dma(btv, 0); 3508 btwrite(0, BT848_INT_MASK); 3509 spin_unlock_irqrestore(&btv->s_lock,flags); 3510 3511 /* save bt878 state */ 3512 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN); 3513 btv->state.gpio_data = gpio_read(); 3514 3515 btv->state.disabled = 1; 3516 return 0; 3517 } 3518 3519 static int __maybe_unused bttv_resume(struct device *dev) 3520 { 3521 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev); 3522 struct bttv *btv = to_bttv(v4l2_dev); 3523 unsigned long flags; 3524 3525 dprintk("%d: resume\n", btv->c.nr); 3526 3527 btv->state.disabled = 0; 3528 3529 /* restore bt878 state */ 3530 bttv_reinit_bt848(btv); 3531 gpio_inout(0xffffff, btv->state.gpio_enable); 3532 gpio_write(btv->state.gpio_data); 3533 3534 /* restart dma */ 3535 spin_lock_irqsave(&btv->s_lock,flags); 3536 btv->curr = btv->state.video; 3537 btv->cvbi = btv->state.vbi; 3538 btv->loop_irq = btv->state.loop_irq; 3539 bttv_buffer_activate_video(btv, &btv->curr); 3540 bttv_buffer_activate_vbi(btv, btv->cvbi); 3541 bttv_set_dma(btv, 0); 3542 spin_unlock_irqrestore(&btv->s_lock,flags); 3543 return 0; 3544 } 3545 3546 static const struct pci_device_id bttv_pci_tbl[] = { 3547 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0}, 3548 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0}, 3549 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0}, 3550 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0}, 3551 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0}, 3552 {0,} 3553 }; 3554 3555 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl); 3556 3557 static SIMPLE_DEV_PM_OPS(bttv_pm_ops, 3558 bttv_suspend, 3559 bttv_resume); 3560 3561 static struct pci_driver bttv_pci_driver = { 3562 .name = "bttv", 3563 .id_table = bttv_pci_tbl, 3564 .probe = bttv_probe, 3565 .remove = bttv_remove, 3566 .driver.pm = &bttv_pm_ops, 3567 }; 3568 3569 static int __init bttv_init_module(void) 3570 { 3571 int ret; 3572 3573 bttv_num = 0; 3574 3575 pr_info("driver version %s loaded\n", BTTV_VERSION); 3576 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME) 3577 gbuffers = 2; 3578 if (gbufsize > BTTV_MAX_FBUF) 3579 gbufsize = BTTV_MAX_FBUF; 3580 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK; 3581 if (bttv_verbose) 3582 pr_info("using %d buffers with %dk (%d pages) each for capture\n", 3583 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT); 3584 3585 bttv_check_chipset(); 3586 3587 ret = bus_register(&bttv_sub_bus_type); 3588 if (ret < 0) { 3589 pr_warn("bus_register error: %d\n", ret); 3590 return ret; 3591 } 3592 ret = pci_register_driver(&bttv_pci_driver); 3593 if (ret < 0) 3594 bus_unregister(&bttv_sub_bus_type); 3595 3596 return ret; 3597 } 3598 3599 static void __exit bttv_cleanup_module(void) 3600 { 3601 pci_unregister_driver(&bttv_pci_driver); 3602 bus_unregister(&bttv_sub_bus_type); 3603 } 3604 3605 module_init(bttv_init_module); 3606 module_exit(bttv_cleanup_module); 3607