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

/*
    hexium_orion.c - v4l2 driver for the Hexium Orion 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_HV_PCI6_ORION		1
#define HEXIUM_ORION_1SVHS_3BNC		2
#define HEXIUM_ORION_4BNC		3

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

struct hexium
{
	int type;
	struct video_device	*video_dev;
	struct i2c_adapter	i2c_adapter;

	int cur_input;	/* current input */
};

/* Philips SAA7110 decoder default registers */
static u8 hexium_saa7110[53]={
/*00*/ 0x4C,0x3C,0x0D,0xEF,0xBD,0xF0,0x00,0x00,
/*08*/ 0xF8,0xF8,0x60,0x60,0x40,0x86,0x18,0x90,
/*10*/ 0x00,0x2C,0x40,0x46,0x42,0x1A,0xFF,0xDA,
/*18*/ 0xF0,0x8B,0x00,0x00,0x00,0x00,0x00,0x00,
/*20*/ 0xD9,0x17,0x40,0x41,0x80,0x41,0x80,0x4F,
/*28*/ 0xFE,0x01,0x0F,0x0F,0x03,0x01,0x81,0x03,
/*30*/ 0x44,0x75,0x01,0x8C,0x03
};

static struct {
	struct hexium_data data[8];
} hexium_input_select[] = {
{
	{ /* cvbs 1 */
		{ 0x06, 0x00 },
		{ 0x20, 0xD9 },
		{ 0x21, 0x17 }, // 0x16,
		{ 0x22, 0x40 },
		{ 0x2C, 0x03 },
		{ 0x30, 0x44 },
		{ 0x31, 0x75 }, // ??
		{ 0x21, 0x16 }, // 0x03,
	}
}, {
	{ /* cvbs 2 */
		{ 0x06, 0x00 },
		{ 0x20, 0x78 },
		{ 0x21, 0x07 }, // 0x03,
		{ 0x22, 0xD2 },
		{ 0x2C, 0x83 },
		{ 0x30, 0x60 },
		{ 0x31, 0xB5 }, // ?
		{ 0x21, 0x03 },
	}
}, {
	{ /* cvbs 3 */
		{ 0x06, 0x00 },
		{ 0x20, 0xBA },
		{ 0x21, 0x07 }, // 0x05,
		{ 0x22, 0x91 },
		{ 0x2C, 0x03 },
		{ 0x30, 0x60 },
		{ 0x31, 0xB5 }, // ??
		{ 0x21, 0x05 }, // 0x03,
	}
}, {
	{ /* cvbs 4 */
		{ 0x06, 0x00 },
		{ 0x20, 0xD8 },
		{ 0x21, 0x17 }, // 0x16,
		{ 0x22, 0x40 },
		{ 0x2C, 0x03 },
		{ 0x30, 0x44 },
		{ 0x31, 0x75 }, // ??
		{ 0x21, 0x16 }, // 0x03,
	}
}, {
	{ /* cvbs 5 */
		{ 0x06, 0x00 },
		{ 0x20, 0xB8 },
		{ 0x21, 0x07 }, // 0x05,
		{ 0x22, 0x91 },
		{ 0x2C, 0x03 },
		{ 0x30, 0x60 },
		{ 0x31, 0xB5 }, // ??
		{ 0x21, 0x05 }, // 0x03,
	}
}, {
	{ /* cvbs 6 */
		{ 0x06, 0x00 },
		{ 0x20, 0x7C },
		{ 0x21, 0x07 }, // 0x03
		{ 0x22, 0xD2 },
		{ 0x2C, 0x83 },
		{ 0x30, 0x60 },
		{ 0x31, 0xB5 }, // ??
		{ 0x21, 0x03 },
	}
}, {
	{ /* y/c 1 */
		{ 0x06, 0x80 },
		{ 0x20, 0x59 },
		{ 0x21, 0x17 },
		{ 0x22, 0x42 },
		{ 0x2C, 0xA3 },
		{ 0x30, 0x44 },
		{ 0x31, 0x75 },
		{ 0x21, 0x12 },
	}
}, {
	{ /* y/c 2 */
		{ 0x06, 0x80 },
		{ 0x20, 0x9A },
		{ 0x21, 0x17 },
		{ 0x22, 0xB1 },
		{ 0x2C, 0x13 },
		{ 0x30, 0x60 },
		{ 0x31, 0xB5 },
		{ 0x21, 0x14 },
	}
}, {
	{ /* y/c 3 */
		{ 0x06, 0x80 },
		{ 0x20, 0x3C },
		{ 0x21, 0x27 },
		{ 0x22, 0xC1 },
		{ 0x2C, 0x23 },
		{ 0x30, 0x44 },
		{ 0x31, 0x75 },
		{ 0x21, 0x21 },
	}
}
};

static struct saa7146_standard hexium_standards[] = {
	{
		.name	= "PAL", 	.id	= V4L2_STD_PAL,
		.v_offset	= 16,	.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	= 16,	.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	= 16,	.v_field 	= 288,
		.h_offset	= 1,	.h_pixels 	= 720,
		.v_max_out	= 576,	.h_max_out	= 768,
	}
};

/* this is only called for old HV-PCI6/Orion cards
   without eeprom */
static int hexium_probe(struct saa7146_dev *dev)
{
	struct hexium *hexium = NULL;
	union i2c_smbus_data data;
	int err = 0;

	DEB_EE((".\n"));

	/* there are no hexium orion cards with revision 0 saa7146s */
	if (0 == dev->revision) {
		return -EFAULT;
	}

	hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
	if (NULL == hexium) {
		printk("hexium_orion: hexium_probe: not enough kernel memory.\n");
		return -ENOMEM;
	}

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

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

	hexium->i2c_adapter = (struct i2c_adapter) {
		.class = I2C_CLASS_TV_ANALOG,
		.name = "hexium orion",
	};
	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 SAA7110 control GPIO 0 */
	saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTHI);
	/*  set HWControl GPIO number 2 */
	saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);

	mdelay(10);

	/* detect newer Hexium Orion cards by subsystem ids */
	if (0x17c8 == dev->pci->subsystem_vendor && 0x0101 == dev->pci->subsystem_device) {
		printk("hexium_orion: device is a Hexium Orion w/ 1 SVHS + 3 BNC inputs.\n");
		/* we store the pointer in our private data field */
		dev->ext_priv = hexium;
		hexium->type = HEXIUM_ORION_1SVHS_3BNC;
		return 0;
	}

	if (0x17c8 == dev->pci->subsystem_vendor && 0x2101 == dev->pci->subsystem_device) {
		printk("hexium_orion: device is a Hexium Orion w/ 4 BNC inputs.\n");
		/* we store the pointer in our private data field */
		dev->ext_priv = hexium;
		hexium->type = HEXIUM_ORION_4BNC;
		return 0;
	}

	/* check if this is an old hexium Orion card by looking at
	   a saa7110 at address 0x4e */
	if (0 == (err = i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_READ, 0x00, I2C_SMBUS_BYTE_DATA, &data))) {
		printk("hexium_orion: device is a Hexium HV-PCI6/Orion (old).\n");
		/* we store the pointer in our private data field */
		dev->ext_priv = hexium;
		hexium->type = HEXIUM_HV_PCI6_ORION;
		return 0;
	}

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

/* 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_saa7110); i++) {
		data.byte = hexium_saa7110[i];
		if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
			printk("hexium_orion: failed for address 0x%02x\n", i);
		}
	}

	return 0;
}

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

	DEB_D((".\n"));

	for (i = 0; i < 8; i++) {
		int adr = hexium_input_select[input].data[i].adr;
		data.byte = hexium_input_select[input].data[i].byte;
		if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, adr, I2C_SMBUS_BYTE_DATA, &data)) {
			return -1;
		}
		printk("%d: 0x%02x => 0x%02x\n",input, adr,data.byte);
	}

	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;

	if (input < 0 || 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 = (struct hexium *) dev->ext_priv;

	DEB_EE((".\n"));

	saa7146_vv_init(dev, &vv_data);
	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;
	if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium orion", VFL_TYPE_GRABBER)) {
		printk("hexium_orion: cannot register capture v4l2 device. skipping.\n");
		return -1;
	}

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

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

	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)
{
	return 0;
}

static struct saa7146_extension extension;

static struct saa7146_pci_extension_data hexium_hv_pci6 = {
	.ext_priv = "Hexium HV-PCI6 / Orion",
	.ext = &extension,
};

static struct saa7146_pci_extension_data hexium_orion_1svhs_3bnc = {
	.ext_priv = "Hexium HV-PCI6 / Orion (1 SVHS/3 BNC)",
	.ext = &extension,
};

static struct saa7146_pci_extension_data hexium_orion_4bnc = {
	.ext_priv = "Hexium HV-PCI6 / Orion (4 BNC)",
	.ext = &extension,
};

static struct pci_device_id pci_tbl[] = {
	{
	 .vendor = PCI_VENDOR_ID_PHILIPS,
	 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	 .subvendor = 0x0000,
	 .subdevice = 0x0000,
	 .driver_data = (unsigned long) &hexium_hv_pci6,
	 },
	{
	 .vendor = PCI_VENDOR_ID_PHILIPS,
	 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	 .subvendor = 0x17c8,
	 .subdevice = 0x0101,
	 .driver_data = (unsigned long) &hexium_orion_1svhs_3bnc,
	 },
	{
	 .vendor = PCI_VENDOR_ID_PHILIPS,
	 .device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	 .subvendor = 0x17c8,
	 .subdevice = 0x2101,
	 .driver_data = (unsigned long) &hexium_orion_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 extension = {
	.name = "hexium HV-PCI6 Orion",
	.flags = 0,		// SAA7146_USE_I2C_IRQ,

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

	.probe = hexium_probe,
	.attach = hexium_attach,
	.detach = hexium_detach,

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

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

	return 0;
}

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

module_init(hexium_init_module);
module_exit(hexium_cleanup_module);

MODULE_DESCRIPTION("video4linux-2 driver for Hexium Orion frame grabber cards");
MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	hexium_orion.c - v4l2 driver for the Hexium Orion frame grabber cards
	3
	4	Visit http://www.mihu.de/linux/saa7146/ and follow the link
	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_HV_PCI6_ORION 1
	36	#define HEXIUM_ORION_1SVHS_3BNC 2
	37	#define HEXIUM_ORION_4BNC 3
	38
	39	#define HEXIUM_INPUTS 9
	40	static struct v4l2_input hexium_inputs[HEXIUM_INPUTS] = {
	41	{ 0, "CVBS 1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	42	{ 1, "CVBS 2", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	43	{ 2, "CVBS 3", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	44	{ 3, "CVBS 4", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	45	{ 4, "CVBS 5", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	46	{ 5, "CVBS 6", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	47	{ 6, "Y/C 1", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	48	{ 7, "Y/C 2", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	49	{ 8, "Y/C 3", V4L2_INPUT_TYPE_CAMERA, 2, 0, V4L2_STD_PAL_BG\|V4L2_STD_NTSC_M, 0 },
	50	};
	51
	52	#define HEXIUM_AUDIOS 0
	53
	54	struct hexium_data
	55	{
	56	s8 adr;
	57	u8 byte;
	58	};
	59
1da177e4 LT	60	struct hexium
	61	{
	62	int type;
	63	struct video_device *video_dev;
a8733ca5	64	struct i2c_adapter i2c_adapter;
1da177e4 LT	65
	66	int cur_input; /* current input */
	67	};
	68
	69	/* Philips SAA7110 decoder default registers */
	70	static u8 hexium_saa7110[53]={
	71	/00/ 0x4C,0x3C,0x0D,0xEF,0xBD,0xF0,0x00,0x00,
	72	/08/ 0xF8,0xF8,0x60,0x60,0x40,0x86,0x18,0x90,
	73	/10/ 0x00,0x2C,0x40,0x46,0x42,0x1A,0xFF,0xDA,
	74	/18/ 0xF0,0x8B,0x00,0x00,0x00,0x00,0x00,0x00,
	75	/20/ 0xD9,0x17,0x40,0x41,0x80,0x41,0x80,0x4F,
	76	/28/ 0xFE,0x01,0x0F,0x0F,0x03,0x01,0x81,0x03,
	77	/30/ 0x44,0x75,0x01,0x8C,0x03
	78	};
	79
	80	static struct {
a8733ca5	81	struct hexium_data data[8];
1da177e4 LT	82	} hexium_input_select[] = {
	83	{
	84	{ /* cvbs 1 */
	85	{ 0x06, 0x00 },
	86	{ 0x20, 0xD9 },
	87	{ 0x21, 0x17 }, // 0x16,
	88	{ 0x22, 0x40 },
	89	{ 0x2C, 0x03 },
	90	{ 0x30, 0x44 },
	91	{ 0x31, 0x75 }, // ??
	92	{ 0x21, 0x16 }, // 0x03,
	93	}
	94	}, {
	95	{ /* cvbs 2 */
	96	{ 0x06, 0x00 },
	97	{ 0x20, 0x78 },
	98	{ 0x21, 0x07 }, // 0x03,
	99	{ 0x22, 0xD2 },
	100	{ 0x2C, 0x83 },
	101	{ 0x30, 0x60 },
	102	{ 0x31, 0xB5 }, // ?
	103	{ 0x21, 0x03 },
	104	}
	105	}, {
	106	{ /* cvbs 3 */
	107	{ 0x06, 0x00 },
	108	{ 0x20, 0xBA },
	109	{ 0x21, 0x07 }, // 0x05,
	110	{ 0x22, 0x91 },
	111	{ 0x2C, 0x03 },
	112	{ 0x30, 0x60 },
	113	{ 0x31, 0xB5 }, // ??
	114	{ 0x21, 0x05 }, // 0x03,
	115	}
	116	}, {
	117	{ /* cvbs 4 */
	118	{ 0x06, 0x00 },
	119	{ 0x20, 0xD8 },
	120	{ 0x21, 0x17 }, // 0x16,
	121	{ 0x22, 0x40 },
	122	{ 0x2C, 0x03 },
	123	{ 0x30, 0x44 },
	124	{ 0x31, 0x75 }, // ??
	125	{ 0x21, 0x16 }, // 0x03,
	126	}
	127	}, {
	128	{ /* cvbs 5 */
	129	{ 0x06, 0x00 },
	130	{ 0x20, 0xB8 },
	131	{ 0x21, 0x07 }, // 0x05,
	132	{ 0x22, 0x91 },
	133	{ 0x2C, 0x03 },
	134	{ 0x30, 0x60 },
	135	{ 0x31, 0xB5 }, // ??
	136	{ 0x21, 0x05 }, // 0x03,
	137	}
	138	}, {
	139	{ /* cvbs 6 */
	140	{ 0x06, 0x00 },
	141	{ 0x20, 0x7C },
	142	{ 0x21, 0x07 }, // 0x03
	143	{ 0x22, 0xD2 },
	144	{ 0x2C, 0x83 },
	145	{ 0x30, 0x60 },
146	{ 0x31, 0xB5 }, // ??
147	{ 0x21, 0x03 },
a8733ca5	148	}
1da177e4 LT	149	}, {
	150	{ /* y/c 1 */
	151	{ 0x06, 0x80 },
	152	{ 0x20, 0x59 },
	153	{ 0x21, 0x17 },
	154	{ 0x22, 0x42 },
	155	{ 0x2C, 0xA3 },
	156	{ 0x30, 0x44 },
	157	{ 0x31, 0x75 },
	158	{ 0x21, 0x12 },
	159	}
	160	}, {
	161	{ /* y/c 2 */
	162	{ 0x06, 0x80 },
	163	{ 0x20, 0x9A },
	164	{ 0x21, 0x17 },
	165	{ 0x22, 0xB1 },
	166	{ 0x2C, 0x13 },
	167	{ 0x30, 0x60 },
	168	{ 0x31, 0xB5 },
	169	{ 0x21, 0x14 },
	170	}
	171	}, {
	172	{ /* y/c 3 */
	173	{ 0x06, 0x80 },
	174	{ 0x20, 0x3C },
	175	{ 0x21, 0x27 },
	176	{ 0x22, 0xC1 },
	177	{ 0x2C, 0x23 },
	178	{ 0x30, 0x44 },
	179	{ 0x31, 0x75 },
	180	{ 0x21, 0x21 },
	181	}
a8733ca5	182	}
1da177e4 LT	183	};
	184
	185	static struct saa7146_standard hexium_standards[] = {
	186	{
	187	.name = "PAL", .id = V4L2_STD_PAL,
	188	.v_offset = 16, .v_field = 288,
	189	.h_offset = 1, .h_pixels = 680,
	190	.v_max_out = 576, .h_max_out = 768,
	191	}, {
	192	.name = "NTSC", .id = V4L2_STD_NTSC,
	193	.v_offset = 16, .v_field = 240,
	194	.h_offset = 1, .h_pixels = 640,
	195	.v_max_out = 480, .h_max_out = 640,
	196	}, {
	197	.name = "SECAM", .id = V4L2_STD_SECAM,
	198	.v_offset = 16, .v_field = 288,
	199	.h_offset = 1, .h_pixels = 720,
	200	.v_max_out = 576, .h_max_out = 768,
	201	}
a8733ca5	202	};
1da177e4 LT	203
	204	/* this is only called for old HV-PCI6/Orion cards
	205	without eeprom */
	206	static int hexium_probe(struct saa7146_dev *dev)
	207	{
	208	struct hexium *hexium = NULL;
	209	union i2c_smbus_data data;
	210	int err = 0;
	211
	212	DEB_EE((".\n"));
	213
	214	/* there are no hexium orion cards with revision 0 saa7146s */
	215	if (0 == dev->revision) {
	216	return -EFAULT;
	217	}
	218
7408187d	219	hexium = kzalloc(sizeof(struct hexium), GFP_KERNEL);
1da177e4 LT	220	if (NULL == hexium) {
	221	printk("hexium_orion: hexium_probe: not enough kernel memory.\n");
	222	return -ENOMEM;
	223	}
1da177e4 LT	224
	225	/* enable i2c-port pins */
	226	saa7146_write(dev, MC1, (MASK_08 \| MASK_24 \| MASK_10 \| MASK_26));
	227
	228	saa7146_write(dev, DD1_INIT, 0x01000100);
	229	saa7146_write(dev, DD1_STREAM_B, 0x00000000);
	230	saa7146_write(dev, MC2, (MASK_09 \| MASK_25 \| MASK_10 \| MASK_26));
	231
	232	hexium->i2c_adapter = (struct i2c_adapter) {
	233	.class = I2C_CLASS_TV_ANALOG,
	234	.name = "hexium orion",
	235	};
	236	saa7146_i2c_adapter_prepare(dev, &hexium->i2c_adapter, SAA7146_I2C_BUS_BIT_RATE_480);
	237	if (i2c_add_adapter(&hexium->i2c_adapter) < 0) {
	238	DEB_S(("cannot register i2c-device. skipping.\n"));
	239	kfree(hexium);
	240	return -EFAULT;
	241	}
	242
	243	/* set SAA7110 control GPIO 0 */
	244	saa7146_setgpio(dev, 0, SAA7146_GPIO_OUTHI);
	245	/* set HWControl GPIO number 2 */
	246	saa7146_setgpio(dev, 2, SAA7146_GPIO_OUTHI);
	247
	248	mdelay(10);
	249
	250	/* detect newer Hexium Orion cards by subsystem ids */
	251	if (0x17c8 == dev->pci->subsystem_vendor && 0x0101 == dev->pci->subsystem_device) {
	252	printk("hexium_orion: device is a Hexium Orion w/ 1 SVHS + 3 BNC inputs.\n");
	253	/* we store the pointer in our private data field */
	254	dev->ext_priv = hexium;
	255	hexium->type = HEXIUM_ORION_1SVHS_3BNC;
	256	return 0;
	257	}
	258
	259	if (0x17c8 == dev->pci->subsystem_vendor && 0x2101 == dev->pci->subsystem_device) {
	260	printk("hexium_orion: device is a Hexium Orion w/ 4 BNC inputs.\n");
	261	/* we store the pointer in our private data field */
	262	dev->ext_priv = hexium;
	263	hexium->type = HEXIUM_ORION_4BNC;
	264	return 0;
	265	}
	266
a8733ca5	267	/* check if this is an old hexium Orion card by looking at
1da177e4 LT	268	a saa7110 at address 0x4e */
	269	if (0 == (err = i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_READ, 0x00, I2C_SMBUS_BYTE_DATA, &data))) {
	270	printk("hexium_orion: device is a Hexium HV-PCI6/Orion (old).\n");
	271	/* we store the pointer in our private data field */
	272	dev->ext_priv = hexium;
	273	hexium->type = HEXIUM_HV_PCI6_ORION;
	274	return 0;
	275	}
	276
	277	i2c_del_adapter(&hexium->i2c_adapter);
	278	kfree(hexium);
	279	return -EFAULT;
	280	}
	281
	282	/* bring hardware to a sane state. this has to be done, just in case someone
	283	wants to capture from this device before it has been properly initialized.
	284	the capture engine would badly fail, because no valid signal arrives on the
	285	saa7146, thus leading to timeouts and stuff. */
	286	static int hexium_init_done(struct saa7146_dev *dev)
	287	{
	288	struct hexium hexium = (struct hexium ) dev->ext_priv;
	289	union i2c_smbus_data data;
	290	int i = 0;
	291
	292	DEB_D(("hexium_init_done called.\n"));
	293
	294	/* initialize the helper ics to useful values */
	295	for (i = 0; i < sizeof(hexium_saa7110); i++) {
	296	data.byte = hexium_saa7110[i];
	297	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, i, I2C_SMBUS_BYTE_DATA, &data)) {
	298	printk("hexium_orion: failed for address 0x%02x\n", i);
	299	}
	300	}
	301
	302	return 0;
	303	}
	304
	305	static int hexium_set_input(struct hexium *hexium, int input)
	306	{
	307	union i2c_smbus_data data;
	308	int i = 0;
a8733ca5	309
1da177e4 LT	310	DEB_D((".\n"));
	311
	312	for (i = 0; i < 8; i++) {
	313	int adr = hexium_input_select[input].data[i].adr;
	314	data.byte = hexium_input_select[input].data[i].byte;
	315	if (0 != i2c_smbus_xfer(&hexium->i2c_adapter, 0x4e, 0, I2C_SMBUS_WRITE, adr, I2C_SMBUS_BYTE_DATA, &data)) {
	316	return -1;
	317	}
	318	printk("%d: 0x%02x => 0x%02x\n",input, adr,data.byte);
	319	}
	320
	321	return 0;
	322	}
	323
b960074f HV	324	static int vidioc_enum_input(struct file file, void fh, struct v4l2_input *i)
	325	{
	326	DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));
	327
223ffe5f	328	if (i->index >= HEXIUM_INPUTS)
b960074f HV	329	return -EINVAL;
	330
	331	memcpy(i, &hexium_inputs[i->index], sizeof(struct v4l2_input));
	332
	333	DEB_D(("v4l2_ioctl: VIDIOC_ENUMINPUT %d.\n", i->index));
	334	return 0;
	335	}
	336
	337	static int vidioc_g_input(struct file file, void fh, unsigned int *input)
	338	{
	339	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	340	struct hexium hexium = (struct hexium ) dev->ext_priv;
	341
	342	*input = hexium->cur_input;
	343
	344	DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
	345	return 0;
	346	}
	347
	348	static int vidioc_s_input(struct file file, void fh, unsigned int input)
	349	{
	350	struct saa7146_dev dev = ((struct saa7146_fh )fh)->dev;
	351	struct hexium hexium = (struct hexium ) dev->ext_priv;
	352
	353	if (input < 0 \|\| input >= HEXIUM_INPUTS)
	354	return -EINVAL;
	355
	356	hexium->cur_input = input;
	357	hexium_set_input(hexium, input);
	358
	359	return 0;
	360	}
	361
1da177e4 LT	362	static struct saa7146_ext_vv vv_data;
	363
	364	/* this function only gets called when the probing was successful */
	365	static int hexium_attach(struct saa7146_dev dev, struct saa7146_pci_extension_data info)
	366	{
	367	struct hexium hexium = (struct hexium ) dev->ext_priv;
	368
	369	DEB_EE((".\n"));
	370
	371	saa7146_vv_init(dev, &vv_data);
b960074f HV	372	vv_data.ops.vidioc_enum_input = vidioc_enum_input;
	373	vv_data.ops.vidioc_g_input = vidioc_g_input;
	374	vv_data.ops.vidioc_s_input = vidioc_s_input;
1da177e4 LT	375	if (0 != saa7146_register_device(&hexium->video_dev, dev, "hexium orion", VFL_TYPE_GRABBER)) {
	376	printk("hexium_orion: cannot register capture v4l2 device. skipping.\n");
	377	return -1;
	378	}
	379
	380	printk("hexium_orion: found 'hexium orion' frame grabber-%d.\n", hexium_num);
	381	hexium_num++;
	382
	383	/* the rest */
	384	hexium->cur_input = 0;
	385	hexium_init_done(dev);
	386
	387	return 0;
	388	}
	389
	390	static int hexium_detach(struct saa7146_dev *dev)
	391	{
	392	struct hexium hexium = (struct hexium ) dev->ext_priv;
	393
	394	DEB_EE(("dev:%p\n", dev));
	395
	396	saa7146_unregister_device(&hexium->video_dev, dev);
	397	saa7146_vv_release(dev);
	398
	399	hexium_num--;
	400
	401	i2c_del_adapter(&hexium->i2c_adapter);
	402	kfree(hexium);
	403	return 0;
	404	}
	405
1da177e4 LT	406	static int std_callback(struct saa7146_dev dev, struct saa7146_standard std)
	407	{
	408	return 0;
	409	}
	410
	411	static struct saa7146_extension extension;
	412
	413	static struct saa7146_pci_extension_data hexium_hv_pci6 = {
	414	.ext_priv = "Hexium HV-PCI6 / Orion",
	415	.ext = &extension,
	416	};
	417
	418	static struct saa7146_pci_extension_data hexium_orion_1svhs_3bnc = {
	419	.ext_priv = "Hexium HV-PCI6 / Orion (1 SVHS/3 BNC)",
	420	.ext = &extension,
	421	};
	422
	423	static struct saa7146_pci_extension_data hexium_orion_4bnc = {
	424	.ext_priv = "Hexium HV-PCI6 / Orion (4 BNC)",
	425	.ext = &extension,
	426	};
	427
	428	static struct pci_device_id pci_tbl[] = {
	429	{
	430	.vendor = PCI_VENDOR_ID_PHILIPS,
	431	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	432	.subvendor = 0x0000,
	433	.subdevice = 0x0000,
	434	.driver_data = (unsigned long) &hexium_hv_pci6,
	435	},
	436	{
	437	.vendor = PCI_VENDOR_ID_PHILIPS,
	438	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	439	.subvendor = 0x17c8,
	440	.subdevice = 0x0101,
	441	.driver_data = (unsigned long) &hexium_orion_1svhs_3bnc,
	442	},
	443	{
	444	.vendor = PCI_VENDOR_ID_PHILIPS,
	445	.device = PCI_DEVICE_ID_PHILIPS_SAA7146,
	446	.subvendor = 0x17c8,
	447	.subdevice = 0x2101,
	448	.driver_data = (unsigned long) &hexium_orion_4bnc,
	449	},
	450	{
	451	.vendor = 0,
	452	}
	453	};
	454
	455	MODULE_DEVICE_TABLE(pci, pci_tbl);
	456
	457	static struct saa7146_ext_vv vv_data = {
	458	.inputs = HEXIUM_INPUTS,
	459	.capabilities = 0,
	460	.stds = &hexium_standards[0],
	461	.num_stds = sizeof(hexium_standards) / sizeof(struct saa7146_standard),
	462	.std_callback = &std_callback,
1da177e4 LT	463	};
	464
	465	static struct saa7146_extension extension = {
922f77de	466	.name = "hexium HV-PCI6 Orion",
1da177e4 LT	467	.flags = 0, // SAA7146_USE_I2C_IRQ,
	468
	469	.pci_tbl = &pci_tbl[0],
	470	.module = THIS_MODULE,
	471
	472	.probe = hexium_probe,
	473	.attach = hexium_attach,
	474	.detach = hexium_detach,
	475
	476	.irq_mask = 0,
	477	.irq_func = NULL,
	478	};
	479
	480	static int __init hexium_init_module(void)
	481	{
	482	if (0 != saa7146_register_extension(&extension)) {
	483	DEB_S(("failed to register extension.\n"));
	484	return -ENODEV;
	485	}
	486
	487	return 0;
	488	}
	489
	490	static void __exit hexium_cleanup_module(void)
	491	{
	492	saa7146_unregister_extension(&extension);
	493	}
	494
	495	module_init(hexium_init_module);
	496	module_exit(hexium_cleanup_module);
	497
	498	MODULE_DESCRIPTION("video4linux-2 driver for Hexium Orion frame grabber cards");
	499	MODULE_AUTHOR("Michael Hunold <michael@mihu.de>");
	500	MODULE_LICENSE("GPL");