Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
saa7134-video.c
Go to the documentation of this file.
1 /*
2  *
3  * device driver for philips saa7134 based TV cards
4  * video4linux video interface
5  *
6  * (c) 2001-03 Gerd Knorr <[email protected]> [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 "saa7134-reg.h"
31 #include "saa7134.h"
32 #include <media/v4l2-common.h>
33 #include <media/saa6588.h>
34 
35 /* ------------------------------------------------------------------ */
36 
37 unsigned int video_debug;
38 static unsigned int gbuffers = 8;
39 static unsigned int noninterlaced; /* 0 */
40 static unsigned int gbufsize = 720*576*4;
41 static unsigned int gbufsize_max = 720*576*4;
42 static char secam[] = "--";
43 module_param(video_debug, int, 0644);
44 MODULE_PARM_DESC(video_debug,"enable debug messages [video]");
45 module_param(gbuffers, int, 0444);
46 MODULE_PARM_DESC(gbuffers,"number of capture buffers, range 2-32");
47 module_param(noninterlaced, int, 0644);
48 MODULE_PARM_DESC(noninterlaced,"capture non interlaced video");
49 module_param_string(secam, secam, sizeof(secam), 0644);
50 MODULE_PARM_DESC(secam, "force SECAM variant, either DK,L or Lc");
51 
52 
53 #define dprintk(fmt, arg...) if (video_debug&0x04) \
54  printk(KERN_DEBUG "%s/video: " fmt, dev->name , ## arg)
55 
56 /* ------------------------------------------------------------------ */
57 /* Defines for Video Output Port Register at address 0x191 */
58 
59 /* Bit 0: VIP code T bit polarity */
60 
61 #define VP_T_CODE_P_NON_INVERTED 0x00
62 #define VP_T_CODE_P_INVERTED 0x01
63 
64 /* ------------------------------------------------------------------ */
65 /* Defines for Video Output Port Register at address 0x195 */
66 
67 /* Bit 2: Video output clock delay control */
68 
69 #define VP_CLK_CTRL2_NOT_DELAYED 0x00
70 #define VP_CLK_CTRL2_DELAYED 0x04
71 
72 /* Bit 1: Video output clock invert control */
73 
74 #define VP_CLK_CTRL1_NON_INVERTED 0x00
75 #define VP_CLK_CTRL1_INVERTED 0x02
76 
77 /* ------------------------------------------------------------------ */
78 /* Defines for Video Output Port Register at address 0x196 */
79 
80 /* Bits 2 to 0: VSYNC pin video vertical sync type */
81 
82 #define VP_VS_TYPE_MASK 0x07
83 
84 #define VP_VS_TYPE_OFF 0x00
85 #define VP_VS_TYPE_V123 0x01
86 #define VP_VS_TYPE_V_ITU 0x02
87 #define VP_VS_TYPE_VGATE_L 0x03
88 #define VP_VS_TYPE_RESERVED1 0x04
89 #define VP_VS_TYPE_RESERVED2 0x05
90 #define VP_VS_TYPE_F_ITU 0x06
91 #define VP_VS_TYPE_SC_FID 0x07
92 
93 /* ------------------------------------------------------------------ */
94 /* data structs for video */
95 
96 static int video_out[][9] = {
97  [CCIR656] = { 0x00, 0xb1, 0x00, 0xa1, 0x00, 0x04, 0x06, 0x00, 0x00 },
98 };
99 
100 static struct saa7134_format formats[] = {
101  {
102  .name = "8 bpp gray",
103  .fourcc = V4L2_PIX_FMT_GREY,
104  .depth = 8,
105  .pm = 0x06,
106  },{
107  .name = "15 bpp RGB, le",
108  .fourcc = V4L2_PIX_FMT_RGB555,
109  .depth = 16,
110  .pm = 0x13 | 0x80,
111  },{
112  .name = "15 bpp RGB, be",
113  .fourcc = V4L2_PIX_FMT_RGB555X,
114  .depth = 16,
115  .pm = 0x13 | 0x80,
116  .bswap = 1,
117  },{
118  .name = "16 bpp RGB, le",
119  .fourcc = V4L2_PIX_FMT_RGB565,
120  .depth = 16,
121  .pm = 0x10 | 0x80,
122  },{
123  .name = "16 bpp RGB, be",
124  .fourcc = V4L2_PIX_FMT_RGB565X,
125  .depth = 16,
126  .pm = 0x10 | 0x80,
127  .bswap = 1,
128  },{
129  .name = "24 bpp RGB, le",
130  .fourcc = V4L2_PIX_FMT_BGR24,
131  .depth = 24,
132  .pm = 0x11,
133  },{
134  .name = "24 bpp RGB, be",
135  .fourcc = V4L2_PIX_FMT_RGB24,
136  .depth = 24,
137  .pm = 0x11,
138  .bswap = 1,
139  },{
140  .name = "32 bpp RGB, le",
141  .fourcc = V4L2_PIX_FMT_BGR32,
142  .depth = 32,
143  .pm = 0x12,
144  },{
145  .name = "32 bpp RGB, be",
146  .fourcc = V4L2_PIX_FMT_RGB32,
147  .depth = 32,
148  .pm = 0x12,
149  .bswap = 1,
150  .wswap = 1,
151  },{
152  .name = "4:2:2 packed, YUYV",
153  .fourcc = V4L2_PIX_FMT_YUYV,
154  .depth = 16,
155  .pm = 0x00,
156  .bswap = 1,
157  .yuv = 1,
158  },{
159  .name = "4:2:2 packed, UYVY",
160  .fourcc = V4L2_PIX_FMT_UYVY,
161  .depth = 16,
162  .pm = 0x00,
163  .yuv = 1,
164  },{
165  .name = "4:2:2 planar, Y-Cb-Cr",
166  .fourcc = V4L2_PIX_FMT_YUV422P,
167  .depth = 16,
168  .pm = 0x09,
169  .yuv = 1,
170  .planar = 1,
171  .hshift = 1,
172  .vshift = 0,
173  },{
174  .name = "4:2:0 planar, Y-Cb-Cr",
175  .fourcc = V4L2_PIX_FMT_YUV420,
176  .depth = 12,
177  .pm = 0x0a,
178  .yuv = 1,
179  .planar = 1,
180  .hshift = 1,
181  .vshift = 1,
182  },{
183  .name = "4:2:0 planar, Y-Cb-Cr",
184  .fourcc = V4L2_PIX_FMT_YVU420,
185  .depth = 12,
186  .pm = 0x0a,
187  .yuv = 1,
188  .planar = 1,
189  .uvswap = 1,
190  .hshift = 1,
191  .vshift = 1,
192  }
193 };
194 #define FORMATS ARRAY_SIZE(formats)
195 
196 #define NORM_625_50 \
197  .h_start = 0, \
198  .h_stop = 719, \
199  .video_v_start = 24, \
200  .video_v_stop = 311, \
201  .vbi_v_start_0 = 7, \
202  .vbi_v_stop_0 = 22, \
203  .vbi_v_start_1 = 319, \
204  .src_timing = 4
205 
206 #define NORM_525_60 \
207  .h_start = 0, \
208  .h_stop = 719, \
209  .video_v_start = 23, \
210  .video_v_stop = 262, \
211  .vbi_v_start_0 = 10, \
212  .vbi_v_stop_0 = 21, \
213  .vbi_v_start_1 = 273, \
214  .src_timing = 7
215 
216 static struct saa7134_tvnorm tvnorms[] = {
217  {
218  .name = "PAL", /* autodetect */
219  .id = V4L2_STD_PAL,
220  NORM_625_50,
221 
222  .sync_control = 0x18,
223  .luma_control = 0x40,
224  .chroma_ctrl1 = 0x81,
225  .chroma_gain = 0x2a,
226  .chroma_ctrl2 = 0x06,
227  .vgate_misc = 0x1c,
228 
229  },{
230  .name = "PAL-BG",
231  .id = V4L2_STD_PAL_BG,
232  NORM_625_50,
233 
234  .sync_control = 0x18,
235  .luma_control = 0x40,
236  .chroma_ctrl1 = 0x81,
237  .chroma_gain = 0x2a,
238  .chroma_ctrl2 = 0x06,
239  .vgate_misc = 0x1c,
240 
241  },{
242  .name = "PAL-I",
243  .id = V4L2_STD_PAL_I,
244  NORM_625_50,
245 
246  .sync_control = 0x18,
247  .luma_control = 0x40,
248  .chroma_ctrl1 = 0x81,
249  .chroma_gain = 0x2a,
250  .chroma_ctrl2 = 0x06,
251  .vgate_misc = 0x1c,
252 
253  },{
254  .name = "PAL-DK",
255  .id = V4L2_STD_PAL_DK,
256  NORM_625_50,
257 
258  .sync_control = 0x18,
259  .luma_control = 0x40,
260  .chroma_ctrl1 = 0x81,
261  .chroma_gain = 0x2a,
262  .chroma_ctrl2 = 0x06,
263  .vgate_misc = 0x1c,
264 
265  },{
266  .name = "NTSC",
267  .id = V4L2_STD_NTSC,
268  NORM_525_60,
269 
270  .sync_control = 0x59,
271  .luma_control = 0x40,
272  .chroma_ctrl1 = 0x89,
273  .chroma_gain = 0x2a,
274  .chroma_ctrl2 = 0x0e,
275  .vgate_misc = 0x18,
276 
277  },{
278  .name = "SECAM",
279  .id = V4L2_STD_SECAM,
280  NORM_625_50,
281 
282  .sync_control = 0x18,
283  .luma_control = 0x1b,
284  .chroma_ctrl1 = 0xd1,
285  .chroma_gain = 0x80,
286  .chroma_ctrl2 = 0x00,
287  .vgate_misc = 0x1c,
288 
289  },{
290  .name = "SECAM-DK",
291  .id = V4L2_STD_SECAM_DK,
292  NORM_625_50,
293 
294  .sync_control = 0x18,
295  .luma_control = 0x1b,
296  .chroma_ctrl1 = 0xd1,
297  .chroma_gain = 0x80,
298  .chroma_ctrl2 = 0x00,
299  .vgate_misc = 0x1c,
300 
301  },{
302  .name = "SECAM-L",
303  .id = V4L2_STD_SECAM_L,
304  NORM_625_50,
305 
306  .sync_control = 0x18,
307  .luma_control = 0x1b,
308  .chroma_ctrl1 = 0xd1,
309  .chroma_gain = 0x80,
310  .chroma_ctrl2 = 0x00,
311  .vgate_misc = 0x1c,
312 
313  },{
314  .name = "SECAM-Lc",
315  .id = V4L2_STD_SECAM_LC,
316  NORM_625_50,
317 
318  .sync_control = 0x18,
319  .luma_control = 0x1b,
320  .chroma_ctrl1 = 0xd1,
321  .chroma_gain = 0x80,
322  .chroma_ctrl2 = 0x00,
323  .vgate_misc = 0x1c,
324 
325  },{
326  .name = "PAL-M",
327  .id = V4L2_STD_PAL_M,
328  NORM_525_60,
329 
330  .sync_control = 0x59,
331  .luma_control = 0x40,
332  .chroma_ctrl1 = 0xb9,
333  .chroma_gain = 0x2a,
334  .chroma_ctrl2 = 0x0e,
335  .vgate_misc = 0x18,
336 
337  },{
338  .name = "PAL-Nc",
339  .id = V4L2_STD_PAL_Nc,
340  NORM_625_50,
341 
342  .sync_control = 0x18,
343  .luma_control = 0x40,
344  .chroma_ctrl1 = 0xa1,
345  .chroma_gain = 0x2a,
346  .chroma_ctrl2 = 0x06,
347  .vgate_misc = 0x1c,
348 
349  },{
350  .name = "PAL-60",
351  .id = V4L2_STD_PAL_60,
352 
353  .h_start = 0,
354  .h_stop = 719,
355  .video_v_start = 23,
356  .video_v_stop = 262,
357  .vbi_v_start_0 = 10,
358  .vbi_v_stop_0 = 21,
359  .vbi_v_start_1 = 273,
360  .src_timing = 7,
361 
362  .sync_control = 0x18,
363  .luma_control = 0x40,
364  .chroma_ctrl1 = 0x81,
365  .chroma_gain = 0x2a,
366  .chroma_ctrl2 = 0x06,
367  .vgate_misc = 0x1c,
368  }
369 };
370 #define TVNORMS ARRAY_SIZE(tvnorms)
371 
372 #define V4L2_CID_PRIVATE_INVERT (V4L2_CID_PRIVATE_BASE + 0)
373 #define V4L2_CID_PRIVATE_Y_ODD (V4L2_CID_PRIVATE_BASE + 1)
374 #define V4L2_CID_PRIVATE_Y_EVEN (V4L2_CID_PRIVATE_BASE + 2)
375 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 3)
376 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 4)
377 
378 static const struct v4l2_queryctrl no_ctrl = {
379  .name = "42",
380  .flags = V4L2_CTRL_FLAG_DISABLED,
381 };
382 static const struct v4l2_queryctrl video_ctrls[] = {
383  /* --- video --- */
384  {
385  .id = V4L2_CID_BRIGHTNESS,
386  .name = "Brightness",
387  .minimum = 0,
388  .maximum = 255,
389  .step = 1,
390  .default_value = 128,
391  .type = V4L2_CTRL_TYPE_INTEGER,
392  },{
393  .id = V4L2_CID_CONTRAST,
394  .name = "Contrast",
395  .minimum = 0,
396  .maximum = 127,
397  .step = 1,
398  .default_value = 68,
399  .type = V4L2_CTRL_TYPE_INTEGER,
400  },{
401  .id = V4L2_CID_SATURATION,
402  .name = "Saturation",
403  .minimum = 0,
404  .maximum = 127,
405  .step = 1,
406  .default_value = 64,
407  .type = V4L2_CTRL_TYPE_INTEGER,
408  },{
409  .id = V4L2_CID_HUE,
410  .name = "Hue",
411  .minimum = -128,
412  .maximum = 127,
413  .step = 1,
414  .default_value = 0,
415  .type = V4L2_CTRL_TYPE_INTEGER,
416  },{
417  .id = V4L2_CID_HFLIP,
418  .name = "Mirror",
419  .minimum = 0,
420  .maximum = 1,
421  .type = V4L2_CTRL_TYPE_BOOLEAN,
422  },
423  /* --- audio --- */
424  {
425  .id = V4L2_CID_AUDIO_MUTE,
426  .name = "Mute",
427  .minimum = 0,
428  .maximum = 1,
429  .type = V4L2_CTRL_TYPE_BOOLEAN,
430  },{
431  .id = V4L2_CID_AUDIO_VOLUME,
432  .name = "Volume",
433  .minimum = -15,
434  .maximum = 15,
435  .step = 1,
436  .default_value = 0,
437  .type = V4L2_CTRL_TYPE_INTEGER,
438  },
439  /* --- private --- */
440  {
441  .id = V4L2_CID_PRIVATE_INVERT,
442  .name = "Invert",
443  .minimum = 0,
444  .maximum = 1,
445  .type = V4L2_CTRL_TYPE_BOOLEAN,
446  },{
447  .id = V4L2_CID_PRIVATE_Y_ODD,
448  .name = "y offset odd field",
449  .minimum = 0,
450  .maximum = 128,
451  .step = 1,
452  .default_value = 0,
453  .type = V4L2_CTRL_TYPE_INTEGER,
454  },{
455  .id = V4L2_CID_PRIVATE_Y_EVEN,
456  .name = "y offset even field",
457  .minimum = 0,
458  .maximum = 128,
459  .step = 1,
460  .default_value = 0,
461  .type = V4L2_CTRL_TYPE_INTEGER,
462  },{
463  .id = V4L2_CID_PRIVATE_AUTOMUTE,
464  .name = "automute",
465  .minimum = 0,
466  .maximum = 1,
467  .default_value = 1,
468  .type = V4L2_CTRL_TYPE_BOOLEAN,
469  }
470 };
471 static const unsigned int CTRLS = ARRAY_SIZE(video_ctrls);
472 
473 static const struct v4l2_queryctrl* ctrl_by_id(unsigned int id)
474 {
475  unsigned int i;
476 
477  for (i = 0; i < CTRLS; i++)
478  if (video_ctrls[i].id == id)
479  return video_ctrls+i;
480  return NULL;
481 }
482 
483 static struct saa7134_format* format_by_fourcc(unsigned int fourcc)
484 {
485  unsigned int i;
486 
487  for (i = 0; i < FORMATS; i++)
488  if (formats[i].fourcc == fourcc)
489  return formats+i;
490  return NULL;
491 }
492 
493 /* ----------------------------------------------------------------------- */
494 /* resource management */
495 
496 static int res_get(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bit)
497 {
498  if (fh->resources & bit)
499  /* have it already allocated */
500  return 1;
501 
502  /* is it free? */
503  mutex_lock(&dev->lock);
504  if (dev->resources & bit) {
505  /* no, someone else uses it */
506  mutex_unlock(&dev->lock);
507  return 0;
508  }
509  /* it's free, grab it */
510  fh->resources |= bit;
511  dev->resources |= bit;
512  dprintk("res: get %d\n",bit);
513  mutex_unlock(&dev->lock);
514  return 1;
515 }
516 
517 static int res_check(struct saa7134_fh *fh, unsigned int bit)
518 {
519  return (fh->resources & bit);
520 }
521 
522 static int res_locked(struct saa7134_dev *dev, unsigned int bit)
523 {
524  return (dev->resources & bit);
525 }
526 
527 static
528 void res_free(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bits)
529 {
530  BUG_ON((fh->resources & bits) != bits);
531 
532  mutex_lock(&dev->lock);
533  fh->resources &= ~bits;
534  dev->resources &= ~bits;
535  dprintk("res: put %d\n",bits);
536  mutex_unlock(&dev->lock);
537 }
538 
539 /* ------------------------------------------------------------------ */
540 
541 static void set_tvnorm(struct saa7134_dev *dev, struct saa7134_tvnorm *norm)
542 {
543  dprintk("set tv norm = %s\n",norm->name);
544  dev->tvnorm = norm;
545 
546  /* setup cropping */
547  dev->crop_bounds.left = norm->h_start;
548  dev->crop_defrect.left = norm->h_start;
549  dev->crop_bounds.width = norm->h_stop - norm->h_start +1;
550  dev->crop_defrect.width = norm->h_stop - norm->h_start +1;
551 
552  dev->crop_bounds.top = (norm->vbi_v_stop_0+1)*2;
553  dev->crop_defrect.top = norm->video_v_start*2;
554  dev->crop_bounds.height = ((norm->id & V4L2_STD_525_60) ? 524 : 624)
555  - dev->crop_bounds.top;
556  dev->crop_defrect.height = (norm->video_v_stop - norm->video_v_start +1)*2;
557 
558  dev->crop_current = dev->crop_defrect;
559 
560  saa7134_set_tvnorm_hw(dev);
561 }
562 
563 static void video_mux(struct saa7134_dev *dev, int input)
564 {
565  dprintk("video input = %d [%s]\n", input, card_in(dev, input).name);
566  dev->ctl_input = input;
567  set_tvnorm(dev, dev->tvnorm);
568  saa7134_tvaudio_setinput(dev, &card_in(dev, input));
569 }
570 
571 
572 static void saa7134_set_decoder(struct saa7134_dev *dev)
573 {
574  int luma_control, sync_control, mux;
575 
576  struct saa7134_tvnorm *norm = dev->tvnorm;
577  mux = card_in(dev, dev->ctl_input).vmux;
578 
579  luma_control = norm->luma_control;
580  sync_control = norm->sync_control;
581 
582  if (mux > 5)
583  luma_control |= 0x80; /* svideo */
584  if (noninterlaced || dev->nosignal)
585  sync_control |= 0x20;
586 
587  /* setup video decoder */
588  saa_writeb(SAA7134_INCR_DELAY, 0x08);
589  saa_writeb(SAA7134_ANALOG_IN_CTRL1, 0xc0 | mux);
590  saa_writeb(SAA7134_ANALOG_IN_CTRL2, 0x00);
591 
592  saa_writeb(SAA7134_ANALOG_IN_CTRL3, 0x90);
593  saa_writeb(SAA7134_ANALOG_IN_CTRL4, 0x90);
594  saa_writeb(SAA7134_HSYNC_START, 0xeb);
595  saa_writeb(SAA7134_HSYNC_STOP, 0xe0);
596  saa_writeb(SAA7134_SOURCE_TIMING1, norm->src_timing);
597 
598  saa_writeb(SAA7134_SYNC_CTRL, sync_control);
599  saa_writeb(SAA7134_LUMA_CTRL, luma_control);
600  saa_writeb(SAA7134_DEC_LUMA_BRIGHT, dev->ctl_bright);
601 
602  saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
603  dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
604 
605  saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
606  dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
607 
608  saa_writeb(SAA7134_DEC_CHROMA_HUE, dev->ctl_hue);
609  saa_writeb(SAA7134_CHROMA_CTRL1, norm->chroma_ctrl1);
610  saa_writeb(SAA7134_CHROMA_GAIN, norm->chroma_gain);
611 
612  saa_writeb(SAA7134_CHROMA_CTRL2, norm->chroma_ctrl2);
613  saa_writeb(SAA7134_MODE_DELAY_CTRL, 0x00);
614 
615  saa_writeb(SAA7134_ANALOG_ADC, 0x01);
616  saa_writeb(SAA7134_VGATE_START, 0x11);
617  saa_writeb(SAA7134_VGATE_STOP, 0xfe);
618  saa_writeb(SAA7134_MISC_VGATE_MSB, norm->vgate_misc);
619  saa_writeb(SAA7134_RAW_DATA_GAIN, 0x40);
620  saa_writeb(SAA7134_RAW_DATA_OFFSET, 0x80);
621 }
622 
623 void saa7134_set_tvnorm_hw(struct saa7134_dev *dev)
624 {
625  saa7134_set_decoder(dev);
626 
627  if (card_in(dev, dev->ctl_input).tv)
628  saa_call_all(dev, core, s_std, dev->tvnorm->id);
629  /* Set the correct norm for the saa6752hs. This function
630  does nothing if there is no saa6752hs. */
631  saa_call_empress(dev, core, s_std, dev->tvnorm->id);
632 }
633 
634 static void set_h_prescale(struct saa7134_dev *dev, int task, int prescale)
635 {
636  static const struct {
637  int xpsc;
638  int xacl;
639  int xc2_1;
640  int xdcg;
641  int vpfy;
642  } vals[] = {
643  /* XPSC XACL XC2_1 XDCG VPFY */
644  { 1, 0, 0, 0, 0 },
645  { 2, 2, 1, 2, 2 },
646  { 3, 4, 1, 3, 2 },
647  { 4, 8, 1, 4, 2 },
648  { 5, 8, 1, 4, 2 },
649  { 6, 8, 1, 4, 3 },
650  { 7, 8, 1, 4, 3 },
651  { 8, 15, 0, 4, 3 },
652  { 9, 15, 0, 4, 3 },
653  { 10, 16, 1, 5, 3 },
654  };
655  static const int count = ARRAY_SIZE(vals);
656  int i;
657 
658  for (i = 0; i < count; i++)
659  if (vals[i].xpsc == prescale)
660  break;
661  if (i == count)
662  return;
663 
664  saa_writeb(SAA7134_H_PRESCALE(task), vals[i].xpsc);
665  saa_writeb(SAA7134_ACC_LENGTH(task), vals[i].xacl);
666  saa_writeb(SAA7134_LEVEL_CTRL(task),
667  (vals[i].xc2_1 << 3) | (vals[i].xdcg));
668  saa_andorb(SAA7134_FIR_PREFILTER_CTRL(task), 0x0f,
669  (vals[i].vpfy << 2) | vals[i].vpfy);
670 }
671 
672 static void set_v_scale(struct saa7134_dev *dev, int task, int yscale)
673 {
674  int val,mirror;
675 
676  saa_writeb(SAA7134_V_SCALE_RATIO1(task), yscale & 0xff);
677  saa_writeb(SAA7134_V_SCALE_RATIO2(task), yscale >> 8);
678 
679  mirror = (dev->ctl_mirror) ? 0x02 : 0x00;
680  if (yscale < 2048) {
681  /* LPI */
682  dprintk("yscale LPI yscale=%d\n",yscale);
683  saa_writeb(SAA7134_V_FILTER(task), 0x00 | mirror);
684  saa_writeb(SAA7134_LUMA_CONTRAST(task), 0x40);
685  saa_writeb(SAA7134_CHROMA_SATURATION(task), 0x40);
686  } else {
687  /* ACM */
688  val = 0x40 * 1024 / yscale;
689  dprintk("yscale ACM yscale=%d val=0x%x\n",yscale,val);
690  saa_writeb(SAA7134_V_FILTER(task), 0x01 | mirror);
691  saa_writeb(SAA7134_LUMA_CONTRAST(task), val);
692  saa_writeb(SAA7134_CHROMA_SATURATION(task), val);
693  }
694  saa_writeb(SAA7134_LUMA_BRIGHT(task), 0x80);
695 }
696 
697 static void set_size(struct saa7134_dev *dev, int task,
698  int width, int height, int interlace)
699 {
700  int prescale,xscale,yscale,y_even,y_odd;
701  int h_start, h_stop, v_start, v_stop;
702  int div = interlace ? 2 : 1;
703 
704  /* setup video scaler */
705  h_start = dev->crop_current.left;
706  v_start = dev->crop_current.top/2;
707  h_stop = (dev->crop_current.left + dev->crop_current.width -1);
708  v_stop = (dev->crop_current.top + dev->crop_current.height -1)/2;
709 
710  saa_writeb(SAA7134_VIDEO_H_START1(task), h_start & 0xff);
711  saa_writeb(SAA7134_VIDEO_H_START2(task), h_start >> 8);
712  saa_writeb(SAA7134_VIDEO_H_STOP1(task), h_stop & 0xff);
713  saa_writeb(SAA7134_VIDEO_H_STOP2(task), h_stop >> 8);
714  saa_writeb(SAA7134_VIDEO_V_START1(task), v_start & 0xff);
715  saa_writeb(SAA7134_VIDEO_V_START2(task), v_start >> 8);
716  saa_writeb(SAA7134_VIDEO_V_STOP1(task), v_stop & 0xff);
717  saa_writeb(SAA7134_VIDEO_V_STOP2(task), v_stop >> 8);
718 
719  prescale = dev->crop_current.width / width;
720  if (0 == prescale)
721  prescale = 1;
722  xscale = 1024 * dev->crop_current.width / prescale / width;
723  yscale = 512 * div * dev->crop_current.height / height;
724  dprintk("prescale=%d xscale=%d yscale=%d\n",prescale,xscale,yscale);
725  set_h_prescale(dev,task,prescale);
726  saa_writeb(SAA7134_H_SCALE_INC1(task), xscale & 0xff);
727  saa_writeb(SAA7134_H_SCALE_INC2(task), xscale >> 8);
728  set_v_scale(dev,task,yscale);
729 
730  saa_writeb(SAA7134_VIDEO_PIXELS1(task), width & 0xff);
731  saa_writeb(SAA7134_VIDEO_PIXELS2(task), width >> 8);
732  saa_writeb(SAA7134_VIDEO_LINES1(task), height/div & 0xff);
733  saa_writeb(SAA7134_VIDEO_LINES2(task), height/div >> 8);
734 
735  /* deinterlace y offsets */
736  y_odd = dev->ctl_y_odd;
737  y_even = dev->ctl_y_even;
738  saa_writeb(SAA7134_V_PHASE_OFFSET0(task), y_odd);
739  saa_writeb(SAA7134_V_PHASE_OFFSET1(task), y_even);
740  saa_writeb(SAA7134_V_PHASE_OFFSET2(task), y_odd);
741  saa_writeb(SAA7134_V_PHASE_OFFSET3(task), y_even);
742 }
743 
744 /* ------------------------------------------------------------------ */
745 
746 struct cliplist {
747  __u16 position;
748  __u8 enable;
749  __u8 disable;
750 };
751 
752 static void set_cliplist(struct saa7134_dev *dev, int reg,
753  struct cliplist *cl, int entries, char *name)
754 {
755  __u8 winbits = 0;
756  int i;
757 
758  for (i = 0; i < entries; i++) {
759  winbits |= cl[i].enable;
760  winbits &= ~cl[i].disable;
761  if (i < 15 && cl[i].position == cl[i+1].position)
762  continue;
763  saa_writeb(reg + 0, winbits);
764  saa_writeb(reg + 2, cl[i].position & 0xff);
765  saa_writeb(reg + 3, cl[i].position >> 8);
766  dprintk("clip: %s winbits=%02x pos=%d\n",
767  name,winbits,cl[i].position);
768  reg += 8;
769  }
770  for (; reg < 0x400; reg += 8) {
771  saa_writeb(reg+ 0, 0);
772  saa_writeb(reg + 1, 0);
773  saa_writeb(reg + 2, 0);
774  saa_writeb(reg + 3, 0);
775  }
776 }
777 
778 static int clip_range(int val)
779 {
780  if (val < 0)
781  val = 0;
782  return val;
783 }
784 
785 /* Sort into smallest position first order */
786 static int cliplist_cmp(const void *a, const void *b)
787 {
788  const struct cliplist *cla = a;
789  const struct cliplist *clb = b;
790  if (cla->position < clb->position)
791  return -1;
792  if (cla->position > clb->position)
793  return 1;
794  return 0;
795 }
796 
797 static int setup_clipping(struct saa7134_dev *dev, struct v4l2_clip *clips,
798  int nclips, int interlace)
799 {
800  struct cliplist col[16], row[16];
801  int cols = 0, rows = 0, i;
802  int div = interlace ? 2 : 1;
803 
804  memset(col, 0, sizeof(col));
805  memset(row, 0, sizeof(row));
806  for (i = 0; i < nclips && i < 8; i++) {
807  col[cols].position = clip_range(clips[i].c.left);
808  col[cols].enable = (1 << i);
809  cols++;
810  col[cols].position = clip_range(clips[i].c.left+clips[i].c.width);
811  col[cols].disable = (1 << i);
812  cols++;
813  row[rows].position = clip_range(clips[i].c.top / div);
814  row[rows].enable = (1 << i);
815  rows++;
816  row[rows].position = clip_range((clips[i].c.top + clips[i].c.height)
817  / div);
818  row[rows].disable = (1 << i);
819  rows++;
820  }
821  sort(col, cols, sizeof col[0], cliplist_cmp, NULL);
822  sort(row, rows, sizeof row[0], cliplist_cmp, NULL);
823  set_cliplist(dev,0x380,col,cols,"cols");
824  set_cliplist(dev,0x384,row,rows,"rows");
825  return 0;
826 }
827 
828 static int verify_preview(struct saa7134_dev *dev, struct v4l2_window *win)
829 {
830  enum v4l2_field field;
831  int maxw, maxh;
832 
833  if (NULL == dev->ovbuf.base)
834  return -EINVAL;
835  if (NULL == dev->ovfmt)
836  return -EINVAL;
837  if (win->w.width < 48 || win->w.height < 32)
838  return -EINVAL;
839  if (win->clipcount > 2048)
840  return -EINVAL;
841 
842  field = win->field;
843  maxw = dev->crop_current.width;
844  maxh = dev->crop_current.height;
845 
846  if (V4L2_FIELD_ANY == field) {
847  field = (win->w.height > maxh/2)
848  ? V4L2_FIELD_INTERLACED
849  : V4L2_FIELD_TOP;
850  }
851  switch (field) {
852  case V4L2_FIELD_TOP:
853  case V4L2_FIELD_BOTTOM:
854  maxh = maxh / 2;
855  break;
856  case V4L2_FIELD_INTERLACED:
857  break;
858  default:
859  return -EINVAL;
860  }
861 
862  win->field = field;
863  if (win->w.width > maxw)
864  win->w.width = maxw;
865  if (win->w.height > maxh)
866  win->w.height = maxh;
867  return 0;
868 }
869 
870 static int start_preview(struct saa7134_dev *dev, struct saa7134_fh *fh)
871 {
872  unsigned long base,control,bpl;
873  int err;
874 
875  err = verify_preview(dev,&fh->win);
876  if (0 != err)
877  return err;
878 
879  dev->ovfield = fh->win.field;
880  dprintk("start_preview %dx%d+%d+%d %s field=%s\n",
881  fh->win.w.width,fh->win.w.height,
882  fh->win.w.left,fh->win.w.top,
883  dev->ovfmt->name,v4l2_field_names[dev->ovfield]);
884 
885  /* setup window + clipping */
886  set_size(dev,TASK_B,fh->win.w.width,fh->win.w.height,
887  V4L2_FIELD_HAS_BOTH(dev->ovfield));
888  setup_clipping(dev,fh->clips,fh->nclips,
889  V4L2_FIELD_HAS_BOTH(dev->ovfield));
890  if (dev->ovfmt->yuv)
891  saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x03);
892  else
893  saa_andorb(SAA7134_DATA_PATH(TASK_B), 0x3f, 0x01);
894  saa_writeb(SAA7134_OFMT_VIDEO_B, dev->ovfmt->pm | 0x20);
895 
896  /* dma: setup channel 1 (= Video Task B) */
897  base = (unsigned long)dev->ovbuf.base;
898  base += dev->ovbuf.fmt.bytesperline * fh->win.w.top;
899  base += dev->ovfmt->depth/8 * fh->win.w.left;
900  bpl = dev->ovbuf.fmt.bytesperline;
901  control = SAA7134_RS_CONTROL_BURST_16;
902  if (dev->ovfmt->bswap)
903  control |= SAA7134_RS_CONTROL_BSWAP;
904  if (dev->ovfmt->wswap)
905  control |= SAA7134_RS_CONTROL_WSWAP;
906  if (V4L2_FIELD_HAS_BOTH(dev->ovfield)) {
907  saa_writel(SAA7134_RS_BA1(1),base);
908  saa_writel(SAA7134_RS_BA2(1),base+bpl);
909  saa_writel(SAA7134_RS_PITCH(1),bpl*2);
910  saa_writel(SAA7134_RS_CONTROL(1),control);
911  } else {
912  saa_writel(SAA7134_RS_BA1(1),base);
913  saa_writel(SAA7134_RS_BA2(1),base);
914  saa_writel(SAA7134_RS_PITCH(1),bpl);
915  saa_writel(SAA7134_RS_CONTROL(1),control);
916  }
917 
918  /* start dma */
919  dev->ovenable = 1;
920  saa7134_set_dmabits(dev);
921 
922  return 0;
923 }
924 
925 static int stop_preview(struct saa7134_dev *dev, struct saa7134_fh *fh)
926 {
927  dev->ovenable = 0;
928  saa7134_set_dmabits(dev);
929  return 0;
930 }
931 
932 /* ------------------------------------------------------------------ */
933 
934 static int buffer_activate(struct saa7134_dev *dev,
935  struct saa7134_buf *buf,
936  struct saa7134_buf *next)
937 {
938  unsigned long base,control,bpl;
939  unsigned long bpl_uv,lines_uv,base2,base3,tmp; /* planar */
940 
941  dprintk("buffer_activate buf=%p\n",buf);
942  buf->vb.state = VIDEOBUF_ACTIVE;
943  buf->top_seen = 0;
944 
945  set_size(dev,TASK_A,buf->vb.width,buf->vb.height,
946  V4L2_FIELD_HAS_BOTH(buf->vb.field));
947  if (buf->fmt->yuv)
948  saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x03);
949  else
950  saa_andorb(SAA7134_DATA_PATH(TASK_A), 0x3f, 0x01);
951  saa_writeb(SAA7134_OFMT_VIDEO_A, buf->fmt->pm);
952 
953  /* DMA: setup channel 0 (= Video Task A0) */
954  base = saa7134_buffer_base(buf);
955  if (buf->fmt->planar)
956  bpl = buf->vb.width;
957  else
958  bpl = (buf->vb.width * buf->fmt->depth) / 8;
959  control = SAA7134_RS_CONTROL_BURST_16 |
960  SAA7134_RS_CONTROL_ME |
961  (buf->pt->dma >> 12);
962  if (buf->fmt->bswap)
963  control |= SAA7134_RS_CONTROL_BSWAP;
964  if (buf->fmt->wswap)
965  control |= SAA7134_RS_CONTROL_WSWAP;
966  if (V4L2_FIELD_HAS_BOTH(buf->vb.field)) {
967  /* interlaced */
968  saa_writel(SAA7134_RS_BA1(0),base);
969  saa_writel(SAA7134_RS_BA2(0),base+bpl);
970  saa_writel(SAA7134_RS_PITCH(0),bpl*2);
971  } else {
972  /* non-interlaced */
973  saa_writel(SAA7134_RS_BA1(0),base);
974  saa_writel(SAA7134_RS_BA2(0),base);
975  saa_writel(SAA7134_RS_PITCH(0),bpl);
976  }
977  saa_writel(SAA7134_RS_CONTROL(0),control);
978 
979  if (buf->fmt->planar) {
980  /* DMA: setup channel 4+5 (= planar task A) */
981  bpl_uv = bpl >> buf->fmt->hshift;
982  lines_uv = buf->vb.height >> buf->fmt->vshift;
983  base2 = base + bpl * buf->vb.height;
984  base3 = base2 + bpl_uv * lines_uv;
985  if (buf->fmt->uvswap)
986  tmp = base2, base2 = base3, base3 = tmp;
987  dprintk("uv: bpl=%ld lines=%ld base2/3=%ld/%ld\n",
988  bpl_uv,lines_uv,base2,base3);
989  if (V4L2_FIELD_HAS_BOTH(buf->vb.field)) {
990  /* interlaced */
991  saa_writel(SAA7134_RS_BA1(4),base2);
992  saa_writel(SAA7134_RS_BA2(4),base2+bpl_uv);
993  saa_writel(SAA7134_RS_PITCH(4),bpl_uv*2);
994  saa_writel(SAA7134_RS_BA1(5),base3);
995  saa_writel(SAA7134_RS_BA2(5),base3+bpl_uv);
996  saa_writel(SAA7134_RS_PITCH(5),bpl_uv*2);
997  } else {
998  /* non-interlaced */
999  saa_writel(SAA7134_RS_BA1(4),base2);
1000  saa_writel(SAA7134_RS_BA2(4),base2);
1001  saa_writel(SAA7134_RS_PITCH(4),bpl_uv);
1002  saa_writel(SAA7134_RS_BA1(5),base3);
1003  saa_writel(SAA7134_RS_BA2(5),base3);
1004  saa_writel(SAA7134_RS_PITCH(5),bpl_uv);
1005  }
1006  saa_writel(SAA7134_RS_CONTROL(4),control);
1007  saa_writel(SAA7134_RS_CONTROL(5),control);
1008  }
1009 
1010  /* start DMA */
1011  saa7134_set_dmabits(dev);
1012  mod_timer(&dev->video_q.timeout, jiffies+BUFFER_TIMEOUT);
1013  return 0;
1014 }
1015 
1016 static int buffer_prepare(struct videobuf_queue *q,
1017  struct videobuf_buffer *vb,
1018  enum v4l2_field field)
1019 {
1020  struct saa7134_fh *fh = q->priv_data;
1021  struct saa7134_dev *dev = fh->dev;
1022  struct saa7134_buf *buf = container_of(vb,struct saa7134_buf,vb);
1023  unsigned int size;
1024  int err;
1025 
1026  /* sanity checks */
1027  if (NULL == fh->fmt)
1028  return -EINVAL;
1029  if (fh->width < 48 ||
1030  fh->height < 32 ||
1031  fh->width/4 > dev->crop_current.width ||
1032  fh->height/4 > dev->crop_current.height ||
1033  fh->width > dev->crop_bounds.width ||
1034  fh->height > dev->crop_bounds.height)
1035  return -EINVAL;
1036  size = (fh->width * fh->height * fh->fmt->depth) >> 3;
1037  if (0 != buf->vb.baddr && buf->vb.bsize < size)
1038  return -EINVAL;
1039 
1040  dprintk("buffer_prepare [%d,size=%dx%d,bytes=%d,fields=%s,%s]\n",
1041  vb->i,fh->width,fh->height,size,v4l2_field_names[field],
1042  fh->fmt->name);
1043  if (buf->vb.width != fh->width ||
1044  buf->vb.height != fh->height ||
1045  buf->vb.size != size ||
1046  buf->vb.field != field ||
1047  buf->fmt != fh->fmt) {
1048  saa7134_dma_free(q,buf);
1049  }
1050 
1051  if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1052  struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
1053 
1054  buf->vb.width = fh->width;
1055  buf->vb.height = fh->height;
1056  buf->vb.size = size;
1057  buf->vb.field = field;
1058  buf->fmt = fh->fmt;
1059  buf->pt = &fh->pt_cap;
1060  dev->video_q.curr = NULL;
1061 
1062  err = videobuf_iolock(q,&buf->vb,&dev->ovbuf);
1063  if (err)
1064  goto oops;
1065  err = saa7134_pgtable_build(dev->pci,buf->pt,
1066  dma->sglist,
1067  dma->sglen,
1068  saa7134_buffer_startpage(buf));
1069  if (err)
1070  goto oops;
1071  }
1072  buf->vb.state = VIDEOBUF_PREPARED;
1073  buf->activate = buffer_activate;
1074  return 0;
1075 
1076  oops:
1077  saa7134_dma_free(q,buf);
1078  return err;
1079 }
1080 
1081 static int
1082 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1083 {
1084  struct saa7134_fh *fh = q->priv_data;
1085 
1086  *size = fh->fmt->depth * fh->width * fh->height >> 3;
1087  if (0 == *count)
1088  *count = gbuffers;
1089  *count = saa7134_buffer_count(*size,*count);
1090  return 0;
1091 }
1092 
1093 static void buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1094 {
1095  struct saa7134_fh *fh = q->priv_data;
1096  struct saa7134_buf *buf = container_of(vb,struct saa7134_buf,vb);
1097 
1098  saa7134_buffer_queue(fh->dev,&fh->dev->video_q,buf);
1099 }
1100 
1101 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1102 {
1103  struct saa7134_buf *buf = container_of(vb,struct saa7134_buf,vb);
1104 
1105  saa7134_dma_free(q,buf);
1106 }
1107 
1108 static struct videobuf_queue_ops video_qops = {
1109  .buf_setup = buffer_setup,
1110  .buf_prepare = buffer_prepare,
1111  .buf_queue = buffer_queue,
1112  .buf_release = buffer_release,
1113 };
1114 
1115 /* ------------------------------------------------------------------ */
1116 
1117 int saa7134_g_ctrl_internal(struct saa7134_dev *dev, struct saa7134_fh *fh, struct v4l2_control *c)
1118 {
1119  const struct v4l2_queryctrl* ctrl;
1120 
1121  ctrl = ctrl_by_id(c->id);
1122  if (NULL == ctrl)
1123  return -EINVAL;
1124  switch (c->id) {
1125  case V4L2_CID_BRIGHTNESS:
1126  c->value = dev->ctl_bright;
1127  break;
1128  case V4L2_CID_HUE:
1129  c->value = dev->ctl_hue;
1130  break;
1131  case V4L2_CID_CONTRAST:
1132  c->value = dev->ctl_contrast;
1133  break;
1134  case V4L2_CID_SATURATION:
1135  c->value = dev->ctl_saturation;
1136  break;
1137  case V4L2_CID_AUDIO_MUTE:
1138  c->value = dev->ctl_mute;
1139  break;
1140  case V4L2_CID_AUDIO_VOLUME:
1141  c->value = dev->ctl_volume;
1142  break;
1143  case V4L2_CID_PRIVATE_INVERT:
1144  c->value = dev->ctl_invert;
1145  break;
1146  case V4L2_CID_HFLIP:
1147  c->value = dev->ctl_mirror;
1148  break;
1149  case V4L2_CID_PRIVATE_Y_EVEN:
1150  c->value = dev->ctl_y_even;
1151  break;
1152  case V4L2_CID_PRIVATE_Y_ODD:
1153  c->value = dev->ctl_y_odd;
1154  break;
1155  case V4L2_CID_PRIVATE_AUTOMUTE:
1156  c->value = dev->ctl_automute;
1157  break;
1158  default:
1159  return -EINVAL;
1160  }
1161  return 0;
1162 }
1163 EXPORT_SYMBOL_GPL(saa7134_g_ctrl_internal);
1164 
1165 static int saa7134_g_ctrl(struct file *file, void *priv, struct v4l2_control *c)
1166 {
1167  struct saa7134_fh *fh = priv;
1168 
1169  return saa7134_g_ctrl_internal(fh->dev, fh, c);
1170 }
1171 
1172 int saa7134_s_ctrl_internal(struct saa7134_dev *dev, struct saa7134_fh *fh, struct v4l2_control *c)
1173 {
1174  const struct v4l2_queryctrl* ctrl;
1175  unsigned long flags;
1176  int restart_overlay = 0;
1177  int err;
1178 
1179  /* When called from the empress code fh == NULL.
1180  That needs to be fixed somehow, but for now this is
1181  good enough. */
1182  if (fh) {
1183  err = v4l2_prio_check(&dev->prio, fh->prio);
1184  if (0 != err)
1185  return err;
1186  }
1187  err = -EINVAL;
1188 
1189  mutex_lock(&dev->lock);
1190 
1191  ctrl = ctrl_by_id(c->id);
1192  if (NULL == ctrl)
1193  goto error;
1194 
1195  dprintk("set_control name=%s val=%d\n",ctrl->name,c->value);
1196  switch (ctrl->type) {
1197  case V4L2_CTRL_TYPE_BOOLEAN:
1198  case V4L2_CTRL_TYPE_MENU:
1199  case V4L2_CTRL_TYPE_INTEGER:
1200  if (c->value < ctrl->minimum)
1201  c->value = ctrl->minimum;
1202  if (c->value > ctrl->maximum)
1203  c->value = ctrl->maximum;
1204  break;
1205  default:
1206  /* nothing */;
1207  }
1208  switch (c->id) {
1209  case V4L2_CID_BRIGHTNESS:
1210  dev->ctl_bright = c->value;
1211  saa_writeb(SAA7134_DEC_LUMA_BRIGHT, dev->ctl_bright);
1212  break;
1213  case V4L2_CID_HUE:
1214  dev->ctl_hue = c->value;
1215  saa_writeb(SAA7134_DEC_CHROMA_HUE, dev->ctl_hue);
1216  break;
1217  case V4L2_CID_CONTRAST:
1218  dev->ctl_contrast = c->value;
1219  saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
1220  dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
1221  break;
1222  case V4L2_CID_SATURATION:
1223  dev->ctl_saturation = c->value;
1224  saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
1225  dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
1226  break;
1227  case V4L2_CID_AUDIO_MUTE:
1228  dev->ctl_mute = c->value;
1229  saa7134_tvaudio_setmute(dev);
1230  break;
1231  case V4L2_CID_AUDIO_VOLUME:
1232  dev->ctl_volume = c->value;
1233  saa7134_tvaudio_setvolume(dev,dev->ctl_volume);
1234  break;
1235  case V4L2_CID_PRIVATE_INVERT:
1236  dev->ctl_invert = c->value;
1237  saa_writeb(SAA7134_DEC_LUMA_CONTRAST,
1238  dev->ctl_invert ? -dev->ctl_contrast : dev->ctl_contrast);
1239  saa_writeb(SAA7134_DEC_CHROMA_SATURATION,
1240  dev->ctl_invert ? -dev->ctl_saturation : dev->ctl_saturation);
1241  break;
1242  case V4L2_CID_HFLIP:
1243  dev->ctl_mirror = c->value;
1244  restart_overlay = 1;
1245  break;
1246  case V4L2_CID_PRIVATE_Y_EVEN:
1247  dev->ctl_y_even = c->value;
1248  restart_overlay = 1;
1249  break;
1250  case V4L2_CID_PRIVATE_Y_ODD:
1251  dev->ctl_y_odd = c->value;
1252  restart_overlay = 1;
1253  break;
1254  case V4L2_CID_PRIVATE_AUTOMUTE:
1255  {
1256  struct v4l2_priv_tun_config tda9887_cfg;
1257 
1258  tda9887_cfg.tuner = TUNER_TDA9887;
1259  tda9887_cfg.priv = &dev->tda9887_conf;
1260 
1261  dev->ctl_automute = c->value;
1262  if (dev->tda9887_conf) {
1263  if (dev->ctl_automute)
1264  dev->tda9887_conf |= TDA9887_AUTOMUTE;
1265  else
1266  dev->tda9887_conf &= ~TDA9887_AUTOMUTE;
1267 
1268  saa_call_all(dev, tuner, s_config, &tda9887_cfg);
1269  }
1270  break;
1271  }
1272  default:
1273  goto error;
1274  }
1275  if (restart_overlay && fh && res_check(fh, RESOURCE_OVERLAY)) {
1276  spin_lock_irqsave(&dev->slock,flags);
1277  stop_preview(dev,fh);
1278  start_preview(dev,fh);
1279  spin_unlock_irqrestore(&dev->slock,flags);
1280  }
1281  err = 0;
1282 
1283 error:
1284  mutex_unlock(&dev->lock);
1285  return err;
1286 }
1287 EXPORT_SYMBOL_GPL(saa7134_s_ctrl_internal);
1288 
1289 static int saa7134_s_ctrl(struct file *file, void *f, struct v4l2_control *c)
1290 {
1291  struct saa7134_fh *fh = f;
1292 
1293  return saa7134_s_ctrl_internal(fh->dev, fh, c);
1294 }
1295 
1296 /* ------------------------------------------------------------------ */
1297 
1298 static struct videobuf_queue* saa7134_queue(struct saa7134_fh *fh)
1299 {
1300  struct videobuf_queue* q = NULL;
1301 
1302  switch (fh->type) {
1303  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1304  q = &fh->cap;
1305  break;
1306  case V4L2_BUF_TYPE_VBI_CAPTURE:
1307  q = &fh->vbi;
1308  break;
1309  default:
1310  BUG();
1311  }
1312  return q;
1313 }
1314 
1315 static int saa7134_resource(struct saa7134_fh *fh)
1316 {
1317  if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1318  return RESOURCE_VIDEO;
1319 
1320  if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1321  return RESOURCE_VBI;
1322 
1323  BUG();
1324  return 0;
1325 }
1326 
1327 static int video_open(struct file *file)
1328 {
1329  struct video_device *vdev = video_devdata(file);
1330  struct saa7134_dev *dev = video_drvdata(file);
1331  struct saa7134_fh *fh;
1332  enum v4l2_buf_type type = 0;
1333  int radio = 0;
1334 
1335  switch (vdev->vfl_type) {
1336  case VFL_TYPE_GRABBER:
1337  type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1338  break;
1339  case VFL_TYPE_VBI:
1340  type = V4L2_BUF_TYPE_VBI_CAPTURE;
1341  break;
1342  case VFL_TYPE_RADIO:
1343  radio = 1;
1344  break;
1345  }
1346 
1347  dprintk("open dev=%s radio=%d type=%s\n", video_device_node_name(vdev),
1348  radio, v4l2_type_names[type]);
1349 
1350  /* allocate + initialize per filehandle data */
1351  fh = kzalloc(sizeof(*fh),GFP_KERNEL);
1352  if (NULL == fh)
1353  return -ENOMEM;
1354 
1355  file->private_data = fh;
1356  fh->dev = dev;
1357  fh->radio = radio;
1358  fh->type = type;
1359  fh->fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
1360  fh->width = 720;
1361  fh->height = 576;
1362  v4l2_prio_open(&dev->prio, &fh->prio);
1363 
1364  videobuf_queue_sg_init(&fh->cap, &video_qops,
1365  &dev->pci->dev, &dev->slock,
1366  V4L2_BUF_TYPE_VIDEO_CAPTURE,
1367  V4L2_FIELD_INTERLACED,
1368  sizeof(struct saa7134_buf),
1369  fh, NULL);
1370  videobuf_queue_sg_init(&fh->vbi, &saa7134_vbi_qops,
1371  &dev->pci->dev, &dev->slock,
1372  V4L2_BUF_TYPE_VBI_CAPTURE,
1373  V4L2_FIELD_SEQ_TB,
1374  sizeof(struct saa7134_buf),
1375  fh, NULL);
1376  saa7134_pgtable_alloc(dev->pci,&fh->pt_cap);
1377  saa7134_pgtable_alloc(dev->pci,&fh->pt_vbi);
1378 
1379  if (fh->radio) {
1380  /* switch to radio mode */
1381  saa7134_tvaudio_setinput(dev,&card(dev).radio);
1382  saa_call_all(dev, tuner, s_radio);
1383  } else {
1384  /* switch to video/vbi mode */
1385  video_mux(dev,dev->ctl_input);
1386  }
1387  return 0;
1388 }
1389 
1390 static ssize_t
1391 video_read(struct file *file, char __user *data, size_t count, loff_t *ppos)
1392 {
1393  struct saa7134_fh *fh = file->private_data;
1394 
1395  switch (fh->type) {
1396  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1397  if (res_locked(fh->dev,RESOURCE_VIDEO))
1398  return -EBUSY;
1399  return videobuf_read_one(saa7134_queue(fh),
1400  data, count, ppos,
1401  file->f_flags & O_NONBLOCK);
1402  case V4L2_BUF_TYPE_VBI_CAPTURE:
1403  if (!res_get(fh->dev,fh,RESOURCE_VBI))
1404  return -EBUSY;
1405  return videobuf_read_stream(saa7134_queue(fh),
1406  data, count, ppos, 1,
1407  file->f_flags & O_NONBLOCK);
1408  break;
1409  default:
1410  BUG();
1411  return 0;
1412  }
1413 }
1414 
1415 static unsigned int
1416 video_poll(struct file *file, struct poll_table_struct *wait)
1417 {
1418  struct saa7134_fh *fh = file->private_data;
1419  struct videobuf_buffer *buf = NULL;
1420  unsigned int rc = 0;
1421 
1422  if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
1423  return videobuf_poll_stream(file, &fh->vbi, wait);
1424 
1425  if (res_check(fh,RESOURCE_VIDEO)) {
1426  mutex_lock(&fh->cap.vb_lock);
1427  if (!list_empty(&fh->cap.stream))
1428  buf = list_entry(fh->cap.stream.next, struct videobuf_buffer, stream);
1429  } else {
1430  mutex_lock(&fh->cap.vb_lock);
1431  if (UNSET == fh->cap.read_off) {
1432  /* need to capture a new frame */
1433  if (res_locked(fh->dev,RESOURCE_VIDEO))
1434  goto err;
1435  if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,fh->cap.field))
1436  goto err;
1437  fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
1438  fh->cap.read_off = 0;
1439  }
1440  buf = fh->cap.read_buf;
1441  }
1442 
1443  if (!buf)
1444  goto err;
1445 
1446  poll_wait(file, &buf->done, wait);
1447  if (buf->state == VIDEOBUF_DONE ||
1448  buf->state == VIDEOBUF_ERROR)
1449  rc = POLLIN|POLLRDNORM;
1450  mutex_unlock(&fh->cap.vb_lock);
1451  return rc;
1452 
1453 err:
1454  mutex_unlock(&fh->cap.vb_lock);
1455  return POLLERR;
1456 }
1457 
1458 static int video_release(struct file *file)
1459 {
1460  struct saa7134_fh *fh = file->private_data;
1461  struct saa7134_dev *dev = fh->dev;
1462  struct saa6588_command cmd;
1463  unsigned long flags;
1464 
1465  saa7134_tvaudio_close(dev);
1466 
1467  /* turn off overlay */
1468  if (res_check(fh, RESOURCE_OVERLAY)) {
1469  spin_lock_irqsave(&dev->slock,flags);
1470  stop_preview(dev,fh);
1471  spin_unlock_irqrestore(&dev->slock,flags);
1472  res_free(dev,fh,RESOURCE_OVERLAY);
1473  }
1474 
1475  /* stop video capture */
1476  if (res_check(fh, RESOURCE_VIDEO)) {
1477  videobuf_streamoff(&fh->cap);
1478  res_free(dev,fh,RESOURCE_VIDEO);
1479  }
1480  if (fh->cap.read_buf) {
1481  buffer_release(&fh->cap,fh->cap.read_buf);
1482  kfree(fh->cap.read_buf);
1483  }
1484 
1485  /* stop vbi capture */
1486  if (res_check(fh, RESOURCE_VBI)) {
1487  videobuf_stop(&fh->vbi);
1488  res_free(dev,fh,RESOURCE_VBI);
1489  }
1490 
1491  /* ts-capture will not work in planar mode, so turn it off Hac: 04.05*/
1492  saa_andorb(SAA7134_OFMT_VIDEO_A, 0x1f, 0);
1493  saa_andorb(SAA7134_OFMT_VIDEO_B, 0x1f, 0);
1494  saa_andorb(SAA7134_OFMT_DATA_A, 0x1f, 0);
1495  saa_andorb(SAA7134_OFMT_DATA_B, 0x1f, 0);
1496 
1497  saa_call_all(dev, core, s_power, 0);
1498  if (fh->radio)
1499  saa_call_all(dev, core, ioctl, SAA6588_CMD_CLOSE, &cmd);
1500 
1501  /* free stuff */
1502  videobuf_mmap_free(&fh->cap);
1503  videobuf_mmap_free(&fh->vbi);
1504  saa7134_pgtable_free(dev->pci,&fh->pt_cap);
1505  saa7134_pgtable_free(dev->pci,&fh->pt_vbi);
1506 
1507  v4l2_prio_close(&dev->prio, fh->prio);
1508  file->private_data = NULL;
1509  kfree(fh);
1510  return 0;
1511 }
1512 
1513 static int video_mmap(struct file *file, struct vm_area_struct * vma)
1514 {
1515  struct saa7134_fh *fh = file->private_data;
1516 
1517  return videobuf_mmap_mapper(saa7134_queue(fh), vma);
1518 }
1519 
1520 static ssize_t radio_read(struct file *file, char __user *data,
1521  size_t count, loff_t *ppos)
1522 {
1523  struct saa7134_fh *fh = file->private_data;
1524  struct saa7134_dev *dev = fh->dev;
1525  struct saa6588_command cmd;
1526 
1527  cmd.block_count = count/3;
1528  cmd.buffer = data;
1529  cmd.instance = file;
1530  cmd.result = -ENODEV;
1531 
1532  saa_call_all(dev, core, ioctl, SAA6588_CMD_READ, &cmd);
1533 
1534  return cmd.result;
1535 }
1536 
1537 static unsigned int radio_poll(struct file *file, poll_table *wait)
1538 {
1539  struct saa7134_fh *fh = file->private_data;
1540  struct saa7134_dev *dev = fh->dev;
1541  struct saa6588_command cmd;
1542 
1543  cmd.instance = file;
1544  cmd.event_list = wait;
1545  cmd.result = -ENODEV;
1546  saa_call_all(dev, core, ioctl, SAA6588_CMD_POLL, &cmd);
1547 
1548  return cmd.result;
1549 }
1550 
1551 /* ------------------------------------------------------------------ */
1552 
1553 static int saa7134_try_get_set_fmt_vbi_cap(struct file *file, void *priv,
1554  struct v4l2_format *f)
1555 {
1556  struct saa7134_fh *fh = priv;
1557  struct saa7134_dev *dev = fh->dev;
1558  struct saa7134_tvnorm *norm = dev->tvnorm;
1559 
1560  f->fmt.vbi.sampling_rate = 6750000 * 4;
1561  f->fmt.vbi.samples_per_line = 2048 /* VBI_LINE_LENGTH */;
1562  f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1563  f->fmt.vbi.offset = 64 * 4;
1564  f->fmt.vbi.start[0] = norm->vbi_v_start_0;
1565  f->fmt.vbi.count[0] = norm->vbi_v_stop_0 - norm->vbi_v_start_0 +1;
1566  f->fmt.vbi.start[1] = norm->vbi_v_start_1;
1567  f->fmt.vbi.count[1] = f->fmt.vbi.count[0];
1568  f->fmt.vbi.flags = 0; /* VBI_UNSYNC VBI_INTERLACED */
1569 
1570  return 0;
1571 }
1572 
1573 static int saa7134_g_fmt_vid_cap(struct file *file, void *priv,
1574  struct v4l2_format *f)
1575 {
1576  struct saa7134_fh *fh = priv;
1577 
1578  f->fmt.pix.width = fh->width;
1579  f->fmt.pix.height = fh->height;
1580  f->fmt.pix.field = fh->cap.field;
1581  f->fmt.pix.pixelformat = fh->fmt->fourcc;
1582  f->fmt.pix.bytesperline =
1583  (f->fmt.pix.width * fh->fmt->depth) >> 3;
1584  f->fmt.pix.sizeimage =
1585  f->fmt.pix.height * f->fmt.pix.bytesperline;
1586  return 0;
1587 }
1588 
1589 static int saa7134_g_fmt_vid_overlay(struct file *file, void *priv,
1590  struct v4l2_format *f)
1591 {
1592  struct saa7134_fh *fh = priv;
1593 
1594  if (saa7134_no_overlay > 0) {
1595  printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
1596  return -EINVAL;
1597  }
1598  f->fmt.win = fh->win;
1599 
1600  return 0;
1601 }
1602 
1603 static int saa7134_try_fmt_vid_cap(struct file *file, void *priv,
1604  struct v4l2_format *f)
1605 {
1606  struct saa7134_fh *fh = priv;
1607  struct saa7134_dev *dev = fh->dev;
1608  struct saa7134_format *fmt;
1609  enum v4l2_field field;
1610  unsigned int maxw, maxh;
1611 
1612  fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1613  if (NULL == fmt)
1614  return -EINVAL;
1615 
1616  field = f->fmt.pix.field;
1617  maxw = min(dev->crop_current.width*4, dev->crop_bounds.width);
1618  maxh = min(dev->crop_current.height*4, dev->crop_bounds.height);
1619 
1620  if (V4L2_FIELD_ANY == field) {
1621  field = (f->fmt.pix.height > maxh/2)
1622  ? V4L2_FIELD_INTERLACED
1623  : V4L2_FIELD_BOTTOM;
1624  }
1625  switch (field) {
1626  case V4L2_FIELD_TOP:
1627  case V4L2_FIELD_BOTTOM:
1628  maxh = maxh / 2;
1629  break;
1630  case V4L2_FIELD_INTERLACED:
1631  break;
1632  default:
1633  return -EINVAL;
1634  }
1635 
1636  f->fmt.pix.field = field;
1637  if (f->fmt.pix.width < 48)
1638  f->fmt.pix.width = 48;
1639  if (f->fmt.pix.height < 32)
1640  f->fmt.pix.height = 32;
1641  if (f->fmt.pix.width > maxw)
1642  f->fmt.pix.width = maxw;
1643  if (f->fmt.pix.height > maxh)
1644  f->fmt.pix.height = maxh;
1645  f->fmt.pix.width &= ~0x03;
1646  f->fmt.pix.bytesperline =
1647  (f->fmt.pix.width * fmt->depth) >> 3;
1648  f->fmt.pix.sizeimage =
1649  f->fmt.pix.height * f->fmt.pix.bytesperline;
1650 
1651  return 0;
1652 }
1653 
1654 static int saa7134_try_fmt_vid_overlay(struct file *file, void *priv,
1655  struct v4l2_format *f)
1656 {
1657  struct saa7134_fh *fh = priv;
1658  struct saa7134_dev *dev = fh->dev;
1659 
1660  if (saa7134_no_overlay > 0) {
1661  printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
1662  return -EINVAL;
1663  }
1664 
1665  return verify_preview(dev, &f->fmt.win);
1666 }
1667 
1668 static int saa7134_s_fmt_vid_cap(struct file *file, void *priv,
1669  struct v4l2_format *f)
1670 {
1671  struct saa7134_fh *fh = priv;
1672  int err;
1673 
1674  err = saa7134_try_fmt_vid_cap(file, priv, f);
1675  if (0 != err)
1676  return err;
1677 
1678  fh->fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1679  fh->width = f->fmt.pix.width;
1680  fh->height = f->fmt.pix.height;
1681  fh->cap.field = f->fmt.pix.field;
1682  return 0;
1683 }
1684 
1685 static int saa7134_s_fmt_vid_overlay(struct file *file, void *priv,
1686  struct v4l2_format *f)
1687 {
1688  struct saa7134_fh *fh = priv;
1689  struct saa7134_dev *dev = fh->dev;
1690  int err;
1691  unsigned long flags;
1692 
1693  if (saa7134_no_overlay > 0) {
1694  printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
1695  return -EINVAL;
1696  }
1697  err = verify_preview(dev, &f->fmt.win);
1698  if (0 != err)
1699  return err;
1700 
1701  mutex_lock(&dev->lock);
1702 
1703  fh->win = f->fmt.win;
1704  fh->nclips = f->fmt.win.clipcount;
1705 
1706  if (fh->nclips > 8)
1707  fh->nclips = 8;
1708 
1709  if (copy_from_user(fh->clips, f->fmt.win.clips,
1710  sizeof(struct v4l2_clip)*fh->nclips)) {
1711  mutex_unlock(&dev->lock);
1712  return -EFAULT;
1713  }
1714 
1715  if (res_check(fh, RESOURCE_OVERLAY)) {
1716  spin_lock_irqsave(&dev->slock, flags);
1717  stop_preview(dev, fh);
1718  start_preview(dev, fh);
1719  spin_unlock_irqrestore(&dev->slock, flags);
1720  }
1721 
1722  mutex_unlock(&dev->lock);
1723  return 0;
1724 }
1725 
1726 int saa7134_queryctrl(struct file *file, void *priv, struct v4l2_queryctrl *c)
1727 {
1728  const struct v4l2_queryctrl *ctrl;
1729 
1730  if ((c->id < V4L2_CID_BASE ||
1731  c->id >= V4L2_CID_LASTP1) &&
1732  (c->id < V4L2_CID_PRIVATE_BASE ||
1733  c->id >= V4L2_CID_PRIVATE_LASTP1))
1734  return -EINVAL;
1735  ctrl = ctrl_by_id(c->id);
1736  *c = (NULL != ctrl) ? *ctrl : no_ctrl;
1737  return 0;
1738 }
1739 EXPORT_SYMBOL_GPL(saa7134_queryctrl);
1740 
1741 static int saa7134_enum_input(struct file *file, void *priv,
1742  struct v4l2_input *i)
1743 {
1744  struct saa7134_fh *fh = priv;
1745  struct saa7134_dev *dev = fh->dev;
1746  unsigned int n;
1747 
1748  n = i->index;
1749  if (n >= SAA7134_INPUT_MAX)
1750  return -EINVAL;
1751  if (NULL == card_in(dev, i->index).name)
1752  return -EINVAL;
1753  i->index = n;
1754  i->type = V4L2_INPUT_TYPE_CAMERA;
1755  strcpy(i->name, card_in(dev, n).name);
1756  if (card_in(dev, n).tv)
1757  i->type = V4L2_INPUT_TYPE_TUNER;
1758  i->audioset = 1;
1759  if (n == dev->ctl_input) {
1760  int v1 = saa_readb(SAA7134_STATUS_VIDEO1);
1761  int v2 = saa_readb(SAA7134_STATUS_VIDEO2);
1762 
1763  if (0 != (v1 & 0x40))
1764  i->status |= V4L2_IN_ST_NO_H_LOCK;
1765  if (0 != (v2 & 0x40))
1766  i->status |= V4L2_IN_ST_NO_SYNC;
1767  if (0 != (v2 & 0x0e))
1768  i->status |= V4L2_IN_ST_MACROVISION;
1769  }
1770  i->std = SAA7134_NORMS;
1771  return 0;
1772 }
1773 
1774 static int saa7134_g_input(struct file *file, void *priv, unsigned int *i)
1775 {
1776  struct saa7134_fh *fh = priv;
1777  struct saa7134_dev *dev = fh->dev;
1778 
1779  *i = dev->ctl_input;
1780  return 0;
1781 }
1782 
1783 static int saa7134_s_input(struct file *file, void *priv, unsigned int i)
1784 {
1785  struct saa7134_fh *fh = priv;
1786  struct saa7134_dev *dev = fh->dev;
1787  int err;
1788 
1789  err = v4l2_prio_check(&dev->prio, fh->prio);
1790  if (0 != err)
1791  return err;
1792 
1793  if (i >= SAA7134_INPUT_MAX)
1794  return -EINVAL;
1795  if (NULL == card_in(dev, i).name)
1796  return -EINVAL;
1797  mutex_lock(&dev->lock);
1798  video_mux(dev, i);
1799  mutex_unlock(&dev->lock);
1800  return 0;
1801 }
1802 
1803 static int saa7134_querycap(struct file *file, void *priv,
1804  struct v4l2_capability *cap)
1805 {
1806  struct saa7134_fh *fh = priv;
1807  struct saa7134_dev *dev = fh->dev;
1808 
1809  unsigned int tuner_type = dev->tuner_type;
1810 
1811  strcpy(cap->driver, "saa7134");
1812  strlcpy(cap->card, saa7134_boards[dev->board].name,
1813  sizeof(cap->card));
1814  sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
1815  cap->capabilities =
1816  V4L2_CAP_VIDEO_CAPTURE |
1817  V4L2_CAP_VBI_CAPTURE |
1818  V4L2_CAP_READWRITE |
1819  V4L2_CAP_STREAMING |
1820  V4L2_CAP_TUNER;
1821  if (dev->has_rds)
1822  cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
1823  if (saa7134_no_overlay <= 0)
1824  cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
1825 
1826  if ((tuner_type == TUNER_ABSENT) || (tuner_type == UNSET))
1827  cap->capabilities &= ~V4L2_CAP_TUNER;
1828  return 0;
1829 }
1830 
1831 int saa7134_s_std_internal(struct saa7134_dev *dev, struct saa7134_fh *fh, v4l2_std_id *id)
1832 {
1833  unsigned long flags;
1834  unsigned int i;
1835  v4l2_std_id fixup;
1836  int err;
1837 
1838  /* When called from the empress code fh == NULL.
1839  That needs to be fixed somehow, but for now this is
1840  good enough. */
1841  if (fh) {
1842  err = v4l2_prio_check(&dev->prio, fh->prio);
1843  if (0 != err)
1844  return err;
1845  } else if (res_locked(dev, RESOURCE_OVERLAY)) {
1846  /* Don't change the std from the mpeg device
1847  if overlay is active. */
1848  return -EBUSY;
1849  }
1850 
1851  for (i = 0; i < TVNORMS; i++)
1852  if (*id == tvnorms[i].id)
1853  break;
1854 
1855  if (i == TVNORMS)
1856  for (i = 0; i < TVNORMS; i++)
1857  if (*id & tvnorms[i].id)
1858  break;
1859  if (i == TVNORMS)
1860  return -EINVAL;
1861 
1862  if ((*id & V4L2_STD_SECAM) && (secam[0] != '-')) {
1863  if (secam[0] == 'L' || secam[0] == 'l') {
1864  if (secam[1] == 'C' || secam[1] == 'c')
1865  fixup = V4L2_STD_SECAM_LC;
1866  else
1867  fixup = V4L2_STD_SECAM_L;
1868  } else {
1869  if (secam[0] == 'D' || secam[0] == 'd')
1870  fixup = V4L2_STD_SECAM_DK;
1871  else
1872  fixup = V4L2_STD_SECAM;
1873  }
1874  for (i = 0; i < TVNORMS; i++) {
1875  if (fixup == tvnorms[i].id)
1876  break;
1877  }
1878  if (i == TVNORMS)
1879  return -EINVAL;
1880  }
1881 
1882  *id = tvnorms[i].id;
1883 
1884  mutex_lock(&dev->lock);
1885  if (fh && res_check(fh, RESOURCE_OVERLAY)) {
1886  spin_lock_irqsave(&dev->slock, flags);
1887  stop_preview(dev, fh);
1888  spin_unlock_irqrestore(&dev->slock, flags);
1889 
1890  set_tvnorm(dev, &tvnorms[i]);
1891 
1892  spin_lock_irqsave(&dev->slock, flags);
1893  start_preview(dev, fh);
1894  spin_unlock_irqrestore(&dev->slock, flags);
1895  } else
1896  set_tvnorm(dev, &tvnorms[i]);
1897 
1898  saa7134_tvaudio_do_scan(dev);
1899  mutex_unlock(&dev->lock);
1900  return 0;
1901 }
1902 EXPORT_SYMBOL_GPL(saa7134_s_std_internal);
1903 
1904 static int saa7134_s_std(struct file *file, void *priv, v4l2_std_id *id)
1905 {
1906  struct saa7134_fh *fh = priv;
1907 
1908  return saa7134_s_std_internal(fh->dev, fh, id);
1909 }
1910 
1911 static int saa7134_g_std(struct file *file, void *priv, v4l2_std_id *id)
1912 {
1913  struct saa7134_fh *fh = priv;
1914  struct saa7134_dev *dev = fh->dev;
1915 
1916  *id = dev->tvnorm->id;
1917  return 0;
1918 }
1919 
1920 static int saa7134_cropcap(struct file *file, void *priv,
1921  struct v4l2_cropcap *cap)
1922 {
1923  struct saa7134_fh *fh = priv;
1924  struct saa7134_dev *dev = fh->dev;
1925 
1926  if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1927  cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
1928  return -EINVAL;
1929  cap->bounds = dev->crop_bounds;
1930  cap->defrect = dev->crop_defrect;
1931  cap->pixelaspect.numerator = 1;
1932  cap->pixelaspect.denominator = 1;
1933  if (dev->tvnorm->id & V4L2_STD_525_60) {
1934  cap->pixelaspect.numerator = 11;
1935  cap->pixelaspect.denominator = 10;
1936  }
1937  if (dev->tvnorm->id & V4L2_STD_625_50) {
1938  cap->pixelaspect.numerator = 54;
1939  cap->pixelaspect.denominator = 59;
1940  }
1941  return 0;
1942 }
1943 
1944 static int saa7134_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
1945 {
1946  struct saa7134_fh *fh = f;
1947  struct saa7134_dev *dev = fh->dev;
1948 
1949  if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1950  crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
1951  return -EINVAL;
1952  crop->c = dev->crop_current;
1953  return 0;
1954 }
1955 
1956 static int saa7134_s_crop(struct file *file, void *f, const struct v4l2_crop *crop)
1957 {
1958  struct saa7134_fh *fh = f;
1959  struct saa7134_dev *dev = fh->dev;
1960  struct v4l2_rect *b = &dev->crop_bounds;
1961  struct v4l2_rect *c = &dev->crop_current;
1962 
1963  if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1964  crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
1965  return -EINVAL;
1966  if (crop->c.height < 0)
1967  return -EINVAL;
1968  if (crop->c.width < 0)
1969  return -EINVAL;
1970 
1971  if (res_locked(fh->dev, RESOURCE_OVERLAY))
1972  return -EBUSY;
1973  if (res_locked(fh->dev, RESOURCE_VIDEO))
1974  return -EBUSY;
1975 
1976  *c = crop->c;
1977  if (c->top < b->top)
1978  c->top = b->top;
1979  if (c->top > b->top + b->height)
1980  c->top = b->top + b->height;
1981  if (c->height > b->top - c->top + b->height)
1982  c->height = b->top - c->top + b->height;
1983 
1984  if (c->left < b->left)
1985  c->left = b->left;
1986  if (c->left > b->left + b->width)
1987  c->left = b->left + b->width;
1988  if (c->width > b->left - c->left + b->width)
1989  c->width = b->left - c->left + b->width;
1990  return 0;
1991 }
1992 
1993 static int saa7134_g_tuner(struct file *file, void *priv,
1994  struct v4l2_tuner *t)
1995 {
1996  struct saa7134_fh *fh = priv;
1997  struct saa7134_dev *dev = fh->dev;
1998  int n;
1999 
2000  if (0 != t->index)
2001  return -EINVAL;
2002  memset(t, 0, sizeof(*t));
2003  for (n = 0; n < SAA7134_INPUT_MAX; n++) {
2004  if (card_in(dev, n).tv)
2005  break;
2006  }
2007  if (n == SAA7134_INPUT_MAX)
2008  return -EINVAL;
2009  if (NULL != card_in(dev, n).name) {
2010  strcpy(t->name, "Television");
2011  t->type = V4L2_TUNER_ANALOG_TV;
2012  t->capability = V4L2_TUNER_CAP_NORM |
2013  V4L2_TUNER_CAP_STEREO |
2014  V4L2_TUNER_CAP_LANG1 |
2015  V4L2_TUNER_CAP_LANG2;
2016  t->rangehigh = 0xffffffffUL;
2017  t->rxsubchans = saa7134_tvaudio_getstereo(dev);
2018  t->audmode = saa7134_tvaudio_rx2mode(t->rxsubchans);
2019  }
2020  if (0 != (saa_readb(SAA7134_STATUS_VIDEO1) & 0x03))
2021  t->signal = 0xffff;
2022  return 0;
2023 }
2024 
2025 static int saa7134_s_tuner(struct file *file, void *priv,
2026  struct v4l2_tuner *t)
2027 {
2028  struct saa7134_fh *fh = priv;
2029  struct saa7134_dev *dev = fh->dev;
2030  int rx, mode, err;
2031 
2032  err = v4l2_prio_check(&dev->prio, fh->prio);
2033  if (0 != err)
2034  return err;
2035 
2036  mode = dev->thread.mode;
2037  if (UNSET == mode) {
2038  rx = saa7134_tvaudio_getstereo(dev);
2039  mode = saa7134_tvaudio_rx2mode(rx);
2040  }
2041  if (mode != t->audmode)
2042  dev->thread.mode = t->audmode;
2043 
2044  return 0;
2045 }
2046 
2047 static int saa7134_g_frequency(struct file *file, void *priv,
2048  struct v4l2_frequency *f)
2049 {
2050  struct saa7134_fh *fh = priv;
2051  struct saa7134_dev *dev = fh->dev;
2052 
2053  f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2054  f->frequency = dev->ctl_freq;
2055 
2056  return 0;
2057 }
2058 
2059 static int saa7134_s_frequency(struct file *file, void *priv,
2060  struct v4l2_frequency *f)
2061 {
2062  struct saa7134_fh *fh = priv;
2063  struct saa7134_dev *dev = fh->dev;
2064  int err;
2065 
2066  err = v4l2_prio_check(&dev->prio, fh->prio);
2067  if (0 != err)
2068  return err;
2069 
2070  if (0 != f->tuner)
2071  return -EINVAL;
2072  if (0 == fh->radio && V4L2_TUNER_ANALOG_TV != f->type)
2073  return -EINVAL;
2074  if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
2075  return -EINVAL;
2076  mutex_lock(&dev->lock);
2077  dev->ctl_freq = f->frequency;
2078 
2079  saa_call_all(dev, tuner, s_frequency, f);
2080 
2081  saa7134_tvaudio_do_scan(dev);
2082  mutex_unlock(&dev->lock);
2083  return 0;
2084 }
2085 
2086 static int saa7134_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
2087 {
2088  strcpy(a->name, "audio");
2089  return 0;
2090 }
2091 
2092 static int saa7134_s_audio(struct file *file, void *priv, const struct v4l2_audio *a)
2093 {
2094  return 0;
2095 }
2096 
2097 static int saa7134_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2098 {
2099  struct saa7134_fh *fh = f;
2100  struct saa7134_dev *dev = fh->dev;
2101 
2102  *p = v4l2_prio_max(&dev->prio);
2103  return 0;
2104 }
2105 
2106 static int saa7134_s_priority(struct file *file, void *f,
2107  enum v4l2_priority prio)
2108 {
2109  struct saa7134_fh *fh = f;
2110  struct saa7134_dev *dev = fh->dev;
2111 
2112  return v4l2_prio_change(&dev->prio, &fh->prio, prio);
2113 }
2114 
2115 static int saa7134_enum_fmt_vid_cap(struct file *file, void *priv,
2116  struct v4l2_fmtdesc *f)
2117 {
2118  if (f->index >= FORMATS)
2119  return -EINVAL;
2120 
2121  strlcpy(f->description, formats[f->index].name,
2122  sizeof(f->description));
2123 
2124  f->pixelformat = formats[f->index].fourcc;
2125 
2126  return 0;
2127 }
2128 
2129 static int saa7134_enum_fmt_vid_overlay(struct file *file, void *priv,
2130  struct v4l2_fmtdesc *f)
2131 {
2132  if (saa7134_no_overlay > 0) {
2133  printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2134  return -EINVAL;
2135  }
2136 
2137  if ((f->index >= FORMATS) || formats[f->index].planar)
2138  return -EINVAL;
2139 
2140  strlcpy(f->description, formats[f->index].name,
2141  sizeof(f->description));
2142 
2143  f->pixelformat = formats[f->index].fourcc;
2144 
2145  return 0;
2146 }
2147 
2148 static int saa7134_g_fbuf(struct file *file, void *f,
2149  struct v4l2_framebuffer *fb)
2150 {
2151  struct saa7134_fh *fh = f;
2152  struct saa7134_dev *dev = fh->dev;
2153 
2154  *fb = dev->ovbuf;
2155  fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2156 
2157  return 0;
2158 }
2159 
2160 static int saa7134_s_fbuf(struct file *file, void *f,
2161  const struct v4l2_framebuffer *fb)
2162 {
2163  struct saa7134_fh *fh = f;
2164  struct saa7134_dev *dev = fh->dev;
2165  struct saa7134_format *fmt;
2166 
2167  if (!capable(CAP_SYS_ADMIN) &&
2168  !capable(CAP_SYS_RAWIO))
2169  return -EPERM;
2170 
2171  /* check args */
2172  fmt = format_by_fourcc(fb->fmt.pixelformat);
2173  if (NULL == fmt)
2174  return -EINVAL;
2175 
2176  /* ok, accept it */
2177  dev->ovbuf = *fb;
2178  dev->ovfmt = fmt;
2179  if (0 == dev->ovbuf.fmt.bytesperline)
2180  dev->ovbuf.fmt.bytesperline =
2181  dev->ovbuf.fmt.width*fmt->depth/8;
2182  return 0;
2183 }
2184 
2185 static int saa7134_overlay(struct file *file, void *f, unsigned int on)
2186 {
2187  struct saa7134_fh *fh = f;
2188  struct saa7134_dev *dev = fh->dev;
2189  unsigned long flags;
2190 
2191  if (on) {
2192  if (saa7134_no_overlay > 0) {
2193  dprintk("no_overlay\n");
2194  return -EINVAL;
2195  }
2196 
2197  if (!res_get(dev, fh, RESOURCE_OVERLAY))
2198  return -EBUSY;
2199  spin_lock_irqsave(&dev->slock, flags);
2200  start_preview(dev, fh);
2201  spin_unlock_irqrestore(&dev->slock, flags);
2202  }
2203  if (!on) {
2204  if (!res_check(fh, RESOURCE_OVERLAY))
2205  return -EINVAL;
2206  spin_lock_irqsave(&dev->slock, flags);
2207  stop_preview(dev, fh);
2208  spin_unlock_irqrestore(&dev->slock, flags);
2209  res_free(dev, fh, RESOURCE_OVERLAY);
2210  }
2211  return 0;
2212 }
2213 
2214 static int saa7134_reqbufs(struct file *file, void *priv,
2215  struct v4l2_requestbuffers *p)
2216 {
2217  struct saa7134_fh *fh = priv;
2218  return videobuf_reqbufs(saa7134_queue(fh), p);
2219 }
2220 
2221 static int saa7134_querybuf(struct file *file, void *priv,
2222  struct v4l2_buffer *b)
2223 {
2224  struct saa7134_fh *fh = priv;
2225  return videobuf_querybuf(saa7134_queue(fh), b);
2226 }
2227 
2228 static int saa7134_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2229 {
2230  struct saa7134_fh *fh = priv;
2231  return videobuf_qbuf(saa7134_queue(fh), b);
2232 }
2233 
2234 static int saa7134_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2235 {
2236  struct saa7134_fh *fh = priv;
2237  return videobuf_dqbuf(saa7134_queue(fh), b,
2238  file->f_flags & O_NONBLOCK);
2239 }
2240 
2241 static int saa7134_streamon(struct file *file, void *priv,
2242  enum v4l2_buf_type type)
2243 {
2244  struct saa7134_fh *fh = priv;
2245  struct saa7134_dev *dev = fh->dev;
2246  int res = saa7134_resource(fh);
2247 
2248  if (!res_get(dev, fh, res))
2249  return -EBUSY;
2250 
2251  return videobuf_streamon(saa7134_queue(fh));
2252 }
2253 
2254 static int saa7134_streamoff(struct file *file, void *priv,
2255  enum v4l2_buf_type type)
2256 {
2257  int err;
2258  struct saa7134_fh *fh = priv;
2259  struct saa7134_dev *dev = fh->dev;
2260  int res = saa7134_resource(fh);
2261 
2262  err = videobuf_streamoff(saa7134_queue(fh));
2263  if (err < 0)
2264  return err;
2265  res_free(dev, fh, res);
2266  return 0;
2267 }
2268 
2269 static int saa7134_g_parm(struct file *file, void *fh,
2270  struct v4l2_streamparm *parm)
2271 {
2272  return 0;
2273 }
2274 
2275 #ifdef CONFIG_VIDEO_ADV_DEBUG
2276 static int vidioc_g_register (struct file *file, void *priv,
2277  struct v4l2_dbg_register *reg)
2278 {
2279  struct saa7134_fh *fh = priv;
2280  struct saa7134_dev *dev = fh->dev;
2281 
2282  if (!v4l2_chip_match_host(&reg->match))
2283  return -EINVAL;
2284  reg->val = saa_readb(reg->reg);
2285  reg->size = 1;
2286  return 0;
2287 }
2288 
2289 static int vidioc_s_register (struct file *file, void *priv,
2290  struct v4l2_dbg_register *reg)
2291 {
2292  struct saa7134_fh *fh = priv;
2293  struct saa7134_dev *dev = fh->dev;
2294 
2295  if (!v4l2_chip_match_host(&reg->match))
2296  return -EINVAL;
2297  saa_writeb(reg->reg&0xffffff, reg->val);
2298  return 0;
2299 }
2300 #endif
2301 
2302 static int radio_querycap(struct file *file, void *priv,
2303  struct v4l2_capability *cap)
2304 {
2305  struct saa7134_fh *fh = file->private_data;
2306  struct saa7134_dev *dev = fh->dev;
2307 
2308  strcpy(cap->driver, "saa7134");
2309  strlcpy(cap->card, saa7134_boards[dev->board].name, sizeof(cap->card));
2310  sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
2311  cap->capabilities = V4L2_CAP_TUNER;
2312  return 0;
2313 }
2314 
2315 static int radio_g_tuner(struct file *file, void *priv,
2316  struct v4l2_tuner *t)
2317 {
2318  struct saa7134_fh *fh = file->private_data;
2319  struct saa7134_dev *dev = fh->dev;
2320 
2321  if (0 != t->index)
2322  return -EINVAL;
2323 
2324  memset(t, 0, sizeof(*t));
2325  strcpy(t->name, "Radio");
2326  t->type = V4L2_TUNER_RADIO;
2327 
2328  saa_call_all(dev, tuner, g_tuner, t);
2329  if (dev->input->amux == TV) {
2330  t->signal = 0xf800 - ((saa_readb(0x581) & 0x1f) << 11);
2331  t->rxsubchans = (saa_readb(0x529) & 0x08) ?
2332  V4L2_TUNER_SUB_STEREO : V4L2_TUNER_SUB_MONO;
2333  }
2334  return 0;
2335 }
2336 static int radio_s_tuner(struct file *file, void *priv,
2337  struct v4l2_tuner *t)
2338 {
2339  struct saa7134_fh *fh = file->private_data;
2340  struct saa7134_dev *dev = fh->dev;
2341 
2342  if (0 != t->index)
2343  return -EINVAL;
2344 
2345  saa_call_all(dev, tuner, s_tuner, t);
2346  return 0;
2347 }
2348 
2349 static int radio_enum_input(struct file *file, void *priv,
2350  struct v4l2_input *i)
2351 {
2352  if (i->index != 0)
2353  return -EINVAL;
2354 
2355  strcpy(i->name, "Radio");
2356  i->type = V4L2_INPUT_TYPE_TUNER;
2357 
2358  return 0;
2359 }
2360 
2361 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
2362 {
2363  *i = 0;
2364  return 0;
2365 }
2366 
2367 static int radio_g_audio(struct file *file, void *priv,
2368  struct v4l2_audio *a)
2369 {
2370  memset(a, 0, sizeof(*a));
2371  strcpy(a->name, "Radio");
2372  return 0;
2373 }
2374 
2375 static int radio_s_audio(struct file *file, void *priv,
2376  const struct v4l2_audio *a)
2377 {
2378  return 0;
2379 }
2380 
2381 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
2382 {
2383  return 0;
2384 }
2385 
2386 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
2387 {
2388  return 0;
2389 }
2390 
2391 static int radio_queryctrl(struct file *file, void *priv,
2392  struct v4l2_queryctrl *c)
2393 {
2394  const struct v4l2_queryctrl *ctrl;
2395 
2396  if (c->id < V4L2_CID_BASE ||
2397  c->id >= V4L2_CID_LASTP1)
2398  return -EINVAL;
2399  if (c->id == V4L2_CID_AUDIO_MUTE) {
2400  ctrl = ctrl_by_id(c->id);
2401  *c = *ctrl;
2402  } else
2403  *c = no_ctrl;
2404  return 0;
2405 }
2406 
2407 static const struct v4l2_file_operations video_fops =
2408 {
2409  .owner = THIS_MODULE,
2410  .open = video_open,
2411  .release = video_release,
2412  .read = video_read,
2413  .poll = video_poll,
2414  .mmap = video_mmap,
2415  .ioctl = video_ioctl2,
2416 };
2417 
2418 static const struct v4l2_ioctl_ops video_ioctl_ops = {
2419  .vidioc_querycap = saa7134_querycap,
2420  .vidioc_enum_fmt_vid_cap = saa7134_enum_fmt_vid_cap,
2421  .vidioc_g_fmt_vid_cap = saa7134_g_fmt_vid_cap,
2422  .vidioc_try_fmt_vid_cap = saa7134_try_fmt_vid_cap,
2423  .vidioc_s_fmt_vid_cap = saa7134_s_fmt_vid_cap,
2424  .vidioc_enum_fmt_vid_overlay = saa7134_enum_fmt_vid_overlay,
2425  .vidioc_g_fmt_vid_overlay = saa7134_g_fmt_vid_overlay,
2426  .vidioc_try_fmt_vid_overlay = saa7134_try_fmt_vid_overlay,
2427  .vidioc_s_fmt_vid_overlay = saa7134_s_fmt_vid_overlay,
2428  .vidioc_g_fmt_vbi_cap = saa7134_try_get_set_fmt_vbi_cap,
2429  .vidioc_try_fmt_vbi_cap = saa7134_try_get_set_fmt_vbi_cap,
2430  .vidioc_s_fmt_vbi_cap = saa7134_try_get_set_fmt_vbi_cap,
2431  .vidioc_g_audio = saa7134_g_audio,
2432  .vidioc_s_audio = saa7134_s_audio,
2433  .vidioc_cropcap = saa7134_cropcap,
2434  .vidioc_reqbufs = saa7134_reqbufs,
2435  .vidioc_querybuf = saa7134_querybuf,
2436  .vidioc_qbuf = saa7134_qbuf,
2437  .vidioc_dqbuf = saa7134_dqbuf,
2438  .vidioc_s_std = saa7134_s_std,
2439  .vidioc_g_std = saa7134_g_std,
2440  .vidioc_enum_input = saa7134_enum_input,
2441  .vidioc_g_input = saa7134_g_input,
2442  .vidioc_s_input = saa7134_s_input,
2443  .vidioc_queryctrl = saa7134_queryctrl,
2444  .vidioc_g_ctrl = saa7134_g_ctrl,
2445  .vidioc_s_ctrl = saa7134_s_ctrl,
2446  .vidioc_streamon = saa7134_streamon,
2447  .vidioc_streamoff = saa7134_streamoff,
2448  .vidioc_g_tuner = saa7134_g_tuner,
2449  .vidioc_s_tuner = saa7134_s_tuner,
2450  .vidioc_g_crop = saa7134_g_crop,
2451  .vidioc_s_crop = saa7134_s_crop,
2452  .vidioc_g_fbuf = saa7134_g_fbuf,
2453  .vidioc_s_fbuf = saa7134_s_fbuf,
2454  .vidioc_overlay = saa7134_overlay,
2455  .vidioc_g_priority = saa7134_g_priority,
2456  .vidioc_s_priority = saa7134_s_priority,
2457  .vidioc_g_parm = saa7134_g_parm,
2458  .vidioc_g_frequency = saa7134_g_frequency,
2459  .vidioc_s_frequency = saa7134_s_frequency,
2460 #ifdef CONFIG_VIDEO_ADV_DEBUG
2461  .vidioc_g_register = vidioc_g_register,
2462  .vidioc_s_register = vidioc_s_register,
2463 #endif
2464 };
2465 
2466 static const struct v4l2_file_operations radio_fops = {
2467  .owner = THIS_MODULE,
2468  .open = video_open,
2469  .read = radio_read,
2470  .release = video_release,
2471  .ioctl = video_ioctl2,
2472  .poll = radio_poll,
2473 };
2474 
2475 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2476  .vidioc_querycap = radio_querycap,
2477  .vidioc_g_tuner = radio_g_tuner,
2478  .vidioc_enum_input = radio_enum_input,
2479  .vidioc_g_audio = radio_g_audio,
2480  .vidioc_s_tuner = radio_s_tuner,
2481  .vidioc_s_audio = radio_s_audio,
2482  .vidioc_s_input = radio_s_input,
2483  .vidioc_s_std = radio_s_std,
2484  .vidioc_queryctrl = radio_queryctrl,
2485  .vidioc_g_input = radio_g_input,
2486  .vidioc_g_ctrl = saa7134_g_ctrl,
2487  .vidioc_s_ctrl = saa7134_s_ctrl,
2488  .vidioc_g_frequency = saa7134_g_frequency,
2489  .vidioc_s_frequency = saa7134_s_frequency,
2490 };
2491 
2492 /* ----------------------------------------------------------- */
2493 /* exported stuff */
2494 
2495 struct video_device saa7134_video_template = {
2496  .name = "saa7134-video",
2497  .fops = &video_fops,
2498  .ioctl_ops = &video_ioctl_ops,
2499  .tvnorms = SAA7134_NORMS,
2500  .current_norm = V4L2_STD_PAL,
2501 };
2502 
2503 struct video_device saa7134_radio_template = {
2504  .name = "saa7134-radio",
2505  .fops = &radio_fops,
2506  .ioctl_ops = &radio_ioctl_ops,
2507 };
2508 
2509 int saa7134_video_init1(struct saa7134_dev *dev)
2510 {
2511  /* sanitycheck insmod options */
2512  if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
2513  gbuffers = 2;
2514  if (gbufsize < 0 || gbufsize > gbufsize_max)
2515  gbufsize = gbufsize_max;
2516  gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
2517 
2518  /* put some sensible defaults into the data structures ... */
2519  dev->ctl_bright = ctrl_by_id(V4L2_CID_BRIGHTNESS)->default_value;
2520  dev->ctl_contrast = ctrl_by_id(V4L2_CID_CONTRAST)->default_value;
2521  dev->ctl_hue = ctrl_by_id(V4L2_CID_HUE)->default_value;
2522  dev->ctl_saturation = ctrl_by_id(V4L2_CID_SATURATION)->default_value;
2523  dev->ctl_volume = ctrl_by_id(V4L2_CID_AUDIO_VOLUME)->default_value;
2524  dev->ctl_mute = 1; // ctrl_by_id(V4L2_CID_AUDIO_MUTE)->default_value;
2525  dev->ctl_invert = ctrl_by_id(V4L2_CID_PRIVATE_INVERT)->default_value;
2526  dev->ctl_automute = ctrl_by_id(V4L2_CID_PRIVATE_AUTOMUTE)->default_value;
2527 
2528  if (dev->tda9887_conf && dev->ctl_automute)
2529  dev->tda9887_conf |= TDA9887_AUTOMUTE;
2530  dev->automute = 0;
2531 
2532  INIT_LIST_HEAD(&dev->video_q.queue);
2533  init_timer(&dev->video_q.timeout);
2534  dev->video_q.timeout.function = saa7134_buffer_timeout;
2535  dev->video_q.timeout.data = (unsigned long)(&dev->video_q);
2536  dev->video_q.dev = dev;
2537 
2538  if (saa7134_boards[dev->board].video_out)
2539  saa7134_videoport_init(dev);
2540 
2541  return 0;
2542 }
2543 
2544 int saa7134_videoport_init(struct saa7134_dev *dev)
2545 {
2546  /* enable video output */
2547  int vo = saa7134_boards[dev->board].video_out;
2548  int video_reg;
2549  unsigned int vid_port_opts = saa7134_boards[dev->board].vid_port_opts;
2550 
2551  /* Configure videoport */
2552  saa_writeb(SAA7134_VIDEO_PORT_CTRL0, video_out[vo][0]);
2553  video_reg = video_out[vo][1];
2554  if (vid_port_opts & SET_T_CODE_POLARITY_NON_INVERTED)
2555  video_reg &= ~VP_T_CODE_P_INVERTED;
2556  saa_writeb(SAA7134_VIDEO_PORT_CTRL1, video_reg);
2557  saa_writeb(SAA7134_VIDEO_PORT_CTRL2, video_out[vo][2]);
2558  saa_writeb(SAA7134_VIDEO_PORT_CTRL4, video_out[vo][4]);
2559  video_reg = video_out[vo][5];
2560  if (vid_port_opts & SET_CLOCK_NOT_DELAYED)
2561  video_reg &= ~VP_CLK_CTRL2_DELAYED;
2562  if (vid_port_opts & SET_CLOCK_INVERTED)
2563  video_reg |= VP_CLK_CTRL1_INVERTED;
2564  saa_writeb(SAA7134_VIDEO_PORT_CTRL5, video_reg);
2565  video_reg = video_out[vo][6];
2566  if (vid_port_opts & SET_VSYNC_OFF) {
2567  video_reg &= ~VP_VS_TYPE_MASK;
2568  video_reg |= VP_VS_TYPE_OFF;
2569  }
2570  saa_writeb(SAA7134_VIDEO_PORT_CTRL6, video_reg);
2571  saa_writeb(SAA7134_VIDEO_PORT_CTRL7, video_out[vo][7]);
2572  saa_writeb(SAA7134_VIDEO_PORT_CTRL8, video_out[vo][8]);
2573 
2574  /* Start videoport */
2575  saa_writeb(SAA7134_VIDEO_PORT_CTRL3, video_out[vo][3]);
2576 
2577  return 0;
2578 }
2579 
2580 int saa7134_video_init2(struct saa7134_dev *dev)
2581 {
2582  /* init video hw */
2583  set_tvnorm(dev,&tvnorms[0]);
2584  video_mux(dev,0);
2585  saa7134_tvaudio_setmute(dev);
2586  saa7134_tvaudio_setvolume(dev,dev->ctl_volume);
2587  return 0;
2588 }
2589 
2590 void saa7134_irq_video_signalchange(struct saa7134_dev *dev)
2591 {
2592  static const char *st[] = {
2593  "(no signal)", "NTSC", "PAL", "SECAM" };
2594  u32 st1,st2;
2595 
2596  st1 = saa_readb(SAA7134_STATUS_VIDEO1);
2597  st2 = saa_readb(SAA7134_STATUS_VIDEO2);
2598  dprintk("DCSDT: pll: %s, sync: %s, norm: %s\n",
2599  (st1 & 0x40) ? "not locked" : "locked",
2600  (st2 & 0x40) ? "no" : "yes",
2601  st[st1 & 0x03]);
2602  dev->nosignal = (st1 & 0x40) || (st2 & 0x40) || !(st2 & 0x1);
2603 
2604  if (dev->nosignal) {
2605  /* no video signal -> mute audio */
2606  if (dev->ctl_automute)
2607  dev->automute = 1;
2608  saa7134_tvaudio_setmute(dev);
2609  } else {
2610  /* wake up tvaudio audio carrier scan thread */
2611  saa7134_tvaudio_do_scan(dev);
2612  }
2613 
2614  if ((st2 & 0x80) && !noninterlaced && !dev->nosignal)
2615  saa_clearb(SAA7134_SYNC_CTRL, 0x20);
2616  else
2617  saa_setb(SAA7134_SYNC_CTRL, 0x20);
2618 
2619  if (dev->mops && dev->mops->signal_change)
2620  dev->mops->signal_change(dev);
2621 }
2622 
2623 
2624 void saa7134_irq_video_done(struct saa7134_dev *dev, unsigned long status)
2625 {
2626  enum v4l2_field field;
2627 
2628  spin_lock(&dev->slock);
2629  if (dev->video_q.curr) {
2630  dev->video_fieldcount++;
2631  field = dev->video_q.curr->vb.field;
2632  if (V4L2_FIELD_HAS_BOTH(field)) {
2633  /* make sure we have seen both fields */
2634  if ((status & 0x10) == 0x00) {
2635  dev->video_q.curr->top_seen = 1;
2636  goto done;
2637  }
2638  if (!dev->video_q.curr->top_seen)
2639  goto done;
2640  } else if (field == V4L2_FIELD_TOP) {
2641  if ((status & 0x10) != 0x10)
2642  goto done;
2643  } else if (field == V4L2_FIELD_BOTTOM) {
2644  if ((status & 0x10) != 0x00)
2645  goto done;
2646  }
2647  dev->video_q.curr->vb.field_count = dev->video_fieldcount;
2648  saa7134_buffer_finish(dev,&dev->video_q,VIDEOBUF_DONE);
2649  }
2650  saa7134_buffer_next(dev,&dev->video_q);
2651 
2652  done:
2653  spin_unlock(&dev->slock);
2654 }
2655 
2656 /* ----------------------------------------------------------- */
2657 /*
2658  * Local variables:
2659  * c-basic-offset: 8
2660  * End:
2661  */
Generated on Thu Jan 10 2013 13:48:42 for Linux Kernel by   doxygen 1.8.2