Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6
* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-2.6: V4L/DVB (11680): cafe_ccic: use = instead of == for setting a value at a var V4L/DVB (11679): cafe_ccic: fix sensor detection V4L/DVB (11675): ivtv/radio: fix V4L2_TUNER_MODE/V4L2_TUNER_SUB confusion V4L/DVB (11674): ivtv: fix incorrect bit tests V4L/DVB (11669): uvc: fix compile warning V4L/DVB (11668): ivtv: fix compiler warning. V4L/DVB (11664): cx23885: Frontend wasn't locking on HVR-1500 V4L/DVB (11662): v4l2-ioctl: Clear buffer type specific trailing fields/padding V4L/DVB (11661): v4l2-ioctl: Check buffer types using g_fmt instead of try_fmt V4L/DVB (11660): zoran: fix bug when enumerating format -1 V4L/DVB (11575): uvcvideo: fix uvc resume failed
This commit is contained in:
commit
2c487bbb0a
14 changed files with 75 additions and 40 deletions
|
@ -153,7 +153,7 @@ static int vidioc_g_tuner(struct file *file, void *priv,
|
|||
mult = (fmi->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
|
||||
v->rangelow = RSF16_MINFREQ / mult;
|
||||
v->rangehigh = RSF16_MAXFREQ / mult;
|
||||
v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
|
||||
v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
|
||||
v->capability = fmi->flags & V4L2_TUNER_CAP_LOW;
|
||||
v->audmode = V4L2_TUNER_MODE_STEREO;
|
||||
v->signal = fmi_getsigstr(fmi);
|
||||
|
|
|
@ -233,7 +233,7 @@ static int vidioc_g_tuner(struct file *file, void *priv,
|
|||
mult = (fmr2->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
|
||||
v->rangelow = RSF16_MINFREQ / mult;
|
||||
v->rangehigh = RSF16_MAXFREQ / mult;
|
||||
v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
|
||||
v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
|
||||
v->capability = fmr2->flags&V4L2_TUNER_CAP_LOW;
|
||||
v->audmode = fmr2->stereo ? V4L2_TUNER_MODE_STEREO:
|
||||
V4L2_TUNER_MODE_MONO;
|
||||
|
|
|
@ -774,6 +774,7 @@ static int cafe_cam_init(struct cafe_camera *cam)
|
|||
ret = __cafe_cam_reset(cam);
|
||||
if (ret)
|
||||
goto out;
|
||||
chip.ident = V4L2_IDENT_NONE;
|
||||
chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
|
||||
chip.match.addr = cam->sensor_addr;
|
||||
ret = sensor_call(cam, core, g_chip_ident, &chip);
|
||||
|
|
|
@ -472,7 +472,7 @@ static int dvb_register(struct cx23885_tsport *port)
|
|||
static struct xc2028_ctrl ctl = {
|
||||
.fname = XC2028_DEFAULT_FIRMWARE,
|
||||
.max_len = 64,
|
||||
.scode_table = XC3028_FE_OREN538,
|
||||
.demod = XC3028_FE_OREN538,
|
||||
};
|
||||
|
||||
fe = dvb_attach(xc2028_attach,
|
||||
|
|
|
@ -305,14 +305,17 @@ int ivtv_waitq(wait_queue_head_t *waitq)
|
|||
/* Generic utility functions */
|
||||
int ivtv_msleep_timeout(unsigned int msecs, int intr)
|
||||
{
|
||||
int ret;
|
||||
int timeout = msecs_to_jiffies(msecs);
|
||||
|
||||
do {
|
||||
set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
|
||||
timeout = schedule_timeout(timeout);
|
||||
if (intr && (ret = signal_pending(current)))
|
||||
return ret;
|
||||
if (intr) {
|
||||
int ret = signal_pending(current);
|
||||
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
} while (timeout);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -190,8 +190,8 @@ static int subdev_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
|
|||
|
||||
mask = itv->card->gpio_audio_detect.mask;
|
||||
if (mask == 0 || (read_reg(IVTV_REG_GPIO_IN) & mask))
|
||||
vt->rxsubchans = V4L2_TUNER_MODE_STEREO |
|
||||
V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
|
||||
vt->rxsubchans = V4L2_TUNER_SUB_STEREO |
|
||||
V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
|
||||
else
|
||||
vt->rxsubchans = V4L2_TUNER_SUB_MONO;
|
||||
return 0;
|
||||
|
|
|
@ -180,7 +180,7 @@ int ivtv_set_speed(struct ivtv *itv, int speed)
|
|||
|
||||
/* Wait for any DMA to finish */
|
||||
prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
|
||||
while (itv->i_flags & IVTV_F_I_DMA) {
|
||||
while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
|
||||
got_sig = signal_pending(current);
|
||||
if (got_sig)
|
||||
break;
|
||||
|
@ -1710,7 +1710,8 @@ static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
|
|||
we are waiting unlock first and later lock again. */
|
||||
mutex_unlock(&itv->serialize_lock);
|
||||
prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
|
||||
if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
|
||||
if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
|
||||
!test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
|
||||
schedule();
|
||||
finish_wait(&itv->event_waitq, &wait);
|
||||
mutex_lock(&itv->serialize_lock);
|
||||
|
|
|
@ -196,7 +196,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
|
|||
bytes_needed, s->name);
|
||||
return -1;
|
||||
}
|
||||
if (rc && !s->buffers_stolen && (s->s_flags & IVTV_F_S_APPL_IO)) {
|
||||
if (rc && !s->buffers_stolen && test_bit(IVTV_F_S_APPL_IO, &s->s_flags)) {
|
||||
IVTV_WARN("All %s stream buffers are full. Dropping data.\n", s->name);
|
||||
IVTV_WARN("Cause: the application is not reading fast enough.\n");
|
||||
}
|
||||
|
|
|
@ -1063,7 +1063,8 @@ static int ivtv_yuv_udma_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
|
|||
prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
|
||||
/* if no UDMA is pending and no UDMA is in progress, then the DMA
|
||||
is finished */
|
||||
while (itv->i_flags & (IVTV_F_I_UDMA_PENDING | IVTV_F_I_UDMA)) {
|
||||
while (test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags) ||
|
||||
test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
|
||||
/* don't interrupt if the DMA is in progress but break off
|
||||
a still pending DMA. */
|
||||
got_sig = signal_pending(current);
|
||||
|
|
|
@ -298,7 +298,8 @@ static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
|
|||
prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
|
||||
/* if no UDMA is pending and no UDMA is in progress, then the DMA
|
||||
is finished */
|
||||
while (itv->i_flags & (IVTV_F_I_UDMA_PENDING | IVTV_F_I_UDMA)) {
|
||||
while (test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags) ||
|
||||
test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
|
||||
/* don't interrupt if the DMA is in progress but break off
|
||||
a still pending DMA. */
|
||||
got_sig = signal_pending(current);
|
||||
|
|
|
@ -1726,14 +1726,17 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
|
|||
static int __uvc_resume(struct usb_interface *intf, int reset)
|
||||
{
|
||||
struct uvc_device *dev = usb_get_intfdata(intf);
|
||||
int ret;
|
||||
|
||||
uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
|
||||
intf->cur_altsetting->desc.bInterfaceNumber);
|
||||
|
||||
if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOCONTROL) {
|
||||
if (reset && (ret = uvc_ctrl_resume_device(dev)) < 0)
|
||||
return ret;
|
||||
if (reset) {
|
||||
int ret = uvc_ctrl_resume_device(dev);
|
||||
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return uvc_status_resume(dev);
|
||||
}
|
||||
|
|
|
@ -742,7 +742,7 @@ static int uvc_alloc_urb_buffers(struct uvc_video_device *video,
|
|||
|
||||
/* Buffers are already allocated, bail out. */
|
||||
if (video->urb_size)
|
||||
return 0;
|
||||
return video->urb_size / psize;
|
||||
|
||||
/* Compute the number of packets. Bulk endpoints might transfer UVC
|
||||
* payloads accross multiple URBs.
|
||||
|
|
|
@ -42,6 +42,12 @@
|
|||
printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
|
||||
} while (0)
|
||||
|
||||
/* Zero out the end of the struct pointed to by p. Everthing after, but
|
||||
* not including, the specified field is cleared. */
|
||||
#define CLEAR_AFTER_FIELD(p, field) \
|
||||
memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
|
||||
0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
|
||||
|
||||
struct std_descr {
|
||||
v4l2_std_id std;
|
||||
const char *descr;
|
||||
|
@ -544,39 +550,39 @@ static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
|
|||
|
||||
switch (type) {
|
||||
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
|
||||
if (ops->vidioc_try_fmt_vid_cap)
|
||||
if (ops->vidioc_g_fmt_vid_cap)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
|
||||
if (ops->vidioc_try_fmt_vid_overlay)
|
||||
if (ops->vidioc_g_fmt_vid_overlay)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OUTPUT:
|
||||
if (ops->vidioc_try_fmt_vid_out)
|
||||
if (ops->vidioc_g_fmt_vid_out)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
|
||||
if (ops->vidioc_try_fmt_vid_out_overlay)
|
||||
if (ops->vidioc_g_fmt_vid_out_overlay)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VBI_CAPTURE:
|
||||
if (ops->vidioc_try_fmt_vbi_cap)
|
||||
if (ops->vidioc_g_fmt_vbi_cap)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VBI_OUTPUT:
|
||||
if (ops->vidioc_try_fmt_vbi_out)
|
||||
if (ops->vidioc_g_fmt_vbi_out)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
|
||||
if (ops->vidioc_try_fmt_sliced_vbi_cap)
|
||||
if (ops->vidioc_g_fmt_sliced_vbi_cap)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
|
||||
if (ops->vidioc_try_fmt_sliced_vbi_out)
|
||||
if (ops->vidioc_g_fmt_sliced_vbi_out)
|
||||
return 0;
|
||||
break;
|
||||
case V4L2_BUF_TYPE_PRIVATE:
|
||||
if (ops->vidioc_try_fmt_type_private)
|
||||
if (ops->vidioc_g_fmt_type_private)
|
||||
return 0;
|
||||
break;
|
||||
}
|
||||
|
@ -782,44 +788,53 @@ static long __video_do_ioctl(struct file *file,
|
|||
|
||||
switch (f->type) {
|
||||
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
|
||||
CLEAR_AFTER_FIELD(f, fmt.pix);
|
||||
v4l_print_pix_fmt(vfd, &f->fmt.pix);
|
||||
if (ops->vidioc_s_fmt_vid_cap)
|
||||
ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
|
||||
CLEAR_AFTER_FIELD(f, fmt.win);
|
||||
if (ops->vidioc_s_fmt_vid_overlay)
|
||||
ret = ops->vidioc_s_fmt_vid_overlay(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OUTPUT:
|
||||
CLEAR_AFTER_FIELD(f, fmt.pix);
|
||||
v4l_print_pix_fmt(vfd, &f->fmt.pix);
|
||||
if (ops->vidioc_s_fmt_vid_out)
|
||||
ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
|
||||
CLEAR_AFTER_FIELD(f, fmt.win);
|
||||
if (ops->vidioc_s_fmt_vid_out_overlay)
|
||||
ret = ops->vidioc_s_fmt_vid_out_overlay(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VBI_CAPTURE:
|
||||
CLEAR_AFTER_FIELD(f, fmt.vbi);
|
||||
if (ops->vidioc_s_fmt_vbi_cap)
|
||||
ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VBI_OUTPUT:
|
||||
CLEAR_AFTER_FIELD(f, fmt.vbi);
|
||||
if (ops->vidioc_s_fmt_vbi_out)
|
||||
ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
|
||||
CLEAR_AFTER_FIELD(f, fmt.sliced);
|
||||
if (ops->vidioc_s_fmt_sliced_vbi_cap)
|
||||
ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
|
||||
CLEAR_AFTER_FIELD(f, fmt.sliced);
|
||||
if (ops->vidioc_s_fmt_sliced_vbi_out)
|
||||
ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_PRIVATE:
|
||||
/* CLEAR_AFTER_FIELD(f, fmt.raw_data); <- does nothing */
|
||||
if (ops->vidioc_s_fmt_type_private)
|
||||
ret = ops->vidioc_s_fmt_type_private(file,
|
||||
fh, f);
|
||||
|
@ -836,46 +851,55 @@ static long __video_do_ioctl(struct file *file,
|
|||
v4l2_type_names));
|
||||
switch (f->type) {
|
||||
case V4L2_BUF_TYPE_VIDEO_CAPTURE:
|
||||
CLEAR_AFTER_FIELD(f, fmt.pix);
|
||||
if (ops->vidioc_try_fmt_vid_cap)
|
||||
ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
|
||||
if (!ret)
|
||||
v4l_print_pix_fmt(vfd, &f->fmt.pix);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OVERLAY:
|
||||
CLEAR_AFTER_FIELD(f, fmt.win);
|
||||
if (ops->vidioc_try_fmt_vid_overlay)
|
||||
ret = ops->vidioc_try_fmt_vid_overlay(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OUTPUT:
|
||||
CLEAR_AFTER_FIELD(f, fmt.pix);
|
||||
if (ops->vidioc_try_fmt_vid_out)
|
||||
ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
|
||||
if (!ret)
|
||||
v4l_print_pix_fmt(vfd, &f->fmt.pix);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
|
||||
CLEAR_AFTER_FIELD(f, fmt.win);
|
||||
if (ops->vidioc_try_fmt_vid_out_overlay)
|
||||
ret = ops->vidioc_try_fmt_vid_out_overlay(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VBI_CAPTURE:
|
||||
CLEAR_AFTER_FIELD(f, fmt.vbi);
|
||||
if (ops->vidioc_try_fmt_vbi_cap)
|
||||
ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_VBI_OUTPUT:
|
||||
CLEAR_AFTER_FIELD(f, fmt.vbi);
|
||||
if (ops->vidioc_try_fmt_vbi_out)
|
||||
ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
|
||||
CLEAR_AFTER_FIELD(f, fmt.sliced);
|
||||
if (ops->vidioc_try_fmt_sliced_vbi_cap)
|
||||
ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
|
||||
CLEAR_AFTER_FIELD(f, fmt.sliced);
|
||||
if (ops->vidioc_try_fmt_sliced_vbi_out)
|
||||
ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
|
||||
fh, f);
|
||||
break;
|
||||
case V4L2_BUF_TYPE_PRIVATE:
|
||||
/* CLEAR_AFTER_FIELD(f, fmt.raw_data); <- does nothing */
|
||||
if (ops->vidioc_try_fmt_type_private)
|
||||
ret = ops->vidioc_try_fmt_type_private(file,
|
||||
fh, f);
|
||||
|
@ -898,6 +922,9 @@ static long __video_do_ioctl(struct file *file,
|
|||
if (ret)
|
||||
break;
|
||||
|
||||
if (p->type < V4L2_BUF_TYPE_PRIVATE)
|
||||
CLEAR_AFTER_FIELD(p, memory);
|
||||
|
||||
ret = ops->vidioc_reqbufs(file, fh, p);
|
||||
dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
|
||||
p->count,
|
||||
|
|
|
@ -1863,22 +1863,20 @@ static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability
|
|||
|
||||
static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag)
|
||||
{
|
||||
int num = -1, i;
|
||||
unsigned int num, i;
|
||||
|
||||
for (i = 0; i < NUM_FORMATS; i++) {
|
||||
if (zoran_formats[i].flags & flag)
|
||||
num++;
|
||||
if (num == fmt->index)
|
||||
break;
|
||||
for (num = i = 0; i < NUM_FORMATS; i++) {
|
||||
if (zoran_formats[i].flags & flag && num++ == fmt->index) {
|
||||
strncpy(fmt->description, zoran_formats[i].name,
|
||||
sizeof(fmt->description) - 1);
|
||||
/* fmt struct pre-zeroed, so adding '\0' not neeed */
|
||||
fmt->pixelformat = zoran_formats[i].fourcc;
|
||||
if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
|
||||
fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
if (fmt->index < 0 /* late, but not too late */ || i == NUM_FORMATS)
|
||||
return -EINVAL;
|
||||
|
||||
strncpy(fmt->description, zoran_formats[i].name, sizeof(fmt->description)-1);
|
||||
fmt->pixelformat = zoran_formats[i].fourcc;
|
||||
if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
|
||||
fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
|
||||
return 0;
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh,
|
||||
|
|
Reference in a new issue