[mirror_ubuntu-artful-kernel.git] / drivers / media / pci / saa7146 / 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 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_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,	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;
};

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

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