2 * Toshiba TC90522 Demodulator
4 * Copyright (C) 2014 Akihiro Tsukada <tskd08@gmail.com>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation version 2.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
19 * This driver is incomplete and lacks init/config of the chips,
20 * as the necessary info is not disclosed.
21 * It assumes that users of this driver (such as a PCI bridge of
22 * DTV receiver cards) properly init and configure the chip
23 * via I2C *before* calling this driver's init() function.
25 * Currently, PT3 driver is the only one that uses this driver,
26 * and contains init/config code in its firmware.
27 * Thus some part of the code might be dependent on PT3 specific config.
30 #include <linux/kernel.h>
31 #include <linux/math64.h>
32 #include <linux/dvb/frontend.h>
36 #define TC90522_I2C_THRU_REG 0xfe
38 #define TC90522_MODULE_IDX(addr) (((u8)(addr) & 0x02U) >> 1)
40 struct tc90522_state
{
41 struct tc90522_config cfg
;
42 struct dvb_frontend fe
;
43 struct i2c_client
*i2c_client
;
44 struct i2c_adapter tuner_i2c
;
55 reg_write(struct tc90522_state
*state
, const struct reg_val
*regs
, int num
)
61 msg
.addr
= state
->i2c_client
->addr
;
64 for (i
= 0; i
< num
; i
++) {
65 msg
.buf
= (u8
*)®s
[i
];
66 ret
= i2c_transfer(state
->i2c_client
->adapter
, &msg
, 1);
75 static int reg_read(struct tc90522_state
*state
, u8 reg
, u8
*val
, u8 len
)
77 struct i2c_msg msgs
[2] = {
79 .addr
= state
->i2c_client
->addr
,
85 .addr
= state
->i2c_client
->addr
,
93 ret
= i2c_transfer(state
->i2c_client
->adapter
, msgs
, ARRAY_SIZE(msgs
));
94 if (ret
== ARRAY_SIZE(msgs
))
101 static struct tc90522_state
*cfg_to_state(struct tc90522_config
*c
)
103 return container_of(c
, struct tc90522_state
, cfg
);
107 static int tc90522s_set_tsid(struct dvb_frontend
*fe
)
109 struct reg_val set_tsid
[] = {
114 set_tsid
[0].val
= (fe
->dtv_property_cache
.stream_id
& 0xff00) >> 8;
115 set_tsid
[1].val
= fe
->dtv_property_cache
.stream_id
& 0xff;
116 return reg_write(fe
->demodulator_priv
, set_tsid
, ARRAY_SIZE(set_tsid
));
119 static int tc90522t_set_layers(struct dvb_frontend
*fe
)
124 laysel
= ~fe
->dtv_property_cache
.isdbt_layer_enabled
& 0x07;
125 laysel
= (laysel
& 0x01) << 2 | (laysel
& 0x02) | (laysel
& 0x04) >> 2;
128 return reg_write(fe
->demodulator_priv
, &rv
, 1);
133 static int tc90522s_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
135 struct tc90522_state
*state
;
139 state
= fe
->demodulator_priv
;
140 ret
= reg_read(state
, 0xc3, ®
, 1);
145 if (reg
& 0x80) /* input level under min ? */
147 *status
|= FE_HAS_SIGNAL
;
149 if (reg
& 0x60) /* carrier? */
151 *status
|= FE_HAS_CARRIER
| FE_HAS_VITERBI
| FE_HAS_SYNC
;
155 if (reg_read(state
, 0xc5, ®
, 1) < 0 || !(reg
& 0x03))
157 *status
|= FE_HAS_LOCK
;
161 static int tc90522t_read_status(struct dvb_frontend
*fe
, fe_status_t
*status
)
163 struct tc90522_state
*state
;
167 state
= fe
->demodulator_priv
;
168 ret
= reg_read(state
, 0x96, ®
, 1);
174 *status
= FE_HAS_SIGNAL
| FE_HAS_CARRIER
| FE_HAS_VITERBI
175 | FE_HAS_SYNC
| FE_HAS_LOCK
;
179 ret
= reg_read(state
, 0x80, ®
, 1);
185 *status
|= FE_HAS_SIGNAL
| FE_HAS_CARRIER
;
189 *status
|= FE_HAS_SYNC
| FE_HAS_VITERBI
;
193 *status
|= FE_HAS_LOCK
;
197 static const fe_code_rate_t fec_conv_sat
[] = {
198 FEC_NONE
, /* unused */
199 FEC_1_2
, /* for BPSK */
200 FEC_1_2
, FEC_2_3
, FEC_3_4
, FEC_5_6
, FEC_7_8
, /* for QPSK */
201 FEC_2_3
, /* for 8PSK. (trellis code) */
204 static int tc90522s_get_frontend(struct dvb_frontend
*fe
)
206 struct tc90522_state
*state
;
207 struct dtv_frontend_properties
*c
;
208 struct dtv_fe_stats
*stats
;
214 state
= fe
->demodulator_priv
;
215 c
= &fe
->dtv_property_cache
;
216 c
->delivery_system
= SYS_ISDBS
;
217 c
->symbol_rate
= 28860000;
220 ret
= reg_read(state
, 0xe6, val
, 5);
224 c
->stream_id
= val
[0] << 8 | val
[1];
226 /* high/single layer */
227 v
= (val
[2] & 0x70) >> 4;
228 c
->modulation
= (v
== 7) ? PSK_8
: QPSK
;
229 c
->fec_inner
= fec_conv_sat
[v
];
230 c
->layer
[0].fec
= c
->fec_inner
;
231 c
->layer
[0].modulation
= c
->modulation
;
232 c
->layer
[0].segment_count
= val
[3] & 0x3f; /* slots */
236 c
->layer
[1].fec
= fec_conv_sat
[v
];
237 if (v
== 0) /* no low layer */
238 c
->layer
[1].segment_count
= 0;
240 c
->layer
[1].segment_count
= val
[4] & 0x3f; /* slots */
241 /* actually, BPSK if v==1, but not defined in fe_modulation_t */
242 c
->layer
[1].modulation
= QPSK
;
243 layers
= (v
> 0) ? 2 : 1;
248 stats
= &c
->strength
;
250 /* let the connected tuner set RSSI property cache */
251 if (fe
->ops
.tuner_ops
.get_rf_strength
) {
254 fe
->ops
.tuner_ops
.get_rf_strength(fe
, &dummy
);
259 stats
->stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
261 ret
= reg_read(state
, 0xbc, val
, 2);
263 cndat
= val
[0] << 8 | val
[1];
268 cndat
-= 3000; /* cndat: 4.12 fixed point float */
270 * cnr[mdB] = -1634.6 * P^5 + 14341 * P^4 - 50259 * P^3
271 * + 88977 * P^2 - 89565 * P + 58857
272 * (P = sqrt(cndat) / 64)
274 /* p := sqrt(cndat) << 8 = P << 14, 2.14 fixed point float */
276 p
= int_sqrt(cndat
<< 16);
278 cn
= div64_s64(-16346LL * p4
* p
, 10) >> 35;
279 cn
+= (14341LL * p4
) >> 21;
280 cn
-= (50259LL * cndat
* p
) >> 23;
281 cn
+= (88977LL * cndat
) >> 9;
282 cn
-= (89565LL * p
) >> 11;
284 stats
->stat
[0].svalue
= cn
>> 3;
285 stats
->stat
[0].scale
= FE_SCALE_DECIBEL
;
288 /* per-layer post viterbi BER (or PER? config dependent?) */
289 stats
= &c
->post_bit_error
;
290 memset(stats
, 0, sizeof(*stats
));
292 ret
= reg_read(state
, 0xeb, val
, 10);
294 for (i
= 0; i
< layers
; i
++)
295 stats
->stat
[i
].scale
= FE_SCALE_NOT_AVAILABLE
;
297 for (i
= 0; i
< layers
; i
++) {
298 stats
->stat
[i
].scale
= FE_SCALE_COUNTER
;
299 stats
->stat
[i
].uvalue
= val
[i
* 5] << 16
300 | val
[i
* 5 + 1] << 8 | val
[i
* 5 + 2];
303 stats
= &c
->post_bit_count
;
304 memset(stats
, 0, sizeof(*stats
));
307 for (i
= 0; i
< layers
; i
++)
308 stats
->stat
[i
].scale
= FE_SCALE_NOT_AVAILABLE
;
310 for (i
= 0; i
< layers
; i
++) {
311 stats
->stat
[i
].scale
= FE_SCALE_COUNTER
;
312 stats
->stat
[i
].uvalue
=
313 val
[i
* 5 + 3] << 8 | val
[i
* 5 + 4];
314 stats
->stat
[i
].uvalue
*= 204 * 8;
322 static const fe_transmit_mode_t tm_conv
[] = {
323 TRANSMISSION_MODE_2K
,
324 TRANSMISSION_MODE_4K
,
325 TRANSMISSION_MODE_8K
,
329 static const fe_code_rate_t fec_conv_ter
[] = {
330 FEC_1_2
, FEC_2_3
, FEC_3_4
, FEC_5_6
, FEC_7_8
, 0, 0, 0
333 static const fe_modulation_t mod_conv
[] = {
334 DQPSK
, QPSK
, QAM_16
, QAM_64
, 0, 0, 0, 0
337 static int tc90522t_get_frontend(struct dvb_frontend
*fe
)
339 struct tc90522_state
*state
;
340 struct dtv_frontend_properties
*c
;
341 struct dtv_fe_stats
*stats
;
347 state
= fe
->demodulator_priv
;
348 c
= &fe
->dtv_property_cache
;
349 c
->delivery_system
= SYS_ISDBT
;
350 c
->bandwidth_hz
= 6000000;
352 ret
= reg_read(state
, 0xb0, val
, 1);
354 mode
= (val
[0] & 0xc0) >> 2;
355 c
->transmission_mode
= tm_conv
[mode
];
356 c
->guard_interval
= (val
[0] & 0x30) >> 4;
359 ret
= reg_read(state
, 0xb2, val
, 6);
364 c
->isdbt_partial_reception
= val
[0] & 0x01;
365 c
->isdbt_sb_mode
= (val
[0] & 0xc0) == 0x40;
368 v
= (val
[2] & 0x78) >> 3;
370 c
->layer
[0].segment_count
= 0;
373 c
->layer
[0].segment_count
= v
;
374 c
->layer
[0].fec
= fec_conv_ter
[(val
[1] & 0x1c) >> 2];
375 c
->layer
[0].modulation
= mod_conv
[(val
[1] & 0xe0) >> 5];
376 v
= (val
[1] & 0x03) << 1 | (val
[2] & 0x80) >> 7;
377 c
->layer
[0].interleaving
= v
;
381 v
= (val
[3] & 0x03) << 1 | (val
[4] & 0xc0) >> 6;
383 c
->layer
[1].segment_count
= 0;
386 c
->layer
[1].segment_count
= v
;
387 c
->layer
[1].fec
= fec_conv_ter
[(val
[3] & 0xe0) >> 5];
388 c
->layer
[1].modulation
= mod_conv
[(val
[2] & 0x07)];
389 c
->layer
[1].interleaving
= (val
[3] & 0x1c) >> 2;
393 v
= (val
[5] & 0x1e) >> 1;
395 c
->layer
[2].segment_count
= 0;
398 c
->layer
[2].segment_count
= v
;
399 c
->layer
[2].fec
= fec_conv_ter
[(val
[4] & 0x07)];
400 c
->layer
[2].modulation
= mod_conv
[(val
[4] & 0x38) >> 3];
401 c
->layer
[2].interleaving
= (val
[5] & 0xe0) >> 5;
407 stats
= &c
->strength
;
409 /* let the connected tuner set RSSI property cache */
410 if (fe
->ops
.tuner_ops
.get_rf_strength
) {
413 fe
->ops
.tuner_ops
.get_rf_strength(fe
, &dummy
);
418 stats
->stat
[0].scale
= FE_SCALE_NOT_AVAILABLE
;
420 ret
= reg_read(state
, 0x8b, val
, 3);
422 cndat
= val
[0] << 16 | val
[1] << 8 | val
[2];
428 * cnr[mdB] = 0.024 P^4 - 1.6 P^3 + 39.8 P^2 + 549.1 P + 3096.5
429 * (P = 10log10(5505024/cndat))
431 /* cn = cnr << 3 (61.3 fixed point float */
432 /* p = 10log10(5505024/cndat) << 24 (8.24 fixed point float)*/
433 p
= intlog10(5505024) - intlog10(cndat
);
437 cn
+= div64_s64(43827LL * p
, 10) >> 24;
439 cn
+= div64_s64(3184LL * tmp
* tmp
, 10) >> 32;
441 cn
-= div64_s64(128LL * tmp
* tmp
* tmp
, 10) >> 33;
443 cn
+= div64_s64(192LL * tmp
* tmp
* tmp
* tmp
, 1000) >> 24;
445 stats
->stat
[0].svalue
= cn
>> 3;
446 stats
->stat
[0].scale
= FE_SCALE_DECIBEL
;
449 /* per-layer post viterbi BER (or PER? config dependent?) */
450 stats
= &c
->post_bit_error
;
451 memset(stats
, 0, sizeof(*stats
));
453 ret
= reg_read(state
, 0x9d, val
, 15);
455 for (i
= 0; i
< layers
; i
++)
456 stats
->stat
[i
].scale
= FE_SCALE_NOT_AVAILABLE
;
458 for (i
= 0; i
< layers
; i
++) {
459 stats
->stat
[i
].scale
= FE_SCALE_COUNTER
;
460 stats
->stat
[i
].uvalue
= val
[i
* 3] << 16
461 | val
[i
* 3 + 1] << 8 | val
[i
* 3 + 2];
464 stats
= &c
->post_bit_count
;
465 memset(stats
, 0, sizeof(*stats
));
468 for (i
= 0; i
< layers
; i
++)
469 stats
->stat
[i
].scale
= FE_SCALE_NOT_AVAILABLE
;
471 for (i
= 0; i
< layers
; i
++) {
472 stats
->stat
[i
].scale
= FE_SCALE_COUNTER
;
473 stats
->stat
[i
].uvalue
=
474 val
[9 + i
* 2] << 8 | val
[9 + i
* 2 + 1];
475 stats
->stat
[i
].uvalue
*= 204 * 8;
482 static const struct reg_val reset_sat
= { 0x03, 0x01 };
483 static const struct reg_val reset_ter
= { 0x01, 0x40 };
485 static int tc90522_set_frontend(struct dvb_frontend
*fe
)
487 struct tc90522_state
*state
;
490 state
= fe
->demodulator_priv
;
492 if (fe
->ops
.tuner_ops
.set_params
)
493 ret
= fe
->ops
.tuner_ops
.set_params(fe
);
499 if (fe
->ops
.delsys
[0] == SYS_ISDBS
) {
500 ret
= tc90522s_set_tsid(fe
);
503 ret
= reg_write(state
, &reset_sat
, 1);
505 ret
= tc90522t_set_layers(fe
);
508 ret
= reg_write(state
, &reset_ter
, 1);
516 dev_warn(&state
->tuner_i2c
.dev
, "(%s) failed. [adap%d-fe%d]\n",
517 __func__
, fe
->dvb
->num
, fe
->id
);
521 static int tc90522_get_tune_settings(struct dvb_frontend
*fe
,
522 struct dvb_frontend_tune_settings
*settings
)
524 if (fe
->ops
.delsys
[0] == SYS_ISDBS
) {
525 settings
->min_delay_ms
= 250;
526 settings
->step_size
= 1000;
527 settings
->max_drift
= settings
->step_size
* 2;
529 settings
->min_delay_ms
= 400;
530 settings
->step_size
= 142857;
531 settings
->max_drift
= settings
->step_size
;
536 static int tc90522_set_if_agc(struct dvb_frontend
*fe
, bool on
)
538 struct reg_val agc_sat
[] = {
544 struct reg_val agc_ter
[] = {
549 struct tc90522_state
*state
;
553 state
= fe
->demodulator_priv
;
554 if (fe
->ops
.delsys
[0] == SYS_ISDBS
) {
555 agc_sat
[0].val
= on
? 0xff : 0x00;
556 agc_sat
[1].val
|= 0x80;
557 agc_sat
[1].val
|= on
? 0x01 : 0x00;
558 agc_sat
[2].val
|= on
? 0x40 : 0x00;
560 num
= ARRAY_SIZE(agc_sat
);
562 agc_ter
[0].val
= on
? 0x40 : 0x00;
563 agc_ter
[1].val
|= on
? 0x00 : 0x01;
565 num
= ARRAY_SIZE(agc_ter
);
567 return reg_write(state
, rv
, num
);
570 static const struct reg_val sleep_sat
= { 0x17, 0x01 };
571 static const struct reg_val sleep_ter
= { 0x03, 0x90 };
573 static int tc90522_sleep(struct dvb_frontend
*fe
)
575 struct tc90522_state
*state
;
578 state
= fe
->demodulator_priv
;
579 if (fe
->ops
.delsys
[0] == SYS_ISDBS
)
580 ret
= reg_write(state
, &sleep_sat
, 1);
582 ret
= reg_write(state
, &sleep_ter
, 1);
583 if (ret
== 0 && fe
->ops
.set_lna
&&
584 fe
->dtv_property_cache
.lna
== LNA_AUTO
) {
585 fe
->dtv_property_cache
.lna
= 0;
586 ret
= fe
->ops
.set_lna(fe
);
587 fe
->dtv_property_cache
.lna
= LNA_AUTO
;
591 dev_warn(&state
->tuner_i2c
.dev
,
592 "(%s) failed. [adap%d-fe%d]\n",
593 __func__
, fe
->dvb
->num
, fe
->id
);
597 static const struct reg_val wakeup_sat
= { 0x17, 0x00 };
598 static const struct reg_val wakeup_ter
= { 0x03, 0x80 };
600 static int tc90522_init(struct dvb_frontend
*fe
)
602 struct tc90522_state
*state
;
606 * Because the init sequence is not public,
607 * the parent device/driver should have init'ed the device before.
608 * just wake up the device here.
611 state
= fe
->demodulator_priv
;
612 if (fe
->ops
.delsys
[0] == SYS_ISDBS
)
613 ret
= reg_write(state
, &wakeup_sat
, 1);
615 ret
= reg_write(state
, &wakeup_ter
, 1);
616 if (ret
== 0 && fe
->ops
.set_lna
&&
617 fe
->dtv_property_cache
.lna
== LNA_AUTO
) {
618 fe
->dtv_property_cache
.lna
= 1;
619 ret
= fe
->ops
.set_lna(fe
);
620 fe
->dtv_property_cache
.lna
= LNA_AUTO
;
624 dev_warn(&state
->tuner_i2c
.dev
,
625 "(%s) failed. [adap%d-fe%d]\n",
626 __func__
, fe
->dvb
->num
, fe
->id
);
630 /* prefer 'all-layers' to 'none' as a default */
631 if (fe
->dtv_property_cache
.isdbt_layer_enabled
== 0)
632 fe
->dtv_property_cache
.isdbt_layer_enabled
= 7;
633 return tc90522_set_if_agc(fe
, true);
638 * tuner I2C adapter functions
642 tc90522_master_xfer(struct i2c_adapter
*adap
, struct i2c_msg
*msgs
, int num
)
644 struct tc90522_state
*state
;
645 struct i2c_msg
*new_msgs
;
655 for (i
= 0; i
< num
; i
++)
656 if (msgs
[i
].flags
& I2C_M_RD
)
658 new_msgs
= kmalloc(sizeof(*new_msgs
) * (num
+ rd_num
), GFP_KERNEL
);
662 state
= i2c_get_adapdata(adap
);
664 bufend
= wbuf
+ sizeof(wbuf
);
665 for (i
= 0, j
= 0; i
< num
; i
++, j
++) {
666 new_msgs
[j
].addr
= state
->i2c_client
->addr
;
667 new_msgs
[j
].flags
= msgs
[i
].flags
;
669 if (msgs
[i
].flags
& I2C_M_RD
) {
670 new_msgs
[j
].flags
&= ~I2C_M_RD
;
673 p
[0] = TC90522_I2C_THRU_REG
;
674 p
[1] = msgs
[i
].addr
<< 1 | 0x01;
679 new_msgs
[j
].addr
= state
->i2c_client
->addr
;
680 new_msgs
[j
].flags
= msgs
[i
].flags
;
681 new_msgs
[j
].buf
= msgs
[i
].buf
;
682 new_msgs
[j
].len
= msgs
[i
].len
;
686 if (p
+ msgs
[i
].len
+ 2 > bufend
)
688 p
[0] = TC90522_I2C_THRU_REG
;
689 p
[1] = msgs
[i
].addr
<< 1;
690 memcpy(p
+ 2, msgs
[i
].buf
, msgs
[i
].len
);
692 new_msgs
[j
].len
= msgs
[i
].len
+ 2;
693 p
+= new_msgs
[j
].len
;
699 ret
= i2c_transfer(state
->i2c_client
->adapter
, new_msgs
, j
);
700 if (ret
>= 0 && ret
< j
)
703 return (ret
== j
) ? num
: ret
;
706 static u32
tc90522_functionality(struct i2c_adapter
*adap
)
711 static const struct i2c_algorithm tc90522_tuner_i2c_algo
= {
712 .master_xfer
= &tc90522_master_xfer
,
713 .functionality
= &tc90522_functionality
,
718 * I2C driver functions
721 static const struct dvb_frontend_ops tc90522_ops_sat
= {
722 .delsys
= { SYS_ISDBS
},
724 .name
= "Toshiba TC90522 ISDB-S module",
725 .frequency_min
= 950000,
726 .frequency_max
= 2150000,
727 .caps
= FE_CAN_INVERSION_AUTO
| FE_CAN_FEC_AUTO
|
728 FE_CAN_QAM_AUTO
| FE_CAN_TRANSMISSION_MODE_AUTO
|
729 FE_CAN_GUARD_INTERVAL_AUTO
| FE_CAN_HIERARCHY_AUTO
,
732 .init
= tc90522_init
,
733 .sleep
= tc90522_sleep
,
734 .set_frontend
= tc90522_set_frontend
,
735 .get_tune_settings
= tc90522_get_tune_settings
,
737 .get_frontend
= tc90522s_get_frontend
,
738 .read_status
= tc90522s_read_status
,
741 static const struct dvb_frontend_ops tc90522_ops_ter
= {
742 .delsys
= { SYS_ISDBT
},
744 .name
= "Toshiba TC90522 ISDB-T module",
745 .frequency_min
= 470000000,
746 .frequency_max
= 770000000,
747 .frequency_stepsize
= 142857,
748 .caps
= FE_CAN_INVERSION_AUTO
|
749 FE_CAN_FEC_1_2
| FE_CAN_FEC_2_3
| FE_CAN_FEC_3_4
|
750 FE_CAN_FEC_5_6
| FE_CAN_FEC_7_8
| FE_CAN_FEC_AUTO
|
751 FE_CAN_QPSK
| FE_CAN_QAM_16
| FE_CAN_QAM_64
|
752 FE_CAN_QAM_AUTO
| FE_CAN_TRANSMISSION_MODE_AUTO
|
753 FE_CAN_GUARD_INTERVAL_AUTO
| FE_CAN_RECOVER
|
754 FE_CAN_HIERARCHY_AUTO
,
757 .init
= tc90522_init
,
758 .sleep
= tc90522_sleep
,
759 .set_frontend
= tc90522_set_frontend
,
760 .get_tune_settings
= tc90522_get_tune_settings
,
762 .get_frontend
= tc90522t_get_frontend
,
763 .read_status
= tc90522t_read_status
,
767 static int tc90522_probe(struct i2c_client
*client
,
768 const struct i2c_device_id
*id
)
770 struct tc90522_state
*state
;
771 struct tc90522_config
*cfg
;
772 const struct dvb_frontend_ops
*ops
;
773 struct i2c_adapter
*adap
;
776 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
779 state
->i2c_client
= client
;
781 cfg
= client
->dev
.platform_data
;
782 memcpy(&state
->cfg
, cfg
, sizeof(state
->cfg
));
783 cfg
->fe
= state
->cfg
.fe
= &state
->fe
;
784 ops
= id
->driver_data
== 0 ? &tc90522_ops_sat
: &tc90522_ops_ter
;
785 memcpy(&state
->fe
.ops
, ops
, sizeof(*ops
));
786 state
->fe
.demodulator_priv
= state
;
788 adap
= &state
->tuner_i2c
;
789 adap
->owner
= THIS_MODULE
;
790 adap
->algo
= &tc90522_tuner_i2c_algo
;
791 adap
->dev
.parent
= &client
->dev
;
792 strlcpy(adap
->name
, "tc90522_sub", sizeof(adap
->name
));
793 i2c_set_adapdata(adap
, state
);
794 ret
= i2c_add_adapter(adap
);
797 cfg
->tuner_i2c
= state
->cfg
.tuner_i2c
= adap
;
799 i2c_set_clientdata(client
, &state
->cfg
);
800 dev_info(&client
->dev
, "Toshiba TC90522 attached.\n");
808 static int tc90522_remove(struct i2c_client
*client
)
810 struct tc90522_state
*state
;
812 state
= cfg_to_state(i2c_get_clientdata(client
));
813 i2c_del_adapter(&state
->tuner_i2c
);
819 static const struct i2c_device_id tc90522_id
[] = {
820 { TC90522_I2C_DEV_SAT
, 0 },
821 { TC90522_I2C_DEV_TER
, 1 },
824 MODULE_DEVICE_TABLE(i2c
, tc90522_id
);
826 static struct i2c_driver tc90522_driver
= {
830 .probe
= tc90522_probe
,
831 .remove
= tc90522_remove
,
832 .id_table
= tc90522_id
,
835 module_i2c_driver(tc90522_driver
);
837 MODULE_DESCRIPTION("Toshiba TC90522 frontend");
838 MODULE_AUTHOR("Akihiro TSUKADA");
839 MODULE_LICENSE("GPL");