redonkable/remarkable-linux
redonkable/remarkable-linux
1
0
Fork 0
Code Releases Activity

[PATCH] USB: Remove LINUX_VERSION_CODE check in pwc/pwc-ctrl.c

Browse source 
this patch removes compatibility with 2.4 kernel, which makes
the code much easier to read.

Signed-off-by: Eric Sesterhenn <snakebyte@gmx.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
Eric Sesterhenn / snakebyte 2006-01-04 18:10:44 +01:00 committed by Greg Kroah-Hartman
parent 9790636927
commit 52ea1619d5
1 changed files with 89 additions and 175 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

264
drivers/usb/media/pwc/pwc-ctrl.c
View file

@ -1152,45 +1152,6 @@ 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.
*/
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 0)
/* 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 */
#else
#define ARG_DEF(ARG_type, ARG_name)\
ARG_type ARG_name;
#define ARG_IN(ARG_name)\
if (copy_from_user(&ARG_name, arg, sizeof(ARG_name))) {\
ret = -EFAULT;\
break;\
}
#define ARGR(ARG_name) ARG_name
#define ARGA(ARG_name) &ARG_name
#define ARG_OUT(ARG_name)\
if (copy_to_user(arg, &ARG_name, sizeof(ARG_name))) {\
ret = -EFAULT;\
break;\
}
#endif
int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
{
@ -1220,243 +1181,206 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
case VIDIOCPWCSCQUAL:
{
ARG_DEF(int, qual)
int *qual = arg;
ARG_IN(qual)
if (ARGR(qual) < 0 || ARGR(qual) > 3)
if (*qual < 0 || *qual > 3)
ret = -EINVAL;
else
ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, ARGR(qual), pdev->vsnapshot);
ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, *qual, pdev->vsnapshot);
if (ret >= 0)
pdev->vcompression = ARGR(qual);
pdev->vcompression = *qual;
break;
}
case VIDIOCPWCGCQUAL:
{
ARG_DEF(int, qual)
ARGR(qual) = pdev->vcompression;
ARG_OUT(qual)
int *qual = arg;
*qual = pdev->vcompression;
break;
}
case VIDIOCPWCPROBE:
{
ARG_DEF(struct pwc_probe, probe)
strcpy(ARGR(probe).name, pdev->vdev->name);
ARGR(probe).type = pdev->type;
ARG_OUT(probe)
struct pwc_probe *probe = arg;
strcpy(probe->name, pdev->vdev->name);
probe->type = pdev->type;
break;
}
case VIDIOCPWCGSERIAL:
{
ARG_DEF(struct pwc_serial, serial)
strcpy(ARGR(serial).serial, pdev->serial);
ARG_OUT(serial)
struct pwc_serial *serial = arg;
strcpy(serial->serial, pdev->serial);
break;
}
case VIDIOCPWCSAGC:
{
ARG_DEF(int, agc)
ARG_IN(agc)
if (pwc_set_agc(pdev, ARGR(agc) < 0 ? 1 : 0, ARGR(agc)))
int *agc = arg;
if (pwc_set_agc(pdev, *agc < 0 ? 1 : 0, *agc))
ret = -EINVAL;
break;
}
case VIDIOCPWCGAGC:
{
ARG_DEF(int, agc)
int *agc = arg;
if (pwc_get_agc(pdev, ARGA(agc)))
if (pwc_get_agc(pdev, agc))
ret = -EINVAL;
ARG_OUT(agc)
break;
}
case VIDIOCPWCSSHUTTER:
{
ARG_DEF(int, shutter_speed)
ARG_IN(shutter_speed)
ret = pwc_set_shutter_speed(pdev, ARGR(shutter_speed) < 0 ? 1 : 0, ARGR(shutter_speed));
int *shutter_speed = arg;
ret = pwc_set_shutter_speed(pdev, *shutter_speed < 0 ? 1 : 0, *shutter_speed);
break;
}
case VIDIOCPWCSAWB:
{
ARG_DEF(struct pwc_whitebalance, wb)
struct pwc_whitebalance *wb = arg;
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);
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);
}
break;
}
case VIDIOCPWCGAWB:
{
ARG_DEF(struct pwc_whitebalance, wb)
struct pwc_whitebalance *wb = arg;
memset(ARGA(wb), 0, sizeof(struct pwc_whitebalance));
ARGR(wb).mode = pwc_get_awb(pdev);
if (ARGR(wb).mode < 0)
memset(wb, 0, sizeof(struct pwc_whitebalance));
wb->mode = pwc_get_awb(pdev);
if (wb->mode < 0)
ret = -EINVAL;
else {
if (ARGR(wb).mode == PWC_WB_MANUAL) {
ret = pwc_get_red_gain(pdev, &ARGR(wb).manual_red);
if (wb->mode == PWC_WB_MANUAL) {
ret = pwc_get_red_gain(pdev, &wb->manual_red);
if (ret < 0)
break;
ret = pwc_get_blue_gain(pdev, &ARGR(wb).manual_blue);
ret = pwc_get_blue_gain(pdev, &wb->manual_blue);
if (ret < 0)
break;
}
if (ARGR(wb).mode == PWC_WB_AUTO) {
ret = pwc_read_red_gain(pdev, &ARGR(wb).read_red);
if (wb->mode == PWC_WB_AUTO) {
ret = pwc_read_red_gain(pdev, &wb->read_red);
if (ret < 0)
break;
ret =pwc_read_blue_gain(pdev, &ARGR(wb).read_blue);
ret = pwc_read_blue_gain(pdev, &wb->read_blue);
if (ret < 0)
break;
}
}
ARG_OUT(wb)
break;
}
case VIDIOCPWCSAWBSPEED:
{
ARG_DEF(struct pwc_wb_speed, wbs)
struct pwc_wb_speed *wbs = arg;
if (ARGR(wbs).control_speed > 0) {
ret = pwc_set_wb_speed(pdev, ARGR(wbs).control_speed);
if (wbs->control_speed > 0) {
ret = pwc_set_wb_speed(pdev, wbs->control_speed);
}
if (ARGR(wbs).control_delay > 0) {
ret = pwc_set_wb_delay(pdev, ARGR(wbs).control_delay);
if (wbs->control_delay > 0) {
ret = pwc_set_wb_delay(pdev, wbs->control_delay);
}
break;
}
case VIDIOCPWCGAWBSPEED:
{
ARG_DEF(struct pwc_wb_speed, wbs)
struct pwc_wb_speed *wbs = arg;
ret = pwc_get_wb_speed(pdev, &ARGR(wbs).control_speed);
ret = pwc_get_wb_speed(pdev, &wbs->control_speed);
if (ret < 0)
break;
ret = pwc_get_wb_delay(pdev, &ARGR(wbs).control_delay);
ret = pwc_get_wb_delay(pdev, &wbs->control_delay);
if (ret < 0)
break;
ARG_OUT(wbs)
break;
}
case VIDIOCPWCSLED:
{
ARG_DEF(struct pwc_leds, leds)
ARG_IN(leds)
ret = pwc_set_leds(pdev, ARGR(leds).led_on, ARGR(leds).led_off);
struct pwc_leds *leds = arg;
ret = pwc_set_leds(pdev, leds->led_on, leds->led_off);
break;
}
case VIDIOCPWCGLED:
{
ARG_DEF(struct pwc_leds, leds)
ret = pwc_get_leds(pdev, &ARGR(leds).led_on, &ARGR(leds).led_off);
ARG_OUT(leds)
struct pwc_leds *leds = arg;
ret = pwc_get_leds(pdev, &leds->led_on, &leds->led_off);
break;
}
case VIDIOCPWCSCONTOUR:
{
ARG_DEF(int, contour)
ARG_IN(contour)
ret = pwc_set_contour(pdev, ARGR(contour));
int *contour = arg;
ret = pwc_set_contour(pdev, *contour);
break;
}
case VIDIOCPWCGCONTOUR:
{
ARG_DEF(int, contour)
ret = pwc_get_contour(pdev, ARGA(contour));
ARG_OUT(contour)
int *contour = arg;
ret = pwc_get_contour(pdev, contour);
break;
}
case VIDIOCPWCSBACKLIGHT:
{
ARG_DEF(int, backlight)
ARG_IN(backlight)
ret = pwc_set_backlight(pdev, ARGR(backlight));
int *backlight = arg;
ret = pwc_set_backlight(pdev, *backlight);
break;
}
case VIDIOCPWCGBACKLIGHT:
{
ARG_DEF(int, backlight)
ret = pwc_get_backlight(pdev, ARGA(backlight));
ARG_OUT(backlight)
int *backlight = arg;
ret = pwc_get_backlight(pdev, backlight);
break;
}
case VIDIOCPWCSFLICKER:
{
ARG_DEF(int, flicker)
ARG_IN(flicker)
ret = pwc_set_flicker(pdev, ARGR(flicker));
int *flicker = arg;
ret = pwc_set_flicker(pdev, *flicker);
break;
}
case VIDIOCPWCGFLICKER:
{
ARG_DEF(int, flicker)
ret = pwc_get_flicker(pdev, ARGA(flicker));
ARG_OUT(flicker)
int *flicker = arg;
ret = pwc_get_flicker(pdev, flicker);
break;
}
case VIDIOCPWCSDYNNOISE:
{
ARG_DEF(int, dynnoise)
ARG_IN(dynnoise)
ret = pwc_set_dynamic_noise(pdev, ARGR(dynnoise));
int *dynnoise = arg;
ret = pwc_set_dynamic_noise(pdev, *dynnoise);
break;
}
case VIDIOCPWCGDYNNOISE:
{
ARG_DEF(int, dynnoise)
ret = pwc_get_dynamic_noise(pdev, ARGA(dynnoise));
ARG_OUT(dynnoise);
int *dynnoise = arg;
ret = pwc_get_dynamic_noise(pdev, dynnoise);
break;
}
case VIDIOCPWCGREALSIZE:
{
ARG_DEF(struct pwc_imagesize, size)
ARGR(size).width = pdev->image.x;
ARGR(size).height = pdev->image.y;
ARG_OUT(size)
struct pwc_imagesize *size = arg;
size->width = pdev->image.x;
size->height = pdev->image.y;
break;
}
@ -1464,10 +1388,9 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
{
if (pdev->features & FEATURE_MOTOR_PANTILT)
{
ARG_DEF(int, flags)
int *flags = arg;
ARG_IN(flags)
ret = pwc_mpt_reset(pdev, ARGR(flags));
ret = pwc_mpt_reset(pdev, *flags);
if (ret >= 0)
{
pdev->pan_angle = 0;
@ -1485,10 +1408,8 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
{
if (pdev->features & FEATURE_MOTOR_PANTILT)
{
ARG_DEF(struct pwc_mpt_range, range)
ARGR(range) = pdev->angle_range;
ARG_OUT(range)
struct pwc_mpt_range *range = arg;
*range = pdev->angle_range;
}
else
{
@ -1503,21 +1424,19 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
if (pdev->features & FEATURE_MOTOR_PANTILT)
{
ARG_DEF(struct pwc_mpt_angles, angles)
ARG_IN(angles)
struct pwc_mpt_angles *angles = arg;
/* The camera can only set relative angles, so
do some calculations when getting an absolute angle .
*/
if (ARGR(angles).absolute)
if (angles->absolute)
{
new_pan = ARGR(angles).pan;
new_tilt = ARGR(angles).tilt;
new_pan = angles->pan;
new_tilt = angles->tilt;
}
else
{
new_pan = pdev->pan_angle + ARGR(angles).pan;
new_tilt = pdev->tilt_angle + ARGR(angles).tilt;
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 ||
@ -1560,12 +1479,11 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
if (pdev->features & FEATURE_MOTOR_PANTILT)
{
ARG_DEF(struct pwc_mpt_angles, angles)
struct pwc_mpt_angles *angles = arg;
ARGR(angles).absolute = 1;
ARGR(angles).pan = pdev->pan_angle;
ARGR(angles).tilt = pdev->tilt_angle;
ARG_OUT(angles)
angles->absolute = 1;
angles->pan = pdev->pan_angle;
angles->tilt = pdev->tilt_angle;
}
else
{
@ -1578,10 +1496,8 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
{
if (pdev->features & FEATURE_MOTOR_PANTILT)
{
ARG_DEF(struct pwc_mpt_status, status)
ret = pwc_mpt_get_status(pdev, ARGA(status));
ARG_OUT(status)
struct pwc_mpt_status *status = arg;
ret = pwc_mpt_get_status(pdev, status);
}
else
{
@ -1592,24 +1508,22 @@ int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
case VIDIOCPWCGVIDCMD:
{
ARG_DEF(struct pwc_video_command, cmd);
struct pwc_video_command *cmd = arg;
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)
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;
break;
}
/*
case VIDIOCPWCGVIDTABLE:
{
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)
struct pwc_table_init_buffer *table = arg;
table->len = pdev->cmd_len;
memcpy(&table->buffer, pdev->decompress_data, pdev->decompressor->table_size);
break;
}
*/