V4L/DVB (3835): [PATCH] update pwc driver

Add v4l2 compatibility
Include the decompressor (legal problem has been resolv by Alan Cox)
Faster decoder and easier to maintain, optimize, ...
Can export to userland compressed stream
Support more cameras, lot of bugs are fixed.

Signed-off-by: Luc Saillard <luc@saillard.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

1 files changed, 387 insertions, 312 deletions

diff --git a/drivers/media/video/pwc/pwc-ctrl.c b/drivers/media/video/pwc/pwc-ctrl.c
index 4ba549bfa0e0..93306c717279 100644
--- a/drivers/media/video/pwc/pwc-ctrl.c
+++ b/drivers/media/video/pwc/pwc-ctrl.c
@@ -2,7 +2,7 @@
    Functions that send various control messages to the webcam, including
    video modes.
    (C) 1999-2003 Nemosoft Unv.
-   (C) 2004      Luc Saillard (luc@saillard.org)
+   (C) 2004-2006 Luc Saillard (luc@saillard.org)
 
    NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
    driver and thus may have bugs that are not present in the original version.
@@ -41,12 +41,14 @@
 #include <asm/uaccess.h>
 #endif
 #include <asm/errno.h>
+#include <linux/version.h>
 
 #include "pwc.h"
-#include "pwc-ioctl.h"
 #include "pwc-uncompress.h"
 #include "pwc-kiara.h"
 #include "pwc-timon.h"
+#include "pwc-dec1.h"
+#include "pwc-dec23.h"
 
 /* Request types: video */
 #define SET_LUM_CTL                     0x01
@@ -57,6 +59,10 @@
 #define GET_STATUS_CTL                  0x06
 #define SET_EP_STREAM_CTL               0x07
 #define GET_EP_STREAM_CTL               0x08
+#define GET_XX_CTL                      0x09
+#define SET_XX_CTL                      0x0A
+#define GET_XY_CTL                      0x0B
+#define SET_XY_CTL                      0x0C
 #define SET_MPT_CTL                     0x0D
 #define GET_MPT_CTL                     0x0E
 
@@ -93,12 +99,20 @@
 #define READ_SHUTTER_FORMATTER                  0x0600
 #define READ_RED_GAIN_FORMATTER                 0x0700
 #define READ_BLUE_GAIN_FORMATTER                0x0800
+#define GET_STATUS_B00                          0x0B00
 #define SENSOR_TYPE_FORMATTER1                  0x0C00
+#define GET_STATUS_3000                         0x3000
 #define READ_RAW_Y_MEAN_FORMATTER               0x3100
 #define SET_POWER_SAVE_MODE_FORMATTER           0x3200
 #define MIRROR_IMAGE_FORMATTER                  0x3300
 #define LED_FORMATTER                           0x3400
+#define LOWLIGHT                                0x3500
+#define GET_STATUS_3600                         0x3600
 #define SENSOR_TYPE_FORMATTER2                  0x3700
+#define GET_STATUS_3800                         0x3800
+#define GET_STATUS_4000                         0x4000
+#define GET_STATUS_4100                         0x4100  /* Get */
+#define CTL_STATUS_4200                         0x4200  /* [GS] 1 */
 
 /* Formatters for the Video Endpoint controls [GS]ET_EP_STREAM_CTL */
 #define VIDEO_OUTPUT_CONTROL_FORMATTER          0x0100
@@ -138,6 +152,7 @@ static struct Nala_table_entry Nala_table[PSZ_MAX][8] =
 #include "pwc-nala.h"
 };
 
+static void pwc_set_image_buffer_size(struct pwc_device *pdev);
 
 /****************************************************************************/
 
@@ -159,31 +174,7 @@ static struct Nala_table_entry Nala_table[PSZ_MAX][8] =
                 &buf, buflen, 500)
 
 
-#if PWC_DEBUG
-void pwc_hexdump(void *p, int len)
-{
-        int i;
-        unsigned char *s;
-        char buf[100], *d;
-
-        s = (unsigned char *)p;
-        d = buf;
-        *d = '\0';
-        Debug("Doing hexdump @ %p, %d bytes.\n", p, len);
-        for (i = 0; i < len; i++) {
-                d += sprintf(d, "%02X ", *s++);
-                if ((i & 0xF) == 0xF) {
-                        Debug("%s\n", buf);
-                        d = buf;
-                        *d = '\0';
-                }
-        }
-        if ((i & 0xF) != 0)
-                Debug("%s\n", buf);
-}
-#endif
-
-static inline int send_video_command(struct usb_device *udev, int index, void *buf, int buflen)
+static int send_video_command(struct usb_device *udev, int index, void *buf, int buflen)
 {
         return usb_control_msg(udev,
                 usb_sndctrlpipe(udev, 0),
@@ -196,7 +187,7 @@ static inline int send_video_command(struct usb_device *udev, int index, void *b
 
 
 
-static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
+static int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
 {
         unsigned char buf[3];
         int ret, fps;
@@ -229,34 +220,14 @@ static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int fra
         if (pEntry->alternate == 0)
                 return -EINVAL;
 
-        if (pEntry->compressed)
-                return -ENOENT; /* Not supported. */
-
         memcpy(buf, pEntry->mode, 3);
         ret = send_video_command(pdev->udev, pdev->vendpoint, buf, 3);
         if (ret < 0) {
-                Debug("Failed to send video command... %d\n", ret);
+                PWC_DEBUG_MODULE("Failed to send video command... %d\n", ret);
                 return ret;
         }
         if (pEntry->compressed && pdev->vpalette != VIDEO_PALETTE_RAW)
-         {
-           switch(pdev->type) {
-             case 645:
-             case 646:
-/*             pwc_dec1_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
-               break;
-
-             case 675:
-             case 680:
-             case 690:
-             case 720:
-             case 730:
-             case 740:
-             case 750:
-/*             pwc_dec23_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
-               break;
-           }
-        }
+                pwc_dec1_init(pdev->type, pdev->release, buf, pdev->decompress_data);
 
         pdev->cmd_len = 3;
         memcpy(pdev->cmd_buf, buf, 3);
@@ -283,7 +254,7 @@ static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int fra
 }
 
 
-static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
+static int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
 {
         unsigned char buf[13];
         const struct Timon_table_entry *pChoose;
@@ -315,8 +286,8 @@ static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int fr
         if (ret < 0)
                 return ret;
 
-/*      if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
-           pwc_dec23_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
+        if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
+                pwc_dec23_init(pdev, pdev->type, buf);
 
         pdev->cmd_len = 13;
         memcpy(pdev->cmd_buf, buf, 13);
@@ -336,7 +307,7 @@ static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int fr
 }
 
 
-static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
+static int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
 {
         const struct Kiara_table_entry *pChoose = NULL;
         int fps, ret;
@@ -350,21 +321,14 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
         fps = (frames / 5) - 1;
 
         /* special case: VGA @ 5 fps and snapshot is raw bayer mode */
-        if (size == PSZ_VGA && frames == 5 && snapshot)
+        if (size == PSZ_VGA && frames == 5 && snapshot && pdev->vpalette == VIDEO_PALETTE_RAW)
         {
                 /* Only available in case the raw palette is selected or
                    we have the decompressor available. This mode is
                    only available in compressed form
                 */
-                if (pdev->vpalette == VIDEO_PALETTE_RAW)
-                {
-                        Info("Choosing VGA/5 BAYER mode (%d).\n", pdev->vpalette);
-                        pChoose = &RawEntry;
-                }
-                else
-                {
-                        Info("VGA/5 BAYER mode _must_ have a decompressor available, or use RAW palette.\n");
-                }
+                PWC_DEBUG_SIZE("Choosing VGA/5 BAYER mode.\n");
+                pChoose = &RawEntry;
         }
         else
         {
@@ -372,6 +336,7 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
                    if the preferred ratio is not available.
                    Skip this step when using RAW modes.
                 */
+                snapshot = 0;
                 while (compression <= 3) {
                         pChoose = &Kiara_table[size][fps][compression];
                         if (pChoose->alternate != 0)
@@ -382,7 +347,7 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
         if (pChoose == NULL || pChoose->alternate == 0)
                 return -ENOENT; /* Not supported. */
 
-        Debug("Using alternate setting %d.\n", pChoose->alternate);
+        PWC_TRACE("Using alternate setting %d.\n", pChoose->alternate);
 
         /* usb_control_msg won't take staticly allocated arrays as argument?? */
         memcpy(buf, pChoose->mode, 12);
@@ -394,8 +359,8 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
         if (ret < 0)
                 return ret;
 
-/*      if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
-          pwc_dec23_init(pdev->type, pdev->release, buf, pdev->decompress_data); */
+        if (pChoose->bandlength > 0 && pdev->vpalette != VIDEO_PALETTE_RAW)
+                pwc_dec23_init(pdev, pdev->type, buf);
 
         pdev->cmd_len = 12;
         memcpy(pdev->cmd_buf, buf, 12);
@@ -410,49 +375,13 @@ static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int fr
                 pdev->frame_size = (pdev->vbandlength * pdev->image.y) / 4;
         else
                 pdev->frame_size = (pdev->image.x * pdev->image.y * 12) / 8;
+        PWC_TRACE("frame_size=%d, vframes=%d, vsize=%d, vsnapshot=%d, vbandlength=%d\n",
+            pdev->frame_size,pdev->vframes,pdev->vsize,pdev->vsnapshot,pdev->vbandlength);
         return 0;
 }
 
 
 
-static void pwc_set_image_buffer_size(struct pwc_device *pdev)
-{
-        int i, factor = 0, filler = 0;
-
-        /* for PALETTE_YUV420P */
-        switch(pdev->vpalette)
-        {
-        case VIDEO_PALETTE_YUV420P:
-                factor = 6;
-                filler = 128;
-                break;
-        case VIDEO_PALETTE_RAW:
-                factor = 6; /* can be uncompressed YUV420P */
-                filler = 0;
-                break;
-        }
-
-        /* Set sizes in bytes */
-        pdev->image.size = pdev->image.x * pdev->image.y * factor / 4;
-        pdev->view.size  = pdev->view.x  * pdev->view.y  * factor / 4;
-
-        /* Align offset, or you'll get some very weird results in
-           YUV420 mode... x must be multiple of 4 (to get the Y's in
-           place), and y even (or you'll mixup U & V). This is less of a
-           problem for YUV420P.
-         */
-        pdev->offset.x = ((pdev->view.x - pdev->image.x) / 2) & 0xFFFC;
-        pdev->offset.y = ((pdev->view.y - pdev->image.y) / 2) & 0xFFFE;
-
-        /* Fill buffers with gray or black */
-        for (i = 0; i < MAX_IMAGES; i++) {
-                if (pdev->image_ptr[i] != NULL)
-                        memset(pdev->image_ptr[i], filler, pdev->view.size);
-        }
-}
-
-
-
 /**
    @pdev: device structure
    @width: viewport width
@@ -465,50 +394,78 @@ int pwc_set_video_mode(struct pwc_device *pdev, int width, int height, int frame
 {
         int ret, size;
 
-        Trace(TRACE_FLOW, "set_video_mode(%dx%d @ %d, palette %d).\n", width, height, frames, pdev->vpalette);
+        PWC_DEBUG_FLOW("set_video_mode(%dx%d @ %d, palette %d).\n", width, height, frames, pdev->vpalette);
         size = pwc_decode_size(pdev, width, height);
         if (size < 0) {
-                Debug("Could not find suitable size.\n");
+                PWC_DEBUG_MODULE("Could not find suitable size.\n");
                 return -ERANGE;
         }
-        Debug("decode_size = %d.\n", size);
+        PWC_TRACE("decode_size = %d.\n", size);
 
-        ret = -EINVAL;
-        switch(pdev->type) {
-        case 645:
-        case 646:
+        if (DEVICE_USE_CODEC1(pdev->type)) {
                 ret = set_video_mode_Nala(pdev, size, frames);
-                break;
-
-        case 675:
-        case 680:
-        case 690:
-                ret = set_video_mode_Timon(pdev, size, frames, compression, snapshot);
-                break;
 
-        case 720:
-        case 730:
-        case 740:
-        case 750:
+        } else if (DEVICE_USE_CODEC3(pdev->type)) {
                 ret = set_video_mode_Kiara(pdev, size, frames, compression, snapshot);
-                break;
+
+        } else {
+                ret = set_video_mode_Timon(pdev, size, frames, compression, snapshot);
         }
         if (ret < 0) {
-                if (ret == -ENOENT)
-                        Info("Video mode %s@%d fps is only supported with the decompressor module (pwcx).\n", size2name[size], frames);
-                else {
-                        Err("Failed to set video mode %s@%d fps; return code = %d\n", size2name[size], frames, ret);
-                }
+                PWC_ERROR("Failed to set video mode %s@%d fps; return code = %d\n", size2name[size], frames, ret);
                 return ret;
         }
         pdev->view.x = width;
         pdev->view.y = height;
         pdev->frame_total_size = pdev->frame_size + pdev->frame_header_size + pdev->frame_trailer_size;
         pwc_set_image_buffer_size(pdev);
-        Trace(TRACE_SIZE, "Set viewport to %dx%d, image size is %dx%d.\n", width, height, pwc_image_sizes[size].x, pwc_image_sizes[size].y);
+        PWC_DEBUG_SIZE("Set viewport to %dx%d, image size is %dx%d.\n", width, height, pwc_image_sizes[size].x, pwc_image_sizes[size].y);
         return 0;
 }
 
+#define BLACK_Y 0
+#define BLACK_U 128
+#define BLACK_V 128
+
+static void pwc_set_image_buffer_size(struct pwc_device *pdev)
+{
+        int i, factor = 0;
+
+        /* for PALETTE_YUV420P */
+        switch(pdev->vpalette)
+        {
+        case VIDEO_PALETTE_YUV420P:
+                factor = 6;
+                break;
+        case VIDEO_PALETTE_RAW:
+                factor = 6; /* can be uncompressed YUV420P */
+                break;
+        }
+
+        /* Set sizes in bytes */
+        pdev->image.size = pdev->image.x * pdev->image.y * factor / 4;
+        pdev->view.size  = pdev->view.x  * pdev->view.y  * factor / 4;
+
+        /* Align offset, or you'll get some very weird results in
+           YUV420 mode... x must be multiple of 4 (to get the Y's in
+           place), and y even (or you'll mixup U & V). This is less of a
+           problem for YUV420P.
+         */
+        pdev->offset.x = ((pdev->view.x - pdev->image.x) / 2) & 0xFFFC;
+        pdev->offset.y = ((pdev->view.y - pdev->image.y) / 2) & 0xFFFE;
+
+        /* Fill buffers with black colors */
+        for (i = 0; i < pwc_mbufs; i++) {
+                unsigned char *p = pdev->image_data + pdev->images[i].offset;
+                memset(p, BLACK_Y, pdev->view.x * pdev->view.y);
+                p += pdev->view.x * pdev->view.y;
+                memset(p, BLACK_U, pdev->view.x * pdev->view.y/4);
+                p += pdev->view.x * pdev->view.y/4;
+                memset(p, BLACK_V, pdev->view.x * pdev->view.y/4);
+        }
+}
+
+
 
 /* BRIGHTNESS */
 
@@ -520,7 +477,7 @@ int pwc_get_brightness(struct pwc_device *pdev)
         ret = RecvControlMsg(GET_LUM_CTL, BRIGHTNESS_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        return buf << 9;
+        return buf;
 }
 
 int pwc_set_brightness(struct pwc_device *pdev, int value)
@@ -545,7 +502,7 @@ int pwc_get_contrast(struct pwc_device *pdev)
         ret = RecvControlMsg(GET_LUM_CTL, CONTRAST_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        return buf << 10;
+        return buf;
 }
 
 int pwc_set_contrast(struct pwc_device *pdev, int value)
@@ -570,7 +527,7 @@ int pwc_get_gamma(struct pwc_device *pdev)
         ret = RecvControlMsg(GET_LUM_CTL, GAMMA_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        return buf << 11;
+        return buf;
 }
 
 int pwc_set_gamma(struct pwc_device *pdev, int value)
@@ -588,37 +545,47 @@ int pwc_set_gamma(struct pwc_device *pdev, int value)
 
 /* SATURATION */
 
-int pwc_get_saturation(struct pwc_device *pdev)
+/* return a value between [-100 , 100] */
+int pwc_get_saturation(struct pwc_device *pdev, int *value)
 {
         char buf;
-        int ret;
+        int ret, saturation_register;
 
         if (pdev->type < 675)
-                return -1;
-        ret = RecvControlMsg(GET_CHROM_CTL, pdev->type < 730 ? SATURATION_MODE_FORMATTER2 : SATURATION_MODE_FORMATTER1, 1);
+                return -EINVAL;
+        if (pdev->type < 730)
+                saturation_register = SATURATION_MODE_FORMATTER2;
+        else
+                saturation_register = SATURATION_MODE_FORMATTER1;
+        ret = RecvControlMsg(GET_CHROM_CTL, saturation_register, 1);
         if (ret < 0)
                 return ret;
-        return 32768 + buf * 327;
+        *value = (signed)buf;
+        return 0;
 }
 
+/* @param value saturation color between [-100 , 100] */
 int pwc_set_saturation(struct pwc_device *pdev, int value)
 {
         char buf;
+        int saturation_register;
 
         if (pdev->type < 675)
                 return -EINVAL;
-        if (value < 0)
-                value = 0;
-        if (value > 0xffff)
-                value = 0xffff;
-        /* saturation ranges from -100 to +100 */
-        buf = (value - 32768) / 327;
-        return SendControlMsg(SET_CHROM_CTL, pdev->type < 730 ? SATURATION_MODE_FORMATTER2 : SATURATION_MODE_FORMATTER1, 1);
+        if (value < -100)
+                value = -100;
+        if (value > 100)
+                value = 100;
+        if (pdev->type < 730)
+                saturation_register = SATURATION_MODE_FORMATTER2;
+        else
+                saturation_register = SATURATION_MODE_FORMATTER1;
+        return SendControlMsg(SET_CHROM_CTL, saturation_register, 1);
 }
 
 /* AGC */
 
-static inline int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
+int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
 {
         char buf;
         int ret;
@@ -643,7 +610,7 @@ static inline int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
         return 0;
 }
 
-static inline int pwc_get_agc(struct pwc_device *pdev, int *value)
+int pwc_get_agc(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -673,7 +640,7 @@ static inline int pwc_get_agc(struct pwc_device *pdev, int *value)
         return 0;
 }
 
-static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
+int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
 {
         char buf[2];
         int speed, ret;
@@ -691,23 +658,16 @@ static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int v
                         value = 0;
                 if (value > 0xffff)
                         value = 0xffff;
-                switch(pdev->type) {
-                case 675:
-                case 680:
-                case 690:
+
+                if (DEVICE_USE_CODEC2(pdev->type)) {
                         /* speed ranges from 0x0 to 0x290 (656) */
                         speed = (value / 100);
                         buf[1] = speed >> 8;
                         buf[0] = speed & 0xff;
-                        break;
-                case 720:
-                case 730:
-                case 740:
-                case 750:
+                } else if (DEVICE_USE_CODEC3(pdev->type)) {
                         /* speed seems to range from 0x0 to 0xff */
                         buf[1] = 0;
                         buf[0] = value >> 8;
-                        break;
                 }
 
                 ret = SendControlMsg(SET_LUM_CTL, PRESET_SHUTTER_FORMATTER, 2);
@@ -715,6 +675,25 @@ static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int v
         return ret;
 }
 
+/* This function is not exported to v4l1, so output values between 0 -> 256 */
+int pwc_get_shutter_speed(struct pwc_device *pdev, int *value)
+{
+        unsigned char buf[2];
+        int ret;
+
+        ret = RecvControlMsg(GET_STATUS_CTL, READ_SHUTTER_FORMATTER, 2);
+        if (ret < 0)
+                return ret;
+        *value = buf[0] + (buf[1] << 8);
+        if (DEVICE_USE_CODEC2(pdev->type)) {
+                /* speed ranges from 0x0 to 0x290 (656) */
+                *value *= 256/656;
+        } else if (DEVICE_USE_CODEC3(pdev->type)) {
+                /* speed seems to range from 0x0 to 0xff */
+        }
+        return 0;
+}
+
 
 /* POWER */
 
@@ -736,19 +715,19 @@ int pwc_camera_power(struct pwc_device *pdev, int power)
 
 /* private calls */
 
-static inline int pwc_restore_user(struct pwc_device *pdev)
+int pwc_restore_user(struct pwc_device *pdev)
 {
         char buf; /* dummy */
         return SendControlMsg(SET_STATUS_CTL, RESTORE_USER_DEFAULTS_FORMATTER, 0);
 }
 
-static inline int pwc_save_user(struct pwc_device *pdev)
+int pwc_save_user(struct pwc_device *pdev)
 {
         char buf; /* dummy */
         return SendControlMsg(SET_STATUS_CTL, SAVE_USER_DEFAULTS_FORMATTER, 0);
 }
 
-static inline int pwc_restore_factory(struct pwc_device *pdev)
+int pwc_restore_factory(struct pwc_device *pdev)
 {
         char buf; /* dummy */
         return SendControlMsg(SET_STATUS_CTL, RESTORE_FACTORY_DEFAULTS_FORMATTER, 0);
@@ -766,7 +745,7 @@ static inline int pwc_restore_factory(struct pwc_device *pdev)
   * 03: manual
   * 04: auto
   */
-static inline int pwc_set_awb(struct pwc_device *pdev, int mode)
+int pwc_set_awb(struct pwc_device *pdev, int mode)
 {
         char buf;
         int ret;
@@ -786,7 +765,7 @@ static inline int pwc_set_awb(struct pwc_device *pdev, int mode)
         return 0;
 }
 
-static inline int pwc_get_awb(struct pwc_device *pdev)
+int pwc_get_awb(struct pwc_device *pdev)
 {
         unsigned char buf;
         int ret;
@@ -798,7 +777,7 @@ static inline int pwc_get_awb(struct pwc_device *pdev)
         return buf;
 }
 
-static inline int pwc_set_red_gain(struct pwc_device *pdev, int value)
+int pwc_set_red_gain(struct pwc_device *pdev, int value)
 {
         unsigned char buf;
 
@@ -811,7 +790,7 @@ static inline int pwc_set_red_gain(struct pwc_device *pdev, int value)
         return SendControlMsg(SET_CHROM_CTL, PRESET_MANUAL_RED_GAIN_FORMATTER, 1);
 }
 
-static inline int pwc_get_red_gain(struct pwc_device *pdev, int *value)
+int pwc_get_red_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -824,7 +803,7 @@ static inline int pwc_get_red_gain(struct pwc_device *pdev, int *value)
 }
 
 
-static inline int pwc_set_blue_gain(struct pwc_device *pdev, int value)
+int pwc_set_blue_gain(struct pwc_device *pdev, int value)
 {
         unsigned char buf;
 
@@ -837,7 +816,7 @@ static inline int pwc_set_blue_gain(struct pwc_device *pdev, int value)
         return SendControlMsg(SET_CHROM_CTL, PRESET_MANUAL_BLUE_GAIN_FORMATTER, 1);
 }
 
-static inline int pwc_get_blue_gain(struct pwc_device *pdev, int *value)
+int pwc_get_blue_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -854,7 +833,7 @@ static inline int pwc_get_blue_gain(struct pwc_device *pdev, int *value)
    internal red/blue gains, which may be different from the manual
    gains set or read above.
  */
-static inline int pwc_read_red_gain(struct pwc_device *pdev, int *value)
+static int pwc_read_red_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -866,7 +845,7 @@ static inline int pwc_read_red_gain(struct pwc_device *pdev, int *value)
         return 0;
 }
 
-static inline int pwc_read_blue_gain(struct pwc_device *pdev, int *value)
+static int pwc_read_blue_gain(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -879,7 +858,7 @@ static inline int pwc_read_blue_gain(struct pwc_device *pdev, int *value)
 }
 
 
-static inline int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
+static int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
 {
         unsigned char buf;
 
@@ -888,7 +867,7 @@ static inline int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
         return SendControlMsg(SET_CHROM_CTL, AWB_CONTROL_SPEED_FORMATTER, 1);
 }
 
-static inline int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
+static int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -901,7 +880,7 @@ static inline int pwc_get_wb_speed(struct pwc_device *pdev, int *value)
 }
 
 
-static inline int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
+static int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
 {
         unsigned char buf;
 
@@ -910,7 +889,7 @@ static inline int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
         return SendControlMsg(SET_CHROM_CTL, AWB_CONTROL_DELAY_FORMATTER, 1);
 }
 
-static inline int pwc_get_wb_delay(struct pwc_device *pdev, int *value)
+static int pwc_get_wb_delay(struct pwc_device *pdev, int *value)
 {
         unsigned char buf;
         int ret;
@@ -946,7 +925,7 @@ int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value)
         return SendControlMsg(SET_STATUS_CTL, LED_FORMATTER, 2);
 }
 
-static int pwc_get_leds(struct pwc_device *pdev, int *on_value, int *off_value)
+int pwc_get_leds(struct pwc_device *pdev, int *on_value, int *off_value)
 {
         unsigned char buf[2];
         int ret;
@@ -965,7 +944,7 @@ static int pwc_get_leds(struct pwc_device *pdev, int *on_value, int *off_value)
         return 0;
 }
 
-static inline int pwc_set_contour(struct pwc_device *pdev, int contour)
+int pwc_set_contour(struct pwc_device *pdev, int contour)
 {
         unsigned char buf;
         int ret;
@@ -990,7 +969,7 @@ static inline int pwc_set_contour(struct pwc_device *pdev, int contour)
         return 0;
 }
 
-static inline int pwc_get_contour(struct pwc_device *pdev, int *contour)
+int pwc_get_contour(struct pwc_device *pdev, int *contour)
 {
         unsigned char buf;
         int ret;
@@ -1012,7 +991,7 @@ static inline int pwc_get_contour(struct pwc_device *pdev, int *contour)
 }
 
 
-static inline int pwc_set_backlight(struct pwc_device *pdev, int backlight)
+int pwc_set_backlight(struct pwc_device *pdev, int backlight)
 {
         unsigned char buf;
 
@@ -1023,7 +1002,7 @@ static inline int pwc_set_backlight(struct pwc_device *pdev, int backlight)
         return SendControlMsg(SET_LUM_CTL, BACK_LIGHT_COMPENSATION_FORMATTER, 1);
 }
 
-static inline int pwc_get_backlight(struct pwc_device *pdev, int *backlight)
+int pwc_get_backlight(struct pwc_device *pdev, int *backlight)
 {
         int ret;
         unsigned char buf;
@@ -1031,12 +1010,35 @@ static inline int pwc_get_backlight(struct pwc_device *pdev, int *backlight)
         ret = RecvControlMsg(GET_LUM_CTL, BACK_LIGHT_COMPENSATION_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        *backlight = buf;
+        *backlight = !!buf;
+        return 0;
+}
+
+int pwc_set_colour_mode(struct pwc_device *pdev, int colour)
+{
+        unsigned char buf;
+
+        if (colour)
+                buf = 0xff;
+        else
+                buf = 0x0;
+        return SendControlMsg(SET_CHROM_CTL, COLOUR_MODE_FORMATTER, 1);
+}
+
+int pwc_get_colour_mode(struct pwc_device *pdev, int *colour)
+{
+        int ret;
+        unsigned char buf;
+
+        ret = RecvControlMsg(GET_CHROM_CTL, COLOUR_MODE_FORMATTER, 1);
+        if (ret < 0)
+                return ret;
+        *colour = !!buf;
         return 0;
 }
 
 
-static inline int pwc_set_flicker(struct pwc_device *pdev, int flicker)
+int pwc_set_flicker(struct pwc_device *pdev, int flicker)
 {
         unsigned char buf;
 
@@ -1047,7 +1049,7 @@ static inline int pwc_set_flicker(struct pwc_device *pdev, int flicker)
         return SendControlMsg(SET_LUM_CTL, FLICKERLESS_MODE_FORMATTER, 1);
 }
 
-static inline int pwc_get_flicker(struct pwc_device *pdev, int *flicker)
+int pwc_get_flicker(struct pwc_device *pdev, int *flicker)
 {
         int ret;
         unsigned char buf;
@@ -1055,12 +1057,11 @@ static inline int pwc_get_flicker(struct pwc_device *pdev, int *flicker)
         ret = RecvControlMsg(GET_LUM_CTL, FLICKERLESS_MODE_FORMATTER, 1);
         if (ret < 0)
                 return ret;
-        *flicker = buf;
+        *flicker = !!buf;
         return 0;
 }
 
-
-static inline int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
+int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
 {
         unsigned char buf;
 
@@ -1072,7 +1073,7 @@ static inline int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
         return SendControlMsg(SET_LUM_CTL, DYNAMIC_NOISE_CONTROL_FORMATTER, 1);
 }
 
-static inline int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise)
+int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise)
 {
         int ret;
         unsigned char buf;
@@ -1084,7 +1085,7 @@ static inline int pwc_get_dynamic_noise(struct pwc_device *pdev, int *noise)
         return 0;
 }
 
-static int pwc_mpt_reset(struct pwc_device *pdev, int flags)
+static int _pwc_mpt_reset(struct pwc_device *pdev, int flags)
 {
         unsigned char buf;
 
@@ -1092,7 +1093,18 @@ static int pwc_mpt_reset(struct pwc_device *pdev, int flags)
         return SendControlMsg(SET_MPT_CTL, PT_RESET_CONTROL_FORMATTER, 1);
 }
 
-static inline int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
+int pwc_mpt_reset(struct pwc_device *pdev, int flags)
+{
+        int ret;
+        ret = _pwc_mpt_reset(pdev, flags);
+        if (ret >= 0) {
+                pdev->pan_angle = 0;
+                pdev->tilt_angle = 0;
+        }
+        return ret;
+}
+
+static int _pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
 {
         unsigned char buf[4];
 
@@ -1110,7 +1122,35 @@ static inline int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
         return SendControlMsg(SET_MPT_CTL, PT_RELATIVE_CONTROL_FORMATTER, 4);
 }
 
-static inline int pwc_mpt_get_status(struct pwc_device *pdev, struct pwc_mpt_status *status)
+int pwc_mpt_set_angle(struct pwc_device *pdev, int pan, int tilt)
+{
+        int ret;
+
+        /* check absolute ranges */
+        if (pan  < pdev->angle_range.pan_min  ||
+            pan  > pdev->angle_range.pan_max  ||
+            tilt < pdev->angle_range.tilt_min ||
+            tilt > pdev->angle_range.tilt_max)
+                return -ERANGE;
+
+        /* go to relative range, check again */
+        pan  -= pdev->pan_angle;
+        tilt -= pdev->tilt_angle;
+        /* angles are specified in degrees * 100, thus the limit = 36000 */
+        if (pan < -36000 || pan > 36000 || tilt < -36000 || tilt > 36000)
+                return -ERANGE;
+
+        ret = _pwc_mpt_set_angle(pdev, pan, tilt);
+        if (ret >= 0) {
+                pdev->pan_angle  += pan;
+                pdev->tilt_angle += tilt;
+        }
+        if (ret == -EPIPE) /* stall -> out of range */
+                ret = -ERANGE;
+        return ret;
+}
+
+static int pwc_mpt_get_status(struct pwc_device *pdev, struct pwc_mpt_status *status)
 {
         int ret;
         unsigned char buf[5];
@@ -1151,6 +1191,26 @@ int pwc_get_cmos_sensor(struct pwc_device *pdev, int *sensor)
  /* End of Add-Ons                                    */
  /* ************************************************* */
 
+/* Linux 2.5.something and 2.6 pass direct pointers to arguments of
+   ioctl() calls. With 2.4, you have to do tedious copy_from_user()
+   and copy_to_user() calls. With these macros we circumvent this,
+   and let me maintain only one source file. The functionality is
+   exactly the same otherwise.
+ */
+
+
+/* define local variable for arg */
+#define ARG_DEF(ARG_type, ARG_name)\
+        ARG_type *ARG_name = arg;
+/* copy arg to local variable */
+#define ARG_IN(ARG_name) /* nothing */
+/* argument itself (referenced) */
+#define ARGR(ARG_name) (*ARG_name)
+/* argument address */
+#define ARGA(ARG_name) ARG_name
+/* copy local variable to arg */
+#define ARG_OUT(ARG_name) /* nothing */
+
 
 int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 {
@@ -1180,206 +1240,243 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
         case VIDIOCPWCSCQUAL:
         {
-                int *qual = arg;
+                ARG_DEF(int, qual)
 
-                if (*qual < 0 || *qual > 3)
+                ARG_IN(qual)
+                if (ARGR(qual) < 0 || ARGR(qual) > 3)
                         ret = -EINVAL;
                 else
-                        ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, *qual, pdev->vsnapshot);
+                        ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, ARGR(qual), pdev->vsnapshot);
                 if (ret >= 0)
-                        pdev->vcompression = *qual;
+                        pdev->vcompression = ARGR(qual);
                 break;
         }
 
         case VIDIOCPWCGCQUAL:
         {
-                int *qual = arg;
-                *qual = pdev->vcompression;
+                ARG_DEF(int, qual)
+
+                ARGR(qual) = pdev->vcompression;
+                ARG_OUT(qual)
                 break;
         }
 
         case VIDIOCPWCPROBE:
         {
-                struct pwc_probe *probe = arg;
-                strcpy(probe->name, pdev->vdev->name);
-                probe->type = pdev->type;
+                ARG_DEF(struct pwc_probe, probe)
+
+                strcpy(ARGR(probe).name, pdev->vdev->name);
+                ARGR(probe).type = pdev->type;
+                ARG_OUT(probe)
                 break;
         }
 
         case VIDIOCPWCGSERIAL:
         {
-                struct pwc_serial *serial = arg;
-                strcpy(serial->serial, pdev->serial);
+                ARG_DEF(struct pwc_serial, serial)
+
+                strcpy(ARGR(serial).serial, pdev->serial);
+                ARG_OUT(serial)
                 break;
         }
 
         case VIDIOCPWCSAGC:
         {
-                int *agc = arg;
-                if (pwc_set_agc(pdev, *agc < 0 ? 1 : 0, *agc))
+                ARG_DEF(int, agc)
+
+                ARG_IN(agc)
+                if (pwc_set_agc(pdev, ARGR(agc) < 0 ? 1 : 0, ARGR(agc)))
                         ret = -EINVAL;
                 break;
         }
 
         case VIDIOCPWCGAGC:
         {
-                int *agc = arg;
+                ARG_DEF(int, agc)
 
-                if (pwc_get_agc(pdev, agc))
+                if (pwc_get_agc(pdev, ARGA(agc)))
                         ret = -EINVAL;
+                ARG_OUT(agc)
                 break;
         }
 
         case VIDIOCPWCSSHUTTER:
         {
-                int *shutter_speed = arg;
-                ret = pwc_set_shutter_speed(pdev, *shutter_speed < 0 ? 1 : 0, *shutter_speed);
+                ARG_DEF(int, shutter_speed)
+
+                ARG_IN(shutter_speed)
+                ret = pwc_set_shutter_speed(pdev, ARGR(shutter_speed) < 0 ? 1 : 0, ARGR(shutter_speed));
                 break;
         }
 
         case VIDIOCPWCSAWB:
         {
-                struct pwc_whitebalance *wb = arg;
+                ARG_DEF(struct pwc_whitebalance, wb)
 
-                ret = pwc_set_awb(pdev, wb->mode);
-                if (ret >= 0 && wb->mode == PWC_WB_MANUAL) {
-                        pwc_set_red_gain(pdev, wb->manual_red);
-                        pwc_set_blue_gain(pdev, wb->manual_blue);
+                ARG_IN(wb)
+                ret = pwc_set_awb(pdev, ARGR(wb).mode);
+                if (ret >= 0 && ARGR(wb).mode == PWC_WB_MANUAL) {
+                        pwc_set_red_gain(pdev, ARGR(wb).manual_red);
+                        pwc_set_blue_gain(pdev, ARGR(wb).manual_blue);
                 }
                 break;
         }
 
         case VIDIOCPWCGAWB:
         {
-                struct pwc_whitebalance *wb = arg;
+                ARG_DEF(struct pwc_whitebalance, wb)
 
-                memset(wb, 0, sizeof(struct pwc_whitebalance));
-                wb->mode = pwc_get_awb(pdev);
-                if (wb->mode < 0)
+                memset(ARGA(wb), 0, sizeof(struct pwc_whitebalance));
+                ARGR(wb).mode = pwc_get_awb(pdev);
+                if (ARGR(wb).mode < 0)
                         ret = -EINVAL;
                 else {
-                        if (wb->mode == PWC_WB_MANUAL) {
-                                ret = pwc_get_red_gain(pdev, &wb->manual_red);
+                        if (ARGR(wb).mode == PWC_WB_MANUAL) {
+                                ret = pwc_get_red_gain(pdev, &ARGR(wb).manual_red);
                                 if (ret < 0)
                                         break;
-                                ret = pwc_get_blue_gain(pdev, &wb->manual_blue);
+                                ret = pwc_get_blue_gain(pdev, &ARGR(wb).manual_blue);
                                 if (ret < 0)
                                         break;
                         }
-                        if (wb->mode == PWC_WB_AUTO) {
-                                ret = pwc_read_red_gain(pdev, &wb->read_red);
+                        if (ARGR(wb).mode == PWC_WB_AUTO) {
+                                ret = pwc_read_red_gain(pdev, &ARGR(wb).read_red);
                                 if (ret < 0)
                                         break;
-                                ret = pwc_read_blue_gain(pdev, &wb->read_blue);
+                                ret =pwc_read_blue_gain(pdev, &ARGR(wb).read_blue);
                                 if (ret < 0)
                                         break;
                         }
                 }
+                ARG_OUT(wb)
                 break;
         }
 
         case VIDIOCPWCSAWBSPEED:
         {
-                struct pwc_wb_speed *wbs = arg;
+                ARG_DEF(struct pwc_wb_speed, wbs)
 
-                if (wbs->control_speed > 0) {
-                        ret = pwc_set_wb_speed(pdev, wbs->control_speed);
+                if (ARGR(wbs).control_speed > 0) {
+                        ret = pwc_set_wb_speed(pdev, ARGR(wbs).control_speed);
                 }
-                if (wbs->control_delay > 0) {
-                        ret = pwc_set_wb_delay(pdev, wbs->control_delay);
+                if (ARGR(wbs).control_delay > 0) {
+                        ret = pwc_set_wb_delay(pdev, ARGR(wbs).control_delay);
                 }
                 break;
         }
 
         case VIDIOCPWCGAWBSPEED:
         {
-                struct pwc_wb_speed *wbs = arg;
+                ARG_DEF(struct pwc_wb_speed, wbs)
 
-                ret = pwc_get_wb_speed(pdev, &wbs->control_speed);
+                ret = pwc_get_wb_speed(pdev, &ARGR(wbs).control_speed);
                 if (ret < 0)
                         break;
-                ret = pwc_get_wb_delay(pdev, &wbs->control_delay);
+                ret = pwc_get_wb_delay(pdev, &ARGR(wbs).control_delay);
                 if (ret < 0)
                         break;
+                ARG_OUT(wbs)
                 break;
         }
 
         case VIDIOCPWCSLED:
         {
-                struct pwc_leds *leds = arg;
-                ret = pwc_set_leds(pdev, leds->led_on, leds->led_off);
+                ARG_DEF(struct pwc_leds, leds)
+
+                ARG_IN(leds)
+                ret = pwc_set_leds(pdev, ARGR(leds).led_on, ARGR(leds).led_off);
                 break;
         }
 
 
         case VIDIOCPWCGLED:
         {
-                struct pwc_leds *leds = arg;
-                ret = pwc_get_leds(pdev, &leds->led_on, &leds->led_off);
+                ARG_DEF(struct pwc_leds, leds)
+
+                ret = pwc_get_leds(pdev, &ARGR(leds).led_on, &ARGR(leds).led_off);
+                ARG_OUT(leds)
                 break;
         }
 
         case VIDIOCPWCSCONTOUR:
         {
-                int *contour = arg;
-                ret = pwc_set_contour(pdev, *contour);
+                ARG_DEF(int, contour)
+
+                ARG_IN(contour)
+                ret = pwc_set_contour(pdev, ARGR(contour));
                 break;
         }
 
         case VIDIOCPWCGCONTOUR:
         {
-                int *contour = arg;
-                ret = pwc_get_contour(pdev, contour);
+                ARG_DEF(int, contour)
+
+                ret = pwc_get_contour(pdev, ARGA(contour));
+                ARG_OUT(contour)
                 break;
         }
 
         case VIDIOCPWCSBACKLIGHT:
         {
-                int *backlight = arg;
-                ret = pwc_set_backlight(pdev, *backlight);
+                ARG_DEF(int, backlight)
+
+                ARG_IN(backlight)
+                ret = pwc_set_backlight(pdev, ARGR(backlight));
                 break;
         }
 
         case VIDIOCPWCGBACKLIGHT:
         {
-                int *backlight = arg;
-                ret = pwc_get_backlight(pdev, backlight);
+                ARG_DEF(int, backlight)
+
+                ret = pwc_get_backlight(pdev, ARGA(backlight));
+                ARG_OUT(backlight)
                 break;
         }
 
         case VIDIOCPWCSFLICKER:
         {
-                int *flicker = arg;
-                ret = pwc_set_flicker(pdev, *flicker);
+                ARG_DEF(int, flicker)
+
+                ARG_IN(flicker)
+                ret = pwc_set_flicker(pdev, ARGR(flicker));
                 break;
         }
 
         case VIDIOCPWCGFLICKER:
         {
-                int *flicker = arg;
-                ret = pwc_get_flicker(pdev, flicker);
+                ARG_DEF(int, flicker)
+
+                ret = pwc_get_flicker(pdev, ARGA(flicker));
+                ARG_OUT(flicker)
                 break;
         }
 
         case VIDIOCPWCSDYNNOISE:
         {
-                int *dynnoise = arg;
-                ret = pwc_set_dynamic_noise(pdev, *dynnoise);
+                ARG_DEF(int, dynnoise)
+
+                ARG_IN(dynnoise)
+                ret = pwc_set_dynamic_noise(pdev, ARGR(dynnoise));
                 break;
         }
 
         case VIDIOCPWCGDYNNOISE:
         {
-                int *dynnoise = arg;
-                ret = pwc_get_dynamic_noise(pdev, dynnoise);
+                ARG_DEF(int, dynnoise)
+
+                ret = pwc_get_dynamic_noise(pdev, ARGA(dynnoise));
+                ARG_OUT(dynnoise);
                 break;
         }
 
         case VIDIOCPWCGREALSIZE:
         {
-                struct pwc_imagesize *size = arg;
-                size->width = pdev->image.x;
-                size->height = pdev->image.y;
+                ARG_DEF(struct pwc_imagesize, size)
+
+                ARGR(size).width = pdev->image.x;
+                ARGR(size).height = pdev->image.y;
+                ARG_OUT(size)
                 break;
         }
 
@@ -1387,14 +1484,10 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
         {
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        int *flags = arg;
+                        ARG_DEF(int, flags)
 
-                        ret = pwc_mpt_reset(pdev, *flags);
-                        if (ret >= 0)
-                        {
-                                pdev->pan_angle = 0;
-                                pdev->tilt_angle = 0;
-                        }
+                        ARG_IN(flags)
+                        ret = pwc_mpt_reset(pdev, ARGR(flags));
                 }
                 else
                 {
@@ -1407,8 +1500,10 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
         {
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_range *range = arg;
-                        *range = pdev->angle_range;
+                        ARG_DEF(struct pwc_mpt_range, range)
+
+                        ARGR(range) = pdev->angle_range;
+                        ARG_OUT(range)
                 }
                 else
                 {
@@ -1423,48 +1518,23 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_angles *angles = arg;
+                        ARG_DEF(struct pwc_mpt_angles, angles)
+
+                        ARG_IN(angles)
                         /* The camera can only set relative angles, so
                            do some calculations when getting an absolute angle .
                          */
-                        if (angles->absolute)
+                        if (ARGR(angles).absolute)
                         {
-                                new_pan  = angles->pan;
-                                new_tilt = angles->tilt;
+                                new_pan  = ARGR(angles).pan;
+                                new_tilt = ARGR(angles).tilt;
                         }
                         else
                         {
-                                new_pan  = pdev->pan_angle  + angles->pan;
-                                new_tilt = pdev->tilt_angle + angles->tilt;
-                        }
-                        /* check absolute ranges */
-                        if (new_pan  < pdev->angle_range.pan_min  ||
-                            new_pan  > pdev->angle_range.pan_max  ||
-                            new_tilt < pdev->angle_range.tilt_min ||
-                            new_tilt > pdev->angle_range.tilt_max)
-                        {
-                                ret = -ERANGE;
-                        }
-                        else
-                        {
-                                /* go to relative range, check again */
-                                new_pan  -= pdev->pan_angle;
-                                new_tilt -= pdev->tilt_angle;
-                                /* angles are specified in degrees * 100, thus the limit = 36000 */
-                                if (new_pan < -36000 || new_pan > 36000 || new_tilt < -36000 || new_tilt > 36000)
-                                        ret = -ERANGE;
-                        }
-                        if (ret == 0) /* no errors so far */
-                        {
-                                ret = pwc_mpt_set_angle(pdev, new_pan, new_tilt);
-                                if (ret >= 0)
-                                {
-                                        pdev->pan_angle  += new_pan;
-                                        pdev->tilt_angle += new_tilt;
-                                }
-                                if (ret == -EPIPE) /* stall -> out of range */
-                                        ret = -ERANGE;
+                                new_pan  = pdev->pan_angle  + ARGR(angles).pan;
+                                new_tilt = pdev->tilt_angle + ARGR(angles).tilt;
                         }
+                        ret = pwc_mpt_set_angle(pdev, new_pan, new_tilt);
                 }
                 else
                 {
@@ -1478,11 +1548,12 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_angles *angles = arg;
+                        ARG_DEF(struct pwc_mpt_angles, angles)
 
-                        angles->absolute = 1;
-                        angles->pan  = pdev->pan_angle;
-                        angles->tilt = pdev->tilt_angle;
+                        ARGR(angles).absolute = 1;
+                        ARGR(angles).pan  = pdev->pan_angle;
+                        ARGR(angles).tilt = pdev->tilt_angle;
+                        ARG_OUT(angles)
                 }
                 else
                 {
@@ -1495,8 +1566,10 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
         {
                 if (pdev->features & FEATURE_MOTOR_PANTILT)
                 {
-                        struct pwc_mpt_status *status = arg;
-                        ret = pwc_mpt_get_status(pdev, status);
+                        ARG_DEF(struct pwc_mpt_status, status)
+
+                        ret = pwc_mpt_get_status(pdev, ARGA(status));
+                        ARG_OUT(status)
                 }
                 else
                 {
@@ -1507,22 +1580,24 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 
         case VIDIOCPWCGVIDCMD:
         {
-                struct pwc_video_command *cmd = arg;
-
-                cmd->type = pdev->type;
-                cmd->release = pdev->release;
-                cmd->command_len = pdev->cmd_len;
-                memcpy(&cmd->command_buf, pdev->cmd_buf, pdev->cmd_len);
-                cmd->bandlength = pdev->vbandlength;
-                cmd->frame_size = pdev->frame_size;
+                ARG_DEF(struct pwc_video_command, cmd);
+
+                ARGR(cmd).type = pdev->type;
+                ARGR(cmd).release = pdev->release;
+                ARGR(cmd).command_len = pdev->cmd_len;
+                memcpy(&ARGR(cmd).command_buf, pdev->cmd_buf, pdev->cmd_len);
+                ARGR(cmd).bandlength = pdev->vbandlength;
+                ARGR(cmd).frame_size = pdev->frame_size;
+                ARG_OUT(cmd)
                 break;
         }
        /*
         case VIDIOCPWCGVIDTABLE:
         {
-                struct pwc_table_init_buffer *table = arg;
-                table->len = pdev->cmd_len;
-                memcpy(&table->buffer, pdev->decompress_data, pdev->decompressor->table_size);
+                ARG_DEF(struct pwc_table_init_buffer, table);
+                ARGR(table).len = pdev->cmd_len;
+                memcpy(&ARGR(table).buffer, pdev->decompress_data, pdev->decompressor->table_size);
+                ARG_OUT(table)
                 break;
         }
         */
@@ -1538,4 +1613,4 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
 }
 
 
-
+/* vim: set cinoptions= formatoptions=croql cindent shiftwidth=8 tabstop=8: */