2 * DVB USB compliant linux driver for ITE IT9135 and IT9137
4 * Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com)
5 * IT9135 (C) ITE Tech Inc.
6 * IT9137 (C) ITE Tech Inc.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License Version 2, as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 * see Documentation/dvb/README.dvb-usb for more information
23 * see Documentation/dvb/it9137.txt for firmware information
26 #define DVB_USB_LOG_PREFIX "it913x"
28 #include <linux/usb.h>
29 #include <linux/usb/input.h>
30 #include <media/rc-core.h>
33 #include "it913x-fe.h"
36 static int dvb_usb_it913x_debug
;
37 #define it_debug(var, level, args...) \
38 do { if ((var & level)) pr_debug(DVB_USB_LOG_PREFIX": " args); \
40 #define deb_info(level, args...) it_debug(dvb_usb_it913x_debug, level, args)
41 #define info(args...) pr_info(DVB_USB_LOG_PREFIX": " args)
43 module_param_named(debug
, dvb_usb_it913x_debug
, int, 0644);
44 MODULE_PARM_DESC(debug
, "set debugging level (1=info (or-able)).");
46 static int dvb_usb_it913x_firmware
;
47 module_param_named(firmware
, dvb_usb_it913x_firmware
, int, 0644);
48 MODULE_PARM_DESC(firmware
, "set firmware 0=auto"\
49 "1=IT9137 2=IT9135 V1 3=IT9135 V2");
50 #define FW_IT9137 "dvb-usb-it9137-01.fw"
51 #define FW_IT9135_V1 "dvb-usb-it9135-01.fw"
52 #define FW_IT9135_V2 "dvb-usb-it9135-02.fw"
54 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
57 struct ite_config it913x_config
;
63 static u16
check_sum(u8
*p
, u8 len
)
68 sum
+= (i
++ & 1) ? (*p
++) << 8 : *p
++;
72 static int it913x_io(struct dvb_usb_device
*d
, u8 mode
, u8 pro
,
73 u8 cmd
, u32 reg
, u8 addr
, u8
*data
, u8 len
)
75 struct it913x_state
*st
= d
->priv
;
76 int ret
= 0, i
, buf_size
= 1;
81 buff
= kzalloc(256, GFP_KERNEL
);
83 info("USB Buffer Failed");
87 buff
[buf_size
++] = pro
;
88 buff
[buf_size
++] = cmd
;
89 buff
[buf_size
++] = st
->cmd_counter
;
94 buff
[buf_size
++] = len
;
96 buff
[buf_size
++] = (reg
>> 24);
97 buff
[buf_size
++] = (reg
>> 16) & 0xff;
98 buff
[buf_size
++] = (reg
>> 8) & 0xff;
99 buff
[buf_size
++] = reg
& 0xff;
102 buff
[buf_size
++] = addr
;
105 buff
[buf_size
++] = len
;
106 buff
[buf_size
++] = addr
;
107 buff
[buf_size
++] = (reg
>> 8) & 0xff;
108 buff
[buf_size
++] = reg
& 0xff;
122 for (i
= 0; i
< len
; i
++)
123 buff
[buf_size
++] = data
[i
];
125 chk_sum
= check_sum(&buff
[1], buf_size
);
127 buff
[buf_size
++] = chk_sum
>> 8;
129 buff
[buf_size
++] = (chk_sum
& 0xff);
131 ret
= dvb_usbv2_generic_rw(d
, buff
, buf_size
, buff
, (mode
& 1) ?
136 rlen
= (mode
& 0x1) ? 0x1 : len
;
141 memcpy(data
, &buff
[3], rlen
);
150 static int it913x_wr_reg(struct dvb_usb_device
*d
, u8 pro
, u32 reg
, u8 data
)
155 ret
= it913x_io(d
, WRITE_LONG
, pro
,
156 CMD_DEMOD_WRITE
, reg
, 0, b
, sizeof(b
));
161 static int it913x_read_reg(struct dvb_usb_device
*d
, u32 reg
)
166 ret
= it913x_io(d
, READ_LONG
, DEV_0
,
167 CMD_DEMOD_READ
, reg
, 0, &data
[0], sizeof(data
));
169 return (ret
< 0) ? ret
: data
[0];
172 static int it913x_query(struct dvb_usb_device
*d
, u8 pro
)
174 struct it913x_state
*st
= d
->priv
;
179 for (i
= 0; i
< 5; i
++) {
180 ret
= it913x_io(d
, READ_LONG
, pro
, CMD_DEMOD_READ
,
181 0x1222, 0, &data
[0], 3);
183 if (ver
> 0 && ver
< 3)
188 if (ver
< 1 || ver
> 2) {
189 info("Failed to identify chip version applying 1");
190 st
->it913x_config
.chip_ver
= 0x1;
191 st
->it913x_config
.chip_type
= 0x9135;
195 st
->it913x_config
.chip_ver
= ver
;
196 st
->it913x_config
.chip_type
= (u16
)(data
[2] << 8) + data
[1];
198 info("Chip Version=%02x Chip Type=%04x", st
->it913x_config
.chip_ver
,
199 st
->it913x_config
.chip_type
);
201 ret
= it913x_io(d
, READ_SHORT
, pro
,
202 CMD_QUERYINFO
, 0, 0x1, &data
[0], 4);
204 st
->it913x_config
.firmware
= (data
[0] << 24) | (data
[1] << 16) |
205 (data
[2] << 8) | data
[3];
210 static int it913x_pid_filter_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
212 struct dvb_usb_device
*d
= adap_to_d(adap
);
213 struct it913x_state
*st
= adap_to_priv(adap
);
215 u8 pro
= (adap
->id
== 0) ? DEV_0_DMOD
: DEV_1_DMOD
;
217 mutex_lock(&d
->i2c_mutex
);
219 deb_info(1, "PID_C (%02x)", onoff
);
221 ret
= it913x_wr_reg(d
, pro
, PID_EN
, st
->pid_filter_onoff
);
223 mutex_unlock(&d
->i2c_mutex
);
227 static int it913x_pid_filter(struct dvb_usb_adapter
*adap
,
228 int index
, u16 pid
, int onoff
)
230 struct dvb_usb_device
*d
= adap_to_d(adap
);
231 struct it913x_state
*st
= adap_to_priv(adap
);
233 u8 pro
= (adap
->id
== 0) ? DEV_0_DMOD
: DEV_1_DMOD
;
235 mutex_lock(&d
->i2c_mutex
);
237 deb_info(1, "PID_F (%02x)", onoff
);
239 ret
= it913x_wr_reg(d
, pro
, PID_LSB
, (u8
)(pid
& 0xff));
241 ret
|= it913x_wr_reg(d
, pro
, PID_MSB
, (u8
)(pid
>> 8));
243 ret
|= it913x_wr_reg(d
, pro
, PID_INX_EN
, (u8
)onoff
);
245 ret
|= it913x_wr_reg(d
, pro
, PID_INX
, (u8
)(index
& 0x1f));
247 if (d
->udev
->speed
== USB_SPEED_HIGH
&& pid
== 0x2000) {
248 ret
|= it913x_wr_reg(d
, pro
, PID_EN
, !onoff
);
249 st
->pid_filter_onoff
= !onoff
;
251 st
->pid_filter_onoff
=
254 mutex_unlock(&d
->i2c_mutex
);
259 static int it913x_return_status(struct dvb_usb_device
*d
)
261 struct it913x_state
*st
= d
->priv
;
262 int ret
= it913x_query(d
, DEV_0
);
263 if (st
->it913x_config
.firmware
> 0)
264 info("Firmware Version %d", st
->it913x_config
.firmware
);
269 static int it913x_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[],
272 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
278 mutex_lock(&d
->i2c_mutex
);
280 deb_info(2, "num of messages %d address %02x", num
, msg
[0].addr
);
282 pro
= (msg
[0].addr
& 0x2) ? DEV_0_DMOD
: 0x0;
283 pro
|= (msg
[0].addr
& 0x20) ? DEV_1
: DEV_0
;
284 memcpy(data
, msg
[0].buf
, msg
[0].len
);
285 reg
= (data
[0] << 24) + (data
[1] << 16) +
286 (data
[2] << 8) + data
[3];
288 ret
= it913x_io(d
, READ_LONG
, pro
,
289 CMD_DEMOD_READ
, reg
, 0, data
, msg
[1].len
);
290 memcpy(msg
[1].buf
, data
, msg
[1].len
);
292 ret
= it913x_io(d
, WRITE_LONG
, pro
, CMD_DEMOD_WRITE
,
293 reg
, 0, &data
[4], msg
[0].len
- 4);
295 mutex_unlock(&d
->i2c_mutex
);
300 static u32
it913x_i2c_func(struct i2c_adapter
*adapter
)
305 static struct i2c_algorithm it913x_i2c_algo
= {
306 .master_xfer
= it913x_i2c_xfer
,
307 .functionality
= it913x_i2c_func
,
310 /* Callbacks for DVB USB */
311 #define IT913X_POLL 250
312 static int it913x_rc_query(struct dvb_usb_device
*d
)
317 /* Avoid conflict with frontends*/
318 mutex_lock(&d
->i2c_mutex
);
320 ret
= it913x_io(d
, READ_LONG
, PRO_LINK
, CMD_IR_GET
,
321 0, 0, &ibuf
[0], sizeof(ibuf
));
323 if ((ibuf
[2] + ibuf
[3]) == 0xff) {
325 key
+= ibuf
[0] << 16;
327 deb_info(1, "NEC Extended Key =%08x", key
);
328 if (d
->rc_dev
!= NULL
)
329 rc_keydown(d
->rc_dev
, key
, 0);
332 mutex_unlock(&d
->i2c_mutex
);
337 /* Firmware sets raw */
338 static const char fw_it9135_v1
[] = FW_IT9135_V1
;
339 static const char fw_it9135_v2
[] = FW_IT9135_V2
;
340 static const char fw_it9137
[] = FW_IT9137
;
342 static void ite_get_firmware_name(struct dvb_usb_device
*d
,
345 struct it913x_state
*st
= d
->priv
;
348 if (le16_to_cpu(d
->udev
->descriptor
.idVendor
) == USB_VID_KWORLD_2
)
350 else if (st
->it913x_config
.chip_ver
== 1)
356 if (dvb_usb_it913x_firmware
!= IT9135_AUTO
)
357 sw
= dvb_usb_it913x_firmware
;
361 st
->it913x_config
.firmware_ver
= 1;
362 st
->it913x_config
.adc_x2
= 1;
363 st
->it913x_config
.read_slevel
= false;
364 *name
= fw_it9135_v1
;
367 st
->it913x_config
.firmware_ver
= 1;
368 st
->it913x_config
.adc_x2
= 1;
369 st
->it913x_config
.read_slevel
= false;
370 *name
= fw_it9135_v2
;
371 switch (st
->it913x_config
.tuner_id_0
) {
376 info("Unknown tuner ID applying default 0x60");
378 st
->it913x_config
.tuner_id_0
= IT9135_60
;
383 st
->it913x_config
.firmware_ver
= 0;
384 st
->it913x_config
.adc_x2
= 0;
385 st
->it913x_config
.read_slevel
= true;
392 #define TS_MPEG_PKT_SIZE 188
394 #define TS_BUFFER_SIZE_PID (EP_LOW*TS_MPEG_PKT_SIZE)
396 #define TS_BUFFER_SIZE_MAX (EP_HIGH*TS_MPEG_PKT_SIZE)
398 static int it913x_get_stream_config(struct dvb_frontend
*fe
, u8
*ts_type
,
399 struct usb_data_stream_properties
*stream
)
401 struct dvb_usb_adapter
*adap
= fe_to_adap(fe
);
402 if (adap
->pid_filtering
)
403 stream
->u
.bulk
.buffersize
= TS_BUFFER_SIZE_PID
;
405 stream
->u
.bulk
.buffersize
= TS_BUFFER_SIZE_MAX
;
410 static int it913x_select_config(struct dvb_usb_device
*d
)
412 struct it913x_state
*st
= d
->priv
;
415 ret
= it913x_return_status(d
);
419 if (st
->it913x_config
.chip_ver
== 0x02
420 && st
->it913x_config
.chip_type
== 0x9135)
421 reg
= it913x_read_reg(d
, 0x461d);
423 reg
= it913x_read_reg(d
, 0x461b);
429 st
->it913x_config
.dual_mode
= 0;
430 st
->it913x_config
.tuner_id_0
= IT9135_38
;
431 st
->proprietary_ir
= true;
434 reg
= it913x_read_reg(d
, 0x49c5);
437 st
->it913x_config
.dual_mode
= reg
;
440 reg
= it913x_read_reg(d
, 0x49ac);
444 info("Remote propriety (raw) mode");
445 st
->proprietary_ir
= true;
446 } else if (reg
== 1) {
447 info("Remote HID mode NOT SUPPORTED");
448 st
->proprietary_ir
= false;
452 reg
= it913x_read_reg(d
, 0x49d0);
455 st
->it913x_config
.tuner_id_0
= reg
;
458 info("Dual mode=%x Tuner Type=%x", st
->it913x_config
.dual_mode
,
459 st
->it913x_config
.tuner_id_0
);
464 static int it913x_streaming_ctrl(struct dvb_frontend
*fe
, int onoff
)
466 struct dvb_usb_adapter
*adap
= fe_to_adap(fe
);
467 struct dvb_usb_device
*d
= adap_to_d(adap
);
468 struct it913x_state
*st
= fe_to_priv(fe
);
470 u8 pro
= (adap
->id
== 0) ? DEV_0_DMOD
: DEV_1_DMOD
;
472 deb_info(1, "STM (%02x)", onoff
);
475 mutex_lock(&d
->i2c_mutex
);
477 ret
= it913x_wr_reg(d
, pro
, PID_RST
, 0x1);
479 mutex_unlock(&d
->i2c_mutex
);
480 st
->pid_filter_onoff
=
488 static int it913x_identify_state(struct dvb_usb_device
*d
, const char **name
)
490 struct it913x_state
*st
= d
->priv
;
494 /* Read and select config */
495 ret
= it913x_select_config(d
);
499 ite_get_firmware_name(d
, name
);
501 if (st
->it913x_config
.firmware
> 0)
504 if (st
->it913x_config
.dual_mode
) {
505 st
->it913x_config
.tuner_id_1
= it913x_read_reg(d
, 0x49e0);
506 ret
= it913x_wr_reg(d
, DEV_0
, GPIOH1_EN
, 0x1);
507 ret
|= it913x_wr_reg(d
, DEV_0
, GPIOH1_ON
, 0x1);
508 ret
|= it913x_wr_reg(d
, DEV_0
, GPIOH1_O
, 0x1);
510 ret
|= it913x_wr_reg(d
, DEV_0
, GPIOH1_O
, 0x0);
512 reg
= it913x_read_reg(d
, GPIOH1_O
);
514 ret
|= it913x_wr_reg(d
, DEV_0
, GPIOH1_O
, 0x1);
515 ret
|= it913x_return_status(d
);
517 ret
= it913x_wr_reg(d
, DEV_0
,
522 reg
= it913x_read_reg(d
, IO_MUX_POWER_CLK
);
524 if (st
->it913x_config
.dual_mode
) {
525 ret
|= it913x_wr_reg(d
, DEV_0
, 0x4bfb, CHIP2_I2C_ADDR
);
526 if (st
->it913x_config
.firmware_ver
== 1)
527 ret
|= it913x_wr_reg(d
, DEV_0
, 0xcfff, 0x1);
529 ret
|= it913x_wr_reg(d
, DEV_0
, CLK_O_EN
, 0x1);
531 ret
|= it913x_wr_reg(d
, DEV_0
, 0x4bfb, 0x0);
532 if (st
->it913x_config
.firmware_ver
== 1)
533 ret
|= it913x_wr_reg(d
, DEV_0
, 0xcfff, 0x0);
535 ret
|= it913x_wr_reg(d
, DEV_0
, CLK_O_EN
, 0x0);
538 ret
|= it913x_wr_reg(d
, DEV_0
, I2C_CLK
, I2C_CLK_100
);
540 return (ret
< 0) ? ret
: COLD
;
543 static int it913x_download_firmware(struct dvb_usb_device
*d
,
544 const struct firmware
*fw
)
546 struct it913x_state
*st
= d
->priv
;
547 int ret
= 0, i
= 0, pos
= 0;
548 u8 packet_size
, min_pkt
;
551 ret
= it913x_wr_reg(d
, DEV_0
, I2C_CLK
, I2C_CLK_100
);
553 info("FRM Starting Firmware Download");
555 /* Multi firmware loader */
556 /* This uses scatter write firmware headers */
557 /* The firmware must start with 03 XX 00 */
558 /* and be the extact firmware length */
560 if (st
->it913x_config
.chip_ver
== 2)
565 while (i
<= fw
->size
) {
566 if (((fw
->data
[i
] == 0x3) && (fw
->data
[i
+ 2] == 0x0))
567 || (i
== fw
->size
)) {
568 packet_size
= i
- pos
;
569 if ((packet_size
> min_pkt
) || (i
== fw
->size
)) {
570 fw_data
= (u8
*)(fw
->data
+ pos
);
572 if (packet_size
> 0) {
573 ret
= it913x_io(d
, WRITE_DATA
,
574 DEV_0
, CMD_SCATTER_WRITE
, 0,
575 0, fw_data
, packet_size
);
586 info("FRM Firmware Download Failed (%d)" , ret
);
588 info("FRM Firmware Download Completed - Resetting Device");
592 ret
= it913x_io(d
, WRITE_CMD
, DEV_0
, CMD_BOOT
, 0, 0, NULL
, 0);
594 info("FRM Device not responding to reboot");
596 ret
= it913x_return_status(d
);
597 if (st
->it913x_config
.firmware
== 0) {
598 info("FRM Failed to reboot device");
604 ret
= it913x_wr_reg(d
, DEV_0
, I2C_CLK
, I2C_CLK_400
);
609 if (st
->it913x_config
.dual_mode
)
610 ret
|= it913x_wr_reg(d
, DEV_0_DMOD
, 0xec4c, 0xa0);
612 ret
|= it913x_wr_reg(d
, DEV_0_DMOD
, 0xec4c, 0x68);
614 if ((st
->it913x_config
.chip_ver
== 1) &&
615 (st
->it913x_config
.chip_type
== 0x9135)) {
616 ret
|= it913x_wr_reg(d
, DEV_0
, PADODPU
, 0x0);
617 ret
|= it913x_wr_reg(d
, DEV_0
, AGC_O_D
, 0x0);
618 if (st
->it913x_config
.dual_mode
) {
619 ret
|= it913x_wr_reg(d
, DEV_1
, PADODPU
, 0x0);
620 ret
|= it913x_wr_reg(d
, DEV_1
, AGC_O_D
, 0x0);
624 return (ret
< 0) ? -ENODEV
: 0;
627 static int it913x_name(struct dvb_usb_adapter
*adap
)
629 struct dvb_usb_device
*d
= adap_to_d(adap
);
630 const char *desc
= d
->name
;
631 char *fe_name
[] = {"_1", "_2", "_3", "_4"};
632 char *name
= adap
->fe
[0]->ops
.info
.name
;
634 strlcpy(name
, desc
, 128);
635 strlcat(name
, fe_name
[adap
->id
], 128);
640 static int it913x_frontend_attach(struct dvb_usb_adapter
*adap
)
642 struct dvb_usb_device
*d
= adap_to_d(adap
);
643 struct it913x_state
*st
= d
->priv
;
645 u8 adap_addr
= I2C_BASE_ADDR
+ (adap
->id
<< 5);
646 u16 ep_size
= adap
->stream
.buf_size
/ 4;
649 if (d
->udev
->speed
!= USB_SPEED_HIGH
)
652 st
->it913x_config
.adf
= it913x_read_reg(d
, IO_MUX_POWER_CLK
);
654 adap
->fe
[0] = dvb_attach(it913x_fe_attach
,
655 &d
->i2c_adap
, adap_addr
, &st
->it913x_config
);
657 if (adap
->id
== 0 && adap
->fe
[0]) {
658 it913x_wr_reg(d
, DEV_0_DMOD
, MP2_SW_RST
, 0x1);
659 it913x_wr_reg(d
, DEV_0_DMOD
, MP2IF2_SW_RST
, 0x1);
660 it913x_wr_reg(d
, DEV_0
, EP0_TX_EN
, 0x0f);
661 it913x_wr_reg(d
, DEV_0
, EP0_TX_NAK
, 0x1b);
662 it913x_wr_reg(d
, DEV_0
, EP0_TX_EN
, 0x2f);
663 it913x_wr_reg(d
, DEV_0
, EP4_TX_LEN_LSB
,
665 it913x_wr_reg(d
, DEV_0
, EP4_TX_LEN_MSB
, ep_size
>> 8);
666 ret
= it913x_wr_reg(d
, DEV_0
, EP4_MAX_PKT
, pkt_size
);
667 } else if (adap
->id
== 1 && adap
->fe
[0]) {
668 it913x_wr_reg(d
, DEV_0
, EP0_TX_EN
, 0x6f);
669 it913x_wr_reg(d
, DEV_0
, EP5_TX_LEN_LSB
,
671 it913x_wr_reg(d
, DEV_0
, EP5_TX_LEN_MSB
, ep_size
>> 8);
672 it913x_wr_reg(d
, DEV_0
, EP5_MAX_PKT
, pkt_size
);
673 it913x_wr_reg(d
, DEV_0_DMOD
, MP2IF2_EN
, 0x1);
674 it913x_wr_reg(d
, DEV_1_DMOD
, MP2IF_SERIAL
, 0x1);
675 it913x_wr_reg(d
, DEV_1
, TOP_HOSTB_SER_MODE
, 0x1);
676 it913x_wr_reg(d
, DEV_0_DMOD
, TSIS_ENABLE
, 0x1);
677 it913x_wr_reg(d
, DEV_0_DMOD
, MP2_SW_RST
, 0x0);
678 it913x_wr_reg(d
, DEV_0_DMOD
, MP2IF2_SW_RST
, 0x0);
679 it913x_wr_reg(d
, DEV_0_DMOD
, MP2IF2_HALF_PSB
, 0x0);
680 it913x_wr_reg(d
, DEV_0_DMOD
, MP2IF_STOP_EN
, 0x1);
681 it913x_wr_reg(d
, DEV_1_DMOD
, MPEG_FULL_SPEED
, 0x0);
682 ret
= it913x_wr_reg(d
, DEV_1_DMOD
, MP2IF_STOP_EN
, 0x0);
686 ret
|= it913x_name(adap
);
692 static int it913x_get_rc_config(struct dvb_usb_device
*d
, struct dvb_usb_rc
*rc
)
694 struct it913x_state
*st
= d
->priv
;
696 if (st
->proprietary_ir
== false) {
701 rc
->allowed_protos
= RC_BIT_NEC
;
702 rc
->query
= it913x_rc_query
;
708 static int it913x_get_adapter_count(struct dvb_usb_device
*d
)
710 struct it913x_state
*st
= d
->priv
;
711 if (st
->it913x_config
.dual_mode
)
716 static struct dvb_usb_device_properties it913x_properties
= {
717 .driver_name
= KBUILD_MODNAME
,
718 .owner
= THIS_MODULE
,
719 .bInterfaceNumber
= 0,
720 .generic_bulk_ctrl_endpoint
= 0x02,
721 .generic_bulk_ctrl_endpoint_response
= 0x81,
723 .adapter_nr
= adapter_nr
,
724 .size_of_priv
= sizeof(struct it913x_state
),
726 .identify_state
= it913x_identify_state
,
727 .i2c_algo
= &it913x_i2c_algo
,
729 .download_firmware
= it913x_download_firmware
,
731 .frontend_attach
= it913x_frontend_attach
,
732 .get_rc_config
= it913x_get_rc_config
,
733 .get_stream_config
= it913x_get_stream_config
,
734 .get_adapter_count
= it913x_get_adapter_count
,
735 .streaming_ctrl
= it913x_streaming_ctrl
,
740 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
741 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
742 .pid_filter_count
= 32,
743 .pid_filter
= it913x_pid_filter
,
744 .pid_filter_ctrl
= it913x_pid_filter_ctrl
,
746 DVB_USB_STREAM_BULK(0x84, 10, TS_BUFFER_SIZE_MAX
),
749 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
750 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
751 .pid_filter_count
= 32,
752 .pid_filter
= it913x_pid_filter
,
753 .pid_filter_ctrl
= it913x_pid_filter_ctrl
,
755 DVB_USB_STREAM_BULK(0x85, 10, TS_BUFFER_SIZE_MAX
),
760 static const struct usb_device_id it913x_id_table
[] = {
761 { DVB_USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_UB499_2T_T09
,
762 &it913x_properties
, "Kworld UB499-2T T09(IT9137)",
764 { DVB_USB_DEVICE(USB_VID_ITETECH
, USB_PID_ITETECH_IT9135
,
765 &it913x_properties
, "ITE 9135 Generic",
767 { DVB_USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_SVEON_STV22_IT9137
,
768 &it913x_properties
, "Sveon STV22 Dual DVB-T HDTV(IT9137)",
770 { DVB_USB_DEVICE(USB_VID_ITETECH
, USB_PID_ITETECH_IT9135_9005
,
771 &it913x_properties
, "ITE 9135(9005) Generic",
773 { DVB_USB_DEVICE(USB_VID_ITETECH
, USB_PID_ITETECH_IT9135_9006
,
774 &it913x_properties
, "ITE 9135(9006) Generic",
776 {} /* Terminating entry */
779 MODULE_DEVICE_TABLE(usb
, it913x_id_table
);
781 static struct usb_driver it913x_driver
= {
782 .name
= KBUILD_MODNAME
,
783 .probe
= dvb_usbv2_probe
,
784 .disconnect
= dvb_usbv2_disconnect
,
785 .suspend
= dvb_usbv2_suspend
,
786 .resume
= dvb_usbv2_resume
,
787 .id_table
= it913x_id_table
,
790 module_usb_driver(it913x_driver
);
792 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
793 MODULE_DESCRIPTION("it913x USB 2 Driver");
794 MODULE_VERSION("1.32");
795 MODULE_LICENSE("GPL");
796 MODULE_FIRMWARE(FW_IT9135_V1
);
797 MODULE_FIRMWARE(FW_IT9135_V2
);
798 MODULE_FIRMWARE(FW_IT9137
);