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