Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/media/usb/dvb-usb/ttusb2.c

  1 /* DVB USB compliant linux driver for Technotrend DVB USB boxes and clones
  2  * (e.g. Pinnacle 400e DVB-S USB2.0).
  3  *
  4  * The Pinnacle 400e uses the same protocol as the Technotrend USB1.1 boxes.
  5  *
  6  * TDA8263 + TDA10086
  7  *
  8  * I2C addresses:
  9  * 0x08 - LNBP21PD   - LNB power supply
 10  * 0x0e - TDA10086   - Demodulator
 11  * 0x50 - FX2 eeprom
 12  * 0x60 - TDA8263    - Tuner
 13  * 0x78 ???
 14  *
 15  * Copyright (c) 2002 Holger Waechtler <holger@convergence.de>
 16  * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net>
 17  * Copyright (C) 2005-6 Patrick Boettcher <pb@linuxtv.org>
 18  *
 19  *      This program is free software; you can redistribute it and/or modify it
 20  *      under the terms of the GNU General Public License as published by the Free
 21  *      Software Foundation, version 2.
 22  *
 23  * see Documentation/dvb/README.dvb-usb for more information
 24  */
 25 #define DVB_USB_LOG_PREFIX "ttusb2"
 26 #include "dvb-usb.h"
 27 
 28 #include "ttusb2.h"
 29 
 30 #include "tda826x.h"
 31 #include "tda10086.h"
 32 #include "tda1002x.h"
 33 #include "tda10048.h"
 34 #include "tda827x.h"
 35 #include "lnbp21.h"
 36 /* CA */
 37 #include "dvb_ca_en50221.h"
 38 
 39 /* debug */
 40 static int dvb_usb_ttusb2_debug;
 41 #define deb_info(args...)   dprintk(dvb_usb_ttusb2_debug,0x01,args)
 42 module_param_named(debug,dvb_usb_ttusb2_debug, int, 0644);
 43 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able))." DVB_USB_DEBUG_STATUS);
 44 static int dvb_usb_ttusb2_debug_ci;
 45 module_param_named(debug_ci,dvb_usb_ttusb2_debug_ci, int, 0644);
 46 MODULE_PARM_DESC(debug_ci, "set debugging ci." DVB_USB_DEBUG_STATUS);
 47 
 48 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
 49 
 50 #define ci_dbg(format, arg...)                \
 51 do {                                          \
 52         if (dvb_usb_ttusb2_debug_ci)                                    \
 53                 printk(KERN_DEBUG DVB_USB_LOG_PREFIX \
 54                         ": %s " format "\n" , __func__, ## arg);       \
 55 } while (0)
 56 
 57 enum {
 58         TT3650_CMD_CI_TEST = 0x40,
 59         TT3650_CMD_CI_RD_CTRL,
 60         TT3650_CMD_CI_WR_CTRL,
 61         TT3650_CMD_CI_RD_ATTR,
 62         TT3650_CMD_CI_WR_ATTR,
 63         TT3650_CMD_CI_RESET,
 64         TT3650_CMD_CI_SET_VIDEO_PORT
 65 };
 66 
 67 struct ttusb2_state {
 68         struct dvb_ca_en50221 ca;
 69         struct mutex ca_mutex;
 70         u8 id;
 71         u16 last_rc_key;
 72 };
 73 
 74 static int ttusb2_msg(struct dvb_usb_device *d, u8 cmd,
 75                 u8 *wbuf, int wlen, u8 *rbuf, int rlen)
 76 {
 77         struct ttusb2_state *st = d->priv;
 78         u8 *s, *r = NULL;
 79         int ret = 0;
 80 
 81         s = kzalloc(wlen+4, GFP_KERNEL);
 82         if (!s)
 83                 return -ENOMEM;
 84 
 85         r = kzalloc(64, GFP_KERNEL);
 86         if (!r) {
 87                 kfree(s);
 88                 return -ENOMEM;
 89         }
 90 
 91         s[0] = 0xaa;
 92         s[1] = ++st->id;
 93         s[2] = cmd;
 94         s[3] = wlen;
 95         memcpy(&s[4],wbuf,wlen);
 96 
 97         ret = dvb_usb_generic_rw(d, s, wlen+4, r, 64, 0);
 98 
 99         if (ret  != 0 ||
100                 r[0] != 0x55 ||
101                 r[1] != s[1] ||
102                 r[2] != cmd ||
103                 (rlen > 0 && r[3] != rlen)) {
104                 warn("there might have been an error during control message transfer. (rlen = %d, was %d)",rlen,r[3]);
105                 kfree(s);
106                 kfree(r);
107                 return -EIO;
108         }
109 
110         if (rlen > 0)
111                 memcpy(rbuf, &r[4], rlen);
112 
113         kfree(s);
114         kfree(r);
115 
116         return 0;
117 }
118 
119 /* ci */
120 static int tt3650_ci_msg(struct dvb_usb_device *d, u8 cmd, u8 *data, unsigned int write_len, unsigned int read_len)
121 {
122         int ret;
123         u8 rx[60];/* (64 -4) */
124         ret = ttusb2_msg(d, cmd, data, write_len, rx, read_len);
125         if (!ret)
126                 memcpy(data, rx, read_len);
127         return ret;
128 }
129 
130 static int tt3650_ci_msg_locked(struct dvb_ca_en50221 *ca, u8 cmd, u8 *data, unsigned int write_len, unsigned int read_len)
131 {
132         struct dvb_usb_device *d = ca->data;
133         struct ttusb2_state *state = d->priv;
134         int ret;
135 
136         mutex_lock(&state->ca_mutex);
137         ret = tt3650_ci_msg(d, cmd, data, write_len, read_len);
138         mutex_unlock(&state->ca_mutex);
139 
140         return ret;
141 }
142 
143 static int tt3650_ci_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address)
144 {
145         u8 buf[3];
146         int ret = 0;
147 
148         if (slot)
149                 return -EINVAL;
150 
151         buf[0] = (address >> 8) & 0x0F;
152         buf[1] = address;
153 
154 
155         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_ATTR, buf, 2, 3);
156 
157         ci_dbg("%04x -> %d 0x%02x", address, ret, buf[2]);
158 
159         if (ret < 0)
160                 return ret;
161 
162         return buf[2];
163 }
164 
165 static int tt3650_ci_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value)
166 {
167         u8 buf[3];
168 
169         ci_dbg("%d 0x%04x 0x%02x", slot, address, value);
170 
171         if (slot)
172                 return -EINVAL;
173 
174         buf[0] = (address >> 8) & 0x0F;
175         buf[1] = address;
176         buf[2] = value;
177 
178         return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_ATTR, buf, 3, 3);
179 }
180 
181 static int tt3650_ci_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address)
182 {
183         u8 buf[2];
184         int ret;
185 
186         if (slot)
187                 return -EINVAL;
188 
189         buf[0] = address & 3;
190 
191         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_CTRL, buf, 1, 2);
192 
193         ci_dbg("0x%02x -> %d 0x%02x", address, ret, buf[1]);
194 
195         if (ret < 0)
196                 return ret;
197 
198         return buf[1];
199 }
200 
201 static int tt3650_ci_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value)
202 {
203         u8 buf[2];
204 
205         ci_dbg("%d 0x%02x 0x%02x", slot, address, value);
206 
207         if (slot)
208                 return -EINVAL;
209 
210         buf[0] = address;
211         buf[1] = value;
212 
213         return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_CTRL, buf, 2, 2);
214 }
215 
216 static int tt3650_ci_set_video_port(struct dvb_ca_en50221 *ca, int slot, int enable)
217 {
218         u8 buf[1];
219         int ret;
220 
221         ci_dbg("%d %d", slot, enable);
222 
223         if (slot)
224                 return -EINVAL;
225 
226         buf[0] = enable;
227 
228         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1);
229         if (ret < 0)
230                 return ret;
231 
232         if (enable != buf[0]) {
233                 err("CI not %sabled.", enable ? "en" : "dis");
234                 return -EIO;
235         }
236 
237         return 0;
238 }
239 
240 static int tt3650_ci_slot_shutdown(struct dvb_ca_en50221 *ca, int slot)
241 {
242         return tt3650_ci_set_video_port(ca, slot, 0);
243 }
244 
245 static int tt3650_ci_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot)
246 {
247         return tt3650_ci_set_video_port(ca, slot, 1);
248 }
249 
250 static int tt3650_ci_slot_reset(struct dvb_ca_en50221 *ca, int slot)
251 {
252         struct dvb_usb_device *d = ca->data;
253         struct ttusb2_state *state = d->priv;
254         u8 buf[1];
255         int ret;
256 
257         ci_dbg("%d", slot);
258 
259         if (slot)
260                 return -EINVAL;
261 
262         buf[0] = 0;
263 
264         mutex_lock(&state->ca_mutex);
265 
266         ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1);
267         if (ret)
268                 goto failed;
269 
270         msleep(500);
271 
272         buf[0] = 1;
273 
274         ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1);
275         if (ret)
276                 goto failed;
277 
278         msleep(500);
279 
280         buf[0] = 0; /* FTA */
281 
282         ret = tt3650_ci_msg(d, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1);
283 
284         msleep(1100);
285 
286  failed:
287         mutex_unlock(&state->ca_mutex);
288 
289         return ret;
290 }
291 
292 static int tt3650_ci_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open)
293 {
294         u8 buf[1];
295         int ret;
296 
297         if (slot)
298                 return -EINVAL;
299 
300         ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_TEST, buf, 0, 1);
301         if (ret)
302                 return ret;
303 
304         if (1 == buf[0]) {
305                 return DVB_CA_EN50221_POLL_CAM_PRESENT |
306                         DVB_CA_EN50221_POLL_CAM_READY;
307         }
308         return 0;
309 }
310 
311 static void tt3650_ci_uninit(struct dvb_usb_device *d)
312 {
313         struct ttusb2_state *state;
314 
315         ci_dbg("");
316 
317         if (NULL == d)
318                 return;
319 
320         state = d->priv;
321         if (NULL == state)
322                 return;
323 
324         if (NULL == state->ca.data)
325                 return;
326 
327         dvb_ca_en50221_release(&state->ca);
328 
329         memset(&state->ca, 0, sizeof(state->ca));
330 }
331 
332 static int tt3650_ci_init(struct dvb_usb_adapter *a)
333 {
334         struct dvb_usb_device *d = a->dev;
335         struct ttusb2_state *state = d->priv;
336         int ret;
337 
338         ci_dbg("");
339 
340         mutex_init(&state->ca_mutex);
341 
342         state->ca.owner = THIS_MODULE;
343         state->ca.read_attribute_mem = tt3650_ci_read_attribute_mem;
344         state->ca.write_attribute_mem = tt3650_ci_write_attribute_mem;
345         state->ca.read_cam_control = tt3650_ci_read_cam_control;
346         state->ca.write_cam_control = tt3650_ci_write_cam_control;
347         state->ca.slot_reset = tt3650_ci_slot_reset;
348         state->ca.slot_shutdown = tt3650_ci_slot_shutdown;
349         state->ca.slot_ts_enable = tt3650_ci_slot_ts_enable;
350         state->ca.poll_slot_status = tt3650_ci_poll_slot_status;
351         state->ca.data = d;
352 
353         ret = dvb_ca_en50221_init(&a->dvb_adap,
354                                   &state->ca,
355                                   /* flags */ 0,
356                                   /* n_slots */ 1);
357         if (ret) {
358                 err("Cannot initialize CI: Error %d.", ret);
359                 memset(&state->ca, 0, sizeof(state->ca));
360                 return ret;
361         }
362 
363         info("CI initialized.");
364 
365         return 0;
366 }
367 
368 static int ttusb2_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
369 {
370         struct dvb_usb_device *d = i2c_get_adapdata(adap);
371         static u8 obuf[60], ibuf[60];
372         int i, write_read, read;
373 
374         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
375                 return -EAGAIN;
376 
377         if (num > 2)
378                 warn("more than 2 i2c messages at a time is not handled yet. TODO.");
379 
380         for (i = 0; i < num; i++) {
381                 write_read = i+1 < num && (msg[i+1].flags & I2C_M_RD);
382                 read = msg[i].flags & I2C_M_RD;
383 
384                 obuf[0] = (msg[i].addr << 1) | (write_read | read);
385                 if (read)
386                         obuf[1] = 0;
387                 else
388                         obuf[1] = msg[i].len;
389 
390                 /* read request */
391                 if (write_read)
392                         obuf[2] = msg[i+1].len;
393                 else if (read)
394                         obuf[2] = msg[i].len;
395                 else
396                         obuf[2] = 0;
397 
398                 memcpy(&obuf[3], msg[i].buf, msg[i].len);
399 
400                 if (ttusb2_msg(d, CMD_I2C_XFER, obuf, obuf[1]+3, ibuf, obuf[2] + 3) < 0) {
401                         err("i2c transfer failed.");
402                         break;
403                 }
404 
405                 if (write_read) {
406                         memcpy(msg[i+1].buf, &ibuf[3], msg[i+1].len);
407                         i++;
408                 } else if (read)
409                         memcpy(msg[i].buf, &ibuf[3], msg[i].len);
410         }
411 
412         mutex_unlock(&d->i2c_mutex);
413         return i;
414 }
415 
416 static u32 ttusb2_i2c_func(struct i2c_adapter *adapter)
417 {
418         return I2C_FUNC_I2C;
419 }
420 
421 static struct i2c_algorithm ttusb2_i2c_algo = {
422         .master_xfer   = ttusb2_i2c_xfer,
423         .functionality = ttusb2_i2c_func,
424 };
425 
426 /* command to poll IR receiver (copied from pctv452e.c) */
427 #define CMD_GET_IR_CODE     0x1b
428 
429 /* IR */
430 static int tt3650_rc_query(struct dvb_usb_device *d)
431 {
432         int ret;
433         u8 rx[9]; /* A CMD_GET_IR_CODE reply is 9 bytes long */
434         struct ttusb2_state *st = d->priv;
435         ret = ttusb2_msg(d, CMD_GET_IR_CODE, NULL, 0, rx, sizeof(rx));
436         if (ret != 0)
437                 return ret;
438 
439         if (rx[8] & 0x01) {
440                 /* got a "press" event */
441                 st->last_rc_key = RC_SCANCODE_RC5(rx[3], rx[2]);
442                 deb_info("%s: cmd=0x%02x sys=0x%02x\n", __func__, rx[2], rx[3]);
443                 rc_keydown(d->rc_dev, RC_TYPE_RC5, st->last_rc_key, rx[1]);
444         } else if (st->last_rc_key) {
445                 rc_keyup(d->rc_dev);
446                 st->last_rc_key = 0;
447         }
448 
449         return 0;
450 }
451 
452 
453 /* Callbacks for DVB USB */
454 static int ttusb2_identify_state (struct usb_device *udev, struct
455                 dvb_usb_device_properties *props, struct dvb_usb_device_description **desc,
456                 int *cold)
457 {
458         *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0;
459         return 0;
460 }
461 
462 static int ttusb2_power_ctrl(struct dvb_usb_device *d, int onoff)
463 {
464         u8 b = onoff;
465         ttusb2_msg(d, CMD_POWER, &b, 0, NULL, 0);
466         return ttusb2_msg(d, CMD_POWER, &b, 1, NULL, 0);
467 }
468 
469 
470 static struct tda10086_config tda10086_config = {
471         .demod_address = 0x0e,
472         .invert = 0,
473         .diseqc_tone = 1,
474         .xtal_freq = TDA10086_XTAL_16M,
475 };
476 
477 static struct tda10023_config tda10023_config = {
478         .demod_address = 0x0c,
479         .invert = 0,
480         .xtal = 16000000,
481         .pll_m = 11,
482         .pll_p = 3,
483         .pll_n = 1,
484         .deltaf = 0xa511,
485 };
486 
487 static struct tda10048_config tda10048_config = {
488         .demod_address    = 0x10 >> 1,
489         .output_mode      = TDA10048_PARALLEL_OUTPUT,
490         .inversion        = TDA10048_INVERSION_ON,
491         .dtv6_if_freq_khz = TDA10048_IF_4000,
492         .dtv7_if_freq_khz = TDA10048_IF_4500,
493         .dtv8_if_freq_khz = TDA10048_IF_5000,
494         .clk_freq_khz     = TDA10048_CLK_16000,
495         .no_firmware      = 1,
496         .set_pll          = true ,
497         .pll_m            = 5,
498         .pll_n            = 3,
499         .pll_p            = 0,
500 };
501 
502 static struct tda827x_config tda827x_config = {
503         .config = 0,
504 };
505 
506 static int ttusb2_frontend_tda10086_attach(struct dvb_usb_adapter *adap)
507 {
508         if (usb_set_interface(adap->dev->udev,0,3) < 0)
509                 err("set interface to alts=3 failed");
510 
511         if ((adap->fe_adap[0].fe = dvb_attach(tda10086_attach, &tda10086_config, &adap->dev->i2c_adap)) == NULL) {
512                 deb_info("TDA10086 attach failed\n");
513                 return -ENODEV;
514         }
515 
516         return 0;
517 }
518 
519 static int ttusb2_ct3650_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
520 {
521         struct dvb_usb_adapter *adap = fe->dvb->priv;
522 
523         return adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, enable);
524 }
525 
526 static int ttusb2_frontend_tda10023_attach(struct dvb_usb_adapter *adap)
527 {
528         if (usb_set_interface(adap->dev->udev, 0, 3) < 0)
529                 err("set interface to alts=3 failed");
530 
531         if (adap->fe_adap[0].fe == NULL) {
532                 /* FE 0 DVB-C */
533                 adap->fe_adap[0].fe = dvb_attach(tda10023_attach,
534                         &tda10023_config, &adap->dev->i2c_adap, 0x48);
535 
536                 if (adap->fe_adap[0].fe == NULL) {
537                         deb_info("TDA10023 attach failed\n");
538                         return -ENODEV;
539                 }
540                 tt3650_ci_init(adap);
541         } else {
542                 adap->fe_adap[1].fe = dvb_attach(tda10048_attach,
543                         &tda10048_config, &adap->dev->i2c_adap);
544 
545                 if (adap->fe_adap[1].fe == NULL) {
546                         deb_info("TDA10048 attach failed\n");
547                         return -ENODEV;
548                 }
549 
550                 /* tuner is behind TDA10023 I2C-gate */
551                 adap->fe_adap[1].fe->ops.i2c_gate_ctrl = ttusb2_ct3650_i2c_gate_ctrl;
552 
553         }
554 
555         return 0;
556 }
557 
558 static int ttusb2_tuner_tda827x_attach(struct dvb_usb_adapter *adap)
559 {
560         struct dvb_frontend *fe;
561 
562         /* MFE: select correct FE to attach tuner since that's called twice */
563         if (adap->fe_adap[1].fe == NULL)
564                 fe = adap->fe_adap[0].fe;
565         else
566                 fe = adap->fe_adap[1].fe;
567 
568         /* attach tuner */
569         if (dvb_attach(tda827x_attach, fe, 0x61, &adap->dev->i2c_adap, &tda827x_config) == NULL) {
570                 printk(KERN_ERR "%s: No tda827x found!\n", __func__);
571                 return -ENODEV;
572         }
573         return 0;
574 }
575 
576 static int ttusb2_tuner_tda826x_attach(struct dvb_usb_adapter *adap)
577 {
578         if (dvb_attach(tda826x_attach, adap->fe_adap[0].fe, 0x60, &adap->dev->i2c_adap, 0) == NULL) {
579                 deb_info("TDA8263 attach failed\n");
580                 return -ENODEV;
581         }
582 
583         if (dvb_attach(lnbp21_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap, 0, 0) == NULL) {
584                 deb_info("LNBP21 attach failed\n");
585                 return -ENODEV;
586         }
587         return 0;
588 }
589 
590 /* DVB USB Driver stuff */
591 static struct dvb_usb_device_properties ttusb2_properties;
592 static struct dvb_usb_device_properties ttusb2_properties_s2400;
593 static struct dvb_usb_device_properties ttusb2_properties_ct3650;
594 
595 static void ttusb2_usb_disconnect(struct usb_interface *intf)
596 {
597         struct dvb_usb_device *d = usb_get_intfdata(intf);
598 
599         tt3650_ci_uninit(d);
600         dvb_usb_device_exit(intf);
601 }
602 
603 static int ttusb2_probe(struct usb_interface *intf,
604                 const struct usb_device_id *id)
605 {
606         if (0 == dvb_usb_device_init(intf, &ttusb2_properties,
607                                      THIS_MODULE, NULL, adapter_nr) ||
608             0 == dvb_usb_device_init(intf, &ttusb2_properties_s2400,
609                                      THIS_MODULE, NULL, adapter_nr) ||
610             0 == dvb_usb_device_init(intf, &ttusb2_properties_ct3650,
611                                      THIS_MODULE, NULL, adapter_nr))
612                 return 0;
613         return -ENODEV;
614 }
615 
616 static struct usb_device_id ttusb2_table [] = {
617         { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_400E) },
618         { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_450E) },
619         { USB_DEVICE(USB_VID_TECHNOTREND,
620                 USB_PID_TECHNOTREND_CONNECT_S2400) },
621         { USB_DEVICE(USB_VID_TECHNOTREND,
622                 USB_PID_TECHNOTREND_CONNECT_CT3650) },
623         { USB_DEVICE(USB_VID_TECHNOTREND,
624                 USB_PID_TECHNOTREND_CONNECT_S2400_8KEEPROM) },
625         {}              /* Terminating entry */
626 };
627 MODULE_DEVICE_TABLE (usb, ttusb2_table);
628 
629 static struct dvb_usb_device_properties ttusb2_properties = {
630         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
631 
632         .usb_ctrl = CYPRESS_FX2,
633         .firmware = "dvb-usb-pctv-400e-01.fw",
634 
635         .size_of_priv = sizeof(struct ttusb2_state),
636 
637         .num_adapters = 1,
638         .adapter = {
639                 {
640                 .num_frontends = 1,
641                 .fe = {{
642                         .streaming_ctrl   = NULL, // ttusb2_streaming_ctrl,
643 
644                         .frontend_attach  = ttusb2_frontend_tda10086_attach,
645                         .tuner_attach     = ttusb2_tuner_tda826x_attach,
646 
647                         /* parameter for the MPEG2-data transfer */
648                         .stream = {
649                                 .type = USB_ISOC,
650                                 .count = 5,
651                                 .endpoint = 0x02,
652                                 .u = {
653                                         .isoc = {
654                                                 .framesperurb = 4,
655                                                 .framesize = 940,
656                                                 .interval = 1,
657                                         }
658                                 }
659                         }
660                 }},
661                 }
662         },
663 
664         .power_ctrl       = ttusb2_power_ctrl,
665         .identify_state   = ttusb2_identify_state,
666 
667         .i2c_algo         = &ttusb2_i2c_algo,
668 
669         .generic_bulk_ctrl_endpoint = 0x01,
670 
671         .num_device_descs = 2,
672         .devices = {
673                 {   "Pinnacle 400e DVB-S USB2.0",
674                         { &ttusb2_table[0], NULL },
675                         { NULL },
676                 },
677                 {   "Pinnacle 450e DVB-S USB2.0",
678                         { &ttusb2_table[1], NULL },
679                         { NULL },
680                 },
681         }
682 };
683 
684 static struct dvb_usb_device_properties ttusb2_properties_s2400 = {
685         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
686 
687         .usb_ctrl = CYPRESS_FX2,
688         .firmware = "dvb-usb-tt-s2400-01.fw",
689 
690         .size_of_priv = sizeof(struct ttusb2_state),
691 
692         .num_adapters = 1,
693         .adapter = {
694                 {
695                 .num_frontends = 1,
696                 .fe = {{
697                         .streaming_ctrl   = NULL,
698 
699                         .frontend_attach  = ttusb2_frontend_tda10086_attach,
700                         .tuner_attach     = ttusb2_tuner_tda826x_attach,
701 
702                         /* parameter for the MPEG2-data transfer */
703                         .stream = {
704                                 .type = USB_ISOC,
705                                 .count = 5,
706                                 .endpoint = 0x02,
707                                 .u = {
708                                         .isoc = {
709                                                 .framesperurb = 4,
710                                                 .framesize = 940,
711                                                 .interval = 1,
712                                         }
713                                 }
714                         }
715                 }},
716                 }
717         },
718 
719         .power_ctrl       = ttusb2_power_ctrl,
720         .identify_state   = ttusb2_identify_state,
721 
722         .i2c_algo         = &ttusb2_i2c_algo,
723 
724         .generic_bulk_ctrl_endpoint = 0x01,
725 
726         .num_device_descs = 2,
727         .devices = {
728                 {   "Technotrend TT-connect S-2400",
729                         { &ttusb2_table[2], NULL },
730                         { NULL },
731                 },
732                 {   "Technotrend TT-connect S-2400 (8kB EEPROM)",
733                         { &ttusb2_table[4], NULL },
734                         { NULL },
735                 },
736         }
737 };
738 
739 static struct dvb_usb_device_properties ttusb2_properties_ct3650 = {
740         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
741 
742         .usb_ctrl = CYPRESS_FX2,
743 
744         .size_of_priv = sizeof(struct ttusb2_state),
745 
746         .rc.core = {
747                 .rc_interval      = 150, /* Less than IR_KEYPRESS_TIMEOUT */
748                 .rc_codes         = RC_MAP_TT_1500,
749                 .rc_query         = tt3650_rc_query,
750                 .allowed_protos   = RC_BIT_RC5,
751         },
752 
753         .num_adapters = 1,
754         .adapter = {
755                 {
756                 .num_frontends = 2,
757                 .fe = {{
758                         .streaming_ctrl   = NULL,
759 
760                         .frontend_attach  = ttusb2_frontend_tda10023_attach,
761                         .tuner_attach = ttusb2_tuner_tda827x_attach,
762 
763                         /* parameter for the MPEG2-data transfer */
764                         .stream = {
765                                 .type = USB_ISOC,
766                                 .count = 5,
767                                 .endpoint = 0x02,
768                                 .u = {
769                                         .isoc = {
770                                                 .framesperurb = 4,
771                                                 .framesize = 940,
772                                                 .interval = 1,
773                                         }
774                                 }
775                         }
776                 }, {
777                         .streaming_ctrl   = NULL,
778 
779                         .frontend_attach  = ttusb2_frontend_tda10023_attach,
780                         .tuner_attach = ttusb2_tuner_tda827x_attach,
781 
782                         /* parameter for the MPEG2-data transfer */
783                         .stream = {
784                                 .type = USB_ISOC,
785                                 .count = 5,
786                                 .endpoint = 0x02,
787                                 .u = {
788                                         .isoc = {
789                                                 .framesperurb = 4,
790                                                 .framesize = 940,
791                                                 .interval = 1,
792                                         }
793                                 }
794                         }
795                 }},
796                 },
797         },
798 
799         .power_ctrl       = ttusb2_power_ctrl,
800         .identify_state   = ttusb2_identify_state,
801 
802         .i2c_algo         = &ttusb2_i2c_algo,
803 
804         .generic_bulk_ctrl_endpoint = 0x01,
805 
806         .num_device_descs = 1,
807         .devices = {
808                 {   "Technotrend TT-connect CT-3650",
809                         .warm_ids = { &ttusb2_table[3], NULL },
810                 },
811         }
812 };
813 
814 static struct usb_driver ttusb2_driver = {
815         .name           = "dvb_usb_ttusb2",
816         .probe          = ttusb2_probe,
817         .disconnect     = ttusb2_usb_disconnect,
818         .id_table       = ttusb2_table,
819 };
820 
821 module_usb_driver(ttusb2_driver);
822 
823 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
824 MODULE_DESCRIPTION("Driver for Pinnacle PCTV 400e DVB-S USB2.0");
825 MODULE_VERSION("1.0");
826 MODULE_LICENSE("GPL");
827 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us