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

static struct saa7146_extension_ioctls ioctls[] = {
	{ VIDIOC_G_INPUT,	SAA7146_EXCLUSIVE },
	{ VIDIOC_S_INPUT,	SAA7146_EXCLUSIVE },
	{ VIDIOC_QUERYCTRL, 	SAA7146_BEFORE },
	{ VIDIOC_ENUMINPUT, 	SAA7146_EXCLUSIVE },
	{ VIDIOC_S_STD,		SAA7146_AFTER },
	{ VIDIOC_G_CTRL,	SAA7146_BEFORE },
	{ VIDIOC_S_CTRL,	SAA7146_BEFORE },
	{ 0,			0 }
};

#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 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"));

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

	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 long hexium_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
{
	struct saa7146_dev *dev = fh->dev;
	struct hexium *hexium = (struct hexium *) dev->ext_priv;
/*
	struct saa7146_vv *vv = dev->vv_data;
*/
	switch (cmd) {
	case VIDIOC_ENUMINPUT:
		{
			struct v4l2_input *i = arg;
			DEB_EE(("VIDIOC_ENUMINPUT %d.\n", i->index));

			if (i->index < 0 || 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;
		}
	case VIDIOC_G_INPUT:
		{
			int *input = (int *) arg;
			*input = hexium->cur_input;

			DEB_D(("VIDIOC_G_INPUT: %d\n", *input));
			return 0;
		}
	case VIDIOC_S_INPUT:
		{
			int input = *(int *) arg;

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

			if (input < 0 || 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.. */
	case VIDIOC_QUERYCTRL:
		{
			struct v4l2_queryctrl *qc = arg;
			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 -EAGAIN;
		}
	case VIDIOC_G_CTRL:
		{
			struct v4l2_control *vc = arg;
			int i;

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

			if (i < 0) {
				return -EAGAIN;
			}

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

	case VIDIOC_S_CTRL:
		{
			struct v4l2_control *vc = arg;
			int i = 0;

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

			if (i < 0) {
				return -EAGAIN;
			}

			switch (vc->id) {
			case V4L2_CID_PRIVATE_BASE:{
					hexium->cur_bw = vc->value;
					break;
				}
			}

			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;
		}
	default:
/*
		DEB_D(("hexium_ioctl() does not handle this ioctl.\n"));
*/
		return -ENOIOCTLCMD;
	}
	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,
	.ioctls = &ioctls[0],
	.ioctl = hexium_ioctl,
};

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