2 * TerraTec Cinergy T²/qanu USB2 DVB-T adapter.
4 * Copyright (C) 2004 Daniel Mack <daniel@qanu.de> and
5 * Holger Waechtler <holger@qanu.de>
7 * Protocol Spec published on http://qanu.de/specs/terratec_cinergyT2.pdf
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/config.h>
26 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/slab.h>
29 #include <linux/usb.h>
30 #include <linux/pci.h>
31 #include <linux/input.h>
32 #include <linux/dvb/frontend.h>
35 #include "dvb_demux.h"
38 #ifdef CONFIG_DVB_CINERGYT2_TUNING
39 #define STREAM_URB_COUNT (CONFIG_DVB_CINERGYT2_STREAM_URB_COUNT)
40 #define STREAM_BUF_SIZE (CONFIG_DVB_CINERGYT2_STREAM_BUF_SIZE)
41 #define QUERY_INTERVAL (CONFIG_DVB_CINERGYT2_QUERY_INTERVAL)
42 #ifdef CONFIG_DVB_CINERGYT2_ENABLE_RC_INPUT_DEVICE
43 #define RC_QUERY_INTERVAL (CONFIG_DVB_CINERGYT2_RC_QUERY_INTERVAL)
47 #define STREAM_URB_COUNT (32)
48 #define STREAM_BUF_SIZE (512) /* bytes */
50 #define RC_QUERY_INTERVAL (50) /* milliseconds */
51 #define QUERY_INTERVAL (333) /* milliseconds */
54 #define DRIVER_NAME "TerraTec/qanu USB2.0 Highspeed DVB-T Receiver"
57 module_param_named(debug
, debug
, int, 0644);
58 MODULE_PARM_DESC(debug
, "Turn on/off debugging (default:off).");
60 #define dprintk(level, args...) \
62 if ((debug & level)) { \
63 printk("%s: %s(): ", __stringify(KBUILD_MODNAME), \
68 enum cinergyt2_ep1_cmd
{
69 CINERGYT2_EP1_PID_TABLE_RESET
= 0x01,
70 CINERGYT2_EP1_PID_SETUP
= 0x02,
71 CINERGYT2_EP1_CONTROL_STREAM_TRANSFER
= 0x03,
72 CINERGYT2_EP1_SET_TUNER_PARAMETERS
= 0x04,
73 CINERGYT2_EP1_GET_TUNER_STATUS
= 0x05,
74 CINERGYT2_EP1_START_SCAN
= 0x06,
75 CINERGYT2_EP1_CONTINUE_SCAN
= 0x07,
76 CINERGYT2_EP1_GET_RC_EVENTS
= 0x08,
77 CINERGYT2_EP1_SLEEP_MODE
= 0x09
80 struct dvbt_set_parameters_msg
{
86 } __attribute__((packed
));
88 struct dvbt_get_status_msg
{
95 uint32_t viterbi_error_rate
;
96 uint32_t rs_error_rate
;
97 uint32_t uncorrected_block_count
;
99 uint8_t prev_lock_bits
;
100 } __attribute__((packed
));
102 static struct dvb_frontend_info cinergyt2_fe_info
= {
105 .frequency_min
= 174000000,
106 .frequency_max
= 862000000,
107 .frequency_stepsize
= 166667,
108 .caps
= FE_CAN_INVERSION_AUTO
| FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
|
109 FE_CAN_FEC_3_4
| FE_CAN_FEC_5_6
| FE_CAN_FEC_7_8
|
111 FE_CAN_QPSK
| FE_CAN_QAM_16
| FE_CAN_QAM_64
| FE_CAN_QAM_AUTO
|
112 FE_CAN_TRANSMISSION_MODE_AUTO
| FE_CAN_GUARD_INTERVAL_AUTO
|
113 FE_CAN_HIERARCHY_AUTO
| FE_CAN_RECOVER
| FE_CAN_MUTE_TS
117 struct dvb_demux demux
;
118 struct usb_device
*udev
;
119 struct semaphore sem
;
120 struct dvb_adapter adapter
;
121 struct dvb_device
*fedev
;
122 struct dmxdev dmxdev
;
123 struct dvb_net dvbnet
;
128 struct dvbt_set_parameters_msg param
;
129 struct dvbt_get_status_msg status
;
130 struct work_struct query_work
;
132 wait_queue_head_t poll_wq
;
133 int pending_fe_events
;
136 dma_addr_t streambuf_dmahandle
;
137 struct urb
*stream_urb
[STREAM_URB_COUNT
];
140 struct input_dev
*rc_input_dev
;
142 struct work_struct rc_query_work
;
145 unsigned long last_event_jiffies
;
150 CINERGYT2_RC_EVENT_TYPE_NONE
= 0x00,
151 CINERGYT2_RC_EVENT_TYPE_NEC
= 0x01,
152 CINERGYT2_RC_EVENT_TYPE_RC5
= 0x02
155 struct cinergyt2_rc_event
{
158 } __attribute__((packed
));
160 static const uint32_t rc_keys
[] = {
161 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfe01eb04, KEY_POWER
,
162 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfd02eb04, KEY_1
,
163 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfc03eb04, KEY_2
,
164 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfb04eb04, KEY_3
,
165 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfa05eb04, KEY_4
,
166 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf906eb04, KEY_5
,
167 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf807eb04, KEY_6
,
168 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf708eb04, KEY_7
,
169 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf609eb04, KEY_8
,
170 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf50aeb04, KEY_9
,
171 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf30ceb04, KEY_0
,
172 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf40beb04, KEY_VIDEO
,
173 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf20deb04, KEY_REFRESH
,
174 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf10eeb04, KEY_SELECT
,
175 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf00feb04, KEY_EPG
,
176 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xef10eb04, KEY_UP
,
177 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xeb14eb04, KEY_DOWN
,
178 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xee11eb04, KEY_LEFT
,
179 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xec13eb04, KEY_RIGHT
,
180 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xed12eb04, KEY_OK
,
181 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xea15eb04, KEY_TEXT
,
182 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe916eb04, KEY_INFO
,
183 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe817eb04, KEY_RED
,
184 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe718eb04, KEY_GREEN
,
185 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe619eb04, KEY_YELLOW
,
186 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe51aeb04, KEY_BLUE
,
187 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe31ceb04, KEY_VOLUMEUP
,
188 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe11eeb04, KEY_VOLUMEDOWN
,
189 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe21deb04, KEY_MUTE
,
190 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe41beb04, KEY_CHANNELUP
,
191 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe01feb04, KEY_CHANNELDOWN
,
192 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xbf40eb04, KEY_PAUSE
,
193 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xb34ceb04, KEY_PLAY
,
194 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xa758eb04, KEY_RECORD
,
195 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xab54eb04, KEY_PREVIOUS
,
196 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xb748eb04, KEY_STOP
,
197 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xa35ceb04, KEY_NEXT
200 static int cinergyt2_command (struct cinergyt2
*cinergyt2
,
201 char *send_buf
, int send_buf_len
,
202 char *recv_buf
, int recv_buf_len
)
208 ret
= usb_bulk_msg(cinergyt2
->udev
, usb_sndbulkpipe(cinergyt2
->udev
, 1),
209 send_buf
, send_buf_len
, &actual_len
, 1000);
212 dprintk(1, "usb_bulk_msg (send) failed, err %i\n", ret
);
217 ret
= usb_bulk_msg(cinergyt2
->udev
, usb_rcvbulkpipe(cinergyt2
->udev
, 1),
218 recv_buf
, recv_buf_len
, &actual_len
, 1000);
221 dprintk(1, "usb_bulk_msg (read) failed, err %i\n", ret
);
223 return ret
? ret
: actual_len
;
226 static void cinergyt2_control_stream_transfer (struct cinergyt2
*cinergyt2
, int enable
)
228 char buf
[] = { CINERGYT2_EP1_CONTROL_STREAM_TRANSFER
, enable
? 1 : 0 };
229 cinergyt2_command(cinergyt2
, buf
, sizeof(buf
), NULL
, 0);
232 static void cinergyt2_sleep (struct cinergyt2
*cinergyt2
, int sleep
)
234 char buf
[] = { CINERGYT2_EP1_SLEEP_MODE
, sleep
? 1 : 0 };
235 cinergyt2_command(cinergyt2
, buf
, sizeof(buf
), NULL
, 0);
236 cinergyt2
->sleeping
= sleep
;
239 static void cinergyt2_stream_irq (struct urb
*urb
, struct pt_regs
*regs
);
241 static int cinergyt2_submit_stream_urb (struct cinergyt2
*cinergyt2
, struct urb
*urb
)
245 usb_fill_bulk_urb(urb
,
247 usb_rcvbulkpipe(cinergyt2
->udev
, 0x2),
248 urb
->transfer_buffer
,
250 cinergyt2_stream_irq
,
253 if ((err
= usb_submit_urb(urb
, GFP_ATOMIC
)))
254 dprintk(1, "urb submission failed (err = %i)!\n", err
);
259 static void cinergyt2_stream_irq (struct urb
*urb
, struct pt_regs
*regs
)
261 struct cinergyt2
*cinergyt2
= urb
->context
;
263 if (urb
->actual_length
> 0)
264 dvb_dmx_swfilter(&cinergyt2
->demux
,
265 urb
->transfer_buffer
, urb
->actual_length
);
267 if (cinergyt2
->streaming
)
268 cinergyt2_submit_stream_urb(cinergyt2
, urb
);
271 static void cinergyt2_free_stream_urbs (struct cinergyt2
*cinergyt2
)
275 for (i
=0; i
<STREAM_URB_COUNT
; i
++)
276 if (cinergyt2
->stream_urb
[i
])
277 usb_free_urb(cinergyt2
->stream_urb
[i
]);
279 usb_buffer_free(cinergyt2
->udev
, STREAM_URB_COUNT
*STREAM_BUF_SIZE
,
280 cinergyt2
->streambuf
, cinergyt2
->streambuf_dmahandle
);
283 static int cinergyt2_alloc_stream_urbs (struct cinergyt2
*cinergyt2
)
287 cinergyt2
->streambuf
= usb_buffer_alloc(cinergyt2
->udev
, STREAM_URB_COUNT
*STREAM_BUF_SIZE
,
288 SLAB_KERNEL
, &cinergyt2
->streambuf_dmahandle
);
289 if (!cinergyt2
->streambuf
) {
290 dprintk(1, "failed to alloc consistent stream memory area, bailing out!\n");
294 memset(cinergyt2
->streambuf
, 0, STREAM_URB_COUNT
*STREAM_BUF_SIZE
);
296 for (i
=0; i
<STREAM_URB_COUNT
; i
++) {
299 if (!(urb
= usb_alloc_urb(0, GFP_ATOMIC
))) {
300 dprintk(1, "failed to alloc consistent stream urbs, bailing out!\n");
301 cinergyt2_free_stream_urbs(cinergyt2
);
305 urb
->transfer_buffer
= cinergyt2
->streambuf
+ i
* STREAM_BUF_SIZE
;
306 urb
->transfer_buffer_length
= STREAM_BUF_SIZE
;
308 cinergyt2
->stream_urb
[i
] = urb
;
314 static void cinergyt2_stop_stream_xfer (struct cinergyt2
*cinergyt2
)
318 cinergyt2_control_stream_transfer(cinergyt2
, 0);
320 for (i
=0; i
<STREAM_URB_COUNT
; i
++)
321 if (cinergyt2
->stream_urb
[i
])
322 usb_kill_urb(cinergyt2
->stream_urb
[i
]);
325 static int cinergyt2_start_stream_xfer (struct cinergyt2
*cinergyt2
)
329 for (i
=0; i
<STREAM_URB_COUNT
; i
++) {
330 if ((err
= cinergyt2_submit_stream_urb(cinergyt2
, cinergyt2
->stream_urb
[i
]))) {
331 cinergyt2_stop_stream_xfer(cinergyt2
);
332 dprintk(1, "failed urb submission (%i: err = %i)!\n", i
, err
);
337 cinergyt2_control_stream_transfer(cinergyt2
, 1);
341 static int cinergyt2_start_feed(struct dvb_demux_feed
*dvbdmxfeed
)
343 struct dvb_demux
*demux
= dvbdmxfeed
->demux
;
344 struct cinergyt2
*cinergyt2
= demux
->priv
;
346 if (down_interruptible(&cinergyt2
->sem
))
349 if (cinergyt2
->streaming
== 0)
350 cinergyt2_start_stream_xfer(cinergyt2
);
352 cinergyt2
->streaming
++;
357 static int cinergyt2_stop_feed(struct dvb_demux_feed
*dvbdmxfeed
)
359 struct dvb_demux
*demux
= dvbdmxfeed
->demux
;
360 struct cinergyt2
*cinergyt2
= demux
->priv
;
362 if (down_interruptible(&cinergyt2
->sem
))
365 if (--cinergyt2
->streaming
== 0)
366 cinergyt2_stop_stream_xfer(cinergyt2
);
373 * convert linux-dvb frontend parameter set into TPS.
374 * See ETSI ETS-300744, section 4.6.2, table 9 for details.
376 * This function is probably reusable and may better get placed in a support
379 * We replace errornous fields by default TPS fields (the ones with value 0).
381 static uint16_t compute_tps (struct dvb_frontend_parameters
*p
)
383 struct dvb_ofdm_parameters
*op
= &p
->u
.ofdm
;
386 switch (op
->code_rate_HP
) {
402 /* tps |= (0 << 7) */;
405 switch (op
->code_rate_LP
) {
421 /* tps |= (0 << 4) */;
424 switch (op
->constellation
) {
433 /* tps |= (0 << 13) */;
436 switch (op
->transmission_mode
) {
437 case TRANSMISSION_MODE_8K
:
440 case TRANSMISSION_MODE_2K
:
442 /* tps |= (0 << 0) */;
445 switch (op
->guard_interval
) {
446 case GUARD_INTERVAL_1_16
:
449 case GUARD_INTERVAL_1_8
:
452 case GUARD_INTERVAL_1_4
:
455 case GUARD_INTERVAL_1_32
:
457 /* tps |= (0 << 2) */;
460 switch (op
->hierarchy_information
) {
472 /* tps |= (0 << 10) */;
478 static int cinergyt2_open (struct inode
*inode
, struct file
*file
)
480 struct dvb_device
*dvbdev
= file
->private_data
;
481 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
484 if ((err
= dvb_generic_open(inode
, file
)))
487 if (down_interruptible(&cinergyt2
->sem
))
490 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
491 cinergyt2_sleep(cinergyt2
, 0);
492 schedule_delayed_work(&cinergyt2
->query_work
, HZ
/2);
499 static int cinergyt2_release (struct inode
*inode
, struct file
*file
)
501 struct dvb_device
*dvbdev
= file
->private_data
;
502 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
504 if (down_interruptible(&cinergyt2
->sem
))
507 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
508 cancel_delayed_work(&cinergyt2
->query_work
);
509 flush_scheduled_work();
510 cinergyt2_sleep(cinergyt2
, 1);
515 return dvb_generic_release(inode
, file
);
518 static unsigned int cinergyt2_poll (struct file
*file
, struct poll_table_struct
*wait
)
520 struct dvb_device
*dvbdev
= file
->private_data
;
521 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
522 poll_wait(file
, &cinergyt2
->poll_wq
, wait
);
523 return (POLLIN
| POLLRDNORM
| POLLPRI
);
527 static int cinergyt2_ioctl (struct inode
*inode
, struct file
*file
,
528 unsigned cmd
, unsigned long arg
)
530 struct dvb_device
*dvbdev
= file
->private_data
;
531 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
532 struct dvbt_get_status_msg
*stat
= &cinergyt2
->status
;
533 fe_status_t status
= 0;
537 return copy_to_user((void __user
*) arg
, &cinergyt2_fe_info
,
538 sizeof(struct dvb_frontend_info
));
541 if (0xffff - le16_to_cpu(stat
->gain
) > 30)
542 status
|= FE_HAS_SIGNAL
;
543 if (stat
->lock_bits
& (1 << 6))
544 status
|= FE_HAS_LOCK
;
545 if (stat
->lock_bits
& (1 << 5))
546 status
|= FE_HAS_SYNC
;
547 if (stat
->lock_bits
& (1 << 4))
548 status
|= FE_HAS_CARRIER
;
549 if (stat
->lock_bits
& (1 << 1))
550 status
|= FE_HAS_VITERBI
;
552 return copy_to_user((void __user
*) arg
, &status
, sizeof(status
));
555 return put_user(le32_to_cpu(stat
->viterbi_error_rate
),
556 (__u32 __user
*) arg
);
558 case FE_READ_SIGNAL_STRENGTH
:
559 return put_user(0xffff - le16_to_cpu(stat
->gain
),
560 (__u16 __user
*) arg
);
563 return put_user((stat
->snr
<< 8) | stat
->snr
,
564 (__u16 __user
*) arg
);
566 case FE_READ_UNCORRECTED_BLOCKS
:
567 /* UNC are already converted to host byte order... */
568 return put_user(stat
->uncorrected_block_count
,
569 (__u32 __user
*) arg
);
571 case FE_SET_FRONTEND
:
573 struct dvbt_set_parameters_msg
*param
= &cinergyt2
->param
;
574 struct dvb_frontend_parameters p
;
577 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
)
580 if (copy_from_user(&p
, (void __user
*) arg
, sizeof(p
)))
583 if (down_interruptible(&cinergyt2
->sem
))
586 param
->cmd
= CINERGYT2_EP1_SET_TUNER_PARAMETERS
;
587 param
->tps
= cpu_to_le16(compute_tps(&p
));
588 param
->freq
= cpu_to_le32(p
.frequency
/ 1000);
589 param
->bandwidth
= 8 - p
.u
.ofdm
.bandwidth
- BANDWIDTH_8_MHZ
;
592 cinergyt2
->pending_fe_events
++;
593 wake_up_interruptible(&cinergyt2
->poll_wq
);
595 err
= cinergyt2_command(cinergyt2
,
596 (char *) param
, sizeof(*param
),
601 return (err
< 0) ? err
: 0;
604 case FE_GET_FRONTEND
:
606 * trivial to implement (see struct dvbt_get_status_msg).
607 * equivalent to FE_READ ioctls, but needs
608 * TPS -> linux-dvb parameter set conversion. Feel free
609 * to implement this and send us a patch if you need this
617 * for now we only fill the status field. the parameters
618 * are trivial to fill as soon FE_GET_FRONTEND is done.
620 struct dvb_frontend_event __user
*e
= (void __user
*) arg
;
621 if (cinergyt2
->pending_fe_events
== 0) {
622 if (file
->f_flags
& O_NONBLOCK
)
624 wait_event_interruptible(cinergyt2
->poll_wq
,
625 cinergyt2
->pending_fe_events
> 0);
627 cinergyt2
->pending_fe_events
= 0;
628 return cinergyt2_ioctl(inode
, file
, FE_READ_STATUS
,
629 (unsigned long) &e
->status
);
639 static int cinergyt2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
641 struct dvb_device
*dvbdev
= file
->private_data
;
642 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
647 if (vma
->vm_flags
& (VM_WRITE
| VM_EXEC
)) {
652 if (vma
->vm_end
> vma
->vm_start
+ STREAM_URB_COUNT
* STREAM_BUF_SIZE
) {
657 vma
->vm_flags
|= (VM_IO
| VM_DONTCOPY
);
660 ret
= remap_pfn_range(vma
, vma
->vm_start
,
661 virt_to_phys(cinergyt2
->streambuf
) >> PAGE_SHIFT
,
662 vma
->vm_end
- vma
->vm_start
,
663 vma
->vm_page_prot
) ? -EAGAIN
: 0;
669 static struct file_operations cinergyt2_fops
= {
670 .owner
= THIS_MODULE
,
671 .ioctl
= cinergyt2_ioctl
,
672 .poll
= cinergyt2_poll
,
673 .open
= cinergyt2_open
,
674 .release
= cinergyt2_release
,
675 .mmap
= cinergyt2_mmap
678 static struct dvb_device cinergyt2_fe_template
= {
682 .fops
= &cinergyt2_fops
687 static void cinergyt2_query_rc (void *data
)
689 struct cinergyt2
*cinergyt2
= data
;
690 char buf
[1] = { CINERGYT2_EP1_GET_RC_EVENTS
};
691 struct cinergyt2_rc_event rc_events
[12];
694 if (down_interruptible(&cinergyt2
->sem
))
697 len
= cinergyt2_command(cinergyt2
, buf
, sizeof(buf
),
698 (char *) rc_events
, sizeof(rc_events
));
702 if (time_after(jiffies
, cinergyt2
->last_event_jiffies
+
703 msecs_to_jiffies(150))) {
704 /* stop key repeat */
705 if (cinergyt2
->rc_input_event
!= KEY_MAX
) {
706 dprintk(1, "rc_input_event=%d Up\n", cinergyt2
->rc_input_event
);
707 input_report_key(cinergyt2
->rc_input_dev
,
708 cinergyt2
->rc_input_event
, 0);
709 cinergyt2
->rc_input_event
= KEY_MAX
;
711 cinergyt2
->rc_last_code
= ~0;
715 cinergyt2
->last_event_jiffies
= jiffies
;
717 for (n
= 0; n
< (len
/ sizeof(rc_events
[0])); n
++) {
718 dprintk(1, "rc_events[%d].value = %x, type=%x\n",
719 n
, le32_to_cpu(rc_events
[n
].value
), rc_events
[n
].type
);
721 if (rc_events
[n
].type
== CINERGYT2_RC_EVENT_TYPE_NEC
&&
722 rc_events
[n
].value
== ~0) {
723 /* keyrepeat bit -> just repeat last rc_input_event */
725 cinergyt2
->rc_input_event
= KEY_MAX
;
726 for (i
= 0; i
< ARRAY_SIZE(rc_keys
); i
+= 3) {
727 if (rc_keys
[i
+ 0] == rc_events
[n
].type
&&
728 rc_keys
[i
+ 1] == le32_to_cpu(rc_events
[n
].value
)) {
729 cinergyt2
->rc_input_event
= rc_keys
[i
+ 2];
735 if (cinergyt2
->rc_input_event
!= KEY_MAX
) {
736 if (rc_events
[n
].value
== cinergyt2
->rc_last_code
&&
737 cinergyt2
->rc_last_code
!= ~0) {
738 /* emit a key-up so the double event is recognized */
739 dprintk(1, "rc_input_event=%d UP\n", cinergyt2
->rc_input_event
);
740 input_report_key(cinergyt2
->rc_input_dev
,
741 cinergyt2
->rc_input_event
, 0);
743 dprintk(1, "rc_input_event=%d\n", cinergyt2
->rc_input_event
);
744 input_report_key(cinergyt2
->rc_input_dev
,
745 cinergyt2
->rc_input_event
, 1);
746 cinergyt2
->rc_last_code
= rc_events
[n
].value
;
751 schedule_delayed_work(&cinergyt2
->rc_query_work
,
752 msecs_to_jiffies(RC_QUERY_INTERVAL
));
757 static int cinergyt2_register_rc(struct cinergyt2
*cinergyt2
)
759 struct input_dev
*input_dev
;
762 cinergyt2
->rc_input_dev
= input_dev
= input_allocate_device();
766 usb_make_path(cinergyt2
->udev
, cinergyt2
->phys
, sizeof(cinergyt2
->phys
));
767 strlcat(cinergyt2
->phys
, "/input0", sizeof(cinergyt2
->phys
));
768 cinergyt2
->rc_input_event
= KEY_MAX
;
769 cinergyt2
->rc_last_code
= ~0;
770 INIT_WORK(&cinergyt2
->rc_query_work
, cinergyt2_query_rc
, cinergyt2
);
772 input_dev
->name
= DRIVER_NAME
" remote control";
773 input_dev
->phys
= cinergyt2
->phys
;
774 input_dev
->evbit
[0] = BIT(EV_KEY
) | BIT(EV_REP
);
775 for (i
= 0; ARRAY_SIZE(rc_keys
); i
+= 3)
776 set_bit(rc_keys
[i
+ 2], input_dev
->keybit
);
777 input_dev
->keycodesize
= 0;
778 input_dev
->keycodemax
= 0;
780 input_register_device(cinergyt2
->rc_input_dev
);
781 schedule_delayed_work(&cinergyt2
->rc_query_work
, HZ
/2);
784 static void cinergyt2_unregister_rc(struct cinergyt2
*cinergyt2
)
786 cancel_delayed_work(&cinergyt2
->rc_query_work
);
787 flush_scheduled_work();
788 input_unregister_device(cinergyt2
->rc_input_dev
);
791 static inline void cinergyt2_suspend_rc(struct cinergyt2
*cinergyt2
)
793 cancel_delayed_work(&cinergyt2
->rc_query_work
);
796 static inline void cinergyt2_resume_rc(struct cinergyt2
*cinergyt2
)
798 schedule_delayed_work(&cinergyt2
->rc_query_work
, HZ
/2);
803 static inline int cinergyt2_register_rc(struct cinergyt2
*cinergyt2
) { return 0; }
804 static inline void cinergyt2_unregister_rc(struct cinergyt2
*cinergyt2
) { }
805 static inline void cinergyt2_suspend_rc(struct cinergyt2
*cinergyt2
) { }
806 static inline void cinergyt2_resume_rc(struct cinergyt2
*cinergyt2
) { }
808 #endif /* ENABLE_RC */
810 static void cinergyt2_query (void *data
)
812 struct cinergyt2
*cinergyt2
= (struct cinergyt2
*) data
;
813 char cmd
[] = { CINERGYT2_EP1_GET_TUNER_STATUS
};
814 struct dvbt_get_status_msg
*s
= &cinergyt2
->status
;
818 if (down_interruptible(&cinergyt2
->sem
))
821 unc
= s
->uncorrected_block_count
;
822 lock_bits
= s
->lock_bits
;
824 cinergyt2_command(cinergyt2
, cmd
, sizeof(cmd
), (char *) s
, sizeof(*s
));
826 unc
+= le32_to_cpu(s
->uncorrected_block_count
);
827 s
->uncorrected_block_count
= unc
;
829 if (lock_bits
!= s
->lock_bits
) {
830 wake_up_interruptible(&cinergyt2
->poll_wq
);
831 cinergyt2
->pending_fe_events
++;
834 schedule_delayed_work(&cinergyt2
->query_work
,
835 msecs_to_jiffies(QUERY_INTERVAL
));
840 static int cinergyt2_probe (struct usb_interface
*intf
,
841 const struct usb_device_id
*id
)
843 struct cinergyt2
*cinergyt2
;
846 if (!(cinergyt2
= kmalloc (sizeof(struct cinergyt2
), GFP_KERNEL
))) {
847 dprintk(1, "out of memory?!?\n");
851 memset (cinergyt2
, 0, sizeof (struct cinergyt2
));
852 usb_set_intfdata (intf
, (void *) cinergyt2
);
854 init_MUTEX(&cinergyt2
->sem
);
855 init_waitqueue_head (&cinergyt2
->poll_wq
);
856 INIT_WORK(&cinergyt2
->query_work
, cinergyt2_query
, cinergyt2
);
858 cinergyt2
->udev
= interface_to_usbdev(intf
);
859 cinergyt2
->param
.cmd
= CINERGYT2_EP1_SET_TUNER_PARAMETERS
;
861 if (cinergyt2_alloc_stream_urbs (cinergyt2
) < 0) {
862 dprintk(1, "unable to allocate stream urbs\n");
867 dvb_register_adapter(&cinergyt2
->adapter
, DRIVER_NAME
, THIS_MODULE
);
869 cinergyt2
->demux
.priv
= cinergyt2
;
870 cinergyt2
->demux
.filternum
= 256;
871 cinergyt2
->demux
.feednum
= 256;
872 cinergyt2
->demux
.start_feed
= cinergyt2_start_feed
;
873 cinergyt2
->demux
.stop_feed
= cinergyt2_stop_feed
;
874 cinergyt2
->demux
.dmx
.capabilities
= DMX_TS_FILTERING
|
875 DMX_SECTION_FILTERING
|
876 DMX_MEMORY_BASED_FILTERING
;
878 if ((err
= dvb_dmx_init(&cinergyt2
->demux
)) < 0) {
879 dprintk(1, "dvb_dmx_init() failed (err = %d)\n", err
);
883 cinergyt2
->dmxdev
.filternum
= cinergyt2
->demux
.filternum
;
884 cinergyt2
->dmxdev
.demux
= &cinergyt2
->demux
.dmx
;
885 cinergyt2
->dmxdev
.capabilities
= 0;
887 if ((err
= dvb_dmxdev_init(&cinergyt2
->dmxdev
, &cinergyt2
->adapter
)) < 0) {
888 dprintk(1, "dvb_dmxdev_init() failed (err = %d)\n", err
);
892 if (dvb_net_init(&cinergyt2
->adapter
, &cinergyt2
->dvbnet
, &cinergyt2
->demux
.dmx
))
893 dprintk(1, "dvb_net_init() failed!\n");
895 dvb_register_device(&cinergyt2
->adapter
, &cinergyt2
->fedev
,
896 &cinergyt2_fe_template
, cinergyt2
,
897 DVB_DEVICE_FRONTEND
);
899 err
= cinergyt2_register_rc(cinergyt2
);
906 dvb_dmxdev_release(&cinergyt2
->dmxdev
);
907 dvb_dmx_release(&cinergyt2
->demux
);
908 dvb_unregister_adapter(&cinergyt2
->adapter
);
909 cinergyt2_free_stream_urbs(cinergyt2
);
914 static void cinergyt2_disconnect (struct usb_interface
*intf
)
916 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
918 if (down_interruptible(&cinergyt2
->sem
))
921 cinergyt2_unregister_rc(cinergyt2
);
923 cinergyt2
->demux
.dmx
.close(&cinergyt2
->demux
.dmx
);
924 dvb_net_release(&cinergyt2
->dvbnet
);
925 dvb_dmxdev_release(&cinergyt2
->dmxdev
);
926 dvb_dmx_release(&cinergyt2
->demux
);
927 dvb_unregister_device(cinergyt2
->fedev
);
928 dvb_unregister_adapter(&cinergyt2
->adapter
);
930 cinergyt2_free_stream_urbs(cinergyt2
);
935 static int cinergyt2_suspend (struct usb_interface
*intf
, pm_message_t state
)
937 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
939 if (down_interruptible(&cinergyt2
->sem
))
942 if (state
.event
> PM_EVENT_ON
) {
943 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
945 cinergyt2_suspend_rc(cinergyt2
);
946 cancel_delayed_work(&cinergyt2
->query_work
);
947 if (cinergyt2
->streaming
)
948 cinergyt2_stop_stream_xfer(cinergyt2
);
949 flush_scheduled_work();
950 cinergyt2_sleep(cinergyt2
, 1);
957 static int cinergyt2_resume (struct usb_interface
*intf
)
959 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
960 struct dvbt_set_parameters_msg
*param
= &cinergyt2
->param
;
962 if (down_interruptible(&cinergyt2
->sem
))
965 if (!cinergyt2
->sleeping
) {
966 cinergyt2_sleep(cinergyt2
, 0);
967 cinergyt2_command(cinergyt2
, (char *) param
, sizeof(*param
), NULL
, 0);
968 if (cinergyt2
->streaming
)
969 cinergyt2_start_stream_xfer(cinergyt2
);
970 schedule_delayed_work(&cinergyt2
->query_work
, HZ
/2);
973 cinergyt2_resume_rc(cinergyt2
);
979 static const struct usb_device_id cinergyt2_table
[] __devinitdata
= {
980 { USB_DEVICE(0x0ccd, 0x0038) },
984 MODULE_DEVICE_TABLE(usb
, cinergyt2_table
);
986 static struct usb_driver cinergyt2_driver
= {
987 .owner
= THIS_MODULE
,
989 .probe
= cinergyt2_probe
,
990 .disconnect
= cinergyt2_disconnect
,
991 .suspend
= cinergyt2_suspend
,
992 .resume
= cinergyt2_resume
,
993 .id_table
= cinergyt2_table
996 static int __init
cinergyt2_init (void)
1000 if ((err
= usb_register(&cinergyt2_driver
)) < 0)
1001 dprintk(1, "usb_register() failed! (err %i)\n", err
);
1006 static void __exit
cinergyt2_exit (void)
1008 usb_deregister(&cinergyt2_driver
);
1011 module_init (cinergyt2_init
);
1012 module_exit (cinergyt2_exit
);
1014 MODULE_LICENSE("GPL");
1015 MODULE_AUTHOR("Holger Waechtler, Daniel Mack");