[deliverable/linux.git] / drivers / media / video / saa7191.c

/*
 *  saa7191.c - Philips SAA7191 video decoder driver
 *
 *  Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
 *  Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */

#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/module.h>
#include <linux/mm.h>
#include <linux/slab.h>

#include <linux/videodev2.h>
#include <linux/i2c.h>
#include <media/v4l2-common.h>
#include <media/v4l2-i2c-drv-legacy.h>

#include "saa7191.h"

#define SAA7191_MODULE_VERSION	"0.0.5"

MODULE_DESCRIPTION("Philips SAA7191 video decoder driver");
MODULE_VERSION(SAA7191_MODULE_VERSION);
MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
MODULE_LICENSE("GPL");

static unsigned short normal_i2c[] = { 0x8a >> 1, 0x8e >> 1, I2C_CLIENT_END };

I2C_CLIENT_INSMOD;

// #define SAA7191_DEBUG

#ifdef SAA7191_DEBUG
#define dprintk(x...) printk("SAA7191: " x);
#else
#define dprintk(x...)
#endif

#define SAA7191_SYNC_COUNT	30
#define SAA7191_SYNC_DELAY	100	/* milliseconds */

struct saa7191 {
	struct i2c_client *client;

	/* the register values are stored here as the actual
	 * I2C-registers are write-only */
	u8 reg[25];

	int input;
	v4l2_std_id norm;
};

static const u8 initseq[] = {
	0,	/* Subaddress */

	0x50,	/* (0x50) SAA7191_REG_IDEL */

	/* 50 Hz signal timing */
	0x30,	/* (0x30) SAA7191_REG_HSYB */
	0x00,	/* (0x00) SAA7191_REG_HSYS */
	0xe8,	/* (0xe8) SAA7191_REG_HCLB */
	0xb6,	/* (0xb6) SAA7191_REG_HCLS */
	0xf4,	/* (0xf4) SAA7191_REG_HPHI */

	/* control */
	SAA7191_LUMA_APER_1,	/* (0x01) SAA7191_REG_LUMA - CVBS mode */
	0x00,	/* (0x00) SAA7191_REG_HUEC */
	0xf8,	/* (0xf8) SAA7191_REG_CKTQ */
	0xf8,	/* (0xf8) SAA7191_REG_CKTS */
	0x90,	/* (0x90) SAA7191_REG_PLSE */
	0x90,	/* (0x90) SAA7191_REG_SESE */
	0x00,	/* (0x00) SAA7191_REG_GAIN */
	SAA7191_STDC_NFEN | SAA7191_STDC_HRMV,	/* (0x0c) SAA7191_REG_STDC
						 * - not SECAM,
						 * slow time constant */
	SAA7191_IOCK_OEDC | SAA7191_IOCK_OEHS | SAA7191_IOCK_OEVS
	| SAA7191_IOCK_OEDY,	/* (0x78) SAA7191_REG_IOCK
				 * - chroma from CVBS, GPSW1 & 2 off */
	SAA7191_CTL3_AUFD | SAA7191_CTL3_SCEN | SAA7191_CTL3_OFTS
	| SAA7191_CTL3_YDEL0,	/* (0x99) SAA7191_REG_CTL3
				 * - automatic field detection */
	0x00,	/* (0x00) SAA7191_REG_CTL4 */
	0x2c,	/* (0x2c) SAA7191_REG_CHCV - PAL nominal value */
	0x00,	/* unused */
	0x00,	/* unused */

	/* 60 Hz signal timing */
	0x34,	/* (0x34) SAA7191_REG_HS6B */
	0x0a,	/* (0x0a) SAA7191_REG_HS6S */
	0xf4,	/* (0xf4) SAA7191_REG_HC6B */
	0xce,	/* (0xce) SAA7191_REG_HC6S */
	0xf4,	/* (0xf4) SAA7191_REG_HP6I */
};

/* SAA7191 register handling */

static u8 saa7191_read_reg(struct i2c_client *client,
			   u8 reg)
{
	return ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg];
}

static int saa7191_read_status(struct i2c_client *client,
			       u8 *value)
{
	int ret;

	ret = i2c_master_recv(client, value, 1);
	if (ret < 0) {
		printk(KERN_ERR "SAA7191: saa7191_read_status(): read failed\n");
		return ret;
	}

	return 0;
}


static int saa7191_write_reg(struct i2c_client *client, u8 reg,
			     u8 value)
{
	((struct saa7191 *)i2c_get_clientdata(client))->reg[reg] = value;
	return i2c_smbus_write_byte_data(client, reg, value);
}

/* the first byte of data must be the first subaddress number (register) */
static int saa7191_write_block(struct i2c_client *client,
			       u8 length, const u8 *data)
{
	int i;
	int ret;

	struct saa7191 *decoder = (struct saa7191 *)i2c_get_clientdata(client);
	for (i = 0; i < (length - 1); i++) {
		decoder->reg[data[0] + i] = data[i + 1];
	}

	ret = i2c_master_send(client, data, length);
	if (ret < 0) {
		printk(KERN_ERR "SAA7191: saa7191_write_block(): "
		       "write failed\n");
		return ret;
	}

	return 0;
}

/* Helper functions */

static int saa7191_set_input(struct i2c_client *client, int input)
{
	struct saa7191 *decoder = i2c_get_clientdata(client);
	u8 luma = saa7191_read_reg(client, SAA7191_REG_LUMA);
	u8 iock = saa7191_read_reg(client, SAA7191_REG_IOCK);
	int err;

	switch (input) {
	case SAA7191_INPUT_COMPOSITE: /* Set Composite input */
		iock &= ~(SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW1
			  | SAA7191_IOCK_GPSW2);
		/* Chrominance trap active */
		luma &= ~SAA7191_LUMA_BYPS;
		break;
	case SAA7191_INPUT_SVIDEO: /* Set S-Video input */
		iock |= SAA7191_IOCK_CHRS | SAA7191_IOCK_GPSW2;
		/* Chrominance trap bypassed */
		luma |= SAA7191_LUMA_BYPS;
		break;
	default:
		return -EINVAL;
	}

	err = saa7191_write_reg(client, SAA7191_REG_LUMA, luma);
	if (err)
		return -EIO;
	err = saa7191_write_reg(client, SAA7191_REG_IOCK, iock);
	if (err)
		return -EIO;

	decoder->input = input;

	return 0;
}

static int saa7191_set_norm(struct i2c_client *client, v4l2_std_id norm)
{
	struct saa7191 *decoder = i2c_get_clientdata(client);
	u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
	u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
	u8 chcv = saa7191_read_reg(client, SAA7191_REG_CHCV);
	int err;

	if (norm & V4L2_STD_PAL) {
		stdc &= ~SAA7191_STDC_SECS;
		ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
		chcv = SAA7191_CHCV_PAL;
	} else if (norm & V4L2_STD_NTSC) {
		stdc &= ~SAA7191_STDC_SECS;
		ctl3 &= ~SAA7191_CTL3_AUFD;
		ctl3 |= SAA7191_CTL3_FSEL;
		chcv = SAA7191_CHCV_NTSC;
	} else if (norm & V4L2_STD_SECAM) {
		stdc |= SAA7191_STDC_SECS;
		ctl3 &= ~(SAA7191_CTL3_AUFD | SAA7191_CTL3_FSEL);
		chcv = SAA7191_CHCV_PAL;
	} else {
		return -EINVAL;
	}

	err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
	if (err)
		return -EIO;
	err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
	if (err)
		return -EIO;
	err = saa7191_write_reg(client, SAA7191_REG_CHCV, chcv);
	if (err)
		return -EIO;

	decoder->norm = norm;

	dprintk("ctl3: %02x stdc: %02x chcv: %02x\n", ctl3,
		stdc, chcv);
	dprintk("norm: %llx\n", norm);

	return 0;
}

static int saa7191_wait_for_signal(struct i2c_client *client, u8 *status)
{
	int i = 0;

	dprintk("Checking for signal...\n");

	for (i = 0; i < SAA7191_SYNC_COUNT; i++) {
		if (saa7191_read_status(client, status))
			return -EIO;

		if (((*status) & SAA7191_STATUS_HLCK) == 0) {
			dprintk("Signal found\n");
			return 0;
		}

		msleep(SAA7191_SYNC_DELAY);
	}

	dprintk("No signal\n");

	return -EBUSY;
}

static int saa7191_autodetect_norm_extended(struct i2c_client *client,
		v4l2_std_id *norm)
{
	struct saa7191 *decoder = i2c_get_clientdata(client);
	u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
	u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
	u8 status;
	v4l2_std_id old_norm = decoder->norm;
	int err = 0;

	dprintk("SAA7191 extended signal auto-detection...\n");

	*norm = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM;
	stdc &= ~SAA7191_STDC_SECS;
	ctl3 &= ~(SAA7191_CTL3_FSEL);

	err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
	if (err) {
		err = -EIO;
		goto out;
	}
	err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
	if (err) {
		err = -EIO;
		goto out;
	}

	ctl3 |= SAA7191_CTL3_AUFD;
	err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
	if (err) {
		err = -EIO;
		goto out;
	}

	msleep(SAA7191_SYNC_DELAY);

	err = saa7191_wait_for_signal(client, &status);
	if (err)
		goto out;

	if (status & SAA7191_STATUS_FIDT) {
		/* 60Hz signal -> NTSC */
		dprintk("60Hz signal: NTSC\n");
		*norm = V4L2_STD_NTSC;
		return 0;
	}

	/* 50Hz signal */
	dprintk("50Hz signal: Trying PAL...\n");

	/* try PAL first */
	err = saa7191_set_norm(client, V4L2_STD_PAL);
	if (err)
		goto out;

	msleep(SAA7191_SYNC_DELAY);

	err = saa7191_wait_for_signal(client, &status);
	if (err)
		goto out;

	/* not 50Hz ? */
	if (status & SAA7191_STATUS_FIDT) {
		dprintk("No 50Hz signal\n");
		saa7191_set_norm(client, old_norm);
		return -EAGAIN;
	}

	if (status & SAA7191_STATUS_CODE) {
		dprintk("PAL\n");
		*norm = V4L2_STD_PAL;
		return saa7191_set_norm(client, old_norm);
	}

	dprintk("No color detected with PAL - Trying SECAM...\n");

	/* no color detected ? -> try SECAM */
	err = saa7191_set_norm(client, V4L2_STD_SECAM);
	if (err)
		goto out;

	msleep(SAA7191_SYNC_DELAY);

	err = saa7191_wait_for_signal(client, &status);
	if (err)
		goto out;

	/* not 50Hz ? */
	if (status & SAA7191_STATUS_FIDT) {
		dprintk("No 50Hz signal\n");
		err = -EAGAIN;
		goto out;
	}

	if (status & SAA7191_STATUS_CODE) {
		/* Color detected -> SECAM */
		dprintk("SECAM\n");
		*norm = V4L2_STD_SECAM;
		return saa7191_set_norm(client, old_norm);
	}

	dprintk("No color detected with SECAM - Going back to PAL.\n");

out:
	return saa7191_set_norm(client, old_norm);
}

static int saa7191_autodetect_norm(struct i2c_client *client)
{
	u8 status;

	dprintk("SAA7191 signal auto-detection...\n");

	dprintk("Reading status...\n");

	if (saa7191_read_status(client, &status))
		return -EIO;

	dprintk("Checking for signal...\n");

	/* no signal ? */
	if (status & SAA7191_STATUS_HLCK) {
		dprintk("No signal\n");
		return -EBUSY;
	}

	dprintk("Signal found\n");

	if (status & SAA7191_STATUS_FIDT) {
		/* 60hz signal -> NTSC */
		dprintk("NTSC\n");
		return saa7191_set_norm(client, V4L2_STD_NTSC);
	} else {
		/* 50hz signal -> PAL */
		dprintk("PAL\n");
		return saa7191_set_norm(client, V4L2_STD_PAL);
	}
}

static int saa7191_get_control(struct i2c_client *client,
			       struct v4l2_control *ctrl)
{
	u8 reg;
	int ret = 0;

	switch (ctrl->id) {
	case SAA7191_CONTROL_BANDPASS:
	case SAA7191_CONTROL_BANDPASS_WEIGHT:
	case SAA7191_CONTROL_CORING:
		reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
		switch (ctrl->id) {
		case SAA7191_CONTROL_BANDPASS:
			ctrl->value = ((s32)reg & SAA7191_LUMA_BPSS_MASK)
				>> SAA7191_LUMA_BPSS_SHIFT;
			break;
		case SAA7191_CONTROL_BANDPASS_WEIGHT:
			ctrl->value = ((s32)reg & SAA7191_LUMA_APER_MASK)
				>> SAA7191_LUMA_APER_SHIFT;
			break;
		case SAA7191_CONTROL_CORING:
			ctrl->value = ((s32)reg & SAA7191_LUMA_CORI_MASK)
				>> SAA7191_LUMA_CORI_SHIFT;
			break;
		}
		break;
	case SAA7191_CONTROL_FORCE_COLOUR:
	case SAA7191_CONTROL_CHROMA_GAIN:
		reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
		if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR)
			ctrl->value = ((s32)reg & SAA7191_GAIN_COLO) ? 1 : 0;
		else
			ctrl->value = ((s32)reg & SAA7191_GAIN_LFIS_MASK)
				>> SAA7191_GAIN_LFIS_SHIFT;
		break;
	case V4L2_CID_HUE:
		reg = saa7191_read_reg(client, SAA7191_REG_HUEC);
		if (reg < 0x80)
			reg += 0x80;
		else
			reg -= 0x80;
		ctrl->value = (s32)reg;
		break;
	case SAA7191_CONTROL_VTRC:
		reg = saa7191_read_reg(client, SAA7191_REG_STDC);
		ctrl->value = ((s32)reg & SAA7191_STDC_VTRC) ? 1 : 0;
		break;
	case SAA7191_CONTROL_LUMA_DELAY:
		reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
		ctrl->value = ((s32)reg & SAA7191_CTL3_YDEL_MASK)
			>> SAA7191_CTL3_YDEL_SHIFT;
		if (ctrl->value >= 4)
			ctrl->value -= 8;
		break;
	case SAA7191_CONTROL_VNR:
		reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
		ctrl->value = ((s32)reg & SAA7191_CTL4_VNOI_MASK)
			>> SAA7191_CTL4_VNOI_SHIFT;
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

static int saa7191_set_control(struct i2c_client *client,
			       struct v4l2_control *ctrl)
{
	u8 reg;
	int ret = 0;

	switch (ctrl->id) {
	case SAA7191_CONTROL_BANDPASS:
	case SAA7191_CONTROL_BANDPASS_WEIGHT:
	case SAA7191_CONTROL_CORING:
		reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
		switch (ctrl->id) {
		case SAA7191_CONTROL_BANDPASS:
			reg &= ~SAA7191_LUMA_BPSS_MASK;
			reg |= (ctrl->value << SAA7191_LUMA_BPSS_SHIFT)
				& SAA7191_LUMA_BPSS_MASK;
			break;
		case SAA7191_CONTROL_BANDPASS_WEIGHT:
			reg &= ~SAA7191_LUMA_APER_MASK;
			reg |= (ctrl->value << SAA7191_LUMA_APER_SHIFT)
				& SAA7191_LUMA_APER_MASK;
			break;
		case SAA7191_CONTROL_CORING:
			reg &= ~SAA7191_LUMA_CORI_MASK;
			reg |= (ctrl->value << SAA7191_LUMA_CORI_SHIFT)
				& SAA7191_LUMA_CORI_MASK;
			break;
		}
		ret = saa7191_write_reg(client, SAA7191_REG_LUMA, reg);
		break;
	case SAA7191_CONTROL_FORCE_COLOUR:
	case SAA7191_CONTROL_CHROMA_GAIN:
		reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
		if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR) {
			if (ctrl->value)
				reg |= SAA7191_GAIN_COLO;
			else
				reg &= ~SAA7191_GAIN_COLO;
		} else {
			reg &= ~SAA7191_GAIN_LFIS_MASK;
			reg |= (ctrl->value << SAA7191_GAIN_LFIS_SHIFT)
				& SAA7191_GAIN_LFIS_MASK;
		}
		ret = saa7191_write_reg(client, SAA7191_REG_GAIN, reg);
		break;
	case V4L2_CID_HUE:
		reg = ctrl->value & 0xff;
		if (reg < 0x80)
			reg += 0x80;
		else
			reg -= 0x80;
		ret = saa7191_write_reg(client, SAA7191_REG_HUEC, reg);
		break;
	case SAA7191_CONTROL_VTRC:
		reg = saa7191_read_reg(client, SAA7191_REG_STDC);
		if (ctrl->value)
			reg |= SAA7191_STDC_VTRC;
		else
			reg &= ~SAA7191_STDC_VTRC;
		ret = saa7191_write_reg(client, SAA7191_REG_STDC, reg);
		break;
	case SAA7191_CONTROL_LUMA_DELAY: {
		s32 value = ctrl->value;
		if (value < 0)
			value += 8;
		reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
		reg &= ~SAA7191_CTL3_YDEL_MASK;
		reg |= (value << SAA7191_CTL3_YDEL_SHIFT)
			& SAA7191_CTL3_YDEL_MASK;
		ret = saa7191_write_reg(client, SAA7191_REG_CTL3, reg);
		break;
	}
	case SAA7191_CONTROL_VNR:
		reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
		reg &= ~SAA7191_CTL4_VNOI_MASK;
		reg |= (ctrl->value << SAA7191_CTL4_VNOI_SHIFT)
			& SAA7191_CTL4_VNOI_MASK;
		ret = saa7191_write_reg(client, SAA7191_REG_CTL4, reg);
		break;
	default:
		ret = -EINVAL;
	}

	return ret;
}

/* I2C-interface */

static int saa7191_command(struct i2c_client *client, unsigned int cmd,
			   void *arg)
{
	switch (cmd) {
	case VIDIOC_INT_G_INPUT_STATUS: {
		u32 *iarg = arg;
		u8 status;
		int res = V4L2_IN_ST_NO_SIGNAL;

		if (saa7191_read_status(client, &status))
			return -EIO;
		if ((status & SAA7191_STATUS_HLCK) == 0)
			res = 0;
		if (!(status & SAA7191_STATUS_CODE))
			res |= V4L2_IN_ST_NO_COLOR;
		*iarg = res;
		break;
	}

	case VIDIOC_QUERYSTD:
		return saa7191_autodetect_norm_extended(client, arg);

	case VIDIOC_S_STD: {
		v4l2_std_id *istd = arg;

		return saa7191_set_norm(client, *istd);
	}
	case VIDIOC_INT_S_VIDEO_ROUTING: {
		struct v4l2_routing *route = arg;

		return saa7191_set_input(client, route->input);
	}

	case VIDIOC_G_CTRL:
		return saa7191_get_control(client, arg);

	case VIDIOC_S_CTRL:
		return saa7191_set_control(client, arg);

	default:
		return -EINVAL;
	}

	return 0;
}

static int saa7191_probe(struct i2c_client *client,
			  const struct i2c_device_id *id)
{
	int err = 0;
	struct saa7191 *decoder;

	v4l_info(client, "chip found @ 0x%x (%s)\n",
			client->addr << 1, client->adapter->name);

	decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
	if (!decoder)
		return -ENOMEM;

	i2c_set_clientdata(client, decoder);

	decoder->client = client;

	err = saa7191_write_block(client, sizeof(initseq), initseq);
	if (err) {
		printk(KERN_ERR "SAA7191 initialization failed\n");
		kfree(decoder);
		return err;
	}

	printk(KERN_INFO "SAA7191 initialized\n");

	decoder->input = SAA7191_INPUT_COMPOSITE;
	decoder->norm = V4L2_STD_PAL;

	err = saa7191_autodetect_norm(client);
	if (err && (err != -EBUSY))
		printk(KERN_ERR "SAA7191: Signal auto-detection failed\n");

	return 0;
}

static int saa7191_remove(struct i2c_client *client)
{
	struct saa7191 *decoder = i2c_get_clientdata(client);

	kfree(decoder);
	return 0;
}

static int saa7191_legacy_probe(struct i2c_adapter *adapter)
{
	return adapter->id == I2C_HW_SGI_VINO;
}

static const struct i2c_device_id saa7191_id[] = {
	{ "saa7191", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, saa7191_id);

static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	.name = "saa7191",
	.driverid = I2C_DRIVERID_SAA7191,
	.command = saa7191_command,
	.probe = saa7191_probe,
	.remove = saa7191_remove,
	.legacy_probe = saa7191_legacy_probe,
	.id_table = saa7191_id,
};
Commit	Line	Data
d203a7ec RB	1	/*
	2	* saa7191.c - Philips SAA7191 video decoder driver
	3	*
	4	* Copyright (C) 2003 Ladislav Michl <ladis@linux-mips.org>
	5	* Copyright (C) 2004,2005 Mikael Nousiainen <tmnousia@cc.hut.fi>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
d203a7ec RB	12	#include <linux/delay.h>
	13	#include <linux/errno.h>
	14	#include <linux/fs.h>
495515b3	15	#include <linux/init.h>
d203a7ec RB	16	#include <linux/kernel.h>
d203a7ec RB	17	#include <linux/major.h>
495515b3	18	#include <linux/module.h>
d203a7ec	19	#include <linux/mm.h>
495515b3	20	#include <linux/slab.h>
d203a7ec	21
cf4e9484	22	#include <linux/videodev2.h>
d203a7ec	23	#include <linux/i2c.h>
babb7dc7 HV	24	#include <media/v4l2-common.h>
babb7dc7 HV	25	#include <media/v4l2-i2c-drv-legacy.h>
d203a7ec RB	26
	27	#include "saa7191.h"
	28
a637a114	29	#define SAA7191_MODULE_VERSION "0.0.5"
d203a7ec RB	30
	31	MODULE_DESCRIPTION("Philips SAA7191 video decoder driver");
	32	MODULE_VERSION(SAA7191_MODULE_VERSION);
	33	MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
	34	MODULE_LICENSE("GPL");
	35
babb7dc7 HV	36	static unsigned short normal_i2c[] = { 0x8a >> 1, 0x8e >> 1, I2C_CLIENT_END };
	37
	38	I2C_CLIENT_INSMOD;
	39
a637a114 LM	40	// #define SAA7191_DEBUG
	41
	42	#ifdef SAA7191_DEBUG
	43	#define dprintk(x...) printk("SAA7191: " x);
	44	#else
	45	#define dprintk(x...)
	46	#endif
	47
	48	#define SAA7191_SYNC_COUNT 30
	49	#define SAA7191_SYNC_DELAY 100 /* milliseconds */
	50
d203a7ec RB	51	struct saa7191 {
	52	struct i2c_client *client;
	53
	54	/* the register values are stored here as the actual
	55	* I2C-registers are write-only */
a637a114	56	u8 reg[25];
d203a7ec	57
a637a114	58	int input;
cf4e9484	59	v4l2_std_id norm;
d203a7ec RB	60	};
d203a7ec RB	61
a637a114	62	static const u8 initseq[] = {
d203a7ec	63	0, /* Subaddress */
a637a114 LM	64
	65	0x50, /* (0x50) SAA7191_REG_IDEL */
	66
	67	/* 50 Hz signal timing */
	68	0x30, /* (0x30) SAA7191_REG_HSYB */
	69	0x00, /* (0x00) SAA7191_REG_HSYS */
	70	0xe8, /* (0xe8) SAA7191_REG_HCLB */
	71	0xb6, /* (0xb6) SAA7191_REG_HCLS */
	72	0xf4, /* (0xf4) SAA7191_REG_HPHI */
	73
	74	/* control */
	75	SAA7191_LUMA_APER_1, /* (0x01) SAA7191_REG_LUMA - CVBS mode */
	76	0x00, /* (0x00) SAA7191_REG_HUEC */
	77	0xf8, /* (0xf8) SAA7191_REG_CKTQ */
	78	0xf8, /* (0xf8) SAA7191_REG_CKTS */
	79	0x90, /* (0x90) SAA7191_REG_PLSE */
	80	0x90, /* (0x90) SAA7191_REG_SESE */
	81	0x00, /* (0x00) SAA7191_REG_GAIN */
	82	SAA7191_STDC_NFEN \| SAA7191_STDC_HRMV, /* (0x0c) SAA7191_REG_STDC
	83	* - not SECAM,
	84	* slow time constant */
	85	SAA7191_IOCK_OEDC \| SAA7191_IOCK_OEHS \| SAA7191_IOCK_OEVS
	86	\| SAA7191_IOCK_OEDY, /* (0x78) SAA7191_REG_IOCK
	87	* - chroma from CVBS, GPSW1 & 2 off */
	88	SAA7191_CTL3_AUFD \| SAA7191_CTL3_SCEN \| SAA7191_CTL3_OFTS
	89	\| SAA7191_CTL3_YDEL0, /* (0x99) SAA7191_REG_CTL3
	90	* - automatic field detection */
	91	0x00, /* (0x00) SAA7191_REG_CTL4 */
	92	0x2c, /* (0x2c) SAA7191_REG_CHCV - PAL nominal value */
d203a7ec RB	93	0x00, /* unused */
d203a7ec RB	94	0x00, /* unused */
a637a114 LM	95
	96	/* 60 Hz signal timing */
	97	0x34, /* (0x34) SAA7191_REG_HS6B */
	98	0x0a, /* (0x0a) SAA7191_REG_HS6S */
	99	0xf4, /* (0xf4) SAA7191_REG_HC6B */
	100	0xce, /* (0xce) SAA7191_REG_HC6S */
	101	0xf4, /* (0xf4) SAA7191_REG_HP6I */
d203a7ec RB	102	};
	103
	104	/* SAA7191 register handling */
	105
a637a114 LM	106	static u8 saa7191_read_reg(struct i2c_client *client,
a637a114 LM	107	u8 reg)
d203a7ec RB	108	{
	109	return ((struct saa7191 *)i2c_get_clientdata(client))->reg[reg];
	110	}
	111
	112	static int saa7191_read_status(struct i2c_client *client,
a637a114	113	u8 *value)
d203a7ec RB	114	{
	115	int ret;
	116
	117	ret = i2c_master_recv(client, value, 1);
	118	if (ret < 0) {
a637a114	119	printk(KERN_ERR "SAA7191: saa7191_read_status(): read failed\n");
d203a7ec RB	120	return ret;
	121	}
	122
	123	return 0;
	124	}
	125
	126
a637a114 LM	127	static int saa7191_write_reg(struct i2c_client *client, u8 reg,
a637a114 LM	128	u8 value)
d203a7ec	129	{
d203a7ec RB	130	((struct saa7191 *)i2c_get_clientdata(client))->reg[reg] = value;
	131	return i2c_smbus_write_byte_data(client, reg, value);
	132	}
	133
	134	/* the first byte of data must be the first subaddress number (register) */
	135	static int saa7191_write_block(struct i2c_client *client,
f5ab272b	136	u8 length, const u8 *data)
d203a7ec RB	137	{
	138	int i;
	139	int ret;
	140
	141	struct saa7191 decoder = (struct saa7191 )i2c_get_clientdata(client);
	142	for (i = 0; i < (length - 1); i++) {
	143	decoder->reg[data[0] + i] = data[i + 1];
	144	}
	145
	146	ret = i2c_master_send(client, data, length);
	147	if (ret < 0) {
	148	printk(KERN_ERR "SAA7191: saa7191_write_block(): "
a637a114	149	"write failed\n");
d203a7ec RB	150	return ret;
	151	}
	152
	153	return 0;
	154	}
	155
	156	/* Helper functions */
	157
	158	static int saa7191_set_input(struct i2c_client *client, int input)
	159	{
a637a114 LM	160	struct saa7191 *decoder = i2c_get_clientdata(client);
	161	u8 luma = saa7191_read_reg(client, SAA7191_REG_LUMA);
	162	u8 iock = saa7191_read_reg(client, SAA7191_REG_IOCK);
d203a7ec RB	163	int err;
	164
	165	switch (input) {
	166	case SAA7191_INPUT_COMPOSITE: /* Set Composite input */
	167	iock &= ~(SAA7191_IOCK_CHRS \| SAA7191_IOCK_GPSW1
	168	\| SAA7191_IOCK_GPSW2);
	169	/* Chrominance trap active */
	170	luma &= ~SAA7191_LUMA_BYPS;
	171	break;
	172	case SAA7191_INPUT_SVIDEO: /* Set S-Video input */
	173	iock \|= SAA7191_IOCK_CHRS \| SAA7191_IOCK_GPSW2;
	174	/* Chrominance trap bypassed */
	175	luma \|= SAA7191_LUMA_BYPS;
	176	break;
	177	default:
	178	return -EINVAL;
	179	}
	180
	181	err = saa7191_write_reg(client, SAA7191_REG_LUMA, luma);
	182	if (err)
	183	return -EIO;
	184	err = saa7191_write_reg(client, SAA7191_REG_IOCK, iock);
	185	if (err)
	186	return -EIO;
	187
a637a114 LM	188	decoder->input = input;
a637a114 LM	189
d203a7ec RB	190	return 0;
	191	}
	192
cf4e9484	193	static int saa7191_set_norm(struct i2c_client *client, v4l2_std_id norm)
d203a7ec RB	194	{
d203a7ec RB	195	struct saa7191 *decoder = i2c_get_clientdata(client);
a637a114 LM	196	u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
	197	u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
	198	u8 chcv = saa7191_read_reg(client, SAA7191_REG_CHCV);
d203a7ec RB	199	int err;
d203a7ec RB	200
cf4e9484	201	if (norm & V4L2_STD_PAL) {
d203a7ec RB	202	stdc &= ~SAA7191_STDC_SECS;
	203	ctl3 &= ~(SAA7191_CTL3_AUFD \| SAA7191_CTL3_FSEL);
	204	chcv = SAA7191_CHCV_PAL;
cf4e9484	205	} else if (norm & V4L2_STD_NTSC) {
d203a7ec RB	206	stdc &= ~SAA7191_STDC_SECS;
	207	ctl3 &= ~SAA7191_CTL3_AUFD;
	208	ctl3 \|= SAA7191_CTL3_FSEL;
	209	chcv = SAA7191_CHCV_NTSC;
cf4e9484	210	} else if (norm & V4L2_STD_SECAM) {
d203a7ec RB	211	stdc \|= SAA7191_STDC_SECS;
	212	ctl3 &= ~(SAA7191_CTL3_AUFD \| SAA7191_CTL3_FSEL);
	213	chcv = SAA7191_CHCV_PAL;
cf4e9484	214	} else {
d203a7ec RB	215	return -EINVAL;
	216	}
	217
	218	err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
	219	if (err)
	220	return -EIO;
	221	err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
	222	if (err)
	223	return -EIO;
	224	err = saa7191_write_reg(client, SAA7191_REG_CHCV, chcv);
	225	if (err)
	226	return -EIO;
	227
	228	decoder->norm = norm;
	229
a637a114 LM	230	dprintk("ctl3: %02x stdc: %02x chcv: %02x\n", ctl3,
a637a114 LM	231	stdc, chcv);
cf4e9484	232	dprintk("norm: %llx\n", norm);
a637a114	233
d203a7ec RB	234	return 0;
	235	}
	236
a637a114	237	static int saa7191_wait_for_signal(struct i2c_client client, u8 status)
d203a7ec	238	{
a637a114	239	int i = 0;
d203a7ec	240
a637a114 LM	241	dprintk("Checking for signal...\n");
	242
	243	for (i = 0; i < SAA7191_SYNC_COUNT; i++) {
	244	if (saa7191_read_status(client, status))
	245	return -EIO;
	246
	247	if (((*status) & SAA7191_STATUS_HLCK) == 0) {
	248	dprintk("Signal found\n");
	249	return 0;
	250	}
	251
	252	msleep(SAA7191_SYNC_DELAY);
d203a7ec	253	}
d203a7ec	254
a637a114	255	dprintk("No signal\n");
d203a7ec	256
a637a114	257	return -EBUSY;
d203a7ec RB	258	}
d203a7ec RB	259
cf4e9484 HV	260	static int saa7191_autodetect_norm_extended(struct i2c_client *client,
cf4e9484 HV	261	v4l2_std_id *norm)
d203a7ec	262	{
cf4e9484	263	struct saa7191 *decoder = i2c_get_clientdata(client);
a637a114 LM	264	u8 stdc = saa7191_read_reg(client, SAA7191_REG_STDC);
	265	u8 ctl3 = saa7191_read_reg(client, SAA7191_REG_CTL3);
	266	u8 status;
cf4e9484	267	v4l2_std_id old_norm = decoder->norm;
a637a114	268	int err = 0;
d203a7ec	269
a637a114 LM	270	dprintk("SAA7191 extended signal auto-detection...\n");
a637a114 LM	271
cf4e9484	272	*norm = V4L2_STD_NTSC \| V4L2_STD_PAL \| V4L2_STD_SECAM;
a637a114 LM	273	stdc &= ~SAA7191_STDC_SECS;
	274	ctl3 &= ~(SAA7191_CTL3_FSEL);
	275
	276	err = saa7191_write_reg(client, SAA7191_REG_STDC, stdc);
	277	if (err) {
	278	err = -EIO;
	279	goto out;
	280	}
	281	err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
	282	if (err) {
	283	err = -EIO;
	284	goto out;
	285	}
	286
	287	ctl3 \|= SAA7191_CTL3_AUFD;
	288	err = saa7191_write_reg(client, SAA7191_REG_CTL3, ctl3);
	289	if (err) {
	290	err = -EIO;
	291	goto out;
	292	}
	293
	294	msleep(SAA7191_SYNC_DELAY);
	295
	296	err = saa7191_wait_for_signal(client, &status);
	297	if (err)
	298	goto out;
	299
	300	if (status & SAA7191_STATUS_FIDT) {
	301	/* 60Hz signal -> NTSC */
	302	dprintk("60Hz signal: NTSC\n");
cf4e9484 HV	303	*norm = V4L2_STD_NTSC;
cf4e9484 HV	304	return 0;
a637a114 LM	305	}
	306
	307	/* 50Hz signal */
	308	dprintk("50Hz signal: Trying PAL...\n");
	309
	310	/* try PAL first */
cf4e9484	311	err = saa7191_set_norm(client, V4L2_STD_PAL);
a637a114 LM	312	if (err)
	313	goto out;
	314
	315	msleep(SAA7191_SYNC_DELAY);
	316
	317	err = saa7191_wait_for_signal(client, &status);
	318	if (err)
	319	goto out;
	320
	321	/* not 50Hz ? */
	322	if (status & SAA7191_STATUS_FIDT) {
	323	dprintk("No 50Hz signal\n");
cf4e9484 HV	324	saa7191_set_norm(client, old_norm);
cf4e9484 HV	325	return -EAGAIN;
a637a114 LM	326	}
	327
	328	if (status & SAA7191_STATUS_CODE) {
	329	dprintk("PAL\n");
cf4e9484 HV	330	*norm = V4L2_STD_PAL;
cf4e9484 HV	331	return saa7191_set_norm(client, old_norm);
a637a114 LM	332	}
	333
	334	dprintk("No color detected with PAL - Trying SECAM...\n");
	335
	336	/* no color detected ? -> try SECAM */
cf4e9484	337	err = saa7191_set_norm(client, V4L2_STD_SECAM);
a637a114 LM	338	if (err)
	339	goto out;
	340
	341	msleep(SAA7191_SYNC_DELAY);
	342
	343	err = saa7191_wait_for_signal(client, &status);
	344	if (err)
	345	goto out;
	346
	347	/* not 50Hz ? */
	348	if (status & SAA7191_STATUS_FIDT) {
	349	dprintk("No 50Hz signal\n");
	350	err = -EAGAIN;
	351	goto out;
	352	}
	353
	354	if (status & SAA7191_STATUS_CODE) {
	355	/* Color detected -> SECAM */
	356	dprintk("SECAM\n");
cf4e9484 HV	357	*norm = V4L2_STD_SECAM;
cf4e9484 HV	358	return saa7191_set_norm(client, old_norm);
a637a114 LM	359	}
	360
	361	dprintk("No color detected with SECAM - Going back to PAL.\n");
	362
a637a114	363	out:
cf4e9484	364	return saa7191_set_norm(client, old_norm);
a637a114 LM	365	}
	366
	367	static int saa7191_autodetect_norm(struct i2c_client *client)
	368	{
	369	u8 status;
	370
	371	dprintk("SAA7191 signal auto-detection...\n");
	372
	373	dprintk("Reading status...\n");
	374
	375	if (saa7191_read_status(client, &status))
	376	return -EIO;
	377
	378	dprintk("Checking for signal...\n");
	379
	380	/* no signal ? */
	381	if (status & SAA7191_STATUS_HLCK) {
	382	dprintk("No signal\n");
	383	return -EBUSY;
	384	}
	385
	386	dprintk("Signal found\n");
	387
	388	if (status & SAA7191_STATUS_FIDT) {
	389	/* 60hz signal -> NTSC */
	390	dprintk("NTSC\n");
cf4e9484	391	return saa7191_set_norm(client, V4L2_STD_NTSC);
a637a114 LM	392	} else {
	393	/* 50hz signal -> PAL */
	394	dprintk("PAL\n");
cf4e9484	395	return saa7191_set_norm(client, V4L2_STD_PAL);
a637a114 LM	396	}
	397	}
	398
	399	static int saa7191_get_control(struct i2c_client *client,
cf4e9484	400	struct v4l2_control *ctrl)
a637a114 LM	401	{
	402	u8 reg;
	403	int ret = 0;
	404
cf4e9484	405	switch (ctrl->id) {
a637a114 LM	406	case SAA7191_CONTROL_BANDPASS:
	407	case SAA7191_CONTROL_BANDPASS_WEIGHT:
	408	case SAA7191_CONTROL_CORING:
	409	reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
cf4e9484	410	switch (ctrl->id) {
a637a114 LM	411	case SAA7191_CONTROL_BANDPASS:
	412	ctrl->value = ((s32)reg & SAA7191_LUMA_BPSS_MASK)
	413	>> SAA7191_LUMA_BPSS_SHIFT;
	414	break;
	415	case SAA7191_CONTROL_BANDPASS_WEIGHT:
	416	ctrl->value = ((s32)reg & SAA7191_LUMA_APER_MASK)
	417	>> SAA7191_LUMA_APER_SHIFT;
	418	break;
	419	case SAA7191_CONTROL_CORING:
	420	ctrl->value = ((s32)reg & SAA7191_LUMA_CORI_MASK)
	421	>> SAA7191_LUMA_CORI_SHIFT;
	422	break;
d203a7ec	423	}
a637a114 LM	424	break;
	425	case SAA7191_CONTROL_FORCE_COLOUR:
	426	case SAA7191_CONTROL_CHROMA_GAIN:
	427	reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
cf4e9484	428	if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR)
a637a114 LM	429	ctrl->value = ((s32)reg & SAA7191_GAIN_COLO) ? 1 : 0;
	430	else
	431	ctrl->value = ((s32)reg & SAA7191_GAIN_LFIS_MASK)
	432	>> SAA7191_GAIN_LFIS_SHIFT;
	433	break;
cf4e9484	434	case V4L2_CID_HUE:
a637a114 LM	435	reg = saa7191_read_reg(client, SAA7191_REG_HUEC);
	436	if (reg < 0x80)
	437	reg += 0x80;
	438	else
	439	reg -= 0x80;
	440	ctrl->value = (s32)reg;
	441	break;
	442	case SAA7191_CONTROL_VTRC:
	443	reg = saa7191_read_reg(client, SAA7191_REG_STDC);
	444	ctrl->value = ((s32)reg & SAA7191_STDC_VTRC) ? 1 : 0;
	445	break;
	446	case SAA7191_CONTROL_LUMA_DELAY:
	447	reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
	448	ctrl->value = ((s32)reg & SAA7191_CTL3_YDEL_MASK)
	449	>> SAA7191_CTL3_YDEL_SHIFT;
	450	if (ctrl->value >= 4)
	451	ctrl->value -= 8;
	452	break;
	453	case SAA7191_CONTROL_VNR:
	454	reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
	455	ctrl->value = ((s32)reg & SAA7191_CTL4_VNOI_MASK)
	456	>> SAA7191_CTL4_VNOI_SHIFT;
	457	break;
	458	default:
	459	ret = -EINVAL;
	460	}
d203a7ec	461
a637a114 LM	462	return ret;
	463	}
	464
	465	static int saa7191_set_control(struct i2c_client *client,
cf4e9484	466	struct v4l2_control *ctrl)
a637a114 LM	467	{
	468	u8 reg;
	469	int ret = 0;
	470
cf4e9484	471	switch (ctrl->id) {
a637a114 LM	472	case SAA7191_CONTROL_BANDPASS:
	473	case SAA7191_CONTROL_BANDPASS_WEIGHT:
	474	case SAA7191_CONTROL_CORING:
	475	reg = saa7191_read_reg(client, SAA7191_REG_LUMA);
cf4e9484	476	switch (ctrl->id) {
a637a114 LM	477	case SAA7191_CONTROL_BANDPASS:
	478	reg &= ~SAA7191_LUMA_BPSS_MASK;
	479	reg \|= (ctrl->value << SAA7191_LUMA_BPSS_SHIFT)
	480	& SAA7191_LUMA_BPSS_MASK;
	481	break;
	482	case SAA7191_CONTROL_BANDPASS_WEIGHT:
	483	reg &= ~SAA7191_LUMA_APER_MASK;
	484	reg \|= (ctrl->value << SAA7191_LUMA_APER_SHIFT)
	485	& SAA7191_LUMA_APER_MASK;
	486	break;
	487	case SAA7191_CONTROL_CORING:
	488	reg &= ~SAA7191_LUMA_CORI_MASK;
	489	reg \|= (ctrl->value << SAA7191_LUMA_CORI_SHIFT)
	490	& SAA7191_LUMA_CORI_MASK;
	491	break;
	492	}
	493	ret = saa7191_write_reg(client, SAA7191_REG_LUMA, reg);
	494	break;
	495	case SAA7191_CONTROL_FORCE_COLOUR:
	496	case SAA7191_CONTROL_CHROMA_GAIN:
	497	reg = saa7191_read_reg(client, SAA7191_REG_GAIN);
cf4e9484	498	if (ctrl->id == SAA7191_CONTROL_FORCE_COLOUR) {
a637a114 LM	499	if (ctrl->value)
	500	reg \|= SAA7191_GAIN_COLO;
	501	else
	502	reg &= ~SAA7191_GAIN_COLO;
	503	} else {
	504	reg &= ~SAA7191_GAIN_LFIS_MASK;
	505	reg \|= (ctrl->value << SAA7191_GAIN_LFIS_SHIFT)
	506	& SAA7191_GAIN_LFIS_MASK;
	507	}
	508	ret = saa7191_write_reg(client, SAA7191_REG_GAIN, reg);
	509	break;
cf4e9484	510	case V4L2_CID_HUE:
a637a114 LM	511	reg = ctrl->value & 0xff;
	512	if (reg < 0x80)
	513	reg += 0x80;
	514	else
	515	reg -= 0x80;
	516	ret = saa7191_write_reg(client, SAA7191_REG_HUEC, reg);
	517	break;
	518	case SAA7191_CONTROL_VTRC:
	519	reg = saa7191_read_reg(client, SAA7191_REG_STDC);
	520	if (ctrl->value)
	521	reg \|= SAA7191_STDC_VTRC;
	522	else
	523	reg &= ~SAA7191_STDC_VTRC;
	524	ret = saa7191_write_reg(client, SAA7191_REG_STDC, reg);
	525	break;
	526	case SAA7191_CONTROL_LUMA_DELAY: {
	527	s32 value = ctrl->value;
	528	if (value < 0)
	529	value += 8;
	530	reg = saa7191_read_reg(client, SAA7191_REG_CTL3);
	531	reg &= ~SAA7191_CTL3_YDEL_MASK;
	532	reg \|= (value << SAA7191_CTL3_YDEL_SHIFT)
	533	& SAA7191_CTL3_YDEL_MASK;
	534	ret = saa7191_write_reg(client, SAA7191_REG_CTL3, reg);
	535	break;
	536	}
	537	case SAA7191_CONTROL_VNR:
	538	reg = saa7191_read_reg(client, SAA7191_REG_CTL4);
	539	reg &= ~SAA7191_CTL4_VNOI_MASK;
	540	reg \|= (ctrl->value << SAA7191_CTL4_VNOI_SHIFT)
	541	& SAA7191_CTL4_VNOI_MASK;
	542	ret = saa7191_write_reg(client, SAA7191_REG_CTL4, reg);
	543	break;
	544	default:
	545	ret = -EINVAL;
d203a7ec RB	546	}
d203a7ec RB	547
a637a114	548	return ret;
d203a7ec RB	549	}
	550
	551	/* I2C-interface */
	552
d203a7ec RB	553	static int saa7191_command(struct i2c_client *client, unsigned int cmd,
	554	void *arg)
	555	{
d203a7ec	556	switch (cmd) {
cf4e9484 HV	557	case VIDIOC_INT_G_INPUT_STATUS: {
cf4e9484 HV	558	u32 *iarg = arg;
a637a114	559	u8 status;
cf4e9484	560	int res = V4L2_IN_ST_NO_SIGNAL;
d203a7ec	561
cf4e9484	562	if (saa7191_read_status(client, &status))
d203a7ec	563	return -EIO;
d203a7ec	564	if ((status & SAA7191_STATUS_HLCK) == 0)
cf4e9484 HV	565	res = 0;
	566	if (!(status & SAA7191_STATUS_CODE))
	567	res \|= V4L2_IN_ST_NO_COLOR;
d203a7ec RB	568	*iarg = res;
	569	break;
	570	}
d203a7ec	571
cf4e9484 HV	572	case VIDIOC_QUERYSTD:
cf4e9484 HV	573	return saa7191_autodetect_norm_extended(client, arg);
a637a114	574
cf4e9484 HV	575	case VIDIOC_S_STD: {
cf4e9484 HV	576	v4l2_std_id *istd = arg;
a637a114	577
cf4e9484	578	return saa7191_set_norm(client, *istd);
d203a7ec	579	}
cf4e9484 HV	580	case VIDIOC_INT_S_VIDEO_ROUTING: {
cf4e9484 HV	581	struct v4l2_routing *route = arg;
d203a7ec	582
cf4e9484	583	return saa7191_set_input(client, route->input);
d203a7ec	584	}
cf4e9484 HV	585
cf4e9484 HV	586	case VIDIOC_G_CTRL:
a637a114	587	return saa7191_get_control(client, arg);
cf4e9484 HV	588
cf4e9484 HV	589	case VIDIOC_S_CTRL:
a637a114	590	return saa7191_set_control(client, arg);
cf4e9484	591
d203a7ec RB	592	default:
	593	return -EINVAL;
	594	}
	595
	596	return 0;
	597	}
	598
babb7dc7 HV	599	static int saa7191_probe(struct i2c_client *client,
	600	const struct i2c_device_id *id)
	601	{
	602	int err = 0;
	603	struct saa7191 *decoder;
d203a7ec	604
babb7dc7 HV	605	v4l_info(client, "chip found @ 0x%x (%s)\n",
	606	client->addr << 1, client->adapter->name);
	607
	608	decoder = kzalloc(sizeof(*decoder), GFP_KERNEL);
	609	if (!decoder)
	610	return -ENOMEM;
	611
	612	i2c_set_clientdata(client, decoder);
	613
	614	decoder->client = client;
	615
	616	err = saa7191_write_block(client, sizeof(initseq), initseq);
	617	if (err) {
	618	printk(KERN_ERR "SAA7191 initialization failed\n");
	619	kfree(decoder);
	620	return err;
	621	}
	622
	623	printk(KERN_INFO "SAA7191 initialized\n");
	624
	625	decoder->input = SAA7191_INPUT_COMPOSITE;
cf4e9484	626	decoder->norm = V4L2_STD_PAL;
babb7dc7 HV	627
	628	err = saa7191_autodetect_norm(client);
	629	if (err && (err != -EBUSY))
	630	printk(KERN_ERR "SAA7191: Signal auto-detection failed\n");
	631
	632	return 0;
	633	}
	634
	635	static int saa7191_remove(struct i2c_client *client)
d203a7ec	636	{
babb7dc7 HV	637	struct saa7191 *decoder = i2c_get_clientdata(client);
	638
	639	kfree(decoder);
	640	return 0;
d203a7ec RB	641	}
d203a7ec RB	642
babb7dc7	643	static int saa7191_legacy_probe(struct i2c_adapter *adapter)
d203a7ec	644	{
babb7dc7	645	return adapter->id == I2C_HW_SGI_VINO;
d203a7ec RB	646	}
d203a7ec RB	647
babb7dc7 HV	648	static const struct i2c_device_id saa7191_id[] = {
	649	{ "saa7191", 0 },
	650	{ }
	651	};
	652	MODULE_DEVICE_TABLE(i2c, saa7191_id);
	653
	654	static struct v4l2_i2c_driver_data v4l2_i2c_data = {
	655	.name = "saa7191",
	656	.driverid = I2C_DRIVERID_SAA7191,
	657	.command = saa7191_command,
	658	.probe = saa7191_probe,
	659	.remove = saa7191_remove,
	660	.legacy_probe = saa7191_legacy_probe,
	661	.id_table = saa7191_id,
	662	};