[media] pwc: Remove driver specific ioctls (a08d2c72) · Commits · e / devices / android_kernel_teracube_emerald

Documentation/feature-removal-schedule.txt

+0 −9

Original line number	Diff line number	Diff line
		@@ -460,15 +460,6 @@ Who: Jean Delvare <khali@linux-fr.org>

		----------------------------

		What: Support for driver specific ioctls in the pwc driver (everything
		defined in media/pwc-ioctl.h)
		When: 3.3
		Why: This stems from the v4l1 era, with v4l2 everything can be done with
		standardized v4l2 API calls
		Who: Hans de Goede <hdegoede@redhat.com>

		----------------------------

		What: Software emulation of arbritary resolutions in the pwc driver
		When: 3.3
		Why: The pwc driver claims to support any resolution between 160x120

drivers/media/video/pwc/pwc-ctrl.c

+0 −571

Original line number	Diff line number	Diff line
		@@ -604,136 +604,6 @@ int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value)
		return r;
		}

		static int pwc_get_leds(struct pwc_device pdev, int on_value, int *off_value)
		{
		unsigned char buf[2];
		int ret;

		if (pdev->type < 730) {
		*on_value = -1;
		*off_value = -1;
		return 0;
		}

		ret = recv_control_msg(pdev,
		GET_STATUS_CTL, LED_FORMATTER, &buf, sizeof(buf));
		if (ret < 0)
		return ret;
		on_value = buf[0] 100;
		off_value = buf[1] 100;
		return 0;
		}

		static int _pwc_mpt_reset(struct pwc_device *pdev, int flags)
		{
		unsigned char buf;
		int r;

		mutex_lock(&pdev->udevlock);
		if (!pdev->udev) {
		r = -ENODEV;
		goto leave;
		}

		buf = flags & 0x03; // only lower two bits are currently used
		r = send_control_msg(pdev,
		SET_MPT_CTL, PT_RESET_CONTROL_FORMATTER, &buf, sizeof(buf));
		leave:
		mutex_unlock(&pdev->udevlock);
		return r;
		}

		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];
		int r;

		mutex_lock(&pdev->udevlock);
		if (!pdev->udev) {
		r = -ENODEV;
		goto leave;
		}

		/* set new relative angle; angles are expressed in degrees * 100,
		but cam as .5 degree resolution, hence divide by 200. Also
		the angle must be multiplied by 64 before it's send to
		the cam (??)
		*/
		pan = 64 * pan / 100;
		tilt = -64 * tilt / 100; /* positive tilt is down, which is not what the user would expect */
		buf[0] = pan & 0xFF;
		buf[1] = (pan >> 8) & 0xFF;
		buf[2] = tilt & 0xFF;
		buf[3] = (tilt >> 8) & 0xFF;
		r = send_control_msg(pdev,
		SET_MPT_CTL, PT_RELATIVE_CONTROL_FORMATTER, &buf, sizeof(buf));
		leave:
		mutex_unlock(&pdev->udevlock);
		return r;
		}

		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];

		mutex_lock(&pdev->udevlock);
		if (!pdev->udev) {
		ret = -ENODEV;
		goto leave;
		}

		ret = recv_control_msg(pdev,
		GET_MPT_CTL, PT_STATUS_FORMATTER, &buf, sizeof(buf));
		if (ret < 0)
		goto leave;
		status->status = buf[0] & 0x7; // 3 bits are used for reporting
		status->time_pan = (buf[1] << 8) + buf[2];
		status->time_tilt = (buf[3] << 8) + buf[4];
		leave:
		mutex_unlock(&pdev->udevlock);
		return ret;
		}

		#ifdef CONFIG_USB_PWC_DEBUG
		int pwc_get_cmos_sensor(struct pwc_device pdev, int sensor)
		{
		@@ -758,444 +628,3 @@ int pwc_get_cmos_sensor(struct pwc_device pdev, int sensor)
		return 0;
		}
		#endif

		/* 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 */

		/*
		* Our ctrls use native values, but the old custom pwc ioctl interface expects
		* values from 0 - 65535, define 2 helper functions to scale things. */
		static int pwc_ioctl_g_ctrl(struct v4l2_ctrl *ctrl)
		{
		return v4l2_ctrl_g_ctrl(ctrl) * 65535 / ctrl->maximum;
		}

		static int pwc_ioctl_s_ctrl(struct v4l2_ctrl *ctrl, int val)
		{
		return v4l2_ctrl_s_ctrl(ctrl, val * ctrl->maximum / 65535);
		}

		long pwc_ioctl(struct pwc_device pdev, unsigned int cmd, void arg)
		{
		long ret = 0;

		switch(cmd) {
		case VIDIOCPWCRUSER:
		ret = v4l2_ctrl_s_ctrl(pdev->restore_user, 0);
		break;

		case VIDIOCPWCSUSER:
		ret = v4l2_ctrl_s_ctrl(pdev->save_user, 0);
		break;

		case VIDIOCPWCFACTORY:
		ret = v4l2_ctrl_s_ctrl(pdev->restore_factory, 0);
		break;

		case VIDIOCPWCSCQUAL:
		{
		ARG_DEF(int, qual)

		mutex_lock(&pdev->udevlock);
		if (!pdev->udev) {
		ret = -ENODEV;
		goto leave;
		}

		if (pdev->iso_init) {
		ret = -EBUSY;
		goto leave;
		}

		ARG_IN(qual)
		if (ARGR(qual) < 0 \|\| ARGR(qual) > 3)
		ret = -EINVAL;
		else
		ret = pwc_set_video_mode(pdev,
		pdev->view.x, pdev->view.y,
		pdev->vframes, ARGR(qual));
		leave:
		mutex_unlock(&pdev->udevlock);
		break;
		}

		case VIDIOCPWCGCQUAL:
		{
		ARG_DEF(int, qual)

		ARGR(qual) = pdev->vcompression;
		ARG_OUT(qual)
		break;
		}

		case VIDIOCPWCPROBE:
		{
		ARG_DEF(struct pwc_probe, probe)

		strcpy(ARGR(probe).name, pdev->vdev.name);
		ARGR(probe).type = pdev->type;
		ARG_OUT(probe)
		break;
		}

		case VIDIOCPWCGSERIAL:
		{
		ARG_DEF(struct pwc_serial, serial)

		strcpy(ARGR(serial).serial, pdev->serial);
		ARG_OUT(serial)
		break;
		}

		case VIDIOCPWCSAGC:
		{
		ARG_DEF(int, agc)
		ARG_IN(agc)
		ret = v4l2_ctrl_s_ctrl(pdev->autogain, ARGR(agc) < 0);
		if (ret == 0 && ARGR(agc) >= 0)
		ret = pwc_ioctl_s_ctrl(pdev->gain, ARGR(agc));
		break;
		}

		case VIDIOCPWCGAGC:
		{
		ARG_DEF(int, agc)
		if (v4l2_ctrl_g_ctrl(pdev->autogain))
		ARGR(agc) = -1;
		else
		ARGR(agc) = pwc_ioctl_g_ctrl(pdev->gain);
		ARG_OUT(agc)
		break;
		}

		case VIDIOCPWCSSHUTTER:
		{
		ARG_DEF(int, shutter)
		ARG_IN(shutter)
		ret = v4l2_ctrl_s_ctrl(pdev->exposure_auto,
		/* Menu idx 0 = auto, idx 1 = manual */
		ARGR(shutter) >= 0);
		if (ret == 0 && ARGR(shutter) >= 0)
		ret = pwc_ioctl_s_ctrl(pdev->exposure, ARGR(shutter));
		break;
		}

		case VIDIOCPWCSAWB:
		{
		ARG_DEF(struct pwc_whitebalance, wb)
		ARG_IN(wb)
		ret = v4l2_ctrl_s_ctrl(pdev->auto_white_balance,
		ARGR(wb).mode);
		if (ret == 0 && ARGR(wb).mode == PWC_WB_MANUAL)
		ret = pwc_ioctl_s_ctrl(pdev->red_balance,
		ARGR(wb).manual_red);
		if (ret == 0 && ARGR(wb).mode == PWC_WB_MANUAL)
		ret = pwc_ioctl_s_ctrl(pdev->blue_balance,
		ARGR(wb).manual_blue);
		break;
		}

		case VIDIOCPWCGAWB:
		{
		ARG_DEF(struct pwc_whitebalance, wb)
		ARGR(wb).mode = v4l2_ctrl_g_ctrl(pdev->auto_white_balance);
		ARGR(wb).manual_red = ARGR(wb).read_red =
		pwc_ioctl_g_ctrl(pdev->red_balance);
		ARGR(wb).manual_blue = ARGR(wb).read_blue =
		pwc_ioctl_g_ctrl(pdev->blue_balance);
		ARG_OUT(wb)
		break;
		}

		case VIDIOCPWCSAWBSPEED:
		{
		ARG_DEF(struct pwc_wb_speed, wbs)

		if (ARGR(wbs).control_speed > 0) {
		ret = pwc_ioctl_s_ctrl(pdev->awb_speed,
		ARGR(wbs).control_speed);
		}
		if (ret == 0 && ARGR(wbs).control_delay > 0) {
		ret = pwc_ioctl_s_ctrl(pdev->awb_delay,
		ARGR(wbs).control_delay);
		}
		break;
		}

		case VIDIOCPWCGAWBSPEED:
		{
		ARG_DEF(struct pwc_wb_speed, wbs)

		ARGR(wbs).control_speed = v4l2_ctrl_g_ctrl(pdev->awb_speed);
		ARGR(wbs).control_delay = v4l2_ctrl_g_ctrl(pdev->awb_delay);
		ARG_OUT(wbs)
		break;
		}

		case VIDIOCPWCSLED:
		{
		ARG_DEF(struct pwc_leds, leds)

		mutex_lock(&pdev->udevlock);
		if (!pdev->udev) {
		ret = -ENODEV;
		break;
		}

		ARG_IN(leds)
		ret = pwc_set_leds(pdev, ARGR(leds).led_on, ARGR(leds).led_off);

		mutex_unlock(&pdev->udevlock);
		break;
		}


		case VIDIOCPWCGLED:
		{
		ARG_DEF(struct pwc_leds, leds)

		mutex_lock(&pdev->udevlock);
		if (!pdev->udev) {
		ret = -ENODEV;
		break;
		}

		ret = pwc_get_leds(pdev, &ARGR(leds).led_on, &ARGR(leds).led_off);
		ARG_OUT(leds)

		mutex_unlock(&pdev->udevlock);
		break;
		}

		case VIDIOCPWCSCONTOUR:
		{
		ARG_DEF(int, contour)
		ARG_IN(contour)
		ret = v4l2_ctrl_s_ctrl(pdev->autocontour, ARGR(contour) < 0);
		if (ret == 0 && ARGR(contour) >= 0)
		ret = pwc_ioctl_s_ctrl(pdev->contour, ARGR(contour));
		break;
		}

		case VIDIOCPWCGCONTOUR:
		{
		ARG_DEF(int, contour)
		if (v4l2_ctrl_g_ctrl(pdev->autocontour))
		ARGR(contour) = -1;
		else
		ARGR(contour) = pwc_ioctl_g_ctrl(pdev->contour);
		ARG_OUT(contour)
		break;
		}

		case VIDIOCPWCSBACKLIGHT:
		{
		ARG_DEF(int, backlight)
		ARG_IN(backlight)
		ret = v4l2_ctrl_s_ctrl(pdev->backlight, ARGR(backlight));
		break;
		}

		case VIDIOCPWCGBACKLIGHT:
		{
		ARG_DEF(int, backlight)
		ARGR(backlight) = v4l2_ctrl_g_ctrl(pdev->backlight);
		ARG_OUT(backlight)
		break;
		}

		case VIDIOCPWCSFLICKER:
		{
		ARG_DEF(int, flicker)
		ARG_IN(flicker)
		ret = v4l2_ctrl_s_ctrl(pdev->flicker, ARGR(flicker));
		break;
		}

		case VIDIOCPWCGFLICKER:
		{
		ARG_DEF(int, flicker)
		ARGR(flicker) = v4l2_ctrl_g_ctrl(pdev->flicker);
		ARG_OUT(flicker)
		break;
		}

		case VIDIOCPWCSDYNNOISE:
		{
		ARG_DEF(int, dynnoise)
		ARG_IN(dynnoise)
		ret = v4l2_ctrl_s_ctrl(pdev->noise_reduction, ARGR(dynnoise));
		break;
		}

		case VIDIOCPWCGDYNNOISE:
		{
		ARG_DEF(int, dynnoise)
		ARGR(dynnoise) = v4l2_ctrl_g_ctrl(pdev->noise_reduction);
		ARG_OUT(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)
		break;
		}

		case VIDIOCPWCMPTRESET:
		{
		if (pdev->features & FEATURE_MOTOR_PANTILT)
		{
		ARG_DEF(int, flags)

		ARG_IN(flags)
		ret = pwc_mpt_reset(pdev, ARGR(flags));
		}
		else
		{
		ret = -ENXIO;
		}
		break;
		}

		case VIDIOCPWCMPTGRANGE:
		{
		if (pdev->features & FEATURE_MOTOR_PANTILT)
		{
		ARG_DEF(struct pwc_mpt_range, range)

		ARGR(range) = pdev->angle_range;
		ARG_OUT(range)
		}
		else
		{
		ret = -ENXIO;
		}
		break;
		}

		case VIDIOCPWCMPTSANGLE:
		{
		int new_pan, new_tilt;

		if (pdev->features & FEATURE_MOTOR_PANTILT)
		{
		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 (ARGR(angles).absolute)
		{
		new_pan = ARGR(angles).pan;
		new_tilt = ARGR(angles).tilt;
		}
		else
		{
		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
		{
		ret = -ENXIO;
		}
		break;
		}

		case VIDIOCPWCMPTGANGLE:
		{

		if (pdev->features & FEATURE_MOTOR_PANTILT)
		{
		ARG_DEF(struct pwc_mpt_angles, angles)

		ARGR(angles).absolute = 1;
		ARGR(angles).pan = pdev->pan_angle;
		ARGR(angles).tilt = pdev->tilt_angle;
		ARG_OUT(angles)
		}
		else
		{
		ret = -ENXIO;
		}
		break;
		}

		case VIDIOCPWCMPTSTATUS:
		{
		if (pdev->features & FEATURE_MOTOR_PANTILT)
		{
		ARG_DEF(struct pwc_mpt_status, status)

		ret = pwc_mpt_get_status(pdev, ARGA(status));
		ARG_OUT(status)
		}
		else
		{
		ret = -ENXIO;
		}
		break;
		}

		case VIDIOCPWCGVIDCMD:
		{
		ARG_DEF(struct pwc_video_command, vcmd);

		ARGR(vcmd).type = pdev->type;
		ARGR(vcmd).release = pdev->release;
		ARGR(vcmd).command_len = pdev->cmd_len;
		memcpy(&ARGR(vcmd).command_buf, pdev->cmd_buf, pdev->cmd_len);
		ARGR(vcmd).bandlength = pdev->vbandlength;
		ARGR(vcmd).frame_size = pdev->frame_size;
		ARG_OUT(vcmd)
		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)
		break;
		}
		*/

		default:
		ret = -ENOIOCTLCMD;
		break;
		}

		if (ret > 0)
		return 0;
		return ret;
		}


		/* vim: set cinoptions= formatoptions=croql cindent shiftwidth=8 tabstop=8: */

drivers/media/video/pwc/pwc-dec23.c

+0 −1

Original line number	Diff line number	Diff line
		@@ -27,7 +27,6 @@
		#include "pwc-timon.h"
		#include "pwc-kiara.h"
		#include "pwc-dec23.h"
		#include <media/pwc-ioctl.h>

		#include <linux/string.h>
		#include <linux/slab.h>

drivers/media/video/pwc/pwc-if.c

+0 −10

Original line number	Diff line number	Diff line
		@@ -1058,16 +1058,6 @@ static int usb_pwc_probe(struct usb_interface *intf, const struct usb_device_id
		pdev->vframes = default_fps;
		strcpy(pdev->serial, serial_number);
		pdev->features = features;
		if (vendor_id == 0x046D && product_id == 0x08B5) {
		/* Logitech QuickCam Orbit
		The ranges have been determined experimentally; they may differ from cam to cam.
		Also, the exact ranges left-right and up-down are different for my cam
		*/
		pdev->angle_range.pan_min = -7000;
		pdev->angle_range.pan_max = 7000;
		pdev->angle_range.tilt_min = -3000;
		pdev->angle_range.tilt_max = 2500;
		}
		pwc_construct(pdev); /* set min/max sizes correct */

		mutex_init(&pdev->capt_file_lock);

drivers/media/video/pwc/pwc-kiara.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -27,7 +27,7 @@
		#ifndef PWC_KIARA_H
		#define PWC_KIARA_H

		#include <media/pwc-ioctl.h>
		#include "pwc.h"

		#define PWC_FPS_MAX_KIARA 6