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