1 /* 2 * 3 * device driver for philips saa7134 based TV cards 4 * video4linux video interface 5 * 6 * (c) 2001-03 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs] 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 */ 22 23 #include <linux/init.h> 24 #include <linux/list.h> 25 #include <linux/module.h> 26 #include <linux/kernel.h> 27 #include <linux/slab.h> 28 #include <linux/sort.h> 29 30 #include <media/v4l2-common.h> 31 #include <media/v4l2-event.h> 32 #include <media/saa6588.h> 33 34 #include "saa7134-reg.h" 35 #include "saa7134.h" 36 37 /* ------------------------------------------------------------------ */ 38 39 unsigned int video_debug; 40 static unsigned int gbuffers = 8; 41 static unsigned int noninterlaced; /* 0 */ 42 static unsigned int gbufsize = 720*576*4; 43 static unsigned int gbufsize_max = 720*576*4; 44 static char secam[] = "--"; 45 module_param(video_debug, int, 0644); 46 MODULE_PARM_DESC(video_debug,"enable debug messages [video]"); 47 module_param(gbuffers, int, 0444); 48 MODULE_PARM_DESC(gbuffers,"number of capture buffers, range 2-32"); 49 module_param(noninterlaced, int, 0644); 50 MODULE_PARM_DESC(noninterlaced,"capture non interlaced video"); 51 module_param_string(secam, secam, sizeof(secam), 0644); 52 MODULE_PARM_DESC(secam, "force SECAM variant, either DK,L or Lc"); 53 54 55 #define dprintk(fmt, arg...) if (video_debug&0x04) \ 56 printk(KERN_DEBUG "%s/video: " fmt, dev->name , ## arg) 57 58 /* ------------------------------------------------------------------ */ 59 /* Defines for Video Output Port Register at address 0x191 */ 60 61 /* Bit 0: VIP code T bit polarity */ 62 63 #define VP_T_CODE_P_NON_INVERTED 0x00 64 #define VP_T_CODE_P_INVERTED 0x01 65 66 /* ------------------------------------------------------------------ */ 67 /* Defines for Video Output Port Register at address 0x195 */ 68 69 /* Bit 2: Video output clock delay control */ 70 71 #define VP_CLK_CTRL2_NOT_DELAYED 0x00 72 #define VP_CLK_CTRL2_DELAYED 0x04 73 74 /* Bit 1: Video output clock invert control */ 75 76 #define VP_CLK_CTRL1_NON_INVERTED 0x00 77 #define VP_CLK_CTRL1_INVERTED 0x02 78 79 /* ------------------------------------------------------------------ */ 80 /* Defines for Video Output Port Register at address 0x196 */ 81 82 /* Bits 2 to 0: VSYNC pin video vertical sync type */ 83 84 #define VP_VS_TYPE_MASK 0x07 85 86 #define VP_VS_TYPE_OFF 0x00 87 #define VP_VS_TYPE_V123 0x01 88 #define VP_VS_TYPE_V_ITU 0x02 89 #define VP_VS_TYPE_VGATE_L 0x03 90 #define VP_VS_TYPE_RESERVED1 0x04 91 #define VP_VS_TYPE_RESERVED2 0x05 92 #define VP_VS_TYPE_F_ITU 0x06 93 #define VP_VS_TYPE_SC_FID 0x07 94 95 /* ------------------------------------------------------------------ */ 96 /* data structs for video */ 97 98 static int video_out[][9] = { 99 [CCIR656] = { 0x00, 0xb1, 0x00, 0xa1, 0x00, 0x04, 0x06, 0x00, 0x00 }, 100 }; 101 102 static struct saa7134_format formats[] = { 103 { 104 .name = "8 bpp gray", 105 .fourcc = V4L2_PIX_FMT_GREY, 106 .depth = 8, 107 .pm = 0x06, 108 },{ 109 .name = "15 bpp RGB, le", 110 .fourcc = V4L2_PIX_FMT_RGB555, 111 .depth = 16, 112 .pm = 0x13 | 0x80, 113 },{ 114 .name = "15 bpp RGB, be", 115 .fourcc = V4L2_PIX_FMT_RGB555X, 116 .depth = 16, 117 .pm = 0x13 | 0x80, 118 .bswap = 1, 119 },{ 120 .name = "16 bpp RGB, le", 121 .fourcc = V4L2_PIX_FMT_RGB565, 122 .depth = 16, 123 .pm = 0x10 | 0x80, 124 },{ 125 .name = "16 bpp RGB, be", 126 .fourcc = V4L2_PIX_FMT_RGB565X, 127 .depth = 16, 128 .pm = 0x10 | 0x80, 129 .bswap = 1, 130 },{ 131 .name = "24 bpp RGB, le", 132 .fourcc = V4L2_PIX_FMT_BGR24, 133 .depth = 24, 134 .pm = 0x11, 135 },{ 136 .name = "24 bpp RGB, be", 137 .fourcc = V4L2_PIX_FMT_RGB24, 138 .depth = 24, 139 .pm = 0x11, 140 .bswap = 1, 141 },{ 142 .name = "32 bpp RGB, le", 143 .fourcc = V4L2_PIX_FMT_BGR32, 144 .depth = 32, 145 .pm = 0x12, 146 },{ 147 .name = "32 bpp RGB, be", 148 .fourcc = V4L2_PIX_FMT_RGB32, 149 .depth = 32, 150 .pm = 0x12, 151 .bswap = 1, 152 .wswap = 1, 153 },{ 154 .name = "4:2:2 packed, YUYV", 155 .fourcc = V4L2_PIX_FMT_YUYV, 156 .depth = 16, 157 .pm = 0x00, 158 .bswap = 1, 159 .yuv = 1, 160 },{ 161 .name = "4:2:2 packed, UYVY", 162 .fourcc = V4L2_PIX_FMT_UYVY, 163 .depth = 16, 164 .pm = 0x00, 165 .yuv = 1, 166 },{ 167 .name = "4:2:2 planar, Y-Cb-Cr", 168 .fourcc = V4L2_PIX_FMT_YUV422P, 169 .depth = 16, 170 .pm = 0x09, 171 .yuv = 1, 172 .planar = 1, 173 .hshift = 1, 174 .vshift = 0, 175 },{ 176 .name = "4:2:0 planar, Y-Cb-Cr", 177 .fourcc = V4L2_PIX_FMT_YUV420, 178 .depth = 12, 179 .pm = 0x0a, 180 .yuv = 1, 181 .planar = 1, 182 .hshift = 1, 183 .vshift = 1, 184 },{ 185 .name = "4:2:0 planar, Y-Cb-Cr", 186 .fourcc = V4L2_PIX_FMT_YVU420, 187 .depth = 12, 188 .pm = 0x0a, 189 .yuv = 1, 190 .planar = 1, 191 .uvswap = 1, 192 .hshift = 1, 193 .vshift = 1, 194 } 195 }; 196 #define FORMATS ARRAY_SIZE(formats) 197 198 #define NORM_625_50 \ 199 .h_start = 0, \ 200 .h_stop = 719, \ 201 .video_v_start = 24, \ 202 .video_v_stop = 311, \ 203 .vbi_v_start_0 = 7, \ 204 .vbi_v_stop_0 = 22, \ 205 .vbi_v_start_1 = 319, \ 206 .src_timing = 4 207 208 #define NORM_525_60 \ 209 .h_start = 0, \ 210 .h_stop = 719, \ 211 .video_v_start = 23, \ 212 .video_v_stop = 262, \ 213 .vbi_v_start_0 = 10, \ 214 .vbi_v_stop_0 = 21, \ 215 .vbi_v_start_1 = 273, \ 216 .src_timing = 7 217 218 static struct saa7134_tvnorm tvnorms[] = { 219 { 220 .name = "PAL", /* autodetect */ 221 .id = V4L2_STD_PAL, 222 NORM_625_50, 223 224 .sync_control = 0x18, 225 .luma_control = 0x40, 226 .chroma_ctrl1 = 0x81, 227 .chroma_gain = 0x2a, 228 .chroma_ctrl2 = 0x06, 229 .vgate_misc = 0x1c, 230 231 },{ 232 .name = "PAL-BG", 233 .id = V4L2_STD_PAL_BG, 234 NORM_625_50, 235 236 .sync_control = 0x18, 237 .luma_control = 0x40, 238 .chroma_ctrl1 = 0x81, 239 .chroma_gain = 0x2a, 240 .chroma_ctrl2 = 0x06, 241 .vgate_misc = 0x1c, 242 243 },{ 244 .name = "PAL-I", 245 .id = V4L2_STD_PAL_I, 246 NORM_625_50, 247 248 .sync_control = 0x18, 249 .luma_control = 0x40, 250 .chroma_ctrl1 = 0x81, 251 .chroma_gain = 0x2a, 252 .chroma_ctrl2 = 0x06, 253 .vgate_misc = 0x1c, 254 255 },{ 256 .name = "PAL-DK", 257 .id = V4L2_STD_PAL_DK, 258 NORM_625_50, 259 260 .sync_control = 0x18, 261 .luma_control = 0x40, 262 .chroma_ctrl1 = 0x81, 263 .chroma_gain = 0x2a, 264 .chroma_ctrl2 = 0x06, 265 .vgate_misc = 0x1c, 266 267 },{ 268 .name = "NTSC", 269 .id = V4L2_STD_NTSC, 270 NORM_525_60, 271 272 .sync_control = 0x59, 273 .luma_control = 0x40, 274 .chroma_ctrl1 = 0x89, 275 .chroma_gain = 0x2a, 276 .chroma_ctrl2 = 0x0e, 277 .vgate_misc = 0x18, 278 279 },{ 280 .name = "SECAM", 281 .id = V4L2_STD_SECAM, 282 NORM_625_50, 283 284 .sync_control = 0x18, 285 .luma_control = 0x1b, 286 .chroma_ctrl1 = 0xd1, 287 .chroma_gain = 0x80, 288 .chroma_ctrl2 = 0x00, 289 .vgate_misc = 0x1c, 290 291 },{ 292 .name = "SECAM-DK", 293 .id = V4L2_STD_SECAM_DK, 294 NORM_625_50, 295 296 .sync_control = 0x18, 297 .luma_control = 0x1b, 298 .chroma_ctrl1 = 0xd1, 299 .chroma_gain = 0x80, 300 .chroma_ctrl2 = 0x00, 301 .vgate_misc = 0x1c, 302 303 },{ 304 .name = "SECAM-L", 305 .id = V4L2_STD_SECAM_L, 306 NORM_625_50, 307 308 .sync_control = 0x18, 309 .luma_control = 0x1b, 310 .chroma_ctrl1 = 0xd1, 311 .chroma_gain = 0x80, 312 .chroma_ctrl2 = 0x00, 313 .vgate_misc = 0x1c, 314 315 },{ 316 .name = "SECAM-Lc", 317 .id = V4L2_STD_SECAM_LC, 318 NORM_625_50, 319 320 .sync_control = 0x18, 321 .luma_control = 0x1b, 322 .chroma_ctrl1 = 0xd1, 323 .chroma_gain = 0x80, 324 .chroma_ctrl2 = 0x00, 325 .vgate_misc = 0x1c, 326 327 },{ 328 .name = "PAL-M", 329 .id = V4L2_STD_PAL_M, 330 NORM_525_60, 331 332 .sync_control = 0x59, 333 .luma_control = 0x40, 334 .chroma_ctrl1 = 0xb9, 335 .chroma_gain = 0x2a, 336 .chroma_ctrl2 = 0x0e, 337 .vgate_misc = 0x18, 338 339 },{ 340 .name = "PAL-Nc", 341 .id = V4L2_STD_PAL_Nc, 342 NORM_625_50, 343 344 .sync_control = 0x18, 345 .luma_control = 0x40, 346 .chroma_ctrl1 = 0xa1, 347 .chroma_gain = 0x2a, 348 .chroma_ctrl2 = 0x06, 349 .vgate_misc = 0x1c, 350 351 },{ 352 .name = "PAL-60", 353 .id = V4L2_STD_PAL_60, 354 355 .h_start = 0, 356 .h_stop = 719, 357 .video_v_start = 23, 358 .video_v_stop = 262, 359 .vbi_v_start_0 = 10, 360 .vbi_v_stop_0 = 21, 361 .vbi_v_start_1 = 273, 362 .src_timing = 7, 363 364 .sync_control = 0x18, 365 .luma_control = 0x40, 366 .chroma_ctrl1 = 0x81, 367 .chroma_gain = 0x2a, 368 .chroma_ctrl2 = 0x06, 369 .vgate_misc = 0x1c, 370 } 371 }; 372 #define TVNORMS ARRAY_SIZE(tvnorms) 373 374 static struct saa7134_format* format_by_fourcc(unsigned int fourcc) 375 { 376 unsigned int i; 377 378 for (i = 0; i < FORMATS; i++) 379 if (formats[i].fourcc == fourcc) 380 return formats+i; 381 return NULL; 382 } 383 384 /* ------------------------------------------------------------------ */ 385 386 static void set_tvnorm(struct saa7134_dev *dev, struct saa7134_tvnorm *norm) 387 { 388 dprintk("set tv norm = %s\n",norm->name); 389 dev->tvnorm = norm; 390 391 /* setup cropping */ 392 dev->crop_bounds.left = norm->h_start; 393 dev->crop_defrect.left = norm->h_start; 394 dev->crop_bounds.width = norm->h_stop - norm->h_start +1; 395 dev->crop_defrect.width = norm->h_stop - norm->h_start +1; 396 397 dev->crop_bounds.top = (norm->vbi_v_stop_0+1)*2; 398 dev->crop_defrect.top = norm->video_v_start*2; 399 dev->crop_bounds.height = ((norm->id & V4L2_STD_525_60) ? 524 : 624) 400 - dev->crop_bounds.top; 401 dev->crop_defrect.height = (norm->video_v_stop - norm->video_v_start +1)*2; 402 403 dev->crop_current = dev->crop_defrect; 404 405 saa7134_set_tvnorm_hw(dev); 406 } 407 408 static void video_mux(struct saa7134_dev *dev, int input) 409 { 410 dprintk("video input = %d [%s]\n", input, card_in(dev, input).name); 411 dev->ctl_input = input; 412 set_tvnorm(dev, dev->tvnorm); 413 saa7134_tvaudio_setinput(dev, &card_in(dev, input)); 414 } 415 416 417 static void saa7134_set_decoder(struct saa7134_dev *dev) 418 { 419 int luma_control, sync_control, chroma_ctrl1, mux; 420 421 struct saa7134_tvnorm *norm = dev->tvnorm; 422 mux = card_in(dev, dev->ctl_input).vmux; 423 424 luma_control = norm->luma_control; 425 sync_control = norm->sync_control; 426 chroma_ctrl1 = norm->chroma_ctrl1; 427 428 if (mux > 5) 429 luma_control |= 0x80; /* svideo */ 430 if (noninterlaced || dev->nosignal) 431 sync_control |= 0x20; 432 433 /* switch on auto standard detection */ 434 sync_control |= SAA7134_SYNC_CTRL_AUFD; 435 chroma_ctrl1 |= SAA7134_CHROMA_CTRL1_AUTO0; 436 chroma_ctrl1 &= ~SAA7134_CHROMA_CTRL1_FCTC; 437 luma_control &= ~SAA7134_LUMA_CTRL_LDEL; 438 439 /* setup video decoder */ 440 saa_writeb(SAA7134_INCR_DELAY, 0x08); 441 saa_writeb(SAA7134_ANALOG_IN_CTRL1, 0xc0 | mux); 442 saa_writeb(SAA7134_ANALOG_IN_CTRL2, 0x00); 443 444 saa_writeb(SAA7134_ANALOG_IN_CTRL3, 0x90); 445 saa_writeb(SAA7134_ANALOG_IN_CTRL4, 0x90); 446 saa_writeb(SAA7134_HSYNC_START, 0xeb); 447 saa_writeb(SAA7134_HSYNC_STOP, 0xe0); 448 saa_writeb(SAA7134_SOURCE_TIMING1, norm->src_timing); 449 450 saa_writeb(SAA7134_SYNC_CTRL, sync_control); 451 saa_writeb(SAA7134_LUMA_CTRL, luma_control); 452 saa_writeb(SAA7134_DEC_LUMA_BRIGHT, dev->ctl_bright); 453 454 saa_writeb(SAA7134_DEC_LUMA_CONTRAST, 455 dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast); 456 457 saa_writeb(SAA7134_DEC_CHROMA_SATURATION, 458 dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation); 459 460 saa_writeb(SAA7134_DEC_CHROMA_HUE, dev->ctl_hue); 461 saa_writeb(SAA7134_CHROMA_CTRL1, chroma_ctrl1); 462 saa_writeb(SAA7134_CHROMA_GAIN, norm->chroma_gain); 463 464 saa_writeb(SAA7134_CHROMA_CTRL2, norm->chroma_ctrl2); 465 saa_writeb(SAA7134_MODE_DELAY_CTRL, 0x00); 466 467 saa_writeb(SAA7134_ANALOG_ADC, 0x01); 468 saa_writeb(SAA7134_VGATE_START, 0x11); 469 saa_writeb(SAA7134_VGATE_STOP, 0xfe); 470 saa_writeb(SAA7134_MISC_VGATE_MSB, norm->vgate_misc); 471 saa_writeb(SAA7134_RAW_DATA_GAIN, 0x40); 472 saa_writeb(SAA7134_RAW_DATA_OFFSET, 0x80); 473 } 474 475 void saa7134_set_tvnorm_hw(struct saa7134_dev *dev) 476 { 477 saa7134_set_decoder(dev); 478 479 if (card_in(dev, dev->ctl_input).tv) 480 saa_call_all(dev, video, s_std, dev->tvnorm->id); 481 /* Set the correct norm for the saa6752hs. This function 482 does nothing if there is no saa6752hs. */ 483 saa_call_empress(dev, video, s_std, dev->tvnorm->id); 484 } 485 486 static void set_h_prescale(struct saa7134_dev *dev, int task, int prescale) 487 { 488 static const struct { 489 int xpsc; 490 int xacl; 491 int xc2_1; 492 int xdcg; 493 int vpfy; 494 } vals[] = { 495 /* XPSC XACL XC2_1 XDCG VPFY */ 496 { 1, 0, 0, 0, 0 }, 497 { 2, 2, 1, 2, 2 }, 498 { 3, 4, 1, 3, 2 }, 499 { 4, 8, 1, 4, 2 }, 500 { 5, 8, 1, 4, 2 }, 501 { 6, 8, 1, 4, 3 }, 502 { 7, 8, 1, 4, 3 }, 503 { 8, 15, 0, 4, 3 }, 504 { 9, 15, 0, 4, 3 }, 505 { 10, 16, 1, 5, 3 }, 506 }; 507 static const int count = ARRAY_SIZE(vals); 508 int i; 509 510 for (i = 0; i < count; i++) 511 if (vals[i].xpsc == prescale) 512 break; 513 if (i == count) 514 return; 515 516 saa_writeb(SAA7134_H_PRESCALE(task), vals[i].xpsc); 517 saa_writeb(SAA7134_ACC_LENGTH(task), vals[i].xacl); 518 saa_writeb(SAA7134_LEVEL_CTRL(task), 519 (vals[i].xc2_1 << 3) | (vals[i].xdcg)); 520 saa_andorb(SAA7134_FIR_PREFILTER_CTRL(task), 0x0f, 521 (vals[i].vpfy << 2) | vals[i].vpfy); 522 } 523 524 static void set_v_scale(struct saa7134_dev *dev, int task, int yscale) 525 { 526 int val,mirror; 527 528 saa_writeb(SAA7134_V_SCALE_RATIO1(task), yscale & 0xff); 529 saa_writeb(SAA7134_V_SCALE_RATIO2(task), yscale >> 8); 530 531 mirror = (dev->ctl_mirror) ? 0x02 : 0x00; 532 if (yscale < 2048) { 533 /* LPI */ 534 dprintk("yscale LPI yscale=%d\n",yscale); 535 saa_writeb(SAA7134_V_FILTER(task), 0x00 | mirror); 536 saa_writeb(SAA7134_LUMA_CONTRAST(task), 0x40); 537 saa_writeb(SAA7134_CHROMA_SATURATION(task), 0x40); 538 } else { 539 /* ACM */ 540 val = 0x40 * 1024 / yscale; 541 dprintk("yscale ACM yscale=%d val=0x%x\n",yscale,val); 542 saa_writeb(SAA7134_V_FILTER(task), 0x01 | mirror); 543 saa_writeb(SAA7134_LUMA_CONTRAST(task), val); 544 saa_writeb(SAA7134_CHROMA_SATURATION(task), val); 545 } 546 saa_writeb(SAA7134_LUMA_BRIGHT(task), 0x80); 547 } 548 549 static void set_size(struct saa7134_dev *dev, int task, 550 int width, int height, int interlace) 551 { 552 int prescale,xscale,yscale,y_even,y_odd; 553 int h_start, h_stop, v_start, v_stop; 554 int div = interlace ? 2 : 1; 555 556 /* setup video scaler */ 557 h_start = dev->crop_current.left; 558 v_start = dev->crop_current.top/2; 559 h_stop = (dev->crop_current.left + dev->crop_current.width -1); 560 v_stop = (dev->crop_current.top + dev->crop_current.height -1)/2; 561 562 saa_writeb(SAA7134_VIDEO_H_START1(task), h_start & 0xff); 563 saa_writeb(SAA7134_VIDEO_H_START2(task), h_start >> 8); 564 saa_writeb(SAA7134_VIDEO_H_STOP1(task), h_stop & 0xff); 565 saa_writeb(SAA7134_VIDEO_H_STOP2(task), h_stop >> 8); 566 saa_writeb(SAA7134_VIDEO_V_START1(task), v_start & 0xff); 567 saa_writeb(SAA7134_VIDEO_V_START2(task), v_start >> 8); 568 saa_writeb(SAA7134_VIDEO_V_STOP1(task), v_stop & 0xff); 569 saa_writeb(SAA7134_VIDEO_V_STOP2(task), v_stop >> 8); 570 571 prescale = dev->crop_current.width / width; 572 if (0 == prescale) 573 prescale = 1; 574 xscale = 1024 * dev->crop_current.width / prescale / width; 575 yscale = 512 * div * dev->crop_current.height / height; 576 dprintk("prescale=%d xscale=%d yscale=%d\n",prescale,xscale,yscale); 577 set_h_prescale(dev,task,prescale); 578 saa_writeb(SAA7134_H_SCALE_INC1(task), xscale & 0xff); 579 saa_writeb(SAA7134_H_SCALE_INC2(task), xscale >> 8); 580 set_v_scale(dev,task,yscale); 581 582 saa_writeb(SAA7134_VIDEO_PIXELS1(task), width & 0xff); 583 saa_writeb(SAA7134_VIDEO_PIXELS2(task), width >> 8); 584 saa_writeb(SAA7134_VIDEO_LINES1(task), height/div & 0xff); 585 saa_writeb(SAA7134_VIDEO_LINES2(task), height/div >> 8); 586 587 /* deinterlace y offsets */ 588 y_odd = dev->ctl_y_odd; 589 y_even = dev->ctl_y_even; 590 saa_writeb(SAA7134_V_PHASE_OFFSET0(task), y_odd); 591 saa_writeb(SAA7134_V_PHASE_OFFSET1(task), y_even); 592 saa_writeb(SAA7134_V_PHASE_OFFSET2(task), y_odd); 593 saa_writeb(SAA7134_V_PHASE_OFFSET3(task), y_even); 594 } 595 596 /* ------------------------------------------------------------------ */ 597 598 struct cliplist { 599 __u16 position; 600 __u8 enable; 601 __u8 disable; 602 }; 603 604 static void set_cliplist(struct saa7134_dev *dev, int reg, 605 struct cliplist *cl, int entries, char *name) 606 { 607 __u8 winbits = 0; 608 int i; 609 610 for (i = 0; i < entries; i++) { 611 winbits |= cl[i].enable; 612 winbits &= ~cl[i].disable; 613 if (i < 15 && cl[i].position == cl[i+1].position) 614 continue; 615 saa_writeb(reg + 0, winbits); 616 saa_writeb(reg + 2, cl[i].position & 0xff); 617 saa_writeb(reg + 3, cl[i].position >> 8); 618 dprintk("clip: %s winbits=%02x pos=%d\n", 619 name,winbits,cl[i].position); 620 reg += 8; 621 } 622 for (; reg < 0x400; reg += 8) { 623 saa_writeb(reg+ 0, 0); 624 saa_writeb(reg + 1, 0); 625 saa_writeb(reg + 2, 0); 626 saa_writeb(reg + 3, 0); 627 } 628 } 629 630 static int clip_range(int val) 631 { 632 if (val < 0) 633 val = 0; 634 return val; 635 } 636 637 /* Sort into smallest position first order */ 638 static int cliplist_cmp(const void *a, const void *b) 639 { 640 const struct cliplist *cla = a; 641 const struct cliplist *clb = b; 642 if (cla->position < clb->position) 643 return -1; 644 if (cla->position > clb->position) 645 return 1; 646 return 0; 647 } 648 649 static int setup_clipping(struct saa7134_dev *dev, struct v4l2_clip *clips, 650 int nclips, int interlace) 651 { 652 struct cliplist col[16], row[16]; 653 int cols = 0, rows = 0, i; 654 int div = interlace ? 2 : 1; 655 656 memset(col, 0, sizeof(col)); 657 memset(row, 0, sizeof(row)); 658 for (i = 0; i < nclips && i < 8; i++) { 659 col[cols].position = clip_range(clips[i].c.left); 660 col[cols].enable = (1 << i); 661 cols++; 662 col[cols].position = clip_range(clips[i].c.left+clips[i].c.width); 663 col[cols].disable = (1 << i); 664 cols++; 665 row[rows].position = clip_range(clips[i].c.top / div); 666 row[rows].enable = (1 << i); 667 rows++; 668 row[rows].position = clip_range((clips[i].c.top + clips[i].c.height) 669 / div); 670 row[rows].disable = (1 << i); 671 rows++; 672 } 673 sort(col, cols, sizeof col[0], cliplist_cmp, NULL); 674 sort(row, rows, sizeof row[0], cliplist_cmp, NULL); 675 set_cliplist(dev,0x380,col,cols,"cols"); 676 set_cliplist(dev,0x384,row,rows,"rows"); 677 return 0; 678 } 679 680 static int verify_preview(struct saa7134_dev *dev, struct v4l2_window *win, bool try) 681 { 682 enum v4l2_field field; 683 int maxw, maxh; 684 685 if (!try && (dev->ovbuf.base == NULL || dev->ovfmt == NULL)) 686 return -EINVAL; 687 if (win->w.width < 48) 688 win->w.width = 48; 689 if (win->w.height < 32) 690 win->w.height = 32; 691 if (win->clipcount > 8) 692 win->clipcount = 8; 693 694 win->chromakey = 0; 695 win->global_alpha = 0; 696 field = win->field; 697 maxw = dev->crop_current.width; 698 maxh = dev->crop_current.height; 699 700 if (V4L2_FIELD_ANY == field) { 701 field = (win->w.height > maxh/2) 702 ? V4L2_FIELD_INTERLACED 703 : V4L2_FIELD_TOP; 704 } 705 switch (field) { 706 case V4L2_FIELD_TOP: 707 case V4L2_FIELD_BOTTOM: 708 maxh = maxh / 2; 709 break; 710 default: 711 field = V4L2_FIELD_INTERLACED; 712 break; 713 } 714 715 win->field = field; 716 if (win->w.width > maxw) 717 win->w.width = maxw; 718 if (win->w.height > maxh) 719 win->w.height = maxh; 720 return 0; 721 } 722 723 static int start_preview(struct saa7134_dev *dev) 724 { 725 unsigned long base,control,bpl; 726 int err; 727 728 err = verify_preview(dev, &dev->win, false); 729 if (0 != err) 730 return err; 731 732 dev->ovfield = dev->win.field; 733 dprintk("start_preview %dx%d+%d+%d %s field=%s\n", 734 dev->win.w.width, dev->win.w.height, 735 dev->win.w.left, dev->win.w.top, 736 dev->ovfmt->name, v4l2_field_names[dev->ovfield]); 737 738 /* setup window + clipping */ 739 set_size(dev, TASK_B, dev->win.w.width, dev->win.w.height, 740 V4L2_FIELD_HAS_BOTH(dev->ovfield)); 741 setup_clipping(dev, dev->clips, dev->nclips, 742 V4L2_FIELD_HAS_BOTH(dev->ovfield)); 743 if (dev->ovfmt->yuv) 744 saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x03); 745 else 746 saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x01); 747 saa_writeb(SAA7134_OFMT_VIDEO_B, dev->ovfmt->pm | 0x20); 748 749 /* dma: setup channel 1 (= Video Task B) */ 750 base = (unsigned long)dev->ovbuf.base; 751 base += dev->ovbuf.fmt.bytesperline * dev->win.w.top; 752 base += dev->ovfmt->depth/8 * dev->win.w.left; 753 bpl = dev->ovbuf.fmt.bytesperline; 754 control = SAA7134_RS_CONTROL_BURST_16; 755 if (dev->ovfmt->bswap) 756 control |= SAA7134_RS_CONTROL_BSWAP; 757 if (dev->ovfmt->wswap) 758 control |= SAA7134_RS_CONTROL_WSWAP; 759 if (V4L2_FIELD_HAS_BOTH(dev->ovfield)) { 760 saa_writel(SAA7134_RS_BA1(1),base); 761 saa_writel(SAA7134_RS_BA2(1),base+bpl); 762 saa_writel(SAA7134_RS_PITCH(1),bpl*2); 763 saa_writel(SAA7134_RS_CONTROL(1),control); 764 } else { 765 saa_writel(SAA7134_RS_BA1(1),base); 766 saa_writel(SAA7134_RS_BA2(1),base); 767 saa_writel(SAA7134_RS_PITCH(1),bpl); 768 saa_writel(SAA7134_RS_CONTROL(1),control); 769 } 770 771 /* start dma */ 772 dev->ovenable = 1; 773 saa7134_set_dmabits(dev); 774 775 return 0; 776 } 777 778 static int stop_preview(struct saa7134_dev *dev) 779 { 780 dev->ovenable = 0; 781 saa7134_set_dmabits(dev); 782 return 0; 783 } 784 785 /* ------------------------------------------------------------------ */ 786 787 static int buffer_activate(struct saa7134_dev *dev, 788 struct saa7134_buf *buf, 789 struct saa7134_buf *next) 790 { 791 struct saa7134_dmaqueue *dmaq = buf->vb2.vb2_queue->drv_priv; 792 unsigned long base,control,bpl; 793 unsigned long bpl_uv,lines_uv,base2,base3,tmp; /* planar */ 794 795 dprintk("buffer_activate buf=%p\n",buf); 796 buf->top_seen = 0; 797 798 set_size(dev, TASK_A, dev->width, dev->height, 799 V4L2_FIELD_HAS_BOTH(dev->field)); 800 if (dev->fmt->yuv) 801 saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x03); 802 else 803 saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x01); 804 saa_writeb(SAA7134_OFMT_VIDEO_A, dev->fmt->pm); 805 806 /* DMA: setup channel 0 (= Video Task A0) */ 807 base = saa7134_buffer_base(buf); 808 if (dev->fmt->planar) 809 bpl = dev->width; 810 else 811 bpl = (dev->width * dev->fmt->depth) / 8; 812 control = SAA7134_RS_CONTROL_BURST_16 | 813 SAA7134_RS_CONTROL_ME | 814 (dmaq->pt.dma >> 12); 815 if (dev->fmt->bswap) 816 control |= SAA7134_RS_CONTROL_BSWAP; 817 if (dev->fmt->wswap) 818 control |= SAA7134_RS_CONTROL_WSWAP; 819 if (V4L2_FIELD_HAS_BOTH(dev->field)) { 820 /* interlaced */ 821 saa_writel(SAA7134_RS_BA1(0),base); 822 saa_writel(SAA7134_RS_BA2(0),base+bpl); 823 saa_writel(SAA7134_RS_PITCH(0),bpl*2); 824 } else { 825 /* non-interlaced */ 826 saa_writel(SAA7134_RS_BA1(0),base); 827 saa_writel(SAA7134_RS_BA2(0),base); 828 saa_writel(SAA7134_RS_PITCH(0),bpl); 829 } 830 saa_writel(SAA7134_RS_CONTROL(0),control); 831 832 if (dev->fmt->planar) { 833 /* DMA: setup channel 4+5 (= planar task A) */ 834 bpl_uv = bpl >> dev->fmt->hshift; 835 lines_uv = dev->height >> dev->fmt->vshift; 836 base2 = base + bpl * dev->height; 837 base3 = base2 + bpl_uv * lines_uv; 838 if (dev->fmt->uvswap) 839 tmp = base2, base2 = base3, base3 = tmp; 840 dprintk("uv: bpl=%ld lines=%ld base2/3=%ld/%ld\n", 841 bpl_uv,lines_uv,base2,base3); 842 if (V4L2_FIELD_HAS_BOTH(dev->field)) { 843 /* interlaced */ 844 saa_writel(SAA7134_RS_BA1(4),base2); 845 saa_writel(SAA7134_RS_BA2(4),base2+bpl_uv); 846 saa_writel(SAA7134_RS_PITCH(4),bpl_uv*2); 847 saa_writel(SAA7134_RS_BA1(5),base3); 848 saa_writel(SAA7134_RS_BA2(5),base3+bpl_uv); 849 saa_writel(SAA7134_RS_PITCH(5),bpl_uv*2); 850 } else { 851 /* non-interlaced */ 852 saa_writel(SAA7134_RS_BA1(4),base2); 853 saa_writel(SAA7134_RS_BA2(4),base2); 854 saa_writel(SAA7134_RS_PITCH(4),bpl_uv); 855 saa_writel(SAA7134_RS_BA1(5),base3); 856 saa_writel(SAA7134_RS_BA2(5),base3); 857 saa_writel(SAA7134_RS_PITCH(5),bpl_uv); 858 } 859 saa_writel(SAA7134_RS_CONTROL(4),control); 860 saa_writel(SAA7134_RS_CONTROL(5),control); 861 } 862 863 /* start DMA */ 864 saa7134_set_dmabits(dev); 865 mod_timer(&dmaq->timeout, jiffies + BUFFER_TIMEOUT); 866 return 0; 867 } 868 869 static int buffer_init(struct vb2_buffer *vb2) 870 { 871 struct saa7134_dmaqueue *dmaq = vb2->vb2_queue->drv_priv; 872 struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2); 873 874 dmaq->curr = NULL; 875 buf->activate = buffer_activate; 876 return 0; 877 } 878 879 static int buffer_prepare(struct vb2_buffer *vb2) 880 { 881 struct saa7134_dmaqueue *dmaq = vb2->vb2_queue->drv_priv; 882 struct saa7134_dev *dev = dmaq->dev; 883 struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2); 884 struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0); 885 unsigned int size; 886 int ret; 887 888 if (dma->sgl->offset) { 889 pr_err("The buffer is not page-aligned\n"); 890 return -EINVAL; 891 } 892 size = (dev->width * dev->height * dev->fmt->depth) >> 3; 893 if (vb2_plane_size(vb2, 0) < size) 894 return -EINVAL; 895 896 vb2_set_plane_payload(vb2, 0, size); 897 vb2->v4l2_buf.field = dev->field; 898 899 ret = dma_map_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE); 900 if (!ret) 901 return -EIO; 902 return saa7134_pgtable_build(dev->pci, &dmaq->pt, dma->sgl, dma->nents, 903 saa7134_buffer_startpage(buf)); 904 } 905 906 static void buffer_finish(struct vb2_buffer *vb2) 907 { 908 struct saa7134_dmaqueue *dmaq = vb2->vb2_queue->drv_priv; 909 struct saa7134_dev *dev = dmaq->dev; 910 struct saa7134_buf *buf = container_of(vb2, struct saa7134_buf, vb2); 911 struct sg_table *dma = vb2_dma_sg_plane_desc(&buf->vb2, 0); 912 913 dma_unmap_sg(&dev->pci->dev, dma->sgl, dma->nents, DMA_FROM_DEVICE); 914 } 915 916 static int queue_setup(struct vb2_queue *q, const struct v4l2_format *fmt, 917 unsigned int *nbuffers, unsigned int *nplanes, 918 unsigned int sizes[], void *alloc_ctxs[]) 919 { 920 struct saa7134_dmaqueue *dmaq = q->drv_priv; 921 struct saa7134_dev *dev = dmaq->dev; 922 int size = dev->fmt->depth * dev->width * dev->height >> 3; 923 924 if (dev->width < 48 || 925 dev->height < 32 || 926 dev->width/4 > dev->crop_current.width || 927 dev->height/4 > dev->crop_current.height || 928 dev->width > dev->crop_bounds.width || 929 dev->height > dev->crop_bounds.height) 930 return -EINVAL; 931 932 *nbuffers = saa7134_buffer_count(size, *nbuffers); 933 *nplanes = 1; 934 sizes[0] = size; 935 return 0; 936 } 937 938 /* 939 * move buffer to hardware queue 940 */ 941 void saa7134_vb2_buffer_queue(struct vb2_buffer *vb) 942 { 943 struct saa7134_dmaqueue *dmaq = vb->vb2_queue->drv_priv; 944 struct saa7134_dev *dev = dmaq->dev; 945 struct saa7134_buf *buf = container_of(vb, struct saa7134_buf, vb2); 946 947 saa7134_buffer_queue(dev, dmaq, buf); 948 } 949 EXPORT_SYMBOL_GPL(saa7134_vb2_buffer_queue); 950 951 int saa7134_vb2_start_streaming(struct vb2_queue *vq, unsigned int count) 952 { 953 struct saa7134_dmaqueue *dmaq = vq->drv_priv; 954 struct saa7134_dev *dev = dmaq->dev; 955 956 /* 957 * Planar video capture and TS share the same DMA channel, 958 * so only one can be active at a time. 959 */ 960 if (card_is_empress(dev) && vb2_is_busy(&dev->empress_vbq) && 961 dmaq == &dev->video_q && dev->fmt->planar) { 962 struct saa7134_buf *buf, *tmp; 963 964 list_for_each_entry_safe(buf, tmp, &dmaq->queue, entry) { 965 list_del(&buf->entry); 966 vb2_buffer_done(&buf->vb2, VB2_BUF_STATE_QUEUED); 967 } 968 if (dmaq->curr) { 969 vb2_buffer_done(&dmaq->curr->vb2, VB2_BUF_STATE_QUEUED); 970 dmaq->curr = NULL; 971 } 972 return -EBUSY; 973 } 974 975 /* The SAA7134 has a 1K FIFO; the datasheet suggests that when 976 * configured conservatively, there's 22 usec of buffering for video. 977 * We therefore request a DMA latency of 20 usec, giving us 2 usec of 978 * margin in case the FIFO is configured differently to the datasheet. 979 * Unfortunately, I lack register-level documentation to check the 980 * Linux FIFO setup and confirm the perfect value. 981 */ 982 if ((dmaq == &dev->video_q && !vb2_is_streaming(&dev->vbi_vbq)) || 983 (dmaq == &dev->vbi_q && !vb2_is_streaming(&dev->video_vbq))) 984 pm_qos_add_request(&dev->qos_request, 985 PM_QOS_CPU_DMA_LATENCY, 20); 986 dmaq->seq_nr = 0; 987 988 return 0; 989 } 990 991 void saa7134_vb2_stop_streaming(struct vb2_queue *vq) 992 { 993 struct saa7134_dmaqueue *dmaq = vq->drv_priv; 994 struct saa7134_dev *dev = dmaq->dev; 995 996 saa7134_stop_streaming(dev, dmaq); 997 998 if ((dmaq == &dev->video_q && !vb2_is_streaming(&dev->vbi_vbq)) || 999 (dmaq == &dev->vbi_q && !vb2_is_streaming(&dev->video_vbq))) 1000 pm_qos_remove_request(&dev->qos_request); 1001 } 1002 1003 static struct vb2_ops vb2_qops = { 1004 .queue_setup = queue_setup, 1005 .buf_init = buffer_init, 1006 .buf_prepare = buffer_prepare, 1007 .buf_finish = buffer_finish, 1008 .buf_queue = saa7134_vb2_buffer_queue, 1009 .wait_prepare = vb2_ops_wait_prepare, 1010 .wait_finish = vb2_ops_wait_finish, 1011 .start_streaming = saa7134_vb2_start_streaming, 1012 .stop_streaming = saa7134_vb2_stop_streaming, 1013 }; 1014 1015 /* ------------------------------------------------------------------ */ 1016 1017 static int saa7134_s_ctrl(struct v4l2_ctrl *ctrl) 1018 { 1019 struct saa7134_dev *dev = container_of(ctrl->handler, struct saa7134_dev, ctrl_handler); 1020 unsigned long flags; 1021 int restart_overlay = 0; 1022 1023 switch (ctrl->id) { 1024 case V4L2_CID_BRIGHTNESS: 1025 dev->ctl_bright = ctrl->val; 1026 saa_writeb(SAA7134_DEC_LUMA_BRIGHT, ctrl->val); 1027 break; 1028 case V4L2_CID_HUE: 1029 dev->ctl_hue = ctrl->val; 1030 saa_writeb(SAA7134_DEC_CHROMA_HUE, ctrl->val); 1031 break; 1032 case V4L2_CID_CONTRAST: 1033 dev->ctl_contrast = ctrl->val; 1034 saa_writeb(SAA7134_DEC_LUMA_CONTRAST, 1035 dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast); 1036 break; 1037 case V4L2_CID_SATURATION: 1038 dev->ctl_saturation = ctrl->val; 1039 saa_writeb(SAA7134_DEC_CHROMA_SATURATION, 1040 dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation); 1041 break; 1042 case V4L2_CID_AUDIO_MUTE: 1043 dev->ctl_mute = ctrl->val; 1044 saa7134_tvaudio_setmute(dev); 1045 break; 1046 case V4L2_CID_AUDIO_VOLUME: 1047 dev->ctl_volume = ctrl->val; 1048 saa7134_tvaudio_setvolume(dev,dev->ctl_volume); 1049 break; 1050 case V4L2_CID_PRIVATE_INVERT: 1051 dev->ctl_invert = ctrl->val; 1052 saa_writeb(SAA7134_DEC_LUMA_CONTRAST, 1053 dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast); 1054 saa_writeb(SAA7134_DEC_CHROMA_SATURATION, 1055 dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation); 1056 break; 1057 case V4L2_CID_HFLIP: 1058 dev->ctl_mirror = ctrl->val; 1059 restart_overlay = 1; 1060 break; 1061 case V4L2_CID_PRIVATE_Y_EVEN: 1062 dev->ctl_y_even = ctrl->val; 1063 restart_overlay = 1; 1064 break; 1065 case V4L2_CID_PRIVATE_Y_ODD: 1066 dev->ctl_y_odd = ctrl->val; 1067 restart_overlay = 1; 1068 break; 1069 case V4L2_CID_PRIVATE_AUTOMUTE: 1070 { 1071 struct v4l2_priv_tun_config tda9887_cfg; 1072 1073 tda9887_cfg.tuner = TUNER_TDA9887; 1074 tda9887_cfg.priv = &dev->tda9887_conf; 1075 1076 dev->ctl_automute = ctrl->val; 1077 if (dev->tda9887_conf) { 1078 if (dev->ctl_automute) 1079 dev->tda9887_conf |= TDA9887_AUTOMUTE; 1080 else 1081 dev->tda9887_conf &= ~TDA9887_AUTOMUTE; 1082 1083 saa_call_all(dev, tuner, s_config, &tda9887_cfg); 1084 } 1085 break; 1086 } 1087 default: 1088 return -EINVAL; 1089 } 1090 if (restart_overlay && dev->overlay_owner) { 1091 spin_lock_irqsave(&dev->slock, flags); 1092 stop_preview(dev); 1093 start_preview(dev); 1094 spin_unlock_irqrestore(&dev->slock, flags); 1095 } 1096 return 0; 1097 } 1098 1099 /* ------------------------------------------------------------------ */ 1100 1101 static inline struct vb2_queue *saa7134_queue(struct file *file) 1102 { 1103 return video_devdata(file)->queue; 1104 } 1105 1106 static int video_open(struct file *file) 1107 { 1108 struct video_device *vdev = video_devdata(file); 1109 struct saa7134_dev *dev = video_drvdata(file); 1110 int ret = v4l2_fh_open(file); 1111 1112 if (ret < 0) 1113 return ret; 1114 1115 mutex_lock(&dev->lock); 1116 if (vdev->vfl_type == VFL_TYPE_RADIO) { 1117 /* switch to radio mode */ 1118 saa7134_tvaudio_setinput(dev, &card(dev).radio); 1119 saa_call_all(dev, tuner, s_radio); 1120 } else { 1121 /* switch to video/vbi mode */ 1122 video_mux(dev, dev->ctl_input); 1123 } 1124 mutex_unlock(&dev->lock); 1125 1126 return 0; 1127 } 1128 1129 static int video_release(struct file *file) 1130 { 1131 struct video_device *vdev = video_devdata(file); 1132 struct saa7134_dev *dev = video_drvdata(file); 1133 struct v4l2_fh *fh = file->private_data; 1134 struct saa6588_command cmd; 1135 unsigned long flags; 1136 1137 mutex_lock(&dev->lock); 1138 saa7134_tvaudio_close(dev); 1139 1140 /* turn off overlay */ 1141 if (fh == dev->overlay_owner) { 1142 spin_lock_irqsave(&dev->slock,flags); 1143 stop_preview(dev); 1144 spin_unlock_irqrestore(&dev->slock,flags); 1145 dev->overlay_owner = NULL; 1146 } 1147 1148 if (vdev->vfl_type == VFL_TYPE_RADIO) 1149 v4l2_fh_release(file); 1150 else 1151 _vb2_fop_release(file, NULL); 1152 1153 /* ts-capture will not work in planar mode, so turn it off Hac: 04.05*/ 1154 saa_andorb(SAA7134_OFMT_VIDEO_A, 0x1f, 0); 1155 saa_andorb(SAA7134_OFMT_VIDEO_B, 0x1f, 0); 1156 saa_andorb(SAA7134_OFMT_DATA_A, 0x1f, 0); 1157 saa_andorb(SAA7134_OFMT_DATA_B, 0x1f, 0); 1158 1159 saa_call_all(dev, core, s_power, 0); 1160 if (vdev->vfl_type == VFL_TYPE_RADIO) 1161 saa_call_all(dev, core, ioctl, SAA6588_CMD_CLOSE, &cmd); 1162 mutex_unlock(&dev->lock); 1163 1164 return 0; 1165 } 1166 1167 static ssize_t radio_read(struct file *file, char __user *data, 1168 size_t count, loff_t *ppos) 1169 { 1170 struct saa7134_dev *dev = video_drvdata(file); 1171 struct saa6588_command cmd; 1172 1173 cmd.block_count = count/3; 1174 cmd.nonblocking = file->f_flags & O_NONBLOCK; 1175 cmd.buffer = data; 1176 cmd.instance = file; 1177 cmd.result = -ENODEV; 1178 1179 mutex_lock(&dev->lock); 1180 saa_call_all(dev, core, ioctl, SAA6588_CMD_READ, &cmd); 1181 mutex_unlock(&dev->lock); 1182 1183 return cmd.result; 1184 } 1185 1186 static unsigned int radio_poll(struct file *file, poll_table *wait) 1187 { 1188 struct saa7134_dev *dev = video_drvdata(file); 1189 struct saa6588_command cmd; 1190 unsigned int rc = v4l2_ctrl_poll(file, wait); 1191 1192 cmd.instance = file; 1193 cmd.event_list = wait; 1194 cmd.result = 0; 1195 mutex_lock(&dev->lock); 1196 saa_call_all(dev, core, ioctl, SAA6588_CMD_POLL, &cmd); 1197 mutex_unlock(&dev->lock); 1198 1199 return rc | cmd.result; 1200 } 1201 1202 /* ------------------------------------------------------------------ */ 1203 1204 static int saa7134_try_get_set_fmt_vbi_cap(struct file *file, void *priv, 1205 struct v4l2_format *f) 1206 { 1207 struct saa7134_dev *dev = video_drvdata(file); 1208 struct saa7134_tvnorm *norm = dev->tvnorm; 1209 1210 memset(&f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved)); 1211 f->fmt.vbi.sampling_rate = 6750000 * 4; 1212 f->fmt.vbi.samples_per_line = 2048 /* VBI_LINE_LENGTH */; 1213 f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY; 1214 f->fmt.vbi.offset = 64 * 4; 1215 f->fmt.vbi.start[0] = norm->vbi_v_start_0; 1216 f->fmt.vbi.count[0] = norm->vbi_v_stop_0 - norm->vbi_v_start_0 +1; 1217 f->fmt.vbi.start[1] = norm->vbi_v_start_1; 1218 f->fmt.vbi.count[1] = f->fmt.vbi.count[0]; 1219 f->fmt.vbi.flags = 0; /* VBI_UNSYNC VBI_INTERLACED */ 1220 1221 return 0; 1222 } 1223 1224 static int saa7134_g_fmt_vid_cap(struct file *file, void *priv, 1225 struct v4l2_format *f) 1226 { 1227 struct saa7134_dev *dev = video_drvdata(file); 1228 1229 f->fmt.pix.width = dev->width; 1230 f->fmt.pix.height = dev->height; 1231 f->fmt.pix.field = dev->field; 1232 f->fmt.pix.pixelformat = dev->fmt->fourcc; 1233 f->fmt.pix.bytesperline = 1234 (f->fmt.pix.width * dev->fmt->depth) >> 3; 1235 f->fmt.pix.sizeimage = 1236 f->fmt.pix.height * f->fmt.pix.bytesperline; 1237 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1238 f->fmt.pix.priv = 0; 1239 return 0; 1240 } 1241 1242 static int saa7134_g_fmt_vid_overlay(struct file *file, void *priv, 1243 struct v4l2_format *f) 1244 { 1245 struct saa7134_dev *dev = video_drvdata(file); 1246 struct v4l2_clip __user *clips = f->fmt.win.clips; 1247 u32 clipcount = f->fmt.win.clipcount; 1248 int err = 0; 1249 int i; 1250 1251 if (saa7134_no_overlay > 0) { 1252 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n"); 1253 return -EINVAL; 1254 } 1255 f->fmt.win = dev->win; 1256 f->fmt.win.clips = clips; 1257 if (clips == NULL) 1258 clipcount = 0; 1259 if (dev->nclips < clipcount) 1260 clipcount = dev->nclips; 1261 f->fmt.win.clipcount = clipcount; 1262 1263 for (i = 0; !err && i < clipcount; i++) { 1264 if (copy_to_user(&f->fmt.win.clips[i].c, &dev->clips[i].c, 1265 sizeof(struct v4l2_rect))) 1266 err = -EFAULT; 1267 } 1268 1269 return err; 1270 } 1271 1272 static int saa7134_try_fmt_vid_cap(struct file *file, void *priv, 1273 struct v4l2_format *f) 1274 { 1275 struct saa7134_dev *dev = video_drvdata(file); 1276 struct saa7134_format *fmt; 1277 enum v4l2_field field; 1278 unsigned int maxw, maxh; 1279 1280 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1281 if (NULL == fmt) 1282 return -EINVAL; 1283 1284 field = f->fmt.pix.field; 1285 maxw = min(dev->crop_current.width*4, dev->crop_bounds.width); 1286 maxh = min(dev->crop_current.height*4, dev->crop_bounds.height); 1287 1288 if (V4L2_FIELD_ANY == field) { 1289 field = (f->fmt.pix.height > maxh/2) 1290 ? V4L2_FIELD_INTERLACED 1291 : V4L2_FIELD_BOTTOM; 1292 } 1293 switch (field) { 1294 case V4L2_FIELD_TOP: 1295 case V4L2_FIELD_BOTTOM: 1296 maxh = maxh / 2; 1297 break; 1298 default: 1299 field = V4L2_FIELD_INTERLACED; 1300 break; 1301 } 1302 1303 f->fmt.pix.field = field; 1304 if (f->fmt.pix.width < 48) 1305 f->fmt.pix.width = 48; 1306 if (f->fmt.pix.height < 32) 1307 f->fmt.pix.height = 32; 1308 if (f->fmt.pix.width > maxw) 1309 f->fmt.pix.width = maxw; 1310 if (f->fmt.pix.height > maxh) 1311 f->fmt.pix.height = maxh; 1312 f->fmt.pix.width &= ~0x03; 1313 f->fmt.pix.bytesperline = 1314 (f->fmt.pix.width * fmt->depth) >> 3; 1315 f->fmt.pix.sizeimage = 1316 f->fmt.pix.height * f->fmt.pix.bytesperline; 1317 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 1318 f->fmt.pix.priv = 0; 1319 1320 return 0; 1321 } 1322 1323 static int saa7134_try_fmt_vid_overlay(struct file *file, void *priv, 1324 struct v4l2_format *f) 1325 { 1326 struct saa7134_dev *dev = video_drvdata(file); 1327 1328 if (saa7134_no_overlay > 0) { 1329 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n"); 1330 return -EINVAL; 1331 } 1332 1333 if (f->fmt.win.clips == NULL) 1334 f->fmt.win.clipcount = 0; 1335 return verify_preview(dev, &f->fmt.win, true); 1336 } 1337 1338 static int saa7134_s_fmt_vid_cap(struct file *file, void *priv, 1339 struct v4l2_format *f) 1340 { 1341 struct saa7134_dev *dev = video_drvdata(file); 1342 int err; 1343 1344 err = saa7134_try_fmt_vid_cap(file, priv, f); 1345 if (0 != err) 1346 return err; 1347 1348 dev->fmt = format_by_fourcc(f->fmt.pix.pixelformat); 1349 dev->width = f->fmt.pix.width; 1350 dev->height = f->fmt.pix.height; 1351 dev->field = f->fmt.pix.field; 1352 return 0; 1353 } 1354 1355 static int saa7134_s_fmt_vid_overlay(struct file *file, void *priv, 1356 struct v4l2_format *f) 1357 { 1358 struct saa7134_dev *dev = video_drvdata(file); 1359 int err; 1360 unsigned long flags; 1361 1362 if (saa7134_no_overlay > 0) { 1363 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n"); 1364 return -EINVAL; 1365 } 1366 if (f->fmt.win.clips == NULL) 1367 f->fmt.win.clipcount = 0; 1368 err = verify_preview(dev, &f->fmt.win, true); 1369 if (0 != err) 1370 return err; 1371 1372 dev->win = f->fmt.win; 1373 dev->nclips = f->fmt.win.clipcount; 1374 1375 if (copy_from_user(dev->clips, f->fmt.win.clips, 1376 sizeof(struct v4l2_clip) * dev->nclips)) 1377 return -EFAULT; 1378 1379 if (priv == dev->overlay_owner) { 1380 spin_lock_irqsave(&dev->slock, flags); 1381 stop_preview(dev); 1382 start_preview(dev); 1383 spin_unlock_irqrestore(&dev->slock, flags); 1384 } 1385 1386 return 0; 1387 } 1388 1389 int saa7134_enum_input(struct file *file, void *priv, struct v4l2_input *i) 1390 { 1391 struct saa7134_dev *dev = video_drvdata(file); 1392 unsigned int n; 1393 1394 n = i->index; 1395 if (n >= SAA7134_INPUT_MAX) 1396 return -EINVAL; 1397 if (NULL == card_in(dev, i->index).name) 1398 return -EINVAL; 1399 i->index = n; 1400 i->type = V4L2_INPUT_TYPE_CAMERA; 1401 strcpy(i->name, card_in(dev, n).name); 1402 if (card_in(dev, n).tv) 1403 i->type = V4L2_INPUT_TYPE_TUNER; 1404 if (n == dev->ctl_input) { 1405 int v1 = saa_readb(SAA7134_STATUS_VIDEO1); 1406 int v2 = saa_readb(SAA7134_STATUS_VIDEO2); 1407 1408 if (0 != (v1 & 0x40)) 1409 i->status |= V4L2_IN_ST_NO_H_LOCK; 1410 if (0 != (v2 & 0x40)) 1411 i->status |= V4L2_IN_ST_NO_SIGNAL; 1412 if (0 != (v2 & 0x0e)) 1413 i->status |= V4L2_IN_ST_MACROVISION; 1414 } 1415 i->std = SAA7134_NORMS; 1416 return 0; 1417 } 1418 EXPORT_SYMBOL_GPL(saa7134_enum_input); 1419 1420 int saa7134_g_input(struct file *file, void *priv, unsigned int *i) 1421 { 1422 struct saa7134_dev *dev = video_drvdata(file); 1423 1424 *i = dev->ctl_input; 1425 return 0; 1426 } 1427 EXPORT_SYMBOL_GPL(saa7134_g_input); 1428 1429 int saa7134_s_input(struct file *file, void *priv, unsigned int i) 1430 { 1431 struct saa7134_dev *dev = video_drvdata(file); 1432 1433 if (i >= SAA7134_INPUT_MAX) 1434 return -EINVAL; 1435 if (NULL == card_in(dev, i).name) 1436 return -EINVAL; 1437 video_mux(dev, i); 1438 return 0; 1439 } 1440 EXPORT_SYMBOL_GPL(saa7134_s_input); 1441 1442 int saa7134_querycap(struct file *file, void *priv, 1443 struct v4l2_capability *cap) 1444 { 1445 struct saa7134_dev *dev = video_drvdata(file); 1446 struct video_device *vdev = video_devdata(file); 1447 u32 radio_caps, video_caps, vbi_caps; 1448 1449 unsigned int tuner_type = dev->tuner_type; 1450 1451 strcpy(cap->driver, "saa7134"); 1452 strlcpy(cap->card, saa7134_boards[dev->board].name, 1453 sizeof(cap->card)); 1454 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci)); 1455 1456 cap->device_caps = V4L2_CAP_READWRITE | V4L2_CAP_STREAMING; 1457 if ((tuner_type != TUNER_ABSENT) && (tuner_type != UNSET)) 1458 cap->device_caps |= V4L2_CAP_TUNER; 1459 1460 radio_caps = V4L2_CAP_RADIO; 1461 if (dev->has_rds) 1462 radio_caps |= V4L2_CAP_RDS_CAPTURE; 1463 1464 video_caps = V4L2_CAP_VIDEO_CAPTURE; 1465 if (saa7134_no_overlay <= 0 && !is_empress(file)) 1466 video_caps |= V4L2_CAP_VIDEO_OVERLAY; 1467 1468 vbi_caps = V4L2_CAP_VBI_CAPTURE; 1469 1470 switch (vdev->vfl_type) { 1471 case VFL_TYPE_RADIO: 1472 cap->device_caps |= radio_caps; 1473 break; 1474 case VFL_TYPE_GRABBER: 1475 cap->device_caps |= video_caps; 1476 break; 1477 case VFL_TYPE_VBI: 1478 cap->device_caps |= vbi_caps; 1479 break; 1480 } 1481 cap->capabilities = radio_caps | video_caps | vbi_caps | 1482 cap->device_caps | V4L2_CAP_DEVICE_CAPS; 1483 if (vdev->vfl_type == VFL_TYPE_RADIO) { 1484 cap->device_caps &= ~V4L2_CAP_STREAMING; 1485 if (!dev->has_rds) 1486 cap->device_caps &= ~V4L2_CAP_READWRITE; 1487 } 1488 1489 return 0; 1490 } 1491 EXPORT_SYMBOL_GPL(saa7134_querycap); 1492 1493 int saa7134_s_std(struct file *file, void *priv, v4l2_std_id id) 1494 { 1495 struct saa7134_dev *dev = video_drvdata(file); 1496 struct v4l2_fh *fh = priv; 1497 unsigned long flags; 1498 unsigned int i; 1499 v4l2_std_id fixup; 1500 1501 if (is_empress(file) && dev->overlay_owner) { 1502 /* Don't change the std from the mpeg device 1503 if overlay is active. */ 1504 return -EBUSY; 1505 } 1506 1507 for (i = 0; i < TVNORMS; i++) 1508 if (id == tvnorms[i].id) 1509 break; 1510 1511 if (i == TVNORMS) 1512 for (i = 0; i < TVNORMS; i++) 1513 if (id & tvnorms[i].id) 1514 break; 1515 if (i == TVNORMS) 1516 return -EINVAL; 1517 1518 if ((id & V4L2_STD_SECAM) && (secam[0] != '-')) { 1519 if (secam[0] == 'L' || secam[0] == 'l') { 1520 if (secam[1] == 'C' || secam[1] == 'c') 1521 fixup = V4L2_STD_SECAM_LC; 1522 else 1523 fixup = V4L2_STD_SECAM_L; 1524 } else { 1525 if (secam[0] == 'D' || secam[0] == 'd') 1526 fixup = V4L2_STD_SECAM_DK; 1527 else 1528 fixup = V4L2_STD_SECAM; 1529 } 1530 for (i = 0; i < TVNORMS; i++) { 1531 if (fixup == tvnorms[i].id) 1532 break; 1533 } 1534 if (i == TVNORMS) 1535 return -EINVAL; 1536 } 1537 1538 id = tvnorms[i].id; 1539 1540 if (!is_empress(file) && fh == dev->overlay_owner) { 1541 spin_lock_irqsave(&dev->slock, flags); 1542 stop_preview(dev); 1543 spin_unlock_irqrestore(&dev->slock, flags); 1544 1545 set_tvnorm(dev, &tvnorms[i]); 1546 1547 spin_lock_irqsave(&dev->slock, flags); 1548 start_preview(dev); 1549 spin_unlock_irqrestore(&dev->slock, flags); 1550 } else 1551 set_tvnorm(dev, &tvnorms[i]); 1552 1553 saa7134_tvaudio_do_scan(dev); 1554 return 0; 1555 } 1556 EXPORT_SYMBOL_GPL(saa7134_s_std); 1557 1558 int saa7134_g_std(struct file *file, void *priv, v4l2_std_id *id) 1559 { 1560 struct saa7134_dev *dev = video_drvdata(file); 1561 1562 *id = dev->tvnorm->id; 1563 return 0; 1564 } 1565 EXPORT_SYMBOL_GPL(saa7134_g_std); 1566 1567 static v4l2_std_id saa7134_read_std(struct saa7134_dev *dev) 1568 { 1569 static v4l2_std_id stds[] = { 1570 V4L2_STD_UNKNOWN, 1571 V4L2_STD_NTSC, 1572 V4L2_STD_PAL, 1573 V4L2_STD_SECAM }; 1574 1575 v4l2_std_id result = 0; 1576 1577 u8 st1 = saa_readb(SAA7134_STATUS_VIDEO1); 1578 u8 st2 = saa_readb(SAA7134_STATUS_VIDEO2); 1579 1580 if (!(st2 & 0x1)) /* RDCAP == 0 */ 1581 result = V4L2_STD_UNKNOWN; 1582 else 1583 result = stds[st1 & 0x03]; 1584 1585 return result; 1586 } 1587 1588 int saa7134_querystd(struct file *file, void *priv, v4l2_std_id *std) 1589 { 1590 struct saa7134_dev *dev = video_drvdata(file); 1591 *std &= saa7134_read_std(dev); 1592 return 0; 1593 } 1594 EXPORT_SYMBOL_GPL(saa7134_querystd); 1595 1596 static int saa7134_cropcap(struct file *file, void *priv, 1597 struct v4l2_cropcap *cap) 1598 { 1599 struct saa7134_dev *dev = video_drvdata(file); 1600 1601 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 1602 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 1603 return -EINVAL; 1604 cap->bounds = dev->crop_bounds; 1605 cap->defrect = dev->crop_defrect; 1606 cap->pixelaspect.numerator = 1; 1607 cap->pixelaspect.denominator = 1; 1608 if (dev->tvnorm->id & V4L2_STD_525_60) { 1609 cap->pixelaspect.numerator = 11; 1610 cap->pixelaspect.denominator = 10; 1611 } 1612 if (dev->tvnorm->id & V4L2_STD_625_50) { 1613 cap->pixelaspect.numerator = 54; 1614 cap->pixelaspect.denominator = 59; 1615 } 1616 return 0; 1617 } 1618 1619 static int saa7134_g_crop(struct file *file, void *f, struct v4l2_crop *crop) 1620 { 1621 struct saa7134_dev *dev = video_drvdata(file); 1622 1623 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 1624 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 1625 return -EINVAL; 1626 crop->c = dev->crop_current; 1627 return 0; 1628 } 1629 1630 static int saa7134_s_crop(struct file *file, void *f, const struct v4l2_crop *crop) 1631 { 1632 struct saa7134_dev *dev = video_drvdata(file); 1633 struct v4l2_rect *b = &dev->crop_bounds; 1634 struct v4l2_rect *c = &dev->crop_current; 1635 1636 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE && 1637 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 1638 return -EINVAL; 1639 1640 if (dev->overlay_owner) 1641 return -EBUSY; 1642 if (vb2_is_streaming(&dev->video_vbq)) 1643 return -EBUSY; 1644 1645 *c = crop->c; 1646 if (c->top < b->top) 1647 c->top = b->top; 1648 if (c->top > b->top + b->height) 1649 c->top = b->top + b->height; 1650 if (c->height > b->top - c->top + b->height) 1651 c->height = b->top - c->top + b->height; 1652 1653 if (c->left < b->left) 1654 c->left = b->left; 1655 if (c->left > b->left + b->width) 1656 c->left = b->left + b->width; 1657 if (c->width > b->left - c->left + b->width) 1658 c->width = b->left - c->left + b->width; 1659 return 0; 1660 } 1661 1662 int saa7134_g_tuner(struct file *file, void *priv, 1663 struct v4l2_tuner *t) 1664 { 1665 struct saa7134_dev *dev = video_drvdata(file); 1666 int n; 1667 1668 if (0 != t->index) 1669 return -EINVAL; 1670 memset(t, 0, sizeof(*t)); 1671 for (n = 0; n < SAA7134_INPUT_MAX; n++) { 1672 if (card_in(dev, n).tv) 1673 break; 1674 } 1675 if (n == SAA7134_INPUT_MAX) 1676 return -EINVAL; 1677 if (NULL != card_in(dev, n).name) { 1678 strcpy(t->name, "Television"); 1679 t->type = V4L2_TUNER_ANALOG_TV; 1680 saa_call_all(dev, tuner, g_tuner, t); 1681 t->capability = V4L2_TUNER_CAP_NORM | 1682 V4L2_TUNER_CAP_STEREO | 1683 V4L2_TUNER_CAP_LANG1 | 1684 V4L2_TUNER_CAP_LANG2; 1685 t->rxsubchans = saa7134_tvaudio_getstereo(dev); 1686 t->audmode = saa7134_tvaudio_rx2mode(t->rxsubchans); 1687 } 1688 if (0 != (saa_readb(SAA7134_STATUS_VIDEO1) & 0x03)) 1689 t->signal = 0xffff; 1690 return 0; 1691 } 1692 EXPORT_SYMBOL_GPL(saa7134_g_tuner); 1693 1694 int saa7134_s_tuner(struct file *file, void *priv, 1695 const struct v4l2_tuner *t) 1696 { 1697 struct saa7134_dev *dev = video_drvdata(file); 1698 int rx, mode; 1699 1700 if (0 != t->index) 1701 return -EINVAL; 1702 1703 mode = dev->thread.mode; 1704 if (UNSET == mode) { 1705 rx = saa7134_tvaudio_getstereo(dev); 1706 mode = saa7134_tvaudio_rx2mode(rx); 1707 } 1708 if (mode != t->audmode) 1709 dev->thread.mode = t->audmode; 1710 1711 return 0; 1712 } 1713 EXPORT_SYMBOL_GPL(saa7134_s_tuner); 1714 1715 int saa7134_g_frequency(struct file *file, void *priv, 1716 struct v4l2_frequency *f) 1717 { 1718 struct saa7134_dev *dev = video_drvdata(file); 1719 1720 if (0 != f->tuner) 1721 return -EINVAL; 1722 1723 saa_call_all(dev, tuner, g_frequency, f); 1724 1725 return 0; 1726 } 1727 EXPORT_SYMBOL_GPL(saa7134_g_frequency); 1728 1729 int saa7134_s_frequency(struct file *file, void *priv, 1730 const struct v4l2_frequency *f) 1731 { 1732 struct saa7134_dev *dev = video_drvdata(file); 1733 1734 if (0 != f->tuner) 1735 return -EINVAL; 1736 1737 saa_call_all(dev, tuner, s_frequency, f); 1738 1739 saa7134_tvaudio_do_scan(dev); 1740 return 0; 1741 } 1742 EXPORT_SYMBOL_GPL(saa7134_s_frequency); 1743 1744 static int saa7134_enum_fmt_vid_cap(struct file *file, void *priv, 1745 struct v4l2_fmtdesc *f) 1746 { 1747 if (f->index >= FORMATS) 1748 return -EINVAL; 1749 1750 strlcpy(f->description, formats[f->index].name, 1751 sizeof(f->description)); 1752 1753 f->pixelformat = formats[f->index].fourcc; 1754 1755 return 0; 1756 } 1757 1758 static int saa7134_enum_fmt_vid_overlay(struct file *file, void *priv, 1759 struct v4l2_fmtdesc *f) 1760 { 1761 if (saa7134_no_overlay > 0) { 1762 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n"); 1763 return -EINVAL; 1764 } 1765 1766 if ((f->index >= FORMATS) || formats[f->index].planar) 1767 return -EINVAL; 1768 1769 strlcpy(f->description, formats[f->index].name, 1770 sizeof(f->description)); 1771 1772 f->pixelformat = formats[f->index].fourcc; 1773 1774 return 0; 1775 } 1776 1777 static int saa7134_g_fbuf(struct file *file, void *f, 1778 struct v4l2_framebuffer *fb) 1779 { 1780 struct saa7134_dev *dev = video_drvdata(file); 1781 1782 *fb = dev->ovbuf; 1783 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING; 1784 1785 return 0; 1786 } 1787 1788 static int saa7134_s_fbuf(struct file *file, void *f, 1789 const struct v4l2_framebuffer *fb) 1790 { 1791 struct saa7134_dev *dev = video_drvdata(file); 1792 struct saa7134_format *fmt; 1793 1794 if (!capable(CAP_SYS_ADMIN) && 1795 !capable(CAP_SYS_RAWIO)) 1796 return -EPERM; 1797 1798 /* check args */ 1799 fmt = format_by_fourcc(fb->fmt.pixelformat); 1800 if (NULL == fmt) 1801 return -EINVAL; 1802 1803 /* ok, accept it */ 1804 dev->ovbuf = *fb; 1805 dev->ovfmt = fmt; 1806 if (0 == dev->ovbuf.fmt.bytesperline) 1807 dev->ovbuf.fmt.bytesperline = 1808 dev->ovbuf.fmt.width*fmt->depth/8; 1809 return 0; 1810 } 1811 1812 static int saa7134_overlay(struct file *file, void *priv, unsigned int on) 1813 { 1814 struct saa7134_dev *dev = video_drvdata(file); 1815 unsigned long flags; 1816 1817 if (on) { 1818 if (saa7134_no_overlay > 0) { 1819 dprintk("no_overlay\n"); 1820 return -EINVAL; 1821 } 1822 1823 if (dev->overlay_owner && priv != dev->overlay_owner) 1824 return -EBUSY; 1825 dev->overlay_owner = priv; 1826 spin_lock_irqsave(&dev->slock, flags); 1827 start_preview(dev); 1828 spin_unlock_irqrestore(&dev->slock, flags); 1829 } 1830 if (!on) { 1831 if (priv != dev->overlay_owner) 1832 return -EINVAL; 1833 spin_lock_irqsave(&dev->slock, flags); 1834 stop_preview(dev); 1835 spin_unlock_irqrestore(&dev->slock, flags); 1836 dev->overlay_owner = NULL; 1837 } 1838 return 0; 1839 } 1840 1841 #ifdef CONFIG_VIDEO_ADV_DEBUG 1842 static int vidioc_g_register (struct file *file, void *priv, 1843 struct v4l2_dbg_register *reg) 1844 { 1845 struct saa7134_dev *dev = video_drvdata(file); 1846 1847 reg->val = saa_readb(reg->reg & 0xffffff); 1848 reg->size = 1; 1849 return 0; 1850 } 1851 1852 static int vidioc_s_register (struct file *file, void *priv, 1853 const struct v4l2_dbg_register *reg) 1854 { 1855 struct saa7134_dev *dev = video_drvdata(file); 1856 1857 saa_writeb(reg->reg & 0xffffff, reg->val); 1858 return 0; 1859 } 1860 #endif 1861 1862 static int radio_g_tuner(struct file *file, void *priv, 1863 struct v4l2_tuner *t) 1864 { 1865 struct saa7134_dev *dev = video_drvdata(file); 1866 1867 if (0 != t->index) 1868 return -EINVAL; 1869 1870 strcpy(t->name, "Radio"); 1871 1872 saa_call_all(dev, tuner, g_tuner, t); 1873 t->audmode &= V4L2_TUNER_MODE_MONO | V4L2_TUNER_MODE_STEREO; 1874 if (dev->input->amux == TV) { 1875 t->signal = 0xf800 - ((saa_readb(0x581) & 0x1f) << 11); 1876 t->rxsubchans = (saa_readb(0x529) & 0x08) ? 1877 V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO; 1878 } 1879 return 0; 1880 } 1881 static int radio_s_tuner(struct file *file, void *priv, 1882 const struct v4l2_tuner *t) 1883 { 1884 struct saa7134_dev *dev = video_drvdata(file); 1885 1886 if (0 != t->index) 1887 return -EINVAL; 1888 1889 saa_call_all(dev, tuner, s_tuner, t); 1890 return 0; 1891 } 1892 1893 static const struct v4l2_file_operations video_fops = 1894 { 1895 .owner = THIS_MODULE, 1896 .open = video_open, 1897 .release = video_release, 1898 .read = vb2_fop_read, 1899 .poll = vb2_fop_poll, 1900 .mmap = vb2_fop_mmap, 1901 .unlocked_ioctl = video_ioctl2, 1902 }; 1903 1904 static const struct v4l2_ioctl_ops video_ioctl_ops = { 1905 .vidioc_querycap = saa7134_querycap, 1906 .vidioc_enum_fmt_vid_cap = saa7134_enum_fmt_vid_cap, 1907 .vidioc_g_fmt_vid_cap = saa7134_g_fmt_vid_cap, 1908 .vidioc_try_fmt_vid_cap = saa7134_try_fmt_vid_cap, 1909 .vidioc_s_fmt_vid_cap = saa7134_s_fmt_vid_cap, 1910 .vidioc_enum_fmt_vid_overlay = saa7134_enum_fmt_vid_overlay, 1911 .vidioc_g_fmt_vid_overlay = saa7134_g_fmt_vid_overlay, 1912 .vidioc_try_fmt_vid_overlay = saa7134_try_fmt_vid_overlay, 1913 .vidioc_s_fmt_vid_overlay = saa7134_s_fmt_vid_overlay, 1914 .vidioc_g_fmt_vbi_cap = saa7134_try_get_set_fmt_vbi_cap, 1915 .vidioc_try_fmt_vbi_cap = saa7134_try_get_set_fmt_vbi_cap, 1916 .vidioc_s_fmt_vbi_cap = saa7134_try_get_set_fmt_vbi_cap, 1917 .vidioc_cropcap = saa7134_cropcap, 1918 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1919 .vidioc_querybuf = vb2_ioctl_querybuf, 1920 .vidioc_qbuf = vb2_ioctl_qbuf, 1921 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1922 .vidioc_s_std = saa7134_s_std, 1923 .vidioc_g_std = saa7134_g_std, 1924 .vidioc_querystd = saa7134_querystd, 1925 .vidioc_enum_input = saa7134_enum_input, 1926 .vidioc_g_input = saa7134_g_input, 1927 .vidioc_s_input = saa7134_s_input, 1928 .vidioc_streamon = vb2_ioctl_streamon, 1929 .vidioc_streamoff = vb2_ioctl_streamoff, 1930 .vidioc_g_tuner = saa7134_g_tuner, 1931 .vidioc_s_tuner = saa7134_s_tuner, 1932 .vidioc_g_crop = saa7134_g_crop, 1933 .vidioc_s_crop = saa7134_s_crop, 1934 .vidioc_g_fbuf = saa7134_g_fbuf, 1935 .vidioc_s_fbuf = saa7134_s_fbuf, 1936 .vidioc_overlay = saa7134_overlay, 1937 .vidioc_g_frequency = saa7134_g_frequency, 1938 .vidioc_s_frequency = saa7134_s_frequency, 1939 #ifdef CONFIG_VIDEO_ADV_DEBUG 1940 .vidioc_g_register = vidioc_g_register, 1941 .vidioc_s_register = vidioc_s_register, 1942 #endif 1943 .vidioc_log_status = v4l2_ctrl_log_status, 1944 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1945 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1946 }; 1947 1948 static const struct v4l2_file_operations radio_fops = { 1949 .owner = THIS_MODULE, 1950 .open = video_open, 1951 .read = radio_read, 1952 .release = video_release, 1953 .unlocked_ioctl = video_ioctl2, 1954 .poll = radio_poll, 1955 }; 1956 1957 static const struct v4l2_ioctl_ops radio_ioctl_ops = { 1958 .vidioc_querycap = saa7134_querycap, 1959 .vidioc_g_tuner = radio_g_tuner, 1960 .vidioc_s_tuner = radio_s_tuner, 1961 .vidioc_g_frequency = saa7134_g_frequency, 1962 .vidioc_s_frequency = saa7134_s_frequency, 1963 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1964 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1965 }; 1966 1967 /* ----------------------------------------------------------- */ 1968 /* exported stuff */ 1969 1970 struct video_device saa7134_video_template = { 1971 .name = "saa7134-video", 1972 .fops = &video_fops, 1973 .ioctl_ops = &video_ioctl_ops, 1974 .tvnorms = SAA7134_NORMS, 1975 }; 1976 1977 struct video_device saa7134_radio_template = { 1978 .name = "saa7134-radio", 1979 .fops = &radio_fops, 1980 .ioctl_ops = &radio_ioctl_ops, 1981 }; 1982 1983 static const struct v4l2_ctrl_ops saa7134_ctrl_ops = { 1984 .s_ctrl = saa7134_s_ctrl, 1985 }; 1986 1987 static const struct v4l2_ctrl_config saa7134_ctrl_invert = { 1988 .ops = &saa7134_ctrl_ops, 1989 .id = V4L2_CID_PRIVATE_INVERT, 1990 .name = "Invert", 1991 .type = V4L2_CTRL_TYPE_BOOLEAN, 1992 .min = 0, 1993 .max = 1, 1994 .step = 1, 1995 }; 1996 1997 static const struct v4l2_ctrl_config saa7134_ctrl_y_odd = { 1998 .ops = &saa7134_ctrl_ops, 1999 .id = V4L2_CID_PRIVATE_Y_ODD, 2000 .name = "Y Offset Odd Field", 2001 .type = V4L2_CTRL_TYPE_INTEGER, 2002 .min = 0, 2003 .max = 128, 2004 .step = 1, 2005 }; 2006 2007 static const struct v4l2_ctrl_config saa7134_ctrl_y_even = { 2008 .ops = &saa7134_ctrl_ops, 2009 .id = V4L2_CID_PRIVATE_Y_EVEN, 2010 .name = "Y Offset Even Field", 2011 .type = V4L2_CTRL_TYPE_INTEGER, 2012 .min = 0, 2013 .max = 128, 2014 .step = 1, 2015 }; 2016 2017 static const struct v4l2_ctrl_config saa7134_ctrl_automute = { 2018 .ops = &saa7134_ctrl_ops, 2019 .id = V4L2_CID_PRIVATE_AUTOMUTE, 2020 .name = "Automute", 2021 .type = V4L2_CTRL_TYPE_BOOLEAN, 2022 .min = 0, 2023 .max = 1, 2024 .step = 1, 2025 .def = 1, 2026 }; 2027 2028 int saa7134_video_init1(struct saa7134_dev *dev) 2029 { 2030 struct v4l2_ctrl_handler *hdl = &dev->ctrl_handler; 2031 struct vb2_queue *q; 2032 int ret; 2033 2034 /* sanitycheck insmod options */ 2035 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME) 2036 gbuffers = 2; 2037 if (gbufsize > gbufsize_max) 2038 gbufsize = gbufsize_max; 2039 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK; 2040 2041 v4l2_ctrl_handler_init(hdl, 11); 2042 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2043 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128); 2044 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2045 V4L2_CID_CONTRAST, 0, 127, 1, 68); 2046 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2047 V4L2_CID_SATURATION, 0, 127, 1, 64); 2048 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2049 V4L2_CID_HUE, -128, 127, 1, 0); 2050 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2051 V4L2_CID_HFLIP, 0, 1, 1, 0); 2052 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2053 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 2054 v4l2_ctrl_new_std(hdl, &saa7134_ctrl_ops, 2055 V4L2_CID_AUDIO_VOLUME, -15, 15, 1, 0); 2056 v4l2_ctrl_new_custom(hdl, &saa7134_ctrl_invert, NULL); 2057 v4l2_ctrl_new_custom(hdl, &saa7134_ctrl_y_odd, NULL); 2058 v4l2_ctrl_new_custom(hdl, &saa7134_ctrl_y_even, NULL); 2059 v4l2_ctrl_new_custom(hdl, &saa7134_ctrl_automute, NULL); 2060 if (hdl->error) 2061 return hdl->error; 2062 if (card_has_radio(dev)) { 2063 hdl = &dev->radio_ctrl_handler; 2064 v4l2_ctrl_handler_init(hdl, 2); 2065 v4l2_ctrl_add_handler(hdl, &dev->ctrl_handler, 2066 v4l2_ctrl_radio_filter); 2067 if (hdl->error) 2068 return hdl->error; 2069 } 2070 dev->ctl_mute = 1; 2071 2072 if (dev->tda9887_conf && saa7134_ctrl_automute.def) 2073 dev->tda9887_conf |= TDA9887_AUTOMUTE; 2074 dev->automute = 0; 2075 2076 INIT_LIST_HEAD(&dev->video_q.queue); 2077 init_timer(&dev->video_q.timeout); 2078 dev->video_q.timeout.function = saa7134_buffer_timeout; 2079 dev->video_q.timeout.data = (unsigned long)(&dev->video_q); 2080 dev->video_q.dev = dev; 2081 dev->fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24); 2082 dev->width = 720; 2083 dev->height = 576; 2084 dev->field = V4L2_FIELD_INTERLACED; 2085 dev->win.w.width = dev->width; 2086 dev->win.w.height = dev->height; 2087 dev->win.field = V4L2_FIELD_INTERLACED; 2088 dev->ovbuf.fmt.width = dev->width; 2089 dev->ovbuf.fmt.height = dev->height; 2090 dev->ovbuf.fmt.pixelformat = dev->fmt->fourcc; 2091 dev->ovbuf.fmt.colorspace = V4L2_COLORSPACE_SMPTE170M; 2092 2093 if (saa7134_boards[dev->board].video_out) 2094 saa7134_videoport_init(dev); 2095 2096 q = &dev->video_vbq; 2097 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2098 /* 2099 * Do not add VB2_USERPTR unless explicitly requested: the saa7134 DMA 2100 * engine cannot handle transfers that do not start at the beginning 2101 * of a page. A user-provided pointer can start anywhere in a page, so 2102 * USERPTR support is a no-go unless the application knows about these 2103 * limitations and has special support for this. 2104 */ 2105 q->io_modes = VB2_MMAP | VB2_READ; 2106 if (saa7134_userptr) 2107 q->io_modes |= VB2_USERPTR; 2108 q->drv_priv = &dev->video_q; 2109 q->ops = &vb2_qops; 2110 q->gfp_flags = GFP_DMA32; 2111 q->mem_ops = &vb2_dma_sg_memops; 2112 q->buf_struct_size = sizeof(struct saa7134_buf); 2113 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 2114 q->lock = &dev->lock; 2115 ret = vb2_queue_init(q); 2116 if (ret) 2117 return ret; 2118 saa7134_pgtable_alloc(dev->pci, &dev->video_q.pt); 2119 2120 q = &dev->vbi_vbq; 2121 q->type = V4L2_BUF_TYPE_VBI_CAPTURE; 2122 /* Don't add VB2_USERPTR, see comment above */ 2123 q->io_modes = VB2_MMAP | VB2_READ; 2124 if (saa7134_userptr) 2125 q->io_modes |= VB2_USERPTR; 2126 q->drv_priv = &dev->vbi_q; 2127 q->ops = &saa7134_vbi_qops; 2128 q->gfp_flags = GFP_DMA32; 2129 q->mem_ops = &vb2_dma_sg_memops; 2130 q->buf_struct_size = sizeof(struct saa7134_buf); 2131 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 2132 q->lock = &dev->lock; 2133 ret = vb2_queue_init(q); 2134 if (ret) 2135 return ret; 2136 saa7134_pgtable_alloc(dev->pci, &dev->vbi_q.pt); 2137 2138 return 0; 2139 } 2140 2141 void saa7134_video_fini(struct saa7134_dev *dev) 2142 { 2143 /* free stuff */ 2144 vb2_queue_release(&dev->video_vbq); 2145 saa7134_pgtable_free(dev->pci, &dev->video_q.pt); 2146 vb2_queue_release(&dev->vbi_vbq); 2147 saa7134_pgtable_free(dev->pci, &dev->vbi_q.pt); 2148 v4l2_ctrl_handler_free(&dev->ctrl_handler); 2149 if (card_has_radio(dev)) 2150 v4l2_ctrl_handler_free(&dev->radio_ctrl_handler); 2151 } 2152 2153 int saa7134_videoport_init(struct saa7134_dev *dev) 2154 { 2155 /* enable video output */ 2156 int vo = saa7134_boards[dev->board].video_out; 2157 int video_reg; 2158 unsigned int vid_port_opts = saa7134_boards[dev->board].vid_port_opts; 2159 2160 /* Configure videoport */ 2161 saa_writeb(SAA7134_VIDEO_PORT_CTRL0, video_out[vo][0]); 2162 video_reg = video_out[vo][1]; 2163 if (vid_port_opts & SET_T_CODE_POLARITY_NON_INVERTED) 2164 video_reg &= ~VP_T_CODE_P_INVERTED; 2165 saa_writeb(SAA7134_VIDEO_PORT_CTRL1, video_reg); 2166 saa_writeb(SAA7134_VIDEO_PORT_CTRL2, video_out[vo][2]); 2167 saa_writeb(SAA7134_VIDEO_PORT_CTRL4, video_out[vo][4]); 2168 video_reg = video_out[vo][5]; 2169 if (vid_port_opts & SET_CLOCK_NOT_DELAYED) 2170 video_reg &= ~VP_CLK_CTRL2_DELAYED; 2171 if (vid_port_opts & SET_CLOCK_INVERTED) 2172 video_reg |= VP_CLK_CTRL1_INVERTED; 2173 saa_writeb(SAA7134_VIDEO_PORT_CTRL5, video_reg); 2174 video_reg = video_out[vo][6]; 2175 if (vid_port_opts & SET_VSYNC_OFF) { 2176 video_reg &= ~VP_VS_TYPE_MASK; 2177 video_reg |= VP_VS_TYPE_OFF; 2178 } 2179 saa_writeb(SAA7134_VIDEO_PORT_CTRL6, video_reg); 2180 saa_writeb(SAA7134_VIDEO_PORT_CTRL7, video_out[vo][7]); 2181 saa_writeb(SAA7134_VIDEO_PORT_CTRL8, video_out[vo][8]); 2182 2183 /* Start videoport */ 2184 saa_writeb(SAA7134_VIDEO_PORT_CTRL3, video_out[vo][3]); 2185 2186 return 0; 2187 } 2188 2189 int saa7134_video_init2(struct saa7134_dev *dev) 2190 { 2191 /* init video hw */ 2192 set_tvnorm(dev,&tvnorms[0]); 2193 video_mux(dev,0); 2194 v4l2_ctrl_handler_setup(&dev->ctrl_handler); 2195 saa7134_tvaudio_setmute(dev); 2196 saa7134_tvaudio_setvolume(dev,dev->ctl_volume); 2197 return 0; 2198 } 2199 2200 void saa7134_irq_video_signalchange(struct saa7134_dev *dev) 2201 { 2202 static const char *st[] = { 2203 "(no signal)", "NTSC", "PAL", "SECAM" }; 2204 u32 st1,st2; 2205 2206 st1 = saa_readb(SAA7134_STATUS_VIDEO1); 2207 st2 = saa_readb(SAA7134_STATUS_VIDEO2); 2208 dprintk("DCSDT: pll: %s, sync: %s, norm: %s\n", 2209 (st1 & 0x40) ? "not locked" : "locked", 2210 (st2 & 0x40) ? "no" : "yes", 2211 st[st1 & 0x03]); 2212 dev->nosignal = (st1 & 0x40) || (st2 & 0x40) || !(st2 & 0x1); 2213 2214 if (dev->nosignal) { 2215 /* no video signal -> mute audio */ 2216 if (dev->ctl_automute) 2217 dev->automute = 1; 2218 saa7134_tvaudio_setmute(dev); 2219 } else { 2220 /* wake up tvaudio audio carrier scan thread */ 2221 saa7134_tvaudio_do_scan(dev); 2222 } 2223 2224 if ((st2 & 0x80) && !noninterlaced && !dev->nosignal) 2225 saa_clearb(SAA7134_SYNC_CTRL, 0x20); 2226 else 2227 saa_setb(SAA7134_SYNC_CTRL, 0x20); 2228 2229 if (dev->mops && dev->mops->signal_change) 2230 dev->mops->signal_change(dev); 2231 } 2232 2233 2234 void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status) 2235 { 2236 enum v4l2_field field; 2237 2238 spin_lock(&dev->slock); 2239 if (dev->video_q.curr) { 2240 field = dev->field; 2241 if (V4L2_FIELD_HAS_BOTH(field)) { 2242 /* make sure we have seen both fields */ 2243 if ((status & 0x10) == 0x00) { 2244 dev->video_q.curr->top_seen = 1; 2245 goto done; 2246 } 2247 if (!dev->video_q.curr->top_seen) 2248 goto done; 2249 } else if (field == V4L2_FIELD_TOP) { 2250 if ((status & 0x10) != 0x10) 2251 goto done; 2252 } else if (field == V4L2_FIELD_BOTTOM) { 2253 if ((status & 0x10) != 0x00) 2254 goto done; 2255 } 2256 saa7134_buffer_finish(dev, &dev->video_q, VB2_BUF_STATE_DONE); 2257 } 2258 saa7134_buffer_next(dev, &dev->video_q); 2259 2260 done: 2261 spin_unlock(&dev->slock); 2262 } 2263