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

/* DVB USB framework compliant Linux driver for the Opera1 DVB-S Card
*
* Copyright (C) 2006 Mario Hlawitschka (dh1pa@amsat.org)
* Copyright (C) 2006 Marco Gittler (g.marco@freenet.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, version 2.
*
* see Documentation/dvb/README.dvb-usb for more information
*/

#define DVB_USB_LOG_PREFIX "opera"

#include "dvb-usb.h"
#include "stv0299.h"

#define OPERA_READ_MSG 0
#define OPERA_WRITE_MSG 1
#define OPERA_I2C_TUNER 0xd1

#define READ_FX2_REG_REQ  0xba
#define READ_MAC_ADDR 0x08
#define OPERA_WRITE_FX2 0xbb
#define OPERA_TUNER_REQ 0xb1
#define REG_1F_SYMBOLRATE_BYTE0 0x1f
#define REG_20_SYMBOLRATE_BYTE1 0x20
#define REG_21_SYMBOLRATE_BYTE2 0x21

#define ADDR_B600_VOLTAGE_13V (0x02)
#define ADDR_B601_VOLTAGE_18V (0x03)
#define ADDR_B1A6_STREAM_CTRL (0x04)
#define ADDR_B880_READ_REMOTE (0x05)

struct opera1_state {
	u32 last_key_pressed;
};
struct rc_map_opera_table {
	u32 keycode;
	u32 event;
};

static int dvb_usb_opera1_debug;
module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
MODULE_PARM_DESC(debug,
		 "set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
		 DVB_USB_DEBUG_STATUS);

DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);


static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
			    u8 * data, u16 len, int flags)
{
	int ret;
	u8 tmp;
	u8 *buf;
	unsigned int pipe = (flags == OPERA_READ_MSG) ?
		usb_rcvctrlpipe(dev,0) : usb_sndctrlpipe(dev, 0);
	u8 request_type = (flags == OPERA_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;

	buf = kmalloc(len, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	if (flags == OPERA_WRITE_MSG)
		memcpy(buf, data, len);
	ret = usb_control_msg(dev, pipe, request,
			request_type | USB_TYPE_VENDOR, value, 0x0,
			buf, len, 2000);

	if (request == OPERA_TUNER_REQ) {
		tmp = buf[0];
		if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			    OPERA_TUNER_REQ, USB_DIR_IN | USB_TYPE_VENDOR,
			    0x01, 0x0, buf, 1, 2000) < 1 || buf[0] != 0x08) {
			ret = 0;
			goto out;
		}
		buf[0] = tmp;
	}
	if (flags == OPERA_READ_MSG)
		memcpy(data, buf, len);
out:
	kfree(buf);
	return ret;
}

/* I2C */

static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
				  u8 * buf, u16 len)
{
	int ret = 0;
	u8 request;
	u16 value;

	if (!dev) {
		info("no usb_device");
		return -EINVAL;
	}
	if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
		return -EAGAIN;

	switch (addr>>1){
		case ADDR_B600_VOLTAGE_13V:
			request=0xb6;
			value=0x00;
			break;
		case ADDR_B601_VOLTAGE_18V:
			request=0xb6;
			value=0x01;
			break;
		case ADDR_B1A6_STREAM_CTRL:
			request=0xb1;
			value=0xa6;
			break;
		case ADDR_B880_READ_REMOTE:
			request=0xb8;
			value=0x80;
			break;
		default:
			request=0xb1;
			value=addr;
	}
	ret = opera1_xilinx_rw(dev->udev, request,
		value, buf, len,
		addr&0x01?OPERA_READ_MSG:OPERA_WRITE_MSG);

	mutex_unlock(&dev->usb_mutex);
	return ret;
}

static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
			   int num)
{
	struct dvb_usb_device *d = i2c_get_adapdata(adap);
	int i = 0, tmp = 0;

	if (!d)
		return -ENODEV;
	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
		return -EAGAIN;

	for (i = 0; i < num; i++) {
		if ((tmp = opera1_usb_i2c_msgxfer(d,
					(msg[i].addr<<1)|(msg[i].flags&I2C_M_RD?0x01:0),
					msg[i].buf,
					msg[i].len
					)) != msg[i].len) {
			break;
		}
		if (dvb_usb_opera1_debug & 0x10)
			info("sending i2c mesage %d %d", tmp, msg[i].len);
	}
	mutex_unlock(&d->i2c_mutex);
	return num;
}

static u32 opera1_i2c_func(struct i2c_adapter *adapter)
{
	return I2C_FUNC_I2C;
}

static struct i2c_algorithm opera1_i2c_algo = {
	.master_xfer = opera1_i2c_xfer,
	.functionality = opera1_i2c_func,
};

static int opera1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
{
	static u8 command_13v[1]={0x00};
	static u8 command_18v[1]={0x01};
	struct i2c_msg msg[] = {
		{.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1},
	};
	struct dvb_usb_adapter *udev_adap =
	    (struct dvb_usb_adapter *)(fe->dvb->priv);
	if (voltage == SEC_VOLTAGE_18) {
		msg[0].addr = ADDR_B601_VOLTAGE_18V;
		msg[0].buf = command_18v;
	}
	i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
	return 0;
}

static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate,
					  u32 ratio)
{
	stv0299_writereg(fe, 0x13, 0x98);
	stv0299_writereg(fe, 0x14, 0x95);
	stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff);
	stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff);
	stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0);
	return 0;

}
static u8 opera1_inittab[] = {
	0x00, 0xa1,
	0x01, 0x15,
	0x02, 0x30,
	0x03, 0x00,
	0x04, 0x7d,
	0x05, 0x05,
	0x06, 0x02,
	0x07, 0x00,
	0x0b, 0x00,
	0x0c, 0x01,
	0x0d, 0x81,
	0x0e, 0x44,
	0x0f, 0x19,
	0x10, 0x3f,
	0x11, 0x84,
	0x12, 0xda,
	0x13, 0x98,
	0x14, 0x95,
	0x15, 0xc9,
	0x16, 0xeb,
	0x17, 0x00,
	0x18, 0x19,
	0x19, 0x8b,
	0x1a, 0x00,
	0x1b, 0x82,
	0x1c, 0x7f,
	0x1d, 0x00,
	0x1e, 0x00,
	REG_1F_SYMBOLRATE_BYTE0, 0x06,
	REG_20_SYMBOLRATE_BYTE1, 0x50,
	REG_21_SYMBOLRATE_BYTE2, 0x10,
	0x22, 0x00,
	0x23, 0x00,
	0x24, 0x37,
	0x25, 0xbc,
	0x26, 0x00,
	0x27, 0x00,
	0x28, 0x00,
	0x29, 0x1e,
	0x2a, 0x14,
	0x2b, 0x1f,
	0x2c, 0x09,
	0x2d, 0x0a,
	0x2e, 0x00,
	0x2f, 0x00,
	0x30, 0x00,
	0x31, 0x1f,
	0x32, 0x19,
	0x33, 0xfc,
	0x34, 0x13,
	0xff, 0xff,
};

static struct stv0299_config opera1_stv0299_config = {
	.demod_address = 0xd0>>1,
	.min_delay_ms = 100,
	.mclk = 88000000UL,
	.invert = 1,
	.skip_reinit = 0,
	.lock_output = STV0299_LOCKOUTPUT_0,
	.volt13_op0_op1 = STV0299_VOLT13_OP0,
	.inittab = opera1_inittab,
	.set_symbol_rate = opera1_stv0299_set_symbol_rate,
};

static int opera1_frontend_attach(struct dvb_usb_adapter *d)
{
	if ((d->fe =
	     dvb_attach(stv0299_attach, &opera1_stv0299_config,
			&d->dev->i2c_adap)) != NULL) {
		d->fe->ops.set_voltage = opera1_set_voltage;
		return 0;
	}
	info("not attached stv0299");
	return -EIO;
}

static int opera1_tuner_attach(struct dvb_usb_adapter *adap)
{
	dvb_attach(
		dvb_pll_attach, adap->fe, 0xc0>>1,
		&adap->dev->i2c_adap, DVB_PLL_OPERA1
	);
	return 0;
}

static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff)
{
	u8 val = onoff ? 0x01 : 0x00;

	if (dvb_usb_opera1_debug)
		info("power %s", onoff ? "on" : "off");
	return opera1_xilinx_rw(d->udev, 0xb7, val,
				&val, 1, OPERA_WRITE_MSG);
}

static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
	static u8 buf_start[2] = { 0xff, 0x03 };
	static u8 buf_stop[2] = { 0xff, 0x00 };
	struct i2c_msg start_tuner[] = {
		{.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2},
	};
	if (dvb_usb_opera1_debug)
		info("streaming %s", onoff ? "on" : "off");
	i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1);
	return 0;
}

static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
			     int onoff)
{
	u8 b_pid[3];
	struct i2c_msg msg[] = {
		{.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
	};
	if (dvb_usb_opera1_debug)
		info("pidfilter index: %d pid: %d %s", index, pid,
			onoff ? "on" : "off");
	b_pid[0] = (2 * index) + 4;
	b_pid[1] = onoff ? (pid & 0xff) : (0x00);
	b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00);
	i2c_transfer(&adap->dev->i2c_adap, msg, 1);
	return 0;
}

static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
{
	int u = 0x04;
	u8 b_pid[3];
	struct i2c_msg msg[] = {
		{.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
	};
	if (dvb_usb_opera1_debug)
		info("%s hw-pidfilter", onoff ? "enable" : "disable");
	for (; u < 0x7e; u += 2) {
		b_pid[0] = u;
		b_pid[1] = 0;
		b_pid[2] = 0x80;
		i2c_transfer(&adap->dev->i2c_adap, msg, 1);
	}
	return 0;
}

static struct rc_map_table rc_map_opera1_table[] = {
	{0x5fa0, KEY_1},
	{0x51af, KEY_2},
	{0x5da2, KEY_3},
	{0x41be, KEY_4},
	{0x0bf5, KEY_5},
	{0x43bd, KEY_6},
	{0x47b8, KEY_7},
	{0x49b6, KEY_8},
	{0x05fa, KEY_9},
	{0x45ba, KEY_0},
	{0x09f6, KEY_CHANNELUP},	/*chanup */
	{0x1be5, KEY_CHANNELDOWN},	/*chandown */
	{0x5da3, KEY_VOLUMEDOWN},	/*voldown */
	{0x5fa1, KEY_VOLUMEUP},		/*volup */
	{0x07f8, KEY_SPACE},		/*tab */
	{0x1fe1, KEY_OK},		/*play ok */
	{0x1be4, KEY_ZOOM},		/*zoom */
	{0x59a6, KEY_MUTE},		/*mute */
	{0x5ba5, KEY_RADIO},		/*tv/f */
	{0x19e7, KEY_RECORD},		/*rec */
	{0x01fe, KEY_STOP},		/*Stop */
	{0x03fd, KEY_PAUSE},		/*pause */
	{0x03fc, KEY_SCREEN},		/*<- -> */
	{0x07f9, KEY_CAMERA},		/*capture */
	{0x47b9, KEY_ESC},		/*exit */
	{0x43bc, KEY_POWER2},		/*power */
};

static int opera1_rc_query(struct dvb_usb_device *dev, u32 * event, int *state)
{
	struct opera1_state *opst = dev->priv;
	u8 rcbuffer[32];
	const u16 startmarker1 = 0x10ed;
	const u16 startmarker2 = 0x11ec;
	struct i2c_msg read_remote[] = {
		{.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
	};
	int i = 0;
	u32 send_key = 0;

	if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
		for (i = 0; i < 32; i++) {
			if (rcbuffer[i])
				send_key |= 1;
			if (i < 31)
				send_key = send_key << 1;
		}
		if (send_key & 0x8000)
			send_key = (send_key << 1) | (send_key >> 15 & 0x01);

		if (send_key == 0xffff && opst->last_key_pressed != 0) {
			*state = REMOTE_KEY_REPEAT;
			*event = opst->last_key_pressed;
			return 0;
		}
		for (; send_key != 0;) {
			if (send_key >> 16 == startmarker2) {
				break;
			} else if (send_key >> 16 == startmarker1) {
				send_key =
					(send_key & 0xfffeffff) | (startmarker1 << 16);
				break;
			} else
				send_key >>= 1;
		}

		if (send_key == 0)
			return 0;

		send_key = (send_key & 0xffff) | 0x0100;

		for (i = 0; i < ARRAY_SIZE(rc_map_opera1_table); i++) {
			if (rc5_scan(&rc_map_opera1_table[i]) == (send_key & 0xffff)) {
				*state = REMOTE_KEY_PRESSED;
				*event = rc_map_opera1_table[i].keycode;
				opst->last_key_pressed =
					rc_map_opera1_table[i].keycode;
				break;
			}
			opst->last_key_pressed = 0;
		}
	} else
		*state = REMOTE_NO_KEY_PRESSED;
	return 0;
}

static struct usb_device_id opera1_table[] = {
	{USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
	{USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
	{}
};

MODULE_DEVICE_TABLE(usb, opera1_table);

static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
{
	u8 command[] = { READ_MAC_ADDR };
	opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
	opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
	return 0;
}
static int opera1_xilinx_load_firmware(struct usb_device *dev,
				       const char *filename)
{
	const struct firmware *fw = NULL;
	u8 *b, *p;
	int ret = 0, i,fpgasize=40;
	u8 testval;
	info("start downloading fpga firmware %s",filename);

	if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
		err("did not find the firmware file. (%s) "
			"Please see linux/Documentation/dvb/ for more details on firmware-problems.",
			filename);
		return ret;
	} else {
		p = kmalloc(fw->size, GFP_KERNEL);
		opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
		if (p != NULL && testval != 0x67) {

			u8 reset = 0, fpga_command = 0;
			memcpy(p, fw->data, fw->size);
			/* clear fpga ? */
			opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
					 OPERA_WRITE_MSG);
			for (i = 0; i < fw->size;) {
				if ( (fw->size - i) <fpgasize){
				    fpgasize=fw->size-i;
				}
				b = (u8 *) p + i;
				if (opera1_xilinx_rw
					(dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
						OPERA_WRITE_MSG) != fpgasize
					) {
					err("error while transferring firmware");
					ret = -EINVAL;
					break;
				}
				i = i + fpgasize;
			}
			/* restart the CPU */
			if (ret || opera1_xilinx_rw
					(dev, 0xa0, 0xe600, &reset, 1,
					OPERA_WRITE_MSG) != 1) {
				err("could not restart the USB controller CPU.");
				ret = -EINVAL;
			}
		}
	}
	kfree(p);
	release_firmware(fw);
	return ret;
}

static struct dvb_usb_device_properties opera1_properties = {
	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
	.usb_ctrl = CYPRESS_FX2,
	.firmware = "dvb-usb-opera-01.fw",
	.size_of_priv = sizeof(struct opera1_state),

	.power_ctrl = opera1_power_ctrl,
	.i2c_algo = &opera1_i2c_algo,

	.rc.legacy = {
		.rc_map_table = rc_map_opera1_table,
		.rc_map_size = ARRAY_SIZE(rc_map_opera1_table),
		.rc_interval = 200,
		.rc_query = opera1_rc_query,
	},
	.read_mac_address = opera1_read_mac_address,
	.generic_bulk_ctrl_endpoint = 0x00,
	/* parameter for the MPEG2-data transfer */
	.num_adapters = 1,
	.adapter = {
		{
			.frontend_attach = opera1_frontend_attach,
			.streaming_ctrl = opera1_streaming_ctrl,
			.tuner_attach = opera1_tuner_attach,
			.caps =
				DVB_USB_ADAP_HAS_PID_FILTER |
				DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
			.pid_filter = opera1_pid_filter,
			.pid_filter_ctrl = opera1_pid_filter_control,
			.pid_filter_count = 252,
			.stream = {
				.type = USB_BULK,
				.count = 10,
				.endpoint = 0x82,
				.u = {
					.bulk = {
						.buffersize = 4096,
					}
				}
			},
		}
	},
	.num_device_descs = 1,
	.devices = {
		{"Opera1 DVB-S USB2.0",
			{&opera1_table[0], NULL},
			{&opera1_table[1], NULL},
		},
	}
};

static int opera1_probe(struct usb_interface *intf,
			const struct usb_device_id *id)
{
	struct usb_device *udev = interface_to_usbdev(intf);

	if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
		udev->descriptor.idVendor == USB_VID_OPERA1 &&
		opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
	    ) {
		return -EINVAL;
	}

	if (0 != dvb_usb_device_init(intf, &opera1_properties,
				     THIS_MODULE, NULL, adapter_nr))
		return -EINVAL;
	return 0;
}

static struct usb_driver opera1_driver = {
	.name = "opera1",
	.probe = opera1_probe,
	.disconnect = dvb_usb_device_exit,
	.id_table = opera1_table,
};

static int __init opera1_module_init(void)
{
	int result = 0;
	if ((result = usb_register(&opera1_driver))) {
		err("usb_register failed. Error number %d", result);
	}
	return result;
}

static void __exit opera1_module_exit(void)
{
	usb_deregister(&opera1_driver);
}

module_init(opera1_module_init);
module_exit(opera1_module_exit);

MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
MODULE_VERSION("0.1");
MODULE_LICENSE("GPL");
Commit	Line	Data
941491f3 MG	1	/* DVB USB framework compliant Linux driver for the Opera1 DVB-S Card
	2	*
	3	* Copyright (C) 2006 Mario Hlawitschka (dh1pa@amsat.org)
	4	* Copyright (C) 2006 Marco Gittler (g.marco@freenet.de)
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the Free
	8	* Software Foundation, version 2.
	9	*
	10	* see Documentation/dvb/README.dvb-usb for more information
	11	*/
	12
53133afb AB	13	#define DVB_USB_LOG_PREFIX "opera"
	14
	15	#include "dvb-usb.h"
941491f3 MG	16	#include "stv0299.h"
	17
	18	#define OPERA_READ_MSG 0
	19	#define OPERA_WRITE_MSG 1
	20	#define OPERA_I2C_TUNER 0xd1
	21
	22	#define READ_FX2_REG_REQ 0xba
	23	#define READ_MAC_ADDR 0x08
	24	#define OPERA_WRITE_FX2 0xbb
	25	#define OPERA_TUNER_REQ 0xb1
	26	#define REG_1F_SYMBOLRATE_BYTE0 0x1f
	27	#define REG_20_SYMBOLRATE_BYTE1 0x20
	28	#define REG_21_SYMBOLRATE_BYTE2 0x21
	29
86534e5e MG	30	#define ADDR_B600_VOLTAGE_13V (0x02)
	31	#define ADDR_B601_VOLTAGE_18V (0x03)
	32	#define ADDR_B1A6_STREAM_CTRL (0x04)
	33	#define ADDR_B880_READ_REMOTE (0x05)
	34
941491f3 MG	35	struct opera1_state {
	36	u32 last_key_pressed;
	37	};
2f4f58d6	38	struct rc_map_opera_table {
941491f3 MG	39	u32 keycode;
	40	u32 event;
	41	};
	42
53133afb	43	static int dvb_usb_opera1_debug;
941491f3 MG	44	module_param_named(debug, dvb_usb_opera1_debug, int, 0644);
	45	MODULE_PARM_DESC(debug,
	46	"set debugging level (1=info,xfer=2,pll=4,ts=8,err=16,rc=32,fw=64 (or-able))."
	47	DVB_USB_DEBUG_STATUS);
	48
78e92006 JG	49	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
	50
	51
941491f3 MG	52	static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
	53	u8 * data, u16 len, int flags)
	54	{
	55	int ret;
12fe2a61 FM	56	u8 tmp;
12fe2a61 FM	57	u8 *buf;
941491f3 MG	58	unsigned int pipe = (flags == OPERA_READ_MSG) ?
	59	usb_rcvctrlpipe(dev,0) : usb_sndctrlpipe(dev, 0);
	60	u8 request_type = (flags == OPERA_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
	61
12fe2a61 FM	62	buf = kmalloc(len, GFP_KERNEL);
	63	if (!buf)
	64	return -ENOMEM;
	65
941491f3	66	if (flags == OPERA_WRITE_MSG)
12fe2a61 FM	67	memcpy(buf, data, len);
	68	ret = usb_control_msg(dev, pipe, request,
	69	request_type \| USB_TYPE_VENDOR, value, 0x0,
	70	buf, len, 2000);
941491f3 MG	71
941491f3 MG	72	if (request == OPERA_TUNER_REQ) {
12fe2a61	73	tmp = buf[0];
941491f3	74	if (usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
12fe2a61 FM	75	OPERA_TUNER_REQ, USB_DIR_IN \| USB_TYPE_VENDOR,
	76	0x01, 0x0, buf, 1, 2000) < 1 \|\| buf[0] != 0x08) {
	77	ret = 0;
	78	goto out;
	79	}
	80	buf[0] = tmp;
941491f3 MG	81	}
941491f3 MG	82	if (flags == OPERA_READ_MSG)
12fe2a61 FM	83	memcpy(data, buf, len);
	84	out:
	85	kfree(buf);
941491f3 MG	86	return ret;
	87	}
	88
	89	/* I2C */
	90
	91	static int opera1_usb_i2c_msgxfer(struct dvb_usb_device *dev, u16 addr,
86534e5e	92	u8 * buf, u16 len)
941491f3 MG	93	{
	94	int ret = 0;
	95	u8 request;
	96	u16 value;
	97
	98	if (!dev) {
	99	info("no usb_device");
	100	return -EINVAL;
	101	}
	102	if (mutex_lock_interruptible(&dev->usb_mutex) < 0)
	103	return -EAGAIN;
	104
86534e5e MG	105	switch (addr>>1){
	106	case ADDR_B600_VOLTAGE_13V:
	107	request=0xb6;
	108	value=0x00;
	109	break;
	110	case ADDR_B601_VOLTAGE_18V:
	111	request=0xb6;
	112	value=0x01;
	113	break;
	114	case ADDR_B1A6_STREAM_CTRL:
	115	request=0xb1;
	116	value=0xa6;
	117	break;
	118	case ADDR_B880_READ_REMOTE:
	119	request=0xb8;
	120	value=0x80;
	121	break;
	122	default:
	123	request=0xb1;
	124	value=addr;
941491f3	125	}
86534e5e MG	126	ret = opera1_xilinx_rw(dev->udev, request,
	127	value, buf, len,
	128	addr&0x01?OPERA_READ_MSG:OPERA_WRITE_MSG);
941491f3 MG	129
	130	mutex_unlock(&dev->usb_mutex);
	131	return ret;
	132	}
	133
	134	static int opera1_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
	135	int num)
	136	{
	137	struct dvb_usb_device *d = i2c_get_adapdata(adap);
	138	int i = 0, tmp = 0;
	139
	140	if (!d)
	141	return -ENODEV;
	142	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
	143	return -EAGAIN;
	144
	145	for (i = 0; i < num; i++) {
	146	if ((tmp = opera1_usb_i2c_msgxfer(d,
86534e5e	147	(msg[i].addr<<1)\|(msg[i].flags&I2C_M_RD?0x01:0),
941491f3	148	msg[i].buf,
86534e5e	149	msg[i].len
1f39b583	150	)) != msg[i].len) {
941491f3 MG	151	break;
	152	}
	153	if (dvb_usb_opera1_debug & 0x10)
	154	info("sending i2c mesage %d %d", tmp, msg[i].len);
	155	}
	156	mutex_unlock(&d->i2c_mutex);
	157	return num;
	158	}
	159
	160	static u32 opera1_i2c_func(struct i2c_adapter *adapter)
	161	{
	162	return I2C_FUNC_I2C;
	163	}
	164
	165	static struct i2c_algorithm opera1_i2c_algo = {
	166	.master_xfer = opera1_i2c_xfer,
	167	.functionality = opera1_i2c_func,
	168	};
	169
	170	static int opera1_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage)
	171	{
	172	static u8 command_13v[1]={0x00};
	173	static u8 command_18v[1]={0x01};
	174	struct i2c_msg msg[] = {
86534e5e	175	{.addr = ADDR_B600_VOLTAGE_13V,.flags = 0,.buf = command_13v,.len = 1},
941491f3 MG	176	};
	177	struct dvb_usb_adapter *udev_adap =
	178	(struct dvb_usb_adapter *)(fe->dvb->priv);
	179	if (voltage == SEC_VOLTAGE_18) {
86534e5e	180	msg[0].addr = ADDR_B601_VOLTAGE_18V;
941491f3 MG	181	msg[0].buf = command_18v;
	182	}
	183	i2c_transfer(&udev_adap->dev->i2c_adap, msg, 1);
	184	return 0;
	185	}
	186
	187	static int opera1_stv0299_set_symbol_rate(struct dvb_frontend *fe, u32 srate,
	188	u32 ratio)
	189	{
	190	stv0299_writereg(fe, 0x13, 0x98);
	191	stv0299_writereg(fe, 0x14, 0x95);
	192	stv0299_writereg(fe, REG_1F_SYMBOLRATE_BYTE0, (ratio >> 16) & 0xff);
	193	stv0299_writereg(fe, REG_20_SYMBOLRATE_BYTE1, (ratio >> 8) & 0xff);
	194	stv0299_writereg(fe, REG_21_SYMBOLRATE_BYTE2, (ratio) & 0xf0);
	195	return 0;
	196
	197	}
	198	static u8 opera1_inittab[] = {
	199	0x00, 0xa1,
	200	0x01, 0x15,
9d8e1b54	201	0x02, 0x30,
941491f3 MG	202	0x03, 0x00,
	203	0x04, 0x7d,
	204	0x05, 0x05,
	205	0x06, 0x02,
	206	0x07, 0x00,
	207	0x0b, 0x00,
	208	0x0c, 0x01,
	209	0x0d, 0x81,
	210	0x0e, 0x44,
	211	0x0f, 0x19,
	212	0x10, 0x3f,
	213	0x11, 0x84,
	214	0x12, 0xda,
	215	0x13, 0x98,
	216	0x14, 0x95,
	217	0x15, 0xc9,
	218	0x16, 0xeb,
	219	0x17, 0x00,
	220	0x18, 0x19,
	221	0x19, 0x8b,
	222	0x1a, 0x00,
	223	0x1b, 0x82,
	224	0x1c, 0x7f,
	225	0x1d, 0x00,
	226	0x1e, 0x00,
	227	REG_1F_SYMBOLRATE_BYTE0, 0x06,
	228	REG_20_SYMBOLRATE_BYTE1, 0x50,
	229	REG_21_SYMBOLRATE_BYTE2, 0x10,
	230	0x22, 0x00,
	231	0x23, 0x00,
	232	0x24, 0x37,
	233	0x25, 0xbc,
	234	0x26, 0x00,
	235	0x27, 0x00,
	236	0x28, 0x00,
	237	0x29, 0x1e,
	238	0x2a, 0x14,
	239	0x2b, 0x1f,
	240	0x2c, 0x09,
	241	0x2d, 0x0a,
	242	0x2e, 0x00,
	243	0x2f, 0x00,
	244	0x30, 0x00,
	245	0x31, 0x1f,
	246	0x32, 0x19,
	247	0x33, 0xfc,
	248	0x34, 0x13,
	249	0xff, 0xff,
	250	};
	251
	252	static struct stv0299_config opera1_stv0299_config = {
86534e5e	253	.demod_address = 0xd0>>1,
941491f3 MG	254	.min_delay_ms = 100,
	255	.mclk = 88000000UL,
	256	.invert = 1,
	257	.skip_reinit = 0,
da2c7f66	258	.lock_output = STV0299_LOCKOUTPUT_0,
941491f3 MG	259	.volt13_op0_op1 = STV0299_VOLT13_OP0,
	260	.inittab = opera1_inittab,
	261	.set_symbol_rate = opera1_stv0299_set_symbol_rate,
	262	};
	263
	264	static int opera1_frontend_attach(struct dvb_usb_adapter *d)
	265	{
	266	if ((d->fe =
	267	dvb_attach(stv0299_attach, &opera1_stv0299_config,
	268	&d->dev->i2c_adap)) != NULL) {
	269	d->fe->ops.set_voltage = opera1_set_voltage;
	270	return 0;
	271	}
	272	info("not attached stv0299");
	273	return -EIO;
	274	}
	275
	276	static int opera1_tuner_attach(struct dvb_usb_adapter *adap)
	277	{
86534e5e MG	278	dvb_attach(
86534e5e MG	279	dvb_pll_attach, adap->fe, 0xc0>>1,
47a9991e	280	&adap->dev->i2c_adap, DVB_PLL_OPERA1
86534e5e	281	);
941491f3 MG	282	return 0;
	283	}
	284
	285	static int opera1_power_ctrl(struct dvb_usb_device *d, int onoff)
	286	{
941491f3	287	u8 val = onoff ? 0x01 : 0x00;
86534e5e	288
941491f3 MG	289	if (dvb_usb_opera1_debug)
941491f3 MG	290	info("power %s", onoff ? "on" : "off");
86534e5e MG	291	return opera1_xilinx_rw(d->udev, 0xb7, val,
86534e5e MG	292	&val, 1, OPERA_WRITE_MSG);
941491f3 MG	293	}
	294
	295	static int opera1_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
	296	{
	297	static u8 buf_start[2] = { 0xff, 0x03 };
	298	static u8 buf_stop[2] = { 0xff, 0x00 };
	299	struct i2c_msg start_tuner[] = {
86534e5e	300	{.addr = ADDR_B1A6_STREAM_CTRL,.buf = onoff ? buf_start : buf_stop,.len = 2},
941491f3 MG	301	};
	302	if (dvb_usb_opera1_debug)
	303	info("streaming %s", onoff ? "on" : "off");
	304	i2c_transfer(&adap->dev->i2c_adap, start_tuner, 1);
	305	return 0;
	306	}
	307
	308	static int opera1_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
	309	int onoff)
	310	{
	311	u8 b_pid[3];
	312	struct i2c_msg msg[] = {
86534e5e	313	{.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
941491f3 MG	314	};
	315	if (dvb_usb_opera1_debug)
	316	info("pidfilter index: %d pid: %d %s", index, pid,
	317	onoff ? "on" : "off");
	318	b_pid[0] = (2 * index) + 4;
	319	b_pid[1] = onoff ? (pid & 0xff) : (0x00);
	320	b_pid[2] = onoff ? ((pid >> 8) & 0xff) : (0x00);
	321	i2c_transfer(&adap->dev->i2c_adap, msg, 1);
	322	return 0;
	323	}
	324
	325	static int opera1_pid_filter_control(struct dvb_usb_adapter *adap, int onoff)
	326	{
	327	int u = 0x04;
	328	u8 b_pid[3];
	329	struct i2c_msg msg[] = {
86534e5e	330	{.addr = ADDR_B1A6_STREAM_CTRL,.buf = b_pid,.len = 3},
941491f3 MG	331	};
	332	if (dvb_usb_opera1_debug)
	333	info("%s hw-pidfilter", onoff ? "enable" : "disable");
	334	for (; u < 0x7e; u += 2) {
	335	b_pid[0] = u;
	336	b_pid[1] = 0;
	337	b_pid[2] = 0x80;
	338	i2c_transfer(&adap->dev->i2c_adap, msg, 1);
	339	}
	340	return 0;
	341	}
	342
2f4f58d6	343	static struct rc_map_table rc_map_opera1_table[] = {
2e365883 MCC	344	{0x5fa0, KEY_1},
	345	{0x51af, KEY_2},
	346	{0x5da2, KEY_3},
	347	{0x41be, KEY_4},
	348	{0x0bf5, KEY_5},
	349	{0x43bd, KEY_6},
	350	{0x47b8, KEY_7},
	351	{0x49b6, KEY_8},
	352	{0x05fa, KEY_9},
	353	{0x45ba, KEY_0},
76fd93b6 MCC	354	{0x09f6, KEY_CHANNELUP}, /chanup /
	355	{0x1be5, KEY_CHANNELDOWN}, /chandown /
	356	{0x5da3, KEY_VOLUMEDOWN}, /voldown /
	357	{0x5fa1, KEY_VOLUMEUP}, /volup /
	358	{0x07f8, KEY_SPACE}, /tab /
	359	{0x1fe1, KEY_OK}, /play ok /
	360	{0x1be4, KEY_ZOOM}, /zoom /
	361	{0x59a6, KEY_MUTE}, /mute /
	362	{0x5ba5, KEY_RADIO}, /tv/f /
	363	{0x19e7, KEY_RECORD}, /rec /
	364	{0x01fe, KEY_STOP}, /Stop /
	365	{0x03fd, KEY_PAUSE}, /pause /
	366	{0x03fc, KEY_SCREEN}, /<- -> /
	367	{0x07f9, KEY_CAMERA}, /capture /
	368	{0x47b9, KEY_ESC}, /exit /
	369	{0x43bc, KEY_POWER2}, /power /
941491f3 MG	370	};
	371
	372	static int opera1_rc_query(struct dvb_usb_device dev, u32 event, int *state)
	373	{
	374	struct opera1_state *opst = dev->priv;
	375	u8 rcbuffer[32];
	376	const u16 startmarker1 = 0x10ed;
	377	const u16 startmarker2 = 0x11ec;
	378	struct i2c_msg read_remote[] = {
86534e5e	379	{.addr = ADDR_B880_READ_REMOTE,.buf = rcbuffer,.flags = I2C_M_RD,.len = 32},
941491f3 MG	380	};
	381	int i = 0;
	382	u32 send_key = 0;
	383
	384	if (i2c_transfer(&dev->i2c_adap, read_remote, 1) == 1) {
	385	for (i = 0; i < 32; i++) {
	386	if (rcbuffer[i])
	387	send_key \|= 1;
	388	if (i < 31)
	389	send_key = send_key << 1;
	390	}
	391	if (send_key & 0x8000)
	392	send_key = (send_key << 1) \| (send_key >> 15 & 0x01);
	393
	394	if (send_key == 0xffff && opst->last_key_pressed != 0) {
	395	*state = REMOTE_KEY_REPEAT;
	396	*event = opst->last_key_pressed;
	397	return 0;
	398	}
	399	for (; send_key != 0;) {
	400	if (send_key >> 16 == startmarker2) {
	401	break;
	402	} else if (send_key >> 16 == startmarker1) {
	403	send_key =
	404	(send_key & 0xfffeffff) \| (startmarker1 << 16);
	405	break;
	406	} else
	407	send_key >>= 1;
	408	}
	409
	410	if (send_key == 0)
	411	return 0;
	412
	413	send_key = (send_key & 0xffff) \| 0x0100;
	414
2f4f58d6 MCC	415	for (i = 0; i < ARRAY_SIZE(rc_map_opera1_table); i++) {
2f4f58d6 MCC	416	if (rc5_scan(&rc_map_opera1_table[i]) == (send_key & 0xffff)) {
941491f3	417	*state = REMOTE_KEY_PRESSED;
2f4f58d6	418	*event = rc_map_opera1_table[i].keycode;
941491f3	419	opst->last_key_pressed =
2f4f58d6	420	rc_map_opera1_table[i].keycode;
941491f3 MG	421	break;
	422	}
	423	opst->last_key_pressed = 0;
	424	}
	425	} else
	426	*state = REMOTE_NO_KEY_PRESSED;
	427	return 0;
	428	}
	429
	430	static struct usb_device_id opera1_table[] = {
	431	{USB_DEVICE(USB_VID_CYPRESS, USB_PID_OPERA1_COLD)},
	432	{USB_DEVICE(USB_VID_OPERA1, USB_PID_OPERA1_WARM)},
	433	{}
	434	};
	435
	436	MODULE_DEVICE_TABLE(usb, opera1_table);
	437
	438	static int opera1_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
	439	{
	440	u8 command[] = { READ_MAC_ADDR };
	441	opera1_xilinx_rw(d->udev, 0xb1, 0xa0, command, 1, OPERA_WRITE_MSG);
	442	opera1_xilinx_rw(d->udev, 0xb1, 0xa1, mac, 6, OPERA_READ_MSG);
	443	return 0;
	444	}
	445	static int opera1_xilinx_load_firmware(struct usb_device *dev,
	446	const char *filename)
	447	{
	448	const struct firmware *fw = NULL;
	449	u8 b, p;
59800555	450	int ret = 0, i,fpgasize=40;
941491f3	451	u8 testval;
59800555	452	info("start downloading fpga firmware %s",filename);
941491f3 MG	453
	454	if ((ret = request_firmware(&fw, filename, &dev->dev)) != 0) {
	455	err("did not find the firmware file. (%s) "
	456	"Please see linux/Documentation/dvb/ for more details on firmware-problems.",
	457	filename);
	458	return ret;
	459	} else {
	460	p = kmalloc(fw->size, GFP_KERNEL);
	461	opera1_xilinx_rw(dev, 0xbc, 0x00, &testval, 1, OPERA_READ_MSG);
	462	if (p != NULL && testval != 0x67) {
	463
	464	u8 reset = 0, fpga_command = 0;
	465	memcpy(p, fw->data, fw->size);
	466	/* clear fpga ? */
	467	opera1_xilinx_rw(dev, 0xbc, 0xaa, &fpga_command, 1,
	468	OPERA_WRITE_MSG);
59800555 MG	469	for (i = 0; i < fw->size;) {
	470	if ( (fw->size - i) <fpgasize){
	471	fpgasize=fw->size-i;
	472	}
941491f3 MG	473	b = (u8 *) p + i;
941491f3 MG	474	if (opera1_xilinx_rw
59800555 MG	475	(dev, OPERA_WRITE_FX2, 0x0, b , fpgasize,
59800555 MG	476	OPERA_WRITE_MSG) != fpgasize
941491f3 MG	477	) {
	478	err("error while transferring firmware");
	479	ret = -EINVAL;
	480	break;
	481	}
59800555	482	i = i + fpgasize;
941491f3 MG	483	}
	484	/* restart the CPU */
	485	if (ret \|\| opera1_xilinx_rw
	486	(dev, 0xa0, 0xe600, &reset, 1,
	487	OPERA_WRITE_MSG) != 1) {
	488	err("could not restart the USB controller CPU.");
	489	ret = -EINVAL;
	490	}
941491f3 MG	491	}
941491f3 MG	492	}
77596058	493	kfree(p);
a8e07124	494	release_firmware(fw);
941491f3 MG	495	return ret;
	496	}
	497
	498	static struct dvb_usb_device_properties opera1_properties = {
	499	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
	500	.usb_ctrl = CYPRESS_FX2,
86534e5e	501	.firmware = "dvb-usb-opera-01.fw",
941491f3 MG	502	.size_of_priv = sizeof(struct opera1_state),
	503
	504	.power_ctrl = opera1_power_ctrl,
	505	.i2c_algo = &opera1_i2c_algo,
	506
f72a27b8	507	.rc.legacy = {
2f4f58d6 MCC	508	.rc_map_table = rc_map_opera1_table,
2f4f58d6 MCC	509	.rc_map_size = ARRAY_SIZE(rc_map_opera1_table),
f72a27b8 MCC	510	.rc_interval = 200,
	511	.rc_query = opera1_rc_query,
	512	},
941491f3 MG	513	.read_mac_address = opera1_read_mac_address,
	514	.generic_bulk_ctrl_endpoint = 0x00,
	515	/* parameter for the MPEG2-data transfer */
	516	.num_adapters = 1,
	517	.adapter = {
	518	{
	519	.frontend_attach = opera1_frontend_attach,
	520	.streaming_ctrl = opera1_streaming_ctrl,
	521	.tuner_attach = opera1_tuner_attach,
	522	.caps =
	523	DVB_USB_ADAP_HAS_PID_FILTER \|
	524	DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
	525	.pid_filter = opera1_pid_filter,
	526	.pid_filter_ctrl = opera1_pid_filter_control,
	527	.pid_filter_count = 252,
	528	.stream = {
	529	.type = USB_BULK,
	530	.count = 10,
	531	.endpoint = 0x82,
	532	.u = {
	533	.bulk = {
	534	.buffersize = 4096,
	535	}
	536	}
	537	},
	538	}
	539	},
	540	.num_device_descs = 1,
	541	.devices = {
	542	{"Opera1 DVB-S USB2.0",
	543	{&opera1_table[0], NULL},
	544	{&opera1_table[1], NULL},
	545	},
	546	}
	547	};
	548
	549	static int opera1_probe(struct usb_interface *intf,
	550	const struct usb_device_id *id)
	551	{
941491f3 MG	552	struct usb_device *udev = interface_to_usbdev(intf);
	553
	554	if (udev->descriptor.idProduct == USB_PID_OPERA1_WARM &&
	555	udev->descriptor.idVendor == USB_VID_OPERA1 &&
59800555	556	opera1_xilinx_load_firmware(udev, "dvb-usb-opera1-fpga-01.fw") != 0
d06cdbe5	557	) {
941491f3 MG	558	return -EINVAL;
	559	}
	560
78e92006 JG	561	if (0 != dvb_usb_device_init(intf, &opera1_properties,
78e92006 JG	562	THIS_MODULE, NULL, adapter_nr))
941491f3 MG	563	return -EINVAL;
	564	return 0;
	565	}
	566
	567	static struct usb_driver opera1_driver = {
	568	.name = "opera1",
	569	.probe = opera1_probe,
	570	.disconnect = dvb_usb_device_exit,
	571	.id_table = opera1_table,
	572	};
	573
	574	static int __init opera1_module_init(void)
	575	{
	576	int result = 0;
	577	if ((result = usb_register(&opera1_driver))) {
	578	err("usb_register failed. Error number %d", result);
	579	}
	580	return result;
	581	}
	582
	583	static void __exit opera1_module_exit(void)
	584	{
	585	usb_deregister(&opera1_driver);
	586	}
	587
	588	module_init(opera1_module_init);
	589	module_exit(opera1_module_exit);
	590
	591	MODULE_AUTHOR("Mario Hlawitschka (c) dh1pa@amsat.org");
	592	MODULE_AUTHOR("Marco Gittler (c) g.marco@freenet.de");
	593	MODULE_DESCRIPTION("Driver for Opera1 DVB-S device");
	594	MODULE_VERSION("0.1");
	595	MODULE_LICENSE("GPL");