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 1535 dprintk("switch_overlay: enter [new=%p]\n", new); 1536 if (new) 1537 new->vb.state = VIDEOBUF_DONE; 1538 spin_lock_irqsave(&btv->s_lock,flags); 1539 old = btv->screen; 1540 btv->screen = new; 1541 btv->loop_irq |= 1; 1542 bttv_set_dma(btv, 0x03); 1543 spin_unlock_irqrestore(&btv->s_lock,flags); 1544 if (NULL != old) { 1545 dprintk("switch_overlay: old=%p state is %d\n", 1546 old, old->vb.state); 1547 bttv_dma_free(&fh->cap,btv, old); 1548 kfree(old); 1549 } 1550 if (NULL == new) 1551 free_btres_lock(btv,fh,RESOURCE_OVERLAY); 1552 dprintk("switch_overlay: done\n"); 1553 return 0; 1554 } 1555 1556 /* ----------------------------------------------------------------------- */ 1557 /* video4linux (1) interface */ 1558 1559 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv, 1560 struct bttv_buffer *buf, 1561 const struct bttv_format *fmt, 1562 unsigned int width, unsigned int height, 1563 enum v4l2_field field) 1564 { 1565 struct bttv_fh *fh = q->priv_data; 1566 int redo_dma_risc = 0; 1567 struct bttv_crop c; 1568 int norm; 1569 int rc; 1570 1571 /* check settings */ 1572 if (NULL == fmt) 1573 return -EINVAL; 1574 if (fmt->btformat == BT848_COLOR_FMT_RAW) { 1575 width = RAW_BPL; 1576 height = RAW_LINES*2; 1577 if (width*height > buf->vb.bsize) 1578 return -EINVAL; 1579 buf->vb.size = buf->vb.bsize; 1580 1581 /* Make sure tvnorm and vbi_end remain consistent 1582 until we're done. */ 1583 1584 norm = btv->tvnorm; 1585 1586 /* In this mode capturing always starts at defrect.top 1587 (default VDELAY), ignoring cropping parameters. */ 1588 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) { 1589 return -EINVAL; 1590 } 1591 1592 c.rect = bttv_tvnorms[norm].cropcap.defrect; 1593 } else { 1594 norm = btv->tvnorm; 1595 c = btv->crop[!!fh->do_crop]; 1596 1597 if (width < c.min_scaled_width || 1598 width > c.max_scaled_width || 1599 height < c.min_scaled_height) 1600 return -EINVAL; 1601 1602 switch (field) { 1603 case V4L2_FIELD_TOP: 1604 case V4L2_FIELD_BOTTOM: 1605 case V4L2_FIELD_ALTERNATE: 1606 /* btv->crop counts frame lines. Max. scale 1607 factor is 16:1 for frames, 8:1 for fields. */ 1608 if (height * 2 > c.max_scaled_height) 1609 return -EINVAL; 1610 break; 1611 1612 default: 1613 if (height > c.max_scaled_height) 1614 return -EINVAL; 1615 break; 1616 } 1617 1618 buf->vb.size = (width * height * fmt->depth) >> 3; 1619 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size) 1620 return -EINVAL; 1621 } 1622 1623 /* alloc + fill struct bttv_buffer (if changed) */ 1624 if (buf->vb.width != width || buf->vb.height != height || 1625 buf->vb.field != field || 1626 buf->tvnorm != norm || buf->fmt != fmt || 1627 buf->crop.top != c.rect.top || 1628 buf->crop.left != c.rect.left || 1629 buf->crop.width != c.rect.width || 1630 buf->crop.height != c.rect.height) { 1631 buf->vb.width = width; 1632 buf->vb.height = height; 1633 buf->vb.field = field; 1634 buf->tvnorm = norm; 1635 buf->fmt = fmt; 1636 buf->crop = c.rect; 1637 redo_dma_risc = 1; 1638 } 1639 1640 /* alloc risc memory */ 1641 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) { 1642 redo_dma_risc = 1; 1643 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf))) 1644 goto fail; 1645 } 1646 1647 if (redo_dma_risc) 1648 if (0 != (rc = bttv_buffer_risc(btv,buf))) 1649 goto fail; 1650 1651 buf->vb.state = VIDEOBUF_PREPARED; 1652 return 0; 1653 1654 fail: 1655 bttv_dma_free(q,btv,buf); 1656 return rc; 1657 } 1658 1659 static int 1660 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size) 1661 { 1662 struct bttv_fh *fh = q->priv_data; 1663 1664 *size = fh->fmt->depth*fh->width*fh->height >> 3; 1665 if (0 == *count) 1666 *count = gbuffers; 1667 if (*size * *count > gbuffers * gbufsize) 1668 *count = (gbuffers * gbufsize) / *size; 1669 return 0; 1670 } 1671 1672 static int 1673 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb, 1674 enum v4l2_field field) 1675 { 1676 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 1677 struct bttv_fh *fh = q->priv_data; 1678 1679 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt, 1680 fh->width, fh->height, field); 1681 } 1682 1683 static void 1684 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb) 1685 { 1686 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 1687 struct bttv_fh *fh = q->priv_data; 1688 struct bttv *btv = fh->btv; 1689 1690 buf->vb.state = VIDEOBUF_QUEUED; 1691 list_add_tail(&buf->vb.queue,&btv->capture); 1692 if (!btv->curr.frame_irq) { 1693 btv->loop_irq |= 1; 1694 bttv_set_dma(btv, 0x03); 1695 } 1696 } 1697 1698 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb) 1699 { 1700 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb); 1701 struct bttv_fh *fh = q->priv_data; 1702 1703 bttv_dma_free(q,fh->btv,buf); 1704 } 1705 1706 static struct videobuf_queue_ops bttv_video_qops = { 1707 .buf_setup = buffer_setup, 1708 .buf_prepare = buffer_prepare, 1709 .buf_queue = buffer_queue, 1710 .buf_release = buffer_release, 1711 }; 1712 1713 static void radio_enable(struct bttv *btv) 1714 { 1715 /* Switch to the radio tuner */ 1716 if (!btv->has_radio_tuner) { 1717 btv->has_radio_tuner = 1; 1718 bttv_call_all(btv, tuner, s_radio); 1719 btv->audio_input = TVAUDIO_INPUT_RADIO; 1720 audio_input(btv, btv->audio_input); 1721 } 1722 } 1723 1724 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id id) 1725 { 1726 struct bttv_fh *fh = priv; 1727 struct bttv *btv = fh->btv; 1728 unsigned int i; 1729 int err = 0; 1730 1731 for (i = 0; i < BTTV_TVNORMS; i++) 1732 if (id & bttv_tvnorms[i].v4l2_id) 1733 break; 1734 if (i == BTTV_TVNORMS) { 1735 err = -EINVAL; 1736 goto err; 1737 } 1738 1739 btv->std = id; 1740 set_tvnorm(btv, i); 1741 1742 err: 1743 1744 return err; 1745 } 1746 1747 static int bttv_g_std(struct file *file, void *priv, v4l2_std_id *id) 1748 { 1749 struct bttv_fh *fh = priv; 1750 struct bttv *btv = fh->btv; 1751 1752 *id = btv->std; 1753 return 0; 1754 } 1755 1756 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id) 1757 { 1758 struct bttv_fh *fh = f; 1759 struct bttv *btv = fh->btv; 1760 1761 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML) 1762 *id &= V4L2_STD_625_50; 1763 else 1764 *id &= V4L2_STD_525_60; 1765 return 0; 1766 } 1767 1768 static int bttv_enum_input(struct file *file, void *priv, 1769 struct v4l2_input *i) 1770 { 1771 struct bttv_fh *fh = priv; 1772 struct bttv *btv = fh->btv; 1773 int rc = 0; 1774 1775 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) { 1776 rc = -EINVAL; 1777 goto err; 1778 } 1779 1780 i->type = V4L2_INPUT_TYPE_CAMERA; 1781 i->audioset = 0; 1782 1783 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) { 1784 sprintf(i->name, "Television"); 1785 i->type = V4L2_INPUT_TYPE_TUNER; 1786 i->tuner = 0; 1787 } else if (i->index == btv->svhs) { 1788 sprintf(i->name, "S-Video"); 1789 } else { 1790 sprintf(i->name, "Composite%d", i->index); 1791 } 1792 1793 if (i->index == btv->input) { 1794 __u32 dstatus = btread(BT848_DSTATUS); 1795 if (0 == (dstatus & BT848_DSTATUS_PRES)) 1796 i->status |= V4L2_IN_ST_NO_SIGNAL; 1797 if (0 == (dstatus & BT848_DSTATUS_HLOC)) 1798 i->status |= V4L2_IN_ST_NO_H_LOCK; 1799 } 1800 1801 i->std = BTTV_NORMS; 1802 1803 err: 1804 1805 return rc; 1806 } 1807 1808 static int bttv_g_input(struct file *file, void *priv, unsigned int *i) 1809 { 1810 struct bttv_fh *fh = priv; 1811 struct bttv *btv = fh->btv; 1812 1813 *i = btv->input; 1814 1815 return 0; 1816 } 1817 1818 static int bttv_s_input(struct file *file, void *priv, unsigned int i) 1819 { 1820 struct bttv_fh *fh = priv; 1821 struct bttv *btv = fh->btv; 1822 1823 if (i >= bttv_tvcards[btv->c.type].video_inputs) 1824 return -EINVAL; 1825 1826 set_input(btv, i, btv->tvnorm); 1827 return 0; 1828 } 1829 1830 static int bttv_s_tuner(struct file *file, void *priv, 1831 const struct v4l2_tuner *t) 1832 { 1833 struct bttv_fh *fh = priv; 1834 struct bttv *btv = fh->btv; 1835 1836 if (t->index) 1837 return -EINVAL; 1838 1839 bttv_call_all(btv, tuner, s_tuner, t); 1840 1841 if (btv->audio_mode_gpio) { 1842 struct v4l2_tuner copy = *t; 1843 1844 btv->audio_mode_gpio(btv, ©, 1); 1845 } 1846 return 0; 1847 } 1848 1849 static int bttv_g_frequency(struct file *file, void *priv, 1850 struct v4l2_frequency *f) 1851 { 1852 struct bttv_fh *fh = priv; 1853 struct bttv *btv = fh->btv; 1854 1855 if (f->tuner) 1856 return -EINVAL; 1857 1858 if (f->type == V4L2_TUNER_RADIO) 1859 radio_enable(btv); 1860 f->frequency = f->type == V4L2_TUNER_RADIO ? 1861 btv->radio_freq : btv->tv_freq; 1862 1863 return 0; 1864 } 1865 1866 static void bttv_set_frequency(struct bttv *btv, const struct v4l2_frequency *f) 1867 { 1868 struct v4l2_frequency new_freq = *f; 1869 1870 bttv_call_all(btv, tuner, s_frequency, f); 1871 /* s_frequency may clamp the frequency, so get the actual 1872 frequency before assigning radio/tv_freq. */ 1873 bttv_call_all(btv, tuner, g_frequency, &new_freq); 1874 if (new_freq.type == V4L2_TUNER_RADIO) { 1875 radio_enable(btv); 1876 btv->radio_freq = new_freq.frequency; 1877 if (btv->has_tea575x) { 1878 btv->tea.freq = btv->radio_freq; 1879 snd_tea575x_set_freq(&btv->tea); 1880 } 1881 } else { 1882 btv->tv_freq = new_freq.frequency; 1883 } 1884 } 1885 1886 static int bttv_s_frequency(struct file *file, void *priv, 1887 const struct v4l2_frequency *f) 1888 { 1889 struct bttv_fh *fh = priv; 1890 struct bttv *btv = fh->btv; 1891 1892 if (f->tuner) 1893 return -EINVAL; 1894 1895 bttv_set_frequency(btv, f); 1896 return 0; 1897 } 1898 1899 static int bttv_log_status(struct file *file, void *f) 1900 { 1901 struct video_device *vdev = video_devdata(file); 1902 struct bttv_fh *fh = f; 1903 struct bttv *btv = fh->btv; 1904 1905 v4l2_ctrl_handler_log_status(vdev->ctrl_handler, btv->c.v4l2_dev.name); 1906 bttv_call_all(btv, core, log_status); 1907 return 0; 1908 } 1909 1910 #ifdef CONFIG_VIDEO_ADV_DEBUG 1911 static int bttv_g_register(struct file *file, void *f, 1912 struct v4l2_dbg_register *reg) 1913 { 1914 struct bttv_fh *fh = f; 1915 struct bttv *btv = fh->btv; 1916 1917 /* bt848 has a 12-bit register space */ 1918 reg->reg &= 0xfff; 1919 reg->val = btread(reg->reg); 1920 reg->size = 1; 1921 1922 return 0; 1923 } 1924 1925 static int bttv_s_register(struct file *file, void *f, 1926 const struct v4l2_dbg_register *reg) 1927 { 1928 struct bttv_fh *fh = f; 1929 struct bttv *btv = fh->btv; 1930 1931 /* bt848 has a 12-bit register space */ 1932 btwrite(reg->val, reg->reg & 0xfff); 1933 1934 return 0; 1935 } 1936 #endif 1937 1938 /* Given cropping boundaries b and the scaled width and height of a 1939 single field or frame, which must not exceed hardware limits, this 1940 function adjusts the cropping parameters c. */ 1941 static void 1942 bttv_crop_adjust (struct bttv_crop * c, 1943 const struct v4l2_rect * b, 1944 __s32 width, 1945 __s32 height, 1946 enum v4l2_field field) 1947 { 1948 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field); 1949 __s32 max_left; 1950 __s32 max_top; 1951 1952 if (width < c->min_scaled_width) { 1953 /* Max. hor. scale factor 16:1. */ 1954 c->rect.width = width * 16; 1955 } else if (width > c->max_scaled_width) { 1956 /* Min. hor. scale factor 1:1. */ 1957 c->rect.width = width; 1958 1959 max_left = b->left + b->width - width; 1960 max_left = min(max_left, (__s32) MAX_HDELAY); 1961 if (c->rect.left > max_left) 1962 c->rect.left = max_left; 1963 } 1964 1965 if (height < c->min_scaled_height) { 1966 /* Max. vert. scale factor 16:1, single fields 8:1. */ 1967 c->rect.height = height * 16; 1968 } else if (frame_height > c->max_scaled_height) { 1969 /* Min. vert. scale factor 1:1. 1970 Top and height count field lines times two. */ 1971 c->rect.height = (frame_height + 1) & ~1; 1972 1973 max_top = b->top + b->height - c->rect.height; 1974 if (c->rect.top > max_top) 1975 c->rect.top = max_top; 1976 } 1977 1978 bttv_crop_calc_limits(c); 1979 } 1980 1981 /* Returns an error if scaling to a frame or single field with the given 1982 width and height is not possible with the current cropping parameters 1983 and width aligned according to width_mask. If adjust_size is TRUE the 1984 function may adjust the width and/or height instead, rounding width 1985 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may 1986 also adjust the current cropping parameters to get closer to the 1987 desired image size. */ 1988 static int 1989 limit_scaled_size_lock (struct bttv_fh * fh, 1990 __s32 * width, 1991 __s32 * height, 1992 enum v4l2_field field, 1993 unsigned int width_mask, 1994 unsigned int width_bias, 1995 int adjust_size, 1996 int adjust_crop) 1997 { 1998 struct bttv *btv = fh->btv; 1999 const struct v4l2_rect *b; 2000 struct bttv_crop *c; 2001 __s32 min_width; 2002 __s32 min_height; 2003 __s32 max_width; 2004 __s32 max_height; 2005 int rc; 2006 2007 BUG_ON((int) width_mask >= 0 || 2008 width_bias >= (unsigned int) -width_mask); 2009 2010 /* Make sure tvnorm, vbi_end and the current cropping parameters 2011 remain consistent until we're done. */ 2012 2013 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2014 2015 /* Do crop - use current, don't - use default parameters. */ 2016 c = &btv->crop[!!fh->do_crop]; 2017 2018 if (fh->do_crop 2019 && adjust_size 2020 && adjust_crop 2021 && !locked_btres(btv, VIDEO_RESOURCES)) { 2022 min_width = 48; 2023 min_height = 32; 2024 2025 /* We cannot scale up. When the scaled image is larger 2026 than crop.rect we adjust the crop.rect as required 2027 by the V4L2 spec, hence cropcap.bounds are our limit. */ 2028 max_width = min_t(unsigned int, b->width, MAX_HACTIVE); 2029 max_height = b->height; 2030 2031 /* We cannot capture the same line as video and VBI data. 2032 Note btv->vbi_end is really a minimum, see 2033 bttv_vbi_try_fmt(). */ 2034 if (btv->vbi_end > b->top) { 2035 max_height -= btv->vbi_end - b->top; 2036 rc = -EBUSY; 2037 if (min_height > max_height) 2038 goto fail; 2039 } 2040 } else { 2041 rc = -EBUSY; 2042 if (btv->vbi_end > c->rect.top) 2043 goto fail; 2044 2045 min_width = c->min_scaled_width; 2046 min_height = c->min_scaled_height; 2047 max_width = c->max_scaled_width; 2048 max_height = c->max_scaled_height; 2049 2050 adjust_crop = 0; 2051 } 2052 2053 min_width = (min_width - width_mask - 1) & width_mask; 2054 max_width = max_width & width_mask; 2055 2056 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */ 2057 min_height = min_height; 2058 /* Min. scale factor is 1:1. */ 2059 max_height >>= !V4L2_FIELD_HAS_BOTH(field); 2060 2061 if (adjust_size) { 2062 *width = clamp(*width, min_width, max_width); 2063 *height = clamp(*height, min_height, max_height); 2064 2065 /* Round after clamping to avoid overflow. */ 2066 *width = (*width + width_bias) & width_mask; 2067 2068 if (adjust_crop) { 2069 bttv_crop_adjust(c, b, *width, *height, field); 2070 2071 if (btv->vbi_end > c->rect.top) { 2072 /* Move the crop window out of the way. */ 2073 c->rect.top = btv->vbi_end; 2074 } 2075 } 2076 } else { 2077 rc = -EINVAL; 2078 if (*width < min_width || 2079 *height < min_height || 2080 *width > max_width || 2081 *height > max_height || 2082 0 != (*width & ~width_mask)) 2083 goto fail; 2084 } 2085 2086 rc = 0; /* success */ 2087 2088 fail: 2089 2090 return rc; 2091 } 2092 2093 /* Returns an error if the given overlay window dimensions are not 2094 possible with the current cropping parameters. If adjust_size is 2095 TRUE the function may adjust the window width and/or height 2096 instead, however it always rounds the horizontal position and 2097 width as btcx_align() does. If adjust_crop is TRUE the function 2098 may also adjust the current cropping parameters to get closer 2099 to the desired window size. */ 2100 static int 2101 verify_window_lock(struct bttv_fh *fh, struct v4l2_window *win, 2102 int adjust_size, int adjust_crop) 2103 { 2104 enum v4l2_field field; 2105 unsigned int width_mask; 2106 int rc; 2107 2108 if (win->w.width < 48) 2109 win->w.width = 48; 2110 if (win->w.height < 32) 2111 win->w.height = 32; 2112 if (win->clipcount > 2048) 2113 win->clipcount = 2048; 2114 2115 win->chromakey = 0; 2116 win->global_alpha = 0; 2117 field = win->field; 2118 2119 switch (field) { 2120 case V4L2_FIELD_TOP: 2121 case V4L2_FIELD_BOTTOM: 2122 case V4L2_FIELD_INTERLACED: 2123 break; 2124 default: 2125 field = V4L2_FIELD_ANY; 2126 break; 2127 } 2128 if (V4L2_FIELD_ANY == field) { 2129 __s32 height2; 2130 2131 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1; 2132 field = (win->w.height > height2) 2133 ? V4L2_FIELD_INTERLACED 2134 : V4L2_FIELD_TOP; 2135 } 2136 win->field = field; 2137 2138 if (NULL == fh->ovfmt) 2139 return -EINVAL; 2140 /* 4-byte alignment. */ 2141 width_mask = ~0; 2142 switch (fh->ovfmt->depth) { 2143 case 8: 2144 case 24: 2145 width_mask = ~3; 2146 break; 2147 case 16: 2148 width_mask = ~1; 2149 break; 2150 case 32: 2151 break; 2152 default: 2153 BUG(); 2154 } 2155 2156 win->w.width -= win->w.left & ~width_mask; 2157 win->w.left = (win->w.left - width_mask - 1) & width_mask; 2158 2159 rc = limit_scaled_size_lock(fh, &win->w.width, &win->w.height, 2160 field, width_mask, 2161 /* width_bias: round down */ 0, 2162 adjust_size, adjust_crop); 2163 if (0 != rc) 2164 return rc; 2165 return 0; 2166 } 2167 2168 static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv, 2169 struct v4l2_window *win, int fixup) 2170 { 2171 struct v4l2_clip *clips = NULL; 2172 int n,size,retval = 0; 2173 2174 if (NULL == fh->ovfmt) 2175 return -EINVAL; 2176 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED)) 2177 return -EINVAL; 2178 retval = verify_window_lock(fh, win, 2179 /* adjust_size */ fixup, 2180 /* adjust_crop */ fixup); 2181 if (0 != retval) 2182 return retval; 2183 2184 /* copy clips -- luckily v4l1 + v4l2 are binary 2185 compatible here ...*/ 2186 n = win->clipcount; 2187 size = sizeof(*clips)*(n+4); 2188 clips = kmalloc(size,GFP_KERNEL); 2189 if (NULL == clips) 2190 return -ENOMEM; 2191 if (n > 0) { 2192 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) { 2193 kfree(clips); 2194 return -EFAULT; 2195 } 2196 } 2197 2198 /* clip against screen */ 2199 if (NULL != btv->fbuf.base) 2200 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height, 2201 &win->w, clips, n); 2202 btcx_sort_clips(clips,n); 2203 2204 /* 4-byte alignments */ 2205 switch (fh->ovfmt->depth) { 2206 case 8: 2207 case 24: 2208 btcx_align(&win->w, clips, n, 3); 2209 break; 2210 case 16: 2211 btcx_align(&win->w, clips, n, 1); 2212 break; 2213 case 32: 2214 /* no alignment fixups needed */ 2215 break; 2216 default: 2217 BUG(); 2218 } 2219 2220 kfree(fh->ov.clips); 2221 fh->ov.clips = clips; 2222 fh->ov.nclips = n; 2223 2224 fh->ov.w = win->w; 2225 fh->ov.field = win->field; 2226 fh->ov.setup_ok = 1; 2227 2228 btv->init.ov.w.width = win->w.width; 2229 btv->init.ov.w.height = win->w.height; 2230 btv->init.ov.field = win->field; 2231 2232 /* update overlay if needed */ 2233 retval = 0; 2234 if (check_btres(fh, RESOURCE_OVERLAY)) { 2235 struct bttv_buffer *new; 2236 2237 new = videobuf_sg_alloc(sizeof(*new)); 2238 new->crop = btv->crop[!!fh->do_crop].rect; 2239 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new); 2240 retval = bttv_switch_overlay(btv,fh,new); 2241 } 2242 return retval; 2243 } 2244 2245 /* ----------------------------------------------------------------------- */ 2246 2247 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh) 2248 { 2249 struct videobuf_queue* q = NULL; 2250 2251 switch (fh->type) { 2252 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2253 q = &fh->cap; 2254 break; 2255 case V4L2_BUF_TYPE_VBI_CAPTURE: 2256 q = &fh->vbi; 2257 break; 2258 default: 2259 BUG(); 2260 } 2261 return q; 2262 } 2263 2264 static int bttv_resource(struct bttv_fh *fh) 2265 { 2266 int res = 0; 2267 2268 switch (fh->type) { 2269 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2270 res = RESOURCE_VIDEO_STREAM; 2271 break; 2272 case V4L2_BUF_TYPE_VBI_CAPTURE: 2273 res = RESOURCE_VBI; 2274 break; 2275 default: 2276 BUG(); 2277 } 2278 return res; 2279 } 2280 2281 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type) 2282 { 2283 struct videobuf_queue *q = bttv_queue(fh); 2284 int res = bttv_resource(fh); 2285 2286 if (check_btres(fh,res)) 2287 return -EBUSY; 2288 if (videobuf_queue_is_busy(q)) 2289 return -EBUSY; 2290 fh->type = type; 2291 return 0; 2292 } 2293 2294 static void 2295 pix_format_set_size (struct v4l2_pix_format * f, 2296 const struct bttv_format * fmt, 2297 unsigned int width, 2298 unsigned int height) 2299 { 2300 f->width = width; 2301 f->height = height; 2302 2303 if (fmt->flags & FORMAT_FLAGS_PLANAR) { 2304 f->bytesperline = width; /* Y plane */ 2305 f->sizeimage = (width * height * fmt->depth) >> 3; 2306 } else { 2307 f->bytesperline = (width * fmt->depth) >> 3; 2308 f->sizeimage = height * f->bytesperline; 2309 } 2310 } 2311 2312 static int bttv_g_fmt_vid_cap(struct file *file, void *priv, 2313 struct v4l2_format *f) 2314 { 2315 struct bttv_fh *fh = priv; 2316 2317 pix_format_set_size(&f->fmt.pix, fh->fmt, 2318 fh->width, fh->height); 2319 f->fmt.pix.field = fh->cap.field; 2320 f->fmt.pix.pixelformat = fh->fmt->fourcc; 2321 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 2322 2323 return 0; 2324 } 2325 2326 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv, 2327 struct v4l2_format *f) 2328 { 2329 struct bttv_fh *fh = priv; 2330 2331 f->fmt.win.w = fh->ov.w; 2332 f->fmt.win.field = fh->ov.field; 2333 2334 return 0; 2335 } 2336 2337 static int bttv_try_fmt_vid_cap(struct file *file, void *priv, 2338 struct v4l2_format *f) 2339 { 2340 const struct bttv_format *fmt; 2341 struct bttv_fh *fh = priv; 2342 struct bttv *btv = fh->btv; 2343 enum v4l2_field field; 2344 __s32 width, height; 2345 __s32 height2; 2346 int rc; 2347 2348 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2349 if (NULL == fmt) 2350 return -EINVAL; 2351 2352 field = f->fmt.pix.field; 2353 2354 switch (field) { 2355 case V4L2_FIELD_TOP: 2356 case V4L2_FIELD_BOTTOM: 2357 case V4L2_FIELD_ALTERNATE: 2358 case V4L2_FIELD_INTERLACED: 2359 break; 2360 case V4L2_FIELD_SEQ_BT: 2361 case V4L2_FIELD_SEQ_TB: 2362 if (!(fmt->flags & FORMAT_FLAGS_PLANAR)) { 2363 field = V4L2_FIELD_SEQ_TB; 2364 break; 2365 } 2366 /* fall through */ 2367 default: /* FIELD_ANY case */ 2368 height2 = btv->crop[!!fh->do_crop].rect.height >> 1; 2369 field = (f->fmt.pix.height > height2) 2370 ? V4L2_FIELD_INTERLACED 2371 : V4L2_FIELD_BOTTOM; 2372 break; 2373 } 2374 2375 width = f->fmt.pix.width; 2376 height = f->fmt.pix.height; 2377 2378 rc = limit_scaled_size_lock(fh, &width, &height, field, 2379 /* width_mask: 4 pixels */ ~3, 2380 /* width_bias: nearest */ 2, 2381 /* adjust_size */ 1, 2382 /* adjust_crop */ 0); 2383 if (0 != rc) 2384 return rc; 2385 2386 /* update data for the application */ 2387 f->fmt.pix.field = field; 2388 pix_format_set_size(&f->fmt.pix, fmt, width, height); 2389 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 2390 2391 return 0; 2392 } 2393 2394 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv, 2395 struct v4l2_format *f) 2396 { 2397 struct bttv_fh *fh = priv; 2398 2399 verify_window_lock(fh, &f->fmt.win, 2400 /* adjust_size */ 1, 2401 /* adjust_crop */ 0); 2402 return 0; 2403 } 2404 2405 static int bttv_s_fmt_vid_cap(struct file *file, void *priv, 2406 struct v4l2_format *f) 2407 { 2408 int retval; 2409 const struct bttv_format *fmt; 2410 struct bttv_fh *fh = priv; 2411 struct bttv *btv = fh->btv; 2412 __s32 width, height; 2413 enum v4l2_field field; 2414 2415 retval = bttv_switch_type(fh, f->type); 2416 if (0 != retval) 2417 return retval; 2418 2419 retval = bttv_try_fmt_vid_cap(file, priv, f); 2420 if (0 != retval) 2421 return retval; 2422 2423 width = f->fmt.pix.width; 2424 height = f->fmt.pix.height; 2425 field = f->fmt.pix.field; 2426 2427 retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field, 2428 /* width_mask: 4 pixels */ ~3, 2429 /* width_bias: nearest */ 2, 2430 /* adjust_size */ 1, 2431 /* adjust_crop */ 1); 2432 if (0 != retval) 2433 return retval; 2434 2435 f->fmt.pix.field = field; 2436 2437 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2438 2439 /* update our state informations */ 2440 fh->fmt = fmt; 2441 fh->cap.field = f->fmt.pix.field; 2442 fh->cap.last = V4L2_FIELD_NONE; 2443 fh->width = f->fmt.pix.width; 2444 fh->height = f->fmt.pix.height; 2445 btv->init.fmt = fmt; 2446 btv->init.width = f->fmt.pix.width; 2447 btv->init.height = f->fmt.pix.height; 2448 2449 return 0; 2450 } 2451 2452 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv, 2453 struct v4l2_format *f) 2454 { 2455 struct bttv_fh *fh = priv; 2456 struct bttv *btv = fh->btv; 2457 2458 if (no_overlay > 0) { 2459 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n"); 2460 return -EINVAL; 2461 } 2462 2463 return setup_window_lock(fh, btv, &f->fmt.win, 1); 2464 } 2465 2466 static int bttv_querycap(struct file *file, void *priv, 2467 struct v4l2_capability *cap) 2468 { 2469 struct video_device *vdev = video_devdata(file); 2470 struct bttv_fh *fh = priv; 2471 struct bttv *btv = fh->btv; 2472 2473 if (0 == v4l2) 2474 return -EINVAL; 2475 2476 strlcpy(cap->driver, "bttv", sizeof(cap->driver)); 2477 strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card)); 2478 snprintf(cap->bus_info, sizeof(cap->bus_info), 2479 "PCI:%s", pci_name(btv->c.pci)); 2480 cap->capabilities = 2481 V4L2_CAP_VIDEO_CAPTURE | 2482 V4L2_CAP_READWRITE | 2483 V4L2_CAP_STREAMING | 2484 V4L2_CAP_DEVICE_CAPS; 2485 if (no_overlay <= 0) 2486 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY; 2487 if (btv->vbi_dev) 2488 cap->capabilities |= V4L2_CAP_VBI_CAPTURE; 2489 if (btv->radio_dev) 2490 cap->capabilities |= V4L2_CAP_RADIO; 2491 2492 /* 2493 * No need to lock here: those vars are initialized during board 2494 * probe and remains untouched during the rest of the driver lifecycle 2495 */ 2496 if (btv->has_saa6588) 2497 cap->capabilities |= V4L2_CAP_RDS_CAPTURE; 2498 if (btv->tuner_type != TUNER_ABSENT) 2499 cap->capabilities |= V4L2_CAP_TUNER; 2500 if (vdev->vfl_type == VFL_TYPE_GRABBER) 2501 cap->device_caps = cap->capabilities & 2502 (V4L2_CAP_VIDEO_CAPTURE | 2503 V4L2_CAP_READWRITE | 2504 V4L2_CAP_STREAMING | 2505 V4L2_CAP_VIDEO_OVERLAY | 2506 V4L2_CAP_TUNER); 2507 else if (vdev->vfl_type == VFL_TYPE_VBI) 2508 cap->device_caps = cap->capabilities & 2509 (V4L2_CAP_VBI_CAPTURE | 2510 V4L2_CAP_READWRITE | 2511 V4L2_CAP_STREAMING | 2512 V4L2_CAP_TUNER); 2513 else { 2514 cap->device_caps = V4L2_CAP_RADIO | V4L2_CAP_TUNER; 2515 if (btv->has_saa6588) 2516 cap->device_caps |= V4L2_CAP_READWRITE | 2517 V4L2_CAP_RDS_CAPTURE; 2518 if (btv->has_tea575x) 2519 cap->device_caps |= V4L2_CAP_HW_FREQ_SEEK; 2520 } 2521 return 0; 2522 } 2523 2524 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f) 2525 { 2526 int index = -1, i; 2527 2528 for (i = 0; i < FORMATS; i++) { 2529 if (formats[i].fourcc != -1) 2530 index++; 2531 if ((unsigned int)index == f->index) 2532 break; 2533 } 2534 if (FORMATS == i) 2535 return -EINVAL; 2536 2537 f->pixelformat = formats[i].fourcc; 2538 strlcpy(f->description, formats[i].name, sizeof(f->description)); 2539 2540 return i; 2541 } 2542 2543 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv, 2544 struct v4l2_fmtdesc *f) 2545 { 2546 int rc = bttv_enum_fmt_cap_ovr(f); 2547 2548 if (rc < 0) 2549 return rc; 2550 2551 return 0; 2552 } 2553 2554 static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv, 2555 struct v4l2_fmtdesc *f) 2556 { 2557 int rc; 2558 2559 if (no_overlay > 0) { 2560 pr_err("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n"); 2561 return -EINVAL; 2562 } 2563 2564 rc = bttv_enum_fmt_cap_ovr(f); 2565 2566 if (rc < 0) 2567 return rc; 2568 2569 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED)) 2570 return -EINVAL; 2571 2572 return 0; 2573 } 2574 2575 static int bttv_g_fbuf(struct file *file, void *f, 2576 struct v4l2_framebuffer *fb) 2577 { 2578 struct bttv_fh *fh = f; 2579 struct bttv *btv = fh->btv; 2580 2581 *fb = btv->fbuf; 2582 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING; 2583 fb->flags = V4L2_FBUF_FLAG_PRIMARY; 2584 if (fh->ovfmt) 2585 fb->fmt.pixelformat = fh->ovfmt->fourcc; 2586 return 0; 2587 } 2588 2589 static int bttv_overlay(struct file *file, void *f, unsigned int on) 2590 { 2591 struct bttv_fh *fh = f; 2592 struct bttv *btv = fh->btv; 2593 struct bttv_buffer *new; 2594 int retval = 0; 2595 2596 if (on) { 2597 /* verify args */ 2598 if (unlikely(!btv->fbuf.base)) { 2599 return -EINVAL; 2600 } 2601 if (unlikely(!fh->ov.setup_ok)) { 2602 dprintk("%d: overlay: !setup_ok\n", btv->c.nr); 2603 retval = -EINVAL; 2604 } 2605 if (retval) 2606 return retval; 2607 } 2608 2609 if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY)) 2610 return -EBUSY; 2611 2612 if (on) { 2613 fh->ov.tvnorm = btv->tvnorm; 2614 new = videobuf_sg_alloc(sizeof(*new)); 2615 new->crop = btv->crop[!!fh->do_crop].rect; 2616 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new); 2617 } else { 2618 new = NULL; 2619 } 2620 2621 /* switch over */ 2622 retval = bttv_switch_overlay(btv, fh, new); 2623 return retval; 2624 } 2625 2626 static int bttv_s_fbuf(struct file *file, void *f, 2627 const struct v4l2_framebuffer *fb) 2628 { 2629 struct bttv_fh *fh = f; 2630 struct bttv *btv = fh->btv; 2631 const struct bttv_format *fmt; 2632 int retval; 2633 2634 if (!capable(CAP_SYS_ADMIN) && 2635 !capable(CAP_SYS_RAWIO)) 2636 return -EPERM; 2637 2638 /* check args */ 2639 fmt = format_by_fourcc(fb->fmt.pixelformat); 2640 if (NULL == fmt) 2641 return -EINVAL; 2642 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED)) 2643 return -EINVAL; 2644 2645 retval = -EINVAL; 2646 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) { 2647 __s32 width = fb->fmt.width; 2648 __s32 height = fb->fmt.height; 2649 2650 retval = limit_scaled_size_lock(fh, &width, &height, 2651 V4L2_FIELD_INTERLACED, 2652 /* width_mask */ ~3, 2653 /* width_bias */ 2, 2654 /* adjust_size */ 0, 2655 /* adjust_crop */ 0); 2656 if (0 != retval) 2657 return retval; 2658 } 2659 2660 /* ok, accept it */ 2661 btv->fbuf.base = fb->base; 2662 btv->fbuf.fmt.width = fb->fmt.width; 2663 btv->fbuf.fmt.height = fb->fmt.height; 2664 if (0 != fb->fmt.bytesperline) 2665 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline; 2666 else 2667 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8; 2668 2669 retval = 0; 2670 fh->ovfmt = fmt; 2671 btv->init.ovfmt = fmt; 2672 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) { 2673 fh->ov.w.left = 0; 2674 fh->ov.w.top = 0; 2675 fh->ov.w.width = fb->fmt.width; 2676 fh->ov.w.height = fb->fmt.height; 2677 btv->init.ov.w.width = fb->fmt.width; 2678 btv->init.ov.w.height = fb->fmt.height; 2679 kfree(fh->ov.clips); 2680 fh->ov.clips = NULL; 2681 fh->ov.nclips = 0; 2682 2683 if (check_btres(fh, RESOURCE_OVERLAY)) { 2684 struct bttv_buffer *new; 2685 2686 new = videobuf_sg_alloc(sizeof(*new)); 2687 new->crop = btv->crop[!!fh->do_crop].rect; 2688 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new); 2689 retval = bttv_switch_overlay(btv, fh, new); 2690 } 2691 } 2692 return retval; 2693 } 2694 2695 static int bttv_reqbufs(struct file *file, void *priv, 2696 struct v4l2_requestbuffers *p) 2697 { 2698 struct bttv_fh *fh = priv; 2699 return videobuf_reqbufs(bttv_queue(fh), p); 2700 } 2701 2702 static int bttv_querybuf(struct file *file, void *priv, 2703 struct v4l2_buffer *b) 2704 { 2705 struct bttv_fh *fh = priv; 2706 return videobuf_querybuf(bttv_queue(fh), b); 2707 } 2708 2709 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2710 { 2711 struct bttv_fh *fh = priv; 2712 struct bttv *btv = fh->btv; 2713 int res = bttv_resource(fh); 2714 2715 if (!check_alloc_btres_lock(btv, fh, res)) 2716 return -EBUSY; 2717 2718 return videobuf_qbuf(bttv_queue(fh), b); 2719 } 2720 2721 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b) 2722 { 2723 struct bttv_fh *fh = priv; 2724 return videobuf_dqbuf(bttv_queue(fh), b, 2725 file->f_flags & O_NONBLOCK); 2726 } 2727 2728 static int bttv_streamon(struct file *file, void *priv, 2729 enum v4l2_buf_type type) 2730 { 2731 struct bttv_fh *fh = priv; 2732 struct bttv *btv = fh->btv; 2733 int res = bttv_resource(fh); 2734 2735 if (!check_alloc_btres_lock(btv, fh, res)) 2736 return -EBUSY; 2737 return videobuf_streamon(bttv_queue(fh)); 2738 } 2739 2740 2741 static int bttv_streamoff(struct file *file, void *priv, 2742 enum v4l2_buf_type type) 2743 { 2744 struct bttv_fh *fh = priv; 2745 struct bttv *btv = fh->btv; 2746 int retval; 2747 int res = bttv_resource(fh); 2748 2749 2750 retval = videobuf_streamoff(bttv_queue(fh)); 2751 if (retval < 0) 2752 return retval; 2753 free_btres_lock(btv, fh, res); 2754 return 0; 2755 } 2756 2757 static int bttv_g_parm(struct file *file, void *f, 2758 struct v4l2_streamparm *parm) 2759 { 2760 struct bttv_fh *fh = f; 2761 struct bttv *btv = fh->btv; 2762 2763 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2764 return -EINVAL; 2765 parm->parm.capture.readbuffers = gbuffers; 2766 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id, 2767 &parm->parm.capture.timeperframe); 2768 2769 return 0; 2770 } 2771 2772 static int bttv_g_tuner(struct file *file, void *priv, 2773 struct v4l2_tuner *t) 2774 { 2775 struct bttv_fh *fh = priv; 2776 struct bttv *btv = fh->btv; 2777 2778 if (0 != t->index) 2779 return -EINVAL; 2780 2781 t->rxsubchans = V4L2_TUNER_SUB_MONO; 2782 t->capability = V4L2_TUNER_CAP_NORM; 2783 bttv_call_all(btv, tuner, g_tuner, t); 2784 strcpy(t->name, "Television"); 2785 t->type = V4L2_TUNER_ANALOG_TV; 2786 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) 2787 t->signal = 0xffff; 2788 2789 if (btv->audio_mode_gpio) 2790 btv->audio_mode_gpio(btv, t, 0); 2791 2792 return 0; 2793 } 2794 2795 static int bttv_cropcap(struct file *file, void *priv, 2796 struct v4l2_cropcap *cap) 2797 { 2798 struct bttv_fh *fh = priv; 2799 struct bttv *btv = fh->btv; 2800 2801 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 2802 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 2803 return -EINVAL; 2804 2805 *cap = bttv_tvnorms[btv->tvnorm].cropcap; 2806 2807 return 0; 2808 } 2809 2810 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop) 2811 { 2812 struct bttv_fh *fh = f; 2813 struct bttv *btv = fh->btv; 2814 2815 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 2816 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 2817 return -EINVAL; 2818 2819 /* No fh->do_crop = 1; because btv->crop[1] may be 2820 inconsistent with fh->width or fh->height and apps 2821 do not expect a change here. */ 2822 2823 crop->c = btv->crop[!!fh->do_crop].rect; 2824 2825 return 0; 2826 } 2827 2828 static int bttv_s_crop(struct file *file, void *f, const struct v4l2_crop *crop) 2829 { 2830 struct bttv_fh *fh = f; 2831 struct bttv *btv = fh->btv; 2832 const struct v4l2_rect *b; 2833 int retval; 2834 struct bttv_crop c; 2835 __s32 b_left; 2836 __s32 b_top; 2837 __s32 b_right; 2838 __s32 b_bottom; 2839 2840 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 2841 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 2842 return -EINVAL; 2843 2844 /* Make sure tvnorm, vbi_end and the current cropping 2845 parameters remain consistent until we're done. Note 2846 read() may change vbi_end in check_alloc_btres_lock(). */ 2847 retval = -EBUSY; 2848 2849 if (locked_btres(fh->btv, VIDEO_RESOURCES)) { 2850 return retval; 2851 } 2852 2853 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2854 2855 b_left = b->left; 2856 b_right = b_left + b->width; 2857 b_bottom = b->top + b->height; 2858 2859 b_top = max(b->top, btv->vbi_end); 2860 if (b_top + 32 >= b_bottom) { 2861 return retval; 2862 } 2863 2864 /* Min. scaled size 48 x 32. */ 2865 c.rect.left = clamp_t(s32, crop->c.left, b_left, b_right - 48); 2866 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY); 2867 2868 c.rect.width = clamp_t(s32, crop->c.width, 2869 48, b_right - c.rect.left); 2870 2871 c.rect.top = clamp_t(s32, crop->c.top, b_top, b_bottom - 32); 2872 /* Top and height must be a multiple of two. */ 2873 c.rect.top = (c.rect.top + 1) & ~1; 2874 2875 c.rect.height = clamp_t(s32, crop->c.height, 2876 32, b_bottom - c.rect.top); 2877 c.rect.height = (c.rect.height + 1) & ~1; 2878 2879 bttv_crop_calc_limits(&c); 2880 2881 btv->crop[1] = c; 2882 2883 fh->do_crop = 1; 2884 2885 if (fh->width < c.min_scaled_width) { 2886 fh->width = c.min_scaled_width; 2887 btv->init.width = c.min_scaled_width; 2888 } else if (fh->width > c.max_scaled_width) { 2889 fh->width = c.max_scaled_width; 2890 btv->init.width = c.max_scaled_width; 2891 } 2892 2893 if (fh->height < c.min_scaled_height) { 2894 fh->height = c.min_scaled_height; 2895 btv->init.height = c.min_scaled_height; 2896 } else if (fh->height > c.max_scaled_height) { 2897 fh->height = c.max_scaled_height; 2898 btv->init.height = c.max_scaled_height; 2899 } 2900 2901 return 0; 2902 } 2903 2904 static ssize_t bttv_read(struct file *file, char __user *data, 2905 size_t count, loff_t *ppos) 2906 { 2907 struct bttv_fh *fh = file->private_data; 2908 int retval = 0; 2909 2910 if (fh->btv->errors) 2911 bttv_reinit_bt848(fh->btv); 2912 dprintk("%d: read count=%d type=%s\n", 2913 fh->btv->c.nr, (int)count, v4l2_type_names[fh->type]); 2914 2915 switch (fh->type) { 2916 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 2917 if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) { 2918 /* VIDEO_READ in use by another fh, 2919 or VIDEO_STREAM by any fh. */ 2920 return -EBUSY; 2921 } 2922 retval = videobuf_read_one(&fh->cap, data, count, ppos, 2923 file->f_flags & O_NONBLOCK); 2924 free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ); 2925 break; 2926 case V4L2_BUF_TYPE_VBI_CAPTURE: 2927 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI)) 2928 return -EBUSY; 2929 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1, 2930 file->f_flags & O_NONBLOCK); 2931 break; 2932 default: 2933 BUG(); 2934 } 2935 return retval; 2936 } 2937 2938 static unsigned int bttv_poll(struct file *file, poll_table *wait) 2939 { 2940 struct bttv_fh *fh = file->private_data; 2941 struct bttv_buffer *buf; 2942 enum v4l2_field field; 2943 unsigned int rc = 0; 2944 unsigned long req_events = poll_requested_events(wait); 2945 2946 if (v4l2_event_pending(&fh->fh)) 2947 rc = POLLPRI; 2948 else if (req_events & POLLPRI) 2949 poll_wait(file, &fh->fh.wait, wait); 2950 2951 if (!(req_events & (POLLIN | POLLRDNORM))) 2952 return rc; 2953 2954 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) { 2955 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI)) 2956 return rc | POLLERR; 2957 return rc | videobuf_poll_stream(file, &fh->vbi, wait); 2958 } 2959 2960 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) { 2961 /* streaming capture */ 2962 if (list_empty(&fh->cap.stream)) 2963 return rc | POLLERR; 2964 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream); 2965 } else { 2966 /* read() capture */ 2967 if (NULL == fh->cap.read_buf) { 2968 /* need to capture a new frame */ 2969 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM)) 2970 return rc | POLLERR; 2971 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize); 2972 if (NULL == fh->cap.read_buf) 2973 return rc | POLLERR; 2974 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR; 2975 field = videobuf_next_field(&fh->cap); 2976 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) { 2977 kfree (fh->cap.read_buf); 2978 fh->cap.read_buf = NULL; 2979 return rc | POLLERR; 2980 } 2981 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf); 2982 fh->cap.read_off = 0; 2983 } 2984 buf = (struct bttv_buffer*)fh->cap.read_buf; 2985 } 2986 2987 poll_wait(file, &buf->vb.done, wait); 2988 if (buf->vb.state == VIDEOBUF_DONE || 2989 buf->vb.state == VIDEOBUF_ERROR) 2990 rc = rc | POLLIN|POLLRDNORM; 2991 return rc; 2992 } 2993 2994 static int bttv_open(struct file *file) 2995 { 2996 struct video_device *vdev = video_devdata(file); 2997 struct bttv *btv = video_drvdata(file); 2998 struct bttv_fh *fh; 2999 enum v4l2_buf_type type = 0; 3000 3001 dprintk("open dev=%s\n", video_device_node_name(vdev)); 3002 3003 if (vdev->vfl_type == VFL_TYPE_GRABBER) { 3004 type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3005 } else if (vdev->vfl_type == VFL_TYPE_VBI) { 3006 type = V4L2_BUF_TYPE_VBI_CAPTURE; 3007 } else { 3008 WARN_ON(1); 3009 return -ENODEV; 3010 } 3011 3012 dprintk("%d: open called (type=%s)\n", 3013 btv->c.nr, v4l2_type_names[type]); 3014 3015 /* allocate per filehandle data */ 3016 fh = kmalloc(sizeof(*fh), GFP_KERNEL); 3017 if (unlikely(!fh)) 3018 return -ENOMEM; 3019 btv->users++; 3020 file->private_data = fh; 3021 3022 *fh = btv->init; 3023 v4l2_fh_init(&fh->fh, vdev); 3024 3025 fh->type = type; 3026 fh->ov.setup_ok = 0; 3027 3028 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops, 3029 &btv->c.pci->dev, &btv->s_lock, 3030 V4L2_BUF_TYPE_VIDEO_CAPTURE, 3031 V4L2_FIELD_INTERLACED, 3032 sizeof(struct bttv_buffer), 3033 fh, &btv->lock); 3034 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops, 3035 &btv->c.pci->dev, &btv->s_lock, 3036 V4L2_BUF_TYPE_VBI_CAPTURE, 3037 V4L2_FIELD_SEQ_TB, 3038 sizeof(struct bttv_buffer), 3039 fh, &btv->lock); 3040 set_tvnorm(btv,btv->tvnorm); 3041 set_input(btv, btv->input, btv->tvnorm); 3042 audio_mute(btv, btv->mute); 3043 3044 /* The V4L2 spec requires one global set of cropping parameters 3045 which only change on request. These are stored in btv->crop[1]. 3046 However for compatibility with V4L apps and cropping unaware 3047 V4L2 apps we now reset the cropping parameters as seen through 3048 this fh, which is to say VIDIOC_G_CROP and scaling limit checks 3049 will use btv->crop[0], the default cropping parameters for the 3050 current video standard, and VIDIOC_S_FMT will not implicitely 3051 change the cropping parameters until VIDIOC_S_CROP has been 3052 called. */ 3053 fh->do_crop = !reset_crop; /* module parameter */ 3054 3055 /* Likewise there should be one global set of VBI capture 3056 parameters, but for compatibility with V4L apps and earlier 3057 driver versions each fh has its own parameters. */ 3058 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm); 3059 3060 bttv_field_count(btv); 3061 v4l2_fh_add(&fh->fh); 3062 return 0; 3063 } 3064 3065 static int bttv_release(struct file *file) 3066 { 3067 struct bttv_fh *fh = file->private_data; 3068 struct bttv *btv = fh->btv; 3069 3070 /* turn off overlay */ 3071 if (check_btres(fh, RESOURCE_OVERLAY)) 3072 bttv_switch_overlay(btv,fh,NULL); 3073 3074 /* stop video capture */ 3075 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) { 3076 videobuf_streamoff(&fh->cap); 3077 free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM); 3078 } 3079 if (fh->cap.read_buf) { 3080 buffer_release(&fh->cap,fh->cap.read_buf); 3081 kfree(fh->cap.read_buf); 3082 } 3083 if (check_btres(fh, RESOURCE_VIDEO_READ)) { 3084 free_btres_lock(btv, fh, RESOURCE_VIDEO_READ); 3085 } 3086 3087 /* stop vbi capture */ 3088 if (check_btres(fh, RESOURCE_VBI)) { 3089 videobuf_stop(&fh->vbi); 3090 free_btres_lock(btv,fh,RESOURCE_VBI); 3091 } 3092 3093 /* free stuff */ 3094 3095 videobuf_mmap_free(&fh->cap); 3096 videobuf_mmap_free(&fh->vbi); 3097 file->private_data = NULL; 3098 3099 btv->users--; 3100 bttv_field_count(btv); 3101 3102 if (!btv->users) 3103 audio_mute(btv, btv->mute); 3104 3105 v4l2_fh_del(&fh->fh); 3106 v4l2_fh_exit(&fh->fh); 3107 kfree(fh); 3108 return 0; 3109 } 3110 3111 static int 3112 bttv_mmap(struct file *file, struct vm_area_struct *vma) 3113 { 3114 struct bttv_fh *fh = file->private_data; 3115 3116 dprintk("%d: mmap type=%s 0x%lx+%ld\n", 3117 fh->btv->c.nr, v4l2_type_names[fh->type], 3118 vma->vm_start, vma->vm_end - vma->vm_start); 3119 return videobuf_mmap_mapper(bttv_queue(fh),vma); 3120 } 3121 3122 static const struct v4l2_file_operations bttv_fops = 3123 { 3124 .owner = THIS_MODULE, 3125 .open = bttv_open, 3126 .release = bttv_release, 3127 .unlocked_ioctl = video_ioctl2, 3128 .read = bttv_read, 3129 .mmap = bttv_mmap, 3130 .poll = bttv_poll, 3131 }; 3132 3133 static const struct v4l2_ioctl_ops bttv_ioctl_ops = { 3134 .vidioc_querycap = bttv_querycap, 3135 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap, 3136 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap, 3137 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap, 3138 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap, 3139 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay, 3140 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay, 3141 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay, 3142 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay, 3143 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap, 3144 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap, 3145 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap, 3146 .vidioc_cropcap = bttv_cropcap, 3147 .vidioc_reqbufs = bttv_reqbufs, 3148 .vidioc_querybuf = bttv_querybuf, 3149 .vidioc_qbuf = bttv_qbuf, 3150 .vidioc_dqbuf = bttv_dqbuf, 3151 .vidioc_s_std = bttv_s_std, 3152 .vidioc_g_std = bttv_g_std, 3153 .vidioc_enum_input = bttv_enum_input, 3154 .vidioc_g_input = bttv_g_input, 3155 .vidioc_s_input = bttv_s_input, 3156 .vidioc_streamon = bttv_streamon, 3157 .vidioc_streamoff = bttv_streamoff, 3158 .vidioc_g_tuner = bttv_g_tuner, 3159 .vidioc_s_tuner = bttv_s_tuner, 3160 .vidioc_g_crop = bttv_g_crop, 3161 .vidioc_s_crop = bttv_s_crop, 3162 .vidioc_g_fbuf = bttv_g_fbuf, 3163 .vidioc_s_fbuf = bttv_s_fbuf, 3164 .vidioc_overlay = bttv_overlay, 3165 .vidioc_g_parm = bttv_g_parm, 3166 .vidioc_g_frequency = bttv_g_frequency, 3167 .vidioc_s_frequency = bttv_s_frequency, 3168 .vidioc_log_status = bttv_log_status, 3169 .vidioc_querystd = bttv_querystd, 3170 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 3171 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 3172 #ifdef CONFIG_VIDEO_ADV_DEBUG 3173 .vidioc_g_register = bttv_g_register, 3174 .vidioc_s_register = bttv_s_register, 3175 #endif 3176 }; 3177 3178 static struct video_device bttv_video_template = { 3179 .fops = &bttv_fops, 3180 .ioctl_ops = &bttv_ioctl_ops, 3181 .tvnorms = BTTV_NORMS, 3182 }; 3183 3184 /* ----------------------------------------------------------------------- */ 3185 /* radio interface */ 3186 3187 static int radio_open(struct file *file) 3188 { 3189 struct video_device *vdev = video_devdata(file); 3190 struct bttv *btv = video_drvdata(file); 3191 struct bttv_fh *fh; 3192 3193 dprintk("open dev=%s\n", video_device_node_name(vdev)); 3194 3195 dprintk("%d: open called (radio)\n", btv->c.nr); 3196 3197 /* allocate per filehandle data */ 3198 fh = kmalloc(sizeof(*fh), GFP_KERNEL); 3199 if (unlikely(!fh)) 3200 return -ENOMEM; 3201 file->private_data = fh; 3202 *fh = btv->init; 3203 v4l2_fh_init(&fh->fh, vdev); 3204 3205 btv->radio_user++; 3206 audio_mute(btv, btv->mute); 3207 3208 v4l2_fh_add(&fh->fh); 3209 3210 return 0; 3211 } 3212 3213 static int radio_release(struct file *file) 3214 { 3215 struct bttv_fh *fh = file->private_data; 3216 struct bttv *btv = fh->btv; 3217 struct saa6588_command cmd; 3218 3219 file->private_data = NULL; 3220 v4l2_fh_del(&fh->fh); 3221 v4l2_fh_exit(&fh->fh); 3222 kfree(fh); 3223 3224 btv->radio_user--; 3225 3226 bttv_call_all(btv, core, ioctl, SAA6588_CMD_CLOSE, &cmd); 3227 3228 if (btv->radio_user == 0) 3229 btv->has_radio_tuner = 0; 3230 return 0; 3231 } 3232 3233 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t) 3234 { 3235 struct bttv_fh *fh = priv; 3236 struct bttv *btv = fh->btv; 3237 3238 if (0 != t->index) 3239 return -EINVAL; 3240 strcpy(t->name, "Radio"); 3241 t->type = V4L2_TUNER_RADIO; 3242 radio_enable(btv); 3243 3244 bttv_call_all(btv, tuner, g_tuner, t); 3245 3246 if (btv->audio_mode_gpio) 3247 btv->audio_mode_gpio(btv, t, 0); 3248 3249 if (btv->has_tea575x) 3250 return snd_tea575x_g_tuner(&btv->tea, t); 3251 3252 return 0; 3253 } 3254 3255 static int radio_s_tuner(struct file *file, void *priv, 3256 const struct v4l2_tuner *t) 3257 { 3258 struct bttv_fh *fh = priv; 3259 struct bttv *btv = fh->btv; 3260 3261 if (0 != t->index) 3262 return -EINVAL; 3263 3264 radio_enable(btv); 3265 bttv_call_all(btv, tuner, s_tuner, t); 3266 return 0; 3267 } 3268 3269 static int radio_s_hw_freq_seek(struct file *file, void *priv, 3270 const struct v4l2_hw_freq_seek *a) 3271 { 3272 struct bttv_fh *fh = priv; 3273 struct bttv *btv = fh->btv; 3274 3275 if (btv->has_tea575x) 3276 return snd_tea575x_s_hw_freq_seek(file, &btv->tea, a); 3277 3278 return -ENOTTY; 3279 } 3280 3281 static int radio_enum_freq_bands(struct file *file, void *priv, 3282 struct v4l2_frequency_band *band) 3283 { 3284 struct bttv_fh *fh = priv; 3285 struct bttv *btv = fh->btv; 3286 3287 if (btv->has_tea575x) 3288 return snd_tea575x_enum_freq_bands(&btv->tea, band); 3289 3290 return -ENOTTY; 3291 } 3292 3293 static ssize_t radio_read(struct file *file, char __user *data, 3294 size_t count, loff_t *ppos) 3295 { 3296 struct bttv_fh *fh = file->private_data; 3297 struct bttv *btv = fh->btv; 3298 struct saa6588_command cmd; 3299 3300 cmd.block_count = count / 3; 3301 cmd.nonblocking = file->f_flags & O_NONBLOCK; 3302 cmd.buffer = data; 3303 cmd.instance = file; 3304 cmd.result = -ENODEV; 3305 radio_enable(btv); 3306 3307 bttv_call_all(btv, core, ioctl, SAA6588_CMD_READ, &cmd); 3308 3309 return cmd.result; 3310 } 3311 3312 static unsigned int radio_poll(struct file *file, poll_table *wait) 3313 { 3314 struct bttv_fh *fh = file->private_data; 3315 struct bttv *btv = fh->btv; 3316 unsigned long req_events = poll_requested_events(wait); 3317 struct saa6588_command cmd; 3318 unsigned int res = 0; 3319 3320 if (v4l2_event_pending(&fh->fh)) 3321 res = POLLPRI; 3322 else if (req_events & POLLPRI) 3323 poll_wait(file, &fh->fh.wait, wait); 3324 radio_enable(btv); 3325 cmd.instance = file; 3326 cmd.event_list = wait; 3327 cmd.result = res; 3328 bttv_call_all(btv, core, ioctl, SAA6588_CMD_POLL, &cmd); 3329 3330 return cmd.result; 3331 } 3332 3333 static const struct v4l2_file_operations radio_fops = 3334 { 3335 .owner = THIS_MODULE, 3336 .open = radio_open, 3337 .read = radio_read, 3338 .release = radio_release, 3339 .unlocked_ioctl = video_ioctl2, 3340 .poll = radio_poll, 3341 }; 3342 3343 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 3344 .vidioc_querycap = bttv_querycap, 3345 .vidioc_log_status = bttv_log_status, 3346 .vidioc_g_tuner = radio_g_tuner, 3347 .vidioc_s_tuner = radio_s_tuner, 3348 .vidioc_g_frequency = bttv_g_frequency, 3349 .vidioc_s_frequency = bttv_s_frequency, 3350 .vidioc_s_hw_freq_seek = radio_s_hw_freq_seek, 3351 .vidioc_enum_freq_bands = radio_enum_freq_bands, 3352 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 3353 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 3354 }; 3355 3356 static struct video_device radio_template = { 3357 .fops = &radio_fops, 3358 .ioctl_ops = &radio_ioctl_ops, 3359 }; 3360 3361 /* ----------------------------------------------------------------------- */ 3362 /* some debug code */ 3363 3364 static int bttv_risc_decode(u32 risc) 3365 { 3366 static char *instr[16] = { 3367 [ BT848_RISC_WRITE >> 28 ] = "write", 3368 [ BT848_RISC_SKIP >> 28 ] = "skip", 3369 [ BT848_RISC_WRITEC >> 28 ] = "writec", 3370 [ BT848_RISC_JUMP >> 28 ] = "jump", 3371 [ BT848_RISC_SYNC >> 28 ] = "sync", 3372 [ BT848_RISC_WRITE123 >> 28 ] = "write123", 3373 [ BT848_RISC_SKIP123 >> 28 ] = "skip123", 3374 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23", 3375 }; 3376 static int incr[16] = { 3377 [ BT848_RISC_WRITE >> 28 ] = 2, 3378 [ BT848_RISC_JUMP >> 28 ] = 2, 3379 [ BT848_RISC_SYNC >> 28 ] = 2, 3380 [ BT848_RISC_WRITE123 >> 28 ] = 5, 3381 [ BT848_RISC_SKIP123 >> 28 ] = 2, 3382 [ BT848_RISC_WRITE1S23 >> 28 ] = 3, 3383 }; 3384 static char *bits[] = { 3385 "be0", "be1", "be2", "be3/resync", 3386 "set0", "set1", "set2", "set3", 3387 "clr0", "clr1", "clr2", "clr3", 3388 "irq", "res", "eol", "sol", 3389 }; 3390 int i; 3391 3392 pr_cont("0x%08x [ %s", risc, 3393 instr[risc >> 28] ? instr[risc >> 28] : "INVALID"); 3394 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--) 3395 if (risc & (1 << (i + 12))) 3396 pr_cont(" %s", bits[i]); 3397 pr_cont(" count=%d ]\n", risc & 0xfff); 3398 return incr[risc >> 28] ? incr[risc >> 28] : 1; 3399 } 3400 3401 static void bttv_risc_disasm(struct bttv *btv, 3402 struct btcx_riscmem *risc) 3403 { 3404 unsigned int i,j,n; 3405 3406 pr_info("%s: risc disasm: %p [dma=0x%08lx]\n", 3407 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma); 3408 for (i = 0; i < (risc->size >> 2); i += n) { 3409 pr_info("%s: 0x%lx: ", 3410 btv->c.v4l2_dev.name, 3411 (unsigned long)(risc->dma + (i<<2))); 3412 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i])); 3413 for (j = 1; j < n; j++) 3414 pr_info("%s: 0x%lx: 0x%08x [ arg #%d ]\n", 3415 btv->c.v4l2_dev.name, 3416 (unsigned long)(risc->dma + ((i+j)<<2)), 3417 risc->cpu[i+j], j); 3418 if (0 == risc->cpu[i]) 3419 break; 3420 } 3421 } 3422 3423 static void bttv_print_riscaddr(struct bttv *btv) 3424 { 3425 pr_info(" main: %08llx\n", (unsigned long long)btv->main.dma); 3426 pr_info(" vbi : o=%08llx e=%08llx\n", 3427 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0, 3428 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0); 3429 pr_info(" cap : o=%08llx e=%08llx\n", 3430 btv->curr.top 3431 ? (unsigned long long)btv->curr.top->top.dma : 0, 3432 btv->curr.bottom 3433 ? (unsigned long long)btv->curr.bottom->bottom.dma : 0); 3434 pr_info(" scr : o=%08llx e=%08llx\n", 3435 btv->screen ? (unsigned long long)btv->screen->top.dma : 0, 3436 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0); 3437 bttv_risc_disasm(btv, &btv->main); 3438 } 3439 3440 /* ----------------------------------------------------------------------- */ 3441 /* irq handler */ 3442 3443 static char *irq_name[] = { 3444 "FMTCHG", // format change detected (525 vs. 625) 3445 "VSYNC", // vertical sync (new field) 3446 "HSYNC", // horizontal sync 3447 "OFLOW", // chroma/luma AGC overflow 3448 "HLOCK", // horizontal lock changed 3449 "VPRES", // video presence changed 3450 "6", "7", 3451 "I2CDONE", // hw irc operation finished 3452 "GPINT", // gpio port triggered irq 3453 "10", 3454 "RISCI", // risc instruction triggered irq 3455 "FBUS", // pixel data fifo dropped data (high pci bus latencies) 3456 "FTRGT", // pixel data fifo overrun 3457 "FDSR", // fifo data stream resyncronisation 3458 "PPERR", // parity error (data transfer) 3459 "RIPERR", // parity error (read risc instructions) 3460 "PABORT", // pci abort 3461 "OCERR", // risc instruction error 3462 "SCERR", // syncronisation error 3463 }; 3464 3465 static void bttv_print_irqbits(u32 print, u32 mark) 3466 { 3467 unsigned int i; 3468 3469 pr_cont("bits:"); 3470 for (i = 0; i < ARRAY_SIZE(irq_name); i++) { 3471 if (print & (1 << i)) 3472 pr_cont(" %s", irq_name[i]); 3473 if (mark & (1 << i)) 3474 pr_cont("*"); 3475 } 3476 } 3477 3478 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc) 3479 { 3480 pr_warn("%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n", 3481 btv->c.nr, 3482 (unsigned long)btv->main.dma, 3483 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]), 3484 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]), 3485 (unsigned long)rc); 3486 3487 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) { 3488 pr_notice("%d: Oh, there (temporarily?) is no input signal. " 3489 "Ok, then this is harmless, don't worry ;)\n", 3490 btv->c.nr); 3491 return; 3492 } 3493 pr_notice("%d: Uhm. Looks like we have unusual high IRQ latencies\n", 3494 btv->c.nr); 3495 pr_notice("%d: Lets try to catch the culpit red-handed ...\n", 3496 btv->c.nr); 3497 dump_stack(); 3498 } 3499 3500 static int 3501 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set) 3502 { 3503 struct bttv_buffer *item; 3504 3505 memset(set,0,sizeof(*set)); 3506 3507 /* capture request ? */ 3508 if (!list_empty(&btv->capture)) { 3509 set->frame_irq = 1; 3510 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue); 3511 if (V4L2_FIELD_HAS_TOP(item->vb.field)) 3512 set->top = item; 3513 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field)) 3514 set->bottom = item; 3515 3516 /* capture request for other field ? */ 3517 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) && 3518 (item->vb.queue.next != &btv->capture)) { 3519 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue); 3520 /* Mike Isely <isely@pobox.com> - Only check 3521 * and set up the bottom field in the logic 3522 * below. Don't ever do the top field. This 3523 * of course means that if we set up the 3524 * bottom field in the above code that we'll 3525 * actually skip a field. But that's OK. 3526 * Having processed only a single buffer this 3527 * time, then the next time around the first 3528 * available buffer should be for a top field. 3529 * That will then cause us here to set up a 3530 * top then a bottom field in the normal way. 3531 * The alternative to this understanding is 3532 * that we set up the second available buffer 3533 * as a top field, but that's out of order 3534 * since this driver always processes the top 3535 * field first - the effect will be the two 3536 * buffers being returned in the wrong order, 3537 * with the second buffer also being delayed 3538 * by one field time (owing to the fifo nature 3539 * of videobuf). Worse still, we'll be stuck 3540 * doing fields out of order now every time 3541 * until something else causes a field to be 3542 * dropped. By effectively forcing a field to 3543 * drop this way then we always get back into 3544 * sync within a single frame time. (Out of 3545 * order fields can screw up deinterlacing 3546 * algorithms.) */ 3547 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) { 3548 if (NULL == set->bottom && 3549 V4L2_FIELD_BOTTOM == item->vb.field) { 3550 set->bottom = item; 3551 } 3552 if (NULL != set->top && NULL != set->bottom) 3553 set->top_irq = 2; 3554 } 3555 } 3556 } 3557 3558 /* screen overlay ? */ 3559 if (NULL != btv->screen) { 3560 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) { 3561 if (NULL == set->top && NULL == set->bottom) { 3562 set->top = btv->screen; 3563 set->bottom = btv->screen; 3564 } 3565 } else { 3566 if (V4L2_FIELD_TOP == btv->screen->vb.field && 3567 NULL == set->top) { 3568 set->top = btv->screen; 3569 } 3570 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field && 3571 NULL == set->bottom) { 3572 set->bottom = btv->screen; 3573 } 3574 } 3575 } 3576 3577 dprintk("%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n", 3578 btv->c.nr, set->top, set->bottom, 3579 btv->screen, set->frame_irq, set->top_irq); 3580 return 0; 3581 } 3582 3583 static void 3584 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup, 3585 struct bttv_buffer_set *curr, unsigned int state) 3586 { 3587 struct timeval ts; 3588 3589 v4l2_get_timestamp(&ts); 3590 3591 if (wakeup->top == wakeup->bottom) { 3592 if (NULL != wakeup->top && curr->top != wakeup->top) { 3593 if (irq_debug > 1) 3594 pr_debug("%d: wakeup: both=%p\n", 3595 btv->c.nr, wakeup->top); 3596 wakeup->top->vb.ts = ts; 3597 wakeup->top->vb.field_count = btv->field_count; 3598 wakeup->top->vb.state = state; 3599 wake_up(&wakeup->top->vb.done); 3600 } 3601 } else { 3602 if (NULL != wakeup->top && curr->top != wakeup->top) { 3603 if (irq_debug > 1) 3604 pr_debug("%d: wakeup: top=%p\n", 3605 btv->c.nr, wakeup->top); 3606 wakeup->top->vb.ts = ts; 3607 wakeup->top->vb.field_count = btv->field_count; 3608 wakeup->top->vb.state = state; 3609 wake_up(&wakeup->top->vb.done); 3610 } 3611 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) { 3612 if (irq_debug > 1) 3613 pr_debug("%d: wakeup: bottom=%p\n", 3614 btv->c.nr, wakeup->bottom); 3615 wakeup->bottom->vb.ts = ts; 3616 wakeup->bottom->vb.field_count = btv->field_count; 3617 wakeup->bottom->vb.state = state; 3618 wake_up(&wakeup->bottom->vb.done); 3619 } 3620 } 3621 } 3622 3623 static void 3624 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup, 3625 unsigned int state) 3626 { 3627 struct timeval ts; 3628 3629 if (NULL == wakeup) 3630 return; 3631 3632 v4l2_get_timestamp(&ts); 3633 wakeup->vb.ts = ts; 3634 wakeup->vb.field_count = btv->field_count; 3635 wakeup->vb.state = state; 3636 wake_up(&wakeup->vb.done); 3637 } 3638 3639 static void bttv_irq_timeout(unsigned long data) 3640 { 3641 struct bttv *btv = (struct bttv *)data; 3642 struct bttv_buffer_set old,new; 3643 struct bttv_buffer *ovbi; 3644 struct bttv_buffer *item; 3645 unsigned long flags; 3646 3647 if (bttv_verbose) { 3648 pr_info("%d: timeout: drop=%d irq=%d/%d, risc=%08x, ", 3649 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total, 3650 btread(BT848_RISC_COUNT)); 3651 bttv_print_irqbits(btread(BT848_INT_STAT),0); 3652 pr_cont("\n"); 3653 } 3654 3655 spin_lock_irqsave(&btv->s_lock,flags); 3656 3657 /* deactivate stuff */ 3658 memset(&new,0,sizeof(new)); 3659 old = btv->curr; 3660 ovbi = btv->cvbi; 3661 btv->curr = new; 3662 btv->cvbi = NULL; 3663 btv->loop_irq = 0; 3664 bttv_buffer_activate_video(btv, &new); 3665 bttv_buffer_activate_vbi(btv, NULL); 3666 bttv_set_dma(btv, 0); 3667 3668 /* wake up */ 3669 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR); 3670 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR); 3671 3672 /* cancel all outstanding capture / vbi requests */ 3673 while (!list_empty(&btv->capture)) { 3674 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue); 3675 list_del(&item->vb.queue); 3676 item->vb.state = VIDEOBUF_ERROR; 3677 wake_up(&item->vb.done); 3678 } 3679 while (!list_empty(&btv->vcapture)) { 3680 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue); 3681 list_del(&item->vb.queue); 3682 item->vb.state = VIDEOBUF_ERROR; 3683 wake_up(&item->vb.done); 3684 } 3685 3686 btv->errors++; 3687 spin_unlock_irqrestore(&btv->s_lock,flags); 3688 } 3689 3690 static void 3691 bttv_irq_wakeup_top(struct bttv *btv) 3692 { 3693 struct bttv_buffer *wakeup = btv->curr.top; 3694 3695 if (NULL == wakeup) 3696 return; 3697 3698 spin_lock(&btv->s_lock); 3699 btv->curr.top_irq = 0; 3700 btv->curr.top = NULL; 3701 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0); 3702 3703 v4l2_get_timestamp(&wakeup->vb.ts); 3704 wakeup->vb.field_count = btv->field_count; 3705 wakeup->vb.state = VIDEOBUF_DONE; 3706 wake_up(&wakeup->vb.done); 3707 spin_unlock(&btv->s_lock); 3708 } 3709 3710 static inline int is_active(struct btcx_riscmem *risc, u32 rc) 3711 { 3712 if (rc < risc->dma) 3713 return 0; 3714 if (rc > risc->dma + risc->size) 3715 return 0; 3716 return 1; 3717 } 3718 3719 static void 3720 bttv_irq_switch_video(struct bttv *btv) 3721 { 3722 struct bttv_buffer_set new; 3723 struct bttv_buffer_set old; 3724 dma_addr_t rc; 3725 3726 spin_lock(&btv->s_lock); 3727 3728 /* new buffer set */ 3729 bttv_irq_next_video(btv, &new); 3730 rc = btread(BT848_RISC_COUNT); 3731 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) || 3732 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) { 3733 btv->framedrop++; 3734 if (debug_latency) 3735 bttv_irq_debug_low_latency(btv, rc); 3736 spin_unlock(&btv->s_lock); 3737 return; 3738 } 3739 3740 /* switch over */ 3741 old = btv->curr; 3742 btv->curr = new; 3743 btv->loop_irq &= ~1; 3744 bttv_buffer_activate_video(btv, &new); 3745 bttv_set_dma(btv, 0); 3746 3747 /* switch input */ 3748 if (UNSET != btv->new_input) { 3749 video_mux(btv,btv->new_input); 3750 btv->new_input = UNSET; 3751 } 3752 3753 /* wake up finished buffers */ 3754 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE); 3755 spin_unlock(&btv->s_lock); 3756 } 3757 3758 static void 3759 bttv_irq_switch_vbi(struct bttv *btv) 3760 { 3761 struct bttv_buffer *new = NULL; 3762 struct bttv_buffer *old; 3763 u32 rc; 3764 3765 spin_lock(&btv->s_lock); 3766 3767 if (!list_empty(&btv->vcapture)) 3768 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue); 3769 old = btv->cvbi; 3770 3771 rc = btread(BT848_RISC_COUNT); 3772 if (NULL != old && (is_active(&old->top, rc) || 3773 is_active(&old->bottom, rc))) { 3774 btv->framedrop++; 3775 if (debug_latency) 3776 bttv_irq_debug_low_latency(btv, rc); 3777 spin_unlock(&btv->s_lock); 3778 return; 3779 } 3780 3781 /* switch */ 3782 btv->cvbi = new; 3783 btv->loop_irq &= ~4; 3784 bttv_buffer_activate_vbi(btv, new); 3785 bttv_set_dma(btv, 0); 3786 3787 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE); 3788 spin_unlock(&btv->s_lock); 3789 } 3790 3791 static irqreturn_t bttv_irq(int irq, void *dev_id) 3792 { 3793 u32 stat,astat; 3794 u32 dstat; 3795 int count; 3796 struct bttv *btv; 3797 int handled = 0; 3798 3799 btv=(struct bttv *)dev_id; 3800 3801 count=0; 3802 while (1) { 3803 /* get/clear interrupt status bits */ 3804 stat=btread(BT848_INT_STAT); 3805 astat=stat&btread(BT848_INT_MASK); 3806 if (!astat) 3807 break; 3808 handled = 1; 3809 btwrite(stat,BT848_INT_STAT); 3810 3811 /* get device status bits */ 3812 dstat=btread(BT848_DSTATUS); 3813 3814 if (irq_debug) { 3815 pr_debug("%d: irq loop=%d fc=%d riscs=%x, riscc=%08x, ", 3816 btv->c.nr, count, btv->field_count, 3817 stat>>28, btread(BT848_RISC_COUNT)); 3818 bttv_print_irqbits(stat,astat); 3819 if (stat & BT848_INT_HLOCK) 3820 pr_cont(" HLOC => %s", 3821 dstat & BT848_DSTATUS_HLOC 3822 ? "yes" : "no"); 3823 if (stat & BT848_INT_VPRES) 3824 pr_cont(" PRES => %s", 3825 dstat & BT848_DSTATUS_PRES 3826 ? "yes" : "no"); 3827 if (stat & BT848_INT_FMTCHG) 3828 pr_cont(" NUML => %s", 3829 dstat & BT848_DSTATUS_NUML 3830 ? "625" : "525"); 3831 pr_cont("\n"); 3832 } 3833 3834 if (astat&BT848_INT_VSYNC) 3835 btv->field_count++; 3836 3837 if ((astat & BT848_INT_GPINT) && btv->remote) { 3838 bttv_input_irq(btv); 3839 } 3840 3841 if (astat & BT848_INT_I2CDONE) { 3842 btv->i2c_done = stat; 3843 wake_up(&btv->i2c_queue); 3844 } 3845 3846 if ((astat & BT848_INT_RISCI) && (stat & (4<<28))) 3847 bttv_irq_switch_vbi(btv); 3848 3849 if ((astat & BT848_INT_RISCI) && (stat & (2<<28))) 3850 bttv_irq_wakeup_top(btv); 3851 3852 if ((astat & BT848_INT_RISCI) && (stat & (1<<28))) 3853 bttv_irq_switch_video(btv); 3854 3855 if ((astat & BT848_INT_HLOCK) && btv->opt_automute) 3856 /* trigger automute */ 3857 audio_mux_gpio(btv, btv->audio_input, btv->mute); 3858 3859 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) { 3860 pr_info("%d: %s%s @ %08x,", 3861 btv->c.nr, 3862 (astat & BT848_INT_SCERR) ? "SCERR" : "", 3863 (astat & BT848_INT_OCERR) ? "OCERR" : "", 3864 btread(BT848_RISC_COUNT)); 3865 bttv_print_irqbits(stat,astat); 3866 pr_cont("\n"); 3867 if (bttv_debug) 3868 bttv_print_riscaddr(btv); 3869 } 3870 if (fdsr && astat & BT848_INT_FDSR) { 3871 pr_info("%d: FDSR @ %08x\n", 3872 btv->c.nr, btread(BT848_RISC_COUNT)); 3873 if (bttv_debug) 3874 bttv_print_riscaddr(btv); 3875 } 3876 3877 count++; 3878 if (count > 4) { 3879 3880 if (count > 8 || !(astat & BT848_INT_GPINT)) { 3881 btwrite(0, BT848_INT_MASK); 3882 3883 pr_err("%d: IRQ lockup, cleared int mask [", 3884 btv->c.nr); 3885 } else { 3886 pr_err("%d: IRQ lockup, clearing GPINT from int mask [", 3887 btv->c.nr); 3888 3889 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT), 3890 BT848_INT_MASK); 3891 } 3892 3893 bttv_print_irqbits(stat,astat); 3894 3895 pr_cont("]\n"); 3896 } 3897 } 3898 btv->irq_total++; 3899 if (handled) 3900 btv->irq_me++; 3901 return IRQ_RETVAL(handled); 3902 } 3903 3904 3905 /* ----------------------------------------------------------------------- */ 3906 /* initialization */ 3907 3908 static struct video_device *vdev_init(struct bttv *btv, 3909 const struct video_device *template, 3910 const char *type_name) 3911 { 3912 struct video_device *vfd; 3913 3914 vfd = video_device_alloc(); 3915 if (NULL == vfd) 3916 return NULL; 3917 *vfd = *template; 3918 vfd->v4l2_dev = &btv->c.v4l2_dev; 3919 vfd->release = video_device_release; 3920 video_set_drvdata(vfd, btv); 3921 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)", 3922 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "", 3923 type_name, bttv_tvcards[btv->c.type].name); 3924 if (btv->tuner_type == TUNER_ABSENT) { 3925 v4l2_disable_ioctl(vfd, VIDIOC_G_FREQUENCY); 3926 v4l2_disable_ioctl(vfd, VIDIOC_S_FREQUENCY); 3927 v4l2_disable_ioctl(vfd, VIDIOC_G_TUNER); 3928 v4l2_disable_ioctl(vfd, VIDIOC_S_TUNER); 3929 } 3930 return vfd; 3931 } 3932 3933 static void bttv_unregister_video(struct bttv *btv) 3934 { 3935 if (btv->video_dev) { 3936 if (video_is_registered(btv->video_dev)) 3937 video_unregister_device(btv->video_dev); 3938 else 3939 video_device_release(btv->video_dev); 3940 btv->video_dev = NULL; 3941 } 3942 if (btv->vbi_dev) { 3943 if (video_is_registered(btv->vbi_dev)) 3944 video_unregister_device(btv->vbi_dev); 3945 else 3946 video_device_release(btv->vbi_dev); 3947 btv->vbi_dev = NULL; 3948 } 3949 if (btv->radio_dev) { 3950 if (video_is_registered(btv->radio_dev)) 3951 video_unregister_device(btv->radio_dev); 3952 else 3953 video_device_release(btv->radio_dev); 3954 btv->radio_dev = NULL; 3955 } 3956 } 3957 3958 /* register video4linux devices */ 3959 static int bttv_register_video(struct bttv *btv) 3960 { 3961 if (no_overlay > 0) 3962 pr_notice("Overlay support disabled\n"); 3963 3964 /* video */ 3965 btv->video_dev = vdev_init(btv, &bttv_video_template, "video"); 3966 3967 if (NULL == btv->video_dev) 3968 goto err; 3969 if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER, 3970 video_nr[btv->c.nr]) < 0) 3971 goto err; 3972 pr_info("%d: registered device %s\n", 3973 btv->c.nr, video_device_node_name(btv->video_dev)); 3974 if (device_create_file(&btv->video_dev->dev, 3975 &dev_attr_card)<0) { 3976 pr_err("%d: device_create_file 'card' failed\n", btv->c.nr); 3977 goto err; 3978 } 3979 3980 /* vbi */ 3981 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi"); 3982 3983 if (NULL == btv->vbi_dev) 3984 goto err; 3985 if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI, 3986 vbi_nr[btv->c.nr]) < 0) 3987 goto err; 3988 pr_info("%d: registered device %s\n", 3989 btv->c.nr, video_device_node_name(btv->vbi_dev)); 3990 3991 if (!btv->has_radio) 3992 return 0; 3993 /* radio */ 3994 btv->radio_dev = vdev_init(btv, &radio_template, "radio"); 3995 if (NULL == btv->radio_dev) 3996 goto err; 3997 btv->radio_dev->ctrl_handler = &btv->radio_ctrl_handler; 3998 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO, 3999 radio_nr[btv->c.nr]) < 0) 4000 goto err; 4001 pr_info("%d: registered device %s\n", 4002 btv->c.nr, video_device_node_name(btv->radio_dev)); 4003 4004 /* all done */ 4005 return 0; 4006 4007 err: 4008 bttv_unregister_video(btv); 4009 return -1; 4010 } 4011 4012 4013 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */ 4014 /* response on cards with no firmware is not enabled by OF */ 4015 static void pci_set_command(struct pci_dev *dev) 4016 { 4017 #if defined(__powerpc__) 4018 unsigned int cmd; 4019 4020 pci_read_config_dword(dev, PCI_COMMAND, &cmd); 4021 cmd = (cmd | PCI_COMMAND_MEMORY ); 4022 pci_write_config_dword(dev, PCI_COMMAND, cmd); 4023 #endif 4024 } 4025 4026 static int bttv_probe(struct pci_dev *dev, const struct pci_device_id *pci_id) 4027 { 4028 struct v4l2_frequency init_freq = { 4029 .tuner = 0, 4030 .type = V4L2_TUNER_ANALOG_TV, 4031 .frequency = 980, 4032 }; 4033 int result; 4034 unsigned char lat; 4035 struct bttv *btv; 4036 struct v4l2_ctrl_handler *hdl; 4037 4038 if (bttv_num == BTTV_MAX) 4039 return -ENOMEM; 4040 pr_info("Bt8xx card found (%d)\n", bttv_num); 4041 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL); 4042 if (btv == NULL) { 4043 pr_err("out of memory\n"); 4044 return -ENOMEM; 4045 } 4046 btv->c.nr = bttv_num; 4047 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name), 4048 "bttv%d", btv->c.nr); 4049 4050 /* initialize structs / fill in defaults */ 4051 mutex_init(&btv->lock); 4052 spin_lock_init(&btv->s_lock); 4053 spin_lock_init(&btv->gpio_lock); 4054 init_waitqueue_head(&btv->i2c_queue); 4055 INIT_LIST_HEAD(&btv->c.subs); 4056 INIT_LIST_HEAD(&btv->capture); 4057 INIT_LIST_HEAD(&btv->vcapture); 4058 4059 init_timer(&btv->timeout); 4060 btv->timeout.function = bttv_irq_timeout; 4061 btv->timeout.data = (unsigned long)btv; 4062 4063 btv->i2c_rc = -1; 4064 btv->tuner_type = UNSET; 4065 btv->new_input = UNSET; 4066 btv->has_radio=radio[btv->c.nr]; 4067 4068 /* pci stuff (init, get irq/mmio, ... */ 4069 btv->c.pci = dev; 4070 btv->id = dev->device; 4071 if (pci_enable_device(dev)) { 4072 pr_warn("%d: Can't enable device\n", btv->c.nr); 4073 return -EIO; 4074 } 4075 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) { 4076 pr_warn("%d: No suitable DMA available\n", btv->c.nr); 4077 return -EIO; 4078 } 4079 if (!request_mem_region(pci_resource_start(dev,0), 4080 pci_resource_len(dev,0), 4081 btv->c.v4l2_dev.name)) { 4082 pr_warn("%d: can't request iomem (0x%llx)\n", 4083 btv->c.nr, 4084 (unsigned long long)pci_resource_start(dev, 0)); 4085 return -EBUSY; 4086 } 4087 pci_set_master(dev); 4088 pci_set_command(dev); 4089 4090 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev); 4091 if (result < 0) { 4092 pr_warn("%d: v4l2_device_register() failed\n", btv->c.nr); 4093 goto fail0; 4094 } 4095 hdl = &btv->ctrl_handler; 4096 v4l2_ctrl_handler_init(hdl, 20); 4097 btv->c.v4l2_dev.ctrl_handler = hdl; 4098 v4l2_ctrl_handler_init(&btv->radio_ctrl_handler, 6); 4099 4100 btv->revision = dev->revision; 4101 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); 4102 pr_info("%d: Bt%d (rev %d) at %s, irq: %d, latency: %d, mmio: 0x%llx\n", 4103 bttv_num, btv->id, btv->revision, pci_name(dev), 4104 btv->c.pci->irq, lat, 4105 (unsigned long long)pci_resource_start(dev, 0)); 4106 schedule(); 4107 4108 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000); 4109 if (NULL == btv->bt848_mmio) { 4110 pr_err("%d: ioremap() failed\n", btv->c.nr); 4111 result = -EIO; 4112 goto fail1; 4113 } 4114 4115 /* identify card */ 4116 bttv_idcard(btv); 4117 4118 /* disable irqs, register irq handler */ 4119 btwrite(0, BT848_INT_MASK); 4120 result = request_irq(btv->c.pci->irq, bttv_irq, 4121 IRQF_SHARED, btv->c.v4l2_dev.name, (void *)btv); 4122 if (result < 0) { 4123 pr_err("%d: can't get IRQ %d\n", 4124 bttv_num, btv->c.pci->irq); 4125 goto fail1; 4126 } 4127 4128 if (0 != bttv_handle_chipset(btv)) { 4129 result = -EIO; 4130 goto fail2; 4131 } 4132 4133 /* init options from insmod args */ 4134 btv->opt_combfilter = combfilter; 4135 bttv_ctrl_combfilter.def = combfilter; 4136 bttv_ctrl_lumafilter.def = lumafilter; 4137 btv->opt_automute = automute; 4138 bttv_ctrl_automute.def = automute; 4139 bttv_ctrl_agc_crush.def = agc_crush; 4140 btv->opt_vcr_hack = vcr_hack; 4141 bttv_ctrl_vcr_hack.def = vcr_hack; 4142 bttv_ctrl_whitecrush_upper.def = whitecrush_upper; 4143 bttv_ctrl_whitecrush_lower.def = whitecrush_lower; 4144 btv->opt_uv_ratio = uv_ratio; 4145 bttv_ctrl_uv_ratio.def = uv_ratio; 4146 bttv_ctrl_full_luma.def = full_luma_range; 4147 bttv_ctrl_coring.def = coring; 4148 4149 /* fill struct bttv with some useful defaults */ 4150 btv->init.btv = btv; 4151 btv->init.ov.w.width = 320; 4152 btv->init.ov.w.height = 240; 4153 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24); 4154 btv->init.width = 320; 4155 btv->init.height = 240; 4156 btv->init.ov.w.width = 320; 4157 btv->init.ov.w.height = 240; 4158 btv->init.ov.field = V4L2_FIELD_INTERLACED; 4159 btv->input = 0; 4160 4161 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4162 V4L2_CID_BRIGHTNESS, 0, 0xff00, 0x100, 32768); 4163 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4164 V4L2_CID_CONTRAST, 0, 0xff80, 0x80, 0x6c00); 4165 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4166 V4L2_CID_SATURATION, 0, 0xff80, 0x80, 32768); 4167 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4168 V4L2_CID_COLOR_KILLER, 0, 1, 1, 0); 4169 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4170 V4L2_CID_HUE, 0, 0xff00, 0x100, 32768); 4171 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4172 V4L2_CID_CHROMA_AGC, 0, 1, 1, !!chroma_agc); 4173 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4174 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 4175 if (btv->volume_gpio) 4176 v4l2_ctrl_new_std(hdl, &bttv_ctrl_ops, 4177 V4L2_CID_AUDIO_VOLUME, 0, 0xff00, 0x100, 0xff00); 4178 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_combfilter, NULL); 4179 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_automute, NULL); 4180 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_lumafilter, NULL); 4181 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_agc_crush, NULL); 4182 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_vcr_hack, NULL); 4183 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_lower, NULL); 4184 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_whitecrush_upper, NULL); 4185 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_uv_ratio, NULL); 4186 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_full_luma, NULL); 4187 v4l2_ctrl_new_custom(hdl, &bttv_ctrl_coring, NULL); 4188 4189 /* initialize hardware */ 4190 if (bttv_gpio) 4191 bttv_gpio_tracking(btv,"pre-init"); 4192 4193 bttv_risc_init_main(btv); 4194 init_bt848(btv); 4195 4196 /* gpio */ 4197 btwrite(0x00, BT848_GPIO_REG_INP); 4198 btwrite(0x00, BT848_GPIO_OUT_EN); 4199 if (bttv_verbose) 4200 bttv_gpio_tracking(btv,"init"); 4201 4202 /* needs to be done before i2c is registered */ 4203 bttv_init_card1(btv); 4204 4205 /* register i2c + gpio */ 4206 init_bttv_i2c(btv); 4207 4208 /* some card-specific stuff (needs working i2c) */ 4209 bttv_init_card2(btv); 4210 bttv_init_tuner(btv); 4211 if (btv->tuner_type != TUNER_ABSENT) { 4212 bttv_set_frequency(btv, &init_freq); 4213 btv->radio_freq = 90500 * 16; /* 90.5Mhz default */ 4214 } 4215 btv->std = V4L2_STD_PAL; 4216 init_irqreg(btv); 4217 if (!bttv_tvcards[btv->c.type].no_video) 4218 v4l2_ctrl_handler_setup(hdl); 4219 if (hdl->error) { 4220 result = hdl->error; 4221 goto fail2; 4222 } 4223 /* mute device */ 4224 audio_mute(btv, 1); 4225 4226 /* register video4linux + input */ 4227 if (!bttv_tvcards[btv->c.type].no_video) { 4228 v4l2_ctrl_add_handler(&btv->radio_ctrl_handler, hdl, 4229 v4l2_ctrl_radio_filter); 4230 if (btv->radio_ctrl_handler.error) { 4231 result = btv->radio_ctrl_handler.error; 4232 goto fail2; 4233 } 4234 set_input(btv, 0, btv->tvnorm); 4235 bttv_crop_reset(&btv->crop[0], btv->tvnorm); 4236 btv->crop[1] = btv->crop[0]; /* current = default */ 4237 disclaim_vbi_lines(btv); 4238 disclaim_video_lines(btv); 4239 bttv_register_video(btv); 4240 } 4241 4242 /* add subdevices and autoload dvb-bt8xx if needed */ 4243 if (bttv_tvcards[btv->c.type].has_dvb) { 4244 bttv_sub_add_device(&btv->c, "dvb"); 4245 request_modules(btv); 4246 } 4247 4248 if (!disable_ir) { 4249 init_bttv_i2c_ir(btv); 4250 bttv_input_init(btv); 4251 } 4252 4253 /* everything is fine */ 4254 bttv_num++; 4255 return 0; 4256 4257 fail2: 4258 free_irq(btv->c.pci->irq,btv); 4259 4260 fail1: 4261 v4l2_ctrl_handler_free(&btv->ctrl_handler); 4262 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler); 4263 v4l2_device_unregister(&btv->c.v4l2_dev); 4264 4265 fail0: 4266 if (btv->bt848_mmio) 4267 iounmap(btv->bt848_mmio); 4268 release_mem_region(pci_resource_start(btv->c.pci,0), 4269 pci_resource_len(btv->c.pci,0)); 4270 return result; 4271 } 4272 4273 static void bttv_remove(struct pci_dev *pci_dev) 4274 { 4275 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev); 4276 struct bttv *btv = to_bttv(v4l2_dev); 4277 4278 if (bttv_verbose) 4279 pr_info("%d: unloading\n", btv->c.nr); 4280 4281 if (bttv_tvcards[btv->c.type].has_dvb) 4282 flush_request_modules(btv); 4283 4284 /* shutdown everything (DMA+IRQs) */ 4285 btand(~15, BT848_GPIO_DMA_CTL); 4286 btwrite(0, BT848_INT_MASK); 4287 btwrite(~0x0, BT848_INT_STAT); 4288 btwrite(0x0, BT848_GPIO_OUT_EN); 4289 if (bttv_gpio) 4290 bttv_gpio_tracking(btv,"cleanup"); 4291 4292 /* tell gpio modules we are leaving ... */ 4293 btv->shutdown=1; 4294 bttv_input_fini(btv); 4295 bttv_sub_del_devices(&btv->c); 4296 4297 /* unregister i2c_bus + input */ 4298 fini_bttv_i2c(btv); 4299 4300 /* unregister video4linux */ 4301 bttv_unregister_video(btv); 4302 4303 /* free allocated memory */ 4304 v4l2_ctrl_handler_free(&btv->ctrl_handler); 4305 v4l2_ctrl_handler_free(&btv->radio_ctrl_handler); 4306 btcx_riscmem_free(btv->c.pci,&btv->main); 4307 4308 /* free resources */ 4309 free_irq(btv->c.pci->irq,btv); 4310 iounmap(btv->bt848_mmio); 4311 release_mem_region(pci_resource_start(btv->c.pci,0), 4312 pci_resource_len(btv->c.pci,0)); 4313 4314 v4l2_device_unregister(&btv->c.v4l2_dev); 4315 bttvs[btv->c.nr] = NULL; 4316 kfree(btv); 4317 4318 return; 4319 } 4320 4321 #ifdef CONFIG_PM 4322 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state) 4323 { 4324 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev); 4325 struct bttv *btv = to_bttv(v4l2_dev); 4326 struct bttv_buffer_set idle; 4327 unsigned long flags; 4328 4329 dprintk("%d: suspend %d\n", btv->c.nr, state.event); 4330 4331 /* stop dma + irqs */ 4332 spin_lock_irqsave(&btv->s_lock,flags); 4333 memset(&idle, 0, sizeof(idle)); 4334 btv->state.video = btv->curr; 4335 btv->state.vbi = btv->cvbi; 4336 btv->state.loop_irq = btv->loop_irq; 4337 btv->curr = idle; 4338 btv->loop_irq = 0; 4339 bttv_buffer_activate_video(btv, &idle); 4340 bttv_buffer_activate_vbi(btv, NULL); 4341 bttv_set_dma(btv, 0); 4342 btwrite(0, BT848_INT_MASK); 4343 spin_unlock_irqrestore(&btv->s_lock,flags); 4344 4345 /* save bt878 state */ 4346 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN); 4347 btv->state.gpio_data = gpio_read(); 4348 4349 /* save pci state */ 4350 pci_save_state(pci_dev); 4351 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) { 4352 pci_disable_device(pci_dev); 4353 btv->state.disabled = 1; 4354 } 4355 return 0; 4356 } 4357 4358 static int bttv_resume(struct pci_dev *pci_dev) 4359 { 4360 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev); 4361 struct bttv *btv = to_bttv(v4l2_dev); 4362 unsigned long flags; 4363 int err; 4364 4365 dprintk("%d: resume\n", btv->c.nr); 4366 4367 /* restore pci state */ 4368 if (btv->state.disabled) { 4369 err=pci_enable_device(pci_dev); 4370 if (err) { 4371 pr_warn("%d: Can't enable device\n", btv->c.nr); 4372 return err; 4373 } 4374 btv->state.disabled = 0; 4375 } 4376 err=pci_set_power_state(pci_dev, PCI_D0); 4377 if (err) { 4378 pci_disable_device(pci_dev); 4379 pr_warn("%d: Can't enable device\n", btv->c.nr); 4380 btv->state.disabled = 1; 4381 return err; 4382 } 4383 4384 pci_restore_state(pci_dev); 4385 4386 /* restore bt878 state */ 4387 bttv_reinit_bt848(btv); 4388 gpio_inout(0xffffff, btv->state.gpio_enable); 4389 gpio_write(btv->state.gpio_data); 4390 4391 /* restart dma */ 4392 spin_lock_irqsave(&btv->s_lock,flags); 4393 btv->curr = btv->state.video; 4394 btv->cvbi = btv->state.vbi; 4395 btv->loop_irq = btv->state.loop_irq; 4396 bttv_buffer_activate_video(btv, &btv->curr); 4397 bttv_buffer_activate_vbi(btv, btv->cvbi); 4398 bttv_set_dma(btv, 0); 4399 spin_unlock_irqrestore(&btv->s_lock,flags); 4400 return 0; 4401 } 4402 #endif 4403 4404 static struct pci_device_id bttv_pci_tbl[] = { 4405 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0}, 4406 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0}, 4407 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0}, 4408 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0}, 4409 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_FUSION879), 0}, 4410 {0,} 4411 }; 4412 4413 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl); 4414 4415 static struct pci_driver bttv_pci_driver = { 4416 .name = "bttv", 4417 .id_table = bttv_pci_tbl, 4418 .probe = bttv_probe, 4419 .remove = bttv_remove, 4420 #ifdef CONFIG_PM 4421 .suspend = bttv_suspend, 4422 .resume = bttv_resume, 4423 #endif 4424 }; 4425 4426 static int __init bttv_init_module(void) 4427 { 4428 int ret; 4429 4430 bttv_num = 0; 4431 4432 pr_info("driver version %s loaded\n", BTTV_VERSION); 4433 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME) 4434 gbuffers = 2; 4435 if (gbufsize > BTTV_MAX_FBUF) 4436 gbufsize = BTTV_MAX_FBUF; 4437 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK; 4438 if (bttv_verbose) 4439 pr_info("using %d buffers with %dk (%d pages) each for capture\n", 4440 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT); 4441 4442 bttv_check_chipset(); 4443 4444 ret = bus_register(&bttv_sub_bus_type); 4445 if (ret < 0) { 4446 pr_warn("bus_register error: %d\n", ret); 4447 return ret; 4448 } 4449 ret = pci_register_driver(&bttv_pci_driver); 4450 if (ret < 0) 4451 bus_unregister(&bttv_sub_bus_type); 4452 4453 return ret; 4454 } 4455 4456 static void __exit bttv_cleanup_module(void) 4457 { 4458 pci_unregister_driver(&bttv_pci_driver); 4459 bus_unregister(&bttv_sub_bus_type); 4460 } 4461 4462 module_init(bttv_init_module); 4463 module_exit(bttv_cleanup_module); 4464