aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video
diff options
context:
space:
mode:
authorHans Verkuil <hverkuil@xs4all.nl>2010-12-24 08:33:19 -0500
committerMauro Carvalho Chehab <mchehab@redhat.com>2010-12-29 05:17:07 -0500
commit08af245de0cf6ab5f4ed008ee2bb99273774fce0 (patch)
treed07a9b38eb4b9442ef0e935063a5f7f40248e19e /drivers/media/video
parentb69a219e0e97441dbeb0262cf85468b61a161399 (diff)
[media] V4L: remove V4L1 compatibility mode
Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Diffstat (limited to 'drivers/media/video')
-rw-r--r--drivers/media/video/Makefile4
-rw-r--r--drivers/media/video/au0828/au0828-video.c12
-rw-r--r--drivers/media/video/bt8xx/bttv-driver.c28
-rw-r--r--drivers/media/video/cpia2/cpia2_v4l.c38
-rw-r--r--drivers/media/video/cx231xx/cx231xx-video.c12
-rw-r--r--drivers/media/video/cx23885/cx23885-video.c32
-rw-r--r--drivers/media/video/cx88/cx88-video.c12
-rw-r--r--drivers/media/video/em28xx/em28xx-video.c16
-rw-r--r--drivers/media/video/pvrusb2/pvrusb2-v4l2.c4
-rw-r--r--drivers/media/video/pwc/pwc-v4l.c17
-rw-r--r--drivers/media/video/s2255drv.c12
-rw-r--r--drivers/media/video/saa7134/saa7134-video.c11
-rw-r--r--drivers/media/video/usbvision/usbvision-video.c3
-rw-r--r--drivers/media/video/uvc/uvc_v4l2.c7
-rw-r--r--drivers/media/video/v4l1-compat.c1277
-rw-r--r--drivers/media/video/v4l2-compat-ioctl32.c325
-rw-r--r--drivers/media/video/v4l2-ioctl.c86
-rw-r--r--drivers/media/video/via-camera.c13
-rw-r--r--drivers/media/video/videobuf-core.c30
-rw-r--r--drivers/media/video/videobuf-dma-sg.c23
-rw-r--r--drivers/media/video/vivi.c12
21 files changed, 4 insertions, 1970 deletions
diff --git a/drivers/media/video/Makefile b/drivers/media/video/Makefile
index 482f14b3ff84..ace7b6eaf5b8 100644
--- a/drivers/media/video/Makefile
+++ b/drivers/media/video/Makefile
@@ -22,10 +22,6 @@ endif
22 22
23obj-$(CONFIG_VIDEO_V4L2_COMMON) += v4l2-common.o 23obj-$(CONFIG_VIDEO_V4L2_COMMON) += v4l2-common.o
24 24
25ifeq ($(CONFIG_VIDEO_V4L1_COMPAT),y)
26 obj-$(CONFIG_VIDEO_DEV) += v4l1-compat.o
27endif
28
29# All i2c modules must come first: 25# All i2c modules must come first:
30 26
31obj-$(CONFIG_VIDEO_TUNER) += tuner.o 27obj-$(CONFIG_VIDEO_TUNER) += tuner.o
diff --git a/drivers/media/video/au0828/au0828-video.c b/drivers/media/video/au0828/au0828-video.c
index 48682af911fa..e41e4ad5cc40 100644
--- a/drivers/media/video/au0828/au0828-video.c
+++ b/drivers/media/video/au0828/au0828-video.c
@@ -1809,15 +1809,6 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1809 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK); 1809 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
1810} 1810}
1811 1811
1812#ifdef CONFIG_VIDEO_V4L1_COMPAT
1813static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1814{
1815 struct au0828_fh *fh = priv;
1816
1817 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1818}
1819#endif
1820
1821static struct v4l2_file_operations au0828_v4l_fops = { 1812static struct v4l2_file_operations au0828_v4l_fops = {
1822 .owner = THIS_MODULE, 1813 .owner = THIS_MODULE,
1823 .open = au0828_v4l2_open, 1814 .open = au0828_v4l2_open,
@@ -1861,9 +1852,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
1861 .vidioc_s_register = vidioc_s_register, 1852 .vidioc_s_register = vidioc_s_register,
1862#endif 1853#endif
1863 .vidioc_g_chip_ident = vidioc_g_chip_ident, 1854 .vidioc_g_chip_ident = vidioc_g_chip_ident,
1864#ifdef CONFIG_VIDEO_V4L1_COMPAT
1865 .vidiocgmbuf = vidiocgmbuf,
1866#endif
1867}; 1855};
1868 1856
1869static const struct video_device au0828_video_template = { 1857static const struct video_device au0828_video_template = {
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 54fbab95b88c..961d0805d877 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -2597,31 +2597,6 @@ static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2597 return setup_window_lock(fh, btv, &f->fmt.win, 1); 2597 return setup_window_lock(fh, btv, &f->fmt.win, 1);
2598} 2598}
2599 2599
2600#ifdef CONFIG_VIDEO_V4L1_COMPAT
2601static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2602{
2603 int retval;
2604 unsigned int i;
2605 struct bttv_fh *fh = priv;
2606
2607 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2608 V4L2_MEMORY_MMAP);
2609 if (retval < 0) {
2610 return retval;
2611 }
2612
2613 gbuffers = retval;
2614 memset(mbuf, 0, sizeof(*mbuf));
2615 mbuf->frames = gbuffers;
2616 mbuf->size = gbuffers * gbufsize;
2617
2618 for (i = 0; i < gbuffers; i++)
2619 mbuf->offsets[i] = i * gbufsize;
2620
2621 return 0;
2622}
2623#endif
2624
2625static int bttv_querycap(struct file *file, void *priv, 2600static int bttv_querycap(struct file *file, void *priv,
2626 struct v4l2_capability *cap) 2601 struct v4l2_capability *cap)
2627{ 2602{
@@ -3354,9 +3329,6 @@ static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3354 .vidioc_streamoff = bttv_streamoff, 3329 .vidioc_streamoff = bttv_streamoff,
3355 .vidioc_g_tuner = bttv_g_tuner, 3330 .vidioc_g_tuner = bttv_g_tuner,
3356 .vidioc_s_tuner = bttv_s_tuner, 3331 .vidioc_s_tuner = bttv_s_tuner,
3357#ifdef CONFIG_VIDEO_V4L1_COMPAT
3358 .vidiocgmbuf = vidiocgmbuf,
3359#endif
3360 .vidioc_g_crop = bttv_g_crop, 3332 .vidioc_g_crop = bttv_g_crop,
3361 .vidioc_s_crop = bttv_s_crop, 3333 .vidioc_s_crop = bttv_s_crop,
3362 .vidioc_g_fbuf = bttv_g_fbuf, 3334 .vidioc_g_fbuf = bttv_g_fbuf,
diff --git a/drivers/media/video/cpia2/cpia2_v4l.c b/drivers/media/video/cpia2/cpia2_v4l.c
index 46b433bbf2c1..7edf80b0d01a 100644
--- a/drivers/media/video/cpia2/cpia2_v4l.c
+++ b/drivers/media/video/cpia2/cpia2_v4l.c
@@ -419,28 +419,6 @@ static int sync(struct camera_data *cam, int frame_nr)
419 419
420/****************************************************************************** 420/******************************************************************************
421 * 421 *
422 * ioctl_get_mbuf
423 *
424 *****************************************************************************/
425#ifdef CONFIG_VIDEO_V4L1_COMPAT
426static int ioctl_get_mbuf(void *arg, struct camera_data *cam)
427{
428 struct video_mbuf *vm;
429 int i;
430 vm = arg;
431
432 memset(vm, 0, sizeof(*vm));
433 vm->size = cam->frame_size*cam->num_frames;
434 vm->frames = cam->num_frames;
435 for (i = 0; i < cam->num_frames; i++)
436 vm->offsets[i] = cam->frame_size * i;
437
438 return 0;
439}
440#endif
441
442/******************************************************************************
443 *
444 * ioctl_set_gpio 422 * ioctl_set_gpio
445 * 423 *
446 *****************************************************************************/ 424 *****************************************************************************/
@@ -1380,17 +1358,6 @@ static long cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
1380 } 1358 }
1381 break; 1359 break;
1382 } 1360 }
1383#ifdef CONFIG_VIDEO_V4L1_COMPAT
1384 case VIDIOCGMBUF:
1385 {
1386 struct cpia2_fh *fh = file->private_data;
1387 if(fh->prio != V4L2_PRIORITY_RECORD) {
1388 mutex_unlock(&cam->busy_lock);
1389 return -EBUSY;
1390 }
1391 break;
1392 }
1393#endif
1394 default: 1361 default:
1395 break; 1362 break;
1396 } 1363 }
@@ -1400,11 +1367,6 @@ static long cpia2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
1400 case CPIA2_IOC_SET_GPIO: 1367 case CPIA2_IOC_SET_GPIO:
1401 retval = ioctl_set_gpio(arg, cam); 1368 retval = ioctl_set_gpio(arg, cam);
1402 break; 1369 break;
1403#ifdef CONFIG_VIDEO_V4L1_COMPAT
1404 case VIDIOCGMBUF: /* mmap interface */
1405 retval = ioctl_get_mbuf(arg, cam);
1406 break;
1407#endif
1408 case VIDIOC_QUERYCAP: 1370 case VIDIOC_QUERYCAP:
1409 retval = ioctl_querycap(arg,cam); 1371 retval = ioctl_querycap(arg,cam);
1410 break; 1372 break;
diff --git a/drivers/media/video/cx231xx/cx231xx-video.c b/drivers/media/video/cx231xx/cx231xx-video.c
index b13b69fb2af6..7e3e8c4f19b7 100644
--- a/drivers/media/video/cx231xx/cx231xx-video.c
+++ b/drivers/media/video/cx231xx/cx231xx-video.c
@@ -2044,15 +2044,6 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2044 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK); 2044 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags & O_NONBLOCK);
2045} 2045}
2046 2046
2047#ifdef CONFIG_VIDEO_V4L1_COMPAT
2048static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2049{
2050 struct cx231xx_fh *fh = priv;
2051
2052 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
2053}
2054#endif
2055
2056/* ----------------------------------------------------------- */ 2047/* ----------------------------------------------------------- */
2057/* RADIO ESPECIFIC IOCTLS */ 2048/* RADIO ESPECIFIC IOCTLS */
2058/* ----------------------------------------------------------- */ 2049/* ----------------------------------------------------------- */
@@ -2507,9 +2498,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
2507 .vidioc_g_register = vidioc_g_register, 2498 .vidioc_g_register = vidioc_g_register,
2508 .vidioc_s_register = vidioc_s_register, 2499 .vidioc_s_register = vidioc_s_register,
2509#endif 2500#endif
2510#ifdef CONFIG_VIDEO_V4L1_COMPAT
2511 .vidiocgmbuf = vidiocgmbuf,
2512#endif
2513}; 2501};
2514 2502
2515static struct video_device cx231xx_vbi_template; 2503static struct video_device cx231xx_vbi_template;
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index 8b2fb8a4375c..796a797b5205 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -1024,35 +1024,6 @@ static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1024 return 0; 1024 return 0;
1025} 1025}
1026 1026
1027#ifdef CONFIG_VIDEO_V4L1_COMPAT
1028static int vidiocgmbuf(struct file *file, void *priv,
1029 struct video_mbuf *mbuf)
1030{
1031 struct cx23885_fh *fh = priv;
1032 struct videobuf_queue *q;
1033 struct v4l2_requestbuffers req;
1034 unsigned int i;
1035 int err;
1036
1037 q = get_queue(fh);
1038 memset(&req, 0, sizeof(req));
1039 req.type = q->type;
1040 req.count = 8;
1041 req.memory = V4L2_MEMORY_MMAP;
1042 err = videobuf_reqbufs(q, &req);
1043 if (err < 0)
1044 return err;
1045
1046 mbuf->frames = req.count;
1047 mbuf->size = 0;
1048 for (i = 0; i < mbuf->frames; i++) {
1049 mbuf->offsets[i] = q->bufs[i]->boff;
1050 mbuf->size += q->bufs[i]->bsize;
1051 }
1052 return 0;
1053}
1054#endif
1055
1056static int vidioc_reqbufs(struct file *file, void *priv, 1027static int vidioc_reqbufs(struct file *file, void *priv,
1057 struct v4l2_requestbuffers *p) 1028 struct v4l2_requestbuffers *p)
1058{ 1029{
@@ -1427,9 +1398,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
1427 .vidioc_s_ctrl = vidioc_s_ctrl, 1398 .vidioc_s_ctrl = vidioc_s_ctrl,
1428 .vidioc_streamon = vidioc_streamon, 1399 .vidioc_streamon = vidioc_streamon,
1429 .vidioc_streamoff = vidioc_streamoff, 1400 .vidioc_streamoff = vidioc_streamoff,
1430#ifdef CONFIG_VIDEO_V4L1_COMPAT
1431 .vidiocgmbuf = vidiocgmbuf,
1432#endif
1433 .vidioc_g_tuner = vidioc_g_tuner, 1401 .vidioc_g_tuner = vidioc_g_tuner,
1434 .vidioc_s_tuner = vidioc_s_tuner, 1402 .vidioc_s_tuner = vidioc_s_tuner,
1435 .vidioc_g_frequency = vidioc_g_frequency, 1403 .vidioc_g_frequency = vidioc_g_frequency,
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index 62cea9549404..9a37b839c67c 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -1179,15 +1179,6 @@ static int vidioc_enum_fmt_vid_cap (struct file *file, void *priv,
1179 return 0; 1179 return 0;
1180} 1180}
1181 1181
1182#ifdef CONFIG_VIDEO_V4L1_COMPAT
1183static int vidiocgmbuf (struct file *file, void *priv, struct video_mbuf *mbuf)
1184{
1185 struct cx8800_fh *fh = priv;
1186
1187 return videobuf_cgmbuf (get_queue(fh), mbuf, 8);
1188}
1189#endif
1190
1191static int vidioc_reqbufs (struct file *file, void *priv, struct v4l2_requestbuffers *p) 1182static int vidioc_reqbufs (struct file *file, void *priv, struct v4l2_requestbuffers *p)
1192{ 1183{
1193 struct cx8800_fh *fh = priv; 1184 struct cx8800_fh *fh = priv;
@@ -1731,9 +1722,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
1731 .vidioc_s_ctrl = vidioc_s_ctrl, 1722 .vidioc_s_ctrl = vidioc_s_ctrl,
1732 .vidioc_streamon = vidioc_streamon, 1723 .vidioc_streamon = vidioc_streamon,
1733 .vidioc_streamoff = vidioc_streamoff, 1724 .vidioc_streamoff = vidioc_streamoff,
1734#ifdef CONFIG_VIDEO_V4L1_COMPAT
1735 .vidiocgmbuf = vidiocgmbuf,
1736#endif
1737 .vidioc_g_tuner = vidioc_g_tuner, 1725 .vidioc_g_tuner = vidioc_g_tuner,
1738 .vidioc_s_tuner = vidioc_s_tuner, 1726 .vidioc_s_tuner = vidioc_s_tuner,
1739 .vidioc_g_frequency = vidioc_g_frequency, 1727 .vidioc_g_frequency = vidioc_g_frequency,
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 908e3bc88303..7be9bbad79ba 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -1934,19 +1934,6 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1934 O_NONBLOCK); 1934 O_NONBLOCK);
1935} 1935}
1936 1936
1937#ifdef CONFIG_VIDEO_V4L1_COMPAT
1938static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1939{
1940 struct em28xx_fh *fh = priv;
1941
1942 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1943 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1944 else
1945 return videobuf_cgmbuf(&fh->vb_vbiq, mbuf, 8);
1946}
1947#endif
1948
1949
1950/* ----------------------------------------------------------- */ 1937/* ----------------------------------------------------------- */
1951/* RADIO ESPECIFIC IOCTLS */ 1938/* RADIO ESPECIFIC IOCTLS */
1952/* ----------------------------------------------------------- */ 1939/* ----------------------------------------------------------- */
@@ -2359,9 +2346,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
2359 .vidioc_s_register = vidioc_s_register, 2346 .vidioc_s_register = vidioc_s_register,
2360 .vidioc_g_chip_ident = vidioc_g_chip_ident, 2347 .vidioc_g_chip_ident = vidioc_g_chip_ident,
2361#endif 2348#endif
2362#ifdef CONFIG_VIDEO_V4L1_COMPAT
2363 .vidiocgmbuf = vidiocgmbuf,
2364#endif
2365}; 2349};
2366 2350
2367static const struct video_device em28xx_video_template = { 2351static const struct video_device em28xx_video_template = {
diff --git a/drivers/media/video/pvrusb2/pvrusb2-v4l2.c b/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
index aaafa0398fd5..58617fc656c2 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-v4l2.c
@@ -852,8 +852,8 @@ static long pvr2_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
852#endif 852#endif
853 853
854 default : 854 default :
855 ret = v4l_compat_translate_ioctl(file, cmd, 855 ret = -EINVAL;
856 arg, pvr2_v4l2_do_ioctl); 856 break;
857 } 857 }
858 858
859 pvr2_hdw_commit_ctl(hdw); 859 pvr2_hdw_commit_ctl(hdw);
diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index 2ef1668638f9..8ca4d22b4384 100644
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -362,23 +362,6 @@ long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
362 362
363 363
364 switch (cmd) { 364 switch (cmd) {
365#ifdef CONFIG_VIDEO_V4L1_COMPAT
366 /* mmap() functions */
367 case VIDIOCGMBUF:
368 {
369 /* Tell the user program how much memory is needed for a mmap() */
370 struct video_mbuf *vm = arg;
371 int i;
372
373 memset(vm, 0, sizeof(*vm));
374 vm->size = pwc_mbufs * pdev->len_per_image;
375 vm->frames = pwc_mbufs; /* double buffering should be enough for most applications */
376 for (i = 0; i < pwc_mbufs; i++)
377 vm->offsets[i] = i * pdev->len_per_image;
378 break;
379 }
380#endif
381
382 /* V4L2 Layer */ 365 /* V4L2 Layer */
383 case VIDIOC_QUERYCAP: 366 case VIDIOC_QUERYCAP:
384 { 367 {
diff --git a/drivers/media/video/s2255drv.c b/drivers/media/video/s2255drv.c
index cf03372d1d17..b63f8cafa671 100644
--- a/drivers/media/video/s2255drv.c
+++ b/drivers/media/video/s2255drv.c
@@ -1097,15 +1097,6 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
1097 return rc; 1097 return rc;
1098} 1098}
1099 1099
1100#ifdef CONFIG_VIDEO_V4L1_COMPAT
1101static int vidioc_cgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
1102{
1103 struct s2255_fh *fh = priv;
1104
1105 return videobuf_cgmbuf(&fh->vb_vidq, mbuf, 8);
1106}
1107#endif
1108
1109/* write to the configuration pipe, synchronously */ 1100/* write to the configuration pipe, synchronously */
1110static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf, 1101static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
1111 int size) 1102 int size)
@@ -1909,9 +1900,6 @@ static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1909 .vidioc_s_ctrl = vidioc_s_ctrl, 1900 .vidioc_s_ctrl = vidioc_s_ctrl,
1910 .vidioc_streamon = vidioc_streamon, 1901 .vidioc_streamon = vidioc_streamon,
1911 .vidioc_streamoff = vidioc_streamoff, 1902 .vidioc_streamoff = vidioc_streamoff,
1912#ifdef CONFIG_VIDEO_V4L1_COMPAT
1913 .vidiocgmbuf = vidioc_cgmbuf,
1914#endif
1915 .vidioc_s_jpegcomp = vidioc_s_jpegcomp, 1903 .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1916 .vidioc_g_jpegcomp = vidioc_g_jpegcomp, 1904 .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1917 .vidioc_s_parm = vidioc_s_parm, 1905 .vidioc_s_parm = vidioc_s_parm,
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index f0b1573137f4..ad22be27bd38 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -2211,14 +2211,6 @@ static int saa7134_overlay(struct file *file, void *f, unsigned int on)
2211 return 0; 2211 return 0;
2212} 2212}
2213 2213
2214#ifdef CONFIG_VIDEO_V4L1_COMPAT
2215static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2216{
2217 struct saa7134_fh *fh = file->private_data;
2218 return videobuf_cgmbuf(saa7134_queue(fh), mbuf, 8);
2219}
2220#endif
2221
2222static int saa7134_reqbufs(struct file *file, void *priv, 2214static int saa7134_reqbufs(struct file *file, void *priv,
2223 struct v4l2_requestbuffers *p) 2215 struct v4l2_requestbuffers *p)
2224{ 2216{
@@ -2456,9 +2448,6 @@ static const struct v4l2_ioctl_ops video_ioctl_ops = {
2456 .vidioc_streamoff = saa7134_streamoff, 2448 .vidioc_streamoff = saa7134_streamoff,
2457 .vidioc_g_tuner = saa7134_g_tuner, 2449 .vidioc_g_tuner = saa7134_g_tuner,
2458 .vidioc_s_tuner = saa7134_s_tuner, 2450 .vidioc_s_tuner = saa7134_s_tuner,
2459#ifdef CONFIG_VIDEO_V4L1_COMPAT
2460 .vidiocgmbuf = vidiocgmbuf,
2461#endif
2462 .vidioc_g_crop = saa7134_g_crop, 2451 .vidioc_g_crop = saa7134_g_crop,
2463 .vidioc_s_crop = saa7134_s_crop, 2452 .vidioc_s_crop = saa7134_s_crop,
2464 .vidioc_g_fbuf = saa7134_g_fbuf, 2453 .vidioc_g_fbuf = saa7134_g_fbuf,
diff --git a/drivers/media/video/usbvision/usbvision-video.c b/drivers/media/video/usbvision/usbvision-video.c
index 011c0c386995..20da6ea2cdf0 100644
--- a/drivers/media/video/usbvision/usbvision-video.c
+++ b/drivers/media/video/usbvision/usbvision-video.c
@@ -1273,9 +1273,6 @@ static const struct v4l2_ioctl_ops usbvision_ioctl_ops = {
1273 .vidioc_s_ctrl = vidioc_s_ctrl, 1273 .vidioc_s_ctrl = vidioc_s_ctrl,
1274 .vidioc_streamon = vidioc_streamon, 1274 .vidioc_streamon = vidioc_streamon,
1275 .vidioc_streamoff = vidioc_streamoff, 1275 .vidioc_streamoff = vidioc_streamoff,
1276#ifdef CONFIG_VIDEO_V4L1_COMPAT
1277/* .vidiocgmbuf = vidiocgmbuf, */
1278#endif
1279 .vidioc_g_tuner = vidioc_g_tuner, 1276 .vidioc_g_tuner = vidioc_g_tuner,
1280 .vidioc_s_tuner = vidioc_s_tuner, 1277 .vidioc_s_tuner = vidioc_s_tuner,
1281 .vidioc_g_frequency = vidioc_g_frequency, 1278 .vidioc_g_frequency = vidioc_g_frequency,
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
index 8cf61e8a634f..9005a8d9d5f8 100644
--- a/drivers/media/video/uvc/uvc_v4l2.c
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -1035,11 +1035,8 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
1035 return uvc_xu_ctrl_query(chain, arg, 1); 1035 return uvc_xu_ctrl_query(chain, arg, 1);
1036 1036
1037 default: 1037 default:
1038 if ((ret = v4l_compat_translate_ioctl(file, cmd, arg, 1038 uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n", cmd);
1039 uvc_v4l2_do_ioctl)) == -ENOIOCTLCMD) 1039 return -EINVAL;
1040 uvc_trace(UVC_TRACE_IOCTL, "Unknown ioctl 0x%08x\n",
1041 cmd);
1042 return ret;
1043 } 1040 }
1044 1041
1045 return ret; 1042 return ret;
diff --git a/drivers/media/video/v4l1-compat.c b/drivers/media/video/v4l1-compat.c
deleted file mode 100644
index d4ac751036a2..000000000000
--- a/drivers/media/video/v4l1-compat.c
+++ /dev/null
@@ -1,1277 +0,0 @@
1/*
2 *
3 * Video for Linux Two
4 * Backward Compatibility Layer
5 *
6 * Support subroutines for providing V4L2 drivers with backward
7 * compatibility with applications using the old API.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
13 *
14 * Author: Bill Dirks <bill@thedirks.org>
15 * et al.
16 *
17 */
18
19
20#include <linux/init.h>
21#include <linux/module.h>
22#include <linux/types.h>
23#include <linux/kernel.h>
24#include <linux/sched.h>
25#include <linux/mm.h>
26#include <linux/fs.h>
27#include <linux/file.h>
28#include <linux/string.h>
29#include <linux/errno.h>
30#include <linux/slab.h>
31#include <linux/videodev.h>
32#include <media/v4l2-common.h>
33#include <media/v4l2-ioctl.h>
34
35#include <asm/uaccess.h>
36#include <asm/system.h>
37#include <asm/pgtable.h>
38
39static unsigned int debug;
40module_param(debug, int, 0644);
41MODULE_PARM_DESC(debug, "enable debug messages");
42MODULE_AUTHOR("Bill Dirks");
43MODULE_DESCRIPTION("v4l(1) compatibility layer for v4l2 drivers.");
44MODULE_LICENSE("GPL");
45
46#define dprintk(fmt, arg...) \
47 do { \
48 if (debug) \
49 printk(KERN_DEBUG "v4l1-compat: " fmt , ## arg);\
50 } while (0)
51
52/*
53 * I O C T L T R A N S L A T I O N
54 *
55 * From here on down is the code for translating the numerous
56 * ioctl commands from the old API to the new API.
57 */
58
59static int
60get_v4l_control(struct file *file,
61 int cid,
62 v4l2_kioctl drv)
63{
64 struct v4l2_queryctrl qctrl2;
65 struct v4l2_control ctrl2;
66 int err;
67
68 qctrl2.id = cid;
69 err = drv(file, VIDIOC_QUERYCTRL, &qctrl2);
70 if (err < 0)
71 dprintk("VIDIOC_QUERYCTRL: %d\n", err);
72 if (err == 0 && !(qctrl2.flags & V4L2_CTRL_FLAG_DISABLED)) {
73 ctrl2.id = qctrl2.id;
74 err = drv(file, VIDIOC_G_CTRL, &ctrl2);
75 if (err < 0) {
76 dprintk("VIDIOC_G_CTRL: %d\n", err);
77 return 0;
78 }
79 return DIV_ROUND_CLOSEST((ctrl2.value-qctrl2.minimum) * 65535,
80 qctrl2.maximum - qctrl2.minimum);
81 }
82 return 0;
83}
84
85static int
86set_v4l_control(struct file *file,
87 int cid,
88 int value,
89 v4l2_kioctl drv)
90{
91 struct v4l2_queryctrl qctrl2;
92 struct v4l2_control ctrl2;
93 int err;
94
95 qctrl2.id = cid;
96 err = drv(file, VIDIOC_QUERYCTRL, &qctrl2);
97 if (err < 0)
98 dprintk("VIDIOC_QUERYCTRL: %d\n", err);
99 if (err == 0 &&
100 !(qctrl2.flags & V4L2_CTRL_FLAG_DISABLED) &&
101 !(qctrl2.flags & V4L2_CTRL_FLAG_GRABBED)) {
102 if (value < 0)
103 value = 0;
104 if (value > 65535)
105 value = 65535;
106 if (value && qctrl2.type == V4L2_CTRL_TYPE_BOOLEAN)
107 value = 65535;
108 ctrl2.id = qctrl2.id;
109 ctrl2.value =
110 (value * (qctrl2.maximum - qctrl2.minimum)
111 + 32767)
112 / 65535;
113 ctrl2.value += qctrl2.minimum;
114 err = drv(file, VIDIOC_S_CTRL, &ctrl2);
115 if (err < 0)
116 dprintk("VIDIOC_S_CTRL: %d\n", err);
117 }
118 return 0;
119}
120
121/* ----------------------------------------------------------------- */
122
123static const unsigned int palette2pixelformat[] = {
124 [VIDEO_PALETTE_GREY] = V4L2_PIX_FMT_GREY,
125 [VIDEO_PALETTE_RGB555] = V4L2_PIX_FMT_RGB555,
126 [VIDEO_PALETTE_RGB565] = V4L2_PIX_FMT_RGB565,
127 [VIDEO_PALETTE_RGB24] = V4L2_PIX_FMT_BGR24,
128 [VIDEO_PALETTE_RGB32] = V4L2_PIX_FMT_BGR32,
129 /* yuv packed pixel */
130 [VIDEO_PALETTE_YUYV] = V4L2_PIX_FMT_YUYV,
131 [VIDEO_PALETTE_YUV422] = V4L2_PIX_FMT_YUYV,
132 [VIDEO_PALETTE_UYVY] = V4L2_PIX_FMT_UYVY,
133 /* yuv planar */
134 [VIDEO_PALETTE_YUV410P] = V4L2_PIX_FMT_YUV410,
135 [VIDEO_PALETTE_YUV420] = V4L2_PIX_FMT_YUV420,
136 [VIDEO_PALETTE_YUV420P] = V4L2_PIX_FMT_YUV420,
137 [VIDEO_PALETTE_YUV411P] = V4L2_PIX_FMT_YUV411P,
138 [VIDEO_PALETTE_YUV422P] = V4L2_PIX_FMT_YUV422P,
139};
140
141static unsigned int __pure
142palette_to_pixelformat(unsigned int palette)
143{
144 if (palette < ARRAY_SIZE(palette2pixelformat))
145 return palette2pixelformat[palette];
146 else
147 return 0;
148}
149
150static unsigned int __attribute_const__
151pixelformat_to_palette(unsigned int pixelformat)
152{
153 int palette = 0;
154 switch (pixelformat) {
155 case V4L2_PIX_FMT_GREY:
156 palette = VIDEO_PALETTE_GREY;
157 break;
158 case V4L2_PIX_FMT_RGB555:
159 palette = VIDEO_PALETTE_RGB555;
160 break;
161 case V4L2_PIX_FMT_RGB565:
162 palette = VIDEO_PALETTE_RGB565;
163 break;
164 case V4L2_PIX_FMT_BGR24:
165 palette = VIDEO_PALETTE_RGB24;
166 break;
167 case V4L2_PIX_FMT_BGR32:
168 palette = VIDEO_PALETTE_RGB32;
169 break;
170 /* yuv packed pixel */
171 case V4L2_PIX_FMT_YUYV:
172 palette = VIDEO_PALETTE_YUYV;
173 break;
174 case V4L2_PIX_FMT_UYVY:
175 palette = VIDEO_PALETTE_UYVY;
176 break;
177 /* yuv planar */
178 case V4L2_PIX_FMT_YUV410:
179 palette = VIDEO_PALETTE_YUV420;
180 break;
181 case V4L2_PIX_FMT_YUV420:
182 palette = VIDEO_PALETTE_YUV420;
183 break;
184 case V4L2_PIX_FMT_YUV411P:
185 palette = VIDEO_PALETTE_YUV411P;
186 break;
187 case V4L2_PIX_FMT_YUV422P:
188 palette = VIDEO_PALETTE_YUV422P;
189 break;
190 }
191 return palette;
192}
193
194/* ----------------------------------------------------------------- */
195
196static int poll_one(struct file *file, struct poll_wqueues *pwq)
197{
198 int retval = 1;
199 poll_table *table;
200
201 poll_initwait(pwq);
202 table = &pwq->pt;
203 for (;;) {
204 int mask;
205 mask = file->f_op->poll(file, table);
206 if (mask & POLLIN)
207 break;
208 table = NULL;
209 if (signal_pending(current)) {
210 retval = -ERESTARTSYS;
211 break;
212 }
213 poll_schedule(pwq, TASK_INTERRUPTIBLE);
214 }
215 poll_freewait(pwq);
216 return retval;
217}
218
219static int count_inputs(
220 struct file *file,
221 v4l2_kioctl drv)
222{
223 struct v4l2_input input2;
224 int i;
225
226 for (i = 0;; i++) {
227 memset(&input2, 0, sizeof(input2));
228 input2.index = i;
229 if (0 != drv(file, VIDIOC_ENUMINPUT, &input2))
230 break;
231 }
232 return i;
233}
234
235static int check_size(
236 struct file *file,
237 v4l2_kioctl drv,
238 int *maxw,
239 int *maxh)
240{
241 struct v4l2_fmtdesc desc2;
242 struct v4l2_format fmt2;
243
244 memset(&desc2, 0, sizeof(desc2));
245 memset(&fmt2, 0, sizeof(fmt2));
246
247 desc2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
248 if (0 != drv(file, VIDIOC_ENUM_FMT, &desc2))
249 goto done;
250
251 fmt2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
252 fmt2.fmt.pix.width = 10000;
253 fmt2.fmt.pix.height = 10000;
254 fmt2.fmt.pix.pixelformat = desc2.pixelformat;
255 if (0 != drv(file, VIDIOC_TRY_FMT, &fmt2))
256 goto done;
257
258 *maxw = fmt2.fmt.pix.width;
259 *maxh = fmt2.fmt.pix.height;
260
261done:
262 return 0;
263}
264
265/* ----------------------------------------------------------------- */
266
267static noinline long v4l1_compat_get_capabilities(
268 struct video_capability *cap,
269 struct file *file,
270 v4l2_kioctl drv)
271{
272 long err;
273 struct v4l2_framebuffer fbuf;
274 struct v4l2_capability *cap2;
275
276 cap2 = kzalloc(sizeof(*cap2), GFP_KERNEL);
277 if (!cap2) {
278 err = -ENOMEM;
279 return err;
280 }
281 memset(cap, 0, sizeof(*cap));
282 memset(&fbuf, 0, sizeof(fbuf));
283
284 err = drv(file, VIDIOC_QUERYCAP, cap2);
285 if (err < 0) {
286 dprintk("VIDIOCGCAP / VIDIOC_QUERYCAP: %ld\n", err);
287 goto done;
288 }
289 if (cap2->capabilities & V4L2_CAP_VIDEO_OVERLAY) {
290 err = drv(file, VIDIOC_G_FBUF, &fbuf);
291 if (err < 0) {
292 dprintk("VIDIOCGCAP / VIDIOC_G_FBUF: %ld\n", err);
293 memset(&fbuf, 0, sizeof(fbuf));
294 }
295 err = 0;
296 }
297
298 memcpy(cap->name, cap2->card,
299 min(sizeof(cap->name), sizeof(cap2->card)));
300 cap->name[sizeof(cap->name) - 1] = 0;
301 if (cap2->capabilities & V4L2_CAP_VIDEO_CAPTURE)
302 cap->type |= VID_TYPE_CAPTURE;
303 if (cap2->capabilities & V4L2_CAP_TUNER)
304 cap->type |= VID_TYPE_TUNER;
305 if (cap2->capabilities & V4L2_CAP_VBI_CAPTURE)
306 cap->type |= VID_TYPE_TELETEXT;
307 if (cap2->capabilities & V4L2_CAP_VIDEO_OVERLAY)
308 cap->type |= VID_TYPE_OVERLAY;
309 if (fbuf.capability & V4L2_FBUF_CAP_LIST_CLIPPING)
310 cap->type |= VID_TYPE_CLIPPING;
311
312 cap->channels = count_inputs(file, drv);
313 check_size(file, drv,
314 &cap->maxwidth, &cap->maxheight);
315 cap->audios = 0; /* FIXME */
316 cap->minwidth = 48; /* FIXME */
317 cap->minheight = 32; /* FIXME */
318
319done:
320 kfree(cap2);
321 return err;
322}
323
324static noinline long v4l1_compat_get_frame_buffer(
325 struct video_buffer *buffer,
326 struct file *file,
327 v4l2_kioctl drv)
328{
329 long err;
330 struct v4l2_framebuffer fbuf;
331
332 memset(buffer, 0, sizeof(*buffer));
333 memset(&fbuf, 0, sizeof(fbuf));
334
335 err = drv(file, VIDIOC_G_FBUF, &fbuf);
336 if (err < 0) {
337 dprintk("VIDIOCGFBUF / VIDIOC_G_FBUF: %ld\n", err);
338 goto done;
339 }
340 buffer->base = fbuf.base;
341 buffer->height = fbuf.fmt.height;
342 buffer->width = fbuf.fmt.width;
343
344 switch (fbuf.fmt.pixelformat) {
345 case V4L2_PIX_FMT_RGB332:
346 buffer->depth = 8;
347 break;
348 case V4L2_PIX_FMT_RGB555:
349 buffer->depth = 15;
350 break;
351 case V4L2_PIX_FMT_RGB565:
352 buffer->depth = 16;
353 break;
354 case V4L2_PIX_FMT_BGR24:
355 buffer->depth = 24;
356 break;
357 case V4L2_PIX_FMT_BGR32:
358 buffer->depth = 32;
359 break;
360 default:
361 buffer->depth = 0;
362 }
363 if (fbuf.fmt.bytesperline) {
364 buffer->bytesperline = fbuf.fmt.bytesperline;
365 if (!buffer->depth && buffer->width)
366 buffer->depth = ((fbuf.fmt.bytesperline<<3)
367 + (buffer->width-1))
368 / buffer->width;
369 } else {
370 buffer->bytesperline =
371 (buffer->width * buffer->depth + 7) & 7;
372 buffer->bytesperline >>= 3;
373 }
374done:
375 return err;
376}
377
378static noinline long v4l1_compat_set_frame_buffer(
379 struct video_buffer *buffer,
380 struct file *file,
381 v4l2_kioctl drv)
382{
383 long err;
384 struct v4l2_framebuffer fbuf;
385
386 memset(&fbuf, 0, sizeof(fbuf));
387 fbuf.base = buffer->base;
388 fbuf.fmt.height = buffer->height;
389 fbuf.fmt.width = buffer->width;
390 switch (buffer->depth) {
391 case 8:
392 fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB332;
393 break;
394 case 15:
395 fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB555;
396 break;
397 case 16:
398 fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB565;
399 break;
400 case 24:
401 fbuf.fmt.pixelformat = V4L2_PIX_FMT_BGR24;
402 break;
403 case 32:
404 fbuf.fmt.pixelformat = V4L2_PIX_FMT_BGR32;
405 break;
406 }
407 fbuf.fmt.bytesperline = buffer->bytesperline;
408 err = drv(file, VIDIOC_S_FBUF, &fbuf);
409 if (err < 0)
410 dprintk("VIDIOCSFBUF / VIDIOC_S_FBUF: %ld\n", err);
411 return err;
412}
413
414static noinline long v4l1_compat_get_win_cap_dimensions(
415 struct video_window *win,
416 struct file *file,
417 v4l2_kioctl drv)
418{
419 long err;
420 struct v4l2_format *fmt;
421
422 fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
423 if (!fmt) {
424 err = -ENOMEM;
425 return err;
426 }
427 memset(win, 0, sizeof(*win));
428
429 fmt->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
430 err = drv(file, VIDIOC_G_FMT, fmt);
431 if (err < 0)
432 dprintk("VIDIOCGWIN / VIDIOC_G_WIN: %ld\n", err);
433 if (err == 0) {
434 win->x = fmt->fmt.win.w.left;
435 win->y = fmt->fmt.win.w.top;
436 win->width = fmt->fmt.win.w.width;
437 win->height = fmt->fmt.win.w.height;
438 win->chromakey = fmt->fmt.win.chromakey;
439 win->clips = NULL;
440 win->clipcount = 0;
441 goto done;
442 }
443
444 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
445 err = drv(file, VIDIOC_G_FMT, fmt);
446 if (err < 0) {
447 dprintk("VIDIOCGWIN / VIDIOC_G_FMT: %ld\n", err);
448 goto done;
449 }
450 win->x = 0;
451 win->y = 0;
452 win->width = fmt->fmt.pix.width;
453 win->height = fmt->fmt.pix.height;
454 win->chromakey = 0;
455 win->clips = NULL;
456 win->clipcount = 0;
457done:
458 kfree(fmt);
459 return err;
460}
461
462static noinline long v4l1_compat_set_win_cap_dimensions(
463 struct video_window *win,
464 struct file *file,
465 v4l2_kioctl drv)
466{
467 long err, err1, err2;
468 struct v4l2_format *fmt;
469
470 fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
471 if (!fmt) {
472 err = -ENOMEM;
473 return err;
474 }
475 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
476 drv(file, VIDIOC_STREAMOFF, &fmt->type);
477 err1 = drv(file, VIDIOC_G_FMT, fmt);
478 if (err1 < 0)
479 dprintk("VIDIOCSWIN / VIDIOC_G_FMT: %ld\n", err1);
480 if (err1 == 0) {
481 fmt->fmt.pix.width = win->width;
482 fmt->fmt.pix.height = win->height;
483 fmt->fmt.pix.field = V4L2_FIELD_ANY;
484 fmt->fmt.pix.bytesperline = 0;
485 err = drv(file, VIDIOC_S_FMT, fmt);
486 if (err < 0)
487 dprintk("VIDIOCSWIN / VIDIOC_S_FMT #1: %ld\n",
488 err);
489 win->width = fmt->fmt.pix.width;
490 win->height = fmt->fmt.pix.height;
491 }
492
493 memset(fmt, 0, sizeof(*fmt));
494 fmt->type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
495 fmt->fmt.win.w.left = win->x;
496 fmt->fmt.win.w.top = win->y;
497 fmt->fmt.win.w.width = win->width;
498 fmt->fmt.win.w.height = win->height;
499 fmt->fmt.win.chromakey = win->chromakey;
500 fmt->fmt.win.clips = (void __user *)win->clips;
501 fmt->fmt.win.clipcount = win->clipcount;
502 err2 = drv(file, VIDIOC_S_FMT, fmt);
503 if (err2 < 0)
504 dprintk("VIDIOCSWIN / VIDIOC_S_FMT #2: %ld\n", err2);
505
506 if (err1 != 0 && err2 != 0)
507 err = err1;
508 else
509 err = 0;
510 kfree(fmt);
511 return err;
512}
513
514static noinline long v4l1_compat_turn_preview_on_off(
515 int *on,
516 struct file *file,
517 v4l2_kioctl drv)
518{
519 long err;
520 enum v4l2_buf_type captype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
521
522 if (0 == *on) {
523 /* dirty hack time. But v4l1 has no STREAMOFF
524 * equivalent in the API, and this one at
525 * least comes close ... */
526 drv(file, VIDIOC_STREAMOFF, &captype);
527 }
528 err = drv(file, VIDIOC_OVERLAY, on);
529 if (err < 0)
530 dprintk("VIDIOCCAPTURE / VIDIOC_PREVIEW: %ld\n", err);
531 return err;
532}
533
534static noinline long v4l1_compat_get_input_info(
535 struct video_channel *chan,
536 struct file *file,
537 v4l2_kioctl drv)
538{
539 long err;
540 struct v4l2_input input2;
541 v4l2_std_id sid;
542
543 memset(&input2, 0, sizeof(input2));
544 input2.index = chan->channel;
545 err = drv(file, VIDIOC_ENUMINPUT, &input2);
546 if (err < 0) {
547 dprintk("VIDIOCGCHAN / VIDIOC_ENUMINPUT: "
548 "channel=%d err=%ld\n", chan->channel, err);
549 goto done;
550 }
551 chan->channel = input2.index;
552 memcpy(chan->name, input2.name,
553 min(sizeof(chan->name), sizeof(input2.name)));
554 chan->name[sizeof(chan->name) - 1] = 0;
555 chan->tuners = (input2.type == V4L2_INPUT_TYPE_TUNER) ? 1 : 0;
556 chan->flags = (chan->tuners) ? VIDEO_VC_TUNER : 0;
557 switch (input2.type) {
558 case V4L2_INPUT_TYPE_TUNER:
559 chan->type = VIDEO_TYPE_TV;
560 break;
561 default:
562 case V4L2_INPUT_TYPE_CAMERA:
563 chan->type = VIDEO_TYPE_CAMERA;
564 break;
565 }
566 chan->norm = 0;
567 /* Note: G_STD might not be present for radio receivers,
568 * so we should ignore any errors. */
569 if (drv(file, VIDIOC_G_STD, &sid) == 0) {
570 if (sid & V4L2_STD_PAL)
571 chan->norm = VIDEO_MODE_PAL;
572 if (sid & V4L2_STD_NTSC)
573 chan->norm = VIDEO_MODE_NTSC;
574 if (sid & V4L2_STD_SECAM)
575 chan->norm = VIDEO_MODE_SECAM;
576 if (sid == V4L2_STD_ALL)
577 chan->norm = VIDEO_MODE_AUTO;
578 }
579done:
580 return err;
581}
582
583static noinline long v4l1_compat_set_input(
584 struct video_channel *chan,
585 struct file *file,
586 v4l2_kioctl drv)
587{
588 long err;
589 v4l2_std_id sid = 0;
590
591 err = drv(file, VIDIOC_S_INPUT, &chan->channel);
592 if (err < 0)
593 dprintk("VIDIOCSCHAN / VIDIOC_S_INPUT: %ld\n", err);
594 switch (chan->norm) {
595 case VIDEO_MODE_PAL:
596 sid = V4L2_STD_PAL;
597 break;
598 case VIDEO_MODE_NTSC:
599 sid = V4L2_STD_NTSC;
600 break;
601 case VIDEO_MODE_SECAM:
602 sid = V4L2_STD_SECAM;
603 break;
604 case VIDEO_MODE_AUTO:
605 sid = V4L2_STD_ALL;
606 break;
607 }
608 if (0 != sid) {
609 err = drv(file, VIDIOC_S_STD, &sid);
610 if (err < 0)
611 dprintk("VIDIOCSCHAN / VIDIOC_S_STD: %ld\n", err);
612 }
613 return err;
614}
615
616static noinline long v4l1_compat_get_picture(
617 struct video_picture *pict,
618 struct file *file,
619 v4l2_kioctl drv)
620{
621 long err;
622 struct v4l2_format *fmt;
623
624 fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
625 if (!fmt) {
626 err = -ENOMEM;
627 return err;
628 }
629
630 pict->brightness = get_v4l_control(file,
631 V4L2_CID_BRIGHTNESS, drv);
632 pict->hue = get_v4l_control(file,
633 V4L2_CID_HUE, drv);
634 pict->contrast = get_v4l_control(file,
635 V4L2_CID_CONTRAST, drv);
636 pict->colour = get_v4l_control(file,
637 V4L2_CID_SATURATION, drv);
638 pict->whiteness = get_v4l_control(file,
639 V4L2_CID_WHITENESS, drv);
640
641 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
642 err = drv(file, VIDIOC_G_FMT, fmt);
643 if (err < 0) {
644 dprintk("VIDIOCGPICT / VIDIOC_G_FMT: %ld\n", err);
645 goto done;
646 }
647
648 if (fmt->fmt.pix.width)
649 {
650 pict->depth = ((fmt->fmt.pix.bytesperline << 3)
651 + (fmt->fmt.pix.width - 1))
652 / fmt->fmt.pix.width;
653 } else {
654 err = -EINVAL;
655 goto done;
656 }
657
658 pict->palette = pixelformat_to_palette(
659 fmt->fmt.pix.pixelformat);
660done:
661 kfree(fmt);
662 return err;
663}
664
665static noinline long v4l1_compat_set_picture(
666 struct video_picture *pict,
667 struct file *file,
668 v4l2_kioctl drv)
669{
670 long err;
671 struct v4l2_framebuffer fbuf;
672 int mem_err = 0, ovl_err = 0;
673 struct v4l2_format *fmt;
674
675 fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
676 if (!fmt) {
677 err = -ENOMEM;
678 return err;
679 }
680 memset(&fbuf, 0, sizeof(fbuf));
681
682 set_v4l_control(file,
683 V4L2_CID_BRIGHTNESS, pict->brightness, drv);
684 set_v4l_control(file,
685 V4L2_CID_HUE, pict->hue, drv);
686 set_v4l_control(file,
687 V4L2_CID_CONTRAST, pict->contrast, drv);
688 set_v4l_control(file,
689 V4L2_CID_SATURATION, pict->colour, drv);
690 set_v4l_control(file,
691 V4L2_CID_WHITENESS, pict->whiteness, drv);
692 /*
693 * V4L1 uses this ioctl to set both memory capture and overlay
694 * pixel format, while V4L2 has two different ioctls for this.
695 * Some cards may not support one or the other, and may support
696 * different pixel formats for memory vs overlay.
697 */
698
699 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
700 err = drv(file, VIDIOC_G_FMT, fmt);
701 /* If VIDIOC_G_FMT failed, then the driver likely doesn't
702 support memory capture. Trying to set the memory capture
703 parameters would be pointless. */
704 if (err < 0) {
705 dprintk("VIDIOCSPICT / VIDIOC_G_FMT: %ld\n", err);
706 mem_err = -1000; /* didn't even try */
707 } else if (fmt->fmt.pix.pixelformat !=
708 palette_to_pixelformat(pict->palette)) {
709 fmt->fmt.pix.pixelformat = palette_to_pixelformat(
710 pict->palette);
711 mem_err = drv(file, VIDIOC_S_FMT, fmt);
712 if (mem_err < 0)
713 dprintk("VIDIOCSPICT / VIDIOC_S_FMT: %d\n",
714 mem_err);
715 }
716
717 err = drv(file, VIDIOC_G_FBUF, &fbuf);
718 /* If VIDIOC_G_FBUF failed, then the driver likely doesn't
719 support overlay. Trying to set the overlay parameters
720 would be quite pointless. */
721 if (err < 0) {
722 dprintk("VIDIOCSPICT / VIDIOC_G_FBUF: %ld\n", err);
723 ovl_err = -1000; /* didn't even try */
724 } else if (fbuf.fmt.pixelformat !=
725 palette_to_pixelformat(pict->palette)) {
726 fbuf.fmt.pixelformat = palette_to_pixelformat(
727 pict->palette);
728 ovl_err = drv(file, VIDIOC_S_FBUF, &fbuf);
729 if (ovl_err < 0)
730 dprintk("VIDIOCSPICT / VIDIOC_S_FBUF: %d\n",
731 ovl_err);
732 }
733 if (ovl_err < 0 && mem_err < 0) {
734 /* ioctl failed, couldn't set either parameter */
735 if (mem_err != -1000)
736 err = mem_err;
737 else if (ovl_err == -EPERM)
738 err = 0;
739 else
740 err = ovl_err;
741 } else
742 err = 0;
743 kfree(fmt);
744 return err;
745}
746
747static noinline long v4l1_compat_get_tuner(
748 struct video_tuner *tun,
749 struct file *file,
750 v4l2_kioctl drv)
751{
752 long err;
753 int i;
754 struct v4l2_tuner tun2;
755 struct v4l2_standard std2;
756 v4l2_std_id sid;
757
758 memset(&tun2, 0, sizeof(tun2));
759 err = drv(file, VIDIOC_G_TUNER, &tun2);
760 if (err < 0) {
761 dprintk("VIDIOCGTUNER / VIDIOC_G_TUNER: %ld\n", err);
762 goto done;
763 }
764 memcpy(tun->name, tun2.name,
765 min(sizeof(tun->name), sizeof(tun2.name)));
766 tun->name[sizeof(tun->name) - 1] = 0;
767 tun->rangelow = tun2.rangelow;
768 tun->rangehigh = tun2.rangehigh;
769 tun->flags = 0;
770 tun->mode = VIDEO_MODE_AUTO;
771
772 for (i = 0; i < 64; i++) {
773 memset(&std2, 0, sizeof(std2));
774 std2.index = i;
775 if (0 != drv(file, VIDIOC_ENUMSTD, &std2))
776 break;
777 if (std2.id & V4L2_STD_PAL)
778 tun->flags |= VIDEO_TUNER_PAL;
779 if (std2.id & V4L2_STD_NTSC)
780 tun->flags |= VIDEO_TUNER_NTSC;
781 if (std2.id & V4L2_STD_SECAM)
782 tun->flags |= VIDEO_TUNER_SECAM;
783 }
784
785 /* Note: G_STD might not be present for radio receivers,
786 * so we should ignore any errors. */
787 if (drv(file, VIDIOC_G_STD, &sid) == 0) {
788 if (sid & V4L2_STD_PAL)
789 tun->mode = VIDEO_MODE_PAL;
790 if (sid & V4L2_STD_NTSC)
791 tun->mode = VIDEO_MODE_NTSC;
792 if (sid & V4L2_STD_SECAM)
793 tun->mode = VIDEO_MODE_SECAM;
794 }
795
796 if (tun2.capability & V4L2_TUNER_CAP_LOW)
797 tun->flags |= VIDEO_TUNER_LOW;
798 if (tun2.rxsubchans & V4L2_TUNER_SUB_STEREO)
799 tun->flags |= VIDEO_TUNER_STEREO_ON;
800 tun->signal = tun2.signal;
801done:
802 return err;
803}
804
805static noinline long v4l1_compat_select_tuner(
806 struct video_tuner *tun,
807 struct file *file,
808 v4l2_kioctl drv)
809{
810 long err;
811 struct v4l2_tuner t;/*84 bytes on x86_64*/
812 memset(&t, 0, sizeof(t));
813
814 t.index = tun->tuner;
815
816 err = drv(file, VIDIOC_S_TUNER, &t);
817 if (err < 0)
818 dprintk("VIDIOCSTUNER / VIDIOC_S_TUNER: %ld\n", err);
819 return err;
820}
821
822static noinline long v4l1_compat_get_frequency(
823 unsigned long *freq,
824 struct file *file,
825 v4l2_kioctl drv)
826{
827 long err;
828 struct v4l2_frequency freq2;
829 memset(&freq2, 0, sizeof(freq2));
830
831 freq2.tuner = 0;
832 err = drv(file, VIDIOC_G_FREQUENCY, &freq2);
833 if (err < 0)
834 dprintk("VIDIOCGFREQ / VIDIOC_G_FREQUENCY: %ld\n", err);
835 if (0 == err)
836 *freq = freq2.frequency;
837 return err;
838}
839
840static noinline long v4l1_compat_set_frequency(
841 unsigned long *freq,
842 struct file *file,
843 v4l2_kioctl drv)
844{
845 long err;
846 struct v4l2_frequency freq2;
847 memset(&freq2, 0, sizeof(freq2));
848
849 drv(file, VIDIOC_G_FREQUENCY, &freq2);
850 freq2.frequency = *freq;
851 err = drv(file, VIDIOC_S_FREQUENCY, &freq2);
852 if (err < 0)
853 dprintk("VIDIOCSFREQ / VIDIOC_S_FREQUENCY: %ld\n", err);
854 return err;
855}
856
857static noinline long v4l1_compat_get_audio(
858 struct video_audio *aud,
859 struct file *file,
860 v4l2_kioctl drv)
861{
862 long err;
863 int i;
864 struct v4l2_queryctrl qctrl2;
865 struct v4l2_audio aud2;
866 struct v4l2_tuner tun2;
867 memset(&aud2, 0, sizeof(aud2));
868
869 err = drv(file, VIDIOC_G_AUDIO, &aud2);
870 if (err < 0) {
871 dprintk("VIDIOCGAUDIO / VIDIOC_G_AUDIO: %ld\n", err);
872 goto done;
873 }
874 memcpy(aud->name, aud2.name,
875 min(sizeof(aud->name), sizeof(aud2.name)));
876 aud->name[sizeof(aud->name) - 1] = 0;
877 aud->audio = aud2.index;
878 aud->flags = 0;
879 i = get_v4l_control(file, V4L2_CID_AUDIO_VOLUME, drv);
880 if (i >= 0) {
881 aud->volume = i;
882 aud->flags |= VIDEO_AUDIO_VOLUME;
883 }
884 i = get_v4l_control(file, V4L2_CID_AUDIO_BASS, drv);
885 if (i >= 0) {
886 aud->bass = i;
887 aud->flags |= VIDEO_AUDIO_BASS;
888 }
889 i = get_v4l_control(file, V4L2_CID_AUDIO_TREBLE, drv);
890 if (i >= 0) {
891 aud->treble = i;
892 aud->flags |= VIDEO_AUDIO_TREBLE;
893 }
894 i = get_v4l_control(file, V4L2_CID_AUDIO_BALANCE, drv);
895 if (i >= 0) {
896 aud->balance = i;
897 aud->flags |= VIDEO_AUDIO_BALANCE;
898 }
899 i = get_v4l_control(file, V4L2_CID_AUDIO_MUTE, drv);
900 if (i >= 0) {
901 if (i)
902 aud->flags |= VIDEO_AUDIO_MUTE;
903 aud->flags |= VIDEO_AUDIO_MUTABLE;
904 }
905 aud->step = 1;
906 qctrl2.id = V4L2_CID_AUDIO_VOLUME;
907 if (drv(file, VIDIOC_QUERYCTRL, &qctrl2) == 0 &&
908 !(qctrl2.flags & V4L2_CTRL_FLAG_DISABLED))
909 aud->step = qctrl2.step;
910 aud->mode = 0;
911
912 memset(&tun2, 0, sizeof(tun2));
913 err = drv(file, VIDIOC_G_TUNER, &tun2);
914 if (err < 0) {
915 dprintk("VIDIOCGAUDIO / VIDIOC_G_TUNER: %ld\n", err);
916 err = 0;
917 goto done;
918 }
919
920 if (tun2.rxsubchans & V4L2_TUNER_SUB_LANG2)
921 aud->mode = VIDEO_SOUND_LANG1 | VIDEO_SOUND_LANG2;
922 else if (tun2.rxsubchans & V4L2_TUNER_SUB_STEREO)
923 aud->mode = VIDEO_SOUND_STEREO;
924 else if (tun2.rxsubchans & V4L2_TUNER_SUB_MONO)
925 aud->mode = VIDEO_SOUND_MONO;
926done:
927 return err;
928}
929
930static noinline long v4l1_compat_set_audio(
931 struct video_audio *aud,
932 struct file *file,
933 v4l2_kioctl drv)
934{
935 long err;
936 struct v4l2_audio aud2;
937 struct v4l2_tuner tun2;
938
939 memset(&aud2, 0, sizeof(aud2));
940 memset(&tun2, 0, sizeof(tun2));
941
942 aud2.index = aud->audio;
943 err = drv(file, VIDIOC_S_AUDIO, &aud2);
944 if (err < 0) {
945 dprintk("VIDIOCSAUDIO / VIDIOC_S_AUDIO: %ld\n", err);
946 goto done;
947 }
948
949 set_v4l_control(file, V4L2_CID_AUDIO_VOLUME,
950 aud->volume, drv);
951 set_v4l_control(file, V4L2_CID_AUDIO_BASS,
952 aud->bass, drv);
953 set_v4l_control(file, V4L2_CID_AUDIO_TREBLE,
954 aud->treble, drv);
955 set_v4l_control(file, V4L2_CID_AUDIO_BALANCE,
956 aud->balance, drv);
957 set_v4l_control(file, V4L2_CID_AUDIO_MUTE,
958 !!(aud->flags & VIDEO_AUDIO_MUTE), drv);
959
960 err = drv(file, VIDIOC_G_TUNER, &tun2);
961 if (err < 0)
962 dprintk("VIDIOCSAUDIO / VIDIOC_G_TUNER: %ld\n", err);
963 if (err == 0) {
964 switch (aud->mode) {
965 default:
966 case VIDEO_SOUND_MONO:
967 case VIDEO_SOUND_LANG1:
968 tun2.audmode = V4L2_TUNER_MODE_MONO;
969 break;
970 case VIDEO_SOUND_STEREO:
971 tun2.audmode = V4L2_TUNER_MODE_STEREO;
972 break;
973 case VIDEO_SOUND_LANG2:
974 tun2.audmode = V4L2_TUNER_MODE_LANG2;
975 break;
976 }
977 err = drv(file, VIDIOC_S_TUNER, &tun2);
978 if (err < 0)
979 dprintk("VIDIOCSAUDIO / VIDIOC_S_TUNER: %ld\n", err);
980 }
981 err = 0;
982done:
983 return err;
984}
985
986static noinline long v4l1_compat_capture_frame(
987 struct video_mmap *mm,
988 struct file *file,
989 v4l2_kioctl drv)
990{
991 long err;
992 enum v4l2_buf_type captype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
993 struct v4l2_buffer buf;
994 struct v4l2_format *fmt;
995
996 fmt = kzalloc(sizeof(*fmt), GFP_KERNEL);
997 if (!fmt) {
998 err = -ENOMEM;
999 return err;
1000 }
1001 memset(&buf, 0, sizeof(buf));
1002
1003 fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1004 err = drv(file, VIDIOC_G_FMT, fmt);
1005 if (err < 0) {
1006 dprintk("VIDIOCMCAPTURE / VIDIOC_G_FMT: %ld\n", err);
1007 goto done;
1008 }
1009 if (mm->width != fmt->fmt.pix.width ||
1010 mm->height != fmt->fmt.pix.height ||
1011 palette_to_pixelformat(mm->format) !=
1012 fmt->fmt.pix.pixelformat) {
1013 /* New capture format... */
1014 fmt->fmt.pix.width = mm->width;
1015 fmt->fmt.pix.height = mm->height;
1016 fmt->fmt.pix.pixelformat =
1017 palette_to_pixelformat(mm->format);
1018 fmt->fmt.pix.field = V4L2_FIELD_ANY;
1019 fmt->fmt.pix.bytesperline = 0;
1020 err = drv(file, VIDIOC_S_FMT, fmt);
1021 if (err < 0) {
1022 dprintk("VIDIOCMCAPTURE / VIDIOC_S_FMT: %ld\n", err);
1023 goto done;
1024 }
1025 }
1026 buf.index = mm->frame;
1027 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1028 err = drv(file, VIDIOC_QUERYBUF, &buf);
1029 if (err < 0) {
1030 dprintk("VIDIOCMCAPTURE / VIDIOC_QUERYBUF: %ld\n", err);
1031 goto done;
1032 }
1033 err = drv(file, VIDIOC_QBUF, &buf);
1034 if (err < 0) {
1035 dprintk("VIDIOCMCAPTURE / VIDIOC_QBUF: %ld\n", err);
1036 goto done;
1037 }
1038 err = drv(file, VIDIOC_STREAMON, &captype);
1039 if (err < 0)
1040 dprintk("VIDIOCMCAPTURE / VIDIOC_STREAMON: %ld\n", err);
1041done:
1042 kfree(fmt);
1043 return err;
1044}
1045
1046static noinline long v4l1_compat_sync(
1047 int *i,
1048 struct file *file,
1049 v4l2_kioctl drv)
1050{
1051 long err;
1052 enum v4l2_buf_type captype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1053 struct v4l2_buffer buf;
1054 struct poll_wqueues *pwq;
1055
1056 memset(&buf, 0, sizeof(buf));
1057 buf.index = *i;
1058 buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1059 err = drv(file, VIDIOC_QUERYBUF, &buf);
1060 if (err < 0) {
1061 /* No such buffer */
1062 dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %ld\n", err);
1063 goto done;
1064 }
1065 if (!(buf.flags & V4L2_BUF_FLAG_MAPPED)) {
1066 /* Buffer is not mapped */
1067 err = -EINVAL;
1068 goto done;
1069 }
1070
1071 /* make sure capture actually runs so we don't block forever */
1072 err = drv(file, VIDIOC_STREAMON, &captype);
1073 if (err < 0) {
1074 dprintk("VIDIOCSYNC / VIDIOC_STREAMON: %ld\n", err);
1075 goto done;
1076 }
1077
1078 pwq = kmalloc(sizeof(*pwq), GFP_KERNEL);
1079 /* Loop as long as the buffer is queued, but not done */
1080 while ((buf.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE))
1081 == V4L2_BUF_FLAG_QUEUED) {
1082 err = poll_one(file, pwq);
1083 if (err < 0 || /* error or sleep was interrupted */
1084 err == 0) /* timeout? Shouldn't occur. */
1085 break;
1086 err = drv(file, VIDIOC_QUERYBUF, &buf);
1087 if (err < 0)
1088 dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %ld\n", err);
1089 }
1090 kfree(pwq);
1091 if (!(buf.flags & V4L2_BUF_FLAG_DONE)) /* not done */
1092 goto done;
1093 do {
1094 err = drv(file, VIDIOC_DQBUF, &buf);
1095 if (err < 0)
1096 dprintk("VIDIOCSYNC / VIDIOC_DQBUF: %ld\n", err);
1097 } while (err == 0 && buf.index != *i);
1098done:
1099 return err;
1100}
1101
1102static noinline long v4l1_compat_get_vbi_format(
1103 struct vbi_format *fmt,
1104 struct file *file,
1105 v4l2_kioctl drv)
1106{
1107 long err;
1108 struct v4l2_format *fmt2;
1109
1110 fmt2 = kzalloc(sizeof(*fmt2), GFP_KERNEL);
1111 if (!fmt2) {
1112 err = -ENOMEM;
1113 return err;
1114 }
1115 fmt2->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1116
1117 err = drv(file, VIDIOC_G_FMT, fmt2);
1118 if (err < 0) {
1119 dprintk("VIDIOCGVBIFMT / VIDIOC_G_FMT: %ld\n", err);
1120 goto done;
1121 }
1122 if (fmt2->fmt.vbi.sample_format != V4L2_PIX_FMT_GREY) {
1123 err = -EINVAL;
1124 goto done;
1125 }
1126 memset(fmt, 0, sizeof(*fmt));
1127 fmt->samples_per_line = fmt2->fmt.vbi.samples_per_line;
1128 fmt->sampling_rate = fmt2->fmt.vbi.sampling_rate;
1129 fmt->sample_format = VIDEO_PALETTE_RAW;
1130 fmt->start[0] = fmt2->fmt.vbi.start[0];
1131 fmt->count[0] = fmt2->fmt.vbi.count[0];
1132 fmt->start[1] = fmt2->fmt.vbi.start[1];
1133 fmt->count[1] = fmt2->fmt.vbi.count[1];
1134 fmt->flags = fmt2->fmt.vbi.flags & 0x03;
1135done:
1136 kfree(fmt2);
1137 return err;
1138}
1139
1140static noinline long v4l1_compat_set_vbi_format(
1141 struct vbi_format *fmt,
1142 struct file *file,
1143 v4l2_kioctl drv)
1144{
1145 long err;
1146 struct v4l2_format *fmt2 = NULL;
1147
1148 if (VIDEO_PALETTE_RAW != fmt->sample_format) {
1149 err = -EINVAL;
1150 return err;
1151 }
1152
1153 fmt2 = kzalloc(sizeof(*fmt2), GFP_KERNEL);
1154 if (!fmt2) {
1155 err = -ENOMEM;
1156 return err;
1157 }
1158 fmt2->type = V4L2_BUF_TYPE_VBI_CAPTURE;
1159 fmt2->fmt.vbi.samples_per_line = fmt->samples_per_line;
1160 fmt2->fmt.vbi.sampling_rate = fmt->sampling_rate;
1161 fmt2->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1162 fmt2->fmt.vbi.start[0] = fmt->start[0];
1163 fmt2->fmt.vbi.count[0] = fmt->count[0];
1164 fmt2->fmt.vbi.start[1] = fmt->start[1];
1165 fmt2->fmt.vbi.count[1] = fmt->count[1];
1166 fmt2->fmt.vbi.flags = fmt->flags;
1167 err = drv(file, VIDIOC_TRY_FMT, fmt2);
1168 if (err < 0) {
1169 dprintk("VIDIOCSVBIFMT / VIDIOC_TRY_FMT: %ld\n", err);
1170 goto done;
1171 }
1172
1173 if (fmt2->fmt.vbi.samples_per_line != fmt->samples_per_line ||
1174 fmt2->fmt.vbi.sampling_rate != fmt->sampling_rate ||
1175 fmt2->fmt.vbi.sample_format != V4L2_PIX_FMT_GREY ||
1176 fmt2->fmt.vbi.start[0] != fmt->start[0] ||
1177 fmt2->fmt.vbi.count[0] != fmt->count[0] ||
1178 fmt2->fmt.vbi.start[1] != fmt->start[1] ||
1179 fmt2->fmt.vbi.count[1] != fmt->count[1] ||
1180 fmt2->fmt.vbi.flags != fmt->flags) {
1181 err = -EINVAL;
1182 goto done;
1183 }
1184 err = drv(file, VIDIOC_S_FMT, fmt2);
1185 if (err < 0)
1186 dprintk("VIDIOCSVBIFMT / VIDIOC_S_FMT: %ld\n", err);
1187done:
1188 kfree(fmt2);
1189 return err;
1190}
1191
1192/*
1193 * This function is exported.
1194 */
1195long
1196v4l_compat_translate_ioctl(struct file *file,
1197 int cmd,
1198 void *arg,
1199 v4l2_kioctl drv)
1200{
1201 long err;
1202
1203 switch (cmd) {
1204 case VIDIOCGCAP: /* capability */
1205 err = v4l1_compat_get_capabilities(arg, file, drv);
1206 break;
1207 case VIDIOCGFBUF: /* get frame buffer */
1208 err = v4l1_compat_get_frame_buffer(arg, file, drv);
1209 break;
1210 case VIDIOCSFBUF: /* set frame buffer */
1211 err = v4l1_compat_set_frame_buffer(arg, file, drv);
1212 break;
1213 case VIDIOCGWIN: /* get window or capture dimensions */
1214 err = v4l1_compat_get_win_cap_dimensions(arg, file, drv);
1215 break;
1216 case VIDIOCSWIN: /* set window and/or capture dimensions */
1217 err = v4l1_compat_set_win_cap_dimensions(arg, file, drv);
1218 break;
1219 case VIDIOCCAPTURE: /* turn on/off preview */
1220 err = v4l1_compat_turn_preview_on_off(arg, file, drv);
1221 break;
1222 case VIDIOCGCHAN: /* get input information */
1223 err = v4l1_compat_get_input_info(arg, file, drv);
1224 break;
1225 case VIDIOCSCHAN: /* set input */
1226 err = v4l1_compat_set_input(arg, file, drv);
1227 break;
1228 case VIDIOCGPICT: /* get tone controls & partial capture format */
1229 err = v4l1_compat_get_picture(arg, file, drv);
1230 break;
1231 case VIDIOCSPICT: /* set tone controls & partial capture format */
1232 err = v4l1_compat_set_picture(arg, file, drv);
1233 break;
1234 case VIDIOCGTUNER: /* get tuner information */
1235 err = v4l1_compat_get_tuner(arg, file, drv);
1236 break;
1237 case VIDIOCSTUNER: /* select a tuner input */
1238 err = v4l1_compat_select_tuner(arg, file, drv);
1239 break;
1240 case VIDIOCGFREQ: /* get frequency */
1241 err = v4l1_compat_get_frequency(arg, file, drv);
1242 break;
1243 case VIDIOCSFREQ: /* set frequency */
1244 err = v4l1_compat_set_frequency(arg, file, drv);
1245 break;
1246 case VIDIOCGAUDIO: /* get audio properties/controls */
1247 err = v4l1_compat_get_audio(arg, file, drv);
1248 break;
1249 case VIDIOCSAUDIO: /* set audio controls */
1250 err = v4l1_compat_set_audio(arg, file, drv);
1251 break;
1252 case VIDIOCMCAPTURE: /* capture a frame */
1253 err = v4l1_compat_capture_frame(arg, file, drv);
1254 break;
1255 case VIDIOCSYNC: /* wait for a frame */
1256 err = v4l1_compat_sync(arg, file, drv);
1257 break;
1258 case VIDIOCGVBIFMT: /* query VBI data capture format */
1259 err = v4l1_compat_get_vbi_format(arg, file, drv);
1260 break;
1261 case VIDIOCSVBIFMT:
1262 err = v4l1_compat_set_vbi_format(arg, file, drv);
1263 break;
1264 default:
1265 err = -ENOIOCTLCMD;
1266 break;
1267 }
1268
1269 return err;
1270}
1271EXPORT_SYMBOL(v4l_compat_translate_ioctl);
1272
1273/*
1274 * Local variables:
1275 * c-basic-offset: 8
1276 * End:
1277 */
diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index e30e8dfb6205..425ac1e4a00e 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -22,212 +22,6 @@
22 22
23#ifdef CONFIG_COMPAT 23#ifdef CONFIG_COMPAT
24 24
25#ifdef CONFIG_VIDEO_V4L1_COMPAT
26struct video_tuner32 {
27 compat_int_t tuner;
28 char name[32];
29 compat_ulong_t rangelow, rangehigh;
30 u32 flags; /* It is really u32 in videodev.h */
31 u16 mode, signal;
32};
33
34static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
35{
36 if (!access_ok(VERIFY_READ, up, sizeof(struct video_tuner32)) ||
37 get_user(kp->tuner, &up->tuner) ||
38 copy_from_user(kp->name, up->name, 32) ||
39 get_user(kp->rangelow, &up->rangelow) ||
40 get_user(kp->rangehigh, &up->rangehigh) ||
41 get_user(kp->flags, &up->flags) ||
42 get_user(kp->mode, &up->mode) ||
43 get_user(kp->signal, &up->signal))
44 return -EFAULT;
45 return 0;
46}
47
48static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
49{
50 if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_tuner32)) ||
51 put_user(kp->tuner, &up->tuner) ||
52 copy_to_user(up->name, kp->name, 32) ||
53 put_user(kp->rangelow, &up->rangelow) ||
54 put_user(kp->rangehigh, &up->rangehigh) ||
55 put_user(kp->flags, &up->flags) ||
56 put_user(kp->mode, &up->mode) ||
57 put_user(kp->signal, &up->signal))
58 return -EFAULT;
59 return 0;
60}
61
62struct video_buffer32 {
63 compat_caddr_t base;
64 compat_int_t height, width, depth, bytesperline;
65};
66
67static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
68{
69 u32 tmp;
70
71 if (!access_ok(VERIFY_READ, up, sizeof(struct video_buffer32)) ||
72 get_user(tmp, &up->base) ||
73 get_user(kp->height, &up->height) ||
74 get_user(kp->width, &up->width) ||
75 get_user(kp->depth, &up->depth) ||
76 get_user(kp->bytesperline, &up->bytesperline))
77 return -EFAULT;
78
79 /* This is actually a physical address stored
80 * as a void pointer.
81 */
82 kp->base = (void *)(unsigned long) tmp;
83
84 return 0;
85}
86
87static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
88{
89 u32 tmp = (u32)((unsigned long)kp->base);
90
91 if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_buffer32)) ||
92 put_user(tmp, &up->base) ||
93 put_user(kp->height, &up->height) ||
94 put_user(kp->width, &up->width) ||
95 put_user(kp->depth, &up->depth) ||
96 put_user(kp->bytesperline, &up->bytesperline))
97 return -EFAULT;
98 return 0;
99}
100
101struct video_clip32 {
102 s32 x, y, width, height; /* It's really s32 in videodev.h */
103 compat_caddr_t next;
104};
105
106struct video_window32 {
107 u32 x, y, width, height, chromakey, flags;
108 compat_caddr_t clips;
109 compat_int_t clipcount;
110};
111
112static int get_video_window32(struct video_window *kp, struct video_window32 __user *up)
113{
114 struct video_clip __user *uclips;
115 struct video_clip __user *kclips;
116 compat_caddr_t p;
117 int nclips;
118
119 if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
120 return -EFAULT;
121
122 if (get_user(nclips, &up->clipcount))
123 return -EFAULT;
124
125 if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)) ||
126 get_user(kp->x, &up->x) ||
127 get_user(kp->y, &up->y) ||
128 get_user(kp->width, &up->width) ||
129 get_user(kp->height, &up->height) ||
130 get_user(kp->chromakey, &up->chromakey) ||
131 get_user(kp->flags, &up->flags) ||
132 get_user(kp->clipcount, &up->clipcount))
133 return -EFAULT;
134
135 nclips = kp->clipcount;
136 kp->clips = NULL;
137
138 if (nclips == 0)
139 return 0;
140 if (get_user(p, &up->clips))
141 return -EFAULT;
142 uclips = compat_ptr(p);
143
144 /* If nclips < 0, then it is a clipping bitmap of size
145 VIDEO_CLIPMAP_SIZE */
146 if (nclips < 0) {
147 if (!access_ok(VERIFY_READ, uclips, VIDEO_CLIPMAP_SIZE))
148 return -EFAULT;
149 kp->clips = compat_alloc_user_space(VIDEO_CLIPMAP_SIZE);
150 if (copy_in_user(kp->clips, uclips, VIDEO_CLIPMAP_SIZE))
151 return -EFAULT;
152 return 0;
153 }
154
155 /* Otherwise it is an array of video_clip structs. */
156 if (!access_ok(VERIFY_READ, uclips, nclips * sizeof(struct video_clip)))
157 return -EFAULT;
158
159 kp->clips = compat_alloc_user_space(nclips * sizeof(struct video_clip));
160 kclips = kp->clips;
161 while (nclips--) {
162 int err;
163
164 err = copy_in_user(&kclips->x, &uclips->x, sizeof(kclips->x));
165 err |= copy_in_user(&kclips->y, &uclips->y, sizeof(kclips->y));
166 err |= copy_in_user(&kclips->width, &uclips->width, sizeof(kclips->width));
167 err |= copy_in_user(&kclips->height, &uclips->height, sizeof(kclips->height));
168 kclips->next = NULL;
169 if (err)
170 return -EFAULT;
171 kclips++;
172 uclips++;
173 }
174 return 0;
175}
176
177/* You get back everything except the clips... */
178static int put_video_window32(struct video_window *kp, struct video_window32 __user *up)
179{
180 if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_window32)) ||
181 put_user(kp->x, &up->x) ||
182 put_user(kp->y, &up->y) ||
183 put_user(kp->width, &up->width) ||
184 put_user(kp->height, &up->height) ||
185 put_user(kp->chromakey, &up->chromakey) ||
186 put_user(kp->flags, &up->flags) ||
187 put_user(kp->clipcount, &up->clipcount))
188 return -EFAULT;
189 return 0;
190}
191
192struct video_code32 {
193 char loadwhat[16]; /* name or tag of file being passed */
194 compat_int_t datasize;
195 compat_uptr_t data;
196};
197
198static struct video_code __user *get_microcode32(struct video_code32 *kp)
199{
200 struct video_code __user *up;
201
202 up = compat_alloc_user_space(sizeof(*up));
203
204 /*
205 * NOTE! We don't actually care if these fail. If the
206 * user address is invalid, the native ioctl will do
207 * the error handling for us
208 */
209 (void) copy_to_user(up->loadwhat, kp->loadwhat, sizeof(up->loadwhat));
210 (void) put_user(kp->datasize, &up->datasize);
211 (void) put_user(compat_ptr(kp->data), &up->data);
212 return up;
213}
214
215#define VIDIOCGTUNER32 _IOWR('v', 4, struct video_tuner32)
216#define VIDIOCSTUNER32 _IOW('v', 5, struct video_tuner32)
217#define VIDIOCGWIN32 _IOR('v', 9, struct video_window32)
218#define VIDIOCSWIN32 _IOW('v', 10, struct video_window32)
219#define VIDIOCGFBUF32 _IOR('v', 11, struct video_buffer32)
220#define VIDIOCSFBUF32 _IOW('v', 12, struct video_buffer32)
221#define VIDIOCGFREQ32 _IOR('v', 14, u32)
222#define VIDIOCSFREQ32 _IOW('v', 15, u32)
223#define VIDIOCSMICROCODE32 _IOW('v', 27, struct video_code32)
224
225#define VIDIOCCAPTURE32 _IOW('v', 8, s32)
226#define VIDIOCSYNC32 _IOW('v', 18, s32)
227#define VIDIOCSWRITEMODE32 _IOW('v', 25, s32)
228
229#endif
230
231static long native_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 25static long native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
232{ 26{
233 long ret = -ENOIOCTLCMD; 27 long ret = -ENOIOCTLCMD;
@@ -741,13 +535,6 @@ static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext
741static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 535static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
742{ 536{
743 union { 537 union {
744#ifdef CONFIG_VIDEO_V4L1_COMPAT
745 struct video_tuner vt;
746 struct video_buffer vb;
747 struct video_window vw;
748 struct video_code32 vc;
749 struct video_audio va;
750#endif
751 struct v4l2_format v2f; 538 struct v4l2_format v2f;
752 struct v4l2_buffer v2b; 539 struct v4l2_buffer v2b;
753 struct v4l2_framebuffer v2fb; 540 struct v4l2_framebuffer v2fb;
@@ -763,17 +550,6 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar
763 550
764 /* First, convert the command. */ 551 /* First, convert the command. */
765 switch (cmd) { 552 switch (cmd) {
766#ifdef CONFIG_VIDEO_V4L1_COMPAT
767 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
768 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
769 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
770 case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
771 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
772 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
773 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
774 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
775 case VIDIOCSMICROCODE32: cmd = VIDIOCSMICROCODE; break;
776#endif
777 case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break; 553 case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break;
778 case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break; 554 case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break;
779 case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break; 555 case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break;
@@ -800,46 +576,6 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar
800 } 576 }
801 577
802 switch (cmd) { 578 switch (cmd) {
803#ifdef CONFIG_VIDEO_V4L1_COMPAT
804 case VIDIOCSTUNER:
805 case VIDIOCGTUNER:
806 err = get_video_tuner32(&karg.vt, up);
807 compatible_arg = 0;
808 break;
809
810 case VIDIOCSFBUF:
811 err = get_video_buffer32(&karg.vb, up);
812 compatible_arg = 0;
813 break;
814
815 case VIDIOCSWIN:
816 err = get_video_window32(&karg.vw, up);
817 compatible_arg = 0;
818 break;
819
820 case VIDIOCGWIN:
821 case VIDIOCGFBUF:
822 case VIDIOCGFREQ:
823 compatible_arg = 0;
824 break;
825
826 case VIDIOCSMICROCODE:
827 /* Copy the 32-bit "video_code32" to kernel space */
828 if (copy_from_user(&karg.vc, up, sizeof(karg.vc)))
829 return -EFAULT;
830 /* Convert the 32-bit version to a 64-bit version in user space */
831 up = get_microcode32(&karg.vc);
832 break;
833
834 case VIDIOCSFREQ:
835 err = get_user(karg.vx, (u32 __user *)up);
836 compatible_arg = 0;
837 break;
838
839 case VIDIOCCAPTURE:
840 case VIDIOCSYNC:
841 case VIDIOCSWRITEMODE:
842#endif
843 case VIDIOC_OVERLAY: 579 case VIDIOC_OVERLAY:
844 case VIDIOC_STREAMON: 580 case VIDIOC_STREAMON:
845 case VIDIOC_STREAMOFF: 581 case VIDIOC_STREAMOFF:
@@ -922,23 +658,6 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar
922 return err; 658 return err;
923 659
924 switch (cmd) { 660 switch (cmd) {
925#ifdef CONFIG_VIDEO_V4L1_COMPAT
926 case VIDIOCGTUNER:
927 err = put_video_tuner32(&karg.vt, up);
928 break;
929
930 case VIDIOCGWIN:
931 err = put_video_window32(&karg.vw, up);
932 break;
933
934 case VIDIOCGFBUF:
935 err = put_video_buffer32(&karg.vb, up);
936 break;
937
938 case VIDIOCGFREQ:
939 err = put_user(((u32)karg.vx), (u32 __user *)up);
940 break;
941#endif
942 case VIDIOC_S_INPUT: 661 case VIDIOC_S_INPUT:
943 case VIDIOC_S_OUTPUT: 662 case VIDIOC_S_OUTPUT:
944 case VIDIOC_G_INPUT: 663 case VIDIOC_G_INPUT:
@@ -981,37 +700,6 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
981 return ret; 700 return ret;
982 701
983 switch (cmd) { 702 switch (cmd) {
984#ifdef CONFIG_VIDEO_V4L1_COMPAT
985 case VIDIOCGCAP:
986 case VIDIOCGCHAN:
987 case VIDIOCSCHAN:
988 case VIDIOCGTUNER32:
989 case VIDIOCSTUNER32:
990 case VIDIOCGPICT:
991 case VIDIOCSPICT:
992 case VIDIOCCAPTURE32:
993 case VIDIOCGWIN32:
994 case VIDIOCSWIN32:
995 case VIDIOCGFBUF32:
996 case VIDIOCSFBUF32:
997 case VIDIOCKEY:
998 case VIDIOCGFREQ32:
999 case VIDIOCSFREQ32:
1000 case VIDIOCGAUDIO:
1001 case VIDIOCSAUDIO:
1002 case VIDIOCSYNC32:
1003 case VIDIOCMCAPTURE:
1004 case VIDIOCGMBUF:
1005 case VIDIOCGUNIT:
1006 case VIDIOCGCAPTURE:
1007 case VIDIOCSCAPTURE:
1008 case VIDIOCSPLAYMODE:
1009 case VIDIOCSWRITEMODE32:
1010 case VIDIOCGPLAYINFO:
1011 case VIDIOCSMICROCODE32:
1012 case VIDIOCGVBIFMT:
1013 case VIDIOCSVBIFMT:
1014#endif
1015#ifdef __OLD_VIDIOC_ 703#ifdef __OLD_VIDIOC_
1016 case VIDIOC_OVERLAY32_OLD: 704 case VIDIOC_OVERLAY32_OLD:
1017 case VIDIOC_S_PARM_OLD: 705 case VIDIOC_S_PARM_OLD:
@@ -1096,19 +784,6 @@ long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
1096 ret = do_video_ioctl(file, cmd, arg); 784 ret = do_video_ioctl(file, cmd, arg);
1097 break; 785 break;
1098 786
1099#ifdef CONFIG_VIDEO_V4L1_COMPAT
1100 /* BTTV specific... */
1101 case _IOW('v', BASE_VIDIOCPRIVATE+0, char [256]):
1102 case _IOR('v', BASE_VIDIOCPRIVATE+1, char [256]):
1103 case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int):
1104 case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */
1105 case _IOR('v' , BASE_VIDIOCPRIVATE+4, int):
1106 case _IOR('v' , BASE_VIDIOCPRIVATE+5, int):
1107 case _IOR('v' , BASE_VIDIOCPRIVATE+6, int):
1108 case _IOR('v' , BASE_VIDIOCPRIVATE+7, int):
1109 ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
1110 break;
1111#endif
1112 default: 787 default:
1113 printk(KERN_WARNING "compat_ioctl32: " 788 printk(KERN_WARNING "compat_ioctl32: "
1114 "unknown ioctl '%c', dir=%d, #%d (0x%08x)\n", 789 "unknown ioctl '%c', dir=%d, #%d (0x%08x)\n",
diff --git a/drivers/media/video/v4l2-ioctl.c b/drivers/media/video/v4l2-ioctl.c
index dd9283fcb564..7e47f15f350d 100644
--- a/drivers/media/video/v4l2-ioctl.c
+++ b/drivers/media/video/v4l2-ioctl.c
@@ -18,12 +18,8 @@
18#include <linux/kernel.h> 18#include <linux/kernel.h>
19 19
20#define __OLD_VIDIOC_ /* To allow fixing old calls */ 20#define __OLD_VIDIOC_ /* To allow fixing old calls */
21#include <linux/videodev.h>
22#include <linux/videodev2.h> 21#include <linux/videodev2.h>
23 22
24#ifdef CONFIG_VIDEO_V4L1
25#include <linux/videodev.h>
26#endif
27#include <media/v4l2-common.h> 23#include <media/v4l2-common.h>
28#include <media/v4l2-ioctl.h> 24#include <media/v4l2-ioctl.h>
29#include <media/v4l2-ctrls.h> 25#include <media/v4l2-ctrls.h>
@@ -183,42 +179,6 @@ static const char *v4l2_memory_names[] = {
183 179
184/* ------------------------------------------------------------------ */ 180/* ------------------------------------------------------------------ */
185/* debug help functions */ 181/* debug help functions */
186
187#ifdef CONFIG_VIDEO_V4L1_COMPAT
188static const char *v4l1_ioctls[] = {
189 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
190 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
191 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
192 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
193 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
194 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
195 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
196 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
197 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
198 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
199 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
200 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
201 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
202 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
203 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
204 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
205 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
206 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
207 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
208 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
209 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
210 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
211 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
212 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
213 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
214 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
215 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
216 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
217 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
218};
219#define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
220#endif
221
222static const char *v4l2_ioctls[] = { 182static const char *v4l2_ioctls[] = {
223 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP", 183 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
224 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED", 184 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
@@ -310,15 +270,6 @@ void v4l_printk_ioctl(unsigned int cmd)
310 case 'd': 270 case 'd':
311 type = "v4l2_int"; 271 type = "v4l2_int";
312 break; 272 break;
313#ifdef CONFIG_VIDEO_V4L1_COMPAT
314 case 'v':
315 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
316 type = "v4l1";
317 break;
318 }
319 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
320 return;
321#endif
322 case 'V': 273 case 'V':
323 if (_IOC_NR(cmd) >= V4L2_IOCTLS) { 274 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
324 type = "v4l2"; 275 type = "v4l2";
@@ -622,20 +573,6 @@ static long __video_do_ioctl(struct file *file,
622 return -EINVAL; 573 return -EINVAL;
623 } 574 }
624 575
625#ifdef CONFIG_VIDEO_V4L1_COMPAT
626 /********************************************************
627 All other V4L1 calls are handled by v4l1_compat module.
628 Those calls will be translated into V4L2 calls, and
629 __video_do_ioctl will be called again, with one or more
630 V4L2 ioctls.
631 ********************************************************/
632 if (_IOC_TYPE(cmd) == 'v' && cmd != VIDIOCGMBUF &&
633 _IOC_NR(cmd) < BASE_VIDIOCPRIVATE) {
634 return v4l_compat_translate_ioctl(file, cmd, arg,
635 __video_do_ioctl);
636 }
637#endif
638
639 if ((vfd->debug & V4L2_DEBUG_IOCTL) && 576 if ((vfd->debug & V4L2_DEBUG_IOCTL) &&
640 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) { 577 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
641 v4l_print_ioctl(vfd->name, cmd); 578 v4l_print_ioctl(vfd->name, cmd);
@@ -644,29 +581,6 @@ static long __video_do_ioctl(struct file *file,
644 581
645 switch (cmd) { 582 switch (cmd) {
646 583
647#ifdef CONFIG_VIDEO_V4L1_COMPAT
648 /***********************************************************
649 Handles calls to the obsoleted V4L1 API
650 Due to the nature of VIDIOCGMBUF, each driver that supports
651 V4L1 should implement its own handler for this ioctl.
652 ***********************************************************/
653
654 /* --- streaming capture ------------------------------------- */
655 case VIDIOCGMBUF:
656 {
657 struct video_mbuf *p = arg;
658
659 if (!ops->vidiocgmbuf)
660 break;
661 ret = ops->vidiocgmbuf(file, fh, p);
662 if (!ret)
663 dbgarg(cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
664 p->size, p->frames,
665 (unsigned long)p->offsets);
666 break;
667 }
668#endif
669
670 /* --- capabilities ------------------------------------------ */ 584 /* --- capabilities ------------------------------------------ */
671 case VIDIOC_QUERYCAP: 585 case VIDIOC_QUERYCAP:
672 { 586 {
diff --git a/drivers/media/video/via-camera.c b/drivers/media/video/via-camera.c
index 9eda7cc03121..e25aca5759fb 100644
--- a/drivers/media/video/via-camera.c
+++ b/drivers/media/video/via-camera.c
@@ -1161,16 +1161,6 @@ out:
1161 return ret; 1161 return ret;
1162} 1162}
1163 1163
1164#ifdef CONFIG_VIDEO_V4L1_COMPAT
1165static int viacam_vidiocgmbuf(struct file *filp, void *priv,
1166 struct video_mbuf *mbuf)
1167{
1168 struct via_camera *cam = priv;
1169
1170 return videobuf_cgmbuf(&cam->vb_queue, mbuf, 6);
1171}
1172#endif
1173
1174/* G/S_PARM */ 1164/* G/S_PARM */
1175 1165
1176static int viacam_g_parm(struct file *filp, void *priv, 1166static int viacam_g_parm(struct file *filp, void *priv,
@@ -1251,9 +1241,6 @@ static const struct v4l2_ioctl_ops viacam_ioctl_ops = {
1251 .vidioc_s_parm = viacam_s_parm, 1241 .vidioc_s_parm = viacam_s_parm,
1252 .vidioc_enum_framesizes = viacam_enum_framesizes, 1242 .vidioc_enum_framesizes = viacam_enum_framesizes,
1253 .vidioc_enum_frameintervals = viacam_enum_frameintervals, 1243 .vidioc_enum_frameintervals = viacam_enum_frameintervals,
1254#ifdef CONFIG_VIDEO_V4L1_COMPAT
1255 .vidiocgmbuf = viacam_vidiocgmbuf,
1256#endif
1257}; 1244};
1258 1245
1259/*----------------------------------------------------------------------------*/ 1246/*----------------------------------------------------------------------------*/
diff --git a/drivers/media/video/videobuf-core.c b/drivers/media/video/videobuf-core.c
index 8979f91fa8e5..de4fa4eb8844 100644
--- a/drivers/media/video/videobuf-core.c
+++ b/drivers/media/video/videobuf-core.c
@@ -1202,33 +1202,3 @@ int videobuf_mmap_mapper(struct videobuf_queue *q, struct vm_area_struct *vma)
1202 return rc; 1202 return rc;
1203} 1203}
1204EXPORT_SYMBOL_GPL(videobuf_mmap_mapper); 1204EXPORT_SYMBOL_GPL(videobuf_mmap_mapper);
1205
1206#ifdef CONFIG_VIDEO_V4L1_COMPAT
1207int videobuf_cgmbuf(struct videobuf_queue *q,
1208 struct video_mbuf *mbuf, int count)
1209{
1210 struct v4l2_requestbuffers req;
1211 int rc, i;
1212
1213 MAGIC_CHECK(q->int_ops->magic, MAGIC_QTYPE_OPS);
1214
1215 memset(&req, 0, sizeof(req));
1216 req.type = q->type;
1217 req.count = count;
1218 req.memory = V4L2_MEMORY_MMAP;
1219 rc = videobuf_reqbufs(q, &req);
1220 if (rc < 0)
1221 return rc;
1222
1223 mbuf->frames = req.count;
1224 mbuf->size = 0;
1225 for (i = 0; i < mbuf->frames; i++) {
1226 mbuf->offsets[i] = q->bufs[i]->boff;
1227 mbuf->size += PAGE_ALIGN(q->bufs[i]->bsize);
1228 }
1229
1230 return 0;
1231}
1232EXPORT_SYMBOL_GPL(videobuf_cgmbuf);
1233#endif
1234
diff --git a/drivers/media/video/videobuf-dma-sg.c b/drivers/media/video/videobuf-dma-sg.c
index ab684e807034..9d520601c70f 100644
--- a/drivers/media/video/videobuf-dma-sg.c
+++ b/drivers/media/video/videobuf-dma-sg.c
@@ -570,29 +570,6 @@ static int __videobuf_mmap_mapper(struct videobuf_queue *q,
570 } 570 }
571 571
572 last = first; 572 last = first;
573#ifdef CONFIG_VIDEO_V4L1_COMPAT
574 if (size != (vma->vm_end - vma->vm_start)) {
575 /* look for last buffer to map */
576 for (last = first + 1; last < VIDEO_MAX_FRAME; last++) {
577 if (NULL == q->bufs[last])
578 continue;
579 if (V4L2_MEMORY_MMAP != q->bufs[last]->memory)
580 continue;
581 if (q->bufs[last]->map) {
582 retval = -EBUSY;
583 goto done;
584 }
585 size += PAGE_ALIGN(q->bufs[last]->bsize);
586 if (size == (vma->vm_end - vma->vm_start))
587 break;
588 }
589 if (VIDEO_MAX_FRAME == last) {
590 dprintk(1, "mmap app bug: size invalid [size=0x%lx]\n",
591 (vma->vm_end - vma->vm_start));
592 goto done;
593 }
594 }
595#endif
596 573
597 /* create mapping + update buffer list */ 574 /* create mapping + update buffer list */
598 retval = -ENOMEM; 575 retval = -ENOMEM;
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index 9797e5a69265..c49c39386bd0 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -870,15 +870,6 @@ static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *p)
870 file->f_flags & O_NONBLOCK); 870 file->f_flags & O_NONBLOCK);
871} 871}
872 872
873#ifdef CONFIG_VIDEO_V4L1_COMPAT
874static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
875{
876 struct vivi_dev *dev = video_drvdata(file);
877
878 return videobuf_cgmbuf(&dev->vb_vidq, mbuf, 8);
879}
880#endif
881
882static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i) 873static int vidioc_streamon(struct file *file, void *priv, enum v4l2_buf_type i)
883{ 874{
884 struct vivi_dev *dev = video_drvdata(file); 875 struct vivi_dev *dev = video_drvdata(file);
@@ -1105,9 +1096,6 @@ static const struct v4l2_ioctl_ops vivi_ioctl_ops = {
1105 .vidioc_queryctrl = vidioc_queryctrl, 1096 .vidioc_queryctrl = vidioc_queryctrl,
1106 .vidioc_g_ctrl = vidioc_g_ctrl, 1097 .vidioc_g_ctrl = vidioc_g_ctrl,
1107 .vidioc_s_ctrl = vidioc_s_ctrl, 1098 .vidioc_s_ctrl = vidioc_s_ctrl,
1108#ifdef CONFIG_VIDEO_V4L1_COMPAT
1109 .vidiocgmbuf = vidiocgmbuf,
1110#endif
1111}; 1099};
1112 1100
1113static struct video_device vivi_template = { 1101static struct video_device vivi_template = {
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-28 14:57:43 -0500