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