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