xref: /external/ltp/testcases/kernel/device-drivers/v4l/user_space/test_VIDIOC_TUNER.c

/*
 * v4l-test: Test environment for Video For Linux Two API
 *
 * 20 Apr 2009  0.5  Added string content validation
 * 18 Apr 2009  0.4  More strict check for strings
 * 28 Mar 2009  0.3  Clean up ret and errno variable names and dprintf() output
 *  9 Feb 2009  0.2  Added test cases for VIDIOC_S_TUNER;
 *                   Some typos corrected;
 *                   Add some debug messages
 * 31 Jan 2009  0.1  First release
 *
 * Written by M�rton N�meth <nm127@freemail.hu>
 * Released under GPL
 */

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <string.h>

#include <linux/videodev2.h>
#include <linux/errno.h>

#include <CUnit/CUnit.h>

#include "v4l2_test.h"
#include "dev_video.h"
#include "video_limits.h"
#include "v4l2_validator.h"

#include "test_VIDIOC_TUNER.h"

int valid_tuner_type(enum v4l2_tuner_type type)
{
	int valid = 0;

	switch (type) {
	case V4L2_TUNER_RADIO:
	case V4L2_TUNER_ANALOG_TV:
		valid = 1;
		break;
	default:
		valid = 0;
	}

	return valid;
}

int valid_tuner_sub(__u32 tuner_sub)
{
	int valid = 0;

	CU_ASSERT_EQUAL(V4L2_TUNER_SUB_SAP, V4L2_TUNER_SUB_LANG2);

	if ((tuner_sub & ~(V4L2_TUNER_SUB_MONO |
			   V4L2_TUNER_SUB_STEREO |
			   V4L2_TUNER_SUB_LANG1 |
			   V4L2_TUNER_SUB_LANG2 | V4L2_TUNER_SUB_SAP))
	    == 0) {
		valid = 1;
	} else {
		valid = 0;
	}
	return valid;
}

int valid_tuner_audmode(__u32 audmode)
{
	int valid = 0;

	CU_ASSERT_EQUAL(V4L2_TUNER_MODE_SAP, V4L2_TUNER_MODE_LANG2);

	switch (audmode) {
	case V4L2_TUNER_MODE_MONO:
	case V4L2_TUNER_MODE_STEREO:
	case V4L2_TUNER_MODE_LANG1:
	case V4L2_TUNER_MODE_LANG2:
	case V4L2_TUNER_MODE_LANG1_LANG2:
		valid = 1;
		break;
	default:
		valid = 0;
	}

	return valid;
}

static int do_get_tuner(int f, __u32 index)
{
	int ret_get, errno_get;
	struct v4l2_tuner tuner;
	struct v4l2_tuner tuner2;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = index;
	ret_get = ioctl(f, VIDIOC_G_TUNER, &tuner);
	errno_get = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret_get=%i, errno_get=%i\n",
		__FILE__, __LINE__, ret_get, errno_get);

	if (ret_get == 0) {
		CU_ASSERT_EQUAL(ret_get, 0);

		CU_ASSERT_EQUAL(tuner.index, index);

		CU_ASSERT(0 < strlen((char *)tuner.name));
		CU_ASSERT(valid_string((char *)tuner.name, sizeof(tuner.name)));

		CU_ASSERT(valid_tuner_type(tuner.type));
		CU_ASSERT(valid_tuner_capability(tuner.capability));

		CU_ASSERT(tuner.rangelow <= tuner.rangehigh);
		CU_ASSERT(valid_tuner_sub(tuner.rxsubchans));
		CU_ASSERT(valid_tuner_audmode(tuner.audmode));

		/* tuner.signal can have any value */
		//CU_ASSERT_EQUAL(tuner.signal, ???);

		/* tuner.afc can have any value */
		//CU_ASSERT_EQUAL(tuner.afc, ???);

		CU_ASSERT_EQUAL(tuner.reserved[0], 0);
		CU_ASSERT_EQUAL(tuner.reserved[1], 0);
		CU_ASSERT_EQUAL(tuner.reserved[2], 0);
		CU_ASSERT_EQUAL(tuner.reserved[3], 0);

		/* Check if the unused bytes of the name string are also filled
		 * with zeros. Also check if there is any padding byte between
		 * any two fields then this padding byte is also filled with
		 * zeros.
		 */
		memset(&tuner2, 0, sizeof(tuner2));
		tuner2.index = tuner.index;
		strncpy((char *)tuner2.name, (char *)tuner.name,
			sizeof(tuner2.name));
		tuner2.type = tuner.type;
		tuner2.capability = tuner.capability;
		tuner2.rangelow = tuner.rangelow;
		tuner2.rangehigh = tuner.rangehigh;
		tuner2.rxsubchans = tuner.rxsubchans;
		tuner2.audmode = tuner.audmode;
		tuner2.signal = tuner.signal;
		tuner2.afc = tuner.afc;
		CU_ASSERT_EQUAL(memcmp(&tuner, &tuner2, sizeof(tuner)), 0);

		dprintf("\ttuner = { "
			".index = %u, "
			".name = \"%s\", "
			".type = %i, "
			".capability = %u, "
			".rangelow = %u, "
			".rangehigh = %u, "
			".rxsubchans = %u, "
			".audmode = %u, "
			".signal = %u, "
			".afc = %i, "
			".reserved[]={ 0x%X, 0x%X, 0x%X, 0x%X } }\n",
			tuner.index,
			tuner.name,
			tuner.type,
			tuner.capability,
			tuner.rangelow,
			tuner.rangehigh,
			tuner.rxsubchans,
			tuner.audmode,
			tuner.signal,
			tuner.afc,
			tuner.reserved[0],
			tuner.reserved[1], tuner.reserved[2], tuner.reserved[3]
		    );

	} else {
		dprintf("\t%s:%u: ret_get=%d (expected %d)\n", __FILE__,
			__LINE__, ret_get, -1);
		dprintf("\t%s:%u: errno_get=%d (expected %d)\n", __FILE__,
			__LINE__, errno_get, EINVAL);
		CU_ASSERT_EQUAL(ret_get, -1);
		CU_ASSERT_EQUAL(errno_get, EINVAL);
	}

	return ret_get;
}

void test_VIDIOC_G_TUNER()
{
	int ret;
	__u32 index;
	int f;

	f = get_video_fd();

	index = 0;
	do {
		ret = do_get_tuner(f, index);
		index++;
	} while (ret == 0);

}

void test_VIDIOC_G_TUNER_S32_MAX()
{
	int ret_get, errno_get;
	__u32 index;
	struct v4l2_tuner tuner;

	index = (__u32) S32_MAX;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = index;
	ret_get = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner);
	errno_get = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret_get=%i, errno_get=%i\n",
		__FILE__, __LINE__, ret_get, errno_get);

	dprintf("\t%s:%u: ret_get=%d (expected %d)\n", __FILE__, __LINE__,
		ret_get, -1);
	dprintf("\t%s:%u: errno_get=%d (expected %d)\n", __FILE__, __LINE__,
		errno_get, EINVAL);
	CU_ASSERT_EQUAL(ret_get, -1);
	CU_ASSERT_EQUAL(errno_get, EINVAL);
}

void test_VIDIOC_G_TUNER_S32_MAX_1()
{
	int ret_get, errno_get;
	__u32 index;
	struct v4l2_tuner tuner;

	index = (__u32) S32_MAX + 1;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = index;
	ret_get = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner);
	errno_get = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret_get=%i\n",
		__FILE__, __LINE__, ret_get);

	dprintf("\t%s:%u: ret_get=%d (expected %d)\n", __FILE__, __LINE__,
		ret_get, -1);
	dprintf("\t%s:%u: errno_get=%d (expected %d)\n", __FILE__, __LINE__,
		errno_get, EINVAL);
	CU_ASSERT_EQUAL(ret_get, -1);
	CU_ASSERT_EQUAL(errno_get, EINVAL);
}

void test_VIDIOC_G_TUNER_U32_MAX()
{
	int ret_get, errno_get;
	__u32 index;
	struct v4l2_tuner tuner;

	index = U32_MAX;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = index;
	ret_get = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner);
	errno_get = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret_get=%i, errno_get=%i\n",
		__FILE__, __LINE__, ret_get, errno_get);

	dprintf("\t%s:%u: ret_get=%d (expected %d)\n", __FILE__, __LINE__,
		ret_get, -1);
	dprintf("\t%s:%u: errno_get=%d (expected %d)\n", __FILE__, __LINE__,
		errno_get, EINVAL);
	CU_ASSERT_EQUAL(ret_get, -1);
	CU_ASSERT_EQUAL(errno_get, EINVAL);
}

void test_VIDIOC_G_TUNER_NULL()
{
	int ret_get, errno_get;
	int ret_null, errno_null;
	struct v4l2_tuner tuner;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = 0;
	ret_get = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner);
	errno_get = errno;
	dprintf("\t%s:%u: VIDIOC_G_TUNER: ret_get=%i, errno_get=%i\n",
		__FILE__, __LINE__, ret_get, errno_get);

	ret_null = ioctl(get_video_fd(), VIDIOC_G_TUNER, NULL);
	errno_null = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER: ret_null=%i, errno_null=%i\n",
		__FILE__, __LINE__, ret_null, errno_null);

	/* check if VIDIOC_G_TUNER is supported at all or not */
	if (ret_get == 0) {
		/* VIDIOC_G_TUNER is supported, the parameter should be checked */
		CU_ASSERT_EQUAL(ret_get, 0);
		CU_ASSERT_EQUAL(ret_null, -1);
		CU_ASSERT_EQUAL(errno_null, EFAULT);
	} else {
		/* VIDIOC_G_TUNER not supported at all, the parameter should not be evaluated */
		CU_ASSERT_EQUAL(ret_get, -1);
		CU_ASSERT_EQUAL(errno_get, EINVAL);
		CU_ASSERT_EQUAL(ret_null, -1);
		CU_ASSERT_EQUAL(errno_null, EINVAL);
	}

}

void do_set_tuner_audmode(__u32 index, __u32 audmode)
{
	int ret_set, errno_set;
	struct v4l2_tuner tuner;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = index;
	tuner.audmode = audmode;
	ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner);
	errno_set = errno;

	dprintf("\t%s:%u: VIDIOC_S_TUNER: index=%u, audmode=%u, "
		"ret_set=%i (expected %i), errno_set=%i\n",
		__FILE__, __LINE__, index, audmode, ret_set, 0, errno_set);

	CU_ASSERT_EQUAL(ret_set, 0);

}

void do_set_tuner_audmode_invalid(__u32 index, __u32 audmode)
{
	int ret_set, errno_set;
	struct v4l2_tuner tuner;

	memset(&tuner, 0xff, sizeof(tuner));
	tuner.index = index;
	tuner.audmode = audmode;
	ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner);
	errno_set = errno;

	dprintf("\t%s:%u: VIDIOC_S_TUNER: index=%u, audmode=%u, "
		"ret_set=%i (expected %i), errno_set=%i (expected %i)\n",
		__FILE__, __LINE__,
		index, audmode, ret_set, -1, errno_set, EINVAL);

	CU_ASSERT_EQUAL(ret_set, -1);
	CU_ASSERT_EQUAL(errno_set, EINVAL);
}

void test_VIDIOC_S_TUNER()
{
	int ret_get, errno_get;
	int ret_set, errno_set;
	struct v4l2_tuner tuner_orig;
	struct v4l2_tuner tuner_set;

	/* remember the tuner settings */
	memset(&tuner_orig, 0, sizeof(tuner_orig));
	ret_get = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner_orig);
	errno_get = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret_get=%i, errno_get=%i\n",
		__FILE__, __LINE__, ret_get, errno_get);

	if (ret_get == 0) {
		CU_ASSERT_EQUAL(ret_get, 0);

		do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_MONO);
		do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_STEREO);
		do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_LANG1);
		do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_LANG2);
		do_set_tuner_audmode(tuner_orig.index, V4L2_TUNER_MODE_SAP);
		do_set_tuner_audmode(tuner_orig.index,
				     V4L2_TUNER_MODE_LANG1_LANG2);

	} else {
		CU_ASSERT_EQUAL(ret_get, -1);
		CU_ASSERT_EQUAL(errno_get, EINVAL);

		/* if VIDIOC_G_TUNER is not supported then VIDIOC_S_TUNER shall also
		 * not supported.
		 */
		do_set_tuner_audmode_invalid(tuner_orig.index,
					     V4L2_TUNER_MODE_MONO);
		do_set_tuner_audmode_invalid(tuner_orig.index,
					     V4L2_TUNER_MODE_STEREO);
		do_set_tuner_audmode_invalid(tuner_orig.index,
					     V4L2_TUNER_MODE_LANG1);
		do_set_tuner_audmode_invalid(tuner_orig.index,
					     V4L2_TUNER_MODE_LANG2);
		do_set_tuner_audmode_invalid(tuner_orig.index,
					     V4L2_TUNER_MODE_SAP);
		do_set_tuner_audmode_invalid(tuner_orig.index,
					     V4L2_TUNER_MODE_LANG1_LANG2);

	}

	if (ret_get == 0) {

		/* restore the tuner settings */
		memset(&tuner_set, 0xff, sizeof(tuner_set));
		tuner_set.index = tuner_orig.index;
		tuner_set.audmode = tuner_orig.audmode;
		ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner_orig);
		errno_set = errno;

		dprintf("\t%s:%u: VIDIOC_S_TUNER, ret_set=%i, errno_set=%i\n",
			__FILE__, __LINE__, ret_set, errno_set);

		CU_ASSERT_EQUAL(ret_set, 0);
	}

}

void test_VIDIOC_S_TUNER_invalid()
{
	int ret1, errno1;
	int ret_set, errno_set;
	struct v4l2_tuner tuner_orig;
	struct v4l2_tuner tuner_set;

	/* remember the tuner settings */
	memset(&tuner_orig, 0, sizeof(tuner_orig));
	ret1 = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner_orig);
	errno1 = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret1=%i, errno1=%i\n",
		__FILE__, __LINE__, ret1, errno1);

	if (ret1 == 0) {
		CU_ASSERT_EQUAL(ret1, 0);

		/* try with invalid index */
		do_set_tuner_audmode_invalid(tuner_orig.index + 1,
					     V4L2_TUNER_MODE_MONO);
		do_set_tuner_audmode_invalid(tuner_orig.index - 1,
					     V4L2_TUNER_MODE_MONO);
		do_set_tuner_audmode_invalid((__u32) S32_MAX,
					     V4L2_TUNER_MODE_MONO);
		do_set_tuner_audmode_invalid(((__u32) S32_MAX) + 1,
					     V4L2_TUNER_MODE_MONO);
		do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_MONO);

		do_set_tuner_audmode_invalid(tuner_orig.index + 1,
					     V4L2_TUNER_MODE_STEREO);
		do_set_tuner_audmode_invalid(tuner_orig.index - 1,
					     V4L2_TUNER_MODE_STEREO);
		do_set_tuner_audmode_invalid((__u32) S32_MAX,
					     V4L2_TUNER_MODE_STEREO);
		do_set_tuner_audmode_invalid(((__u32) S32_MAX) + 1,
					     V4L2_TUNER_MODE_STEREO);
		do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_STEREO);

		do_set_tuner_audmode_invalid(tuner_orig.index + 1,
					     V4L2_TUNER_MODE_LANG1);
		do_set_tuner_audmode_invalid(tuner_orig.index - 1,
					     V4L2_TUNER_MODE_LANG1);
		do_set_tuner_audmode_invalid((__u32) S32_MAX,
					     V4L2_TUNER_MODE_LANG1);
		do_set_tuner_audmode_invalid(((__u32) S32_MAX) + 1,
					     V4L2_TUNER_MODE_LANG1);
		do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_LANG1);

		do_set_tuner_audmode_invalid(tuner_orig.index + 1,
					     V4L2_TUNER_MODE_LANG2);
		do_set_tuner_audmode_invalid(tuner_orig.index - 1,
					     V4L2_TUNER_MODE_LANG2);
		do_set_tuner_audmode_invalid((__u32) S32_MAX,
					     V4L2_TUNER_MODE_LANG2);
		do_set_tuner_audmode_invalid(((__u32) S32_MAX) + 1,
					     V4L2_TUNER_MODE_LANG2);
		do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_LANG2);

		do_set_tuner_audmode_invalid(tuner_orig.index + 1,
					     V4L2_TUNER_MODE_SAP);
		do_set_tuner_audmode_invalid(tuner_orig.index - 1,
					     V4L2_TUNER_MODE_SAP);
		do_set_tuner_audmode_invalid((__u32) S32_MAX,
					     V4L2_TUNER_MODE_SAP);
		do_set_tuner_audmode_invalid(((__u32) S32_MAX) + 1,
					     V4L2_TUNER_MODE_SAP);
		do_set_tuner_audmode_invalid(U32_MAX, V4L2_TUNER_MODE_SAP);

		do_set_tuner_audmode_invalid(tuner_orig.index + 1,
					     V4L2_TUNER_MODE_LANG1_LANG2);
		do_set_tuner_audmode_invalid(tuner_orig.index - 1,
					     V4L2_TUNER_MODE_LANG1_LANG2);
		do_set_tuner_audmode_invalid((__u32) S32_MAX,
					     V4L2_TUNER_MODE_LANG1_LANG2);
		do_set_tuner_audmode_invalid(((__u32) S32_MAX) + 1,
					     V4L2_TUNER_MODE_LANG1_LANG2);
		do_set_tuner_audmode_invalid(U32_MAX,
					     V4L2_TUNER_MODE_LANG1_LANG2);

	} else {
		CU_ASSERT_EQUAL(ret1, -1);
		CU_ASSERT_EQUAL(errno1, EINVAL);

	}

	/* try with invalid audmode */
	do_set_tuner_audmode_invalid(tuner_orig.index, 5);
	do_set_tuner_audmode_invalid(tuner_orig.index, (__u32) S32_MAX);
	do_set_tuner_audmode_invalid(tuner_orig.index, ((__u32) S32_MAX) + 1);
	do_set_tuner_audmode_invalid(tuner_orig.index, U32_MAX);

	if (ret1 == 0) {

		/* restore the tuner settings */
		memset(&tuner_set, 0xff, sizeof(tuner_set));
		tuner_set.index = tuner_orig.index;
		tuner_set.audmode = tuner_orig.audmode;
		ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner_orig);
		errno_set = errno;

		dprintf("\t%s:%u: VIDIOC_S_TUNER, ret_set=%i, errno_set=%i\n",
			__FILE__, __LINE__, ret_set, errno_set);

		CU_ASSERT_EQUAL(ret_set, 0);
	}

}

void test_VIDIOC_S_TUNER_NULL()
{
	int ret_orig, errno_orig;
	int ret_null, errno_null;
	int ret_set, errno_set;
	struct v4l2_tuner tuner_orig;
	struct v4l2_tuner tuner;

	/* remember the tuner settings */
	memset(&tuner_orig, 0, sizeof(tuner_orig));
	ret_orig = ioctl(get_video_fd(), VIDIOC_G_TUNER, &tuner_orig);
	errno_orig = errno;

	dprintf("\t%s:%u: VIDIOC_G_TUNER, ret_orig=%i, errno_orig=%i\n",
		__FILE__, __LINE__, ret_orig, errno_orig);

	memset(&tuner, 0, sizeof(tuner));
	tuner.index = tuner_orig.index;
	tuner.audmode = tuner_orig.audmode;
	ret_set = ioctl(get_video_fd(), VIDIOC_S_TUNER, &tuner);
	errno_set = errno;

	dprintf("\t%s:%u:VIDIOC_S_TUNER: ret_set=%i, errno_set=%i\n",
		__FILE__, __LINE__, ret_set, errno_set);

	ret_null = ioctl(get_video_fd(), VIDIOC_S_TUNER, NULL);
	errno_null = errno;

	dprintf("\t%s:%u:VIDIOC_S_TUNER: ret_null=%i, errno_null=%i\n",
		__FILE__, __LINE__, ret_set, errno_set);

	if (ret_set == 0) {
		CU_ASSERT_EQUAL(ret_set, 0);
		CU_ASSERT_EQUAL(ret_null, -1);
		CU_ASSERT_EQUAL(errno_null, EFAULT);
	} else {
		CU_ASSERT_EQUAL(ret_set, -1);
		CU_ASSERT_EQUAL(errno_set, EINVAL);
		CU_ASSERT_EQUAL(ret_null, -1);
		CU_ASSERT_EQUAL(errno_null, EINVAL);
	}

}