aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video')
-rw-r--r--drivers/media/video/arv.c2
-rw-r--r--drivers/media/video/bt8xx/bttv-driver.c117
-rw-r--r--drivers/media/video/bw-qcam.c2
-rw-r--r--drivers/media/video/c-qcam.c2
-rw-r--r--drivers/media/video/cafe_ccic.c2
-rw-r--r--drivers/media/video/cx18/cx18-alsa-pcm.c8
-rw-r--r--drivers/media/video/cx18/cx18-streams.c2
-rw-r--r--drivers/media/video/cx25840/cx25840-core.c19
-rw-r--r--drivers/media/video/cx88/cx88-alsa.c99
-rw-r--r--drivers/media/video/cx88/cx88-cards.c7
-rw-r--r--drivers/media/video/cx88/cx88-video.c27
-rw-r--r--drivers/media/video/cx88/cx88.h6
-rw-r--r--drivers/media/video/em28xx/em28xx-video.c2
-rw-r--r--drivers/media/video/et61x251/et61x251_core.c2
-rw-r--r--drivers/media/video/gspca/sonixj.c416
-rw-r--r--drivers/media/video/meye.c14
-rw-r--r--drivers/media/video/mx2_camera.c2
-rw-r--r--drivers/media/video/pms.c2
-rw-r--r--drivers/media/video/s5p-fimc/fimc-capture.c51
-rw-r--r--drivers/media/video/s5p-fimc/fimc-core.c54
-rw-r--r--drivers/media/video/s5p-fimc/fimc-core.h24
-rw-r--r--drivers/media/video/s5p-fimc/regs-fimc.h3
-rw-r--r--drivers/media/video/sh_mobile_ceu_camera.c2
-rw-r--r--drivers/media/video/sh_vou.c13
-rw-r--r--drivers/media/video/sn9c102/sn9c102_core.c2
-rw-r--r--drivers/media/video/soc_camera.c4
-rw-r--r--drivers/media/video/uvc/uvc_ctrl.c48
-rw-r--r--drivers/media/video/uvc/uvc_queue.c133
-rw-r--r--drivers/media/video/uvc/uvc_v4l2.c185
-rw-r--r--drivers/media/video/uvc/uvc_video.c3
-rw-r--r--drivers/media/video/uvc/uvcvideo.h10
-rw-r--r--drivers/media/video/v4l2-dev.c69
-rw-r--r--drivers/media/video/v4l2-device.c1
-rw-r--r--drivers/media/video/w9966.c2
-rw-r--r--drivers/media/video/wm8775.c104
35 files changed, 674 insertions, 765 deletions
diff --git a/drivers/media/video/arv.c b/drivers/media/video/arv.c
index 31e7a123d19a..f989f2820d88 100644
--- a/drivers/media/video/arv.c
+++ b/drivers/media/video/arv.c
@@ -712,7 +712,7 @@ static int ar_initialize(struct ar *ar)
712static const struct v4l2_file_operations ar_fops = { 712static const struct v4l2_file_operations ar_fops = {
713 .owner = THIS_MODULE, 713 .owner = THIS_MODULE,
714 .read = ar_read, 714 .read = ar_read,
715 .ioctl = video_ioctl2, 715 .unlocked_ioctl = video_ioctl2,
716}; 716};
717 717
718static const struct v4l2_ioctl_ops ar_ioctl_ops = { 718static const struct v4l2_ioctl_ops ar_ioctl_ops = {
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index a529619e51f6..0902ec041c7a 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -854,7 +854,6 @@ int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit)
854 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM; 854 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
855 855
856 /* is it free? */ 856 /* is it free? */
857 mutex_lock(&btv->lock);
858 if (btv->resources & xbits) { 857 if (btv->resources & xbits) {
859 /* no, someone else uses it */ 858 /* no, someone else uses it */
860 goto fail; 859 goto fail;
@@ -884,11 +883,9 @@ int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit)
884 /* it's free, grab it */ 883 /* it's free, grab it */
885 fh->resources |= bit; 884 fh->resources |= bit;
886 btv->resources |= bit; 885 btv->resources |= bit;
887 mutex_unlock(&btv->lock);
888 return 1; 886 return 1;
889 887
890 fail: 888 fail:
891 mutex_unlock(&btv->lock);
892 return 0; 889 return 0;
893} 890}
894 891
@@ -940,7 +937,6 @@ void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits)
940 /* trying to free ressources not allocated by us ... */ 937 /* trying to free ressources not allocated by us ... */
941 printk("bttv: BUG! (btres)\n"); 938 printk("bttv: BUG! (btres)\n");
942 } 939 }
943 mutex_lock(&btv->lock);
944 fh->resources &= ~bits; 940 fh->resources &= ~bits;
945 btv->resources &= ~bits; 941 btv->resources &= ~bits;
946 942
@@ -951,8 +947,6 @@ void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits)
951 947
952 if (0 == (bits & VBI_RESOURCES)) 948 if (0 == (bits & VBI_RESOURCES))
953 disclaim_vbi_lines(btv); 949 disclaim_vbi_lines(btv);
954
955 mutex_unlock(&btv->lock);
956} 950}
957 951
958/* ----------------------------------------------------------------------- */ 952/* ----------------------------------------------------------------------- */
@@ -1713,28 +1707,20 @@ static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1713 1707
1714 /* Make sure tvnorm and vbi_end remain consistent 1708 /* Make sure tvnorm and vbi_end remain consistent
1715 until we're done. */ 1709 until we're done. */
1716 mutex_lock(&btv->lock);
1717 1710
1718 norm = btv->tvnorm; 1711 norm = btv->tvnorm;
1719 1712
1720 /* In this mode capturing always starts at defrect.top 1713 /* In this mode capturing always starts at defrect.top
1721 (default VDELAY), ignoring cropping parameters. */ 1714 (default VDELAY), ignoring cropping parameters. */
1722 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) { 1715 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1723 mutex_unlock(&btv->lock);
1724 return -EINVAL; 1716 return -EINVAL;
1725 } 1717 }
1726 1718
1727 mutex_unlock(&btv->lock);
1728
1729 c.rect = bttv_tvnorms[norm].cropcap.defrect; 1719 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1730 } else { 1720 } else {
1731 mutex_lock(&btv->lock);
1732
1733 norm = btv->tvnorm; 1721 norm = btv->tvnorm;
1734 c = btv->crop[!!fh->do_crop]; 1722 c = btv->crop[!!fh->do_crop];
1735 1723
1736 mutex_unlock(&btv->lock);
1737
1738 if (width < c.min_scaled_width || 1724 if (width < c.min_scaled_width ||
1739 width > c.max_scaled_width || 1725 width > c.max_scaled_width ||
1740 height < c.min_scaled_height) 1726 height < c.min_scaled_height)
@@ -1858,7 +1844,6 @@ static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1858 unsigned int i; 1844 unsigned int i;
1859 int err; 1845 int err;
1860 1846
1861 mutex_lock(&btv->lock);
1862 err = v4l2_prio_check(&btv->prio, fh->prio); 1847 err = v4l2_prio_check(&btv->prio, fh->prio);
1863 if (err) 1848 if (err)
1864 goto err; 1849 goto err;
@@ -1874,7 +1859,6 @@ static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1874 set_tvnorm(btv, i); 1859 set_tvnorm(btv, i);
1875 1860
1876err: 1861err:
1877 mutex_unlock(&btv->lock);
1878 1862
1879 return err; 1863 return err;
1880} 1864}
@@ -1898,7 +1882,6 @@ static int bttv_enum_input(struct file *file, void *priv,
1898 struct bttv *btv = fh->btv; 1882 struct bttv *btv = fh->btv;
1899 int rc = 0; 1883 int rc = 0;
1900 1884
1901 mutex_lock(&btv->lock);
1902 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) { 1885 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) {
1903 rc = -EINVAL; 1886 rc = -EINVAL;
1904 goto err; 1887 goto err;
@@ -1928,7 +1911,6 @@ static int bttv_enum_input(struct file *file, void *priv,
1928 i->std = BTTV_NORMS; 1911 i->std = BTTV_NORMS;
1929 1912
1930err: 1913err:
1931 mutex_unlock(&btv->lock);
1932 1914
1933 return rc; 1915 return rc;
1934} 1916}
@@ -1938,9 +1920,7 @@ static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1938 struct bttv_fh *fh = priv; 1920 struct bttv_fh *fh = priv;
1939 struct bttv *btv = fh->btv; 1921 struct bttv *btv = fh->btv;
1940 1922
1941 mutex_lock(&btv->lock);
1942 *i = btv->input; 1923 *i = btv->input;
1943 mutex_unlock(&btv->lock);
1944 1924
1945 return 0; 1925 return 0;
1946} 1926}
@@ -1952,7 +1932,6 @@ static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1952 1932
1953 int err; 1933 int err;
1954 1934
1955 mutex_lock(&btv->lock);
1956 err = v4l2_prio_check(&btv->prio, fh->prio); 1935 err = v4l2_prio_check(&btv->prio, fh->prio);
1957 if (unlikely(err)) 1936 if (unlikely(err))
1958 goto err; 1937 goto err;
@@ -1965,7 +1944,6 @@ static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1965 set_input(btv, i, btv->tvnorm); 1944 set_input(btv, i, btv->tvnorm);
1966 1945
1967err: 1946err:
1968 mutex_unlock(&btv->lock);
1969 return 0; 1947 return 0;
1970} 1948}
1971 1949
@@ -1979,7 +1957,6 @@ static int bttv_s_tuner(struct file *file, void *priv,
1979 if (unlikely(0 != t->index)) 1957 if (unlikely(0 != t->index))
1980 return -EINVAL; 1958 return -EINVAL;
1981 1959
1982 mutex_lock(&btv->lock);
1983 if (unlikely(btv->tuner_type == TUNER_ABSENT)) { 1960 if (unlikely(btv->tuner_type == TUNER_ABSENT)) {
1984 err = -EINVAL; 1961 err = -EINVAL;
1985 goto err; 1962 goto err;
@@ -1995,7 +1972,6 @@ static int bttv_s_tuner(struct file *file, void *priv,
1995 btv->audio_mode_gpio(btv, t, 1); 1972 btv->audio_mode_gpio(btv, t, 1);
1996 1973
1997err: 1974err:
1998 mutex_unlock(&btv->lock);
1999 1975
2000 return 0; 1976 return 0;
2001} 1977}
@@ -2006,10 +1982,8 @@ static int bttv_g_frequency(struct file *file, void *priv,
2006 struct bttv_fh *fh = priv; 1982 struct bttv_fh *fh = priv;
2007 struct bttv *btv = fh->btv; 1983 struct bttv *btv = fh->btv;
2008 1984
2009 mutex_lock(&btv->lock);
2010 f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV; 1985 f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2011 f->frequency = btv->freq; 1986 f->frequency = btv->freq;
2012 mutex_unlock(&btv->lock);
2013 1987
2014 return 0; 1988 return 0;
2015} 1989}
@@ -2024,7 +1998,6 @@ static int bttv_s_frequency(struct file *file, void *priv,
2024 if (unlikely(f->tuner != 0)) 1998 if (unlikely(f->tuner != 0))
2025 return -EINVAL; 1999 return -EINVAL;
2026 2000
2027 mutex_lock(&btv->lock);
2028 err = v4l2_prio_check(&btv->prio, fh->prio); 2001 err = v4l2_prio_check(&btv->prio, fh->prio);
2029 if (unlikely(err)) 2002 if (unlikely(err))
2030 goto err; 2003 goto err;
@@ -2039,7 +2012,6 @@ static int bttv_s_frequency(struct file *file, void *priv,
2039 if (btv->has_matchbox && btv->radio_user) 2012 if (btv->has_matchbox && btv->radio_user)
2040 tea5757_set_freq(btv, btv->freq); 2013 tea5757_set_freq(btv, btv->freq);
2041err: 2014err:
2042 mutex_unlock(&btv->lock);
2043 2015
2044 return 0; 2016 return 0;
2045} 2017}
@@ -2172,7 +2144,6 @@ limit_scaled_size_lock (struct bttv_fh * fh,
2172 2144
2173 /* Make sure tvnorm, vbi_end and the current cropping parameters 2145 /* Make sure tvnorm, vbi_end and the current cropping parameters
2174 remain consistent until we're done. */ 2146 remain consistent until we're done. */
2175 mutex_lock(&btv->lock);
2176 2147
2177 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds; 2148 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2178 2149
@@ -2250,7 +2221,6 @@ limit_scaled_size_lock (struct bttv_fh * fh,
2250 rc = 0; /* success */ 2221 rc = 0; /* success */
2251 2222
2252 fail: 2223 fail:
2253 mutex_unlock(&btv->lock);
2254 2224
2255 return rc; 2225 return rc;
2256} 2226}
@@ -2282,9 +2252,7 @@ verify_window_lock (struct bttv_fh * fh,
2282 if (V4L2_FIELD_ANY == field) { 2252 if (V4L2_FIELD_ANY == field) {
2283 __s32 height2; 2253 __s32 height2;
2284 2254
2285 mutex_lock(&fh->btv->lock);
2286 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1; 2255 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2287 mutex_unlock(&fh->btv->lock);
2288 field = (win->w.height > height2) 2256 field = (win->w.height > height2)
2289 ? V4L2_FIELD_INTERLACED 2257 ? V4L2_FIELD_INTERLACED
2290 : V4L2_FIELD_TOP; 2258 : V4L2_FIELD_TOP;
@@ -2360,7 +2328,6 @@ static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2360 } 2328 }
2361 } 2329 }
2362 2330
2363 mutex_lock(&fh->cap.vb_lock);
2364 /* clip against screen */ 2331 /* clip against screen */
2365 if (NULL != btv->fbuf.base) 2332 if (NULL != btv->fbuf.base)
2366 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height, 2333 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
@@ -2391,13 +2358,6 @@ static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2391 fh->ov.field = win->field; 2358 fh->ov.field = win->field;
2392 fh->ov.setup_ok = 1; 2359 fh->ov.setup_ok = 1;
2393 2360
2394 /*
2395 * FIXME: btv is protected by btv->lock mutex, while btv->init
2396 * is protected by fh->cap.vb_lock. This seems to open the
2397 * possibility for some race situations. Maybe the better would
2398 * be to unify those locks or to use another way to store the
2399 * init values that will be consumed by videobuf callbacks
2400 */
2401 btv->init.ov.w.width = win->w.width; 2361 btv->init.ov.w.width = win->w.width;
2402 btv->init.ov.w.height = win->w.height; 2362 btv->init.ov.w.height = win->w.height;
2403 btv->init.ov.field = win->field; 2363 btv->init.ov.field = win->field;
@@ -2412,7 +2372,6 @@ static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2412 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new); 2372 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2413 retval = bttv_switch_overlay(btv,fh,new); 2373 retval = bttv_switch_overlay(btv,fh,new);
2414 } 2374 }
2415 mutex_unlock(&fh->cap.vb_lock);
2416 return retval; 2375 return retval;
2417} 2376}
2418 2377
@@ -2526,9 +2485,7 @@ static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2526 if (V4L2_FIELD_ANY == field) { 2485 if (V4L2_FIELD_ANY == field) {
2527 __s32 height2; 2486 __s32 height2;
2528 2487
2529 mutex_lock(&btv->lock);
2530 height2 = btv->crop[!!fh->do_crop].rect.height >> 1; 2488 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2531 mutex_unlock(&btv->lock);
2532 field = (f->fmt.pix.height > height2) 2489 field = (f->fmt.pix.height > height2)
2533 ? V4L2_FIELD_INTERLACED 2490 ? V4L2_FIELD_INTERLACED
2534 : V4L2_FIELD_BOTTOM; 2491 : V4L2_FIELD_BOTTOM;
@@ -2614,7 +2571,6 @@ static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2614 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 2571 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2615 2572
2616 /* update our state informations */ 2573 /* update our state informations */
2617 mutex_lock(&fh->cap.vb_lock);
2618 fh->fmt = fmt; 2574 fh->fmt = fmt;
2619 fh->cap.field = f->fmt.pix.field; 2575 fh->cap.field = f->fmt.pix.field;
2620 fh->cap.last = V4L2_FIELD_NONE; 2576 fh->cap.last = V4L2_FIELD_NONE;
@@ -2623,7 +2579,6 @@ static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2623 btv->init.fmt = fmt; 2579 btv->init.fmt = fmt;
2624 btv->init.width = f->fmt.pix.width; 2580 btv->init.width = f->fmt.pix.width;
2625 btv->init.height = f->fmt.pix.height; 2581 btv->init.height = f->fmt.pix.height;
2626 mutex_unlock(&fh->cap.vb_lock);
2627 2582
2628 return 0; 2583 return 0;
2629} 2584}
@@ -2649,11 +2604,9 @@ static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2649 unsigned int i; 2604 unsigned int i;
2650 struct bttv_fh *fh = priv; 2605 struct bttv_fh *fh = priv;
2651 2606
2652 mutex_lock(&fh->cap.vb_lock);
2653 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize, 2607 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2654 V4L2_MEMORY_MMAP); 2608 V4L2_MEMORY_MMAP);
2655 if (retval < 0) { 2609 if (retval < 0) {
2656 mutex_unlock(&fh->cap.vb_lock);
2657 return retval; 2610 return retval;
2658 } 2611 }
2659 2612
@@ -2665,7 +2618,6 @@ static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2665 for (i = 0; i < gbuffers; i++) 2618 for (i = 0; i < gbuffers; i++)
2666 mbuf->offsets[i] = i * gbufsize; 2619 mbuf->offsets[i] = i * gbufsize;
2667 2620
2668 mutex_unlock(&fh->cap.vb_lock);
2669 return 0; 2621 return 0;
2670} 2622}
2671#endif 2623#endif
@@ -2775,10 +2727,8 @@ static int bttv_overlay(struct file *file, void *f, unsigned int on)
2775 int retval = 0; 2727 int retval = 0;
2776 2728
2777 if (on) { 2729 if (on) {
2778 mutex_lock(&fh->cap.vb_lock);
2779 /* verify args */ 2730 /* verify args */
2780 if (unlikely(!btv->fbuf.base)) { 2731 if (unlikely(!btv->fbuf.base)) {
2781 mutex_unlock(&fh->cap.vb_lock);
2782 return -EINVAL; 2732 return -EINVAL;
2783 } 2733 }
2784 if (unlikely(!fh->ov.setup_ok)) { 2734 if (unlikely(!fh->ov.setup_ok)) {
@@ -2787,13 +2737,11 @@ static int bttv_overlay(struct file *file, void *f, unsigned int on)
2787 } 2737 }
2788 if (retval) 2738 if (retval)
2789 return retval; 2739 return retval;
2790 mutex_unlock(&fh->cap.vb_lock);
2791 } 2740 }
2792 2741
2793 if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY)) 2742 if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
2794 return -EBUSY; 2743 return -EBUSY;
2795 2744
2796 mutex_lock(&fh->cap.vb_lock);
2797 if (on) { 2745 if (on) {
2798 fh->ov.tvnorm = btv->tvnorm; 2746 fh->ov.tvnorm = btv->tvnorm;
2799 new = videobuf_sg_alloc(sizeof(*new)); 2747 new = videobuf_sg_alloc(sizeof(*new));
@@ -2805,7 +2753,6 @@ static int bttv_overlay(struct file *file, void *f, unsigned int on)
2805 2753
2806 /* switch over */ 2754 /* switch over */
2807 retval = bttv_switch_overlay(btv, fh, new); 2755 retval = bttv_switch_overlay(btv, fh, new);
2808 mutex_unlock(&fh->cap.vb_lock);
2809 return retval; 2756 return retval;
2810} 2757}
2811 2758
@@ -2844,7 +2791,6 @@ static int bttv_s_fbuf(struct file *file, void *f,
2844 } 2791 }
2845 2792
2846 /* ok, accept it */ 2793 /* ok, accept it */
2847 mutex_lock(&fh->cap.vb_lock);
2848 btv->fbuf.base = fb->base; 2794 btv->fbuf.base = fb->base;
2849 btv->fbuf.fmt.width = fb->fmt.width; 2795 btv->fbuf.fmt.width = fb->fmt.width;
2850 btv->fbuf.fmt.height = fb->fmt.height; 2796 btv->fbuf.fmt.height = fb->fmt.height;
@@ -2876,7 +2822,6 @@ static int bttv_s_fbuf(struct file *file, void *f,
2876 retval = bttv_switch_overlay(btv, fh, new); 2822 retval = bttv_switch_overlay(btv, fh, new);
2877 } 2823 }
2878 } 2824 }
2879 mutex_unlock(&fh->cap.vb_lock);
2880 return retval; 2825 return retval;
2881} 2826}
2882 2827
@@ -2955,7 +2900,6 @@ static int bttv_queryctrl(struct file *file, void *priv,
2955 c->id >= V4L2_CID_PRIVATE_LASTP1)) 2900 c->id >= V4L2_CID_PRIVATE_LASTP1))
2956 return -EINVAL; 2901 return -EINVAL;
2957 2902
2958 mutex_lock(&btv->lock);
2959 if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME)) 2903 if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2960 *c = no_ctl; 2904 *c = no_ctl;
2961 else { 2905 else {
@@ -2963,7 +2907,6 @@ static int bttv_queryctrl(struct file *file, void *priv,
2963 2907
2964 *c = (NULL != ctrl) ? *ctrl : no_ctl; 2908 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2965 } 2909 }
2966 mutex_unlock(&btv->lock);
2967 2910
2968 return 0; 2911 return 0;
2969} 2912}
@@ -2974,10 +2917,8 @@ static int bttv_g_parm(struct file *file, void *f,
2974 struct bttv_fh *fh = f; 2917 struct bttv_fh *fh = f;
2975 struct bttv *btv = fh->btv; 2918 struct bttv *btv = fh->btv;
2976 2919
2977 mutex_lock(&btv->lock);
2978 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id, 2920 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2979 &parm->parm.capture.timeperframe); 2921 &parm->parm.capture.timeperframe);
2980 mutex_unlock(&btv->lock);
2981 2922
2982 return 0; 2923 return 0;
2983} 2924}
@@ -2993,7 +2934,6 @@ static int bttv_g_tuner(struct file *file, void *priv,
2993 if (0 != t->index) 2934 if (0 != t->index)
2994 return -EINVAL; 2935 return -EINVAL;
2995 2936
2996 mutex_lock(&btv->lock);
2997 t->rxsubchans = V4L2_TUNER_SUB_MONO; 2937 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2998 bttv_call_all(btv, tuner, g_tuner, t); 2938 bttv_call_all(btv, tuner, g_tuner, t);
2999 strcpy(t->name, "Television"); 2939 strcpy(t->name, "Television");
@@ -3005,7 +2945,6 @@ static int bttv_g_tuner(struct file *file, void *priv,
3005 if (btv->audio_mode_gpio) 2945 if (btv->audio_mode_gpio)
3006 btv->audio_mode_gpio(btv, t, 0); 2946 btv->audio_mode_gpio(btv, t, 0);
3007 2947
3008 mutex_unlock(&btv->lock);
3009 return 0; 2948 return 0;
3010} 2949}
3011 2950
@@ -3014,9 +2953,7 @@ static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
3014 struct bttv_fh *fh = f; 2953 struct bttv_fh *fh = f;
3015 struct bttv *btv = fh->btv; 2954 struct bttv *btv = fh->btv;
3016 2955
3017 mutex_lock(&btv->lock);
3018 *p = v4l2_prio_max(&btv->prio); 2956 *p = v4l2_prio_max(&btv->prio);
3019 mutex_unlock(&btv->lock);
3020 2957
3021 return 0; 2958 return 0;
3022} 2959}
@@ -3028,9 +2965,7 @@ static int bttv_s_priority(struct file *file, void *f,
3028 struct bttv *btv = fh->btv; 2965 struct bttv *btv = fh->btv;
3029 int rc; 2966 int rc;
3030 2967
3031 mutex_lock(&btv->lock);
3032 rc = v4l2_prio_change(&btv->prio, &fh->prio, prio); 2968 rc = v4l2_prio_change(&btv->prio, &fh->prio, prio);
3033 mutex_unlock(&btv->lock);
3034 2969
3035 return rc; 2970 return rc;
3036} 2971}
@@ -3045,9 +2980,7 @@ static int bttv_cropcap(struct file *file, void *priv,
3045 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY) 2980 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3046 return -EINVAL; 2981 return -EINVAL;
3047 2982
3048 mutex_lock(&btv->lock);
3049 *cap = bttv_tvnorms[btv->tvnorm].cropcap; 2983 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3050 mutex_unlock(&btv->lock);
3051 2984
3052 return 0; 2985 return 0;
3053} 2986}
@@ -3065,9 +2998,7 @@ static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
3065 inconsistent with fh->width or fh->height and apps 2998 inconsistent with fh->width or fh->height and apps
3066 do not expect a change here. */ 2999 do not expect a change here. */
3067 3000
3068 mutex_lock(&btv->lock);
3069 crop->c = btv->crop[!!fh->do_crop].rect; 3001 crop->c = btv->crop[!!fh->do_crop].rect;
3070 mutex_unlock(&btv->lock);
3071 3002
3072 return 0; 3003 return 0;
3073} 3004}
@@ -3091,17 +3022,14 @@ static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3091 /* Make sure tvnorm, vbi_end and the current cropping 3022 /* Make sure tvnorm, vbi_end and the current cropping
3092 parameters remain consistent until we're done. Note 3023 parameters remain consistent until we're done. Note
3093 read() may change vbi_end in check_alloc_btres_lock(). */ 3024 read() may change vbi_end in check_alloc_btres_lock(). */
3094 mutex_lock(&btv->lock);
3095 retval = v4l2_prio_check(&btv->prio, fh->prio); 3025 retval = v4l2_prio_check(&btv->prio, fh->prio);
3096 if (0 != retval) { 3026 if (0 != retval) {
3097 mutex_unlock(&btv->lock);
3098 return retval; 3027 return retval;
3099 } 3028 }
3100 3029
3101 retval = -EBUSY; 3030 retval = -EBUSY;
3102 3031
3103 if (locked_btres(fh->btv, VIDEO_RESOURCES)) { 3032 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3104 mutex_unlock(&btv->lock);
3105 return retval; 3033 return retval;
3106 } 3034 }
3107 3035
@@ -3113,7 +3041,6 @@ static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3113 3041
3114 b_top = max(b->top, btv->vbi_end); 3042 b_top = max(b->top, btv->vbi_end);
3115 if (b_top + 32 >= b_bottom) { 3043 if (b_top + 32 >= b_bottom) {
3116 mutex_unlock(&btv->lock);
3117 return retval; 3044 return retval;
3118 } 3045 }
3119 3046
@@ -3136,12 +3063,8 @@ static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3136 3063
3137 btv->crop[1] = c; 3064 btv->crop[1] = c;
3138 3065
3139 mutex_unlock(&btv->lock);
3140
3141 fh->do_crop = 1; 3066 fh->do_crop = 1;
3142 3067
3143 mutex_lock(&fh->cap.vb_lock);
3144
3145 if (fh->width < c.min_scaled_width) { 3068 if (fh->width < c.min_scaled_width) {
3146 fh->width = c.min_scaled_width; 3069 fh->width = c.min_scaled_width;
3147 btv->init.width = c.min_scaled_width; 3070 btv->init.width = c.min_scaled_width;
@@ -3158,8 +3081,6 @@ static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3158 btv->init.height = c.max_scaled_height; 3081 btv->init.height = c.max_scaled_height;
3159 } 3082 }
3160 3083
3161 mutex_unlock(&fh->cap.vb_lock);
3162
3163 return 0; 3084 return 0;
3164} 3085}
3165 3086
@@ -3227,7 +3148,6 @@ static unsigned int bttv_poll(struct file *file, poll_table *wait)
3227 return videobuf_poll_stream(file, &fh->vbi, wait); 3148 return videobuf_poll_stream(file, &fh->vbi, wait);
3228 } 3149 }
3229 3150
3230 mutex_lock(&fh->cap.vb_lock);
3231 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) { 3151 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3232 /* streaming capture */ 3152 /* streaming capture */
3233 if (list_empty(&fh->cap.stream)) 3153 if (list_empty(&fh->cap.stream))
@@ -3262,7 +3182,6 @@ static unsigned int bttv_poll(struct file *file, poll_table *wait)
3262 else 3182 else
3263 rc = 0; 3183 rc = 0;
3264err: 3184err:
3265 mutex_unlock(&fh->cap.vb_lock);
3266 return rc; 3185 return rc;
3267} 3186}
3268 3187
@@ -3293,23 +3212,11 @@ static int bttv_open(struct file *file)
3293 return -ENOMEM; 3212 return -ENOMEM;
3294 file->private_data = fh; 3213 file->private_data = fh;
3295 3214
3296 /*
3297 * btv is protected by btv->lock mutex, while btv->init and other
3298 * streaming vars are protected by fh->cap.vb_lock. We need to take
3299 * care of both locks to avoid troubles. However, vb_lock is used also
3300 * inside videobuf, without calling buf->lock. So, it is a very bad
3301 * idea to hold both locks at the same time.
3302 * Let's first copy btv->init at fh, holding cap.vb_lock, and then work
3303 * with the rest of init, holding btv->lock.
3304 */
3305 mutex_lock(&fh->cap.vb_lock);
3306 *fh = btv->init; 3215 *fh = btv->init;
3307 mutex_unlock(&fh->cap.vb_lock);
3308 3216
3309 fh->type = type; 3217 fh->type = type;
3310 fh->ov.setup_ok = 0; 3218 fh->ov.setup_ok = 0;
3311 3219
3312 mutex_lock(&btv->lock);
3313 v4l2_prio_open(&btv->prio, &fh->prio); 3220 v4l2_prio_open(&btv->prio, &fh->prio);
3314 3221
3315 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops, 3222 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
@@ -3317,13 +3224,13 @@ static int bttv_open(struct file *file)
3317 V4L2_BUF_TYPE_VIDEO_CAPTURE, 3224 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3318 V4L2_FIELD_INTERLACED, 3225 V4L2_FIELD_INTERLACED,
3319 sizeof(struct bttv_buffer), 3226 sizeof(struct bttv_buffer),
3320 fh, NULL); 3227 fh, &btv->lock);
3321 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops, 3228 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3322 &btv->c.pci->dev, &btv->s_lock, 3229 &btv->c.pci->dev, &btv->s_lock,
3323 V4L2_BUF_TYPE_VBI_CAPTURE, 3230 V4L2_BUF_TYPE_VBI_CAPTURE,
3324 V4L2_FIELD_SEQ_TB, 3231 V4L2_FIELD_SEQ_TB,
3325 sizeof(struct bttv_buffer), 3232 sizeof(struct bttv_buffer),
3326 fh, NULL); 3233 fh, &btv->lock);
3327 set_tvnorm(btv,btv->tvnorm); 3234 set_tvnorm(btv,btv->tvnorm);
3328 set_input(btv, btv->input, btv->tvnorm); 3235 set_input(btv, btv->input, btv->tvnorm);
3329 3236
@@ -3346,7 +3253,6 @@ static int bttv_open(struct file *file)
3346 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm); 3253 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3347 3254
3348 bttv_field_count(btv); 3255 bttv_field_count(btv);
3349 mutex_unlock(&btv->lock);
3350 return 0; 3256 return 0;
3351} 3257}
3352 3258
@@ -3355,7 +3261,6 @@ static int bttv_release(struct file *file)
3355 struct bttv_fh *fh = file->private_data; 3261 struct bttv_fh *fh = file->private_data;
3356 struct bttv *btv = fh->btv; 3262 struct bttv *btv = fh->btv;
3357 3263
3358 mutex_lock(&btv->lock);
3359 /* turn off overlay */ 3264 /* turn off overlay */
3360 if (check_btres(fh, RESOURCE_OVERLAY)) 3265 if (check_btres(fh, RESOURCE_OVERLAY))
3361 bttv_switch_overlay(btv,fh,NULL); 3266 bttv_switch_overlay(btv,fh,NULL);
@@ -3381,14 +3286,8 @@ static int bttv_release(struct file *file)
3381 3286
3382 /* free stuff */ 3287 /* free stuff */
3383 3288
3384 /*
3385 * videobuf uses cap.vb_lock - we should avoid holding btv->lock,
3386 * otherwise we may have dead lock conditions
3387 */
3388 mutex_unlock(&btv->lock);
3389 videobuf_mmap_free(&fh->cap); 3289 videobuf_mmap_free(&fh->cap);
3390 videobuf_mmap_free(&fh->vbi); 3290 videobuf_mmap_free(&fh->vbi);
3391 mutex_lock(&btv->lock);
3392 v4l2_prio_close(&btv->prio, fh->prio); 3291 v4l2_prio_close(&btv->prio, fh->prio);
3393 file->private_data = NULL; 3292 file->private_data = NULL;
3394 kfree(fh); 3293 kfree(fh);
@@ -3398,7 +3297,6 @@ static int bttv_release(struct file *file)
3398 3297
3399 if (!btv->users) 3298 if (!btv->users)
3400 audio_mute(btv, 1); 3299 audio_mute(btv, 1);
3401 mutex_unlock(&btv->lock);
3402 3300
3403 return 0; 3301 return 0;
3404} 3302}
@@ -3502,11 +3400,8 @@ static int radio_open(struct file *file)
3502 if (unlikely(!fh)) 3400 if (unlikely(!fh))
3503 return -ENOMEM; 3401 return -ENOMEM;
3504 file->private_data = fh; 3402 file->private_data = fh;
3505 mutex_lock(&fh->cap.vb_lock);
3506 *fh = btv->init; 3403 *fh = btv->init;
3507 mutex_unlock(&fh->cap.vb_lock);
3508 3404
3509 mutex_lock(&btv->lock);
3510 v4l2_prio_open(&btv->prio, &fh->prio); 3405 v4l2_prio_open(&btv->prio, &fh->prio);
3511 3406
3512 btv->radio_user++; 3407 btv->radio_user++;
@@ -3514,7 +3409,6 @@ static int radio_open(struct file *file)
3514 bttv_call_all(btv, tuner, s_radio); 3409 bttv_call_all(btv, tuner, s_radio);
3515 audio_input(btv,TVAUDIO_INPUT_RADIO); 3410 audio_input(btv,TVAUDIO_INPUT_RADIO);
3516 3411
3517 mutex_unlock(&btv->lock);
3518 return 0; 3412 return 0;
3519} 3413}
3520 3414
@@ -3524,7 +3418,6 @@ static int radio_release(struct file *file)
3524 struct bttv *btv = fh->btv; 3418 struct bttv *btv = fh->btv;
3525 struct rds_command cmd; 3419 struct rds_command cmd;
3526 3420
3527 mutex_lock(&btv->lock);
3528 v4l2_prio_close(&btv->prio, fh->prio); 3421 v4l2_prio_close(&btv->prio, fh->prio);
3529 file->private_data = NULL; 3422 file->private_data = NULL;
3530 kfree(fh); 3423 kfree(fh);
@@ -3532,7 +3425,6 @@ static int radio_release(struct file *file)
3532 btv->radio_user--; 3425 btv->radio_user--;
3533 3426
3534 bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd); 3427 bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
3535 mutex_unlock(&btv->lock);
3536 3428
3537 return 0; 3429 return 0;
3538} 3430}
@@ -3561,7 +3453,6 @@ static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3561 return -EINVAL; 3453 return -EINVAL;
3562 if (0 != t->index) 3454 if (0 != t->index)
3563 return -EINVAL; 3455 return -EINVAL;
3564 mutex_lock(&btv->lock);
3565 strcpy(t->name, "Radio"); 3456 strcpy(t->name, "Radio");
3566 t->type = V4L2_TUNER_RADIO; 3457 t->type = V4L2_TUNER_RADIO;
3567 3458
@@ -3570,8 +3461,6 @@ static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3570 if (btv->audio_mode_gpio) 3461 if (btv->audio_mode_gpio)
3571 btv->audio_mode_gpio(btv, t, 0); 3462 btv->audio_mode_gpio(btv, t, 0);
3572 3463
3573 mutex_unlock(&btv->lock);
3574
3575 return 0; 3464 return 0;
3576} 3465}
3577 3466
@@ -3692,7 +3581,7 @@ static const struct v4l2_file_operations radio_fops =
3692 .open = radio_open, 3581 .open = radio_open,
3693 .read = radio_read, 3582 .read = radio_read,
3694 .release = radio_release, 3583 .release = radio_release,
3695 .ioctl = video_ioctl2, 3584 .unlocked_ioctl = video_ioctl2,
3696 .poll = radio_poll, 3585 .poll = radio_poll,
3697}; 3586};
3698 3587
diff --git a/drivers/media/video/bw-qcam.c b/drivers/media/video/bw-qcam.c
index 935e0c9a9674..c1193506131c 100644
--- a/drivers/media/video/bw-qcam.c
+++ b/drivers/media/video/bw-qcam.c
@@ -860,7 +860,7 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
860 860
861static const struct v4l2_file_operations qcam_fops = { 861static const struct v4l2_file_operations qcam_fops = {
862 .owner = THIS_MODULE, 862 .owner = THIS_MODULE,
863 .ioctl = video_ioctl2, 863 .unlocked_ioctl = video_ioctl2,
864 .read = qcam_read, 864 .read = qcam_read,
865}; 865};
866 866
diff --git a/drivers/media/video/c-qcam.c b/drivers/media/video/c-qcam.c
index 6e4b19698c13..24fc00965a12 100644
--- a/drivers/media/video/c-qcam.c
+++ b/drivers/media/video/c-qcam.c
@@ -718,7 +718,7 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
718 718
719static const struct v4l2_file_operations qcam_fops = { 719static const struct v4l2_file_operations qcam_fops = {
720 .owner = THIS_MODULE, 720 .owner = THIS_MODULE,
721 .ioctl = video_ioctl2, 721 .unlocked_ioctl = video_ioctl2,
722 .read = qcam_read, 722 .read = qcam_read,
723}; 723};
724 724
diff --git a/drivers/media/video/cafe_ccic.c b/drivers/media/video/cafe_ccic.c
index 260c666ce931..0dfff50891e4 100644
--- a/drivers/media/video/cafe_ccic.c
+++ b/drivers/media/video/cafe_ccic.c
@@ -1775,7 +1775,7 @@ static const struct v4l2_file_operations cafe_v4l_fops = {
1775 .read = cafe_v4l_read, 1775 .read = cafe_v4l_read,
1776 .poll = cafe_v4l_poll, 1776 .poll = cafe_v4l_poll,
1777 .mmap = cafe_v4l_mmap, 1777 .mmap = cafe_v4l_mmap,
1778 .ioctl = video_ioctl2, 1778 .unlocked_ioctl = video_ioctl2,
1779}; 1779};
1780 1780
1781static const struct v4l2_ioctl_ops cafe_v4l_ioctl_ops = { 1781static const struct v4l2_ioctl_ops cafe_v4l_ioctl_ops = {
diff --git a/drivers/media/video/cx18/cx18-alsa-pcm.c b/drivers/media/video/cx18/cx18-alsa-pcm.c
index 8f55692db36d..82d195be9197 100644
--- a/drivers/media/video/cx18/cx18-alsa-pcm.c
+++ b/drivers/media/video/cx18/cx18-alsa-pcm.c
@@ -218,7 +218,13 @@ static int snd_cx18_pcm_capture_close(struct snd_pcm_substream *substream)
218static int snd_cx18_pcm_ioctl(struct snd_pcm_substream *substream, 218static int snd_cx18_pcm_ioctl(struct snd_pcm_substream *substream,
219 unsigned int cmd, void *arg) 219 unsigned int cmd, void *arg)
220{ 220{
221 return snd_pcm_lib_ioctl(substream, cmd, arg); 221 struct snd_cx18_card *cxsc = snd_pcm_substream_chip(substream);
222 int ret;
223
224 snd_cx18_lock(cxsc);
225 ret = snd_pcm_lib_ioctl(substream, cmd, arg);
226 snd_cx18_unlock(cxsc);
227 return ret;
222} 228}
223 229
224 230
diff --git a/drivers/media/video/cx18/cx18-streams.c b/drivers/media/video/cx18/cx18-streams.c
index 9045f1ece0eb..ab461e27d9dd 100644
--- a/drivers/media/video/cx18/cx18-streams.c
+++ b/drivers/media/video/cx18/cx18-streams.c
@@ -41,7 +41,7 @@ static struct v4l2_file_operations cx18_v4l2_enc_fops = {
41 .read = cx18_v4l2_read, 41 .read = cx18_v4l2_read,
42 .open = cx18_v4l2_open, 42 .open = cx18_v4l2_open,
43 /* FIXME change to video_ioctl2 if serialization lock can be removed */ 43 /* FIXME change to video_ioctl2 if serialization lock can be removed */
44 .ioctl = cx18_v4l2_ioctl, 44 .unlocked_ioctl = cx18_v4l2_ioctl,
45 .release = cx18_v4l2_close, 45 .release = cx18_v4l2_close,
46 .poll = cx18_v4l2_enc_poll, 46 .poll = cx18_v4l2_enc_poll,
47}; 47};
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index dfb198d0415b..f16461844c5c 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -1989,8 +1989,23 @@ static int cx25840_probe(struct i2c_client *client,
1989 v4l2_ctrl_new_std(&state->hdl, &cx25840_ctrl_ops, 1989 v4l2_ctrl_new_std(&state->hdl, &cx25840_ctrl_ops,
1990 V4L2_CID_HUE, -128, 127, 1, 0); 1990 V4L2_CID_HUE, -128, 127, 1, 0);
1991 if (!is_cx2583x(state)) { 1991 if (!is_cx2583x(state)) {
1992 default_volume = 228 - cx25840_read(client, 0x8d4); 1992 default_volume = cx25840_read(client, 0x8d4);
1993 default_volume = ((default_volume / 2) + 23) << 9; 1993 /*
1994 * Enforce the legacy PVR-350/MSP3400 to PVR-150/CX25843 volume
1995 * scale mapping limits to avoid -ERANGE errors when
1996 * initializing the volume control
1997 */
1998 if (default_volume > 228) {
1999 /* Bottom out at -96 dB, v4l2 vol range 0x2e00-0x2fff */
2000 default_volume = 228;
2001 cx25840_write(client, 0x8d4, 228);
2002 }
2003 else if (default_volume < 20) {
2004 /* Top out at + 8 dB, v4l2 vol range 0xfe00-0xffff */
2005 default_volume = 20;
2006 cx25840_write(client, 0x8d4, 20);
2007 }
2008 default_volume = (((228 - default_volume) >> 1) + 23) << 9;
1994 2009
1995 state->volume = v4l2_ctrl_new_std(&state->hdl, 2010 state->volume = v4l2_ctrl_new_std(&state->hdl,
1996 &cx25840_audio_ctrl_ops, V4L2_CID_AUDIO_VOLUME, 2011 &cx25840_audio_ctrl_ops, V4L2_CID_AUDIO_VOLUME,
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index 4aaa47c0eabf..54b7fcd469a8 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -40,7 +40,6 @@
40#include <sound/control.h> 40#include <sound/control.h>
41#include <sound/initval.h> 41#include <sound/initval.h>
42#include <sound/tlv.h> 42#include <sound/tlv.h>
43#include <media/wm8775.h>
44 43
45#include "cx88.h" 44#include "cx88.h"
46#include "cx88-reg.h" 45#include "cx88-reg.h"
@@ -587,47 +586,26 @@ static int snd_cx88_volume_put(struct snd_kcontrol *kcontrol,
587 int left, right, v, b; 586 int left, right, v, b;
588 int changed = 0; 587 int changed = 0;
589 u32 old; 588 u32 old;
590 struct v4l2_control client_ctl;
591
592 /* Pass volume & balance onto any WM8775 */
593 if (value->value.integer.value[0] >= value->value.integer.value[1]) {
594 v = value->value.integer.value[0] << 10;
595 b = value->value.integer.value[0] ?
596 (0x8000 * value->value.integer.value[1]) / value->value.integer.value[0] :
597 0x8000;
598 } else {
599 v = value->value.integer.value[1] << 10;
600 b = value->value.integer.value[1] ?
601 0xffff - (0x8000 * value->value.integer.value[0]) / value->value.integer.value[1] :
602 0x8000;
603 }
604 client_ctl.value = v;
605 client_ctl.id = V4L2_CID_AUDIO_VOLUME;
606 call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl);
607
608 client_ctl.value = b;
609 client_ctl.id = V4L2_CID_AUDIO_BALANCE;
610 call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl);
611 589
612 left = value->value.integer.value[0] & 0x3f; 590 left = value->value.integer.value[0] & 0x3f;
613 right = value->value.integer.value[1] & 0x3f; 591 right = value->value.integer.value[1] & 0x3f;
614 b = right - left; 592 b = right - left;
615 if (b < 0) { 593 if (b < 0) {
616 v = 0x3f - left; 594 v = 0x3f - left;
617 b = (-b) | 0x40; 595 b = (-b) | 0x40;
618 } else { 596 } else {
619 v = 0x3f - right; 597 v = 0x3f - right;
620 } 598 }
621 /* Do we really know this will always be called with IRQs on? */ 599 /* Do we really know this will always be called with IRQs on? */
622 spin_lock_irq(&chip->reg_lock); 600 spin_lock_irq(&chip->reg_lock);
623 old = cx_read(AUD_VOL_CTL); 601 old = cx_read(AUD_VOL_CTL);
624 if (v != (old & 0x3f)) { 602 if (v != (old & 0x3f)) {
625 cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, (old & ~0x3f) | v); 603 cx_write(AUD_VOL_CTL, (old & ~0x3f) | v);
626 changed = 1; 604 changed = 1;
627 } 605 }
628 if ((cx_read(AUD_BAL_CTL) & 0x7f) != b) { 606 if (cx_read(AUD_BAL_CTL) != b) {
629 cx_write(AUD_BAL_CTL, b); 607 cx_write(AUD_BAL_CTL, b);
630 changed = 1; 608 changed = 1;
631 } 609 }
632 spin_unlock_irq(&chip->reg_lock); 610 spin_unlock_irq(&chip->reg_lock);
633 611
@@ -640,7 +618,7 @@ static const struct snd_kcontrol_new snd_cx88_volume = {
640 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 618 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
641 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 619 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
642 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 620 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
643 .name = "Analog-TV Volume", 621 .name = "Playback Volume",
644 .info = snd_cx88_volume_info, 622 .info = snd_cx88_volume_info,
645 .get = snd_cx88_volume_get, 623 .get = snd_cx88_volume_get,
646 .put = snd_cx88_volume_put, 624 .put = snd_cx88_volume_put,
@@ -671,14 +649,7 @@ static int snd_cx88_switch_put(struct snd_kcontrol *kcontrol,
671 vol = cx_read(AUD_VOL_CTL); 649 vol = cx_read(AUD_VOL_CTL);
672 if (value->value.integer.value[0] != !(vol & bit)) { 650 if (value->value.integer.value[0] != !(vol & bit)) {
673 vol ^= bit; 651 vol ^= bit;
674 cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, vol); 652 cx_write(AUD_VOL_CTL, vol);
675 /* Pass mute onto any WM8775 */
676 if ((1<<6) == bit) {
677 struct v4l2_control client_ctl;
678 client_ctl.value = 0 != (vol & bit);
679 client_ctl.id = V4L2_CID_AUDIO_MUTE;
680 call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl);
681 }
682 ret = 1; 653 ret = 1;
683 } 654 }
684 spin_unlock_irq(&chip->reg_lock); 655 spin_unlock_irq(&chip->reg_lock);
@@ -687,7 +658,7 @@ static int snd_cx88_switch_put(struct snd_kcontrol *kcontrol,
687 658
688static const struct snd_kcontrol_new snd_cx88_dac_switch = { 659static const struct snd_kcontrol_new snd_cx88_dac_switch = {
689 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 660 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
690 .name = "Audio-Out Switch", 661 .name = "Playback Switch",
691 .info = snd_ctl_boolean_mono_info, 662 .info = snd_ctl_boolean_mono_info,
692 .get = snd_cx88_switch_get, 663 .get = snd_cx88_switch_get,
693 .put = snd_cx88_switch_put, 664 .put = snd_cx88_switch_put,
@@ -696,49 +667,13 @@ static const struct snd_kcontrol_new snd_cx88_dac_switch = {
696 667
697static const struct snd_kcontrol_new snd_cx88_source_switch = { 668static const struct snd_kcontrol_new snd_cx88_source_switch = {
698 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 669 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
699 .name = "Analog-TV Switch", 670 .name = "Capture Switch",
700 .info = snd_ctl_boolean_mono_info, 671 .info = snd_ctl_boolean_mono_info,
701 .get = snd_cx88_switch_get, 672 .get = snd_cx88_switch_get,
702 .put = snd_cx88_switch_put, 673 .put = snd_cx88_switch_put,
703 .private_value = (1<<6), 674 .private_value = (1<<6),
704}; 675};
705 676
706static int snd_cx88_alc_get(struct snd_kcontrol *kcontrol,
707 struct snd_ctl_elem_value *value)
708{
709 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol);
710 struct cx88_core *core = chip->core;
711 struct v4l2_control client_ctl;
712
713 client_ctl.id = V4L2_CID_AUDIO_LOUDNESS;
714 call_hw(core, WM8775_GID, core, g_ctrl, &client_ctl);
715 value->value.integer.value[0] = client_ctl.value ? 1 : 0;
716
717 return 0;
718}
719
720static int snd_cx88_alc_put(struct snd_kcontrol *kcontrol,
721 struct snd_ctl_elem_value *value)
722{
723 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol);
724 struct cx88_core *core = chip->core;
725 struct v4l2_control client_ctl;
726
727 client_ctl.value = 0 != value->value.integer.value[0];
728 client_ctl.id = V4L2_CID_AUDIO_LOUDNESS;
729 call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl);
730
731 return 0;
732}
733
734static struct snd_kcontrol_new snd_cx88_alc_switch = {
735 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
736 .name = "Line-In ALC Switch",
737 .info = snd_ctl_boolean_mono_info,
738 .get = snd_cx88_alc_get,
739 .put = snd_cx88_alc_put,
740};
741
742/**************************************************************************** 677/****************************************************************************
743 Basic Flow for Sound Devices 678 Basic Flow for Sound Devices
744 ****************************************************************************/ 679 ****************************************************************************/
@@ -860,7 +795,6 @@ static int __devinit cx88_audio_initdev(struct pci_dev *pci,
860{ 795{
861 struct snd_card *card; 796 struct snd_card *card;
862 snd_cx88_card_t *chip; 797 snd_cx88_card_t *chip;
863 struct v4l2_subdev *sd;
864 int err; 798 int err;
865 799
866 if (devno >= SNDRV_CARDS) 800 if (devno >= SNDRV_CARDS)
@@ -896,15 +830,6 @@ static int __devinit cx88_audio_initdev(struct pci_dev *pci,
896 if (err < 0) 830 if (err < 0)
897 goto error; 831 goto error;
898 832
899 /* If there's a wm8775 then add a Line-In ALC switch */
900 list_for_each_entry(sd, &chip->core->v4l2_dev.subdevs, list) {
901 if (WM8775_GID == sd->grp_id) {
902 snd_ctl_add(card, snd_ctl_new1(&snd_cx88_alc_switch,
903 chip));
904 break;
905 }
906 }
907
908 strcpy (card->driver, "CX88x"); 833 strcpy (card->driver, "CX88x");
909 sprintf(card->shortname, "Conexant CX%x", pci->device); 834 sprintf(card->shortname, "Conexant CX%x", pci->device);
910 sprintf(card->longname, "%s at %#llx", 835 sprintf(card->longname, "%s at %#llx",
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index 9b9e169cce90..0ccc2afd7266 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1007,15 +1007,22 @@ static const struct cx88_board cx88_boards[] = {
1007 .radio_type = UNSET, 1007 .radio_type = UNSET,
1008 .tuner_addr = ADDR_UNSET, 1008 .tuner_addr = ADDR_UNSET,
1009 .radio_addr = ADDR_UNSET, 1009 .radio_addr = ADDR_UNSET,
1010 .audio_chip = V4L2_IDENT_WM8775,
1010 .input = {{ 1011 .input = {{
1011 .type = CX88_VMUX_DVB, 1012 .type = CX88_VMUX_DVB,
1012 .vmux = 0, 1013 .vmux = 0,
1014 /* 2: Line-In */
1015 .audioroute = 2,
1013 },{ 1016 },{
1014 .type = CX88_VMUX_COMPOSITE1, 1017 .type = CX88_VMUX_COMPOSITE1,
1015 .vmux = 1, 1018 .vmux = 1,
1019 /* 2: Line-In */
1020 .audioroute = 2,
1016 },{ 1021 },{
1017 .type = CX88_VMUX_SVIDEO, 1022 .type = CX88_VMUX_SVIDEO,
1018 .vmux = 2, 1023 .vmux = 2,
1024 /* 2: Line-In */
1025 .audioroute = 2,
1019 }}, 1026 }},
1020 .mpeg = CX88_MPEG_DVB, 1027 .mpeg = CX88_MPEG_DVB,
1021 }, 1028 },
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index 62cea9549404..d9249e5a04c9 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -40,7 +40,6 @@
40#include "cx88.h" 40#include "cx88.h"
41#include <media/v4l2-common.h> 41#include <media/v4l2-common.h>
42#include <media/v4l2-ioctl.h> 42#include <media/v4l2-ioctl.h>
43#include <media/wm8775.h>
44 43
45MODULE_DESCRIPTION("v4l2 driver module for cx2388x based TV cards"); 44MODULE_DESCRIPTION("v4l2 driver module for cx2388x based TV cards");
46MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]"); 45MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
@@ -977,7 +976,6 @@ int cx88_set_control(struct cx88_core *core, struct v4l2_control *ctl)
977 const struct cx88_ctrl *c = NULL; 976 const struct cx88_ctrl *c = NULL;
978 u32 value,mask; 977 u32 value,mask;
979 int i; 978 int i;
980 struct v4l2_control client_ctl;
981 979
982 for (i = 0; i < CX8800_CTLS; i++) { 980 for (i = 0; i < CX8800_CTLS; i++) {
983 if (cx8800_ctls[i].v.id == ctl->id) { 981 if (cx8800_ctls[i].v.id == ctl->id) {
@@ -991,27 +989,6 @@ int cx88_set_control(struct cx88_core *core, struct v4l2_control *ctl)
991 ctl->value = c->v.minimum; 989 ctl->value = c->v.minimum;
992 if (ctl->value > c->v.maximum) 990 if (ctl->value > c->v.maximum)
993 ctl->value = c->v.maximum; 991 ctl->value = c->v.maximum;
994
995 /* Pass changes onto any WM8775 */
996 client_ctl.id = ctl->id;
997 switch (ctl->id) {
998 case V4L2_CID_AUDIO_MUTE:
999 client_ctl.value = ctl->value;
1000 break;
1001 case V4L2_CID_AUDIO_VOLUME:
1002 client_ctl.value = (ctl->value) ?
1003 (0x90 + ctl->value) << 8 : 0;
1004 break;
1005 case V4L2_CID_AUDIO_BALANCE:
1006 client_ctl.value = ctl->value << 9;
1007 break;
1008 default:
1009 client_ctl.id = 0;
1010 break;
1011 }
1012 if (client_ctl.id)
1013 call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl);
1014
1015 mask=c->mask; 992 mask=c->mask;
1016 switch (ctl->id) { 993 switch (ctl->id) {
1017 case V4L2_CID_AUDIO_BALANCE: 994 case V4L2_CID_AUDIO_BALANCE:
@@ -1558,9 +1535,7 @@ static int radio_queryctrl (struct file *file, void *priv,
1558 if (c->id < V4L2_CID_BASE || 1535 if (c->id < V4L2_CID_BASE ||
1559 c->id >= V4L2_CID_LASTP1) 1536 c->id >= V4L2_CID_LASTP1)
1560 return -EINVAL; 1537 return -EINVAL;
1561 if (c->id == V4L2_CID_AUDIO_MUTE || 1538 if (c->id == V4L2_CID_AUDIO_MUTE) {
1562 c->id == V4L2_CID_AUDIO_VOLUME ||
1563 c->id == V4L2_CID_AUDIO_BALANCE) {
1564 for (i = 0; i < CX8800_CTLS; i++) { 1539 for (i = 0; i < CX8800_CTLS; i++) {
1565 if (cx8800_ctls[i].v.id == c->id) 1540 if (cx8800_ctls[i].v.id == c->id)
1566 break; 1541 break;
diff --git a/drivers/media/video/cx88/cx88.h b/drivers/media/video/cx88/cx88.h
index e8c732e7ae4f..c9981e77416a 100644
--- a/drivers/media/video/cx88/cx88.h
+++ b/drivers/media/video/cx88/cx88.h
@@ -398,19 +398,17 @@ static inline struct cx88_core *to_core(struct v4l2_device *v4l2_dev)
398 return container_of(v4l2_dev, struct cx88_core, v4l2_dev); 398 return container_of(v4l2_dev, struct cx88_core, v4l2_dev);
399} 399}
400 400
401#define call_hw(core, grpid, o, f, args...) \ 401#define call_all(core, o, f, args...) \
402 do { \ 402 do { \
403 if (!core->i2c_rc) { \ 403 if (!core->i2c_rc) { \
404 if (core->gate_ctrl) \ 404 if (core->gate_ctrl) \
405 core->gate_ctrl(core, 1); \ 405 core->gate_ctrl(core, 1); \
406 v4l2_device_call_all(&core->v4l2_dev, grpid, o, f, ##args); \ 406 v4l2_device_call_all(&core->v4l2_dev, 0, o, f, ##args); \
407 if (core->gate_ctrl) \ 407 if (core->gate_ctrl) \
408 core->gate_ctrl(core, 0); \ 408 core->gate_ctrl(core, 0); \
409 } \ 409 } \
410 } while (0) 410 } while (0)
411 411
412#define call_all(core, o, f, args...) call_hw(core, 0, o, f, ##args)
413
414struct cx8800_dev; 412struct cx8800_dev;
415struct cx8802_dev; 413struct cx8802_dev;
416 414
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 908e3bc88303..2c3007280032 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -2377,7 +2377,7 @@ static const struct v4l2_file_operations radio_fops = {
2377 .owner = THIS_MODULE, 2377 .owner = THIS_MODULE,
2378 .open = em28xx_v4l2_open, 2378 .open = em28xx_v4l2_open,
2379 .release = em28xx_v4l2_close, 2379 .release = em28xx_v4l2_close,
2380 .ioctl = video_ioctl2, 2380 .unlocked_ioctl = video_ioctl2,
2381}; 2381};
2382 2382
2383static const struct v4l2_ioctl_ops radio_ioctl_ops = { 2383static const struct v4l2_ioctl_ops radio_ioctl_ops = {
diff --git a/drivers/media/video/et61x251/et61x251_core.c b/drivers/media/video/et61x251/et61x251_core.c
index a5cfc76b40b7..bb164099ea2c 100644
--- a/drivers/media/video/et61x251/et61x251_core.c
+++ b/drivers/media/video/et61x251/et61x251_core.c
@@ -2530,7 +2530,7 @@ static const struct v4l2_file_operations et61x251_fops = {
2530 .owner = THIS_MODULE, 2530 .owner = THIS_MODULE,
2531 .open = et61x251_open, 2531 .open = et61x251_open,
2532 .release = et61x251_release, 2532 .release = et61x251_release,
2533 .ioctl = et61x251_ioctl, 2533 .unlocked_ioctl = et61x251_ioctl,
2534 .read = et61x251_read, 2534 .read = et61x251_read,
2535 .poll = et61x251_poll, 2535 .poll = et61x251_poll,
2536 .mmap = et61x251_mmap, 2536 .mmap = et61x251_mmap,
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index 330dadc00106..e23de57e2c73 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -63,7 +63,10 @@ struct sd {
63#define QUALITY_DEF 80 63#define QUALITY_DEF 80
64 u8 jpegqual; /* webcam quality */ 64 u8 jpegqual; /* webcam quality */
65 65
66 u8 reg01;
67 u8 reg17;
66 u8 reg18; 68 u8 reg18;
69 u8 flags;
67 70
68 s8 ag_cnt; 71 s8 ag_cnt;
69#define AG_CNT_START 13 72#define AG_CNT_START 13
@@ -96,6 +99,22 @@ enum sensors {
96 SENSOR_SP80708, 99 SENSOR_SP80708,
97}; 100};
98 101
102/* device flags */
103#define PDN_INV 1 /* inverse pin S_PWR_DN / sn_xxx tables */
104
105/* sn9c1xx definitions */
106/* register 0x01 */
107#define S_PWR_DN 0x01 /* sensor power down */
108#define S_PDN_INV 0x02 /* inverse pin S_PWR_DN */
109#define V_TX_EN 0x04 /* video transfer enable */
110#define LED 0x08 /* output to pin LED */
111#define SCL_SEL_OD 0x20 /* open-drain mode */
112#define SYS_SEL_48M 0x40 /* system clock 0: 24MHz, 1: 48MHz */
113/* register 0x17 */
114#define MCK_SIZE_MASK 0x1f /* sensor master clock */
115#define SEN_CLK_EN 0x20 /* enable sensor clock */
116#define DEF_EN 0x80 /* defect pixel by 0: soft, 1: hard */
117
99/* V4L2 controls supported by the driver */ 118/* V4L2 controls supported by the driver */
100static void setbrightness(struct gspca_dev *gspca_dev); 119static void setbrightness(struct gspca_dev *gspca_dev);
101static void setcontrast(struct gspca_dev *gspca_dev); 120static void setcontrast(struct gspca_dev *gspca_dev);
@@ -1755,141 +1774,6 @@ static void po2030n_probe(struct gspca_dev *gspca_dev)
1755 } 1774 }
1756} 1775}
1757 1776
1758static void bridge_init(struct gspca_dev *gspca_dev,
1759 const u8 *sn9c1xx)
1760{
1761 struct sd *sd = (struct sd *) gspca_dev;
1762 u8 reg0102[2];
1763 const u8 *reg9a;
1764 static const u8 reg9a_def[] =
1765 {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
1766 static const u8 reg9a_spec[] =
1767 {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
1768 static const u8 regd4[] = {0x60, 0x00, 0x00};
1769
1770 /* sensor clock already enabled in sd_init */
1771 /* reg_w1(gspca_dev, 0xf1, 0x00); */
1772 reg_w1(gspca_dev, 0x01, sn9c1xx[1]);
1773
1774 /* configure gpio */
1775 reg0102[0] = sn9c1xx[1];
1776 reg0102[1] = sn9c1xx[2];
1777 if (gspca_dev->audio)
1778 reg0102[1] |= 0x04; /* keep the audio connection */
1779 reg_w(gspca_dev, 0x01, reg0102, 2);
1780 reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
1781 reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);
1782 switch (sd->sensor) {
1783 case SENSOR_GC0307:
1784 case SENSOR_OV7660:
1785 case SENSOR_PO1030:
1786 case SENSOR_PO2030N:
1787 case SENSOR_SOI768:
1788 case SENSOR_SP80708:
1789 reg9a = reg9a_spec;
1790 break;
1791 default:
1792 reg9a = reg9a_def;
1793 break;
1794 }
1795 reg_w(gspca_dev, 0x9a, reg9a, 6);
1796
1797 reg_w(gspca_dev, 0xd4, regd4, sizeof regd4);
1798
1799 reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
1800
1801 switch (sd->sensor) {
1802 case SENSOR_ADCM1700:
1803 reg_w1(gspca_dev, 0x01, 0x43);
1804 reg_w1(gspca_dev, 0x17, 0x62);
1805 reg_w1(gspca_dev, 0x01, 0x42);
1806 reg_w1(gspca_dev, 0x01, 0x42);
1807 break;
1808 case SENSOR_GC0307:
1809 msleep(50);
1810 reg_w1(gspca_dev, 0x01, 0x61);
1811 reg_w1(gspca_dev, 0x17, 0x22);
1812 reg_w1(gspca_dev, 0x01, 0x60);
1813 reg_w1(gspca_dev, 0x01, 0x40);
1814 msleep(50);
1815 break;
1816 case SENSOR_MI0360B:
1817 reg_w1(gspca_dev, 0x01, 0x61);
1818 reg_w1(gspca_dev, 0x17, 0x60);
1819 reg_w1(gspca_dev, 0x01, 0x60);
1820 reg_w1(gspca_dev, 0x01, 0x40);
1821 break;
1822 case SENSOR_MT9V111:
1823 reg_w1(gspca_dev, 0x01, 0x61);
1824 reg_w1(gspca_dev, 0x17, 0x61);
1825 reg_w1(gspca_dev, 0x01, 0x60);
1826 reg_w1(gspca_dev, 0x01, 0x40);
1827 break;
1828 case SENSOR_OM6802:
1829 msleep(10);
1830 reg_w1(gspca_dev, 0x02, 0x73);
1831 reg_w1(gspca_dev, 0x17, 0x60);
1832 reg_w1(gspca_dev, 0x01, 0x22);
1833 msleep(100);
1834 reg_w1(gspca_dev, 0x01, 0x62);
1835 reg_w1(gspca_dev, 0x17, 0x64);
1836 reg_w1(gspca_dev, 0x17, 0x64);
1837 reg_w1(gspca_dev, 0x01, 0x42);
1838 msleep(10);
1839 reg_w1(gspca_dev, 0x01, 0x42);
1840 i2c_w8(gspca_dev, om6802_init0[0]);
1841 i2c_w8(gspca_dev, om6802_init0[1]);
1842 msleep(15);
1843 reg_w1(gspca_dev, 0x02, 0x71);
1844 msleep(150);
1845 break;
1846 case SENSOR_OV7630:
1847 reg_w1(gspca_dev, 0x01, 0x61);
1848 reg_w1(gspca_dev, 0x17, 0xe2);
1849 reg_w1(gspca_dev, 0x01, 0x60);
1850 reg_w1(gspca_dev, 0x01, 0x40);
1851 break;
1852 case SENSOR_OV7648:
1853 reg_w1(gspca_dev, 0x01, 0x63);
1854 reg_w1(gspca_dev, 0x17, 0x20);
1855 reg_w1(gspca_dev, 0x01, 0x62);
1856 reg_w1(gspca_dev, 0x01, 0x42);
1857 break;
1858 case SENSOR_PO1030:
1859 case SENSOR_SOI768:
1860 reg_w1(gspca_dev, 0x01, 0x61);
1861 reg_w1(gspca_dev, 0x17, 0x20);
1862 reg_w1(gspca_dev, 0x01, 0x60);
1863 reg_w1(gspca_dev, 0x01, 0x40);
1864 break;
1865 case SENSOR_PO2030N:
1866 case SENSOR_OV7660:
1867 reg_w1(gspca_dev, 0x01, 0x63);
1868 reg_w1(gspca_dev, 0x17, 0x20);
1869 reg_w1(gspca_dev, 0x01, 0x62);
1870 reg_w1(gspca_dev, 0x01, 0x42);
1871 break;
1872 case SENSOR_SP80708:
1873 reg_w1(gspca_dev, 0x01, 0x63);
1874 reg_w1(gspca_dev, 0x17, 0x20);
1875 reg_w1(gspca_dev, 0x01, 0x62);
1876 reg_w1(gspca_dev, 0x01, 0x42);
1877 msleep(100);
1878 reg_w1(gspca_dev, 0x02, 0x62);
1879 break;
1880 default:
1881/* case SENSOR_HV7131R: */
1882/* case SENSOR_MI0360: */
1883/* case SENSOR_MO4000: */
1884 reg_w1(gspca_dev, 0x01, 0x43);
1885 reg_w1(gspca_dev, 0x17, 0x61);
1886 reg_w1(gspca_dev, 0x01, 0x42);
1887 if (sd->sensor == SENSOR_HV7131R)
1888 hv7131r_probe(gspca_dev);
1889 break;
1890 }
1891}
1892
1893/* this function is called at probe time */ 1777/* this function is called at probe time */
1894static int sd_config(struct gspca_dev *gspca_dev, 1778static int sd_config(struct gspca_dev *gspca_dev,
1895 const struct usb_device_id *id) 1779 const struct usb_device_id *id)
@@ -1898,7 +1782,8 @@ static int sd_config(struct gspca_dev *gspca_dev,
1898 struct cam *cam; 1782 struct cam *cam;
1899 1783
1900 sd->bridge = id->driver_info >> 16; 1784 sd->bridge = id->driver_info >> 16;
1901 sd->sensor = id->driver_info; 1785 sd->sensor = id->driver_info >> 8;
1786 sd->flags = id->driver_info;
1902 1787
1903 cam = &gspca_dev->cam; 1788 cam = &gspca_dev->cam;
1904 if (sd->sensor == SENSOR_ADCM1700) { 1789 if (sd->sensor == SENSOR_ADCM1700) {
@@ -1929,7 +1814,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
1929 /* setup a selector by bridge */ 1814 /* setup a selector by bridge */
1930 reg_w1(gspca_dev, 0xf1, 0x01); 1815 reg_w1(gspca_dev, 0xf1, 0x01);
1931 reg_r(gspca_dev, 0x00, 1); 1816 reg_r(gspca_dev, 0x00, 1);
1932 reg_w1(gspca_dev, 0xf1, gspca_dev->usb_buf[0]); 1817 reg_w1(gspca_dev, 0xf1, 0x00);
1933 reg_r(gspca_dev, 0x00, 1); /* get sonix chip id */ 1818 reg_r(gspca_dev, 0x00, 1); /* get sonix chip id */
1934 regF1 = gspca_dev->usb_buf[0]; 1819 regF1 = gspca_dev->usb_buf[0];
1935 if (gspca_dev->usb_err < 0) 1820 if (gspca_dev->usb_err < 0)
@@ -2423,10 +2308,17 @@ static int sd_start(struct gspca_dev *gspca_dev)
2423{ 2308{
2424 struct sd *sd = (struct sd *) gspca_dev; 2309 struct sd *sd = (struct sd *) gspca_dev;
2425 int i; 2310 int i;
2426 u8 reg1, reg17; 2311 u8 reg01, reg17;
2312 u8 reg0102[2];
2427 const u8 *sn9c1xx; 2313 const u8 *sn9c1xx;
2428 const u8 (*init)[8]; 2314 const u8 (*init)[8];
2315 const u8 *reg9a;
2429 int mode; 2316 int mode;
2317 static const u8 reg9a_def[] =
2318 {0x00, 0x40, 0x20, 0x00, 0x00, 0x00};
2319 static const u8 reg9a_spec[] =
2320 {0x00, 0x40, 0x38, 0x30, 0x00, 0x20};
2321 static const u8 regd4[] = {0x60, 0x00, 0x00};
2430 static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f }; 2322 static const u8 C0[] = { 0x2d, 0x2d, 0x3a, 0x05, 0x04, 0x3f };
2431 static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec }; 2323 static const u8 CA[] = { 0x28, 0xd8, 0x14, 0xec };
2432 static const u8 CA_adcm1700[] = 2324 static const u8 CA_adcm1700[] =
@@ -2448,7 +2340,85 @@ static int sd_start(struct gspca_dev *gspca_dev)
2448 2340
2449 /* initialize the bridge */ 2341 /* initialize the bridge */
2450 sn9c1xx = sn_tb[sd->sensor]; 2342 sn9c1xx = sn_tb[sd->sensor];
2451 bridge_init(gspca_dev, sn9c1xx); 2343
2344 /* sensor clock already enabled in sd_init */
2345 /* reg_w1(gspca_dev, 0xf1, 0x00); */
2346 reg01 = sn9c1xx[1];
2347 if (sd->flags & PDN_INV)
2348 reg01 ^= S_PDN_INV; /* power down inverted */
2349 reg_w1(gspca_dev, 0x01, reg01);
2350
2351 /* configure gpio */
2352 reg0102[0] = reg01;
2353 reg0102[1] = sn9c1xx[2];
2354 if (gspca_dev->audio)
2355 reg0102[1] |= 0x04; /* keep the audio connection */
2356 reg_w(gspca_dev, 0x01, reg0102, 2);
2357 reg_w(gspca_dev, 0x08, &sn9c1xx[8], 2);
2358 reg_w(gspca_dev, 0x17, &sn9c1xx[0x17], 5);
2359 switch (sd->sensor) {
2360 case SENSOR_GC0307:
2361 case SENSOR_OV7660:
2362 case SENSOR_PO1030:
2363 case SENSOR_PO2030N:
2364 case SENSOR_SOI768:
2365 case SENSOR_SP80708:
2366 reg9a = reg9a_spec;
2367 break;
2368 default:
2369 reg9a = reg9a_def;
2370 break;
2371 }
2372 reg_w(gspca_dev, 0x9a, reg9a, 6);
2373
2374 reg_w(gspca_dev, 0xd4, regd4, sizeof regd4);
2375
2376 reg_w(gspca_dev, 0x03, &sn9c1xx[3], 0x0f);
2377
2378 reg17 = sn9c1xx[0x17];
2379 switch (sd->sensor) {
2380 case SENSOR_GC0307:
2381 msleep(50); /*fixme: is it useful? */
2382 break;
2383 case SENSOR_OM6802:
2384 msleep(10);
2385 reg_w1(gspca_dev, 0x02, 0x73);
2386 reg17 |= SEN_CLK_EN;
2387 reg_w1(gspca_dev, 0x17, reg17);
2388 reg_w1(gspca_dev, 0x01, 0x22);
2389 msleep(100);
2390 reg01 = SCL_SEL_OD | S_PDN_INV;
2391 reg17 &= MCK_SIZE_MASK;
2392 reg17 |= 0x04; /* clock / 4 */
2393 break;
2394 }
2395 reg01 |= SYS_SEL_48M;
2396 reg_w1(gspca_dev, 0x01, reg01);
2397 reg17 |= SEN_CLK_EN;
2398 reg_w1(gspca_dev, 0x17, reg17);
2399 reg01 &= ~S_PWR_DN; /* sensor power on */
2400 reg_w1(gspca_dev, 0x01, reg01);
2401 reg01 &= ~SYS_SEL_48M;
2402 reg_w1(gspca_dev, 0x01, reg01);
2403
2404 switch (sd->sensor) {
2405 case SENSOR_HV7131R:
2406 hv7131r_probe(gspca_dev); /*fixme: is it useful? */
2407 break;
2408 case SENSOR_OM6802:
2409 msleep(10);
2410 reg_w1(gspca_dev, 0x01, reg01);
2411 i2c_w8(gspca_dev, om6802_init0[0]);
2412 i2c_w8(gspca_dev, om6802_init0[1]);
2413 msleep(15);
2414 reg_w1(gspca_dev, 0x02, 0x71);
2415 msleep(150);
2416 break;
2417 case SENSOR_SP80708:
2418 msleep(100);
2419 reg_w1(gspca_dev, 0x02, 0x62);
2420 break;
2421 }
2452 2422
2453 /* initialize the sensor */ 2423 /* initialize the sensor */
2454 i2c_w_seq(gspca_dev, sensor_init[sd->sensor]); 2424 i2c_w_seq(gspca_dev, sensor_init[sd->sensor]);
@@ -2476,30 +2446,11 @@ static int sd_start(struct gspca_dev *gspca_dev)
2476 } 2446 }
2477 reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]); 2447 reg_w1(gspca_dev, 0x18, sn9c1xx[0x18]);
2478 switch (sd->sensor) { 2448 switch (sd->sensor) {
2479 case SENSOR_GC0307: 2449 case SENSOR_OM6802:
2480 reg17 = 0xa2; 2450/* case SENSOR_OV7648: * fixme: sometimes */
2481 break;
2482 case SENSOR_MT9V111:
2483 case SENSOR_MI0360B:
2484 reg17 = 0xe0;
2485 break;
2486 case SENSOR_ADCM1700:
2487 case SENSOR_OV7630:
2488 reg17 = 0xe2;
2489 break;
2490 case SENSOR_OV7648:
2491 reg17 = 0x20;
2492 break;
2493 case SENSOR_OV7660:
2494 case SENSOR_SOI768:
2495 reg17 = 0xa0;
2496 break;
2497 case SENSOR_PO1030:
2498 case SENSOR_PO2030N:
2499 reg17 = 0xa0;
2500 break; 2451 break;
2501 default: 2452 default:
2502 reg17 = 0x60; 2453 reg17 |= DEF_EN;
2503 break; 2454 break;
2504 } 2455 }
2505 reg_w1(gspca_dev, 0x17, reg17); 2456 reg_w1(gspca_dev, 0x17, reg17);
@@ -2546,95 +2497,67 @@ static int sd_start(struct gspca_dev *gspca_dev)
2546 2497
2547 init = NULL; 2498 init = NULL;
2548 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv; 2499 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
2549 if (mode) 2500 reg01 |= SYS_SEL_48M | V_TX_EN;
2550 reg1 = 0x46; /* 320x240: clk 48Mhz, video trf enable */ 2501 reg17 &= ~MCK_SIZE_MASK;
2551 else 2502 reg17 |= 0x02; /* clock / 2 */
2552 reg1 = 0x06; /* 640x480: clk 24Mhz, video trf enable */
2553 reg17 = 0x61; /* 0x:20: enable sensor clock */
2554 switch (sd->sensor) { 2503 switch (sd->sensor) {
2555 case SENSOR_ADCM1700: 2504 case SENSOR_ADCM1700:
2556 init = adcm1700_sensor_param1; 2505 init = adcm1700_sensor_param1;
2557 reg1 = 0x46;
2558 reg17 = 0xe2;
2559 break; 2506 break;
2560 case SENSOR_GC0307: 2507 case SENSOR_GC0307:
2561 init = gc0307_sensor_param1; 2508 init = gc0307_sensor_param1;
2562 reg17 = 0xa2; 2509 break;
2563 reg1 = 0x44; 2510 case SENSOR_HV7131R:
2511 case SENSOR_MI0360:
2512 if (mode)
2513 reg01 |= SYS_SEL_48M; /* 320x240: clk 48Mhz */
2514 else
2515 reg01 &= ~SYS_SEL_48M; /* 640x480: clk 24Mhz */
2516 reg17 &= ~MCK_SIZE_MASK;
2517 reg17 |= 0x01; /* clock / 1 */
2564 break; 2518 break;
2565 case SENSOR_MI0360B: 2519 case SENSOR_MI0360B:
2566 init = mi0360b_sensor_param1; 2520 init = mi0360b_sensor_param1;
2567 reg1 &= ~0x02; /* don't inverse pin S_PWR_DN */
2568 reg17 = 0xe2;
2569 break; 2521 break;
2570 case SENSOR_MO4000: 2522 case SENSOR_MO4000:
2571 if (mode) { 2523 if (mode) { /* if 320x240 */
2572/* reg1 = 0x46; * 320 clk 48Mhz 60fp/s */ 2524 reg01 &= ~SYS_SEL_48M; /* clk 24Mz */
2573 reg1 = 0x06; /* clk 24Mz */ 2525 reg17 &= ~MCK_SIZE_MASK;
2574 } else { 2526 reg17 |= 0x01; /* clock / 1 */
2575 reg17 = 0x22; /* 640 MCKSIZE */
2576/* reg1 = 0x06; * 640 clk 24Mz (done) */
2577 } 2527 }
2578 break; 2528 break;
2579 case SENSOR_MT9V111: 2529 case SENSOR_MT9V111:
2580 init = mt9v111_sensor_param1; 2530 init = mt9v111_sensor_param1;
2581 if (mode) {
2582 reg1 = 0x04; /* 320 clk 48Mhz */
2583 } else {
2584/* reg1 = 0x06; * 640 clk 24Mz (done) */
2585 reg17 = 0xc2;
2586 }
2587 break; 2531 break;
2588 case SENSOR_OM6802: 2532 case SENSOR_OM6802:
2589 init = om6802_sensor_param1; 2533 init = om6802_sensor_param1;
2590 reg17 = 0x64; /* 640 MCKSIZE */ 2534 if (!mode) { /* if 640x480 */
2535 reg17 &= ~MCK_SIZE_MASK;
2536 reg17 |= 0x01; /* clock / 4 */
2537 }
2591 break; 2538 break;
2592 case SENSOR_OV7630: 2539 case SENSOR_OV7630:
2593 init = ov7630_sensor_param1; 2540 init = ov7630_sensor_param1;
2594 reg17 = 0xe2;
2595 reg1 = 0x44;
2596 break; 2541 break;
2597 case SENSOR_OV7648: 2542 case SENSOR_OV7648:
2598 init = ov7648_sensor_param1; 2543 init = ov7648_sensor_param1;
2599 reg17 = 0x21; 2544 reg17 &= ~MCK_SIZE_MASK;
2600/* reg1 = 0x42; * 42 - 46? */ 2545 reg17 |= 0x01; /* clock / 1 */
2601 break; 2546 break;
2602 case SENSOR_OV7660: 2547 case SENSOR_OV7660:
2603 init = ov7660_sensor_param1; 2548 init = ov7660_sensor_param1;
2604 if (sd->bridge == BRIDGE_SN9C120) {
2605 if (mode) { /* 320x240 - 160x120 */
2606 reg17 = 0xa2;
2607 reg1 = 0x44; /* 48 Mhz, video trf eneble */
2608 }
2609 } else {
2610 reg17 = 0x22;
2611 reg1 = 0x06; /* 24 Mhz, video trf eneble
2612 * inverse power down */
2613 }
2614 break; 2549 break;
2615 case SENSOR_PO1030: 2550 case SENSOR_PO1030:
2616 init = po1030_sensor_param1; 2551 init = po1030_sensor_param1;
2617 reg17 = 0xa2;
2618 reg1 = 0x44;
2619 break; 2552 break;
2620 case SENSOR_PO2030N: 2553 case SENSOR_PO2030N:
2621 init = po2030n_sensor_param1; 2554 init = po2030n_sensor_param1;
2622 reg1 = 0x46;
2623 reg17 = 0xa2;
2624 break; 2555 break;
2625 case SENSOR_SOI768: 2556 case SENSOR_SOI768:
2626 init = soi768_sensor_param1; 2557 init = soi768_sensor_param1;
2627 reg1 = 0x44;
2628 reg17 = 0xa2;
2629 break; 2558 break;
2630 case SENSOR_SP80708: 2559 case SENSOR_SP80708:
2631 init = sp80708_sensor_param1; 2560 init = sp80708_sensor_param1;
2632 if (mode) {
2633/*?? reg1 = 0x04; * 320 clk 48Mhz */
2634 } else {
2635 reg1 = 0x46; /* 640 clk 48Mz */
2636 reg17 = 0xa2;
2637 }
2638 break; 2561 break;
2639 } 2562 }
2640 2563
@@ -2684,7 +2607,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
2684 setjpegqual(gspca_dev); 2607 setjpegqual(gspca_dev);
2685 2608
2686 reg_w1(gspca_dev, 0x17, reg17); 2609 reg_w1(gspca_dev, 0x17, reg17);
2687 reg_w1(gspca_dev, 0x01, reg1); 2610 reg_w1(gspca_dev, 0x01, reg01);
2611 sd->reg01 = reg01;
2612 sd->reg17 = reg17;
2688 2613
2689 sethvflip(gspca_dev); 2614 sethvflip(gspca_dev);
2690 setbrightness(gspca_dev); 2615 setbrightness(gspca_dev);
@@ -2706,41 +2631,64 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
2706 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 }; 2631 { 0xa1, 0x21, 0x76, 0x20, 0x00, 0x00, 0x00, 0x10 };
2707 static const u8 stopsoi768[] = 2632 static const u8 stopsoi768[] =
2708 { 0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10 }; 2633 { 0xa1, 0x21, 0x12, 0x80, 0x00, 0x00, 0x00, 0x10 };
2709 u8 data; 2634 u8 reg01;
2710 const u8 *sn9c1xx; 2635 u8 reg17;
2711 2636
2712 data = 0x0b; 2637 reg01 = sd->reg01;
2638 reg17 = sd->reg17 & ~SEN_CLK_EN;
2713 switch (sd->sensor) { 2639 switch (sd->sensor) {
2640 case SENSOR_ADCM1700:
2714 case SENSOR_GC0307: 2641 case SENSOR_GC0307:
2715 data = 0x29; 2642 case SENSOR_PO2030N:
2643 case SENSOR_SP80708:
2644 reg01 |= LED;
2645 reg_w1(gspca_dev, 0x01, reg01);
2646 reg01 &= ~(LED | V_TX_EN);
2647 reg_w1(gspca_dev, 0x01, reg01);
2648/* reg_w1(gspca_dev, 0x02, 0x??); * LED off ? */
2716 break; 2649 break;
2717 case SENSOR_HV7131R: 2650 case SENSOR_HV7131R:
2651 reg01 &= ~V_TX_EN;
2652 reg_w1(gspca_dev, 0x01, reg01);
2718 i2c_w8(gspca_dev, stophv7131); 2653 i2c_w8(gspca_dev, stophv7131);
2719 data = 0x2b;
2720 break; 2654 break;
2721 case SENSOR_MI0360: 2655 case SENSOR_MI0360:
2722 case SENSOR_MI0360B: 2656 case SENSOR_MI0360B:
2657 reg01 &= ~V_TX_EN;
2658 reg_w1(gspca_dev, 0x01, reg01);
2659/* reg_w1(gspca_dev, 0x02, 0x40); * LED off ? */
2723 i2c_w8(gspca_dev, stopmi0360); 2660 i2c_w8(gspca_dev, stopmi0360);
2724 data = 0x29;
2725 break; 2661 break;
2726 case SENSOR_OV7648:
2727 i2c_w8(gspca_dev, stopov7648);
2728 /* fall thru */
2729 case SENSOR_MT9V111: 2662 case SENSOR_MT9V111:
2730 case SENSOR_OV7630: 2663 case SENSOR_OM6802:
2731 case SENSOR_PO1030: 2664 case SENSOR_PO1030:
2732 data = 0x29; 2665 reg01 &= ~V_TX_EN;
2666 reg_w1(gspca_dev, 0x01, reg01);
2667 break;
2668 case SENSOR_OV7630:
2669 case SENSOR_OV7648:
2670 reg01 &= ~V_TX_EN;
2671 reg_w1(gspca_dev, 0x01, reg01);
2672 i2c_w8(gspca_dev, stopov7648);
2673 break;
2674 case SENSOR_OV7660:
2675 reg01 &= ~V_TX_EN;
2676 reg_w1(gspca_dev, 0x01, reg01);
2733 break; 2677 break;
2734 case SENSOR_SOI768: 2678 case SENSOR_SOI768:
2735 i2c_w8(gspca_dev, stopsoi768); 2679 i2c_w8(gspca_dev, stopsoi768);
2736 data = 0x29;
2737 break; 2680 break;
2738 } 2681 }
2739 sn9c1xx = sn_tb[sd->sensor]; 2682
2740 reg_w1(gspca_dev, 0x01, sn9c1xx[1]); 2683 reg01 |= SCL_SEL_OD;
2741 reg_w1(gspca_dev, 0x17, sn9c1xx[0x17]); 2684 reg_w1(gspca_dev, 0x01, reg01);
2742 reg_w1(gspca_dev, 0x01, sn9c1xx[1]); 2685 reg01 |= S_PWR_DN; /* sensor power down */
2743 reg_w1(gspca_dev, 0x01, data); 2686 reg_w1(gspca_dev, 0x01, reg01);
2687 reg_w1(gspca_dev, 0x17, reg17);
2688 reg01 &= ~SYS_SEL_48M; /* clock 24MHz */
2689 reg_w1(gspca_dev, 0x01, reg01);
2690 reg01 |= LED;
2691 reg_w1(gspca_dev, 0x01, reg01);
2744 /* Don't disable sensor clock as that disables the button on the cam */ 2692 /* Don't disable sensor clock as that disables the button on the cam */
2745 /* reg_w1(gspca_dev, 0xf1, 0x01); */ 2693 /* reg_w1(gspca_dev, 0xf1, 0x01); */
2746} 2694}
@@ -2954,14 +2902,18 @@ static const struct sd_desc sd_desc = {
2954/* -- module initialisation -- */ 2902/* -- module initialisation -- */
2955#define BS(bridge, sensor) \ 2903#define BS(bridge, sensor) \
2956 .driver_info = (BRIDGE_ ## bridge << 16) \ 2904 .driver_info = (BRIDGE_ ## bridge << 16) \
2957 | SENSOR_ ## sensor 2905 | (SENSOR_ ## sensor << 8)
2906#define BSF(bridge, sensor, flags) \
2907 .driver_info = (BRIDGE_ ## bridge << 16) \
2908 | (SENSOR_ ## sensor << 8) \
2909 | (flags)
2958static const __devinitdata struct usb_device_id device_table[] = { 2910static const __devinitdata struct usb_device_id device_table[] = {
2959#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE 2911#if !defined CONFIG_USB_SN9C102 && !defined CONFIG_USB_SN9C102_MODULE
2960 {USB_DEVICE(0x0458, 0x7025), BS(SN9C120, MI0360)}, 2912 {USB_DEVICE(0x0458, 0x7025), BS(SN9C120, MI0360)},
2961 {USB_DEVICE(0x0458, 0x702e), BS(SN9C120, OV7660)}, 2913 {USB_DEVICE(0x0458, 0x702e), BS(SN9C120, OV7660)},
2962#endif 2914#endif
2963 {USB_DEVICE(0x045e, 0x00f5), BS(SN9C105, OV7660)}, 2915 {USB_DEVICE(0x045e, 0x00f5), BSF(SN9C105, OV7660, PDN_INV)},
2964 {USB_DEVICE(0x045e, 0x00f7), BS(SN9C105, OV7660)}, 2916 {USB_DEVICE(0x045e, 0x00f7), BSF(SN9C105, OV7660, PDN_INV)},
2965 {USB_DEVICE(0x0471, 0x0327), BS(SN9C105, MI0360)}, 2917 {USB_DEVICE(0x0471, 0x0327), BS(SN9C105, MI0360)},
2966 {USB_DEVICE(0x0471, 0x0328), BS(SN9C105, MI0360)}, 2918 {USB_DEVICE(0x0471, 0x0328), BS(SN9C105, MI0360)},
2967 {USB_DEVICE(0x0471, 0x0330), BS(SN9C105, MI0360)}, 2919 {USB_DEVICE(0x0471, 0x0330), BS(SN9C105, MI0360)},
diff --git a/drivers/media/video/meye.c b/drivers/media/video/meye.c
index 2be23bccd3c8..48d2c2419c13 100644
--- a/drivers/media/video/meye.c
+++ b/drivers/media/video/meye.c
@@ -1659,7 +1659,7 @@ static const struct v4l2_file_operations meye_fops = {
1659 .open = meye_open, 1659 .open = meye_open,
1660 .release = meye_release, 1660 .release = meye_release,
1661 .mmap = meye_mmap, 1661 .mmap = meye_mmap,
1662 .ioctl = video_ioctl2, 1662 .unlocked_ioctl = video_ioctl2,
1663 .poll = meye_poll, 1663 .poll = meye_poll,
1664}; 1664};
1665 1665
@@ -1831,12 +1831,6 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
1831 msleep(1); 1831 msleep(1);
1832 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK); 1832 mchip_set(MCHIP_MM_INTA, MCHIP_MM_INTA_HIC_1_MASK);
1833 1833
1834 if (video_register_device(meye.vdev, VFL_TYPE_GRABBER,
1835 video_nr) < 0) {
1836 v4l2_err(v4l2_dev, "video_register_device failed\n");
1837 goto outvideoreg;
1838 }
1839
1840 mutex_init(&meye.lock); 1834 mutex_init(&meye.lock);
1841 init_waitqueue_head(&meye.proc_list); 1835 init_waitqueue_head(&meye.proc_list);
1842 meye.brightness = 32 << 10; 1836 meye.brightness = 32 << 10;
@@ -1858,6 +1852,12 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
1858 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0); 1852 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAPICTURE, 0);
1859 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48); 1853 sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERAAGC, 48);
1860 1854
1855 if (video_register_device(meye.vdev, VFL_TYPE_GRABBER,
1856 video_nr) < 0) {
1857 v4l2_err(v4l2_dev, "video_register_device failed\n");
1858 goto outvideoreg;
1859 }
1860
1861 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n", 1861 v4l2_info(v4l2_dev, "Motion Eye Camera Driver v%s.\n",
1862 MEYE_DRIVER_VERSION); 1862 MEYE_DRIVER_VERSION);
1863 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n", 1863 v4l2_info(v4l2_dev, "mchip KL5A72002 rev. %d, base %lx, irq %d\n",
diff --git a/drivers/media/video/mx2_camera.c b/drivers/media/video/mx2_camera.c
index 072bd2d1cfad..13565cba237d 100644
--- a/drivers/media/video/mx2_camera.c
+++ b/drivers/media/video/mx2_camera.c
@@ -807,8 +807,6 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd,
807 807
808 if (common_flags & SOCAM_PCLK_SAMPLE_RISING) 808 if (common_flags & SOCAM_PCLK_SAMPLE_RISING)
809 csicr1 |= CSICR1_REDGE; 809 csicr1 |= CSICR1_REDGE;
810 if (common_flags & SOCAM_PCLK_SAMPLE_FALLING)
811 csicr1 |= CSICR1_INV_PCLK;
812 if (common_flags & SOCAM_VSYNC_ACTIVE_HIGH) 810 if (common_flags & SOCAM_VSYNC_ACTIVE_HIGH)
813 csicr1 |= CSICR1_SOF_POL; 811 csicr1 |= CSICR1_SOF_POL;
814 if (common_flags & SOCAM_HSYNC_ACTIVE_HIGH) 812 if (common_flags & SOCAM_HSYNC_ACTIVE_HIGH)
diff --git a/drivers/media/video/pms.c b/drivers/media/video/pms.c
index 7129b50757db..7551907f8c28 100644
--- a/drivers/media/video/pms.c
+++ b/drivers/media/video/pms.c
@@ -932,7 +932,7 @@ static ssize_t pms_read(struct file *file, char __user *buf,
932 932
933static const struct v4l2_file_operations pms_fops = { 933static const struct v4l2_file_operations pms_fops = {
934 .owner = THIS_MODULE, 934 .owner = THIS_MODULE,
935 .ioctl = video_ioctl2, 935 .unlocked_ioctl = video_ioctl2,
936 .read = pms_read, 936 .read = pms_read,
937}; 937};
938 938
diff --git a/drivers/media/video/s5p-fimc/fimc-capture.c b/drivers/media/video/s5p-fimc/fimc-capture.c
index 1b93207c89e8..2f500809f53d 100644
--- a/drivers/media/video/s5p-fimc/fimc-capture.c
+++ b/drivers/media/video/s5p-fimc/fimc-capture.c
@@ -522,6 +522,7 @@ static int fimc_cap_streamon(struct file *file, void *priv,
522 INIT_LIST_HEAD(&fimc->vid_cap.active_buf_q); 522 INIT_LIST_HEAD(&fimc->vid_cap.active_buf_q);
523 fimc->vid_cap.active_buf_cnt = 0; 523 fimc->vid_cap.active_buf_cnt = 0;
524 fimc->vid_cap.frame_count = 0; 524 fimc->vid_cap.frame_count = 0;
525 fimc->vid_cap.buf_index = fimc_hw_get_frame_index(fimc);
525 526
526 set_bit(ST_CAPT_PEND, &fimc->state); 527 set_bit(ST_CAPT_PEND, &fimc->state);
527 ret = videobuf_streamon(&fimc->vid_cap.vbq); 528 ret = videobuf_streamon(&fimc->vid_cap.vbq);
@@ -652,6 +653,50 @@ static int fimc_cap_s_ctrl(struct file *file, void *priv,
652 return ret; 653 return ret;
653} 654}
654 655
656static int fimc_cap_cropcap(struct file *file, void *fh,
657 struct v4l2_cropcap *cr)
658{
659 struct fimc_frame *f;
660 struct fimc_ctx *ctx = fh;
661 struct fimc_dev *fimc = ctx->fimc_dev;
662
663 if (cr->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
664 return -EINVAL;
665
666 if (mutex_lock_interruptible(&fimc->lock))
667 return -ERESTARTSYS;
668
669 f = &ctx->s_frame;
670 cr->bounds.left = 0;
671 cr->bounds.top = 0;
672 cr->bounds.width = f->o_width;
673 cr->bounds.height = f->o_height;
674 cr->defrect = cr->bounds;
675
676 mutex_unlock(&fimc->lock);
677 return 0;
678}
679
680static int fimc_cap_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
681{
682 struct fimc_frame *f;
683 struct fimc_ctx *ctx = file->private_data;
684 struct fimc_dev *fimc = ctx->fimc_dev;
685
686
687 if (mutex_lock_interruptible(&fimc->lock))
688 return -ERESTARTSYS;
689
690 f = &ctx->s_frame;
691 cr->c.left = f->offs_h;
692 cr->c.top = f->offs_v;
693 cr->c.width = f->width;
694 cr->c.height = f->height;
695
696 mutex_unlock(&fimc->lock);
697 return 0;
698}
699
655static int fimc_cap_s_crop(struct file *file, void *fh, 700static int fimc_cap_s_crop(struct file *file, void *fh,
656 struct v4l2_crop *cr) 701 struct v4l2_crop *cr)
657{ 702{
@@ -716,9 +761,9 @@ static const struct v4l2_ioctl_ops fimc_capture_ioctl_ops = {
716 .vidioc_g_ctrl = fimc_vidioc_g_ctrl, 761 .vidioc_g_ctrl = fimc_vidioc_g_ctrl,
717 .vidioc_s_ctrl = fimc_cap_s_ctrl, 762 .vidioc_s_ctrl = fimc_cap_s_ctrl,
718 763
719 .vidioc_g_crop = fimc_vidioc_g_crop, 764 .vidioc_g_crop = fimc_cap_g_crop,
720 .vidioc_s_crop = fimc_cap_s_crop, 765 .vidioc_s_crop = fimc_cap_s_crop,
721 .vidioc_cropcap = fimc_vidioc_cropcap, 766 .vidioc_cropcap = fimc_cap_cropcap,
722 767
723 .vidioc_enum_input = fimc_cap_enum_input, 768 .vidioc_enum_input = fimc_cap_enum_input,
724 .vidioc_s_input = fimc_cap_s_input, 769 .vidioc_s_input = fimc_cap_s_input,
@@ -785,7 +830,7 @@ int fimc_register_capture_device(struct fimc_dev *fimc)
785 videobuf_queue_dma_contig_init(&vid_cap->vbq, &fimc_qops, 830 videobuf_queue_dma_contig_init(&vid_cap->vbq, &fimc_qops,
786 vid_cap->v4l2_dev.dev, &fimc->irqlock, 831 vid_cap->v4l2_dev.dev, &fimc->irqlock,
787 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE, 832 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
788 sizeof(struct fimc_vid_buffer), (void *)ctx); 833 sizeof(struct fimc_vid_buffer), (void *)ctx, NULL);
789 834
790 ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1); 835 ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
791 if (ret) { 836 if (ret) {
diff --git a/drivers/media/video/s5p-fimc/fimc-core.c b/drivers/media/video/s5p-fimc/fimc-core.c
index 2e7c547894b6..bb99f2d805d3 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.c
+++ b/drivers/media/video/s5p-fimc/fimc-core.c
@@ -50,8 +50,8 @@ static struct fimc_fmt fimc_formats[] = {
50 .planes_cnt = 1, 50 .planes_cnt = 1,
51 .flags = FMT_FLAGS_M2M, 51 .flags = FMT_FLAGS_M2M,
52 }, { 52 }, {
53 .name = "XRGB-8-8-8-8, 24 bpp", 53 .name = "XRGB-8-8-8-8, 32 bpp",
54 .fourcc = V4L2_PIX_FMT_RGB24, 54 .fourcc = V4L2_PIX_FMT_RGB32,
55 .depth = 32, 55 .depth = 32,
56 .color = S5P_FIMC_RGB888, 56 .color = S5P_FIMC_RGB888,
57 .buff_cnt = 1, 57 .buff_cnt = 1,
@@ -983,6 +983,7 @@ int fimc_vidioc_queryctrl(struct file *file, void *priv,
983{ 983{
984 struct fimc_ctx *ctx = priv; 984 struct fimc_ctx *ctx = priv;
985 struct v4l2_queryctrl *c; 985 struct v4l2_queryctrl *c;
986 int ret = -EINVAL;
986 987
987 c = get_ctrl(qc->id); 988 c = get_ctrl(qc->id);
988 if (c) { 989 if (c) {
@@ -990,10 +991,14 @@ int fimc_vidioc_queryctrl(struct file *file, void *priv,
990 return 0; 991 return 0;
991 } 992 }
992 993
993 if (ctx->state & FIMC_CTX_CAP) 994 if (ctx->state & FIMC_CTX_CAP) {
994 return v4l2_subdev_call(ctx->fimc_dev->vid_cap.sd, 995 if (mutex_lock_interruptible(&ctx->fimc_dev->lock))
996 return -ERESTARTSYS;
997 ret = v4l2_subdev_call(ctx->fimc_dev->vid_cap.sd,
995 core, queryctrl, qc); 998 core, queryctrl, qc);
996 return -EINVAL; 999 mutex_unlock(&ctx->fimc_dev->lock);
1000 }
1001 return ret;
997} 1002}
998 1003
999int fimc_vidioc_g_ctrl(struct file *file, void *priv, 1004int fimc_vidioc_g_ctrl(struct file *file, void *priv,
@@ -1115,7 +1120,7 @@ static int fimc_m2m_s_ctrl(struct file *file, void *priv,
1115 return 0; 1120 return 0;
1116} 1121}
1117 1122
1118int fimc_vidioc_cropcap(struct file *file, void *fh, 1123static int fimc_m2m_cropcap(struct file *file, void *fh,
1119 struct v4l2_cropcap *cr) 1124 struct v4l2_cropcap *cr)
1120{ 1125{
1121 struct fimc_frame *frame; 1126 struct fimc_frame *frame;
@@ -1139,7 +1144,7 @@ int fimc_vidioc_cropcap(struct file *file, void *fh,
1139 return 0; 1144 return 0;
1140} 1145}
1141 1146
1142int fimc_vidioc_g_crop(struct file *file, void *fh, struct v4l2_crop *cr) 1147static int fimc_m2m_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1143{ 1148{
1144 struct fimc_frame *frame; 1149 struct fimc_frame *frame;
1145 struct fimc_ctx *ctx = file->private_data; 1150 struct fimc_ctx *ctx = file->private_data;
@@ -1167,22 +1172,22 @@ int fimc_try_crop(struct fimc_ctx *ctx, struct v4l2_crop *cr)
1167 struct fimc_frame *f; 1172 struct fimc_frame *f;
1168 u32 min_size, halign; 1173 u32 min_size, halign;
1169 1174
1170 f = (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) ?
1171 &ctx->s_frame : &ctx->d_frame;
1172
1173 if (cr->c.top < 0 || cr->c.left < 0) { 1175 if (cr->c.top < 0 || cr->c.left < 0) {
1174 v4l2_err(&fimc->m2m.v4l2_dev, 1176 v4l2_err(&fimc->m2m.v4l2_dev,
1175 "doesn't support negative values for top & left\n"); 1177 "doesn't support negative values for top & left\n");
1176 return -EINVAL; 1178 return -EINVAL;
1177 } 1179 }
1178 1180
1179 f = ctx_get_frame(ctx, cr->type); 1181 if (cr->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1180 if (IS_ERR(f)) 1182 f = (ctx->state & FIMC_CTX_CAP) ? &ctx->s_frame : &ctx->d_frame;
1181 return PTR_ERR(f); 1183 else if (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT &&
1184 ctx->state & FIMC_CTX_M2M)
1185 f = &ctx->s_frame;
1186 else
1187 return -EINVAL;
1182 1188
1183 min_size = (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1189 min_size = (f == &ctx->s_frame) ?
1184 ? fimc->variant->min_inp_pixsize 1190 fimc->variant->min_inp_pixsize : fimc->variant->min_out_pixsize;
1185 : fimc->variant->min_out_pixsize;
1186 1191
1187 if (ctx->state & FIMC_CTX_M2M) { 1192 if (ctx->state & FIMC_CTX_M2M) {
1188 if (fimc->id == 1 && fimc->variant->pix_hoff) 1193 if (fimc->id == 1 && fimc->variant->pix_hoff)
@@ -1233,6 +1238,9 @@ static int fimc_m2m_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1233 f = (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) ? 1238 f = (cr->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) ?
1234 &ctx->s_frame : &ctx->d_frame; 1239 &ctx->s_frame : &ctx->d_frame;
1235 1240
1241 if (mutex_lock_interruptible(&fimc->lock))
1242 return -ERESTARTSYS;
1243
1236 spin_lock_irqsave(&ctx->slock, flags); 1244 spin_lock_irqsave(&ctx->slock, flags);
1237 if (~ctx->state & (FIMC_SRC_FMT | FIMC_DST_FMT)) { 1245 if (~ctx->state & (FIMC_SRC_FMT | FIMC_DST_FMT)) {
1238 /* Check to see if scaling ratio is within supported range */ 1246 /* Check to see if scaling ratio is within supported range */
@@ -1241,9 +1249,9 @@ static int fimc_m2m_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1241 else 1249 else
1242 ret = fimc_check_scaler_ratio(&cr->c, &ctx->s_frame); 1250 ret = fimc_check_scaler_ratio(&cr->c, &ctx->s_frame);
1243 if (ret) { 1251 if (ret) {
1244 spin_unlock_irqrestore(&ctx->slock, flags);
1245 v4l2_err(&fimc->m2m.v4l2_dev, "Out of scaler range"); 1252 v4l2_err(&fimc->m2m.v4l2_dev, "Out of scaler range");
1246 return -EINVAL; 1253 ret = -EINVAL;
1254 goto scr_unlock;
1247 } 1255 }
1248 } 1256 }
1249 ctx->state |= FIMC_PARAMS; 1257 ctx->state |= FIMC_PARAMS;
@@ -1253,7 +1261,9 @@ static int fimc_m2m_s_crop(struct file *file, void *fh, struct v4l2_crop *cr)
1253 f->width = cr->c.width; 1261 f->width = cr->c.width;
1254 f->height = cr->c.height; 1262 f->height = cr->c.height;
1255 1263
1264scr_unlock:
1256 spin_unlock_irqrestore(&ctx->slock, flags); 1265 spin_unlock_irqrestore(&ctx->slock, flags);
1266 mutex_unlock(&fimc->lock);
1257 return 0; 1267 return 0;
1258} 1268}
1259 1269
@@ -1285,9 +1295,9 @@ static const struct v4l2_ioctl_ops fimc_m2m_ioctl_ops = {
1285 .vidioc_g_ctrl = fimc_vidioc_g_ctrl, 1295 .vidioc_g_ctrl = fimc_vidioc_g_ctrl,
1286 .vidioc_s_ctrl = fimc_m2m_s_ctrl, 1296 .vidioc_s_ctrl = fimc_m2m_s_ctrl,
1287 1297
1288 .vidioc_g_crop = fimc_vidioc_g_crop, 1298 .vidioc_g_crop = fimc_m2m_g_crop,
1289 .vidioc_s_crop = fimc_m2m_s_crop, 1299 .vidioc_s_crop = fimc_m2m_s_crop,
1290 .vidioc_cropcap = fimc_vidioc_cropcap 1300 .vidioc_cropcap = fimc_m2m_cropcap
1291 1301
1292}; 1302};
1293 1303
@@ -1396,7 +1406,7 @@ static const struct v4l2_file_operations fimc_m2m_fops = {
1396 .open = fimc_m2m_open, 1406 .open = fimc_m2m_open,
1397 .release = fimc_m2m_release, 1407 .release = fimc_m2m_release,
1398 .poll = fimc_m2m_poll, 1408 .poll = fimc_m2m_poll,
1399 .ioctl = video_ioctl2, 1409 .unlocked_ioctl = video_ioctl2,
1400 .mmap = fimc_m2m_mmap, 1410 .mmap = fimc_m2m_mmap,
1401}; 1411};
1402 1412
@@ -1736,6 +1746,7 @@ static struct samsung_fimc_variant fimc0_variant_s5pv310 = {
1736 .pix_hoff = 1, 1746 .pix_hoff = 1,
1737 .has_inp_rot = 1, 1747 .has_inp_rot = 1,
1738 .has_out_rot = 1, 1748 .has_out_rot = 1,
1749 .has_cistatus2 = 1,
1739 .min_inp_pixsize = 16, 1750 .min_inp_pixsize = 16,
1740 .min_out_pixsize = 16, 1751 .min_out_pixsize = 16,
1741 .hor_offs_align = 1, 1752 .hor_offs_align = 1,
@@ -1745,6 +1756,7 @@ static struct samsung_fimc_variant fimc0_variant_s5pv310 = {
1745 1756
1746static struct samsung_fimc_variant fimc2_variant_s5pv310 = { 1757static struct samsung_fimc_variant fimc2_variant_s5pv310 = {
1747 .pix_hoff = 1, 1758 .pix_hoff = 1,
1759 .has_cistatus2 = 1,
1748 .min_inp_pixsize = 16, 1760 .min_inp_pixsize = 16,
1749 .min_out_pixsize = 16, 1761 .min_out_pixsize = 16,
1750 .hor_offs_align = 1, 1762 .hor_offs_align = 1,
diff --git a/drivers/media/video/s5p-fimc/fimc-core.h b/drivers/media/video/s5p-fimc/fimc-core.h
index 3e1078516560..4f047d35f8ad 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.h
+++ b/drivers/media/video/s5p-fimc/fimc-core.h
@@ -13,13 +13,15 @@
13 13
14/*#define DEBUG*/ 14/*#define DEBUG*/
15 15
16#include <linux/sched.h>
16#include <linux/types.h> 17#include <linux/types.h>
18#include <linux/videodev2.h>
17#include <media/videobuf-core.h> 19#include <media/videobuf-core.h>
18#include <media/v4l2-device.h> 20#include <media/v4l2-device.h>
19#include <media/v4l2-mem2mem.h> 21#include <media/v4l2-mem2mem.h>
20#include <media/v4l2-mediabus.h> 22#include <media/v4l2-mediabus.h>
21#include <media/s3c_fimc.h> 23#include <media/s3c_fimc.h>
22#include <linux/videodev2.h> 24
23#include "regs-fimc.h" 25#include "regs-fimc.h"
24 26
25#define err(fmt, args...) \ 27#define err(fmt, args...) \
@@ -369,6 +371,7 @@ struct fimc_pix_limit {
369 * @pix_hoff: indicate whether horizontal offset is in pixels or in bytes 371 * @pix_hoff: indicate whether horizontal offset is in pixels or in bytes
370 * @has_inp_rot: set if has input rotator 372 * @has_inp_rot: set if has input rotator
371 * @has_out_rot: set if has output rotator 373 * @has_out_rot: set if has output rotator
374 * @has_cistatus2: 1 if CISTATUS2 register is present in this IP revision
372 * @pix_limit: pixel size constraints for the scaler 375 * @pix_limit: pixel size constraints for the scaler
373 * @min_inp_pixsize: minimum input pixel size 376 * @min_inp_pixsize: minimum input pixel size
374 * @min_out_pixsize: minimum output pixel size 377 * @min_out_pixsize: minimum output pixel size
@@ -379,6 +382,7 @@ struct samsung_fimc_variant {
379 unsigned int pix_hoff:1; 382 unsigned int pix_hoff:1;
380 unsigned int has_inp_rot:1; 383 unsigned int has_inp_rot:1;
381 unsigned int has_out_rot:1; 384 unsigned int has_out_rot:1;
385 unsigned int has_cistatus2:1;
382 struct fimc_pix_limit *pix_limit; 386 struct fimc_pix_limit *pix_limit;
383 u16 min_inp_pixsize; 387 u16 min_inp_pixsize;
384 u16 min_out_pixsize; 388 u16 min_out_pixsize;
@@ -554,11 +558,19 @@ static inline struct fimc_frame *ctx_get_frame(struct fimc_ctx *ctx,
554 return frame; 558 return frame;
555} 559}
556 560
561/* Return an index to the buffer actually being written. */
557static inline u32 fimc_hw_get_frame_index(struct fimc_dev *dev) 562static inline u32 fimc_hw_get_frame_index(struct fimc_dev *dev)
558{ 563{
559 u32 reg = readl(dev->regs + S5P_CISTATUS); 564 u32 reg;
560 return (reg & S5P_CISTATUS_FRAMECNT_MASK) >> 565
561 S5P_CISTATUS_FRAMECNT_SHIFT; 566 if (dev->variant->has_cistatus2) {
567 reg = readl(dev->regs + S5P_CISTATUS2) & 0x3F;
568 return reg > 0 ? --reg : reg;
569 } else {
570 reg = readl(dev->regs + S5P_CISTATUS);
571 return (reg & S5P_CISTATUS_FRAMECNT_MASK) >>
572 S5P_CISTATUS_FRAMECNT_SHIFT;
573 }
562} 574}
563 575
564/* -----------------------------------------------------*/ 576/* -----------------------------------------------------*/
@@ -594,10 +606,6 @@ int fimc_vidioc_g_fmt(struct file *file, void *priv,
594 struct v4l2_format *f); 606 struct v4l2_format *f);
595int fimc_vidioc_try_fmt(struct file *file, void *priv, 607int fimc_vidioc_try_fmt(struct file *file, void *priv,
596 struct v4l2_format *f); 608 struct v4l2_format *f);
597int fimc_vidioc_g_crop(struct file *file, void *fh,
598 struct v4l2_crop *cr);
599int fimc_vidioc_cropcap(struct file *file, void *fh,
600 struct v4l2_cropcap *cr);
601int fimc_vidioc_queryctrl(struct file *file, void *priv, 609int fimc_vidioc_queryctrl(struct file *file, void *priv,
602 struct v4l2_queryctrl *qc); 610 struct v4l2_queryctrl *qc);
603int fimc_vidioc_g_ctrl(struct file *file, void *priv, 611int fimc_vidioc_g_ctrl(struct file *file, void *priv,
diff --git a/drivers/media/video/s5p-fimc/regs-fimc.h b/drivers/media/video/s5p-fimc/regs-fimc.h
index a57daedb5b5c..57e33f84fcfa 100644
--- a/drivers/media/video/s5p-fimc/regs-fimc.h
+++ b/drivers/media/video/s5p-fimc/regs-fimc.h
@@ -165,6 +165,9 @@
165#define S5P_CISTATUS_VVALID_A (1 << 15) 165#define S5P_CISTATUS_VVALID_A (1 << 15)
166#define S5P_CISTATUS_VVALID_B (1 << 14) 166#define S5P_CISTATUS_VVALID_B (1 << 14)
167 167
168/* Indexes to the last and the currently processed buffer. */
169#define S5P_CISTATUS2 0x68
170
168/* Image capture control */ 171/* Image capture control */
169#define S5P_CIIMGCPT 0xc0 172#define S5P_CIIMGCPT 0xc0
170#define S5P_CIIMGCPT_IMGCPTEN (1 << 31) 173#define S5P_CIIMGCPT_IMGCPTEN (1 << 31)
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index 5c209afb0ac8..2486520582f2 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -1980,7 +1980,7 @@ static int __devinit sh_mobile_ceu_probe(struct platform_device *pdev)
1980 * we complete the completion. 1980 * we complete the completion.
1981 */ 1981 */
1982 1982
1983 if (!csi2->driver || !csi2->driver->owner) { 1983 if (!csi2->driver) {
1984 complete(&wait.completion); 1984 complete(&wait.completion);
1985 /* Either too late, or probing failed */ 1985 /* Either too late, or probing failed */
1986 bus_unregister_notifier(&platform_bus_type, &wait.notifier); 1986 bus_unregister_notifier(&platform_bus_type, &wait.notifier);
diff --git a/drivers/media/video/sh_vou.c b/drivers/media/video/sh_vou.c
index 4e5a8cf76ded..07cf0c6c7c1f 100644
--- a/drivers/media/video/sh_vou.c
+++ b/drivers/media/video/sh_vou.c
@@ -75,6 +75,7 @@ struct sh_vou_device {
75 int pix_idx; 75 int pix_idx;
76 struct videobuf_buffer *active; 76 struct videobuf_buffer *active;
77 enum sh_vou_status status; 77 enum sh_vou_status status;
78 struct mutex fop_lock;
78}; 79};
79 80
80struct sh_vou_file { 81struct sh_vou_file {
@@ -235,7 +236,7 @@ static void free_buffer(struct videobuf_queue *vq, struct videobuf_buffer *vb)
235 vb->state = VIDEOBUF_NEEDS_INIT; 236 vb->state = VIDEOBUF_NEEDS_INIT;
236} 237}
237 238
238/* Locking: caller holds vq->vb_lock mutex */ 239/* Locking: caller holds fop_lock mutex */
239static int sh_vou_buf_setup(struct videobuf_queue *vq, unsigned int *count, 240static int sh_vou_buf_setup(struct videobuf_queue *vq, unsigned int *count,
240 unsigned int *size) 241 unsigned int *size)
241{ 242{
@@ -257,7 +258,7 @@ static int sh_vou_buf_setup(struct videobuf_queue *vq, unsigned int *count,
257 return 0; 258 return 0;
258} 259}
259 260
260/* Locking: caller holds vq->vb_lock mutex */ 261/* Locking: caller holds fop_lock mutex */
261static int sh_vou_buf_prepare(struct videobuf_queue *vq, 262static int sh_vou_buf_prepare(struct videobuf_queue *vq,
262 struct videobuf_buffer *vb, 263 struct videobuf_buffer *vb,
263 enum v4l2_field field) 264 enum v4l2_field field)
@@ -306,7 +307,7 @@ static int sh_vou_buf_prepare(struct videobuf_queue *vq,
306 return 0; 307 return 0;
307} 308}
308 309
309/* Locking: caller holds vq->vb_lock mutex and vq->irqlock spinlock */ 310/* Locking: caller holds fop_lock mutex and vq->irqlock spinlock */
310static void sh_vou_buf_queue(struct videobuf_queue *vq, 311static void sh_vou_buf_queue(struct videobuf_queue *vq,
311 struct videobuf_buffer *vb) 312 struct videobuf_buffer *vb)
312{ 313{
@@ -1190,7 +1191,7 @@ static int sh_vou_open(struct file *file)
1190 V4L2_BUF_TYPE_VIDEO_OUTPUT, 1191 V4L2_BUF_TYPE_VIDEO_OUTPUT,
1191 V4L2_FIELD_NONE, 1192 V4L2_FIELD_NONE,
1192 sizeof(struct videobuf_buffer), vdev, 1193 sizeof(struct videobuf_buffer), vdev,
1193 NULL); 1194 &vou_dev->fop_lock);
1194 1195
1195 return 0; 1196 return 0;
1196} 1197}
@@ -1292,7 +1293,7 @@ static const struct v4l2_file_operations sh_vou_fops = {
1292 .owner = THIS_MODULE, 1293 .owner = THIS_MODULE,
1293 .open = sh_vou_open, 1294 .open = sh_vou_open,
1294 .release = sh_vou_release, 1295 .release = sh_vou_release,
1295 .ioctl = video_ioctl2, 1296 .unlocked_ioctl = video_ioctl2,
1296 .mmap = sh_vou_mmap, 1297 .mmap = sh_vou_mmap,
1297 .poll = sh_vou_poll, 1298 .poll = sh_vou_poll,
1298}; 1299};
@@ -1331,6 +1332,7 @@ static int __devinit sh_vou_probe(struct platform_device *pdev)
1331 1332
1332 INIT_LIST_HEAD(&vou_dev->queue); 1333 INIT_LIST_HEAD(&vou_dev->queue);
1333 spin_lock_init(&vou_dev->lock); 1334 spin_lock_init(&vou_dev->lock);
1335 mutex_init(&vou_dev->fop_lock);
1334 atomic_set(&vou_dev->use_count, 0); 1336 atomic_set(&vou_dev->use_count, 0);
1335 vou_dev->pdata = vou_pdata; 1337 vou_dev->pdata = vou_pdata;
1336 vou_dev->status = SH_VOU_IDLE; 1338 vou_dev->status = SH_VOU_IDLE;
@@ -1388,6 +1390,7 @@ static int __devinit sh_vou_probe(struct platform_device *pdev)
1388 vdev->tvnorms |= V4L2_STD_PAL; 1390 vdev->tvnorms |= V4L2_STD_PAL;
1389 vdev->v4l2_dev = &vou_dev->v4l2_dev; 1391 vdev->v4l2_dev = &vou_dev->v4l2_dev;
1390 vdev->release = video_device_release; 1392 vdev->release = video_device_release;
1393 vdev->lock = &vou_dev->fop_lock;
1391 1394
1392 vou_dev->vdev = vdev; 1395 vou_dev->vdev = vdev;
1393 video_set_drvdata(vdev, vou_dev); 1396 video_set_drvdata(vdev, vou_dev);
diff --git a/drivers/media/video/sn9c102/sn9c102_core.c b/drivers/media/video/sn9c102/sn9c102_core.c
index 28e19daadec9..f49fbfb7dc13 100644
--- a/drivers/media/video/sn9c102/sn9c102_core.c
+++ b/drivers/media/video/sn9c102/sn9c102_core.c
@@ -3238,7 +3238,7 @@ static const struct v4l2_file_operations sn9c102_fops = {
3238 .owner = THIS_MODULE, 3238 .owner = THIS_MODULE,
3239 .open = sn9c102_open, 3239 .open = sn9c102_open,
3240 .release = sn9c102_release, 3240 .release = sn9c102_release,
3241 .ioctl = sn9c102_ioctl, 3241 .unlocked_ioctl = sn9c102_ioctl,
3242 .read = sn9c102_read, 3242 .read = sn9c102_read,
3243 .poll = sn9c102_poll, 3243 .poll = sn9c102_poll,
3244 .mmap = sn9c102_mmap, 3244 .mmap = sn9c102_mmap,
diff --git a/drivers/media/video/soc_camera.c b/drivers/media/video/soc_camera.c
index 335120c2021b..052bd6dfa5a7 100644
--- a/drivers/media/video/soc_camera.c
+++ b/drivers/media/video/soc_camera.c
@@ -405,13 +405,13 @@ static int soc_camera_open(struct file *file)
405 ret = soc_camera_set_fmt(icd, &f); 405 ret = soc_camera_set_fmt(icd, &f);
406 if (ret < 0) 406 if (ret < 0)
407 goto esfmt; 407 goto esfmt;
408
409 ici->ops->init_videobuf(&icd->vb_vidq, icd);
408 } 410 }
409 411
410 file->private_data = icd; 412 file->private_data = icd;
411 dev_dbg(&icd->dev, "camera device open\n"); 413 dev_dbg(&icd->dev, "camera device open\n");
412 414
413 ici->ops->init_videobuf(&icd->vb_vidq, icd);
414
415 mutex_unlock(&icd->video_lock); 415 mutex_unlock(&icd->video_lock);
416 416
417 return 0; 417 return 0;
diff --git a/drivers/media/video/uvc/uvc_ctrl.c b/drivers/media/video/uvc/uvc_ctrl.c
index f169f7736677..59f8a9ad3796 100644
--- a/drivers/media/video/uvc/uvc_ctrl.c
+++ b/drivers/media/video/uvc/uvc_ctrl.c
@@ -785,7 +785,7 @@ static void __uvc_find_control(struct uvc_entity *entity, __u32 v4l2_id,
785 } 785 }
786} 786}
787 787
788struct uvc_control *uvc_find_control(struct uvc_video_chain *chain, 788static struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
789 __u32 v4l2_id, struct uvc_control_mapping **mapping) 789 __u32 v4l2_id, struct uvc_control_mapping **mapping)
790{ 790{
791 struct uvc_control *ctrl = NULL; 791 struct uvc_control *ctrl = NULL;
@@ -944,6 +944,52 @@ done:
944 return ret; 944 return ret;
945} 945}
946 946
947/*
948 * Mapping V4L2 controls to UVC controls can be straighforward if done well.
949 * Most of the UVC controls exist in V4L2, and can be mapped directly. Some
950 * must be grouped (for instance the Red Balance, Blue Balance and Do White
951 * Balance V4L2 controls use the White Balance Component UVC control) or
952 * otherwise translated. The approach we take here is to use a translation
953 * table for the controls that can be mapped directly, and handle the others
954 * manually.
955 */
956int uvc_query_v4l2_menu(struct uvc_video_chain *chain,
957 struct v4l2_querymenu *query_menu)
958{
959 struct uvc_menu_info *menu_info;
960 struct uvc_control_mapping *mapping;
961 struct uvc_control *ctrl;
962 u32 index = query_menu->index;
963 u32 id = query_menu->id;
964 int ret;
965
966 memset(query_menu, 0, sizeof(*query_menu));
967 query_menu->id = id;
968 query_menu->index = index;
969
970 ret = mutex_lock_interruptible(&chain->ctrl_mutex);
971 if (ret < 0)
972 return -ERESTARTSYS;
973
974 ctrl = uvc_find_control(chain, query_menu->id, &mapping);
975 if (ctrl == NULL || mapping->v4l2_type != V4L2_CTRL_TYPE_MENU) {
976 ret = -EINVAL;
977 goto done;
978 }
979
980 if (query_menu->index >= mapping->menu_count) {
981 ret = -EINVAL;
982 goto done;
983 }
984
985 menu_info = &mapping->menu_info[query_menu->index];
986 strlcpy(query_menu->name, menu_info->name, sizeof query_menu->name);
987
988done:
989 mutex_unlock(&chain->ctrl_mutex);
990 return ret;
991}
992
947 993
948/* -------------------------------------------------------------------------- 994/* --------------------------------------------------------------------------
949 * Control transactions 995 * Control transactions
diff --git a/drivers/media/video/uvc/uvc_queue.c b/drivers/media/video/uvc/uvc_queue.c
index ed6d5449741c..f14581bd707f 100644
--- a/drivers/media/video/uvc/uvc_queue.c
+++ b/drivers/media/video/uvc/uvc_queue.c
@@ -90,6 +90,39 @@ void uvc_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type,
90} 90}
91 91
92/* 92/*
93 * Free the video buffers.
94 *
95 * This function must be called with the queue lock held.
96 */
97static int __uvc_free_buffers(struct uvc_video_queue *queue)
98{
99 unsigned int i;
100
101 for (i = 0; i < queue->count; ++i) {
102 if (queue->buffer[i].vma_use_count != 0)
103 return -EBUSY;
104 }
105
106 if (queue->count) {
107 vfree(queue->mem);
108 queue->count = 0;
109 }
110
111 return 0;
112}
113
114int uvc_free_buffers(struct uvc_video_queue *queue)
115{
116 int ret;
117
118 mutex_lock(&queue->mutex);
119 ret = __uvc_free_buffers(queue);
120 mutex_unlock(&queue->mutex);
121
122 return ret;
123}
124
125/*
93 * Allocate the video buffers. 126 * Allocate the video buffers.
94 * 127 *
95 * Pages are reserved to make sure they will not be swapped, as they will be 128 * Pages are reserved to make sure they will not be swapped, as they will be
@@ -110,7 +143,7 @@ int uvc_alloc_buffers(struct uvc_video_queue *queue, unsigned int nbuffers,
110 143
111 mutex_lock(&queue->mutex); 144 mutex_lock(&queue->mutex);
112 145
113 if ((ret = uvc_free_buffers(queue)) < 0) 146 if ((ret = __uvc_free_buffers(queue)) < 0)
114 goto done; 147 goto done;
115 148
116 /* Bail out if no buffers should be allocated. */ 149 /* Bail out if no buffers should be allocated. */
@@ -152,28 +185,6 @@ done:
152} 185}
153 186
154/* 187/*
155 * Free the video buffers.
156 *
157 * This function must be called with the queue lock held.
158 */
159int uvc_free_buffers(struct uvc_video_queue *queue)
160{
161 unsigned int i;
162
163 for (i = 0; i < queue->count; ++i) {
164 if (queue->buffer[i].vma_use_count != 0)
165 return -EBUSY;
166 }
167
168 if (queue->count) {
169 vfree(queue->mem);
170 queue->count = 0;
171 }
172
173 return 0;
174}
175
176/*
177 * Check if buffers have been allocated. 188 * Check if buffers have been allocated.
178 */ 189 */
179int uvc_queue_allocated(struct uvc_video_queue *queue) 190int uvc_queue_allocated(struct uvc_video_queue *queue)
@@ -369,6 +380,82 @@ done:
369} 380}
370 381
371/* 382/*
383 * VMA operations.
384 */
385static void uvc_vm_open(struct vm_area_struct *vma)
386{
387 struct uvc_buffer *buffer = vma->vm_private_data;
388 buffer->vma_use_count++;
389}
390
391static void uvc_vm_close(struct vm_area_struct *vma)
392{
393 struct uvc_buffer *buffer = vma->vm_private_data;
394 buffer->vma_use_count--;
395}
396
397static const struct vm_operations_struct uvc_vm_ops = {
398 .open = uvc_vm_open,
399 .close = uvc_vm_close,
400};
401
402/*
403 * Memory-map a video buffer.
404 *
405 * This function implements video buffers memory mapping and is intended to be
406 * used by the device mmap handler.
407 */
408int uvc_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
409{
410 struct uvc_buffer *uninitialized_var(buffer);
411 struct page *page;
412 unsigned long addr, start, size;
413 unsigned int i;
414 int ret = 0;
415
416 start = vma->vm_start;
417 size = vma->vm_end - vma->vm_start;
418
419 mutex_lock(&queue->mutex);
420
421 for (i = 0; i < queue->count; ++i) {
422 buffer = &queue->buffer[i];
423 if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
424 break;
425 }
426
427 if (i == queue->count || size != queue->buf_size) {
428 ret = -EINVAL;
429 goto done;
430 }
431
432 /*
433 * VM_IO marks the area as being an mmaped region for I/O to a
434 * device. It also prevents the region from being core dumped.
435 */
436 vma->vm_flags |= VM_IO;
437
438 addr = (unsigned long)queue->mem + buffer->buf.m.offset;
439 while (size > 0) {
440 page = vmalloc_to_page((void *)addr);
441 if ((ret = vm_insert_page(vma, start, page)) < 0)
442 goto done;
443
444 start += PAGE_SIZE;
445 addr += PAGE_SIZE;
446 size -= PAGE_SIZE;
447 }
448
449 vma->vm_ops = &uvc_vm_ops;
450 vma->vm_private_data = buffer;
451 uvc_vm_open(vma);
452
453done:
454 mutex_unlock(&queue->mutex);
455 return ret;
456}
457
458/*
372 * Poll the video queue. 459 * Poll the video queue.
373 * 460 *
374 * This function implements video queue polling and is intended to be used by 461 * This function implements video queue polling and is intended to be used by
diff --git a/drivers/media/video/uvc/uvc_v4l2.c b/drivers/media/video/uvc/uvc_v4l2.c
index 6d15de9b5204..8cf61e8a634f 100644
--- a/drivers/media/video/uvc/uvc_v4l2.c
+++ b/drivers/media/video/uvc/uvc_v4l2.c
@@ -101,40 +101,6 @@ done:
101 */ 101 */
102 102
103/* 103/*
104 * Mapping V4L2 controls to UVC controls can be straighforward if done well.
105 * Most of the UVC controls exist in V4L2, and can be mapped directly. Some
106 * must be grouped (for instance the Red Balance, Blue Balance and Do White
107 * Balance V4L2 controls use the White Balance Component UVC control) or
108 * otherwise translated. The approach we take here is to use a translation
109 * table for the controls that can be mapped directly, and handle the others
110 * manually.
111 */
112static int uvc_v4l2_query_menu(struct uvc_video_chain *chain,
113 struct v4l2_querymenu *query_menu)
114{
115 struct uvc_menu_info *menu_info;
116 struct uvc_control_mapping *mapping;
117 struct uvc_control *ctrl;
118 u32 index = query_menu->index;
119 u32 id = query_menu->id;
120
121 ctrl = uvc_find_control(chain, query_menu->id, &mapping);
122 if (ctrl == NULL || mapping->v4l2_type != V4L2_CTRL_TYPE_MENU)
123 return -EINVAL;
124
125 if (query_menu->index >= mapping->menu_count)
126 return -EINVAL;
127
128 memset(query_menu, 0, sizeof(*query_menu));
129 query_menu->id = id;
130 query_menu->index = index;
131
132 menu_info = &mapping->menu_info[query_menu->index];
133 strlcpy(query_menu->name, menu_info->name, sizeof query_menu->name);
134 return 0;
135}
136
137/*
138 * Find the frame interval closest to the requested frame interval for the 104 * Find the frame interval closest to the requested frame interval for the
139 * given frame format and size. This should be done by the device as part of 105 * given frame format and size. This should be done by the device as part of
140 * the Video Probe and Commit negotiation, but some hardware don't implement 106 * the Video Probe and Commit negotiation, but some hardware don't implement
@@ -260,12 +226,14 @@ static int uvc_v4l2_try_format(struct uvc_streaming *stream,
260 * developers test their webcams with the Linux driver as well as with 226 * developers test their webcams with the Linux driver as well as with
261 * the Windows driver). 227 * the Windows driver).
262 */ 228 */
229 mutex_lock(&stream->mutex);
263 if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS) 230 if (stream->dev->quirks & UVC_QUIRK_PROBE_EXTRAFIELDS)
264 probe->dwMaxVideoFrameSize = 231 probe->dwMaxVideoFrameSize =
265 stream->ctrl.dwMaxVideoFrameSize; 232 stream->ctrl.dwMaxVideoFrameSize;
266 233
267 /* Probe the device. */ 234 /* Probe the device. */
268 ret = uvc_probe_video(stream, probe); 235 ret = uvc_probe_video(stream, probe);
236 mutex_unlock(&stream->mutex);
269 if (ret < 0) 237 if (ret < 0)
270 goto done; 238 goto done;
271 239
@@ -289,14 +257,21 @@ done:
289static int uvc_v4l2_get_format(struct uvc_streaming *stream, 257static int uvc_v4l2_get_format(struct uvc_streaming *stream,
290 struct v4l2_format *fmt) 258 struct v4l2_format *fmt)
291{ 259{
292 struct uvc_format *format = stream->cur_format; 260 struct uvc_format *format;
293 struct uvc_frame *frame = stream->cur_frame; 261 struct uvc_frame *frame;
262 int ret = 0;
294 263
295 if (fmt->type != stream->type) 264 if (fmt->type != stream->type)
296 return -EINVAL; 265 return -EINVAL;
297 266
298 if (format == NULL || frame == NULL) 267 mutex_lock(&stream->mutex);
299 return -EINVAL; 268 format = stream->cur_format;
269 frame = stream->cur_frame;
270
271 if (format == NULL || frame == NULL) {
272 ret = -EINVAL;
273 goto done;
274 }
300 275
301 fmt->fmt.pix.pixelformat = format->fcc; 276 fmt->fmt.pix.pixelformat = format->fcc;
302 fmt->fmt.pix.width = frame->wWidth; 277 fmt->fmt.pix.width = frame->wWidth;
@@ -307,7 +282,9 @@ static int uvc_v4l2_get_format(struct uvc_streaming *stream,
307 fmt->fmt.pix.colorspace = format->colorspace; 282 fmt->fmt.pix.colorspace = format->colorspace;
308 fmt->fmt.pix.priv = 0; 283 fmt->fmt.pix.priv = 0;
309 284
310 return 0; 285done:
286 mutex_unlock(&stream->mutex);
287 return ret;
311} 288}
312 289
313static int uvc_v4l2_set_format(struct uvc_streaming *stream, 290static int uvc_v4l2_set_format(struct uvc_streaming *stream,
@@ -321,18 +298,24 @@ static int uvc_v4l2_set_format(struct uvc_streaming *stream,
321 if (fmt->type != stream->type) 298 if (fmt->type != stream->type)
322 return -EINVAL; 299 return -EINVAL;
323 300
324 if (uvc_queue_allocated(&stream->queue))
325 return -EBUSY;
326
327 ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame); 301 ret = uvc_v4l2_try_format(stream, fmt, &probe, &format, &frame);
328 if (ret < 0) 302 if (ret < 0)
329 return ret; 303 return ret;
330 304
305 mutex_lock(&stream->mutex);
306
307 if (uvc_queue_allocated(&stream->queue)) {
308 ret = -EBUSY;
309 goto done;
310 }
311
331 memcpy(&stream->ctrl, &probe, sizeof probe); 312 memcpy(&stream->ctrl, &probe, sizeof probe);
332 stream->cur_format = format; 313 stream->cur_format = format;
333 stream->cur_frame = frame; 314 stream->cur_frame = frame;
334 315
335 return 0; 316done:
317 mutex_unlock(&stream->mutex);
318 return ret;
336} 319}
337 320
338static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream, 321static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
@@ -343,7 +326,10 @@ static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
343 if (parm->type != stream->type) 326 if (parm->type != stream->type)
344 return -EINVAL; 327 return -EINVAL;
345 328
329 mutex_lock(&stream->mutex);
346 numerator = stream->ctrl.dwFrameInterval; 330 numerator = stream->ctrl.dwFrameInterval;
331 mutex_unlock(&stream->mutex);
332
347 denominator = 10000000; 333 denominator = 10000000;
348 uvc_simplify_fraction(&numerator, &denominator, 8, 333); 334 uvc_simplify_fraction(&numerator, &denominator, 8, 333);
349 335
@@ -370,7 +356,6 @@ static int uvc_v4l2_get_streamparm(struct uvc_streaming *stream,
370static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream, 356static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
371 struct v4l2_streamparm *parm) 357 struct v4l2_streamparm *parm)
372{ 358{
373 struct uvc_frame *frame = stream->cur_frame;
374 struct uvc_streaming_control probe; 359 struct uvc_streaming_control probe;
375 struct v4l2_fract timeperframe; 360 struct v4l2_fract timeperframe;
376 uint32_t interval; 361 uint32_t interval;
@@ -379,28 +364,36 @@ static int uvc_v4l2_set_streamparm(struct uvc_streaming *stream,
379 if (parm->type != stream->type) 364 if (parm->type != stream->type)
380 return -EINVAL; 365 return -EINVAL;
381 366
382 if (uvc_queue_streaming(&stream->queue))
383 return -EBUSY;
384
385 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) 367 if (parm->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
386 timeperframe = parm->parm.capture.timeperframe; 368 timeperframe = parm->parm.capture.timeperframe;
387 else 369 else
388 timeperframe = parm->parm.output.timeperframe; 370 timeperframe = parm->parm.output.timeperframe;
389 371
390 memcpy(&probe, &stream->ctrl, sizeof probe);
391 interval = uvc_fraction_to_interval(timeperframe.numerator, 372 interval = uvc_fraction_to_interval(timeperframe.numerator,
392 timeperframe.denominator); 373 timeperframe.denominator);
393
394 uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n", 374 uvc_trace(UVC_TRACE_FORMAT, "Setting frame interval to %u/%u (%u).\n",
395 timeperframe.numerator, timeperframe.denominator, interval); 375 timeperframe.numerator, timeperframe.denominator, interval);
396 probe.dwFrameInterval = uvc_try_frame_interval(frame, interval); 376
377 mutex_lock(&stream->mutex);
378
379 if (uvc_queue_streaming(&stream->queue)) {
380 mutex_unlock(&stream->mutex);
381 return -EBUSY;
382 }
383
384 memcpy(&probe, &stream->ctrl, sizeof probe);
385 probe.dwFrameInterval =
386 uvc_try_frame_interval(stream->cur_frame, interval);
397 387
398 /* Probe the device with the new settings. */ 388 /* Probe the device with the new settings. */
399 ret = uvc_probe_video(stream, &probe); 389 ret = uvc_probe_video(stream, &probe);
400 if (ret < 0) 390 if (ret < 0) {
391 mutex_unlock(&stream->mutex);
401 return ret; 392 return ret;
393 }
402 394
403 memcpy(&stream->ctrl, &probe, sizeof probe); 395 memcpy(&stream->ctrl, &probe, sizeof probe);
396 mutex_unlock(&stream->mutex);
404 397
405 /* Return the actual frame period. */ 398 /* Return the actual frame period. */
406 timeperframe.numerator = probe.dwFrameInterval; 399 timeperframe.numerator = probe.dwFrameInterval;
@@ -528,11 +521,9 @@ static int uvc_v4l2_release(struct file *file)
528 if (uvc_has_privileges(handle)) { 521 if (uvc_has_privileges(handle)) {
529 uvc_video_enable(stream, 0); 522 uvc_video_enable(stream, 0);
530 523
531 mutex_lock(&stream->queue.mutex);
532 if (uvc_free_buffers(&stream->queue) < 0) 524 if (uvc_free_buffers(&stream->queue) < 0)
533 uvc_printk(KERN_ERR, "uvc_v4l2_release: Unable to " 525 uvc_printk(KERN_ERR, "uvc_v4l2_release: Unable to "
534 "free buffers.\n"); 526 "free buffers.\n");
535 mutex_unlock(&stream->queue.mutex);
536 } 527 }
537 528
538 /* Release the file handle. */ 529 /* Release the file handle. */
@@ -624,7 +615,7 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
624 } 615 }
625 616
626 case VIDIOC_QUERYMENU: 617 case VIDIOC_QUERYMENU:
627 return uvc_v4l2_query_menu(chain, arg); 618 return uvc_query_v4l2_menu(chain, arg);
628 619
629 case VIDIOC_G_EXT_CTRLS: 620 case VIDIOC_G_EXT_CTRLS:
630 { 621 {
@@ -905,15 +896,17 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
905 case VIDIOC_CROPCAP: 896 case VIDIOC_CROPCAP:
906 { 897 {
907 struct v4l2_cropcap *ccap = arg; 898 struct v4l2_cropcap *ccap = arg;
908 struct uvc_frame *frame = stream->cur_frame;
909 899
910 if (ccap->type != stream->type) 900 if (ccap->type != stream->type)
911 return -EINVAL; 901 return -EINVAL;
912 902
913 ccap->bounds.left = 0; 903 ccap->bounds.left = 0;
914 ccap->bounds.top = 0; 904 ccap->bounds.top = 0;
915 ccap->bounds.width = frame->wWidth; 905
916 ccap->bounds.height = frame->wHeight; 906 mutex_lock(&stream->mutex);
907 ccap->bounds.width = stream->cur_frame->wWidth;
908 ccap->bounds.height = stream->cur_frame->wHeight;
909 mutex_unlock(&stream->mutex);
917 910
918 ccap->defrect = ccap->bounds; 911 ccap->defrect = ccap->bounds;
919 912
@@ -930,8 +923,6 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
930 case VIDIOC_REQBUFS: 923 case VIDIOC_REQBUFS:
931 { 924 {
932 struct v4l2_requestbuffers *rb = arg; 925 struct v4l2_requestbuffers *rb = arg;
933 unsigned int bufsize =
934 stream->ctrl.dwMaxVideoFrameSize;
935 926
936 if (rb->type != stream->type || 927 if (rb->type != stream->type ||
937 rb->memory != V4L2_MEMORY_MMAP) 928 rb->memory != V4L2_MEMORY_MMAP)
@@ -940,7 +931,10 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
940 if ((ret = uvc_acquire_privileges(handle)) < 0) 931 if ((ret = uvc_acquire_privileges(handle)) < 0)
941 return ret; 932 return ret;
942 933
943 ret = uvc_alloc_buffers(&stream->queue, rb->count, bufsize); 934 mutex_lock(&stream->mutex);
935 ret = uvc_alloc_buffers(&stream->queue, rb->count,
936 stream->ctrl.dwMaxVideoFrameSize);
937 mutex_unlock(&stream->mutex);
944 if (ret < 0) 938 if (ret < 0)
945 return ret; 939 return ret;
946 940
@@ -988,7 +982,9 @@ static long uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
988 if (!uvc_has_privileges(handle)) 982 if (!uvc_has_privileges(handle))
989 return -EBUSY; 983 return -EBUSY;
990 984
985 mutex_lock(&stream->mutex);
991 ret = uvc_video_enable(stream, 1); 986 ret = uvc_video_enable(stream, 1);
987 mutex_unlock(&stream->mutex);
992 if (ret < 0) 988 if (ret < 0)
993 return ret; 989 return ret;
994 break; 990 break;
@@ -1068,79 +1064,14 @@ static ssize_t uvc_v4l2_read(struct file *file, char __user *data,
1068 return -EINVAL; 1064 return -EINVAL;
1069} 1065}
1070 1066
1071/*
1072 * VMA operations.
1073 */
1074static void uvc_vm_open(struct vm_area_struct *vma)
1075{
1076 struct uvc_buffer *buffer = vma->vm_private_data;
1077 buffer->vma_use_count++;
1078}
1079
1080static void uvc_vm_close(struct vm_area_struct *vma)
1081{
1082 struct uvc_buffer *buffer = vma->vm_private_data;
1083 buffer->vma_use_count--;
1084}
1085
1086static const struct vm_operations_struct uvc_vm_ops = {
1087 .open = uvc_vm_open,
1088 .close = uvc_vm_close,
1089};
1090
1091static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma) 1067static int uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
1092{ 1068{
1093 struct uvc_fh *handle = file->private_data; 1069 struct uvc_fh *handle = file->private_data;
1094 struct uvc_streaming *stream = handle->stream; 1070 struct uvc_streaming *stream = handle->stream;
1095 struct uvc_video_queue *queue = &stream->queue;
1096 struct uvc_buffer *uninitialized_var(buffer);
1097 struct page *page;
1098 unsigned long addr, start, size;
1099 unsigned int i;
1100 int ret = 0;
1101 1071
1102 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n"); 1072 uvc_trace(UVC_TRACE_CALLS, "uvc_v4l2_mmap\n");
1103 1073
1104 start = vma->vm_start; 1074 return uvc_queue_mmap(&stream->queue, vma);
1105 size = vma->vm_end - vma->vm_start;
1106
1107 mutex_lock(&queue->mutex);
1108
1109 for (i = 0; i < queue->count; ++i) {
1110 buffer = &queue->buffer[i];
1111 if ((buffer->buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
1112 break;
1113 }
1114
1115 if (i == queue->count || size != queue->buf_size) {
1116 ret = -EINVAL;
1117 goto done;
1118 }
1119
1120 /*
1121 * VM_IO marks the area as being an mmaped region for I/O to a
1122 * device. It also prevents the region from being core dumped.
1123 */
1124 vma->vm_flags |= VM_IO;
1125
1126 addr = (unsigned long)queue->mem + buffer->buf.m.offset;
1127 while (size > 0) {
1128 page = vmalloc_to_page((void *)addr);
1129 if ((ret = vm_insert_page(vma, start, page)) < 0)
1130 goto done;
1131
1132 start += PAGE_SIZE;
1133 addr += PAGE_SIZE;
1134 size -= PAGE_SIZE;
1135 }
1136
1137 vma->vm_ops = &uvc_vm_ops;
1138 vma->vm_private_data = buffer;
1139 uvc_vm_open(vma);
1140
1141done:
1142 mutex_unlock(&queue->mutex);
1143 return ret;
1144} 1075}
1145 1076
1146static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait) 1077static unsigned int uvc_v4l2_poll(struct file *file, poll_table *wait)
@@ -1157,7 +1088,7 @@ const struct v4l2_file_operations uvc_fops = {
1157 .owner = THIS_MODULE, 1088 .owner = THIS_MODULE,
1158 .open = uvc_v4l2_open, 1089 .open = uvc_v4l2_open,
1159 .release = uvc_v4l2_release, 1090 .release = uvc_v4l2_release,
1160 .ioctl = uvc_v4l2_ioctl, 1091 .unlocked_ioctl = uvc_v4l2_ioctl,
1161 .read = uvc_v4l2_read, 1092 .read = uvc_v4l2_read,
1162 .mmap = uvc_v4l2_mmap, 1093 .mmap = uvc_v4l2_mmap,
1163 .poll = uvc_v4l2_poll, 1094 .poll = uvc_v4l2_poll,
diff --git a/drivers/media/video/uvc/uvc_video.c b/drivers/media/video/uvc/uvc_video.c
index 5555f0102838..5673d673504b 100644
--- a/drivers/media/video/uvc/uvc_video.c
+++ b/drivers/media/video/uvc/uvc_video.c
@@ -293,8 +293,6 @@ int uvc_probe_video(struct uvc_streaming *stream,
293 unsigned int i; 293 unsigned int i;
294 int ret; 294 int ret;
295 295
296 mutex_lock(&stream->mutex);
297
298 /* Perform probing. The device should adjust the requested values 296 /* Perform probing. The device should adjust the requested values
299 * according to its capabilities. However, some devices, namely the 297 * according to its capabilities. However, some devices, namely the
300 * first generation UVC Logitech webcams, don't implement the Video 298 * first generation UVC Logitech webcams, don't implement the Video
@@ -346,7 +344,6 @@ int uvc_probe_video(struct uvc_streaming *stream,
346 } 344 }
347 345
348done: 346done:
349 mutex_unlock(&stream->mutex);
350 return ret; 347 return ret;
351} 348}
352 349
diff --git a/drivers/media/video/uvc/uvcvideo.h b/drivers/media/video/uvc/uvcvideo.h
index d97cf6d6a4f9..45f01e7e13d2 100644
--- a/drivers/media/video/uvc/uvcvideo.h
+++ b/drivers/media/video/uvc/uvcvideo.h
@@ -436,7 +436,9 @@ struct uvc_streaming {
436 struct uvc_streaming_control ctrl; 436 struct uvc_streaming_control ctrl;
437 struct uvc_format *cur_format; 437 struct uvc_format *cur_format;
438 struct uvc_frame *cur_frame; 438 struct uvc_frame *cur_frame;
439 439 /* Protect access to ctrl, cur_format, cur_frame and hardware video
440 * probe control.
441 */
440 struct mutex mutex; 442 struct mutex mutex;
441 443
442 unsigned int frozen : 1; 444 unsigned int frozen : 1;
@@ -574,6 +576,8 @@ extern int uvc_queue_enable(struct uvc_video_queue *queue, int enable);
574extern void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect); 576extern void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect);
575extern struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue, 577extern struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
576 struct uvc_buffer *buf); 578 struct uvc_buffer *buf);
579extern int uvc_queue_mmap(struct uvc_video_queue *queue,
580 struct vm_area_struct *vma);
577extern unsigned int uvc_queue_poll(struct uvc_video_queue *queue, 581extern unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
578 struct file *file, poll_table *wait); 582 struct file *file, poll_table *wait);
579extern int uvc_queue_allocated(struct uvc_video_queue *queue); 583extern int uvc_queue_allocated(struct uvc_video_queue *queue);
@@ -606,10 +610,10 @@ extern int uvc_status_suspend(struct uvc_device *dev);
606extern int uvc_status_resume(struct uvc_device *dev); 610extern int uvc_status_resume(struct uvc_device *dev);
607 611
608/* Controls */ 612/* Controls */
609extern struct uvc_control *uvc_find_control(struct uvc_video_chain *chain,
610 __u32 v4l2_id, struct uvc_control_mapping **mapping);
611extern int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain, 613extern int uvc_query_v4l2_ctrl(struct uvc_video_chain *chain,
612 struct v4l2_queryctrl *v4l2_ctrl); 614 struct v4l2_queryctrl *v4l2_ctrl);
615extern int uvc_query_v4l2_menu(struct uvc_video_chain *chain,
616 struct v4l2_querymenu *query_menu);
613 617
614extern int uvc_ctrl_add_mapping(struct uvc_video_chain *chain, 618extern int uvc_ctrl_add_mapping(struct uvc_video_chain *chain,
615 const struct uvc_control_mapping *mapping); 619 const struct uvc_control_mapping *mapping);
diff --git a/drivers/media/video/v4l2-dev.c b/drivers/media/video/v4l2-dev.c
index 03f7f4670e9b..359e23290a7e 100644
--- a/drivers/media/video/v4l2-dev.c
+++ b/drivers/media/video/v4l2-dev.c
@@ -186,12 +186,12 @@ static ssize_t v4l2_read(struct file *filp, char __user *buf,
186 size_t sz, loff_t *off) 186 size_t sz, loff_t *off)
187{ 187{
188 struct video_device *vdev = video_devdata(filp); 188 struct video_device *vdev = video_devdata(filp);
189 int ret = -EIO; 189 int ret = -ENODEV;
190 190
191 if (!vdev->fops->read) 191 if (!vdev->fops->read)
192 return -EINVAL; 192 return -EINVAL;
193 if (vdev->lock) 193 if (vdev->lock && mutex_lock_interruptible(vdev->lock))
194 mutex_lock(vdev->lock); 194 return -ERESTARTSYS;
195 if (video_is_registered(vdev)) 195 if (video_is_registered(vdev))
196 ret = vdev->fops->read(filp, buf, sz, off); 196 ret = vdev->fops->read(filp, buf, sz, off);
197 if (vdev->lock) 197 if (vdev->lock)
@@ -203,12 +203,12 @@ static ssize_t v4l2_write(struct file *filp, const char __user *buf,
203 size_t sz, loff_t *off) 203 size_t sz, loff_t *off)
204{ 204{
205 struct video_device *vdev = video_devdata(filp); 205 struct video_device *vdev = video_devdata(filp);
206 int ret = -EIO; 206 int ret = -ENODEV;
207 207
208 if (!vdev->fops->write) 208 if (!vdev->fops->write)
209 return -EINVAL; 209 return -EINVAL;
210 if (vdev->lock) 210 if (vdev->lock && mutex_lock_interruptible(vdev->lock))
211 mutex_lock(vdev->lock); 211 return -ERESTARTSYS;
212 if (video_is_registered(vdev)) 212 if (video_is_registered(vdev))
213 ret = vdev->fops->write(filp, buf, sz, off); 213 ret = vdev->fops->write(filp, buf, sz, off);
214 if (vdev->lock) 214 if (vdev->lock)
@@ -219,10 +219,10 @@ static ssize_t v4l2_write(struct file *filp, const char __user *buf,
219static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll) 219static unsigned int v4l2_poll(struct file *filp, struct poll_table_struct *poll)
220{ 220{
221 struct video_device *vdev = video_devdata(filp); 221 struct video_device *vdev = video_devdata(filp);
222 int ret = DEFAULT_POLLMASK; 222 int ret = POLLERR | POLLHUP;
223 223
224 if (!vdev->fops->poll) 224 if (!vdev->fops->poll)
225 return ret; 225 return DEFAULT_POLLMASK;
226 if (vdev->lock) 226 if (vdev->lock)
227 mutex_lock(vdev->lock); 227 mutex_lock(vdev->lock);
228 if (video_is_registered(vdev)) 228 if (video_is_registered(vdev))
@@ -238,20 +238,45 @@ static long v4l2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
238 int ret = -ENODEV; 238 int ret = -ENODEV;
239 239
240 if (vdev->fops->unlocked_ioctl) { 240 if (vdev->fops->unlocked_ioctl) {
241 if (vdev->lock) 241 if (vdev->lock && mutex_lock_interruptible(vdev->lock))
242 mutex_lock(vdev->lock); 242 return -ERESTARTSYS;
243 if (video_is_registered(vdev)) 243 if (video_is_registered(vdev))
244 ret = vdev->fops->unlocked_ioctl(filp, cmd, arg); 244 ret = vdev->fops->unlocked_ioctl(filp, cmd, arg);
245 if (vdev->lock) 245 if (vdev->lock)
246 mutex_unlock(vdev->lock); 246 mutex_unlock(vdev->lock);
247 } else if (vdev->fops->ioctl) { 247 } else if (vdev->fops->ioctl) {
248 /* TODO: convert all drivers to unlocked_ioctl */ 248 /* This code path is a replacement for the BKL. It is a major
249 * hack but it will have to do for those drivers that are not
250 * yet converted to use unlocked_ioctl.
251 *
252 * There are two options: if the driver implements struct
253 * v4l2_device, then the lock defined there is used to
254 * serialize the ioctls. Otherwise the v4l2 core lock defined
255 * below is used. This lock is really bad since it serializes
256 * completely independent devices.
257 *
258 * Both variants suffer from the same problem: if the driver
259 * sleeps, then it blocks all ioctls since the lock is still
260 * held. This is very common for VIDIOC_DQBUF since that
261 * normally waits for a frame to arrive. As a result any other
262 * ioctl calls will proceed very, very slowly since each call
263 * will have to wait for the VIDIOC_QBUF to finish. Things that
264 * should take 0.01s may now take 10-20 seconds.
265 *
266 * The workaround is to *not* take the lock for VIDIOC_DQBUF.
267 * This actually works OK for videobuf-based drivers, since
268 * videobuf will take its own internal lock.
269 */
249 static DEFINE_MUTEX(v4l2_ioctl_mutex); 270 static DEFINE_MUTEX(v4l2_ioctl_mutex);
271 struct mutex *m = vdev->v4l2_dev ?
272 &vdev->v4l2_dev->ioctl_lock : &v4l2_ioctl_mutex;
250 273
251 mutex_lock(&v4l2_ioctl_mutex); 274 if (cmd != VIDIOC_DQBUF && mutex_lock_interruptible(m))
275 return -ERESTARTSYS;
252 if (video_is_registered(vdev)) 276 if (video_is_registered(vdev))
253 ret = vdev->fops->ioctl(filp, cmd, arg); 277 ret = vdev->fops->ioctl(filp, cmd, arg);
254 mutex_unlock(&v4l2_ioctl_mutex); 278 if (cmd != VIDIOC_DQBUF)
279 mutex_unlock(m);
255 } else 280 } else
256 ret = -ENOTTY; 281 ret = -ENOTTY;
257 282
@@ -265,8 +290,8 @@ static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm)
265 290
266 if (!vdev->fops->mmap) 291 if (!vdev->fops->mmap)
267 return ret; 292 return ret;
268 if (vdev->lock) 293 if (vdev->lock && mutex_lock_interruptible(vdev->lock))
269 mutex_lock(vdev->lock); 294 return -ERESTARTSYS;
270 if (video_is_registered(vdev)) 295 if (video_is_registered(vdev))
271 ret = vdev->fops->mmap(filp, vm); 296 ret = vdev->fops->mmap(filp, vm);
272 if (vdev->lock) 297 if (vdev->lock)
@@ -284,7 +309,7 @@ static int v4l2_open(struct inode *inode, struct file *filp)
284 mutex_lock(&videodev_lock); 309 mutex_lock(&videodev_lock);
285 vdev = video_devdata(filp); 310 vdev = video_devdata(filp);
286 /* return ENODEV if the video device has already been removed. */ 311 /* return ENODEV if the video device has already been removed. */
287 if (vdev == NULL) { 312 if (vdev == NULL || !video_is_registered(vdev)) {
288 mutex_unlock(&videodev_lock); 313 mutex_unlock(&videodev_lock);
289 return -ENODEV; 314 return -ENODEV;
290 } 315 }
@@ -292,8 +317,10 @@ static int v4l2_open(struct inode *inode, struct file *filp)
292 video_get(vdev); 317 video_get(vdev);
293 mutex_unlock(&videodev_lock); 318 mutex_unlock(&videodev_lock);
294 if (vdev->fops->open) { 319 if (vdev->fops->open) {
295 if (vdev->lock) 320 if (vdev->lock && mutex_lock_interruptible(vdev->lock)) {
296 mutex_lock(vdev->lock); 321 ret = -ERESTARTSYS;
322 goto err;
323 }
297 if (video_is_registered(vdev)) 324 if (video_is_registered(vdev))
298 ret = vdev->fops->open(filp); 325 ret = vdev->fops->open(filp);
299 else 326 else
@@ -302,6 +329,7 @@ static int v4l2_open(struct inode *inode, struct file *filp)
302 mutex_unlock(vdev->lock); 329 mutex_unlock(vdev->lock);
303 } 330 }
304 331
332err:
305 /* decrease the refcount in case of an error */ 333 /* decrease the refcount in case of an error */
306 if (ret) 334 if (ret)
307 video_put(vdev); 335 video_put(vdev);
@@ -596,7 +624,12 @@ void video_unregister_device(struct video_device *vdev)
596 if (!vdev || !video_is_registered(vdev)) 624 if (!vdev || !video_is_registered(vdev))
597 return; 625 return;
598 626
627 mutex_lock(&videodev_lock);
628 /* This must be in a critical section to prevent a race with v4l2_open.
629 * Once this bit has been cleared video_get may never be called again.
630 */
599 clear_bit(V4L2_FL_REGISTERED, &vdev->flags); 631 clear_bit(V4L2_FL_REGISTERED, &vdev->flags);
632 mutex_unlock(&videodev_lock);
600 device_unregister(&vdev->dev); 633 device_unregister(&vdev->dev);
601} 634}
602EXPORT_SYMBOL(video_unregister_device); 635EXPORT_SYMBOL(video_unregister_device);
diff --git a/drivers/media/video/v4l2-device.c b/drivers/media/video/v4l2-device.c
index 0b08f96b74a5..7fe6f92af480 100644
--- a/drivers/media/video/v4l2-device.c
+++ b/drivers/media/video/v4l2-device.c
@@ -35,6 +35,7 @@ int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
35 35
36 INIT_LIST_HEAD(&v4l2_dev->subdevs); 36 INIT_LIST_HEAD(&v4l2_dev->subdevs);
37 spin_lock_init(&v4l2_dev->lock); 37 spin_lock_init(&v4l2_dev->lock);
38 mutex_init(&v4l2_dev->ioctl_lock);
38 v4l2_dev->dev = dev; 39 v4l2_dev->dev = dev;
39 if (dev == NULL) { 40 if (dev == NULL) {
40 /* If dev == NULL, then name must be filled in by the caller */ 41 /* If dev == NULL, then name must be filled in by the caller */
diff --git a/drivers/media/video/w9966.c b/drivers/media/video/w9966.c
index 635420d8d84a..019ee206cbee 100644
--- a/drivers/media/video/w9966.c
+++ b/drivers/media/video/w9966.c
@@ -815,7 +815,7 @@ out:
815 815
816static const struct v4l2_file_operations w9966_fops = { 816static const struct v4l2_file_operations w9966_fops = {
817 .owner = THIS_MODULE, 817 .owner = THIS_MODULE,
818 .ioctl = video_ioctl2, 818 .unlocked_ioctl = video_ioctl2,
819 .read = w9966_v4l_read, 819 .read = w9966_v4l_read,
820}; 820};
821 821
diff --git a/drivers/media/video/wm8775.c b/drivers/media/video/wm8775.c
index 135525649086..fe8ef6419f83 100644
--- a/drivers/media/video/wm8775.c
+++ b/drivers/media/video/wm8775.c
@@ -35,7 +35,6 @@
35#include <media/v4l2-device.h> 35#include <media/v4l2-device.h>
36#include <media/v4l2-chip-ident.h> 36#include <media/v4l2-chip-ident.h>
37#include <media/v4l2-ctrls.h> 37#include <media/v4l2-ctrls.h>
38#include <media/wm8775.h>
39 38
40MODULE_DESCRIPTION("wm8775 driver"); 39MODULE_DESCRIPTION("wm8775 driver");
41MODULE_AUTHOR("Ulf Eklund, Hans Verkuil"); 40MODULE_AUTHOR("Ulf Eklund, Hans Verkuil");
@@ -51,16 +50,10 @@ enum {
51 TOT_REGS 50 TOT_REGS
52}; 51};
53 52
54#define ALC_HOLD 0x85 /* R17: use zero cross detection, ALC hold time 42.6 ms */
55#define ALC_EN 0x100 /* R17: ALC enable */
56
57struct wm8775_state { 53struct wm8775_state {
58 struct v4l2_subdev sd; 54 struct v4l2_subdev sd;
59 struct v4l2_ctrl_handler hdl; 55 struct v4l2_ctrl_handler hdl;
60 struct v4l2_ctrl *mute; 56 struct v4l2_ctrl *mute;
61 struct v4l2_ctrl *vol;
62 struct v4l2_ctrl *bal;
63 struct v4l2_ctrl *loud;
64 u8 input; /* Last selected input (0-0xf) */ 57 u8 input; /* Last selected input (0-0xf) */
65}; 58};
66 59
@@ -92,30 +85,6 @@ static int wm8775_write(struct v4l2_subdev *sd, int reg, u16 val)
92 return -1; 85 return -1;
93} 86}
94 87
95static void wm8775_set_audio(struct v4l2_subdev *sd, int quietly)
96{
97 struct wm8775_state *state = to_state(sd);
98 u8 vol_l, vol_r;
99 int muted = 0 != state->mute->val;
100 u16 volume = (u16)state->vol->val;
101 u16 balance = (u16)state->bal->val;
102
103 /* normalize ( 65535 to 0 -> 255 to 0 (+24dB to -103dB) ) */
104 vol_l = (min(65536 - balance, 32768) * volume) >> 23;
105 vol_r = (min(balance, (u16)32768) * volume) >> 23;
106
107 /* Mute */
108 if (muted || quietly)
109 wm8775_write(sd, R21, 0x0c0 | state->input);
110
111 wm8775_write(sd, R14, vol_l | 0x100); /* 0x100= Left channel ADC zero cross enable */
112 wm8775_write(sd, R15, vol_r | 0x100); /* 0x100= Right channel ADC zero cross enable */
113
114 /* Un-mute */
115 if (!muted)
116 wm8775_write(sd, R21, state->input);
117}
118
119static int wm8775_s_routing(struct v4l2_subdev *sd, 88static int wm8775_s_routing(struct v4l2_subdev *sd,
120 u32 input, u32 output, u32 config) 89 u32 input, u32 output, u32 config)
121{ 90{
@@ -133,26 +102,25 @@ static int wm8775_s_routing(struct v4l2_subdev *sd,
133 state->input = input; 102 state->input = input;
134 if (!v4l2_ctrl_g_ctrl(state->mute)) 103 if (!v4l2_ctrl_g_ctrl(state->mute))
135 return 0; 104 return 0;
136 if (!v4l2_ctrl_g_ctrl(state->vol)) 105 wm8775_write(sd, R21, 0x0c0);
137 return 0; 106 wm8775_write(sd, R14, 0x1d4);
138 if (!v4l2_ctrl_g_ctrl(state->bal)) 107 wm8775_write(sd, R15, 0x1d4);
139 return 0; 108 wm8775_write(sd, R21, 0x100 + state->input);
140 wm8775_set_audio(sd, 1);
141 return 0; 109 return 0;
142} 110}
143 111
144static int wm8775_s_ctrl(struct v4l2_ctrl *ctrl) 112static int wm8775_s_ctrl(struct v4l2_ctrl *ctrl)
145{ 113{
146 struct v4l2_subdev *sd = to_sd(ctrl); 114 struct v4l2_subdev *sd = to_sd(ctrl);
115 struct wm8775_state *state = to_state(sd);
147 116
148 switch (ctrl->id) { 117 switch (ctrl->id) {
149 case V4L2_CID_AUDIO_MUTE: 118 case V4L2_CID_AUDIO_MUTE:
150 case V4L2_CID_AUDIO_VOLUME: 119 wm8775_write(sd, R21, 0x0c0);
151 case V4L2_CID_AUDIO_BALANCE: 120 wm8775_write(sd, R14, 0x1d4);
152 wm8775_set_audio(sd, 0); 121 wm8775_write(sd, R15, 0x1d4);
153 return 0; 122 if (!ctrl->val)
154 case V4L2_CID_AUDIO_LOUDNESS: 123 wm8775_write(sd, R21, 0x100 + state->input);
155 wm8775_write(sd, R17, (ctrl->val ? ALC_EN : 0) | ALC_HOLD);
156 return 0; 124 return 0;
157 } 125 }
158 return -EINVAL; 126 return -EINVAL;
@@ -176,7 +144,16 @@ static int wm8775_log_status(struct v4l2_subdev *sd)
176 144
177static int wm8775_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq) 145static int wm8775_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
178{ 146{
179 wm8775_set_audio(sd, 0); 147 struct wm8775_state *state = to_state(sd);
148
149 /* If I remove this, then it can happen that I have no
150 sound the first time I tune from static to a valid channel.
151 It's difficult to reproduce and is almost certainly related
152 to the zero cross detect circuit. */
153 wm8775_write(sd, R21, 0x0c0);
154 wm8775_write(sd, R14, 0x1d4);
155 wm8775_write(sd, R15, 0x1d4);
156 wm8775_write(sd, R21, 0x100 + state->input);
180 return 0; 157 return 0;
181} 158}
182 159
@@ -226,7 +203,6 @@ static int wm8775_probe(struct i2c_client *client,
226{ 203{
227 struct wm8775_state *state; 204 struct wm8775_state *state;
228 struct v4l2_subdev *sd; 205 struct v4l2_subdev *sd;
229 int err;
230 206
231 /* Check if the adapter supports the needed features */ 207 /* Check if the adapter supports the needed features */
232 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 208 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
@@ -240,21 +216,15 @@ static int wm8775_probe(struct i2c_client *client,
240 return -ENOMEM; 216 return -ENOMEM;
241 sd = &state->sd; 217 sd = &state->sd;
242 v4l2_i2c_subdev_init(sd, client, &wm8775_ops); 218 v4l2_i2c_subdev_init(sd, client, &wm8775_ops);
243 sd->grp_id = WM8775_GID; /* subdev group id */
244 state->input = 2; 219 state->input = 2;
245 220
246 v4l2_ctrl_handler_init(&state->hdl, 4); 221 v4l2_ctrl_handler_init(&state->hdl, 1);
247 state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops, 222 state->mute = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
248 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0); 223 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
249 state->vol = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
250 V4L2_CID_AUDIO_VOLUME, 0, 65535, (65535+99)/100, 0xCF00); /* 0dB*/
251 state->bal = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
252 V4L2_CID_AUDIO_BALANCE, 0, 65535, (65535+99)/100, 32768);
253 state->loud = v4l2_ctrl_new_std(&state->hdl, &wm8775_ctrl_ops,
254 V4L2_CID_AUDIO_LOUDNESS, 0, 1, 1, 1);
255 sd->ctrl_handler = &state->hdl; 224 sd->ctrl_handler = &state->hdl;
256 err = state->hdl.error; 225 if (state->hdl.error) {
257 if (err) { 226 int err = state->hdl.error;
227
258 v4l2_ctrl_handler_free(&state->hdl); 228 v4l2_ctrl_handler_free(&state->hdl);
259 kfree(state); 229 kfree(state);
260 return err; 230 return err;
@@ -266,25 +236,29 @@ static int wm8775_probe(struct i2c_client *client,
266 wm8775_write(sd, R23, 0x000); 236 wm8775_write(sd, R23, 0x000);
267 /* Disable zero cross detect timeout */ 237 /* Disable zero cross detect timeout */
268 wm8775_write(sd, R7, 0x000); 238 wm8775_write(sd, R7, 0x000);
269 /* HPF enable, I2S mode, 24-bit */ 239 /* Left justified, 24-bit mode */
270 wm8775_write(sd, R11, 0x022); 240 wm8775_write(sd, R11, 0x021);
271 /* Master mode, clock ratio 256fs */ 241 /* Master mode, clock ratio 256fs */
272 wm8775_write(sd, R12, 0x102); 242 wm8775_write(sd, R12, 0x102);
273 /* Powered up */ 243 /* Powered up */
274 wm8775_write(sd, R13, 0x000); 244 wm8775_write(sd, R13, 0x000);
275 /* ALC stereo, ALC target level -5dB FS, ALC max gain +8dB */ 245 /* ADC gain +2.5dB, enable zero cross */
276 wm8775_write(sd, R16, 0x1bb); 246 wm8775_write(sd, R14, 0x1d4);
277 /* Set ALC mode and hold time */ 247 /* ADC gain +2.5dB, enable zero cross */
278 wm8775_write(sd, R17, (state->loud->val ? ALC_EN : 0) | ALC_HOLD); 248 wm8775_write(sd, R15, 0x1d4);
249 /* ALC Stereo, ALC target level -1dB FS max gain +8dB */
250 wm8775_write(sd, R16, 0x1bf);
251 /* Enable gain control, use zero cross detection,
252 ALC hold time 42.6 ms */
253 wm8775_write(sd, R17, 0x185);
279 /* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */ 254 /* ALC gain ramp up delay 34 s, ALC gain ramp down delay 33 ms */
280 wm8775_write(sd, R18, 0x0a2); 255 wm8775_write(sd, R18, 0x0a2);
281 /* Enable noise gate, threshold -72dBfs */ 256 /* Enable noise gate, threshold -72dBfs */
282 wm8775_write(sd, R19, 0x005); 257 wm8775_write(sd, R19, 0x005);
283 /* Transient window 4ms, ALC min gain -5dB */ 258 /* Transient window 4ms, lower PGA gain limit -1dB */
284 wm8775_write(sd, R20, 0x0fb); 259 wm8775_write(sd, R20, 0x07a);
285 260 /* LRBOTH = 1, use input 2. */
286 wm8775_set_audio(sd, 1); /* set volume/mute/mux */ 261 wm8775_write(sd, R21, 0x102);
287
288 return 0; 262 return 0;
289} 263}
290 264
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-26 21:34:02 -0500