aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/radio
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/radio')
-rw-r--r--drivers/media/radio/Kconfig16
-rw-r--r--drivers/media/radio/Makefile1
-rw-r--r--drivers/media/radio/radio-aimslab.c23
-rw-r--r--drivers/media/radio/radio-wl1273.c2330
-rw-r--r--drivers/media/radio/si470x/radio-si470x.h1
-rw-r--r--drivers/media/radio/si4713-i2c.c74
-rw-r--r--drivers/media/radio/si4713-i2c.h5
7 files changed, 2420 insertions, 30 deletions
diff --git a/drivers/media/radio/Kconfig b/drivers/media/radio/Kconfig
index 83567b898d09..3c5a4739ed70 100644
--- a/drivers/media/radio/Kconfig
+++ b/drivers/media/radio/Kconfig
@@ -452,4 +452,20 @@ config RADIO_TIMBERDALE
452 found behind the Timberdale FPGA on the Russellville board. 452 found behind the Timberdale FPGA on the Russellville board.
453 Enabling this driver will automatically select the DSP and tuner. 453 Enabling this driver will automatically select the DSP and tuner.
454 454
455config RADIO_WL1273
456 tristate "Texas Instruments WL1273 I2C FM Radio"
457 depends on I2C && VIDEO_V4L2
458 select MFD_WL1273_CORE
459 select FW_LOADER
460 ---help---
461 Choose Y here if you have this FM radio chip.
462
463 In order to control your radio card, you will need to use programs
464 that are compatible with the Video For Linux 2 API. Information on
465 this API and pointers to "v4l2" programs may be found at
466 <file:Documentation/video4linux/API.html>.
467
468 To compile this driver as a module, choose M here: the
469 module will be called radio-wl1273.
470
455endif # RADIO_ADAPTERS 471endif # RADIO_ADAPTERS
diff --git a/drivers/media/radio/Makefile b/drivers/media/radio/Makefile
index f615583b4837..d2970748a69f 100644
--- a/drivers/media/radio/Makefile
+++ b/drivers/media/radio/Makefile
@@ -26,5 +26,6 @@ obj-$(CONFIG_RADIO_TEA5764) += radio-tea5764.o
26obj-$(CONFIG_RADIO_SAA7706H) += saa7706h.o 26obj-$(CONFIG_RADIO_SAA7706H) += saa7706h.o
27obj-$(CONFIG_RADIO_TEF6862) += tef6862.o 27obj-$(CONFIG_RADIO_TEF6862) += tef6862.o
28obj-$(CONFIG_RADIO_TIMBERDALE) += radio-timb.o 28obj-$(CONFIG_RADIO_TIMBERDALE) += radio-timb.o
29obj-$(CONFIG_RADIO_WL1273) += radio-wl1273.o
29 30
30EXTRA_CFLAGS += -Isound 31EXTRA_CFLAGS += -Isound
diff --git a/drivers/media/radio/radio-aimslab.c b/drivers/media/radio/radio-aimslab.c
index 05e832f61c3e..6cc5d130fbc8 100644
--- a/drivers/media/radio/radio-aimslab.c
+++ b/drivers/media/radio/radio-aimslab.c
@@ -31,7 +31,6 @@
31#include <linux/module.h> /* Modules */ 31#include <linux/module.h> /* Modules */
32#include <linux/init.h> /* Initdata */ 32#include <linux/init.h> /* Initdata */
33#include <linux/ioport.h> /* request_region */ 33#include <linux/ioport.h> /* request_region */
34#include <linux/delay.h> /* udelay */
35#include <linux/videodev2.h> /* kernel radio structs */ 34#include <linux/videodev2.h> /* kernel radio structs */
36#include <linux/version.h> /* for KERNEL_VERSION MACRO */ 35#include <linux/version.h> /* for KERNEL_VERSION MACRO */
37#include <linux/io.h> /* outb, outb_p */ 36#include <linux/io.h> /* outb, outb_p */
@@ -71,27 +70,17 @@ static struct rtrack rtrack_card;
71 70
72/* local things */ 71/* local things */
73 72
74static void sleep_delay(long n)
75{
76 /* Sleep nicely for 'n' uS */
77 int d = n / msecs_to_jiffies(1000);
78 if (!d)
79 udelay(n);
80 else
81 msleep(jiffies_to_msecs(d));
82}
83
84static void rt_decvol(struct rtrack *rt) 73static void rt_decvol(struct rtrack *rt)
85{ 74{
86 outb(0x58, rt->io); /* volume down + sigstr + on */ 75 outb(0x58, rt->io); /* volume down + sigstr + on */
87 sleep_delay(100000); 76 msleep(100);
88 outb(0xd8, rt->io); /* volume steady + sigstr + on */ 77 outb(0xd8, rt->io); /* volume steady + sigstr + on */
89} 78}
90 79
91static void rt_incvol(struct rtrack *rt) 80static void rt_incvol(struct rtrack *rt)
92{ 81{
93 outb(0x98, rt->io); /* volume up + sigstr + on */ 82 outb(0x98, rt->io); /* volume up + sigstr + on */
94 sleep_delay(100000); 83 msleep(100);
95 outb(0xd8, rt->io); /* volume steady + sigstr + on */ 84 outb(0xd8, rt->io); /* volume steady + sigstr + on */
96} 85}
97 86
@@ -120,7 +109,7 @@ static int rt_setvol(struct rtrack *rt, int vol)
120 109
121 if (vol == 0) { /* volume = 0 means mute the card */ 110 if (vol == 0) { /* volume = 0 means mute the card */
122 outb(0x48, rt->io); /* volume down but still "on" */ 111 outb(0x48, rt->io); /* volume down but still "on" */
123 sleep_delay(2000000); /* make sure it's totally down */ 112 msleep(2000); /* make sure it's totally down */
124 outb(0xd0, rt->io); /* volume steady, off */ 113 outb(0xd0, rt->io); /* volume steady, off */
125 rt->curvol = 0; /* track the volume state! */ 114 rt->curvol = 0; /* track the volume state! */
126 mutex_unlock(&rt->lock); 115 mutex_unlock(&rt->lock);
@@ -155,7 +144,7 @@ static void send_0_byte(struct rtrack *rt)
155 outb_p(128+64+16+8+ 1, rt->io); /* on + wr-enable + data low */ 144 outb_p(128+64+16+8+ 1, rt->io); /* on + wr-enable + data low */
156 outb_p(128+64+16+8+2+1, rt->io); /* clock */ 145 outb_p(128+64+16+8+2+1, rt->io); /* clock */
157 } 146 }
158 sleep_delay(1000); 147 msleep(1);
159} 148}
160 149
161static void send_1_byte(struct rtrack *rt) 150static void send_1_byte(struct rtrack *rt)
@@ -169,7 +158,7 @@ static void send_1_byte(struct rtrack *rt)
169 outb_p(128+64+16+8+4+2+1, rt->io); /* clock */ 158 outb_p(128+64+16+8+4+2+1, rt->io); /* clock */
170 } 159 }
171 160
172 sleep_delay(1000); 161 msleep(1);
173} 162}
174 163
175static int rt_setfreq(struct rtrack *rt, unsigned long freq) 164static int rt_setfreq(struct rtrack *rt, unsigned long freq)
@@ -420,7 +409,7 @@ static int __init rtrack_init(void)
420 409
421 /* this ensures that the volume is all the way down */ 410 /* this ensures that the volume is all the way down */
422 outb(0x48, rt->io); /* volume down but still "on" */ 411 outb(0x48, rt->io); /* volume down but still "on" */
423 sleep_delay(2000000); /* make sure it's totally down */ 412 msleep(2000); /* make sure it's totally down */
424 outb(0xc0, rt->io); /* steady volume, mute card */ 413 outb(0xc0, rt->io); /* steady volume, mute card */
425 414
426 if (video_register_device(&rt->vdev, VFL_TYPE_RADIO, radio_nr) < 0) { 415 if (video_register_device(&rt->vdev, VFL_TYPE_RADIO, radio_nr) < 0) {
diff --git a/drivers/media/radio/radio-wl1273.c b/drivers/media/radio/radio-wl1273.c
new file mode 100644
index 000000000000..dd6bd364efa0
--- /dev/null
+++ b/drivers/media/radio/radio-wl1273.c
@@ -0,0 +1,2330 @@
1/*
2 * Driver for the Texas Instruments WL1273 FM radio.
3 *
4 * Copyright (C) 2010 Nokia Corporation
5 * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21#include <linux/delay.h>
22#include <linux/firmware.h>
23#include <linux/interrupt.h>
24#include <linux/mfd/wl1273-core.h>
25#include <linux/slab.h>
26#include <media/v4l2-common.h>
27#include <media/v4l2-ctrls.h>
28#include <media/v4l2-device.h>
29#include <media/v4l2-ioctl.h>
30
31#define DRIVER_DESC "Wl1273 FM Radio"
32
33#define WL1273_POWER_SET_OFF 0
34#define WL1273_POWER_SET_FM BIT(0)
35#define WL1273_POWER_SET_RDS BIT(1)
36#define WL1273_POWER_SET_RETENTION BIT(4)
37
38#define WL1273_PUPD_SET_OFF 0x00
39#define WL1273_PUPD_SET_ON 0x01
40#define WL1273_PUPD_SET_RETENTION 0x10
41
42#define WL1273_FREQ(x) (x * 10000 / 625)
43#define WL1273_INV_FREQ(x) (x * 625 / 10000)
44
45/*
46 * static int radio_nr - The number of the radio device
47 *
48 * The default is 0.
49 */
50static int radio_nr;
51module_param(radio_nr, int, 0);
52MODULE_PARM_DESC(radio_nr, "The number of the radio device. Default = 0");
53
54struct wl1273_device {
55 char *bus_type;
56
57 u8 forbidden;
58 unsigned int preemphasis;
59 unsigned int spacing;
60 unsigned int tx_power;
61 unsigned int rx_frequency;
62 unsigned int tx_frequency;
63 unsigned int rangelow;
64 unsigned int rangehigh;
65 unsigned int band;
66 bool stereo;
67
68 /* RDS */
69 unsigned int rds_on;
70 struct delayed_work work;
71
72 wait_queue_head_t read_queue;
73 struct mutex lock; /* for serializing fm radio operations */
74 struct completion busy;
75
76 unsigned char *buffer;
77 unsigned int buf_size;
78 unsigned int rd_index;
79 unsigned int wr_index;
80
81 /* Selected interrupts */
82 u16 irq_flags;
83 u16 irq_received;
84
85 struct v4l2_ctrl_handler ctrl_handler;
86 struct v4l2_device v4l2dev;
87 struct video_device videodev;
88 struct device *dev;
89 struct wl1273_core *core;
90 struct file *owner;
91 char *write_buf;
92 unsigned int rds_users;
93};
94
95#define WL1273_IRQ_MASK (WL1273_FR_EVENT | \
96 WL1273_POW_ENB_EVENT)
97
98/*
99 * static unsigned int rds_buf - the number of RDS buffer blocks used.
100 *
101 * The default number is 100.
102 */
103static unsigned int rds_buf = 100;
104module_param(rds_buf, uint, 0);
105MODULE_PARM_DESC(rds_buf, "Number of RDS buffer entries. Default = 100");
106
107static int wl1273_fm_read_reg(struct wl1273_core *core, u8 reg, u16 *value)
108{
109 struct i2c_client *client = core->client;
110 u8 b[2];
111 int r;
112
113 r = i2c_smbus_read_i2c_block_data(client, reg, sizeof(b), b);
114 if (r != 2) {
115 dev_err(&client->dev, "%s: Read: %d fails.\n", __func__, reg);
116 return -EREMOTEIO;
117 }
118
119 *value = (u16)b[0] << 8 | b[1];
120
121 return 0;
122}
123
124static int wl1273_fm_write_cmd(struct wl1273_core *core, u8 cmd, u16 param)
125{
126 struct i2c_client *client = core->client;
127 u8 buf[] = { (param >> 8) & 0xff, param & 0xff };
128 int r;
129
130 r = i2c_smbus_write_i2c_block_data(client, cmd, sizeof(buf), buf);
131 if (r) {
132 dev_err(&client->dev, "%s: Cmd: %d fails.\n", __func__, cmd);
133 return r;
134 }
135
136 return 0;
137}
138
139static int wl1273_fm_write_data(struct wl1273_core *core, u8 *data, u16 len)
140{
141 struct i2c_client *client = core->client;
142 struct i2c_msg msg;
143 int r;
144
145 msg.addr = client->addr;
146 msg.flags = 0;
147 msg.buf = data;
148 msg.len = len;
149
150 r = i2c_transfer(client->adapter, &msg, 1);
151 if (r != 1) {
152 dev_err(&client->dev, "%s: write error.\n", __func__);
153 return -EREMOTEIO;
154 }
155
156 return 0;
157}
158
159static int wl1273_fm_write_fw(struct wl1273_core *core,
160 __u8 *fw, int len)
161{
162 struct i2c_client *client = core->client;
163 struct i2c_msg msg;
164 int i, r = 0;
165
166 msg.addr = client->addr;
167 msg.flags = 0;
168
169 for (i = 0; i <= len; i++) {
170 msg.len = fw[0];
171 msg.buf = fw + 1;
172
173 fw += msg.len + 1;
174 dev_dbg(&client->dev, "%s:len[%d]: %d\n", __func__, i, msg.len);
175
176 r = i2c_transfer(client->adapter, &msg, 1);
177 if (r < 0 && i < len + 1)
178 break;
179 }
180
181 dev_dbg(&client->dev, "%s: i: %d\n", __func__, i);
182 dev_dbg(&client->dev, "%s: len + 1: %d\n", __func__, len + 1);
183
184 /* Last transfer always fails. */
185 if (i == len || r == 1)
186 r = 0;
187
188 return r;
189}
190
191/**
192 * wl1273_fm_set_audio() - Set audio mode.
193 * @core: A pointer to the device struct.
194 * @new_mode: The new audio mode.
195 *
196 * Audio modes are WL1273_AUDIO_DIGITAL and WL1273_AUDIO_ANALOG.
197 */
198static int wl1273_fm_set_audio(struct wl1273_core *core, unsigned int new_mode)
199{
200 int r = 0;
201
202 if (core->mode == WL1273_MODE_OFF ||
203 core->mode == WL1273_MODE_SUSPENDED)
204 return -EPERM;
205
206 if (core->mode == WL1273_MODE_RX && new_mode == WL1273_AUDIO_DIGITAL) {
207 r = wl1273_fm_write_cmd(core, WL1273_PCM_MODE_SET,
208 WL1273_PCM_DEF_MODE);
209 if (r)
210 goto out;
211
212 r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET,
213 core->i2s_mode);
214 if (r)
215 goto out;
216
217 r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE,
218 WL1273_AUDIO_ENABLE_I2S);
219 if (r)
220 goto out;
221
222 } else if (core->mode == WL1273_MODE_RX &&
223 new_mode == WL1273_AUDIO_ANALOG) {
224 r = wl1273_fm_write_cmd(core, WL1273_AUDIO_ENABLE,
225 WL1273_AUDIO_ENABLE_ANALOG);
226 if (r)
227 goto out;
228
229 } else if (core->mode == WL1273_MODE_TX &&
230 new_mode == WL1273_AUDIO_DIGITAL) {
231 r = wl1273_fm_write_cmd(core, WL1273_I2S_MODE_CONFIG_SET,
232 core->i2s_mode);
233 if (r)
234 goto out;
235
236 r = wl1273_fm_write_cmd(core, WL1273_AUDIO_IO_SET,
237 WL1273_AUDIO_IO_SET_I2S);
238 if (r)
239 goto out;
240
241 } else if (core->mode == WL1273_MODE_TX &&
242 new_mode == WL1273_AUDIO_ANALOG) {
243 r = wl1273_fm_write_cmd(core, WL1273_AUDIO_IO_SET,
244 WL1273_AUDIO_IO_SET_ANALOG);
245 if (r)
246 goto out;
247 }
248
249 core->audio_mode = new_mode;
250out:
251 return r;
252}
253
254/**
255 * wl1273_fm_set_volume() - Set volume.
256 * @core: A pointer to the device struct.
257 * @volume: The new volume value.
258 */
259static int wl1273_fm_set_volume(struct wl1273_core *core, unsigned int volume)
260{
261 u16 val;
262 int r;
263
264 if (volume > WL1273_MAX_VOLUME)
265 return -EINVAL;
266
267 if (core->volume == volume)
268 return 0;
269
270 val = volume;
271 r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val);
272 if (r)
273 return r;
274
275 core->volume = volume;
276 return 0;
277}
278
279#define WL1273_FIFO_HAS_DATA(status) (1 << 5 & status)
280#define WL1273_RDS_CORRECTABLE_ERROR (1 << 3)
281#define WL1273_RDS_UNCORRECTABLE_ERROR (1 << 4)
282
283static int wl1273_fm_rds(struct wl1273_device *radio)
284{
285 struct wl1273_core *core = radio->core;
286 struct i2c_client *client = core->client;
287 u16 val;
288 u8 b0 = WL1273_RDS_DATA_GET, status;
289 struct v4l2_rds_data rds = { 0, 0, 0 };
290 struct i2c_msg msg[] = {
291 {
292 .addr = client->addr,
293 .flags = 0,
294 .buf = &b0,
295 .len = 1,
296 },
297 {
298 .addr = client->addr,
299 .flags = I2C_M_RD,
300 .buf = (u8 *) &rds,
301 .len = sizeof(rds),
302 }
303 };
304 int r;
305
306 if (core->mode != WL1273_MODE_RX)
307 return 0;
308
309 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
310 if (r)
311 return r;
312
313 if ((val & 0x01) == 0) {
314 /* RDS decoder not synchronized */
315 return -EAGAIN;
316 }
317
318 /* copy all four RDS blocks to internal buffer */
319 do {
320 r = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
321 if (r != ARRAY_SIZE(msg)) {
322 dev_err(radio->dev, WL1273_FM_DRIVER_NAME
323 ": %s: read_rds error r == %i)\n",
324 __func__, r);
325 }
326
327 status = rds.block;
328
329 if (!WL1273_FIFO_HAS_DATA(status))
330 break;
331
332 /* copy bits 0-2 (the block ID) to bits 3-5 */
333 rds.block = V4L2_RDS_BLOCK_MSK & status;
334 rds.block |= rds.block << 3;
335
336 /* copy the error bits to standard positions */
337 if (WL1273_RDS_UNCORRECTABLE_ERROR & status) {
338 rds.block |= V4L2_RDS_BLOCK_ERROR;
339 rds.block &= ~V4L2_RDS_BLOCK_CORRECTED;
340 } else if (WL1273_RDS_CORRECTABLE_ERROR & status) {
341 rds.block &= ~V4L2_RDS_BLOCK_ERROR;
342 rds.block |= V4L2_RDS_BLOCK_CORRECTED;
343 }
344
345 /* copy RDS block to internal buffer */
346 memcpy(&radio->buffer[radio->wr_index], &rds, RDS_BLOCK_SIZE);
347 radio->wr_index += 3;
348
349 /* wrap write pointer */
350 if (radio->wr_index >= radio->buf_size)
351 radio->wr_index = 0;
352
353 /* check for overflow & start over */
354 if (radio->wr_index == radio->rd_index) {
355 dev_dbg(radio->dev, "RDS OVERFLOW");
356
357 radio->rd_index = 0;
358 radio->wr_index = 0;
359 break;
360 }
361 } while (WL1273_FIFO_HAS_DATA(status));
362
363 /* wake up read queue */
364 if (radio->wr_index != radio->rd_index)
365 wake_up_interruptible(&radio->read_queue);
366
367 return 0;
368}
369
370static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id)
371{
372 struct wl1273_device *radio = dev_id;
373 struct wl1273_core *core = radio->core;
374 u16 flags;
375 int r;
376
377 r = wl1273_fm_read_reg(core, WL1273_FLAG_GET, &flags);
378 if (r)
379 goto out;
380
381 if (flags & WL1273_BL_EVENT) {
382 radio->irq_received = flags;
383 dev_dbg(radio->dev, "IRQ: BL\n");
384 }
385
386 if (flags & WL1273_RDS_EVENT) {
387 msleep(200);
388
389 wl1273_fm_rds(radio);
390 }
391
392 if (flags & WL1273_BBLK_EVENT)
393 dev_dbg(radio->dev, "IRQ: BBLK\n");
394
395 if (flags & WL1273_LSYNC_EVENT)
396 dev_dbg(radio->dev, "IRQ: LSYNC\n");
397
398 if (flags & WL1273_LEV_EVENT) {
399 u16 level;
400
401 r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &level);
402 if (r)
403 goto out;
404
405 if (level > 14)
406 dev_dbg(radio->dev, "IRQ: LEV: 0x%x04\n", level);
407 }
408
409 if (flags & WL1273_IFFR_EVENT)
410 dev_dbg(radio->dev, "IRQ: IFFR\n");
411
412 if (flags & WL1273_PI_EVENT)
413 dev_dbg(radio->dev, "IRQ: PI\n");
414
415 if (flags & WL1273_PD_EVENT)
416 dev_dbg(radio->dev, "IRQ: PD\n");
417
418 if (flags & WL1273_STIC_EVENT)
419 dev_dbg(radio->dev, "IRQ: STIC\n");
420
421 if (flags & WL1273_MAL_EVENT)
422 dev_dbg(radio->dev, "IRQ: MAL\n");
423
424 if (flags & WL1273_POW_ENB_EVENT) {
425 complete(&radio->busy);
426 dev_dbg(radio->dev, "NOT BUSY\n");
427 dev_dbg(radio->dev, "IRQ: POW_ENB\n");
428 }
429
430 if (flags & WL1273_SCAN_OVER_EVENT)
431 dev_dbg(radio->dev, "IRQ: SCAN_OVER\n");
432
433 if (flags & WL1273_ERROR_EVENT)
434 dev_dbg(radio->dev, "IRQ: ERROR\n");
435
436 if (flags & WL1273_FR_EVENT) {
437 u16 freq;
438
439 dev_dbg(radio->dev, "IRQ: FR:\n");
440
441 if (core->mode == WL1273_MODE_RX) {
442 r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET,
443 TUNER_MODE_STOP_SEARCH);
444 if (r) {
445 dev_err(radio->dev,
446 "%s: TUNER_MODE_SET fails: %d\n",
447 __func__, r);
448 goto out;
449 }
450
451 r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &freq);
452 if (r)
453 goto out;
454
455 if (radio->band == WL1273_BAND_JAPAN)
456 radio->rx_frequency = WL1273_BAND_JAPAN_LOW +
457 freq * 50;
458 else
459 radio->rx_frequency = WL1273_BAND_OTHER_LOW +
460 freq * 50;
461 /*
462 * The driver works better with this msleep,
463 * the documentation doesn't mention it.
464 */
465 usleep_range(10000, 15000);
466
467 dev_dbg(radio->dev, "%dkHz\n", radio->rx_frequency);
468
469 } else {
470 r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &freq);
471 if (r)
472 goto out;
473
474 dev_dbg(radio->dev, "%dkHz\n", freq);
475 }
476 dev_dbg(radio->dev, "%s: NOT BUSY\n", __func__);
477 }
478
479out:
480 wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET,
481 radio->irq_flags);
482 complete(&radio->busy);
483
484 return IRQ_HANDLED;
485}
486
487static int wl1273_fm_set_tx_freq(struct wl1273_device *radio, unsigned int freq)
488{
489 struct wl1273_core *core = radio->core;
490 int r = 0;
491
492 if (freq < WL1273_BAND_TX_LOW) {
493 dev_err(radio->dev,
494 "Frequency out of range: %d < %d\n", freq,
495 WL1273_BAND_TX_LOW);
496 return -ERANGE;
497 }
498
499 if (freq > WL1273_BAND_TX_HIGH) {
500 dev_err(radio->dev,
501 "Frequency out of range: %d > %d\n", freq,
502 WL1273_BAND_TX_HIGH);
503 return -ERANGE;
504 }
505
506 /*
507 * The driver works better with this sleep,
508 * the documentation doesn't mention it.
509 */
510 usleep_range(5000, 10000);
511
512 dev_dbg(radio->dev, "%s: freq: %d kHz\n", __func__, freq);
513
514 /* Set the current tx channel */
515 r = wl1273_fm_write_cmd(core, WL1273_CHANL_SET, freq / 10);
516 if (r)
517 return r;
518
519 INIT_COMPLETION(radio->busy);
520
521 /* wait for the FR IRQ */
522 r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000));
523 if (!r)
524 return -ETIMEDOUT;
525
526 dev_dbg(radio->dev, "WL1273_CHANL_SET: %d\n", r);
527
528 /* Enable the output power */
529 r = wl1273_fm_write_cmd(core, WL1273_POWER_ENB_SET, 1);
530 if (r)
531 return r;
532
533 INIT_COMPLETION(radio->busy);
534
535 /* wait for the POWER_ENB IRQ */
536 r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
537 if (!r)
538 return -ETIMEDOUT;
539
540 radio->tx_frequency = freq;
541 dev_dbg(radio->dev, "WL1273_POWER_ENB_SET: %d\n", r);
542
543 return 0;
544}
545
546static int wl1273_fm_set_rx_freq(struct wl1273_device *radio, unsigned int freq)
547{
548 struct wl1273_core *core = radio->core;
549 int r, f;
550
551 if (freq < radio->rangelow) {
552 dev_err(radio->dev,
553 "Frequency out of range: %d < %d\n", freq,
554 radio->rangelow);
555 r = -ERANGE;
556 goto err;
557 }
558
559 if (freq > radio->rangehigh) {
560 dev_err(radio->dev,
561 "Frequency out of range: %d > %d\n", freq,
562 radio->rangehigh);
563 r = -ERANGE;
564 goto err;
565 }
566
567 dev_dbg(radio->dev, "%s: %dkHz\n", __func__, freq);
568
569 wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, radio->irq_flags);
570
571 if (radio->band == WL1273_BAND_JAPAN)
572 f = (freq - WL1273_BAND_JAPAN_LOW) / 50;
573 else
574 f = (freq - WL1273_BAND_OTHER_LOW) / 50;
575
576 r = wl1273_fm_write_cmd(core, WL1273_FREQ_SET, f);
577 if (r) {
578 dev_err(radio->dev, "FREQ_SET fails\n");
579 goto err;
580 }
581
582 r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET);
583 if (r) {
584 dev_err(radio->dev, "TUNER_MODE_SET fails\n");
585 goto err;
586 }
587
588 INIT_COMPLETION(radio->busy);
589
590 r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000));
591 if (!r) {
592 dev_err(radio->dev, "%s: TIMEOUT\n", __func__);
593 return -ETIMEDOUT;
594 }
595
596 radio->rd_index = 0;
597 radio->wr_index = 0;
598 radio->rx_frequency = freq;
599 return 0;
600err:
601 return r;
602}
603
604static int wl1273_fm_get_freq(struct wl1273_device *radio)
605{
606 struct wl1273_core *core = radio->core;
607 unsigned int freq;
608 u16 f;
609 int r;
610
611 if (core->mode == WL1273_MODE_RX) {
612 r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &f);
613 if (r)
614 return r;
615
616 dev_dbg(radio->dev, "Freq get: 0x%04x\n", f);
617 if (radio->band == WL1273_BAND_JAPAN)
618 freq = WL1273_BAND_JAPAN_LOW + 50 * f;
619 else
620 freq = WL1273_BAND_OTHER_LOW + 50 * f;
621 } else {
622 r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &f);
623 if (r)
624 return r;
625
626 freq = f * 10;
627 }
628
629 return freq;
630}
631
632/**
633 * wl1273_fm_upload_firmware_patch() - Upload the firmware.
634 * @radio: A pointer to the device struct.
635 *
636 * The firmware file consists of arrays of bytes where the first byte
637 * gives the array length. The first byte in the file gives the
638 * number of these arrays.
639 */
640static int wl1273_fm_upload_firmware_patch(struct wl1273_device *radio)
641{
642 struct wl1273_core *core = radio->core;
643 unsigned int packet_num;
644 const struct firmware *fw_p;
645 const char *fw_name = "radio-wl1273-fw.bin";
646 struct device *dev = radio->dev;
647 __u8 *ptr;
648 int r;
649
650 dev_dbg(dev, "%s:\n", __func__);
651
652 /*
653 * Uploading the firmware patch is not always necessary,
654 * so we only print an info message.
655 */
656 if (request_firmware(&fw_p, fw_name, dev)) {
657 dev_info(dev, "%s - %s not found\n", __func__, fw_name);
658
659 return 0;
660 }
661
662 ptr = (__u8 *) fw_p->data;
663 packet_num = ptr[0];
664 dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num);
665
666 r = wl1273_fm_write_fw(core, ptr + 1, packet_num);
667 if (r) {
668 dev_err(dev, "FW upload error: %d\n", r);
669 goto out;
670 }
671
672 /* ignore possible error here */
673 wl1273_fm_write_cmd(core, WL1273_RESET, 0);
674
675 dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r);
676out:
677 release_firmware(fw_p);
678 return r;
679}
680
681static int wl1273_fm_stop(struct wl1273_device *radio)
682{
683 struct wl1273_core *core = radio->core;
684
685 if (core->mode == WL1273_MODE_RX) {
686 int r = wl1273_fm_write_cmd(core, WL1273_POWER_SET,
687 WL1273_POWER_SET_OFF);
688 if (r)
689 dev_err(radio->dev, "%s: POWER_SET fails: %d\n",
690 __func__, r);
691 } else if (core->mode == WL1273_MODE_TX) {
692 int r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
693 WL1273_PUPD_SET_OFF);
694 if (r)
695 dev_err(radio->dev,
696 "%s: PUPD_SET fails: %d\n", __func__, r);
697 }
698
699 if (core->pdata->disable) {
700 core->pdata->disable();
701 dev_dbg(radio->dev, "Back to reset\n");
702 }
703
704 return 0;
705}
706
707static int wl1273_fm_start(struct wl1273_device *radio, int new_mode)
708{
709 struct wl1273_core *core = radio->core;
710 struct wl1273_fm_platform_data *pdata = core->pdata;
711 struct device *dev = radio->dev;
712 int r = -EINVAL;
713
714 if (pdata->enable && core->mode == WL1273_MODE_OFF) {
715 dev_dbg(radio->dev, "Out of reset\n");
716
717 pdata->enable();
718 msleep(250);
719 }
720
721 if (new_mode == WL1273_MODE_RX) {
722 u16 val = WL1273_POWER_SET_FM;
723
724 if (radio->rds_on)
725 val |= WL1273_POWER_SET_RDS;
726
727 /* If this fails try again */
728 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val);
729 if (r) {
730 msleep(100);
731
732 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val);
733 if (r) {
734 dev_err(dev, "%s: POWER_SET fails\n", __func__);
735 goto fail;
736 }
737 }
738
739 /* rds buffer configuration */
740 radio->wr_index = 0;
741 radio->rd_index = 0;
742
743 } else if (new_mode == WL1273_MODE_TX) {
744 /* If this fails try again once */
745 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
746 WL1273_PUPD_SET_ON);
747 if (r) {
748 msleep(100);
749 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
750 WL1273_PUPD_SET_ON);
751 if (r) {
752 dev_err(dev, "%s: PUPD_SET fails\n", __func__);
753 goto fail;
754 }
755 }
756
757 if (radio->rds_on)
758 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1);
759 else
760 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0);
761 } else {
762 dev_warn(dev, "%s: Illegal mode.\n", __func__);
763 }
764
765 if (core->mode == WL1273_MODE_OFF) {
766 r = wl1273_fm_upload_firmware_patch(radio);
767 if (r)
768 dev_warn(dev, "Firmware upload failed.\n");
769
770 /*
771 * Sometimes the chip is in a wrong power state at this point.
772 * So we set the power once again.
773 */
774 if (new_mode == WL1273_MODE_RX) {
775 u16 val = WL1273_POWER_SET_FM;
776
777 if (radio->rds_on)
778 val |= WL1273_POWER_SET_RDS;
779
780 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val);
781 if (r) {
782 dev_err(dev, "%s: POWER_SET fails\n", __func__);
783 goto fail;
784 }
785 } else if (new_mode == WL1273_MODE_TX) {
786 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
787 WL1273_PUPD_SET_ON);
788 if (r) {
789 dev_err(dev, "%s: PUPD_SET fails\n", __func__);
790 goto fail;
791 }
792 }
793 }
794
795 return 0;
796fail:
797 if (pdata->disable)
798 pdata->disable();
799
800 dev_dbg(dev, "%s: return: %d\n", __func__, r);
801 return r;
802}
803
804static int wl1273_fm_suspend(struct wl1273_device *radio)
805{
806 struct wl1273_core *core = radio->core;
807 int r = 0;
808
809 /* Cannot go from OFF to SUSPENDED */
810 if (core->mode == WL1273_MODE_RX)
811 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET,
812 WL1273_POWER_SET_RETENTION);
813 else if (core->mode == WL1273_MODE_TX)
814 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
815 WL1273_PUPD_SET_RETENTION);
816 else
817 r = -EINVAL;
818
819 if (r) {
820 dev_err(radio->dev, "%s: POWER_SET fails: %d\n", __func__, r);
821 goto out;
822 }
823
824out:
825 return r;
826}
827
828static int wl1273_fm_set_mode(struct wl1273_device *radio, int mode)
829{
830 struct wl1273_core *core = radio->core;
831 struct device *dev = radio->dev;
832 int old_mode;
833 int r;
834
835 dev_dbg(dev, "%s\n", __func__);
836 dev_dbg(dev, "Forbidden modes: 0x%02x\n", radio->forbidden);
837
838 old_mode = core->mode;
839 if (mode & radio->forbidden) {
840 r = -EPERM;
841 goto out;
842 }
843
844 switch (mode) {
845 case WL1273_MODE_RX:
846 case WL1273_MODE_TX:
847 r = wl1273_fm_start(radio, mode);
848 if (r) {
849 dev_err(dev, "%s: Cannot start.\n", __func__);
850 wl1273_fm_stop(radio);
851 goto out;
852 }
853
854 core->mode = mode;
855 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET,
856 radio->irq_flags);
857 if (r) {
858 dev_err(dev, "INT_MASK_SET fails.\n");
859 goto out;
860 }
861
862 /* remember previous settings */
863 if (mode == WL1273_MODE_RX) {
864 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
865 if (r) {
866 dev_err(dev, "set freq fails: %d.\n", r);
867 goto out;
868 }
869
870 r = core->set_volume(core, core->volume);
871 if (r) {
872 dev_err(dev, "set volume fails: %d.\n", r);
873 goto out;
874 }
875
876 dev_dbg(dev, "%s: Set vol: %d.\n", __func__,
877 core->volume);
878 } else {
879 r = wl1273_fm_set_tx_freq(radio, radio->tx_frequency);
880 if (r) {
881 dev_err(dev, "set freq fails: %d.\n", r);
882 goto out;
883 }
884 }
885
886 dev_dbg(radio->dev, "%s: Set audio mode.\n", __func__);
887
888 r = core->set_audio(core, core->audio_mode);
889 if (r)
890 dev_err(dev, "Cannot set audio mode.\n");
891 break;
892
893 case WL1273_MODE_OFF:
894 r = wl1273_fm_stop(radio);
895 if (r)
896 dev_err(dev, "%s: Off fails: %d\n", __func__, r);
897 else
898 core->mode = WL1273_MODE_OFF;
899
900 break;
901
902 case WL1273_MODE_SUSPENDED:
903 r = wl1273_fm_suspend(radio);
904 if (r)
905 dev_err(dev, "%s: Suspend fails: %d\n", __func__, r);
906 else
907 core->mode = WL1273_MODE_SUSPENDED;
908
909 break;
910
911 default:
912 dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode);
913 r = -EINVAL;
914 break;
915 }
916out:
917 if (r)
918 core->mode = old_mode;
919
920 return r;
921}
922
923static int wl1273_fm_set_seek(struct wl1273_device *radio,
924 unsigned int wrap_around,
925 unsigned int seek_upward,
926 int level)
927{
928 struct wl1273_core *core = radio->core;
929 int r = 0;
930 unsigned int dir = (seek_upward == 0) ? 0 : 1;
931 unsigned int f;
932
933 f = radio->rx_frequency;
934 dev_dbg(radio->dev, "rx_frequency: %d\n", f);
935
936 if (dir && f + radio->spacing <= radio->rangehigh)
937 r = wl1273_fm_set_rx_freq(radio, f + radio->spacing);
938 else if (dir && wrap_around)
939 r = wl1273_fm_set_rx_freq(radio, radio->rangelow);
940 else if (f - radio->spacing >= radio->rangelow)
941 r = wl1273_fm_set_rx_freq(radio, f - radio->spacing);
942 else if (wrap_around)
943 r = wl1273_fm_set_rx_freq(radio, radio->rangehigh);
944
945 if (r)
946 goto out;
947
948 if (level < SCHAR_MIN || level > SCHAR_MAX)
949 return -EINVAL;
950
951 INIT_COMPLETION(radio->busy);
952 dev_dbg(radio->dev, "%s: BUSY\n", __func__);
953
954 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, radio->irq_flags);
955 if (r)
956 goto out;
957
958 dev_dbg(radio->dev, "%s\n", __func__);
959
960 r = wl1273_fm_write_cmd(core, WL1273_SEARCH_LVL_SET, level);
961 if (r)
962 goto out;
963
964 r = wl1273_fm_write_cmd(core, WL1273_SEARCH_DIR_SET, dir);
965 if (r)
966 goto out;
967
968 r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET,
969 TUNER_MODE_AUTO_SEEK);
970 if (r)
971 goto out;
972
973 wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
974 if (!(radio->irq_received & WL1273_BL_EVENT))
975 goto out;
976
977 radio->irq_received &= ~WL1273_BL_EVENT;
978
979 if (!wrap_around)
980 goto out;
981
982 /* Wrap around */
983 dev_dbg(radio->dev, "Wrap around in HW seek.\n");
984
985 if (seek_upward)
986 f = radio->rangelow;
987 else
988 f = radio->rangehigh;
989
990 r = wl1273_fm_set_rx_freq(radio, f);
991 if (r)
992 goto out;
993
994 INIT_COMPLETION(radio->busy);
995 dev_dbg(radio->dev, "%s: BUSY\n", __func__);
996
997 r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET,
998 TUNER_MODE_AUTO_SEEK);
999 if (r)
1000 goto out;
1001
1002 wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
1003out:
1004 dev_dbg(radio->dev, "%s: Err: %d\n", __func__, r);
1005 return r;
1006}
1007
1008/**
1009 * wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value.
1010 * @radio: A pointer to the device struct.
1011 */
1012static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device *radio)
1013{
1014 struct wl1273_core *core = radio->core;
1015 struct device *dev = radio->dev;
1016 u16 val;
1017 int r;
1018
1019 if (core->mode == WL1273_MODE_OFF ||
1020 core->mode == WL1273_MODE_SUSPENDED)
1021 return -EPERM;
1022
1023 r = wl1273_fm_read_reg(core, WL1273_READ_FMANT_TUNE_VALUE, &val);
1024 if (r) {
1025 dev_err(dev, "%s: read error: %d\n", __func__, r);
1026 goto out;
1027 }
1028
1029out:
1030 return val;
1031}
1032
1033/**
1034 * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value.
1035 * @radio: A pointer to the device struct.
1036 * @preemphasis: The new pre-amphasis value.
1037 *
1038 * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED,
1039 * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS.
1040 */
1041static int wl1273_fm_set_preemphasis(struct wl1273_device *radio,
1042 unsigned int preemphasis)
1043{
1044 struct wl1273_core *core = radio->core;
1045 int r;
1046 u16 em;
1047
1048 if (core->mode == WL1273_MODE_OFF ||
1049 core->mode == WL1273_MODE_SUSPENDED)
1050 return -EPERM;
1051
1052 mutex_lock(&core->lock);
1053
1054 switch (preemphasis) {
1055 case V4L2_PREEMPHASIS_DISABLED:
1056 em = 1;
1057 break;
1058 case V4L2_PREEMPHASIS_50_uS:
1059 em = 0;
1060 break;
1061 case V4L2_PREEMPHASIS_75_uS:
1062 em = 2;
1063 break;
1064 default:
1065 r = -EINVAL;
1066 goto out;
1067 }
1068
1069 r = wl1273_fm_write_cmd(core, WL1273_PREMPH_SET, em);
1070 if (r)
1071 goto out;
1072
1073 radio->preemphasis = preemphasis;
1074
1075out:
1076 mutex_unlock(&core->lock);
1077 return r;
1078}
1079
1080static int wl1273_fm_rds_on(struct wl1273_device *radio)
1081{
1082 struct wl1273_core *core = radio->core;
1083 int r;
1084
1085 dev_dbg(radio->dev, "%s\n", __func__);
1086 if (radio->rds_on)
1087 return 0;
1088
1089 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET,
1090 WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS);
1091 if (r)
1092 goto out;
1093
1094 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
1095 if (r)
1096 dev_err(radio->dev, "set freq fails: %d.\n", r);
1097out:
1098 return r;
1099}
1100
1101static int wl1273_fm_rds_off(struct wl1273_device *radio)
1102{
1103 struct wl1273_core *core = radio->core;
1104 int r;
1105
1106 if (!radio->rds_on)
1107 return 0;
1108
1109 radio->irq_flags &= ~WL1273_RDS_EVENT;
1110
1111 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, radio->irq_flags);
1112 if (r)
1113 goto out;
1114
1115 /* stop rds reception */
1116 cancel_delayed_work(&radio->work);
1117
1118 /* Service pending read */
1119 wake_up_interruptible(&radio->read_queue);
1120
1121 dev_dbg(radio->dev, "%s\n", __func__);
1122
1123 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, WL1273_POWER_SET_FM);
1124 if (r)
1125 goto out;
1126
1127 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
1128 if (r)
1129 dev_err(radio->dev, "set freq fails: %d.\n", r);
1130out:
1131 dev_dbg(radio->dev, "%s: exiting...\n", __func__);
1132
1133 return r;
1134}
1135
1136static int wl1273_fm_set_rds(struct wl1273_device *radio, unsigned int new_mode)
1137{
1138 int r = 0;
1139 struct wl1273_core *core = radio->core;
1140
1141 if (core->mode == WL1273_MODE_OFF ||
1142 core->mode == WL1273_MODE_SUSPENDED)
1143 return -EPERM;
1144
1145 if (new_mode == WL1273_RDS_RESET) {
1146 r = wl1273_fm_write_cmd(core, WL1273_RDS_CNTRL_SET, 1);
1147 return r;
1148 }
1149
1150 if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) {
1151 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0);
1152 } else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) {
1153 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1);
1154 } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) {
1155 r = wl1273_fm_rds_off(radio);
1156 } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) {
1157 r = wl1273_fm_rds_on(radio);
1158 } else {
1159 dev_err(radio->dev, "%s: Unknown mode: %d\n",
1160 __func__, new_mode);
1161 r = -EINVAL;
1162 }
1163
1164 if (!r)
1165 radio->rds_on = (new_mode == WL1273_RDS_ON) ? true : false;
1166
1167 return r;
1168}
1169
1170static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf,
1171 size_t count, loff_t *ppos)
1172{
1173 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1174 u16 val;
1175 int r;
1176
1177 dev_dbg(radio->dev, "%s\n", __func__);
1178
1179 if (radio->core->mode != WL1273_MODE_TX)
1180 return count;
1181
1182 if (radio->rds_users == 0) {
1183 dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1184 return 0;
1185 }
1186
1187 if (mutex_lock_interruptible(&radio->core->lock))
1188 return -EINTR;
1189 /*
1190 * Multiple processes can open the device, but only
1191 * one gets to write to it.
1192 */
1193 if (radio->owner && radio->owner != file) {
1194 r = -EBUSY;
1195 goto out;
1196 }
1197 radio->owner = file;
1198
1199 /* Manual Mode */
1200 if (count > 255)
1201 val = 255;
1202 else
1203 val = count;
1204
1205 wl1273_fm_write_cmd(radio->core, WL1273_RDS_CONFIG_DATA_SET, val);
1206
1207 if (copy_from_user(radio->write_buf + 1, buf, val)) {
1208 r = -EFAULT;
1209 goto out;
1210 }
1211
1212 dev_dbg(radio->dev, "Count: %d\n", val);
1213 dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf);
1214
1215 radio->write_buf[0] = WL1273_RDS_DATA_SET;
1216 wl1273_fm_write_data(radio->core, radio->write_buf, val + 1);
1217
1218 r = val;
1219out:
1220 mutex_unlock(&radio->core->lock);
1221
1222 return r;
1223}
1224
1225static unsigned int wl1273_fm_fops_poll(struct file *file,
1226 struct poll_table_struct *pts)
1227{
1228 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1229 struct wl1273_core *core = radio->core;
1230
1231 if (radio->owner && radio->owner != file)
1232 return -EBUSY;
1233
1234 radio->owner = file;
1235
1236 if (core->mode == WL1273_MODE_RX) {
1237 poll_wait(file, &radio->read_queue, pts);
1238
1239 if (radio->rd_index != radio->wr_index)
1240 return POLLIN | POLLRDNORM;
1241
1242 } else if (core->mode == WL1273_MODE_TX) {
1243 return POLLOUT | POLLWRNORM;
1244 }
1245
1246 return 0;
1247}
1248
1249static int wl1273_fm_fops_open(struct file *file)
1250{
1251 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1252 struct wl1273_core *core = radio->core;
1253 int r = 0;
1254
1255 dev_dbg(radio->dev, "%s\n", __func__);
1256
1257 if (core->mode == WL1273_MODE_RX && radio->rds_on &&
1258 !radio->rds_users) {
1259 dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode);
1260
1261 if (mutex_lock_interruptible(&core->lock))
1262 return -EINTR;
1263
1264 radio->irq_flags |= WL1273_RDS_EVENT;
1265
1266 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET,
1267 radio->irq_flags);
1268 if (r) {
1269 mutex_unlock(&core->lock);
1270 goto out;
1271 }
1272
1273 radio->rds_users++;
1274
1275 mutex_unlock(&core->lock);
1276 }
1277out:
1278 return r;
1279}
1280
1281static int wl1273_fm_fops_release(struct file *file)
1282{
1283 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1284 struct wl1273_core *core = radio->core;
1285 int r = 0;
1286
1287 dev_dbg(radio->dev, "%s\n", __func__);
1288
1289 if (radio->rds_users > 0) {
1290 radio->rds_users--;
1291 if (radio->rds_users == 0) {
1292 if (mutex_lock_interruptible(&core->lock))
1293 return -EINTR;
1294
1295 radio->irq_flags &= ~WL1273_RDS_EVENT;
1296
1297 if (core->mode == WL1273_MODE_RX) {
1298 r = wl1273_fm_write_cmd(core,
1299 WL1273_INT_MASK_SET,
1300 radio->irq_flags);
1301 if (r) {
1302 mutex_unlock(&core->lock);
1303 goto out;
1304 }
1305 }
1306 mutex_unlock(&core->lock);
1307 }
1308 }
1309
1310 if (file == radio->owner)
1311 radio->owner = NULL;
1312out:
1313 return r;
1314}
1315
1316static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf,
1317 size_t count, loff_t *ppos)
1318{
1319 int r = 0;
1320 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1321 struct wl1273_core *core = radio->core;
1322 unsigned int block_count = 0;
1323 u16 val;
1324
1325 dev_dbg(radio->dev, "%s\n", __func__);
1326
1327 if (radio->core->mode != WL1273_MODE_RX)
1328 return 0;
1329
1330 if (radio->rds_users == 0) {
1331 dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1332 return 0;
1333 }
1334
1335 if (mutex_lock_interruptible(&core->lock))
1336 return -EINTR;
1337
1338 /*
1339 * Multiple processes can open the device, but only
1340 * one at a time gets read access.
1341 */
1342 if (radio->owner && radio->owner != file) {
1343 r = -EBUSY;
1344 goto out;
1345 }
1346 radio->owner = file;
1347
1348 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
1349 if (r) {
1350 dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__);
1351 goto out;
1352 } else if (val == 0) {
1353 dev_info(radio->dev, "RDS_SYNC: Not synchronized\n");
1354 r = -ENODATA;
1355 goto out;
1356 }
1357
1358 /* block if no new data available */
1359 while (radio->wr_index == radio->rd_index) {
1360 if (file->f_flags & O_NONBLOCK) {
1361 r = -EWOULDBLOCK;
1362 goto out;
1363 }
1364
1365 dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__);
1366 if (wait_event_interruptible(radio->read_queue,
1367 radio->wr_index !=
1368 radio->rd_index) < 0) {
1369 r = -EINTR;
1370 goto out;
1371 }
1372 }
1373
1374 /* calculate block count from byte count */
1375 count /= RDS_BLOCK_SIZE;
1376
1377 /* copy RDS blocks from the internal buffer and to user buffer */
1378 while (block_count < count) {
1379 if (radio->rd_index == radio->wr_index)
1380 break;
1381
1382 /* always transfer complete RDS blocks */
1383 if (copy_to_user(buf, &radio->buffer[radio->rd_index],
1384 RDS_BLOCK_SIZE))
1385 break;
1386
1387 /* increment and wrap the read pointer */
1388 radio->rd_index += RDS_BLOCK_SIZE;
1389 if (radio->rd_index >= radio->buf_size)
1390 radio->rd_index = 0;
1391
1392 /* increment counters */
1393 block_count++;
1394 buf += RDS_BLOCK_SIZE;
1395 r += RDS_BLOCK_SIZE;
1396 }
1397
1398out:
1399 dev_dbg(radio->dev, "%s: exit\n", __func__);
1400 mutex_unlock(&core->lock);
1401
1402 return r;
1403}
1404
1405static const struct v4l2_file_operations wl1273_fops = {
1406 .owner = THIS_MODULE,
1407 .read = wl1273_fm_fops_read,
1408 .write = wl1273_fm_fops_write,
1409 .poll = wl1273_fm_fops_poll,
1410 .ioctl = video_ioctl2,
1411 .open = wl1273_fm_fops_open,
1412 .release = wl1273_fm_fops_release,
1413};
1414
1415static int wl1273_fm_vidioc_querycap(struct file *file, void *priv,
1416 struct v4l2_capability *capability)
1417{
1418 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1419
1420 dev_dbg(radio->dev, "%s\n", __func__);
1421
1422 strlcpy(capability->driver, WL1273_FM_DRIVER_NAME,
1423 sizeof(capability->driver));
1424 strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio",
1425 sizeof(capability->card));
1426 strlcpy(capability->bus_info, radio->bus_type,
1427 sizeof(capability->bus_info));
1428
1429 capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
1430 V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO |
1431 V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR |
1432 V4L2_CAP_RDS_OUTPUT;
1433
1434 return 0;
1435}
1436
1437static int wl1273_fm_vidioc_g_input(struct file *file, void *priv,
1438 unsigned int *i)
1439{
1440 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1441
1442 dev_dbg(radio->dev, "%s\n", __func__);
1443
1444 *i = 0;
1445
1446 return 0;
1447}
1448
1449static int wl1273_fm_vidioc_s_input(struct file *file, void *priv,
1450 unsigned int i)
1451{
1452 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1453
1454 dev_dbg(radio->dev, "%s\n", __func__);
1455
1456 if (i != 0)
1457 return -EINVAL;
1458
1459 return 0;
1460}
1461
1462/**
1463 * wl1273_fm_set_tx_power() - Set the transmission power value.
1464 * @core: A pointer to the device struct.
1465 * @power: The new power value.
1466 */
1467static int wl1273_fm_set_tx_power(struct wl1273_device *radio, u16 power)
1468{
1469 int r;
1470
1471 if (radio->core->mode == WL1273_MODE_OFF ||
1472 radio->core->mode == WL1273_MODE_SUSPENDED)
1473 return -EPERM;
1474
1475 mutex_lock(&radio->core->lock);
1476
1477 /* Convert the dBuV value to chip presentation */
1478 r = wl1273_fm_write_cmd(radio->core, WL1273_POWER_LEV_SET, 122 - power);
1479 if (r)
1480 goto out;
1481
1482 radio->tx_power = power;
1483
1484out:
1485 mutex_unlock(&radio->core->lock);
1486 return r;
1487}
1488
1489#define WL1273_SPACING_50kHz 1
1490#define WL1273_SPACING_100kHz 2
1491#define WL1273_SPACING_200kHz 4
1492
1493static int wl1273_fm_tx_set_spacing(struct wl1273_device *radio,
1494 unsigned int spacing)
1495{
1496 int r;
1497
1498 if (spacing == 0) {
1499 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1500 WL1273_SPACING_100kHz);
1501 radio->spacing = 100;
1502 } else if (spacing - 50000 < 25000) {
1503 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1504 WL1273_SPACING_50kHz);
1505 radio->spacing = 50;
1506 } else if (spacing - 100000 < 50000) {
1507 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1508 WL1273_SPACING_100kHz);
1509 radio->spacing = 100;
1510 } else {
1511 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1512 WL1273_SPACING_200kHz);
1513 radio->spacing = 200;
1514 }
1515
1516 return r;
1517}
1518
1519static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1520{
1521 struct wl1273_device *radio = ctrl->priv;
1522 struct wl1273_core *core = radio->core;
1523
1524 dev_dbg(radio->dev, "%s\n", __func__);
1525
1526 if (mutex_lock_interruptible(&core->lock))
1527 return -EINTR;
1528
1529 switch (ctrl->id) {
1530 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1531 ctrl->val = wl1273_fm_get_tx_ctune(radio);
1532 break;
1533
1534 default:
1535 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1536 __func__, ctrl->id);
1537 break;
1538 }
1539
1540 mutex_unlock(&core->lock);
1541
1542 return 0;
1543}
1544
1545#define WL1273_MUTE_SOFT_ENABLE (1 << 0)
1546#define WL1273_MUTE_AC (1 << 1)
1547#define WL1273_MUTE_HARD_LEFT (1 << 2)
1548#define WL1273_MUTE_HARD_RIGHT (1 << 3)
1549#define WL1273_MUTE_SOFT_FORCE (1 << 4)
1550
1551static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl)
1552{
1553 return container_of(ctrl->handler, struct wl1273_device, ctrl_handler);
1554}
1555
1556static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl)
1557{
1558 struct wl1273_device *radio = to_radio(ctrl);
1559 struct wl1273_core *core = radio->core;
1560 int r = 0;
1561
1562 dev_dbg(radio->dev, "%s\n", __func__);
1563
1564 switch (ctrl->id) {
1565 case V4L2_CID_AUDIO_MUTE:
1566 if (mutex_lock_interruptible(&core->lock))
1567 return -EINTR;
1568
1569 if (core->mode == WL1273_MODE_RX && ctrl->val)
1570 r = wl1273_fm_write_cmd(core,
1571 WL1273_MUTE_STATUS_SET,
1572 WL1273_MUTE_HARD_LEFT |
1573 WL1273_MUTE_HARD_RIGHT);
1574 else if (core->mode == WL1273_MODE_RX)
1575 r = wl1273_fm_write_cmd(core,
1576 WL1273_MUTE_STATUS_SET, 0x0);
1577 else if (core->mode == WL1273_MODE_TX && ctrl->val)
1578 r = wl1273_fm_write_cmd(core, WL1273_MUTE, 1);
1579 else if (core->mode == WL1273_MODE_TX)
1580 r = wl1273_fm_write_cmd(core, WL1273_MUTE, 0);
1581
1582 mutex_unlock(&core->lock);
1583 break;
1584
1585 case V4L2_CID_AUDIO_VOLUME:
1586 if (ctrl->val == 0)
1587 r = wl1273_fm_set_mode(radio, WL1273_MODE_OFF);
1588 else
1589 r = core->set_volume(core, core->volume);
1590 break;
1591
1592 case V4L2_CID_TUNE_PREEMPHASIS:
1593 r = wl1273_fm_set_preemphasis(radio, ctrl->val);
1594 break;
1595
1596 case V4L2_CID_TUNE_POWER_LEVEL:
1597 r = wl1273_fm_set_tx_power(radio, ctrl->val);
1598 break;
1599
1600 default:
1601 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1602 __func__, ctrl->id);
1603 break;
1604 }
1605
1606 dev_dbg(radio->dev, "%s\n", __func__);
1607 return r;
1608}
1609
1610static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv,
1611 struct v4l2_audio *audio)
1612{
1613 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1614
1615 dev_dbg(radio->dev, "%s\n", __func__);
1616
1617 if (audio->index > 1)
1618 return -EINVAL;
1619
1620 strlcpy(audio->name, "Radio", sizeof(audio->name));
1621 audio->capability = V4L2_AUDCAP_STEREO;
1622
1623 return 0;
1624}
1625
1626static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv,
1627 struct v4l2_audio *audio)
1628{
1629 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1630
1631 dev_dbg(radio->dev, "%s\n", __func__);
1632
1633 if (audio->index != 0)
1634 return -EINVAL;
1635
1636 return 0;
1637}
1638
1639#define WL1273_RDS_NOT_SYNCHRONIZED 0
1640#define WL1273_RDS_SYNCHRONIZED 1
1641
1642static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv,
1643 struct v4l2_tuner *tuner)
1644{
1645 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1646 struct wl1273_core *core = radio->core;
1647 u16 val;
1648 int r;
1649
1650 dev_dbg(radio->dev, "%s\n", __func__);
1651
1652 if (tuner->index > 0)
1653 return -EINVAL;
1654
1655 strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name));
1656 tuner->type = V4L2_TUNER_RADIO;
1657
1658 tuner->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1659 tuner->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1660
1661 tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1662 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1663
1664 if (radio->stereo)
1665 tuner->audmode = V4L2_TUNER_MODE_STEREO;
1666 else
1667 tuner->audmode = V4L2_TUNER_MODE_MONO;
1668
1669 if (core->mode != WL1273_MODE_RX)
1670 return 0;
1671
1672 if (mutex_lock_interruptible(&core->lock))
1673 return -EINTR;
1674
1675 r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val);
1676 if (r)
1677 goto out;
1678
1679 if (val == 1)
1680 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
1681 else
1682 tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
1683
1684 r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val);
1685 if (r)
1686 goto out;
1687
1688 tuner->signal = (s16) val;
1689 dev_dbg(radio->dev, "Signal: %d\n", tuner->signal);
1690
1691 tuner->afc = 0;
1692
1693 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
1694 if (r)
1695 goto out;
1696
1697 if (val == WL1273_RDS_SYNCHRONIZED)
1698 tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
1699out:
1700 mutex_unlock(&core->lock);
1701
1702 return r;
1703}
1704
1705static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv,
1706 struct v4l2_tuner *tuner)
1707{
1708 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1709 struct wl1273_core *core = radio->core;
1710 int r = 0;
1711
1712 dev_dbg(radio->dev, "%s\n", __func__);
1713 dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index);
1714 dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name);
1715 dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability);
1716 dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans);
1717 dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow);
1718 dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh);
1719
1720 if (tuner->index > 0)
1721 return -EINVAL;
1722
1723 if (mutex_lock_interruptible(&core->lock))
1724 return -EINTR;
1725
1726 r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1727 if (r)
1728 goto out;
1729
1730 if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS)
1731 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1732 else
1733 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1734
1735 if (r)
1736 dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r);
1737
1738 if (tuner->audmode == V4L2_TUNER_MODE_MONO) {
1739 r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET,
1740 WL1273_RX_MONO);
1741 if (r < 0) {
1742 dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1743 __func__, r);
1744 goto out;
1745 }
1746 radio->stereo = false;
1747 } else if (tuner->audmode == V4L2_TUNER_MODE_STEREO) {
1748 r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET,
1749 WL1273_RX_STEREO);
1750 if (r < 0) {
1751 dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1752 __func__, r);
1753 goto out;
1754 }
1755 radio->stereo = true;
1756 } else {
1757 dev_err(radio->dev, "%s: tuner->audmode: %d\n",
1758 __func__, tuner->audmode);
1759 r = -EINVAL;
1760 goto out;
1761 }
1762
1763out:
1764 mutex_unlock(&core->lock);
1765
1766 return r;
1767}
1768
1769static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv,
1770 struct v4l2_frequency *freq)
1771{
1772 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1773 struct wl1273_core *core = radio->core;
1774
1775 dev_dbg(radio->dev, "%s\n", __func__);
1776
1777 if (mutex_lock_interruptible(&core->lock))
1778 return -EINTR;
1779
1780 freq->type = V4L2_TUNER_RADIO;
1781 freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(radio));
1782
1783 mutex_unlock(&core->lock);
1784
1785 return 0;
1786}
1787
1788static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv,
1789 struct v4l2_frequency *freq)
1790{
1791 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1792 struct wl1273_core *core = radio->core;
1793 int r;
1794
1795 dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency);
1796
1797 if (freq->type != V4L2_TUNER_RADIO) {
1798 dev_dbg(radio->dev,
1799 "freq->type != V4L2_TUNER_RADIO: %d\n", freq->type);
1800 return -EINVAL;
1801 }
1802
1803 if (mutex_lock_interruptible(&core->lock))
1804 return -EINTR;
1805
1806 if (core->mode == WL1273_MODE_RX) {
1807 dev_dbg(radio->dev, "freq: %d\n", freq->frequency);
1808
1809 r = wl1273_fm_set_rx_freq(radio,
1810 WL1273_INV_FREQ(freq->frequency));
1811 if (r)
1812 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1813 ": set frequency failed with %d\n", r);
1814 } else {
1815 r = wl1273_fm_set_tx_freq(radio,
1816 WL1273_INV_FREQ(freq->frequency));
1817 if (r)
1818 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1819 ": set frequency failed with %d\n", r);
1820 }
1821
1822 mutex_unlock(&core->lock);
1823
1824 dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n");
1825 return r;
1826}
1827
1828#define WL1273_DEFAULT_SEEK_LEVEL 7
1829
1830static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv,
1831 struct v4l2_hw_freq_seek *seek)
1832{
1833 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1834 struct wl1273_core *core = radio->core;
1835 int r;
1836
1837 dev_dbg(radio->dev, "%s\n", __func__);
1838
1839 if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO)
1840 return -EINVAL;
1841
1842 if (mutex_lock_interruptible(&core->lock))
1843 return -EINTR;
1844
1845 r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1846 if (r)
1847 goto out;
1848
1849 r = wl1273_fm_tx_set_spacing(radio, seek->spacing);
1850 if (r)
1851 dev_warn(radio->dev, "HW seek failed: %d\n", r);
1852
1853 r = wl1273_fm_set_seek(radio, seek->wrap_around, seek->seek_upward,
1854 WL1273_DEFAULT_SEEK_LEVEL);
1855 if (r)
1856 dev_warn(radio->dev, "HW seek failed: %d\n", r);
1857
1858out:
1859 mutex_unlock(&core->lock);
1860 return r;
1861}
1862
1863static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv,
1864 struct v4l2_modulator *modulator)
1865{
1866 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1867 struct wl1273_core *core = radio->core;
1868 int r = 0;
1869
1870 dev_dbg(radio->dev, "%s\n", __func__);
1871
1872 if (modulator->index > 0)
1873 return -EINVAL;
1874
1875 if (mutex_lock_interruptible(&core->lock))
1876 return -EINTR;
1877
1878 r = wl1273_fm_set_mode(radio, WL1273_MODE_TX);
1879 if (r)
1880 goto out;
1881
1882 if (modulator->txsubchans & V4L2_TUNER_SUB_RDS)
1883 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1884 else
1885 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1886
1887 if (modulator->txsubchans & V4L2_TUNER_SUB_MONO)
1888 r = wl1273_fm_write_cmd(core, WL1273_MONO_SET, WL1273_TX_MONO);
1889 else
1890 r = wl1273_fm_write_cmd(core, WL1273_MONO_SET,
1891 WL1273_RX_STEREO);
1892 if (r < 0)
1893 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1894 "MONO_SET fails: %d\n", r);
1895out:
1896 mutex_unlock(&core->lock);
1897
1898 return r;
1899}
1900
1901static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv,
1902 struct v4l2_modulator *modulator)
1903{
1904 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1905 struct wl1273_core *core = radio->core;
1906 u16 val;
1907 int r;
1908
1909 dev_dbg(radio->dev, "%s\n", __func__);
1910
1911 strlcpy(modulator->name, WL1273_FM_DRIVER_NAME,
1912 sizeof(modulator->name));
1913
1914 modulator->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1915 modulator->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1916
1917 modulator->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1918 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1919
1920 if (core->mode != WL1273_MODE_TX)
1921 return 0;
1922
1923 if (mutex_lock_interruptible(&core->lock))
1924 return -EINTR;
1925
1926 r = wl1273_fm_read_reg(core, WL1273_MONO_SET, &val);
1927 if (r)
1928 goto out;
1929
1930 if (val == WL1273_TX_STEREO)
1931 modulator->txsubchans = V4L2_TUNER_SUB_STEREO;
1932 else
1933 modulator->txsubchans = V4L2_TUNER_SUB_MONO;
1934
1935 if (radio->rds_on)
1936 modulator->txsubchans |= V4L2_TUNER_SUB_RDS;
1937out:
1938 mutex_unlock(&core->lock);
1939
1940 return 0;
1941}
1942
1943static int wl1273_fm_vidioc_log_status(struct file *file, void *priv)
1944{
1945 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1946 struct wl1273_core *core = radio->core;
1947 struct device *dev = radio->dev;
1948 u16 val;
1949 int r;
1950
1951 dev_info(dev, DRIVER_DESC);
1952
1953 if (core->mode == WL1273_MODE_OFF) {
1954 dev_info(dev, "Mode: Off\n");
1955 return 0;
1956 }
1957
1958 if (core->mode == WL1273_MODE_SUSPENDED) {
1959 dev_info(dev, "Mode: Suspended\n");
1960 return 0;
1961 }
1962
1963 r = wl1273_fm_read_reg(core, WL1273_ASIC_ID_GET, &val);
1964 if (r)
1965 dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__);
1966 else
1967 dev_info(dev, "ASIC_ID: 0x%04x\n", val);
1968
1969 r = wl1273_fm_read_reg(core, WL1273_ASIC_VER_GET, &val);
1970 if (r)
1971 dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__);
1972 else
1973 dev_info(dev, "ASIC Version: 0x%04x\n", val);
1974
1975 r = wl1273_fm_read_reg(core, WL1273_FIRM_VER_GET, &val);
1976 if (r)
1977 dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__);
1978 else
1979 dev_info(dev, "FW version: %d(0x%04x)\n", val, val);
1980
1981 r = wl1273_fm_read_reg(core, WL1273_BAND_SET, &val);
1982 if (r)
1983 dev_err(dev, "%s: Get BAND fails.\n", __func__);
1984 else
1985 dev_info(dev, "BAND: %d\n", val);
1986
1987 if (core->mode == WL1273_MODE_TX) {
1988 r = wl1273_fm_read_reg(core, WL1273_PUPD_SET, &val);
1989 if (r)
1990 dev_err(dev, "%s: Get PUPD fails.\n", __func__);
1991 else
1992 dev_info(dev, "PUPD: 0x%04x\n", val);
1993
1994 r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &val);
1995 if (r)
1996 dev_err(dev, "%s: Get CHANL fails.\n", __func__);
1997 else
1998 dev_info(dev, "Tx frequency: %dkHz\n", val*10);
1999 } else if (core->mode == WL1273_MODE_RX) {
2000 int bf = radio->rangelow;
2001
2002 r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &val);
2003 if (r)
2004 dev_err(dev, "%s: Get FREQ fails.\n", __func__);
2005 else
2006 dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50);
2007
2008 r = wl1273_fm_read_reg(core, WL1273_MOST_MODE_SET, &val);
2009 if (r)
2010 dev_err(dev, "%s: Get MOST_MODE fails.\n",
2011 __func__);
2012 else if (val == 0)
2013 dev_info(dev, "MOST_MODE: Stereo according to blend\n");
2014 else if (val == 1)
2015 dev_info(dev, "MOST_MODE: Force mono output\n");
2016 else
2017 dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val);
2018
2019 r = wl1273_fm_read_reg(core, WL1273_MOST_BLEND_SET, &val);
2020 if (r)
2021 dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__);
2022 else if (val == 0)
2023 dev_info(dev,
2024 "MOST_BLEND: Switched blend & hysteresis.\n");
2025 else if (val == 1)
2026 dev_info(dev, "MOST_BLEND: Soft blend.\n");
2027 else
2028 dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val);
2029
2030 r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val);
2031 if (r)
2032 dev_err(dev, "%s: Get STEREO fails.\n", __func__);
2033 else if (val == 0)
2034 dev_info(dev, "STEREO: Not detected\n");
2035 else if (val == 1)
2036 dev_info(dev, "STEREO: Detected\n");
2037 else
2038 dev_info(dev, "STEREO: Unexpected value: %d\n", val);
2039
2040 r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val);
2041 if (r)
2042 dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__);
2043 else
2044 dev_info(dev, "RX signal strength: %d\n", (s16) val);
2045
2046 r = wl1273_fm_read_reg(core, WL1273_POWER_SET, &val);
2047 if (r)
2048 dev_err(dev, "%s: Get POWER fails.\n", __func__);
2049 else
2050 dev_info(dev, "POWER: 0x%04x\n", val);
2051
2052 r = wl1273_fm_read_reg(core, WL1273_INT_MASK_SET, &val);
2053 if (r)
2054 dev_err(dev, "%s: Get INT_MASK fails.\n", __func__);
2055 else
2056 dev_info(dev, "INT_MASK: 0x%04x\n", val);
2057
2058 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
2059 if (r)
2060 dev_err(dev, "%s: Get RDS_SYNC fails.\n",
2061 __func__);
2062 else if (val == 0)
2063 dev_info(dev, "RDS_SYNC: Not synchronized\n");
2064
2065 else if (val == 1)
2066 dev_info(dev, "RDS_SYNC: Synchronized\n");
2067 else
2068 dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val);
2069
2070 r = wl1273_fm_read_reg(core, WL1273_I2S_MODE_CONFIG_SET, &val);
2071 if (r)
2072 dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n",
2073 __func__);
2074 else
2075 dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val);
2076
2077 r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val);
2078 if (r)
2079 dev_err(dev, "%s: Get VOLUME fails.\n", __func__);
2080 else
2081 dev_info(dev, "VOLUME: 0x%04x\n", val);
2082 }
2083
2084 return 0;
2085}
2086
2087static void wl1273_vdev_release(struct video_device *dev)
2088{
2089}
2090
2091static const struct v4l2_ctrl_ops wl1273_ctrl_ops = {
2092 .s_ctrl = wl1273_fm_vidioc_s_ctrl,
2093 .g_volatile_ctrl = wl1273_fm_g_volatile_ctrl,
2094};
2095
2096static const struct v4l2_ioctl_ops wl1273_ioctl_ops = {
2097 .vidioc_querycap = wl1273_fm_vidioc_querycap,
2098 .vidioc_g_input = wl1273_fm_vidioc_g_input,
2099 .vidioc_s_input = wl1273_fm_vidioc_s_input,
2100 .vidioc_g_audio = wl1273_fm_vidioc_g_audio,
2101 .vidioc_s_audio = wl1273_fm_vidioc_s_audio,
2102 .vidioc_g_tuner = wl1273_fm_vidioc_g_tuner,
2103 .vidioc_s_tuner = wl1273_fm_vidioc_s_tuner,
2104 .vidioc_g_frequency = wl1273_fm_vidioc_g_frequency,
2105 .vidioc_s_frequency = wl1273_fm_vidioc_s_frequency,
2106 .vidioc_s_hw_freq_seek = wl1273_fm_vidioc_s_hw_freq_seek,
2107 .vidioc_g_modulator = wl1273_fm_vidioc_g_modulator,
2108 .vidioc_s_modulator = wl1273_fm_vidioc_s_modulator,
2109 .vidioc_log_status = wl1273_fm_vidioc_log_status,
2110};
2111
2112static struct video_device wl1273_viddev_template = {
2113 .fops = &wl1273_fops,
2114 .ioctl_ops = &wl1273_ioctl_ops,
2115 .name = WL1273_FM_DRIVER_NAME,
2116 .release = wl1273_vdev_release,
2117};
2118
2119static int wl1273_fm_radio_remove(struct platform_device *pdev)
2120{
2121 struct wl1273_device *radio = platform_get_drvdata(pdev);
2122 struct wl1273_core *core = radio->core;
2123
2124 dev_info(&pdev->dev, "%s.\n", __func__);
2125
2126 free_irq(core->client->irq, radio);
2127 core->pdata->free_resources();
2128
2129 v4l2_ctrl_handler_free(&radio->ctrl_handler);
2130 video_unregister_device(&radio->videodev);
2131 v4l2_device_unregister(&radio->v4l2dev);
2132 kfree(radio->buffer);
2133 kfree(radio->write_buf);
2134 kfree(radio);
2135
2136 return 0;
2137}
2138
2139static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev)
2140{
2141 struct wl1273_core **core = pdev->dev.platform_data;
2142 struct wl1273_device *radio;
2143 struct v4l2_ctrl *ctrl;
2144 int r = 0;
2145
2146 pr_debug("%s\n", __func__);
2147
2148 if (!core) {
2149 dev_err(&pdev->dev, "No platform data.\n");
2150 r = -EINVAL;
2151 goto pdata_err;
2152 }
2153
2154 radio = kzalloc(sizeof(*radio), GFP_KERNEL);
2155 if (!radio) {
2156 r = -ENOMEM;
2157 goto pdata_err;
2158 }
2159
2160 /* RDS buffer allocation */
2161 radio->buf_size = rds_buf * RDS_BLOCK_SIZE;
2162 radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
2163 if (!radio->buffer) {
2164 pr_err("Cannot allocate memory for RDS buffer.\n");
2165 r = -ENOMEM;
2166 goto err_kmalloc;
2167 }
2168
2169 radio->core = *core;
2170 radio->irq_flags = WL1273_IRQ_MASK;
2171 radio->dev = &radio->core->client->dev;
2172 radio->rds_on = false;
2173 radio->core->mode = WL1273_MODE_OFF;
2174 radio->tx_power = 118;
2175 radio->core->audio_mode = WL1273_AUDIO_ANALOG;
2176 radio->band = WL1273_BAND_OTHER;
2177 radio->core->i2s_mode = WL1273_I2S_DEF_MODE;
2178 radio->core->channel_number = 2;
2179 radio->core->volume = WL1273_DEFAULT_VOLUME;
2180 radio->rx_frequency = WL1273_BAND_OTHER_LOW;
2181 radio->tx_frequency = WL1273_BAND_OTHER_HIGH;
2182 radio->rangelow = WL1273_BAND_OTHER_LOW;
2183 radio->rangehigh = WL1273_BAND_OTHER_HIGH;
2184 radio->stereo = true;
2185 radio->bus_type = "I2C";
2186
2187 radio->core->write = wl1273_fm_write_cmd;
2188 radio->core->set_audio = wl1273_fm_set_audio;
2189 radio->core->set_volume = wl1273_fm_set_volume;
2190
2191 if (radio->core->pdata->request_resources) {
2192 r = radio->core->pdata->request_resources(radio->core->client);
2193 if (r) {
2194 dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2195 ": Cannot get platform data\n");
2196 goto err_resources;
2197 }
2198
2199 dev_dbg(radio->dev, "irq: %d\n", radio->core->client->irq);
2200
2201 r = request_threaded_irq(radio->core->client->irq, NULL,
2202 wl1273_fm_irq_thread_handler,
2203 IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
2204 "wl1273-fm", radio);
2205 if (r < 0) {
2206 dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2207 ": Unable to register IRQ handler: %d\n", r);
2208 goto err_request_irq;
2209 }
2210 } else {
2211 dev_err(radio->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ"
2212 " not configured");
2213 r = -EINVAL;
2214 goto err_resources;
2215 }
2216
2217 init_completion(&radio->busy);
2218 init_waitqueue_head(&radio->read_queue);
2219
2220 radio->write_buf = kmalloc(256, GFP_KERNEL);
2221 if (!radio->write_buf) {
2222 r = -ENOMEM;
2223 goto write_buf_err;
2224 }
2225
2226 radio->dev = &pdev->dev;
2227 radio->v4l2dev.ctrl_handler = &radio->ctrl_handler;
2228 radio->rds_users = 0;
2229
2230 r = v4l2_device_register(&pdev->dev, &radio->v4l2dev);
2231 if (r) {
2232 dev_err(&pdev->dev, "Cannot register v4l2_device.\n");
2233 goto device_register_err;
2234 }
2235
2236 /* V4L2 configuration */
2237 memcpy(&radio->videodev, &wl1273_viddev_template,
2238 sizeof(wl1273_viddev_template));
2239
2240 radio->videodev.v4l2_dev = &radio->v4l2dev;
2241
2242 v4l2_ctrl_handler_init(&radio->ctrl_handler, 6);
2243
2244 /* add in ascending ID order */
2245 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2246 V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1,
2247 WL1273_DEFAULT_VOLUME);
2248
2249 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2250 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2251
2252 v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops,
2253 V4L2_CID_TUNE_PREEMPHASIS,
2254 V4L2_PREEMPHASIS_75_uS, 0x03,
2255 V4L2_PREEMPHASIS_50_uS);
2256
2257 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2258 V4L2_CID_TUNE_POWER_LEVEL, 91, 122, 1, 118);
2259
2260 ctrl = v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2261 V4L2_CID_TUNE_ANTENNA_CAPACITOR,
2262 0, 255, 1, 255);
2263 if (ctrl)
2264 ctrl->is_volatile = 1;
2265
2266 if (radio->ctrl_handler.error) {
2267 r = radio->ctrl_handler.error;
2268 dev_err(&pdev->dev, "Ctrl handler error: %d\n", r);
2269 goto handler_init_err;
2270 }
2271
2272 video_set_drvdata(&radio->videodev, radio);
2273 platform_set_drvdata(pdev, radio);
2274
2275 /* register video device */
2276 r = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
2277 if (r) {
2278 dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME
2279 ": Could not register video device\n");
2280 goto handler_init_err;
2281 }
2282
2283 return 0;
2284
2285handler_init_err:
2286 v4l2_ctrl_handler_free(&radio->ctrl_handler);
2287 v4l2_device_unregister(&radio->v4l2dev);
2288device_register_err:
2289 kfree(radio->write_buf);
2290write_buf_err:
2291 free_irq(radio->core->client->irq, radio);
2292err_request_irq:
2293 radio->core->pdata->free_resources();
2294err_resources:
2295 kfree(radio->buffer);
2296err_kmalloc:
2297 kfree(radio);
2298pdata_err:
2299 return r;
2300}
2301
2302MODULE_ALIAS("platform:wl1273_fm_radio");
2303
2304static struct platform_driver wl1273_fm_radio_driver = {
2305 .probe = wl1273_fm_radio_probe,
2306 .remove = __devexit_p(wl1273_fm_radio_remove),
2307 .driver = {
2308 .name = "wl1273_fm_radio",
2309 .owner = THIS_MODULE,
2310 },
2311};
2312
2313static int __init wl1273_fm_module_init(void)
2314{
2315 pr_info("%s\n", __func__);
2316 return platform_driver_register(&wl1273_fm_radio_driver);
2317}
2318module_init(wl1273_fm_module_init);
2319
2320static void __exit wl1273_fm_module_exit(void)
2321{
2322 flush_scheduled_work();
2323 platform_driver_unregister(&wl1273_fm_radio_driver);
2324 pr_info(DRIVER_DESC ", Exiting.\n");
2325}
2326module_exit(wl1273_fm_module_exit);
2327
2328MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>");
2329MODULE_DESCRIPTION(DRIVER_DESC);
2330MODULE_LICENSE("GPL");
diff --git a/drivers/media/radio/si470x/radio-si470x.h b/drivers/media/radio/si470x/radio-si470x.h
index b9914d7a0c9f..4a4e908db04c 100644
--- a/drivers/media/radio/si470x/radio-si470x.h
+++ b/drivers/media/radio/si470x/radio-si470x.h
@@ -37,7 +37,6 @@
37#include <linux/mutex.h> 37#include <linux/mutex.h>
38#include <media/v4l2-common.h> 38#include <media/v4l2-common.h>
39#include <media/v4l2-ioctl.h> 39#include <media/v4l2-ioctl.h>
40#include <media/rds.h>
41#include <asm/unaligned.h> 40#include <asm/unaligned.h>
42 41
43 42
diff --git a/drivers/media/radio/si4713-i2c.c b/drivers/media/radio/si4713-i2c.c
index a6e6f1987a3a..0fab6f8f7e24 100644
--- a/drivers/media/radio/si4713-i2c.c
+++ b/drivers/media/radio/si4713-i2c.c
@@ -27,6 +27,8 @@
27#include <linux/interrupt.h> 27#include <linux/interrupt.h>
28#include <linux/i2c.h> 28#include <linux/i2c.h>
29#include <linux/slab.h> 29#include <linux/slab.h>
30#include <linux/gpio.h>
31#include <linux/regulator/consumer.h>
30#include <media/v4l2-device.h> 32#include <media/v4l2-device.h>
31#include <media/v4l2-ioctl.h> 33#include <media/v4l2-ioctl.h>
32#include <media/v4l2-common.h> 34#include <media/v4l2-common.h>
@@ -43,6 +45,11 @@ MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>");
43MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter"); 45MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter");
44MODULE_VERSION("0.0.1"); 46MODULE_VERSION("0.0.1");
45 47
48static const char *si4713_supply_names[SI4713_NUM_SUPPLIES] = {
49 "vio",
50 "vdd",
51};
52
46#define DEFAULT_RDS_PI 0x00 53#define DEFAULT_RDS_PI 0x00
47#define DEFAULT_RDS_PTY 0x00 54#define DEFAULT_RDS_PTY 0x00
48#define DEFAULT_RDS_PS_NAME "" 55#define DEFAULT_RDS_PS_NAME ""
@@ -369,7 +376,17 @@ static int si4713_powerup(struct si4713_device *sdev)
369 if (sdev->power_state) 376 if (sdev->power_state)
370 return 0; 377 return 0;
371 378
372 sdev->platform_data->set_power(1); 379 err = regulator_bulk_enable(ARRAY_SIZE(sdev->supplies),
380 sdev->supplies);
381 if (err) {
382 v4l2_err(&sdev->sd, "Failed to enable supplies: %d\n", err);
383 return err;
384 }
385 if (gpio_is_valid(sdev->gpio_reset)) {
386 udelay(50);
387 gpio_set_value(sdev->gpio_reset, 1);
388 }
389
373 err = si4713_send_command(sdev, SI4713_CMD_POWER_UP, 390 err = si4713_send_command(sdev, SI4713_CMD_POWER_UP,
374 args, ARRAY_SIZE(args), 391 args, ARRAY_SIZE(args),
375 resp, ARRAY_SIZE(resp), 392 resp, ARRAY_SIZE(resp),
@@ -384,7 +401,13 @@ static int si4713_powerup(struct si4713_device *sdev)
384 err = si4713_write_property(sdev, SI4713_GPO_IEN, 401 err = si4713_write_property(sdev, SI4713_GPO_IEN,
385 SI4713_STC_INT | SI4713_CTS); 402 SI4713_STC_INT | SI4713_CTS);
386 } else { 403 } else {
387 sdev->platform_data->set_power(0); 404 if (gpio_is_valid(sdev->gpio_reset))
405 gpio_set_value(sdev->gpio_reset, 0);
406 err = regulator_bulk_disable(ARRAY_SIZE(sdev->supplies),
407 sdev->supplies);
408 if (err)
409 v4l2_err(&sdev->sd,
410 "Failed to disable supplies: %d\n", err);
388 } 411 }
389 412
390 return err; 413 return err;
@@ -411,7 +434,13 @@ static int si4713_powerdown(struct si4713_device *sdev)
411 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n", 434 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n",
412 resp[0]); 435 resp[0]);
413 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n"); 436 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n");
414 sdev->platform_data->set_power(0); 437 if (gpio_is_valid(sdev->gpio_reset))
438 gpio_set_value(sdev->gpio_reset, 0);
439 err = regulator_bulk_disable(ARRAY_SIZE(sdev->supplies),
440 sdev->supplies);
441 if (err)
442 v4l2_err(&sdev->sd,
443 "Failed to disable supplies: %d\n", err);
415 sdev->power_state = POWER_OFF; 444 sdev->power_state = POWER_OFF;
416 } 445 }
417 446
@@ -1967,7 +1996,8 @@ static int si4713_probe(struct i2c_client *client,
1967 const struct i2c_device_id *id) 1996 const struct i2c_device_id *id)
1968{ 1997{
1969 struct si4713_device *sdev; 1998 struct si4713_device *sdev;
1970 int rval; 1999 struct si4713_platform_data *pdata = client->dev.platform_data;
2000 int rval, i;
1971 2001
1972 sdev = kzalloc(sizeof *sdev, GFP_KERNEL); 2002 sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
1973 if (!sdev) { 2003 if (!sdev) {
@@ -1976,11 +2006,26 @@ static int si4713_probe(struct i2c_client *client,
1976 goto exit; 2006 goto exit;
1977 } 2007 }
1978 2008
1979 sdev->platform_data = client->dev.platform_data; 2009 sdev->gpio_reset = -1;
1980 if (!sdev->platform_data) { 2010 if (pdata && gpio_is_valid(pdata->gpio_reset)) {
1981 v4l2_err(&sdev->sd, "No platform data registered.\n"); 2011 rval = gpio_request(pdata->gpio_reset, "si4713 reset");
1982 rval = -ENODEV; 2012 if (rval) {
1983 goto free_sdev; 2013 dev_err(&client->dev,
2014 "Failed to request gpio: %d\n", rval);
2015 goto free_sdev;
2016 }
2017 sdev->gpio_reset = pdata->gpio_reset;
2018 gpio_direction_output(sdev->gpio_reset, 0);
2019 }
2020
2021 for (i = 0; i < ARRAY_SIZE(sdev->supplies); i++)
2022 sdev->supplies[i].supply = si4713_supply_names[i];
2023
2024 rval = regulator_bulk_get(&client->dev, ARRAY_SIZE(sdev->supplies),
2025 sdev->supplies);
2026 if (rval) {
2027 dev_err(&client->dev, "Cannot get regulators: %d\n", rval);
2028 goto free_gpio;
1984 } 2029 }
1985 2030
1986 v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops); 2031 v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
@@ -1994,7 +2039,7 @@ static int si4713_probe(struct i2c_client *client,
1994 client->name, sdev); 2039 client->name, sdev);
1995 if (rval < 0) { 2040 if (rval < 0) {
1996 v4l2_err(&sdev->sd, "Could not request IRQ\n"); 2041 v4l2_err(&sdev->sd, "Could not request IRQ\n");
1997 goto free_sdev; 2042 goto put_reg;
1998 } 2043 }
1999 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n"); 2044 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
2000 } else { 2045 } else {
@@ -2012,6 +2057,11 @@ static int si4713_probe(struct i2c_client *client,
2012free_irq: 2057free_irq:
2013 if (client->irq) 2058 if (client->irq)
2014 free_irq(client->irq, sdev); 2059 free_irq(client->irq, sdev);
2060put_reg:
2061 regulator_bulk_free(ARRAY_SIZE(sdev->supplies), sdev->supplies);
2062free_gpio:
2063 if (gpio_is_valid(sdev->gpio_reset))
2064 gpio_free(sdev->gpio_reset);
2015free_sdev: 2065free_sdev:
2016 kfree(sdev); 2066 kfree(sdev);
2017exit: 2067exit:
@@ -2031,7 +2081,9 @@ static int si4713_remove(struct i2c_client *client)
2031 free_irq(client->irq, sdev); 2081 free_irq(client->irq, sdev);
2032 2082
2033 v4l2_device_unregister_subdev(sd); 2083 v4l2_device_unregister_subdev(sd);
2034 2084 regulator_bulk_free(ARRAY_SIZE(sdev->supplies), sdev->supplies);
2085 if (gpio_is_valid(sdev->gpio_reset))
2086 gpio_free(sdev->gpio_reset);
2035 kfree(sdev); 2087 kfree(sdev);
2036 2088
2037 return 0; 2089 return 0;
diff --git a/drivers/media/radio/si4713-i2c.h b/drivers/media/radio/si4713-i2c.h
index faf8cff124f1..c6dfa7fb101c 100644
--- a/drivers/media/radio/si4713-i2c.h
+++ b/drivers/media/radio/si4713-i2c.h
@@ -211,6 +211,8 @@ struct acomp_info {
211 u32 enabled; 211 u32 enabled;
212}; 212};
213 213
214#define SI4713_NUM_SUPPLIES 2
215
214/* 216/*
215 * si4713_device - private data 217 * si4713_device - private data
216 */ 218 */
@@ -220,11 +222,12 @@ struct si4713_device {
220 /* private data structures */ 222 /* private data structures */
221 struct mutex mutex; 223 struct mutex mutex;
222 struct completion work; 224 struct completion work;
223 struct si4713_platform_data *platform_data;
224 struct rds_info rds_info; 225 struct rds_info rds_info;
225 struct limiter_info limiter_info; 226 struct limiter_info limiter_info;
226 struct pilot_info pilot_info; 227 struct pilot_info pilot_info;
227 struct acomp_info acomp_info; 228 struct acomp_info acomp_info;
229 struct regulator_bulk_data supplies[SI4713_NUM_SUPPLIES];
230 int gpio_reset;
228 u32 frequency; 231 u32 frequency;
229 u32 preemphasis; 232 u32 preemphasis;
230 u32 mute; 233 u32 mute;
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-12 04:57:31 -0500