dib0700_core.c 23.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* Linux driver for devices based on the DiBcom DiB0700 USB bridge
 *
 *	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.
 *
 *  Copyright (C) 2005-6 DiBcom, SA
 */
#include "dib0700.h"

/* debug */
int dvb_usb_dib0700_debug;
module_param_named(debug,dvb_usb_dib0700_debug, int, 0644);
MODULE_PARM_DESC(debug, "set debugging level (1=info,2=fw,4=fwdata,8=data (or-able))." DVB_USB_DEBUG_STATUS);

16 17 18
static int nb_packet_buffer_size = 21;
module_param(nb_packet_buffer_size, int, 0644);
MODULE_PARM_DESC(nb_packet_buffer_size,
19
	"Set the dib0700 driver data buffer size. This parameter corresponds to the number of TS packets. The actual size of the data buffer corresponds to this parameter multiplied by 188 (default: 21)");
20

21 22
DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);

23 24 25 26

int dib0700_get_version(struct dvb_usb_device *d, u32 *hwversion,
			u32 *romversion, u32 *ramversion, u32 *fwtype)
{
27 28 29
	struct dib0700_state *st = d->priv;
	int ret;

30
	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
31
		err("could not acquire lock");
32
		return -EINTR;
33 34
	}

35
	ret = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev, 0),
36 37
				  REQUEST_GET_VERSION,
				  USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
38
				  st->buf, 16, USB_CTRL_GET_TIMEOUT);
39
	if (hwversion != NULL)
40 41
		*hwversion  = (st->buf[0] << 24)  | (st->buf[1] << 16)  |
			(st->buf[2] << 8)  | st->buf[3];
42
	if (romversion != NULL)
43 44
		*romversion = (st->buf[4] << 24)  | (st->buf[5] << 16)  |
			(st->buf[6] << 8)  | st->buf[7];
45
	if (ramversion != NULL)
46 47
		*ramversion = (st->buf[8] << 24)  | (st->buf[9] << 16)  |
			(st->buf[10] << 8) | st->buf[11];
48
	if (fwtype != NULL)
49 50
		*fwtype     = (st->buf[12] << 24) | (st->buf[13] << 16) |
			(st->buf[14] << 8) | st->buf[15];
51
	mutex_unlock(&d->usb_mutex);
52 53 54
	return ret;
}

55 56 57 58 59 60
/* expecting rx buffer: request data[0] data[1] ... data[2] */
static int dib0700_ctrl_wr(struct dvb_usb_device *d, u8 *tx, u8 txlen)
{
	int status;

	deb_data(">>> ");
61
	debug_dump(tx, txlen, deb_data);
62 63 64 65 66 67

	status = usb_control_msg(d->udev, usb_sndctrlpipe(d->udev,0),
		tx[0], USB_TYPE_VENDOR | USB_DIR_OUT, 0, 0, tx, txlen,
		USB_CTRL_GET_TIMEOUT);

	if (status != txlen)
68
		deb_data("ep 0 write error (status = %d, len: %d)\n",status,txlen);
69 70 71 72 73

	return status < 0 ? status : 0;
}

/* expecting tx buffer: request data[0] ... data[n] (n <= 4) */
74
int dib0700_ctrl_rd(struct dvb_usb_device *d, u8 *tx, u8 txlen, u8 *rx, u8 rxlen)
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
{
	u16 index, value;
	int status;

	if (txlen < 2) {
		err("tx buffer length is smaller than 2. Makes no sense.");
		return -EINVAL;
	}
	if (txlen > 4) {
		err("tx buffer length is larger than 4. Not supported.");
		return -EINVAL;
	}

	deb_data(">>> ");
	debug_dump(tx,txlen,deb_data);

	value = ((txlen - 2) << 8) | tx[1];
	index = 0;
	if (txlen > 2)
		index |= (tx[2] << 8);
	if (txlen > 3)
		index |= tx[3];

	status = usb_control_msg(d->udev, usb_rcvctrlpipe(d->udev,0), tx[0],
			USB_TYPE_VENDOR | USB_DIR_IN, value, index, rx, rxlen,
			USB_CTRL_GET_TIMEOUT);

	if (status < 0)
103
		deb_info("ep 0 read error (status = %d)\n",status);
104 105

	deb_data("<<< ");
106
	debug_dump(rx, rxlen, deb_data);
107 108 109 110 111 112

	return status; /* length in case of success */
}

int dib0700_set_gpio(struct dvb_usb_device *d, enum dib07x0_gpios gpio, u8 gpio_dir, u8 gpio_val)
{
113
	struct dib0700_state *st = d->priv;
114 115 116
	int ret;

	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
117
		err("could not acquire lock");
118
		return -EINTR;
119
	}
120 121 122 123 124 125 126

	st->buf[0] = REQUEST_SET_GPIO;
	st->buf[1] = gpio;
	st->buf[2] = ((gpio_dir & 0x01) << 7) | ((gpio_val & 0x01) << 6);

	ret = dib0700_ctrl_wr(d, st->buf, 3);

127
	mutex_unlock(&d->usb_mutex);
128
	return ret;
129 130
}

131 132
static int dib0700_set_usb_xfer_len(struct dvb_usb_device *d, u16 nb_ts_packets)
{
133 134 135 136
	struct dib0700_state *st = d->priv;
	int ret;

	if (st->fw_version >= 0x10201) {
137
		if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
138
			err("could not acquire lock");
139
			return -EINTR;
140 141
		}

142 143 144
		st->buf[0] = REQUEST_SET_USB_XFER_LEN;
		st->buf[1] = (nb_ts_packets >> 8) & 0xff;
		st->buf[2] = nb_ts_packets & 0xff;
145 146 147

		deb_info("set the USB xfer len to %i Ts packet\n", nb_ts_packets);

148
		ret = dib0700_ctrl_wr(d, st->buf, 3);
149
		mutex_unlock(&d->usb_mutex);
150 151 152 153 154 155
	} else {
		deb_info("this firmware does not allow to change the USB xfer len\n");
		ret = -EIO;
	}

	return ret;
156 157
}

158
/*
159
 * I2C master xfer function (supported in 1.20 firmware)
160
 */
161 162 163 164 165 166 167
static int dib0700_i2c_xfer_new(struct i2c_adapter *adap, struct i2c_msg *msg,
				int num)
{
	/* The new i2c firmware messages are more reliable and in particular
	   properly support i2c read calls not preceded by a write */

	struct dvb_usb_device *d = i2c_get_adapdata(adap);
168
	struct dib0700_state *st = d->priv;
169 170 171 172 173 174 175 176 177
	uint8_t bus_mode = 1;  /* 0=eeprom bus, 1=frontend bus */
	uint8_t gen_mode = 0; /* 0=master i2c, 1=gpio i2c */
	uint8_t en_start = 0;
	uint8_t en_stop = 0;
	int result, i;

	/* Ensure nobody else hits the i2c bus while we're sending our
	   sequence of messages, (such as the remote control thread) */
	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
178
		return -EINTR;
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205

	for (i = 0; i < num; i++) {
		if (i == 0) {
			/* First message in the transaction */
			en_start = 1;
		} else if (!(msg[i].flags & I2C_M_NOSTART)) {
			/* Device supports repeated-start */
			en_start = 1;
		} else {
			/* Not the first packet and device doesn't support
			   repeated start */
			en_start = 0;
		}
		if (i == (num - 1)) {
			/* Last message in the transaction */
			en_stop = 1;
		}

		if (msg[i].flags & I2C_M_RD) {
			/* Read request */
			u16 index, value;
			uint8_t i2c_dest;

			i2c_dest = (msg[i].addr << 1);
			value = ((en_start << 7) | (en_stop << 6) |
				 (msg[i].len & 0x3F)) << 8 | i2c_dest;
			/* I2C ctrl + FE bus; */
206 207
			index = ((gen_mode << 6) & 0xC0) |
				((bus_mode << 4) & 0x30);
208 209 210 211 212

			result = usb_control_msg(d->udev,
						 usb_rcvctrlpipe(d->udev, 0),
						 REQUEST_NEW_I2C_READ,
						 USB_TYPE_VENDOR | USB_DIR_IN,
213
						 value, index, st->buf,
214 215 216
						 msg[i].len,
						 USB_CTRL_GET_TIMEOUT);
			if (result < 0) {
217
				deb_info("i2c read error (status = %d)\n", result);
218
				goto unlock;
219
			}
220

221 222 223
			if (msg[i].len > sizeof(st->buf)) {
				deb_info("buffer too small to fit %d bytes\n",
					 msg[i].len);
224 225
				result = -EIO;
				goto unlock;
226 227 228 229
			}

			memcpy(msg[i].buf, st->buf, msg[i].len);

230 231 232
			deb_data("<<< ");
			debug_dump(msg[i].buf, msg[i].len, deb_data);

233 234
		} else {
			/* Write request */
235
			if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
236
				err("could not acquire lock");
237 238
				result = -EINTR;
				goto unlock;
239
			}
240 241 242
			st->buf[0] = REQUEST_NEW_I2C_WRITE;
			st->buf[1] = msg[i].addr << 1;
			st->buf[2] = (en_start << 7) | (en_stop << 6) |
243 244
				(msg[i].len & 0x3F);
			/* I2C ctrl + FE bus; */
245
			st->buf[3] = ((gen_mode << 6) & 0xC0) |
246
				 ((bus_mode << 4) & 0x30);
247 248 249 250

			if (msg[i].len > sizeof(st->buf) - 4) {
				deb_info("i2c message to big: %d\n",
					 msg[i].len);
251 252 253
				mutex_unlock(&d->usb_mutex);
				result = -EIO;
				goto unlock;
254 255
			}

256
			/* The Actual i2c payload */
257
			memcpy(&st->buf[4], msg[i].buf, msg[i].len);
258

259
			deb_data(">>> ");
260
			debug_dump(st->buf, msg[i].len + 4, deb_data);
261

262 263 264 265
			result = usb_control_msg(d->udev,
						 usb_sndctrlpipe(d->udev, 0),
						 REQUEST_NEW_I2C_WRITE,
						 USB_TYPE_VENDOR | USB_DIR_OUT,
266
						 0, 0, st->buf, msg[i].len + 4,
267
						 USB_CTRL_GET_TIMEOUT);
268
			mutex_unlock(&d->usb_mutex);
269
			if (result < 0) {
270
				deb_info("i2c write error (status = %d)\n", result);
271 272 273 274
				break;
			}
		}
	}
275 276 277
	result = i;

unlock:
278
	mutex_unlock(&d->i2c_mutex);
279
	return result;
280 281 282 283 284 285 286
}

/*
 * I2C master xfer function (pre-1.20 firmware)
 */
static int dib0700_i2c_xfer_legacy(struct i2c_adapter *adap,
				   struct i2c_msg *msg, int num)
287 288
{
	struct dvb_usb_device *d = i2c_get_adapdata(adap);
289
	struct dib0700_state *st = d->priv;
290
	int i, len, result;
291 292

	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
293
		return -EINTR;
294
	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
295
		err("could not acquire lock");
296 297
		mutex_unlock(&d->i2c_mutex);
		return -EINTR;
298
	}
299 300 301

	for (i = 0; i < num; i++) {
		/* fill in the address */
302
		st->buf[1] = msg[i].addr << 1;
303
		/* fill the buffer */
304 305 306
		if (msg[i].len > sizeof(st->buf) - 2) {
			deb_info("i2c xfer to big: %d\n",
				msg[i].len);
307 308
			result = -EIO;
			goto unlock;
309
		}
310
		memcpy(&st->buf[2], msg[i].buf, msg[i].len);
311 312 313

		/* write/read request */
		if (i+1 < num && (msg[i+1].flags & I2C_M_RD)) {
314 315
			st->buf[0] = REQUEST_I2C_READ;
			st->buf[1] |= 1;
316 317

			/* special thing in the current firmware: when length is zero the read-failed */
318
			len = dib0700_ctrl_rd(d, st->buf, msg[i].len + 2,
319
					      st->buf, msg[i + 1].len);
320
			if (len <= 0) {
321
				deb_info("I2C read failed on address 0x%02x\n",
322
						msg[i].addr);
323 324
				result = -EIO;
				goto unlock;
325
			}
326

327 328 329
			if (msg[i + 1].len > sizeof(st->buf)) {
				deb_info("i2c xfer buffer to small for %d\n",
					msg[i].len);
330 331
				result = -EIO;
				goto unlock;
332
			}
333 334
			memcpy(msg[i + 1].buf, st->buf, msg[i + 1].len);

335 336 337 338
			msg[i+1].len = len;

			i++;
		} else {
339
			st->buf[0] = REQUEST_I2C_WRITE;
340 341 342
			result = dib0700_ctrl_wr(d, st->buf, msg[i].len + 2);
			if (result < 0)
				goto unlock;
343 344
		}
	}
345 346
	result = i;
unlock:
347
	mutex_unlock(&d->usb_mutex);
348
	mutex_unlock(&d->i2c_mutex);
349

350
	return result;
351 352
}

353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
static int dib0700_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msg,
			    int num)
{
	struct dvb_usb_device *d = i2c_get_adapdata(adap);
	struct dib0700_state *st = d->priv;

	if (st->fw_use_new_i2c_api == 1) {
		/* User running at least fw 1.20 */
		return dib0700_i2c_xfer_new(adap, msg, num);
	} else {
		/* Use legacy calls */
		return dib0700_i2c_xfer_legacy(adap, msg, num);
	}
}

368 369 370 371 372 373 374 375 376 377
static u32 dib0700_i2c_func(struct i2c_adapter *adapter)
{
	return I2C_FUNC_I2C;
}

struct i2c_algorithm dib0700_i2c_algo = {
	.master_xfer   = dib0700_i2c_xfer,
	.functionality = dib0700_i2c_func,
};

378 379 380
int dib0700_identify_state(struct usb_device *udev, struct dvb_usb_device_properties *props,
			struct dvb_usb_device_description **desc, int *cold)
{
381 382 383 384 385 386 387 388 389
	s16 ret;
	u8 *b;

	b = kmalloc(16, GFP_KERNEL);
	if (!b)
		return	-ENOMEM;


	ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
390 391 392 393 394
		REQUEST_GET_VERSION, USB_TYPE_VENDOR | USB_DIR_IN, 0, 0, b, 16, USB_CTRL_GET_TIMEOUT);

	deb_info("FW GET_VERSION length: %d\n",ret);

	*cold = ret <= 0;
395
	deb_info("cold: %d\n", *cold);
396 397

	kfree(b);
398 399 400
	return 0;
}

401 402 403 404
static int dib0700_set_clock(struct dvb_usb_device *d, u8 en_pll,
	u8 pll_src, u8 pll_range, u8 clock_gpio3, u16 pll_prediv,
	u16 pll_loopdiv, u16 free_div, u16 dsuScaler)
{
405
	struct dib0700_state *st = d->priv;
406 407 408
	int ret;

	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
409
		err("could not acquire lock");
410
		return -EINTR;
411
	}
412 413 414 415 416 417 418 419 420 421 422 423 424 425

	st->buf[0] = REQUEST_SET_CLOCK;
	st->buf[1] = (en_pll << 7) | (pll_src << 6) |
		(pll_range << 5) | (clock_gpio3 << 4);
	st->buf[2] = (pll_prediv >> 8)  & 0xff; /* MSB */
	st->buf[3] =  pll_prediv        & 0xff; /* LSB */
	st->buf[4] = (pll_loopdiv >> 8) & 0xff; /* MSB */
	st->buf[5] =  pll_loopdiv       & 0xff; /* LSB */
	st->buf[6] = (free_div >> 8)    & 0xff; /* MSB */
	st->buf[7] =  free_div          & 0xff; /* LSB */
	st->buf[8] = (dsuScaler >> 8)   & 0xff; /* MSB */
	st->buf[9] =  dsuScaler         & 0xff; /* LSB */

	ret = dib0700_ctrl_wr(d, st->buf, 10);
426
	mutex_unlock(&d->usb_mutex);
427 428

	return ret;
429 430
}

431 432
int dib0700_set_i2c_speed(struct dvb_usb_device *d, u16 scl_kHz)
{
433
	struct dib0700_state *st = d->priv;
434
	u16 divider;
435
	int ret;
436 437 438 439

	if (scl_kHz == 0)
		return -EINVAL;

440
	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
441
		err("could not acquire lock");
442
		return -EINTR;
443 444
	}

445
	st->buf[0] = REQUEST_SET_I2C_PARAM;
446
	divider = (u16) (30000 / scl_kHz);
447 448 449
	st->buf[1] = 0;
	st->buf[2] = (u8) (divider >> 8);
	st->buf[3] = (u8) (divider & 0xff);
450
	divider = (u16) (72000 / scl_kHz);
451 452
	st->buf[4] = (u8) (divider >> 8);
	st->buf[5] = (u8) (divider & 0xff);
453
	divider = (u16) (72000 / scl_kHz); /* clock: 72MHz */
454 455
	st->buf[6] = (u8) (divider >> 8);
	st->buf[7] = (u8) (divider & 0xff);
456

457
	deb_info("setting I2C speed: %04x %04x %04x (%d kHz).",
458 459
		(st->buf[2] << 8) | (st->buf[3]), (st->buf[4] << 8) |
		st->buf[5], (st->buf[6] << 8) | st->buf[7], scl_kHz);
460 461 462 463 464

	ret = dib0700_ctrl_wr(d, st->buf, 8);
	mutex_unlock(&d->usb_mutex);

	return ret;
465 466 467
}


468 469 470 471 472 473 474 475 476
int dib0700_ctrl_clock(struct dvb_usb_device *d, u32 clk_MHz, u8 clock_out_gp3)
{
	switch (clk_MHz) {
		case 72: dib0700_set_clock(d, 1, 0, 1, clock_out_gp3, 2, 24, 0, 0x4c); break;
		default: return -EINVAL;
	}
	return 0;
}

477 478
static int dib0700_jumpram(struct usb_device *udev, u32 address)
{
479 480 481 482 483 484 485 486 487 488 489 490 491 492
	int ret = 0, actlen;
	u8 *buf;

	buf = kmalloc(8, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
	buf[0] = REQUEST_JUMPRAM;
	buf[1] = 0;
	buf[2] = 0;
	buf[3] = 0;
	buf[4] = (address >> 24) & 0xff;
	buf[5] = (address >> 16) & 0xff;
	buf[6] = (address >> 8)  & 0xff;
	buf[7] =  address        & 0xff;
493 494 495

	if ((ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x01),buf,8,&actlen,1000)) < 0) {
		deb_fw("jumpram to 0x%x failed\n",address);
496
		goto out;
497 498 499
	}
	if (actlen != 8) {
		deb_fw("jumpram to 0x%x failed\n",address);
500 501
		ret = -EIO;
		goto out;
502
	}
503 504 505
out:
	kfree(buf);
	return ret;
506 507 508 509 510
}

int dib0700_download_firmware(struct usb_device *udev, const struct firmware *fw)
{
	struct hexline hx;
511
	int pos = 0, ret, act_len, i, adap_num;
512
	u8 *buf;
513
	u32 fw_version;
514

515 516 517
	buf = kmalloc(260, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;
518 519

	while ((ret = dvb_usb_get_hexline(fw, &hx, &pos)) > 0) {
520 521
		deb_fwdata("writing to address 0x%08x (buffer: 0x%02x %02x)\n",
				hx.addr, hx.len, hx.chk);
522 523

		buf[0] = hx.len;
524 525
		buf[1] = (hx.addr >> 8) & 0xff;
		buf[2] =  hx.addr       & 0xff;
526 527 528 529 530 531 532 533 534 535 536 537 538
		buf[3] = hx.type;
		memcpy(&buf[4],hx.data,hx.len);
		buf[4+hx.len] = hx.chk;

		ret = usb_bulk_msg(udev,
			usb_sndbulkpipe(udev, 0x01),
			buf,
			hx.len + 5,
			&act_len,
			1000);

		if (ret < 0) {
			err("firmware download failed at %d with %d",pos,ret);
539
			goto out;
540 541 542 543 544
		}
	}

	if (ret == 0) {
		/* start the firmware */
545
		if ((ret = dib0700_jumpram(udev, 0x70000000)) == 0) {
546
			info("firmware started successfully.");
547
			msleep(500);
548
		}
549 550 551
	} else
		ret = -EIO;

552 553 554 555
	/* the number of ts packet has to be at least 1 */
	if (nb_packet_buffer_size < 1)
		nb_packet_buffer_size = 1;

556
	/* get the firmware version */
557 558 559
	usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
				  REQUEST_GET_VERSION,
				  USB_TYPE_VENDOR | USB_DIR_IN, 0, 0,
560 561
				  buf, 16, USB_CTRL_GET_TIMEOUT);
	fw_version = (buf[8] << 24) | (buf[9] << 16) | (buf[10] << 8) | buf[11];
562 563 564 565 566 567

	/* set the buffer size - DVB-USB is allocating URB buffers
	 * only after the firwmare download was successful */
	for (i = 0; i < dib0700_device_count; i++) {
		for (adap_num = 0; adap_num < dib0700_devices[i].num_adapters;
				adap_num++) {
568
			if (fw_version >= 0x10201) {
569
				dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 188*nb_packet_buffer_size;
570
			} else {
571 572
				/* for fw version older than 1.20.1,
				 * the buffersize has to be n times 512 */
573 574 575
				dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = ((188*nb_packet_buffer_size+188/2)/512)*512;
				if (dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize < 512)
					dib0700_devices[i].adapter[adap_num].fe[0].stream.u.bulk.buffersize = 512;
576 577 578
			}
		}
	}
579 580
out:
	kfree(buf);
581 582 583 584 585 586
	return ret;
}

int dib0700_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
	struct dib0700_state *st = adap->dev->priv;
587 588 589 590 591 592 593 594 595 596 597 598
	int ret;

	if ((onoff != 0) && (st->fw_version >= 0x10201)) {
		/* for firmware later than 1.20.1,
		 * the USB xfer length can be set  */
		ret = dib0700_set_usb_xfer_len(adap->dev,
			st->nb_packet_buffer_size);
		if (ret < 0) {
			deb_info("can not set the USB xfer len\n");
			return ret;
		}
	}
599

600
	mutex_lock(&adap->dev->usb_mutex);
601

602 603 604 605
	st->buf[0] = REQUEST_ENABLE_VIDEO;
	/* this bit gives a kind of command,
	 * rather than enabling something or not */
	st->buf[1] = (onoff << 4) | 0x00;
606 607

	if (st->disable_streaming_master_mode == 1)
608
		st->buf[2] = 0x00;
609
	else
610
		st->buf[2] = 0x01 << 4; /* Master mode */
611

612
	st->buf[3] = 0x00;
613 614 615

	deb_info("modifying (%d) streaming state for %d\n", onoff, adap->id);

616
	st->channel_state &= ~0x3;
617 618 619
	if ((adap->fe_adap[0].stream.props.endpoint != 2)
			&& (adap->fe_adap[0].stream.props.endpoint != 3)) {
		deb_info("the endpoint number (%i) is not correct, use the adapter id instead", adap->fe_adap[0].stream.props.endpoint);
620 621 622
		if (onoff)
			st->channel_state |=	1 << (adap->id);
		else
623
			st->channel_state |=	1 << ~(adap->id);
624
	} else {
625
		if (onoff)
626
			st->channel_state |=	1 << (adap->fe_adap[0].stream.props.endpoint-2);
627
		else
628
			st->channel_state |=	1 << (3-adap->fe_adap[0].stream.props.endpoint);
629
	}
630

631
	st->buf[2] |= st->channel_state;
632

633
	deb_info("data for streaming: %x %x\n", st->buf[1], st->buf[2]);
634

635 636 637 638
	ret = dib0700_ctrl_wr(adap->dev, st->buf, 4);
	mutex_unlock(&adap->dev->usb_mutex);

	return ret;
639 640
}

641
int dib0700_change_protocol(struct rc_dev *rc, u64 *rc_proto)
642
{
643
	struct dvb_usb_device *d = rc->priv;
644 645 646
	struct dib0700_state *st = d->priv;
	int new_proto, ret;

647
	if (mutex_lock_interruptible(&d->usb_mutex) < 0) {
648
		err("could not acquire lock");
649
		return -EINTR;
650 651
	}

652 653 654 655
	st->buf[0] = REQUEST_SET_RC;
	st->buf[1] = 0;
	st->buf[2] = 0;

656
	/* Set the IR mode */
657
	if (*rc_proto & RC_PROTO_BIT_RC5) {
658
		new_proto = 1;
659 660
		*rc_proto = RC_PROTO_BIT_RC5;
	} else if (*rc_proto & RC_PROTO_BIT_NEC) {
661
		new_proto = 0;
662 663
		*rc_proto = RC_PROTO_BIT_NEC;
	} else if (*rc_proto & RC_PROTO_BIT_RC6_MCE) {
664 665 666 667
		if (st->fw_version < 0x10200) {
			ret = -EINVAL;
			goto out;
		}
668
		new_proto = 2;
669
		*rc_proto = RC_PROTO_BIT_RC6_MCE;
670 671 672 673
	} else {
		ret = -EINVAL;
		goto out;
	}
674

675
	st->buf[1] = new_proto;
676

677
	ret = dib0700_ctrl_wr(d, st->buf, 3);
678 679
	if (ret < 0) {
		err("ir protocol setup failed");
680
		goto out;
681 682
	}

683
	d->props.rc.core.protocol = *rc_proto;
684

685 686
out:
	mutex_unlock(&d->usb_mutex);
687 688 689
	return ret;
}

690 691 692 693
/* This is the structure of the RC response packet starting in firmware 1.20 */
struct dib0700_rc_response {
	u8 report_id;
	u8 data_state;
694 695 696 697 698 699 700 701 702 703 704 705 706 707
	union {
		struct {
			u8 system;
			u8 not_system;
			u8 data;
			u8 not_data;
		} nec;
		struct {
			u8 not_used;
			u8 system;
			u8 data;
			u8 not_data;
		} rc5;
	};
708 709 710 711 712 713
};
#define RC_MSG_SIZE_V1_20 6

static void dib0700_rc_urb_completion(struct urb *purb)
{
	struct dvb_usb_device *d = purb->context;
714
	struct dib0700_rc_response *poll_reply;
715
	enum rc_proto protocol;
716
	u32 keycode;
717
	u8 toggle;
718 719

	deb_info("%s()\n", __func__);
720
	if (d->rc_dev == NULL) {
721
		/* This will occur if disable_rc_polling=1 */
722
		kfree(purb->transfer_buffer);
723 724 725 726
		usb_free_urb(purb);
		return;
	}

727
	poll_reply = purb->transfer_buffer;
728 729 730

	if (purb->status < 0) {
		deb_info("discontinuing polling\n");
731
		kfree(purb->transfer_buffer);
732 733 734 735 736 737 738 739 740
		usb_free_urb(purb);
		return;
	}

	if (purb->actual_length != RC_MSG_SIZE_V1_20) {
		deb_info("malformed rc msg size=%d\n", purb->actual_length);
		goto resubmit;
	}

741 742
	deb_data("IR ID = %02X state = %02X System = %02X %02X Cmd = %02X %02X (len %d)\n",
		 poll_reply->report_id, poll_reply->data_state,
743 744
		 poll_reply->nec.system, poll_reply->nec.not_system,
		 poll_reply->nec.data, poll_reply->nec.not_data,
745
		 purb->actual_length);
746

747
	switch (d->props.rc.core.protocol) {
748
	case RC_PROTO_BIT_NEC:
749
		toggle = 0;
750 751

		/* NEC protocol sends repeat code as 0 0 0 FF */
752 753 754 755
		if (poll_reply->nec.system     == 0x00 &&
		    poll_reply->nec.not_system == 0x00 &&
		    poll_reply->nec.data       == 0x00 &&
		    poll_reply->nec.not_data   == 0xff) {
756
			poll_reply->data_state = 2;
757 758
			rc_repeat(d->rc_dev);
			goto resubmit;
759
		}
760

761
		if ((poll_reply->nec.data ^ poll_reply->nec.not_data) != 0xff) {
762
			deb_data("NEC32 protocol\n");
763 764 765 766
			keycode = RC_SCANCODE_NEC32(poll_reply->nec.system     << 24 |
						     poll_reply->nec.not_system << 16 |
						     poll_reply->nec.data       << 8  |
						     poll_reply->nec.not_data);
767
			protocol = RC_PROTO_NEC32;
768
		} else if ((poll_reply->nec.system ^ poll_reply->nec.not_system) != 0xff) {
769
			deb_data("NEC extended protocol\n");
770 771 772
			keycode = RC_SCANCODE_NECX(poll_reply->nec.system << 8 |
						    poll_reply->nec.not_system,
						    poll_reply->nec.data);
773

774
			protocol = RC_PROTO_NECX;
775 776
		} else {
			deb_data("NEC normal protocol\n");
777 778
			keycode = RC_SCANCODE_NEC(poll_reply->nec.system,
						   poll_reply->nec.data);
779
			protocol = RC_PROTO_NEC;
780 781
		}

782 783
		break;
	default:
784
		deb_data("RC5 protocol\n");
785
		protocol = RC_PROTO_RC5;
786
		toggle = poll_reply->report_id;
787 788 789 790 791 792 793 794 795
		keycode = RC_SCANCODE_RC5(poll_reply->rc5.system, poll_reply->rc5.data);

		if ((poll_reply->rc5.data ^ poll_reply->rc5.not_data) != 0xff) {
			/* Key failed integrity check */
			err("key failed integrity check: %02x %02x %02x %02x",
			    poll_reply->rc5.not_used, poll_reply->rc5.system,
			    poll_reply->rc5.data, poll_reply->rc5.not_data);
			goto resubmit;
		}
796

797 798 799
		break;
	}

800
	rc_keydown(d->rc_dev, protocol, keycode, toggle);
801 802 803 804 805 806 807 808 809

resubmit:
	/* Clean the buffer before we requeue */
	memset(purb->transfer_buffer, 0, RC_MSG_SIZE_V1_20);

	/* Requeue URB */
	usb_submit_urb(purb, GFP_ATOMIC);
}

810
int dib0700_rc_setup(struct dvb_usb_device *d, struct usb_interface *intf)
811
{
812 813
	struct dib0700_state *st = d->priv;
	struct urb *purb;
814 815 816
	const struct usb_endpoint_descriptor *e;
	int ret, rc_ep = 1;
	unsigned int pipe = 0;
817

818
	/* Poll-based. Don't initialize bulk mode */
819
	if (st->fw_version < 0x10200 || !intf)
820 821 822
		return 0;

	/* Starting in firmware 1.20, the RC info is provided on a bulk pipe */
823

824 825 826
	if (intf->altsetting[0].desc.bNumEndpoints < rc_ep + 1)
		return -ENODEV;

827
	purb = usb_alloc_urb(0, GFP_KERNEL);
828
	if (purb == NULL)
829
		return -ENOMEM;
830 831 832

	purb->transfer_buffer = kzalloc(RC_MSG_SIZE_V1_20, GFP_KERNEL);
	if (purb->transfer_buffer == NULL) {
833
		err("rc kzalloc failed");
834
		usb_free_urb(purb);
835
		return -ENOMEM;
836 837 838
	}

	purb->status = -EINPROGRESS;
839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867

	/*
	 * Some devices like the Hauppauge NovaTD model 52009 use an interrupt
	 * endpoint, while others use a bulk one.
	 */
	e = &intf->altsetting[0].endpoint[rc_ep].desc;
	if (usb_endpoint_dir_in(e)) {
		if (usb_endpoint_xfer_bulk(e)) {
			pipe = usb_rcvbulkpipe(d->udev, rc_ep);
			usb_fill_bulk_urb(purb, d->udev, pipe,
					  purb->transfer_buffer,
					  RC_MSG_SIZE_V1_20,
					  dib0700_rc_urb_completion, d);

		} else if (usb_endpoint_xfer_int(e)) {
			pipe = usb_rcvintpipe(d->udev, rc_ep);
			usb_fill_int_urb(purb, d->udev, pipe,
					  purb->transfer_buffer,
					  RC_MSG_SIZE_V1_20,
					  dib0700_rc_urb_completion, d, 1);
		}
	}

	if (!pipe) {
		err("There's no endpoint for remote controller");
		kfree(purb->transfer_buffer);
		usb_free_urb(purb);
		return 0;
	}
868 869

	ret = usb_submit_urb(purb, GFP_ATOMIC);
870
	if (ret) {
871
		err("rc submit urb failed");
872 873 874
		kfree(purb->transfer_buffer);
		usb_free_urb(purb);
	}
875

876
	return ret;
877 878
}

879 880 881 882
static int dib0700_probe(struct usb_interface *intf,
		const struct usb_device_id *id)
{
	int i;
883
	struct dvb_usb_device *dev;
884 885

	for (i = 0; i < dib0700_device_count; i++)
886
		if (dvb_usb_device_init(intf, &dib0700_devices[i], THIS_MODULE,
887 888 889 890 891 892 893 894 895 896 897 898 899
		    &dev, adapter_nr) == 0) {
			struct dib0700_state *st = dev->priv;
			u32 hwversion, romversion, fw_version, fwtype;

			dib0700_get_version(dev, &hwversion, &romversion,
				&fw_version, &fwtype);

			deb_info("Firmware version: %x, %d, 0x%x, %d\n",
				hwversion, romversion, fw_version, fwtype);

			st->fw_version = fw_version;
			st->nb_packet_buffer_size = (u32)nb_packet_buffer_size;

900 901 902 903 904 905
			/* Disable polling mode on newer firmwares */
			if (st->fw_version >= 0x10200)
				dev->props.rc.core.bulk_mode = true;
			else
				dev->props.rc.core.bulk_mode = false;

906
			dib0700_rc_setup(dev, intf);
907

908
			return 0;
909
		}
910 911 912 913

	return -ENODEV;
}

914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
static void dib0700_disconnect(struct usb_interface *intf)
{
	struct dvb_usb_device *d = usb_get_intfdata(intf);
	struct dib0700_state *st = d->priv;
	struct i2c_client *client;

	/* remove I2C client for tuner */
	client = st->i2c_client_tuner;
	if (client) {
		module_put(client->dev.driver->owner);
		i2c_unregister_device(client);
	}

	/* remove I2C client for demodulator */
	client = st->i2c_client_demod;
	if (client) {
		module_put(client->dev.driver->owner);
		i2c_unregister_device(client);
	}

	dvb_usb_device_exit(intf);
}


938 939 940
static struct usb_driver dib0700_driver = {
	.name       = "dvb_usb_dib0700",
	.probe      = dib0700_probe,
941
	.disconnect = dib0700_disconnect,
942 943 944
	.id_table   = dib0700_usb_id_table,
};

945
module_usb_driver(dib0700_driver);
946

947
MODULE_FIRMWARE("dvb-usb-dib0700-1.20.fw");
948
MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
949 950 951
MODULE_DESCRIPTION("Driver for devices based on DiBcom DiB0700 - USB bridge");
MODULE_VERSION("1.0");
MODULE_LICENSE("GPL");