Fixes lots of small errors at videodev.

From: Mauro Carvalho Chehab <mchehab@infradead.org>

Fixes several small errors at debug;
Fixes max line size to 80 columns;
Fixes parameter passage to callback functions;
Removed unused fh pointer at video_device struct.

Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

1 files changed, 397 insertions, 310 deletions

diff --git a/linux/drivers/media/video/videodev.c b/linux/drivers/media/video/videodev.c
index 727cccc07..e372394f5 100644
--- a/linux/drivers/media/video/videodev.c
+++ b/linux/drivers/media/video/videodev.c
@@ -1,13 +1,13 @@
 /*
  * Video capture interface for Linux version 2
  *
- *		A generic video device interface for the LINUX operating system
- *		using a set of device structures/vectors for low level operations.
+ *	A generic video device interface for the LINUX operating system
+ *	using a set of device structures/vectors for low level operations.
  *
- *		This program is free software; you can redistribute it and/or
- *		modify it under the terms of the GNU General Public License
- *		as published by the Free Software Foundation; either version
- *		2 of the License, or (at your option) any later version.
+ *	This program is free software; you can redistribute it and/or
+ *	modify it under the terms of the GNU General Public License
+ *	as published by the Free Software Foundation; either version
+ *	2 of the License, or (at your option) any later version.
  *
  * Authors:	Alan Cox, <alan@redhat.com> (version 1)
  *              Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
@@ -16,10 +16,15 @@
  *		- Added procfs support
  */
 
-#define dbgarg(fmt, arg...) \
-		if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
-			printk ("%s: " fmt, vfd->name, ## arg);
+#define dbgarg(cmd, fmt, arg...) \
+		if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)			\
+			printk (KERN_DEBUG "%s: ",  vfd->name);		\
+			v4l_printk_ioctl(cmd);				\
+			printk (KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
 
+#define dbgarg2(fmt, arg...) \
+		if (vfd->debug & V4L2_DEBUG_IOCTL_ARG)			\
+			printk (KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
 
 #include <linux/module.h>
 #include <linux/types.h>
@@ -57,7 +62,8 @@
 
 static ssize_t show_name(struct class_device *cd, char *buf)
 {
-	struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+	struct video_device *vfd = container_of(cd, struct video_device,
+								class_dev);
 	return sprintf(buf,"%.*s\n",(int)sizeof(vfd->name),vfd->name);
 }
 
@@ -65,7 +71,8 @@ static CLASS_DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,12)
 static ssize_t show_dev(struct class_device *cd, char *buf)
 {
-	struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+	struct video_device *vfd = container_of(cd, struct video_device,
+								class_dev);
 	dev_t dev = MKDEV(VIDEO_MAJOR, vfd->minor);
 	return print_dev_t(buf,dev);
 }
@@ -88,7 +95,8 @@ void video_device_release(struct video_device *vfd)
 
 static void video_release(struct class_device *cd)
 {
-	struct video_device *vfd = container_of(cd, struct video_device, class_dev);
+	struct video_device *vfd = container_of(cd, struct video_device,
+								class_dev);
 
 #if 1	/* keep */
 	/* needed until all drivers are fixed */
@@ -226,7 +234,8 @@ video_usercopy(struct inode *inode, struct file *file,
 
 		err = -EFAULT;
 		if (_IOC_DIR(cmd) & _IOC_WRITE)
-			if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
+			if (copy_from_user(parg, (void __user *)arg,
+							_IOC_SIZE(cmd)))
 				goto out;
 		break;
 	}
@@ -312,10 +321,12 @@ static char *v4l2_field_names_FIXME[] = {
 
 #define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
 
-static void dbgbuf(struct video_device *vfd, struct v4l2_buffer *p) {
+static void dbgbuf(unsigned int cmd, struct video_device *vfd,
+					struct v4l2_buffer *p)
+{
 	struct v4l2_timecode *tc=&p->timecode;
 
-	dbgarg ("%02ld:%02d:%02d.%08ld index=%d, type=%s, "
+	dbgarg (cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
 		"bytesused=%d, flags=0x%08d, "
 		"field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx\n",
 			(p->timestamp.tv_sec/3600),
@@ -328,22 +339,23 @@ static void dbgbuf(struct video_device *vfd, struct v4l2_buffer *p) {
 			p->field,p->sequence,
 			prt_names(p->memory,v4l2_memory_names),
 			p->m.userptr);
-	dbgarg ("timecode= %02d:%02d:%02d type=%d, "
+	dbgarg2 ("timecode= %02d:%02d:%02d type=%d, "
 		"flags=0x%08d, frames=%d, userbits=0x%08x\n",
 			tc->hours,tc->minutes,tc->seconds,
 			tc->type, tc->flags, tc->frames, (__u32) tc->userbits);
 }
 
-static inline void dbgrect(struct video_device *vfd, char *s, struct v4l2_rect *r)
+static inline void dbgrect(struct video_device *vfd, char *s,
+							struct v4l2_rect *r)
 {
-	dbgarg ("%sRect start at %dx%d, size= %dx%d", s, r->left, r->top,
+	dbgarg2 ("%sRect start at %dx%d, size= %dx%d\n", s, r->left, r->top,
 						r->width, r->height);
 };
 
 static inline void v4l_print_pix_fmt (struct video_device *vfd,
 						struct v4l2_pix_format *fmt)
 {
-	dbgarg ("width=%d, height=%d, format=%d, field=%s, "
+	dbgarg2 ("width=%d, height=%d, format=%d, field=%s, "
 		"bytesperline=%d sizeimage=%d, colorspace=%d\n",
 		fmt->width,fmt->height,fmt->pixelformat,
 		prt_names(fmt->field,v4l2_field_names_FIXME),
@@ -393,12 +405,9 @@ static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
 static int __video_do_ioctl(struct inode *inode, struct file *file,
 		unsigned int cmd, void *arg)
 {
-	struct video_device *vfd;
-	void *fh;
-	int ret=-EINVAL;
-
-	vfd = video_devdata(file);
-	fh = vfd->fh;
+	struct video_device *vfd = video_devdata(file);
+	void                 *fh = file->private_data;
+	int                  ret = -EINVAL;
 
 	if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
 				!(vfd->debug | V4L2_DEBUG_IOCTL_ARG)) {
@@ -412,14 +421,17 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 		struct v4l2_capability *cap = (struct v4l2_capability*)arg;
 		memset(cap, 0, sizeof(*cap));
 
-		if (vfd->vidioc_querycap) {
-			ret=vfd->vidioc_querycap(file,fh, cap);
-			dbgarg ("driver=%s, card=%s, bus=%s, version=0x%08x, "
-				"capabilities=0x%08x\n",
+		if (!vfd->vidioc_querycap)
+			break;
+
+		ret=vfd->vidioc_querycap(file, fh, cap);
+		if (!ret)
+			dbgarg (cmd, "driver=%s, card=%s, bus=%s, "
+					"version=0x%08x, "
+					"capabilities=0x%08x\n",
 					cap->driver,cap->card,cap->bus_info,
 					cap->version,
 					cap->capabilities);
-		}
 		break;
 	}
 
@@ -428,20 +440,21 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	{
 		enum v4l2_priority *p=arg;
 
-		if (vfd->vidioc_g_priority) {
-			dbgarg("priority is %d\n", *p);
-			ret=vfd->vidioc_g_priority(file, fh, p);
-		}
+		if (!vfd->vidioc_g_priority)
+			break;
+		ret=vfd->vidioc_g_priority(file, fh, p);
+		if (!ret)
+			dbgarg(cmd, "priority is %d\n", *p);
 		break;
 	}
 	case VIDIOC_S_PRIORITY:
 	{
 		enum v4l2_priority *p=arg;
 
-		if (vfd->vidioc_s_priority) {
-			ret=vfd->vidioc_s_priority(file, fh, *p);
-			dbgarg("priority is %d\n", *p);
-		}
+		if (!vfd->vidioc_s_priority)
+			break;
+		dbgarg(cmd, "setting priority to %d\n", *p);
+		ret=vfd->vidioc_s_priority(file, fh, *p);
 		break;
 	}
 
@@ -473,29 +486,37 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 			if (vfd->vidioc_enum_fmt_vbi_output)
-				ret=vfd->vidioc_enum_fmt_vbi_output(file, fh, f);
+				ret=vfd->vidioc_enum_fmt_vbi_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 			if (vfd->vidioc_enum_fmt_vbi_capture)
-				ret=vfd->vidioc_enum_fmt_vbi_capture(file, fh, f);
+				ret=vfd->vidioc_enum_fmt_vbi_capture(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (vfd->vidioc_enum_fmt_video_output)
-				ret=vfd->vidioc_enum_fmt_video_output(file, fh, f);
+				ret=vfd->vidioc_enum_fmt_video_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (vfd->vidioc_enum_fmt_vbi_output)
-				ret=vfd->vidioc_enum_fmt_vbi_output(file, fh, f);
+				ret=vfd->vidioc_enum_fmt_vbi_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (vfd->vidioc_enum_fmt_type_private)
-				ret=vfd->vidioc_enum_fmt_type_private(file, fh, f);
+				ret=vfd->vidioc_enum_fmt_type_private(file,
+								fh, f);
 			break;
 		}
-		dbgarg ("index=%d, type=%d, flags=%d, description=%s,"
-			" pixelformat=%d\n",
-				f->index, f->type, f->flags, f->description,
-				f->pixelformat);
+		if (!ret)
+			dbgarg (cmd, "index=%d, type=%d, flags=%d, "
+					"description=%s,"
+					" pixelformat=%d\n",
+					f->index, f->type, f->flags,
+					f->description,
+					f->pixelformat);
 
 		break;
 	}
@@ -507,6 +528,10 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 
 		memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
 
+		/* FIXME: Should be one dump per type */
+		dbgarg (cmd, "type=%s\n", prt_names(f->type,
+					v4l2_type_names_FIXME));
+
 		switch (type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 			if (vfd->vidioc_g_fmt_cap)
@@ -530,7 +555,8 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (vfd->vidioc_g_fmt_video_output)
-				ret=vfd->vidioc_g_fmt_video_output(file, fh, f);
+				ret=vfd->vidioc_g_fmt_video_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (vfd->vidioc_g_fmt_vbi_output)
@@ -538,24 +564,23 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (vfd->vidioc_g_fmt_type_private)
-				ret=vfd->vidioc_g_fmt_type_private(file, fh, f);
+				ret=vfd->vidioc_g_fmt_type_private(file,
+								fh, f);
 			break;
 		}
-		/* FIXME: Should be one dump per type */
-		dbgarg ("type=%s\n", prt_names(f->type,v4l2_type_names_FIXME));
 
 		break;
 	}
 	case VIDIOC_S_FMT:
 	{
 		struct v4l2_format *f = (struct v4l2_format *)arg;
-
 		enum v4l2_buf_type type=f->type;
 
 		memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
 
 		/* FIXME: Should be one dump per type */
-		dbgarg ("type=%s\n", prt_names(f->type,v4l2_type_names_FIXME));
+		dbgarg (cmd, "type=%s\n", prt_names(f->type,
+					v4l2_type_names_FIXME));
 
 		switch (type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
@@ -580,15 +605,18 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (vfd->vidioc_s_fmt_video_output)
-				ret=vfd->vidioc_s_fmt_video_output(file, fh, f);
+				ret=vfd->vidioc_s_fmt_video_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (vfd->vidioc_s_fmt_vbi_output)
-				ret=vfd->vidioc_s_fmt_vbi_output(file, fh, f);
+				ret=vfd->vidioc_s_fmt_vbi_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (vfd->vidioc_s_fmt_type_private)
-				ret=vfd->vidioc_s_fmt_type_private(file, fh, f);
+				ret=vfd->vidioc_s_fmt_type_private(file,
+								fh, f);
 			break;
 		}
 		break;
@@ -600,6 +628,9 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 
 		memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
 
+		/* FIXME: Should be one dump per type */
+		dbgarg (cmd, "type=%s\n", prt_names(f->type,
+						v4l2_type_names_FIXME));
 		switch (type) {
 		case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 			if (vfd->vidioc_try_fmt_cap)
@@ -615,27 +646,30 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 			if (vfd->vidioc_try_fmt_vbi_output)
-				ret=vfd->vidioc_try_fmt_vbi_output(file, fh, f);
+				ret=vfd->vidioc_try_fmt_vbi_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 			if (vfd->vidioc_try_fmt_vbi_capture)
-				ret=vfd->vidioc_try_fmt_vbi_capture(file, fh, f);
+				ret=vfd->vidioc_try_fmt_vbi_capture(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 			if (vfd->vidioc_try_fmt_video_output)
-				ret=vfd->vidioc_try_fmt_video_output(file, fh, f);
+				ret=vfd->vidioc_try_fmt_video_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_VBI_OUTPUT:
 			if (vfd->vidioc_try_fmt_vbi_output)
-				ret=vfd->vidioc_try_fmt_vbi_output(file, fh, f);
+				ret=vfd->vidioc_try_fmt_vbi_output(file,
+								fh, f);
 			break;
 		case V4L2_BUF_TYPE_PRIVATE:
 			if (vfd->vidioc_try_fmt_type_private)
-				ret=vfd->vidioc_try_fmt_type_private(file, fh, f);
+				ret=vfd->vidioc_try_fmt_type_private(file,
+								fh, f);
 			break;
 		}
-		/* FIXME: Should be one dump per type */
-		dbgarg ("type=%s\n", prt_names(f->type,v4l2_type_names_FIXME));
 
 		break;
 	}
@@ -647,68 +681,71 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	{
 		struct v4l2_requestbuffers *p=arg;
 
-		if (vfd->vidioc_reqbufs) {
-			ret = check_fmt (vfd, p->type);
-			if (ret)
-				break;
+		if (!vfd->vidioc_reqbufs)
+			break;
+		ret = check_fmt (vfd, p->type);
+		if (ret)
+			break;
 
-			ret=vfd->vidioc_reqbufs(file, fh, p);
-			dbgarg ("count=%d, type=%s, memory=%s\n",
-					p->count,
-					prt_names(p->type,v4l2_type_names_FIXME),
-					prt_names(p->memory,v4l2_memory_names));
-		}
+		ret=vfd->vidioc_reqbufs(file, fh, p);
+		dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
+				p->count,
+				prt_names(p->type,v4l2_type_names_FIXME),
+				prt_names(p->memory,v4l2_memory_names));
 		break;
 	}
 	case VIDIOC_QUERYBUF:
 	{
 		struct v4l2_buffer *p=arg;
 
-		if (vfd->vidioc_querybuf) {
-			ret = check_fmt (vfd, p->type);
-			if (ret)
-				break;
+		if (!vfd->vidioc_querybuf)
+			break;
+		ret = check_fmt (vfd, p->type);
+		if (ret)
+			break;
 
-			ret=vfd->vidioc_querybuf(file, fh, p);
-			dbgbuf(vfd,p);
-		}
+		ret=vfd->vidioc_querybuf(file, fh, p);
+		if (!ret)
+			dbgbuf(cmd,vfd,p);
 		break;
 	}
 	case VIDIOC_QBUF:
 	{
 		struct v4l2_buffer *p=arg;
 
-		if (vfd->vidioc_qbuf) {
-			ret = check_fmt (vfd, p->type);
-			if (ret)
-				break;
+		if (!vfd->vidioc_qbuf)
+			break;
+		ret = check_fmt (vfd, p->type);
+		if (ret)
+			break;
 
-			ret=vfd->vidioc_qbuf(file, fh, p);
-			dbgbuf(vfd,p);
-		}
+		ret=vfd->vidioc_qbuf(file, fh, p);
+		if (!ret)
+			dbgbuf(cmd,vfd,p);
 		break;
 	}
 	case VIDIOC_DQBUF:
 	{
 		struct v4l2_buffer *p=arg;
-		if (vfd->vidioc_qbuf) {
-			ret = check_fmt (vfd, p->type);
-			if (ret)
-				break;
+		if (!vfd->vidioc_qbuf)
+			break;
+		ret = check_fmt (vfd, p->type);
+		if (ret)
+			break;
 
-			ret=vfd->vidioc_qbuf(file, fh, p);
-			dbgbuf(vfd,p);
-		}
+		ret=vfd->vidioc_qbuf(file, fh, p);
+		if (!ret)
+			dbgbuf(cmd,vfd,p);
 		break;
 	}
 	case VIDIOC_OVERLAY:
 	{
 		int *i = arg;
 
-		if (vfd->vidioc_overlay) {
-			dbgarg ("value=%d\n",*i);
-			ret=vfd->vidioc_overlay(file, fh, *i);
-		}
+		if (!vfd->vidioc_overlay)
+			break;
+		dbgarg (cmd, "value=%d\n",*i);
+		ret=vfd->vidioc_overlay(file, fh, *i);
 		break;
 	}
 #ifdef HAVE_V4L1
@@ -719,22 +756,24 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 
 		memset(&p,0,sizeof(p));
 
-		if (vfd->vidiocgmbuf) {
-			ret=vfd->vidiocgmbuf(file, fh, p);
-			dbgarg ("size=%d, frames=%d, offsets=0x%08lx\n",
-				p->size,
-				p->frames,
-				(unsigned long)p->offsets);
-		}
+		if (!vfd->vidiocgmbuf)
+			break;
+		ret=vfd->vidiocgmbuf(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
+						p->size, p->frames,
+						(unsigned long)p->offsets);
 		break;
 	}
 #endif
 	case VIDIOC_G_FBUF:
 	{
 		struct v4l2_framebuffer *p=arg;
-		if (vfd->vidioc_g_fbuf) {
-			ret=vfd->vidioc_g_fbuf(file, fh, arg);
-			dbgarg ("capability=%d, flags=%d, base=0x%08lx\n",
+		if (!vfd->vidioc_g_fbuf)
+			break;
+		ret=vfd->vidioc_g_fbuf(file, fh, arg);
+		if (!ret) {
+			dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
 					p->capability,p->flags,
 					(unsigned long)p->base);
 			v4l_print_pix_fmt (vfd, &p->fmt);
@@ -744,30 +783,33 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	case VIDIOC_S_FBUF:
 	{
 		struct v4l2_framebuffer *p=arg;
-		dbgarg ("capability=%d, flags=%d, base=0x%08lx\n",
+		if (!vfd->vidioc_s_fbuf)
+			break;
+
+		dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
 				p->capability,p->flags,(unsigned long)p->base);
 		v4l_print_pix_fmt (vfd, &p->fmt);
-		if (vfd->vidioc_s_fbuf)
-			ret=vfd->vidioc_s_fbuf(file, fh, arg);
+		ret=vfd->vidioc_s_fbuf(file, fh, arg);
+
 		break;
 	}
 	case VIDIOC_STREAMON:
 	{
 		enum v4l2_buf_type i = *(int *)arg;
-		if (vfd->vidioc_streamon) {
-			dbgarg ("type=%s\n", prt_names(i,v4l2_type_names_FIXME));
-			ret=vfd->vidioc_streamon(file, fh,i);
-		}
+		if (!vfd->vidioc_streamon)
+			break;
+		dbgarg (cmd, "type=%s\n", prt_names(i,v4l2_type_names_FIXME));
+		ret=vfd->vidioc_streamon(file, fh,i);
 		break;
 	}
 	case VIDIOC_STREAMOFF:
 	{
 		enum v4l2_buf_type i = *(int *)arg;
 
-		if (vfd->vidioc_streamon){
-			dbgarg ("type=%s\n", prt_names(i,v4l2_type_names_FIXME));
-			ret=vfd->vidioc_streamoff(file, fh, i);
-		}
+		if (!vfd->vidioc_streamon)
+			break;
+		dbgarg (cmd, "type=%s\n", prt_names(i,v4l2_type_names_FIXME));
+		ret=vfd->vidioc_streamoff(file, fh, i);
 		break;
 	}
 	/* ---------- tv norms ---------- */
@@ -776,14 +818,22 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 		struct v4l2_standard *p = arg;
 		unsigned int index = p->index;
 
-		if (index<=0 || index >= vfd->tvnormsize)
+		if (!vfd->tvnormsize) {
+			printk (KERN_WARNING "%s: no TV norms defined!\n",
+						vfd->name);
+			break;
+		}
+
+		if (index<=0 || index >= vfd->tvnormsize) {
+			ret=-EINVAL;
 			break;
+		}
 		v4l2_video_std_construct(p, vfd->tvnorms[p->index].id,
 					 vfd->tvnorms[p->index].name);
 		p->index = index;
 
-		dbgarg ("index=%d, id=%Ld, name=%s, fps=%d/%d, "
-			"framelines=%d\n", p->index,
+		dbgarg (cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
+				"framelines=%d\n", p->index,
 				(unsigned long long)p->id, p->name,
 				p->frameperiod.numerator,
 				p->frameperiod.denominator,
@@ -798,7 +848,7 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 
 		*id = vfd->current_norm;
 
-		dbgarg ("value=%Lu\n", (long long unsigned) *id);
+		dbgarg (cmd, "value=%Lu\n", (long long unsigned) *id);
 
 		ret=0;
 		break;
@@ -808,9 +858,14 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 		v4l2_std_id *id = arg;
 		unsigned int i;
 
-		dbgarg ("value=%Lu\n", (long long unsigned) *id);
+		if (!vfd->tvnormsize) {
+			printk (KERN_WARNING "%s: no TV norms defined!\n",
+						vfd->name);
+			break;
+		}
+
+		dbgarg (cmd, "value=%Lu\n", (long long unsigned) *id);
 
-		ret=0;
 		/* First search for exact match */
 		for (i = 0; i < vfd->tvnormsize; i++)
 			if (*id == vfd->tvnorms[i].id)
@@ -820,8 +875,9 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 			for (i = 0; i < vfd->tvnormsize; i++)
 				if (*id & vfd->tvnorms[i].id)
 					break;
-		if (i == vfd->tvnormsize)
-			return -EINVAL;
+		if (i == vfd->tvnormsize) {
+			break;
+		}
 
 		/* Calls the specific handler */
 		if (vfd->vidioc_s_std)
@@ -839,10 +895,12 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	{
 		v4l2_std_id *p=arg;
 
-		if (vfd->vidioc_querystd) {
-			ret=vfd->vidioc_querystd(file, fh, arg);
-			dbgarg ("detected std=%Lu\n", (unsigned long long)*p);
-		}
+		if (!vfd->vidioc_querystd)
+			break;
+		ret=vfd->vidioc_querystd(file, fh, arg);
+		if (!ret)
+			dbgarg (cmd, "detected std=%Lu\n",
+						(unsigned long long)*p);
 		break;
 	}
 	/* ------ input switching ---------- */
@@ -852,41 +910,41 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 		struct v4l2_input *p=arg;
 		int i=p->index;
 
-		if (vfd->vidioc_enum_input) {
-
-			memset(p, 0, sizeof(*p));
-			p->index=i;
+		if (!vfd->vidioc_enum_input)
+			break;
+		memset(p, 0, sizeof(*p));
+		p->index=i;
 
-			ret=vfd->vidioc_enum_input(file, fh, p);
-			dbgarg ("index=%d, name=%s, type=%d, audioset=%d, "
-				"tuner=%d, std=%Ld, status=%d\n",
+		ret=vfd->vidioc_enum_input(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "index=%d, name=%s, type=%d, "
+					"audioset=%d, "
+					"tuner=%d, std=%Ld, status=%d\n",
 					p->index,p->name,p->type,p->audioset,
 					p->tuner,
 					(unsigned long long)p->std,
 					p->status);
-		}
 		break;
 	}
 	case VIDIOC_G_INPUT:
 	{
 		unsigned int *i = arg;
 
-		if (vfd->vidioc_g_input) {
-			dbgarg ("value=%d\n",*i);
-
-			ret=vfd->vidioc_g_input(file, fh, i);
-		}
+		if (!vfd->vidioc_g_input)
+			break;
+		ret=vfd->vidioc_g_input(file, fh, i);
+		if (!ret)
+			dbgarg (cmd, "value=%d\n",*i);
 		break;
 	}
 	case VIDIOC_S_INPUT:
 	{
 		unsigned int *i = arg;
 
-		if (vfd->vidioc_s_input) {
-			ret=vfd->vidioc_s_input(file, fh, *i);
-
-			dbgarg ("value=%d\n",*i);
-		}
+		if (!vfd->vidioc_s_input)
+			break;
+		dbgarg (cmd, "value=%d\n",*i);
+		ret=vfd->vidioc_s_input(file, fh, *i);
 		break;
 	}
 
@@ -895,21 +953,21 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	{
 		unsigned int *i = arg;
 
-		if (vfd->vidioc_g_output) {
-			ret=vfd->vidioc_g_output(file, fh, i);
-			dbgarg ("value=%d\n",*i);
-		}
+		if (!vfd->vidioc_g_output)
+			break;
+		ret=vfd->vidioc_g_output(file, fh, i);
+		if (!ret)
+			dbgarg (cmd, "value=%d\n",*i);
 		break;
 	}
 	case VIDIOC_S_OUTPUT:
 	{
 		unsigned int *i = arg;
 
-
-		if (vfd->vidioc_s_output) {
-			dbgarg ("value=%d\n",*i);
-			ret=vfd->vidioc_s_output(file, fh, *i);
-		}
+		if (!vfd->vidioc_s_output)
+			break;
+		dbgarg (cmd, "value=%d\n",*i);
+		ret=vfd->vidioc_s_output(file, fh, *i);
 		break;
 	}
 
@@ -918,47 +976,52 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	{
 		struct v4l2_queryctrl *p=arg;
 
-		if (vfd->vidioc_queryctrl) {
-			ret=vfd->vidioc_queryctrl(file, fh, p);
+		if (!vfd->vidioc_queryctrl)
+			break;
+		ret=vfd->vidioc_queryctrl(file, fh, p);
 
-			dbgarg ("id=%d, type=%d, name=%s, min/max=%d/%d,"
-				" step=%d, default=%d, flags=0x%08x\n",
-				p->id,p->type,p->name,p->minimum,p->maximum,
-				p->step,p->default_value,p->flags);
-		}
+		if (!ret)
+			dbgarg (cmd, "id=%d, type=%d, name=%s, "
+					"min/max=%d/%d,"
+					" step=%d, default=%d, flags=0x%08x\n",
+					p->id,p->type,p->name,p->minimum,
+					p->maximum,p->step,p->default_value,
+					p->flags);
 		break;
 	}
 	case VIDIOC_G_CTRL:
 	{
 		struct v4l2_control *p = arg;
 
-		if (vfd->vidioc_g_ctrl) {
-			dbgarg("Enum for index=%d\n", p->id);
+		if (!vfd->vidioc_g_ctrl)
+			break;
+		dbgarg(cmd, "Enum for index=%d\n", p->id);
 
-			ret=vfd->vidioc_g_ctrl(file, fh, p);
-			dbgarg ("id=%d, value=%d\n", p->id, p->value);
-		}
+		ret=vfd->vidioc_g_ctrl(file, fh, p);
+		if (!ret)
+			dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
 		break;
 	}
 	case VIDIOC_S_CTRL:
 	{
 		struct v4l2_control *p = arg;
 
-		if (vfd->vidioc_s_ctrl) {
-			dbgarg ("id=%d, value=%d\n", p->id, p->value);
+		if (!vfd->vidioc_s_ctrl)
+			break;
+		dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
 
-			ret=vfd->vidioc_s_ctrl(file, fh, p);
-		}
+		ret=vfd->vidioc_s_ctrl(file, fh, p);
 		break;
 	}
 	case VIDIOC_QUERYMENU:
 	{
 		struct v4l2_querymenu *p=arg;
-		if (vfd->vidioc_querymenu) {
-			dbgarg ("id=%d, index=%d, name=%s\n",
-					p->id,p->index,p->name);
-			ret=vfd->vidioc_querymenu(file, fh, p);
-		}
+		if (!vfd->vidioc_querymenu)
+			break;
+		ret=vfd->vidioc_querymenu(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "id=%d, index=%d, name=%s\n",
+						p->id,p->index,p->name);
 		break;
 	}
 	/* --- audio ---------------------------------------------- */
@@ -966,103 +1029,118 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	{
 		struct v4l2_audio *p=arg;
 
-		if (vfd->vidioc_enumaudio) {
-			dbgarg("Enum for index=%d\n", p->index);
-			ret=vfd->vidioc_enumaudio(file, fh, p);
-			dbgarg("index=%d, name=%s, capability=%d, mode=%d\n",
-				p->index, p->name,p->capability, p->mode);
-		}
+		if (!vfd->vidioc_enumaudio)
+			break;
+		dbgarg(cmd, "Enum for index=%d\n", p->index);
+		ret=vfd->vidioc_enumaudio(file, fh, p);
+		if (!ret)
+			dbgarg2("index=%d, name=%s, capability=%d, "
+					"mode=%d\n",p->index,p->name,
+					p->capability, p->mode);
 		break;
 	}
 	case VIDIOC_G_AUDIO:
 	{
 		struct v4l2_audio *p=arg;
 
-		if (vfd->vidioc_g_audio) {
-			dbgarg("Get for index=%d\n", p->index);
-			ret=vfd->vidioc_g_audio(file, fh, p);
-			dbgarg("index=%d, name=%s, capability=%d, mode=%d\n",
-				p->index, p->name,p->capability, p->mode);
-		}
+		if (!vfd->vidioc_g_audio)
+			break;
+		dbgarg(cmd, "Get for index=%d\n", p->index);
+		ret=vfd->vidioc_g_audio(file, fh, p);
+		if (!ret)
+			dbgarg2("index=%d, name=%s, capability=%d, "
+					"mode=%d\n",p->index,
+					p->name,p->capability, p->mode);
 		break;
 	}
 	case VIDIOC_S_AUDIO:
 	{
 		struct v4l2_audio *p=arg;
 
-		if (vfd->vidioc_s_audio) {
-			dbgarg("index=%d, name=%s, capability=%d, mode=%d\n",
-				p->index, p->name,p->capability, p->mode);
-			ret=vfd->vidioc_s_audio(file, fh, p);
-		}
+		if (!vfd->vidioc_s_audio)
+			break;
+		dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+					"mode=%d\n", p->index, p->name,
+					p->capability, p->mode);
+		ret=vfd->vidioc_s_audio(file, fh, p);
 		break;
 	}
 	case VIDIOC_ENUMAUDOUT:
 	{
 		struct v4l2_audioout *p=arg;
 
-		if (vfd->vidioc_enumaudout) {
-			dbgarg("Enum for index=%d\n", p->index);
-			ret=vfd->vidioc_enumaudout(file, fh, p);
-			dbgarg("index=%d, name=%s, capability=%d, mode=%d\n",
-				p->index, p->name, p->capability,p->mode);
-		}
+		if (!vfd->vidioc_enumaudout)
+			break;
+		dbgarg(cmd, "Enum for index=%d\n", p->index);
+		ret=vfd->vidioc_enumaudout(file, fh, p);
+		if (!ret)
+			dbgarg2("index=%d, name=%s, capability=%d, "
+					"mode=%d\n", p->index, p->name,
+					p->capability,p->mode);
 		break;
 	}
 	case VIDIOC_G_AUDOUT:
 	{
 		struct v4l2_audioout *p=arg;
 
-		if (vfd->vidioc_g_audout) {
-			dbgarg("Enum for index=%d\n", p->index);
-			ret=vfd->vidioc_g_audout(file, fh, p);
-			dbgarg("index=%d, name=%s, capability=%d, mode=%d\n",
-				p->index, p->name, p->capability,p->mode);
-		}
+		if (!vfd->vidioc_g_audout)
+			break;
+		dbgarg(cmd, "Enum for index=%d\n", p->index);
+		ret=vfd->vidioc_g_audout(file, fh, p);
+		if (!ret)
+			dbgarg2("index=%d, name=%s, capability=%d, "
+					"mode=%d\n", p->index, p->name,
+					p->capability,p->mode);
 		break;
 	}
 	case VIDIOC_S_AUDOUT:
 	{
 		struct v4l2_audioout *p=arg;
 
-		if (vfd->vidioc_s_audout) {
-			dbgarg("index=%d, name=%s, capability=%d, mode=%d\n",
-				p->index, p->name, p->capability,p->mode);
+		if (!vfd->vidioc_s_audout)
+			break;
+		dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+					"mode=%d\n", p->index, p->name,
+					p->capability,p->mode);
 
-			ret=vfd->vidioc_s_audout(file, fh, p);
-		}
+		ret=vfd->vidioc_s_audout(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_MODULATOR:
 	{
 		struct v4l2_modulator *p=arg;
-		if (vfd->vidioc_g_modulator) {
-			ret=vfd->vidioc_g_modulator(file, fh, p);
-			dbgarg("index=%d, name=%s, capability=%d, rangelow=%d,"
-				" rangehigh=%d, txsubchans=%d\n",
-				p->index, p->name,p->capability,p->rangelow,
-				p->rangehigh,p->txsubchans);
-		}
+		if (!vfd->vidioc_g_modulator)
+			break;
+		ret=vfd->vidioc_g_modulator(file, fh, p);
+		if (!ret)
+			dbgarg(cmd, "index=%d, name=%s, "
+					"capability=%d, rangelow=%d,"
+					" rangehigh=%d, txsubchans=%d\n",
+					p->index, p->name,p->capability,
+					p->rangelow, p->rangehigh,
+					p->txsubchans);
 		break;
 	}
 	case VIDIOC_S_MODULATOR:
 	{
 		struct v4l2_modulator *p=arg;
-		if (vfd->vidioc_s_modulator) {
-			dbgarg("index=%d, name=%s, capability=%d, rangelow=%d,"
-				" rangehigh=%d, txsubchans=%d\n",
+		if (!vfd->vidioc_s_modulator)
+			break;
+		dbgarg(cmd, "index=%d, name=%s, capability=%d, "
+				"rangelow=%d, rangehigh=%d, txsubchans=%d\n",
 				p->index, p->name,p->capability,p->rangelow,
 				p->rangehigh,p->txsubchans);
 			ret=vfd->vidioc_s_modulator(file, fh, p);
-		}
 		break;
 	}
 	case VIDIOC_G_CROP:
 	{
 		struct v4l2_crop *p=arg;
-		if (vfd->vidioc_g_crop) {
-			ret=vfd->vidioc_g_crop(file, fh, p);
-			dbgarg("type=%d\n", p->type);
+		if (!vfd->vidioc_g_crop)
+			break;
+		ret=vfd->vidioc_g_crop(file, fh, p);
+		if (!ret) {
+			dbgarg(cmd, "type=%d\n", p->type);
 			dbgrect(vfd, "", &p->c);
 		}
 		break;
@@ -1070,50 +1148,54 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 	case VIDIOC_S_CROP:
 	{
 		struct v4l2_crop *p=arg;
-		if (vfd->vidioc_s_crop) {
-			dbgarg("type=%d\n", p->type);
-			dbgrect(vfd, "", &p->c);
-			ret=vfd->vidioc_s_crop(file, fh, p);
-		}
+		if (!vfd->vidioc_s_crop)
+			break;
+		dbgarg(cmd, "type=%d\n", p->type);
+		dbgrect(vfd, "", &p->c);
+		ret=vfd->vidioc_s_crop(file, fh, p);
 		break;
 	}
 	case VIDIOC_CROPCAP:
 	{
 		struct v4l2_cropcap *p=arg;
 		/*FIXME: Should also show v4l2_fract pixelaspect */
-		if (vfd->vidioc_cropcap) {
-			dbgarg("type=%d\n", p->type);
-			dbgrect(vfd, "bounds ", &p->bounds);
-			dbgrect(vfd, "defrect ", &p->defrect);
-			ret=vfd->vidioc_cropcap(file, fh, p);
-		}
+		if (!vfd->vidioc_cropcap)
+			break;
+		dbgarg(cmd, "type=%d\n", p->type);
+		dbgrect(vfd, "bounds ", &p->bounds);
+		dbgrect(vfd, "defrect ", &p->defrect);
+		ret=vfd->vidioc_cropcap(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_MPEGCOMP:
 	{
 		struct v4l2_mpeg_compression *p=arg;
 		/*FIXME: Several fields not shown */
-		if (vfd->vidioc_g_mpegcomp) {
-			ret=vfd->vidioc_g_mpegcomp(file, fh, p);
-			dbgarg ("ts_pid_pmt=%d, ts_pid_audio=%d, "
-				"ts_pid_video=%d, ts_pid_pcr=%d, ps_size=%d, "
-				"au_sample_rate=%d, au_pesid=%c, "
-				"vi_frame_rate=%d, vi_frames_per_gop=%d, "
-				"vi_bframes_count=%d, vi_pesid=%c\n",
-				p->ts_pid_pmt,p->ts_pid_audio, p->ts_pid_video,
-				p->ts_pid_pcr, p->ps_size, p->au_sample_rate,
-				p->au_pesid, p->vi_frame_rate,
-				p->vi_frames_per_gop, p->vi_bframes_count,
-				p->vi_pesid);
-		}
+		if (!vfd->vidioc_g_mpegcomp)
+			break;
+		ret=vfd->vidioc_g_mpegcomp(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "ts_pid_pmt=%d, ts_pid_audio=%d,"
+					" ts_pid_video=%d, ts_pid_pcr=%d, "
+					"ps_size=%d, au_sample_rate=%d, "
+					"au_pesid=%c, vi_frame_rate=%d, "
+					"vi_frames_per_gop=%d, "
+					"vi_bframes_count=%d, vi_pesid=%c\n",
+					p->ts_pid_pmt,p->ts_pid_audio,
+					p->ts_pid_video,p->ts_pid_pcr,
+					p->ps_size, p->au_sample_rate,
+					p->au_pesid, p->vi_frame_rate,
+					p->vi_frames_per_gop,
+					p->vi_bframes_count, p->vi_pesid);
 		break;
 	}
 	case VIDIOC_S_MPEGCOMP:
 	{
 		struct v4l2_mpeg_compression *p=arg;
 		/*FIXME: Several fields not shown */
-		if (vfd->vidioc_s_mpegcomp) {
-			dbgarg ("ts_pid_pmt=%d, ts_pid_audio=%d, "
+		if (!vfd->vidioc_s_mpegcomp)
+			break;
+		dbgarg (cmd, "ts_pid_pmt=%d, ts_pid_audio=%d, "
 				"ts_pid_video=%d, ts_pid_pcr=%d, ps_size=%d, "
 				"au_sample_rate=%d, au_pesid=%c, "
 				"vi_frame_rate=%d, vi_frames_per_gop=%d, "
@@ -1123,116 +1205,121 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 				p->au_pesid, p->vi_frame_rate,
 				p->vi_frames_per_gop, p->vi_bframes_count,
 				p->vi_pesid);
-			ret=vfd->vidioc_s_mpegcomp(file, fh, p);
-		}
+		ret=vfd->vidioc_s_mpegcomp(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_JPEGCOMP:
 	{
 		struct v4l2_jpegcompression *p=arg;
-		if (vfd->vidioc_g_jpegcomp) {
-			dbgarg ("quality=%d, APPn=%d, APP_len=%d, COM_len=%d,"
-				" jpeg_markers=%d\n",
-					p->quality,p->APPn,p->APP_len,
-					p->COM_len,p->jpeg_markers);
-			ret=vfd->vidioc_g_jpegcomp(file, fh, p);
-		}
+		if (!vfd->vidioc_g_jpegcomp)
+			break;
+		ret=vfd->vidioc_g_jpegcomp(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "quality=%d, APPn=%d, "
+						"APP_len=%d, COM_len=%d, "
+						"jpeg_markers=%d\n",
+						p->quality,p->APPn,p->APP_len,
+						p->COM_len,p->jpeg_markers);
 		break;
 	}
 	case VIDIOC_S_JPEGCOMP:
 	{
 		struct v4l2_jpegcompression *p=arg;
-		if (vfd->vidioc_g_jpegcomp) {
-			ret=vfd->vidioc_s_jpegcomp(file, fh, p);
-			dbgarg ("quality=%d, APPn=%d, APP_len=%d, COM_len=%d,"
-				" jpeg_markers=%d\n",
+		if (!vfd->vidioc_g_jpegcomp)
+			break;
+		dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
+					"COM_len=%d, jpeg_markers=%d\n",
 					p->quality,p->APPn,p->APP_len,
 					p->COM_len,p->jpeg_markers);
-		}
+			ret=vfd->vidioc_s_jpegcomp(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_PARM:
 	{
 		struct v4l2_streamparm *p=arg;
-		if (vfd->vidioc_g_parm) {
-			dbgarg ("type=%d\n", p->type);
-			ret=vfd->vidioc_g_parm(file, fh, p);
-		}
+		if (!vfd->vidioc_g_parm)
+			break;
+		ret=vfd->vidioc_g_parm(file, fh, p);
+		dbgarg (cmd, "type=%d\n", p->type);
 		break;
 	}
 	case VIDIOC_S_PARM:
 	{
 		struct v4l2_streamparm *p=arg;
-		if (vfd->vidioc_s_parm) {
-			ret=vfd->vidioc_s_parm(file, fh, p);
-			dbgarg ("type=%d\n", p->type);
-		}
+		if (!vfd->vidioc_s_parm)
+			break;
+		dbgarg (cmd, "type=%d\n", p->type);
+		ret=vfd->vidioc_s_parm(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_TUNER:
 	{
 		struct v4l2_tuner *p=arg;
-		if (vfd->vidioc_g_tuner) {
-			ret=vfd->vidioc_g_tuner(file, fh, p);
-			dbgarg ("index=%d, name=%s, type=%d, capability=%d, "
-				"rangelow=%d, rangehigh=%d, signal=%d, afc=%d, "
-				"rxsubchans=%d, audmode=%d\n",
-				p->index, p->name, p->type,
-				p->capability, p->rangelow,p->rangehigh,
-				p->rxsubchans, p->audmode, p->signal,
-				p->afc);
-		}
+		if (!vfd->vidioc_g_tuner)
+			break;
+		ret=vfd->vidioc_g_tuner(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "index=%d, name=%s, type=%d, "
+					"capability=%d, rangelow=%d, "
+					"rangehigh=%d, signal=%d, afc=%d, "
+					"rxsubchans=%d, audmode=%d\n",
+					p->index, p->name, p->type,
+					p->capability, p->rangelow,
+					p->rangehigh, p->rxsubchans,
+					p->audmode, p->signal, p->afc);
 		break;
 	}
 	case VIDIOC_S_TUNER:
 	{
 		struct v4l2_tuner *p=arg;
-		if (vfd->vidioc_s_tuner) {
-			dbgarg ("index=%d, name=%s, type=%d, capability=%d, "
-				"rangelow=%d, rangehigh=%d, signal=%d, afc=%d, "
-				"rxsubchans=%d, audmode=%d\n",
-				p->index, p->name, p->type,
+		if (!vfd->vidioc_s_tuner)
+			break;
+		dbgarg (cmd, "index=%d, name=%s, type=%d, "
+				"capability=%d, rangelow=%d, rangehigh=%d, "
+				"signal=%d, afc=%d, rxsubchans=%d, "
+				"audmode=%d\n",p->index, p->name, p->type,
 				p->capability, p->rangelow,p->rangehigh,
 				p->rxsubchans, p->audmode, p->signal,
 				p->afc);
-			ret=vfd->vidioc_s_tuner(file, fh, p);
-		}
+		ret=vfd->vidioc_s_tuner(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_FREQUENCY:
 	{
 		struct v4l2_frequency *p=arg;
-		if (vfd->vidioc_g_frequency) {
-			dbgarg ("tuner=%d, type=%d, frequency=%d\n",
-				p->tuner,p->type,p->frequency);
-			ret=vfd->vidioc_g_frequency(file, fh, p);
-		}
+		if (!vfd->vidioc_g_frequency)
+			break;
+		ret=vfd->vidioc_g_frequency(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
+						p->tuner,p->type,p->frequency);
 		break;
 	}
 	case VIDIOC_S_FREQUENCY:
 	{
 		struct v4l2_frequency *p=arg;
-		if (vfd->vidioc_s_frequency) {
-			ret=vfd->vidioc_s_frequency(file, fh, p);
-			dbgarg ("tuner=%d, type=%d, frequency=%d\n",
+		if (!vfd->vidioc_s_frequency)
+			break;
+		dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
 				p->tuner,p->type,p->frequency);
-		}
+		ret=vfd->vidioc_s_frequency(file, fh, p);
 		break;
 	}
 	case VIDIOC_G_SLICED_VBI_CAP:
 	{
 		struct v4l2_sliced_vbi_cap *p=arg;
-		if (vfd->vidioc_g_sliced_vbi_cap) {
-			dbgarg ("service_set=%d\n", p->service_set);
-			ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
-		}
+		if (!vfd->vidioc_g_sliced_vbi_cap)
+			break;
+		ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
+		if (!ret)
+			dbgarg (cmd, "service_set=%d\n", p->service_set);
 		break;
 	}
 	case VIDIOC_LOG_STATUS:
 	{
-		if (vfd->vidioc_log_status) {
-			ret=vfd->vidioc_log_status(file, fh);
-		}
+		if (!vfd->vidioc_log_status)
+			break;
+		ret=vfd->vidioc_log_status(file, fh);
 		break;
 	}
 
@@ -1244,8 +1331,8 @@ static int __video_do_ioctl(struct inode *inode, struct file *file,
 
 	if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
 		if (ret<0) {
-			printk ("%s", vfd->name);
-			v4l_print_ioctl("(err):", cmd);
+			printk ("%s: err:\n", vfd->name);
+			v4l_print_ioctl(vfd->name, cmd);
 		}
 	}