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/init.h>
26 #include <linux/module.h>
27 #include <linux/slab.h>
28 #include <linux/usb.h>
29 #include <linux/pci.h>
30 #include <linux/input.h>
31 #include <linux/dvb/frontend.h>
32 #include <linux/mutex.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(): ", 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
;
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 delayed_work query_work
;
132 wait_queue_head_t poll_wq
;
133 int pending_fe_events
;
134 int disconnect_pending
;
138 dma_addr_t streambuf_dmahandle
;
139 struct urb
*stream_urb
[STREAM_URB_COUNT
];
142 struct input_dev
*rc_input_dev
;
144 struct delayed_work rc_query_work
;
147 unsigned long last_event_jiffies
;
152 CINERGYT2_RC_EVENT_TYPE_NONE
= 0x00,
153 CINERGYT2_RC_EVENT_TYPE_NEC
= 0x01,
154 CINERGYT2_RC_EVENT_TYPE_RC5
= 0x02
157 struct cinergyt2_rc_event
{
160 } __attribute__((packed
));
162 static const uint32_t rc_keys
[] = {
163 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfe01eb04, KEY_POWER
,
164 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfd02eb04, KEY_1
,
165 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfc03eb04, KEY_2
,
166 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfb04eb04, KEY_3
,
167 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xfa05eb04, KEY_4
,
168 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf906eb04, KEY_5
,
169 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf807eb04, KEY_6
,
170 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf708eb04, KEY_7
,
171 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf609eb04, KEY_8
,
172 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf50aeb04, KEY_9
,
173 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf30ceb04, KEY_0
,
174 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf40beb04, KEY_VIDEO
,
175 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf20deb04, KEY_REFRESH
,
176 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf10eeb04, KEY_SELECT
,
177 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xf00feb04, KEY_EPG
,
178 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xef10eb04, KEY_UP
,
179 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xeb14eb04, KEY_DOWN
,
180 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xee11eb04, KEY_LEFT
,
181 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xec13eb04, KEY_RIGHT
,
182 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xed12eb04, KEY_OK
,
183 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xea15eb04, KEY_TEXT
,
184 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe916eb04, KEY_INFO
,
185 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe817eb04, KEY_RED
,
186 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe718eb04, KEY_GREEN
,
187 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe619eb04, KEY_YELLOW
,
188 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe51aeb04, KEY_BLUE
,
189 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe31ceb04, KEY_VOLUMEUP
,
190 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe11eeb04, KEY_VOLUMEDOWN
,
191 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe21deb04, KEY_MUTE
,
192 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe41beb04, KEY_CHANNELUP
,
193 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xe01feb04, KEY_CHANNELDOWN
,
194 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xbf40eb04, KEY_PAUSE
,
195 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xb34ceb04, KEY_PLAY
,
196 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xa758eb04, KEY_RECORD
,
197 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xab54eb04, KEY_PREVIOUS
,
198 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xb748eb04, KEY_STOP
,
199 CINERGYT2_RC_EVENT_TYPE_NEC
, 0xa35ceb04, KEY_NEXT
202 static int cinergyt2_command (struct cinergyt2
*cinergyt2
,
203 char *send_buf
, int send_buf_len
,
204 char *recv_buf
, int recv_buf_len
)
210 ret
= usb_bulk_msg(cinergyt2
->udev
, usb_sndbulkpipe(cinergyt2
->udev
, 1),
211 send_buf
, send_buf_len
, &actual_len
, 1000);
214 dprintk(1, "usb_bulk_msg (send) failed, err %i\n", ret
);
219 ret
= usb_bulk_msg(cinergyt2
->udev
, usb_rcvbulkpipe(cinergyt2
->udev
, 1),
220 recv_buf
, recv_buf_len
, &actual_len
, 1000);
223 dprintk(1, "usb_bulk_msg (read) failed, err %i\n", ret
);
225 return ret
? ret
: actual_len
;
228 static void cinergyt2_control_stream_transfer (struct cinergyt2
*cinergyt2
, int enable
)
230 char buf
[] = { CINERGYT2_EP1_CONTROL_STREAM_TRANSFER
, enable
? 1 : 0 };
231 cinergyt2_command(cinergyt2
, buf
, sizeof(buf
), NULL
, 0);
234 static void cinergyt2_sleep (struct cinergyt2
*cinergyt2
, int sleep
)
236 char buf
[] = { CINERGYT2_EP1_SLEEP_MODE
, sleep
? 1 : 0 };
237 cinergyt2_command(cinergyt2
, buf
, sizeof(buf
), NULL
, 0);
238 cinergyt2
->sleeping
= sleep
;
241 static void cinergyt2_stream_irq (struct urb
*urb
);
243 static int cinergyt2_submit_stream_urb (struct cinergyt2
*cinergyt2
, struct urb
*urb
)
247 usb_fill_bulk_urb(urb
,
249 usb_rcvbulkpipe(cinergyt2
->udev
, 0x2),
250 urb
->transfer_buffer
,
252 cinergyt2_stream_irq
,
255 if ((err
= usb_submit_urb(urb
, GFP_ATOMIC
)))
256 dprintk(1, "urb submission failed (err = %i)!\n", err
);
261 static void cinergyt2_stream_irq (struct urb
*urb
)
263 struct cinergyt2
*cinergyt2
= urb
->context
;
265 if (urb
->actual_length
> 0)
266 dvb_dmx_swfilter(&cinergyt2
->demux
,
267 urb
->transfer_buffer
, urb
->actual_length
);
269 if (cinergyt2
->streaming
)
270 cinergyt2_submit_stream_urb(cinergyt2
, urb
);
273 static void cinergyt2_free_stream_urbs (struct cinergyt2
*cinergyt2
)
277 for (i
=0; i
<STREAM_URB_COUNT
; i
++)
278 if (cinergyt2
->stream_urb
[i
])
279 usb_free_urb(cinergyt2
->stream_urb
[i
]);
281 usb_buffer_free(cinergyt2
->udev
, STREAM_URB_COUNT
*STREAM_BUF_SIZE
,
282 cinergyt2
->streambuf
, cinergyt2
->streambuf_dmahandle
);
285 static int cinergyt2_alloc_stream_urbs (struct cinergyt2
*cinergyt2
)
289 cinergyt2
->streambuf
= usb_buffer_alloc(cinergyt2
->udev
, STREAM_URB_COUNT
*STREAM_BUF_SIZE
,
290 SLAB_KERNEL
, &cinergyt2
->streambuf_dmahandle
);
291 if (!cinergyt2
->streambuf
) {
292 dprintk(1, "failed to alloc consistent stream memory area, bailing out!\n");
296 memset(cinergyt2
->streambuf
, 0, STREAM_URB_COUNT
*STREAM_BUF_SIZE
);
298 for (i
=0; i
<STREAM_URB_COUNT
; i
++) {
301 if (!(urb
= usb_alloc_urb(0, GFP_ATOMIC
))) {
302 dprintk(1, "failed to alloc consistent stream urbs, bailing out!\n");
303 cinergyt2_free_stream_urbs(cinergyt2
);
307 urb
->transfer_buffer
= cinergyt2
->streambuf
+ i
* STREAM_BUF_SIZE
;
308 urb
->transfer_buffer_length
= STREAM_BUF_SIZE
;
310 cinergyt2
->stream_urb
[i
] = urb
;
316 static void cinergyt2_stop_stream_xfer (struct cinergyt2
*cinergyt2
)
320 cinergyt2_control_stream_transfer(cinergyt2
, 0);
322 for (i
=0; i
<STREAM_URB_COUNT
; i
++)
323 if (cinergyt2
->stream_urb
[i
])
324 usb_kill_urb(cinergyt2
->stream_urb
[i
]);
327 static int cinergyt2_start_stream_xfer (struct cinergyt2
*cinergyt2
)
331 for (i
=0; i
<STREAM_URB_COUNT
; i
++) {
332 if ((err
= cinergyt2_submit_stream_urb(cinergyt2
, cinergyt2
->stream_urb
[i
]))) {
333 cinergyt2_stop_stream_xfer(cinergyt2
);
334 dprintk(1, "failed urb submission (%i: err = %i)!\n", i
, err
);
339 cinergyt2_control_stream_transfer(cinergyt2
, 1);
343 static int cinergyt2_start_feed(struct dvb_demux_feed
*dvbdmxfeed
)
345 struct dvb_demux
*demux
= dvbdmxfeed
->demux
;
346 struct cinergyt2
*cinergyt2
= demux
->priv
;
348 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
351 if (cinergyt2
->streaming
== 0)
352 cinergyt2_start_stream_xfer(cinergyt2
);
354 cinergyt2
->streaming
++;
355 mutex_unlock(&cinergyt2
->sem
);
359 static int cinergyt2_stop_feed(struct dvb_demux_feed
*dvbdmxfeed
)
361 struct dvb_demux
*demux
= dvbdmxfeed
->demux
;
362 struct cinergyt2
*cinergyt2
= demux
->priv
;
364 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
367 if (--cinergyt2
->streaming
== 0)
368 cinergyt2_stop_stream_xfer(cinergyt2
);
370 mutex_unlock(&cinergyt2
->sem
);
375 * convert linux-dvb frontend parameter set into TPS.
376 * See ETSI ETS-300744, section 4.6.2, table 9 for details.
378 * This function is probably reusable and may better get placed in a support
381 * We replace errornous fields by default TPS fields (the ones with value 0).
383 static uint16_t compute_tps (struct dvb_frontend_parameters
*p
)
385 struct dvb_ofdm_parameters
*op
= &p
->u
.ofdm
;
388 switch (op
->code_rate_HP
) {
404 /* tps |= (0 << 7) */;
407 switch (op
->code_rate_LP
) {
423 /* tps |= (0 << 4) */;
426 switch (op
->constellation
) {
435 /* tps |= (0 << 13) */;
438 switch (op
->transmission_mode
) {
439 case TRANSMISSION_MODE_8K
:
442 case TRANSMISSION_MODE_2K
:
444 /* tps |= (0 << 0) */;
447 switch (op
->guard_interval
) {
448 case GUARD_INTERVAL_1_16
:
451 case GUARD_INTERVAL_1_8
:
454 case GUARD_INTERVAL_1_4
:
457 case GUARD_INTERVAL_1_32
:
459 /* tps |= (0 << 2) */;
462 switch (op
->hierarchy_information
) {
474 /* tps |= (0 << 10) */;
480 static int cinergyt2_open (struct inode
*inode
, struct file
*file
)
482 struct dvb_device
*dvbdev
= file
->private_data
;
483 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
484 int err
= -ERESTARTSYS
;
486 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
489 if ((err
= dvb_generic_open(inode
, file
))) {
490 mutex_unlock(&cinergyt2
->sem
);
495 if ((file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
496 cinergyt2_sleep(cinergyt2
, 0);
497 schedule_delayed_work(&cinergyt2
->query_work
, HZ
/2);
500 atomic_inc(&cinergyt2
->inuse
);
502 mutex_unlock(&cinergyt2
->sem
);
506 static void cinergyt2_unregister(struct cinergyt2
*cinergyt2
)
508 dvb_net_release(&cinergyt2
->dvbnet
);
509 dvb_dmxdev_release(&cinergyt2
->dmxdev
);
510 dvb_dmx_release(&cinergyt2
->demux
);
511 dvb_unregister_device(cinergyt2
->fedev
);
512 dvb_unregister_adapter(&cinergyt2
->adapter
);
514 cinergyt2_free_stream_urbs(cinergyt2
);
518 static int cinergyt2_release (struct inode
*inode
, struct file
*file
)
520 struct dvb_device
*dvbdev
= file
->private_data
;
521 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
523 if (mutex_lock_interruptible(&cinergyt2
->sem
))
526 if (!cinergyt2
->disconnect_pending
&& (file
->f_flags
& O_ACCMODE
) != O_RDONLY
) {
527 cancel_delayed_work(&cinergyt2
->query_work
);
528 flush_scheduled_work();
529 cinergyt2_sleep(cinergyt2
, 1);
532 mutex_unlock(&cinergyt2
->sem
);
534 if (atomic_dec_and_test(&cinergyt2
->inuse
) && cinergyt2
->disconnect_pending
) {
535 warn("delayed unregister in release");
536 cinergyt2_unregister(cinergyt2
);
539 return dvb_generic_release(inode
, file
);
542 static unsigned int cinergyt2_poll (struct file
*file
, struct poll_table_struct
*wait
)
544 struct dvb_device
*dvbdev
= file
->private_data
;
545 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
546 unsigned int mask
= 0;
548 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
551 poll_wait(file
, &cinergyt2
->poll_wq
, wait
);
553 if (cinergyt2
->pending_fe_events
!= 0)
554 mask
|= (POLLIN
| POLLRDNORM
| POLLPRI
);
556 mutex_unlock(&cinergyt2
->sem
);
562 static int cinergyt2_ioctl (struct inode
*inode
, struct file
*file
,
563 unsigned cmd
, unsigned long arg
)
565 struct dvb_device
*dvbdev
= file
->private_data
;
566 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
567 struct dvbt_get_status_msg
*stat
= &cinergyt2
->status
;
568 fe_status_t status
= 0;
572 return copy_to_user((void __user
*) arg
, &cinergyt2_fe_info
,
573 sizeof(struct dvb_frontend_info
));
576 if (0xffff - le16_to_cpu(stat
->gain
) > 30)
577 status
|= FE_HAS_SIGNAL
;
578 if (stat
->lock_bits
& (1 << 6))
579 status
|= FE_HAS_LOCK
;
580 if (stat
->lock_bits
& (1 << 5))
581 status
|= FE_HAS_SYNC
;
582 if (stat
->lock_bits
& (1 << 4))
583 status
|= FE_HAS_CARRIER
;
584 if (stat
->lock_bits
& (1 << 1))
585 status
|= FE_HAS_VITERBI
;
587 return copy_to_user((void __user
*) arg
, &status
, sizeof(status
));
590 return put_user(le32_to_cpu(stat
->viterbi_error_rate
),
591 (__u32 __user
*) arg
);
593 case FE_READ_SIGNAL_STRENGTH
:
594 return put_user(0xffff - le16_to_cpu(stat
->gain
),
595 (__u16 __user
*) arg
);
598 return put_user((stat
->snr
<< 8) | stat
->snr
,
599 (__u16 __user
*) arg
);
601 case FE_READ_UNCORRECTED_BLOCKS
:
605 unc_count
= stat
->uncorrected_block_count
;
606 stat
->uncorrected_block_count
= 0;
608 /* UNC are already converted to host byte order... */
609 return put_user(unc_count
,(__u32 __user
*) arg
);
611 case FE_SET_FRONTEND
:
613 struct dvbt_set_parameters_msg
*param
= &cinergyt2
->param
;
614 struct dvb_frontend_parameters p
;
617 if ((file
->f_flags
& O_ACCMODE
) == O_RDONLY
)
620 if (copy_from_user(&p
, (void __user
*) arg
, sizeof(p
)))
623 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
626 param
->cmd
= CINERGYT2_EP1_SET_TUNER_PARAMETERS
;
627 param
->tps
= cpu_to_le16(compute_tps(&p
));
628 param
->freq
= cpu_to_le32(p
.frequency
/ 1000);
629 param
->bandwidth
= 8 - p
.u
.ofdm
.bandwidth
- BANDWIDTH_8_MHZ
;
632 cinergyt2
->pending_fe_events
++;
633 wake_up_interruptible(&cinergyt2
->poll_wq
);
635 err
= cinergyt2_command(cinergyt2
,
636 (char *) param
, sizeof(*param
),
639 mutex_unlock(&cinergyt2
->sem
);
641 return (err
< 0) ? err
: 0;
644 case FE_GET_FRONTEND
:
646 * trivial to implement (see struct dvbt_get_status_msg).
647 * equivalent to FE_READ ioctls, but needs
648 * TPS -> linux-dvb parameter set conversion. Feel free
649 * to implement this and send us a patch if you need this
657 * for now we only fill the status field. the parameters
658 * are trivial to fill as soon FE_GET_FRONTEND is done.
660 struct dvb_frontend_event __user
*e
= (void __user
*) arg
;
661 if (cinergyt2
->pending_fe_events
== 0) {
662 if (file
->f_flags
& O_NONBLOCK
)
664 wait_event_interruptible(cinergyt2
->poll_wq
,
665 cinergyt2
->pending_fe_events
> 0);
667 cinergyt2
->pending_fe_events
= 0;
668 return cinergyt2_ioctl(inode
, file
, FE_READ_STATUS
,
669 (unsigned long) &e
->status
);
679 static int cinergyt2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
681 struct dvb_device
*dvbdev
= file
->private_data
;
682 struct cinergyt2
*cinergyt2
= dvbdev
->priv
;
687 if (vma
->vm_flags
& (VM_WRITE
| VM_EXEC
)) {
692 if (vma
->vm_end
> vma
->vm_start
+ STREAM_URB_COUNT
* STREAM_BUF_SIZE
) {
697 vma
->vm_flags
|= (VM_IO
| VM_DONTCOPY
);
700 ret
= remap_pfn_range(vma
, vma
->vm_start
,
701 virt_to_phys(cinergyt2
->streambuf
) >> PAGE_SHIFT
,
702 vma
->vm_end
- vma
->vm_start
,
703 vma
->vm_page_prot
) ? -EAGAIN
: 0;
709 static struct file_operations cinergyt2_fops
= {
710 .owner
= THIS_MODULE
,
711 .ioctl
= cinergyt2_ioctl
,
712 .poll
= cinergyt2_poll
,
713 .open
= cinergyt2_open
,
714 .release
= cinergyt2_release
,
715 .mmap
= cinergyt2_mmap
718 static struct dvb_device cinergyt2_fe_template
= {
722 .fops
= &cinergyt2_fops
727 static void cinergyt2_query_rc (struct work_struct
*work
)
729 struct cinergyt2
*cinergyt2
=
730 container_of(work
, struct cinergyt2
, rc_query_work
.work
);
731 char buf
[1] = { CINERGYT2_EP1_GET_RC_EVENTS
};
732 struct cinergyt2_rc_event rc_events
[12];
735 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
738 len
= cinergyt2_command(cinergyt2
, buf
, sizeof(buf
),
739 (char *) rc_events
, sizeof(rc_events
));
743 if (time_after(jiffies
, cinergyt2
->last_event_jiffies
+
744 msecs_to_jiffies(150))) {
745 /* stop key repeat */
746 if (cinergyt2
->rc_input_event
!= KEY_MAX
) {
747 dprintk(1, "rc_input_event=%d Up\n", cinergyt2
->rc_input_event
);
748 input_report_key(cinergyt2
->rc_input_dev
,
749 cinergyt2
->rc_input_event
, 0);
750 cinergyt2
->rc_input_event
= KEY_MAX
;
752 cinergyt2
->rc_last_code
= ~0;
756 cinergyt2
->last_event_jiffies
= jiffies
;
758 for (n
= 0; n
< (len
/ sizeof(rc_events
[0])); n
++) {
759 dprintk(1, "rc_events[%d].value = %x, type=%x\n",
760 n
, le32_to_cpu(rc_events
[n
].value
), rc_events
[n
].type
);
762 if (rc_events
[n
].type
== CINERGYT2_RC_EVENT_TYPE_NEC
&&
763 rc_events
[n
].value
== ~0) {
764 /* keyrepeat bit -> just repeat last rc_input_event */
766 cinergyt2
->rc_input_event
= KEY_MAX
;
767 for (i
= 0; i
< ARRAY_SIZE(rc_keys
); i
+= 3) {
768 if (rc_keys
[i
+ 0] == rc_events
[n
].type
&&
769 rc_keys
[i
+ 1] == le32_to_cpu(rc_events
[n
].value
)) {
770 cinergyt2
->rc_input_event
= rc_keys
[i
+ 2];
776 if (cinergyt2
->rc_input_event
!= KEY_MAX
) {
777 if (rc_events
[n
].value
== cinergyt2
->rc_last_code
&&
778 cinergyt2
->rc_last_code
!= ~0) {
779 /* emit a key-up so the double event is recognized */
780 dprintk(1, "rc_input_event=%d UP\n", cinergyt2
->rc_input_event
);
781 input_report_key(cinergyt2
->rc_input_dev
,
782 cinergyt2
->rc_input_event
, 0);
784 dprintk(1, "rc_input_event=%d\n", cinergyt2
->rc_input_event
);
785 input_report_key(cinergyt2
->rc_input_dev
,
786 cinergyt2
->rc_input_event
, 1);
787 cinergyt2
->rc_last_code
= rc_events
[n
].value
;
792 schedule_delayed_work(&cinergyt2
->rc_query_work
,
793 msecs_to_jiffies(RC_QUERY_INTERVAL
));
795 mutex_unlock(&cinergyt2
->sem
);
798 static int cinergyt2_register_rc(struct cinergyt2
*cinergyt2
)
800 struct input_dev
*input_dev
;
803 cinergyt2
->rc_input_dev
= input_dev
= input_allocate_device();
807 usb_make_path(cinergyt2
->udev
, cinergyt2
->phys
, sizeof(cinergyt2
->phys
));
808 strlcat(cinergyt2
->phys
, "/input0", sizeof(cinergyt2
->phys
));
809 cinergyt2
->rc_input_event
= KEY_MAX
;
810 cinergyt2
->rc_last_code
= ~0;
811 INIT_DELAYED_WORK(&cinergyt2
->rc_query_work
, cinergyt2_query_rc
);
813 input_dev
->name
= DRIVER_NAME
" remote control";
814 input_dev
->phys
= cinergyt2
->phys
;
815 input_dev
->evbit
[0] = BIT(EV_KEY
) | BIT(EV_REP
);
816 for (i
= 0; i
< ARRAY_SIZE(rc_keys
); i
+= 3)
817 set_bit(rc_keys
[i
+ 2], input_dev
->keybit
);
818 input_dev
->keycodesize
= 0;
819 input_dev
->keycodemax
= 0;
821 input_register_device(cinergyt2
->rc_input_dev
);
822 schedule_delayed_work(&cinergyt2
->rc_query_work
, HZ
/2);
827 static void cinergyt2_unregister_rc(struct cinergyt2
*cinergyt2
)
829 cancel_delayed_work(&cinergyt2
->rc_query_work
);
830 input_unregister_device(cinergyt2
->rc_input_dev
);
833 static inline void cinergyt2_suspend_rc(struct cinergyt2
*cinergyt2
)
835 cancel_delayed_work(&cinergyt2
->rc_query_work
);
838 static inline void cinergyt2_resume_rc(struct cinergyt2
*cinergyt2
)
840 schedule_delayed_work(&cinergyt2
->rc_query_work
, HZ
/2);
845 static inline int cinergyt2_register_rc(struct cinergyt2
*cinergyt2
) { return 0; }
846 static inline void cinergyt2_unregister_rc(struct cinergyt2
*cinergyt2
) { }
847 static inline void cinergyt2_suspend_rc(struct cinergyt2
*cinergyt2
) { }
848 static inline void cinergyt2_resume_rc(struct cinergyt2
*cinergyt2
) { }
850 #endif /* ENABLE_RC */
852 static void cinergyt2_query (struct work_struct
*work
)
854 struct cinergyt2
*cinergyt2
=
855 container_of(work
, struct cinergyt2
, query_work
.work
);
856 char cmd
[] = { CINERGYT2_EP1_GET_TUNER_STATUS
};
857 struct dvbt_get_status_msg
*s
= &cinergyt2
->status
;
861 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
864 unc
= s
->uncorrected_block_count
;
865 lock_bits
= s
->lock_bits
;
867 cinergyt2_command(cinergyt2
, cmd
, sizeof(cmd
), (char *) s
, sizeof(*s
));
869 unc
+= le32_to_cpu(s
->uncorrected_block_count
);
870 s
->uncorrected_block_count
= unc
;
872 if (lock_bits
!= s
->lock_bits
) {
873 wake_up_interruptible(&cinergyt2
->poll_wq
);
874 cinergyt2
->pending_fe_events
++;
877 schedule_delayed_work(&cinergyt2
->query_work
,
878 msecs_to_jiffies(QUERY_INTERVAL
));
880 mutex_unlock(&cinergyt2
->sem
);
883 static int cinergyt2_probe (struct usb_interface
*intf
,
884 const struct usb_device_id
*id
)
886 struct cinergyt2
*cinergyt2
;
889 if (!(cinergyt2
= kmalloc (sizeof(struct cinergyt2
), GFP_KERNEL
))) {
890 dprintk(1, "out of memory?!?\n");
894 memset (cinergyt2
, 0, sizeof (struct cinergyt2
));
895 usb_set_intfdata (intf
, (void *) cinergyt2
);
897 mutex_init(&cinergyt2
->sem
);
898 init_waitqueue_head (&cinergyt2
->poll_wq
);
899 INIT_DELAYED_WORK(&cinergyt2
->query_work
, cinergyt2_query
);
901 cinergyt2
->udev
= interface_to_usbdev(intf
);
902 cinergyt2
->param
.cmd
= CINERGYT2_EP1_SET_TUNER_PARAMETERS
;
904 if (cinergyt2_alloc_stream_urbs (cinergyt2
) < 0) {
905 dprintk(1, "unable to allocate stream urbs\n");
910 if ((err
= dvb_register_adapter(&cinergyt2
->adapter
, DRIVER_NAME
, THIS_MODULE
, &cinergyt2
->udev
->dev
)) < 0) {
915 cinergyt2
->demux
.priv
= cinergyt2
;
916 cinergyt2
->demux
.filternum
= 256;
917 cinergyt2
->demux
.feednum
= 256;
918 cinergyt2
->demux
.start_feed
= cinergyt2_start_feed
;
919 cinergyt2
->demux
.stop_feed
= cinergyt2_stop_feed
;
920 cinergyt2
->demux
.dmx
.capabilities
= DMX_TS_FILTERING
|
921 DMX_SECTION_FILTERING
|
922 DMX_MEMORY_BASED_FILTERING
;
924 if ((err
= dvb_dmx_init(&cinergyt2
->demux
)) < 0) {
925 dprintk(1, "dvb_dmx_init() failed (err = %d)\n", err
);
929 cinergyt2
->dmxdev
.filternum
= cinergyt2
->demux
.filternum
;
930 cinergyt2
->dmxdev
.demux
= &cinergyt2
->demux
.dmx
;
931 cinergyt2
->dmxdev
.capabilities
= 0;
933 if ((err
= dvb_dmxdev_init(&cinergyt2
->dmxdev
, &cinergyt2
->adapter
)) < 0) {
934 dprintk(1, "dvb_dmxdev_init() failed (err = %d)\n", err
);
938 if (dvb_net_init(&cinergyt2
->adapter
, &cinergyt2
->dvbnet
, &cinergyt2
->demux
.dmx
))
939 dprintk(1, "dvb_net_init() failed!\n");
941 dvb_register_device(&cinergyt2
->adapter
, &cinergyt2
->fedev
,
942 &cinergyt2_fe_template
, cinergyt2
,
943 DVB_DEVICE_FRONTEND
);
945 err
= cinergyt2_register_rc(cinergyt2
);
952 dvb_net_release(&cinergyt2
->dvbnet
);
953 dvb_dmxdev_release(&cinergyt2
->dmxdev
);
954 dvb_dmx_release(&cinergyt2
->demux
);
955 dvb_unregister_adapter(&cinergyt2
->adapter
);
956 cinergyt2_free_stream_urbs(cinergyt2
);
961 static void cinergyt2_disconnect (struct usb_interface
*intf
)
963 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
965 flush_scheduled_work();
967 cinergyt2_unregister_rc(cinergyt2
);
969 cancel_delayed_work(&cinergyt2
->query_work
);
970 wake_up_interruptible(&cinergyt2
->poll_wq
);
972 cinergyt2
->demux
.dmx
.close(&cinergyt2
->demux
.dmx
);
973 cinergyt2
->disconnect_pending
= 1;
975 if (!atomic_read(&cinergyt2
->inuse
))
976 cinergyt2_unregister(cinergyt2
);
979 static int cinergyt2_suspend (struct usb_interface
*intf
, pm_message_t state
)
981 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
983 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
987 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
989 cinergyt2_suspend_rc(cinergyt2
);
990 cancel_delayed_work(&cinergyt2
->query_work
);
991 if (cinergyt2
->streaming
)
992 cinergyt2_stop_stream_xfer(cinergyt2
);
993 flush_scheduled_work();
994 cinergyt2_sleep(cinergyt2
, 1);
997 mutex_unlock(&cinergyt2
->sem
);
1001 static int cinergyt2_resume (struct usb_interface
*intf
)
1003 struct cinergyt2
*cinergyt2
= usb_get_intfdata (intf
);
1004 struct dvbt_set_parameters_msg
*param
= &cinergyt2
->param
;
1006 if (cinergyt2
->disconnect_pending
|| mutex_lock_interruptible(&cinergyt2
->sem
))
1007 return -ERESTARTSYS
;
1009 if (!cinergyt2
->sleeping
) {
1010 cinergyt2_sleep(cinergyt2
, 0);
1011 cinergyt2_command(cinergyt2
, (char *) param
, sizeof(*param
), NULL
, 0);
1012 if (cinergyt2
->streaming
)
1013 cinergyt2_start_stream_xfer(cinergyt2
);
1014 schedule_delayed_work(&cinergyt2
->query_work
, HZ
/2);
1017 cinergyt2_resume_rc(cinergyt2
);
1019 mutex_unlock(&cinergyt2
->sem
);
1023 static const struct usb_device_id cinergyt2_table
[] __devinitdata
= {
1024 { USB_DEVICE(0x0ccd, 0x0038) },
1028 MODULE_DEVICE_TABLE(usb
, cinergyt2_table
);
1030 static struct usb_driver cinergyt2_driver
= {
1031 .name
= "cinergyT2",
1032 .probe
= cinergyt2_probe
,
1033 .disconnect
= cinergyt2_disconnect
,
1034 .suspend
= cinergyt2_suspend
,
1035 .resume
= cinergyt2_resume
,
1036 .id_table
= cinergyt2_table
1039 static int __init
cinergyt2_init (void)
1043 if ((err
= usb_register(&cinergyt2_driver
)) < 0)
1044 dprintk(1, "usb_register() failed! (err %i)\n", err
);
1049 static void __exit
cinergyt2_exit (void)
1051 usb_deregister(&cinergyt2_driver
);
1054 module_init (cinergyt2_init
);
1055 module_exit (cinergyt2_exit
);
1057 MODULE_LICENSE("GPL");
1058 MODULE_AUTHOR("Holger Waechtler, Daniel Mack");