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