* [PATCH v9 0/4] FM Radio driver.
@ 2010-08-30 11:38 Matti J. Aaltonen
2010-08-30 11:38 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Matti J. Aaltonen
` (2 more replies)
0 siblings, 3 replies; 23+ messages in thread
From: Matti J. Aaltonen @ 2010-08-30 11:38 UTC (permalink / raw)
To: linux-media, hverkuil, eduardo.valentin, mchehab; +Cc: Matti J. Aaltonen
Hi again,
and thanks for the comments.
I've left the audio codec out of this patch set.
Hans wrote:
> > In principle yes, but we haven't yet decided to implement those now, at
> > the moment the RDS interpretation is left completely to user space
> > applications.
>
> Matti, is it even possible to use the current FM TX RDS API for this chip?
> That API expects that the chip can generate the correct RDS packets based on
> high-level data. If the chip can only handle 'raw' RDS packets (requiring a
> userspace RDS encoder), then that API will never work.
>
> But if this chip can indeed handle raw RDS only, then we need to add some
> capability flags to signal that to userspace.
It is possible to use the current FM TX RDS API, the chip supports at least
most of it. I just haven't implemented the support into the driver yet,
for a multiple of reasons. I'm planning of adding that in the relatively
near future.
Anyhow, I've now added a way of telling that only raw RDS is supported.
Can we use one bit it the capability field for that?
> > + struct wl1273_device *radio = ctrl->priv;
>
> No need to use priv for this. You can use this instead:
>
> static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl)
> {
> return container_of(ctrl->handler, struct wl1273_device, ctrl_handler);
> }
Fixed. I just didn't come to think that it can be done like this.
> > + dev_dbg(radio->dev, "%s\n", __func__);
> > + return r;
> > +}
>
> Was the documentation on the control handler understandable enough? Any
> comments on how to improve the API or documentation? It's very new, so
> I'm interested in hearing about your experiences implementing this API.
I think the documentation is OK. But I didn't have time to dwell on it,
but on the other hand I remember thinking that the new API is better
than the previous one...
But what's the motivation behind having subdevices? You'll hardly
have several FM radios and want to do the same things on each
one at the same time?
> No need to use priv.
...
> First V4L2_CID_FM_BAND using new_std instead of new_std_menu (which it should
be).
...
> And a second?!
>
> > + if (ctrl) {
> > + ctrl->is_volatile = 1;
> > + ctrl->priv = radio;
> > + }
>
> And it is volatile? I thought that the ANTENNA_CAPACITOR was volatile.
> Something is messed up here.
Fixed. Yes, that was completely messed up...
Thanks...
Matti
Matti J. Aaltonen (4):
V4L2: Add seek spacing and FM RX class.
MFD: WL1273 FM Radio: MFD driver for the FM radio.
V4L2: WL1273 FM Radio: Controls for the FM radio.
Documentation: v4l: Add hw_seek spacing and FM_RX class
Documentation/DocBook/v4l/controls.xml | 71 +
Documentation/DocBook/v4l/dev-rds.xml | 5 +
.../DocBook/v4l/vidioc-s-hw-freq-seek.xml | 10 +-
drivers/media/radio/Kconfig | 15 +
drivers/media/radio/Makefile | 1 +
drivers/media/radio/radio-wl1273.c | 1935 ++++++++++++++++++++
drivers/media/video/v4l2-ctrls.c | 12 +
drivers/mfd/Kconfig | 5 +
drivers/mfd/Makefile | 2 +
drivers/mfd/wl1273-core.c | 612 +++++++
include/linux/mfd/wl1273-core.h | 314 ++++
include/linux/videodev2.h | 16 +-
12 files changed, 2995 insertions(+), 3 deletions(-)
create mode 100644 drivers/media/radio/radio-wl1273.c
create mode 100644 drivers/mfd/wl1273-core.c
create mode 100644 include/linux/mfd/wl1273-core.h
^ permalink raw reply [flat|nested] 23+ messages in thread* [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class. 2010-08-30 11:38 [PATCH v9 0/4] FM Radio driver Matti J. Aaltonen @ 2010-08-30 11:38 ` Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio Matti J. Aaltonen 2010-09-08 18:35 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Mauro Carvalho Chehab 2010-09-07 19:10 ` [PATCH v9 0/4] FM Radio driver Hans Verkuil 2010-09-11 12:10 ` Hans Verkuil 2 siblings, 2 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-08-30 11:38 UTC (permalink / raw) To: linux-media, hverkuil, eduardo.valentin, mchehab; +Cc: Matti J. Aaltonen Add spacing field to v4l2_hw_freq_seek, add V4L2_CAP_RAW_RDS_ONLY to driver capabilities and also add FM RX class to control classes. Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> --- drivers/media/video/v4l2-ctrls.c | 12 ++++++++++++ include/linux/videodev2.h | 16 +++++++++++++++- 2 files changed, 27 insertions(+), 1 deletions(-) diff --git a/drivers/media/video/v4l2-ctrls.c b/drivers/media/video/v4l2-ctrls.c index ea8d32c..15749f1 100644 --- a/drivers/media/video/v4l2-ctrls.c +++ b/drivers/media/video/v4l2-ctrls.c @@ -216,6 +216,12 @@ const char **v4l2_ctrl_get_menu(u32 id) "75 useconds", NULL, }; + static const char *fm_band[] = { + "87.5 - 108. MHz", + "76. - 90. MHz, Japan", + "65. - 74. MHz, OIRT", + NULL, + }; switch (id) { case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: @@ -256,6 +262,8 @@ const char **v4l2_ctrl_get_menu(u32 id) return colorfx; case V4L2_CID_TUNE_PREEMPHASIS: return tune_preemphasis; + case V4L2_CID_FM_BAND: + return fm_band; default: return NULL; } @@ -386,6 +394,8 @@ const char *v4l2_ctrl_get_name(u32 id) case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings"; case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level"; case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor"; + case V4L2_CID_FM_RX_CLASS: return "FM Radio Tuner Controls"; + case V4L2_CID_FM_BAND: return "FM Band"; default: return NULL; @@ -448,6 +458,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, case V4L2_CID_EXPOSURE_AUTO: case V4L2_CID_COLORFX: case V4L2_CID_TUNE_PREEMPHASIS: + case V4L2_CID_FM_BAND: *type = V4L2_CTRL_TYPE_MENU; break; case V4L2_CID_RDS_TX_PS_NAME: @@ -458,6 +469,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, case V4L2_CID_CAMERA_CLASS: case V4L2_CID_MPEG_CLASS: case V4L2_CID_FM_TX_CLASS: + case V4L2_CID_FM_RX_CLASS: *type = V4L2_CTRL_TYPE_CTRL_CLASS; /* You can neither read not write these */ *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY; diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h index 61490c6..7d6511e 100644 --- a/include/linux/videodev2.h +++ b/include/linux/videodev2.h @@ -244,6 +244,7 @@ struct v4l2_capability { #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */ #define V4L2_CAP_HW_FREQ_SEEK 0x00000400 /* Can do hardware frequency seek */ #define V4L2_CAP_RDS_OUTPUT 0x00000800 /* Is an RDS encoder */ +#define V4L2_CAP_RAW_RDS_ONLY 0x00001000 /* Does not interpret RDS data */ #define V4L2_CAP_TUNER 0x00010000 /* has a tuner */ #define V4L2_CAP_AUDIO 0x00020000 /* has audio support */ @@ -930,6 +931,7 @@ struct v4l2_ext_controls { #define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */ #define V4L2_CTRL_CLASS_CAMERA 0x009a0000 /* Camera class controls */ #define V4L2_CTRL_CLASS_FM_TX 0x009b0000 /* FM Modulator control class */ +#define V4L2_CTRL_CLASS_FM_RX 0x009c0000 /* FM Tuner control class */ #define V4L2_CTRL_ID_MASK (0x0fffffff) #define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL) @@ -1328,6 +1330,17 @@ enum v4l2_preemphasis { #define V4L2_CID_TUNE_POWER_LEVEL (V4L2_CID_FM_TX_CLASS_BASE + 113) #define V4L2_CID_TUNE_ANTENNA_CAPACITOR (V4L2_CID_FM_TX_CLASS_BASE + 114) +/* FM Tuner class control IDs */ +#define V4L2_CID_FM_RX_CLASS_BASE (V4L2_CTRL_CLASS_FM_RX | 0x900) +#define V4L2_CID_FM_RX_CLASS (V4L2_CTRL_CLASS_FM_RX | 1) + +#define V4L2_CID_FM_BAND (V4L2_CID_FM_RX_CLASS_BASE + 1) +enum v4l2_fm_band { + V4L2_FM_BAND_OTHER = 0, + V4L2_FM_BAND_JAPAN = 1, + V4L2_FM_BAND_OIRT = 2 +}; + /* * T U N I N G */ @@ -1392,7 +1405,8 @@ struct v4l2_hw_freq_seek { enum v4l2_tuner_type type; __u32 seek_upward; __u32 wrap_around; - __u32 reserved[8]; + __u32 spacing; + __u32 reserved[7]; }; /* -- 1.6.1.3 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio. 2010-08-30 11:38 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Matti J. Aaltonen @ 2010-08-30 11:38 ` Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls " Matti J. Aaltonen 2010-09-08 18:49 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver " Mauro Carvalho Chehab 2010-09-08 18:35 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Mauro Carvalho Chehab 1 sibling, 2 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-08-30 11:38 UTC (permalink / raw) To: linux-media, hverkuil, eduardo.valentin, mchehab; +Cc: Matti J. Aaltonen This is a parent for two child drivers: a V4L2 driver and an ALSA codec driver. The MFD part implements I2C communication to the device and provides a couple of functions that are called from both children. Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> --- drivers/mfd/wl1273-core.c | 612 +++++++++++++++++++++++++++++++++++++++ include/linux/mfd/wl1273-core.h | 314 ++++++++++++++++++++ 2 files changed, 926 insertions(+), 0 deletions(-) create mode 100644 drivers/mfd/wl1273-core.c create mode 100644 include/linux/mfd/wl1273-core.h diff --git a/drivers/mfd/wl1273-core.c b/drivers/mfd/wl1273-core.c new file mode 100644 index 0000000..9fa3850 --- /dev/null +++ b/drivers/mfd/wl1273-core.c @@ -0,0 +1,612 @@ +/* + * MFD driver for wl1273 FM radio and audio codec submodules. + * + * Author: Matti Aaltonen <matti.j.aaltonen@nokia.com> + * + * Copyright: (C) 2010 Nokia Corporation + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#include <linux/delay.h> +#include <linux/interrupt.h> +#include <linux/mfd/wl1273-core.h> +#include <linux/slab.h> +#include <media/v4l2-common.h> + +#define DRIVER_DESC "WL1273 FM Radio Core" + +#define WL1273_IRQ_MASK (WL1273_FR_EVENT | \ + WL1273_POW_ENB_EVENT) + +static const struct band_info bands[] = { + /* USA & Europe */ + { + .bottom_frequency = 87500, + .top_frequency = 108000, + .band = V4L2_FM_BAND_OTHER, + }, + /* Japan */ + { + .bottom_frequency = 76000, + .top_frequency = 90000, + .band = V4L2_FM_BAND_JAPAN, + }, +}; + +/* + * static unsigned char radio_band - Band + * + * The bands are 0 == USA-Europe, 1 == Japan. USA-Europe is the default. + */ +static unsigned char radio_band; +module_param(radio_band, byte, 0); +MODULE_PARM_DESC(radio_band, "Band: 0=USA-Europe, 1=Japan"); + +/* + * static unsigned int rds_buf - the number of RDS buffer blocks used. + * + * The default number is 100. + */ +static unsigned int rds_buf = 100; +module_param(rds_buf, uint, 0); +MODULE_PARM_DESC(rds_buf, "RDS buffer entries: *100*"); + +int wl1273_fm_read_reg(struct wl1273_core *core, u8 reg, u16 *value) +{ + struct i2c_client *client = core->i2c_dev; + u8 b[2]; + int r; + + r = i2c_smbus_read_i2c_block_data(client, reg, 2, b); + if (r != 2) { + dev_err(&client->dev, "%s: Read: %d fails.\n", __func__, reg); + return -EREMOTEIO; + } + + *value = (u16)b[0] << 8 | b[1]; + + return 0; +} +EXPORT_SYMBOL(wl1273_fm_read_reg); + +int wl1273_fm_write_cmd(struct wl1273_core *core, u8 cmd, u16 param) +{ + struct i2c_client *client = core->i2c_dev; + u8 buf[] = { (param >> 8) & 0xff, param & 0xff }; + int r; + + r = i2c_smbus_write_i2c_block_data(client, cmd, 2, buf); + if (r) { + dev_err(&client->dev, "%s: Cmd: %d fails.\n", __func__, cmd); + return r; + } + + return 0; +} +EXPORT_SYMBOL(wl1273_fm_write_cmd); + +int wl1273_fm_write_data(struct wl1273_core *core, u8 *data, u16 len) +{ + struct i2c_client *client = core->i2c_dev; + struct i2c_msg msg[1]; + int r; + + msg[0].addr = client->addr; + msg[0].flags = 0; + msg[0].buf = data; + msg[0].len = len; + + r = i2c_transfer(client->adapter, msg, 1); + + if (r != 1) { + dev_err(&client->dev, "%s: write error.\n", __func__); + return -EREMOTEIO; + } + + return 0; +} +EXPORT_SYMBOL(wl1273_fm_write_data); + +/** + * wl1273_fm_set_audio() - Set audio mode. + * @core: A pointer to the device struct. + * @new_mode: The new audio mode. + * + * Audio modes are WL1273_AUDIO_DIGITAL and WL1273_AUDIO_ANALOG. + */ +int wl1273_fm_set_audio(struct wl1273_core *core, unsigned int new_mode) +{ + int r = 0; + + if (core->mode == WL1273_MODE_OFF || + core->mode == WL1273_MODE_SUSPENDED) + return -EPERM; + + if (core->mode == WL1273_MODE_RX && new_mode == WL1273_AUDIO_DIGITAL) { + r = wl1273_fm_write_cmd(core, WL1273_PCM_MODE_SET, + WL1273_PCM_DEF_MODE); + if (r) + goto out; + + r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET, + core->i2s_mode); + if (r) + goto out; + + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE, + WL1273_AUDIO_ENABLE_I2S); + if (r) + goto out; + + } else if (core->mode == WL1273_MODE_RX && + new_mode == WL1273_AUDIO_ANALOG) { + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE, + WL1273_AUDIO_ENABLE_ANALOG); + if (r) + goto out; + + } else if (core->mode == WL1273_MODE_TX && + new_mode == WL1273_AUDIO_DIGITAL) { + r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET, + core->i2s_mode); + if (r) + goto out; + + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_IO_SET, + WL1273_AUDIO_IO_SET_I2S); + if (r) + goto out; + + } else if (core->mode == WL1273_MODE_TX && + new_mode == WL1273_AUDIO_ANALOG) { + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_IO_SET, + WL1273_AUDIO_IO_SET_ANALOG); + if (r) + goto out; + } + + core->audio_mode = new_mode; + +out: + return r; +} +EXPORT_SYMBOL(wl1273_fm_set_audio); + +/** + * wl1273_fm_set_volume() - Set volume. + * @core: A pointer to the device struct. + * @volume: The new volume value. + */ +int wl1273_fm_set_volume(struct wl1273_core *core, unsigned int volume) +{ + u16 val; + int r; + + if (volume > WL1273_MAX_VOLUME) + return -EINVAL; + + if (core->volume == volume) + return 0; + + val = volume; + r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val); + if (r) + return r; + + core->volume = volume; + return 0; +} +EXPORT_SYMBOL(wl1273_fm_set_volume); + +#define WL1273_FIFO_HAS_DATA(status) (1 << 5 & status) + +#define WL1273_RDS_CORRECTABLE_ERROR (1 << 3) +#define WL1273_RDS_UNCORRECTABLE_ERROR (1 << 4) + +static int wl1273_fm_rds(struct wl1273_core *core) +{ + struct i2c_client *client = core->i2c_dev; + struct device *dev = &client->dev; + u16 val; + u8 b0[] = { WL1273_RDS_DATA_GET }, status; + struct v4l2_rds_data rds = { 0, 0, 0 }; + struct i2c_msg msg[] = { + { + .addr = client->addr, + .flags = 0, + .buf = b0, + .len = sizeof(b0) + }, + { + .addr = client->addr, + .flags = I2C_M_RD, + .buf = (u8 *) &rds, + .len = sizeof(rds), + } + }; + int r; + + if (core->mode != WL1273_MODE_RX) + return 0; + + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); + if (r) + return r; + + if ((val & 0x01) == 0) { + /* RDS decoder not synchronized */ + return -EAGAIN; + } + + /* copy all four RDS blocks to internal buffer */ + do { + r = i2c_transfer(client->adapter, msg, 2); + if (r != 2) { + dev_err(dev, WL1273_FM_DRIVER_NAME + ": %s: read_rds error r == %i)\n", + __func__, r); + } + + status = rds.block; + + if (!WL1273_FIFO_HAS_DATA(status)) + break; + + /* fill bits 0-5 */ + rds.block = 0x07 & status; + rds.block |= rds.block << 3; + + /* copy the error bits to standard positions */ + if (WL1273_RDS_UNCORRECTABLE_ERROR & status) { + rds.block |= V4L2_RDS_BLOCK_ERROR; + rds.block &= ~V4L2_RDS_BLOCK_CORRECTED; + } else if (WL1273_RDS_CORRECTABLE_ERROR & status) { + rds.block &= ~V4L2_RDS_BLOCK_ERROR; + rds.block |= V4L2_RDS_BLOCK_CORRECTED; + } + + /* copy RDS block to internal buffer */ + memcpy(&core->buffer[core->wr_index], &rds, 3); + core->wr_index += 3; + + /* wrap write pointer */ + if (core->wr_index >= core->buf_size) + core->wr_index = 0; + + /* check for overflow & start over */ + if (core->wr_index == core->rd_index) { + dev_dbg(dev, "RDS OVERFLOW"); + + core->rd_index = 0; + core->wr_index = 0; + break; + } + } while (WL1273_FIFO_HAS_DATA(status)); + + /* wake up read queue */ + if (core->wr_index != core->rd_index) + wake_up_interruptible(&core->read_queue); + + return 0; +} + +static void wl1273_fm_rds_work(struct wl1273_core *core) +{ + wl1273_fm_rds(core); +} + +static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id) +{ + int r; + u16 flags; + struct wl1273_core *core = dev_id; + + r = wl1273_fm_read_reg(core, WL1273_FLAG_GET, &flags); + if (r) + goto out; + + if (flags & WL1273_BL_EVENT) { + core->irq_received = flags; + dev_dbg(&core->i2c_dev->dev, "IRQ: BL\n"); + } + + if (flags & WL1273_RDS_EVENT) { + msleep(200); + + wl1273_fm_rds_work(core); + } + + if (flags & WL1273_BBLK_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: BBLK\n"); + + if (flags & WL1273_LSYNC_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: LSYNC\n"); + + if (flags & WL1273_LEV_EVENT) { + u16 level; + + r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &level); + + if (r) + goto out; + + if (level > 14) + dev_dbg(&core->i2c_dev->dev, "IRQ: LEV: 0x%x04\n", + level); + } + + if (flags & WL1273_IFFR_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: IFFR\n"); + + if (flags & WL1273_PI_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: PI\n"); + + if (flags & WL1273_PD_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: PD\n"); + + if (flags & WL1273_STIC_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: STIC\n"); + + if (flags & WL1273_MAL_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: MAL\n"); + + if (flags & WL1273_POW_ENB_EVENT) { + complete(&core->busy); + dev_dbg(&core->i2c_dev->dev, "NOT BUSY\n"); + dev_dbg(&core->i2c_dev->dev, "IRQ: POW_ENB\n"); + } + + if (flags & WL1273_SCAN_OVER_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: SCAN_OVER\n"); + + if (flags & WL1273_ERROR_EVENT) + dev_dbg(&core->i2c_dev->dev, "IRQ: ERROR\n"); + + if (flags & WL1273_FR_EVENT) { + u16 freq; + + dev_dbg(&core->i2c_dev->dev, "IRQ: FR:\n"); + + if (core->mode == WL1273_MODE_RX) { + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, + TUNER_MODE_STOP_SEARCH); + if (r) { + dev_err(&core->i2c_dev->dev, + "%s: TUNER_MODE_SET fails: %d\n", + __func__, r); + goto out; + } + + r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &freq); + if (r) + goto out; + + core->rx_frequency = + bands[core->band].bottom_frequency + + freq * 50; + + /* + * The driver works better with this msleep, + * the documentation doesn't mention it. + */ + usleep_range(10000, 15000); + + dev_dbg(&core->i2c_dev->dev, "%dkHz\n", + core->rx_frequency); + + } else { + r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &freq); + if (r) + goto out; + + dev_dbg(&core->i2c_dev->dev, "%dkHz\n", freq); + } + dev_dbg(&core->i2c_dev->dev, "%s: NOT BUSY\n", __func__); + } + +out: + wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, + core->irq_flags); + complete(&core->busy); + + return IRQ_HANDLED; +} + +static struct i2c_device_id wl1273_driver_id_table[] = { + { WL1273_FM_DRIVER_NAME, 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, wl1273_driver_id_table); + +static int wl1273_core_remove(struct i2c_client *client) +{ + struct wl1273_core *core = i2c_get_clientdata(client); + struct wl1273_fm_platform_data *pdata = + client->dev.platform_data; + + dev_dbg(&client->dev, "%s\n", __func__); + + mfd_remove_devices(&client->dev); + i2c_set_clientdata(client, core); + + free_irq(client->irq, core); + pdata->free_resources(); + + kfree(core->buffer); + kfree(core); + + return 0; +} + +static int __devinit wl1273_core_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct wl1273_fm_platform_data *pdata = client->dev.platform_data; + int r = 0; + struct wl1273_core *core; + int children = 0; + + dev_dbg(&client->dev, "%s\n", __func__); + + if (!pdata) { + dev_err(&client->dev, "No platform data.\n"); + return -EINVAL; + } + + core = kzalloc(sizeof(*core), GFP_KERNEL); + if (!core) + return -ENOMEM; + + /* RDS buffer allocation */ + core->buf_size = rds_buf * 3; + core->buffer = kmalloc(core->buf_size, GFP_KERNEL); + if (!core->buffer) { + dev_err(&client->dev, + "Cannot allocate memory for RDS buffer.\n"); + r = -ENOMEM; + goto err_kmalloc; + } + + core->irq_flags = WL1273_IRQ_MASK; + core->i2c_dev = client; + core->rds_on = false; + core->mode = WL1273_MODE_OFF; + core->tx_power = 118; + core->audio_mode = WL1273_AUDIO_ANALOG; + core->band = radio_band; + core->bands = bands; + core->number_of_bands = ARRAY_SIZE(bands); + core->i2s_mode = WL1273_I2S_DEF_MODE; + core->channel_number = 2; + core->volume = WL1273_DEFAULT_VOLUME; + core->rx_frequency = bands[core->band].bottom_frequency; + core->tx_frequency = bands[core->band].top_frequency; + core->stereo = true; + + dev_dbg(&client->dev, "radio_band: %d\n", radio_band); + + mutex_init(&core->lock); + + pdata = client->dev.platform_data; + if (pdata) { + r = pdata->request_resources(client); + if (r) { + dev_err(&client->dev, WL1273_FM_DRIVER_NAME + ": Cannot get platform data\n"); + goto err_new_mixer; + } + + r = request_threaded_irq(client->irq, NULL, + wl1273_fm_irq_thread_handler, + IRQF_ONESHOT | IRQF_TRIGGER_FALLING, + "wl1273-fm", core); + if (r < 0) { + dev_err(&client->dev, WL1273_FM_DRIVER_NAME + ": Unable to register IRQ handler\n"); + goto err_request_irq; + } + } else { + dev_err(&client->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ" + " not configured"); + r = -EINVAL; + goto err_new_mixer; + } + + init_completion(&core->busy); + init_waitqueue_head(&core->read_queue); + + i2c_set_clientdata(client, core); + + if (pdata->children & WL1273_RADIO_CHILD) { + struct mfd_cell *cell = &core->cells[children]; + dev_dbg(&client->dev, "%s: Have V4L2.\n", __func__); + cell->name = "wl1273_fm_radio"; + cell->platform_data = &core; + cell->data_size = sizeof(core); + children++; + } + + if (pdata->children & WL1273_CODEC_CHILD) { + struct mfd_cell *cell = &core->cells[children]; + dev_dbg(&client->dev, "%s: Have codec.\n", __func__); + cell->name = "wl1273_codec_audio"; + cell->platform_data = &core; + cell->data_size = sizeof(core); + children++; + } + + if (children) { + dev_dbg(&client->dev, "%s: Have children.\n", __func__); + r = mfd_add_devices(&client->dev, -1, core->cells, + children, NULL, 0); + } else { + dev_err(&client->dev, "No platform data found for children.\n"); + r = -ENODEV; + } + + if (!r) + return 0; + + i2c_set_clientdata(client, NULL); + kfree(core); + free_irq(client->irq, core); +err_request_irq: + pdata->free_resources(); +err_new_mixer: + kfree(core->buffer); +err_kmalloc: + kfree(core); + dev_dbg(&client->dev, "%s\n", __func__); + + return r; +} + +static struct i2c_driver wl1273_core_driver = { + .driver = { + .name = WL1273_FM_DRIVER_NAME, + }, + .probe = wl1273_core_probe, + .id_table = wl1273_driver_id_table, + .remove = __devexit_p(wl1273_core_remove), +}; + +static int __init wl1273_core_init(void) +{ + int r; + + r = i2c_add_driver(&wl1273_core_driver); + if (r) { + pr_err(WL1273_FM_DRIVER_NAME + ": driver registration failed\n"); + return r; + } + + return 0; +} + +static void __exit wl1273_core_exit(void) +{ + flush_scheduled_work(); + + i2c_del_driver(&wl1273_core_driver); +} +late_initcall(wl1273_core_init); +module_exit(wl1273_core_exit); + +MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>"); +MODULE_DESCRIPTION(DRIVER_DESC); +MODULE_LICENSE("GPL"); diff --git a/include/linux/mfd/wl1273-core.h b/include/linux/mfd/wl1273-core.h new file mode 100644 index 0000000..30a9e9a --- /dev/null +++ b/include/linux/mfd/wl1273-core.h @@ -0,0 +1,314 @@ +/* + * include/media/radio/radio-wl1273.h + * + * Some definitions for the wl1273 radio receiver/transmitter chip. + * + * Copyright (C) Nokia Corporation + * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + */ + +#ifndef RADIO_WL1273_H +#define RADIO_WL1273_H + +#include <linux/i2c.h> +#include <linux/mfd/core.h> + +#define WL1273_FM_DRIVER_NAME "wl1273-fm" +#define RX71_FM_I2C_ADDR 0x22 + +#define WL1273_STEREO_GET 0 +#define WL1273_RSSI_LVL_GET 1 +#define WL1273_IF_COUNT_GET 2 +#define WL1273_FLAG_GET 3 +#define WL1273_RDS_SYNC_GET 4 +#define WL1273_RDS_DATA_GET 5 +#define WL1273_FREQ_SET 10 +#define WL1273_AF_FREQ_SET 11 +#define WL1273_MOST_MODE_SET 12 +#define WL1273_MOST_BLEND_SET 13 +#define WL1273_DEMPH_MODE_SET 14 +#define WL1273_SEARCH_LVL_SET 15 +#define WL1273_BAND_SET 16 +#define WL1273_MUTE_STATUS_SET 17 +#define WL1273_RDS_PAUSE_LVL_SET 18 +#define WL1273_RDS_PAUSE_DUR_SET 19 +#define WL1273_RDS_MEM_SET 20 +#define WL1273_RDS_BLK_B_SET 21 +#define WL1273_RDS_MSK_B_SET 22 +#define WL1273_RDS_PI_MASK_SET 23 +#define WL1273_RDS_PI_SET 24 +#define WL1273_RDS_SYSTEM_SET 25 +#define WL1273_INT_MASK_SET 26 +#define WL1273_SEARCH_DIR_SET 27 +#define WL1273_VOLUME_SET 28 +#define WL1273_AUDIO_ENABLE 29 +#define WL1273_PCM_MODE_SET 30 +#define WL1273_I2S_MODE_CONFIG_SET 31 +#define WL1273_POWER_SET 32 +#define WL1273_INTX_CONFIG_SET 33 +#define WL1273_PULL_EN_SET 34 +#define WL1273_HILO_SET 35 +#define WL1273_SWITCH2FREF 36 +#define WL1273_FREQ_DRIFT_REPORT 37 + +#define WL1273_PCE_GET 40 +#define WL1273_FIRM_VER_GET 41 +#define WL1273_ASIC_VER_GET 42 +#define WL1273_ASIC_ID_GET 43 +#define WL1273_MAN_ID_GET 44 +#define WL1273_TUNER_MODE_SET 45 +#define WL1273_STOP_SEARCH 46 +#define WL1273_RDS_CNTRL_SET 47 + +#define WL1273_WRITE_HARDWARE_REG 100 +#define WL1273_CODE_DOWNLOAD 101 +#define WL1273_RESET 102 + +#define WL1273_FM_POWER_MODE 254 +#define WL1273_FM_INTERRUPT 255 + +/* Transmitter API */ + +#define WL1273_CHANL_SET 55 +#define WL1273_SCAN_SPACING_SET 56 +#define WL1273_REF_SET 57 +#define WL1273_POWER_ENB_SET 90 +#define WL1273_POWER_ATT_SET 58 +#define WL1273_POWER_LEV_SET 59 +#define WL1273_AUDIO_DEV_SET 60 +#define WL1273_PILOT_DEV_SET 61 +#define WL1273_RDS_DEV_SET 62 +#define WL1273_PUPD_SET 91 +#define WL1273_AUDIO_IO_SET 63 +#define WL1273_PREMPH_SET 64 +#define WL1273_MONO_SET 66 +#define WL1273_MUTE 92 +#define WL1273_MPX_LMT_ENABLE 67 +#define WL1273_PI_SET 93 +#define WL1273_ECC_SET 69 +#define WL1273_PTY 70 +#define WL1273_AF 71 +#define WL1273_DISPLAY_MODE 74 +#define WL1273_RDS_REP_SET 77 +#define WL1273_RDS_CONFIG_DATA_SET 98 +#define WL1273_RDS_DATA_SET 99 +#define WL1273_RDS_DATA_ENB 94 +#define WL1273_TA_SET 78 +#define WL1273_TP_SET 79 +#define WL1273_DI_SET 80 +#define WL1273_MS_SET 81 +#define WL1273_PS_SCROLL_SPEED 82 +#define WL1273_TX_AUDIO_LEVEL_TEST 96 +#define WL1273_TX_AUDIO_LEVEL_TEST_THRESHOLD 73 +#define WL1273_TX_AUDIO_INPUT_LEVEL_RANGE_SET 54 +#define WL1273_RX_ANTENNA_SELECT 87 +#define WL1273_I2C_DEV_ADDR_SET 86 +#define WL1273_REF_ERR_CALIB_PARAM_SET 88 +#define WL1273_REF_ERR_CALIB_PERIODICITY_SET 89 +#define WL1273_SOC_INT_TRIGGER 52 +#define WL1273_SOC_AUDIO_PATH_SET 83 +#define WL1273_SOC_PCMI_OVERRIDE 84 +#define WL1273_SOC_I2S_OVERRIDE 85 +#define WL1273_RSSI_BLOCK_SCAN_FREQ_SET 95 +#define WL1273_RSSI_BLOCK_SCAN_START 97 +#define WL1273_RSSI_BLOCK_SCAN_DATA_GET 5 +#define WL1273_READ_FMANT_TUNE_VALUE 104 + +#define WL1273_RDS_OFF 0 +#define WL1273_RDS_ON 1 +#define WL1273_RDS_RESET 2 + +#define WL1273_AUDIO_DIGITAL 0 +#define WL1273_AUDIO_ANALOG 1 + +#define WL1273_MODE_RX (1 << 0) +#define WL1273_MODE_TX (1 << 1) +#define WL1273_MODE_OFF (1 << 2) +#define WL1273_MODE_SUSPENDED (1 << 3) + +#define WL1273_RADIO_CHILD (1 << 0) +#define WL1273_CODEC_CHILD (1 << 1) + +#define WL1273_RX_MONO 1 +#define WL1273_RX_STEREO 0 +#define WL1273_TX_MONO 0 +#define WL1273_TX_STEREO 1 + +#define WL1273_MAX_VOLUME 0xffff +#define WL1273_DEFAULT_VOLUME 0x78b8 + +/* I2S protocol, left channel first, data width 16 bits */ +#define WL1273_PCM_DEF_MODE 0x00 + +/* Rx */ +#define WL1273_AUDIO_ENABLE_I2S (1 << 0) +#define WL1273_AUDIO_ENABLE_ANALOG (1 << 1) + +/* Tx */ +#define WL1273_AUDIO_IO_SET_ANALOG 0 +#define WL1273_AUDIO_IO_SET_I2S 1 + +#define WL1273_POWER_SET_OFF 0 +#define WL1273_POWER_SET_FM (1 << 0) +#define WL1273_POWER_SET_RDS (1 << 1) +#define WL1273_POWER_SET_RETENTION (1 << 4) + +#define WL1273_PUPD_SET_OFF 0x00 +#define WL1273_PUPD_SET_ON 0x01 +#define WL1273_PUPD_SET_RETENTION 0x10 + +/* I2S mode */ +#define WL1273_IS2_WIDTH_32 0x0 +#define WL1273_IS2_WIDTH_40 0x1 +#define WL1273_IS2_WIDTH_22_23 0x2 +#define WL1273_IS2_WIDTH_23_22 0x3 +#define WL1273_IS2_WIDTH_48 0x4 +#define WL1273_IS2_WIDTH_50 0x5 +#define WL1273_IS2_WIDTH_60 0x6 +#define WL1273_IS2_WIDTH_64 0x7 +#define WL1273_IS2_WIDTH_80 0x8 +#define WL1273_IS2_WIDTH_96 0x9 +#define WL1273_IS2_WIDTH_128 0xa +#define WL1273_IS2_WIDTH 0xf + +#define WL1273_IS2_FORMAT_STD (0x0 << 4) +#define WL1273_IS2_FORMAT_LEFT (0x1 << 4) +#define WL1273_IS2_FORMAT_RIGHT (0x2 << 4) +#define WL1273_IS2_FORMAT_USER (0x3 << 4) + +#define WL1273_IS2_MASTER (0x0 << 6) +#define WL1273_IS2_SLAVEW (0x1 << 6) + +#define WL1273_IS2_TRI_AFTER_SENDING (0x0 << 7) +#define WL1273_IS2_TRI_ALWAYS_ACTIVE (0x1 << 7) + +#define WL1273_IS2_SDOWS_RR (0x0 << 8) +#define WL1273_IS2_SDOWS_RF (0x1 << 8) +#define WL1273_IS2_SDOWS_FR (0x2 << 8) +#define WL1273_IS2_SDOWS_FF (0x3 << 8) + +#define WL1273_IS2_TRI_OPT (0x0 << 10) +#define WL1273_IS2_TRI_ALWAYS (0x1 << 10) + +#define WL1273_IS2_RATE_48K (0x0 << 12) +#define WL1273_IS2_RATE_44_1K (0x1 << 12) +#define WL1273_IS2_RATE_32K (0x2 << 12) +#define WL1273_IS2_RATE_22_05K (0x4 << 12) +#define WL1273_IS2_RATE_16K (0x5 << 12) +#define WL1273_IS2_RATE_12K (0x8 << 12) +#define WL1273_IS2_RATE_11_025 (0x9 << 12) +#define WL1273_IS2_RATE_8K (0xa << 12) +#define WL1273_IS2_RATE (0xf << 12) + +#define WL1273_I2S_DEF_MODE (WL1273_IS2_WIDTH_32 | \ + WL1273_IS2_FORMAT_STD | \ + WL1273_IS2_MASTER | \ + WL1273_IS2_TRI_AFTER_SENDING | \ + WL1273_IS2_SDOWS_RR | \ + WL1273_IS2_TRI_OPT | \ + WL1273_IS2_RATE_48K) + +#define SCHAR_MIN (-128) +#define SCHAR_MAX 127 + +#define WL1273_FR_EVENT (1 << 0) +#define WL1273_BL_EVENT (1 << 1) +#define WL1273_RDS_EVENT (1 << 2) +#define WL1273_BBLK_EVENT (1 << 3) +#define WL1273_LSYNC_EVENT (1 << 4) +#define WL1273_LEV_EVENT (1 << 5) +#define WL1273_IFFR_EVENT (1 << 6) +#define WL1273_PI_EVENT (1 << 7) +#define WL1273_PD_EVENT (1 << 8) +#define WL1273_STIC_EVENT (1 << 9) +#define WL1273_MAL_EVENT (1 << 10) +#define WL1273_POW_ENB_EVENT (1 << 11) +#define WL1273_SCAN_OVER_EVENT (1 << 12) +#define WL1273_ERROR_EVENT (1 << 13) + +#define TUNER_MODE_STOP_SEARCH 0 +#define TUNER_MODE_PRESET 1 +#define TUNER_MODE_AUTO_SEEK 2 +#define TUNER_MODE_AF 3 +#define TUNER_MODE_AUTO_SEEK_PI 4 +#define TUNER_MODE_AUTO_SEEK_BULK 5 + +struct band_info { + u32 bottom_frequency; + u32 top_frequency; + u8 band; +}; + +struct wl1273_fm_platform_data { + int (*request_resources) (struct i2c_client *client); + void (*free_resources) (void); + void (*enable) (void); + void (*disable) (void); + + u8 forbidden_modes; + unsigned int children; +}; + +#define WL1273_FM_CORE_CELLS 2 + +struct wl1273_core { + struct mfd_cell cells[WL1273_FM_CORE_CELLS]; + struct i2c_client *i2c_dev; + + u8 forbidden; + unsigned int mode; + unsigned int preemphasis; + unsigned int audio_mode; + unsigned int spacing; + unsigned int tx_power; + unsigned int rx_frequency; + unsigned int tx_frequency; + unsigned int band; + unsigned int i2s_mode; + unsigned int channel_number; + unsigned int number_of_bands; + unsigned int volume; + bool stereo; + + const struct band_info *bands; + + /* RDS */ + unsigned int rds_on; + struct delayed_work work; + + wait_queue_head_t read_queue; + struct mutex lock; /* for serializing fm radio operations */ + struct completion busy; + + unsigned char *buffer; + unsigned int buf_size; + unsigned int rd_index; + unsigned int wr_index; + + /* Selected interrupts */ + u16 irq_flags; + u16 irq_received; +}; + +int wl1273_fm_write_cmd(struct wl1273_core *core, u8 cmd, u16 param); +int wl1273_fm_write_data(struct wl1273_core *core, u8 *data, u16 len); +int wl1273_fm_read_reg(struct wl1273_core *core, u8 reg, u16 *value); + +int wl1273_fm_set_audio(struct wl1273_core *core, unsigned int mode); +int wl1273_fm_set_volume(struct wl1273_core *core, unsigned int volume); + +#endif /* ifndef RADIO_WL1273_H */ -- 1.6.1.3 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio. 2010-08-30 11:38 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio Matti J. Aaltonen @ 2010-08-30 11:38 ` Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 4/4] Documentation: v4l: Add hw_seek spacing and FM_RX class Matti J. Aaltonen 2010-09-08 19:09 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio Mauro Carvalho Chehab 2010-09-08 18:49 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver " Mauro Carvalho Chehab 1 sibling, 2 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-08-30 11:38 UTC (permalink / raw) To: linux-media, hverkuil, eduardo.valentin, mchehab; +Cc: Matti J. Aaltonen This driver implements V4L2 controls for the Texas Instruments WL1273 FM Radio. Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> --- drivers/media/radio/Kconfig | 15 + drivers/media/radio/Makefile | 1 + drivers/media/radio/radio-wl1273.c | 1935 ++++++++++++++++++++++++++++++++++++ drivers/mfd/Kconfig | 5 + drivers/mfd/Makefile | 2 + 5 files changed, 1958 insertions(+), 0 deletions(-) create mode 100644 drivers/media/radio/radio-wl1273.c diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig index 83567b8..209fd37 100644 --- a/drivers/media/radio/Kconfig +++ b/drivers/media/radio/Kconfig @@ -452,4 +452,19 @@ config RADIO_TIMBERDALE found behind the Timberdale FPGA on the Russellville board. Enabling this driver will automatically select the DSP and tuner. +config RADIO_WL1273 + tristate "Texas Instruments WL1273 I2C FM Radio" + depends on I2C && VIDEO_V4L2 && SND + select FW_LOADER + ---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>. + + To compile this driver as a module, choose M here: the + module will be called radio-wl1273. + endif # RADIO_ADAPTERS diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile index f615583..d297074 100644 --- a/drivers/media/radio/Makefile +++ b/drivers/media/radio/Makefile @@ -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_WL1273) += radio-wl1273.o EXTRA_CFLAGS += -Isound diff --git a/drivers/media/radio/radio-wl1273.c b/drivers/media/radio/radio-wl1273.c new file mode 100644 index 0000000..aa1eeed --- /dev/null +++ b/drivers/media/radio/radio-wl1273.c @@ -0,0 +1,1935 @@ +/* + * Driver for the Texas Instruments WL1273 FM radio. + * + * Copyright (C) Nokia Corporation + * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> + * + * 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 <linux/firmware.h> +#include <linux/mfd/wl1273-core.h> +#include <linux/slab.h> +#include <media/v4l2-common.h> +#include <media/v4l2-ctrls.h> +#include <media/v4l2-device.h> +#include <media/v4l2-ioctl.h> + +#define DRIVER_DESC "Wl1273 FM Radio - V4L2" + +#define WL1273_POWER_SET_OFF 0 +#define WL1273_POWER_SET_FM (1 << 0) +#define WL1273_POWER_SET_RDS (1 << 1) +#define WL1273_POWER_SET_RETENTION (1 << 4) + +#define WL1273_PUPD_SET_OFF 0x00 +#define WL1273_PUPD_SET_ON 0x01 +#define WL1273_PUPD_SET_RETENTION 0x10 + +#define WL1273_FREQ(x) (x * 10000 / 625) +#define WL1273_INV_FREQ(x) (x * 625 / 10000) + +/* + * static int radio_nr - The number of the radio device + * + * The default is 0. + */ +static int radio_nr = -1; +module_param(radio_nr, int, 0); +MODULE_PARM_DESC(radio_nr, "Radio Nr"); + +struct wl1273_device { + struct v4l2_ctrl_handler ctrl_handler; + struct v4l2_device v4l2dev; + struct video_device videodev; + struct device *dev; + struct wl1273_core *core; + struct file *owner; + char *write_buf; + unsigned int rds_users; +}; + +static int wl1273_fm_set_tx_freq(struct wl1273_core *core, unsigned int freq) +{ + int r = 0; + + if (freq < 76000) { + dev_err(&core->i2c_dev->dev, + "Frequency out of range: %d < %d\n", + freq, core->bands[core->band].bottom_frequency); + return -ERANGE; + } + + if (freq > 108000) { + dev_err(&core->i2c_dev->dev, + "Frequency out of range: %d > %d\n", + freq, core->bands[core->band].top_frequency); + return -ERANGE; + } + + /* + * The driver works better with this sleep, + * the documentation doesn't mention it. + */ + usleep_range(5000, 10000); + + dev_dbg(&core->i2c_dev->dev, "%s: freq: %d kHz\n", __func__, freq); + + INIT_COMPLETION(core->busy); + /* Set the current tx channel */ + r = wl1273_fm_write_cmd(core, WL1273_CHANL_SET, freq / 10); + if (r) + return r; + + /* wait for the FR IRQ */ + r = wait_for_completion_timeout(&core->busy, msecs_to_jiffies(2000)); + if (!r) + return -ETIMEDOUT; + + dev_dbg(&core->i2c_dev->dev, "WL1273_CHANL_SET: %d\n", r); + + /* Enable the output power */ + INIT_COMPLETION(core->busy); + r = wl1273_fm_write_cmd(core, WL1273_POWER_ENB_SET, 1); + if (r) + return r; + + /* wait for the POWER_ENB IRQ */ + r = wait_for_completion_timeout(&core->busy, msecs_to_jiffies(1000)); + if (!r) + return -ETIMEDOUT; + + core->tx_frequency = freq; + dev_dbg(&core->i2c_dev->dev, "WL1273_POWER_ENB_SET: %d\n", r); + + return 0; +} + +static int wl1273_fm_set_rx_freq(struct wl1273_core *core, unsigned int freq) +{ + int r; + int f; + + if (freq < core->bands[core->band].bottom_frequency) { + dev_err(&core->i2c_dev->dev, + "Frequency out of range: %d < %d\n", + freq, core->bands[core->band].bottom_frequency); + r = -ERANGE; + goto err; + } + + if (freq > core->bands[core->band].top_frequency) { + dev_err(&core->i2c_dev->dev, + "Frequency out of range: %d > %d\n", + freq, core->bands[core->band].top_frequency); + r = -ERANGE; + goto err; + } + + dev_dbg(&core->i2c_dev->dev, "%s: %dkHz\n", __func__, freq); + + wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, core->irq_flags); + + f = (freq - core->bands[core->band].bottom_frequency) / 50; + r = wl1273_fm_write_cmd(core, WL1273_FREQ_SET, f); + if (r) { + dev_err(&core->i2c_dev->dev, "FREQ_SET fails\n"); + goto err; + } + + INIT_COMPLETION(core->busy); + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET); + if (r) { + dev_err(&core->i2c_dev->dev, "TUNER_MODE_SET fails\n"); + complete(&core->busy); + goto err; + } + + r = wait_for_completion_timeout(&core->busy, msecs_to_jiffies(2000)); + if (!r) { + dev_err(&core->i2c_dev->dev, "TIMEOUT\n"); + return -ETIMEDOUT; + } + + core->rd_index = 0; + core->wr_index = 0; + core->rx_frequency = freq; + return 0; + +err: + return r; +} + +static int wl1273_fm_get_freq(struct wl1273_core *core) +{ + unsigned int freq; + u16 f; + int r; + + if (core->mode == WL1273_MODE_RX) { + r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &f); + if (r) + return r; + + dev_dbg(&core->i2c_dev->dev, "Freq get: 0x%04x\n", f); + freq = core->bands[core->band].bottom_frequency + 50 * f; + } else { + r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &f); + if (r) + return r; + + freq = f * 10; + } + + return freq; +} + +/** + * wl1273_fm_upload_firmware_patch() - Upload the firmware. + * @core: A pointer to the device struct. + * + * The firmware file consists of arrays of bytes where the first byte + * gives the array length. The first byte in the file gives the + * number of these arrays. + */ +static int wl1273_fm_upload_firmware_patch(struct wl1273_core *core) +{ + unsigned int packet_num; + const struct firmware *fw_p; + const char *fw_name = "radio-wl1273-fw.bin"; + struct device *dev = &core->i2c_dev->dev; + __u8 *ptr; + int i, n, len, r; + struct i2c_msg *msgs; + + dev_dbg(dev, "%s:\n", __func__); + + if (request_firmware(&fw_p, fw_name, dev)) { + dev_info(dev, "%s - %s not found\n", __func__, fw_name); + + return 0; + } + + ptr = (__u8 *) fw_p->data; + packet_num = ptr[0]; + dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num); + + msgs = kmalloc((packet_num + 1)*sizeof(struct i2c_msg), GFP_KERNEL); + if (!msgs) { + r = -ENOMEM; + goto out; + } + + i = 1; + for (n = 0; n <= packet_num; n++) { + len = ptr[i]; + + dev_dbg(dev, "%s: len[%d]: %d\n", __func__, n, len); + + if (i + len + 1 <= fw_p->size) { + msgs[n].addr = core->i2c_dev->addr; + msgs[n].flags = 0; + msgs[n].len = len; + msgs[n].buf = ptr + i + 1; + } else { + break; + } + + i += len + 1; + } + + r = i2c_transfer(core->i2c_dev->adapter, msgs, packet_num); + kfree(msgs); + + if (r != packet_num) { + dev_err(dev, "FW upload error: %d\n", r); + dev_dbg(dev, "%d != %d\n", packet_num, r); + + r = -EREMOTEIO; + goto out; + } else { + r = 0; + } + + /* ignore possible error here */ + wl1273_fm_write_cmd(core, WL1273_RESET, 0); + dev_dbg(dev, "n: %d, i: %d\n", n, i); + + if (n - 1 != packet_num) + dev_warn(dev, "%s - incorrect firmware size.\n", __func__); + + if (i != fw_p->size) + dev_warn(dev, "%s - inconsistent firmware.\n", __func__); + + dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r); + +out: + release_firmware(fw_p); + return r; +} + +static int wl1273_fm_stop(struct wl1273_core *core) +{ + struct wl1273_fm_platform_data *pdata = + core->i2c_dev->dev.platform_data; + + if (core->mode == WL1273_MODE_RX) { + int r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, + WL1273_POWER_SET_OFF); + if (r) + dev_err(&core->i2c_dev->dev, + "%s: POWER_SET fails: %d\n", __func__, r); + } else if (core->mode == WL1273_MODE_TX) { + int r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, + WL1273_PUPD_SET_OFF); + if (r) + dev_err(&core->i2c_dev->dev, + "%s: PUPD_SET fails: %d\n", __func__, r); + } + + if (pdata->disable) { + pdata->disable(); + dev_dbg(&core->i2c_dev->dev, "Back to reset\n"); + } + + return 0; +} + +static int wl1273_fm_start(struct wl1273_core *core, int new_mode) +{ + struct wl1273_fm_platform_data *pdata = + core->i2c_dev->dev.platform_data; + struct device *dev = &core->i2c_dev->dev; + int r = -EINVAL; + + if (pdata->enable && core->mode == WL1273_MODE_OFF) { + dev_dbg(dev, "Out of reset\n"); + + pdata->enable(); + msleep(250); + } + + if (new_mode == WL1273_MODE_RX) { + u16 val = WL1273_POWER_SET_FM; + + if (core->rds_on) + val |= WL1273_POWER_SET_RDS; + + /* If this fails try again */ + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val); + if (r) { + msleep(100); + + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val); + if (r) { + dev_err(dev, "%s: POWER_SET fails\n", __func__); + goto fail; + } + } + + /* rds buffer configuration */ + core->wr_index = 0; + core->rd_index = 0; + + } else if (new_mode == WL1273_MODE_TX) { + /* If this fails try again */ + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, + WL1273_PUPD_SET_ON); + if (r) { + msleep(100); + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, + WL1273_PUPD_SET_ON); + if (r) { + dev_err(dev, "%s: PUPD_SET fails\n", __func__); + goto fail; + } + } + + if (core->rds_on) + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1); + else + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0); + } else { + dev_warn(dev, "%s: Illegal mode.\n", __func__); + } + + if (core->mode == WL1273_MODE_OFF) { + r = wl1273_fm_upload_firmware_patch(core); + if (r) + dev_warn(dev, "Firmware upload failed.\n"); + + /* + * Sometimes the chip is in a wrong power state at this point. + * So we set the power once again. + */ + if (new_mode == WL1273_MODE_RX) { + u16 val = WL1273_POWER_SET_FM; + + if (core->rds_on) + val |= WL1273_POWER_SET_RDS; + + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val); + if (r) { + dev_err(dev, "%s: POWER_SET fails\n", __func__); + goto fail; + } + } else if (new_mode == WL1273_MODE_TX) { + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, + WL1273_PUPD_SET_ON); + if (r) { + dev_err(dev, "%s: PUPD_SET fails\n", __func__); + goto fail; + } + } + } + + return 0; +fail: + if (pdata->disable) + pdata->disable(); + + dev_dbg(dev, "%s: return: %d\n", __func__, r); + return r; +} + +static int wl1273_fm_suspend(struct wl1273_core *core) +{ + int r = 0; + struct device *dev = &core->i2c_dev->dev; + + /* Cannot go from OFF to SUSPENDED */ + if (core->mode == WL1273_MODE_RX) + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, + WL1273_POWER_SET_RETENTION); + else if (core->mode == WL1273_MODE_TX) + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, + WL1273_PUPD_SET_RETENTION); + else + r = -EINVAL; + + if (r) { + dev_err(dev, "%s: POWER_SET fails: %d\n", __func__, r); + goto out; + } + +out: + return r; +} + +static int wl1273_fm_set_mode(struct wl1273_core *core, int mode) +{ + int r; + int old_mode; + struct device *dev = &core->i2c_dev->dev; + + dev_dbg(dev, "%s\n", __func__); + dev_dbg(dev, "Forbidden modes: 0x%02x\n", core->forbidden); + + old_mode = core->mode; + if (mode & core->forbidden) { + r = -EPERM; + goto out; + } + + switch (mode) { + case WL1273_MODE_RX: + case WL1273_MODE_TX: + r = wl1273_fm_start(core, mode); + if (r) { + dev_err(dev, "%s: Cannot start.\n", __func__); + wl1273_fm_stop(core); + goto out; + } + + core->mode = mode; + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, + core->irq_flags); + if (r) { + dev_err(dev, "INT_MASK_SET fails.\n"); + goto out; + } + + /* remember previous settings */ + if (mode == WL1273_MODE_RX) { + r = wl1273_fm_set_rx_freq(core, core->rx_frequency); + if (r) { + dev_err(dev, "set freq fails: %d.\n", r); + goto out; + } + + r = wl1273_fm_set_volume(core, core->volume); + if (r) { + dev_err(dev, "set volume fails: %d.\n", r); + goto out; + } + + dev_dbg(dev, "%s: Set vol: %d.\n", __func__, + core->volume); + } else { + r = wl1273_fm_set_tx_freq(core, core->tx_frequency); + if (r) { + dev_err(dev, "set freq fails: %d.\n", r); + goto out; + } + } + + dev_dbg(dev, "%s: Set audio mode.\n", __func__); + + r = wl1273_fm_set_audio(core, core->audio_mode); + if (r) + dev_err(dev, "Cannot set audio mode.\n"); + break; + + case WL1273_MODE_OFF: + r = wl1273_fm_stop(core); + if (r) + dev_err(dev, "%s: Off fails: %d\n", __func__, r); + else + core->mode = WL1273_MODE_OFF; + + break; + + case WL1273_MODE_SUSPENDED: + r = wl1273_fm_suspend(core); + if (r) + dev_err(dev, "%s: Suspend fails: %d\n", __func__, r); + else + core->mode = WL1273_MODE_SUSPENDED; + + break; + + default: + dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode); + r = -EINVAL; + break; + } + +out: + if (r) + core->mode = old_mode; + + return r; +} + +static int wl1273_fm_set_seek(struct wl1273_core *core, + unsigned int wrap_around, + unsigned int seek_upward, + int level) +{ + int r = 0; + unsigned int dir = (seek_upward == 0) ? 0 : 1; + unsigned int rx_frequency, top_frequency, bottom_frequency; + + rx_frequency = core->rx_frequency; + top_frequency = core->bands[core->band].top_frequency; + bottom_frequency = core->bands[core->band].bottom_frequency; + dev_dbg(&core->i2c_dev->dev, "core->rx_frequency: %d\n", + rx_frequency); + + if (dir && rx_frequency + core->spacing <= top_frequency) + r = wl1273_fm_set_rx_freq(core, rx_frequency + core->spacing); + else if (dir && wrap_around) + r = wl1273_fm_set_rx_freq(core, bottom_frequency); + else if (rx_frequency - core->spacing >= bottom_frequency) + r = wl1273_fm_set_rx_freq(core, rx_frequency - core->spacing); + else if (wrap_around) + r = wl1273_fm_set_rx_freq(core, top_frequency); + + if (r) + goto out; + + if (level < SCHAR_MIN || level > SCHAR_MAX) + return -EINVAL; + + INIT_COMPLETION(core->busy); + dev_dbg(&core->i2c_dev->dev, "%s: BUSY\n", __func__); + + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, core->irq_flags); + if (r) + goto out; + + dev_dbg(&core->i2c_dev->dev, "%s\n", __func__); + + r = wl1273_fm_write_cmd(core, WL1273_SEARCH_LVL_SET, level); + if (r) + goto out; + + r = wl1273_fm_write_cmd(core, WL1273_SEARCH_DIR_SET, dir); + if (r) + goto out; + + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, + TUNER_MODE_AUTO_SEEK); + if (r) + goto out; + + wait_for_completion_timeout(&core->busy, msecs_to_jiffies(1000)); + if (!(core->irq_received & WL1273_BL_EVENT)) + goto out; + + core->irq_received &= ~WL1273_BL_EVENT; + + if (!wrap_around) + goto out; + + /* Wrap around */ + dev_dbg(&core->i2c_dev->dev, "Wrap around in HW seek.\n"); + + if (seek_upward) + rx_frequency = bottom_frequency; + else + rx_frequency = top_frequency; + + r = wl1273_fm_set_rx_freq(core, rx_frequency); + if (r) + goto out; + + INIT_COMPLETION(core->busy); + dev_dbg(&core->i2c_dev->dev, "%s: BUSY\n", __func__); + + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, + TUNER_MODE_AUTO_SEEK); + if (r) + goto out; + + wait_for_completion_timeout(&core->busy, msecs_to_jiffies(1000)); +out: + dev_dbg(&core->i2c_dev->dev, "%s: Err: %d\n", __func__, r); + return r; +} + +/** + * wl1273_fm_set_band() - Change the current band. + * @core: A pointer to the device structure. + * @band: The ID of the new band. + * + * Wl1273 supports only two bands USA/Europe and Japan. + */ +static int wl1273_fm_set_band(struct wl1273_core *core, unsigned int band) +{ + int r = 0; + unsigned int new_frequency = 0; + + dev_dbg(&core->i2c_dev->dev, "%s: Number of bands: %d\n", __func__, + core->number_of_bands); + + if (band == core->band) + return 0; + + if (core->mode == WL1273_MODE_OFF || + core->mode == WL1273_MODE_SUSPENDED) + return -EPERM; + + if (band >= core->number_of_bands) + return -EINVAL; + + mutex_lock(&core->lock); + + core->band = band; + + if (core->rx_frequency < core->bands[core->band].bottom_frequency) + new_frequency = core->bands[core->band].bottom_frequency; + else if (core->rx_frequency > core->bands[core->band].top_frequency) + new_frequency = core->bands[core->band].top_frequency; + + if (new_frequency) { + core->rx_frequency = new_frequency; + if (core->mode == WL1273_MODE_RX) { + r = wl1273_fm_set_rx_freq(core, new_frequency); + if (r) + goto out; + } + } + + new_frequency = 0; + if (core->tx_frequency < core->bands[core->band].bottom_frequency) + new_frequency = core->bands[core->band].bottom_frequency; + else if (core->tx_frequency > core->bands[core->band].top_frequency) + new_frequency = core->bands[core->band].top_frequency; + + if (new_frequency) { + core->tx_frequency = new_frequency; + + if (core->mode == WL1273_MODE_TX) { + r = wl1273_fm_set_tx_freq(core, new_frequency); + if (r) + goto out; + } + } + +out: + mutex_unlock(&core->lock); + return r; +} + +/** + * wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value. + * @core: A pointer to the device struct. + */ +static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_core *core) +{ + struct device *dev = &core->i2c_dev->dev; + u16 val; + int r; + + if (core->mode == WL1273_MODE_OFF || + core->mode == WL1273_MODE_SUSPENDED) + return -EPERM; + + r = wl1273_fm_read_reg(core, WL1273_READ_FMANT_TUNE_VALUE, &val); + if (r) { + dev_err(dev, "%s: I2C error: %d\n", __func__, r); + goto out; + } + +out: + return val; +} + +/** + * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value. + * @core: A pointer to the device struct. + * @preemphasis: The new pre-amphasis value. + * + * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED, + * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS. + */ +static int wl1273_fm_set_preemphasis(struct wl1273_core *core, + unsigned int preemphasis) +{ + int r; + u16 em; + + if (core->mode == WL1273_MODE_OFF || + core->mode == WL1273_MODE_SUSPENDED) + return -EPERM; + + mutex_lock(&core->lock); + + switch (preemphasis) { + case V4L2_PREEMPHASIS_DISABLED: + em = 1; + break; + case V4L2_PREEMPHASIS_50_uS: + em = 0; + break; + case V4L2_PREEMPHASIS_75_uS: + em = 2; + break; + default: + r = -EINVAL; + goto out; + } + + r = wl1273_fm_write_cmd(core, WL1273_PREMPH_SET, em); + if (r) + goto out; + + core->preemphasis = preemphasis; + +out: + mutex_unlock(&core->lock); + return r; +} + +static int wl1273_fm_rds_on(struct wl1273_core *core) +{ + int r; + + dev_dbg(&core->i2c_dev->dev, "%s\n", __func__); + if (core->rds_on) + return 0; + + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, + WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS); + if (r) + goto out; + + r = wl1273_fm_set_rx_freq(core, core->rx_frequency); + if (r) + dev_err(&core->i2c_dev->dev, "set freq fails: %d.\n", r); +out: + return r; +} + +static int wl1273_fm_rds_off(struct wl1273_core *core) +{ + struct device *dev = &core->i2c_dev->dev; + int r; + + if (!core->rds_on) + return 0; + + core->irq_flags &= ~WL1273_RDS_EVENT; + + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, core->irq_flags); + if (r) + goto out; + + /* stop rds reception */ + cancel_delayed_work(&core->work); + + /* Service pending read */ + wake_up_interruptible(&core->read_queue); + + dev_dbg(dev, "%s\n", __func__); + + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, WL1273_POWER_SET_FM); + if (r) + goto out; + + r = wl1273_fm_set_rx_freq(core, core->rx_frequency); + if (r) + dev_err(&core->i2c_dev->dev, "set freq fails: %d.\n", r); + +out: + dev_dbg(dev, "%s: exiting...\n", __func__); + + return r; +} + +static int wl1273_fm_set_rds(struct wl1273_core *core, unsigned int new_mode) +{ + int r = 0; + struct device *dev = &core->i2c_dev->dev; + + if (core->mode == WL1273_MODE_OFF || + core->mode == WL1273_MODE_SUSPENDED) + return -EPERM; + + if (new_mode == WL1273_RDS_RESET) { + r = wl1273_fm_write_cmd(core, WL1273_RDS_CNTRL_SET, 1); + return r; + } + + if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) { + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0); + } else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) { + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1); + } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) { + r = wl1273_fm_rds_off(core); + } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) { + r = wl1273_fm_rds_on(core); + } else { + dev_err(dev, "%s: Unknown mode: %d\n", __func__, new_mode); + r = -EINVAL; + } + + if (!r) + core->rds_on = (new_mode == WL1273_RDS_ON) ? true : false; + + return r; +} + +static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf, + size_t count, loff_t *ppos) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + u16 val; + int r; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (radio->core->mode != WL1273_MODE_TX) + return count; + + if (radio->rds_users == 0) { + dev_warn(radio->dev, "%s: RDS not on.\n", __func__); + return 0; + } + + if (mutex_lock_interruptible(&radio->core->lock)) + return -EINTR; + /* + * Multiple processes can open the device, but only + * one gets to write to it. + */ + if (radio->owner && radio->owner != file) { + r = -EBUSY; + goto out; + } + radio->owner = file; + + /* Manual Mode */ + if (count > 255) + val = 255; + else + val = count; + + wl1273_fm_write_cmd(radio->core, WL1273_RDS_CONFIG_DATA_SET, val); + + if (copy_from_user(radio->write_buf + 1, buf, val)) { + r = -EFAULT; + goto out; + } + + dev_dbg(radio->dev, "Count: %d\n", val); + dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf); + + radio->write_buf[0] = WL1273_RDS_DATA_SET; + wl1273_fm_write_data(radio->core, radio->write_buf, val + 1); + + r = val; +out: + mutex_unlock(&radio->core->lock); + + return r; +} + +static unsigned int wl1273_fm_fops_poll(struct file *file, + struct poll_table_struct *pts) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + + if (radio->owner && radio->owner != file) + return -EBUSY; + + radio->owner = file; + + if (core->mode == WL1273_MODE_RX) { + poll_wait(file, &core->read_queue, pts); + + if (core->rd_index != core->wr_index) + return POLLIN | POLLRDNORM; + + } else if (core->mode == WL1273_MODE_TX) { + return POLLOUT | POLLWRNORM; + } + + return 0; +} + +static int wl1273_fm_fops_open(struct file *file) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + int r = 0; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (core->mode == WL1273_MODE_RX && core->rds_on && !radio->rds_users) { + dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode); + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + core->irq_flags |= WL1273_RDS_EVENT; + + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, + core->irq_flags); + if (r) { + mutex_unlock(&core->lock); + goto out; + } + + radio->rds_users++; + + mutex_unlock(&core->lock); + } +out: + return r; +} + +static int wl1273_fm_fops_release(struct file *file) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + int r = 0; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (radio->rds_users > 0) { + radio->rds_users--; + if (radio->rds_users == 0) { + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + core->irq_flags &= ~WL1273_RDS_EVENT; + + if (core->mode == WL1273_MODE_RX) { + dev_dbg(radio->dev, "%s: A'\n", __func__); + r = wl1273_fm_write_cmd(core, + WL1273_INT_MASK_SET, + core->irq_flags); + if (r) { + mutex_unlock(&core->lock); + goto out; + } + } + mutex_unlock(&core->lock); + } + } + + if (file == radio->owner) + radio->owner = NULL; +out: + return r; +} + +static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf, + size_t count, loff_t *ppos) +{ + int r = 0; + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + unsigned int block_count = 0; + u16 val; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (radio->core->mode != WL1273_MODE_RX) + return 0; + + if (radio->rds_users == 0) { + dev_warn(radio->dev, "%s: RDS not on.\n", __func__); + return 0; + } + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + /* + * Multiple processes can open the device, but only + * one gets to read from it. + */ + if (radio->owner && radio->owner != file) { + r = -EBUSY; + goto out; + } + radio->owner = file; + + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); + if (r) { + dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__); + goto out; + } else if (val == 0) { + dev_info(radio->dev, "RDS_SYNC: Not synchronized\n"); + r = -ENODATA; + goto out; + } + + /* block if no new data available */ + while (core->wr_index == core->rd_index) { + if (file->f_flags & O_NONBLOCK) { + r = -EWOULDBLOCK; + goto out; + } + + dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__); + if (wait_event_interruptible(core->read_queue, + core->wr_index != + core->rd_index) < 0) { + r = -EINTR; + goto out; + } + } + + /* calculate block count from byte count */ + count /= 3; + + /* copy RDS blocks from the internal buffer and to user buffer */ + while (block_count < count) { + if (core->rd_index == core->wr_index) + break; + + /* always transfer complete RDS blocks */ + if (copy_to_user(buf, &core->buffer[core->rd_index], 3)) + break; + + /* increment and wrap the read pointer */ + core->rd_index += 3; + if (core->rd_index >= core->buf_size) + core->rd_index = 0; + + /* increment counters */ + block_count++; + buf += 3; + r += 3; + } + +out: + dev_dbg(radio->dev, "%s: exit\n", __func__); + mutex_unlock(&core->lock); + + return r; +} + +static const struct v4l2_file_operations wl1273_fops = { + .owner = THIS_MODULE, + .read = wl1273_fm_fops_read, + .write = wl1273_fm_fops_write, + .poll = wl1273_fm_fops_poll, + .ioctl = video_ioctl2, + .open = wl1273_fm_fops_open, + .release = wl1273_fm_fops_release, +}; + +static int wl1273_fm_vidioc_querycap(struct file *file, void *priv, + struct v4l2_capability *capability) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + + dev_dbg(radio->dev, "%s\n", __func__); + + strlcpy(capability->driver, WL1273_FM_DRIVER_NAME, + sizeof(capability->driver)); + strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio", + sizeof(capability->card)); + strlcpy(capability->bus_info, "I2C", sizeof(capability->bus_info)); + + capability->capabilities = V4L2_CAP_HW_FREQ_SEEK | + V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO | + V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR | + V4L2_CAP_RDS_OUTPUT | V4L2_CAP_RAW_RDS_ONLY; + + return 0; +} + +static int wl1273_fm_vidioc_g_input(struct file *file, void *priv, + unsigned int *i) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + + dev_dbg(radio->dev, "%s\n", __func__); + + *i = 0; + + return 0; +} + +static int wl1273_fm_vidioc_s_input(struct file *file, void *priv, + unsigned int i) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + + dev_dbg(radio->dev, "%s\n", __func__); + + if (i != 0) + return -EINVAL; + + return 0; +} + +/** + * wl1273_fm_set_tx_power() - Set the transmission power value. + * @core: A pointer to the device struct. + * @power: The new power value. + */ +static int wl1273_fm_set_tx_power(struct wl1273_core *core, u16 power) +{ + int r; + + if (core->mode == WL1273_MODE_OFF || + core->mode == WL1273_MODE_SUSPENDED) + return -EPERM; + + mutex_lock(&core->lock); + + /* Convert the dBuV value to chip presentation */ + r = wl1273_fm_write_cmd(core, WL1273_POWER_LEV_SET, 122 - power); + if (r) + goto out; + + core->tx_power = power; + +out: + mutex_unlock(&core->lock); + return r; +} + +#define WL1273_SPACING_50kHz 1 +#define WL1273_SPACING_100kHz 2 +#define WL1273_SPACING_200kHz 4 + +static int wl1273_fm_tx_set_spacing(struct wl1273_core *core, + unsigned int spacing) +{ + int r; + + if (spacing == 0) { + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, + WL1273_SPACING_100kHz); + core->spacing = 100; + } else if (spacing - 50000 < 25000) { + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, + WL1273_SPACING_50kHz); + core->spacing = 50; + } else if (spacing - 100000 < 50000) { + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, + WL1273_SPACING_100kHz); + core->spacing = 100; + } else { + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, + WL1273_SPACING_200kHz); + core->spacing = 200; + } + + return r; +} + +static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl) +{ + struct wl1273_device *radio = ctrl->priv; + struct wl1273_core *core = radio->core; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + switch (ctrl->id) { + case V4L2_CID_TUNE_ANTENNA_CAPACITOR: + ctrl->val = wl1273_fm_get_tx_ctune(core); + break; + + default: + dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n", + __func__, ctrl->id); + break; + } + + mutex_unlock(&core->lock); + + return 0; +} + +#define WL1273_MUTE_SOFT_ENABLE (1 << 0) +#define WL1273_MUTE_AC (1 << 1) +#define WL1273_MUTE_HARD_LEFT (1 << 2) +#define WL1273_MUTE_HARD_RIGHT (1 << 3) +#define WL1273_MUTE_SOFT_FORCE (1 << 4) + +static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl) +{ + return container_of(ctrl->handler, struct wl1273_device, ctrl_handler); +} + +static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl) +{ + struct wl1273_device *radio = to_radio(ctrl); + struct wl1273_core *core = radio->core; + int r = 0; + + dev_dbg(radio->dev, "%s\n", __func__); + + switch (ctrl->id) { + case V4L2_CID_AUDIO_MUTE: + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + if (core->mode == WL1273_MODE_RX && ctrl->val) + r = wl1273_fm_write_cmd(core, + WL1273_MUTE_STATUS_SET, + WL1273_MUTE_HARD_LEFT | + WL1273_MUTE_HARD_RIGHT); + else if (core->mode == WL1273_MODE_RX) + r = wl1273_fm_write_cmd(core, + WL1273_MUTE_STATUS_SET, 0x0); + else if (core->mode == WL1273_MODE_TX && ctrl->val) + r = wl1273_fm_write_cmd(core, WL1273_MUTE, 1); + else if (core->mode == WL1273_MODE_TX) + r = wl1273_fm_write_cmd(core, WL1273_MUTE, 0); + + mutex_unlock(&core->lock); + break; + + case V4L2_CID_AUDIO_VOLUME: + if (ctrl->val == 0) + r = wl1273_fm_set_mode(core, WL1273_MODE_OFF); + else + r = wl1273_fm_set_volume(core, core->volume); + break; + + case V4L2_CID_TUNE_PREEMPHASIS: + r = wl1273_fm_set_preemphasis(core, ctrl->val); + break; + + case V4L2_CID_TUNE_POWER_LEVEL: + r = wl1273_fm_set_tx_power(core, ctrl->val); + break; + + case V4L2_CID_FM_BAND: + r = wl1273_fm_set_band(core, ctrl->val); + break; + + default: + dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n", + __func__, ctrl->id); + break; + } + + dev_dbg(radio->dev, "%s\n", __func__); + return r; +} + +static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv, + struct v4l2_audio *audio) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + + dev_dbg(radio->dev, "%s\n", __func__); + + if (audio->index > 1) + return -EINVAL; + + strlcpy(audio->name, "Radio", sizeof(audio->name)); + audio->capability = V4L2_AUDCAP_STEREO; + + return 0; +} + +static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv, + struct v4l2_audio *audio) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + + dev_dbg(radio->dev, "%s\n", __func__); + + if (audio->index != 0) + return -EINVAL; + + return 0; +} + +#define WL1273_RDS_NOT_SYNCHRONIZED 0 +#define WL1273_RDS_SYNCHRONIZED 1 + +static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv, + struct v4l2_tuner *tuner) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + u16 val; + int r; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (tuner->index > 0) + return -EINVAL; + + strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name)); + tuner->type = V4L2_TUNER_RADIO; + + tuner->rangelow = + WL1273_FREQ(core->bands[core->band].bottom_frequency); + tuner->rangehigh = + WL1273_FREQ(core->bands[core->band].top_frequency); + + tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS | + V4L2_TUNER_CAP_STEREO; + + if (core->stereo) + tuner->audmode = V4L2_TUNER_MODE_STEREO; + else + tuner->audmode = V4L2_TUNER_MODE_MONO; + + if (core->mode != WL1273_MODE_RX) + return 0; + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val); + if (r) + goto out; + + if (val == 1) + tuner->rxsubchans = V4L2_TUNER_SUB_STEREO; + else + tuner->rxsubchans = V4L2_TUNER_SUB_MONO; + + r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val); + if (r) + goto out; + + tuner->signal = (s16) val; + dev_dbg(radio->dev, "Signal: %d\n", tuner->signal); + + tuner->afc = 0; + + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); + if (r) + goto out; + + if (val == WL1273_RDS_SYNCHRONIZED) + tuner->rxsubchans |= V4L2_TUNER_SUB_RDS; +out: + mutex_unlock(&core->lock); + + return r; +} + +static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv, + struct v4l2_tuner *tuner) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + int r = 0; + + dev_dbg(radio->dev, "%s\n", __func__); + dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index); + dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name); + dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability); + dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans); + dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow); + dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh); + + if (tuner->index > 0) + return -EINVAL; + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + r = wl1273_fm_set_mode(core, WL1273_MODE_RX); + if (r) + goto out; + + if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS) + r = wl1273_fm_set_rds(core, WL1273_RDS_ON); + else + r = wl1273_fm_set_rds(core, WL1273_RDS_OFF); + + if (r) + dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r); + + if (tuner->audmode == V4L2_TUNER_MODE_MONO) { + r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET, + WL1273_RX_MONO); + if (r < 0) { + dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n", + __func__, r); + goto out; + } + core->stereo = false; + } else if (tuner->audmode == V4L2_TUNER_MODE_MONO) { + r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET, + WL1273_RX_STEREO); + if (r < 0) { + dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n", + __func__, r); + goto out; + } + core->stereo = true; + } else { + dev_err(radio->dev, "%s: tuner->audmode: %d\n", + __func__, tuner->audmode); + r = -EINVAL; + goto out; + } + +out: + mutex_unlock(&core->lock); + + return r; +} + +static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv, + struct v4l2_frequency *freq) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + freq->type = V4L2_TUNER_RADIO; + freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(core)); + + mutex_unlock(&core->lock); + + return 0; +} + +static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv, + struct v4l2_frequency *freq) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + int r; + + dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency); + + if (freq->type != V4L2_TUNER_RADIO) { + dev_dbg(radio->dev, + "freq->type != V4L2_TUNER_RADIO: %d\n", freq->type); + return -EINVAL; + } + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + if (core->mode == WL1273_MODE_RX) { + dev_dbg(radio->dev, "freq: %d\n", freq->frequency); + + r = wl1273_fm_set_rx_freq(core, + WL1273_INV_FREQ(freq->frequency)); + if (r) + dev_warn(radio->dev, WL1273_FM_DRIVER_NAME + ": set frequency failed with %d\n", r); + } else { + r = wl1273_fm_set_tx_freq(core, + WL1273_INV_FREQ(freq->frequency)); + if (r) + dev_warn(radio->dev, WL1273_FM_DRIVER_NAME + ": set frequency failed with %d\n", r); + } + + mutex_unlock(&core->lock); + + dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n"); + return r; +} + +#define WL1273_DEFAULT_SEEK_LEVEL 7 + +static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv, + struct v4l2_hw_freq_seek *seek) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + int r; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO) + return -EINVAL; + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + r = wl1273_fm_set_mode(core, WL1273_MODE_RX); + if (r) + goto out; + + r = wl1273_fm_tx_set_spacing(core, seek->spacing); + if (r) + dev_warn(radio->dev, "HW seek failed: %d\n", r); + + r = wl1273_fm_set_seek(core, seek->wrap_around, seek->seek_upward, + WL1273_DEFAULT_SEEK_LEVEL); + if (r) + dev_warn(radio->dev, "HW seek failed: %d\n", r); + +out: + mutex_unlock(&core->lock); + return r; +} + +static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv, + struct v4l2_modulator *modulator) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + int r = 0; + + dev_dbg(radio->dev, "%s\n", __func__); + + if (modulator->index > 0) + return -EINVAL; + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + r = wl1273_fm_set_mode(core, WL1273_MODE_TX); + if (r) + goto out; + + if (modulator->txsubchans & V4L2_TUNER_SUB_RDS) + r = wl1273_fm_set_rds(core, WL1273_RDS_ON); + else + r = wl1273_fm_set_rds(core, WL1273_RDS_OFF); + + if (modulator->txsubchans & V4L2_TUNER_SUB_MONO) + r = wl1273_fm_write_cmd(core, WL1273_MONO_SET, WL1273_TX_MONO); + else + r = wl1273_fm_write_cmd(core, WL1273_MONO_SET, + WL1273_RX_STEREO); + if (r < 0) + dev_warn(radio->dev, WL1273_FM_DRIVER_NAME + "MONO_SET fails: %d\n", r); +out: + mutex_unlock(&core->lock); + + return r; +} + +static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv, + struct v4l2_modulator *modulator) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + u16 val; + int r; + + dev_dbg(radio->dev, "%s\n", __func__); + + strlcpy(modulator->name, WL1273_FM_DRIVER_NAME, + sizeof(modulator->name)); + + modulator->rangelow = + WL1273_FREQ(core->bands[core->band].bottom_frequency); + modulator->rangehigh = + WL1273_FREQ(core->bands[core->band].top_frequency); + + modulator->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS | + V4L2_TUNER_CAP_STEREO; + + if (core->mode != WL1273_MODE_TX) + return 0; + + if (mutex_lock_interruptible(&core->lock)) + return -EINTR; + + r = wl1273_fm_read_reg(core, WL1273_MONO_SET, &val); + if (r) + goto out; + + if (val == WL1273_TX_STEREO) + modulator->txsubchans = V4L2_TUNER_SUB_STEREO; + else + modulator->txsubchans = V4L2_TUNER_SUB_MONO; + + if (core->rds_on) + modulator->txsubchans |= V4L2_TUNER_SUB_RDS; +out: + mutex_unlock(&core->lock); + + return 0; +} + +static int wl1273_fm_vidioc_log_status(struct file *file, void *priv) +{ + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); + struct wl1273_core *core = radio->core; + struct device *dev = radio->dev; + u16 val; + int r; + + dev_info(dev, DRIVER_DESC); + + if (core->mode == WL1273_MODE_OFF) { + dev_info(dev, "Mode: Off\n"); + return 0; + } + + if (core->mode == WL1273_MODE_SUSPENDED) { + dev_info(dev, "Mode: Suspended\n"); + return 0; + } + + r = wl1273_fm_read_reg(core, WL1273_ASIC_ID_GET, &val); + if (r) + dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__); + else + dev_info(dev, "ASIC_ID: 0x%04x\n", val); + + r = wl1273_fm_read_reg(core, WL1273_ASIC_VER_GET, &val); + if (r) + dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__); + else + dev_info(dev, "ASIC Version: 0x%04x\n", val); + + r = wl1273_fm_read_reg(core, WL1273_FIRM_VER_GET, &val); + if (r) + dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__); + else + dev_info(dev, "FW version: %d(0x%04x)\n", val, val); + + r = wl1273_fm_read_reg(core, WL1273_BAND_SET, &val); + if (r) + dev_err(dev, "%s: Get BAND fails.\n", __func__); + else + dev_info(dev, "BAND: %d\n", val); + + if (core->mode == WL1273_MODE_TX) { + r = wl1273_fm_read_reg(core, WL1273_PUPD_SET, &val); + if (r) + dev_err(dev, "%s: Get PUPD fails.\n", __func__); + else + dev_info(dev, "PUPD: 0x%04x\n", val); + + r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &val); + if (r) + dev_err(dev, "%s: Get CHANL fails.\n", __func__); + else + dev_info(dev, "Tx frequency: %dkHz\n", val*10); + } else if (core->mode == WL1273_MODE_RX) { + int bf = core->bands[core->band].bottom_frequency; + + r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &val); + if (r) + dev_err(dev, "%s: Get FREQ fails.\n", __func__); + else + dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50); + + r = wl1273_fm_read_reg(core, WL1273_MOST_MODE_SET, &val); + if (r) + dev_err(dev, "%s: Get MOST_MODE fails.\n", + __func__); + else if (val == 0) + dev_info(dev, "MOST_MODE: Stereo according to blend\n"); + else if (val == 1) + dev_info(dev, "MOST_MODE: Force mono output\n"); + else + dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val); + + r = wl1273_fm_read_reg(core, WL1273_MOST_BLEND_SET, &val); + if (r) + dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__); + else if (val == 0) + dev_info(dev, + "MOST_BLEND: Switched blend & hysteresis.\n"); + else if (val == 1) + dev_info(dev, "MOST_BLEND: Soft blend.\n"); + else + dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val); + + r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val); + if (r) + dev_err(dev, "%s: Get STEREO fails.\n", __func__); + else if (val == 0) + dev_info(dev, "STEREO: Not detected\n"); + else if (val == 1) + dev_info(dev, "STEREO: Detected\n"); + else + dev_info(dev, "STEREO: Unexpected value: %d\n", val); + + r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val); + if (r) + dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__); + else + dev_info(dev, "RX signal strength: %d\n", (s16) val); + + r = wl1273_fm_read_reg(core, WL1273_POWER_SET, &val); + if (r) + dev_err(dev, "%s: Get POWER fails.\n", __func__); + else + dev_info(dev, "POWER: 0x%04x\n", val); + + r = wl1273_fm_read_reg(core, WL1273_INT_MASK_SET, &val); + if (r) + dev_err(dev, "%s: Get INT_MASK fails.\n", __func__); + else + dev_info(dev, "INT_MASK: 0x%04x\n", val); + + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); + if (r) + dev_err(dev, "%s: Get RDS_SYNC fails.\n", + __func__); + else if (val == 0) + dev_info(dev, "RDS_SYNC: Not synchronized\n"); + + else if (val == 1) + dev_info(dev, "RDS_SYNC: Synchronized\n"); + else + dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val); + + r = wl1273_fm_read_reg(core, WL1273_I2S_MODE_CONFIG_SET, &val); + if (r) + dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n", + __func__); + else + dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val); + + r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val); + if (r) + dev_err(dev, "%s: Get VOLUME fails.\n", __func__); + else + dev_info(dev, "VOLUME: 0x%04x\n", val); + } + + return 0; +} + +static void wl1273_vdev_release(struct video_device *dev) +{ +} + +static const struct v4l2_ctrl_ops wl1273_ctrl_ops = { + .s_ctrl = wl1273_fm_vidioc_s_ctrl, + .g_volatile_ctrl = wl1273_fm_g_volatile_ctrl, +}; + +static const struct v4l2_ioctl_ops wl1273_ioctl_ops = { + .vidioc_querycap = wl1273_fm_vidioc_querycap, + .vidioc_g_input = wl1273_fm_vidioc_g_input, + .vidioc_s_input = wl1273_fm_vidioc_s_input, + .vidioc_g_audio = wl1273_fm_vidioc_g_audio, + .vidioc_s_audio = wl1273_fm_vidioc_s_audio, + .vidioc_g_tuner = wl1273_fm_vidioc_g_tuner, + .vidioc_s_tuner = wl1273_fm_vidioc_s_tuner, + .vidioc_g_frequency = wl1273_fm_vidioc_g_frequency, + .vidioc_s_frequency = wl1273_fm_vidioc_s_frequency, + .vidioc_s_hw_freq_seek = wl1273_fm_vidioc_s_hw_freq_seek, + .vidioc_g_modulator = wl1273_fm_vidioc_g_modulator, + .vidioc_s_modulator = wl1273_fm_vidioc_s_modulator, + .vidioc_log_status = wl1273_fm_vidioc_log_status, +}; + +static struct video_device wl1273_viddev_template = { + .fops = &wl1273_fops, + .ioctl_ops = &wl1273_ioctl_ops, + .name = WL1273_FM_DRIVER_NAME, + .release = wl1273_vdev_release, +}; + +static int wl1273_fm_radio_remove(struct platform_device *pdev) +{ + struct wl1273_device *radio = platform_get_drvdata(pdev);; + + dev_info(&pdev->dev, "%s.\n", __func__); + + v4l2_ctrl_handler_free(&radio->ctrl_handler); + video_unregister_device(&radio->videodev); + v4l2_device_unregister(&radio->v4l2dev); + kfree(radio->write_buf); + kfree(radio); + + return 0; +} + +static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev) +{ + struct wl1273_core **pdata = pdev->dev.platform_data; + struct wl1273_device *radio; + struct v4l2_ctrl *ctrl; + int r = 0; + + dev_dbg(&pdev->dev, "%s\n", __func__); + + if (!pdata) { + dev_err(&pdev->dev, "No platform data.\n"); + r = -EINVAL; + goto pdata_err; + } + + radio = kzalloc(sizeof(*radio), GFP_KERNEL); + if (!radio) { + r = -ENOMEM; + goto pdata_err; + } + + radio->write_buf = kmalloc(256, GFP_KERNEL); + if (!radio->write_buf) { + r = -ENOMEM; + goto write_buf_err; + } + + radio->core = *pdata; + radio->dev = &pdev->dev; + radio->v4l2dev.ctrl_handler = &radio->ctrl_handler; + radio->rds_users = 0; + + r = v4l2_device_register(&pdev->dev, &radio->v4l2dev); + if (r) { + dev_err(&pdev->dev, "Cannot register v4l2_device.\n"); + goto device_register_err; + } + + /* V4L2 configuration */ + memcpy(&radio->videodev, &wl1273_viddev_template, + sizeof(wl1273_viddev_template)); + + radio->videodev.v4l2_dev = &radio->v4l2dev; + + /* register video device */ + r = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr); + if (r) { + dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME + ": Could not register video device\n"); + goto video_register_err; + } + + v4l2_ctrl_handler_init(&radio->ctrl_handler, 6); + /* add in ascending ID order */ + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, + V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1, + WL1273_DEFAULT_VOLUME); + + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, + V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); + + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, + V4L2_CID_TUNE_PREEMPHASIS, V4L2_PREEMPHASIS_DISABLED, + V4L2_PREEMPHASIS_75_uS, 1, V4L2_PREEMPHASIS_50_uS); + + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, + V4L2_CID_TUNE_POWER_LEVEL, 91, 122, 1, 118); + + ctrl = v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, + V4L2_CID_TUNE_ANTENNA_CAPACITOR, + 0, 255, 1, 255); + if (ctrl) + ctrl->is_volatile = 1; + + v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops, + V4L2_CID_FM_BAND, V4L2_FM_BAND_JAPAN, 0, + V4L2_FM_BAND_OTHER); + + if (radio->ctrl_handler.error) { + r = radio->ctrl_handler.error; + goto handler_init_err; + } + + video_set_drvdata(&radio->videodev, radio); + platform_set_drvdata(pdev, radio); + + return 0; + +handler_init_err: + v4l2_ctrl_handler_free(&radio->ctrl_handler); + video_unregister_device(&radio->videodev); +video_register_err: + v4l2_device_unregister(&radio->v4l2dev); +device_register_err: + kfree(radio->write_buf); +write_buf_err: + kfree(radio); +pdata_err: + return r; +} + +MODULE_ALIAS("platform:wl1273_fm_radio"); + +static struct platform_driver wl1273_fm_radio_driver = { + .probe = wl1273_fm_radio_probe, + .remove = __devexit_p(wl1273_fm_radio_remove), + .driver = { + .name = "wl1273_fm_radio", + .owner = THIS_MODULE, + }, +}; + +static int __init wl1273_fm_module_init(void) +{ + pr_info("%s\n", __func__); + return platform_driver_register(&wl1273_fm_radio_driver); +} +module_init(wl1273_fm_module_init); + +static void __exit wl1273_fm_module_exit(void) +{ + flush_scheduled_work(); + platform_driver_unregister(&wl1273_fm_radio_driver); + pr_info(DRIVER_DESC ", Exiting.\n"); +} +module_exit(wl1273_fm_module_exit); + +MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>"); +MODULE_DESCRIPTION(DRIVER_DESC); +MODULE_LICENSE("GPL"); diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig index db51ea1..ffb88c6 100644 --- a/drivers/mfd/Kconfig +++ b/drivers/mfd/Kconfig @@ -228,6 +228,11 @@ config MFD_TC35892 This driver provides common support for accessing the device, additional drivers must be enabled in order to use the functionality of the device. +config WL1273_CORE + tristate + depends on I2C + select MFD_CORE + default n config MFD_TMIO bool diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile index feaeeae..c43ab14 100644 --- a/drivers/mfd/Makefile +++ b/drivers/mfd/Makefile @@ -39,6 +39,8 @@ obj-$(CONFIG_TWL4030_POWER) += twl4030-power.o obj-$(CONFIG_TWL4030_CODEC) += twl4030-codec.o obj-$(CONFIG_TWL6030_PWM) += twl6030-pwm.o +obj-$(CONFIG_WL1273_CORE) += wl1273-core.o + obj-$(CONFIG_MFD_MC13783) += mc13783-core.o obj-$(CONFIG_MFD_CORE) += mfd-core.o -- 1.6.1.3 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* [PATCH v9 4/4] Documentation: v4l: Add hw_seek spacing and FM_RX class 2010-08-30 11:38 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls " Matti J. Aaltonen @ 2010-08-30 11:38 ` Matti J. Aaltonen 2010-09-08 18:37 ` Mauro Carvalho Chehab 2010-09-08 19:09 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio Mauro Carvalho Chehab 1 sibling, 1 reply; 23+ messages in thread From: Matti J. Aaltonen @ 2010-08-30 11:38 UTC (permalink / raw) To: linux-media, hverkuil, eduardo.valentin, mchehab; +Cc: Matti J. Aaltonen Add a couple of words about the spacing field in the HW seek struct, about the V4L2_CAP_RAW_RDS_ONLY capability flag and about the new FM RX control class. Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> --- Documentation/DocBook/v4l/controls.xml | 71 ++++++++++++++++++++ Documentation/DocBook/v4l/dev-rds.xml | 5 ++ .../DocBook/v4l/vidioc-s-hw-freq-seek.xml | 10 ++- 3 files changed, 84 insertions(+), 2 deletions(-) diff --git a/Documentation/DocBook/v4l/controls.xml b/Documentation/DocBook/v4l/controls.xml index 8408caa..e9512eb 100644 --- a/Documentation/DocBook/v4l/controls.xml +++ b/Documentation/DocBook/v4l/controls.xml @@ -2088,6 +2088,77 @@ manually or automatically if set to zero. Unit, range and step are driver-specif <para>For more details about RDS specification, refer to <xref linkend="en50067" /> document, from CENELEC.</para> </section> + <section id="fm-rx-controls"> + <title>FM Tuner Control Reference</title> + + <para>The FM Tuner (FM_RX) class includes controls for common features of +devices that are capable of receiving FM transmissions. Currently this class includes a parameter +defining the FM radio band being used.</para> + + <table pgwide="1" frame="none" id="fm-rx-control-id"> + <title>FM_RX Control IDs</title> + + <tgroup cols="4"> + <colspec colname="c1" colwidth="1*" /> + <colspec colname="c2" colwidth="6*" /> + <colspec colname="c3" colwidth="2*" /> + <colspec colname="c4" colwidth="6*" /> + <spanspec namest="c1" nameend="c2" spanname="id" /> + <spanspec namest="c2" nameend="c4" spanname="descr" /> + <thead> + <row> + <entry spanname="id" align="left">ID</entry> + <entry align="left">Type</entry> + </row><row rowsep="1"><entry spanname="descr" align="left">Description</entry> + </row> + </thead> + <tbody valign="top"> + <row><entry></entry></row> + <row> + <entry spanname="id"><constant>V4L2_CID_FM_RX_CLASS</constant> </entry> + <entry>class</entry> + </row><row><entry spanname="descr">The FM_RX class +descriptor. Calling &VIDIOC-QUERYCTRL; for this control will return a +description of this control class.</entry> + </row> + <row> + <entry spanname="id"><constant>V4L2_CID_FM_RX_BAND</constant> </entry> + <entry>integer</entry> + </row> + <row id="v4l2-fm_rx_band"><entry spanname="descr">Configures the FM radio +frequency range being used. Currently there are three bands in use, see <ulink +url="http://en.wikipedia.org/wiki/FM_broadcasting">Wikipedia</ulink>. +Usually 87.5 to 108.0 MHz is used, or some portion thereof, with a few exceptions: +In Japan, the band 76-90 MHz is used and in the former Soviet republics +and some Eastern European countries, the older 65-74 MHz band, +referred also to as the OIRT band, is still used. + +The enum v4l2_fm_rx_band defines possible values for the FM band. They are:</entry> + </row><row> + <entrytbl spanname="descr" cols="2"> + <tbody valign="top"> + <row> + <entry><constant>V4L2_FM_BAND_OTHER</constant> </entry> + <entry>Frequencies from 87.5 to 108.0 MHz</entry> + </row> + <row> + <entry><constant>V4L2_FM_BAND_JAPAN</constant> </entry> + <entry>from 65 to 74 MHz</entry> + </row> + <row> + <entry><constant>V4L2_FM_BAND_OIRT</constant> </entry> + <entry>from 65 to 74 MHz</entry> + </row> + </tbody> + </entrytbl> + + </row> + <row><entry></entry></row> + </tbody> + </tgroup> + </table> + + </section> </section> <!-- diff --git a/Documentation/DocBook/v4l/dev-rds.xml b/Documentation/DocBook/v4l/dev-rds.xml index 0869d70..39c89c2 100644 --- a/Documentation/DocBook/v4l/dev-rds.xml +++ b/Documentation/DocBook/v4l/dev-rds.xml @@ -42,6 +42,11 @@ field of &v4l2-modulator;. In order to enable the RDS transmission one must set the <constant>V4L2_TUNER_SUB_RDS</constant> bit in the <structfield>txsubchans</structfield> field of &v4l2-modulator;.</para> + <para>Devices capable of only passing through raw uninterpreted RDS data +set the flags as described above and in addition +set the <constant>V4L2_CAP_RAW_RDS_ONLY</constant> flag in +the <structfield>capabilities</structfield> field of &v4l2-capability; +returned by the &VIDIOC-QUERYCAP; ioctl.</para> </section> <section> diff --git a/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml b/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml index 14b3ec7..c30dcc4 100644 --- a/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml +++ b/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml @@ -51,7 +51,8 @@ <para>Start a hardware frequency seek from the current frequency. To do this applications initialize the <structfield>tuner</structfield>, -<structfield>type</structfield>, <structfield>seek_upward</structfield> and +<structfield>type</structfield>, <structfield>seek_upward</structfield>, +<structfield>spacing</structfield> and <structfield>wrap_around</structfield> fields, and zero out the <structfield>reserved</structfield> array of a &v4l2-hw-freq-seek; and call the <constant>VIDIOC_S_HW_FREQ_SEEK</constant> ioctl with a pointer @@ -89,7 +90,12 @@ field and the &v4l2-tuner; <structfield>index</structfield> field.</entry> </row> <row> <entry>__u32</entry> - <entry><structfield>reserved</structfield>[8]</entry> + <entry><structfield>spacing</structfield></entry> + <entry>If non-zero, defines the hardware seek resolution in Hz. The driver selects the nearest value that is supported by the device. If spacing is zero a reasonable default value is used.</entry> + </row> + <row> + <entry>__u32</entry> + <entry><structfield>reserved</structfield>[7]</entry> <entry>Reserved for future extensions. Drivers and applications must set the array to zero.</entry> </row> -- 1.6.1.3 ^ permalink raw reply related [flat|nested] 23+ messages in thread
* Re: [PATCH v9 4/4] Documentation: v4l: Add hw_seek spacing and FM_RX class 2010-08-30 11:38 ` [PATCH v9 4/4] Documentation: v4l: Add hw_seek spacing and FM_RX class Matti J. Aaltonen @ 2010-09-08 18:37 ` Mauro Carvalho Chehab 0 siblings, 0 replies; 23+ messages in thread From: Mauro Carvalho Chehab @ 2010-09-08 18:37 UTC (permalink / raw) To: Matti J. Aaltonen; +Cc: linux-media, hverkuil, eduardo.valentin Em 30-08-2010 08:38, Matti J. Aaltonen escreveu: > Add a couple of words about the spacing field in the HW seek struct, > about the V4L2_CAP_RAW_RDS_ONLY capability flag and about the > new FM RX control class. Same comment as patch 1/4: FM bandwidth can already be defined via VIDIOC_[G|S]_TUNER. So, this patch is just creating a duplicated API for something already defined. > > Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> > --- > Documentation/DocBook/v4l/controls.xml | 71 ++++++++++++++++++++ > Documentation/DocBook/v4l/dev-rds.xml | 5 ++ > .../DocBook/v4l/vidioc-s-hw-freq-seek.xml | 10 ++- > 3 files changed, 84 insertions(+), 2 deletions(-) > > diff --git a/Documentation/DocBook/v4l/controls.xml b/Documentation/DocBook/v4l/controls.xml > index 8408caa..e9512eb 100644 > --- a/Documentation/DocBook/v4l/controls.xml > +++ b/Documentation/DocBook/v4l/controls.xml > @@ -2088,6 +2088,77 @@ manually or automatically if set to zero. Unit, range and step are driver-specif > <para>For more details about RDS specification, refer to > <xref linkend="en50067" /> document, from CENELEC.</para> > </section> > + <section id="fm-rx-controls"> > + <title>FM Tuner Control Reference</title> > + > + <para>The FM Tuner (FM_RX) class includes controls for common features of > +devices that are capable of receiving FM transmissions. Currently this class includes a parameter > +defining the FM radio band being used.</para> > + > + <table pgwide="1" frame="none" id="fm-rx-control-id"> > + <title>FM_RX Control IDs</title> > + > + <tgroup cols="4"> > + <colspec colname="c1" colwidth="1*" /> > + <colspec colname="c2" colwidth="6*" /> > + <colspec colname="c3" colwidth="2*" /> > + <colspec colname="c4" colwidth="6*" /> > + <spanspec namest="c1" nameend="c2" spanname="id" /> > + <spanspec namest="c2" nameend="c4" spanname="descr" /> > + <thead> > + <row> > + <entry spanname="id" align="left">ID</entry> > + <entry align="left">Type</entry> > + </row><row rowsep="1"><entry spanname="descr" align="left">Description</entry> > + </row> > + </thead> > + <tbody valign="top"> > + <row><entry></entry></row> > + <row> > + <entry spanname="id"><constant>V4L2_CID_FM_RX_CLASS</constant> </entry> > + <entry>class</entry> > + </row><row><entry spanname="descr">The FM_RX class > +descriptor. Calling &VIDIOC-QUERYCTRL; for this control will return a > +description of this control class.</entry> > + </row> > + <row> > + <entry spanname="id"><constant>V4L2_CID_FM_RX_BAND</constant> </entry> > + <entry>integer</entry> > + </row> > + <row id="v4l2-fm_rx_band"><entry spanname="descr">Configures the FM radio > +frequency range being used. Currently there are three bands in use, see <ulink > +url="http://en.wikipedia.org/wiki/FM_broadcasting">Wikipedia</ulink>. > +Usually 87.5 to 108.0 MHz is used, or some portion thereof, with a few exceptions: > +In Japan, the band 76-90 MHz is used and in the former Soviet republics > +and some Eastern European countries, the older 65-74 MHz band, > +referred also to as the OIRT band, is still used. > + > +The enum v4l2_fm_rx_band defines possible values for the FM band. They are:</entry> > + </row><row> > + <entrytbl spanname="descr" cols="2"> > + <tbody valign="top"> > + <row> > + <entry><constant>V4L2_FM_BAND_OTHER</constant> </entry> > + <entry>Frequencies from 87.5 to 108.0 MHz</entry> > + </row> > + <row> > + <entry><constant>V4L2_FM_BAND_JAPAN</constant> </entry> > + <entry>from 65 to 74 MHz</entry> > + </row> > + <row> > + <entry><constant>V4L2_FM_BAND_OIRT</constant> </entry> > + <entry>from 65 to 74 MHz</entry> > + </row> > + </tbody> > + </entrytbl> > + > + </row> > + <row><entry></entry></row> > + </tbody> > + </tgroup> > + </table> > + > + </section> > </section> > > <!-- > diff --git a/Documentation/DocBook/v4l/dev-rds.xml b/Documentation/DocBook/v4l/dev-rds.xml > index 0869d70..39c89c2 100644 > --- a/Documentation/DocBook/v4l/dev-rds.xml > +++ b/Documentation/DocBook/v4l/dev-rds.xml > @@ -42,6 +42,11 @@ field of &v4l2-modulator;. > In order to enable the RDS transmission one must set the <constant>V4L2_TUNER_SUB_RDS</constant> > bit in the <structfield>txsubchans</structfield> field of &v4l2-modulator;.</para> > > + <para>Devices capable of only passing through raw uninterpreted RDS data > +set the flags as described above and in addition > +set the <constant>V4L2_CAP_RAW_RDS_ONLY</constant> flag in > +the <structfield>capabilities</structfield> field of &v4l2-capability; > +returned by the &VIDIOC-QUERYCAP; ioctl.</para> > </section> > > <section> > diff --git a/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml b/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml > index 14b3ec7..c30dcc4 100644 > --- a/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml > +++ b/Documentation/DocBook/v4l/vidioc-s-hw-freq-seek.xml > @@ -51,7 +51,8 @@ > > <para>Start a hardware frequency seek from the current frequency. > To do this applications initialize the <structfield>tuner</structfield>, > -<structfield>type</structfield>, <structfield>seek_upward</structfield> and > +<structfield>type</structfield>, <structfield>seek_upward</structfield>, > +<structfield>spacing</structfield> and > <structfield>wrap_around</structfield> fields, and zero out the > <structfield>reserved</structfield> array of a &v4l2-hw-freq-seek; and > call the <constant>VIDIOC_S_HW_FREQ_SEEK</constant> ioctl with a pointer > @@ -89,7 +90,12 @@ field and the &v4l2-tuner; <structfield>index</structfield> field.</entry> > </row> > <row> > <entry>__u32</entry> > - <entry><structfield>reserved</structfield>[8]</entry> > + <entry><structfield>spacing</structfield></entry> > + <entry>If non-zero, defines the hardware seek resolution in Hz. The driver selects the nearest value that is supported by the device. If spacing is zero a reasonable default value is used.</entry> > + </row> > + <row> > + <entry>__u32</entry> > + <entry><structfield>reserved</structfield>[7]</entry> > <entry>Reserved for future extensions. Drivers and > applications must set the array to zero.</entry> > </row> ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio. 2010-08-30 11:38 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls " Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 4/4] Documentation: v4l: Add hw_seek spacing and FM_RX class Matti J. Aaltonen @ 2010-09-08 19:09 ` Mauro Carvalho Chehab 2010-09-15 11:36 ` Matti J. Aaltonen 2010-09-16 7:37 ` Matti J. Aaltonen 1 sibling, 2 replies; 23+ messages in thread From: Mauro Carvalho Chehab @ 2010-09-08 19:09 UTC (permalink / raw) To: Matti J. Aaltonen; +Cc: linux-media, hverkuil, eduardo.valentin Em 30-08-2010 08:38, Matti J. Aaltonen escreveu: > This driver implements V4L2 controls for the Texas Instruments > WL1273 FM Radio. > > Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> > --- > drivers/media/radio/Kconfig | 15 + > drivers/media/radio/Makefile | 1 + > drivers/media/radio/radio-wl1273.c | 1935 ++++++++++++++++++++++++++++++++++++ > drivers/mfd/Kconfig | 5 + > drivers/mfd/Makefile | 2 + > 5 files changed, 1958 insertions(+), 0 deletions(-) > create mode 100644 drivers/media/radio/radio-wl1273.c > > diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig > index 83567b8..209fd37 100644 > --- a/drivers/media/radio/Kconfig > +++ b/drivers/media/radio/Kconfig > @@ -452,4 +452,19 @@ config RADIO_TIMBERDALE > found behind the Timberdale FPGA on the Russellville board. > Enabling this driver will automatically select the DSP and tuner. > > +config RADIO_WL1273 > + tristate "Texas Instruments WL1273 I2C FM Radio" > + depends on I2C && VIDEO_V4L2 && SND > + select FW_LOADER > + ---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>. > + > + To compile this driver as a module, choose M here: the > + module will be called radio-wl1273. > + > endif # RADIO_ADAPTERS > diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile > index f615583..d297074 100644 > --- a/drivers/media/radio/Makefile > +++ b/drivers/media/radio/Makefile > @@ -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_WL1273) += radio-wl1273.o > >From what I saw, wl1273-core and radio-wl1273 are just part of the same radio driver. So, the better would be to just merge them into one driver module, with something like: obj-wl1273.o = radio-wl1273.o wl1273-core.o obj-$(CONFIG_RADIO_WL1273) += radio-wl1273.o And remove all those export_symbol' s from wl1273-core. > EXTRA_CFLAGS += -Isound > diff --git a/drivers/media/radio/radio-wl1273.c b/drivers/media/radio/radio-wl1273.c > new file mode 100644 > index 0000000..aa1eeed > --- /dev/null > +++ b/drivers/media/radio/radio-wl1273.c > @@ -0,0 +1,1935 @@ > +/* > + * Driver for the Texas Instruments WL1273 FM radio. > + * > + * Copyright (C) Nokia Corporation > + * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> > + * > + * 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 <linux/firmware.h> > +#include <linux/mfd/wl1273-core.h> > +#include <linux/slab.h> > +#include <media/v4l2-common.h> > +#include <media/v4l2-ctrls.h> > +#include <media/v4l2-device.h> > +#include <media/v4l2-ioctl.h> > + > +#define DRIVER_DESC "Wl1273 FM Radio - V4L2" Why V4L2??? Just call it as "Wl1273 FM Radio". > + > +#define WL1273_POWER_SET_OFF 0 > +#define WL1273_POWER_SET_FM (1 << 0) > +#define WL1273_POWER_SET_RDS (1 << 1) > +#define WL1273_POWER_SET_RETENTION (1 << 4) > + > +#define WL1273_PUPD_SET_OFF 0x00 > +#define WL1273_PUPD_SET_ON 0x01 > +#define WL1273_PUPD_SET_RETENTION 0x10 > + > +#define WL1273_FREQ(x) (x * 10000 / 625) > +#define WL1273_INV_FREQ(x) (x * 625 / 10000) > + > +/* > + * static int radio_nr - The number of the radio device > + * > + * The default is 0. > + */ > +static int radio_nr = -1; > +module_param(radio_nr, int, 0); > +MODULE_PARM_DESC(radio_nr, "Radio Nr"); > + > +struct wl1273_device { > + struct v4l2_ctrl_handler ctrl_handler; > + struct v4l2_device v4l2dev; > + struct video_device videodev; > + struct device *dev; > + struct wl1273_core *core; > + struct file *owner; > + char *write_buf; > + unsigned int rds_users; > +}; > + > +static int wl1273_fm_set_tx_freq(struct wl1273_core *core, unsigned int freq) > +{ > + int r = 0; > + > + if (freq < 76000) { > + dev_err(&core->i2c_dev->dev, > + "Frequency out of range: %d < %d\n", > + freq, core->bands[core->band].bottom_frequency); > + return -ERANGE; > + } > + > + if (freq > 108000) { > + dev_err(&core->i2c_dev->dev, > + "Frequency out of range: %d > %d\n", > + freq, core->bands[core->band].top_frequency); > + return -ERANGE; > + } > + > + /* > + * The driver works better with this sleep, > + * the documentation doesn't mention it. > + */ > + usleep_range(5000, 10000); > + > + dev_dbg(&core->i2c_dev->dev, "%s: freq: %d kHz\n", __func__, freq); > + > + INIT_COMPLETION(core->busy); > + /* Set the current tx channel */ > + r = wl1273_fm_write_cmd(core, WL1273_CHANL_SET, freq / 10); > + if (r) > + return r; > + > + /* wait for the FR IRQ */ > + r = wait_for_completion_timeout(&core->busy, msecs_to_jiffies(2000)); > + if (!r) > + return -ETIMEDOUT; > + > + dev_dbg(&core->i2c_dev->dev, "WL1273_CHANL_SET: %d\n", r); > + > + /* Enable the output power */ > + INIT_COMPLETION(core->busy); > + r = wl1273_fm_write_cmd(core, WL1273_POWER_ENB_SET, 1); > + if (r) > + return r; > + > + /* wait for the POWER_ENB IRQ */ > + r = wait_for_completion_timeout(&core->busy, msecs_to_jiffies(1000)); > + if (!r) > + return -ETIMEDOUT; > + > + core->tx_frequency = freq; > + dev_dbg(&core->i2c_dev->dev, "WL1273_POWER_ENB_SET: %d\n", r); > + > + return 0; > +} > + > +static int wl1273_fm_set_rx_freq(struct wl1273_core *core, unsigned int freq) > +{ > + int r; > + int f; > + > + if (freq < core->bands[core->band].bottom_frequency) { > + dev_err(&core->i2c_dev->dev, > + "Frequency out of range: %d < %d\n", > + freq, core->bands[core->band].bottom_frequency); > + r = -ERANGE; > + goto err; > + } > + > + if (freq > core->bands[core->band].top_frequency) { > + dev_err(&core->i2c_dev->dev, > + "Frequency out of range: %d > %d\n", > + freq, core->bands[core->band].top_frequency); > + r = -ERANGE; > + goto err; > + } > + > + dev_dbg(&core->i2c_dev->dev, "%s: %dkHz\n", __func__, freq); > + > + wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, core->irq_flags); > + > + f = (freq - core->bands[core->band].bottom_frequency) / 50; > + r = wl1273_fm_write_cmd(core, WL1273_FREQ_SET, f); > + if (r) { > + dev_err(&core->i2c_dev->dev, "FREQ_SET fails\n"); > + goto err; > + } > + > + INIT_COMPLETION(core->busy); > + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET); > + if (r) { > + dev_err(&core->i2c_dev->dev, "TUNER_MODE_SET fails\n"); > + complete(&core->busy); > + goto err; > + } > + > + r = wait_for_completion_timeout(&core->busy, msecs_to_jiffies(2000)); > + if (!r) { > + dev_err(&core->i2c_dev->dev, "TIMEOUT\n"); > + return -ETIMEDOUT; > + } > + > + core->rd_index = 0; > + core->wr_index = 0; > + core->rx_frequency = freq; > + return 0; > + > +err: > + return r; > +} > + > +static int wl1273_fm_get_freq(struct wl1273_core *core) > +{ > + unsigned int freq; > + u16 f; > + int r; > + > + if (core->mode == WL1273_MODE_RX) { > + r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &f); > + if (r) > + return r; > + > + dev_dbg(&core->i2c_dev->dev, "Freq get: 0x%04x\n", f); > + freq = core->bands[core->band].bottom_frequency + 50 * f; > + } else { > + r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &f); > + if (r) > + return r; > + > + freq = f * 10; > + } > + > + return freq; > +} > + > +/** > + * wl1273_fm_upload_firmware_patch() - Upload the firmware. > + * @core: A pointer to the device struct. > + * > + * The firmware file consists of arrays of bytes where the first byte > + * gives the array length. The first byte in the file gives the > + * number of these arrays. > + */ > +static int wl1273_fm_upload_firmware_patch(struct wl1273_core *core) > +{ > + unsigned int packet_num; > + const struct firmware *fw_p; > + const char *fw_name = "radio-wl1273-fw.bin"; > + struct device *dev = &core->i2c_dev->dev; > + __u8 *ptr; > + int i, n, len, r; > + struct i2c_msg *msgs; > + > + dev_dbg(dev, "%s:\n", __func__); > + > + if (request_firmware(&fw_p, fw_name, dev)) { > + dev_info(dev, "%s - %s not found\n", __func__, fw_name); > + > + return 0; > + } > + > + ptr = (__u8 *) fw_p->data; > + packet_num = ptr[0]; > + dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num); > + > + msgs = kmalloc((packet_num + 1)*sizeof(struct i2c_msg), GFP_KERNEL); Small CodingStyle issue: please use spaces between "*" operator: msgs = kmalloc((packet_num + 1) * sizeof(struct i2c_msg), GFP_KERNEL); > + if (!msgs) { > + r = -ENOMEM; > + goto out; > + } > + > + i = 1; > + for (n = 0; n <= packet_num; n++) { > + len = ptr[i]; > + > + dev_dbg(dev, "%s: len[%d]: %d\n", __func__, n, len); > + > + if (i + len + 1 <= fw_p->size) { > + msgs[n].addr = core->i2c_dev->addr; > + msgs[n].flags = 0; > + msgs[n].len = len; > + msgs[n].buf = ptr + i + 1; > + } else { > + break; > + } > + > + i += len + 1; > + } > + > + r = i2c_transfer(core->i2c_dev->adapter, msgs, packet_num); > + kfree(msgs); > + > + if (r != packet_num) { > + dev_err(dev, "FW upload error: %d\n", r); > + dev_dbg(dev, "%d != %d\n", packet_num, r); > + > + r = -EREMOTEIO; > + goto out; > + } else { > + r = 0; > + } > + > + /* ignore possible error here */ > + wl1273_fm_write_cmd(core, WL1273_RESET, 0); > + dev_dbg(dev, "n: %d, i: %d\n", n, i); > + > + if (n - 1 != packet_num) > + dev_warn(dev, "%s - incorrect firmware size.\n", __func__); > + > + if (i != fw_p->size) > + dev_warn(dev, "%s - inconsistent firmware.\n", __func__); > + > + dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r); > + > +out: > + release_firmware(fw_p); > + return r; > +} > + > +static int wl1273_fm_stop(struct wl1273_core *core) > +{ > + struct wl1273_fm_platform_data *pdata = > + core->i2c_dev->dev.platform_data; > + > + if (core->mode == WL1273_MODE_RX) { > + int r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, > + WL1273_POWER_SET_OFF); > + if (r) > + dev_err(&core->i2c_dev->dev, > + "%s: POWER_SET fails: %d\n", __func__, r); > + } else if (core->mode == WL1273_MODE_TX) { > + int r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, > + WL1273_PUPD_SET_OFF); > + if (r) > + dev_err(&core->i2c_dev->dev, > + "%s: PUPD_SET fails: %d\n", __func__, r); > + } > + > + if (pdata->disable) { > + pdata->disable(); > + dev_dbg(&core->i2c_dev->dev, "Back to reset\n"); > + } > + > + return 0; > +} > + > +static int wl1273_fm_start(struct wl1273_core *core, int new_mode) > +{ > + struct wl1273_fm_platform_data *pdata = > + core->i2c_dev->dev.platform_data; > + struct device *dev = &core->i2c_dev->dev; > + int r = -EINVAL; > + > + if (pdata->enable && core->mode == WL1273_MODE_OFF) { > + dev_dbg(dev, "Out of reset\n"); > + > + pdata->enable(); > + msleep(250); > + } > + > + if (new_mode == WL1273_MODE_RX) { > + u16 val = WL1273_POWER_SET_FM; > + > + if (core->rds_on) > + val |= WL1273_POWER_SET_RDS; > + > + /* If this fails try again */ > + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val); > + if (r) { > + msleep(100); > + > + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val); > + if (r) { > + dev_err(dev, "%s: POWER_SET fails\n", __func__); > + goto fail; > + } > + } > + > + /* rds buffer configuration */ > + core->wr_index = 0; > + core->rd_index = 0; > + > + } else if (new_mode == WL1273_MODE_TX) { > + /* If this fails try again */ > + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, > + WL1273_PUPD_SET_ON); > + if (r) { > + msleep(100); > + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, > + WL1273_PUPD_SET_ON); > + if (r) { > + dev_err(dev, "%s: PUPD_SET fails\n", __func__); > + goto fail; > + } > + } > + > + if (core->rds_on) > + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1); > + else > + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0); > + } else { > + dev_warn(dev, "%s: Illegal mode.\n", __func__); > + } > + > + if (core->mode == WL1273_MODE_OFF) { > + r = wl1273_fm_upload_firmware_patch(core); > + if (r) > + dev_warn(dev, "Firmware upload failed.\n"); > + > + /* > + * Sometimes the chip is in a wrong power state at this point. > + * So we set the power once again. > + */ > + if (new_mode == WL1273_MODE_RX) { > + u16 val = WL1273_POWER_SET_FM; > + > + if (core->rds_on) > + val |= WL1273_POWER_SET_RDS; > + > + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val); > + if (r) { > + dev_err(dev, "%s: POWER_SET fails\n", __func__); > + goto fail; > + } > + } else if (new_mode == WL1273_MODE_TX) { > + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, > + WL1273_PUPD_SET_ON); > + if (r) { > + dev_err(dev, "%s: PUPD_SET fails\n", __func__); > + goto fail; > + } > + } > + } > + > + return 0; > +fail: > + if (pdata->disable) > + pdata->disable(); > + > + dev_dbg(dev, "%s: return: %d\n", __func__, r); > + return r; > +} > + > +static int wl1273_fm_suspend(struct wl1273_core *core) > +{ > + int r = 0; > + struct device *dev = &core->i2c_dev->dev; > + > + /* Cannot go from OFF to SUSPENDED */ > + if (core->mode == WL1273_MODE_RX) > + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, > + WL1273_POWER_SET_RETENTION); > + else if (core->mode == WL1273_MODE_TX) > + r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET, > + WL1273_PUPD_SET_RETENTION); > + else > + r = -EINVAL; > + > + if (r) { > + dev_err(dev, "%s: POWER_SET fails: %d\n", __func__, r); > + goto out; > + } > + > +out: > + return r; > +} > + > +static int wl1273_fm_set_mode(struct wl1273_core *core, int mode) > +{ > + int r; > + int old_mode; > + struct device *dev = &core->i2c_dev->dev; > + > + dev_dbg(dev, "%s\n", __func__); > + dev_dbg(dev, "Forbidden modes: 0x%02x\n", core->forbidden); > + > + old_mode = core->mode; > + if (mode & core->forbidden) { > + r = -EPERM; > + goto out; > + } > + > + switch (mode) { > + case WL1273_MODE_RX: > + case WL1273_MODE_TX: > + r = wl1273_fm_start(core, mode); > + if (r) { > + dev_err(dev, "%s: Cannot start.\n", __func__); > + wl1273_fm_stop(core); > + goto out; > + } > + > + core->mode = mode; > + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, > + core->irq_flags); > + if (r) { > + dev_err(dev, "INT_MASK_SET fails.\n"); > + goto out; > + } > + > + /* remember previous settings */ > + if (mode == WL1273_MODE_RX) { > + r = wl1273_fm_set_rx_freq(core, core->rx_frequency); > + if (r) { > + dev_err(dev, "set freq fails: %d.\n", r); > + goto out; > + } > + > + r = wl1273_fm_set_volume(core, core->volume); > + if (r) { > + dev_err(dev, "set volume fails: %d.\n", r); > + goto out; > + } > + > + dev_dbg(dev, "%s: Set vol: %d.\n", __func__, > + core->volume); > + } else { > + r = wl1273_fm_set_tx_freq(core, core->tx_frequency); > + if (r) { > + dev_err(dev, "set freq fails: %d.\n", r); > + goto out; > + } > + } > + > + dev_dbg(dev, "%s: Set audio mode.\n", __func__); > + > + r = wl1273_fm_set_audio(core, core->audio_mode); > + if (r) > + dev_err(dev, "Cannot set audio mode.\n"); > + break; > + > + case WL1273_MODE_OFF: > + r = wl1273_fm_stop(core); > + if (r) > + dev_err(dev, "%s: Off fails: %d\n", __func__, r); > + else > + core->mode = WL1273_MODE_OFF; > + > + break; > + > + case WL1273_MODE_SUSPENDED: > + r = wl1273_fm_suspend(core); > + if (r) > + dev_err(dev, "%s: Suspend fails: %d\n", __func__, r); > + else > + core->mode = WL1273_MODE_SUSPENDED; > + > + break; > + > + default: > + dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode); > + r = -EINVAL; > + break; > + } > + > +out: > + if (r) > + core->mode = old_mode; > + > + return r; > +} > + > +static int wl1273_fm_set_seek(struct wl1273_core *core, > + unsigned int wrap_around, > + unsigned int seek_upward, > + int level) > +{ > + int r = 0; > + unsigned int dir = (seek_upward == 0) ? 0 : 1; > + unsigned int rx_frequency, top_frequency, bottom_frequency; > + > + rx_frequency = core->rx_frequency; > + top_frequency = core->bands[core->band].top_frequency; > + bottom_frequency = core->bands[core->band].bottom_frequency; > + dev_dbg(&core->i2c_dev->dev, "core->rx_frequency: %d\n", > + rx_frequency); > + > + if (dir && rx_frequency + core->spacing <= top_frequency) > + r = wl1273_fm_set_rx_freq(core, rx_frequency + core->spacing); > + else if (dir && wrap_around) > + r = wl1273_fm_set_rx_freq(core, bottom_frequency); > + else if (rx_frequency - core->spacing >= bottom_frequency) > + r = wl1273_fm_set_rx_freq(core, rx_frequency - core->spacing); > + else if (wrap_around) > + r = wl1273_fm_set_rx_freq(core, top_frequency); > + > + if (r) > + goto out; > + > + if (level < SCHAR_MIN || level > SCHAR_MAX) > + return -EINVAL; > + > + INIT_COMPLETION(core->busy); > + dev_dbg(&core->i2c_dev->dev, "%s: BUSY\n", __func__); > + > + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, core->irq_flags); > + if (r) > + goto out; > + > + dev_dbg(&core->i2c_dev->dev, "%s\n", __func__); > + > + r = wl1273_fm_write_cmd(core, WL1273_SEARCH_LVL_SET, level); > + if (r) > + goto out; > + > + r = wl1273_fm_write_cmd(core, WL1273_SEARCH_DIR_SET, dir); > + if (r) > + goto out; > + > + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, > + TUNER_MODE_AUTO_SEEK); > + if (r) > + goto out; > + > + wait_for_completion_timeout(&core->busy, msecs_to_jiffies(1000)); > + if (!(core->irq_received & WL1273_BL_EVENT)) > + goto out; > + > + core->irq_received &= ~WL1273_BL_EVENT; > + > + if (!wrap_around) > + goto out; > + > + /* Wrap around */ > + dev_dbg(&core->i2c_dev->dev, "Wrap around in HW seek.\n"); > + > + if (seek_upward) > + rx_frequency = bottom_frequency; > + else > + rx_frequency = top_frequency; > + > + r = wl1273_fm_set_rx_freq(core, rx_frequency); > + if (r) > + goto out; > + > + INIT_COMPLETION(core->busy); > + dev_dbg(&core->i2c_dev->dev, "%s: BUSY\n", __func__); > + > + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, > + TUNER_MODE_AUTO_SEEK); > + if (r) > + goto out; > + > + wait_for_completion_timeout(&core->busy, msecs_to_jiffies(1000)); > +out: > + dev_dbg(&core->i2c_dev->dev, "%s: Err: %d\n", __func__, r); > + return r; > +} > + > +/** > + * wl1273_fm_set_band() - Change the current band. > + * @core: A pointer to the device structure. > + * @band: The ID of the new band. > + * > + * Wl1273 supports only two bands USA/Europe and Japan. > + */ > +static int wl1273_fm_set_band(struct wl1273_core *core, unsigned int band) > +{ Should be adjusted to use VIDIOC_[G|S]_TUNER for RX. > + int r = 0; > + unsigned int new_frequency = 0; > + > + dev_dbg(&core->i2c_dev->dev, "%s: Number of bands: %d\n", __func__, > + core->number_of_bands); > + > + if (band == core->band) > + return 0; > + > + if (core->mode == WL1273_MODE_OFF || > + core->mode == WL1273_MODE_SUSPENDED) > + return -EPERM; > + > + if (band >= core->number_of_bands) > + return -EINVAL; > + > + mutex_lock(&core->lock); > + > + core->band = band; > + > + if (core->rx_frequency < core->bands[core->band].bottom_frequency) > + new_frequency = core->bands[core->band].bottom_frequency; > + else if (core->rx_frequency > core->bands[core->band].top_frequency) > + new_frequency = core->bands[core->band].top_frequency; > + > + if (new_frequency) { > + core->rx_frequency = new_frequency; > + if (core->mode == WL1273_MODE_RX) { > + r = wl1273_fm_set_rx_freq(core, new_frequency); > + if (r) > + goto out; > + } > + } > + > + new_frequency = 0; > + if (core->tx_frequency < core->bands[core->band].bottom_frequency) > + new_frequency = core->bands[core->band].bottom_frequency; > + else if (core->tx_frequency > core->bands[core->band].top_frequency) > + new_frequency = core->bands[core->band].top_frequency; > + > + if (new_frequency) { > + core->tx_frequency = new_frequency; > + > + if (core->mode == WL1273_MODE_TX) { > + r = wl1273_fm_set_tx_freq(core, new_frequency); > + if (r) > + goto out; > + } > + } > + > +out: > + mutex_unlock(&core->lock); > + return r; > +} > + > +/** > + * wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value. > + * @core: A pointer to the device struct. > + */ > +static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_core *core) > +{ > + struct device *dev = &core->i2c_dev->dev; > + u16 val; > + int r; > + > + if (core->mode == WL1273_MODE_OFF || > + core->mode == WL1273_MODE_SUSPENDED) > + return -EPERM; > + > + r = wl1273_fm_read_reg(core, WL1273_READ_FMANT_TUNE_VALUE, &val); > + if (r) { > + dev_err(dev, "%s: I2C error: %d\n", __func__, r); > + goto out; > + } > + > +out: > + return val; > +} > + > +/** > + * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value. > + * @core: A pointer to the device struct. > + * @preemphasis: The new pre-amphasis value. > + * > + * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED, > + * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS. > + */ > +static int wl1273_fm_set_preemphasis(struct wl1273_core *core, > + unsigned int preemphasis) > +{ > + int r; > + u16 em; > + > + if (core->mode == WL1273_MODE_OFF || > + core->mode == WL1273_MODE_SUSPENDED) > + return -EPERM; > + > + mutex_lock(&core->lock); > + > + switch (preemphasis) { > + case V4L2_PREEMPHASIS_DISABLED: > + em = 1; > + break; > + case V4L2_PREEMPHASIS_50_uS: > + em = 0; > + break; > + case V4L2_PREEMPHASIS_75_uS: > + em = 2; > + break; > + default: > + r = -EINVAL; > + goto out; > + } > + > + r = wl1273_fm_write_cmd(core, WL1273_PREMPH_SET, em); > + if (r) > + goto out; > + > + core->preemphasis = preemphasis; > + > +out: > + mutex_unlock(&core->lock); > + return r; > +} > + > +static int wl1273_fm_rds_on(struct wl1273_core *core) > +{ > + int r; > + > + dev_dbg(&core->i2c_dev->dev, "%s\n", __func__); > + if (core->rds_on) > + return 0; > + > + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, > + WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS); > + if (r) > + goto out; > + > + r = wl1273_fm_set_rx_freq(core, core->rx_frequency); > + if (r) > + dev_err(&core->i2c_dev->dev, "set freq fails: %d.\n", r); > +out: > + return r; > +} > + > +static int wl1273_fm_rds_off(struct wl1273_core *core) > +{ > + struct device *dev = &core->i2c_dev->dev; > + int r; > + > + if (!core->rds_on) > + return 0; > + > + core->irq_flags &= ~WL1273_RDS_EVENT; > + > + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, core->irq_flags); > + if (r) > + goto out; > + > + /* stop rds reception */ > + cancel_delayed_work(&core->work); > + > + /* Service pending read */ > + wake_up_interruptible(&core->read_queue); > + > + dev_dbg(dev, "%s\n", __func__); > + > + r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, WL1273_POWER_SET_FM); > + if (r) > + goto out; > + > + r = wl1273_fm_set_rx_freq(core, core->rx_frequency); > + if (r) > + dev_err(&core->i2c_dev->dev, "set freq fails: %d.\n", r); > + > +out: > + dev_dbg(dev, "%s: exiting...\n", __func__); > + > + return r; > +} > + > +static int wl1273_fm_set_rds(struct wl1273_core *core, unsigned int new_mode) > +{ > + int r = 0; > + struct device *dev = &core->i2c_dev->dev; > + > + if (core->mode == WL1273_MODE_OFF || > + core->mode == WL1273_MODE_SUSPENDED) > + return -EPERM; > + > + if (new_mode == WL1273_RDS_RESET) { > + r = wl1273_fm_write_cmd(core, WL1273_RDS_CNTRL_SET, 1); > + return r; > + } > + > + if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) { > + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0); > + } else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) { > + r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1); > + } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) { > + r = wl1273_fm_rds_off(core); > + } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) { > + r = wl1273_fm_rds_on(core); > + } else { > + dev_err(dev, "%s: Unknown mode: %d\n", __func__, new_mode); > + r = -EINVAL; > + } > + > + if (!r) > + core->rds_on = (new_mode == WL1273_RDS_ON) ? true : false; > + > + return r; > +} > + > +static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf, > + size_t count, loff_t *ppos) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + u16 val; > + int r; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (radio->core->mode != WL1273_MODE_TX) > + return count; > + > + if (radio->rds_users == 0) { > + dev_warn(radio->dev, "%s: RDS not on.\n", __func__); > + return 0; > + } > + > + if (mutex_lock_interruptible(&radio->core->lock)) > + return -EINTR; > + /* > + * Multiple processes can open the device, but only > + * one gets to write to it. > + */ > + if (radio->owner && radio->owner != file) { > + r = -EBUSY; > + goto out; > + } > + radio->owner = file; > + > + /* Manual Mode */ > + if (count > 255) > + val = 255; > + else > + val = count; > + > + wl1273_fm_write_cmd(radio->core, WL1273_RDS_CONFIG_DATA_SET, val); > + > + if (copy_from_user(radio->write_buf + 1, buf, val)) { > + r = -EFAULT; > + goto out; > + } > + > + dev_dbg(radio->dev, "Count: %d\n", val); > + dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf); > + > + radio->write_buf[0] = WL1273_RDS_DATA_SET; > + wl1273_fm_write_data(radio->core, radio->write_buf, val + 1); > + > + r = val; > +out: > + mutex_unlock(&radio->core->lock); > + > + return r; > +} > + > +static unsigned int wl1273_fm_fops_poll(struct file *file, > + struct poll_table_struct *pts) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + > + if (radio->owner && radio->owner != file) > + return -EBUSY; > + > + radio->owner = file; > + > + if (core->mode == WL1273_MODE_RX) { > + poll_wait(file, &core->read_queue, pts); > + > + if (core->rd_index != core->wr_index) > + return POLLIN | POLLRDNORM; > + > + } else if (core->mode == WL1273_MODE_TX) { > + return POLLOUT | POLLWRNORM; > + } > + > + return 0; > +} > + > +static int wl1273_fm_fops_open(struct file *file) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + int r = 0; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (core->mode == WL1273_MODE_RX && core->rds_on && !radio->rds_users) { > + dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode); > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + core->irq_flags |= WL1273_RDS_EVENT; > + > + r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, > + core->irq_flags); > + if (r) { > + mutex_unlock(&core->lock); > + goto out; > + } > + > + radio->rds_users++; > + > + mutex_unlock(&core->lock); > + } > +out: > + return r; > +} > + > +static int wl1273_fm_fops_release(struct file *file) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + int r = 0; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (radio->rds_users > 0) { > + radio->rds_users--; > + if (radio->rds_users == 0) { > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + core->irq_flags &= ~WL1273_RDS_EVENT; > + > + if (core->mode == WL1273_MODE_RX) { > + dev_dbg(radio->dev, "%s: A'\n", __func__); > + r = wl1273_fm_write_cmd(core, > + WL1273_INT_MASK_SET, > + core->irq_flags); > + if (r) { > + mutex_unlock(&core->lock); > + goto out; > + } > + } > + mutex_unlock(&core->lock); > + } > + } > + > + if (file == radio->owner) > + radio->owner = NULL; > +out: > + return r; > +} > + > +static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf, > + size_t count, loff_t *ppos) > +{ > + int r = 0; > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + unsigned int block_count = 0; > + u16 val; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (radio->core->mode != WL1273_MODE_RX) > + return 0; > + > + if (radio->rds_users == 0) { > + dev_warn(radio->dev, "%s: RDS not on.\n", __func__); > + return 0; > + } > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + /* > + * Multiple processes can open the device, but only > + * one gets to read from it. > + */ > + if (radio->owner && radio->owner != file) { > + r = -EBUSY; > + goto out; > + } > + radio->owner = file; > + > + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); > + if (r) { > + dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__); > + goto out; > + } else if (val == 0) { > + dev_info(radio->dev, "RDS_SYNC: Not synchronized\n"); > + r = -ENODATA; > + goto out; > + } > + > + /* block if no new data available */ > + while (core->wr_index == core->rd_index) { > + if (file->f_flags & O_NONBLOCK) { > + r = -EWOULDBLOCK; > + goto out; > + } > + > + dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__); > + if (wait_event_interruptible(core->read_queue, > + core->wr_index != > + core->rd_index) < 0) { > + r = -EINTR; > + goto out; > + } > + } > + > + /* calculate block count from byte count */ > + count /= 3; Why the "magic" value of 3? Instead, please define a constant, naming it in a way that a casual code reviewer could understand why you're multiplying/dividing by 3. > + > + /* copy RDS blocks from the internal buffer and to user buffer */ > + while (block_count < count) { > + if (core->rd_index == core->wr_index) > + break; > + > + /* always transfer complete RDS blocks */ > + if (copy_to_user(buf, &core->buffer[core->rd_index], 3)) Again, the "magic" 3. > + break; > + > + /* increment and wrap the read pointer */ > + core->rd_index += 3; Again, the "magic" 3. > + if (core->rd_index >= core->buf_size) > + core->rd_index = 0; > + > + /* increment counters */ > + block_count++; > + buf += 3; > + r += 3; Again, the "magic" 3. > + } > + > +out: > + dev_dbg(radio->dev, "%s: exit\n", __func__); > + mutex_unlock(&core->lock); > + > + return r; > +} > + > +static const struct v4l2_file_operations wl1273_fops = { > + .owner = THIS_MODULE, > + .read = wl1273_fm_fops_read, > + .write = wl1273_fm_fops_write, > + .poll = wl1273_fm_fops_poll, > + .ioctl = video_ioctl2, > + .open = wl1273_fm_fops_open, > + .release = wl1273_fm_fops_release, > +}; > + > +static int wl1273_fm_vidioc_querycap(struct file *file, void *priv, > + struct v4l2_capability *capability) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + strlcpy(capability->driver, WL1273_FM_DRIVER_NAME, > + sizeof(capability->driver)); > + strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio", > + sizeof(capability->card)); > + strlcpy(capability->bus_info, "I2C", sizeof(capability->bus_info)); > + > + capability->capabilities = V4L2_CAP_HW_FREQ_SEEK | > + V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO | > + V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR | > + V4L2_CAP_RDS_OUTPUT | V4L2_CAP_RAW_RDS_ONLY; > + > + return 0; > +} > + > +static int wl1273_fm_vidioc_g_input(struct file *file, void *priv, > + unsigned int *i) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + *i = 0; > + > + return 0; > +} > + > +static int wl1273_fm_vidioc_s_input(struct file *file, void *priv, > + unsigned int i) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (i != 0) > + return -EINVAL; > + > + return 0; > +} > + > +/** > + * wl1273_fm_set_tx_power() - Set the transmission power value. > + * @core: A pointer to the device struct. > + * @power: The new power value. > + */ > +static int wl1273_fm_set_tx_power(struct wl1273_core *core, u16 power) > +{ > + int r; > + > + if (core->mode == WL1273_MODE_OFF || > + core->mode == WL1273_MODE_SUSPENDED) > + return -EPERM; > + > + mutex_lock(&core->lock); > + > + /* Convert the dBuV value to chip presentation */ > + r = wl1273_fm_write_cmd(core, WL1273_POWER_LEV_SET, 122 - power); > + if (r) > + goto out; > + > + core->tx_power = power; > + > +out: > + mutex_unlock(&core->lock); > + return r; > +} > + > +#define WL1273_SPACING_50kHz 1 > +#define WL1273_SPACING_100kHz 2 > +#define WL1273_SPACING_200kHz 4 > + > +static int wl1273_fm_tx_set_spacing(struct wl1273_core *core, > + unsigned int spacing) > +{ > + int r; > + > + if (spacing == 0) { > + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, > + WL1273_SPACING_100kHz); > + core->spacing = 100; > + } else if (spacing - 50000 < 25000) { > + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, > + WL1273_SPACING_50kHz); > + core->spacing = 50; > + } else if (spacing - 100000 < 50000) { > + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, > + WL1273_SPACING_100kHz); > + core->spacing = 100; > + } else { > + r = wl1273_fm_write_cmd(core, WL1273_SCAN_SPACING_SET, > + WL1273_SPACING_200kHz); > + core->spacing = 200; > + } > + > + return r; > +} > + > +static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl) > +{ > + struct wl1273_device *radio = ctrl->priv; > + struct wl1273_core *core = radio->core; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + switch (ctrl->id) { > + case V4L2_CID_TUNE_ANTENNA_CAPACITOR: > + ctrl->val = wl1273_fm_get_tx_ctune(core); > + break; > + > + default: > + dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n", > + __func__, ctrl->id); > + break; > + } > + > + mutex_unlock(&core->lock); > + > + return 0; > +} > + > +#define WL1273_MUTE_SOFT_ENABLE (1 << 0) > +#define WL1273_MUTE_AC (1 << 1) > +#define WL1273_MUTE_HARD_LEFT (1 << 2) > +#define WL1273_MUTE_HARD_RIGHT (1 << 3) > +#define WL1273_MUTE_SOFT_FORCE (1 << 4) > + > +static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl) > +{ > + return container_of(ctrl->handler, struct wl1273_device, ctrl_handler); > +} > + > +static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl) > +{ > + struct wl1273_device *radio = to_radio(ctrl); > + struct wl1273_core *core = radio->core; > + int r = 0; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + switch (ctrl->id) { > + case V4L2_CID_AUDIO_MUTE: > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + if (core->mode == WL1273_MODE_RX && ctrl->val) > + r = wl1273_fm_write_cmd(core, > + WL1273_MUTE_STATUS_SET, > + WL1273_MUTE_HARD_LEFT | > + WL1273_MUTE_HARD_RIGHT); > + else if (core->mode == WL1273_MODE_RX) > + r = wl1273_fm_write_cmd(core, > + WL1273_MUTE_STATUS_SET, 0x0); > + else if (core->mode == WL1273_MODE_TX && ctrl->val) > + r = wl1273_fm_write_cmd(core, WL1273_MUTE, 1); > + else if (core->mode == WL1273_MODE_TX) > + r = wl1273_fm_write_cmd(core, WL1273_MUTE, 0); > + > + mutex_unlock(&core->lock); > + break; > + > + case V4L2_CID_AUDIO_VOLUME: > + if (ctrl->val == 0) > + r = wl1273_fm_set_mode(core, WL1273_MODE_OFF); > + else > + r = wl1273_fm_set_volume(core, core->volume); > + break; > + > + case V4L2_CID_TUNE_PREEMPHASIS: > + r = wl1273_fm_set_preemphasis(core, ctrl->val); > + break; > + > + case V4L2_CID_TUNE_POWER_LEVEL: > + r = wl1273_fm_set_tx_power(core, ctrl->val); > + break; > + > + case V4L2_CID_FM_BAND: > + r = wl1273_fm_set_band(core, ctrl->val); > + break; Not needed. Instead, please implement it via VIDIOC_S_TUNER. > + > + default: > + dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n", > + __func__, ctrl->id); > + break; > + } > + > + dev_dbg(radio->dev, "%s\n", __func__); > + return r; > +} > + > +static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv, > + struct v4l2_audio *audio) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (audio->index > 1) > + return -EINVAL; > + > + strlcpy(audio->name, "Radio", sizeof(audio->name)); > + audio->capability = V4L2_AUDCAP_STEREO; > + > + return 0; > +} > + > +static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv, > + struct v4l2_audio *audio) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (audio->index != 0) > + return -EINVAL; > + > + return 0; > +} > + > +#define WL1273_RDS_NOT_SYNCHRONIZED 0 > +#define WL1273_RDS_SYNCHRONIZED 1 > + > +static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv, > + struct v4l2_tuner *tuner) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + u16 val; > + int r; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (tuner->index > 0) > + return -EINVAL; > + > + strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name)); > + tuner->type = V4L2_TUNER_RADIO; > + > + tuner->rangelow = > + WL1273_FREQ(core->bands[core->band].bottom_frequency); > + tuner->rangehigh = > + WL1273_FREQ(core->bands[core->band].top_frequency); > + > + tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS | > + V4L2_TUNER_CAP_STEREO; > + > + if (core->stereo) > + tuner->audmode = V4L2_TUNER_MODE_STEREO; > + else > + tuner->audmode = V4L2_TUNER_MODE_MONO; > + > + if (core->mode != WL1273_MODE_RX) > + return 0; > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val); > + if (r) > + goto out; > + > + if (val == 1) > + tuner->rxsubchans = V4L2_TUNER_SUB_STEREO; > + else > + tuner->rxsubchans = V4L2_TUNER_SUB_MONO; > + > + r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val); > + if (r) > + goto out; > + > + tuner->signal = (s16) val; > + dev_dbg(radio->dev, "Signal: %d\n", tuner->signal); > + > + tuner->afc = 0; > + > + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); > + if (r) > + goto out; > + > + if (val == WL1273_RDS_SYNCHRONIZED) > + tuner->rxsubchans |= V4L2_TUNER_SUB_RDS; > +out: > + mutex_unlock(&core->lock); > + > + return r; > +} > + > +static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv, > + struct v4l2_tuner *tuner) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + int r = 0; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index); > + dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name); > + dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability); > + dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans); > + dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow); > + dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh); Ranges should be using tuner->rangelow/rangehigh to change band limits. > + > + if (tuner->index > 0) > + return -EINVAL; > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + r = wl1273_fm_set_mode(core, WL1273_MODE_RX); > + if (r) > + goto out; > + > + if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS) > + r = wl1273_fm_set_rds(core, WL1273_RDS_ON); > + else > + r = wl1273_fm_set_rds(core, WL1273_RDS_OFF); > + > + if (r) > + dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r); > + > + if (tuner->audmode == V4L2_TUNER_MODE_MONO) { > + r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET, > + WL1273_RX_MONO); > + if (r < 0) { > + dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n", > + __func__, r); > + goto out; > + } > + core->stereo = false; > + } else if (tuner->audmode == V4L2_TUNER_MODE_MONO) { > + r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET, > + WL1273_RX_STEREO); > + if (r < 0) { > + dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n", > + __func__, r); > + goto out; > + } > + core->stereo = true; > + } else { > + dev_err(radio->dev, "%s: tuner->audmode: %d\n", > + __func__, tuner->audmode); > + r = -EINVAL; > + goto out; > + } > + > +out: > + mutex_unlock(&core->lock); > + > + return r; > +} > + > +static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv, > + struct v4l2_frequency *freq) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + freq->type = V4L2_TUNER_RADIO; > + freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(core)); > + > + mutex_unlock(&core->lock); > + > + return 0; > +} > + > +static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv, > + struct v4l2_frequency *freq) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + int r; > + > + dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency); > + > + if (freq->type != V4L2_TUNER_RADIO) { > + dev_dbg(radio->dev, > + "freq->type != V4L2_TUNER_RADIO: %d\n", freq->type); > + return -EINVAL; > + } > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + if (core->mode == WL1273_MODE_RX) { > + dev_dbg(radio->dev, "freq: %d\n", freq->frequency); > + > + r = wl1273_fm_set_rx_freq(core, > + WL1273_INV_FREQ(freq->frequency)); > + if (r) > + dev_warn(radio->dev, WL1273_FM_DRIVER_NAME > + ": set frequency failed with %d\n", r); > + } else { > + r = wl1273_fm_set_tx_freq(core, > + WL1273_INV_FREQ(freq->frequency)); > + if (r) > + dev_warn(radio->dev, WL1273_FM_DRIVER_NAME > + ": set frequency failed with %d\n", r); > + } > + > + mutex_unlock(&core->lock); > + > + dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n"); > + return r; > +} > + > +#define WL1273_DEFAULT_SEEK_LEVEL 7 > + > +static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv, > + struct v4l2_hw_freq_seek *seek) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + int r; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO) > + return -EINVAL; > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + r = wl1273_fm_set_mode(core, WL1273_MODE_RX); > + if (r) > + goto out; > + > + r = wl1273_fm_tx_set_spacing(core, seek->spacing); > + if (r) > + dev_warn(radio->dev, "HW seek failed: %d\n", r); > + > + r = wl1273_fm_set_seek(core, seek->wrap_around, seek->seek_upward, > + WL1273_DEFAULT_SEEK_LEVEL); > + if (r) > + dev_warn(radio->dev, "HW seek failed: %d\n", r); > + > +out: > + mutex_unlock(&core->lock); > + return r; > +} > + > +static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv, > + struct v4l2_modulator *modulator) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + int r = 0; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + if (modulator->index > 0) > + return -EINVAL; > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + r = wl1273_fm_set_mode(core, WL1273_MODE_TX); > + if (r) > + goto out; > + > + if (modulator->txsubchans & V4L2_TUNER_SUB_RDS) > + r = wl1273_fm_set_rds(core, WL1273_RDS_ON); > + else > + r = wl1273_fm_set_rds(core, WL1273_RDS_OFF); > + > + if (modulator->txsubchans & V4L2_TUNER_SUB_MONO) > + r = wl1273_fm_write_cmd(core, WL1273_MONO_SET, WL1273_TX_MONO); > + else > + r = wl1273_fm_write_cmd(core, WL1273_MONO_SET, > + WL1273_RX_STEREO); > + if (r < 0) > + dev_warn(radio->dev, WL1273_FM_DRIVER_NAME > + "MONO_SET fails: %d\n", r); > +out: > + mutex_unlock(&core->lock); > + > + return r; > +} > + > +static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv, > + struct v4l2_modulator *modulator) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + u16 val; > + int r; > + > + dev_dbg(radio->dev, "%s\n", __func__); > + > + strlcpy(modulator->name, WL1273_FM_DRIVER_NAME, > + sizeof(modulator->name)); > + > + modulator->rangelow = > + WL1273_FREQ(core->bands[core->band].bottom_frequency); > + modulator->rangehigh = > + WL1273_FREQ(core->bands[core->band].top_frequency); > + > + modulator->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS | > + V4L2_TUNER_CAP_STEREO; > + > + if (core->mode != WL1273_MODE_TX) > + return 0; > + > + if (mutex_lock_interruptible(&core->lock)) > + return -EINTR; > + > + r = wl1273_fm_read_reg(core, WL1273_MONO_SET, &val); > + if (r) > + goto out; > + > + if (val == WL1273_TX_STEREO) > + modulator->txsubchans = V4L2_TUNER_SUB_STEREO; > + else > + modulator->txsubchans = V4L2_TUNER_SUB_MONO; > + > + if (core->rds_on) > + modulator->txsubchans |= V4L2_TUNER_SUB_RDS; > +out: > + mutex_unlock(&core->lock); > + > + return 0; > +} > + > +static int wl1273_fm_vidioc_log_status(struct file *file, void *priv) > +{ > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > + struct wl1273_core *core = radio->core; > + struct device *dev = radio->dev; > + u16 val; > + int r; > + > + dev_info(dev, DRIVER_DESC); > + > + if (core->mode == WL1273_MODE_OFF) { > + dev_info(dev, "Mode: Off\n"); > + return 0; > + } > + > + if (core->mode == WL1273_MODE_SUSPENDED) { > + dev_info(dev, "Mode: Suspended\n"); > + return 0; > + } > + > + r = wl1273_fm_read_reg(core, WL1273_ASIC_ID_GET, &val); > + if (r) > + dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__); > + else > + dev_info(dev, "ASIC_ID: 0x%04x\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_ASIC_VER_GET, &val); > + if (r) > + dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__); > + else > + dev_info(dev, "ASIC Version: 0x%04x\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_FIRM_VER_GET, &val); > + if (r) > + dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__); > + else > + dev_info(dev, "FW version: %d(0x%04x)\n", val, val); > + > + r = wl1273_fm_read_reg(core, WL1273_BAND_SET, &val); > + if (r) > + dev_err(dev, "%s: Get BAND fails.\n", __func__); > + else > + dev_info(dev, "BAND: %d\n", val); > + > + if (core->mode == WL1273_MODE_TX) { > + r = wl1273_fm_read_reg(core, WL1273_PUPD_SET, &val); > + if (r) > + dev_err(dev, "%s: Get PUPD fails.\n", __func__); > + else > + dev_info(dev, "PUPD: 0x%04x\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &val); > + if (r) > + dev_err(dev, "%s: Get CHANL fails.\n", __func__); > + else > + dev_info(dev, "Tx frequency: %dkHz\n", val*10); > + } else if (core->mode == WL1273_MODE_RX) { > + int bf = core->bands[core->band].bottom_frequency; > + > + r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &val); > + if (r) > + dev_err(dev, "%s: Get FREQ fails.\n", __func__); > + else > + dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50); > + > + r = wl1273_fm_read_reg(core, WL1273_MOST_MODE_SET, &val); > + if (r) > + dev_err(dev, "%s: Get MOST_MODE fails.\n", > + __func__); > + else if (val == 0) > + dev_info(dev, "MOST_MODE: Stereo according to blend\n"); > + else if (val == 1) > + dev_info(dev, "MOST_MODE: Force mono output\n"); > + else > + dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_MOST_BLEND_SET, &val); > + if (r) > + dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__); > + else if (val == 0) > + dev_info(dev, > + "MOST_BLEND: Switched blend & hysteresis.\n"); > + else if (val == 1) > + dev_info(dev, "MOST_BLEND: Soft blend.\n"); > + else > + dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val); > + if (r) > + dev_err(dev, "%s: Get STEREO fails.\n", __func__); > + else if (val == 0) > + dev_info(dev, "STEREO: Not detected\n"); > + else if (val == 1) > + dev_info(dev, "STEREO: Detected\n"); > + else > + dev_info(dev, "STEREO: Unexpected value: %d\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val); > + if (r) > + dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__); > + else > + dev_info(dev, "RX signal strength: %d\n", (s16) val); > + > + r = wl1273_fm_read_reg(core, WL1273_POWER_SET, &val); > + if (r) > + dev_err(dev, "%s: Get POWER fails.\n", __func__); > + else > + dev_info(dev, "POWER: 0x%04x\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_INT_MASK_SET, &val); > + if (r) > + dev_err(dev, "%s: Get INT_MASK fails.\n", __func__); > + else > + dev_info(dev, "INT_MASK: 0x%04x\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); > + if (r) > + dev_err(dev, "%s: Get RDS_SYNC fails.\n", > + __func__); > + else if (val == 0) > + dev_info(dev, "RDS_SYNC: Not synchronized\n"); > + > + else if (val == 1) > + dev_info(dev, "RDS_SYNC: Synchronized\n"); > + else > + dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_I2S_MODE_CONFIG_SET, &val); > + if (r) > + dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n", > + __func__); > + else > + dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val); > + > + r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val); > + if (r) > + dev_err(dev, "%s: Get VOLUME fails.\n", __func__); > + else > + dev_info(dev, "VOLUME: 0x%04x\n", val); > + } > + > + return 0; > +} > + > +static void wl1273_vdev_release(struct video_device *dev) > +{ > +} > + > +static const struct v4l2_ctrl_ops wl1273_ctrl_ops = { > + .s_ctrl = wl1273_fm_vidioc_s_ctrl, > + .g_volatile_ctrl = wl1273_fm_g_volatile_ctrl, > +}; > + > +static const struct v4l2_ioctl_ops wl1273_ioctl_ops = { > + .vidioc_querycap = wl1273_fm_vidioc_querycap, > + .vidioc_g_input = wl1273_fm_vidioc_g_input, > + .vidioc_s_input = wl1273_fm_vidioc_s_input, > + .vidioc_g_audio = wl1273_fm_vidioc_g_audio, > + .vidioc_s_audio = wl1273_fm_vidioc_s_audio, > + .vidioc_g_tuner = wl1273_fm_vidioc_g_tuner, > + .vidioc_s_tuner = wl1273_fm_vidioc_s_tuner, > + .vidioc_g_frequency = wl1273_fm_vidioc_g_frequency, > + .vidioc_s_frequency = wl1273_fm_vidioc_s_frequency, > + .vidioc_s_hw_freq_seek = wl1273_fm_vidioc_s_hw_freq_seek, > + .vidioc_g_modulator = wl1273_fm_vidioc_g_modulator, > + .vidioc_s_modulator = wl1273_fm_vidioc_s_modulator, > + .vidioc_log_status = wl1273_fm_vidioc_log_status, > +}; > + > +static struct video_device wl1273_viddev_template = { > + .fops = &wl1273_fops, > + .ioctl_ops = &wl1273_ioctl_ops, > + .name = WL1273_FM_DRIVER_NAME, > + .release = wl1273_vdev_release, > +}; > + > +static int wl1273_fm_radio_remove(struct platform_device *pdev) > +{ > + struct wl1273_device *radio = platform_get_drvdata(pdev);; > + > + dev_info(&pdev->dev, "%s.\n", __func__); > + > + v4l2_ctrl_handler_free(&radio->ctrl_handler); > + video_unregister_device(&radio->videodev); > + v4l2_device_unregister(&radio->v4l2dev); > + kfree(radio->write_buf); > + kfree(radio); > + > + return 0; > +} > + > +static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev) > +{ > + struct wl1273_core **pdata = pdev->dev.platform_data; > + struct wl1273_device *radio; > + struct v4l2_ctrl *ctrl; > + int r = 0; > + > + dev_dbg(&pdev->dev, "%s\n", __func__); > + > + if (!pdata) { > + dev_err(&pdev->dev, "No platform data.\n"); > + r = -EINVAL; > + goto pdata_err; > + } > + > + radio = kzalloc(sizeof(*radio), GFP_KERNEL); > + if (!radio) { > + r = -ENOMEM; > + goto pdata_err; > + } > + > + radio->write_buf = kmalloc(256, GFP_KERNEL); > + if (!radio->write_buf) { > + r = -ENOMEM; > + goto write_buf_err; > + } > + > + radio->core = *pdata; > + radio->dev = &pdev->dev; > + radio->v4l2dev.ctrl_handler = &radio->ctrl_handler; > + radio->rds_users = 0; > + > + r = v4l2_device_register(&pdev->dev, &radio->v4l2dev); > + if (r) { > + dev_err(&pdev->dev, "Cannot register v4l2_device.\n"); > + goto device_register_err; > + } > + > + /* V4L2 configuration */ > + memcpy(&radio->videodev, &wl1273_viddev_template, > + sizeof(wl1273_viddev_template)); > + > + radio->videodev.v4l2_dev = &radio->v4l2dev; > + > + /* register video device */ > + r = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr); > + if (r) { > + dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME > + ": Could not register video device\n"); > + goto video_register_err; > + } Please do the registration of the device at the end. Applications may try to open (and udev, in fact does it) the device while you're still initializing it. If you need to do it earlier, you'll need a lock protecting open/close/init, to avoid race conditions. > + > + v4l2_ctrl_handler_init(&radio->ctrl_handler, 6); > + /* add in ascending ID order */ > + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, > + V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1, > + WL1273_DEFAULT_VOLUME); > + > + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, > + V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); > + > + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, > + V4L2_CID_TUNE_PREEMPHASIS, V4L2_PREEMPHASIS_DISABLED, > + V4L2_PREEMPHASIS_75_uS, 1, V4L2_PREEMPHASIS_50_uS); > + > + v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, > + V4L2_CID_TUNE_POWER_LEVEL, 91, 122, 1, 118); > + > + ctrl = v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, > + V4L2_CID_TUNE_ANTENNA_CAPACITOR, > + 0, 255, 1, 255); > + if (ctrl) > + ctrl->is_volatile = 1; > + > + v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops, > + V4L2_CID_FM_BAND, V4L2_FM_BAND_JAPAN, 0, > + V4L2_FM_BAND_OTHER); > + > + if (radio->ctrl_handler.error) { > + r = radio->ctrl_handler.error; > + goto handler_init_err; > + } > + > + video_set_drvdata(&radio->videodev, radio); > + platform_set_drvdata(pdev, radio); > + > + return 0; > + > +handler_init_err: > + v4l2_ctrl_handler_free(&radio->ctrl_handler); > + video_unregister_device(&radio->videodev); > +video_register_err: > + v4l2_device_unregister(&radio->v4l2dev); > +device_register_err: > + kfree(radio->write_buf); > +write_buf_err: > + kfree(radio); > +pdata_err: > + return r; > +} > + > +MODULE_ALIAS("platform:wl1273_fm_radio"); > + > +static struct platform_driver wl1273_fm_radio_driver = { > + .probe = wl1273_fm_radio_probe, > + .remove = __devexit_p(wl1273_fm_radio_remove), > + .driver = { > + .name = "wl1273_fm_radio", > + .owner = THIS_MODULE, > + }, > +}; > + > +static int __init wl1273_fm_module_init(void) > +{ > + pr_info("%s\n", __func__); > + return platform_driver_register(&wl1273_fm_radio_driver); > +} > +module_init(wl1273_fm_module_init); > + > +static void __exit wl1273_fm_module_exit(void) > +{ > + flush_scheduled_work(); > + platform_driver_unregister(&wl1273_fm_radio_driver); > + pr_info(DRIVER_DESC ", Exiting.\n"); > +} > +module_exit(wl1273_fm_module_exit); > + > +MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>"); > +MODULE_DESCRIPTION(DRIVER_DESC); > +MODULE_LICENSE("GPL"); > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index db51ea1..ffb88c6 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -228,6 +228,11 @@ config MFD_TC35892 > This driver provides common support for accessing the device, > additional drivers must be enabled in order to use the > functionality of the device. > +config WL1273_CORE > + tristate > + depends on I2C > + select MFD_CORE > + default n > > config MFD_TMIO > bool > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index feaeeae..c43ab14 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -39,6 +39,8 @@ obj-$(CONFIG_TWL4030_POWER) += twl4030-power.o > obj-$(CONFIG_TWL4030_CODEC) += twl4030-codec.o > obj-$(CONFIG_TWL6030_PWM) += twl6030-pwm.o > > +obj-$(CONFIG_WL1273_CORE) += wl1273-core.o > + > obj-$(CONFIG_MFD_MC13783) += mc13783-core.o > > obj-$(CONFIG_MFD_CORE) += mfd-core.o ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio. 2010-09-08 19:09 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio Mauro Carvalho Chehab @ 2010-09-15 11:36 ` Matti J. Aaltonen 2010-09-16 7:37 ` Matti J. Aaltonen 1 sibling, 0 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-15 11:36 UTC (permalink / raw) To: ext Mauro Carvalho Chehab Cc: linux-media@vger.kernel.org, hverkuil@xs4all.nl, Valentin Eduardo (Nokia-MS/Helsinki) Hi. On Wed, 2010-09-08 at 21:09 +0200, ext Mauro Carvalho Chehab wrote: > > +static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv, > > + struct v4l2_tuner *tuner) > > +{ > > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > > + struct wl1273_core *core = radio->core; > > + int r = 0; > > + > > + dev_dbg(radio->dev, "%s\n", __func__); > > + dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index); > > + dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name); > > + dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability); > > + dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans); > > + dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow); > > + dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh); > > Ranges should be using tuner->rangelow/rangehigh to change band limits. I just want to make sure that I understand you correctly. So the idea is that with the g_tuner the driver can tell the frequency range that's supported by the chip in RX mode, which is 76MHz to 108 MHz. The lowest part is in the Japan band and the highest is in the Europe/USA band, the middle section can be either... Then the application can choose any sub-range of the above by calling s_tuner with any values rangelow > 76MHz and rangehigh < 108MHz? After that the driver just deals with the given frequencies by changing the band if necessary? Cheers, Matti ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio. 2010-09-08 19:09 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio Mauro Carvalho Chehab 2010-09-15 11:36 ` Matti J. Aaltonen @ 2010-09-16 7:37 ` Matti J. Aaltonen 1 sibling, 0 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-16 7:37 UTC (permalink / raw) To: ext Mauro Carvalho Chehab Cc: linux-media@vger.kernel.org, hverkuil@xs4all.nl, Valentin Eduardo (Nokia-MS/Helsinki) Hi. On Wed, 2010-09-08 at 21:09 +0200, ext Mauro Carvalho Chehab wrote: > > +static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv, > > + struct v4l2_tuner *tuner) > > +{ > > + struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); > > + struct wl1273_core *core = radio->core; > > + int r = 0; > > + > > + dev_dbg(radio->dev, "%s\n", __func__); > > + dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index); > > + dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name); > > + dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability); > > + dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans); > > + dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow); > > + dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh); > > Ranges should be using tuner->rangelow/rangehigh to change band limits. I just want to make sure that I understand you correctly. So the idea is that with the g_tuner the driver can tell the frequency range that's supported by the chip in RX mode, which is 76MHz to 108 MHz. The lowest part is in the Japan band and the highest is in the Europe/USA band, the middle section can be either... Then the application can choose any sub-range of the above by calling s_tuner with any values rangelow > 76MHz and rangehigh < 108MHz? After that the driver just deals with the given frequencies by changing the band if necessary? Cheers, Matti ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio. 2010-08-30 11:38 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls " Matti J. Aaltonen @ 2010-09-08 18:49 ` Mauro Carvalho Chehab 1 sibling, 0 replies; 23+ messages in thread From: Mauro Carvalho Chehab @ 2010-09-08 18:49 UTC (permalink / raw) To: Matti J. Aaltonen; +Cc: linux-media, hverkuil, eduardo.valentin Em 30-08-2010 08:38, Matti J. Aaltonen escreveu: > This is a parent for two child drivers: a V4L2 driver and > an ALSA codec driver. The MFD part implements I2C communication > to the device and provides a couple of functions that are called > from both children. > > Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> > --- > drivers/mfd/wl1273-core.c | 612 +++++++++++++++++++++++++++++++++++++++ > include/linux/mfd/wl1273-core.h | 314 ++++++++++++++++++++ > 2 files changed, 926 insertions(+), 0 deletions(-) > create mode 100644 drivers/mfd/wl1273-core.c > create mode 100644 include/linux/mfd/wl1273-core.h > > diff --git a/drivers/mfd/wl1273-core.c b/drivers/mfd/wl1273-core.c > new file mode 100644 > index 0000000..9fa3850 > --- /dev/null > +++ b/drivers/mfd/wl1273-core.c > @@ -0,0 +1,612 @@ > +/* > + * MFD driver for wl1273 FM radio and audio codec submodules. > + * > + * Author: Matti Aaltonen <matti.j.aaltonen@nokia.com> > + * > + * Copyright: (C) 2010 Nokia Corporation > + * > + * 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., 51 Franklin St, Fifth Floor, Boston, MA > + * 02110-1301 USA > + * > + */ > + > +#include <linux/delay.h> > +#include <linux/interrupt.h> > +#include <linux/mfd/wl1273-core.h> > +#include <linux/slab.h> > +#include <media/v4l2-common.h> > + > +#define DRIVER_DESC "WL1273 FM Radio Core" > + > +#define WL1273_IRQ_MASK (WL1273_FR_EVENT | \ > + WL1273_POW_ENB_EVENT) > + > +static const struct band_info bands[] = { > + /* USA & Europe */ > + { > + .bottom_frequency = 87500, > + .top_frequency = 108000, > + .band = V4L2_FM_BAND_OTHER, > + }, > + /* Japan */ > + { > + .bottom_frequency = 76000, > + .top_frequency = 90000, > + .band = V4L2_FM_BAND_JAPAN, > + }, > +}; > + > +/* > + * static unsigned char radio_band - Band > + * > + * The bands are 0 == USA-Europe, 1 == Japan. USA-Europe is the default. > + */ > +static unsigned char radio_band; > +module_param(radio_band, byte, 0); > +MODULE_PARM_DESC(radio_band, "Band: 0=USA-Europe, 1=Japan"); There's no need for a parameter to set the bandwidth. > + > +/* > + * static unsigned int rds_buf - the number of RDS buffer blocks used. > + * > + * The default number is 100. > + */ > +static unsigned int rds_buf = 100; > +module_param(rds_buf, uint, 0); > +MODULE_PARM_DESC(rds_buf, "RDS buffer entries: *100*"); Hmm... it would be better to use, instead: MODULE_PARM_DESC(rds_buf, "Number of RDS buffer entries. Default = 100"); > + > +int wl1273_fm_read_reg(struct wl1273_core *core, u8 reg, u16 *value) > +{ > + struct i2c_client *client = core->i2c_dev; > + u8 b[2]; > + int r; > + > + r = i2c_smbus_read_i2c_block_data(client, reg, 2, b); > + if (r != 2) { > + dev_err(&client->dev, "%s: Read: %d fails.\n", __func__, reg); > + return -EREMOTEIO; > + } > + > + *value = (u16)b[0] << 8 | b[1]; > + > + return 0; > +} > +EXPORT_SYMBOL(wl1273_fm_read_reg); Hmm... why do you need to export a symbol here? > + > +int wl1273_fm_write_cmd(struct wl1273_core *core, u8 cmd, u16 param) > +{ > + struct i2c_client *client = core->i2c_dev; > + u8 buf[] = { (param >> 8) & 0xff, param & 0xff }; > + int r; > + > + r = i2c_smbus_write_i2c_block_data(client, cmd, 2, buf); > + if (r) { > + dev_err(&client->dev, "%s: Cmd: %d fails.\n", __func__, cmd); > + return r; > + } > + > + return 0; > +} > +EXPORT_SYMBOL(wl1273_fm_write_cmd); Hmm... why do you need to export a symbol here? > + > +int wl1273_fm_write_data(struct wl1273_core *core, u8 *data, u16 len) > +{ > + struct i2c_client *client = core->i2c_dev; > + struct i2c_msg msg[1]; > + int r; > + > + msg[0].addr = client->addr; > + msg[0].flags = 0; > + msg[0].buf = data; > + msg[0].len = len; > + > + r = i2c_transfer(client->adapter, msg, 1); > + > + if (r != 1) { > + dev_err(&client->dev, "%s: write error.\n", __func__); > + return -EREMOTEIO; > + } > + > + return 0; > +} > +EXPORT_SYMBOL(wl1273_fm_write_data); Hmm... why do you need to export a symbol here? > + > +/** > + * wl1273_fm_set_audio() - Set audio mode. > + * @core: A pointer to the device struct. > + * @new_mode: The new audio mode. > + * > + * Audio modes are WL1273_AUDIO_DIGITAL and WL1273_AUDIO_ANALOG. > + */ > +int wl1273_fm_set_audio(struct wl1273_core *core, unsigned int new_mode) > +{ > + int r = 0; > + > + if (core->mode == WL1273_MODE_OFF || > + core->mode == WL1273_MODE_SUSPENDED) > + return -EPERM; > + > + if (core->mode == WL1273_MODE_RX && new_mode == WL1273_AUDIO_DIGITAL) { > + r = wl1273_fm_write_cmd(core, WL1273_PCM_MODE_SET, > + WL1273_PCM_DEF_MODE); > + if (r) > + goto out; > + > + r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET, > + core->i2s_mode); > + if (r) > + goto out; > + > + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE, > + WL1273_AUDIO_ENABLE_I2S); > + if (r) > + goto out; > + > + } else if (core->mode == WL1273_MODE_RX && > + new_mode == WL1273_AUDIO_ANALOG) { > + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE, > + WL1273_AUDIO_ENABLE_ANALOG); > + if (r) > + goto out; > + > + } else if (core->mode == WL1273_MODE_TX && > + new_mode == WL1273_AUDIO_DIGITAL) { > + r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET, > + core->i2s_mode); > + if (r) > + goto out; > + > + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_IO_SET, > + WL1273_AUDIO_IO_SET_I2S); > + if (r) > + goto out; > + > + } else if (core->mode == WL1273_MODE_TX && > + new_mode == WL1273_AUDIO_ANALOG) { > + r = wl1273_fm_write_cmd(core, WL1273_AUDIO_IO_SET, > + WL1273_AUDIO_IO_SET_ANALOG); > + if (r) > + goto out; > + } > + > + core->audio_mode = new_mode; > + > +out: > + return r; > +} > +EXPORT_SYMBOL(wl1273_fm_set_audio); Hmm... why do you need to export a symbol here? > + > +/** > + * wl1273_fm_set_volume() - Set volume. > + * @core: A pointer to the device struct. > + * @volume: The new volume value. > + */ > +int wl1273_fm_set_volume(struct wl1273_core *core, unsigned int volume) > +{ > + u16 val; > + int r; > + > + if (volume > WL1273_MAX_VOLUME) > + return -EINVAL; > + > + if (core->volume == volume) > + return 0; > + > + val = volume; > + r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val); > + if (r) > + return r; > + > + core->volume = volume; > + return 0; > +} > +EXPORT_SYMBOL(wl1273_fm_set_volume); Hmm... why do you need to export a symbol here? > + > +#define WL1273_FIFO_HAS_DATA(status) (1 << 5 & status) > + > +#define WL1273_RDS_CORRECTABLE_ERROR (1 << 3) > +#define WL1273_RDS_UNCORRECTABLE_ERROR (1 << 4) > + > +static int wl1273_fm_rds(struct wl1273_core *core) > +{ > + struct i2c_client *client = core->i2c_dev; > + struct device *dev = &client->dev; > + u16 val; > + u8 b0[] = { WL1273_RDS_DATA_GET }, status; > + struct v4l2_rds_data rds = { 0, 0, 0 }; > + struct i2c_msg msg[] = { > + { > + .addr = client->addr, > + .flags = 0, > + .buf = b0, > + .len = sizeof(b0) > + }, > + { > + .addr = client->addr, > + .flags = I2C_M_RD, > + .buf = (u8 *) &rds, > + .len = sizeof(rds), > + } > + }; > + int r; > + > + if (core->mode != WL1273_MODE_RX) > + return 0; > + > + r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val); > + if (r) > + return r; > + > + if ((val & 0x01) == 0) { > + /* RDS decoder not synchronized */ > + return -EAGAIN; > + } > + > + /* copy all four RDS blocks to internal buffer */ > + do { > + r = i2c_transfer(client->adapter, msg, 2); > + if (r != 2) { > + dev_err(dev, WL1273_FM_DRIVER_NAME > + ": %s: read_rds error r == %i)\n", > + __func__, r); > + } > + > + status = rds.block; > + > + if (!WL1273_FIFO_HAS_DATA(status)) > + break; > + > + /* fill bits 0-5 */ > + rds.block = 0x07 & status; > + rds.block |= rds.block << 3; > + > + /* copy the error bits to standard positions */ > + if (WL1273_RDS_UNCORRECTABLE_ERROR & status) { > + rds.block |= V4L2_RDS_BLOCK_ERROR; > + rds.block &= ~V4L2_RDS_BLOCK_CORRECTED; > + } else if (WL1273_RDS_CORRECTABLE_ERROR & status) { > + rds.block &= ~V4L2_RDS_BLOCK_ERROR; > + rds.block |= V4L2_RDS_BLOCK_CORRECTED; > + } > + > + /* copy RDS block to internal buffer */ > + memcpy(&core->buffer[core->wr_index], &rds, 3); > + core->wr_index += 3; > + > + /* wrap write pointer */ > + if (core->wr_index >= core->buf_size) > + core->wr_index = 0; > + > + /* check for overflow & start over */ > + if (core->wr_index == core->rd_index) { > + dev_dbg(dev, "RDS OVERFLOW"); > + > + core->rd_index = 0; > + core->wr_index = 0; > + break; > + } > + } while (WL1273_FIFO_HAS_DATA(status)); > + > + /* wake up read queue */ > + if (core->wr_index != core->rd_index) > + wake_up_interruptible(&core->read_queue); > + > + return 0; > +} > + > +static void wl1273_fm_rds_work(struct wl1273_core *core) > +{ > + wl1273_fm_rds(core); > +} Wouldn't be better to just use wl1273_fm_rds() instead of this? > + > +static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id) > +{ > + int r; > + u16 flags; > + struct wl1273_core *core = dev_id; > + > + r = wl1273_fm_read_reg(core, WL1273_FLAG_GET, &flags); > + if (r) > + goto out; > + > + if (flags & WL1273_BL_EVENT) { > + core->irq_received = flags; > + dev_dbg(&core->i2c_dev->dev, "IRQ: BL\n"); > + } > + > + if (flags & WL1273_RDS_EVENT) { > + msleep(200); > + > + wl1273_fm_rds_work(core); > + } > + > + if (flags & WL1273_BBLK_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: BBLK\n"); > + > + if (flags & WL1273_LSYNC_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: LSYNC\n"); > + > + if (flags & WL1273_LEV_EVENT) { > + u16 level; > + > + r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &level); > + > + if (r) > + goto out; > + > + if (level > 14) > + dev_dbg(&core->i2c_dev->dev, "IRQ: LEV: 0x%x04\n", > + level); > + } > + > + if (flags & WL1273_IFFR_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: IFFR\n"); > + > + if (flags & WL1273_PI_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: PI\n"); > + > + if (flags & WL1273_PD_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: PD\n"); > + > + if (flags & WL1273_STIC_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: STIC\n"); > + > + if (flags & WL1273_MAL_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: MAL\n"); > + > + if (flags & WL1273_POW_ENB_EVENT) { > + complete(&core->busy); > + dev_dbg(&core->i2c_dev->dev, "NOT BUSY\n"); > + dev_dbg(&core->i2c_dev->dev, "IRQ: POW_ENB\n"); > + } > + > + if (flags & WL1273_SCAN_OVER_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: SCAN_OVER\n"); > + > + if (flags & WL1273_ERROR_EVENT) > + dev_dbg(&core->i2c_dev->dev, "IRQ: ERROR\n"); > + > + if (flags & WL1273_FR_EVENT) { > + u16 freq; > + > + dev_dbg(&core->i2c_dev->dev, "IRQ: FR:\n"); > + > + if (core->mode == WL1273_MODE_RX) { > + r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, > + TUNER_MODE_STOP_SEARCH); > + if (r) { > + dev_err(&core->i2c_dev->dev, > + "%s: TUNER_MODE_SET fails: %d\n", > + __func__, r); > + goto out; > + } > + > + r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &freq); > + if (r) > + goto out; > + > + core->rx_frequency = > + bands[core->band].bottom_frequency + > + freq * 50; > + > + /* > + * The driver works better with this msleep, > + * the documentation doesn't mention it. > + */ > + usleep_range(10000, 15000); > + > + dev_dbg(&core->i2c_dev->dev, "%dkHz\n", > + core->rx_frequency); > + > + } else { > + r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &freq); > + if (r) > + goto out; > + > + dev_dbg(&core->i2c_dev->dev, "%dkHz\n", freq); > + } > + dev_dbg(&core->i2c_dev->dev, "%s: NOT BUSY\n", __func__); > + } > + > +out: > + wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, > + core->irq_flags); > + complete(&core->busy); > + > + return IRQ_HANDLED; > +} > + > +static struct i2c_device_id wl1273_driver_id_table[] = { > + { WL1273_FM_DRIVER_NAME, 0 }, > + { } > +}; > +MODULE_DEVICE_TABLE(i2c, wl1273_driver_id_table); > + > +static int wl1273_core_remove(struct i2c_client *client) > +{ > + struct wl1273_core *core = i2c_get_clientdata(client); > + struct wl1273_fm_platform_data *pdata = > + client->dev.platform_data; > + > + dev_dbg(&client->dev, "%s\n", __func__); > + > + mfd_remove_devices(&client->dev); > + i2c_set_clientdata(client, core); > + > + free_irq(client->irq, core); > + pdata->free_resources(); > + > + kfree(core->buffer); > + kfree(core); > + > + return 0; > +} > + > +static int __devinit wl1273_core_probe(struct i2c_client *client, > + const struct i2c_device_id *id) > +{ > + struct wl1273_fm_platform_data *pdata = client->dev.platform_data; > + int r = 0; > + struct wl1273_core *core; > + int children = 0; > + > + dev_dbg(&client->dev, "%s\n", __func__); > + > + if (!pdata) { > + dev_err(&client->dev, "No platform data.\n"); > + return -EINVAL; > + } > + > + core = kzalloc(sizeof(*core), GFP_KERNEL); > + if (!core) > + return -ENOMEM; > + > + /* RDS buffer allocation */ > + core->buf_size = rds_buf * 3; Why it should be multiplied by a "random"value of 3? > + core->buffer = kmalloc(core->buf_size, GFP_KERNEL); > + if (!core->buffer) { > + dev_err(&client->dev, > + "Cannot allocate memory for RDS buffer.\n"); > + r = -ENOMEM; > + goto err_kmalloc; > + } > + > + core->irq_flags = WL1273_IRQ_MASK; > + core->i2c_dev = client; > + core->rds_on = false; > + core->mode = WL1273_MODE_OFF; > + core->tx_power = 118; > + core->audio_mode = WL1273_AUDIO_ANALOG; > + core->band = radio_band; > + core->bands = bands; > + core->number_of_bands = ARRAY_SIZE(bands); > + core->i2s_mode = WL1273_I2S_DEF_MODE; > + core->channel_number = 2; > + core->volume = WL1273_DEFAULT_VOLUME; > + core->rx_frequency = bands[core->band].bottom_frequency; > + core->tx_frequency = bands[core->band].top_frequency; > + core->stereo = true; > + > + dev_dbg(&client->dev, "radio_band: %d\n", radio_band); > + > + mutex_init(&core->lock); > + > + pdata = client->dev.platform_data; > + if (pdata) { > + r = pdata->request_resources(client); > + if (r) { > + dev_err(&client->dev, WL1273_FM_DRIVER_NAME > + ": Cannot get platform data\n"); > + goto err_new_mixer; > + } > + > + r = request_threaded_irq(client->irq, NULL, > + wl1273_fm_irq_thread_handler, > + IRQF_ONESHOT | IRQF_TRIGGER_FALLING, > + "wl1273-fm", core); > + if (r < 0) { > + dev_err(&client->dev, WL1273_FM_DRIVER_NAME > + ": Unable to register IRQ handler\n"); > + goto err_request_irq; > + } > + } else { > + dev_err(&client->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ" > + " not configured"); > + r = -EINVAL; > + goto err_new_mixer; > + } > + > + init_completion(&core->busy); > + init_waitqueue_head(&core->read_queue); > + > + i2c_set_clientdata(client, core); > + > + if (pdata->children & WL1273_RADIO_CHILD) { > + struct mfd_cell *cell = &core->cells[children]; > + dev_dbg(&client->dev, "%s: Have V4L2.\n", __func__); > + cell->name = "wl1273_fm_radio"; > + cell->platform_data = &core; > + cell->data_size = sizeof(core); > + children++; > + } > + > + if (pdata->children & WL1273_CODEC_CHILD) { > + struct mfd_cell *cell = &core->cells[children]; > + dev_dbg(&client->dev, "%s: Have codec.\n", __func__); > + cell->name = "wl1273_codec_audio"; > + cell->platform_data = &core; > + cell->data_size = sizeof(core); > + children++; > + } > + > + if (children) { > + dev_dbg(&client->dev, "%s: Have children.\n", __func__); > + r = mfd_add_devices(&client->dev, -1, core->cells, > + children, NULL, 0); > + } else { > + dev_err(&client->dev, "No platform data found for children.\n"); > + r = -ENODEV; > + } > + > + if (!r) > + return 0; > + > + i2c_set_clientdata(client, NULL); > + kfree(core); > + free_irq(client->irq, core); > +err_request_irq: > + pdata->free_resources(); > +err_new_mixer: > + kfree(core->buffer); > +err_kmalloc: > + kfree(core); > + dev_dbg(&client->dev, "%s\n", __func__); > + > + return r; > +} > + > +static struct i2c_driver wl1273_core_driver = { > + .driver = { > + .name = WL1273_FM_DRIVER_NAME, > + }, > + .probe = wl1273_core_probe, > + .id_table = wl1273_driver_id_table, > + .remove = __devexit_p(wl1273_core_remove), > +}; > + > +static int __init wl1273_core_init(void) > +{ > + int r; > + > + r = i2c_add_driver(&wl1273_core_driver); > + if (r) { > + pr_err(WL1273_FM_DRIVER_NAME > + ": driver registration failed\n"); > + return r; > + } > + > + return 0; > +} > + > +static void __exit wl1273_core_exit(void) > +{ > + flush_scheduled_work(); > + > + i2c_del_driver(&wl1273_core_driver); > +} > +late_initcall(wl1273_core_init); > +module_exit(wl1273_core_exit); > + > +MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>"); > +MODULE_DESCRIPTION(DRIVER_DESC); > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/mfd/wl1273-core.h b/include/linux/mfd/wl1273-core.h > new file mode 100644 > index 0000000..30a9e9a > --- /dev/null > +++ b/include/linux/mfd/wl1273-core.h > @@ -0,0 +1,314 @@ > +/* > + * include/media/radio/radio-wl1273.h > + * > + * Some definitions for the wl1273 radio receiver/transmitter chip. > + * > + * Copyright (C) Nokia Corporation > + * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> > + * > + * 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., 51 Franklin St, Fifth Floor, Boston, MA > + * 02110-1301 USA > + */ > + > +#ifndef RADIO_WL1273_H > +#define RADIO_WL1273_H > + > +#include <linux/i2c.h> > +#include <linux/mfd/core.h> > + > +#define WL1273_FM_DRIVER_NAME "wl1273-fm" > +#define RX71_FM_I2C_ADDR 0x22 > + > +#define WL1273_STEREO_GET 0 > +#define WL1273_RSSI_LVL_GET 1 > +#define WL1273_IF_COUNT_GET 2 > +#define WL1273_FLAG_GET 3 > +#define WL1273_RDS_SYNC_GET 4 > +#define WL1273_RDS_DATA_GET 5 > +#define WL1273_FREQ_SET 10 > +#define WL1273_AF_FREQ_SET 11 > +#define WL1273_MOST_MODE_SET 12 > +#define WL1273_MOST_BLEND_SET 13 > +#define WL1273_DEMPH_MODE_SET 14 > +#define WL1273_SEARCH_LVL_SET 15 > +#define WL1273_BAND_SET 16 > +#define WL1273_MUTE_STATUS_SET 17 > +#define WL1273_RDS_PAUSE_LVL_SET 18 > +#define WL1273_RDS_PAUSE_DUR_SET 19 > +#define WL1273_RDS_MEM_SET 20 > +#define WL1273_RDS_BLK_B_SET 21 > +#define WL1273_RDS_MSK_B_SET 22 > +#define WL1273_RDS_PI_MASK_SET 23 > +#define WL1273_RDS_PI_SET 24 > +#define WL1273_RDS_SYSTEM_SET 25 > +#define WL1273_INT_MASK_SET 26 > +#define WL1273_SEARCH_DIR_SET 27 > +#define WL1273_VOLUME_SET 28 > +#define WL1273_AUDIO_ENABLE 29 > +#define WL1273_PCM_MODE_SET 30 > +#define WL1273_I2S_MODE_CONFIG_SET 31 > +#define WL1273_POWER_SET 32 > +#define WL1273_INTX_CONFIG_SET 33 > +#define WL1273_PULL_EN_SET 34 > +#define WL1273_HILO_SET 35 > +#define WL1273_SWITCH2FREF 36 > +#define WL1273_FREQ_DRIFT_REPORT 37 > + > +#define WL1273_PCE_GET 40 > +#define WL1273_FIRM_VER_GET 41 > +#define WL1273_ASIC_VER_GET 42 > +#define WL1273_ASIC_ID_GET 43 > +#define WL1273_MAN_ID_GET 44 > +#define WL1273_TUNER_MODE_SET 45 > +#define WL1273_STOP_SEARCH 46 > +#define WL1273_RDS_CNTRL_SET 47 > + > +#define WL1273_WRITE_HARDWARE_REG 100 > +#define WL1273_CODE_DOWNLOAD 101 > +#define WL1273_RESET 102 > + > +#define WL1273_FM_POWER_MODE 254 > +#define WL1273_FM_INTERRUPT 255 > + > +/* Transmitter API */ > + > +#define WL1273_CHANL_SET 55 > +#define WL1273_SCAN_SPACING_SET 56 > +#define WL1273_REF_SET 57 > +#define WL1273_POWER_ENB_SET 90 > +#define WL1273_POWER_ATT_SET 58 > +#define WL1273_POWER_LEV_SET 59 > +#define WL1273_AUDIO_DEV_SET 60 > +#define WL1273_PILOT_DEV_SET 61 > +#define WL1273_RDS_DEV_SET 62 > +#define WL1273_PUPD_SET 91 > +#define WL1273_AUDIO_IO_SET 63 > +#define WL1273_PREMPH_SET 64 > +#define WL1273_MONO_SET 66 > +#define WL1273_MUTE 92 > +#define WL1273_MPX_LMT_ENABLE 67 > +#define WL1273_PI_SET 93 > +#define WL1273_ECC_SET 69 > +#define WL1273_PTY 70 > +#define WL1273_AF 71 > +#define WL1273_DISPLAY_MODE 74 > +#define WL1273_RDS_REP_SET 77 > +#define WL1273_RDS_CONFIG_DATA_SET 98 > +#define WL1273_RDS_DATA_SET 99 > +#define WL1273_RDS_DATA_ENB 94 > +#define WL1273_TA_SET 78 > +#define WL1273_TP_SET 79 > +#define WL1273_DI_SET 80 > +#define WL1273_MS_SET 81 > +#define WL1273_PS_SCROLL_SPEED 82 > +#define WL1273_TX_AUDIO_LEVEL_TEST 96 > +#define WL1273_TX_AUDIO_LEVEL_TEST_THRESHOLD 73 > +#define WL1273_TX_AUDIO_INPUT_LEVEL_RANGE_SET 54 > +#define WL1273_RX_ANTENNA_SELECT 87 > +#define WL1273_I2C_DEV_ADDR_SET 86 > +#define WL1273_REF_ERR_CALIB_PARAM_SET 88 > +#define WL1273_REF_ERR_CALIB_PERIODICITY_SET 89 > +#define WL1273_SOC_INT_TRIGGER 52 > +#define WL1273_SOC_AUDIO_PATH_SET 83 > +#define WL1273_SOC_PCMI_OVERRIDE 84 > +#define WL1273_SOC_I2S_OVERRIDE 85 > +#define WL1273_RSSI_BLOCK_SCAN_FREQ_SET 95 > +#define WL1273_RSSI_BLOCK_SCAN_START 97 > +#define WL1273_RSSI_BLOCK_SCAN_DATA_GET 5 > +#define WL1273_READ_FMANT_TUNE_VALUE 104 > + > +#define WL1273_RDS_OFF 0 > +#define WL1273_RDS_ON 1 > +#define WL1273_RDS_RESET 2 > + > +#define WL1273_AUDIO_DIGITAL 0 > +#define WL1273_AUDIO_ANALOG 1 > + > +#define WL1273_MODE_RX (1 << 0) > +#define WL1273_MODE_TX (1 << 1) > +#define WL1273_MODE_OFF (1 << 2) > +#define WL1273_MODE_SUSPENDED (1 << 3) > + > +#define WL1273_RADIO_CHILD (1 << 0) > +#define WL1273_CODEC_CHILD (1 << 1) > + > +#define WL1273_RX_MONO 1 > +#define WL1273_RX_STEREO 0 > +#define WL1273_TX_MONO 0 > +#define WL1273_TX_STEREO 1 > + > +#define WL1273_MAX_VOLUME 0xffff > +#define WL1273_DEFAULT_VOLUME 0x78b8 > + > +/* I2S protocol, left channel first, data width 16 bits */ > +#define WL1273_PCM_DEF_MODE 0x00 > + > +/* Rx */ > +#define WL1273_AUDIO_ENABLE_I2S (1 << 0) > +#define WL1273_AUDIO_ENABLE_ANALOG (1 << 1) > + > +/* Tx */ > +#define WL1273_AUDIO_IO_SET_ANALOG 0 > +#define WL1273_AUDIO_IO_SET_I2S 1 > + > +#define WL1273_POWER_SET_OFF 0 > +#define WL1273_POWER_SET_FM (1 << 0) > +#define WL1273_POWER_SET_RDS (1 << 1) > +#define WL1273_POWER_SET_RETENTION (1 << 4) > + > +#define WL1273_PUPD_SET_OFF 0x00 > +#define WL1273_PUPD_SET_ON 0x01 > +#define WL1273_PUPD_SET_RETENTION 0x10 > + > +/* I2S mode */ > +#define WL1273_IS2_WIDTH_32 0x0 > +#define WL1273_IS2_WIDTH_40 0x1 > +#define WL1273_IS2_WIDTH_22_23 0x2 > +#define WL1273_IS2_WIDTH_23_22 0x3 > +#define WL1273_IS2_WIDTH_48 0x4 > +#define WL1273_IS2_WIDTH_50 0x5 > +#define WL1273_IS2_WIDTH_60 0x6 > +#define WL1273_IS2_WIDTH_64 0x7 > +#define WL1273_IS2_WIDTH_80 0x8 > +#define WL1273_IS2_WIDTH_96 0x9 > +#define WL1273_IS2_WIDTH_128 0xa > +#define WL1273_IS2_WIDTH 0xf > + > +#define WL1273_IS2_FORMAT_STD (0x0 << 4) > +#define WL1273_IS2_FORMAT_LEFT (0x1 << 4) > +#define WL1273_IS2_FORMAT_RIGHT (0x2 << 4) > +#define WL1273_IS2_FORMAT_USER (0x3 << 4) > + > +#define WL1273_IS2_MASTER (0x0 << 6) > +#define WL1273_IS2_SLAVEW (0x1 << 6) > + > +#define WL1273_IS2_TRI_AFTER_SENDING (0x0 << 7) > +#define WL1273_IS2_TRI_ALWAYS_ACTIVE (0x1 << 7) > + > +#define WL1273_IS2_SDOWS_RR (0x0 << 8) > +#define WL1273_IS2_SDOWS_RF (0x1 << 8) > +#define WL1273_IS2_SDOWS_FR (0x2 << 8) > +#define WL1273_IS2_SDOWS_FF (0x3 << 8) > + > +#define WL1273_IS2_TRI_OPT (0x0 << 10) > +#define WL1273_IS2_TRI_ALWAYS (0x1 << 10) > + > +#define WL1273_IS2_RATE_48K (0x0 << 12) > +#define WL1273_IS2_RATE_44_1K (0x1 << 12) > +#define WL1273_IS2_RATE_32K (0x2 << 12) > +#define WL1273_IS2_RATE_22_05K (0x4 << 12) > +#define WL1273_IS2_RATE_16K (0x5 << 12) > +#define WL1273_IS2_RATE_12K (0x8 << 12) > +#define WL1273_IS2_RATE_11_025 (0x9 << 12) > +#define WL1273_IS2_RATE_8K (0xa << 12) > +#define WL1273_IS2_RATE (0xf << 12) > + > +#define WL1273_I2S_DEF_MODE (WL1273_IS2_WIDTH_32 | \ > + WL1273_IS2_FORMAT_STD | \ > + WL1273_IS2_MASTER | \ > + WL1273_IS2_TRI_AFTER_SENDING | \ > + WL1273_IS2_SDOWS_RR | \ > + WL1273_IS2_TRI_OPT | \ > + WL1273_IS2_RATE_48K) > + > +#define SCHAR_MIN (-128) > +#define SCHAR_MAX 127 > + > +#define WL1273_FR_EVENT (1 << 0) > +#define WL1273_BL_EVENT (1 << 1) > +#define WL1273_RDS_EVENT (1 << 2) > +#define WL1273_BBLK_EVENT (1 << 3) > +#define WL1273_LSYNC_EVENT (1 << 4) > +#define WL1273_LEV_EVENT (1 << 5) > +#define WL1273_IFFR_EVENT (1 << 6) > +#define WL1273_PI_EVENT (1 << 7) > +#define WL1273_PD_EVENT (1 << 8) > +#define WL1273_STIC_EVENT (1 << 9) > +#define WL1273_MAL_EVENT (1 << 10) > +#define WL1273_POW_ENB_EVENT (1 << 11) > +#define WL1273_SCAN_OVER_EVENT (1 << 12) > +#define WL1273_ERROR_EVENT (1 << 13) > + > +#define TUNER_MODE_STOP_SEARCH 0 > +#define TUNER_MODE_PRESET 1 > +#define TUNER_MODE_AUTO_SEEK 2 > +#define TUNER_MODE_AF 3 > +#define TUNER_MODE_AUTO_SEEK_PI 4 > +#define TUNER_MODE_AUTO_SEEK_BULK 5 > + > +struct band_info { > + u32 bottom_frequency; > + u32 top_frequency; > + u8 band; > +}; > + > +struct wl1273_fm_platform_data { > + int (*request_resources) (struct i2c_client *client); > + void (*free_resources) (void); > + void (*enable) (void); > + void (*disable) (void); > + > + u8 forbidden_modes; > + unsigned int children; > +}; > + > +#define WL1273_FM_CORE_CELLS 2 > + > +struct wl1273_core { > + struct mfd_cell cells[WL1273_FM_CORE_CELLS]; > + struct i2c_client *i2c_dev; > + > + u8 forbidden; > + unsigned int mode; > + unsigned int preemphasis; > + unsigned int audio_mode; > + unsigned int spacing; > + unsigned int tx_power; > + unsigned int rx_frequency; > + unsigned int tx_frequency; > + unsigned int band; > + unsigned int i2s_mode; > + unsigned int channel_number; > + unsigned int number_of_bands; > + unsigned int volume; > + bool stereo; > + > + const struct band_info *bands; > + > + /* RDS */ > + unsigned int rds_on; > + struct delayed_work work; > + > + wait_queue_head_t read_queue; > + struct mutex lock; /* for serializing fm radio operations */ > + struct completion busy; > + > + unsigned char *buffer; > + unsigned int buf_size; > + unsigned int rd_index; > + unsigned int wr_index; > + > + /* Selected interrupts */ > + u16 irq_flags; > + u16 irq_received; > +}; > + > +int wl1273_fm_write_cmd(struct wl1273_core *core, u8 cmd, u16 param); > +int wl1273_fm_write_data(struct wl1273_core *core, u8 *data, u16 len); > +int wl1273_fm_read_reg(struct wl1273_core *core, u8 reg, u16 *value); > + > +int wl1273_fm_set_audio(struct wl1273_core *core, unsigned int mode); > +int wl1273_fm_set_volume(struct wl1273_core *core, unsigned int volume); > + > +#endif /* ifndef RADIO_WL1273_H */ ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class. 2010-08-30 11:38 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio Matti J. Aaltonen @ 2010-09-08 18:35 ` Mauro Carvalho Chehab 2010-09-09 7:57 ` Matti J. Aaltonen 2010-09-15 9:54 ` Matti J. Aaltonen 1 sibling, 2 replies; 23+ messages in thread From: Mauro Carvalho Chehab @ 2010-09-08 18:35 UTC (permalink / raw) To: Matti J. Aaltonen; +Cc: linux-media, hverkuil, eduardo.valentin Em 30-08-2010 08:38, Matti J. Aaltonen escreveu: > Add spacing field to v4l2_hw_freq_seek, add V4L2_CAP_RAW_RDS_ONLY > to driver capabilities and also add FM RX class to control classes. > > Signed-off-by: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> > --- > drivers/media/video/v4l2-ctrls.c | 12 ++++++++++++ > include/linux/videodev2.h | 16 +++++++++++++++- > 2 files changed, 27 insertions(+), 1 deletions(-) > > diff --git a/drivers/media/video/v4l2-ctrls.c b/drivers/media/video/v4l2-ctrls.c > index ea8d32c..15749f1 100644 > --- a/drivers/media/video/v4l2-ctrls.c > +++ b/drivers/media/video/v4l2-ctrls.c > @@ -216,6 +216,12 @@ const char **v4l2_ctrl_get_menu(u32 id) > "75 useconds", > NULL, > }; > + static const char *fm_band[] = { > + "87.5 - 108. MHz", > + "76. - 90. MHz, Japan", > + "65. - 74. MHz, OIRT", > + NULL, > + }; > > switch (id) { > case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: > @@ -256,6 +262,8 @@ const char **v4l2_ctrl_get_menu(u32 id) > return colorfx; > case V4L2_CID_TUNE_PREEMPHASIS: > return tune_preemphasis; > + case V4L2_CID_FM_BAND: > + return fm_band; > default: > return NULL; > } > @@ -386,6 +394,8 @@ const char *v4l2_ctrl_get_name(u32 id) > case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings"; > case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level"; > case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor"; > + case V4L2_CID_FM_RX_CLASS: return "FM Radio Tuner Controls"; > + case V4L2_CID_FM_BAND: return "FM Band"; There's no need for a FM control, as there's already an ioctl pair that allows get/set the frequency bandwidth: VIDIOC_S_TUNER and VIDIOC_G_TUNER. So, the entire patch here seems uneeded/unwanted. > > default: > return NULL; > @@ -448,6 +458,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, > case V4L2_CID_EXPOSURE_AUTO: > case V4L2_CID_COLORFX: > case V4L2_CID_TUNE_PREEMPHASIS: > + case V4L2_CID_FM_BAND: > *type = V4L2_CTRL_TYPE_MENU; > break; > case V4L2_CID_RDS_TX_PS_NAME: > @@ -458,6 +469,7 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type, > case V4L2_CID_CAMERA_CLASS: > case V4L2_CID_MPEG_CLASS: > case V4L2_CID_FM_TX_CLASS: > + case V4L2_CID_FM_RX_CLASS: > *type = V4L2_CTRL_TYPE_CTRL_CLASS; > /* You can neither read not write these */ > *flags |= V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY; > diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h > index 61490c6..7d6511e 100644 > --- a/include/linux/videodev2.h > +++ b/include/linux/videodev2.h > @@ -244,6 +244,7 @@ struct v4l2_capability { > #define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */ > #define V4L2_CAP_HW_FREQ_SEEK 0x00000400 /* Can do hardware frequency seek */ > #define V4L2_CAP_RDS_OUTPUT 0x00000800 /* Is an RDS encoder */ > +#define V4L2_CAP_RAW_RDS_ONLY 0x00001000 /* Does not interpret RDS data */ > > #define V4L2_CAP_TUNER 0x00010000 /* has a tuner */ > #define V4L2_CAP_AUDIO 0x00020000 /* has audio support */ > @@ -930,6 +931,7 @@ struct v4l2_ext_controls { > #define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */ > #define V4L2_CTRL_CLASS_CAMERA 0x009a0000 /* Camera class controls */ > #define V4L2_CTRL_CLASS_FM_TX 0x009b0000 /* FM Modulator control class */ > +#define V4L2_CTRL_CLASS_FM_RX 0x009c0000 /* FM Tuner control class */ > > #define V4L2_CTRL_ID_MASK (0x0fffffff) > #define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL) > @@ -1328,6 +1330,17 @@ enum v4l2_preemphasis { > #define V4L2_CID_TUNE_POWER_LEVEL (V4L2_CID_FM_TX_CLASS_BASE + 113) > #define V4L2_CID_TUNE_ANTENNA_CAPACITOR (V4L2_CID_FM_TX_CLASS_BASE + 114) > > +/* FM Tuner class control IDs */ > +#define V4L2_CID_FM_RX_CLASS_BASE (V4L2_CTRL_CLASS_FM_RX | 0x900) > +#define V4L2_CID_FM_RX_CLASS (V4L2_CTRL_CLASS_FM_RX | 1) > + > +#define V4L2_CID_FM_BAND (V4L2_CID_FM_RX_CLASS_BASE + 1) > +enum v4l2_fm_band { > + V4L2_FM_BAND_OTHER = 0, > + V4L2_FM_BAND_JAPAN = 1, > + V4L2_FM_BAND_OIRT = 2 > +}; > + > /* > * T U N I N G > */ > @@ -1392,7 +1405,8 @@ struct v4l2_hw_freq_seek { > enum v4l2_tuner_type type; > __u32 seek_upward; > __u32 wrap_around; > - __u32 reserved[8]; > + __u32 spacing; > + __u32 reserved[7]; > }; > > /* ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class. 2010-09-08 18:35 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Mauro Carvalho Chehab @ 2010-09-09 7:57 ` Matti J. Aaltonen 2010-09-15 9:54 ` Matti J. Aaltonen 1 sibling, 0 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-09 7:57 UTC (permalink / raw) To: ext Mauro Carvalho Chehab Cc: linux-media@vger.kernel.org, hverkuil@xs4all.nl, Valentin Eduardo (Nokia-MS/Helsinki) Hello. And thanks for the comments. On Wed, 2010-09-08 at 20:35 +0200, ext Mauro Carvalho > > } > > @@ -386,6 +394,8 @@ const char *v4l2_ctrl_get_name(u32 id) > > case V4L2_CID_TUNE_PREEMPHASIS: return "Pre-emphasis settings"; > > case V4L2_CID_TUNE_POWER_LEVEL: return "Tune Power Level"; > > case V4L2_CID_TUNE_ANTENNA_CAPACITOR: return "Tune Antenna Capacitor"; > > + case V4L2_CID_FM_RX_CLASS: return "FM Radio Tuner Controls"; > > > + case V4L2_CID_FM_BAND: return "FM Band"; > > > There's no need for a FM control, as there's already an ioctl pair that allows get/set the frequency > bandwidth: VIDIOC_S_TUNER and VIDIOC_G_TUNER. So, the entire patch here seems uneeded/unwanted. Sometime ago Hans said the following in his comment to v5 patches: > Based on this article: > http://en.wikipedia.org/wiki/FM_broadcasting, there > seem to be only three bands for FM radio in > practice: 87.5-108, 76-90 (Japan) > and 65-74 (former Soviet republics, some former > eastern bloc countries). > > So this should be a standard control. Since the > latter band is being phased > out I think a menu control with just the two other > bands is sufficient. > > And I also think this should be a control of a new > FM_RX class. > > I know, that's not what I said last time. So sue > me :-) But if we now have a consensus when we are at v9 that's good news... Thanks, Matti ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class. 2010-09-08 18:35 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Mauro Carvalho Chehab 2010-09-09 7:57 ` Matti J. Aaltonen @ 2010-09-15 9:54 ` Matti J. Aaltonen 1 sibling, 0 replies; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-15 9:54 UTC (permalink / raw) To: ext Mauro Carvalho Chehab Cc: linux-media@vger.kernel.org, hverkuil@xs4all.nl, Valentin Eduardo (Nokia-MS/Helsinki) Hello. On Wed, 2010-09-08 at 20:35 +0200, ext Mauro Carvalho Chehab wrote: > > + case V4L2_CID_FM_BAND: return "FM Band"; > > There's no need for a FM control, as there's already an ioctl pair that allows get/set the frequency > bandwidth: VIDIOC_S_TUNER and VIDIOC_G_TUNER. So, the entire patch here seems uneeded/unwanted. Yes I agree, we can manage without having BAND support, but it isn't completely covered by VIDIOC_S_TUNER and VIDIOC_G_TUNER. Actually it would have had the biggest effect on the HW seek operation. For example without V4L2_CID_FM_BAND using wl1273 FM radio, which supports two bands, you need to do two seeks and band switch for every HW_SEEK IOCTL and those seeks are kind of slow operations to begin with. You have probably taken this into consideration but I wanted point this out anyway... Could the seek struct have a band indicator? B.R. Matti ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-08-30 11:38 [PATCH v9 0/4] FM Radio driver Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Matti J. Aaltonen @ 2010-09-07 19:10 ` Hans Verkuil 2010-09-11 12:10 ` Hans Verkuil 2 siblings, 0 replies; 23+ messages in thread From: Hans Verkuil @ 2010-09-07 19:10 UTC (permalink / raw) To: Matti J. Aaltonen; +Cc: linux-media, eduardo.valentin, mchehab On Monday, August 30, 2010 13:38:18 Matti J. Aaltonen wrote: > Hi again, > > and thanks for the comments. > I've left the audio codec out of this patch set. > > Hans wrote: > > > In principle yes, but we haven't yet decided to implement those now, at > > > the moment the RDS interpretation is left completely to user space > > > applications. > > > > Matti, is it even possible to use the current FM TX RDS API for this chip? > > That API expects that the chip can generate the correct RDS packets based on > > high-level data. If the chip can only handle 'raw' RDS packets (requiring a > > userspace RDS encoder), then that API will never work. > > > > But if this chip can indeed handle raw RDS only, then we need to add some > > capability flags to signal that to userspace. > > It is possible to use the current FM TX RDS API, the chip supports at least > most of it. I just haven't implemented the support into the driver yet, > for a multiple of reasons. I'm planning of adding that in the relatively > near future. OK, good to know. > Anyhow, I've now added a way of telling that only raw RDS is supported. > Can we use one bit it the capability field for that? I need to research this a bit. I intended to do that last weekend, but Real Life (tm) interfered. I hope to get around it in the upcoming weekend. I'm really sorry about the long delays on my side. Believe me, it's not intentional. > > > + struct wl1273_device *radio = ctrl->priv; > > > > No need to use priv for this. You can use this instead: > > > > static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl) > > { > > return container_of(ctrl->handler, struct wl1273_device, ctrl_handler); > > } > > Fixed. I just didn't come to think that it can be done like this. > > > > + dev_dbg(radio->dev, "%s\n", __func__); > > > + return r; > > > +} > > > > Was the documentation on the control handler understandable enough? Any > > comments on how to improve the API or documentation? It's very new, so > > I'm interested in hearing about your experiences implementing this API. > > I think the documentation is OK. But I didn't have time to dwell on it, > but on the other hand I remember thinking that the new API is better > than the previous one... That's good news :-) > But what's the motivation behind having subdevices? You'll hardly > have several FM radios and want to do the same things on each > one at the same time? Right now this driver is a platform device if I'm not mistaken. But what if someone would stick this wl1273 on a USB stick? Or on some PCI board? Implementing the core wl1273 driver as a subdevice makes it independent from how it is assembled in the final product. There are other reasons as well, but it all boils down to creating an abstract interface towards hardware devices so that you no longer have to care about how they are hooked up physically to your platform/board/SoC/whatever. > > No need to use priv. > ... > > First V4L2_CID_FM_BAND using new_std instead of new_std_menu (which it should > be). > ... > > And a second?! > > > > > + if (ctrl) { > > > + ctrl->is_volatile = 1; > > > + ctrl->priv = radio; > > > + } > > > > And it is volatile? I thought that the ANTENNA_CAPACITOR was volatile. > > Something is messed up here. > > Fixed. Yes, that was completely messed up... I hope to have the final comments ready this weekend. It's high time to get this out of the door. Regards, Hans > > Thanks... > > Matti > > Matti J. Aaltonen (4): > V4L2: Add seek spacing and FM RX class. > MFD: WL1273 FM Radio: MFD driver for the FM radio. > V4L2: WL1273 FM Radio: Controls for the FM radio. > Documentation: v4l: Add hw_seek spacing and FM_RX class > > Documentation/DocBook/v4l/controls.xml | 71 + > Documentation/DocBook/v4l/dev-rds.xml | 5 + > .../DocBook/v4l/vidioc-s-hw-freq-seek.xml | 10 +- > drivers/media/radio/Kconfig | 15 + > drivers/media/radio/Makefile | 1 + > drivers/media/radio/radio-wl1273.c | 1935 ++++++++++++++++++++ > drivers/media/video/v4l2-ctrls.c | 12 + > drivers/mfd/Kconfig | 5 + > drivers/mfd/Makefile | 2 + > drivers/mfd/wl1273-core.c | 612 +++++++ > include/linux/mfd/wl1273-core.h | 314 ++++ > include/linux/videodev2.h | 16 +- > 12 files changed, 2995 insertions(+), 3 deletions(-) > create mode 100644 drivers/media/radio/radio-wl1273.c > create mode 100644 drivers/mfd/wl1273-core.c > create mode 100644 include/linux/mfd/wl1273-core.h > > -- > To unsubscribe from this list: send the line "unsubscribe linux-media" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > > -- Hans Verkuil - video4linux developer - sponsored by TANDBERG, part of Cisco ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-08-30 11:38 [PATCH v9 0/4] FM Radio driver Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Matti J. Aaltonen 2010-09-07 19:10 ` [PATCH v9 0/4] FM Radio driver Hans Verkuil @ 2010-09-11 12:10 ` Hans Verkuil 2010-09-13 10:50 ` Matti J. Aaltonen 2 siblings, 1 reply; 23+ messages in thread From: Hans Verkuil @ 2010-09-11 12:10 UTC (permalink / raw) To: Matti J. Aaltonen; +Cc: linux-media, eduardo.valentin, mchehab On Monday, August 30, 2010 13:38:18 Matti J. Aaltonen wrote: > Hi again, > > and thanks for the comments. > I've left the audio codec out of this patch set. > > Hans wrote: > > > In principle yes, but we haven't yet decided to implement those now, at > > > the moment the RDS interpretation is left completely to user space > > > applications. > > > > Matti, is it even possible to use the current FM TX RDS API for this chip? > > That API expects that the chip can generate the correct RDS packets based on > > high-level data. If the chip can only handle 'raw' RDS packets (requiring a > > userspace RDS encoder), then that API will never work. > > > > But if this chip can indeed handle raw RDS only, then we need to add some > > capability flags to signal that to userspace. > > It is possible to use the current FM TX RDS API, the chip supports at least > most of it. I just haven't implemented the support into the driver yet, > for a multiple of reasons. I'm planning of adding that in the relatively > near future. > > Anyhow, I've now added a way of telling that only raw RDS is supported. > Can we use one bit it the capability field for that? No, I don't think that is the right place. I've been thinking about this and I realized that the V4L2_TUNER_CAP_ bits are the best place to put this (these capability defines are reused by the modulator as well). It is a bit unfortunate that I didn't think about it some more when the RDS output API was made because the current V4L2_TUNER_CAP_RDS bit is now used for two different RDS formats: for capture it means the read() interface with a stream of v4l2_rds_data blocks and for output it means using the RDS controls. There are also up to three ways the RDS data can be received/sent: either as RDS blocks, or using controls, or as a completely raw bitstream. The latter is unlikely to be used for RDS output, but a cheap RDS receiver might just do this (and I believe these devices actually exist). So I propose to add the following tuner capability flags: V4L2_TUNER_CAP_RDS_READWRITE 0x0100 Use read()/write() V4L2_TUNER_CAP_RDS_CONTROLS 0x0200 Use RDS controls And this allows us to add a RDS_RAW_READWRITE in the future should we need it. We do need to add these capability flags to the existing RDS drivers (there are only a few, so that's no problem) and we need to document that for RDS capture the READWRITE is the default if neither READWRITE or CONTROLS is set, and that for RDS output the CONTROLS is the default in that case. Comments? Hans -- Hans Verkuil - video4linux developer - sponsored by TANDBERG, part of Cisco ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-11 12:10 ` Hans Verkuil @ 2010-09-13 10:50 ` Matti J. Aaltonen 2010-09-13 11:32 ` Hans Verkuil 0 siblings, 1 reply; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-13 10:50 UTC (permalink / raw) To: ext Hans Verkuil Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Sat, 2010-09-11 at 14:10 +0200, ext Hans Verkuil wrote: > There are also up to three ways the RDS data can be received/sent: either as > RDS blocks, or using controls, or as a completely raw bitstream. The latter is > unlikely to be used for RDS output, but a cheap RDS receiver might just do this > (and I believe these devices actually exist). I thought that the "raw" mode meant reading and writing (uninterpreted) RDS blocks. At least that's what the wl1273 chip does and that was what I meant. Is there already a way to deal with this case? Anyway the difference between the "completely raw bits" and the "raw" blocks is small. And I doubt the usefulness of supporting the "completely raw" format. B.R. Matti > So I propose to add the following tuner capability flags: > > V4L2_TUNER_CAP_RDS_READWRITE 0x0100 Use read()/write() > V4L2_TUNER_CAP_RDS_CONTROLS 0x0200 Use RDS controls > > And this allows us to add a RDS_RAW_READWRITE in the future should we need it. > > We do need to add these capability flags to the existing RDS drivers (there > are only a few, so that's no problem) and we need to document that for RDS > capture the READWRITE is the default if neither READWRITE or CONTROLS is set, > and that for RDS output the CONTROLS is the default in that case. > > Comments? > > Hans > ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 10:50 ` Matti J. Aaltonen @ 2010-09-13 11:32 ` Hans Verkuil 2010-09-13 11:44 ` Matti J. Aaltonen 0 siblings, 1 reply; 23+ messages in thread From: Hans Verkuil @ 2010-09-13 11:32 UTC (permalink / raw) To: matti.j.aaltonen Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Monday, September 13, 2010 12:50:31 Matti J. Aaltonen wrote: > On Sat, 2010-09-11 at 14:10 +0200, ext Hans Verkuil wrote: > > There are also up to three ways the RDS data can be received/sent: either as > > RDS blocks, or using controls, or as a completely raw bitstream. The latter is > > unlikely to be used for RDS output, but a cheap RDS receiver might just do this > > (and I believe these devices actually exist). > > I thought that the "raw" mode meant reading and writing (uninterpreted) > RDS blocks. At least that's what the wl1273 chip does and that was what > I meant. Is there already a way to deal with this case? I had to dig into the linux-media archives, but I found one chip (the cx2388x) that produces a 38 kHz 16 bit RDS data stream that needs to be demodulated in software. That's really raw :-) But I'm not aware of any board based on this chipset that actually uses this. > Anyway the difference between the "completely raw bits" and the "raw" > blocks is small. And I doubt the usefulness of supporting the > "completely raw" format. I don't intend to support it now. But we need to realize that it exists and we have to plan for it. Regards, Hans > > B.R. > Matti > > > So I propose to add the following tuner capability flags: > > > > V4L2_TUNER_CAP_RDS_READWRITE 0x0100 Use read()/write() > > V4L2_TUNER_CAP_RDS_CONTROLS 0x0200 Use RDS controls > > > > And this allows us to add a RDS_RAW_READWRITE in the future should we need it. > > > > We do need to add these capability flags to the existing RDS drivers (there > > are only a few, so that's no problem) and we need to document that for RDS > > capture the READWRITE is the default if neither READWRITE or CONTROLS is set, > > and that for RDS output the CONTROLS is the default in that case. > > > > Comments? > > > > Hans > > > > > -- Hans Verkuil - video4linux developer - sponsored by TANDBERG, part of Cisco ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 11:32 ` Hans Verkuil @ 2010-09-13 11:44 ` Matti J. Aaltonen 2010-09-13 11:51 ` Hans Verkuil 0 siblings, 1 reply; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-13 11:44 UTC (permalink / raw) To: ext Hans Verkuil Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Mon, 2010-09-13 at 13:32 +0200, ext Hans Verkuil wrote: > > Anyway the difference between the "completely raw bits" and the "raw" > > blocks is small. And I doubt the usefulness of supporting the > > "completely raw" format. > > I don't intend to support it now. But we need to realize that it exists and > we have to plan for it. OK. So we can have RDS_RAW_READWRITE and also RDS_RAW_BLOCK_READWRITE (or something to the same effect)? B.R. Matti ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 11:44 ` Matti J. Aaltonen @ 2010-09-13 11:51 ` Hans Verkuil 2010-09-13 11:59 ` Matti J. Aaltonen 0 siblings, 1 reply; 23+ messages in thread From: Hans Verkuil @ 2010-09-13 11:51 UTC (permalink / raw) To: matti.j.aaltonen Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Monday, September 13, 2010 13:44:31 Matti J. Aaltonen wrote: > On Mon, 2010-09-13 at 13:32 +0200, ext Hans Verkuil wrote: > > > Anyway the difference between the "completely raw bits" and the "raw" > > > blocks is small. And I doubt the usefulness of supporting the > > > "completely raw" format. > > > > I don't intend to support it now. But we need to realize that it exists and > > we have to plan for it. > > OK. So we can have RDS_RAW_READWRITE and also RDS_RAW_BLOCK_READWRITE > (or something to the same effect)? In theory, yes. My proposed API additions allow for this to be added in the future. Frankly, I don't think it is likely that it will be needed, but you never know. Regards, Hans > > B.R. > Matti > > > -- > To unsubscribe from this list: send the line "unsubscribe linux-media" in > the body of a message to majordomo@vger.kernel.org > More majordomo info at http://vger.kernel.org/majordomo-info.html > -- Hans Verkuil - video4linux developer - sponsored by TANDBERG, part of Cisco ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 11:51 ` Hans Verkuil @ 2010-09-13 11:59 ` Matti J. Aaltonen 2010-09-13 12:06 ` Hans Verkuil 0 siblings, 1 reply; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-13 11:59 UTC (permalink / raw) To: ext Hans Verkuil Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Mon, 2010-09-13 at 13:51 +0200, ext Hans Verkuil wrote: > On Monday, September 13, 2010 13:44:31 Matti J. Aaltonen wrote: > > On Mon, 2010-09-13 at 13:32 +0200, ext Hans Verkuil wrote: > > > > Anyway the difference between the "completely raw bits" and the "raw" > > > > blocks is small. And I doubt the usefulness of supporting the > > > > "completely raw" format. > > > > > > I don't intend to support it now. But we need to realize that it exists and > > > we have to plan for it. > > > > OK. So we can have RDS_RAW_READWRITE and also RDS_RAW_BLOCK_READWRITE > > (or something to the same effect)? > > In theory, yes. My proposed API additions allow for this to be added in the > future. Frankly, I don't think it is likely that it will be needed, but you > never know. Yes but I would like to add the RDS_RAW_BLOCK_READWRITE possibility right away because that's what the wl1273 driver does now... I guess that's OK? B.R. Matti > > Regards, > > Hans > > > > > B.R. > > Matti > > > > > > -- > > To unsubscribe from this list: send the line "unsubscribe linux-media" in > > the body of a message to majordomo@vger.kernel.org > > More majordomo info at http://vger.kernel.org/majordomo-info.html > > > ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 11:59 ` Matti J. Aaltonen @ 2010-09-13 12:06 ` Hans Verkuil 2010-09-13 12:15 ` Matti J. Aaltonen 0 siblings, 1 reply; 23+ messages in thread From: Hans Verkuil @ 2010-09-13 12:06 UTC (permalink / raw) To: matti.j.aaltonen Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Monday, September 13, 2010 13:59:30 Matti J. Aaltonen wrote: > On Mon, 2010-09-13 at 13:51 +0200, ext Hans Verkuil wrote: > > On Monday, September 13, 2010 13:44:31 Matti J. Aaltonen wrote: > > > On Mon, 2010-09-13 at 13:32 +0200, ext Hans Verkuil wrote: > > > > > Anyway the difference between the "completely raw bits" and the "raw" > > > > > blocks is small. And I doubt the usefulness of supporting the > > > > > "completely raw" format. > > > > > > > > I don't intend to support it now. But we need to realize that it exists and > > > > we have to plan for it. > > > > > > OK. So we can have RDS_RAW_READWRITE and also RDS_RAW_BLOCK_READWRITE > > > (or something to the same effect)? > > > > In theory, yes. My proposed API additions allow for this to be added in the > > future. Frankly, I don't think it is likely that it will be needed, but you > > never know. > > Yes but I would like to add the RDS_RAW_BLOCK_READWRITE possibility > right away because that's what the wl1273 driver does now... I guess > that's OK? Well, yeah. That's what I proposed with the new tuner caps: V4L2_TUNER_CAP_RDS_READWRITE 0x0100 Use read()/write() V4L2_TUNER_CAP_RDS_CONTROLS 0x0200 Use RDS controls Feel free to rename V4L2_TUNER_CAP_RDS_READWRITE to V4L2_TUNER_CAP_RDS_BLOCKS, that's a better name for it. Regards, Hans > > B.R. > Matti > > > > > Regards, > > > > Hans > > > > > > > > B.R. > > > Matti > > > > > > > > > -- > > > To unsubscribe from this list: send the line "unsubscribe linux-media" in > > > the body of a message to majordomo@vger.kernel.org > > > More majordomo info at http://vger.kernel.org/majordomo-info.html > > > > > > > > -- Hans Verkuil - video4linux developer - sponsored by TANDBERG, part of Cisco ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 12:06 ` Hans Verkuil @ 2010-09-13 12:15 ` Matti J. Aaltonen 2010-09-13 12:23 ` Hans Verkuil 0 siblings, 1 reply; 23+ messages in thread From: Matti J. Aaltonen @ 2010-09-13 12:15 UTC (permalink / raw) To: ext Hans Verkuil Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Mon, 2010-09-13 at 14:06 +0200, ext Hans Verkuil wrote: > On Monday, September 13, 2010 13:59:30 Matti J. Aaltonen wrote: > > On Mon, 2010-09-13 at 13:51 +0200, ext Hans Verkuil wrote: > > > On Monday, September 13, 2010 13:44:31 Matti J. Aaltonen wrote: > > > > On Mon, 2010-09-13 at 13:32 +0200, ext Hans Verkuil wrote: > > > > > > Anyway the difference between the "completely raw bits" and the "raw" > > > > > > blocks is small. And I doubt the usefulness of supporting the > > > > > > "completely raw" format. > > > > > > > > > > I don't intend to support it now. But we need to realize that it exists and > > > > > we have to plan for it. > > > > > > > > OK. So we can have RDS_RAW_READWRITE and also RDS_RAW_BLOCK_READWRITE > > > > (or something to the same effect)? > > > > > > In theory, yes. My proposed API additions allow for this to be added in the > > > future. Frankly, I don't think it is likely that it will be needed, but you > > > never know. > > > > Yes but I would like to add the RDS_RAW_BLOCK_READWRITE possibility > > right away because that's what the wl1273 driver does now... I guess > > that's OK? > > Well, yeah. That's what I proposed with the new tuner caps: OK, I didn't fully get that... sorry... > V4L2_TUNER_CAP_RDS_READWRITE 0x0100 Use read()/write() > V4L2_TUNER_CAP_RDS_CONTROLS 0x0200 Use RDS controls But now I see:-) We'll have: V4L2_TUNER_CAP_RDS_BLOCKS read()/write() V4L2_TUNER_CAP_RDS_CONTROLS RDS controls V4L2_TUNER_CAP_RDS_RAW also read()/write() B.R. Matti. ^ permalink raw reply [flat|nested] 23+ messages in thread
* Re: [PATCH v9 0/4] FM Radio driver. 2010-09-13 12:15 ` Matti J. Aaltonen @ 2010-09-13 12:23 ` Hans Verkuil 0 siblings, 0 replies; 23+ messages in thread From: Hans Verkuil @ 2010-09-13 12:23 UTC (permalink / raw) To: matti.j.aaltonen Cc: linux-media@vger.kernel.org, Valentin Eduardo (Nokia-MS/Helsinki), mchehab@redhat.com On Monday, September 13, 2010 14:15:00 Matti J. Aaltonen wrote: > On Mon, 2010-09-13 at 14:06 +0200, ext Hans Verkuil wrote: > > On Monday, September 13, 2010 13:59:30 Matti J. Aaltonen wrote: > > > On Mon, 2010-09-13 at 13:51 +0200, ext Hans Verkuil wrote: > > > > On Monday, September 13, 2010 13:44:31 Matti J. Aaltonen wrote: > > > > > On Mon, 2010-09-13 at 13:32 +0200, ext Hans Verkuil wrote: > > > > > > > Anyway the difference between the "completely raw bits" and the "raw" > > > > > > > blocks is small. And I doubt the usefulness of supporting the > > > > > > > "completely raw" format. > > > > > > > > > > > > I don't intend to support it now. But we need to realize that it exists and > > > > > > we have to plan for it. > > > > > > > > > > OK. So we can have RDS_RAW_READWRITE and also RDS_RAW_BLOCK_READWRITE > > > > > (or something to the same effect)? > > > > > > > > In theory, yes. My proposed API additions allow for this to be added in the > > > > future. Frankly, I don't think it is likely that it will be needed, but you > > > > never know. > > > > > > Yes but I would like to add the RDS_RAW_BLOCK_READWRITE possibility > > > right away because that's what the wl1273 driver does now... I guess > > > that's OK? > > > > Well, yeah. That's what I proposed with the new tuner caps: > > OK, I didn't fully get that... sorry... > > > V4L2_TUNER_CAP_RDS_READWRITE 0x0100 Use read()/write() > > V4L2_TUNER_CAP_RDS_CONTROLS 0x0200 Use RDS controls > > But now I see:-) > > We'll have: > > V4L2_TUNER_CAP_RDS_BLOCKS read()/write() > V4L2_TUNER_CAP_RDS_CONTROLS RDS controls > V4L2_TUNER_CAP_RDS_RAW also read()/write() Right! That's the idea. Regards, Hans > > B.R. > Matti. > > > > -- Hans Verkuil - video4linux developer - sponsored by TANDBERG, part of Cisco ^ permalink raw reply [flat|nested] 23+ messages in thread
end of thread, other threads:[~2010-09-16 7:37 UTC | newest] Thread overview: 23+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2010-08-30 11:38 [PATCH v9 0/4] FM Radio driver Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver for the FM radio Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls " Matti J. Aaltonen 2010-08-30 11:38 ` [PATCH v9 4/4] Documentation: v4l: Add hw_seek spacing and FM_RX class Matti J. Aaltonen 2010-09-08 18:37 ` Mauro Carvalho Chehab 2010-09-08 19:09 ` [PATCH v9 3/4] V4L2: WL1273 FM Radio: Controls for the FM radio Mauro Carvalho Chehab 2010-09-15 11:36 ` Matti J. Aaltonen 2010-09-16 7:37 ` Matti J. Aaltonen 2010-09-08 18:49 ` [PATCH v9 2/4] MFD: WL1273 FM Radio: MFD driver " Mauro Carvalho Chehab 2010-09-08 18:35 ` [PATCH v9 1/4] V4L2: Add seek spacing and FM RX class Mauro Carvalho Chehab 2010-09-09 7:57 ` Matti J. Aaltonen 2010-09-15 9:54 ` Matti J. Aaltonen 2010-09-07 19:10 ` [PATCH v9 0/4] FM Radio driver Hans Verkuil 2010-09-11 12:10 ` Hans Verkuil 2010-09-13 10:50 ` Matti J. Aaltonen 2010-09-13 11:32 ` Hans Verkuil 2010-09-13 11:44 ` Matti J. Aaltonen 2010-09-13 11:51 ` Hans Verkuil 2010-09-13 11:59 ` Matti J. Aaltonen 2010-09-13 12:06 ` Hans Verkuil 2010-09-13 12:15 ` Matti J. Aaltonen 2010-09-13 12:23 ` Hans Verkuil
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.