[linux-2.6-block.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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#define DEBUG_VARIABLE debug

#include <media/saa7146_vv.h>
#include <linux/module.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,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 1, "CVBS 2",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 2, "CVBS 3",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 3, "CVBS 4",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 4, "CVBS 5",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 5, "CVBS 6",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 6, "Y/C 1",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 7, "Y/C 2",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	{ 8, "Y/C 3",	V4L2_INPUT_TYPE_CAMERA,	0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
};

#define HEXIUM_AUDIOS	0

struct hexium_data
{
	s8 adr;
	u8 byte;
};

#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 */
};

/* 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_ntsc[] = {
	{ 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)) {
			pr_err("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)) {
			pr_err("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;
}

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;
	int ret;

	DEB_EE("\n");

	hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
	if (NULL == hexium) {
		pr_err("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) {
		.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.vid_ops.vidioc_enum_input = vidioc_enum_input;
	vv_data.vid_ops.vidioc_g_input = vidioc_g_input;
	vv_data.vid_ops.vidioc_s_input = vidioc_s_input;
	ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
	if (ret < 0) {
		pr_err("cannot register capture v4l2 device. skipping.\n");
		return ret;
	}

	pr_info("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
44d0b80e JP	24	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
44d0b80e JP	25
1da177e4 LT	26	#define DEBUG_VARIABLE debug
	27
	28	#include <media/saa7146_vv.h>
7a707b89	29	#include <linux/module.h>
1da177e4	30
ff699e6b	31	static int debug;
1da177e4 LT	32	module_param(debug, int, 0);
	33	MODULE_PARM_DESC(debug, "debug verbosity");
	34
	35	/* global variables */
ff699e6b	36	static int hexium_num;
1da177e4 LT	37
	38	#define HEXIUM_GEMINI 4
	39	#define HEXIUM_GEMINI_DUAL 5
	40
	41	#define HEXIUM_INPUTS 9
	42	static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
332e799c HV	43	{ 0, "CVBS 1", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	44	{ 1, "CVBS 2", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	45	{ 2, "CVBS 3", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	46	{ 3, "CVBS 4", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	47	{ 4, "CVBS 5", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	48	{ 5, "CVBS 6", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	49	{ 6, "Y/C 1", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	50	{ 7, "Y/C 2", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
	51	{ 8, "Y/C 3", V4L2_INPUT_TYPE_CAMERA, 0, 0, V4L2_STD_ALL, 0, V4L2_IN_CAP_STD },
1da177e4 LT	52	};
	53
	54	#define HEXIUM_AUDIOS 0
	55
	56	struct hexium_data
	57	{
	58	s8 adr;
	59	u8 byte;
	60	};
	61
1da177e4 LT	62	#define HEXIUM_GEMINI_V_1_0 1
	63	#define HEXIUM_GEMINI_DUAL_V_1_0 2
	64
	65	struct hexium
	66	{
	67	int type;
	68
	69	struct video_device *video_dev;
	70	struct i2c_adapter i2c_adapter;
a8733ca5	71
1da177e4 LT	72	int cur_input; /* current input */
1da177e4 LT	73	v4l2_std_id cur_std; /* current standard */
1da177e4 LT	74	};
	75
	76	/* Samsung KS0127B decoder default registers */
	77	static u8 hexium_ks0127b[0x100]={
	78	/00/ 0x00,0x52,0x30,0x40,0x01,0x0C,0x2A,0x10,
	79	/08/ 0x00,0x00,0x00,0x60,0x00,0x00,0x0F,0x06,
	80	/10/ 0x00,0x00,0xE4,0xC0,0x00,0x00,0x00,0x00,
	81	/18/ 0x14,0x9B,0xFE,0xFF,0xFC,0xFF,0x03,0x22,
	82	/20/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	83	/28/ 0x00,0x00,0x00,0x00,0x00,0x2C,0x9B,0x00,
	84	/30/ 0x00,0x00,0x10,0x80,0x80,0x10,0x80,0x80,
	85	/38/ 0x01,0x04,0x00,0x00,0x00,0x29,0xC0,0x00,
	86	/40/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	87	/48/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	88	/50/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	89	/58/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	90	/60/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	91	/68/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	92	/70/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	93	/78/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	94	/80/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	95	/88/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	96	/90/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	97	/98/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	98	/A0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	99	/A8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	100	/B0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	101	/B8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	102	/C0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	103	/C8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	104	/D0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	105	/D8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	106	/E0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	107	/E8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	108	/F0/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	109	/F8/ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
	110	};
	111
	112	static struct hexium_data hexium_pal[] = {
	113	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
	114	};
	115
1da177e4 LT	116	static struct hexium_data hexium_ntsc[] = {
	117	{ 0x01, 0x53 }, { 0x12, 0x04 }, { 0x2D, 0x23 }, { 0x2E, 0x81 }, { -1 , 0xFF }
	118	};
	119
1da177e4 LT	120	static struct hexium_data hexium_secam[] = {
	121	{ 0x01, 0x52 }, { 0x12, 0x64 }, { 0x2D, 0x2C }, { 0x2E, 0x9B }, { -1 , 0xFF }
	122	};
	123
	124	static struct hexium_data hexium_input_select[] = {
	125	{ 0x02, 0x60 },
	126	{ 0x02, 0x64 },
	127	{ 0x02, 0x61 },
	128	{ 0x02, 0x65 },
	129	{ 0x02, 0x62 },
	130	{ 0x02, 0x66 },
	131	{ 0x02, 0x68 },
	132	{ 0x02, 0x69 },
	133	{ 0x02, 0x6A },
	134	};
	135
	136	/* fixme: h_offset = 0 for Hexium Gemini Dual, which
	137	are currently not supported*/
	138	static struct saa7146_standard hexium_standards[] = {
	139	{
	140	.name = "PAL", .id = V4L2_STD_PAL,
	141	.v_offset = 28, .v_field = 288,
	142	.h_offset = 1, .h_pixels = 680,
	143	.v_max_out = 576, .h_max_out = 768,
	144	}, {
	145	.name = "NTSC", .id = V4L2_STD_NTSC,
	146	.v_offset = 28, .v_field = 240,
	147	.h_offset = 1, .h_pixels = 640,
	148	.v_max_out = 480, .h_max_out = 640,
	149	}, {
	150	.name = "SECAM", .id = V4L2_STD_SECAM,
	151	.v_offset = 28, .v_field = 288,
	152	.h_offset = 1, .h_pixels = 720,
	153	.v_max_out = 576, .h_max_out = 768,
	154	}
a8733ca5	155	};
1da177e4 LT	156
	157	/* bring hardware to a sane state. this has to be done, just in case someone
	158	wants to capture from this device before it has been properly initialized.
	159	the capture engine would badly fail, because no valid signal arrives on the
	160	saa7146, thus leading to timeouts and stuff. */
	161	static int hexium_init_done(struct saa7146_dev *dev)
	162	{
	163	struct hexium hexium = (struct hexium ) dev->ext_priv;
	164	union i2c_smbus_data data;
	165	int i = 0;
	166
44d0b80e	167	DEB_D("hexium_init_done called\n");
1da177e4 LT	168
	169	/* initialize the helper ics to useful values */
	170	for (i = 0; i < sizeof(hexium_ks0127b); i++) {
	171	data.byte = hexium_ks0127b[i];
	172	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
44d0b80e JP	173	pr_err("hexium_init_done() failed for address 0x%02x\n",
44d0b80e JP	174	i);
1da177e4 LT	175	}
	176	}
	177
	178	return 0;
	179	}
	180
	181	static int hexium_set_input(struct hexium *hexium, int input)
	182	{
	183	union i2c_smbus_data data;
	184
44d0b80e	185	DEB_D("\n");
1da177e4 LT	186
	187	data.byte = hexium_input_select[input].byte;
	188	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, hexium_input_select[input].adr, I2C_SMBUS_BYTE_DATA, &data)) {
	189	return -1;
	190	}
	191
	192	return 0;
	193	}
	194
	195	static int hexium_set_standard(struct hexium hexium, struct hexium_data vdec)
	196	{
	197	union i2c_smbus_data data;
	198	int i = 0;
	199
44d0b80e	200	DEB_D("\n");
1da177e4 LT	201
	202	while (vdec[i].adr != -1) {
	203	data.byte = vdec[i].byte;
	204	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x6c, 0, I2C_SMBUS_WRITE, vdec[i].adr, I2C_SMBUS_BYTE_DATA, &data)) {
44d0b80e JP	205	pr_err("hexium_init_done: hexium_set_standard() failed for address 0x%02x\n",
44d0b80e JP	206	i);
1da177e4 LT	207	return -1;
	208	}
	209	i++;
	210	}
	211	return 0;
	212	}
	213
b960074f HV	214	static int vidioc_enum_input(struct file file, void fh, struct v4l2_input *i)
b960074f HV	215	{
44d0b80e	216	DEB_EE("VIDIOC_ENUMINPUT %d\n", i->index);
b960074f	217
223ffe5f	218	if (i->index >= HEXIUM_INPUTS)
b960074f HV	219	return -EINVAL;
	220
	221	memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
	222
44d0b80e	223	DEB_D("v4l2_ioctl: VIDIOC_ENUMINPUT %d\n", i->index);
b960074f HV	224	return 0;
	225	}
	226
	227	static int vidioc_g_input(struct file file, void fh, unsigned int *input)
	228	{
	229	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	230	struct hexium hexium = (struct hexium ) dev->ext_priv;
	231
	232	*input = hexium->cur_input;
	233
44d0b80e	234	DEB_D("VIDIOC_G_INPUT: %d\n", *input);
b960074f HV	235	return 0;
	236	}
	237
	238	static int vidioc_s_input(struct file file, void fh, unsigned int input)
	239	{
	240	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	241	struct hexium hexium = (struct hexium ) dev->ext_priv;
	242
44d0b80e	243	DEB_EE("VIDIOC_S_INPUT %d\n", input);
b960074f	244
f14a2972	245	if (input >= HEXIUM_INPUTS)
b960074f HV	246	return -EINVAL;
	247
	248	hexium->cur_input = input;
	249	hexium_set_input(hexium, input);
	250	return 0;
	251	}
	252
1da177e4 LT	253	static struct saa7146_ext_vv vv_data;
	254
	255	/* this function only gets called when the probing was successful */
	256	static int hexium_attach(struct saa7146_dev dev, struct saa7146_pci_extension_data info)
	257	{
f00fd919	258	struct hexium *hexium;
cd7d9beb	259	int ret;
1da177e4	260
44d0b80e	261	DEB_EE("\n");
1da177e4	262
7408187d	263	hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
1da177e4	264	if (NULL == hexium) {
44d0b80e	265	pr_err("not enough kernel memory in hexium_attach()\n");
1da177e4 LT	266	return -ENOMEM;
1da177e4 LT	267	}
1da177e4 LT	268	dev->ext_priv = hexium;
	269
	270	/* enable i2c-port pins */
	271	saa7146_write(dev, MC1, (MASK_08 \| MASK_24 \| MASK_10 \| MASK_26));
	272
	273	hexium->i2c_adapter = (struct i2c_adapter) {
1da177e4 LT	274	.name = "hexium gemini",
	275	};
	276	saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
	277	if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
44d0b80e	278	DEB_S("cannot register i2c-device. skipping.\n");
1da177e4 LT	279	kfree(hexium);
	280	return -EFAULT;
	281	}
	282
	283	/* set HWControl GPIO number 2 */
	284	saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
	285
	286	saa7146_write(dev, DD1_INIT, 0x07000700);
	287	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
	288	saa7146_write(dev, MC2, (MASK_09 \| MASK_25 \| MASK_10 \| MASK_26));
	289
	290	/* the rest */
	291	hexium->cur_input = 0;
	292	hexium_init_done(dev);
	293
	294	hexium_set_standard(hexium, hexium_pal);
	295	hexium->cur_std = V4L2_STD_PAL;
	296
	297	hexium_set_input(hexium, 0);
	298	hexium->cur_input = 0;
	299
	300	saa7146_vv_init(dev, &vv_data);
332e799c	301
ab49ae0f HV	302	vv_data.vid_ops.vidioc_enum_input = vidioc_enum_input;
	303	vv_data.vid_ops.vidioc_g_input = vidioc_g_input;
	304	vv_data.vid_ops.vidioc_s_input = vidioc_s_input;
cd7d9beb HV	305	ret = saa7146_register_device(&hexium->video_dev, dev, "hexium gemini", VFL_TYPE_GRABBER);
cd7d9beb HV	306	if (ret < 0) {
44d0b80e	307	pr_err("cannot register capture v4l2 device. skipping.\n");
cd7d9beb	308	return ret;
1da177e4 LT	309	}
1da177e4 LT	310
44d0b80e	311	pr_info("found 'hexium gemini' frame grabber-%d\n", hexium_num);
1da177e4 LT	312	hexium_num++;
	313
	314	return 0;
	315	}
	316
	317	static int hexium_detach(struct saa7146_dev *dev)
	318	{
	319	struct hexium hexium = (struct hexium ) dev->ext_priv;
	320
44d0b80e	321	DEB_EE("dev:%p\n", dev);
1da177e4 LT	322
	323	saa7146_unregister_device(&hexium->video_dev, dev);
	324	saa7146_vv_release(dev);
	325
	326	hexium_num--;
	327
	328	i2c_del_adapter(&hexium->i2c_adapter);
	329	kfree(hexium);
	330	return 0;
	331	}
	332
1da177e4 LT	333	static int std_callback(struct saa7146_dev dev, struct saa7146_standard std)
	334	{
	335	struct hexium hexium = (struct hexium ) dev->ext_priv;
	336
	337	if (V4L2_STD_PAL == std->id) {
	338	hexium_set_standard(hexium, hexium_pal);
	339	hexium->cur_std = V4L2_STD_PAL;
	340	return 0;
	341	} else if (V4L2_STD_NTSC == std->id) {
	342	hexium_set_standard(hexium, hexium_ntsc);
	343	hexium->cur_std = V4L2_STD_NTSC;
	344	return 0;
	345	} else if (V4L2_STD_SECAM == std->id) {
	346	hexium_set_standard(hexium, hexium_secam);
	347	hexium->cur_std = V4L2_STD_SECAM;
	348	return 0;
	349	}
	350
	351	return -1;
	352	}
	353
	354	static struct saa7146_extension hexium_extension;
	355
	356	static struct saa7146_pci_extension_data hexium_gemini_4bnc = {
	357	.ext_priv = "Hexium Gemini (4 BNC)",
	358	.ext = &hexium_extension,
	359	};
	360
	361	static struct saa7146_pci_extension_data hexium_gemini_dual_4bnc = {
	362	.ext_priv = "Hexium Gemini Dual (4 BNC)",
	363	.ext = &hexium_extension,
	364	};
	365
	366	static struct pci_device_id pci_tbl[] = {
	367	{
	368	.vendor = PCI_VENDOR_ID_PHILIPS,
	369	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	370	.subvendor = 0x17c8,
	371	.subdevice = 0x2401,
	372	.driver_data = (unsigned long) &hexium_gemini_4bnc,
	373	},
	374	{
	375	.vendor = PCI_VENDOR_ID_PHILIPS,
	376	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	377	.subvendor = 0x17c8,
	378	.subdevice = 0x2402,
	379	.driver_data = (unsigned long) &hexium_gemini_dual_4bnc,
	380	},
	381	{
	382	.vendor = 0,
	383	}
	384	};
	385
	386	MODULE_DEVICE_TABLE(pci, pci_tbl);
	387
	388	static struct saa7146_ext_vv vv_data = {
	389	.inputs = HEXIUM_INPUTS,
	390	.capabilities = 0,
	391	.stds = &hexium_standards[0],
	392	.num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
	393	.std_callback = &std_callback,
1da177e4 LT	394	};
	395
	396	static struct saa7146_extension hexium_extension = {
	397	.name = "hexium gemini",
	398	.flags = SAA7146_USE_I2C_IRQ,
	399
	400	.pci_tbl = &pci_tbl[0],
	401	.module = THIS_MODULE,
	402
	403	.attach = hexium_attach,
	404	.detach = hexium_detach,
	405
	406	.irq_mask = 0,
	407	.irq_func = NULL,
	408	};
	409
	410	static int __init hexium_init_module(void)
	411	{
	412	if (0 != saa7146_register_extension(&hexium_extension)) {
44d0b80e	413	DEB_S("failed to register extension\n");
1da177e4 LT	414	return -ENODEV;
	415	}
	416
	417	return 0;
	418	}
	419
	420	static void __exit hexium_cleanup_module(void)
	421	{
	422	saa7146_unregister_extension(&hexium_extension);
	423	}
	424
	425	module_init(hexium_init_module);
	426	module_exit(hexium_cleanup_module);
	427
	428	MODULE_DESCRIPTION("video4linux-2 driver for Hexium Gemini frame grabber cards");
	429	MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
	430	MODULE_LICENSE("GPL");