/*
 *  drivers/media/radio/si470x/radio-si470x-common.c
 *
 *  Driver for radios with Silicon Labs Si470x FM Radio Receivers
 *
 *  Copyright (c) 2009 Tobias Lorenz <tobias.lorenz@gmx.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */


/*
 * History:
 * 2008-01-12   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.0
 *              - First working version
 * 2008-01-13   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.1
 *              - Improved error handling, every function now returns errno
 *              - Improved multi user access (start/mute/stop)
 *              - Channel doesn't get lost anymore after start/mute/stop
 *              - RDS support added (polling mode via interrupt EP 1)
 *              - marked default module parameters with *value*
 *              - switched from bit structs to bit masks
 *              - header file cleaned and integrated
 * 2008-01-14   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.2
 *              - hex values are now lower case
 *              - commented USB ID for ADS/Tech moved on todo list
 *              - blacklisted si470x in hid-quirks.c
 *              - rds buffer handling functions integrated into *_work, *_read
 *              - rds_command in si470x_poll exchanged against simple retval
 *              - check for firmware version 15
 *              - code order and prototypes still remain the same
 *              - spacing and bottom of band codes remain the same
 * 2008-01-16   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.3
 *              - code reordered to avoid function prototypes
 *              - switch/case defaults are now more user-friendly
 *              - unified comment style
 *              - applied all checkpatch.pl v1.12 suggestions
 *                except the warning about the too long lines with bit comments
 *              - renamed FMRADIO to RADIO to cut line length (checkpatch.pl)
 * 2008-01-22   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.4
 *              - avoid poss. locking when doing copy_to_user which may sleep
 *              - RDS is automatically activated on read now
 *              - code cleaned of unnecessary rds_commands
 *              - USB Vendor/Product ID for ADS/Tech FM Radio Receiver verified
 *                (thanks to Guillaume RAMOUSSE)
 * 2008-01-27   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.5
 *              - number of seek_retries changed to tune_timeout
 *              - fixed problem with incomplete tune operations by own buffers
 *              - optimization of variables and printf types
 *              - improved error logging
 * 2008-01-31   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Oliver Neukum <oliver@neukum.org>
 *              Version 1.0.6
 *              - fixed coverity checker warnings in *_usb_driver_disconnect
 *              - probe()/open() race by correct ordering in probe()
 *              - DMA coherency rules by separate allocation of all buffers
 *              - use of endianness macros
 *              - abuse of spinlock, replaced by mutex
 *              - racy handling of timer in disconnect,
 *                replaced by delayed_work
 *              - racy interruptible_sleep_on(),
 *                replaced with wait_event_interruptible()
 *              - handle signals in read()
 * 2008-02-08   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Oliver Neukum <oliver@neukum.org>
 *              Version 1.0.7
 *              - usb autosuspend support
 *              - unplugging fixed
 * 2008-05-07   Tobias Lorenz <tobias.lorenz@gmx.net>
 *              Version 1.0.8
 *              - hardware frequency seek support
 *              - afc indication
 *              - more safety checks, let si470x_get_freq return errno
 *              - vidioc behavior corrected according to v4l2 spec
 * 2008-10-20   Alexey Klimov <klimov.linux@gmail.com>
 *              - add support for KWorld USB FM Radio FM700
 *              - blacklisted KWorld radio in hid-core.c and hid-ids.h
 * 2008-12-03   Mark Lord <mlord@pobox.com>
 *              - add support for DealExtreme USB Radio
 * 2009-01-31   Bob Ross <pigiron@gmx.com>
 *              - correction of stereo detection/setting
 *              - correction of signal strength indicator scaling
 * 2009-01-31   Rick Bronson <rick@efn.org>
 *              Tobias Lorenz <tobias.lorenz@gmx.net>
 *              - add LED status output
 *              - get HW/SW version from scratchpad
 * 2009-06-16   Edouard Lafargue <edouard@lafargue.name>
 *              Version 1.0.10
 *              - add support for interrupt mode for RDS endpoint,
 *                instead of polling.
 *                Improves RDS reception significantly
 */


/* kernel includes */
#include "radio-si470x.h"



/**************************************************************************
 * Module Parameters
 **************************************************************************/

/* Spacing (kHz) */
/* 0: 200 kHz (USA, Australia) */
/* 1: 100 kHz (Europe, Japan) */
/* 2:  50 kHz */
static unsigned short space = 2;
module_param(space, ushort, 0444);
MODULE_PARM_DESC(space, "Spacing: 0=200kHz 1=100kHz *2=50kHz*");

/* Bottom of Band (MHz) */
/* 0: 87.5 - 108 MHz (USA, Europe)*/
/* 1: 76   - 108 MHz (Japan wide band) */
/* 2: 76   -  90 MHz (Japan) */
static unsigned short band = 1;
module_param(band, ushort, 0444);
MODULE_PARM_DESC(band, "Band: 0=87.5..108MHz *1=76..108MHz* 2=76..90MHz");

/* De-emphasis */
/* 0: 75 us (USA) */
/* 1: 50 us (Europe, Australia, Japan) */
static unsigned short de = 1;
module_param(de, ushort, 0444);
MODULE_PARM_DESC(de, "De-emphasis: 0=75us *1=50us*");

/* Tune timeout */
static unsigned int tune_timeout = 3000;
module_param(tune_timeout, uint, 0644);
MODULE_PARM_DESC(tune_timeout, "Tune timeout: *3000*");

/* Seek timeout */
static unsigned int seek_timeout = 5000;
module_param(seek_timeout, uint, 0644);
MODULE_PARM_DESC(seek_timeout, "Seek timeout: *5000*");



/**************************************************************************
 * Generic Functions
 **************************************************************************/

/*
 * si470x_set_chan - set the channel
 */
static int si470x_set_chan(struct si470x_device *radio, unsigned short chan)
{
        int retval;
        unsigned long timeout;
        bool timed_out = 0;

        /* start tuning */
        radio->registers[CHANNEL] &= ~CHANNEL_CHAN;
        radio->registers[CHANNEL] |= CHANNEL_TUNE | chan;
        retval = si470x_set_register(radio, CHANNEL);
        if (retval < 0)
                goto done;

        /* wait till tune operation has completed */
        timeout = jiffies + msecs_to_jiffies(tune_timeout);
        do {
                retval = si470x_get_register(radio, STATUSRSSI);
                if (retval < 0)
                        goto stop;
                timed_out = time_after(jiffies, timeout);
        } while (((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0) &&
                (!timed_out));
        if ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0)
                dev_warn(&radio->videodev->dev, "tune does not complete\n");
        if (timed_out)
                dev_warn(&radio->videodev->dev,
                        "tune timed out after %u ms\n", tune_timeout);

stop:
        /* stop tuning */
        radio->registers[CHANNEL] &= ~CHANNEL_TUNE;
        retval = si470x_set_register(radio, CHANNEL);

done:
        return retval;
}


/*
 * si470x_get_freq - get the frequency
 */
static int si470x_get_freq(struct si470x_device *radio, unsigned int *freq)
{
        unsigned int spacing, band_bottom;
        unsigned short chan;
        int retval;

        /* Spacing (kHz) */
        switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_SPACE) >> 4) {
        /* 0: 200 kHz (USA, Australia) */
        case 0:
                spacing = 0.200 * FREQ_MUL; break;
        /* 1: 100 kHz (Europe, Japan) */
        case 1:
                spacing = 0.100 * FREQ_MUL; break;
        /* 2:  50 kHz */
        default:
                spacing = 0.050 * FREQ_MUL; break;
        };

        /* Bottom of Band (MHz) */
        switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_BAND) >> 6) {
        /* 0: 87.5 - 108 MHz (USA, Europe) */
        case 0:
                band_bottom = 87.5 * FREQ_MUL; break;
        /* 1: 76   - 108 MHz (Japan wide band) */
        default:
                band_bottom = 76   * FREQ_MUL; break;
        /* 2: 76   -  90 MHz (Japan) */
        case 2:
                band_bottom = 76   * FREQ_MUL; break;
        };

        /* read channel */
        retval = si470x_get_register(radio, READCHAN);
        chan = radio->registers[READCHAN] & READCHAN_READCHAN;

        /* Frequency (MHz) = Spacing (kHz) x Channel + Bottom of Band (MHz) */
        *freq = chan * spacing + band_bottom;

        return retval;
}


/*
 * si470x_set_freq - set the frequency
 */
int si470x_set_freq(struct si470x_device *radio, unsigned int freq)
{
        unsigned int spacing, band_bottom;
        unsigned short chan;

        /* Spacing (kHz) */
        switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_SPACE) >> 4) {
        /* 0: 200 kHz (USA, Australia) */
        case 0:
                spacing = 0.200 * FREQ_MUL; break;
        /* 1: 100 kHz (Europe, Japan) */
        case 1:
                spacing = 0.100 * FREQ_MUL; break;
        /* 2:  50 kHz */
        default:
                spacing = 0.050 * FREQ_MUL; break;
        };

        /* Bottom of Band (MHz) */
        switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_BAND) >> 6) {
        /* 0: 87.5 - 108 MHz (USA, Europe) */
        case 0:
                band_bottom = 87.5 * FREQ_MUL; break;
        /* 1: 76   - 108 MHz (Japan wide band) */
        default:
                band_bottom = 76   * FREQ_MUL; break;
        /* 2: 76   -  90 MHz (Japan) */
        case 2:
                band_bottom = 76   * FREQ_MUL; break;
        };

        /* Chan = [ Freq (Mhz) - Bottom of Band (MHz) ] / Spacing (kHz) */
        chan = (freq - band_bottom) / spacing;

        return si470x_set_chan(radio, chan);
}


/*
 * si470x_set_seek - set seek
 */
static int si470x_set_seek(struct si470x_device *radio,
                unsigned int wrap_around, unsigned int seek_upward)
{
        int retval = 0;
        unsigned long timeout;
        bool timed_out = 0;

        /* start seeking */
        radio->registers[POWERCFG] |= POWERCFG_SEEK;
        if (wrap_around == 1)
                radio->registers[POWERCFG] &= ~POWERCFG_SKMODE;
        else
                radio->registers[POWERCFG] |= POWERCFG_SKMODE;
        if (seek_upward == 1)
                radio->registers[POWERCFG] |= POWERCFG_SEEKUP;
        else
                radio->registers[POWERCFG] &= ~POWERCFG_SEEKUP;
        retval = si470x_set_register(radio, POWERCFG);
        if (retval < 0)
                goto done;

        /* wait till seek operation has completed */
        timeout = jiffies + msecs_to_jiffies(seek_timeout);
        do {
                retval = si470x_get_register(radio, STATUSRSSI);
                if (retval < 0)
                        goto stop;
                timed_out = time_after(jiffies, timeout);
        } while (((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0) &&
                (!timed_out));
        if ((radio->registers[STATUSRSSI] & STATUSRSSI_STC) == 0)
                dev_warn(&radio->videodev->dev, "seek does not complete\n");
        if (radio->registers[STATUSRSSI] & STATUSRSSI_SF)
                dev_warn(&radio->videodev->dev,
                        "seek failed / band limit reached\n");
        if (timed_out)
                dev_warn(&radio->videodev->dev,
                        "seek timed out after %u ms\n", seek_timeout);

stop:
        /* stop seeking */
        radio->registers[POWERCFG] &= ~POWERCFG_SEEK;
        retval = si470x_set_register(radio, POWERCFG);

done:
        /* try again, if timed out */
        if ((retval == 0) && timed_out)
                retval = -EAGAIN;

        return retval;
}


/*
 * si470x_start - switch on radio
 */
int si470x_start(struct si470x_device *radio)
{
        int retval;

        /* powercfg */
        radio->registers[POWERCFG] =
                POWERCFG_DMUTE | POWERCFG_ENABLE | POWERCFG_RDSM;
        retval = si470x_set_register(radio, POWERCFG);
        if (retval < 0)
                goto done;

        /* sysconfig 1 */
        radio->registers[SYSCONFIG1] = SYSCONFIG1_DE;
        retval = si470x_set_register(radio, SYSCONFIG1);
        if (retval < 0)
                goto done;

        /* sysconfig 2 */
        radio->registers[SYSCONFIG2] =
                (0x3f  << 8) |                          /* SEEKTH */
                ((band  << 6) & SYSCONFIG2_BAND)  |     /* BAND */
                ((space << 4) & SYSCONFIG2_SPACE) |     /* SPACE */
                15;                                     /* VOLUME (max) */
        retval = si470x_set_register(radio, SYSCONFIG2);
        if (retval < 0)
                goto done;

        /* reset last channel */
        retval = si470x_set_chan(radio,
                radio->registers[CHANNEL] & CHANNEL_CHAN);

done:
        return retval;
}


/*
 * si470x_stop - switch off radio
 */
int si470x_stop(struct si470x_device *radio)
{
        int retval;

        /* sysconfig 1 */
        radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS;
        retval = si470x_set_register(radio, SYSCONFIG1);
        if (retval < 0)
                goto done;

        /* powercfg */
        radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
        /* POWERCFG_ENABLE has to automatically go low */
        radio->registers[POWERCFG] |= POWERCFG_ENABLE | POWERCFG_DISABLE;
        retval = si470x_set_register(radio, POWERCFG);

done:
        return retval;
}


/*
 * si470x_rds_on - switch on rds reception
 */
int si470x_rds_on(struct si470x_device *radio)
{
        int retval;

        /* sysconfig 1 */
        mutex_lock(&radio->lock);
        radio->registers[SYSCONFIG1] |= SYSCONFIG1_RDS;
        retval = si470x_set_register(radio, SYSCONFIG1);
        if (retval < 0)
                radio->registers[SYSCONFIG1] &= ~SYSCONFIG1_RDS;
        mutex_unlock(&radio->lock);

        return retval;
}



/**************************************************************************
 * Video4Linux Interface
 **************************************************************************/

/*
 * si470x_vidioc_queryctrl - enumerate control items
 */
static int si470x_vidioc_queryctrl(struct file *file, void *priv,
                struct v4l2_queryctrl *qc)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = -EINVAL;

        /* abort if qc->id is below V4L2_CID_BASE */
        if (qc->id < V4L2_CID_BASE)
                goto done;

        /* search video control */
        switch (qc->id) {
        case V4L2_CID_AUDIO_VOLUME:
                return v4l2_ctrl_query_fill(qc, 0, 15, 1, 15);
        case V4L2_CID_AUDIO_MUTE:
                return v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
        }

        /* disable unsupported base controls */
        /* to satisfy kradio and such apps */
        if ((retval == -EINVAL) && (qc->id < V4L2_CID_LASTP1)) {
                qc->flags = V4L2_CTRL_FLAG_DISABLED;
                retval = 0;
        }

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "query controls failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_g_ctrl - get the value of a control
 */
static int si470x_vidioc_g_ctrl(struct file *file, void *priv,
                struct v4l2_control *ctrl)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = 0;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        switch (ctrl->id) {
        case V4L2_CID_AUDIO_VOLUME:
                ctrl->value = radio->registers[SYSCONFIG2] &
                                SYSCONFIG2_VOLUME;
                break;
        case V4L2_CID_AUDIO_MUTE:
                ctrl->value = ((radio->registers[POWERCFG] &
                                POWERCFG_DMUTE) == 0) ? 1 : 0;
                break;
        default:
                retval = -EINVAL;
        }

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "get control failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_s_ctrl - set the value of a control
 */
static int si470x_vidioc_s_ctrl(struct file *file, void *priv,
                struct v4l2_control *ctrl)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = 0;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        switch (ctrl->id) {
        case V4L2_CID_AUDIO_VOLUME:
                radio->registers[SYSCONFIG2] &= ~SYSCONFIG2_VOLUME;
                radio->registers[SYSCONFIG2] |= ctrl->value;
                retval = si470x_set_register(radio, SYSCONFIG2);
                break;
        case V4L2_CID_AUDIO_MUTE:
                if (ctrl->value == 1)
                        radio->registers[POWERCFG] &= ~POWERCFG_DMUTE;
                else
                        radio->registers[POWERCFG] |= POWERCFG_DMUTE;
                retval = si470x_set_register(radio, POWERCFG);
                break;
        default:
                retval = -EINVAL;
        }

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "set control failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_g_audio - get audio attributes
 */
static int si470x_vidioc_g_audio(struct file *file, void *priv,
                struct v4l2_audio *audio)
{
        /* driver constants */
        audio->index = 0;
        strcpy(audio->name, "Radio");
        audio->capability = V4L2_AUDCAP_STEREO;
        audio->mode = 0;

        return 0;
}


/*
 * si470x_vidioc_g_tuner - get tuner attributes
 */
static int si470x_vidioc_g_tuner(struct file *file, void *priv,
                struct v4l2_tuner *tuner)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = 0;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        if (tuner->index != 0) {
                retval = -EINVAL;
                goto done;
        }

        retval = si470x_get_register(radio, STATUSRSSI);
        if (retval < 0)
                goto done;

        /* driver constants */
        strcpy(tuner->name, "FM");
        tuner->type = V4L2_TUNER_RADIO;
#if defined(CONFIG_USB_SI470X) || defined(CONFIG_USB_SI470X_MODULE)
        tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO |
                            V4L2_TUNER_CAP_RDS;
#else
        tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
#endif

        /* range limits */
        switch ((radio->registers[SYSCONFIG2] & SYSCONFIG2_BAND) >> 6) {
        /* 0: 87.5 - 108 MHz (USA, Europe, default) */
        default:
                tuner->rangelow  =  87.5 * FREQ_MUL;
                tuner->rangehigh = 108   * FREQ_MUL;
                break;
        /* 1: 76   - 108 MHz (Japan wide band) */
        case 1:
                tuner->rangelow  =  76   * FREQ_MUL;
                tuner->rangehigh = 108   * FREQ_MUL;
                break;
        /* 2: 76   -  90 MHz (Japan) */
        case 2:
                tuner->rangelow  =  76   * FREQ_MUL;
                tuner->rangehigh =  90   * FREQ_MUL;
                break;
        };

        /* stereo indicator == stereo (instead of mono) */
        if ((radio->registers[STATUSRSSI] & STATUSRSSI_ST) == 0)
                tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
        else
                tuner->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
#if defined(CONFIG_USB_SI470X) || defined(CONFIG_USB_SI470X_MODULE)
        /* If there is a reliable method of detecting an RDS channel,
           then this code should check for that before setting this
           RDS subchannel. */
        tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
#endif

        /* mono/stereo selector */
        if ((radio->registers[POWERCFG] & POWERCFG_MONO) == 0)
                tuner->audmode = V4L2_TUNER_MODE_STEREO;
        else
                tuner->audmode = V4L2_TUNER_MODE_MONO;

        /* min is worst, max is best; signal:0..0xffff; rssi: 0..0xff */
        /* measured in units of db쨉V in 1 db increments (max at ~75 db쨉V) */
        tuner->signal = (radio->registers[STATUSRSSI] & STATUSRSSI_RSSI);
        /* the ideal factor is 0xffff/75 = 873,8 */
        tuner->signal = (tuner->signal * 873) + (8 * tuner->signal / 10);

        /* automatic frequency control: -1: freq to low, 1 freq to high */
        /* AFCRL does only indicate that freq. differs, not if too low/high */
        tuner->afc = (radio->registers[STATUSRSSI] & STATUSRSSI_AFCRL) ? 1 : 0;

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "get tuner failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_s_tuner - set tuner attributes
 */
static int si470x_vidioc_s_tuner(struct file *file, void *priv,
                struct v4l2_tuner *tuner)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = -EINVAL;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        if (tuner->index != 0)
                goto done;

        /* mono/stereo selector */
        switch (tuner->audmode) {
        case V4L2_TUNER_MODE_MONO:
                radio->registers[POWERCFG] |= POWERCFG_MONO;  /* force mono */
                break;
        case V4L2_TUNER_MODE_STEREO:
                radio->registers[POWERCFG] &= ~POWERCFG_MONO; /* try stereo */
                break;
        default:
                goto done;
        }

        retval = si470x_set_register(radio, POWERCFG);

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "set tuner failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_g_frequency - get tuner or modulator radio frequency
 */
static int si470x_vidioc_g_frequency(struct file *file, void *priv,
                struct v4l2_frequency *freq)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = 0;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        if (freq->tuner != 0) {
                retval = -EINVAL;
                goto done;
        }

        freq->type = V4L2_TUNER_RADIO;
        retval = si470x_get_freq(radio, &freq->frequency);

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "get frequency failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_s_frequency - set tuner or modulator radio frequency
 */
static int si470x_vidioc_s_frequency(struct file *file, void *priv,
                struct v4l2_frequency *freq)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = 0;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        if (freq->tuner != 0) {
                retval = -EINVAL;
                goto done;
        }

        retval = si470x_set_freq(radio, freq->frequency);

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "set frequency failed with %d\n", retval);
        return retval;
}


/*
 * si470x_vidioc_s_hw_freq_seek - set hardware frequency seek
 */
static int si470x_vidioc_s_hw_freq_seek(struct file *file, void *priv,
                struct v4l2_hw_freq_seek *seek)
{
        struct si470x_device *radio = video_drvdata(file);
        int retval = 0;

        /* safety checks */
        retval = si470x_disconnect_check(radio);
        if (retval)
                goto done;

        if (seek->tuner != 0) {
                retval = -EINVAL;
                goto done;
        }

        retval = si470x_set_seek(radio, seek->wrap_around, seek->seek_upward);

done:
        if (retval < 0)
                dev_warn(&radio->videodev->dev,
                        "set hardware frequency seek failed with %d\n", retval);
        return retval;
}


/*
 * si470x_ioctl_ops - video device ioctl operations
 */
static const struct v4l2_ioctl_ops si470x_ioctl_ops = {
        .vidioc_querycap        = si470x_vidioc_querycap,
        .vidioc_queryctrl       = si470x_vidioc_queryctrl,
        .vidioc_g_ctrl          = si470x_vidioc_g_ctrl,
        .vidioc_s_ctrl          = si470x_vidioc_s_ctrl,
        .vidioc_g_audio         = si470x_vidioc_g_audio,
        .vidioc_g_tuner         = si470x_vidioc_g_tuner,
        .vidioc_s_tuner         = si470x_vidioc_s_tuner,
        .vidioc_g_frequency     = si470x_vidioc_g_frequency,
        .vidioc_s_frequency     = si470x_vidioc_s_frequency,
        .vidioc_s_hw_freq_seek  = si470x_vidioc_s_hw_freq_seek,
};


/*
 * si470x_viddev_template - video device interface
 */
struct video_device si470x_viddev_template = {
        .fops                   = &si470x_fops,
        .name                   = DRIVER_NAME,
        .release                = video_device_release,
        .ioctl_ops              = &si470x_ioctl_ops,
};