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