[mirror_ubuntu-zesty-kernel.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
*/

#include "opera1.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 opera_rc_keys {
	u32 keycode;
	u32 event;
};

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

static int opera1_xilinx_rw(struct usb_device *dev, u8 request, u16 value,
			    u8 * data, u16 len, int flags)
{
	int ret;
	u8 r;
	u8 u8buf[len];

	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;

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

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