2 * Afatech AF9035 DVB USB driver
4 * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
5 * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
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 along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr
);
26 static u16
af9035_checksum(const u8
*buf
, size_t len
)
31 for (i
= 1; i
< len
; i
++) {
33 checksum
+= buf
[i
] << 8;
42 static int af9035_ctrl_msg(struct dvb_usb_device
*d
, struct usb_req
*req
)
45 #define REQ_HDR_LEN 4 /* send header size */
46 #define ACK_HDR_LEN 3 /* rece header size */
47 #define CHECKSUM_LEN 2
48 #define USB_TIMEOUT 2000
49 struct state
*state
= d_to_priv(d
);
52 u16 checksum
, tmp_checksum
;
54 /* buffer overflow check */
55 if (req
->wlen
> (BUF_LEN
- REQ_HDR_LEN
- CHECKSUM_LEN
) ||
56 req
->rlen
> (BUF_LEN
- ACK_HDR_LEN
- CHECKSUM_LEN
)) {
57 dev_err(&d
->udev
->dev
, "%s: too much data wlen=%d rlen=%d\n",
58 __func__
, req
->wlen
, req
->rlen
);
62 buf
[0] = REQ_HDR_LEN
+ req
->wlen
+ CHECKSUM_LEN
- 1;
65 buf
[3] = state
->seq
++;
66 memcpy(&buf
[REQ_HDR_LEN
], req
->wbuf
, req
->wlen
);
68 wlen
= REQ_HDR_LEN
+ req
->wlen
+ CHECKSUM_LEN
;
69 rlen
= ACK_HDR_LEN
+ req
->rlen
+ CHECKSUM_LEN
;
71 /* calc and add checksum */
72 checksum
= af9035_checksum(buf
, buf
[0] - 1);
73 buf
[buf
[0] - 1] = (checksum
>> 8);
74 buf
[buf
[0] - 0] = (checksum
& 0xff);
76 /* no ack for these packets */
77 if (req
->cmd
== CMD_FW_DL
)
80 ret
= dvb_usbv2_generic_rw(d
, buf
, wlen
, buf
, rlen
);
84 /* no ack for those packets */
85 if (req
->cmd
== CMD_FW_DL
)
89 checksum
= af9035_checksum(buf
, rlen
- 2);
90 tmp_checksum
= (buf
[rlen
- 2] << 8) | buf
[rlen
- 1];
91 if (tmp_checksum
!= checksum
) {
92 dev_err(&d
->udev
->dev
, "%s: command=%02x checksum mismatch " \
93 "(%04x != %04x)\n", KBUILD_MODNAME
, req
->cmd
,
94 tmp_checksum
, checksum
);
101 dev_dbg(&d
->udev
->dev
, "%s: command=%02x failed fw error=%d\n",
102 __func__
, req
->cmd
, buf
[2]);
107 /* read request, copy returned data to return buf */
109 memcpy(req
->rbuf
, &buf
[ACK_HDR_LEN
], req
->rlen
);
115 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
120 /* write multiple registers */
121 static int af9035_wr_regs(struct dvb_usb_device
*d
, u32 reg
, u8
*val
, int len
)
124 u8 mbox
= (reg
>> 16) & 0xff;
125 struct usb_req req
= { CMD_MEM_WR
, mbox
, sizeof(wbuf
), wbuf
, 0, NULL
};
131 wbuf
[4] = (reg
>> 8) & 0xff;
132 wbuf
[5] = (reg
>> 0) & 0xff;
133 memcpy(&wbuf
[6], val
, len
);
135 return af9035_ctrl_msg(d
, &req
);
138 /* read multiple registers */
139 static int af9035_rd_regs(struct dvb_usb_device
*d
, u32 reg
, u8
*val
, int len
)
141 u8 wbuf
[] = { len
, 2, 0, 0, (reg
>> 8) & 0xff, reg
& 0xff };
142 u8 mbox
= (reg
>> 16) & 0xff;
143 struct usb_req req
= { CMD_MEM_RD
, mbox
, sizeof(wbuf
), wbuf
, len
, val
};
145 return af9035_ctrl_msg(d
, &req
);
148 /* write single register */
149 static int af9035_wr_reg(struct dvb_usb_device
*d
, u32 reg
, u8 val
)
151 return af9035_wr_regs(d
, reg
, &val
, 1);
154 /* read single register */
155 static int af9035_rd_reg(struct dvb_usb_device
*d
, u32 reg
, u8
*val
)
157 return af9035_rd_regs(d
, reg
, val
, 1);
160 /* write single register with mask */
161 static int af9035_wr_reg_mask(struct dvb_usb_device
*d
, u32 reg
, u8 val
,
167 /* no need for read if whole reg is written */
169 ret
= af9035_rd_regs(d
, reg
, &tmp
, 1);
178 return af9035_wr_regs(d
, reg
, &val
, 1);
181 static int af9035_i2c_master_xfer(struct i2c_adapter
*adap
,
182 struct i2c_msg msg
[], int num
)
184 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
185 struct state
*state
= d_to_priv(d
);
188 if (mutex_lock_interruptible(&d
->i2c_mutex
) < 0)
192 * I2C sub header is 5 bytes long. Meaning of those bytes are:
196 * byte 3 and 4 can be used as reg addr
198 * used when reg addr len is set to 2
200 * used when reg addr len is set to 1 or 2
202 * For the simplify we do not use register addr at all.
203 * NOTE: As a firmware knows tuner type there is very small possibility
204 * there could be some tuner I2C hacks done by firmware and this may
205 * lead problems if firmware expects those bytes are used.
207 if (num
== 2 && !(msg
[0].flags
& I2C_M_RD
) &&
208 (msg
[1].flags
& I2C_M_RD
)) {
209 if (msg
[0].len
> 40 || msg
[1].len
> 40) {
210 /* TODO: correct limits > 40 */
212 } else if (msg
[0].addr
== state
->af9033_config
[0].i2c_addr
) {
213 /* integrated demod */
214 u32 reg
= msg
[0].buf
[0] << 16 | msg
[0].buf
[1] << 8 |
216 ret
= af9035_rd_regs(d
, reg
, &msg
[1].buf
[0],
220 u8 buf
[5 + msg
[0].len
];
221 struct usb_req req
= { CMD_I2C_RD
, 0, sizeof(buf
),
222 buf
, msg
[1].len
, msg
[1].buf
};
224 buf
[1] = msg
[0].addr
<< 1;
225 buf
[2] = 0x00; /* reg addr len */
226 buf
[3] = 0x00; /* reg addr MSB */
227 buf
[4] = 0x00; /* reg addr LSB */
228 memcpy(&buf
[5], msg
[0].buf
, msg
[0].len
);
229 ret
= af9035_ctrl_msg(d
, &req
);
231 } else if (num
== 1 && !(msg
[0].flags
& I2C_M_RD
)) {
232 if (msg
[0].len
> 40) {
233 /* TODO: correct limits > 40 */
235 } else if (msg
[0].addr
== state
->af9033_config
[0].i2c_addr
) {
236 /* integrated demod */
237 u32 reg
= msg
[0].buf
[0] << 16 | msg
[0].buf
[1] << 8 |
239 ret
= af9035_wr_regs(d
, reg
, &msg
[0].buf
[3],
243 u8 buf
[5 + msg
[0].len
];
244 struct usb_req req
= { CMD_I2C_WR
, 0, sizeof(buf
), buf
,
247 buf
[1] = msg
[0].addr
<< 1;
248 buf
[2] = 0x00; /* reg addr len */
249 buf
[3] = 0x00; /* reg addr MSB */
250 buf
[4] = 0x00; /* reg addr LSB */
251 memcpy(&buf
[5], msg
[0].buf
, msg
[0].len
);
252 ret
= af9035_ctrl_msg(d
, &req
);
256 * We support only two kind of I2C transactions:
257 * 1) 1 x read + 1 x write
263 mutex_unlock(&d
->i2c_mutex
);
271 static u32
af9035_i2c_functionality(struct i2c_adapter
*adapter
)
276 static struct i2c_algorithm af9035_i2c_algo
= {
277 .master_xfer
= af9035_i2c_master_xfer
,
278 .functionality
= af9035_i2c_functionality
,
281 static int af9035_identify_state(struct dvb_usb_device
*d
, const char **name
)
286 struct usb_req req
= { CMD_FW_QUERYINFO
, 0, sizeof(wbuf
), wbuf
,
287 sizeof(rbuf
), rbuf
};
289 ret
= af9035_ctrl_msg(d
, &req
);
293 dev_dbg(&d
->udev
->dev
, "%s: reply=%*ph\n", __func__
, 4, rbuf
);
294 if (rbuf
[0] || rbuf
[1] || rbuf
[2] || rbuf
[3])
302 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
307 static int af9035_download_firmware(struct dvb_usb_device
*d
,
308 const struct firmware
*fw
)
313 struct usb_req req
= { 0, 0, 0, NULL
, 0, NULL
};
314 struct usb_req req_fw_dl
= { CMD_FW_DL
, 0, 0, wbuf
, 0, NULL
};
315 struct usb_req req_fw_ver
= { CMD_FW_QUERYINFO
, 0, 1, wbuf
, 4, rbuf
} ;
317 u16 hdr_addr
, hdr_data_len
, hdr_checksum
;
322 * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info!
324 * byte 0: MCS 51 core
325 * There are two inside the AF9035 (1=Link and 2=OFDM) with separate
327 * byte 1-2: Big endian destination address
328 * byte 3-4: Big endian number of data bytes following the header
329 * byte 5-6: Big endian header checksum, apparently ignored by the chip
330 * Calculated as ~(h[0]*256+h[1]+h[2]*256+h[3]+h[4]*256)
333 for (i
= fw
->size
; i
> HDR_SIZE
;) {
334 hdr_core
= fw
->data
[fw
->size
- i
+ 0];
335 hdr_addr
= fw
->data
[fw
->size
- i
+ 1] << 8;
336 hdr_addr
|= fw
->data
[fw
->size
- i
+ 2] << 0;
337 hdr_data_len
= fw
->data
[fw
->size
- i
+ 3] << 8;
338 hdr_data_len
|= fw
->data
[fw
->size
- i
+ 4] << 0;
339 hdr_checksum
= fw
->data
[fw
->size
- i
+ 5] << 8;
340 hdr_checksum
|= fw
->data
[fw
->size
- i
+ 6] << 0;
342 dev_dbg(&d
->udev
->dev
, "%s: core=%d addr=%04x data_len=%d " \
343 "checksum=%04x\n", __func__
, hdr_core
, hdr_addr
,
344 hdr_data_len
, hdr_checksum
);
346 if (((hdr_core
!= 1) && (hdr_core
!= 2)) ||
347 (hdr_data_len
> i
)) {
348 dev_dbg(&d
->udev
->dev
, "%s: bad firmware\n", __func__
);
352 /* download begin packet */
353 req
.cmd
= CMD_FW_DL_BEGIN
;
354 ret
= af9035_ctrl_msg(d
, &req
);
358 /* download firmware packet(s) */
359 for (j
= HDR_SIZE
+ hdr_data_len
; j
> 0; j
-= MAX_DATA
) {
363 req_fw_dl
.wlen
= len
;
364 req_fw_dl
.wbuf
= (u8
*) &fw
->data
[fw
->size
- i
+
365 HDR_SIZE
+ hdr_data_len
- j
];
366 ret
= af9035_ctrl_msg(d
, &req_fw_dl
);
371 /* download end packet */
372 req
.cmd
= CMD_FW_DL_END
;
373 ret
= af9035_ctrl_msg(d
, &req
);
377 i
-= hdr_data_len
+ HDR_SIZE
;
379 dev_dbg(&d
->udev
->dev
, "%s: data uploaded=%zu\n",
380 __func__
, fw
->size
- i
);
383 /* firmware loaded, request boot */
384 req
.cmd
= CMD_FW_BOOT
;
385 ret
= af9035_ctrl_msg(d
, &req
);
389 /* ensure firmware starts */
391 ret
= af9035_ctrl_msg(d
, &req_fw_ver
);
395 if (!(rbuf
[0] || rbuf
[1] || rbuf
[2] || rbuf
[3])) {
396 dev_err(&d
->udev
->dev
, "%s: firmware did not run\n",
402 dev_info(&d
->udev
->dev
, "%s: firmware version=%d.%d.%d.%d",
403 KBUILD_MODNAME
, rbuf
[0], rbuf
[1], rbuf
[2], rbuf
[3]);
408 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
413 static int af9035_download_firmware_it9135(struct dvb_usb_device
*d
,
414 const struct firmware
*fw
)
419 struct usb_req req
= { 0, 0, 0, NULL
, 0, NULL
};
420 struct usb_req req_fw_dl
= { CMD_FW_SCATTER_WR
, 0, 0, NULL
, 0, NULL
};
421 struct usb_req req_fw_ver
= { CMD_FW_QUERYINFO
, 0, 1, wbuf
, 4, rbuf
} ;
425 * There seems to be following firmware header. Meaning of bytes 0-3
434 * 6: count of data bytes ?
437 for (i
= HDR_SIZE
, i_prev
= 0; i
<= fw
->size
; i
++) {
439 (fw
->data
[i
+ 0] == 0x03 &&
440 (fw
->data
[i
+ 1] == 0x00 ||
441 fw
->data
[i
+ 1] == 0x01) &&
442 fw
->data
[i
+ 2] == 0x00)) {
443 req_fw_dl
.wlen
= i
- i_prev
;
444 req_fw_dl
.wbuf
= (u8
*) &fw
->data
[i_prev
];
446 ret
= af9035_ctrl_msg(d
, &req_fw_dl
);
450 dev_dbg(&d
->udev
->dev
, "%s: data uploaded=%d\n",
455 /* firmware loaded, request boot */
456 req
.cmd
= CMD_FW_BOOT
;
457 ret
= af9035_ctrl_msg(d
, &req
);
461 /* ensure firmware starts */
463 ret
= af9035_ctrl_msg(d
, &req_fw_ver
);
467 if (!(rbuf
[0] || rbuf
[1] || rbuf
[2] || rbuf
[3])) {
468 dev_err(&d
->udev
->dev
, "%s: firmware did not run\n",
474 dev_info(&d
->udev
->dev
, "%s: firmware version=%d.%d.%d.%d",
475 KBUILD_MODNAME
, rbuf
[0], rbuf
[1], rbuf
[2], rbuf
[3]);
480 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
485 static int af9035_read_config(struct dvb_usb_device
*d
)
487 struct state
*state
= d_to_priv(d
);
488 int ret
, i
, eeprom_shift
= 0;
492 /* check if there is dual tuners */
493 ret
= af9035_rd_reg(d
, EEPROM_DUAL_MODE
, &tmp
);
497 state
->dual_mode
= tmp
;
498 dev_dbg(&d
->udev
->dev
, "%s: dual mode=%d\n",
499 __func__
, state
->dual_mode
);
501 for (i
= 0; i
< state
->dual_mode
+ 1; i
++) {
503 ret
= af9035_rd_reg(d
, EEPROM_1_TUNER_ID
+ eeprom_shift
, &tmp
);
507 state
->af9033_config
[i
].tuner
= tmp
;
508 dev_dbg(&d
->udev
->dev
, "%s: [%d]tuner=%02x\n",
512 case AF9033_TUNER_TUA9001
:
513 case AF9033_TUNER_FC0011
:
514 case AF9033_TUNER_MXL5007T
:
515 case AF9033_TUNER_TDA18218
:
516 case AF9033_TUNER_FC2580
:
517 state
->af9033_config
[i
].spec_inv
= 1;
520 dev_warn(&d
->udev
->dev
, "%s: tuner id=%02x not " \
521 "supported, please report!",
522 KBUILD_MODNAME
, tmp
);
525 /* tuner IF frequency */
526 ret
= af9035_rd_reg(d
, EEPROM_1_IFFREQ_L
+ eeprom_shift
, &tmp
);
532 ret
= af9035_rd_reg(d
, EEPROM_1_IFFREQ_H
+ eeprom_shift
, &tmp
);
538 dev_dbg(&d
->udev
->dev
, "%s: [%d]IF=%d\n", __func__
, i
, tmp16
);
540 eeprom_shift
= 0x10; /* shift for the 2nd tuner params */
543 /* get demod clock */
544 ret
= af9035_rd_reg(d
, 0x00d800, &tmp
);
548 tmp
= (tmp
>> 0) & 0x0f;
550 for (i
= 0; i
< ARRAY_SIZE(state
->af9033_config
); i
++)
551 state
->af9033_config
[i
].clock
= clock_lut
[tmp
];
556 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
561 static int af9035_read_config_it9135(struct dvb_usb_device
*d
)
563 struct state
*state
= d_to_priv(d
);
567 state
->dual_mode
= false;
569 /* get demod clock */
570 ret
= af9035_rd_reg(d
, 0x00d800, &tmp
);
574 tmp
= (tmp
>> 0) & 0x0f;
576 for (i
= 0; i
< ARRAY_SIZE(state
->af9033_config
); i
++)
577 state
->af9033_config
[i
].clock
= clock_lut_it9135
[tmp
];
582 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
587 static int af9035_tua9001_tuner_callback(struct dvb_usb_device
*d
,
593 dev_dbg(&d
->udev
->dev
, "%s: cmd=%d arg=%d\n", __func__
, cmd
, arg
);
596 * CEN always enabled by hardware wiring
602 case TUA9001_CMD_RESETN
:
608 ret
= af9035_wr_reg_mask(d
, 0x00d8e7, val
, 0x01);
612 case TUA9001_CMD_RXEN
:
618 ret
= af9035_wr_reg_mask(d
, 0x00d8eb, val
, 0x01);
627 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
633 static int af9035_fc0011_tuner_callback(struct dvb_usb_device
*d
,
639 case FC0011_FE_CALLBACK_POWER
:
641 ret
= af9035_wr_reg_mask(d
, 0xd8eb, 1, 1);
645 ret
= af9035_wr_reg_mask(d
, 0xd8ec, 1, 1);
649 ret
= af9035_wr_reg_mask(d
, 0xd8ed, 1, 1);
654 ret
= af9035_wr_reg_mask(d
, 0xd8d0, 1, 1);
658 ret
= af9035_wr_reg_mask(d
, 0xd8d1, 1, 1);
662 usleep_range(10000, 50000);
664 case FC0011_FE_CALLBACK_RESET
:
665 ret
= af9035_wr_reg(d
, 0xd8e9, 1);
669 ret
= af9035_wr_reg(d
, 0xd8e8, 1);
673 ret
= af9035_wr_reg(d
, 0xd8e7, 1);
677 usleep_range(10000, 20000);
679 ret
= af9035_wr_reg(d
, 0xd8e7, 0);
683 usleep_range(10000, 20000);
693 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
698 static int af9035_tuner_callback(struct dvb_usb_device
*d
, int cmd
, int arg
)
700 struct state
*state
= d_to_priv(d
);
702 switch (state
->af9033_config
[0].tuner
) {
703 case AF9033_TUNER_FC0011
:
704 return af9035_fc0011_tuner_callback(d
, cmd
, arg
);
705 case AF9033_TUNER_TUA9001
:
706 return af9035_tua9001_tuner_callback(d
, cmd
, arg
);
714 static int af9035_frontend_callback(void *adapter_priv
, int component
,
717 struct i2c_adapter
*adap
= adapter_priv
;
718 struct dvb_usb_device
*d
= i2c_get_adapdata(adap
);
720 dev_dbg(&d
->udev
->dev
, "%s: component=%d cmd=%d arg=%d\n",
721 __func__
, component
, cmd
, arg
);
724 case DVB_FRONTEND_COMPONENT_TUNER
:
725 return af9035_tuner_callback(d
, cmd
, arg
);
733 static int af9035_frontend_attach(struct dvb_usb_adapter
*adap
)
735 struct state
*state
= adap_to_priv(adap
);
736 struct dvb_usb_device
*d
= adap_to_d(adap
);
739 if (!state
->af9033_config
[adap
->id
].tuner
) {
740 /* unsupported tuner */
746 state
->af9033_config
[0].ts_mode
= AF9033_TS_MODE_USB
;
747 state
->af9033_config
[1].ts_mode
= AF9033_TS_MODE_SERIAL
;
749 ret
= af9035_wr_reg(d
, 0x00417f,
750 state
->af9033_config
[1].i2c_addr
);
754 ret
= af9035_wr_reg(d
, 0x00d81a,
760 /* attach demodulator */
761 adap
->fe
[0] = dvb_attach(af9033_attach
,
762 &state
->af9033_config
[adap
->id
], &d
->i2c_adap
);
763 if (adap
->fe
[0] == NULL
) {
768 /* disable I2C-gate */
769 adap
->fe
[0]->ops
.i2c_gate_ctrl
= NULL
;
770 adap
->fe
[0]->callback
= af9035_frontend_callback
;
775 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
780 static struct tua9001_config af9035_tua9001_config
= {
784 static const struct fc0011_config af9035_fc0011_config
= {
788 static struct mxl5007t_config af9035_mxl5007t_config
= {
789 .xtal_freq_hz
= MxL_XTAL_24_MHZ
,
790 .if_freq_hz
= MxL_IF_4_57_MHZ
,
792 .loop_thru_enable
= 0,
794 .clk_out_amp
= MxL_CLKOUT_AMP_0_94V
,
797 static struct tda18218_config af9035_tda18218_config
= {
802 static const struct fc2580_config af9035_fc2580_config
= {
807 static int af9035_tuner_attach(struct dvb_usb_adapter
*adap
)
809 struct state
*state
= adap_to_priv(adap
);
810 struct dvb_usb_device
*d
= adap_to_d(adap
);
812 struct dvb_frontend
*fe
;
814 switch (state
->af9033_config
[adap
->id
].tuner
) {
815 case AF9033_TUNER_TUA9001
:
816 /* AF9035 gpiot3 = TUA9001 RESETN
817 AF9035 gpiot2 = TUA9001 RXEN */
819 /* configure gpiot2 and gpiot2 as output */
820 ret
= af9035_wr_reg_mask(d
, 0x00d8ec, 0x01, 0x01);
824 ret
= af9035_wr_reg_mask(d
, 0x00d8ed, 0x01, 0x01);
828 ret
= af9035_wr_reg_mask(d
, 0x00d8e8, 0x01, 0x01);
832 ret
= af9035_wr_reg_mask(d
, 0x00d8e9, 0x01, 0x01);
837 fe
= dvb_attach(tua9001_attach
, adap
->fe
[0],
838 &d
->i2c_adap
, &af9035_tua9001_config
);
840 case AF9033_TUNER_FC0011
:
841 fe
= dvb_attach(fc0011_attach
, adap
->fe
[0],
842 &d
->i2c_adap
, &af9035_fc0011_config
);
844 case AF9033_TUNER_MXL5007T
:
845 ret
= af9035_wr_reg(d
, 0x00d8e0, 1);
848 ret
= af9035_wr_reg(d
, 0x00d8e1, 1);
851 ret
= af9035_wr_reg(d
, 0x00d8df, 0);
857 ret
= af9035_wr_reg(d
, 0x00d8df, 1);
863 ret
= af9035_wr_reg(d
, 0x00d8c0, 1);
866 ret
= af9035_wr_reg(d
, 0x00d8c1, 1);
869 ret
= af9035_wr_reg(d
, 0x00d8bf, 0);
872 ret
= af9035_wr_reg(d
, 0x00d8b4, 1);
875 ret
= af9035_wr_reg(d
, 0x00d8b5, 1);
878 ret
= af9035_wr_reg(d
, 0x00d8b3, 1);
883 fe
= dvb_attach(mxl5007t_attach
, adap
->fe
[0],
884 &d
->i2c_adap
, 0x60, &af9035_mxl5007t_config
);
886 case AF9033_TUNER_TDA18218
:
888 fe
= dvb_attach(tda18218_attach
, adap
->fe
[0],
889 &d
->i2c_adap
, &af9035_tda18218_config
);
891 case AF9033_TUNER_FC2580
:
892 /* Tuner enable using gpiot2_o, gpiot2_en and gpiot2_on */
893 ret
= af9035_wr_reg_mask(d
, 0xd8eb, 0x01, 0x01);
897 ret
= af9035_wr_reg_mask(d
, 0xd8ec, 0x01, 0x01);
901 ret
= af9035_wr_reg_mask(d
, 0xd8ed, 0x01, 0x01);
905 usleep_range(10000, 50000);
907 fe
= dvb_attach(fc2580_attach
, adap
->fe
[0],
908 &d
->i2c_adap
, &af9035_fc2580_config
);
922 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
927 static int af9035_init(struct dvb_usb_device
*d
)
929 struct state
*state
= d_to_priv(d
);
931 u16 frame_size
= 87 * 188 / 4;
932 u8 packet_size
= 512 / 4;
933 struct reg_val_mask tab
[] = {
934 { 0x80f99d, 0x01, 0x01 },
935 { 0x80f9a4, 0x01, 0x01 },
936 { 0x00dd11, 0x00, 0x20 },
937 { 0x00dd11, 0x00, 0x40 },
938 { 0x00dd13, 0x00, 0x20 },
939 { 0x00dd13, 0x00, 0x40 },
940 { 0x00dd11, 0x20, 0x20 },
941 { 0x00dd88, (frame_size
>> 0) & 0xff, 0xff},
942 { 0x00dd89, (frame_size
>> 8) & 0xff, 0xff},
943 { 0x00dd0c, packet_size
, 0xff},
944 { 0x00dd11, state
->dual_mode
<< 6, 0x40 },
945 { 0x00dd8a, (frame_size
>> 0) & 0xff, 0xff},
946 { 0x00dd8b, (frame_size
>> 8) & 0xff, 0xff},
947 { 0x00dd0d, packet_size
, 0xff },
948 { 0x80f9a3, 0x00, 0x01 },
949 { 0x80f9cd, 0x00, 0x01 },
950 { 0x80f99d, 0x00, 0x01 },
951 { 0x80f9a4, 0x00, 0x01 },
954 dev_dbg(&d
->udev
->dev
, "%s: USB speed=%d frame_size=%04x " \
955 "packet_size=%02x\n", __func__
,
956 d
->udev
->speed
, frame_size
, packet_size
);
959 for (i
= 0; i
< ARRAY_SIZE(tab
); i
++) {
960 ret
= af9035_wr_reg_mask(d
, tab
[i
].reg
, tab
[i
].val
,
969 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
974 static int af9035_rc_query(struct dvb_usb_device
*d
)
979 struct usb_req req
= { CMD_IR_GET
, 0, 0, NULL
, 4, b
};
981 ret
= af9035_ctrl_msg(d
, &req
);
985 if ((b
[2] + b
[3]) == 0xff) {
986 if ((b
[0] + b
[1]) == 0xff) {
988 key
= b
[0] << 8 | b
[2];
991 key
= b
[0] << 16 | b
[1] << 8 | b
[2];
994 key
= b
[0] << 24 | b
[1] << 16 | b
[2] << 8 | b
[3];
997 rc_keydown(d
->rc_dev
, key
, 0);
1004 static int af9035_get_rc_config(struct dvb_usb_device
*d
, struct dvb_usb_rc
*rc
)
1009 ret
= af9035_rd_reg(d
, EEPROM_IR_MODE
, &tmp
);
1013 dev_dbg(&d
->udev
->dev
, "%s: ir_mode=%02x\n", __func__
, tmp
);
1015 /* don't activate rc if in HID mode or if not available */
1017 ret
= af9035_rd_reg(d
, EEPROM_IR_TYPE
, &tmp
);
1021 dev_dbg(&d
->udev
->dev
, "%s: ir_type=%02x\n", __func__
, tmp
);
1026 rc
->allowed_protos
= RC_BIT_NEC
;
1029 rc
->allowed_protos
= RC_BIT_RC6_MCE
;
1033 rc
->query
= af9035_rc_query
;
1036 /* load empty to enable rc */
1038 rc
->map_name
= RC_MAP_EMPTY
;
1044 dev_dbg(&d
->udev
->dev
, "%s: failed=%d\n", __func__
, ret
);
1049 /* interface 0 is used by DVB-T receiver and
1050 interface 1 is for remote controller (HID) */
1051 static const struct dvb_usb_device_properties af9035_props
= {
1052 .driver_name
= KBUILD_MODNAME
,
1053 .owner
= THIS_MODULE
,
1054 .adapter_nr
= adapter_nr
,
1055 .size_of_priv
= sizeof(struct state
),
1057 .generic_bulk_ctrl_endpoint
= 0x02,
1058 .generic_bulk_ctrl_endpoint_response
= 0x81,
1060 .identify_state
= af9035_identify_state
,
1061 .firmware
= AF9035_FIRMWARE_AF9035
,
1062 .download_firmware
= af9035_download_firmware
,
1064 .i2c_algo
= &af9035_i2c_algo
,
1065 .read_config
= af9035_read_config
,
1066 .frontend_attach
= af9035_frontend_attach
,
1067 .tuner_attach
= af9035_tuner_attach
,
1068 .init
= af9035_init
,
1069 .get_rc_config
= af9035_get_rc_config
,
1074 .stream
= DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),
1076 .stream
= DVB_USB_STREAM_BULK(0x85, 6, 87 * 188),
1081 static const struct dvb_usb_device_properties it9135_props
= {
1082 .driver_name
= KBUILD_MODNAME
,
1083 .owner
= THIS_MODULE
,
1084 .adapter_nr
= adapter_nr
,
1085 .size_of_priv
= sizeof(struct state
),
1087 .generic_bulk_ctrl_endpoint
= 0x02,
1088 .generic_bulk_ctrl_endpoint_response
= 0x81,
1090 .identify_state
= af9035_identify_state
,
1091 .firmware
= AF9035_FIRMWARE_IT9135
,
1092 .download_firmware
= af9035_download_firmware_it9135
,
1094 .i2c_algo
= &af9035_i2c_algo
,
1095 .read_config
= af9035_read_config_it9135
,
1096 .frontend_attach
= af9035_frontend_attach
,
1097 .tuner_attach
= af9035_tuner_attach
,
1098 .init
= af9035_init
,
1099 .get_rc_config
= af9035_get_rc_config
,
1104 .stream
= DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),
1106 .stream
= DVB_USB_STREAM_BULK(0x85, 6, 87 * 188),
1111 static const struct usb_device_id af9035_id_table
[] = {
1112 { DVB_USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9035_9035
,
1113 &af9035_props
, "Afatech AF9035 reference design", NULL
) },
1114 { DVB_USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9035_1000
,
1115 &af9035_props
, "Afatech AF9035 reference design", NULL
) },
1116 { DVB_USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9035_1001
,
1117 &af9035_props
, "Afatech AF9035 reference design", NULL
) },
1118 { DVB_USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9035_1002
,
1119 &af9035_props
, "Afatech AF9035 reference design", NULL
) },
1120 { DVB_USB_DEVICE(USB_VID_AFATECH
, USB_PID_AFATECH_AF9035_1003
,
1121 &af9035_props
, "Afatech AF9035 reference design", NULL
) },
1122 { DVB_USB_DEVICE(USB_VID_TERRATEC
, USB_PID_TERRATEC_CINERGY_T_STICK
,
1123 &af9035_props
, "TerraTec Cinergy T Stick", NULL
) },
1124 { DVB_USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A835
,
1125 &af9035_props
, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL
) },
1126 { DVB_USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_B835
,
1127 &af9035_props
, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL
) },
1128 { DVB_USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_1867
,
1129 &af9035_props
, "AVerMedia HD Volar (A867)", NULL
) },
1130 { DVB_USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_A867
,
1131 &af9035_props
, "AVerMedia HD Volar (A867)", NULL
) },
1132 { DVB_USB_DEVICE(USB_VID_AVERMEDIA
, USB_PID_AVERMEDIA_TWINSTAR
,
1133 &af9035_props
, "AVerMedia Twinstar (A825)", NULL
) },
1134 { DVB_USB_DEVICE(USB_VID_ASUS
, USB_PID_ASUS_U3100MINI_PLUS
,
1135 &af9035_props
, "Asus U3100Mini Plus", NULL
) },
1138 MODULE_DEVICE_TABLE(usb
, af9035_id_table
);
1140 static struct usb_driver af9035_usb_driver
= {
1141 .name
= KBUILD_MODNAME
,
1142 .id_table
= af9035_id_table
,
1143 .probe
= dvb_usbv2_probe
,
1144 .disconnect
= dvb_usbv2_disconnect
,
1145 .suspend
= dvb_usbv2_suspend
,
1146 .resume
= dvb_usbv2_resume
,
1147 .reset_resume
= dvb_usbv2_reset_resume
,
1152 module_usb_driver(af9035_usb_driver
);
1154 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1155 MODULE_DESCRIPTION("Afatech AF9035 driver");
1156 MODULE_LICENSE("GPL");
1157 MODULE_FIRMWARE(AF9035_FIRMWARE_AF9035
);
1158 MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135
);