FM V4L2 drivers for WL128x
v9 cover FM V4L2 drivers for WL128x
From: Manjunatha Halli <[email protected]>
Mauro and the list,
This is the v9 version of the TI WL128x FM V4L2 drivers patchset. This introduces wl128x folder under the drivers/media/radio which cater to FM core on Texas Instrument's WL128x (also compatible with WL127x) WiLink chipsets.
WL128x's FM can work in either Rx or Tx mode, and V4L2 interfaces are provided for both.
** patch description **
Texas Instrument's WL128x chipset packs BT, FM, GPS and WLAN in a single die with BT, FM and GPS being interfaced over a single UART. This driver works on top of the shared transport line discipline driver. This driver can also be made use for the WL127x version of the chip which packs BT, FM and WLAN only.
Comments on the last version of the patches have been taken care, such as,
- using the 'early return' constructs where applicable.
- Renaming all the variables based on scope and frequency of use.
- Use of 'temp' pointers wherever required insted of breaking the lines.
- printing the error messages at the lowest level,and just propagate the error code up without repeating the error message.
Thanks & Regards,
Manjunatha Halli
Manjunatha Halli (7):
drivers:media:radio: wl128x: fmdrv common header file drivers:media:radio: wl128x: FM Driver V4L2 sources drivers:media:radio: wl128x: FM Driver Common sources drivers:media:radio: wl128x: FM driver RX sources drivers:media:radio: wl128x: FM driver TX sources drivers:media:radio: wl128x: Kconfig & Makefile for wl128x driver drivers:media:radio: Update Kconfig and Makefile for wl128x FM
driver.
drivers/media/radio/Kconfig | 3 + drivers/media/radio/Makefile | 1 + drivers/media/radio/wl128x/Kconfig | 17 + drivers/media/radio/wl128x/Makefile | 6 + drivers/media/radio/wl128x/fmdrv.h | 242 ++++ drivers/media/radio/wl128x/fmdrv_common.c | 1693 +++++++++++++++++++++++++++++ drivers/media/radio/wl128x/fmdrv_common.h | 402 +++++++ drivers/media/radio/wl128x/fmdrv_rx.c | 876 +++++++++++++++ drivers/media/radio/wl128x/fmdrv_rx.h | 59 + drivers/media/radio/wl128x/fmdrv_tx.c | 433 ++++++++ drivers/media/radio/wl128x/fmdrv_tx.h | 37 + drivers/media/radio/wl128x/fmdrv_v4l2.c | 594 ++++++++++ drivers/media/radio/wl128x/fmdrv_v4l2.h | 33 + 13 files changed, 4396 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/Kconfig create mode 100644 drivers/media/radio/wl128x/Makefile create mode 100644 drivers/media/radio/wl128x/fmdrv.h create mode 100644 drivers/media/radio/wl128x/fmdrv_common.c create mode 100644 drivers/media/radio/wl128x/fmdrv_common.h create mode 100644 drivers/media/radio/wl128x/fmdrv_rx.c create mode 100644 drivers/media/radio/wl128x/fmdrv_rx.h create mode 100644 drivers/media/radio/wl128x/fmdrv_tx.c create mode 100644 drivers/media/radio/wl128x/fmdrv_tx.h create mode 100644 drivers/media/radio/wl128x/fmdrv_v4l2.c create mode 100644 drivers/media/radio/wl128x/fmdrv_v4l2.h
RFC v9 1/7 drivers:media:radio: wl128x: fmdrv common header file
From: Manjunatha Halli <[email protected]>
These are common headers used in FM submodules (FM V4L2, FM common, FM Rx,and FM TX).
--- drivers/media/radio/wl128x/fmdrv.h | 242 ++++++++++++++++++++++++++++++++++++ 1 files changed, 242 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/fmdrv.h
drivers/media/radio/wl128x/fmdrv.h new file +242 -0
@@ -0,0 +1,242 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* +* Common header for all FM driver sub-modules. +* +* Copyright (C) 2011 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#ifndef _FM_DRV_H +#define _FM_DRV_H + +#include <linux/skbuff.h> +#include <linux/interrupt.h> +#include <sound/core.h> +#include <sound/initval.h> +#include <linux/timer.h> +#include <linux/version.h> +#include <media/v4l2-ioctl.h> +#include <media/v4l2-common.h> +#include <media/v4l2-ctrls.h> + +#define FM_DRV_VERSION "0.09" +/* Should match with FM_DRV_VERSION */ +#define FM_DRV_RADIO_VERSION KERNEL_VERSION(0, 0, 1) +#define FM_DRV_NAME "ti_fmdrv" +#define FM_DRV_CARD_SHORT_NAME "TI FM Radio" +#define FM_DRV_CARD_LONG_NAME "Texas Instruments FM Radio" + +/* Flag info */ +#define FM_INTTASK_RUNNING 0 +#define FM_INTTASK_SCHEDULE_PENDING 1 +#define FM_FW_DW_INPROGRESS 2 +#define FM_CORE_READY 3 +#define FM_CORE_TRANSPORT_READY 4 +#define FM_AF_SWITCH_INPROGRESS 5 +#define FM_CORE_TX_XMITING 6 + +#define FM_TUNE_COMPLETE 0x1 +#define FM_BAND_LIMIT 0x2 + +#define FM_DRV_TX_TIMEOUT (5*HZ)/* 5 seconds */ +#define FM_DRV_RX_SEEK_TIMEOUT (20*HZ)/* 20 seconds */ + +#define NO_OF_ENTRIES_IN_ARRAY (array) (sizeof(array) / sizeof(array[0])) + +#define fmerr (format, ...) \ + printk(KERN_ERR "fmdrv: " format,## __VA_ARGS__) +#ifdef DEBUG +#define fmdbg (format, ...) \ + printk(KERN_DEBUG "fmdrv: " format,## __VA_ARGS__) +#else /* DEBUG */ +#define fmdbg (format, ...) +#endif +enum { +FM_MODE_OFF , +FM_MODE_TX , +FM_MODE_RX , +FM_MODE_ENTRY_MAX +}; + +#define FM_RX_RDS_INFO_FIELD_MAX 8/* 4 Group * 2 Bytes */ + +/* RX RDS data format */ +struct fm_rdsdata_format { +union { +struct { +u8 buff[FM_RX_RDS_INFO_FIELD_MAX ]; + } groupdatabuff; +struct { +u16 pidata; +u8 blk_b[2 ]; +u8 blk_c[2 ]; +u8 blk_d[2 ]; + } groupgeneral; +struct { +u16 pidata; +u8 blk_b[2 ]; +u8 af[2 ]; +u8 ps[2 ]; + } group0A; +struct { +u16 pi[2 ]; +u8 blk_b[2 ]; +u8 ps[2 ]; + } group0B; + } data; +}; + +/* FM region (Europe/US, Japan) info */ +struct region_info { +u32 chanl_space; +u32 bot_freq; +u32 top_freq; +u8 fm_band; +}; +struct fmdev ; +typedef void (*int_handler_prototype ) (struct fmdev *); + +/* FM Interrupt processing related info */ +struct fm_irq { +u8 stage; +u16 flag;/* FM interrupt flag */ +u16 mask;/* FM interrupt mask */ +/* Interrupt process timeout handler */ +struct timer_list timer; +u8 retry; +int_handler_prototype *handlers; +}; + +/* RDS info */ +struct fm_rds { +u8 flag;/* RX RDS on/off status */ +u8 last_blk_idx;/* Last received RDS block */ + +/* RDS buffer */ +wait_queue_head_t read_queue; +u32 buf_size;/* Size is always multiple of 3 */ +u32 wr_idx; +u32 rd_idx; +u8 *buff; +}; + +#define FM_RDS_MAX_AF_LIST 25 + +/* +* Current RX channel Alternate Frequency cache. +* This info is used to switch to other freq (AF) +* when current channel signal strengh is below RSSI threshold. +*/ +struct tuned_station_info { +u16 picode; +u32 af_cache[FM_RDS_MAX_AF_LIST ]; +u8 afcache_size; +u8 af_list_max; +}; + +/* FM RX mode info */ +struct fm_rx { +struct region_info region;/* Current selected band */ +u32 freq;/* Current RX frquency */ +u8 mute_mode;/* Current mute mode */ +u8 deemphasis_mode;/* Current deemphasis mode */ +/* RF dependent soft mute mode */ +u8 rf_depend_mute; +u16 volume;/* Current volume level */ +u16 rssi_threshold;/* Current RSSI threshold level */ +/* Holds the index of the current AF jump */ +u8 afjump_idx; +/* Will hold the frequency before the jump */ +u32 freq_before_jump; +u8 rds_mode;/* RDS operation mode (RDS/RDBS) */ +u8 af_mode;/* Alternate frequency on/off */ +struct tuned_station_info stat_info; +struct fm_rds rds; +}; + +#define FMTX_RDS_TXT_STR_SIZE 25 +/* +* FM TX RDS data +* +* @ text_type: is the text following PS or RT +* @ text: radio text string which could either be PS or RT +* @ af_freq: alternate frequency for Tx +* TODO: to be declared in application +*/ +struct tx_rds { +u8 text_type; +u8 text[FMTX_RDS_TXT_STR_SIZE ]; +u8 flag; +u32 af_freq; +}; +/* +* FM TX global data +* +* @ pwr_lvl: Power Level of the Transmission from mixer control +* @ xmit_state: Transmission state = Updated locally upon Start/Stop +* @ audio_io: i2S/Analog +* @ tx_frq: Transmission frequency +*/ +struct fmtx_data { +u8 pwr_lvl; +u8 xmit_state; +u8 audio_io; +u8 region; +u16 aud_mode; +u32 preemph; +u32 tx_frq; +struct tx_rds rds; +}; + +/* FM driver operation structure */ +struct fmdev { +struct video_device *radio_dev;/* V4L2 video device pointer */ +struct snd_card *card;/* Card which holds FM mixer controls */ +u16 asci_id; +spinlock_t rds_buff_lock;/* To protect access to RDS buffer */ +spinlock_t resp_skb_lock;/* To protect access to received SKB */ + +long flag;/* FM driver state machine info */ +u8 streg_cbdata;/* status of ST registration */ + +struct sk_buff_head rx_q;/* RX queue */ +struct tasklet_struct rx_task;/* RX Tasklet */ + +struct sk_buff_head tx_q;/* TX queue */ +struct tasklet_struct tx_task;/* TX Tasklet */ +unsigned long last_tx_jiffies;/* Timestamp of last pkt sent */ +atomic_t tx_cnt;/* Number of packets can send at a time */ + +struct sk_buff *resp_skb;/* Response from the chip */ +/* Main task completion handler */ +struct completion maintask_comp; +/* Opcode of last command sent to the chip */ +u8 pre_op; +/* Handler used for wakeup when response packet is received */ +struct completion *resp_comp; +struct fm_irq irq_info; +u8 curr_fmmode;/* Current FM chip mode (TX, RX, OFF) */ +struct fm_rx rx;/* FM receiver info */ +struct fmtx_data tx_data; + +/* V4L2 ctrl framwork handler*/ +struct v4l2_ctrl_handler ctrl_handler; + +/* For core assisted locking */ +struct mutex mutex; +}; +#endif
Signature · 1 line
1.5.6.3
RFC v9 2/7 drivers:media:radio: wl128x: FM Driver V4L2 sources
From: Manjunatha Halli <[email protected]>
This module interfaces V4L2 subsystem and FM common module. It registers itself with V4L2 as Radio module.
--- drivers/media/radio/wl128x/fmdrv_v4l2.c | 594 +++++++++++++++++++++++++++++++ drivers/media/radio/wl128x/fmdrv_v4l2.h | 33 ++ 2 files changed, 627 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/fmdrv_v4l2.c create mode 100644 drivers/media/radio/wl128x/fmdrv_v4l2.h
drivers/media/radio/wl128x/fmdrv_v4l2.c new file +594 -0
@@ -0,0 +1,594 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* This file provides interfaces to V4L2 subsystem. +* +* This module registers with V4L2 subsystem as Radio +* data system interface (/dev/radio). During the registration, +* it will expose two set of function pointers. +* +* 1) File operation related API (open, close, read, write, poll...etc). +* 2) Set of V4L2 IOCTL complaint API. +* +* Copyright (C) 2011 Texas Instruments +* Author: Raja Mani <[email protected]> +* Author: Manjunatha Halli <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#include "fmdrv.h" +#include "fmdrv_v4l2.h" +#include "fmdrv_common.h" +#include "fmdrv_rx.h" +#include "fmdrv_tx.h" + +static struct video_device *gradio_dev; +static u8 radio_disconnected; + +/* -- V4L2 RADIO (/dev/radioX) device file operation interfaces --- */ + +/* Read RX RDS data */ +static ssize_t fm_v4l2_fops_read (struct file *file,char __user * buf, +size_t count,loff_t *ppos) +{ +u8 rds_mode; +int ret; +struct fmdev *fmdev; + + fmdev =video_drvdata (file); + +if (!radio_disconnected) { +fmerr ("FM device is already disconnected\n" ); +return -EIO ; + } + +/* Turn on RDS mode , if it is disabled */ + ret =fm_rx_get_rds_mode (fmdev, &rds_mode); +if (ret <0 ) { +fmerr ("Unable to read current rds mode\n" ); +return ret; + } + +if (rds_mode ==FM_RDS_DISABLE ) { + ret =fmc_set_rds_mode (fmdev,FM_RDS_ENABLE ); +if (ret <0 ) { +fmerr ("Failed to enable rds mode\n" ); +return ret; + } + } + +/* Copy RDS data from internal buffer to user buffer */ + ret =fmc_transfer_rds_from_internal_buff (fmdev, file, buf, count); + +return ret; +} + +/* Write TX RDS data */ +static ssize_t fm_v4l2_fops_write (struct file *file,const char __user * buf, +size_t count,loff_t *ppos) +{ +struct tx_rds rds; +int ret; +struct fmdev *fmdev; + + ret =copy_from_user (&rds, buf,sizeof (rds)); +fmdbg ("(%d)type: %d, text %s, af %d\n" , + ret, rds.text_type, rds.text, rds.af_freq); + + fmdev =video_drvdata (file); +fm_tx_set_radio_text (fmdev, rds.text, rds.text_type); +fm_tx_set_af (fmdev, rds.af_freq); + +return 0 ; +} + +static u32 fm_v4l2_fops_poll (struct file *file,struct poll_table_struct *pts) +{ +int ret; +struct fmdev *fmdev; + + fmdev =video_drvdata (file); + ret =fmc_is_rds_data_available (fmdev, file, pts); +if (ret <0 ) +return POLLIN |POLLRDNORM ; + +return 0 ; +} + +/* +* Handle open request for "/dev/radioX" device. +* Start with FM RX mode as default. +*/ +static int fm_v4l2_fops_open (struct file *file) +{ +int ret; +struct fmdev *fmdev =NULL ; + +/* Don't allow multiple open */ +if (radio_disconnected) { +fmerr ("FM device is already opened\n" ); +return -EBUSY ; + } + + fmdev =video_drvdata (file); + + ret =fmc_prepare (fmdev); +if (ret <0 ) { +fmerr ("Unable to prepare FM CORE\n" ); +return ret; + } + +fmdbg ("Load FM RX firmware..\n" ); + + ret =fmc_set_mode (fmdev,FM_MODE_RX ); +if (ret <0 ) { +fmerr ("Unable to load FM RX firmware\n" ); +return ret; + } + radio_disconnected =1 ; + +return ret; +} + +static int fm_v4l2_fops_release (struct file *file) +{ +int ret =0 ; +struct fmdev *fmdev; + + fmdev =video_drvdata (file); +if (!radio_disconnected) { +fmdbg ("FM device is already closed\n" ); +return ret; + } + + ret =fmc_set_mode (fmdev,FM_MODE_OFF ); +if (ret <0 ) { +fmerr ("Unable to turn off the chip\n" ); +return ret; + } + + ret =fmc_release (fmdev); +if (ret <0 ) { +fmerr ("FM CORE release failed\n" ); +return ret; + } + radio_disconnected =0 ; + +return ret; +} + +/* V4L2 RADIO (/dev/radioX) device IOCTL interfaces */ +static int fm_v4l2_vidioc_querycap (struct file *file,void *priv, +struct v4l2_capability *capability) +{ +strlcpy (capability->driver,FM_DRV_NAME ,sizeof (capability->driver)); +strlcpy (capability->card,FM_DRV_CARD_SHORT_NAME , +sizeof (capability->card)); +sprintf (capability->bus_info,"UART" ); + capability->version =FM_DRV_RADIO_VERSION ; + capability->capabilities =V4L2_CAP_HW_FREQ_SEEK |V4L2_CAP_TUNER | +V4L2_CAP_RADIO |V4L2_CAP_MODULATOR | +V4L2_CAP_AUDIO |V4L2_CAP_READWRITE | +V4L2_CAP_RDS_CAPTURE ; + +return 0 ; +} + +static int fm_g_volatile_ctrl (struct v4l2_ctrl *ctrl) +{ +struct fmdev *fmdev =container_of (ctrl->handler, + struct fmdev, ctrl_handler); + +switch (ctrl->id) { +case V4L2_CID_TUNE_ANTENNA_CAPACITOR : + ctrl->val =fm_tx_get_tune_cap_val (fmdev); +break ; +default : +pr_warn ("(fmdev): %s: Unknown IOCTL: %d\n" , + __func__, ctrl->id); +break ; + } + +return 0 ; +} + +static int fm_v4l2_s_ctrl (struct v4l2_ctrl *ctrl) +{ +struct fmdev *fmdev =container_of (ctrl->handler, + struct fmdev, ctrl_handler); + +switch (ctrl->id) { +case V4L2_CID_AUDIO_VOLUME :/* set volume */ +return fm_rx_set_volume (fmdev, + (u16 )ctrl->val); +break ; +case V4L2_CID_AUDIO_MUTE :/* set mute */ +return fmc_set_mute_mode (fmdev, + (u8 )ctrl->val); +break ; +case V4L2_CID_TUNE_POWER_LEVEL : +/* set TX power level - ext control */ +return fm_tx_set_pwr_lvl (fmdev, + (u8 )ctrl->val); +break ; +case V4L2_CID_TUNE_PREEMPHASIS : +return fm_tx_set_preemph_filter (fmdev, + (u8 ) ctrl->val); +break ; +default : +return -EINVAL ; + } +} + +static int fm_v4l2_vidioc_g_audio (struct file *file,void *priv, +struct v4l2_audio *audio) +{ +memset (audio,0 ,sizeof (*audio)); + audio->index =0 ; +strcpy (audio->name,"Radio" ); + audio->capability =V4L2_AUDCAP_STEREO ; + +return 0 ; +} + +static int fm_v4l2_vidioc_s_audio (struct file *file,void *priv, +struct v4l2_audio *audio) +{ +if (audio->index !=0 ) +return -EINVAL ; + +return 0 ; +} + +/* Get tuner attributes. If current mode is NOT RX, return error */ +static int fm_v4l2_vidioc_g_tuner (struct file *file,void *priv, +struct v4l2_tuner *tuner) +{ +struct fmdev *fmdev =video_drvdata (file); +u32 bottom_freq; +u32 top_freq; +u16 stereo_mono_mode; +u16 rssilvl; +int ret = -EINVAL ; + +if (tuner->index !=0 ) +return ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + + ret =fm_rx_get_currband_freq_range (fmdev, &bottom_freq, + &top_freq); +if (ret !=0 ) +return ret; + + ret =fm_rx_get_stereo_mono (fmdev, &stereo_mono_mode); +if (ret !=0 ) +return ret; + + ret =fm_rx_get_rssi_level (fmdev, &rssilvl); +if (ret !=0 ) +return ret; + +strcpy (tuner->name,"FM" ); + tuner->type =V4L2_TUNER_RADIO ; +/* Store rangelow and rangehigh freq in unit of 62.5 Hz */ + tuner->rangelow = bottom_freq *16 ; + tuner->rangehigh = top_freq *16 ; + tuner->rxsubchans =V4L2_TUNER_SUB_MONO |V4L2_TUNER_SUB_STEREO | + ((fmdev->rx.rds.flag ==FM_RDS_ENABLE ) ?V4L2_TUNER_SUB_RDS :0 ); + tuner->capability =V4L2_TUNER_CAP_STEREO |V4L2_TUNER_CAP_RDS | +V4L2_TUNER_CAP_LOW ; + tuner->audmode = (stereo_mono_mode ? +V4L2_TUNER_MODE_MONO :V4L2_TUNER_MODE_STEREO ); + +/* +* Actual rssi value lies in between -128 to +127. +* Convert this range from 0 to 255 by adding +128 +*/ + rssilvl +=128 ; + +/* +* Return signal strength value should be within 0 to 65535. +* Find out correct signal radio by multiplying (65535/255) = 257 +*/ + tuner->signal = rssilvl *257 ; + tuner->afc =0 ; + +return ret; +} + +/* +* Set tuner attributes. If current mode is NOT RX, set to RX. +* Currently, we set only audio mode (mono/stereo) and RDS state (on/off). +* Should we set other tuner attributes, too? +*/ +static int fm_v4l2_vidioc_s_tuner (struct file *file,void *priv, +struct v4l2_tuner *tuner) +{ +struct fmdev *fmdev =video_drvdata (file); +u16 aud_mode; +u8 rds_mode; +int ret = -EINVAL ; + +if (tuner->index !=0 ) +return ret; + + aud_mode = (tuner->audmode ==V4L2_TUNER_MODE_STEREO ) ? +FM_STEREO_MODE :FM_MONO_MODE ; + rds_mode = (tuner->rxsubchans &V4L2_TUNER_SUB_RDS ) ? +FM_RDS_ENABLE :FM_RDS_DISABLE ; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) { + ret =fmc_set_mode (fmdev,FM_MODE_RX ); +if (ret <0 ) { +fmerr ("Failed to set RX mode; unable to " +"write tuner attributes\n" ); +return ret; + } + } + + ret =fmc_set_stereo_mono (fmdev, aud_mode); +if (ret <0 ) { +fmerr ("Failed to set RX stereo/mono mode\n" ); +return ret; + } + + ret =fmc_set_rds_mode (fmdev, rds_mode); +if (ret <0 ) +fmerr ("Failed to set RX RDS mode\n" ); + +return ret; +} + +/* Get tuner or modulator radio frequency */ +static int fm_v4l2_vidioc_g_freq (struct file *file,void *priv, +struct v4l2_frequency *freq) +{ +int ret; +struct fmdev *fmdev =video_drvdata (file); + + ret =fmc_get_freq (fmdev, &freq->frequency); +if (ret <0 ) { +fmerr ("Failed to get frequency\n" ); +return ret; + } + +/* Frequency unit of 62.5 Hz*/ + freq->frequency = (u32 ) freq->frequency *16 ; + +return 0 ; +} + +/* Set tuner or modulator radio frequency */ +static int fm_v4l2_vidioc_s_freq (struct file *file,void *priv, +struct v4l2_frequency *freq) +{ +struct fmdev *fmdev =video_drvdata (file); +int ret; + +/* +* As V4L2_TUNER_CAP_LOW is set 1 user sends the frequency +* in units of 62.5 Hz. +*/ + freq->frequency = (u32)(freq->frequency /16 ); + + ret =fmc_set_freq (fmdev, freq->frequency); + +return ret; +} + +/* Set hardware frequency seek. If current mode is NOT RX, set it RX. */ +static int fm_v4l2_vidioc_s_hw_freq_seek (struct file *file,void *priv, +struct v4l2_hw_freq_seek *seek) +{ +struct fmdev *fmdev =video_drvdata (file); +int ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) { + ret =fmc_set_mode (fmdev,FM_MODE_RX ); +if (ret !=0 ) { +fmerr ("Failed to set RX mode; unable to " +"start HW frequency seek\n" ); +return ret; + } + } + + ret =fm_rx_seek (fmdev, seek->seek_upward, seek->wrap_around, + seek->spacing); +if (ret <0 ) +fmerr ("RX seek failed - %d\n" , ret); + +return ret; +} +/* Get modulator attributes. If mode is not TX, return no attributes. */ +static int fm_v4l2_vidioc_g_modulator (struct file *file,void *priv, +struct v4l2_modulator *mod) +{ +struct fmdev *fmdev =video_drvdata (file);; + +if (mod->index !=0 ) +return -EINVAL ; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + + mod->txsubchans = ((fmdev->tx_data.aud_mode ==FM_STEREO_MODE ) ? +V4L2_TUNER_SUB_STEREO :V4L2_TUNER_SUB_MONO ) | + ((fmdev->tx_data.rds.flag ==FM_RDS_ENABLE ) ?V4L2_TUNER_SUB_RDS :0 ); + + mod->capability =V4L2_TUNER_CAP_STEREO | +V4L2_TUNER_CAP_RDS |V4L2_TUNER_CAP_LOW ; + +return 0 ; +} + +/* Set modulator attributes. If mode is not TX, set to TX. */ +static int fm_v4l2_vidioc_s_modulator (struct file *file,void *priv, +struct v4l2_modulator *mod) +{ +struct fmdev *fmdev =video_drvdata (file); +u8 rds_mode; +u16 aud_mode; +int ret; + +if (mod->index !=0 ) +return -EINVAL ; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) { + ret =fmc_set_mode (fmdev,FM_MODE_TX ); +if (ret !=0 ) { +fmerr ("Failed to set TX mode; unable to " +"set modulator attributes\n" ); +return ret; + } + } + + aud_mode = (mod->txsubchans &V4L2_TUNER_SUB_STEREO ) ? +FM_STEREO_MODE :FM_MONO_MODE ; + rds_mode = (mod->txsubchans &V4L2_TUNER_SUB_RDS ) ? +FM_RDS_ENABLE :FM_RDS_DISABLE ; + ret =fm_tx_set_stereo_mono (fmdev, aud_mode); +if (ret <0 ) { +fmerr ("Failed to set mono/stereo mode for TX\n" ); +return ret; + } + ret =fm_tx_set_rds_mode (fmdev, rds_mode); +if (ret <0 ) +fmerr ("Failed to set rds mode for TX\n" ); + +return ret; +} + +static const struct v4l2_file_operations fm_drv_fops = { + .owner =THIS_MODULE , + .read = fm_v4l2_fops_read, + .write = fm_v4l2_fops_write, + .poll = fm_v4l2_fops_poll, + .unlocked_ioctl = video_ioctl2, + .open = fm_v4l2_fops_open, + .release = fm_v4l2_fops_release, +}; + +static const struct v4l2_ctrl_ops fm_ctrl_ops = { + .s_ctrl = fm_v4l2_s_ctrl, + .g_volatile_ctrl = fm_g_volatile_ctrl, +}; +static const struct v4l2_ioctl_ops fm_drv_ioctl_ops = { + .vidioc_querycap = fm_v4l2_vidioc_querycap, + .vidioc_g_audio = fm_v4l2_vidioc_g_audio, + .vidioc_s_audio = fm_v4l2_vidioc_s_audio, + .vidioc_g_tuner = fm_v4l2_vidioc_g_tuner, + .vidioc_s_tuner = fm_v4l2_vidioc_s_tuner, + .vidioc_g_frequency = fm_v4l2_vidioc_g_freq, + .vidioc_s_frequency = fm_v4l2_vidioc_s_freq, + .vidioc_s_hw_freq_seek = fm_v4l2_vidioc_s_hw_freq_seek, + .vidioc_g_modulator = fm_v4l2_vidioc_g_modulator, + .vidioc_s_modulator = fm_v4l2_vidioc_s_modulator +}; + +/* V4L2 RADIO device parent structure */ +static struct video_device fm_viddev_template = { + .fops = &fm_drv_fops, + .ioctl_ops = &fm_drv_ioctl_ops, + .name =FM_DRV_NAME , + .release = video_device_release, +}; + +int fm_v4l2_init_video_device (struct fmdev *fmdev,int radio_nr) +{ +struct v4l2_ctrl *ctrl; +int ret; + +/* Init mutex for core locking */ +mutex_init (&fmdev->mutex); + +/* Allocate new video device */ + gradio_dev =video_device_alloc (); +if (NULL == gradio_dev) { +fmerr ("Can't allocate video device\n" ); +return -ENOMEM ; + } + +/* Setup FM driver's V4L2 properties */ +memcpy (gradio_dev, &fm_viddev_template,sizeof (fm_viddev_template)); + +video_set_drvdata (gradio_dev, fmdev); + + gradio_dev->lock = &fmdev->mutex; + +/* Register with V4L2 subsystem as RADIO device */ +if (video_register_device (gradio_dev,VFL_TYPE_RADIO , radio_nr)) { +video_device_release (gradio_dev); +fmerr ("Could not register video device\n" ); +return -ENOMEM ; + } + + fmdev->radio_dev = gradio_dev; + +/* Register to v4l2 ctrl handler framework */ + fmdev->radio_dev->ctrl_handler = &fmdev->ctrl_handler; + + ret =v4l2_ctrl_handler_init (&fmdev->ctrl_handler,5 ); +if (ret <0 ) { +fmerr ("(fmdev): Can't init ctrl handler\n" ); +v4l2_ctrl_handler_free (&fmdev->ctrl_handler); +return -EBUSY ; + } + +/* +* Following controls are handled by V4L2 control framework. +* Added in ascending ID order. +*/ +v4l2_ctrl_new_std (&fmdev->ctrl_handler, &fm_ctrl_ops, +V4L2_CID_AUDIO_VOLUME ,FM_RX_VOLUME_MIN , +FM_RX_VOLUME_MAX ,1 ,FM_RX_VOLUME_MAX ); + +v4l2_ctrl_new_std (&fmdev->ctrl_handler, &fm_ctrl_ops, +V4L2_CID_AUDIO_MUTE ,0 ,1 ,1 ,1 ); + +v4l2_ctrl_new_std_menu (&fmdev->ctrl_handler, &fm_ctrl_ops, +V4L2_CID_TUNE_PREEMPHASIS , V4L2_PREEMPHASIS_75_uS, +0 , V4L2_PREEMPHASIS_75_uS); + +v4l2_ctrl_new_std (&fmdev->ctrl_handler, &fm_ctrl_ops, +V4L2_CID_TUNE_POWER_LEVEL ,FM_PWR_LVL_LOW , +FM_PWR_LVL_HIGH ,1 ,FM_PWR_LVL_HIGH ); + + ctrl =v4l2_ctrl_new_std (&fmdev->ctrl_handler, &fm_ctrl_ops, +V4L2_CID_TUNE_ANTENNA_CAPACITOR ,0 , +255 ,1 ,255 ); + +if (ctrl) + ctrl->is_volatile =1 ; + +return 0 ; +} + +void *fm_v4l2_deinit_video_device (void ) +{ +struct fmdev *fmdev; + + + fmdev =video_get_drvdata (gradio_dev); + +/* Unregister to v4l2 ctrl handler framework*/ +v4l2_ctrl_handler_free (&fmdev->ctrl_handler); + +/* Unregister RADIO device from V4L2 subsystem */ +video_unregister_device (gradio_dev); + +return fmdev; +}
drivers/media/radio/wl128x/fmdrv_v4l2.h new file +33 -0
@@ -0,0 +1,33 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* +* FM V4L2 module header. +* +* Copyright (C) 2011 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#ifndef _FMDRV_V4L2_H +#define _FMDRV_V4L2_H + +#include <media/v4l2-ioctl.h> +#include <media/v4l2-common.h> +#include <media/v4l2-ctrls.h> + +int fm_v4l2_init_video_device (struct fmdev *,int ); +void *fm_v4l2_deinit_video_device (void ); + +#endif
Signature · 1 line
1.5.6.3
RFC v9 3/7 drivers:media:radio: wl128x: FM Driver Common sources
From: Manjunatha Halli <[email protected]>
These are the sources for the common interfaces required by the FM V4L2 driver for TI WL127x and WL128x chips.
These implement the FM channel-8 protocol communication with the chip. This makes use of the Shared Transport as its transport.
--- drivers/media/radio/wl128x/fmdrv_common.c | 1693 +++++++++++++++++++++++++++++ drivers/media/radio/wl128x/fmdrv_common.h | 402 +++++++ 2 files changed, 2095 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/fmdrv_common.c create mode 100644 drivers/media/radio/wl128x/fmdrv_common.h
drivers/media/radio/wl128x/fmdrv_common.c new file +1693 -0
@@ -0,0 +1,1693 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* +* This sub-module of FM driver is common for FM RX and TX +* functionality. This module is responsible for: +* 1) Forming group of Channel-8 commands to perform particular +* functionality (eg., frequency set require more than +* one Channel-8 command to be sent to the chip). +* 2) Sending each Channel-8 command to the chip and reading +* response back over Shared Transport. +* 3) Managing TX and RX Queues and Tasklets. +* 4) Handling FM Interrupt packet and taking appropriate action. +* 5) Loading FM firmware to the chip (common, FM TX, and FM RX +* firmware files based on mode selection) +* +* Copyright (C) 2011 Texas Instruments +* Author: Raja Mani <[email protected]> +* Author: Manjunatha Halli <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#include <linux/module.h> +#include <linux/firmware.h> +#include <linux/delay.h> +#include "fmdrv.h" +#include "fmdrv_v4l2.h" +#include "fmdrv_common.h" +#include <linux/ti_wilink_st.h> +#include "fmdrv_rx.h" +#include "fmdrv_tx.h" + +/* Region info */ +static struct region_info region_configs[] = { +/* Europe/US */ + { + .chanl_space =FM_CHANNEL_SPACING_200KHZ *FM_FREQ_MUL , + .bot_freq =87500 ,/* 87.5 MHz */ + .top_freq =108000 ,/* 108 MHz */ + .fm_band =0 , + }, +/* Japan */ + { + .chanl_space =FM_CHANNEL_SPACING_200KHZ *FM_FREQ_MUL , + .bot_freq =76000 ,/* 76 MHz */ + .top_freq =90000 ,/* 90 MHz */ + .fm_band =1 , + }, +}; + +/* Band selection */ +static u8 default_radio_region;/* Europe/US */ +module_param (default_radio_region, byte,0 ); +MODULE_PARM_DESC (default_radio_region,"Region: 0=Europe/US, 1=Japan" ); + +/* RDS buffer blocks */ +static u32 default_rds_buf =300 ; +module_param (default_rds_buf, uint,0444 ); +MODULE_PARM_DESC (rds_buf,"RDS buffer entries" ); + +/* Radio Nr */ +static u32 radio_nr =-1 ; +module_param (radio_nr, int,0444 ); +MODULE_PARM_DESC (radio_nr,"Radio Nr" ); + +/* FM irq handlers forward declaration */ +static void fm_irq_send_flag_getcmd (struct fmdev *); +static void fm_irq_handle_flag_getcmd_resp (struct fmdev *); +static void fm_irq_handle_hw_malfunction (struct fmdev *); +static void fm_irq_handle_rds_start (struct fmdev *); +static void fm_irq_send_rdsdata_getcmd (struct fmdev *); +static void fm_irq_handle_rdsdata_getcmd_resp (struct fmdev *); +static void fm_irq_handle_rds_finish (struct fmdev *); +static void fm_irq_handle_tune_op_ended (struct fmdev *); +static void fm_irq_handle_power_enb (struct fmdev *); +static void fm_irq_handle_low_rssi_start (struct fmdev *); +static void fm_irq_afjump_set_pi (struct fmdev *); +static void fm_irq_handle_set_pi_resp (struct fmdev *); +static void fm_irq_afjump_set_pimask (struct fmdev *); +static void fm_irq_handle_set_pimask_resp (struct fmdev *); +static void fm_irq_afjump_setfreq (struct fmdev *); +static void fm_irq_handle_setfreq_resp (struct fmdev *); +static void fm_irq_afjump_enableint (struct fmdev *); +static void fm_irq_afjump_enableint_resp (struct fmdev *); +static void fm_irq_start_afjump (struct fmdev *); +static void fm_irq_handle_start_afjump_resp (struct fmdev *); +static void fm_irq_afjump_rd_freq (struct fmdev *); +static void fm_irq_afjump_rd_freq_resp (struct fmdev *); +static void fm_irq_handle_low_rssi_finish (struct fmdev *); +static void fm_irq_send_intmsk_cmd (struct fmdev *); +static void fm_irq_handle_intmsk_cmd_resp (struct fmdev *); + +/* +* When FM common module receives interrupt packet, following handlers +* will be executed one after another to service the interrupt(s) +*/ +enum fmc_irq_handler_index { +FM_SEND_FLAG_GETCMD_IDX , +FM_HANDLE_FLAG_GETCMD_RESP_IDX , + +/* HW malfunction irq handler */ +FM_HW_MAL_FUNC_IDX , + +/* RDS threshold reached irq handler */ +FM_RDS_START_IDX , +FM_RDS_SEND_RDS_GETCMD_IDX , +FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX , +FM_RDS_FINISH_IDX , + +/* Tune operation ended irq handler */ +FM_HW_TUNE_OP_ENDED_IDX , + +/* TX power enable irq handler */ +FM_HW_POWER_ENB_IDX , + +/* Low RSSI irq handler */ +FM_LOW_RSSI_START_IDX , +FM_AF_JUMP_SETPI_IDX , +FM_AF_JUMP_HANDLE_SETPI_RESP_IDX , +FM_AF_JUMP_SETPI_MASK_IDX , +FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX , +FM_AF_JUMP_SET_AF_FREQ_IDX , +FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX , +FM_AF_JUMP_ENABLE_INT_IDX , +FM_AF_JUMP_ENABLE_INT_RESP_IDX , +FM_AF_JUMP_START_AFJUMP_IDX , +FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX , +FM_AF_JUMP_RD_FREQ_IDX , +FM_AF_JUMP_RD_FREQ_RESP_IDX , +FM_LOW_RSSI_FINISH_IDX , + +/* Interrupt process post action */ +FM_SEND_INTMSK_CMD_IDX , +FM_HANDLE_INTMSK_CMD_RESP_IDX , +}; + +/* FM interrupt handler table */ +static int_handler_prototype int_handler_table[] = { + fm_irq_send_flag_getcmd, + fm_irq_handle_flag_getcmd_resp, + fm_irq_handle_hw_malfunction, + fm_irq_handle_rds_start,/* RDS threshold reached irq handler */ + fm_irq_send_rdsdata_getcmd, + fm_irq_handle_rdsdata_getcmd_resp, + fm_irq_handle_rds_finish, + fm_irq_handle_tune_op_ended, + fm_irq_handle_power_enb,/* TX power enable irq handler */ + fm_irq_handle_low_rssi_start, + fm_irq_afjump_set_pi, + fm_irq_handle_set_pi_resp, + fm_irq_afjump_set_pimask, + fm_irq_handle_set_pimask_resp, + fm_irq_afjump_setfreq, + fm_irq_handle_setfreq_resp, + fm_irq_afjump_enableint, + fm_irq_afjump_enableint_resp, + fm_irq_start_afjump, + fm_irq_handle_start_afjump_resp, + fm_irq_afjump_rd_freq, + fm_irq_afjump_rd_freq_resp, + fm_irq_handle_low_rssi_finish, + fm_irq_send_intmsk_cmd,/* Interrupt process post action */ + fm_irq_handle_intmsk_cmd_resp +}; + +long (*g_st_write) (struct sk_buff *skb); +static struct completion wait_for_fmdrv_reg_comp; + +static inline void fm_irq_call (struct fmdev *fmdev) +{ + fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev); +} + +/* Continue next function in interrupt handler table */ +static inline void fm_irq_call_stage (struct fmdev *fmdev,u8 stage) +{ + fmdev->irq_info.stage = stage; +fm_irq_call (fmdev); +} + +static inline void fm_irq_timeout_stage (struct fmdev *fmdev,u8 stage) +{ + fmdev->irq_info.stage = stage; +mod_timer (&fmdev->irq_info.timer, jiffies +FM_DRV_TX_TIMEOUT ); +} + +#ifdef FM_DUMP_TXRX_PKT +/* To dump outgoing FM Channel-8 packets */ +inline void dump_tx_skb_data (struct sk_buff *skb) +{ +int len, len_org; +u8 index; +struct fm_cmd_msg_hdr *cmd_hdr; + + cmd_hdr = (struct fm_cmd_msg_hdr *)skb->data; +printk (KERN_INFO "<<%shdr:%02x len:%02x opcode:%02x type:%s dlen:%02x" , +fm_cb (skb)->completion ?" " :"*" , cmd_hdr->hdr, + cmd_hdr->len, cmd_hdr->op, + cmd_hdr->rd_wr ?"RD" :"WR" , cmd_hdr->dlen); + + len_org = skb->len -FM_CMD_MSG_HDR_SIZE ; +if (len_org >0 ) { +printk ("\n data(%d): " , cmd_hdr->dlen); + len =min (len_org,14 ); +for (index =0 ; index < len; index++) +printk ("%x " , + skb->data[FM_CMD_MSG_HDR_SIZE + index]); +printk ("%s" , (len_org >14 ) ?".." :"" ); + } +printk ("\n" ); +} + +/* To dump incoming FM Channel-8 packets */ +inline void dump_rx_skb_data (struct sk_buff *skb) +{ +int len, len_org; +u8 index; +struct fm_event_msg_hdr *evt_hdr; + + evt_hdr = (struct fm_event_msg_hdr *)skb->data; +printk (KERN_INFO ">> hdr:%02x len:%02x sts:%02x numhci:%02x " +"opcode:%02x type:%s dlen:%02x" , evt_hdr->hdr, evt_hdr->len, + evt_hdr->status, evt_hdr->num_fm_hci_cmds, evt_hdr->op, + (evt_hdr->rd_wr) ?"RD" :"WR" , evt_hdr->dlen); + + len_org = skb->len -FM_EVT_MSG_HDR_SIZE ; +if (len_org >0 ) { +printk ("\n data(%d): " , evt_hdr->dlen); + len =min (len_org,14 ); +for (index =0 ; index < len; index++) +printk ("%x " , + skb->data[FM_EVT_MSG_HDR_SIZE + index]); +printk ("%s" , (len_org >14 ) ?".." :"" ); + } +printk ("\n" ); +} +#endif + +void fmc_update_region_info (struct fmdev *fmdev,u8 region_to_set) +{ + fmdev->rx.region = region_configs[region_to_set]; +} + +/* +* FM common sub-module will schedule this tasklet whenever it receives +* FM packet from ST driver. +*/ +static void recv_tasklet (unsigned long arg) +{ +struct fmdev *fmdev; +struct fm_irq *irq_info; +struct fm_event_msg_hdr *evt_hdr; +struct sk_buff *skb; +u8 num_fm_hci_cmds; +unsigned long flags; + + fmdev = (struct fmdev *)arg; + irq_info = &fmdev->irq_info; +/* Process all packets in the RX queue */ +while ((skb =skb_dequeue (&fmdev->rx_q))) { +if (skb->len <sizeof (struct fm_event_msg_hdr )) { +fmerr ("skb(%p) has only %d bytes" +"atleast need %d bytes to decode\n" ,skb, + skb->len,sizeof (struct fm_event_msg_hdr )); +kfree_skb (skb); +continue ; + } + + evt_hdr = (void *)skb->data; + num_fm_hci_cmds = evt_hdr->num_fm_hci_cmds; + +/* FM interrupt packet? */ +if (evt_hdr->op ==FM_INTERRUPT ) { +/* FM interrupt handler started already? */ +if (!test_bit (FM_INTTASK_RUNNING , &fmdev->flag)) { +set_bit (FM_INTTASK_RUNNING , &fmdev->flag); +if (irq_info->stage !=0 ) { +fmerr ("Inval stage resetting to zero\n" ); + irq_info->stage =0 ; + } + +/* +* Execute first function in interrupt handler +* table. +*/ + irq_info->handlers[irq_info->stage](fmdev); + }else { +set_bit (FM_INTTASK_SCHEDULE_PENDING ,&fmdev->flag); + } +kfree_skb (skb); + } +/* Anyone waiting for this with completion handler? */ +else if (evt_hdr->op == fmdev->pre_op && fmdev->resp_comp !=NULL ) { + +spin_lock_irqsave (&fmdev->resp_skb_lock, flags); + fmdev->resp_skb = skb; +spin_unlock_irqrestore (&fmdev->resp_skb_lock, flags); +complete (fmdev->resp_comp); + + fmdev->resp_comp =NULL ; +atomic_set (&fmdev->tx_cnt,1 ); + } +/* Is this for interrupt handler? */ +else if (evt_hdr->op == fmdev->pre_op && fmdev->resp_comp ==NULL ) { +if (fmdev->resp_skb !=NULL ) +fmerr ("Response SKB ptr not NULL\n" ); + +spin_lock_irqsave (&fmdev->resp_skb_lock, flags); + fmdev->resp_skb = skb; +spin_unlock_irqrestore (&fmdev->resp_skb_lock, flags); + +/* Execute interrupt handler where state index points */ + irq_info->handlers[irq_info->stage](fmdev); + +kfree_skb (skb); +atomic_set (&fmdev->tx_cnt,1 ); + }else { +fmerr ("Nobody claimed SKB(%p),purging\n" ,skb); + } + +/* +* Check flow control field. If Num_FM_HCI_Commands field is +* not zero, schedule FM TX tasklet. +*/ +if (num_fm_hci_cmds &&atomic_read (&fmdev->tx_cnt)) +if (!skb_queue_empty (&fmdev->tx_q)) +tasklet_schedule (&fmdev->tx_task); + } +} + +/* FM send tasklet: is scheduled when FM packet has to be sent to chip */ +static void send_tasklet (unsigned long arg) +{ +struct fmdev *fmdev; +struct sk_buff *skb; +int len; + + fmdev = (struct fmdev *)arg; + +if (!atomic_read (&fmdev->tx_cnt)) +return ; + +/* Check, is there any timeout happenned to last transmitted packet */ +if ((jiffies - fmdev->last_tx_jiffies) >FM_DRV_TX_TIMEOUT ) { +fmerr ("TX timeout occurred\n" ); +atomic_set (&fmdev->tx_cnt,1 ); + } + +/* Send queued FM TX packets */ + skb =skb_dequeue (&fmdev->tx_q); +if (!skb) +return ; + +atomic_dec (&fmdev->tx_cnt); + fmdev->pre_op =fm_cb (skb)->fm_op; + +if (fmdev->resp_comp !=NULL ) +fmerr ("Response completion handler is not NULL\n" ); + + fmdev->resp_comp =fm_cb (skb)->completion; + +/* Write FM packet to ST driver */ + len =g_st_write (skb); +if (len <0 ) { +kfree_skb (skb); + fmdev->resp_comp =NULL ; +fmerr ("TX tasklet failed to send skb(%p)\n" , skb); +atomic_set (&fmdev->tx_cnt,1 ); + }else { + fmdev->last_tx_jiffies = jiffies; + } +} + +/* +* Queues FM Channel-8 packet to FM TX queue and schedules FM TX tasklet for +* transmission +*/ +static u32 fm_send_cmd (struct fmdev *fmdev,u8 fm_op,u16 type,void *payload, +int payload_len,struct completion *wait_completion) +{ +struct sk_buff *skb; +struct fm_cmd_msg_hdr *hdr; +int size; + +if (fm_op >=FM_INTERRUPT ) { +fmerr ("Invalid fm opcode - %d\n" ,fm_op); +return -EINVAL ; + } +if (test_bit (FM_FW_DW_INPROGRESS , &fmdev->flag) && payload ==NULL ) { +fmerr ("Payload data is NULL during fw download\n" ); +return -EINVAL ; + } +if (!test_bit (FM_FW_DW_INPROGRESS , &fmdev->flag)) + size = +FM_CMD_MSG_HDR_SIZE + ((payload ==NULL ) ?0 : payload_len); +else + size = payload_len; + + skb =alloc_skb (size,GFP_ATOMIC ); +if (!skb) { +fmerr ("No memory to create new SKB\n" ); +return -ENOMEM ; + } +/* +* Don't fill FM header info for the commands which come from +* FM firmware file. +*/ +if (!test_bit (FM_FW_DW_INPROGRESS , &fmdev->flag) || +test_bit (FM_INTTASK_RUNNING , &fmdev->flag)) { +/* Fill command header info */ + hdr = (struct fm_cmd_msg_hdr *)skb_put (skb,FM_CMD_MSG_HDR_SIZE ); + hdr->hdr =FM_PKT_LOGICAL_CHAN_NUMBER ;/* 0x08 */ + +/* 3 (fm_opcode,rd_wr,dlen) + payload len) */ + hdr->len = ((payload ==NULL ) ?0 : payload_len) +3 ; + +/* FM opcode */ + hdr->op = fm_op; + +/* read/write type */ + hdr->rd_wr = type; + hdr->dlen = payload_len; +fm_cb (skb)->fm_op = fm_op; + +/* +* If firmware download has finished and the command is +* not a read command then payload is != NULL - a write +* command with u16 payload - convert to be16 +*/ +if (payload !=NULL ) + *(u16 *)payload =cpu_to_be16 (*(u16 *)payload); + + }else if (payload !=NULL ) { +fm_cb (skb)->fm_op = *((u8 *)payload +2 ); + } +if (payload !=NULL ) +memcpy (skb_put (skb, payload_len), payload, payload_len); + +fm_cb (skb)->completion = wait_completion; +skb_queue_tail (&fmdev->tx_q, skb); +tasklet_schedule (&fmdev->tx_task); + +return 0 ; +} + +/* Sends FM Channel-8 command to the chip and waits for the response */ +u32 fmc_send_cmd (struct fmdev *fmdev,u8 fm_op,u16 type,void *payload, +unsigned int payload_len,void *response,int *response_len) +{ +struct sk_buff *skb; +struct fm_event_msg_hdr *evt_hdr; +unsigned long flags; +u32 ret; + +init_completion (&fmdev->maintask_comp); + ret =fm_send_cmd (fmdev, fm_op, type, payload, payload_len, + &fmdev->maintask_comp); +if (ret) +return ret; + + ret =wait_for_completion_timeout (&fmdev->maintask_comp,FM_DRV_TX_TIMEOUT ); +if (!ret) { +fmerr ("Timeout(%d sec),didn't get reg" +"completion signal from RX tasklet\n" , +jiffies_to_msecs (FM_DRV_TX_TIMEOUT ) /1000 ); +return -ETIMEDOUT ; + } +if (!fmdev->resp_skb) { +fmerr ("Reponse SKB is missing\n" ); +return -EFAULT ; + } +spin_lock_irqsave (&fmdev->resp_skb_lock, flags); + skb = fmdev->resp_skb; + fmdev->resp_skb =NULL ; +spin_unlock_irqrestore (&fmdev->resp_skb_lock, flags); + + evt_hdr = (void *)skb->data; +if (evt_hdr->status !=0 ) { +fmerr ("Received event pkt status(%d) is not zero\n" , + evt_hdr->status); +kfree_skb (skb); +return -EIO ; + } +/* Send response data to caller */ +if (response !=NULL && response_len !=NULL && evt_hdr->dlen) { +/* Skip header info and copy only response data */ +skb_pull (skb,sizeof (struct fm_event_msg_hdr )); +memcpy (response, skb->data, evt_hdr->dlen); + *response_len = evt_hdr->dlen; + }else if (response_len !=NULL && evt_hdr->dlen ==0 ) { + *response_len =0 ; + } +kfree_skb (skb); + +return 0 ; +} + +/* --- Helper functions used in FM interrupt handlers ---*/ +static inline u32 check_cmdresp_status (struct fmdev *fmdev, +struct sk_buff **skb) +{ +struct fm_event_msg_hdr *fm_evt_hdr; +unsigned long flags; + +del_timer (&fmdev->irq_info.timer); + +spin_lock_irqsave (&fmdev->resp_skb_lock, flags); + *skb = fmdev->resp_skb; + fmdev->resp_skb =NULL ; +spin_unlock_irqrestore (&fmdev->resp_skb_lock, flags); + + fm_evt_hdr = (void *)(*skb)->data; +if (fm_evt_hdr->status !=0 ) { +fmerr ("irq: opcode %x response status is not zero " +"Initiating irq recovery process\n" , + fm_evt_hdr->op); + +mod_timer (&fmdev->irq_info.timer, jiffies +FM_DRV_TX_TIMEOUT ); +return -1 ; + } + +return 0 ; +} + +static inline void fm_irq_common_cmd_resp_helper (struct fmdev *fmdev,u8 stage) +{ +struct sk_buff *skb; + +if (!check_cmdresp_status (fmdev, &skb)) +fm_irq_call_stage (fmdev, stage); +} + +/* +* Interrupt process timeout handler. +* One of the irq handler did not get proper response from the chip. So take +* recovery action here. FM interrupts are disabled in the beginning of +* interrupt process. Therefore reset stage index to re-enable default +* interrupts. So that next interrupt will be processed as usual. +*/ +static void int_timeout_handler (unsigned long data) +{ +struct fmdev *fmdev; +struct fm_irq *fmirq; + +fmdbg ("irq: timeout,trying to re-enable fm interrupts\n" ); + fmdev = (struct fmdev *)data; + fmirq = &fmdev->irq_info; + fmirq->retry++; + +if (fmirq->retry >FM_IRQ_TIMEOUT_RETRY_MAX ) { +/* Stop recovery action (interrupt reenable process) and +* reset stage index & retry count values */ + fmirq->stage =0 ; + fmirq->retry =0 ; +fmerr ("Recovery action failed during" +"irq processing, max retry reached\n" ); +return ; + } +fm_irq_call_stage (fmdev,FM_SEND_INTMSK_CMD_IDX ); +} + +/* --------- FM interrupt handlers ------------*/ +static void fm_irq_send_flag_getcmd (struct fmdev *fmdev) +{ +u16 flag; + +/* Send FLAG_GET command , to know the source of interrupt */ +if (!fm_send_cmd (fmdev,FLAG_GET ,REG_RD ,NULL ,sizeof (flag),NULL )) +fm_irq_timeout_stage (fmdev,FM_HANDLE_FLAG_GETCMD_RESP_IDX ); +} + +static void fm_irq_handle_flag_getcmd_resp (struct fmdev *fmdev) +{ +struct sk_buff *skb; +struct fm_event_msg_hdr *fm_evt_hdr; + +if (check_cmdresp_status (fmdev, &skb)) +return ; + + fm_evt_hdr = (void *)skb->data; + +/* Skip header info and copy only response data */ +skb_pull (skb,sizeof (struct fm_event_msg_hdr )); +memcpy (&fmdev->irq_info.flag, skb->data, fm_evt_hdr->dlen); + + fmdev->irq_info.flag =be16_to_cpu (fmdev->irq_info.flag); +fmdbg ("irq: flag register(0x%x)\n" , fmdev->irq_info.flag); + +/* Continue next function in interrupt handler table */ +fm_irq_call_stage (fmdev,FM_HW_MAL_FUNC_IDX ); +} + +static void fm_irq_handle_hw_malfunction (struct fmdev *fmdev) +{ +if (fmdev->irq_info.flag &FM_MAL_EVENT & fmdev->irq_info.mask) +fmerr ("irq: HW MAL int received - do nothing\n" ); + +/* Continue next function in interrupt handler table */ +fm_irq_call_stage (fmdev,FM_RDS_START_IDX ); +} + +static void fm_irq_handle_rds_start (struct fmdev *fmdev) +{ +if (fmdev->irq_info.flag &FM_RDS_EVENT & fmdev->irq_info.mask) { +fmdbg ("irq: rds threshold reached\n" ); + fmdev->irq_info.stage =FM_RDS_SEND_RDS_GETCMD_IDX ; + }else { +/* Continue next function in interrupt handler table */ + fmdev->irq_info.stage =FM_HW_TUNE_OP_ENDED_IDX ; + } + +fm_irq_call (fmdev); +} + +static void fm_irq_send_rdsdata_getcmd (struct fmdev *fmdev) +{ +/* Send the command to read RDS data from the chip */ +if (!fm_send_cmd (fmdev,RDS_DATA_GET ,REG_RD ,NULL , + (FM_RX_RDS_FIFO_THRESHOLD *3 ),NULL )) +fm_irq_timeout_stage (fmdev,FM_RDS_HANDLE_RDS_GETCMD_RESP_IDX ); +} + +/* Keeps track of current RX channel AF (Alternate Frequency) */ +static void fm_rx_update_af_cache (struct fmdev *fmdev,u8 af) +{ +struct tuned_station_info *stat_info = &fmdev->rx.stat_info; +u8 reg_idx = fmdev->rx.region.fm_band; +u8 index; +u32 freq; + +/* First AF indicates the number of AF follows. Reset the list */ +if ((af >=FM_RDS_1_AF_FOLLOWS ) && (af <=FM_RDS_25_AF_FOLLOWS )) { + fmdev->rx.stat_info.af_list_max = (af -FM_RDS_1_AF_FOLLOWS +1 ); + fmdev->rx.stat_info.afcache_size =0 ; +fmdbg ("No of expected AF : %d\n" ,fmdev->rx.stat_info.af_list_max); +return ; + } + +if (af <FM_RDS_MIN_AF ) +return ; +if (reg_idx ==FM_BAND_EUROPE_US && af >FM_RDS_MAX_AF ) +return ; +if (reg_idx ==FM_BAND_JAPAN && af >FM_RDS_MAX_AF_JAPAN ) +return ; + + freq = fmdev->rx.region.bot_freq + (af *100 ); +if (freq == fmdev->rx.freq) { +fmdbg ("Current freq(%d) is matching with received AF(%d)\n" , + fmdev->rx.freq, freq); +return ; + } +/* Do check in AF cache */ +for (index =0 ; index < stat_info->afcache_size; index++) { +if (stat_info->af_cache[index] == freq) +break ; + } +/* Reached the limit of the list - ignore the next AF */ +if (index == stat_info->af_list_max) { +fmdbg ("AF cache is full\n" ); +return ; + } +/* +* If we reached the end of the list then this AF is not +* in the list - add it. +*/ +if (index == stat_info->afcache_size) { +fmdbg ("Storing AF %d to cache index %d\n" ,freq, index); + stat_info->af_cache[index] = freq; + stat_info->afcache_size++; + } +} + +/* +* Converts RDS buffer data from big endian format +* to little endian format. +*/ +static void fm_rdsparse_swapbytes (struct fmdev *fmdev, +struct fm_rdsdata_format *rds_format) +{ +u8 byte1; +u8 index =0 ; +u8 *rds_buff; + +/* +* Since in Orca the 2 RDS Data bytes are in little endian and +* in Dolphin they are in big endian, the parsing of the RDS data +* is chip dependent +*/ +if (fmdev->asci_id !=0x6350 ) { + rds_buff = &rds_format->data.groupdatabuff.buff[0 ]; +while (index +1 <FM_RX_RDS_INFO_FIELD_MAX ) { + byte1 = rds_buff[index]; + rds_buff[index] = rds_buff[index +1 ]; + rds_buff[index +1 ] = byte1; + index +=2 ; + } + } +} + +static void fm_irq_handle_rdsdata_getcmd_resp (struct fmdev *fmdev) +{ +struct sk_buff *skb; +struct fm_rdsdata_format rds_fmt; +struct fm_rds *rds = &fmdev->rx.rds; +unsigned long group_idx, flags; +u8 *rds_data, meta_data, tmpbuf[3 ]; +u8 type, blk_idx; +u16 cur_picode; +u32 rds_len; + +if (check_cmdresp_status (fmdev, &skb)) +return ; + +/* Skip header info */ +skb_pull (skb,sizeof (struct fm_event_msg_hdr )); + rds_data = skb->data; + rds_len = skb->len; + +/* Parse the RDS data */ +while (rds_len >=FM_RDS_BLK_SIZE ) { + meta_data = rds_data[2 ]; +/* Get the type: 0=A, 1=B, 2=C, 3=C', 4=D, 5=E */ + type = (meta_data &0x07 ); + +/* Transform the blk type into index sequence (0, 1, 2, 3, 4) */ + blk_idx = (type <=FM_RDS_BLOCK_C ? type : (type -1 )); +fmdbg ("Block index:%d(%s)\n" , blk_idx, + (meta_data &FM_RDS_STATUS_ERR_MASK ) ?"Bad" :"Ok" ); + +if ((meta_data &FM_RDS_STATUS_ERR_MASK ) !=0 ) +break ; + +if (blk_idx <FM_RDS_BLK_IDX_A || blk_idx >FM_RDS_BLK_IDX_D ) { +fmdbg ("Block sequence mismatch\n" ); + rds->last_blk_idx =-1 ; +break ; + } + +/* Skip checkword (control) byte and copy only data byte */ +memcpy (&rds_fmt.data.groupdatabuff. + buff[blk_idx * (FM_RDS_BLK_SIZE -1 )], + rds_data, (FM_RDS_BLK_SIZE -1 )); + + rds->last_blk_idx = blk_idx; + +/* If completed a whole group then handle it */ +if (blk_idx ==FM_RDS_BLK_IDX_D ) { +fmdbg ("Good block received\n" ); +fm_rdsparse_swapbytes (fmdev, &rds_fmt); + +/* +* Extract PI code and store in local cache. +* We need this during AF switch processing. +*/ + cur_picode =be16_to_cpu (rds_fmt.data.groupgeneral.pidata); +if (fmdev->rx.stat_info.picode != cur_picode) + fmdev->rx.stat_info.picode = cur_picode; + +fmdbg ("picode:%d\n" , cur_picode); + + group_idx = (rds_fmt.data.groupgeneral.blk_b[0 ] >>3 ); +fmdbg ("(fmdrv):Group:%ld%s\n" , group_idx/2 , + (group_idx %2 ) ?"B" :"A" ); + + group_idx =1 << (rds_fmt.data.groupgeneral.blk_b[0 ] >>3 ); +if (group_idx ==FM_RDS_GROUP_TYPE_MASK_0A ) { +fm_rx_update_af_cache (fmdev, rds_fmt.data.group0A.af[0 ]); +fm_rx_update_af_cache (fmdev, rds_fmt.data.group0A.af[1 ]); + } + } + rds_len -=FM_RDS_BLK_SIZE ; + rds_data +=FM_RDS_BLK_SIZE ; + } + +/* Copy raw rds data to internal rds buffer */ + rds_data = skb->data; + rds_len = skb->len; + +spin_lock_irqsave (&fmdev->rds_buff_lock, flags); +while (rds_len >0 ) { +/* +* Fill RDS buffer as per V4L2 specification. +* Store control byte +*/ + type = (rds_data[2 ] &0x07 ); + blk_idx = (type <=FM_RDS_BLOCK_C ? type : (type -1 )); + tmpbuf[2 ] = blk_idx;/* Offset name */ + tmpbuf[2 ] |= blk_idx <<3 ;/* Received offset */ + +/* Store data byte */ + tmpbuf[0 ] = rds_data[0 ]; + tmpbuf[1 ] = rds_data[1 ]; + +memcpy (&rds->buff[rds->wr_idx], &tmpbuf,FM_RDS_BLK_SIZE ); + rds->wr_idx = (rds->wr_idx +FM_RDS_BLK_SIZE ) % rds->buf_size; + +/* Check for overflow & start over */ +if (rds->wr_idx == rds->rd_idx) { +fmdbg ("RDS buffer overflow\n" ); + rds->wr_idx =0 ; + rds->rd_idx =0 ; +break ; + } + rds_len -=FM_RDS_BLK_SIZE ; + rds_data +=FM_RDS_BLK_SIZE ; + } +spin_unlock_irqrestore (&fmdev->rds_buff_lock, flags); + +/* Wakeup read queue */ +if (rds->wr_idx != rds->rd_idx) +wake_up_interruptible (&rds->read_queue); + +fm_irq_call_stage (fmdev,FM_RDS_FINISH_IDX ); +} + +static void fm_irq_handle_rds_finish (struct fmdev *fmdev) +{ +fm_irq_call_stage (fmdev,FM_HW_TUNE_OP_ENDED_IDX ); +} + +static void fm_irq_handle_tune_op_ended (struct fmdev *fmdev) +{ +if (fmdev->irq_info.flag & (FM_FR_EVENT |FM_BL_EVENT ) & fmdev-> + irq_info.mask) { +fmdbg ("irq: tune ended/bandlimit reached\n" ); +if (test_and_clear_bit (FM_AF_SWITCH_INPROGRESS , &fmdev->flag)) { + fmdev->irq_info.stage =FM_AF_JUMP_RD_FREQ_IDX ; + }else { +complete (&fmdev->maintask_comp); + fmdev->irq_info.stage =FM_HW_POWER_ENB_IDX ; + } + }else + fmdev->irq_info.stage =FM_HW_POWER_ENB_IDX ; + +fm_irq_call (fmdev); +} + +static void fm_irq_handle_power_enb (struct fmdev *fmdev) +{ +if (fmdev->irq_info.flag &FM_POW_ENB_EVENT ) { +fmdbg ("irq: Power Enabled/Disabled\n" ); +complete (&fmdev->maintask_comp); + } + +fm_irq_call_stage (fmdev,FM_LOW_RSSI_START_IDX ); +} + +static void fm_irq_handle_low_rssi_start (struct fmdev *fmdev) +{ +if ((fmdev->rx.af_mode ==FM_RX_RDS_AF_SWITCH_MODE_ON ) && + (fmdev->irq_info.flag &FM_LEV_EVENT & fmdev->irq_info.mask) && + (fmdev->rx.freq !=FM_UNDEFINED_FREQ ) && + (fmdev->rx.stat_info.afcache_size !=0 )) { +fmdbg ("irq: rssi level has fallen below threshold level\n" ); + +/* Disable further low RSSI interrupts */ + fmdev->irq_info.mask &= ~FM_LEV_EVENT ; + + fmdev->rx.afjump_idx =0 ; + fmdev->rx.freq_before_jump = fmdev->rx.freq; + fmdev->irq_info.stage =FM_AF_JUMP_SETPI_IDX ; + }else { +/* Continue next function in interrupt handler table */ + fmdev->irq_info.stage =FM_SEND_INTMSK_CMD_IDX ; + } + +fm_irq_call (fmdev); +} + +static void fm_irq_afjump_set_pi (struct fmdev *fmdev) +{ +u16 payload; + +/* Set PI code - must be updated if the AF list is not empty */ + payload = fmdev->rx.stat_info.picode; +if (!fm_send_cmd (fmdev,RDS_PI_SET ,REG_WR , &payload,sizeof (payload),NULL )) +fm_irq_timeout_stage (fmdev,FM_AF_JUMP_HANDLE_SETPI_RESP_IDX ); +} + +static void fm_irq_handle_set_pi_resp (struct fmdev *fmdev) +{ +fm_irq_common_cmd_resp_helper (fmdev,FM_AF_JUMP_SETPI_MASK_IDX ); +} + +/* +* Set PI mask. +* 0xFFFF = Enable PI code matching +* 0x0000 = Disable PI code matching +*/ +static void fm_irq_afjump_set_pimask (struct fmdev *fmdev) +{ +u16 payload; + + payload =0x0000 ; +if (!fm_send_cmd (fmdev,RDS_PI_MASK_SET ,REG_WR , &payload,sizeof (payload),NULL )) +fm_irq_timeout_stage (fmdev,FM_AF_JUMP_HANDLE_SETPI_MASK_RESP_IDX ); +} + +static void fm_irq_handle_set_pimask_resp (struct fmdev *fmdev) +{ +fm_irq_common_cmd_resp_helper (fmdev,FM_AF_JUMP_SET_AF_FREQ_IDX ); +} + +static void fm_irq_afjump_setfreq (struct fmdev *fmdev) +{ +u16 frq_index; +u16 payload; + +fmdbg ("Swtich to %d KHz\n" , fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx]); + frq_index = (fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx] - + fmdev->rx.region.bot_freq) /FM_FREQ_MUL ; + + payload = frq_index; +if (!fm_send_cmd (fmdev,AF_FREQ_SET ,REG_WR , &payload,sizeof (payload),NULL )) +fm_irq_timeout_stage (fmdev,FM_AF_JUMP_HANDLE_SET_AFFREQ_RESP_IDX ); +} + +static void fm_irq_handle_setfreq_resp (struct fmdev *fmdev) +{ +fm_irq_common_cmd_resp_helper (fmdev,FM_AF_JUMP_ENABLE_INT_IDX ); +} + +static void fm_irq_afjump_enableint (struct fmdev *fmdev) +{ +u16 payload; + +/* Enable FR (tuning operation ended) interrupt */ + payload =FM_FR_EVENT ; +if (!fm_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload,sizeof (payload),NULL )) +fm_irq_timeout_stage (fmdev,FM_AF_JUMP_ENABLE_INT_RESP_IDX ); +} + +static void fm_irq_afjump_enableint_resp (struct fmdev *fmdev) +{ +fm_irq_common_cmd_resp_helper (fmdev,FM_AF_JUMP_START_AFJUMP_IDX ); +} + +static void fm_irq_start_afjump (struct fmdev *fmdev) +{ +u16 payload; + + payload =FM_TUNER_AF_JUMP_MODE ; +if (!fm_send_cmd (fmdev,TUNER_MODE_SET ,REG_WR , &payload, +sizeof (payload),NULL )) +fm_irq_timeout_stage (fmdev,FM_AF_JUMP_HANDLE_START_AFJUMP_RESP_IDX ); +} + +static void fm_irq_handle_start_afjump_resp (struct fmdev *fmdev) +{ +struct sk_buff *skb; + +if (check_cmdresp_status (fmdev, &skb)) +return ; + + fmdev->irq_info.stage =FM_SEND_FLAG_GETCMD_IDX ; +set_bit (FM_AF_SWITCH_INPROGRESS , &fmdev->flag); +clear_bit (FM_INTTASK_RUNNING , &fmdev->flag); +} + +static void fm_irq_afjump_rd_freq (struct fmdev *fmdev) +{ +u16 payload; + +if (!fm_send_cmd (fmdev,FREQ_SET ,REG_RD ,NULL ,sizeof (payload),NULL )); +fm_irq_timeout_stage (fmdev,FM_AF_JUMP_RD_FREQ_RESP_IDX ); +} + +static void fm_irq_afjump_rd_freq_resp (struct fmdev *fmdev) +{ +struct sk_buff *skb; +u16 read_freq; +u32 curr_freq, jumped_freq; + +if (check_cmdresp_status (fmdev, &skb)) +return ; + +/* Skip header info and copy only response data */ +skb_pull (skb,sizeof (struct fm_event_msg_hdr )); +memcpy (&read_freq, skb->data,sizeof (read_freq)); + read_freq =be16_to_cpu (read_freq); + curr_freq = fmdev->rx.region.bot_freq + ((u32 )read_freq *FM_FREQ_MUL ); + + jumped_freq = fmdev->rx.stat_info.af_cache[fmdev->rx.afjump_idx]; + +/* If the frequency was changed the jump succeeded */ +if ((curr_freq != fmdev->rx.freq_before_jump) && (curr_freq == jumped_freq)) { +fmdbg ("Successfully switched to alternate freq %d\n" , curr_freq); + fmdev->rx.freq = curr_freq; +fm_rx_reset_rds_cache (fmdev); + +/* AF feature is on, enable low level RSSI interrupt */ +if (fmdev->rx.af_mode ==FM_RX_RDS_AF_SWITCH_MODE_ON ) + fmdev->irq_info.mask |=FM_LEV_EVENT ; + + fmdev->irq_info.stage =FM_LOW_RSSI_FINISH_IDX ; + }else {/* jump to the next freq in the AF list */ + fmdev->rx.afjump_idx++; + +/* If we reached the end of the list - stop searching */ +if (fmdev->rx.afjump_idx >= fmdev->rx.stat_info.afcache_size) { +fmdbg ("AF switch processing failed\n" ); + fmdev->irq_info.stage =FM_LOW_RSSI_FINISH_IDX ; + }else {/* AF List is not over - try next one */ + +fmdbg ("Trying next freq in AF cache\n" ); + fmdev->irq_info.stage =FM_AF_JUMP_SETPI_IDX ; + } + } +fm_irq_call (fmdev); +} + +static void fm_irq_handle_low_rssi_finish (struct fmdev *fmdev) +{ +fm_irq_call_stage (fmdev,FM_SEND_INTMSK_CMD_IDX ); +} + +static void fm_irq_send_intmsk_cmd (struct fmdev *fmdev) +{ +u16 payload; + +/* Re-enable FM interrupts */ + payload = fmdev->irq_info.mask; + +if (!fm_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL )) +fm_irq_timeout_stage (fmdev,FM_HANDLE_INTMSK_CMD_RESP_IDX ); +} + +static void fm_irq_handle_intmsk_cmd_resp (struct fmdev *fmdev) +{ +struct sk_buff *skb; + +if (check_cmdresp_status (fmdev, &skb)) +return ; +/* +* This is last function in interrupt table to be executed. +* So, reset stage index to 0. +*/ + fmdev->irq_info.stage =FM_SEND_FLAG_GETCMD_IDX ; + +/* Start processing any pending interrupt */ +if (test_and_clear_bit (FM_INTTASK_SCHEDULE_PENDING , &fmdev->flag)) { + fmdev->irq_info.handlers[fmdev->irq_info.stage](fmdev); + }else +clear_bit (FM_INTTASK_RUNNING , &fmdev->flag); +} + +/* Returns availability of RDS data in internel buffer */ +u32 fmc_is_rds_data_available (struct fmdev *fmdev,struct file *file, +struct poll_table_struct *pts) +{ +poll_wait (file, &fmdev->rx.rds.read_queue, pts); +if (fmdev->rx.rds.rd_idx != fmdev->rx.rds.wr_idx) +return 0 ; + +return -EAGAIN ; +} + +/* Copies RDS data from internal buffer to user buffer */ +u32 fmc_transfer_rds_from_internal_buff (struct fmdev *fmdev,struct file *file, +u8 __user *buf,size_t count) +{ +u32 block_count; +unsigned long flags; +int ret; + +if (fmdev->rx.rds.wr_idx == fmdev->rx.rds.rd_idx) { +if (file->f_flags &O_NONBLOCK ) +return -EWOULDBLOCK ; + + ret =wait_event_interruptible (fmdev->rx.rds.read_queue, + (fmdev->rx.rds.wr_idx != fmdev->rx.rds.rd_idx)); +if (ret) +return -EINTR ; + } + +/* Calculate block count from byte count */ + count /=3 ; + block_count =0 ; + ret =0 ; + +spin_lock_irqsave (&fmdev->rds_buff_lock, flags); + +while (block_count < count) { +if (fmdev->rx.rds.wr_idx == fmdev->rx.rds.rd_idx) +break ; + +if (copy_to_user (buf, &fmdev->rx.rds.buff[fmdev->rx.rds.rd_idx], +FM_RDS_BLK_SIZE )) +break ; + + fmdev->rx.rds.rd_idx +=FM_RDS_BLK_SIZE ; +if (fmdev->rx.rds.rd_idx >= fmdev->rx.rds.buf_size) + fmdev->rx.rds.rd_idx =0 ; + + block_count++; + buf +=FM_RDS_BLK_SIZE ; + ret +=FM_RDS_BLK_SIZE ; + } +spin_unlock_irqrestore (&fmdev->rds_buff_lock, flags); +return ret; +} + +u32 fmc_set_freq (struct fmdev *fmdev,u32 freq_to_set) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_freq (fmdev, freq_to_set); +break ; + +case FM_MODE_TX : +return fm_tx_set_freq (fmdev, freq_to_set); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_get_freq (struct fmdev *fmdev,u32 *cur_tuned_frq) +{ +if (fmdev->rx.freq ==FM_UNDEFINED_FREQ ) { +fmerr ("RX frequency is not set\n" ); +return -EPERM ; + } +if (cur_tuned_frq ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : + *cur_tuned_frq = fmdev->rx.freq; +break ; + +case FM_MODE_TX : + *cur_tuned_frq =0 ;/* TODO : Change this later */ +break ; + +default : +return -EINVAL ; + } + +return 0 ; +} + +u32 fmc_set_region (struct fmdev *fmdev,u8 region_to_set) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_region (fmdev, region_to_set); +break ; + +case FM_MODE_TX : +return fm_tx_set_region (fmdev, region_to_set); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_set_mute_mode (struct fmdev *fmdev,u8 mute_mode_toset) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_mute_mode (fmdev, mute_mode_toset); +break ; + +case FM_MODE_TX : +return fm_tx_set_mute_mode (fmdev, mute_mode_toset); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_set_stereo_mono (struct fmdev *fmdev,u16 mode) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_stereo_mono (fmdev, mode); +break ; + +case FM_MODE_TX : +return fm_tx_set_stereo_mono (fmdev, mode); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_set_rds_mode (struct fmdev *fmdev,u8 rds_en_dis) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_rds_mode (fmdev, rds_en_dis); +break ; + +case FM_MODE_TX : +return fm_tx_set_rds_mode (fmdev, rds_en_dis); +break ; + +default : +return -EINVAL ; + } +} + +/* Sends power off command to the chip */ +static u32 fm_power_down (struct fmdev *fmdev) +{ +u16 payload; +u32 ret =0 ; + +if (!test_bit (FM_CORE_READY , &fmdev->flag)) { +fmerr ("FM core is not ready\n" ); +return -EPERM ; + } +if (fmdev->curr_fmmode ==FM_MODE_OFF ) { +fmdbg ("FM chip is already in OFF state\n" ); +return ret; + } + + payload =0x0 ; + ret =fmc_send_cmd (fmdev,FM_POWER_MODE ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + ret =fmc_release (fmdev); + +return ret; +} + +/* Reads init command from FM firmware file and loads to the chip */ +static u32 fm_download_firmware (struct fmdev *fmdev,const u8 *fw_name) +{ +const struct firmware *fw_entry; +struct bts_header *fw_header; +struct bts_action *action; +struct bts_action_delay *delay; +u8 *fw_data; +int ret, fw_len, cmd_cnt; + + cmd_cnt =0 ; +set_bit (FM_FW_DW_INPROGRESS , &fmdev->flag); + + ret =request_firmware (&fw_entry, fw_name, + &fmdev->radio_dev->dev); +if (ret <0 ) { +fmerr ("Unable to read firmware(%s) content\n" , fw_name); +return ret; + } +fmdbg ("Firmware(%s) length : %d bytes\n" , fw_name, fw_entry->size); + + fw_data = (void *)fw_entry->data; + fw_len = fw_entry->size; + + fw_header = (struct bts_header *)fw_data; +if (fw_header->magic !=FM_FW_FILE_HEADER_MAGIC ) { +fmerr ("%s not a legal TI firmware file\n" , fw_name); + ret = -EINVAL ; + goto rel_fw; + } +fmdbg ("FW(%s) magic number : 0x%x\n" , fw_name, fw_header->magic); + +/* Skip file header info , we already verified it */ + fw_data +=sizeof (struct bts_header ); + fw_len -=sizeof (struct bts_header ); + +while (fw_data && fw_len >0 ) { + action = (struct bts_action *)fw_data; + +switch (action->type) { +case ACTION_SEND_COMMAND :/* Send */ +if (fmc_send_cmd (fmdev,0 ,0 , action->data, + action->size,NULL ,NULL )) + goto rel_fw; + + cmd_cnt++; +break ; + +case ACTION_DELAY :/* Delay */ + delay = (struct bts_action_delay *)action->data; +mdelay (delay->msec); +break ; + } + + fw_data += (sizeof (struct bts_action ) + (action->size)); + fw_len -= (sizeof (struct bts_action ) + (action->size)); + } +fmdbg ("Firmare commands(%d) loaded to chip\n" , cmd_cnt); +rel_fw: +release_firmware (fw_entry); +clear_bit (FM_FW_DW_INPROGRESS , &fmdev->flag); + +return ret; +} + +/* Loads default RX configuration to the chip */ +static u32 load_default_rx_configuration (struct fmdev *fmdev) +{ +int ret; + + ret =fm_rx_set_volume (fmdev,FM_DEFAULT_RX_VOLUME ); +if (ret <0 ) +return ret; + + ret =fm_rx_set_rssi_threshold (fmdev,FM_DEFAULT_RSSI_THRESHOLD ); +return ret; +} + +/* Does FM power on sequence */ +static u32 fm_power_up (struct fmdev *fmdev,u8 mode) +{ +u16 payload, asic_id, asic_ver; +int resp_len, ret; +u8 fw_name[50 ]; + +if (mode >=FM_MODE_ENTRY_MAX ) { +fmerr ("Invalid firmware download option\n" ); +return -EINVAL ; + } + +/* +* Initialize FM common module. FM GPIO toggling is +* taken care in Shared Transport driver. +*/ + ret =fmc_prepare (fmdev); +if (ret <0 ) { +fmerr ("Unable to prepare FM Common\n" ); +return ret; + } + + payload =FM_ENABLE ; +if (fmc_send_cmd (fmdev,FM_POWER_MODE ,REG_WR , &payload, +sizeof (payload),NULL ,NULL )) + goto rel; + +/* Allow the chip to settle down in Channel-8 mode */ +msleep (20 ); + +if (fmc_send_cmd (fmdev,ASIC_ID_GET ,REG_RD ,NULL , +sizeof (asic_id), &asic_id, &resp_len)) + goto rel; + +if (fmc_send_cmd (fmdev,ASIC_VER_GET ,REG_RD ,NULL , +sizeof (asic_ver), &asic_ver, &resp_len)) + goto rel; + +fmdbg ("ASIC ID: 0x%x , ASIC Version: %d\n" , +be16_to_cpu (asic_id),be16_to_cpu (asic_ver)); + +sprintf (fw_name,"%s_%x.%d.bts" ,FM_FMC_FW_FILE_START , +be16_to_cpu (asic_id),be16_to_cpu (asic_ver)); + + ret =fm_download_firmware (fmdev, fw_name); +if (ret <0 ) { +fmdbg ("Failed to download firmware file %s\n" , fw_name); + goto rel; + } +sprintf (fw_name,"%s_%x.%d.bts" , (mode ==FM_MODE_RX ) ? +FM_RX_FW_FILE_START :FM_TX_FW_FILE_START , +be16_to_cpu (asic_id),be16_to_cpu (asic_ver)); + + ret =fm_download_firmware (fmdev, fw_name); +if (ret <0 ) { +fmdbg ("Failed to download firmware file %s\n" , fw_name); + goto rel; + }else +return ret; +rel: +fmc_release (fmdev); + +return ret; +} + +/* Set FM Modes(TX, RX, OFF) */ +u32 fmc_set_mode (struct fmdev *fmdev,u8 fm_mode) +{ +int ret =0 ; + +if (fm_mode >=FM_MODE_ENTRY_MAX ) { +fmerr ("Invalid FM mode\n" ); +return -EINVAL ; + } +if (fmdev->curr_fmmode == fm_mode) { +fmdbg ("Already fm is in mode(%d)\n" , fm_mode); +return ret; + } + +switch (fm_mode) { +case FM_MODE_OFF :/* OFF Mode */ + ret =fm_power_down (fmdev); +if (ret <0 ) { +fmerr ("Failed to set OFF mode\n" ); +return ret; + } +break ; + +case FM_MODE_TX :/* TX Mode */ +case FM_MODE_RX :/* RX Mode */ +/* Power down before switching to TX or RX mode */ +if (fmdev->curr_fmmode !=FM_MODE_OFF ) { + ret =fm_power_down (fmdev); +if (ret <0 ) { +fmerr ("Failed to set OFF mode\n" ); +return ret; + } +msleep (30 ); + } + ret =fm_power_up (fmdev, fm_mode); +if (ret <0 ) { +fmerr ("Failed to load firmware\n" ); +return ret; + } + } + fmdev->curr_fmmode = fm_mode; + +/* Set default configuration */ +if (fmdev->curr_fmmode ==FM_MODE_RX ) { +fmdbg ("Loading default rx configuration..\n" ); + ret =load_default_rx_configuration (fmdev); +if (ret <0 ) +fmerr ("Failed to load default values\n" ); + } + +return ret; +} + +/* Returns current FM mode (TX, RX, OFF) */ +u32 fmc_get_mode (struct fmdev *fmdev,u8 *fmmode) +{ +if (!test_bit (FM_CORE_READY , &fmdev->flag)) { +fmerr ("FM core is not ready\n" ); +return -EPERM ; + } +if (fmmode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *fmmode = fmdev->curr_fmmode; +return 0 ; +} + +/* Called by ST layer when FM packet is available */ +static long fm_st_receive (void *arg,struct sk_buff *skb) +{ +struct fmdev *fmdev; + + fmdev = (struct fmdev *)arg; + +if (skb ==NULL ) { +fmerr ("Invalid SKB received from ST\n" ); +return -EFAULT ; + } + +if (skb->cb[0 ] !=FM_PKT_LOGICAL_CHAN_NUMBER ) { +fmerr ("Received SKB (%p) is not FM Channel 8 pkt\n" , skb); +return -EINVAL ; + } + +memcpy (skb_push (skb,1 ), &skb->cb[0 ],1 ); +skb_queue_tail (&fmdev->rx_q, skb); +tasklet_schedule (&fmdev->rx_task); + +return 0 ; +} + +/* +* Called by ST layer to indicate protocol registration completion +* status. +*/ +static void fm_st_reg_comp_cb (void *arg,char data) +{ +struct fmdev *fmdev; + + fmdev = (struct fmdev *)arg; + fmdev->streg_cbdata = data; +complete (&wait_for_fmdrv_reg_comp); +} + +/* +* This function will be called from FM V4L2 open function. +* Register with ST driver and initialize driver data. +*/ +u32 fmc_prepare (struct fmdev *fmdev) +{ +static struct st_proto_s fm_st_proto; +u32 ret =0 ; + +if (test_bit (FM_CORE_READY , &fmdev->flag)) { +fmdbg ("FM Core is already up\n" ); +return ret; + } + +memset (&fm_st_proto,0 ,sizeof (fm_st_proto)); + fm_st_proto.type =ST_FM ; + fm_st_proto.recv = fm_st_receive; + fm_st_proto.match_packet =NULL ; + fm_st_proto.reg_complete_cb = fm_st_reg_comp_cb; + fm_st_proto.write =NULL ;/* TI ST driver will fill write pointer */ + fm_st_proto.priv_data = fmdev; + + ret =st_register (&fm_st_proto); +if (ret == -EINPROGRESS ) { +init_completion (&wait_for_fmdrv_reg_comp); + fmdev->streg_cbdata = -EINPROGRESS ; +fmdbg ("%s waiting for ST reg completion signal\n" ,__func__); + + ret =wait_for_completion_timeout (&wait_for_fmdrv_reg_comp, +FM_ST_REG_TIMEOUT ); + +if (!ret) { +fmerr ("Timeout(%d sec), didn't get reg " +"completion signal from ST\n" , +jiffies_to_msecs (FM_ST_REG_TIMEOUT ) /1000 ); +return -ETIMEDOUT ; + } +if (fmdev->streg_cbdata !=0 ) { +fmerr ("ST reg comp CB called with error " +"status %d\n" , fmdev->streg_cbdata); +return -EAGAIN ; + } + + ret =0 ; + }else if (ret ==-1 ) { +fmerr ("st_register failed %d\n" , ret); +return -EAGAIN ; + } + +if (fm_st_proto.write !=NULL ) { + g_st_write = fm_st_proto.write; + }else { +fmerr ("Failed to get ST write func pointer\n" ); + ret =st_unregister (ST_FM ); +if (ret <0 ) +fmerr ("st_unregister failed %d\n" , ret); +return -EAGAIN ; + } + +spin_lock_init (&fmdev->rds_buff_lock); +spin_lock_init (&fmdev->resp_skb_lock); + +/* Initialize TX queue and TX tasklet */ +skb_queue_head_init (&fmdev->tx_q); +tasklet_init (&fmdev->tx_task, send_tasklet, (unsigned long )fmdev); + +/* Initialize RX Queue and RX tasklet */ +skb_queue_head_init (&fmdev->rx_q); +tasklet_init (&fmdev->rx_task, recv_tasklet, (unsigned long )fmdev); + + fmdev->irq_info.stage =0 ; +atomic_set (&fmdev->tx_cnt,1 ); + fmdev->resp_comp =NULL ; + +init_timer (&fmdev->irq_info.timer); + fmdev->irq_info.timer.function = &int_timeout_handler; + fmdev->irq_info.timer.data = (unsigned long )fmdev; +/*TODO: add FM_STIC_EVENT later */ + fmdev->irq_info.mask =FM_MAL_EVENT ; + +/* Region info */ +memcpy (&fmdev->rx.region, ®ion_configs[default_radio_region], +sizeof (struct region_info )); + + fmdev->rx.mute_mode =FM_MUTE_OFF ; + fmdev->rx.rf_depend_mute =FM_RX_RF_DEPENDENT_MUTE_OFF ; + fmdev->rx.rds.flag =FM_RDS_DISABLE ; + fmdev->rx.freq =FM_UNDEFINED_FREQ ; + fmdev->rx.rds_mode =FM_RDS_SYSTEM_RDS ; + fmdev->rx.af_mode =FM_RX_RDS_AF_SWITCH_MODE_OFF ; + fmdev->irq_info.retry =0 ; + +fm_rx_reset_rds_cache (fmdev); +init_waitqueue_head (&fmdev->rx.rds.read_queue); + +fm_rx_reset_station_info (fmdev); +set_bit (FM_CORE_READY , &fmdev->flag); + +return ret; +} + +/* +* This function will be called from FM V4L2 release function. +* Unregister from ST driver. +*/ +u32 fmc_release (struct fmdev *fmdev) +{ +u32 ret; + +if (!test_bit (FM_CORE_READY , &fmdev->flag)) { +fmdbg ("FM Core is already down\n" ); +return 0 ; + } +/* Sevice pending read */ +wake_up_interruptible (&fmdev->rx.rds.read_queue); + +tasklet_kill (&fmdev->tx_task); +tasklet_kill (&fmdev->rx_task); + +skb_queue_purge (&fmdev->tx_q); +skb_queue_purge (&fmdev->rx_q); + + fmdev->resp_comp =NULL ; + fmdev->rx.freq =0 ; + + ret =st_unregister (ST_FM ); +if (ret <0 ) +fmerr ("Failed to de-register FM from ST %d\n" , ret); +else +fmdbg ("Successfully unregistered from ST\n" ); + +clear_bit (FM_CORE_READY , &fmdev->flag); +return ret; +} + +/* +* Module init function. Ask FM V4L module to register video device. +* Allocate memory for FM driver context and RX RDS buffer. +*/ +static int __init fm_drv_init (void ) +{ +struct fmdev *fmdev =NULL ; +u32 ret = -ENOMEM ; + +fmdbg ("FM driver version %s\n" ,FM_DRV_VERSION ); + + fmdev =kzalloc (sizeof (struct fmdev ),GFP_KERNEL ); +if (NULL == fmdev) { +fmerr ("Can't allocate operation structure memory\n" ); +return ret; + } + fmdev->rx.rds.buf_size = default_rds_buf *FM_RDS_BLK_SIZE ; + fmdev->rx.rds.buff =kzalloc (fmdev->rx.rds.buf_size,GFP_KERNEL ); +if (NULL == fmdev->rx.rds.buff) { +fmerr ("Can't allocate rds ring buffer\n" ); + goto rel_dev; + } + + ret =fm_v4l2_init_video_device (fmdev, radio_nr); +if (ret <0 ) + goto rel_rdsbuf; + + fmdev->irq_info.handlers = int_handler_table; + fmdev->curr_fmmode =FM_MODE_OFF ; + fmdev->tx_data.pwr_lvl =FM_PWR_LVL_DEF ; + fmdev->tx_data.preemph =FM_TX_PREEMPH_50US ; +return ret; + +rel_rdsbuf: +kfree (fmdev->rx.rds.buff); +rel_dev: +kfree (fmdev); + +return ret; +} + +/* Module exit function. Ask FM V4L module to unregister video device */ +static void __exit fm_drv_exit(void) +{ +struct fmdev *fmdev =NULL ; + + fmdev =fm_v4l2_deinit_video_device (); +if (fmdev !=NULL ) { +kfree (fmdev->rx.rds.buff); +kfree (fmdev); + } +} + +module_init (fm_drv_init); +module_exit (fm_drv_exit); + +/* ------------- Module Info ------------- */ +MODULE_AUTHOR ("Manjunatha Halli <[email protected]>" ); +MODULE_DESCRIPTION ("FM Driver for TI's Connectivity chip. " FM_DRV_VERSION ); +MODULE_VERSION (FM_DRV_VERSION ); +MODULE_LICENSE ("GPL" );
drivers/media/radio/wl128x/fmdrv_common.h new file +402 -0
402 lines not on this page · raw message
Signature · 1 line
1.5.6.3
RFC v9 4/7 drivers:media:radio: wl128x: FM driver RX sources
From: Manjunatha Halli <[email protected]>
This has implementation for FM RX functionality. It communicates with FM V4l2 module and FM common module
--- drivers/media/radio/wl128x/fmdrv_rx.c | 876 +++++++++++++++++++++++++++++++++ drivers/media/radio/wl128x/fmdrv_rx.h | 59 +++ 2 files changed, 935 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/fmdrv_rx.c create mode 100644 drivers/media/radio/wl128x/fmdrv_rx.h
drivers/media/radio/wl128x/fmdrv_rx.c new file +876 -0
@@ -0,0 +1,876 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* This sub-module of FM driver implements FM RX functionality. +* +* Copyright (C) 2011 Texas Instruments +* Author: Raja Mani <[email protected]> +* Author: Manjunatha Halli <[email protected]> +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#include "fmdrv.h" +#include "fmdrv_common.h" +#include "fmdrv_rx.h" + +void fm_rx_reset_rds_cache (struct fmdev *fmdev) +{ + fmdev->rx.rds.flag =FM_RDS_DISABLE ; + fmdev->rx.rds.last_blk_idx =0 ; + fmdev->rx.rds.wr_idx =0 ; + fmdev->rx.rds.rd_idx =0 ; + +if (fmdev->rx.af_mode ==FM_RX_RDS_AF_SWITCH_MODE_ON ) + fmdev->irq_info.mask |=FM_LEV_EVENT ; +} + +void fm_rx_reset_station_info (struct fmdev *fmdev) +{ + fmdev->rx.stat_info.picode =FM_NO_PI_CODE ; + fmdev->rx.stat_info.afcache_size =0 ; + fmdev->rx.stat_info.af_list_max =0 ; +} + +u32 fm_rx_set_freq (struct fmdev *fmdev,u32 freq) +{ +unsigned long timeleft; +u16 payload, curr_frq, frq_index, intr_flag; +u32 curr_frq_in_khz; +u32 ret, resp_len; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (freq < fmdev->rx.region.bot_freq || freq > fmdev->rx.region.top_freq) { +fmerr ("Invalid frequency %d\n" , freq); +return -EINVAL ; + } + +/* Set audio enable */ + payload =FM_RX_AUDIO_ENABLE_I2S_AND_ANALOG ; + + ret =fmc_send_cmd (fmdev,AUDIO_ENABLE_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Set hilo to automatic selection */ + payload =FM_RX_IFFREQ_HILO_AUTOMATIC ; + ret =fmc_send_cmd (fmdev,HILO_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Calculate frequency index to write */ + frq_index = (freq - fmdev->rx.region.bot_freq) /FM_FREQ_MUL ; + +/* Set frequency index */ + payload = frq_index; + ret =fmc_send_cmd (fmdev,FREQ_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Read flags - just to clear any pending interrupts if we had */ + ret =fmc_send_cmd (fmdev,FLAG_GET ,REG_RD ,NULL ,2 ,NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Enable FR, BL interrupts */ + intr_flag = fmdev->irq_info.mask; + fmdev->irq_info.mask = (FM_FR_EVENT |FM_BL_EVENT ); + payload = fmdev->irq_info.mask; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Start tune */ + payload =FM_TUNER_PRESET_MODE ; + ret =fmc_send_cmd (fmdev,TUNER_MODE_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) + goto exit; + +/* Wait for tune ended interrupt */ +init_completion (&fmdev->maintask_comp); + timeleft =wait_for_completion_timeout (&fmdev->maintask_comp, +FM_DRV_TX_TIMEOUT ); +if (!timeleft) { +fmerr ("Timeout(%d sec),didn't get tune ended int\n" , +jiffies_to_msecs (FM_DRV_TX_TIMEOUT ) /1000 ); + ret = -ETIMEDOUT ; + goto exit; + } + +/* Read freq back to confirm */ + ret =fmc_send_cmd (fmdev,FREQ_SET ,REG_RD ,NULL ,2 , &curr_frq, &resp_len); +if (ret <0 ) + goto exit; + + curr_frq =be16_to_cpu (curr_frq); + curr_frq_in_khz = (fmdev->rx.region.bot_freq + ((u32 )curr_frq *FM_FREQ_MUL )); + +if (curr_frq_in_khz != freq) { +pr_info ("Frequency is set to (%d) but " +"requested freq is (%d)\n" , curr_frq_in_khz, freq); + } + +/* Update local cache */ + fmdev->rx.freq = curr_frq_in_khz; +exit: +/* Re-enable default FM interrupts */ + fmdev->irq_info.mask = intr_flag; + payload = fmdev->irq_info.mask; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Reset RDS cache and current station pointers */ +fm_rx_reset_rds_cache (fmdev); +fm_rx_reset_station_info (fmdev); + +/* Do we need to reset anything else? */ + +return ret; +} + +static u32 fm_rx_set_channel_spacing (struct fmdev *fmdev,u32 spacing) +{ +u16 payload; +u32 ret; + +if (spacing >0 && spacing <=50000 ) + spacing =FM_CHANNEL_SPACING_50KHZ ; +else if (spacing >50000 && spacing <=100000 ) + spacing =FM_CHANNEL_SPACING_100KHZ ; +else + spacing =FM_CHANNEL_SPACING_200KHZ ; + +/* set channel spacing */ + payload = spacing; + ret =fmc_send_cmd (fmdev,CHANL_BW_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->rx.region.chanl_space = spacing *FM_FREQ_MUL ; + +return ret; +} + +u32 fm_rx_seek (struct fmdev *fmdev,u32 seek_upward, +u32 wrap_around,u32 spacing) +{ +u32 resp_len; +u16 curr_frq, next_frq, last_frq; +u16 payload, int_reason, intr_flag; +u16 offset, space_idx; +unsigned long timeleft; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +/* Set channel spacing */ + ret =fm_rx_set_channel_spacing (fmdev, spacing); +if (ret <0 ) { +fmerr ("Failed to set channel spacing\n" ); +return ret; + } + +/* Read the current frequency from chip */ + ret =fmc_send_cmd (fmdev,FREQ_SET ,REG_RD ,NULL , +sizeof (curr_frq), &curr_frq, &resp_len); +if (ret <0 ) +return ret; + + curr_frq =be16_to_cpu (curr_frq); + last_frq = (fmdev->rx.region.top_freq - fmdev->rx.region.bot_freq) /FM_FREQ_MUL ; + +/* Check the offset in order to be aligned to the channel spacing*/ + space_idx = fmdev->rx.region.chanl_space /FM_FREQ_MUL ; + offset = curr_frq % space_idx; + + next_frq = seek_upward ? curr_frq + space_idx/* Seek Up */ : + curr_frq - space_idx/* Seek Down */ ; + +/* +* Add or subtract offset in order to stay aligned to the channel +* spacing. +*/ +if ((short )next_frq <0 ) + next_frq = last_frq - offset; +else if (next_frq > last_frq) + next_frq =0 + offset; + +again: +/* Set calculated next frequency to perform seek */ + payload = next_frq; + ret =fmc_send_cmd (fmdev,FREQ_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Set search direction (0:Seek Down, 1:Seek Up) */ + payload = (seek_upward ?FM_SEARCH_DIRECTION_UP :FM_SEARCH_DIRECTION_DOWN ); + ret =fmc_send_cmd (fmdev,SEARCH_DIR_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Read flags - just to clear any pending interrupts if we had */ + ret =fmc_send_cmd (fmdev,FLAG_GET ,REG_RD ,NULL ,2 ,NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Enable FR, BL interrupts */ + intr_flag = fmdev->irq_info.mask; + fmdev->irq_info.mask = (FM_FR_EVENT |FM_BL_EVENT ); + payload = fmdev->irq_info.mask; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Start seek */ + payload =FM_TUNER_AUTONOMOUS_SEARCH_MODE ; + ret =fmc_send_cmd (fmdev,TUNER_MODE_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Wait for tune ended/band limit reached interrupt */ +init_completion (&fmdev->maintask_comp); + timeleft =wait_for_completion_timeout (&fmdev->maintask_comp, +FM_DRV_RX_SEEK_TIMEOUT ); +if (!timeleft) { +fmerr ("Timeout(%d sec),didn't get tune ended int\n" , +jiffies_to_msecs (FM_DRV_RX_SEEK_TIMEOUT ) /1000 ); +return -ETIMEDOUT ; + } + + int_reason = fmdev->irq_info.flag & (FM_TUNE_COMPLETE |FM_BAND_LIMIT ); + +/* Re-enable default FM interrupts */ + fmdev->irq_info.mask = intr_flag; + payload = fmdev->irq_info.mask; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +if (int_reason &FM_BL_EVENT ) { +if (wrap_around ==0 ) { + fmdev->rx.freq = seek_upward ? + fmdev->rx.region.top_freq : + fmdev->rx.region.bot_freq; + }else { + fmdev->rx.freq = seek_upward ? + fmdev->rx.region.bot_freq : + fmdev->rx.region.top_freq; +/* Calculate frequency index to write */ + next_frq = (fmdev->rx.freq - + fmdev->rx.region.bot_freq) /FM_FREQ_MUL ; + goto again; + } + }else { +/* Read freq to know where operation tune operation stopped */ + ret =fmc_send_cmd (fmdev,FREQ_SET ,REG_RD ,NULL ,2 , + &curr_frq, &resp_len); +if (ret <0 ) +return ret; + + curr_frq =be16_to_cpu (curr_frq); + fmdev->rx.freq = (fmdev->rx.region.bot_freq + + ((u32 )curr_frq *FM_FREQ_MUL )); + + } +/* Reset RDS cache and current station pointers */ +fm_rx_reset_rds_cache (fmdev); +fm_rx_reset_station_info (fmdev); + +return ret; +} + +u32 fm_rx_set_volume (struct fmdev *fmdev,u16 vol_to_set) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (vol_to_set <FM_RX_VOLUME_MIN || vol_to_set >FM_RX_VOLUME_MAX ) { +fmerr ("Volume is not within(%d-%d) range\n" , +FM_RX_VOLUME_MIN ,FM_RX_VOLUME_MAX ); +return -EINVAL ; + } + vol_to_set *=FM_RX_VOLUME_GAIN_STEP ; + + payload = vol_to_set; + ret =fmc_send_cmd (fmdev,VOLUME_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->rx.volume = vol_to_set; +return ret; +} + +/* Get volume */ +u32 fm_rx_get_volume (struct fmdev *fmdev,u16 *curr_vol) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (curr_vol ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *curr_vol = fmdev->rx.volume /FM_RX_VOLUME_GAIN_STEP ; + +return 0 ; +} + +/* To get current band's bottom and top frequency */ +u32 fm_rx_get_currband_freq_range (struct fmdev *fmdev,u32 *bot_freq,u32 *top_freq) +{ +if (bot_freq !=NULL ) + *bot_freq = fmdev->rx.region.bot_freq; + +if (top_freq !=NULL ) + *top_freq = fmdev->rx.region.top_freq; + +return 0 ; +} + +/* Returns current band index (0-Europe/US; 1-Japan) */ +void fm_rx_get_region (struct fmdev *fmdev,u8 *region) +{ + *region = fmdev->rx.region.fm_band; +} + +/* Sets band (0-Europe/US; 1-Japan) */ +u32 fm_rx_set_region (struct fmdev *fmdev,u8 region_to_set) +{ +u16 payload; +u32 new_frq =0 ; +u32 ret = -EPERM ; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return ret; + +if (region_to_set !=FM_BAND_EUROPE_US && + region_to_set !=FM_BAND_JAPAN ) { +fmerr ("Invalid band\n" ); +return -EINVAL ; + } + +if (fmdev->rx.region.fm_band == region_to_set) { +fmerr ("Requested band is already configured\n" ); +return ret; + } + +/* Send cmd to set the band */ + payload = (u16 )region_to_set; + ret =fmc_send_cmd (fmdev,BAND_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +fmc_update_region_info (fmdev, region_to_set); + +/* Check whether current RX frequency is within band boundary */ +if (fmdev->rx.freq < fmdev->rx.region.bot_freq) + new_frq = fmdev->rx.region.bot_freq; +else if (fmdev->rx.freq > fmdev->rx.region.top_freq) + new_frq = fmdev->rx.region.top_freq; + +if (new_frq) { +fmdbg ("Current freq is not within band limit boundary," +"switching to %d KHz\n" , new_frq); +/* Current RX frequency is not in range. So, update it */ + ret =fm_rx_set_freq (fmdev, new_frq); + } + +return ret; +} + +/* Reads current mute mode (Mute Off/On/Attenuate)*/ +u32 fm_rx_get_mute_mode (struct fmdev *fmdev,u8 *curr_mute_mode) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (curr_mute_mode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *curr_mute_mode = fmdev->rx.mute_mode; + +return 0 ; +} + +static u32 fm_config_rx_mute_reg (struct fmdev *fmdev) +{ +u16 payload, muteval; +u32 ret; + + muteval =0 ; +switch (fmdev->rx.mute_mode) { +case FM_MUTE_ON : + muteval =FM_RX_AC_MUTE_MODE ; +break ; + +case FM_MUTE_OFF : + muteval =FM_RX_UNMUTE_MODE ; +break ; + +case FM_MUTE_ATTENUATE : + muteval =FM_RX_SOFT_MUTE_FORCE_MODE ; +break ; + } +if (fmdev->rx.rf_depend_mute ==FM_RX_RF_DEPENDENT_MUTE_ON ) + muteval |=FM_RX_RF_DEP_MODE ; +else + muteval &= ~FM_RX_RF_DEP_MODE ; + + payload = muteval; + ret =fmc_send_cmd (fmdev,MUTE_STATUS_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +/* Configures mute mode (Mute Off/On/Attenuate) */ +u32 fm_rx_set_mute_mode (struct fmdev *fmdev,u8 mute_mode_toset) +{ +u8 org_state; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (fmdev->rx.mute_mode == mute_mode_toset) +return 0 ; + + org_state = fmdev->rx.mute_mode; + fmdev->rx.mute_mode = mute_mode_toset; + + ret =fm_config_rx_mute_reg (fmdev); +if (ret <0 ) { + fmdev->rx.mute_mode = org_state; +return ret; + } + +return 0 ; +} + +/* Gets RF dependent soft mute mode enable/disable status */ +u32 fm_rx_get_rfdepend_softmute (struct fmdev *fmdev,u8 *curr_mute_mode) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (curr_mute_mode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *curr_mute_mode = fmdev->rx.rf_depend_mute; + +return 0 ; +} + +/* Sets RF dependent soft mute mode */ +u32 fm_rx_set_rfdepend_softmute (struct fmdev *fmdev,u8 rfdepend_mute) +{ +u8 org_state; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (rfdepend_mute !=FM_RX_RF_DEPENDENT_MUTE_ON && + rfdepend_mute !=FM_RX_RF_DEPENDENT_MUTE_OFF ) { +fmerr ("Invalid RF dependent soft mute\n" ); +return -EINVAL ; + } +if (fmdev->rx.rf_depend_mute == rfdepend_mute) +return 0 ; + + org_state = fmdev->rx.rf_depend_mute; + fmdev->rx.rf_depend_mute = rfdepend_mute; + + ret =fm_config_rx_mute_reg (fmdev); +if (ret <0 ) { + fmdev->rx.rf_depend_mute = org_state; +return ret; + } + +return 0 ; +} + +/* Returns the signal strength level of current channel */ +u32 fm_rx_get_rssi_level (struct fmdev *fmdev,u16 *rssilvl) +{ +u16 curr_rssi_lel; +u32 resp_len; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (rssilvl ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } +/* Read current RSSI level */ + ret =fmc_send_cmd (fmdev,RSSI_LVL_GET ,REG_RD ,NULL ,2 , + &curr_rssi_lel, &resp_len); +if (ret <0 ) +return ret; + + *rssilvl =be16_to_cpu (curr_rssi_lel); + +return 0 ; +} + +/* +* Sets the signal strength level that once reached +* will stop the auto search process +*/ +u32 fm_rx_set_rssi_threshold (struct fmdev *fmdev,short rssi_lvl_toset) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (rssi_lvl_toset <FM_RX_RSSI_THRESHOLD_MIN || + rssi_lvl_toset >FM_RX_RSSI_THRESHOLD_MAX ) { +fmerr ("Invalid RSSI threshold level\n" ); +return -EINVAL ; + } + payload = (u16 )rssi_lvl_toset; + ret =fmc_send_cmd (fmdev,SEARCH_LVL_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->rx.rssi_threshold = rssi_lvl_toset; +return 0 ; +} + +/* Returns current RX RSSI threshold value */ +u32 fm_rx_get_rssi_threshold (struct fmdev *fmdev,short *curr_rssi_lvl) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (curr_rssi_lvl ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *curr_rssi_lvl = fmdev->rx.rssi_threshold; + +return 0 ; +} + +/* Sets RX stereo/mono modes */ +u32 fm_rx_set_stereo_mono (struct fmdev *fmdev,u16 mode) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (mode !=FM_STEREO_MODE && mode !=FM_MONO_MODE ) { +fmerr ("Invalid mode\n" ); +return -EINVAL ; + } + +/* Set stereo/mono mode */ + payload = (u16 )mode; + ret =fmc_send_cmd (fmdev,MOST_MODE_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Set stereo blending mode */ + payload =FM_STEREO_SOFT_BLEND ; + ret =fmc_send_cmd (fmdev,MOST_BLEND_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +/* Gets current RX stereo/mono mode */ +u32 fm_rx_get_stereo_mono (struct fmdev *fmdev,u16 *mode) +{ +u16 curr_mode; +u32 ret, resp_len; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (mode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + ret =fmc_send_cmd (fmdev,MOST_MODE_SET ,REG_RD ,NULL ,2 , + &curr_mode, &resp_len); +if (ret <0 ) +return ret; + + *mode =be16_to_cpu (curr_mode); + +return 0 ; +} + +/* Choose RX de-emphasis filter mode (50us/75us) */ +u32 fm_rx_set_deemphasis_mode (struct fmdev *fmdev,u16 mode) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (mode !=FM_RX_EMPHASIS_FILTER_50_USEC && + mode !=FM_RX_EMPHASIS_FILTER_75_USEC ) { +fmerr ("Invalid rx de-emphasis mode (%d)\n" , mode); +return -EINVAL ; + } + + payload = mode; + ret =fmc_send_cmd (fmdev,DEMPH_MODE_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->rx.deemphasis_mode = mode; +return 0 ; +} + +/* Gets current RX de-emphasis filter mode */ +u32 fm_rx_get_deemph_mode (struct fmdev *fmdev,u16 *curr_deemphasis_mode) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (curr_deemphasis_mode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *curr_deemphasis_mode = fmdev->rx.deemphasis_mode; + +return 0 ; +} + +/* Enable/Disable RX RDS */ +u32 fm_rx_set_rds_mode (struct fmdev *fmdev,u8 rds_en_dis) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (rds_en_dis !=FM_RDS_ENABLE && rds_en_dis !=FM_RDS_DISABLE ) { +fmerr ("Invalid rds option\n" ); +return -EINVAL ; + } + +if (rds_en_dis ==FM_RDS_ENABLE + && fmdev->rx.rds.flag ==FM_RDS_DISABLE ) { +/* Turn on RX RDS and RDS circuit */ + payload =FM_RX_PWR_SET_FM_AND_RDS_BLK_ON ; + ret =fmc_send_cmd (fmdev,POWER_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Clear and reset RDS FIFO */ + payload =FM_RX_RDS_FLUSH_FIFO ; + ret =fmc_send_cmd (fmdev,RDS_CNTRL_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Read flags - just to clear any pending interrupts. */ + ret =fmc_send_cmd (fmdev,FLAG_GET ,REG_RD ,NULL ,2 , +NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Set RDS FIFO threshold value */ + payload =FM_RX_RDS_FIFO_THRESHOLD ; + ret =fmc_send_cmd (fmdev,RDS_MEM_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Enable RDS interrupt */ + fmdev->irq_info.mask |=FM_RDS_EVENT ; + payload = fmdev->irq_info.mask; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) { + fmdev->irq_info.mask &= ~FM_RDS_EVENT ; +return ret; + } + +/* Update our local flag */ + fmdev->rx.rds.flag =FM_RDS_ENABLE ; + }else if (rds_en_dis ==FM_RDS_DISABLE + && fmdev->rx.rds.flag ==FM_RDS_ENABLE ) { +/* Turn off RX RDS */ + payload =FM_RX_PWR_SET_FM_ON_RDS_OFF ; + ret =fmc_send_cmd (fmdev,POWER_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Reset RDS pointers */ + fmdev->rx.rds.last_blk_idx =0 ; + fmdev->rx.rds.wr_idx =0 ; + fmdev->rx.rds.rd_idx =0 ; +fm_rx_reset_station_info (fmdev); + +/* Update RDS local cache */ + fmdev->irq_info.mask &= ~(FM_RDS_EVENT ); + fmdev->rx.rds.flag =FM_RDS_DISABLE ; + } + +return 0 ; +} + +/* Returns current RX RDS enable/disable status */ +u32 fm_rx_get_rds_mode (struct fmdev *fmdev,u8 *curr_rds_en_dis) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (curr_rds_en_dis ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *curr_rds_en_dis = fmdev->rx.rds.flag; + +return 0 ; +} + +/* Sets RDS operation mode (RDS/RDBS) */ +u32 fm_rx_set_rds_system (struct fmdev *fmdev,u8 rds_mode) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (rds_mode !=FM_RDS_SYSTEM_RDS && rds_mode !=FM_RDS_SYSTEM_RBDS ) { +fmerr ("Invalid rds mode\n" ); +return -EINVAL ; + } +/* Set RDS operation mode */ + payload = (u16 )rds_mode; + ret =fmc_send_cmd (fmdev,RDS_SYSTEM_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->rx.rds_mode = rds_mode; + +return 0 ; +} + +/* Returns current RDS operation mode */ +u32 fm_rx_get_rds_system (struct fmdev *fmdev,u8 *rds_mode) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (rds_mode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *rds_mode = fmdev->rx.rds_mode; + +return 0 ; +} + +/* Configures Alternate Frequency switch mode */ +u32 fm_rx_set_af_switch (struct fmdev *fmdev,u8 af_mode) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (af_mode !=FM_RX_RDS_AF_SWITCH_MODE_ON && + af_mode !=FM_RX_RDS_AF_SWITCH_MODE_OFF ) { +fmerr ("Invalid af mode\n" ); +return -EINVAL ; + } +/* Enable/disable low RSSI interrupt based on af_mode */ +if (af_mode ==FM_RX_RDS_AF_SWITCH_MODE_ON ) + fmdev->irq_info.mask |=FM_LEV_EVENT ; +else + fmdev->irq_info.mask &= ~FM_LEV_EVENT ; + + payload = fmdev->irq_info.mask; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->rx.af_mode = af_mode; + +return 0 ; +} + +/* Returns Alternate Frequency switch status */ +u32 fm_rx_get_af_switch (struct fmdev *fmdev,u8 *af_mode) +{ +if (fmdev->curr_fmmode !=FM_MODE_RX ) +return -EPERM ; + +if (af_mode ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + + *af_mode = fmdev->rx.af_mode; + +return 0 ; +}
drivers/media/radio/wl128x/fmdrv_rx.h new file +59 -0
59 lines not on this page · raw message
Signature · 1 line
1.5.6.3
RFC v9 5/7 drivers:media:radio: wl128x: FM driver TX sources
From: Manjunatha Halli <[email protected]>
This has implementation for FM TX functionality. It communicates with FM V4l2 module and FM common module.
--- drivers/media/radio/wl128x/fmdrv_tx.c | 433 +++++++++++++++++++++++++++++++++ drivers/media/radio/wl128x/fmdrv_tx.h | 37 +++ 2 files changed, 470 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/fmdrv_tx.c create mode 100644 drivers/media/radio/wl128x/fmdrv_tx.h
drivers/media/radio/wl128x/fmdrv_tx.c new file +433 -0
@@ -0,0 +1,433 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* This sub-module of FM driver implements FM TX functionality. +* +* Copyright (C) 2011 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#include <linux/delay.h> +#include "fmdrv.h" +#include "fmdrv_common.h" +#include "fmdrv_tx.h" + +u32 fm_tx_set_stereo_mono (struct fmdev *fmdev,u16 mode) +{ +u16 payload; +u32 ret =0 ; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + +if (fmdev->tx_data.aud_mode == mode) +return ret; + +fmdbg ("stereo mode: %d\n" , mode); + +/* Set Stereo/Mono mode */ + payload = (1 - mode); + ret =fmc_send_cmd (fmdev,MONO_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + fmdev->tx_data.aud_mode = mode; + +return ret; +} + +static u32 set_rds_text (struct fmdev *fmdev,u8 *rds_text) +{ +u16 payload; +u32 ret; + + ret =fmc_send_cmd (fmdev,RDS_DATA_SET ,REG_WR , rds_text, +strlen (rds_text),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Scroll mode */ + payload = (u16 )0x1 ; + ret =fmc_send_cmd (fmdev,DISPLAY_MODE ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +static u32 set_rds_data_mode (struct fmdev *fmdev,u8 mode) +{ +u16 payload; +u32 ret; + +/* Setting unique PI TODO: how unique? */ + payload = (u16 )0xcafe ; + ret =fmc_send_cmd (fmdev,PI_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Set decoder id */ + payload = (u16 )0xa ; + ret =fmc_send_cmd (fmdev,DI_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* TODO: RDS_MODE_GET? */ +return 0 ; +} + +static u32 set_rds_len (struct fmdev *fmdev,u8 type,u16 len) +{ +u16 payload; +u32 ret; + + len |= type <<8 ; + payload = len; + ret =fmc_send_cmd (fmdev,RDS_CONFIG_DATA_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* TODO: LENGTH_GET? */ +return 0 ; +} + +u32 fm_tx_set_rds_mode (struct fmdev *fmdev,u8 rds_en_dis) +{ +u16 payload; +u32 ret; +u8 rds_text[] ="Zoom2\n" ; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + +fmdbg ("rds_en_dis:%d(E:%d, D:%d)\n" , rds_en_dis, +FM_RDS_ENABLE ,FM_RDS_DISABLE ); + +if (rds_en_dis ==FM_RDS_ENABLE ) { +/* Set RDS length */ +set_rds_len (fmdev,0 ,strlen (rds_text)); + +/* Set RDS text */ +set_rds_text (fmdev, rds_text); + +/* Set RDS mode */ +set_rds_data_mode (fmdev,0x0 ); + } + +/* Send command to enable RDS */ +if (rds_en_dis ==FM_RDS_ENABLE ) + payload =0x01 ; +else + payload =0x00 ; + + ret =fmc_send_cmd (fmdev,RDS_DATA_ENB ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +if (rds_en_dis ==FM_RDS_ENABLE ) { +/* Set RDS length */ +set_rds_len (fmdev,0 ,strlen (rds_text)); + +/* Set RDS text */ +set_rds_text (fmdev, rds_text); + } + fmdev->tx_data.rds.flag = rds_en_dis; + +return 0 ; +} + +u32 fm_tx_set_radio_text (struct fmdev *fmdev,u8 *rds_text,u8 rds_type) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + +fm_tx_set_rds_mode (fmdev,0 ); + +/* Set RDS length */ +set_rds_len (fmdev, rds_type,strlen (rds_text)); + +/* Set RDS text */ +set_rds_text (fmdev, rds_text); + +/* Set RDS mode */ +set_rds_data_mode (fmdev,0x0 ); + + payload =1 ; + ret =fmc_send_cmd (fmdev,RDS_DATA_ENB ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +u32 fm_tx_set_af (struct fmdev *fmdev,u32 af) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + +fmdbg ("AF: %d\n" , af); + + af = (af -87500 ) /100 ; + payload = (u16 )af; + ret =fmc_send_cmd (fmdev,TA_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +u32 fm_tx_set_region (struct fmdev *fmdev,u8 region) +{ +u16 payload; +u32 ret; + +if (region !=FM_BAND_EUROPE_US && region !=FM_BAND_JAPAN ) { +fmerr ("Invalid band\n" ); +return -EINVAL ; + } + +/* Send command to set the band */ + payload = (u16 )region; + ret =fmc_send_cmd (fmdev,TX_BAND_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +u32 fm_tx_set_mute_mode (struct fmdev *fmdev,u8 mute_mode_toset) +{ +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; +fmdbg ("tx: mute mode %d\n" , mute_mode_toset); + + payload = mute_mode_toset; + ret =fmc_send_cmd (fmdev,MUTE ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +return 0 ; +} + +/* Set TX Audio I/O */ +static u32 set_audio_io (struct fmdev *fmdev) +{ +struct fmtx_data *tx = &fmdev->tx_data; +u16 payload; +u32 ret; + +/* Set Audio I/O Enable */ + payload = tx->audio_io; + ret =fmc_send_cmd (fmdev,AUDIO_IO_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* TODO: is audio set? */ +return 0 ; +} + +/* Start TX Transmission */ +static u32 enable_xmit (struct fmdev *fmdev,u8 new_xmit_state) +{ +struct fmtx_data *tx = &fmdev->tx_data; +unsigned long timeleft; +u16 payload; +u32 ret; + +/* Enable POWER_ENB interrupts */ + payload =FM_POW_ENB_EVENT ; + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Set Power Enable */ + payload = new_xmit_state; + ret =fmc_send_cmd (fmdev,POWER_ENB_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* Wait for Power Enabled */ +init_completion (&fmdev->maintask_comp); + timeleft =wait_for_completion_timeout (&fmdev->maintask_comp, +FM_DRV_TX_TIMEOUT ); +if (!timeleft) { +fmerr ("Timeout(%d sec),didn't get tune ended interrupt\n" , +jiffies_to_msecs (FM_DRV_TX_TIMEOUT ) /1000 ); +return -ETIMEDOUT ; + } + +set_bit (FM_CORE_TX_XMITING , &fmdev->flag); + tx->xmit_state = new_xmit_state; + +return 0 ; +} + +/* Set TX power level */ +u32 fm_tx_set_pwr_lvl (struct fmdev *fmdev,u8 new_pwr_lvl) +{ +u16 payload; +struct fmtx_data *tx = &fmdev->tx_data; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; +fmdbg ("tx: pwr_level_to_set %ld\n" , (long int )new_pwr_lvl); + +/* If the core isn't ready update global variable */ +if (!test_bit (FM_CORE_READY , &fmdev->flag)) { + tx->pwr_lvl = new_pwr_lvl; +return 0 ; + } + +/* Set power level: Application will specify power level value in +* units of dB/uV, whereas range and step are specific to FM chip. +* For TI's WL chips, convert application specified power level value +* to chip specific value by subtracting 122 from it. Refer to TI FM +* data sheet for details. +* */ + + payload = (FM_PWR_LVL_HIGH - new_pwr_lvl); + ret =fmc_send_cmd (fmdev,POWER_LEV_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +/* TODO: is the power level set? */ + tx->pwr_lvl = new_pwr_lvl; + +return 0 ; +} + +/* +* Sets FM TX pre-emphasis filter value (OFF, 50us, or 75us) +* Convert V4L2 specified filter values to chip specific filter values. +*/ +u32 fm_tx_set_preemph_filter (struct fmdev *fmdev,u32 preemphasis) +{ +struct fmtx_data *tx = &fmdev->tx_data; +u16 payload; +u32 ret; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + +switch (preemphasis) { +case V4L2_PREEMPHASIS_DISABLED : + payload =FM_TX_PREEMPH_OFF ; +break ; +case V4L2_PREEMPHASIS_50_uS: + payload =FM_TX_PREEMPH_50US ; +break ; +case V4L2_PREEMPHASIS_75_uS: + payload =FM_TX_PREEMPH_75US ; +break ; + } + + ret =fmc_send_cmd (fmdev,PREMPH_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + tx->preemph = payload; + +return ret; +} + +/* Get the TX tuning capacitor value.*/ +u32 fm_tx_get_tune_cap_val (struct fmdev *fmdev) +{ +u16 curr_val; +u32 ret, resp_len; + +if (fmdev->curr_fmmode !=FM_MODE_TX ) +return -EPERM ; + + ret =fmc_send_cmd (fmdev,READ_FMANT_TUNE_VALUE ,REG_RD , +NULL ,sizeof (curr_val), &curr_val, &resp_len); +if (ret <0 ) +return ret; + + curr_val =be16_to_cpu (curr_val); + +return curr_val; +} + +/* Set TX Frequency */ +u32 fm_tx_set_freq (struct fmdev *fmdev,u32 freq_to_set) +{ +struct fmtx_data *tx = &fmdev->tx_data; +u16 payload, chanl_index; +u32 ret; + +if (test_bit (FM_CORE_TX_XMITING , &fmdev->flag)) { +enable_xmit (fmdev,0 ); +clear_bit (FM_CORE_TX_XMITING , &fmdev->flag); + } + +/* Enable FR, BL interrupts */ + payload = (FM_FR_EVENT |FM_BL_EVENT ); + ret =fmc_send_cmd (fmdev,INT_MASK_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + tx->tx_frq = (unsigned long )freq_to_set; +fmdbg ("tx: freq_to_set %ld\n" , (long int )tx->tx_frq); + + chanl_index = freq_to_set /10 ; + +/* Set current tuner channel */ + payload = chanl_index; + ret =fmc_send_cmd (fmdev,CHANL_SET ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + +fm_tx_set_pwr_lvl (fmdev, tx->pwr_lvl); +fm_tx_set_preemph_filter (fmdev, tx->preemph); + + tx->audio_io =0x01 ;/* I2S */ +set_audio_io (fmdev); + +enable_xmit (fmdev,0x01 );/* Enable transmission */ + + tx->aud_mode =FM_STEREO_MODE ; + tx->rds.flag =FM_RDS_DISABLE ; + +return 0 ; +} +
drivers/media/radio/wl128x/fmdrv_tx.h new file +37 -0
@@ -0,0 +1,37 @@ +/* +* FM Driver for Connectivity chip of Texas Instruments. +* FM TX module header. +* +* Copyright (C) 2011 Texas Instruments +* +* This program is free software; you can redistribute it and/or modify +* it under the terms of the GNU General Public License version 2 as +* published by the Free Software Foundation. +* +* 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 +* +*/ + +#ifndef _FMDRV_TX_H +#define _FMDRV_TX_H + +u32 fm_tx_set_freq (struct fmdev *,u32 ); +u32 fm_tx_set_pwr_lvl (struct fmdev *,u8 ); +u32 fm_tx_set_region (struct fmdev *,u8 ); +u32 fm_tx_set_mute_mode (struct fmdev *,u8 ); +u32 fm_tx_set_stereo_mono (struct fmdev *,u16 ); +u32 fm_tx_set_rds_mode (struct fmdev *,u8 ); +u32 fm_tx_set_radio_text (struct fmdev *,u8 *,u8 ); +u32 fm_tx_set_af (struct fmdev *,u32 ); +u32 fm_tx_set_preemph_filter (struct fmdev *,u32 ); +u32 fm_tx_get_tune_cap_val (struct fmdev *); + +#endif +
Signature · 1 line
1.5.6.3
RFC v9 6/7 drivers:media:radio: wl128x: Kconfig & Makefile for wl128x driver
From: Manjunatha Halli <[email protected]>
--- drivers/media/radio/wl128x/Kconfig | 17 +++++++++++++++++ drivers/media/radio/wl128x/Makefile | 6 ++++++ 2 files changed, 23 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/Kconfig create mode 100644 drivers/media/radio/wl128x/Makefile
drivers/media/radio/wl128x/Kconfig new file +17 -0
@@ -0,0 +1,17 @@ +# +# TI's wl128x FM driver based on TI's ST driver. +# +menu "Texas Instruments WL128x FM driver (ST based)" +config RADIO_WL128X + tristate "Texas Instruments WL128x FM Radio" + depends on VIDEO_V4L2 && RFKILL + select TI_ST + help + Choose Y here if you have this FM radio chip. + + In order to control your radio card, you will need to use programs + that are compatible with the Video For Linux 2 API. Information on + this API and pointers to "v4l2" programs may be found at + <file:Documentation/video4linux/API.html>. + +endmenu
drivers/media/radio/wl128x/Makefile new file +6 -0
@@ -0,0 +1,6 @@ +# +# Makefile for TI's shared transport driver based wl128x +# FM radio. +# +obj-$(CONFIG_RADIO_WL128X) += fm_drv.o +fm_drv-objs := fmdrv_common.o fmdrv_rx.o fmdrv_tx.o fmdrv_v4l2.o
Signature · 1 line
1.5.6.3
RFC v9 7/7 drivers:media:radio: Update Kconfig and Makefile for wl128x FM driver.
From: Manjunatha Halli <[email protected]>
--- drivers/media/radio/Kconfig | 3 +++ drivers/media/radio/Makefile | 1 + 2 files changed, 4 insertions(+), 0 deletions(-)
drivers/media/radio/Kconfig +3 -0
@@ -452,4 +452,7 @@ config RADIO_TIMBERDALE found behind the Timberdale FPGA on the Russellville board. Enabling this driver will automatically select the DSP and tuner. +# TI's ST based wl128x FM radio +source "drivers/media/radio/wl128x/Kconfig" + endif # RADIO_ADAPTERS
drivers/media/radio/Makefile +1 -0
@@ -26,5 +26,6 @@ obj-$(CONFIG_RADIO_TEA5764) += radio-tea5764.o obj-$(CONFIG_RADIO_SAA7706H) += saa7706h.o obj-$(CONFIG_RADIO_TEF6862) += tef6862.o obj-$(CONFIG_RADIO_TIMBERDALE) += radio-timb.o +obj-$(CONFIG_RADIO_WL128X) += wl128x/ EXTRA_CFLAGS += -Isound
Signature · 1 line
1.5.6.3
Re: [RFC V9 3/7] drivers:media:radio: wl128x: FM Driver Common sources
In reply to [email protected]Hi Manjunatha,
Thanks for all the work, it looks much better now!
I found a few little things here, but otherwise you can stick a
tag in the whole driver series.
Quoted 21 lines · On Monday, January 10, 2011 14:04:56 [email protected] wrote:
From: Manjunatha Halli <[email protected]>
These are the sources for the common interfaces required by the FM V4L2 driver for TI WL127x and WL128x chips.
These implement the FM channel-8 protocol communication with the chip. This makes use of the Shared Transport as its transport.
Signed-off-by Manjunatha Halli <[email protected]>--- drivers/media/radio/wl128x/fmdrv_common.c | 1693 +++++++++++++++++++++++++++++ drivers/media/radio/wl128x/fmdrv_common.h | 402 +++++++ 2 files changed, 2095 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/wl128x/fmdrv_common.c create mode 100644 drivers/media/radio/wl128x/fmdrv_common.hdrivers/media/radio/wl128x/fmdrv_common.c new file +0
-0
<snip>
drivers/media/radio/wl128x/fmdrv_common.c line 1121
Quoted 6 lines
drivers/media/radio/wl128x/fmdrv_common.c new file +6
-0+u32 fmc_set_freq (struct fmdev *fmdev,u32 freq_to_set) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_freq (fmdev, freq_to_set); +break ;
'break' after a 'return' can be removed. This is repeated several times.
Quoted 113 lines
drivers/media/radio/wl128x/fmdrv_common.c new file +113
-0+ +case FM_MODE_TX : +return fm_tx_set_freq (fmdev, freq_to_set); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_get_freq (struct fmdev *fmdev,u32 *cur_tuned_frq) +{ +if (fmdev->rx.freq ==FM_UNDEFINED_FREQ ) { +fmerr ("RX frequency is not set\n" ); +return -EPERM ; + } +if (cur_tuned_frq ==NULL ) { +fmerr ("Invalid memory\n" ); +return -ENOMEM ; + } + +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : + *cur_tuned_frq = fmdev->rx.freq; +break ; + +case FM_MODE_TX : + *cur_tuned_frq =0 ;/* TODO : Change this later */ +break ; + +default : +return -EINVAL ; + } + +return 0 ; +} + +u32 fmc_set_region (struct fmdev *fmdev,u8 region_to_set) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_region (fmdev, region_to_set); +break ; + +case FM_MODE_TX : +return fm_tx_set_region (fmdev, region_to_set); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_set_mute_mode (struct fmdev *fmdev,u8 mute_mode_toset) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_mute_mode (fmdev, mute_mode_toset); +break ; + +case FM_MODE_TX : +return fm_tx_set_mute_mode (fmdev, mute_mode_toset); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_set_stereo_mono (struct fmdev *fmdev,u16 mode) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_stereo_mono (fmdev, mode); +break ; + +case FM_MODE_TX : +return fm_tx_set_stereo_mono (fmdev, mode); +break ; + +default : +return -EINVAL ; + } +} + +u32 fmc_set_rds_mode (struct fmdev *fmdev,u8 rds_en_dis) +{ +switch (fmdev->curr_fmmode) { +case FM_MODE_RX : +return fm_rx_set_rds_mode (fmdev, rds_en_dis); +break ; + +case FM_MODE_TX : +return fm_tx_set_rds_mode (fmdev, rds_en_dis); +break ; + +default : +return -EINVAL ; + } +} + +/* Sends power off command to the chip */ +static u32 fm_power_down (struct fmdev *fmdev) +{ +u16 payload; +u32 ret =0 ; + +if (!test_bit (FM_CORE_READY , &fmdev->flag)) { +fmerr ("FM core is not ready\n" ); +return -EPERM ; + } +if (fmdev->curr_fmmode ==FM_MODE_OFF ) { +fmdbg ("FM chip is already in OFF state\n" );
drivers/media/radio/wl128x/fmdrv_common.c line 1244
Quoted 10 lines
drivers/media/radio/wl128x/fmdrv_common.c new file +10
-0+return ret; + } + + payload =0x0 ; + ret =fmc_send_cmd (fmdev,FM_POWER_MODE ,REG_WR , &payload, +sizeof (payload),NULL ,NULL ); +if (ret <0 ) +return ret; + + ret =fmc_release (fmdev);
Just do 'return fmc_release(fmdev);' here.
Quoted 52 lines
drivers/media/radio/wl128x/fmdrv_common.c new file +52
-0+ +return ret; +} + +/* Reads init command from FM firmware file and loads to the chip */ +static u32 fm_download_firmware (struct fmdev *fmdev,const u8 *fw_name) +{ +const struct firmware *fw_entry; +struct bts_header *fw_header; +struct bts_action *action; +struct bts_action_delay *delay; +u8 *fw_data; +int ret, fw_len, cmd_cnt; + + cmd_cnt =0 ; +set_bit (FM_FW_DW_INPROGRESS , &fmdev->flag); + + ret =request_firmware (&fw_entry, fw_name, + &fmdev->radio_dev->dev); +if (ret <0 ) { +fmerr ("Unable to read firmware(%s) content\n" , fw_name); +return ret; + } +fmdbg ("Firmware(%s) length : %d bytes\n" , fw_name, fw_entry->size); + + fw_data = (void *)fw_entry->data; + fw_len = fw_entry->size; + + fw_header = (struct bts_header *)fw_data; +if (fw_header->magic !=FM_FW_FILE_HEADER_MAGIC ) { +fmerr ("%s not a legal TI firmware file\n" , fw_name); + ret = -EINVAL ; + goto rel_fw; + } +fmdbg ("FW(%s) magic number : 0x%x\n" , fw_name, fw_header->magic); + +/* Skip file header info , we already verified it */ + fw_data +=sizeof (struct bts_header ); + fw_len -=sizeof (struct bts_header ); + +while (fw_data && fw_len >0 ) { + action = (struct bts_action *)fw_data; + +switch (action->type) { +case ACTION_SEND_COMMAND :/* Send */ +if (fmc_send_cmd (fmdev,0 ,0 , action->data, + action->size,NULL ,NULL )) + goto rel_fw; + + cmd_cnt++; +break ; +
drivers/media/radio/wl128x/fmdrv_common.c line 1306
Quoted 10 lines
drivers/media/radio/wl128x/fmdrv_common.c new file +10
-0+case ACTION_DELAY :/* Delay */ + delay = (struct bts_action_delay *)action->data; +mdelay (delay->msec); +break ; + } + + fw_data += (sizeof (struct bts_action ) + (action->size)); + fw_len -= (sizeof (struct bts_action ) + (action->size)); + } +fmdbg ("Firmare commands(%d) loaded to chip\n" , cmd_cnt);
Firmare -> Firmware
drivers/media/radio/wl128x/fmdrv_common.c line 1312
Quoted 6 lines
drivers/media/radio/wl128x/fmdrv_common.c new file +6
-0+rel_fw: +release_firmware (fw_entry); +clear_bit (FM_FW_DW_INPROGRESS , &fmdev->flag); + +return ret; +}
<snip>
Regards,
Hans
Signature · 1 line
Hans Verkuil - video4linux developer - sponsored by Cisco