[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / media / dvb / dvb-usb / gp8psk.c

/* DVB USB compliant Linux driver for the
 *  - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
 *
 * Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
 * Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com)
 *
 * Thanks to GENPIX for the sample code used to implement this module.
 *
 * This module is based off the vp7045 and vp702x modules
 *
 *	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, version 2.
 *
 * see Documentation/dvb/README.dvb-usb for more information
 */
#include "gp8psk.h"

/* debug */
static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw";
int dvb_usb_gp8psk_debug;
module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);

DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);

static int gp8psk_get_fw_version(struct dvb_usb_device *d, u8 *fw_vers)
{
	return (gp8psk_usb_in_op(d, GET_FW_VERS, 0, 0, fw_vers, 6));
}

static int gp8psk_get_fpga_version(struct dvb_usb_device *d, u8 *fpga_vers)
{
	return (gp8psk_usb_in_op(d, GET_FPGA_VERS, 0, 0, fpga_vers, 1));
}

static void gp8psk_info(struct dvb_usb_device *d)
{
	u8 fpga_vers, fw_vers[6];

	if (!gp8psk_get_fw_version(d, fw_vers))
		info("FW Version = %i.%02i.%i (0x%x)  Build %4i/%02i/%02i",
		fw_vers[2], fw_vers[1], fw_vers[0], GP8PSK_FW_VERS(fw_vers),
		2000 + fw_vers[5], fw_vers[4], fw_vers[3]);
	else
		info("failed to get FW version");

	if (!gp8psk_get_fpga_version(d, &fpga_vers))
		info("FPGA Version = %i", fpga_vers);
	else
		info("failed to get FPGA version");
}

int gp8psk_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
{
	int ret = 0,try = 0;

	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
		return ret;

	while (ret >= 0 && ret != blen && try < 3) {
		ret = usb_control_msg(d->udev,
			usb_rcvctrlpipe(d->udev,0),
			req,
			USB_TYPE_VENDOR | USB_DIR_IN,
			value,index,b,blen,
			2000);
		deb_info("reading number %d (ret: %d)\n",try,ret);
		try++;
	}

	if (ret < 0 || ret != blen) {
		warn("usb in %d operation failed.", req);
		ret = -EIO;
	} else
		ret = 0;

	deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
	debug_dump(b,blen,deb_xfer);

	mutex_unlock(&d->usb_mutex);

	return ret;
}

int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
			     u16 index, u8 *b, int blen)
{
	int ret;

	deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
	debug_dump(b,blen,deb_xfer);

	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
		return ret;

	if (usb_control_msg(d->udev,
			usb_sndctrlpipe(d->udev,0),
			req,
			USB_TYPE_VENDOR | USB_DIR_OUT,
			value,index,b,blen,
			2000) != blen) {
		warn("usb out operation failed.");
		ret = -EIO;
	} else
		ret = 0;
	mutex_unlock(&d->usb_mutex);

	return ret;
}

static int gp8psk_load_bcm4500fw(struct dvb_usb_device *d)
{
	int ret;
	const struct firmware *fw = NULL;
	const u8 *ptr;
	u8 *buf;
	if ((ret = request_firmware(&fw, bcm4500_firmware,
					&d->udev->dev)) != 0) {
		err("did not find the bcm4500 firmware file. (%s) "
			"Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)",
			bcm4500_firmware,ret);
		return ret;
	}

	ret = -EINVAL;

	if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
		goto out_rel_fw;

	info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware);

	ptr = fw->data;
	buf = kmalloc(64, GFP_KERNEL | GFP_DMA);
	if (!buf) {
		ret = -ENOMEM;
		goto out_rel_fw;
	}

	while (ptr[0] != 0xff) {
		u16 buflen = ptr[0] + 4;
		if (ptr + buflen >= fw->data + fw->size) {
			err("failed to load bcm4500 firmware.");
			goto out_free;
		}
		memcpy(buf, ptr, buflen);
		if (dvb_usb_generic_write(d, buf, buflen)) {
			err("failed to load bcm4500 firmware.");
			goto out_free;
		}
		ptr += buflen;
	}

	ret = 0;

out_free:
	kfree(buf);
out_rel_fw:
	release_firmware(fw);

	return ret;
}

static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
{
	u8 status, buf;
	int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);

	if (onoff) {
		gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
		if (! (status & bm8pskStarted)) {  /* started */
			if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
				gp8psk_usb_out_op(d, CW3K_INIT, 1, 0, NULL, 0);
			if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
				return -EINVAL;
			gp8psk_info(d);
		}

		if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
			if (! (status & bm8pskFW_Loaded)) /* BCM4500 firmware loaded */
				if(gp8psk_load_bcm4500fw(d))
					return -EINVAL;

		if (! (status & bmIntersilOn)) /* LNB Power */
			if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
					&buf, 1))
				return -EINVAL;

		/* Set DVB mode to 1 */
		if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
			if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
				return -EINVAL;
		/* Abort possible TS (if previous tune crashed) */
		if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0))
			return -EINVAL;
	} else {
		/* Turn off LNB power */
		if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
			return -EINVAL;
		/* Turn off 8psk power */
		if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
			return -EINVAL;
		if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
			gp8psk_usb_out_op(d, CW3K_INIT, 0, 0, NULL, 0);
	}
	return 0;
}

int gp8psk_bcm4500_reload(struct dvb_usb_device *d)
{
	u8 buf;
	int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
	/* Turn off 8psk power */
	if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
		return -EINVAL;
	/* Turn On 8psk power */
	if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
		return -EINVAL;
	/* load BCM4500 firmware */
	if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
		if (gp8psk_load_bcm4500fw(d))
			return -EINVAL;
	return 0;
}

static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
	return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0);
}

static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap)
{
	adap->fe = gp8psk_fe_attach(adap->dev);
	return 0;
}

static struct dvb_usb_device_properties gp8psk_properties;

static int gp8psk_usb_probe(struct usb_interface *intf,
		const struct usb_device_id *id)
{
	int ret;
	struct usb_device *udev = interface_to_usbdev(intf);
	ret = dvb_usb_device_init(intf, &gp8psk_properties,
				  THIS_MODULE, NULL, adapter_nr);
	if (ret == 0) {
		info("found Genpix USB device pID = %x (hex)",
			le16_to_cpu(udev->descriptor.idProduct));
	}
	return ret;
}

static struct usb_device_id gp8psk_usb_table [] = {
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_COLD) },
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_WARM) },
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_2) },
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_1) },
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_2) },
/*	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_CW3K) }, */
	    { 0 },
};
MODULE_DEVICE_TABLE(usb, gp8psk_usb_table);

static struct dvb_usb_device_properties gp8psk_properties = {
	.usb_ctrl = CYPRESS_FX2,
	.firmware = "dvb-usb-gp8psk-01.fw",

	.num_adapters = 1,
	.adapter = {
		{
			.streaming_ctrl   = gp8psk_streaming_ctrl,
			.frontend_attach  = gp8psk_frontend_attach,
			/* parameter for the MPEG2-data transfer */
			.stream = {
				.type = USB_BULK,
				.count = 7,
				.endpoint = 0x82,
				.u = {
					.bulk = {
						.buffersize = 8192,
					}
				}
			},
		}
	},
	.power_ctrl       = gp8psk_power_ctrl,

	.generic_bulk_ctrl_endpoint = 0x01,

	.num_device_descs = 4,
	.devices = {
		{ .name = "Genpix 8PSK-to-USB2 Rev.1 DVB-S receiver",
		  .cold_ids = { &gp8psk_usb_table[0], NULL },
		  .warm_ids = { &gp8psk_usb_table[1], NULL },
		},
		{ .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver",
		  .cold_ids = { NULL },
		  .warm_ids = { &gp8psk_usb_table[2], NULL },
		},
		{ .name = "Genpix SkyWalker-1 DVB-S receiver",
		  .cold_ids = { NULL },
		  .warm_ids = { &gp8psk_usb_table[3], NULL },
		},
		{ .name = "Genpix SkyWalker-2 DVB-S receiver",
		  .cold_ids = { NULL },
		  .warm_ids = { &gp8psk_usb_table[4], NULL },
		},
		{ NULL },
	}
};

/* usb specific object needed to register this driver with the usb subsystem */
static struct usb_driver gp8psk_usb_driver = {
	.name		= "dvb_usb_gp8psk",
	.probe		= gp8psk_usb_probe,
	.disconnect = dvb_usb_device_exit,
	.id_table	= gp8psk_usb_table,
};

/* module stuff */
static int __init gp8psk_usb_module_init(void)
{
	int result;
	if ((result = usb_register(&gp8psk_usb_driver))) {
		err("usb_register failed. (%d)",result);
		return result;
	}

	return 0;
}

static void __exit gp8psk_usb_module_exit(void)
{
	/* deregister this driver from the USB subsystem */
	usb_deregister(&gp8psk_usb_driver);
}

module_init(gp8psk_usb_module_init);
module_exit(gp8psk_usb_module_exit);

MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>");
MODULE_DESCRIPTION("Driver for Genpix DVB-S");
MODULE_VERSION("1.1");
MODULE_LICENSE("GPL");
Commit	Line	Data
9bbe076f	1	/* DVB USB compliant Linux driver for the
458b634c	2	* - GENPIX 8pks/qpsk/DCII USB2.0 DVB-S module
9bbe076f	3	*
458b634c AN	4	* Copyright (C) 2006,2007 Alan Nisota (alannisota@gmail.com)
458b634c AN	5	* Copyright (C) 2006,2007 Genpix Electronics (genpix@genpix-electronics.com)
9bbe076f AN	6	*
	7	* Thanks to GENPIX for the sample code used to implement this module.
	8	*
	9	* This module is based off the vp7045 and vp702x modules
	10	*
	11	* This program is free software; you can redistribute it and/or modify it
	12	* under the terms of the GNU General Public License as published by the Free
	13	* Software Foundation, version 2.
	14	*
	15	* see Documentation/dvb/README.dvb-usb for more information
	16	*/
	17	#include "gp8psk.h"
	18
	19	/* debug */
	20	static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw";
	21	int dvb_usb_gp8psk_debug;
	22	module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
	23	MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
	24
78e92006 JG	25	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
78e92006 JG	26
9e21ccaa VU	27	static int gp8psk_get_fw_version(struct dvb_usb_device d, u8 fw_vers)
	28	{
	29	return (gp8psk_usb_in_op(d, GET_FW_VERS, 0, 0, fw_vers, 6));
	30	}
	31
	32	static int gp8psk_get_fpga_version(struct dvb_usb_device d, u8 fpga_vers)
	33	{
	34	return (gp8psk_usb_in_op(d, GET_FPGA_VERS, 0, 0, fpga_vers, 1));
	35	}
	36
	37	static void gp8psk_info(struct dvb_usb_device *d)
	38	{
	39	u8 fpga_vers, fw_vers[6];
	40
	41	if (!gp8psk_get_fw_version(d, fw_vers))
	42	info("FW Version = %i.%02i.%i (0x%x) Build %4i/%02i/%02i",
	43	fw_vers[2], fw_vers[1], fw_vers[0], GP8PSK_FW_VERS(fw_vers),
	44	2000 + fw_vers[5], fw_vers[4], fw_vers[3]);
	45	else
	46	info("failed to get FW version");
	47
	48	if (!gp8psk_get_fpga_version(d, &fpga_vers))
	49	info("FPGA Version = %i", fpga_vers);
	50	else
	51	info("failed to get FPGA version");
	52	}
	53
9bbe076f AN	54	int gp8psk_usb_in_op(struct dvb_usb_device d, u8 req, u16 value, u16 index, u8 b, int blen)
	55	{
	56	int ret = 0,try = 0;
	57
	58	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
	59	return ret;
	60
	61	while (ret >= 0 && ret != blen && try < 3) {
	62	ret = usb_control_msg(d->udev,
	63	usb_rcvctrlpipe(d->udev,0),
	64	req,
	65	USB_TYPE_VENDOR \| USB_DIR_IN,
	66	value,index,b,blen,
	67	2000);
	68	deb_info("reading number %d (ret: %d)\n",try,ret);
	69	try++;
	70	}
	71
	72	if (ret < 0 \|\| ret != blen) {
458b634c	73	warn("usb in %d operation failed.", req);
9bbe076f AN	74	ret = -EIO;
	75	} else
	76	ret = 0;
	77
	78	deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
	79	debug_dump(b,blen,deb_xfer);
	80
	81	mutex_unlock(&d->usb_mutex);
	82
	83	return ret;
	84	}
	85
	86	int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
	87	u16 index, u8 *b, int blen)
	88	{
	89	int ret;
	90
	91	deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
	92	debug_dump(b,blen,deb_xfer);
	93
	94	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
	95	return ret;
	96
	97	if (usb_control_msg(d->udev,
	98	usb_sndctrlpipe(d->udev,0),
	99	req,
	100	USB_TYPE_VENDOR \| USB_DIR_OUT,
	101	value,index,b,blen,
	102	2000) != blen) {
	103	warn("usb out operation failed.");
	104	ret = -EIO;
	105	} else
	106	ret = 0;
	107	mutex_unlock(&d->usb_mutex);
	108
	109	return ret;
	110	}
	111
	112	static int gp8psk_load_bcm4500fw(struct dvb_usb_device *d)
	113	{
	114	int ret;
	115	const struct firmware *fw = NULL;
3a9282ca DW	116	const u8 *ptr;
3a9282ca DW	117	u8 *buf;
9bbe076f AN	118	if ((ret = request_firmware(&fw, bcm4500_firmware,
	119	&d->udev->dev)) != 0) {
	120	err("did not find the bcm4500 firmware file. (%s) "
	121	"Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)",
	122	bcm4500_firmware,ret);
	123	return ret;
	124	}
	125
976e3483 PB	126	ret = -EINVAL;
	127
	128	if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
	129	goto out_rel_fw;
9bbe076f	130
458b634c	131	info("downloading bcm4500 firmware from file '%s'",bcm4500_firmware);
9bbe076f AN	132
9bbe076f AN	133	ptr = fw->data;
458b634c	134	buf = kmalloc(64, GFP_KERNEL \| GFP_DMA);
205161ed JS	135	if (!buf) {
	136	ret = -ENOMEM;
	137	goto out_rel_fw;
	138	}
9bbe076f AN	139
	140	while (ptr[0] != 0xff) {
	141	u16 buflen = ptr[0] + 4;
	142	if (ptr + buflen >= fw->data + fw->size) {
	143	err("failed to load bcm4500 firmware.");
976e3483	144	goto out_free;
9bbe076f AN	145	}
	146	memcpy(buf, ptr, buflen);
	147	if (dvb_usb_generic_write(d, buf, buflen)) {
	148	err("failed to load bcm4500 firmware.");
976e3483	149	goto out_free;
9bbe076f AN	150	}
	151	ptr += buflen;
	152	}
976e3483 PB	153
	154	ret = 0;
	155
	156	out_free:
9bbe076f	157	kfree(buf);
976e3483 PB	158	out_rel_fw:
	159	release_firmware(fw);
	160
	161	return ret;
9bbe076f AN	162	}
	163
	164	static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
	165	{
	166	u8 status, buf;
458b634c AN	167	int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
458b634c AN	168
9bbe076f AN	169	if (onoff) {
9bbe076f AN	170	gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
458b634c AN	171	if (! (status & bm8pskStarted)) { /* started */
	172	if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
	173	gp8psk_usb_out_op(d, CW3K_INIT, 1, 0, NULL, 0);
9bbe076f AN	174	if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
9bbe076f AN	175	return -EINVAL;
9e21ccaa	176	gp8psk_info(d);
458b634c	177	}
9bbe076f	178
458b634c AN	179	if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
	180	if (! (status & bm8pskFW_Loaded)) /* BCM4500 firmware loaded */
	181	if(gp8psk_load_bcm4500fw(d))
7fa7b858	182	return -EINVAL;
9bbe076f	183
458b634c	184	if (! (status & bmIntersilOn)) /* LNB Power */
9bbe076f AN	185	if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
9bbe076f AN	186	&buf, 1))
7fa7b858	187	return -EINVAL;
9bbe076f	188
458b634c AN	189	/* Set DVB mode to 1 */
	190	if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
	191	if (gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
7fa7b858	192	return -EINVAL;
458b634c AN	193	/* Abort possible TS (if previous tune crashed) */
458b634c AN	194	if (gp8psk_usb_out_op(d, ARM_TRANSFER, 0, 0, NULL, 0))
7fa7b858	195	return -EINVAL;
9bbe076f AN	196	} else {
	197	/* Turn off LNB power */
	198	if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
7fa7b858	199	return -EINVAL;
9bbe076f AN	200	/* Turn off 8psk power */
	201	if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
	202	return -EINVAL;
458b634c AN	203	if(gp_product_id == USB_PID_GENPIX_SKYWALKER_CW3K)
458b634c AN	204	gp8psk_usb_out_op(d, CW3K_INIT, 0, 0, NULL, 0);
9bbe076f AN	205	}
	206	return 0;
	207	}
	208
02ebf23b AN	209	int gp8psk_bcm4500_reload(struct dvb_usb_device *d)
	210	{
	211	u8 buf;
	212	int gp_product_id = le16_to_cpu(d->udev->descriptor.idProduct);
	213	/* Turn off 8psk power */
	214	if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
	215	return -EINVAL;
	216	/* Turn On 8psk power */
	217	if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
	218	return -EINVAL;
	219	/* load BCM4500 firmware */
	220	if (gp_product_id == USB_PID_GENPIX_8PSK_REV_1_WARM)
	221	if (gp8psk_load_bcm4500fw(d))
da1b5c95	222	return -EINVAL;
02ebf23b AN	223	return 0;
02ebf23b AN	224	}
9bbe076f	225
4d43e13f	226	static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
9bbe076f	227	{
4d43e13f	228	return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0);
9bbe076f AN	229	}
9bbe076f AN	230
4d43e13f	231	static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap)
9bbe076f	232	{
4d43e13f	233	adap->fe = gp8psk_fe_attach(adap->dev);
9bbe076f AN	234	return 0;
	235	}
	236
4d43e13f	237	static struct dvb_usb_device_properties gp8psk_properties;
9bbe076f AN	238
	239	static int gp8psk_usb_probe(struct usb_interface *intf,
	240	const struct usb_device_id *id)
	241	{
458b634c AN	242	int ret;
458b634c AN	243	struct usb_device *udev = interface_to_usbdev(intf);
78e92006 JG	244	ret = dvb_usb_device_init(intf, &gp8psk_properties,
78e92006 JG	245	THIS_MODULE, NULL, adapter_nr);
458b634c AN	246	if (ret == 0) {
	247	info("found Genpix USB device pID = %x (hex)",
	248	le16_to_cpu(udev->descriptor.idProduct));
	249	}
	250	return ret;
9bbe076f AN	251	}
	252
	253	static struct usb_device_id gp8psk_usb_table [] = {
458b634c AN	254	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_COLD) },
	255	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_1_WARM) },
	256	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_REV_2) },
	257	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_1) },
bdd1751b	258	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_2) },
86cf5f84	259	/* { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_SKYWALKER_CW3K) }, */
9bbe076f AN	260	{ 0 },
	261	};
	262	MODULE_DEVICE_TABLE(usb, gp8psk_usb_table);
	263
4d43e13f	264	static struct dvb_usb_device_properties gp8psk_properties = {
9bbe076f AN	265	.usb_ctrl = CYPRESS_FX2,
	266	.firmware = "dvb-usb-gp8psk-01.fw",
	267
4d43e13f PB	268	.num_adapters = 1,
	269	.adapter = {
	270	{
01451e72 PB	271	.streaming_ctrl = gp8psk_streaming_ctrl,
	272	.frontend_attach = gp8psk_frontend_attach,
	273	/* parameter for the MPEG2-data transfer */
4d43e13f PB	274	.stream = {
4d43e13f PB	275	.type = USB_BULK,
01451e72 PB	276	.count = 7,
	277	.endpoint = 0x82,
	278	.u = {
	279	.bulk = {
	280	.buffersize = 8192,
	281	}
	282	}
	283	},
4d43e13f PB	284	}
	285	},
	286	.power_ctrl = gp8psk_power_ctrl,
	287
	288	.generic_bulk_ctrl_endpoint = 0x01,
9bbe076f	289
bdd1751b	290	.num_device_descs = 4,
9bbe076f	291	.devices = {
458b634c	292	{ .name = "Genpix 8PSK-to-USB2 Rev.1 DVB-S receiver",
9bbe076f AN	293	.cold_ids = { &gp8psk_usb_table[0], NULL },
	294	.warm_ids = { &gp8psk_usb_table[1], NULL },
	295	},
458b634c AN	296	{ .name = "Genpix 8PSK-to-USB2 Rev.2 DVB-S receiver",
	297	.cold_ids = { NULL },
	298	.warm_ids = { &gp8psk_usb_table[2], NULL },
	299	},
	300	{ .name = "Genpix SkyWalker-1 DVB-S receiver",
	301	.cold_ids = { NULL },
	302	.warm_ids = { &gp8psk_usb_table[3], NULL },
	303	},
bdd1751b DK	304	{ .name = "Genpix SkyWalker-2 DVB-S receiver",
	305	.cold_ids = { NULL },
	306	.warm_ids = { &gp8psk_usb_table[4], NULL },
	307	},
ab9caf9e	308	{ NULL },
9bbe076f AN	309	}
	310	};
	311
	312	/* usb specific object needed to register this driver with the usb subsystem */
	313	static struct usb_driver gp8psk_usb_driver = {
	314	.name = "dvb_usb_gp8psk",
	315	.probe = gp8psk_usb_probe,
	316	.disconnect = dvb_usb_device_exit,
	317	.id_table = gp8psk_usb_table,
	318	};
	319
	320	/* module stuff */
	321	static int __init gp8psk_usb_module_init(void)
	322	{
	323	int result;
	324	if ((result = usb_register(&gp8psk_usb_driver))) {
	325	err("usb_register failed. (%d)",result);
	326	return result;
	327	}
	328
	329	return 0;
	330	}
	331
	332	static void __exit gp8psk_usb_module_exit(void)
	333	{
	334	/* deregister this driver from the USB subsystem */
	335	usb_deregister(&gp8psk_usb_driver);
	336	}
	337
	338	module_init(gp8psk_usb_module_init);
	339	module_exit(gp8psk_usb_module_exit);
	340
	341	MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>");
d12da8e9	342	MODULE_DESCRIPTION("Driver for Genpix DVB-S");
458b634c	343	MODULE_VERSION("1.1");
9bbe076f	344	MODULE_LICENSE("GPL");