1 /* DVB USB compliant linux driver for IT9137
3 * Copyright (C) 2011 Malcolm Priestley (tvboxspy@gmail.com)
4 * IT9137 (C) ITE Tech Inc.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License Version 2, as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 * see Documentation/dvb/README.dvb-usb for more information
21 * see Documentation/dvb/it9137.txt for firmware information
24 #define DVB_USB_LOG_PREFIX "it913x"
26 #include <linux/usb.h>
27 #include <linux/usb/input.h>
28 #include <media/rc-core.h>
31 #include "it913x-fe.h"
34 static int dvb_usb_it913x_debug
;
35 #define l_dprintk(var, level, args...) do { \
37 printk(KERN_DEBUG DVB_USB_LOG_PREFIX ": " args); \
40 #define deb_info(level, args...) l_dprintk(dvb_usb_it913x_debug, level, args)
41 #define debug_data_snipet(level, name, p) \
42 deb_info(level, name" (%02x%02x%02x%02x%02x%02x%02x%02x)", \
43 *p, *(p+1), *(p+2), *(p+3), *(p+4), \
44 *(p+5), *(p+6), *(p+7));
47 module_param_named(debug
, dvb_usb_it913x_debug
, int, 0644);
48 MODULE_PARM_DESC(debug
, "set debugging level (1=info (or-able))."
49 DVB_USB_DEBUG_STATUS
);
51 static int pid_filter
;
52 module_param_named(pid
, pid_filter
, int, 0644);
53 MODULE_PARM_DESC(pid
, "set default 0=on 1=off");
55 static int dvb_usb_it913x_firmware
;
56 module_param_named(firmware
, dvb_usb_it913x_firmware
, int, 0644);
57 MODULE_PARM_DESC(firmware
, "set firmware 0=auto 1=IT9137 2=IT9135V1");
62 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
66 struct ite_config it913x_config
;
70 struct ite_config it913x_config
;
72 #define IT913X_RETRY 10
73 #define IT913X_SND_TIMEOUT 100
74 #define IT913X_RCV_TIMEOUT 200
76 static int it913x_bulk_write(struct usb_device
*dev
,
77 u8
*snd
, int len
, u8 pipe
)
81 for (i
= 0; i
< IT913X_RETRY
; i
++) {
82 ret
= usb_bulk_msg(dev
, usb_sndbulkpipe(dev
, pipe
),
83 snd
, len
, &actual_l
, IT913X_SND_TIMEOUT
);
84 if (ret
!= -EBUSY
&& ret
!= -ETIMEDOUT
)
88 if (len
!= actual_l
&& ret
== 0)
94 static int it913x_bulk_read(struct usb_device
*dev
,
95 u8
*rev
, int len
, u8 pipe
)
99 for (i
= 0; i
< IT913X_RETRY
; i
++) {
100 ret
= usb_bulk_msg(dev
, usb_rcvbulkpipe(dev
, pipe
),
101 rev
, len
, &actual_l
, IT913X_RCV_TIMEOUT
);
102 if (ret
!= -EBUSY
&& ret
!= -ETIMEDOUT
)
106 if (len
!= actual_l
&& ret
== 0)
112 static u16
check_sum(u8
*p
, u8 len
)
117 sum
+= (i
++ & 1) ? (*p
++) << 8 : *p
++;
121 static int it913x_usb_talk(struct usb_device
*udev
, u8 mode
, u8 pro
,
122 u8 cmd
, u32 reg
, u8 addr
, u8
*data
, u8 len
)
124 int ret
= 0, i
, buf_size
= 1;
129 buff
= kzalloc(256, GFP_KERNEL
);
131 info("USB Buffer Failed");
135 buff
[buf_size
++] = pro
;
136 buff
[buf_size
++] = cmd
;
137 buff
[buf_size
++] = cmd_counter
;
142 buff
[buf_size
++] = len
;
143 buff
[buf_size
++] = 2;
144 buff
[buf_size
++] = (reg
>> 24);
145 buff
[buf_size
++] = (reg
>> 16) & 0xff;
146 buff
[buf_size
++] = (reg
>> 8) & 0xff;
147 buff
[buf_size
++] = reg
& 0xff;
150 buff
[buf_size
++] = addr
;
153 buff
[buf_size
++] = len
;
154 buff
[buf_size
++] = addr
;
155 buff
[buf_size
++] = (reg
>> 8) & 0xff;
156 buff
[buf_size
++] = reg
& 0xff;
170 for (i
= 0; i
< len
; i
++)
171 buff
[buf_size
++] = data
[i
];
173 chk_sum
= check_sum(&buff
[1], buf_size
);
175 buff
[buf_size
++] = chk_sum
>> 8;
177 buff
[buf_size
++] = (chk_sum
& 0xff);
179 ret
= it913x_bulk_write(udev
, buff
, buf_size
, 0x02);
183 ret
= it913x_bulk_read(udev
, buff
, (mode
& 1) ?
188 rlen
= (mode
& 0x1) ? 0x1 : len
;
193 memcpy(data
, &buff
[3], rlen
);
202 static int it913x_io(struct usb_device
*udev
, u8 mode
, u8 pro
,
203 u8 cmd
, u32 reg
, u8 addr
, u8
*data
, u8 len
)
207 for (i
= 0; i
< IT913X_RETRY
; i
++) {
208 ret
= it913x_usb_talk(udev
, mode
, pro
,
209 cmd
, reg
, addr
, data
, len
);
217 static int it913x_wr_reg(struct usb_device
*udev
, u8 pro
, u32 reg
, u8 data
)
222 ret
= it913x_io(udev
, WRITE_LONG
, pro
,
223 CMD_DEMOD_WRITE
, reg
, 0, b
, sizeof(b
));
228 static int it913x_read_reg(struct usb_device
*udev
, u32 reg
)
233 ret
= it913x_io(udev
, READ_LONG
, DEV_0
,
234 CMD_DEMOD_READ
, reg
, 0, &data
[0], 1);
236 return (ret
< 0) ? ret
: data
[0];
239 static u32
it913x_query(struct usb_device
*udev
, u8 pro
)
245 for (i
= 0; i
< 5; i
++) {
246 ret
= it913x_io(udev
, READ_LONG
, pro
, CMD_DEMOD_READ
,
247 0x1222, 0, &data
[0], 3);
249 if (ver
> 0 && ver
< 3)
254 if (ver
< 1 || ver
> 2) {
255 info("Failed to identify chip version applying 1");
256 it913x_config
.chip_ver
= 0x1;
257 it913x_config
.chip_type
= 0x9135;
261 it913x_config
.chip_ver
= ver
;
262 it913x_config
.chip_type
= (u16
)(data
[2] << 8) + data
[1];
264 info("Chip Version=%02x Chip Type=%04x", it913x_config
.chip_ver
,
265 it913x_config
.chip_type
);
267 ret
|= it913x_io(udev
, READ_SHORT
, pro
,
268 CMD_QUERYINFO
, 0, 0x1, &data
[0], 4);
270 it913x_config
.firmware
= (data
[0] << 24) + (data
[1] << 16) +
271 (data
[2] << 8) + data
[3];
273 return (ret
< 0) ? 0 : it913x_config
.firmware
;
276 static int it913x_pid_filter_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
278 struct it913x_state
*st
= adap
->dev
->priv
;
279 struct usb_device
*udev
= adap
->dev
->udev
;
281 u8 pro
= (adap
->id
== 0) ? DEV_0_DMOD
: DEV_1_DMOD
;
283 mutex_lock(&adap
->dev
->i2c_mutex
);
285 deb_info(1, "PID_C (%02x)", onoff
);
287 ret
= it913x_wr_reg(udev
, pro
, PID_EN
, st
->pid_filter_onoff
);
289 mutex_unlock(&adap
->dev
->i2c_mutex
);
293 static int it913x_pid_filter(struct dvb_usb_adapter
*adap
,
294 int index
, u16 pid
, int onoff
)
296 struct it913x_state
*st
= adap
->dev
->priv
;
297 struct usb_device
*udev
= adap
->dev
->udev
;
299 u8 pro
= (adap
->id
== 0) ? DEV_0_DMOD
: DEV_1_DMOD
;
301 mutex_lock(&adap
->dev
->i2c_mutex
);
303 deb_info(1, "PID_F (%02x)", onoff
);
305 ret
= it913x_wr_reg(udev
, pro
, PID_LSB
, (u8
)(pid
& 0xff));
307 ret
|= it913x_wr_reg(udev
, pro
, PID_MSB
, (u8
)(pid
>> 8));
309 ret
|= it913x_wr_reg(udev
, pro
, PID_INX_EN
, (u8
)onoff
);
311 ret
|= it913x_wr_reg(udev
, pro
, PID_INX
, (u8
)(index
& 0x1f));
313 if (udev
->speed
== USB_SPEED_HIGH
&& pid
== 0x2000) {
314 ret
|= it913x_wr_reg(udev
, pro
, PID_EN
, !onoff
);
315 st
->pid_filter_onoff
= !onoff
;
317 st
->pid_filter_onoff
=
318 adap
->fe_adap
[adap
->active_fe
].pid_filtering
;
320 mutex_unlock(&adap
->dev
->i2c_mutex
);
325 static int it913x_return_status(struct usb_device
*udev
)
329 firm
= it913x_query(udev
, DEV_0
);
331 info("Firmware Version %d", firm
);
333 return (firm
> 0) ? firm
: 0;
336 static int it913x_i2c_xfer(struct i2c_adapter
*adap
, struct i2c_msg msg
[],
339 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
345 mutex_lock(&d
->i2c_mutex
);
347 debug_data_snipet(1, "Message out", msg
[0].buf
);
348 deb_info(2, "num of messages %d address %02x", num
, msg
[0].addr
);
350 pro
= (msg
[0].addr
& 0x2) ? DEV_0_DMOD
: 0x0;
351 pro
|= (msg
[0].addr
& 0x20) ? DEV_1
: DEV_0
;
352 memcpy(data
, msg
[0].buf
, msg
[0].len
);
353 reg
= (data
[0] << 24) + (data
[1] << 16) +
354 (data
[2] << 8) + data
[3];
356 ret
= it913x_io(d
->udev
, READ_LONG
, pro
,
357 CMD_DEMOD_READ
, reg
, 0, data
, msg
[1].len
);
358 memcpy(msg
[1].buf
, data
, msg
[1].len
);
360 ret
= it913x_io(d
->udev
, WRITE_LONG
, pro
, CMD_DEMOD_WRITE
,
361 reg
, 0, &data
[4], msg
[0].len
- 4);
363 mutex_unlock(&d
->i2c_mutex
);
368 static u32
it913x_i2c_func(struct i2c_adapter
*adapter
)
373 static struct i2c_algorithm it913x_i2c_algo
= {
374 .master_xfer
= it913x_i2c_xfer
,
375 .functionality
= it913x_i2c_func
,
378 /* Callbacks for DVB USB */
379 #define IT913X_POLL 250
380 static int it913x_rc_query(struct dvb_usb_device
*d
)
385 /* Avoid conflict with frontends*/
386 mutex_lock(&d
->i2c_mutex
);
388 ret
= it913x_io(d
->udev
, READ_LONG
, PRO_LINK
, CMD_IR_GET
,
389 0, 0, &ibuf
[0], sizeof(ibuf
));
391 if ((ibuf
[2] + ibuf
[3]) == 0xff) {
393 key
+= ibuf
[0] << 16;
395 deb_info(1, "NEC Extended Key =%08x", key
);
396 if (d
->rc_dev
!= NULL
)
397 rc_keydown(d
->rc_dev
, key
, 0);
400 mutex_unlock(&d
->i2c_mutex
);
405 /* Firmware sets raw */
406 const char fw_it9135_v1
[] = "dvb-usb-it9135-01.fw";
407 const char fw_it9135_v2
[] = "dvb-usb-it9135-02.fw";
408 const char fw_it9137
[] = "dvb-usb-it9137-01.fw";
410 static int ite_firmware_select(struct usb_device
*udev
,
411 struct dvb_usb_device_properties
*props
)
415 if (le16_to_cpu(udev
->descriptor
.idVendor
) == USB_VID_KWORLD_2
)
417 else if (it913x_config
.chip_ver
== 1)
423 if (dvb_usb_it913x_firmware
!= IT9135_AUTO
)
424 sw
= dvb_usb_it913x_firmware
;
428 it913x_config
.firmware_ver
= 1;
429 it913x_config
.adc_x2
= 1;
430 it913x_config
.read_slevel
= false;
431 props
->firmware
= fw_it9135_v1
;
434 it913x_config
.firmware_ver
= 1;
435 it913x_config
.adc_x2
= 1;
436 it913x_config
.read_slevel
= false;
437 props
->firmware
= fw_it9135_v2
;
438 switch (it913x_config
.tuner_id_0
) {
443 info("Unknown tuner ID applying default 0x60");
445 it913x_config
.tuner_id_0
= IT9135_60
;
450 it913x_config
.firmware_ver
= 0;
451 it913x_config
.adc_x2
= 0;
452 it913x_config
.read_slevel
= true;
453 props
->firmware
= fw_it9137
;
459 static void it913x_select_remote(struct usb_device
*udev
,
460 struct dvb_usb_device_properties
*props
)
462 switch (le16_to_cpu(udev
->descriptor
.idProduct
)) {
463 case USB_PID_ITETECH_IT9135_9005
:
464 props
->rc
.core
.rc_codes
= RC_MAP_IT913X_V2
;
467 props
->rc
.core
.rc_codes
= RC_MAP_IT913X_V1
;
472 #define TS_MPEG_PKT_SIZE 188
474 #define TS_BUFFER_SIZE_PID (EP_LOW*TS_MPEG_PKT_SIZE)
476 #define TS_BUFFER_SIZE_MAX (EP_HIGH*TS_MPEG_PKT_SIZE)
478 static int it913x_select_config(struct usb_device
*udev
,
479 struct dvb_usb_device_properties
*props
)
482 bool proprietary_ir
= false;
484 if (it913x_config
.chip_ver
== 0x02
485 && it913x_config
.chip_type
== 0x9135)
486 reg
= it913x_read_reg(udev
, 0x461d);
488 reg
= it913x_read_reg(udev
, 0x461b);
494 it913x_config
.dual_mode
= 0;
495 it913x_config
.tuner_id_0
= IT9135_38
;
496 proprietary_ir
= true;
499 reg
= it913x_read_reg(udev
, 0x49c5);
502 it913x_config
.dual_mode
= reg
;
505 reg
= it913x_read_reg(udev
, 0x49ac);
509 info("Remote propriety (raw) mode");
510 proprietary_ir
= true;
511 } else if (reg
== 1) {
512 info("Remote HID mode NOT SUPPORTED");
513 proprietary_ir
= false;
514 props
->rc
.core
.rc_codes
= NULL
;
516 props
->rc
.core
.rc_codes
= NULL
;
519 reg
= it913x_read_reg(udev
, 0x49d0);
522 it913x_config
.tuner_id_0
= reg
;
526 it913x_select_remote(udev
, props
);
528 if (udev
->speed
!= USB_SPEED_HIGH
) {
529 props
->adapter
[0].fe
[0].pid_filter_count
= 5;
530 info("USB 1 low speed mode - connect to USB 2 port");
533 if (it913x_config
.dual_mode
) {
534 it913x_config
.dual_mode
= 0;
535 info("Dual mode not supported in USB 1");
537 } else /* For replugging */
538 if(props
->adapter
[0].fe
[0].pid_filter_count
== 5)
539 props
->adapter
[0].fe
[0].pid_filter_count
= 31;
541 /* Select Stream Buffer Size and pid filter option*/
543 props
->adapter
[0].fe
[0].stream
.u
.bulk
.buffersize
=
545 props
->adapter
[0].fe
[0].caps
&=
546 ~DVB_USB_ADAP_NEED_PID_FILTERING
;
548 props
->adapter
[0].fe
[0].stream
.u
.bulk
.buffersize
=
551 if (it913x_config
.dual_mode
) {
552 props
->adapter
[1].fe
[0].stream
.u
.bulk
.buffersize
=
553 props
->adapter
[0].fe
[0].stream
.u
.bulk
.buffersize
;
554 props
->num_adapters
= 2;
556 props
->adapter
[1].fe
[0].caps
=
557 props
->adapter
[0].fe
[0].caps
;
559 props
->num_adapters
= 1;
561 info("Dual mode=%x Tuner Type=%x", it913x_config
.dual_mode
,
562 it913x_config
.tuner_id_0
);
564 ret
= ite_firmware_select(udev
, props
);
569 static int it913x_identify_state(struct usb_device
*udev
,
570 struct dvb_usb_device_properties
*props
,
571 struct dvb_usb_device_description
**desc
,
574 int ret
= 0, firm_no
;
577 firm_no
= it913x_return_status(udev
);
579 /* Read and select config */
580 ret
= it913x_select_config(udev
, props
);
589 if (it913x_config
.dual_mode
) {
590 it913x_config
.tuner_id_1
= it913x_read_reg(udev
, 0x49e0);
591 ret
= it913x_wr_reg(udev
, DEV_0
, GPIOH1_EN
, 0x1);
592 ret
|= it913x_wr_reg(udev
, DEV_0
, GPIOH1_ON
, 0x1);
593 ret
|= it913x_wr_reg(udev
, DEV_0
, GPIOH1_O
, 0x1);
595 ret
|= it913x_wr_reg(udev
, DEV_0
, GPIOH1_O
, 0x0);
597 reg
= it913x_read_reg(udev
, GPIOH1_O
);
599 ret
|= it913x_wr_reg(udev
, DEV_0
, GPIOH1_O
, 0x1);
600 ret
|= it913x_return_status(udev
);
602 ret
= it913x_wr_reg(udev
, DEV_0
,
607 reg
= it913x_read_reg(udev
, IO_MUX_POWER_CLK
);
609 if (it913x_config
.dual_mode
) {
610 ret
|= it913x_wr_reg(udev
, DEV_0
, 0x4bfb, CHIP2_I2C_ADDR
);
611 if (it913x_config
.firmware_ver
== 1)
612 ret
|= it913x_wr_reg(udev
, DEV_0
, 0xcfff, 0x1);
614 ret
|= it913x_wr_reg(udev
, DEV_0
, CLK_O_EN
, 0x1);
616 ret
|= it913x_wr_reg(udev
, DEV_0
, 0x4bfb, 0x0);
617 if (it913x_config
.firmware_ver
== 1)
618 ret
|= it913x_wr_reg(udev
, DEV_0
, 0xcfff, 0x0);
620 ret
|= it913x_wr_reg(udev
, DEV_0
, CLK_O_EN
, 0x0);
625 return (ret
< 0) ? -ENODEV
: 0;
628 static int it913x_streaming_ctrl(struct dvb_usb_adapter
*adap
, int onoff
)
630 struct it913x_state
*st
= adap
->dev
->priv
;
632 u8 pro
= (adap
->id
== 0) ? DEV_0_DMOD
: DEV_1_DMOD
;
634 deb_info(1, "STM (%02x)", onoff
);
637 mutex_lock(&adap
->dev
->i2c_mutex
);
639 ret
= it913x_wr_reg(adap
->dev
->udev
, pro
, PID_RST
, 0x1);
641 mutex_unlock(&adap
->dev
->i2c_mutex
);
642 st
->pid_filter_onoff
=
643 adap
->fe_adap
[adap
->active_fe
].pid_filtering
;
650 static int it913x_download_firmware(struct usb_device
*udev
,
651 const struct firmware
*fw
)
653 int ret
= 0, i
= 0, pos
= 0;
654 u8 packet_size
, min_pkt
;
657 ret
= it913x_wr_reg(udev
, DEV_0
, I2C_CLK
, I2C_CLK_100
);
659 info("FRM Starting Firmware Download");
661 /* Multi firmware loader */
662 /* This uses scatter write firmware headers */
663 /* The firmware must start with 03 XX 00 */
664 /* and be the extact firmware length */
666 if (it913x_config
.chip_ver
== 2)
671 while (i
<= fw
->size
) {
672 if (((fw
->data
[i
] == 0x3) && (fw
->data
[i
+ 2] == 0x0))
673 || (i
== fw
->size
)) {
674 packet_size
= i
- pos
;
675 if ((packet_size
> min_pkt
) || (i
== fw
->size
)) {
676 fw_data
= (u8
*)(fw
->data
+ pos
);
678 if (packet_size
> 0) {
679 ret
= it913x_io(udev
, WRITE_DATA
,
680 DEV_0
, CMD_SCATTER_WRITE
, 0,
681 0, fw_data
, packet_size
);
692 info("FRM Firmware Download Failed (%d)" , ret
);
694 info("FRM Firmware Download Completed - Resetting Device");
698 ret
= it913x_io(udev
, WRITE_CMD
, DEV_0
, CMD_BOOT
, 0, 0, NULL
, 0);
700 info("FRM Device not responding to reboot");
702 ret
= it913x_return_status(udev
);
704 info("FRM Failed to reboot device");
710 ret
= it913x_wr_reg(udev
, DEV_0
, I2C_CLK
, I2C_CLK_400
);
715 if (it913x_config
.dual_mode
)
716 ret
|= it913x_wr_reg(udev
, DEV_0_DMOD
, 0xec4c, 0xa0);
718 ret
|= it913x_wr_reg(udev
, DEV_0_DMOD
, 0xec4c, 0x68);
720 if ((it913x_config
.chip_ver
== 1) &&
721 (it913x_config
.chip_type
== 0x9135)) {
722 ret
|= it913x_wr_reg(udev
, DEV_0
, PADODPU
, 0x0);
723 ret
|= it913x_wr_reg(udev
, DEV_0
, AGC_O_D
, 0x0);
724 if (it913x_config
.dual_mode
) {
725 ret
|= it913x_wr_reg(udev
, DEV_1
, PADODPU
, 0x0);
726 ret
|= it913x_wr_reg(udev
, DEV_1
, AGC_O_D
, 0x0);
730 return (ret
< 0) ? -ENODEV
: 0;
733 static int it913x_name(struct dvb_usb_adapter
*adap
)
735 const char *desc
= adap
->dev
->desc
->name
;
736 char *fe_name
[] = {"_1", "_2", "_3", "_4"};
737 char *name
= adap
->fe_adap
[0].fe
->ops
.info
.name
;
739 strlcpy(name
, desc
, 128);
740 strlcat(name
, fe_name
[adap
->id
], 128);
745 static int it913x_frontend_attach(struct dvb_usb_adapter
*adap
)
747 struct usb_device
*udev
= adap
->dev
->udev
;
748 struct it913x_state
*st
= adap
->dev
->priv
;
750 u8 adap_addr
= I2C_BASE_ADDR
+ (adap
->id
<< 5);
751 u16 ep_size
= adap
->props
.fe
[0].stream
.u
.bulk
.buffersize
/ 4;
754 if (adap
->dev
->udev
->speed
!= USB_SPEED_HIGH
)
757 it913x_config
.adf
= it913x_read_reg(udev
, IO_MUX_POWER_CLK
);
760 memcpy(&st
->it913x_config
, &it913x_config
,
761 sizeof(struct ite_config
));
763 adap
->fe_adap
[0].fe
= dvb_attach(it913x_fe_attach
,
764 &adap
->dev
->i2c_adap
, adap_addr
, &st
->it913x_config
);
766 if (adap
->id
== 0 && adap
->fe_adap
[0].fe
) {
767 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2_SW_RST
, 0x1);
768 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2IF2_SW_RST
, 0x1);
769 ret
= it913x_wr_reg(udev
, DEV_0
, EP0_TX_EN
, 0x0f);
770 ret
= it913x_wr_reg(udev
, DEV_0
, EP0_TX_NAK
, 0x1b);
771 ret
= it913x_wr_reg(udev
, DEV_0
, EP0_TX_EN
, 0x2f);
772 ret
= it913x_wr_reg(udev
, DEV_0
, EP4_TX_LEN_LSB
,
774 ret
= it913x_wr_reg(udev
, DEV_0
, EP4_TX_LEN_MSB
, ep_size
>> 8);
775 ret
= it913x_wr_reg(udev
, DEV_0
, EP4_MAX_PKT
, pkt_size
);
776 } else if (adap
->id
== 1 && adap
->fe_adap
[0].fe
) {
777 ret
= it913x_wr_reg(udev
, DEV_0
, EP0_TX_EN
, 0x6f);
778 ret
= it913x_wr_reg(udev
, DEV_0
, EP5_TX_LEN_LSB
,
780 ret
= it913x_wr_reg(udev
, DEV_0
, EP5_TX_LEN_MSB
, ep_size
>> 8);
781 ret
= it913x_wr_reg(udev
, DEV_0
, EP5_MAX_PKT
, pkt_size
);
782 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2IF2_EN
, 0x1);
783 ret
= it913x_wr_reg(udev
, DEV_1_DMOD
, MP2IF_SERIAL
, 0x1);
784 ret
= it913x_wr_reg(udev
, DEV_1
, TOP_HOSTB_SER_MODE
, 0x1);
785 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, TSIS_ENABLE
, 0x1);
786 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2_SW_RST
, 0x0);
787 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2IF2_SW_RST
, 0x0);
788 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2IF2_HALF_PSB
, 0x0);
789 ret
= it913x_wr_reg(udev
, DEV_0_DMOD
, MP2IF_STOP_EN
, 0x1);
790 ret
= it913x_wr_reg(udev
, DEV_1_DMOD
, MPEG_FULL_SPEED
, 0x0);
791 ret
= it913x_wr_reg(udev
, DEV_1_DMOD
, MP2IF_STOP_EN
, 0x0);
795 ret
= it913x_name(adap
);
801 static struct dvb_usb_device_properties it913x_properties
;
803 static int it913x_probe(struct usb_interface
*intf
,
804 const struct usb_device_id
*id
)
807 if (0 == dvb_usb_device_init(intf
, &it913x_properties
,
808 THIS_MODULE
, NULL
, adapter_nr
)) {
809 info("DEV registering device driver");
813 info("DEV it913x Error");
818 static struct usb_device_id it913x_table
[] = {
819 { USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_KWORLD_UB499_2T_T09
) },
820 { USB_DEVICE(USB_VID_ITETECH
, USB_PID_ITETECH_IT9135
) },
821 { USB_DEVICE(USB_VID_KWORLD_2
, USB_PID_SVEON_STV22_IT9137
) },
822 { USB_DEVICE(USB_VID_ITETECH
, USB_PID_ITETECH_IT9135_9005
) },
823 { USB_DEVICE(USB_VID_ITETECH
, USB_PID_ITETECH_IT9135_9006
) },
824 {} /* Terminating entry */
827 MODULE_DEVICE_TABLE(usb
, it913x_table
);
829 static struct dvb_usb_device_properties it913x_properties
= {
830 .caps
= DVB_USB_IS_AN_I2C_ADAPTER
,
831 .usb_ctrl
= DEVICE_SPECIFIC
,
832 .download_firmware
= it913x_download_firmware
,
833 .firmware
= "dvb-usb-it9137-01.fw",
835 .size_of_priv
= sizeof(struct it913x_state
),
841 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
842 DVB_USB_ADAP_NEED_PID_FILTERING
|
843 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
844 .streaming_ctrl
= it913x_streaming_ctrl
,
845 .pid_filter_count
= 31,
846 .pid_filter
= it913x_pid_filter
,
847 .pid_filter_ctrl
= it913x_pid_filter_ctrl
,
848 .frontend_attach
= it913x_frontend_attach
,
849 /* parameter for the MPEG2-data transfer */
854 .u
= {/* Keep Low if PID filter on */
866 .caps
= DVB_USB_ADAP_HAS_PID_FILTER
|
867 DVB_USB_ADAP_NEED_PID_FILTERING
|
868 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF
,
869 .streaming_ctrl
= it913x_streaming_ctrl
,
870 .pid_filter_count
= 31,
871 .pid_filter
= it913x_pid_filter
,
872 .pid_filter_ctrl
= it913x_pid_filter_ctrl
,
873 .frontend_attach
= it913x_frontend_attach
,
874 /* parameter for the MPEG2-data transfer */
889 .identify_state
= it913x_identify_state
,
891 .protocol
= RC_TYPE_NEC
,
892 .module_name
= "it913x",
893 .rc_query
= it913x_rc_query
,
894 .rc_interval
= IT913X_POLL
,
895 .allowed_protos
= RC_TYPE_NEC
,
896 .rc_codes
= RC_MAP_IT913X_V1
,
898 .i2c_algo
= &it913x_i2c_algo
,
899 .num_device_descs
= 5,
901 { "Kworld UB499-2T T09(IT9137)",
902 { &it913x_table
[0], NULL
},
904 { "ITE 9135 Generic",
905 { &it913x_table
[1], NULL
},
907 { "Sveon STV22 Dual DVB-T HDTV(IT9137)",
908 { &it913x_table
[2], NULL
},
910 { "ITE 9135(9005) Generic",
911 { &it913x_table
[3], NULL
},
913 { "ITE 9135(9006) Generic",
914 { &it913x_table
[4], NULL
},
919 static struct usb_driver it913x_driver
= {
921 .probe
= it913x_probe
,
922 .disconnect
= dvb_usb_device_exit
,
923 .id_table
= it913x_table
,
926 module_usb_driver(it913x_driver
);
928 MODULE_AUTHOR("Malcolm Priestley <tvboxspy@gmail.com>");
929 MODULE_DESCRIPTION("it913x USB 2 Driver");
930 MODULE_VERSION("1.28");
931 MODULE_LICENSE("GPL");