2 * drivers/media/radio/radio-si476x.c -- V4L2 driver for SI476X chips
4 * Copyright (C) 2012 Innovative Converged Devices(ICD)
5 * Copyright (C) 2013 Andrey Smirnov
7 * Author: Andrey Smirnov <andrew.smirnov@gmail.com>
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; version 2 of the License.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
20 #include <linux/module.h>
21 #include <linux/delay.h>
22 #include <linux/interrupt.h>
23 #include <linux/slab.h>
24 #include <linux/atomic.h>
25 #include <linux/videodev2.h>
26 #include <linux/mutex.h>
27 #include <linux/debugfs.h>
28 #include <media/v4l2-common.h>
29 #include <media/v4l2-ioctl.h>
30 #include <media/v4l2-ctrls.h>
31 #include <media/v4l2-event.h>
32 #include <media/v4l2-device.h>
34 #include <media/drv-intf/si476x.h>
35 #include <linux/mfd/si476x-core.h>
37 #define FM_FREQ_RANGE_LOW 64000000
38 #define FM_FREQ_RANGE_HIGH 108000000
40 #define AM_FREQ_RANGE_LOW 520000
41 #define AM_FREQ_RANGE_HIGH 30000000
43 #define PWRLINEFLTR (1 << 8)
45 #define FREQ_MUL (10000000 / 625)
47 #define SI476X_PHDIV_STATUS_LINK_LOCKED(status) (0x80 & (status))
49 #define DRIVER_NAME "si476x-radio"
50 #define DRIVER_CARD "SI476x AM/FM Receiver"
52 enum si476x_freq_bands
{
57 static const struct v4l2_frequency_band si476x_bands
[] = {
59 .type
= V4L2_TUNER_RADIO
,
60 .index
= SI476X_BAND_FM
,
61 .capability
= V4L2_TUNER_CAP_LOW
62 | V4L2_TUNER_CAP_STEREO
64 | V4L2_TUNER_CAP_RDS_BLOCK_IO
65 | V4L2_TUNER_CAP_FREQ_BANDS
,
66 .rangelow
= 64 * FREQ_MUL
,
67 .rangehigh
= 108 * FREQ_MUL
,
68 .modulation
= V4L2_BAND_MODULATION_FM
,
71 .type
= V4L2_TUNER_RADIO
,
72 .index
= SI476X_BAND_AM
,
73 .capability
= V4L2_TUNER_CAP_LOW
74 | V4L2_TUNER_CAP_FREQ_BANDS
,
75 .rangelow
= 0.52 * FREQ_MUL
,
76 .rangehigh
= 30 * FREQ_MUL
,
77 .modulation
= V4L2_BAND_MODULATION_AM
,
81 static inline bool si476x_radio_freq_is_inside_of_the_band(u32 freq
, int band
)
83 return freq
>= si476x_bands
[band
].rangelow
&&
84 freq
<= si476x_bands
[band
].rangehigh
;
87 static inline bool si476x_radio_range_is_inside_of_the_band(u32 low
, u32 high
,
90 return low
>= si476x_bands
[band
].rangelow
&&
91 high
<= si476x_bands
[band
].rangehigh
;
94 static int si476x_radio_s_ctrl(struct v4l2_ctrl
*ctrl
);
95 static int si476x_radio_g_volatile_ctrl(struct v4l2_ctrl
*ctrl
);
97 enum phase_diversity_modes_idx
{
98 SI476X_IDX_PHDIV_DISABLED
,
99 SI476X_IDX_PHDIV_PRIMARY_COMBINING
,
100 SI476X_IDX_PHDIV_PRIMARY_ANTENNA
,
101 SI476X_IDX_PHDIV_SECONDARY_ANTENNA
,
102 SI476X_IDX_PHDIV_SECONDARY_COMBINING
,
105 static const char * const phase_diversity_modes
[] = {
106 [SI476X_IDX_PHDIV_DISABLED
] = "Disabled",
107 [SI476X_IDX_PHDIV_PRIMARY_COMBINING
] = "Primary with Secondary",
108 [SI476X_IDX_PHDIV_PRIMARY_ANTENNA
] = "Primary Antenna",
109 [SI476X_IDX_PHDIV_SECONDARY_ANTENNA
] = "Secondary Antenna",
110 [SI476X_IDX_PHDIV_SECONDARY_COMBINING
] = "Secondary with Primary",
113 static inline enum phase_diversity_modes_idx
114 si476x_phase_diversity_mode_to_idx(enum si476x_phase_diversity_mode mode
)
117 default: /* FALLTHROUGH */
118 case SI476X_PHDIV_DISABLED
:
119 return SI476X_IDX_PHDIV_DISABLED
;
120 case SI476X_PHDIV_PRIMARY_COMBINING
:
121 return SI476X_IDX_PHDIV_PRIMARY_COMBINING
;
122 case SI476X_PHDIV_PRIMARY_ANTENNA
:
123 return SI476X_IDX_PHDIV_PRIMARY_ANTENNA
;
124 case SI476X_PHDIV_SECONDARY_ANTENNA
:
125 return SI476X_IDX_PHDIV_SECONDARY_ANTENNA
;
126 case SI476X_PHDIV_SECONDARY_COMBINING
:
127 return SI476X_IDX_PHDIV_SECONDARY_COMBINING
;
131 static inline enum si476x_phase_diversity_mode
132 si476x_phase_diversity_idx_to_mode(enum phase_diversity_modes_idx idx
)
134 static const int idx_to_value
[] = {
135 [SI476X_IDX_PHDIV_DISABLED
] = SI476X_PHDIV_DISABLED
,
136 [SI476X_IDX_PHDIV_PRIMARY_COMBINING
] = SI476X_PHDIV_PRIMARY_COMBINING
,
137 [SI476X_IDX_PHDIV_PRIMARY_ANTENNA
] = SI476X_PHDIV_PRIMARY_ANTENNA
,
138 [SI476X_IDX_PHDIV_SECONDARY_ANTENNA
] = SI476X_PHDIV_SECONDARY_ANTENNA
,
139 [SI476X_IDX_PHDIV_SECONDARY_COMBINING
] = SI476X_PHDIV_SECONDARY_COMBINING
,
142 return idx_to_value
[idx
];
145 static const struct v4l2_ctrl_ops si476x_ctrl_ops
= {
146 .g_volatile_ctrl
= si476x_radio_g_volatile_ctrl
,
147 .s_ctrl
= si476x_radio_s_ctrl
,
151 enum si476x_ctrl_idx
{
152 SI476X_IDX_RSSI_THRESHOLD
,
153 SI476X_IDX_SNR_THRESHOLD
,
154 SI476X_IDX_MAX_TUNE_ERROR
,
155 SI476X_IDX_HARMONICS_COUNT
,
156 SI476X_IDX_DIVERSITY_MODE
,
157 SI476X_IDX_INTERCHIP_LINK
,
159 static struct v4l2_ctrl_config si476x_ctrls
[] = {
162 * SI476X during its station seeking(or tuning) process uses several
163 * parameters to detrmine if "the station" is valid:
165 * - Signal's SNR(in dBuV) must be lower than
166 * #V4L2_CID_SI476X_SNR_THRESHOLD
167 * - Signal's RSSI(in dBuV) must be greater than
168 * #V4L2_CID_SI476X_RSSI_THRESHOLD
169 * - Signal's frequency deviation(in units of 2ppm) must not be
170 * more than #V4L2_CID_SI476X_MAX_TUNE_ERROR
172 [SI476X_IDX_RSSI_THRESHOLD
] = {
173 .ops
= &si476x_ctrl_ops
,
174 .id
= V4L2_CID_SI476X_RSSI_THRESHOLD
,
175 .name
= "Valid RSSI Threshold",
176 .type
= V4L2_CTRL_TYPE_INTEGER
,
181 [SI476X_IDX_SNR_THRESHOLD
] = {
182 .ops
= &si476x_ctrl_ops
,
183 .id
= V4L2_CID_SI476X_SNR_THRESHOLD
,
184 .type
= V4L2_CTRL_TYPE_INTEGER
,
185 .name
= "Valid SNR Threshold",
190 [SI476X_IDX_MAX_TUNE_ERROR
] = {
191 .ops
= &si476x_ctrl_ops
,
192 .id
= V4L2_CID_SI476X_MAX_TUNE_ERROR
,
193 .type
= V4L2_CTRL_TYPE_INTEGER
,
194 .name
= "Max Tune Errors",
201 * #V4L2_CID_SI476X_HARMONICS_COUNT -- number of harmonics
202 * built-in power-line noise supression filter is to reject
203 * during AM-mode operation.
205 [SI476X_IDX_HARMONICS_COUNT
] = {
206 .ops
= &si476x_ctrl_ops
,
207 .id
= V4L2_CID_SI476X_HARMONICS_COUNT
,
208 .type
= V4L2_CTRL_TYPE_INTEGER
,
210 .name
= "Count of Harmonics to Reject",
217 * #V4L2_CID_SI476X_DIVERSITY_MODE -- configuration which
218 * two tuners working in diversity mode are to work in.
220 * - #SI476X_IDX_PHDIV_DISABLED diversity mode disabled
221 * - #SI476X_IDX_PHDIV_PRIMARY_COMBINING diversity mode is
222 * on, primary tuner's antenna is the main one.
223 * - #SI476X_IDX_PHDIV_PRIMARY_ANTENNA diversity mode is
224 * off, primary tuner's antenna is the main one.
225 * - #SI476X_IDX_PHDIV_SECONDARY_ANTENNA diversity mode is
226 * off, secondary tuner's antenna is the main one.
227 * - #SI476X_IDX_PHDIV_SECONDARY_COMBINING diversity mode is
228 * on, secondary tuner's antenna is the main one.
230 [SI476X_IDX_DIVERSITY_MODE
] = {
231 .ops
= &si476x_ctrl_ops
,
232 .id
= V4L2_CID_SI476X_DIVERSITY_MODE
,
233 .type
= V4L2_CTRL_TYPE_MENU
,
234 .name
= "Phase Diversity Mode",
235 .qmenu
= phase_diversity_modes
,
237 .max
= ARRAY_SIZE(phase_diversity_modes
) - 1,
241 * #V4L2_CID_SI476X_INTERCHIP_LINK -- inter-chip link in
242 * diversity mode indicator. Allows user to determine if two
243 * chips working in diversity mode have established a link
244 * between each other and if the system as a whole uses
245 * signals from both antennas to receive FM radio.
247 [SI476X_IDX_INTERCHIP_LINK
] = {
248 .ops
= &si476x_ctrl_ops
,
249 .id
= V4L2_CID_SI476X_INTERCHIP_LINK
,
250 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
251 .flags
= V4L2_CTRL_FLAG_READ_ONLY
| V4L2_CTRL_FLAG_VOLATILE
,
252 .name
= "Inter-Chip Link",
262 * struct si476x_radio_ops - vtable of tuner functions
264 * This table holds pointers to functions implementing particular
265 * operations depending on the mode in which the tuner chip was
266 * configured to start in. If the function is not supported
267 * corresponding element is set to #NULL.
269 * @tune_freq: Tune chip to a specific frequency
270 * @seek_start: Star station seeking
271 * @rsq_status: Get Received Signal Quality(RSQ) status
272 * @rds_blckcnt: Get received RDS blocks count
273 * @phase_diversity: Change phase diversity mode of the tuner
274 * @phase_div_status: Get phase diversity mode status
275 * @acf_status: Get the status of Automatically Controlled
277 * @agc_status: Get Automatic Gain Control(AGC) status
279 struct si476x_radio_ops
{
280 int (*tune_freq
)(struct si476x_core
*, struct si476x_tune_freq_args
*);
281 int (*seek_start
)(struct si476x_core
*, bool, bool);
282 int (*rsq_status
)(struct si476x_core
*, struct si476x_rsq_status_args
*,
283 struct si476x_rsq_status_report
*);
284 int (*rds_blckcnt
)(struct si476x_core
*, bool,
285 struct si476x_rds_blockcount_report
*);
287 int (*phase_diversity
)(struct si476x_core
*,
288 enum si476x_phase_diversity_mode
);
289 int (*phase_div_status
)(struct si476x_core
*);
290 int (*acf_status
)(struct si476x_core
*,
291 struct si476x_acf_status_report
*);
292 int (*agc_status
)(struct si476x_core
*,
293 struct si476x_agc_status_report
*);
297 * struct si476x_radio - radio device
299 * @v4l2dev: Pointer to V4L2 device created by V4L2 subsystem
300 * @videodev: Pointer to video device created by V4L2 subsystem
301 * @ctrl_handler: V4L2 controls handler
302 * @core: Pointer to underlying core device
303 * @ops: Vtable of functions. See struct si476x_radio_ops for details
304 * @debugfs: pointer to &strucd dentry for debugfs
305 * @audmode: audio mode, as defined for the rxsubchans field
308 * core structure is the radio device is being used
310 struct si476x_radio
{
311 struct v4l2_device v4l2dev
;
312 struct video_device videodev
;
313 struct v4l2_ctrl_handler ctrl_handler
;
315 struct si476x_core
*core
;
316 /* This field should not be accesses unless core lock is held */
317 const struct si476x_radio_ops
*ops
;
319 struct dentry
*debugfs
;
323 static inline struct si476x_radio
*
324 v4l2_dev_to_radio(struct v4l2_device
*d
)
326 return container_of(d
, struct si476x_radio
, v4l2dev
);
329 static inline struct si476x_radio
*
330 v4l2_ctrl_handler_to_radio(struct v4l2_ctrl_handler
*d
)
332 return container_of(d
, struct si476x_radio
, ctrl_handler
);
336 * si476x_vidioc_querycap - query device capabilities
338 static int si476x_radio_querycap(struct file
*file
, void *priv
,
339 struct v4l2_capability
*capability
)
341 struct si476x_radio
*radio
= video_drvdata(file
);
343 strlcpy(capability
->driver
, radio
->v4l2dev
.name
,
344 sizeof(capability
->driver
));
345 strlcpy(capability
->card
, DRIVER_CARD
, sizeof(capability
->card
));
346 snprintf(capability
->bus_info
, sizeof(capability
->bus_info
),
347 "platform:%s", radio
->v4l2dev
.name
);
349 capability
->device_caps
= V4L2_CAP_TUNER
351 | V4L2_CAP_HW_FREQ_SEEK
;
353 si476x_core_lock(radio
->core
);
354 if (!si476x_core_is_a_secondary_tuner(radio
->core
))
355 capability
->device_caps
|= V4L2_CAP_RDS_CAPTURE
356 | V4L2_CAP_READWRITE
;
357 si476x_core_unlock(radio
->core
);
359 capability
->capabilities
= capability
->device_caps
360 | V4L2_CAP_DEVICE_CAPS
;
364 static int si476x_radio_enum_freq_bands(struct file
*file
, void *priv
,
365 struct v4l2_frequency_band
*band
)
368 struct si476x_radio
*radio
= video_drvdata(file
);
370 if (band
->tuner
!= 0)
373 switch (radio
->core
->chip_id
) {
374 /* AM/FM tuners -- all bands are supported */
375 case SI476X_CHIP_SI4761
:
376 case SI476X_CHIP_SI4764
:
377 if (band
->index
< ARRAY_SIZE(si476x_bands
)) {
378 *band
= si476x_bands
[band
->index
];
384 /* FM companion tuner chips -- only FM bands are
386 case SI476X_CHIP_SI4768
:
387 if (band
->index
== SI476X_BAND_FM
) {
388 *band
= si476x_bands
[band
->index
];
401 static int si476x_radio_g_tuner(struct file
*file
, void *priv
,
402 struct v4l2_tuner
*tuner
)
405 struct si476x_rsq_status_report report
;
406 struct si476x_radio
*radio
= video_drvdata(file
);
408 struct si476x_rsq_status_args args
= {
416 if (tuner
->index
!= 0)
419 tuner
->type
= V4L2_TUNER_RADIO
;
420 tuner
->capability
= V4L2_TUNER_CAP_LOW
/* Measure frequencies
423 | V4L2_TUNER_CAP_STEREO
424 | V4L2_TUNER_CAP_HWSEEK_BOUNDED
425 | V4L2_TUNER_CAP_HWSEEK_WRAP
426 | V4L2_TUNER_CAP_HWSEEK_PROG_LIM
;
428 si476x_core_lock(radio
->core
);
430 if (si476x_core_is_a_secondary_tuner(radio
->core
)) {
431 strlcpy(tuner
->name
, "FM (secondary)", sizeof(tuner
->name
));
432 tuner
->rxsubchans
= 0;
433 tuner
->rangelow
= si476x_bands
[SI476X_BAND_FM
].rangelow
;
434 } else if (si476x_core_has_am(radio
->core
)) {
435 if (si476x_core_is_a_primary_tuner(radio
->core
))
436 strlcpy(tuner
->name
, "AM/FM (primary)",
437 sizeof(tuner
->name
));
439 strlcpy(tuner
->name
, "AM/FM", sizeof(tuner
->name
));
441 tuner
->rxsubchans
= V4L2_TUNER_SUB_MONO
| V4L2_TUNER_SUB_STEREO
442 | V4L2_TUNER_SUB_RDS
;
443 tuner
->capability
|= V4L2_TUNER_CAP_RDS
444 | V4L2_TUNER_CAP_RDS_BLOCK_IO
445 | V4L2_TUNER_CAP_FREQ_BANDS
;
447 tuner
->rangelow
= si476x_bands
[SI476X_BAND_AM
].rangelow
;
449 strlcpy(tuner
->name
, "FM", sizeof(tuner
->name
));
450 tuner
->rxsubchans
= V4L2_TUNER_SUB_RDS
;
451 tuner
->capability
|= V4L2_TUNER_CAP_RDS
452 | V4L2_TUNER_CAP_RDS_BLOCK_IO
453 | V4L2_TUNER_CAP_FREQ_BANDS
;
454 tuner
->rangelow
= si476x_bands
[SI476X_BAND_FM
].rangelow
;
457 tuner
->audmode
= radio
->audmode
;
460 tuner
->rangehigh
= si476x_bands
[SI476X_BAND_FM
].rangehigh
;
462 err
= radio
->ops
->rsq_status(radio
->core
,
468 * tuner->signal value range: 0x0000 .. 0xFFFF,
469 * report.rssi: -128 .. 127
471 tuner
->signal
= (report
.rssi
+ 128) * 257;
473 si476x_core_unlock(radio
->core
);
478 static int si476x_radio_s_tuner(struct file
*file
, void *priv
,
479 const struct v4l2_tuner
*tuner
)
481 struct si476x_radio
*radio
= video_drvdata(file
);
483 if (tuner
->index
!= 0)
486 if (tuner
->audmode
== V4L2_TUNER_MODE_MONO
||
487 tuner
->audmode
== V4L2_TUNER_MODE_STEREO
)
488 radio
->audmode
= tuner
->audmode
;
490 radio
->audmode
= V4L2_TUNER_MODE_STEREO
;
495 static int si476x_radio_init_vtable(struct si476x_radio
*radio
,
496 enum si476x_func func
)
498 static const struct si476x_radio_ops fm_ops
= {
499 .tune_freq
= si476x_core_cmd_fm_tune_freq
,
500 .seek_start
= si476x_core_cmd_fm_seek_start
,
501 .rsq_status
= si476x_core_cmd_fm_rsq_status
,
502 .rds_blckcnt
= si476x_core_cmd_fm_rds_blockcount
,
503 .phase_diversity
= si476x_core_cmd_fm_phase_diversity
,
504 .phase_div_status
= si476x_core_cmd_fm_phase_div_status
,
505 .acf_status
= si476x_core_cmd_fm_acf_status
,
506 .agc_status
= si476x_core_cmd_agc_status
,
509 static const struct si476x_radio_ops am_ops
= {
510 .tune_freq
= si476x_core_cmd_am_tune_freq
,
511 .seek_start
= si476x_core_cmd_am_seek_start
,
512 .rsq_status
= si476x_core_cmd_am_rsq_status
,
514 .phase_diversity
= NULL
,
515 .phase_div_status
= NULL
,
516 .acf_status
= si476x_core_cmd_am_acf_status
,
521 case SI476X_FUNC_FM_RECEIVER
:
522 radio
->ops
= &fm_ops
;
525 case SI476X_FUNC_AM_RECEIVER
:
526 radio
->ops
= &am_ops
;
529 WARN(1, "Unexpected tuner function value\n");
534 static int si476x_radio_pretune(struct si476x_radio
*radio
,
535 enum si476x_func func
)
539 struct si476x_tune_freq_args args
= {
542 .injside
= SI476X_INJSIDE_AUTO
,
543 .tunemode
= SI476X_TM_VALIDATED_NORMAL_TUNE
,
544 .smoothmetrics
= SI476X_SM_INITIALIZE_AUDIO
,
549 case SI476X_FUNC_FM_RECEIVER
:
550 args
.freq
= v4l2_to_si476x(radio
->core
,
552 retval
= radio
->ops
->tune_freq(radio
->core
, &args
);
554 case SI476X_FUNC_AM_RECEIVER
:
555 args
.freq
= v4l2_to_si476x(radio
->core
,
557 retval
= radio
->ops
->tune_freq(radio
->core
, &args
);
560 WARN(1, "Unexpected tuner function value\n");
566 static int si476x_radio_do_post_powerup_init(struct si476x_radio
*radio
,
567 enum si476x_func func
)
571 /* regcache_mark_dirty(radio->core->regmap); */
572 err
= regcache_sync_region(radio
->core
->regmap
,
573 SI476X_PROP_DIGITAL_IO_INPUT_SAMPLE_RATE
,
574 SI476X_PROP_DIGITAL_IO_OUTPUT_FORMAT
);
578 err
= regcache_sync_region(radio
->core
->regmap
,
579 SI476X_PROP_AUDIO_DEEMPHASIS
,
580 SI476X_PROP_AUDIO_PWR_LINE_FILTER
);
584 err
= regcache_sync_region(radio
->core
->regmap
,
585 SI476X_PROP_INT_CTL_ENABLE
,
586 SI476X_PROP_INT_CTL_ENABLE
);
591 * Is there any point in restoring SNR and the like
592 * when switching between AM/FM?
594 err
= regcache_sync_region(radio
->core
->regmap
,
595 SI476X_PROP_VALID_MAX_TUNE_ERROR
,
596 SI476X_PROP_VALID_MAX_TUNE_ERROR
);
600 err
= regcache_sync_region(radio
->core
->regmap
,
601 SI476X_PROP_VALID_SNR_THRESHOLD
,
602 SI476X_PROP_VALID_RSSI_THRESHOLD
);
606 if (func
== SI476X_FUNC_FM_RECEIVER
) {
607 if (si476x_core_has_diversity(radio
->core
)) {
608 err
= si476x_core_cmd_fm_phase_diversity(radio
->core
,
609 radio
->core
->diversity_mode
);
614 err
= regcache_sync_region(radio
->core
->regmap
,
615 SI476X_PROP_FM_RDS_INTERRUPT_SOURCE
,
616 SI476X_PROP_FM_RDS_CONFIG
);
621 return si476x_radio_init_vtable(radio
, func
);
625 static int si476x_radio_change_func(struct si476x_radio
*radio
,
626 enum si476x_func func
)
631 * Since power/up down is a very time consuming operation,
632 * try to avoid doing it if the requested mode matches the one
635 if (func
== radio
->core
->power_up_parameters
.func
)
639 err
= si476x_core_stop(radio
->core
, soft
);
642 * OK, if the chip does not want to play nice let's
643 * try to reset it in more brutal way
646 err
= si476x_core_stop(radio
->core
, soft
);
651 Set the desired radio tuner function
653 radio
->core
->power_up_parameters
.func
= func
;
655 err
= si476x_core_start(radio
->core
, soft
);
660 * No need to do the rest of manipulations for the bootlader
663 if (func
!= SI476X_FUNC_FM_RECEIVER
&&
664 func
!= SI476X_FUNC_AM_RECEIVER
)
667 return si476x_radio_do_post_powerup_init(radio
, func
);
670 static int si476x_radio_g_frequency(struct file
*file
, void *priv
,
671 struct v4l2_frequency
*f
)
674 struct si476x_radio
*radio
= video_drvdata(file
);
677 f
->type
!= V4L2_TUNER_RADIO
)
680 si476x_core_lock(radio
->core
);
682 if (radio
->ops
->rsq_status
) {
683 struct si476x_rsq_status_report report
;
684 struct si476x_rsq_status_args args
= {
692 err
= radio
->ops
->rsq_status(radio
->core
, &args
, &report
);
694 f
->frequency
= si476x_to_v4l2(radio
->core
,
700 si476x_core_unlock(radio
->core
);
705 static int si476x_radio_s_frequency(struct file
*file
, void *priv
,
706 const struct v4l2_frequency
*f
)
709 u32 freq
= f
->frequency
;
710 struct si476x_tune_freq_args args
;
711 struct si476x_radio
*radio
= video_drvdata(file
);
713 const u32 midrange
= (si476x_bands
[SI476X_BAND_AM
].rangehigh
+
714 si476x_bands
[SI476X_BAND_FM
].rangelow
) / 2;
715 const int band
= (freq
> midrange
) ?
716 SI476X_BAND_FM
: SI476X_BAND_AM
;
717 const enum si476x_func func
= (band
== SI476X_BAND_AM
) ?
718 SI476X_FUNC_AM_RECEIVER
: SI476X_FUNC_FM_RECEIVER
;
721 f
->type
!= V4L2_TUNER_RADIO
)
724 si476x_core_lock(radio
->core
);
727 si476x_bands
[band
].rangelow
,
728 si476x_bands
[band
].rangehigh
);
730 if (si476x_radio_freq_is_inside_of_the_band(freq
,
732 (!si476x_core_has_am(radio
->core
) ||
733 si476x_core_is_a_secondary_tuner(radio
->core
))) {
738 err
= si476x_radio_change_func(radio
, func
);
744 args
.injside
= SI476X_INJSIDE_AUTO
;
745 args
.freq
= v4l2_to_si476x(radio
->core
, freq
);
746 args
.tunemode
= SI476X_TM_VALIDATED_NORMAL_TUNE
;
747 args
.smoothmetrics
= SI476X_SM_INITIALIZE_AUDIO
;
750 err
= radio
->ops
->tune_freq(radio
->core
, &args
);
753 si476x_core_unlock(radio
->core
);
757 static int si476x_radio_s_hw_freq_seek(struct file
*file
, void *priv
,
758 const struct v4l2_hw_freq_seek
*seek
)
761 enum si476x_func func
;
762 u32 rangelow
= seek
->rangelow
, rangehigh
= seek
->rangehigh
;
763 struct si476x_radio
*radio
= video_drvdata(file
);
765 if (file
->f_flags
& O_NONBLOCK
)
768 if (seek
->tuner
!= 0 ||
769 seek
->type
!= V4L2_TUNER_RADIO
)
772 si476x_core_lock(radio
->core
);
775 err
= regmap_read(radio
->core
->regmap
,
776 SI476X_PROP_SEEK_BAND_BOTTOM
,
780 rangelow
= si476x_to_v4l2(radio
->core
, rangelow
);
783 err
= regmap_read(radio
->core
->regmap
,
784 SI476X_PROP_SEEK_BAND_TOP
,
788 rangehigh
= si476x_to_v4l2(radio
->core
, rangehigh
);
791 if (rangelow
> rangehigh
) {
796 if (si476x_radio_range_is_inside_of_the_band(rangelow
, rangehigh
,
798 func
= SI476X_FUNC_FM_RECEIVER
;
800 } else if (si476x_core_has_am(radio
->core
) &&
801 si476x_radio_range_is_inside_of_the_band(rangelow
, rangehigh
,
803 func
= SI476X_FUNC_AM_RECEIVER
;
809 err
= si476x_radio_change_func(radio
, func
);
813 if (seek
->rangehigh
) {
814 err
= regmap_write(radio
->core
->regmap
,
815 SI476X_PROP_SEEK_BAND_TOP
,
816 v4l2_to_si476x(radio
->core
,
821 if (seek
->rangelow
) {
822 err
= regmap_write(radio
->core
->regmap
,
823 SI476X_PROP_SEEK_BAND_BOTTOM
,
824 v4l2_to_si476x(radio
->core
,
830 err
= regmap_write(radio
->core
->regmap
,
831 SI476X_PROP_SEEK_FREQUENCY_SPACING
,
832 v4l2_to_si476x(radio
->core
,
838 err
= radio
->ops
->seek_start(radio
->core
,
842 si476x_core_unlock(radio
->core
);
849 static int si476x_radio_g_volatile_ctrl(struct v4l2_ctrl
*ctrl
)
852 struct si476x_radio
*radio
= v4l2_ctrl_handler_to_radio(ctrl
->handler
);
854 si476x_core_lock(radio
->core
);
857 case V4L2_CID_SI476X_INTERCHIP_LINK
:
858 if (si476x_core_has_diversity(radio
->core
)) {
859 if (radio
->ops
->phase_diversity
) {
860 retval
= radio
->ops
->phase_div_status(radio
->core
);
864 ctrl
->val
= !!SI476X_PHDIV_STATUS_LINK_LOCKED(retval
);
878 si476x_core_unlock(radio
->core
);
883 static int si476x_radio_s_ctrl(struct v4l2_ctrl
*ctrl
)
886 enum si476x_phase_diversity_mode mode
;
887 struct si476x_radio
*radio
= v4l2_ctrl_handler_to_radio(ctrl
->handler
);
889 si476x_core_lock(radio
->core
);
892 case V4L2_CID_SI476X_HARMONICS_COUNT
:
893 retval
= regmap_update_bits(radio
->core
->regmap
,
894 SI476X_PROP_AUDIO_PWR_LINE_FILTER
,
895 SI476X_PROP_PWR_HARMONICS_MASK
,
898 case V4L2_CID_POWER_LINE_FREQUENCY
:
900 case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED
:
901 retval
= regmap_update_bits(radio
->core
->regmap
,
902 SI476X_PROP_AUDIO_PWR_LINE_FILTER
,
903 SI476X_PROP_PWR_ENABLE_MASK
,
906 case V4L2_CID_POWER_LINE_FREQUENCY_50HZ
:
907 retval
= regmap_update_bits(radio
->core
->regmap
,
908 SI476X_PROP_AUDIO_PWR_LINE_FILTER
,
909 SI476X_PROP_PWR_GRID_MASK
,
910 SI476X_PROP_PWR_GRID_50HZ
);
912 case V4L2_CID_POWER_LINE_FREQUENCY_60HZ
:
913 retval
= regmap_update_bits(radio
->core
->regmap
,
914 SI476X_PROP_AUDIO_PWR_LINE_FILTER
,
915 SI476X_PROP_PWR_GRID_MASK
,
916 SI476X_PROP_PWR_GRID_60HZ
);
923 case V4L2_CID_SI476X_RSSI_THRESHOLD
:
924 retval
= regmap_write(radio
->core
->regmap
,
925 SI476X_PROP_VALID_RSSI_THRESHOLD
,
928 case V4L2_CID_SI476X_SNR_THRESHOLD
:
929 retval
= regmap_write(radio
->core
->regmap
,
930 SI476X_PROP_VALID_SNR_THRESHOLD
,
933 case V4L2_CID_SI476X_MAX_TUNE_ERROR
:
934 retval
= regmap_write(radio
->core
->regmap
,
935 SI476X_PROP_VALID_MAX_TUNE_ERROR
,
938 case V4L2_CID_RDS_RECEPTION
:
940 * It looks like RDS related properties are
941 * inaccesable when tuner is in AM mode, so cache the
944 if (si476x_core_is_in_am_receiver_mode(radio
->core
))
945 regcache_cache_only(radio
->core
->regmap
, true);
948 retval
= regmap_write(radio
->core
->regmap
,
949 SI476X_PROP_FM_RDS_INTERRUPT_FIFO_COUNT
,
950 radio
->core
->rds_fifo_depth
);
954 if (radio
->core
->client
->irq
) {
955 retval
= regmap_write(radio
->core
->regmap
,
956 SI476X_PROP_FM_RDS_INTERRUPT_SOURCE
,
962 /* Drain RDS FIFO before enabling RDS processing */
963 retval
= si476x_core_cmd_fm_rds_status(radio
->core
,
971 retval
= regmap_update_bits(radio
->core
->regmap
,
972 SI476X_PROP_FM_RDS_CONFIG
,
973 SI476X_PROP_RDSEN_MASK
,
976 retval
= regmap_update_bits(radio
->core
->regmap
,
977 SI476X_PROP_FM_RDS_CONFIG
,
978 SI476X_PROP_RDSEN_MASK
,
982 if (si476x_core_is_in_am_receiver_mode(radio
->core
))
983 regcache_cache_only(radio
->core
->regmap
, false);
985 case V4L2_CID_TUNE_DEEMPHASIS
:
986 retval
= regmap_write(radio
->core
->regmap
,
987 SI476X_PROP_AUDIO_DEEMPHASIS
,
991 case V4L2_CID_SI476X_DIVERSITY_MODE
:
992 mode
= si476x_phase_diversity_idx_to_mode(ctrl
->val
);
994 if (mode
== radio
->core
->diversity_mode
) {
999 if (si476x_core_is_in_am_receiver_mode(radio
->core
)) {
1001 * Diversity cannot be configured while tuner
1002 * is in AM mode so save the changes and carry on.
1004 radio
->core
->diversity_mode
= mode
;
1007 retval
= radio
->ops
->phase_diversity(radio
->core
, mode
);
1009 radio
->core
->diversity_mode
= mode
;
1018 si476x_core_unlock(radio
->core
);
1023 #ifdef CONFIG_VIDEO_ADV_DEBUG
1024 static int si476x_radio_g_register(struct file
*file
, void *fh
,
1025 struct v4l2_dbg_register
*reg
)
1029 struct si476x_radio
*radio
= video_drvdata(file
);
1031 si476x_core_lock(radio
->core
);
1033 err
= regmap_read(radio
->core
->regmap
,
1034 (unsigned int)reg
->reg
, &value
);
1036 si476x_core_unlock(radio
->core
);
1040 static int si476x_radio_s_register(struct file
*file
, void *fh
,
1041 const struct v4l2_dbg_register
*reg
)
1045 struct si476x_radio
*radio
= video_drvdata(file
);
1047 si476x_core_lock(radio
->core
);
1048 err
= regmap_write(radio
->core
->regmap
,
1049 (unsigned int)reg
->reg
,
1050 (unsigned int)reg
->val
);
1051 si476x_core_unlock(radio
->core
);
1057 static int si476x_radio_fops_open(struct file
*file
)
1059 struct si476x_radio
*radio
= video_drvdata(file
);
1062 err
= v4l2_fh_open(file
);
1066 if (v4l2_fh_is_singular_file(file
)) {
1067 si476x_core_lock(radio
->core
);
1068 err
= si476x_core_set_power_state(radio
->core
,
1069 SI476X_POWER_UP_FULL
);
1073 err
= si476x_radio_do_post_powerup_init(radio
,
1074 radio
->core
->power_up_parameters
.func
);
1078 err
= si476x_radio_pretune(radio
,
1079 radio
->core
->power_up_parameters
.func
);
1083 si476x_core_unlock(radio
->core
);
1084 /*Must be done after si476x_core_unlock to prevent a deadlock*/
1085 v4l2_ctrl_handler_setup(&radio
->ctrl_handler
);
1091 si476x_core_set_power_state(radio
->core
,
1094 si476x_core_unlock(radio
->core
);
1095 v4l2_fh_release(file
);
1100 static int si476x_radio_fops_release(struct file
*file
)
1103 struct si476x_radio
*radio
= video_drvdata(file
);
1105 if (v4l2_fh_is_singular_file(file
) &&
1106 atomic_read(&radio
->core
->is_alive
))
1107 si476x_core_set_power_state(radio
->core
,
1110 err
= v4l2_fh_release(file
);
1115 static ssize_t
si476x_radio_fops_read(struct file
*file
, char __user
*buf
,
1116 size_t count
, loff_t
*ppos
)
1120 unsigned int copied
;
1122 struct si476x_radio
*radio
= video_drvdata(file
);
1124 /* block if no new data available */
1125 if (kfifo_is_empty(&radio
->core
->rds_fifo
)) {
1126 if (file
->f_flags
& O_NONBLOCK
)
1127 return -EWOULDBLOCK
;
1129 rval
= wait_event_interruptible(radio
->core
->rds_read_queue
,
1130 (!kfifo_is_empty(&radio
->core
->rds_fifo
) ||
1131 !atomic_read(&radio
->core
->is_alive
)));
1135 if (!atomic_read(&radio
->core
->is_alive
))
1139 fifo_len
= kfifo_len(&radio
->core
->rds_fifo
);
1141 if (kfifo_to_user(&radio
->core
->rds_fifo
, buf
,
1142 min(fifo_len
, count
),
1144 dev_warn(&radio
->videodev
.dev
,
1145 "Error during FIFO to userspace copy\n");
1148 rval
= (ssize_t
)copied
;
1154 static __poll_t
si476x_radio_fops_poll(struct file
*file
,
1155 struct poll_table_struct
*pts
)
1157 struct si476x_radio
*radio
= video_drvdata(file
);
1158 __poll_t req_events
= poll_requested_events(pts
);
1159 __poll_t err
= v4l2_ctrl_poll(file
, pts
);
1161 if (req_events
& (EPOLLIN
| EPOLLRDNORM
)) {
1162 if (atomic_read(&radio
->core
->is_alive
))
1163 poll_wait(file
, &radio
->core
->rds_read_queue
, pts
);
1165 if (!atomic_read(&radio
->core
->is_alive
))
1168 if (!kfifo_is_empty(&radio
->core
->rds_fifo
))
1169 err
= EPOLLIN
| EPOLLRDNORM
;
1175 static const struct v4l2_file_operations si476x_fops
= {
1176 .owner
= THIS_MODULE
,
1177 .read
= si476x_radio_fops_read
,
1178 .poll
= si476x_radio_fops_poll
,
1179 .unlocked_ioctl
= video_ioctl2
,
1180 .open
= si476x_radio_fops_open
,
1181 .release
= si476x_radio_fops_release
,
1185 static const struct v4l2_ioctl_ops si4761_ioctl_ops
= {
1186 .vidioc_querycap
= si476x_radio_querycap
,
1187 .vidioc_g_tuner
= si476x_radio_g_tuner
,
1188 .vidioc_s_tuner
= si476x_radio_s_tuner
,
1190 .vidioc_g_frequency
= si476x_radio_g_frequency
,
1191 .vidioc_s_frequency
= si476x_radio_s_frequency
,
1192 .vidioc_s_hw_freq_seek
= si476x_radio_s_hw_freq_seek
,
1193 .vidioc_enum_freq_bands
= si476x_radio_enum_freq_bands
,
1195 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1196 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1198 #ifdef CONFIG_VIDEO_ADV_DEBUG
1199 .vidioc_g_register
= si476x_radio_g_register
,
1200 .vidioc_s_register
= si476x_radio_s_register
,
1205 static const struct video_device si476x_viddev_template
= {
1206 .fops
= &si476x_fops
,
1207 .name
= DRIVER_NAME
,
1208 .release
= video_device_release_empty
,
1213 static ssize_t
si476x_radio_read_acf_blob(struct file
*file
,
1214 char __user
*user_buf
,
1215 size_t count
, loff_t
*ppos
)
1218 struct si476x_radio
*radio
= file
->private_data
;
1219 struct si476x_acf_status_report report
;
1221 si476x_core_lock(radio
->core
);
1222 if (radio
->ops
->acf_status
)
1223 err
= radio
->ops
->acf_status(radio
->core
, &report
);
1226 si476x_core_unlock(radio
->core
);
1231 return simple_read_from_buffer(user_buf
, count
, ppos
, &report
,
1235 static const struct file_operations radio_acf_fops
= {
1236 .open
= simple_open
,
1237 .llseek
= default_llseek
,
1238 .read
= si476x_radio_read_acf_blob
,
1241 static ssize_t
si476x_radio_read_rds_blckcnt_blob(struct file
*file
,
1242 char __user
*user_buf
,
1243 size_t count
, loff_t
*ppos
)
1246 struct si476x_radio
*radio
= file
->private_data
;
1247 struct si476x_rds_blockcount_report report
;
1249 si476x_core_lock(radio
->core
);
1250 if (radio
->ops
->rds_blckcnt
)
1251 err
= radio
->ops
->rds_blckcnt(radio
->core
, true,
1255 si476x_core_unlock(radio
->core
);
1260 return simple_read_from_buffer(user_buf
, count
, ppos
, &report
,
1264 static const struct file_operations radio_rds_blckcnt_fops
= {
1265 .open
= simple_open
,
1266 .llseek
= default_llseek
,
1267 .read
= si476x_radio_read_rds_blckcnt_blob
,
1270 static ssize_t
si476x_radio_read_agc_blob(struct file
*file
,
1271 char __user
*user_buf
,
1272 size_t count
, loff_t
*ppos
)
1275 struct si476x_radio
*radio
= file
->private_data
;
1276 struct si476x_agc_status_report report
;
1278 si476x_core_lock(radio
->core
);
1279 if (radio
->ops
->rds_blckcnt
)
1280 err
= radio
->ops
->agc_status(radio
->core
, &report
);
1283 si476x_core_unlock(radio
->core
);
1288 return simple_read_from_buffer(user_buf
, count
, ppos
, &report
,
1292 static const struct file_operations radio_agc_fops
= {
1293 .open
= simple_open
,
1294 .llseek
= default_llseek
,
1295 .read
= si476x_radio_read_agc_blob
,
1298 static ssize_t
si476x_radio_read_rsq_blob(struct file
*file
,
1299 char __user
*user_buf
,
1300 size_t count
, loff_t
*ppos
)
1303 struct si476x_radio
*radio
= file
->private_data
;
1304 struct si476x_rsq_status_report report
;
1305 struct si476x_rsq_status_args args
= {
1313 si476x_core_lock(radio
->core
);
1314 if (radio
->ops
->rds_blckcnt
)
1315 err
= radio
->ops
->rsq_status(radio
->core
, &args
, &report
);
1318 si476x_core_unlock(radio
->core
);
1323 return simple_read_from_buffer(user_buf
, count
, ppos
, &report
,
1327 static const struct file_operations radio_rsq_fops
= {
1328 .open
= simple_open
,
1329 .llseek
= default_llseek
,
1330 .read
= si476x_radio_read_rsq_blob
,
1333 static ssize_t
si476x_radio_read_rsq_primary_blob(struct file
*file
,
1334 char __user
*user_buf
,
1335 size_t count
, loff_t
*ppos
)
1338 struct si476x_radio
*radio
= file
->private_data
;
1339 struct si476x_rsq_status_report report
;
1340 struct si476x_rsq_status_args args
= {
1348 si476x_core_lock(radio
->core
);
1349 if (radio
->ops
->rds_blckcnt
)
1350 err
= radio
->ops
->rsq_status(radio
->core
, &args
, &report
);
1353 si476x_core_unlock(radio
->core
);
1358 return simple_read_from_buffer(user_buf
, count
, ppos
, &report
,
1362 static const struct file_operations radio_rsq_primary_fops
= {
1363 .open
= simple_open
,
1364 .llseek
= default_llseek
,
1365 .read
= si476x_radio_read_rsq_primary_blob
,
1369 static int si476x_radio_init_debugfs(struct si476x_radio
*radio
)
1371 struct dentry
*dentry
;
1374 dentry
= debugfs_create_dir(dev_name(radio
->v4l2dev
.dev
), NULL
);
1375 if (IS_ERR(dentry
)) {
1376 ret
= PTR_ERR(dentry
);
1379 radio
->debugfs
= dentry
;
1381 dentry
= debugfs_create_file("acf", S_IRUGO
,
1382 radio
->debugfs
, radio
, &radio_acf_fops
);
1383 if (IS_ERR(dentry
)) {
1384 ret
= PTR_ERR(dentry
);
1388 dentry
= debugfs_create_file("rds_blckcnt", S_IRUGO
,
1389 radio
->debugfs
, radio
,
1390 &radio_rds_blckcnt_fops
);
1391 if (IS_ERR(dentry
)) {
1392 ret
= PTR_ERR(dentry
);
1396 dentry
= debugfs_create_file("agc", S_IRUGO
,
1397 radio
->debugfs
, radio
, &radio_agc_fops
);
1398 if (IS_ERR(dentry
)) {
1399 ret
= PTR_ERR(dentry
);
1403 dentry
= debugfs_create_file("rsq", S_IRUGO
,
1404 radio
->debugfs
, radio
, &radio_rsq_fops
);
1405 if (IS_ERR(dentry
)) {
1406 ret
= PTR_ERR(dentry
);
1410 dentry
= debugfs_create_file("rsq_primary", S_IRUGO
,
1411 radio
->debugfs
, radio
,
1412 &radio_rsq_primary_fops
);
1413 if (IS_ERR(dentry
)) {
1414 ret
= PTR_ERR(dentry
);
1420 debugfs_remove_recursive(radio
->debugfs
);
1426 static int si476x_radio_add_new_custom(struct si476x_radio
*radio
,
1427 enum si476x_ctrl_idx idx
)
1430 struct v4l2_ctrl
*ctrl
;
1432 ctrl
= v4l2_ctrl_new_custom(&radio
->ctrl_handler
,
1435 rval
= radio
->ctrl_handler
.error
;
1436 if (ctrl
== NULL
&& rval
)
1437 dev_err(radio
->v4l2dev
.dev
,
1438 "Could not initialize '%s' control %d\n",
1439 si476x_ctrls
[idx
].name
, rval
);
1444 static int si476x_radio_probe(struct platform_device
*pdev
)
1447 struct si476x_radio
*radio
;
1448 struct v4l2_ctrl
*ctrl
;
1450 static atomic_t instance
= ATOMIC_INIT(0);
1452 radio
= devm_kzalloc(&pdev
->dev
, sizeof(*radio
), GFP_KERNEL
);
1456 radio
->core
= i2c_mfd_cell_to_core(&pdev
->dev
);
1458 v4l2_device_set_name(&radio
->v4l2dev
, DRIVER_NAME
, &instance
);
1460 rval
= v4l2_device_register(&pdev
->dev
, &radio
->v4l2dev
);
1462 dev_err(&pdev
->dev
, "Cannot register v4l2_device.\n");
1466 memcpy(&radio
->videodev
, &si476x_viddev_template
,
1467 sizeof(struct video_device
));
1469 radio
->videodev
.v4l2_dev
= &radio
->v4l2dev
;
1470 radio
->videodev
.ioctl_ops
= &si4761_ioctl_ops
;
1472 video_set_drvdata(&radio
->videodev
, radio
);
1473 platform_set_drvdata(pdev
, radio
);
1476 radio
->v4l2dev
.ctrl_handler
= &radio
->ctrl_handler
;
1477 v4l2_ctrl_handler_init(&radio
->ctrl_handler
,
1478 1 + ARRAY_SIZE(si476x_ctrls
));
1480 if (si476x_core_has_am(radio
->core
)) {
1481 ctrl
= v4l2_ctrl_new_std_menu(&radio
->ctrl_handler
,
1483 V4L2_CID_POWER_LINE_FREQUENCY
,
1484 V4L2_CID_POWER_LINE_FREQUENCY_60HZ
,
1486 rval
= radio
->ctrl_handler
.error
;
1487 if (ctrl
== NULL
&& rval
) {
1488 dev_err(&pdev
->dev
, "Could not initialize V4L2_CID_POWER_LINE_FREQUENCY control %d\n",
1493 rval
= si476x_radio_add_new_custom(radio
,
1494 SI476X_IDX_HARMONICS_COUNT
);
1499 rval
= si476x_radio_add_new_custom(radio
, SI476X_IDX_RSSI_THRESHOLD
);
1503 rval
= si476x_radio_add_new_custom(radio
, SI476X_IDX_SNR_THRESHOLD
);
1507 rval
= si476x_radio_add_new_custom(radio
, SI476X_IDX_MAX_TUNE_ERROR
);
1511 ctrl
= v4l2_ctrl_new_std_menu(&radio
->ctrl_handler
,
1513 V4L2_CID_TUNE_DEEMPHASIS
,
1514 V4L2_DEEMPHASIS_75_uS
, 0, 0);
1515 rval
= radio
->ctrl_handler
.error
;
1516 if (ctrl
== NULL
&& rval
) {
1517 dev_err(&pdev
->dev
, "Could not initialize V4L2_CID_TUNE_DEEMPHASIS control %d\n",
1522 ctrl
= v4l2_ctrl_new_std(&radio
->ctrl_handler
, &si476x_ctrl_ops
,
1523 V4L2_CID_RDS_RECEPTION
,
1525 rval
= radio
->ctrl_handler
.error
;
1526 if (ctrl
== NULL
&& rval
) {
1527 dev_err(&pdev
->dev
, "Could not initialize V4L2_CID_RDS_RECEPTION control %d\n",
1532 if (si476x_core_has_diversity(radio
->core
)) {
1533 si476x_ctrls
[SI476X_IDX_DIVERSITY_MODE
].def
=
1534 si476x_phase_diversity_mode_to_idx(radio
->core
->diversity_mode
);
1535 rval
= si476x_radio_add_new_custom(radio
, SI476X_IDX_DIVERSITY_MODE
);
1539 rval
= si476x_radio_add_new_custom(radio
, SI476X_IDX_INTERCHIP_LINK
);
1544 /* register video device */
1545 rval
= video_register_device(&radio
->videodev
, VFL_TYPE_RADIO
, -1);
1547 dev_err(&pdev
->dev
, "Could not register video device\n");
1551 rval
= si476x_radio_init_debugfs(radio
);
1553 dev_err(&pdev
->dev
, "Could not creat debugfs interface\n");
1559 v4l2_ctrl_handler_free(radio
->videodev
.ctrl_handler
);
1563 static int si476x_radio_remove(struct platform_device
*pdev
)
1565 struct si476x_radio
*radio
= platform_get_drvdata(pdev
);
1567 v4l2_ctrl_handler_free(radio
->videodev
.ctrl_handler
);
1568 video_unregister_device(&radio
->videodev
);
1569 v4l2_device_unregister(&radio
->v4l2dev
);
1570 debugfs_remove_recursive(radio
->debugfs
);
1575 MODULE_ALIAS("platform:si476x-radio");
1577 static struct platform_driver si476x_radio_driver
= {
1579 .name
= DRIVER_NAME
,
1581 .probe
= si476x_radio_probe
,
1582 .remove
= si476x_radio_remove
,
1584 module_platform_driver(si476x_radio_driver
);
1586 MODULE_AUTHOR("Andrey Smirnov <andrew.smirnov@gmail.com>");
1587 MODULE_DESCRIPTION("Driver for Si4761/64/68 AM/FM Radio MFD Cell");
1588 MODULE_LICENSE("GPL");