1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * PCTV 452e DVB driver
4  *
5  * Copyright (c) 2006-2008 Dominik Kuhlen <dkuhlen@gmx.net>
6  *
7  * TT connect S2-3650-CI Common Interface support, MAC readout
8  * Copyright (C) 2008 Michael H. Schimek <mschimek@gmx.at>
9  */
10 
11 /* dvb usb framework */
12 #define DVB_USB_LOG_PREFIX "pctv452e"
13 #include "dvb-usb.h"
14 
15 /* Demodulator */
16 #include "stb0899_drv.h"
17 #include "stb0899_reg.h"
18 #include "stb0899_cfg.h"
19 /* Tuner */
20 #include "stb6100.h"
21 #include "stb6100_cfg.h"
22 /* FE Power */
23 #include "isl6423.h"
24 #include "lnbp22.h"
25 
26 #include <media/dvb_ca_en50221.h>
27 #include "ttpci-eeprom.h"
28 
29 #include <linux/etherdevice.h>
30 
31 static int debug;
32 module_param(debug, int, 0644);
33 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
34 
35 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
36 
37 #define ISOC_INTERFACE_ALTERNATIVE 3
38 
39 #define SYNC_BYTE_OUT 0xaa
40 #define SYNC_BYTE_IN  0x55
41 
42 /* guessed: (copied from ttusb-budget) */
43 #define PCTV_CMD_RESET 0x15
44 /* command to poll IR receiver */
45 #define PCTV_CMD_IR    0x1b
46 /* command to send I2C  */
47 #define PCTV_CMD_I2C   0x31
48 
49 #define I2C_ADDR_STB0899 (0xd0 >> 1)
50 #define I2C_ADDR_STB6100 (0xc0 >> 1)
51 #define I2C_ADDR_LNBP22  (0x10 >> 1)
52 #define I2C_ADDR_24C16   (0xa0 >> 1)
53 #define I2C_ADDR_24C64   (0xa2 >> 1)
54 
55 
56 /* pctv452e sends us this amount of data for each issued usb-command */
57 #define PCTV_ANSWER_LEN 64
58 /* Wait up to 1000ms for device  */
59 #define PCTV_TIMEOUT 1000
60 
61 
62 #define PCTV_LED_GPIO   STB0899_GPIO01
63 #define PCTV_LED_GREEN  0x82
64 #define PCTV_LED_ORANGE 0x02
65 
66 #define ci_dbg(format, arg...)				\
67 do {							\
68 	if (0)						\
69 		printk(KERN_DEBUG DVB_USB_LOG_PREFIX	\
70 			": " format "\n" , ## arg);	\
71 } while (0)
72 
73 enum {
74 	TT3650_CMD_CI_TEST = 0x40,
75 	TT3650_CMD_CI_RD_CTRL,
76 	TT3650_CMD_CI_WR_CTRL,
77 	TT3650_CMD_CI_RD_ATTR,
78 	TT3650_CMD_CI_WR_ATTR,
79 	TT3650_CMD_CI_RESET,
80 	TT3650_CMD_CI_SET_VIDEO_PORT
81 };
82 
83 
84 static struct stb0899_postproc pctv45e_postproc[] = {
85 	{ PCTV_LED_GPIO, STB0899_GPIOPULLUP },
86 	{ 0, 0 }
87 };
88 
89 static struct isl6423_config pctv452e_isl6423_config = {
90 	.current_max		= SEC_CURRENT_515m,
91 	.curlim			= SEC_CURRENT_LIM_ON,
92 	.mod_extern		= 1,
93 	.addr			= 0x08,
94 };
95 
96 /*
97  * stores all private variables for communication with the PCTV452e DVB-S2
98  */
99 struct pctv452e_state {
100 	struct dvb_ca_en50221 ca;
101 	struct mutex ca_mutex;
102 
103 	u8 c;	   /* transaction counter, wraps around...  */
104 	u8 initialized; /* set to 1 if 0x15 has been sent */
105 	u16 last_rc_key;
106 };
107 
108 static int tt3650_ci_msg(struct dvb_usb_device *d, u8 cmd, u8 *data,
109 			 unsigned int write_len, unsigned int read_len)
110 {
111 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
112 	u8 *buf;
113 	u8 id;
114 	unsigned int rlen;
115 	int ret;
116 
117 	if (!data || (write_len > 64 - 4) || (read_len > 64 - 4)) {
118 		err("%s: transfer data invalid", __func__);
119 		return -EIO;
120 	}
121 
122 	buf = kmalloc(64, GFP_KERNEL);
123 	if (!buf)
124 		return -ENOMEM;
125 
126 	id = state->c++;
127 
128 	buf[0] = SYNC_BYTE_OUT;
129 	buf[1] = id;
130 	buf[2] = cmd;
131 	buf[3] = write_len;
132 
133 	memcpy(buf + 4, data, write_len);
134 
135 	rlen = (read_len > 0) ? 64 : 0;
136 	ret = dvb_usb_generic_rw(d, buf, 4 + write_len,
137 				  buf, rlen, /* delay_ms */ 0);
138 	if (0 != ret)
139 		goto failed;
140 
141 	ret = -EIO;
142 	if (SYNC_BYTE_IN != buf[0] || id != buf[1])
143 		goto failed;
144 
145 	memcpy(data, buf + 4, read_len);
146 
147 	kfree(buf);
148 	return 0;
149 
150 failed:
151 	err("CI error %d; %02X %02X %02X -> %*ph.",
152 	     ret, SYNC_BYTE_OUT, id, cmd, 3, buf);
153 
154 	kfree(buf);
155 	return ret;
156 }
157 
158 static int tt3650_ci_msg_locked(struct dvb_ca_en50221 *ca,
159 				u8 cmd, u8 *data, unsigned int write_len,
160 				unsigned int read_len)
161 {
162 	struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
163 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
164 	int ret;
165 
166 	mutex_lock(&state->ca_mutex);
167 	ret = tt3650_ci_msg(d, cmd, data, write_len, read_len);
168 	mutex_unlock(&state->ca_mutex);
169 
170 	return ret;
171 }
172 
173 static int tt3650_ci_read_attribute_mem(struct dvb_ca_en50221 *ca,
174 				 int slot, int address)
175 {
176 	u8 buf[3];
177 	int ret;
178 
179 	if (0 != slot)
180 		return -EINVAL;
181 
182 	buf[0] = (address >> 8) & 0x0F;
183 	buf[1] = address;
184 
185 	ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_ATTR, buf, 2, 3);
186 
187 	ci_dbg("%s %04x -> %d 0x%02x",
188 		__func__, address, ret, buf[2]);
189 
190 	if (ret < 0)
191 		return ret;
192 
193 	return buf[2];
194 }
195 
196 static int tt3650_ci_write_attribute_mem(struct dvb_ca_en50221 *ca,
197 				 int slot, int address, u8 value)
198 {
199 	u8 buf[3];
200 
201 	ci_dbg("%s %d 0x%04x 0x%02x",
202 		__func__, slot, address, value);
203 
204 	if (0 != slot)
205 		return -EINVAL;
206 
207 	buf[0] = (address >> 8) & 0x0F;
208 	buf[1] = address;
209 	buf[2] = value;
210 
211 	return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_ATTR, buf, 3, 3);
212 }
213 
214 static int tt3650_ci_read_cam_control(struct dvb_ca_en50221 *ca,
215 				 int			slot,
216 				 u8			address)
217 {
218 	u8 buf[2];
219 	int ret;
220 
221 	if (0 != slot)
222 		return -EINVAL;
223 
224 	buf[0] = address & 3;
225 
226 	ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_CTRL, buf, 1, 2);
227 
228 	ci_dbg("%s 0x%02x -> %d 0x%02x",
229 		__func__, address, ret, buf[1]);
230 
231 	if (ret < 0)
232 		return ret;
233 
234 	return buf[1];
235 }
236 
237 static int tt3650_ci_write_cam_control(struct dvb_ca_en50221 *ca,
238 				 int			slot,
239 				 u8			address,
240 				 u8			value)
241 {
242 	u8 buf[2];
243 
244 	ci_dbg("%s %d 0x%02x 0x%02x",
245 		__func__, slot, address, value);
246 
247 	if (0 != slot)
248 		return -EINVAL;
249 
250 	buf[0] = address;
251 	buf[1] = value;
252 
253 	return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_CTRL, buf, 2, 2);
254 }
255 
256 static int tt3650_ci_set_video_port(struct dvb_ca_en50221 *ca,
257 				 int			slot,
258 				 int			enable)
259 {
260 	u8 buf[1];
261 	int ret;
262 
263 	ci_dbg("%s %d %d", __func__, slot, enable);
264 
265 	if (0 != slot)
266 		return -EINVAL;
267 
268 	enable = !!enable;
269 	buf[0] = enable;
270 
271 	ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1);
272 	if (ret < 0)
273 		return ret;
274 
275 	if (enable != buf[0]) {
276 		err("CI not %sabled.", enable ? "en" : "dis");
277 		return -EIO;
278 	}
279 
280 	return 0;
281 }
282 
283 static int tt3650_ci_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
284 {
285 	return tt3650_ci_set_video_port(ca, slot, /* enable */ 0);
286 }
287 
288 static int tt3650_ci_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
289 {
290 	return tt3650_ci_set_video_port(ca, slot, /* enable */ 1);
291 }
292 
293 static int tt3650_ci_slot_reset(struct dvb_ca_en50221 *ca, int slot)
294 {
295 	struct dvb_usb_device *d = (struct dvb_usb_device *)ca->data;
296 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
297 	u8 buf[1];
298 	int ret;
299 
300 	ci_dbg("%s %d", __func__, slot);
301 
302 	if (0 != slot)
303 		return -EINVAL;
304 
305 	buf[0] = 0;
306 
307 	mutex_lock(&state->ca_mutex);
308 
309 	ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1);
310 	if (0 != ret)
311 		goto failed;
312 
313 	msleep(500);
314 
315 	buf[0] = 1;
316 
317 	ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1);
318 	if (0 != ret)
319 		goto failed;
320 
321 	msleep(500);
322 
323 	buf[0] = 0; /* FTA */
324 
325 	ret = tt3650_ci_msg(d, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1);
326 
327  failed:
328 	mutex_unlock(&state->ca_mutex);
329 
330 	return ret;
331 }
332 
333 static int tt3650_ci_poll_slot_status(struct dvb_ca_en50221 *ca,
334 				 int			slot,
335 				 int			open)
336 {
337 	u8 buf[1];
338 	int ret;
339 
340 	if (0 != slot)
341 		return -EINVAL;
342 
343 	ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_TEST, buf, 0, 1);
344 	if (0 != ret)
345 		return ret;
346 
347 	if (1 == buf[0])
348 		return DVB_CA_EN50221_POLL_CAM_PRESENT |
349 			DVB_CA_EN50221_POLL_CAM_READY;
350 
351 	return 0;
352 
353 }
354 
355 static void tt3650_ci_uninit(struct dvb_usb_device *d)
356 {
357 	struct pctv452e_state *state;
358 
359 	ci_dbg("%s", __func__);
360 
361 	if (NULL == d)
362 		return;
363 
364 	state = (struct pctv452e_state *)d->priv;
365 	if (NULL == state)
366 		return;
367 
368 	if (NULL == state->ca.data)
369 		return;
370 
371 	/* Error ignored. */
372 	tt3650_ci_set_video_port(&state->ca, /* slot */ 0, /* enable */ 0);
373 
374 	dvb_ca_en50221_release(&state->ca);
375 
376 	memset(&state->ca, 0, sizeof(state->ca));
377 }
378 
379 static int tt3650_ci_init(struct dvb_usb_adapter *a)
380 {
381 	struct dvb_usb_device *d = a->dev;
382 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
383 	int ret;
384 
385 	ci_dbg("%s", __func__);
386 
387 	mutex_init(&state->ca_mutex);
388 
389 	state->ca.owner = THIS_MODULE;
390 	state->ca.read_attribute_mem = tt3650_ci_read_attribute_mem;
391 	state->ca.write_attribute_mem = tt3650_ci_write_attribute_mem;
392 	state->ca.read_cam_control = tt3650_ci_read_cam_control;
393 	state->ca.write_cam_control = tt3650_ci_write_cam_control;
394 	state->ca.slot_reset = tt3650_ci_slot_reset;
395 	state->ca.slot_shutdown = tt3650_ci_slot_shutdown;
396 	state->ca.slot_ts_enable = tt3650_ci_slot_ts_enable;
397 	state->ca.poll_slot_status = tt3650_ci_poll_slot_status;
398 	state->ca.data = d;
399 
400 	ret = dvb_ca_en50221_init(&a->dvb_adap,
401 				   &state->ca,
402 				   /* flags */ 0,
403 				   /* n_slots */ 1);
404 	if (0 != ret) {
405 		err("Cannot initialize CI: Error %d.", ret);
406 		memset(&state->ca, 0, sizeof(state->ca));
407 		return ret;
408 	}
409 
410 	info("CI initialized.");
411 
412 	return 0;
413 }
414 
415 #define CMD_BUFFER_SIZE 0x28
416 static int pctv452e_i2c_msg(struct dvb_usb_device *d, u8 addr,
417 				const u8 *snd_buf, u8 snd_len,
418 				u8 *rcv_buf, u8 rcv_len)
419 {
420 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
421 	u8 *buf;
422 	u8 id;
423 	int ret;
424 
425 	buf = kmalloc(64, GFP_KERNEL);
426 	if (!buf)
427 		return -ENOMEM;
428 
429 	id = state->c++;
430 
431 	ret = -EINVAL;
432 	if (snd_len > 64 - 7 || rcv_len > 64 - 7)
433 		goto failed;
434 
435 	buf[0] = SYNC_BYTE_OUT;
436 	buf[1] = id;
437 	buf[2] = PCTV_CMD_I2C;
438 	buf[3] = snd_len + 3;
439 	buf[4] = addr << 1;
440 	buf[5] = snd_len;
441 	buf[6] = rcv_len;
442 
443 	memcpy(buf + 7, snd_buf, snd_len);
444 
445 	ret = dvb_usb_generic_rw(d, buf, 7 + snd_len,
446 				  buf, /* rcv_len */ 64,
447 				  /* delay_ms */ 0);
448 	if (ret < 0)
449 		goto failed;
450 
451 	/* TT USB protocol error. */
452 	ret = -EIO;
453 	if (SYNC_BYTE_IN != buf[0] || id != buf[1])
454 		goto failed;
455 
456 	/* I2C device didn't respond as expected. */
457 	ret = -EREMOTEIO;
458 	if (buf[5] < snd_len || buf[6] < rcv_len)
459 		goto failed;
460 
461 	memcpy(rcv_buf, buf + 7, rcv_len);
462 
463 	kfree(buf);
464 	return rcv_len;
465 
466 failed:
467 	err("I2C error %d; %02X %02X  %02X %02X %02X -> %*ph",
468 	     ret, SYNC_BYTE_OUT, id, addr << 1, snd_len, rcv_len,
469 	     7, buf);
470 
471 	kfree(buf);
472 	return ret;
473 }
474 
475 static int pctv452e_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msg,
476 				int num)
477 {
478 	struct dvb_usb_device *d = i2c_get_adapdata(adapter);
479 	int i;
480 
481 	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
482 		return -EAGAIN;
483 
484 	for (i = 0; i < num; i++) {
485 		u8 addr, snd_len, rcv_len, *snd_buf, *rcv_buf;
486 		int ret;
487 
488 		if (msg[i].flags & I2C_M_RD) {
489 			addr = msg[i].addr;
490 			snd_buf = NULL;
491 			snd_len = 0;
492 			rcv_buf = msg[i].buf;
493 			rcv_len = msg[i].len;
494 		} else {
495 			addr = msg[i].addr;
496 			snd_buf = msg[i].buf;
497 			snd_len = msg[i].len;
498 			rcv_buf = NULL;
499 			rcv_len = 0;
500 		}
501 
502 		ret = pctv452e_i2c_msg(d, addr, snd_buf, snd_len, rcv_buf,
503 					rcv_len);
504 		if (ret < rcv_len)
505 			break;
506 	}
507 
508 	mutex_unlock(&d->i2c_mutex);
509 	return i;
510 }
511 
512 static u32 pctv452e_i2c_func(struct i2c_adapter *adapter)
513 {
514 	return I2C_FUNC_I2C;
515 }
516 
517 static int pctv452e_power_ctrl(struct dvb_usb_device *d, int i)
518 {
519 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
520 	u8 *b0, *rx;
521 	int ret;
522 
523 	info("%s: %d\n", __func__, i);
524 
525 	if (!i)
526 		return 0;
527 
528 	if (state->initialized)
529 		return 0;
530 
531 	b0 = kmalloc(5 + PCTV_ANSWER_LEN, GFP_KERNEL);
532 	if (!b0)
533 		return -ENOMEM;
534 
535 	rx = b0 + 5;
536 
537 	/* hmm where should this should go? */
538 	ret = usb_set_interface(d->udev, 0, ISOC_INTERFACE_ALTERNATIVE);
539 	if (ret != 0)
540 		info("%s: Warning set interface returned: %d\n",
541 			__func__, ret);
542 
543 	/* this is a one-time initialization, don't know where to put */
544 	b0[0] = 0xaa;
545 	b0[1] = state->c++;
546 	b0[2] = PCTV_CMD_RESET;
547 	b0[3] = 1;
548 	b0[4] = 0;
549 	/* reset board */
550 	ret = dvb_usb_generic_rw(d, b0, 5, rx, PCTV_ANSWER_LEN, 0);
551 	if (ret)
552 		goto ret;
553 
554 	b0[1] = state->c++;
555 	b0[4] = 1;
556 	/* reset board (again?) */
557 	ret = dvb_usb_generic_rw(d, b0, 5, rx, PCTV_ANSWER_LEN, 0);
558 	if (ret)
559 		goto ret;
560 
561 	state->initialized = 1;
562 
563 ret:
564 	kfree(b0);
565 	return ret;
566 }
567 
568 static int pctv452e_rc_query(struct dvb_usb_device *d)
569 {
570 	struct pctv452e_state *state = (struct pctv452e_state *)d->priv;
571 	u8 *b, *rx;
572 	int ret, i;
573 	u8 id;
574 
575 	b = kmalloc(CMD_BUFFER_SIZE + PCTV_ANSWER_LEN, GFP_KERNEL);
576 	if (!b)
577 		return -ENOMEM;
578 
579 	rx = b + CMD_BUFFER_SIZE;
580 
581 	id = state->c++;
582 
583 	/* prepare command header  */
584 	b[0] = SYNC_BYTE_OUT;
585 	b[1] = id;
586 	b[2] = PCTV_CMD_IR;
587 	b[3] = 0;
588 
589 	/* send ir request */
590 	ret = dvb_usb_generic_rw(d, b, 4, rx, PCTV_ANSWER_LEN, 0);
591 	if (ret != 0)
592 		goto ret;
593 
594 	if (debug > 3) {
595 		info("%s: read: %2d: %*ph: ", __func__, ret, 3, rx);
596 		for (i = 0; (i < rx[3]) && ((i+3) < PCTV_ANSWER_LEN); i++)
597 			info(" %02x", rx[i+3]);
598 
599 		info("\n");
600 	}
601 
602 	if ((rx[3] == 9) &&  (rx[12] & 0x01)) {
603 		/* got a "press" event */
604 		state->last_rc_key = RC_SCANCODE_RC5(rx[7], rx[6]);
605 		if (debug > 2)
606 			info("%s: cmd=0x%02x sys=0x%02x\n",
607 				__func__, rx[6], rx[7]);
608 
609 		rc_keydown(d->rc_dev, RC_PROTO_RC5, state->last_rc_key, 0);
610 	} else if (state->last_rc_key) {
611 		rc_keyup(d->rc_dev);
612 		state->last_rc_key = 0;
613 	}
614 ret:
615 	kfree(b);
616 	return ret;
617 }
618 
619 static int pctv452e_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
620 {
621 	const u8 mem_addr[] = { 0x1f, 0xcc };
622 	u8 encoded_mac[20];
623 	int ret;
624 
625 	ret = -EAGAIN;
626 	if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
627 		goto failed;
628 
629 	ret = pctv452e_i2c_msg(d, I2C_ADDR_24C16,
630 				mem_addr + 1, /* snd_len */ 1,
631 				encoded_mac, /* rcv_len */ 20);
632 	if (-EREMOTEIO == ret)
633 		/* Caution! A 24C16 interprets 0xA2 0x1F 0xCC as a
634 		   byte write if /WC is low. */
635 		ret = pctv452e_i2c_msg(d, I2C_ADDR_24C64,
636 					mem_addr, 2,
637 					encoded_mac, 20);
638 
639 	mutex_unlock(&d->i2c_mutex);
640 
641 	if (20 != ret)
642 		goto failed;
643 
644 	ret = ttpci_eeprom_decode_mac(mac, encoded_mac);
645 	if (0 != ret)
646 		goto failed;
647 
648 	return 0;
649 
650 failed:
651 	eth_zero_addr(mac);
652 
653 	return ret;
654 }
655 
656 static const struct stb0899_s1_reg pctv452e_init_dev[] = {
657 	{ STB0899_DISCNTRL1,	0x26 },
658 	{ STB0899_DISCNTRL2,	0x80 },
659 	{ STB0899_DISRX_ST0,	0x04 },
660 	{ STB0899_DISRX_ST1,	0x20 },
661 	{ STB0899_DISPARITY,	0x00 },
662 	{ STB0899_DISFIFO,	0x00 },
663 	{ STB0899_DISF22,	0x99 },
664 	{ STB0899_DISF22RX,	0x85 }, /* 0xa8 */
665 	{ STB0899_ACRPRESC,	0x11 },
666 	{ STB0899_ACRDIV1,	0x0a },
667 	{ STB0899_ACRDIV2,	0x05 },
668 	{ STB0899_DACR1	,	0x00 },
669 	{ STB0899_DACR2	,	0x00 },
670 	{ STB0899_OUTCFG,	0x00 },
671 	{ STB0899_MODECFG,	0x00 }, /* Inversion */
672 	{ STB0899_IRQMSK_3,	0xf3 },
673 	{ STB0899_IRQMSK_2,	0xfc },
674 	{ STB0899_IRQMSK_1,	0xff },
675 	{ STB0899_IRQMSK_0,	0xff },
676 	{ STB0899_I2CCFG,	0x88 },
677 	{ STB0899_I2CRPT,	0x58 },
678 	{ STB0899_GPIO00CFG,	0x82 },
679 	{ STB0899_GPIO01CFG,	0x82 }, /* LED: 0x02 green, 0x82 orange */
680 	{ STB0899_GPIO02CFG,	0x82 },
681 	{ STB0899_GPIO03CFG,	0x82 },
682 	{ STB0899_GPIO04CFG,	0x82 },
683 	{ STB0899_GPIO05CFG,	0x82 },
684 	{ STB0899_GPIO06CFG,	0x82 },
685 	{ STB0899_GPIO07CFG,	0x82 },
686 	{ STB0899_GPIO08CFG,	0x82 },
687 	{ STB0899_GPIO09CFG,	0x82 },
688 	{ STB0899_GPIO10CFG,	0x82 },
689 	{ STB0899_GPIO11CFG,	0x82 },
690 	{ STB0899_GPIO12CFG,	0x82 },
691 	{ STB0899_GPIO13CFG,	0x82 },
692 	{ STB0899_GPIO14CFG,	0x82 },
693 	{ STB0899_GPIO15CFG,	0x82 },
694 	{ STB0899_GPIO16CFG,	0x82 },
695 	{ STB0899_GPIO17CFG,	0x82 },
696 	{ STB0899_GPIO18CFG,	0x82 },
697 	{ STB0899_GPIO19CFG,	0x82 },
698 	{ STB0899_GPIO20CFG,	0x82 },
699 	{ STB0899_SDATCFG,	0xb8 },
700 	{ STB0899_SCLTCFG,	0xba },
701 	{ STB0899_AGCRFCFG,	0x1c }, /* 0x11 DVB-S; 0x1c DVB-S2 (1c, rjkm) */
702 	{ STB0899_GPIO22,	0x82 },
703 	{ STB0899_GPIO21,	0x91 },
704 	{ STB0899_DIRCLKCFG,	0x82 },
705 	{ STB0899_CLKOUT27CFG,	0x7e },
706 	{ STB0899_STDBYCFG,	0x82 },
707 	{ STB0899_CS0CFG,	0x82 },
708 	{ STB0899_CS1CFG,	0x82 },
709 	{ STB0899_DISEQCOCFG,	0x20 },
710 	{ STB0899_NCOARSE,	0x15 }, /* 0x15 27Mhz, F/3 198MHz, F/6 108MHz */
711 	{ STB0899_SYNTCTRL,	0x00 }, /* 0x00 CLKI, 0x02 XTALI */
712 	{ STB0899_FILTCTRL,	0x00 },
713 	{ STB0899_SYSCTRL,	0x00 },
714 	{ STB0899_STOPCLK1,	0x20 }, /* orig: 0x00 budget-ci: 0x20 */
715 	{ STB0899_STOPCLK2,	0x00 },
716 	{ STB0899_INTBUFCTRL,	0x0a },
717 	{ STB0899_AGC2I1,	0x00 },
718 	{ STB0899_AGC2I2,	0x00 },
719 	{ STB0899_AGCIQIN,	0x00 },
720 	{ STB0899_TSTRES,	0x40 }, /* rjkm */
721 	{ 0xffff,		0xff },
722 };
723 
724 static const struct stb0899_s1_reg pctv452e_init_s1_demod[] = {
725 	{ STB0899_DEMOD,	0x00 },
726 	{ STB0899_RCOMPC,	0xc9 },
727 	{ STB0899_AGC1CN,	0x01 },
728 	{ STB0899_AGC1REF,	0x10 },
729 	{ STB0899_RTC,		0x23 },
730 	{ STB0899_TMGCFG,	0x4e },
731 	{ STB0899_AGC2REF,	0x34 },
732 	{ STB0899_TLSR,		0x84 },
733 	{ STB0899_CFD,		0xf7 },
734 	{ STB0899_ACLC,		0x87 },
735 	{ STB0899_BCLC,		0x94 },
736 	{ STB0899_EQON,		0x41 },
737 	{ STB0899_LDT,		0xf1 },
738 	{ STB0899_LDT2,		0xe3 },
739 	{ STB0899_EQUALREF,	0xb4 },
740 	{ STB0899_TMGRAMP,	0x10 },
741 	{ STB0899_TMGTHD,	0x30 },
742 	{ STB0899_IDCCOMP,	0xfd },
743 	{ STB0899_QDCCOMP,	0xff },
744 	{ STB0899_POWERI,	0x0c },
745 	{ STB0899_POWERQ,	0x0f },
746 	{ STB0899_RCOMP,	0x6c },
747 	{ STB0899_AGCIQIN,	0x80 },
748 	{ STB0899_AGC2I1,	0x06 },
749 	{ STB0899_AGC2I2,	0x00 },
750 	{ STB0899_TLIR,		0x30 },
751 	{ STB0899_RTF,		0x7f },
752 	{ STB0899_DSTATUS,	0x00 },
753 	{ STB0899_LDI,		0xbc },
754 	{ STB0899_CFRM,		0xea },
755 	{ STB0899_CFRL,		0x31 },
756 	{ STB0899_NIRM,		0x2b },
757 	{ STB0899_NIRL,		0x80 },
758 	{ STB0899_ISYMB,	0x1d },
759 	{ STB0899_QSYMB,	0xa6 },
760 	{ STB0899_SFRH,		0x2f },
761 	{ STB0899_SFRM,		0x68 },
762 	{ STB0899_SFRL,		0x40 },
763 	{ STB0899_SFRUPH,	0x2f },
764 	{ STB0899_SFRUPM,	0x68 },
765 	{ STB0899_SFRUPL,	0x40 },
766 	{ STB0899_EQUAI1,	0x02 },
767 	{ STB0899_EQUAQ1,	0xff },
768 	{ STB0899_EQUAI2,	0x04 },
769 	{ STB0899_EQUAQ2,	0x05 },
770 	{ STB0899_EQUAI3,	0x02 },
771 	{ STB0899_EQUAQ3,	0xfd },
772 	{ STB0899_EQUAI4,	0x03 },
773 	{ STB0899_EQUAQ4,	0x07 },
774 	{ STB0899_EQUAI5,	0x08 },
775 	{ STB0899_EQUAQ5,	0xf5 },
776 	{ STB0899_DSTATUS2,	0x00 },
777 	{ STB0899_VSTATUS,	0x00 },
778 	{ STB0899_VERROR,	0x86 },
779 	{ STB0899_IQSWAP,	0x2a },
780 	{ STB0899_ECNT1M,	0x00 },
781 	{ STB0899_ECNT1L,	0x00 },
782 	{ STB0899_ECNT2M,	0x00 },
783 	{ STB0899_ECNT2L,	0x00 },
784 	{ STB0899_ECNT3M,	0x0a },
785 	{ STB0899_ECNT3L,	0xad },
786 	{ STB0899_FECAUTO1,	0x06 },
787 	{ STB0899_FECM,		0x01 },
788 	{ STB0899_VTH12,	0xb0 },
789 	{ STB0899_VTH23,	0x7a },
790 	{ STB0899_VTH34,	0x58 },
791 	{ STB0899_VTH56,	0x38 },
792 	{ STB0899_VTH67,	0x34 },
793 	{ STB0899_VTH78,	0x24 },
794 	{ STB0899_PRVIT,	0xff },
795 	{ STB0899_VITSYNC,	0x19 },
796 	{ STB0899_RSULC,	0xb1 }, /* DVB = 0xb1, DSS = 0xa1 */
797 	{ STB0899_TSULC,	0x42 },
798 	{ STB0899_RSLLC,	0x41 },
799 	{ STB0899_TSLPL,	0x12 },
800 	{ STB0899_TSCFGH,	0x0c },
801 	{ STB0899_TSCFGM,	0x00 },
802 	{ STB0899_TSCFGL,	0x00 },
803 	{ STB0899_TSOUT,	0x69 }, /* 0x0d for CAM */
804 	{ STB0899_RSSYNCDEL,	0x00 },
805 	{ STB0899_TSINHDELH,	0x02 },
806 	{ STB0899_TSINHDELM,	0x00 },
807 	{ STB0899_TSINHDELL,	0x00 },
808 	{ STB0899_TSLLSTKM,	0x1b },
809 	{ STB0899_TSLLSTKL,	0xb3 },
810 	{ STB0899_TSULSTKM,	0x00 },
811 	{ STB0899_TSULSTKL,	0x00 },
812 	{ STB0899_PCKLENUL,	0xbc },
813 	{ STB0899_PCKLENLL,	0xcc },
814 	{ STB0899_RSPCKLEN,	0xbd },
815 	{ STB0899_TSSTATUS,	0x90 },
816 	{ STB0899_ERRCTRL1,	0xb6 },
817 	{ STB0899_ERRCTRL2,	0x95 },
818 	{ STB0899_ERRCTRL3,	0x8d },
819 	{ STB0899_DMONMSK1,	0x27 },
820 	{ STB0899_DMONMSK0,	0x03 },
821 	{ STB0899_DEMAPVIT,	0x5c },
822 	{ STB0899_PLPARM,	0x19 },
823 	{ STB0899_PDELCTRL,	0x48 },
824 	{ STB0899_PDELCTRL2,	0x00 },
825 	{ STB0899_BBHCTRL1,	0x00 },
826 	{ STB0899_BBHCTRL2,	0x00 },
827 	{ STB0899_HYSTTHRESH,	0x77 },
828 	{ STB0899_MATCSTM,	0x00 },
829 	{ STB0899_MATCSTL,	0x00 },
830 	{ STB0899_UPLCSTM,	0x00 },
831 	{ STB0899_UPLCSTL,	0x00 },
832 	{ STB0899_DFLCSTM,	0x00 },
833 	{ STB0899_DFLCSTL,	0x00 },
834 	{ STB0899_SYNCCST,	0x00 },
835 	{ STB0899_SYNCDCSTM,	0x00 },
836 	{ STB0899_SYNCDCSTL,	0x00 },
837 	{ STB0899_ISI_ENTRY,	0x00 },
838 	{ STB0899_ISI_BIT_EN,	0x00 },
839 	{ STB0899_MATSTRM,	0xf0 },
840 	{ STB0899_MATSTRL,	0x02 },
841 	{ STB0899_UPLSTRM,	0x45 },
842 	{ STB0899_UPLSTRL,	0x60 },
843 	{ STB0899_DFLSTRM,	0xe3 },
844 	{ STB0899_DFLSTRL,	0x00 },
845 	{ STB0899_SYNCSTR,	0x47 },
846 	{ STB0899_SYNCDSTRM,	0x05 },
847 	{ STB0899_SYNCDSTRL,	0x18 },
848 	{ STB0899_CFGPDELSTATUS1, 0x19 },
849 	{ STB0899_CFGPDELSTATUS2, 0x2b },
850 	{ STB0899_BBFERRORM,	0x00 },
851 	{ STB0899_BBFERRORL,	0x01 },
852 	{ STB0899_UPKTERRORM,	0x00 },
853 	{ STB0899_UPKTERRORL,	0x00 },
854 	{ 0xffff,		0xff },
855 };
856 
857 static struct stb0899_config stb0899_config = {
858 	.init_dev	= pctv452e_init_dev,
859 	.init_s2_demod	= stb0899_s2_init_2,
860 	.init_s1_demod	= pctv452e_init_s1_demod,
861 	.init_s2_fec	= stb0899_s2_init_4,
862 	.init_tst	= stb0899_s1_init_5,
863 
864 	.demod_address   = I2C_ADDR_STB0899, /* I2C Address */
865 	.block_sync_mode = STB0899_SYNC_FORCED, /* ? */
866 
867 	.xtal_freq       = 27000000,	 /* Assume Hz ? */
868 	.inversion       = IQ_SWAP_ON,
869 
870 	.lo_clk	  = 76500000,
871 	.hi_clk	  = 99000000,
872 
873 	.ts_output_mode  = 0,	/* Use parallel mode */
874 	.clock_polarity  = 0,
875 	.data_clk_parity = 0,
876 	.fec_mode	= 0,
877 
878 	.esno_ave	    = STB0899_DVBS2_ESNO_AVE,
879 	.esno_quant	  = STB0899_DVBS2_ESNO_QUANT,
880 	.avframes_coarse     = STB0899_DVBS2_AVFRAMES_COARSE,
881 	.avframes_fine       = STB0899_DVBS2_AVFRAMES_FINE,
882 	.miss_threshold      = STB0899_DVBS2_MISS_THRESHOLD,
883 	.uwp_threshold_acq   = STB0899_DVBS2_UWP_THRESHOLD_ACQ,
884 	.uwp_threshold_track = STB0899_DVBS2_UWP_THRESHOLD_TRACK,
885 	.uwp_threshold_sof   = STB0899_DVBS2_UWP_THRESHOLD_SOF,
886 	.sof_search_timeout  = STB0899_DVBS2_SOF_SEARCH_TIMEOUT,
887 
888 	.btr_nco_bits	  = STB0899_DVBS2_BTR_NCO_BITS,
889 	.btr_gain_shift_offset = STB0899_DVBS2_BTR_GAIN_SHIFT_OFFSET,
890 	.crl_nco_bits	  = STB0899_DVBS2_CRL_NCO_BITS,
891 	.ldpc_max_iter	 = STB0899_DVBS2_LDPC_MAX_ITER,
892 
893 	.tuner_get_frequency	= stb6100_get_frequency,
894 	.tuner_set_frequency	= stb6100_set_frequency,
895 	.tuner_set_bandwidth	= stb6100_set_bandwidth,
896 	.tuner_get_bandwidth	= stb6100_get_bandwidth,
897 	.tuner_set_rfsiggain	= NULL,
898 
899 	/* helper for switching LED green/orange */
900 	.postproc = pctv45e_postproc
901 };
902 
903 static struct stb6100_config stb6100_config = {
904 	.tuner_address = I2C_ADDR_STB6100,
905 	.refclock      = 27000000
906 };
907 
908 
909 static struct i2c_algorithm pctv452e_i2c_algo = {
910 	.master_xfer   = pctv452e_i2c_xfer,
911 	.functionality = pctv452e_i2c_func
912 };
913 
914 static int pctv452e_frontend_attach(struct dvb_usb_adapter *a)
915 {
916 	struct usb_device_id *id;
917 
918 	a->fe_adap[0].fe = dvb_attach(stb0899_attach, &stb0899_config,
919 						&a->dev->i2c_adap);
920 	if (!a->fe_adap[0].fe)
921 		return -ENODEV;
922 
923 	id = a->dev->desc->warm_ids[0];
924 	if (id->idVendor == USB_VID_TECHNOTREND &&
925 	    id->idProduct == USB_PID_TECHNOTREND_CONNECT_S2_3650_CI) {
926 		if (dvb_attach(lnbp22_attach,
927 			       a->fe_adap[0].fe,
928 			       &a->dev->i2c_adap) == NULL) {
929 			err("Cannot attach lnbp22\n");
930 		}
931 		/* Error ignored. */
932 		tt3650_ci_init(a);
933 	} else if (dvb_attach(isl6423_attach,
934 			      a->fe_adap[0].fe,
935 			      &a->dev->i2c_adap,
936 			      &pctv452e_isl6423_config) == NULL) {
937 		err("Cannot attach isl6423\n");
938 	}
939 
940 	return 0;
941 }
942 
943 static int pctv452e_tuner_attach(struct dvb_usb_adapter *a)
944 {
945 	if (!a->fe_adap[0].fe)
946 		return -ENODEV;
947 	if (dvb_attach(stb6100_attach, a->fe_adap[0].fe, &stb6100_config,
948 					&a->dev->i2c_adap) == NULL) {
949 		err("%s failed\n", __func__);
950 		return -ENODEV;
951 	}
952 
953 	return 0;
954 }
955 
956 enum {
957 	PINNACLE_PCTV_452E,
958 	TECHNOTREND_CONNECT_S2_3600,
959 	TECHNOTREND_CONNECT_S2_3650_CI,
960 };
961 
962 static struct usb_device_id pctv452e_usb_table[] = {
963 	DVB_USB_DEV(PINNACLE, PINNACLE_PCTV_452E),
964 	DVB_USB_DEV(TECHNOTREND, TECHNOTREND_CONNECT_S2_3600),
965 	DVB_USB_DEV(TECHNOTREND, TECHNOTREND_CONNECT_S2_3650_CI),
966 	{ }
967 };
968 
969 MODULE_DEVICE_TABLE(usb, pctv452e_usb_table);
970 
971 static struct dvb_usb_device_properties pctv452e_properties = {
972 	.caps = DVB_USB_IS_AN_I2C_ADAPTER, /* more ? */
973 	.usb_ctrl = DEVICE_SPECIFIC,
974 
975 	.size_of_priv     = sizeof(struct pctv452e_state),
976 
977 	.power_ctrl       = pctv452e_power_ctrl,
978 
979 	.rc.core = {
980 		.rc_codes	= RC_MAP_DIB0700_RC5_TABLE,
981 		.allowed_protos	= RC_PROTO_BIT_RC5,
982 		.rc_query	= pctv452e_rc_query,
983 		.rc_interval	= 100,
984 	},
985 
986 	.num_adapters     = 1,
987 	.adapter = {{
988 		.num_frontends = 1,
989 		.fe = {{
990 			.frontend_attach  = pctv452e_frontend_attach,
991 			.tuner_attach     = pctv452e_tuner_attach,
992 
993 			/* parameter for the MPEG2-data transfer */
994 			.stream = {
995 				.type     = USB_ISOC,
996 				.count    = 4,
997 				.endpoint = 0x02,
998 				.u = {
999 					.isoc = {
1000 						.framesperurb = 4,
1001 						.framesize    = 940,
1002 						.interval     = 1
1003 					}
1004 				}
1005 			},
1006 		} },
1007 	} },
1008 
1009 	.i2c_algo = &pctv452e_i2c_algo,
1010 
1011 	.generic_bulk_ctrl_endpoint = 1, /* allow generice rw function */
1012 
1013 	.num_device_descs = 1,
1014 	.devices = {
1015 		{ .name = "PCTV HDTV USB",
1016 		  .cold_ids = { NULL, NULL }, /* this is a warm only device */
1017 		  .warm_ids = { &pctv452e_usb_table[PINNACLE_PCTV_452E], NULL }
1018 		},
1019 		{ NULL },
1020 	}
1021 };
1022 
1023 static struct dvb_usb_device_properties tt_connect_s2_3600_properties = {
1024 	.caps = DVB_USB_IS_AN_I2C_ADAPTER, /* more ? */
1025 	.usb_ctrl = DEVICE_SPECIFIC,
1026 
1027 	.size_of_priv		= sizeof(struct pctv452e_state),
1028 
1029 	.power_ctrl		= pctv452e_power_ctrl,
1030 	.read_mac_address	= pctv452e_read_mac_address,
1031 
1032 	.rc.core = {
1033 		.rc_codes	= RC_MAP_TT_1500,
1034 		.allowed_protos	= RC_PROTO_BIT_RC5,
1035 		.rc_query	= pctv452e_rc_query,
1036 		.rc_interval	= 100,
1037 	},
1038 
1039 	.num_adapters		= 1,
1040 	.adapter = {{
1041 		.num_frontends = 1,
1042 		.fe = {{
1043 			.frontend_attach = pctv452e_frontend_attach,
1044 			.tuner_attach = pctv452e_tuner_attach,
1045 
1046 			/* parameter for the MPEG2-data transfer */
1047 			.stream = {
1048 				.type = USB_ISOC,
1049 				.count = 4,
1050 				.endpoint = 0x02,
1051 				.u = {
1052 					.isoc = {
1053 						.framesperurb = 64,
1054 						.framesize = 940,
1055 						.interval = 1
1056 					}
1057 				}
1058 			},
1059 
1060 		} },
1061 	} },
1062 
1063 	.i2c_algo = &pctv452e_i2c_algo,
1064 
1065 	.generic_bulk_ctrl_endpoint = 1, /* allow generic rw function*/
1066 
1067 	.num_device_descs = 2,
1068 	.devices = {
1069 		{ .name = "Technotrend TT Connect S2-3600",
1070 		  .cold_ids = { NULL, NULL }, /* this is a warm only device */
1071 		  .warm_ids = { &pctv452e_usb_table[TECHNOTREND_CONNECT_S2_3600], NULL }
1072 		},
1073 		{ .name = "Technotrend TT Connect S2-3650-CI",
1074 		  .cold_ids = { NULL, NULL },
1075 		  .warm_ids = { &pctv452e_usb_table[TECHNOTREND_CONNECT_S2_3650_CI], NULL }
1076 		},
1077 		{ NULL },
1078 	}
1079 };
1080 
1081 static void pctv452e_usb_disconnect(struct usb_interface *intf)
1082 {
1083 	struct dvb_usb_device *d = usb_get_intfdata(intf);
1084 
1085 	tt3650_ci_uninit(d);
1086 	dvb_usb_device_exit(intf);
1087 }
1088 
1089 static int pctv452e_usb_probe(struct usb_interface *intf,
1090 				const struct usb_device_id *id)
1091 {
1092 	if (0 == dvb_usb_device_init(intf, &pctv452e_properties,
1093 					THIS_MODULE, NULL, adapter_nr) ||
1094 	    0 == dvb_usb_device_init(intf, &tt_connect_s2_3600_properties,
1095 					THIS_MODULE, NULL, adapter_nr))
1096 		return 0;
1097 
1098 	return -ENODEV;
1099 }
1100 
1101 static struct usb_driver pctv452e_usb_driver = {
1102 	.name       = "pctv452e",
1103 	.probe      = pctv452e_usb_probe,
1104 	.disconnect = pctv452e_usb_disconnect,
1105 	.id_table   = pctv452e_usb_table,
1106 };
1107 
1108 module_usb_driver(pctv452e_usb_driver);
1109 
1110 MODULE_AUTHOR("Dominik Kuhlen <dkuhlen@gmx.net>");
1111 MODULE_AUTHOR("Andre Weidemann <Andre.Weidemann@web.de>");
1112 MODULE_AUTHOR("Michael H. Schimek <mschimek@gmx.at>");
1113 MODULE_DESCRIPTION("Pinnacle PCTV HDTV USB DVB / TT connect S2-3600 Driver");
1114 MODULE_LICENSE("GPL");
1115