[mirror_ubuntu-focal-kernel.git] / drivers / media / dvb / dvb-usb / gp8psk.c

/* DVB USB compliant Linux driver for the
 *  - GENPIX 8pks/qpsk USB2.0 DVB-S module
 *
 * Copyright (C) 2006 Alan Nisota (alannisota@gmail.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);

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 operation failed.");
		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;
	u8 *ptr, *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("downloaidng bcm4500 firmware from file '%s'",bcm4500_firmware);

	ptr = fw->data;
	buf = kmalloc(512, GFP_KERNEL | GFP_DMA);

	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;
	if (onoff) {
		gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
		if (! (status & 0x01))  /* started */
			if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
				return -EINVAL;

		if (! (status & 0x02)) /* BCM4500 firmware loaded */
			if(gp8psk_load_bcm4500fw(d))
				return EINVAL;

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

		/* Set DVB mode */
		if(gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
			return -EINVAL;
		gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
	} 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;

	}
	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)
{
	return dvb_usb_device_init(intf,&gp8psk_properties,THIS_MODULE,NULL);
}

static struct usb_device_id gp8psk_usb_table [] = {
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_COLD) },
	    { USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_WARM) },
	    { 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 = 1,
	.devices = {
		{ .name = "Genpix 8PSK-USB DVB-S USB2.0 receiver",
		  .cold_ids = { &gp8psk_usb_table[0], NULL },
		  .warm_ids = { &gp8psk_usb_table[1], 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 8psk-USB DVB-S USB2.0");
MODULE_VERSION("1.0");
MODULE_LICENSE("GPL");
Commit	Line	Data
9bbe076f AN	1	/* DVB USB compliant Linux driver for the
	2	* - GENPIX 8pks/qpsk USB2.0 DVB-S module
	3	*
	4	* Copyright (C) 2006 Alan Nisota (alannisota@gmail.com)
	5	*
	6	* Thanks to GENPIX for the sample code used to implement this module.
	7	*
	8	* This module is based off the vp7045 and vp702x modules
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the Free
	12	* Software Foundation, version 2.
	13	*
	14	* see Documentation/dvb/README.dvb-usb for more information
	15	*/
	16	#include "gp8psk.h"
	17
	18	/* debug */
	19	static char bcm4500_firmware[] = "dvb-usb-gp8psk-02.fw";
	20	int dvb_usb_gp8psk_debug;
	21	module_param_named(debug,dvb_usb_gp8psk_debug, int, 0644);
	22	MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
	23
	24	int gp8psk_usb_in_op(struct dvb_usb_device d, u8 req, u16 value, u16 index, u8 b, int blen)
	25	{
	26	int ret = 0,try = 0;
	27
	28	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
	29	return ret;
	30
	31	while (ret >= 0 && ret != blen && try < 3) {
	32	ret = usb_control_msg(d->udev,
	33	usb_rcvctrlpipe(d->udev,0),
	34	req,
	35	USB_TYPE_VENDOR \| USB_DIR_IN,
	36	value,index,b,blen,
	37	2000);
	38	deb_info("reading number %d (ret: %d)\n",try,ret);
	39	try++;
	40	}
	41
	42	if (ret < 0 \|\| ret != blen) {
	43	warn("usb in operation failed.");
	44	ret = -EIO;
	45	} else
	46	ret = 0;
	47
	48	deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
	49	debug_dump(b,blen,deb_xfer);
	50
	51	mutex_unlock(&d->usb_mutex);
	52
	53	return ret;
	54	}
	55
	56	int gp8psk_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
	57	u16 index, u8 *b, int blen)
	58	{
	59	int ret;
	60
	61	deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
	62	debug_dump(b,blen,deb_xfer);
	63
	64	if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
65	return ret;
66
67	if (usb_control_msg(d->udev,
68	usb_sndctrlpipe(d->udev,0),
69	req,
70	USB_TYPE_VENDOR \| USB_DIR_OUT,
71	value,index,b,blen,
72	2000) != blen) {
73	warn("usb out operation failed.");
74	ret = -EIO;
75	} else
76	ret = 0;
77	mutex_unlock(&d->usb_mutex);
78
79	return ret;
80	}
81
82	static int gp8psk_load_bcm4500fw(struct dvb_usb_device *d)
83	{
84	int ret;
85	const struct firmware *fw = NULL;
86	u8 ptr, buf;
87	if ((ret = request_firmware(&fw, bcm4500_firmware,
88	&d->udev->dev)) != 0) {
89	err("did not find the bcm4500 firmware file. (%s) "
90	"Please see linux/Documentation/dvb/ for more details on firmware-problems. (%d)",
91	bcm4500_firmware,ret);
92	return ret;
93	}
94
976e3483 PB	95	ret = -EINVAL;
	96
	97	if (gp8psk_usb_out_op(d, LOAD_BCM4500,1,0,NULL, 0))
	98	goto out_rel_fw;
9bbe076f AN	99
	100	info("downloaidng bcm4500 firmware from file '%s'",bcm4500_firmware);
	101
	102	ptr = fw->data;
976e3483	103	buf = kmalloc(512, GFP_KERNEL \| GFP_DMA);
9bbe076f AN	104
	105	while (ptr[0] != 0xff) {
	106	u16 buflen = ptr[0] + 4;
	107	if (ptr + buflen >= fw->data + fw->size) {
	108	err("failed to load bcm4500 firmware.");
976e3483	109	goto out_free;
9bbe076f AN	110	}
	111	memcpy(buf, ptr, buflen);
	112	if (dvb_usb_generic_write(d, buf, buflen)) {
	113	err("failed to load bcm4500 firmware.");
976e3483	114	goto out_free;
9bbe076f AN	115	}
	116	ptr += buflen;
	117	}
976e3483 PB	118
	119	ret = 0;
	120
	121	out_free:
9bbe076f	122	kfree(buf);
976e3483 PB	123	out_rel_fw:
	124	release_firmware(fw);
	125
	126	return ret;
9bbe076f AN	127	}
	128
	129	static int gp8psk_power_ctrl(struct dvb_usb_device *d, int onoff)
	130	{
	131	u8 status, buf;
	132	if (onoff) {
	133	gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
	134	if (! (status & 0x01)) /* started */
	135	if (gp8psk_usb_in_op(d, BOOT_8PSK, 1, 0, &buf, 1))
	136	return -EINVAL;
	137
	138	if (! (status & 0x02)) /* BCM4500 firmware loaded */
	139	if(gp8psk_load_bcm4500fw(d))
	140	return EINVAL;
	141
	142	if (! (status & 0x04)) /* LNB Power */
	143	if (gp8psk_usb_in_op(d, START_INTERSIL, 1, 0,
	144	&buf, 1))
	145	return EINVAL;
	146
	147	/* Set DVB mode */
	148	if(gp8psk_usb_out_op(d, SET_DVB_MODE, 1, 0, NULL, 0))
	149	return -EINVAL;
	150	gp8psk_usb_in_op(d, GET_8PSK_CONFIG,0,0,&status,1);
	151	} else {
	152	/* Turn off LNB power */
	153	if (gp8psk_usb_in_op(d, START_INTERSIL, 0, 0, &buf, 1))
	154	return EINVAL;
	155	/* Turn off 8psk power */
	156	if (gp8psk_usb_in_op(d, BOOT_8PSK, 0, 0, &buf, 1))
	157	return -EINVAL;
	158
	159	}
	160	return 0;
	161	}
	162
	163
4d43e13f	164	static int gp8psk_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
9bbe076f	165	{
4d43e13f	166	return gp8psk_usb_out_op(adap->dev, ARM_TRANSFER, onoff, 0 , NULL, 0);
9bbe076f AN	167	}
9bbe076f AN	168
4d43e13f	169	static int gp8psk_frontend_attach(struct dvb_usb_adapter *adap)
9bbe076f	170	{
4d43e13f	171	adap->fe = gp8psk_fe_attach(adap->dev);
9bbe076f AN	172	return 0;
	173	}
	174
4d43e13f	175	static struct dvb_usb_device_properties gp8psk_properties;
9bbe076f AN	176
	177	static int gp8psk_usb_probe(struct usb_interface *intf,
	178	const struct usb_device_id *id)
	179	{
	180	return dvb_usb_device_init(intf,&gp8psk_properties,THIS_MODULE,NULL);
	181	}
	182
	183	static struct usb_device_id gp8psk_usb_table [] = {
	184	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_COLD) },
	185	{ USB_DEVICE(USB_VID_GENPIX, USB_PID_GENPIX_8PSK_WARM) },
	186	{ 0 },
	187	};
	188	MODULE_DEVICE_TABLE(usb, gp8psk_usb_table);
	189
4d43e13f	190	static struct dvb_usb_device_properties gp8psk_properties = {
9bbe076f AN	191	.usb_ctrl = CYPRESS_FX2,
	192	.firmware = "dvb-usb-gp8psk-01.fw",
	193
4d43e13f PB	194	.num_adapters = 1,
	195	.adapter = {
	196	{
9bbe076f	197	.streaming_ctrl = gp8psk_streaming_ctrl,
9bbe076f	198	.frontend_attach = gp8psk_frontend_attach,
9bbe076f	199	/* parameter for the MPEG2-data transfer */
4d43e13f PB	200	.stream = {
4d43e13f PB	201	.type = USB_BULK,
9bbe076f AN	202	.count = 7,
	203	.endpoint = 0x82,
	204	.u = {
	205	.bulk = {
	206	.buffersize = 8192,
	207	}
	208	}
	209	},
4d43e13f PB	210	}
	211	},
	212	.power_ctrl = gp8psk_power_ctrl,
	213
	214	.generic_bulk_ctrl_endpoint = 0x01,
9bbe076f AN	215
	216	.num_device_descs = 1,
	217	.devices = {
	218	{ .name = "Genpix 8PSK-USB DVB-S USB2.0 receiver",
	219	.cold_ids = { &gp8psk_usb_table[0], NULL },
	220	.warm_ids = { &gp8psk_usb_table[1], NULL },
	221	},
ab9caf9e	222	{ NULL },
9bbe076f AN	223	}
	224	};
	225
	226	/* usb specific object needed to register this driver with the usb subsystem */
	227	static struct usb_driver gp8psk_usb_driver = {
	228	.name = "dvb_usb_gp8psk",
	229	.probe = gp8psk_usb_probe,
	230	.disconnect = dvb_usb_device_exit,
	231	.id_table = gp8psk_usb_table,
	232	};
	233
	234	/* module stuff */
	235	static int __init gp8psk_usb_module_init(void)
	236	{
	237	int result;
	238	if ((result = usb_register(&gp8psk_usb_driver))) {
	239	err("usb_register failed. (%d)",result);
	240	return result;
	241	}
	242
	243	return 0;
	244	}
	245
	246	static void __exit gp8psk_usb_module_exit(void)
	247	{
	248	/* deregister this driver from the USB subsystem */
	249	usb_deregister(&gp8psk_usb_driver);
	250	}
	251
	252	module_init(gp8psk_usb_module_init);
	253	module_exit(gp8psk_usb_module_exit);
	254
	255	MODULE_AUTHOR("Alan Nisota <alannisota@gamil.com>");
	256	MODULE_DESCRIPTION("Driver for Genpix 8psk-USB DVB-S USB2.0");
	257	MODULE_VERSION("1.0");
	258	MODULE_LICENSE("GPL");