[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / video / hexium_gemini.c

/*
    hexium_gemini.c - v4l2 driver for Hexium Gemini frame grabber cards

    Visit http://www.mihu.de/linux/saa7146/ and follow the link
    to "hexium" for further details about this card.

    Copyright (C) 2003 Michael Hunold <michael@mihu.de>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#define DEBUG_VARIABLE debug

#include <media/saa7146_vv.h>

static int debug;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "debug verbosity");

/* global variables */
static int hexium_num;

#define HEXIUM_GEMINI			4
#define HEXIUM_GEMINI_DUAL		5

#define HEXIUM_INPUTS	9
static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
	{ 0, "CVBS 1",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 1, "CVBS 2",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 2, "CVBS 3",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 3, "CVBS 4",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 4, "CVBS 5",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 5, "CVBS 6",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 6, "Y/C 1",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 7, "Y/C 2",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
	{ 8, "Y/C 3",	V4L2_INPUT_TYPE_CAMERA,	2, 0, V4L2_STD_PAL_BG|V4L2_STD_NTSC_M, 0 },
};

#define HEXIUM_AUDIOS	0

struct hexium_data
{
	s8 adr;
	u8 byte;
};

#define HEXIUM_CONTROLS	1
static struct v4l2_queryctrl hexium_controls[] = {
	{ V4L2_CID_PRIVATE_BASE, V4L2_CTRL_TYPE_BOOLEAN, "B/W", 0, 1, 1, 0, 0 },
};

#define HEXIUM_GEMINI_V_1_0		1
#define HEXIUM_GEMINI_DUAL_V_1_0	2

struct hexium
{
	int type;

	struct video_device	*video_dev;
	struct i2c_adapter	i2c_adapter;

	int 		cur_input;	/* current input */
	v4l2_std_id 	cur_std;	/* current standard */
	int		cur_bw;		/* current black/white status */
};

/* Samsung KS0127B decoder default registers */
static u8 hexium_ks0127b[0x100]={
/*00*/ 0x00,0x52,0x30,0x40,0x01,0x0C,0x2A,0x10,
/*08*/ 0x00,0x00,0x00,0x60,0x00,0x00,0x0F,0x06,
/*10*/ 0x00,0x00,0xE4,0xC0,0x00,0x00,0x00,0x00,
/*18*/ 0x14,0x9B,0xFE,0xFF,0xFC,0xFF,0x03,0x22,
/*20*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*28*/ 0x00,0x00,0x00,0x00,0x00,0x2C,0x9B,0x00,
/*30*/ 0x00,0x00,0x10,0x80,0x80,0x10,0x80,0x80,
/*38*/ 0x01,0x04,0x00,0x00,0x00,0x29,0xC0,0x00,
/*40*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*48*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*50*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*58*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*60*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*68*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*70*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*78*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*80*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*88*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*90*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*98*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*A0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*A8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*B0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*B8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*C0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*C8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*D0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*D8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*E0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*E8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*F0*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*F8*/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};

static struct hexium_data hexium_pal[] = {
	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
};

static struct hexium_data hexium_pal_bw[] = {
	{ 0x01, 0x52 },	{ 0x12, 0x64 },	{ 0x2D, 0x2C },	{ 0x2E, 0x9B },	{ -1 , 0xFF }
};

static struct hexium_data hexium_ntsc[] = {
	{ 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
};

static struct hexium_data hexium_ntsc_bw[] = {
	{ 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
};

static struct hexium_data hexium_secam[] = {
	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
};

static struct hexium_data hexium_input_select[] = {
	{ 0x02, 0x60 },
	{ 0x02, 0x64 },
	{ 0x02, 0x61 },
	{ 0x02, 0x65 },
	{ 0x02, 0x62 },
	{ 0x02, 0x66 },
	{ 0x02, 0x68 },
	{ 0x02, 0x69 },
	{ 0x02, 0x6A },
};

/* fixme: h_offset = 0 for Hexium Gemini *Dual*, which
   are currently *not* supported*/
static struct saa7146_standard hexium_standards[] = {
	{
		.name	= "PAL", 	.id	= V4L2_STD_PAL,
		.v_offset	= 28,	.v_field 	= 288,
		.h_offset	= 1,	.h_pixels 	= 680,
		.v_max_out	= 576,	.h_max_out	= 768,
	}, {
		.name	= "NTSC", 	.id	= V4L2_STD_NTSC,
		.v_offset	= 28,	.v_field 	= 240,
		.h_offset	= 1,	.h_pixels 	= 640,
		.v_max_out	= 480,	.h_max_out	= 640,
	}, {
		.name	= "SECAM", 	.id	= V4L2_STD_SECAM,
		.v_offset	= 28,	.v_field 	= 288,
		.h_offset	= 1,	.h_pixels 	= 720,
		.v_max_out	= 576,	.h_max_out	= 768,
	}
};

/* bring hardware to a sane state. this has to be done, just in case someone
   wants to capture from this device before it has been properly initialized.
   the capture engine would badly fail, because no valid signal arrives on the
   saa7146, thus leading to timeouts and stuff. */
static int hexium_init_done(struct saa7146_dev *dev)
{
	struct hexium *hexium = (struct hexium *) dev->ext_priv;
	union i2c_smbus_data data;
	int i = 0;

	DEB_D(("hexium_init_done called.\n"));

	/* initialize the helper ics to useful values */
	for (i = 0; i < sizeof(hexium_ks0127b); i++) {
		data.byte = hexium_ks0127b[i];
		if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
			printk("hexium_gemini: hexium_init_done() failed for address 0x%02x\n", i);
		}
	}

	return 0;
}

static int hexium_set_input(struct hexium *hexium, int input)
{
	union i2c_smbus_data data;

	DEB_D((".\n"));

	data.byte = hexium_input_select[input].byte;
	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, hexium_input_select[input].adr, I2C_SMBUS_BYTE_DATA, &data)) {
		return -1;
	}

	return 0;
}

static int hexium_set_standard(struct hexium *hexium, struct hexium_data *vdec)
{
	union i2c_smbus_data data;
	int i = 0;

	DEB_D((".\n"));

	while (vdec[i].adr != -1) {
		data.byte = vdec[i].byte;
		if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, vdec[i].adr, I2C_SMBUS_BYTE_DATA, &data)) {
			printk("hexium_init_done: hexium_set_standard() failed for address 0x%02x\n", i);
			return -1;
		}
		i++;
	}
	return 0;
}

static int vidioc_enum_input(struct file *file, void *fh, struct v4l2_input *i)
{
	DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));

	if (i->index >= HEXIUM_INPUTS)
		return -EINVAL;

	memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));

	DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
	return 0;
}

static int vidioc_g_input(struct file *file, void *fh, unsigned int *input)
{
	struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
	struct hexium *hexium = (struct hexium *) dev->ext_priv;

	*input = hexium->cur_input;

	DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
	return 0;
}

static int vidioc_s_input(struct file *file, void *fh, unsigned int input)
{
	struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
	struct hexium *hexium = (struct hexium *) dev->ext_priv;

	DEB_EE(("VIDIOC_S_INPUT %d.\n", input));

	if (input >= HEXIUM_INPUTS)
		return -EINVAL;

	hexium->cur_input = input;
	hexium_set_input(hexium, input);
	return 0;
}

/* the saa7146 provides some controls (brightness, contrast, saturation)
   which gets registered *after* this function. because of this we have
   to return with a value != 0 even if the function succeded.. */
static int vidioc_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *qc)
{
	struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
	int i;

	for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
		if (hexium_controls[i].id == qc->id) {
			*qc = hexium_controls[i];
			DEB_D(("VIDIOC_QUERYCTRL %d.\n", qc->id));
			return 0;
		}
	}
	return dev->ext_vv_data->core_ops->vidioc_queryctrl(file, fh, qc);
}

static int vidioc_g_ctrl(struct file *file, void *fh, struct v4l2_control *vc)
{
	struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
	struct hexium *hexium = (struct hexium *) dev->ext_priv;
	int i;

	for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
		if (hexium_controls[i].id == vc->id)
			break;
	}

	if (i < 0)
		return dev->ext_vv_data->core_ops->vidioc_g_ctrl(file, fh, vc);

	if (vc->id == V4L2_CID_PRIVATE_BASE) {
		vc->value = hexium->cur_bw;
		DEB_D(("VIDIOC_G_CTRL BW:%d.\n", vc->value));
		return 0;
	}
	return -EINVAL;
}

static int vidioc_s_ctrl(struct file *file, void *fh, struct v4l2_control *vc)
{
	struct saa7146_dev *dev = ((struct saa7146_fh *)fh)->dev;
	struct hexium *hexium = (struct hexium *) dev->ext_priv;
	int i = 0;

	for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
		if (hexium_controls[i].id == vc->id)
			break;
	}

	if (i < 0)
		return dev->ext_vv_data->core_ops->vidioc_s_ctrl(file, fh, vc);

	if (vc->id == V4L2_CID_PRIVATE_BASE)
		hexium->cur_bw = vc->value;

	DEB_D(("VIDIOC_S_CTRL BW:%d.\n", hexium->cur_bw));

	if (0 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
		hexium_set_standard(hexium, hexium_pal);
		return 0;
	}
	if (0 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
		hexium_set_standard(hexium, hexium_ntsc);
		return 0;
	}
	if (0 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std) {
		hexium_set_standard(hexium, hexium_secam);
		return 0;
	}
	if (1 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
		hexium_set_standard(hexium, hexium_pal_bw);
		return 0;
	}
	if (1 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
		hexium_set_standard(hexium, hexium_ntsc_bw);
		return 0;
	}
	if (1 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std)
		/* fixme: is there no bw secam mode? */
		return -EINVAL;

	return -EINVAL;
}


static struct saa7146_ext_vv vv_data;

/* this function only gets called when the probing was successful */
static int hexium_attach(struct saa7146_dev *dev, struct saa7146_pci_extension_data *info)
{
	struct hexium *hexium = (struct hexium *) dev->ext_priv;
	int ret;

	DEB_EE((".\n"));

	ret = saa7146_vv_devinit(dev);
	if (ret)
		return ret;
	hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
	if (NULL == hexium) {
		printk("hexium_gemini: not enough kernel memory in hexium_attach().\n");
		return -ENOMEM;
	}
	dev->ext_priv = hexium;

	/* enable i2c-port pins */
	saa7146_write(dev, MC1, (MASK_08 | MASK_24 | MASK_10 | MASK_26));

	hexium->i2c_adapter = (struct i2c_adapter) {
		.class = I2C_CLASS_TV_ANALOG,
		.name = "hexium gemini",
	};
	saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
	if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
		DEB_S(("cannot register i2c-device. skipping.\n"));
		kfree(hexium);
		return -EFAULT;
	}

	/*  set HWControl GPIO number 2 */
	saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);

	saa7146_write(dev, DD1_INIT, 0x07000700);
	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
	saa7146_write(dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));

	/* the rest */
	hexium->cur_input = 0;
	hexium_init_done(dev);

	hexium_set_standard(hexium, hexium_pal);
	hexium->cur_std = V4L2_STD_PAL;

	hexium_set_input(hexium, 0);
	hexium->cur_input = 0;

	saa7146_vv_init(dev, &vv_data);
	vv_data.ops.vidioc_queryctrl = vidioc_queryctrl;
	vv_data.ops.vidioc_g_ctrl = vidioc_g_ctrl;
	vv_data.ops.vidioc_s_ctrl = vidioc_s_ctrl;
	vv_data.ops.vidioc_enum_input = vidioc_enum_input;
	vv_data.ops.vidioc_g_input = vidioc_g_input;
	vv_data.ops.vidioc_s_input = vidioc_s_input;
	ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
	if (ret < 0) {
		printk("hexium_gemini: cannot register capture v4l2 device. skipping.\n");
		return ret;
	}

	printk("hexium_gemini: found 'hexium gemini' frame grabber-%d.\n", hexium_num);
	hexium_num++;

	return 0;
}

static int hexium_detach(struct saa7146_dev *dev)
{
	struct hexium *hexium = (struct hexium *) dev->ext_priv;

	DEB_EE(("dev:%p\n", dev));

	saa7146_unregister_device(&hexium->video_dev, dev);
	saa7146_vv_release(dev);

	hexium_num--;

	i2c_del_adapter(&hexium->i2c_adapter);
	kfree(hexium);
	return 0;
}

static int std_callback(struct saa7146_dev *dev, struct saa7146_standard *std)
{
	struct hexium *hexium = (struct hexium *) dev->ext_priv;

	if (V4L2_STD_PAL == std->id) {
		hexium_set_standard(hexium, hexium_pal);
		hexium->cur_std = V4L2_STD_PAL;
		return 0;
	} else if (V4L2_STD_NTSC == std->id) {
		hexium_set_standard(hexium, hexium_ntsc);
		hexium->cur_std = V4L2_STD_NTSC;
		return 0;
	} else if (V4L2_STD_SECAM == std->id) {
		hexium_set_standard(hexium, hexium_secam);
		hexium->cur_std = V4L2_STD_SECAM;
		return 0;
	}

	return -1;
}

static struct saa7146_extension hexium_extension;

static struct saa7146_pci_extension_data hexium_gemini_4bnc = {
	.ext_priv = "Hexium Gemini (4 BNC)",
	.ext = &hexium_extension,
};

static struct saa7146_pci_extension_data hexium_gemini_dual_4bnc = {
	.ext_priv = "Hexium Gemini Dual (4 BNC)",
	.ext = &hexium_extension,
};

static struct pci_device_id pci_tbl[] = {
	{
	 .vendor = PCI_VENDOR_ID_PHILIPS,
	 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	 .subvendor = 0x17c8,
	 .subdevice = 0x2401,
	 .driver_data = (unsigned long) &hexium_gemini_4bnc,
	 },
	{
	 .vendor = PCI_VENDOR_ID_PHILIPS,
	 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	 .subvendor = 0x17c8,
	 .subdevice = 0x2402,
	 .driver_data = (unsigned long) &hexium_gemini_dual_4bnc,
	 },
	{
	 .vendor = 0,
	 }
};

MODULE_DEVICE_TABLE(pci, pci_tbl);

static struct saa7146_ext_vv vv_data = {
	.inputs = HEXIUM_INPUTS,
	.capabilities = 0,
	.stds = &hexium_standards[0],
	.num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
	.std_callback = &std_callback,
};

static struct saa7146_extension hexium_extension = {
	.name = "hexium gemini",
	.flags = SAA7146_USE_I2C_IRQ,

	.pci_tbl = &pci_tbl[0],
	.module = THIS_MODULE,

	.attach = hexium_attach,
	.detach = hexium_detach,

	.irq_mask = 0,
	.irq_func = NULL,
};

static int __init hexium_init_module(void)
{
	if (0 != saa7146_register_extension(&hexium_extension)) {
		DEB_S(("failed to register extension.\n"));
		return -ENODEV;
	}

	return 0;
}

static void __exit hexium_cleanup_module(void)
{
	saa7146_unregister_extension(&hexium_extension);
}

module_init(hexium_init_module);
module_exit(hexium_cleanup_module);

MODULE_DESCRIPTION("video4linux-2 driver for Hexium Gemini frame grabber cards");
MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
1da177e4 LT	2	hexium_gemini.c - v4l2 driver for Hexium Gemini frame grabber cards
a8733ca5	3
1da177e4 LT	4	Visit http://www.mihu.de/linux/saa7146/ and follow the link
1da177e4 LT	5	to "hexium" for further details about this card.
a8733ca5	6
1da177e4 LT	7	Copyright (C) 2003 Michael Hunold <michael@mihu.de>
	8
	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
	13
	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	22	*/
	23
	24	#define DEBUG_VARIABLE debug
	25
	26	#include <media/saa7146_vv.h>
	27
ff699e6b	28	static int debug;
1da177e4 LT	29	module_param(debug, int, 0);
	30	MODULE_PARM_DESC(debug, "debug verbosity");
	31
	32	/* global variables */
ff699e6b	33	static int hexium_num;
1da177e4 LT	34
	35	#define HEXIUM_GEMINI 4
	36	#define HEXIUM_GEMINI_DUAL 5
	37
	38	#define HEXIUM_INPUTS 9
	39	static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
	40	{ 0, "CVBS 1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	41	{ 1, "CVBS 2", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	42	{ 2, "CVBS 3", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	43	{ 3, "CVBS 4", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	44	{ 4, "CVBS 5", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	45	{ 5, "CVBS 6", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	46	{ 6, "Y/C 1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	47	{ 7, "Y/C 2", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	48	{ 8, "Y/C 3", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	49	};
	50
	51	#define HEXIUM_AUDIOS 0
	52
	53	struct hexium_data
	54	{
	55	s8 adr;
	56	u8 byte;
	57	};
	58
1da177e4 LT	59	#define HEXIUM_CONTROLS 1
	60	static struct v4l2_queryctrl hexium_controls[] = {
	61	{ V4L2_CID_PRIVATE_BASE, V4L2_CTRL_TYPE_BOOLEAN, "B/W", 0, 1, 1, 0, 0 },
	62	};
	63
	64	#define HEXIUM_GEMINI_V_1_0 1
	65	#define HEXIUM_GEMINI_DUAL_V_1_0 2
	66
	67	struct hexium
	68	{
	69	int type;
	70
	71	struct video_device *video_dev;
	72	struct i2c_adapter i2c_adapter;
a8733ca5	73
1da177e4 LT	74	int cur_input; /* current input */
	75	v4l2_std_id cur_std; /* current standard */
	76	int cur_bw; /* current black/white status */
	77	};
	78
	79	/* Samsung KS0127B decoder default registers */
	80	static u8 hexium_ks0127b[0x100]={
	81	/00/ 0x00,0x52,0x30,0x40,0x01,0x0C,0x2A,0x10,
	82	/08/ 0x00,0x00,0x00,0x60,0x00,0x00,0x0F,0x06,
	83	/10/ 0x00,0x00,0xE4,0xC0,0x00,0x00,0x00,0x00,
	84	/18/ 0x14,0x9B,0xFE,0xFF,0xFC,0xFF,0x03,0x22,
	85	/20/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	86	/28/ 0x00,0x00,0x00,0x00,0x00,0x2C,0x9B,0x00,
	87	/30/ 0x00,0x00,0x10,0x80,0x80,0x10,0x80,0x80,
	88	/38/ 0x01,0x04,0x00,0x00,0x00,0x29,0xC0,0x00,
	89	/40/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	90	/48/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	91	/50/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	92	/58/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	93	/60/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	94	/68/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	95	/70/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	96	/78/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	97	/80/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	98	/88/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	99	/90/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	100	/98/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	101	/A0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	102	/A8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	103	/B0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	104	/B8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	105	/C0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	106	/C8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	107	/D0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	108	/D8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	109	/E0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	110	/E8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	111	/F0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	112	/F8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
	113	};
	114
	115	static struct hexium_data hexium_pal[] = {
	116	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
	117	};
	118
	119	static struct hexium_data hexium_pal_bw[] = {
	120	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
	121	};
	122
	123	static struct hexium_data hexium_ntsc[] = {
	124	{ 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
	125	};
	126
	127	static struct hexium_data hexium_ntsc_bw[] = {
	128	{ 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
	129	};
	130
	131	static struct hexium_data hexium_secam[] = {
	132	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
	133	};
	134
	135	static struct hexium_data hexium_input_select[] = {
	136	{ 0x02, 0x60 },
	137	{ 0x02, 0x64 },
138	{ 0x02, 0x61 },
139	{ 0x02, 0x65 },
140	{ 0x02, 0x62 },
141	{ 0x02, 0x66 },
142	{ 0x02, 0x68 },
143	{ 0x02, 0x69 },
144	{ 0x02, 0x6A },
145	};
146
147	/* fixme: h_offset = 0 for Hexium Gemini Dual, which
148	are currently not supported*/
149	static struct saa7146_standard hexium_standards[] = {
150	{
151	.name = "PAL", .id = V4L2_STD_PAL,
152	.v_offset = 28, .v_field = 288,
153	.h_offset = 1, .h_pixels = 680,
154	.v_max_out = 576, .h_max_out = 768,
155	}, {
156	.name = "NTSC", .id = V4L2_STD_NTSC,
157	.v_offset = 28, .v_field = 240,
158	.h_offset = 1, .h_pixels = 640,
159	.v_max_out = 480, .h_max_out = 640,
160	}, {
161	.name = "SECAM", .id = V4L2_STD_SECAM,
162	.v_offset = 28, .v_field = 288,
163	.h_offset = 1, .h_pixels = 720,
164	.v_max_out = 576, .h_max_out = 768,
165	}
a8733ca5	166	};
1da177e4 LT	167
	168	/* bring hardware to a sane state. this has to be done, just in case someone
	169	wants to capture from this device before it has been properly initialized.
	170	the capture engine would badly fail, because no valid signal arrives on the
	171	saa7146, thus leading to timeouts and stuff. */
	172	static int hexium_init_done(struct saa7146_dev *dev)
	173	{
	174	struct hexium hexium = (struct hexium ) dev->ext_priv;
	175	union i2c_smbus_data data;
	176	int i = 0;
	177
	178	DEB_D(("hexium_init_done called.\n"));
	179
	180	/* initialize the helper ics to useful values */
	181	for (i = 0; i < sizeof(hexium_ks0127b); i++) {
	182	data.byte = hexium_ks0127b[i];
	183	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
	184	printk("hexium_gemini: hexium_init_done() failed for address 0x%02x\n", i);
	185	}
	186	}
	187
	188	return 0;
	189	}
	190
	191	static int hexium_set_input(struct hexium *hexium, int input)
	192	{
	193	union i2c_smbus_data data;
	194
	195	DEB_D((".\n"));
	196
	197	data.byte = hexium_input_select[input].byte;
	198	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, hexium_input_select[input].adr, I2C_SMBUS_BYTE_DATA, &data)) {
	199	return -1;
	200	}
	201
	202	return 0;
	203	}
	204
	205	static int hexium_set_standard(struct hexium hexium, struct hexium_data vdec)
	206	{
	207	union i2c_smbus_data data;
	208	int i = 0;
	209
	210	DEB_D((".\n"));
	211
	212	while (vdec[i].adr != -1) {
	213	data.byte = vdec[i].byte;
	214	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, vdec[i].adr, I2C_SMBUS_BYTE_DATA, &data)) {
	215	printk("hexium_init_done: hexium_set_standard() failed for address 0x%02x\n", i);
	216	return -1;
	217	}
	218	i++;
	219	}
	220	return 0;
	221	}
	222
b960074f HV	223	static int vidioc_enum_input(struct file file, void fh, struct v4l2_input *i)
	224	{
	225	DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
	226
223ffe5f	227	if (i->index >= HEXIUM_INPUTS)
b960074f HV	228	return -EINVAL;
	229
	230	memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
	231
	232	DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
	233	return 0;
	234	}
	235
	236	static int vidioc_g_input(struct file file, void fh, unsigned int *input)
	237	{
	238	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	239	struct hexium hexium = (struct hexium ) dev->ext_priv;
	240
	241	*input = hexium->cur_input;
	242
	243	DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
	244	return 0;
	245	}
	246
	247	static int vidioc_s_input(struct file file, void fh, unsigned int input)
	248	{
	249	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	250	struct hexium hexium = (struct hexium ) dev->ext_priv;
	251
	252	DEB_EE(("VIDIOC_S_INPUT %d.\n", input));
	253
f14a2972	254	if (input >= HEXIUM_INPUTS)
b960074f HV	255	return -EINVAL;
	256
	257	hexium->cur_input = input;
	258	hexium_set_input(hexium, input);
	259	return 0;
	260	}
	261
	262	/* the saa7146 provides some controls (brightness, contrast, saturation)
	263	which gets registered after this function. because of this we have
	264	to return with a value != 0 even if the function succeded.. */
	265	static int vidioc_queryctrl(struct file file, void fh, struct v4l2_queryctrl *qc)
	266	{
	267	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	268	int i;
	269
	270	for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
	271	if (hexium_controls[i].id == qc->id) {
	272	*qc = hexium_controls[i];
	273	DEB_D(("VIDIOC_QUERYCTRL %d.\n", qc->id));
	274	return 0;
	275	}
	276	}
	277	return dev->ext_vv_data->core_ops->vidioc_queryctrl(file, fh, qc);
	278	}
	279
	280	static int vidioc_g_ctrl(struct file file, void fh, struct v4l2_control *vc)
	281	{
	282	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	283	struct hexium hexium = (struct hexium ) dev->ext_priv;
	284	int i;
	285
	286	for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
	287	if (hexium_controls[i].id == vc->id)
	288	break;
	289	}
	290
	291	if (i < 0)
	292	return dev->ext_vv_data->core_ops->vidioc_g_ctrl(file, fh, vc);
	293
	294	if (vc->id == V4L2_CID_PRIVATE_BASE) {
	295	vc->value = hexium->cur_bw;
	296	DEB_D(("VIDIOC_G_CTRL BW:%d.\n", vc->value));
	297	return 0;
	298	}
	299	return -EINVAL;
	300	}
	301
	302	static int vidioc_s_ctrl(struct file file, void fh, struct v4l2_control *vc)
	303	{
	304	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	305	struct hexium hexium = (struct hexium ) dev->ext_priv;
	306	int i = 0;
	307
	308	for (i = HEXIUM_CONTROLS - 1; i >= 0; i--) {
	309	if (hexium_controls[i].id == vc->id)
	310	break;
	311	}
	312
	313	if (i < 0)
	314	return dev->ext_vv_data->core_ops->vidioc_s_ctrl(file, fh, vc);
	315
	316	if (vc->id == V4L2_CID_PRIVATE_BASE)
	317	hexium->cur_bw = vc->value;
	318
319	DEB_D(("VIDIOC_S_CTRL BW:%d.\n", hexium->cur_bw));
320
321	if (0 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
322	hexium_set_standard(hexium, hexium_pal);
323	return 0;
324	}
325	if (0 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
326	hexium_set_standard(hexium, hexium_ntsc);
327	return 0;
328	}
329	if (0 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std) {
330	hexium_set_standard(hexium, hexium_secam);
331	return 0;
332	}
333	if (1 == hexium->cur_bw && V4L2_STD_PAL == hexium->cur_std) {
334	hexium_set_standard(hexium, hexium_pal_bw);
335	return 0;
336	}
337	if (1 == hexium->cur_bw && V4L2_STD_NTSC == hexium->cur_std) {
338	hexium_set_standard(hexium, hexium_ntsc_bw);
339	return 0;
340	}
341	if (1 == hexium->cur_bw && V4L2_STD_SECAM == hexium->cur_std)
342	/* fixme: is there no bw secam mode? */
343	return -EINVAL;
344
345	return -EINVAL;
346	}
347
348
1da177e4 LT	349	static struct saa7146_ext_vv vv_data;
	350
	351	/* this function only gets called when the probing was successful */
	352	static int hexium_attach(struct saa7146_dev dev, struct saa7146_pci_extension_data info)
	353	{
	354	struct hexium hexium = (struct hexium ) dev->ext_priv;
cd7d9beb	355	int ret;
1da177e4 LT	356
	357	DEB_EE((".\n"));
	358
cd7d9beb HV	359	ret = saa7146_vv_devinit(dev);
	360	if (ret)
	361	return ret;
7408187d	362	hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
1da177e4 LT	363	if (NULL == hexium) {
	364	printk("hexium_gemini: not enough kernel memory in hexium_attach().\n");
	365	return -ENOMEM;
	366	}
1da177e4 LT	367	dev->ext_priv = hexium;
	368
	369	/* enable i2c-port pins */
	370	saa7146_write(dev, MC1, (MASK_08 \| MASK_24 \| MASK_10 \| MASK_26));
	371
	372	hexium->i2c_adapter = (struct i2c_adapter) {
	373	.class = I2C_CLASS_TV_ANALOG,
	374	.name = "hexium gemini",
	375	};
	376	saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
	377	if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
	378	DEB_S(("cannot register i2c-device. skipping.\n"));
	379	kfree(hexium);
	380	return -EFAULT;
	381	}
	382
	383	/* set HWControl GPIO number 2 */
	384	saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
	385
	386	saa7146_write(dev, DD1_INIT, 0x07000700);
	387	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
	388	saa7146_write(dev, MC2, (MASK_09 \| MASK_25 \| MASK_10 \| MASK_26));
	389
	390	/* the rest */
	391	hexium->cur_input = 0;
	392	hexium_init_done(dev);
	393
	394	hexium_set_standard(hexium, hexium_pal);
	395	hexium->cur_std = V4L2_STD_PAL;
	396
	397	hexium_set_input(hexium, 0);
	398	hexium->cur_input = 0;
	399
	400	saa7146_vv_init(dev, &vv_data);
b960074f HV	401	vv_data.ops.vidioc_queryctrl = vidioc_queryctrl;
	402	vv_data.ops.vidioc_g_ctrl = vidioc_g_ctrl;
	403	vv_data.ops.vidioc_s_ctrl = vidioc_s_ctrl;
	404	vv_data.ops.vidioc_enum_input = vidioc_enum_input;
	405	vv_data.ops.vidioc_g_input = vidioc_g_input;
	406	vv_data.ops.vidioc_s_input = vidioc_s_input;
cd7d9beb HV	407	ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
cd7d9beb HV	408	if (ret < 0) {
1da177e4	409	printk("hexium_gemini: cannot register capture v4l2 device. skipping.\n");
cd7d9beb	410	return ret;
1da177e4 LT	411	}
	412
	413	printk("hexium_gemini: found 'hexium gemini' frame grabber-%d.\n", hexium_num);
	414	hexium_num++;
	415
	416	return 0;
	417	}
	418
	419	static int hexium_detach(struct saa7146_dev *dev)
	420	{
	421	struct hexium hexium = (struct hexium ) dev->ext_priv;
	422
	423	DEB_EE(("dev:%p\n", dev));
	424
	425	saa7146_unregister_device(&hexium->video_dev, dev);
	426	saa7146_vv_release(dev);
	427
	428	hexium_num--;
	429
	430	i2c_del_adapter(&hexium->i2c_adapter);
	431	kfree(hexium);
	432	return 0;
	433	}
	434
1da177e4 LT	435	static int std_callback(struct saa7146_dev dev, struct saa7146_standard std)
	436	{
	437	struct hexium hexium = (struct hexium ) dev->ext_priv;
	438
	439	if (V4L2_STD_PAL == std->id) {
	440	hexium_set_standard(hexium, hexium_pal);
	441	hexium->cur_std = V4L2_STD_PAL;
	442	return 0;
	443	} else if (V4L2_STD_NTSC == std->id) {
	444	hexium_set_standard(hexium, hexium_ntsc);
	445	hexium->cur_std = V4L2_STD_NTSC;
	446	return 0;
	447	} else if (V4L2_STD_SECAM == std->id) {
	448	hexium_set_standard(hexium, hexium_secam);
	449	hexium->cur_std = V4L2_STD_SECAM;
	450	return 0;
	451	}
	452
	453	return -1;
	454	}
	455
	456	static struct saa7146_extension hexium_extension;
	457
	458	static struct saa7146_pci_extension_data hexium_gemini_4bnc = {
	459	.ext_priv = "Hexium Gemini (4 BNC)",
	460	.ext = &hexium_extension,
	461	};
	462
	463	static struct saa7146_pci_extension_data hexium_gemini_dual_4bnc = {
	464	.ext_priv = "Hexium Gemini Dual (4 BNC)",
	465	.ext = &hexium_extension,
	466	};
	467
	468	static struct pci_device_id pci_tbl[] = {
	469	{
	470	.vendor = PCI_VENDOR_ID_PHILIPS,
	471	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	472	.subvendor = 0x17c8,
	473	.subdevice = 0x2401,
	474	.driver_data = (unsigned long) &hexium_gemini_4bnc,
	475	},
	476	{
	477	.vendor = PCI_VENDOR_ID_PHILIPS,
	478	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	479	.subvendor = 0x17c8,
	480	.subdevice = 0x2402,
	481	.driver_data = (unsigned long) &hexium_gemini_dual_4bnc,
	482	},
	483	{
	484	.vendor = 0,
	485	}
	486	};
	487
	488	MODULE_DEVICE_TABLE(pci, pci_tbl);
	489
	490	static struct saa7146_ext_vv vv_data = {
	491	.inputs = HEXIUM_INPUTS,
	492	.capabilities = 0,
	493	.stds = &hexium_standards[0],
	494	.num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
	495	.std_callback = &std_callback,
1da177e4 LT	496	};
	497
	498	static struct saa7146_extension hexium_extension = {
	499	.name = "hexium gemini",
	500	.flags = SAA7146_USE_I2C_IRQ,
	501
	502	.pci_tbl = &pci_tbl[0],
	503	.module = THIS_MODULE,
	504
	505	.attach = hexium_attach,
	506	.detach = hexium_detach,
	507
	508	.irq_mask = 0,
	509	.irq_func = NULL,
	510	};
	511
	512	static int __init hexium_init_module(void)
	513	{
	514	if (0 != saa7146_register_extension(&hexium_extension)) {
	515	DEB_S(("failed to register extension.\n"));
	516	return -ENODEV;
	517	}
	518
	519	return 0;
	520	}
	521
	522	static void __exit hexium_cleanup_module(void)
	523	{
	524	saa7146_unregister_extension(&hexium_extension);
	525	}
	526
	527	module_init(hexium_init_module);
	528	module_exit(hexium_cleanup_module);
	529
	530	MODULE_DESCRIPTION("video4linux-2 driver for Hexium Gemini frame grabber cards");
	531	MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
	532	MODULE_LICENSE("GPL");