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