projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] dmxdev: Fix a compilation warning due to a bad type
[deliverable/linux.git] / drivers / media / radio / radio-wl1273.c
CommitLineData
87d1a50c
MA		 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 i, n, 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, "n: %d, i: %d\n", n, i);
676 dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r);
677out:
678 release_firmware(fw_p);
679 return r;
680}
681
682static int wl1273_fm_stop(struct wl1273_device *radio)
683{
684 struct wl1273_core *core = radio->core;
685
686 if (core->mode == WL1273_MODE_RX) {
687 int r = wl1273_fm_write_cmd(core, WL1273_POWER_SET,
688 WL1273_POWER_SET_OFF);
689 if (r)
690 dev_err(radio->dev, "%s: POWER_SET fails: %d\n",
691 __func__, r);
692 } else if (core->mode == WL1273_MODE_TX) {
693 int r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
694 WL1273_PUPD_SET_OFF);
695 if (r)
696 dev_err(radio->dev,
697 "%s: PUPD_SET fails: %d\n", __func__, r);
698 }
699
700 if (core->pdata->disable) {
701 core->pdata->disable();
702 dev_dbg(radio->dev, "Back to reset\n");
703 }
704
705 return 0;
706}
707
708static int wl1273_fm_start(struct wl1273_device *radio, int new_mode)
709{
710 struct wl1273_core *core = radio->core;
711 struct wl1273_fm_platform_data *pdata = core->pdata;
712 struct device *dev = radio->dev;
713 int r = -EINVAL;
714
715 if (pdata->enable && core->mode == WL1273_MODE_OFF) {
716 dev_dbg(radio->dev, "Out of reset\n");
717
718 pdata->enable();
719 msleep(250);
720 }
721
722 if (new_mode == WL1273_MODE_RX) {
723 u16 val = WL1273_POWER_SET_FM;
724
725 if (radio->rds_on)
726 val |= WL1273_POWER_SET_RDS;
727
728 /* If this fails try again */
729 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val);
730 if (r) {
731 msleep(100);
732
733 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val);
734 if (r) {
735 dev_err(dev, "%s: POWER_SET fails\n", __func__);
736 goto fail;
737 }
738 }
739
740 /* rds buffer configuration */
741 radio->wr_index = 0;
742 radio->rd_index = 0;
743
744 } else if (new_mode == WL1273_MODE_TX) {
745 /* If this fails try again once */
746 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
747 WL1273_PUPD_SET_ON);
748 if (r) {
749 msleep(100);
750 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
751 WL1273_PUPD_SET_ON);
752 if (r) {
753 dev_err(dev, "%s: PUPD_SET fails\n", __func__);
754 goto fail;
755 }
756 }
757
758 if (radio->rds_on)
759 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1);
760 else
761 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0);
762 } else {
763 dev_warn(dev, "%s: Illegal mode.\n", __func__);
764 }
765
766 if (core->mode == WL1273_MODE_OFF) {
767 r = wl1273_fm_upload_firmware_patch(radio);
768 if (r)
769 dev_warn(dev, "Firmware upload failed.\n");
770
771 /*
772 * Sometimes the chip is in a wrong power state at this point.
773 * So we set the power once again.
774 */
775 if (new_mode == WL1273_MODE_RX) {
776 u16 val = WL1273_POWER_SET_FM;
777
778 if (radio->rds_on)
779 val |= WL1273_POWER_SET_RDS;
780
781 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, val);
782 if (r) {
783 dev_err(dev, "%s: POWER_SET fails\n", __func__);
784 goto fail;
785 }
786 } else if (new_mode == WL1273_MODE_TX) {
787 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
788 WL1273_PUPD_SET_ON);
789 if (r) {
790 dev_err(dev, "%s: PUPD_SET fails\n", __func__);
791 goto fail;
792 }
793 }
794 }
795
796 return 0;
797fail:
798 if (pdata->disable)
799 pdata->disable();
800
801 dev_dbg(dev, "%s: return: %d\n", __func__, r);
802 return r;
803}
804
805static int wl1273_fm_suspend(struct wl1273_device *radio)
806{
807 struct wl1273_core *core = radio->core;
808 int r = 0;
809
810 /* Cannot go from OFF to SUSPENDED */
811 if (core->mode == WL1273_MODE_RX)
812 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET,
813 WL1273_POWER_SET_RETENTION);
814 else if (core->mode == WL1273_MODE_TX)
815 r = wl1273_fm_write_cmd(core, WL1273_PUPD_SET,
816 WL1273_PUPD_SET_RETENTION);
817 else
818 r = -EINVAL;
819
820 if (r) {
821 dev_err(radio->dev, "%s: POWER_SET fails: %d\n", __func__, r);
822 goto out;
823 }
824
825out:
826 return r;
827}
828
829static int wl1273_fm_set_mode(struct wl1273_device *radio, int mode)
830{
831 struct wl1273_core *core = radio->core;
832 struct device *dev = radio->dev;
833 int old_mode;
834 int r;
835
836 dev_dbg(dev, "%s\n", __func__);
837 dev_dbg(dev, "Forbidden modes: 0x%02x\n", radio->forbidden);
838
839 old_mode = core->mode;
840 if (mode & radio->forbidden) {
841 r = -EPERM;
842 goto out;
843 }
844
845 switch (mode) {
846 case WL1273_MODE_RX:
847 case WL1273_MODE_TX:
848 r = wl1273_fm_start(radio, mode);
849 if (r) {
850 dev_err(dev, "%s: Cannot start.\n", __func__);
851 wl1273_fm_stop(radio);
852 goto out;
853 }
854
855 core->mode = mode;
856 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET,
857 radio->irq_flags);
858 if (r) {
859 dev_err(dev, "INT_MASK_SET fails.\n");
860 goto out;
861 }
862
863 /* remember previous settings */
864 if (mode == WL1273_MODE_RX) {
865 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
866 if (r) {
867 dev_err(dev, "set freq fails: %d.\n", r);
868 goto out;
869 }
870
871 r = core->set_volume(core, core->volume);
872 if (r) {
873 dev_err(dev, "set volume fails: %d.\n", r);
874 goto out;
875 }
876
877 dev_dbg(dev, "%s: Set vol: %d.\n", __func__,
878 core->volume);
879 } else {
880 r = wl1273_fm_set_tx_freq(radio, radio->tx_frequency);
881 if (r) {
882 dev_err(dev, "set freq fails: %d.\n", r);
883 goto out;
884 }
885 }
886
887 dev_dbg(radio->dev, "%s: Set audio mode.\n", __func__);
888
889 r = core->set_audio(core, core->audio_mode);
890 if (r)
891 dev_err(dev, "Cannot set audio mode.\n");
892 break;
893
894 case WL1273_MODE_OFF:
895 r = wl1273_fm_stop(radio);
896 if (r)
897 dev_err(dev, "%s: Off fails: %d\n", __func__, r);
898 else
899 core->mode = WL1273_MODE_OFF;
900
901 break;
902
903 case WL1273_MODE_SUSPENDED:
904 r = wl1273_fm_suspend(radio);
905 if (r)
906 dev_err(dev, "%s: Suspend fails: %d\n", __func__, r);
907 else
908 core->mode = WL1273_MODE_SUSPENDED;
909
910 break;
911
912 default:
913 dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode);
914 r = -EINVAL;
915 break;
916 }
917out:
918 if (r)
919 core->mode = old_mode;
920
921 return r;
922}
923
924static int wl1273_fm_set_seek(struct wl1273_device *radio,
925 unsigned int wrap_around,
926 unsigned int seek_upward,
927 int level)
928{
929 struct wl1273_core *core = radio->core;
930 int r = 0;
931 unsigned int dir = (seek_upward == 0) ? 0 : 1;
932 unsigned int f;
933
934 f = radio->rx_frequency;
935 dev_dbg(radio->dev, "rx_frequency: %d\n", f);
936
937 if (dir && f + radio->spacing <= radio->rangehigh)
938 r = wl1273_fm_set_rx_freq(radio, f + radio->spacing);
939 else if (dir && wrap_around)
940 r = wl1273_fm_set_rx_freq(radio, radio->rangelow);
941 else if (f - radio->spacing >= radio->rangelow)
942 r = wl1273_fm_set_rx_freq(radio, f - radio->spacing);
943 else if (wrap_around)
944 r = wl1273_fm_set_rx_freq(radio, radio->rangehigh);
945
946 if (r)
947 goto out;
948
949 if (level < SCHAR_MIN || level > SCHAR_MAX)
950 return -EINVAL;
951
952 INIT_COMPLETION(radio->busy);
953 dev_dbg(radio->dev, "%s: BUSY\n", __func__);
954
955 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, radio->irq_flags);
956 if (r)
957 goto out;
958
959 dev_dbg(radio->dev, "%s\n", __func__);
960
961 r = wl1273_fm_write_cmd(core, WL1273_SEARCH_LVL_SET, level);
962 if (r)
963 goto out;
964
965 r = wl1273_fm_write_cmd(core, WL1273_SEARCH_DIR_SET, dir);
966 if (r)
967 goto out;
968
969 r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET,
970 TUNER_MODE_AUTO_SEEK);
971 if (r)
972 goto out;
973
974 wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
975 if (!(radio->irq_received & WL1273_BL_EVENT))
976 goto out;
977
978 radio->irq_received &= ~WL1273_BL_EVENT;
979
980 if (!wrap_around)
981 goto out;
982
983 /* Wrap around */
984 dev_dbg(radio->dev, "Wrap around in HW seek.\n");
985
986 if (seek_upward)
987 f = radio->rangelow;
988 else
989 f = radio->rangehigh;
990
991 r = wl1273_fm_set_rx_freq(radio, f);
992 if (r)
993 goto out;
994
995 INIT_COMPLETION(radio->busy);
996 dev_dbg(radio->dev, "%s: BUSY\n", __func__);
997
998 r = wl1273_fm_write_cmd(core, WL1273_TUNER_MODE_SET,
999 TUNER_MODE_AUTO_SEEK);
1000 if (r)
1001 goto out;
1002
1003 wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000));
1004out:
1005 dev_dbg(radio->dev, "%s: Err: %d\n", __func__, r);
1006 return r;
1007}
1008
1009/**
1010 * wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value.
1011 * @radio: A pointer to the device struct.
1012 */
1013static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device *radio)
1014{
1015 struct wl1273_core *core = radio->core;
1016 struct device *dev = radio->dev;
1017 u16 val;
1018 int r;
1019
1020 if (core->mode == WL1273_MODE_OFF ||
1021 core->mode == WL1273_MODE_SUSPENDED)
1022 return -EPERM;
1023
1024 r = wl1273_fm_read_reg(core, WL1273_READ_FMANT_TUNE_VALUE, &val);
1025 if (r) {
1026 dev_err(dev, "%s: read error: %d\n", __func__, r);
1027 goto out;
1028 }
1029
1030out:
1031 return val;
1032}
1033
1034/**
1035 * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value.
1036 * @radio: A pointer to the device struct.
1037 * @preemphasis: The new pre-amphasis value.
1038 *
1039 * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED,
1040 * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS.
1041 */
1042static int wl1273_fm_set_preemphasis(struct wl1273_device *radio,
1043 unsigned int preemphasis)
1044{
1045 struct wl1273_core *core = radio->core;
1046 int r;
1047 u16 em;
1048
1049 if (core->mode == WL1273_MODE_OFF ||
1050 core->mode == WL1273_MODE_SUSPENDED)
1051 return -EPERM;
1052
1053 mutex_lock(&core->lock);
1054
1055 switch (preemphasis) {
1056 case V4L2_PREEMPHASIS_DISABLED:
1057 em = 1;
1058 break;
1059 case V4L2_PREEMPHASIS_50_uS:
1060 em = 0;
1061 break;
1062 case V4L2_PREEMPHASIS_75_uS:
1063 em = 2;
1064 break;
1065 default:
1066 r = -EINVAL;
1067 goto out;
1068 }
1069
1070 r = wl1273_fm_write_cmd(core, WL1273_PREMPH_SET, em);
1071 if (r)
1072 goto out;
1073
1074 radio->preemphasis = preemphasis;
1075
1076out:
1077 mutex_unlock(&core->lock);
1078 return r;
1079}
1080
1081static int wl1273_fm_rds_on(struct wl1273_device *radio)
1082{
1083 struct wl1273_core *core = radio->core;
1084 int r;
1085
1086 dev_dbg(radio->dev, "%s\n", __func__);
1087 if (radio->rds_on)
1088 return 0;
1089
1090 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET,
1091 WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS);
1092 if (r)
1093 goto out;
1094
1095 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
1096 if (r)
1097 dev_err(radio->dev, "set freq fails: %d.\n", r);
1098out:
1099 return r;
1100}
1101
1102static int wl1273_fm_rds_off(struct wl1273_device *radio)
1103{
1104 struct wl1273_core *core = radio->core;
1105 int r;
1106
1107 if (!radio->rds_on)
1108 return 0;
1109
1110 radio->irq_flags &= ~WL1273_RDS_EVENT;
1111
1112 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET, radio->irq_flags);
1113 if (r)
1114 goto out;
1115
1116 /* stop rds reception */
1117 cancel_delayed_work(&radio->work);
1118
1119 /* Service pending read */
1120 wake_up_interruptible(&radio->read_queue);
1121
1122 dev_dbg(radio->dev, "%s\n", __func__);
1123
1124 r = wl1273_fm_write_cmd(core, WL1273_POWER_SET, WL1273_POWER_SET_FM);
1125 if (r)
1126 goto out;
1127
1128 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency);
1129 if (r)
1130 dev_err(radio->dev, "set freq fails: %d.\n", r);
1131out:
1132 dev_dbg(radio->dev, "%s: exiting...\n", __func__);
1133
1134 return r;
1135}
1136
1137static int wl1273_fm_set_rds(struct wl1273_device *radio, unsigned int new_mode)
1138{
1139 int r = 0;
1140 struct wl1273_core *core = radio->core;
1141
1142 if (core->mode == WL1273_MODE_OFF ||
1143 core->mode == WL1273_MODE_SUSPENDED)
1144 return -EPERM;
1145
1146 if (new_mode == WL1273_RDS_RESET) {
1147 r = wl1273_fm_write_cmd(core, WL1273_RDS_CNTRL_SET, 1);
1148 return r;
1149 }
1150
1151 if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) {
1152 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 0);
1153 } else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) {
1154 r = wl1273_fm_write_cmd(core, WL1273_RDS_DATA_ENB, 1);
1155 } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) {
1156 r = wl1273_fm_rds_off(radio);
1157 } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) {
1158 r = wl1273_fm_rds_on(radio);
1159 } else {
1160 dev_err(radio->dev, "%s: Unknown mode: %d\n",
1161 __func__, new_mode);
1162 r = -EINVAL;
1163 }
1164
1165 if (!r)
1166 radio->rds_on = (new_mode == WL1273_RDS_ON) ? true : false;
1167
1168 return r;
1169}
1170
1171static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf,
1172 size_t count, loff_t *ppos)
1173{
1174 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1175 u16 val;
1176 int r;
1177
1178 dev_dbg(radio->dev, "%s\n", __func__);
1179
1180 if (radio->core->mode != WL1273_MODE_TX)
1181 return count;
1182
1183 if (radio->rds_users == 0) {
1184 dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1185 return 0;
1186 }
1187
1188 if (mutex_lock_interruptible(&radio->core->lock))
1189 return -EINTR;
1190 /*
1191 * Multiple processes can open the device, but only
1192 * one gets to write to it.
1193 */
1194 if (radio->owner && radio->owner != file) {
1195 r = -EBUSY;
1196 goto out;
1197 }
1198 radio->owner = file;
1199
1200 /* Manual Mode */
1201 if (count > 255)
1202 val = 255;
1203 else
1204 val = count;
1205
1206 wl1273_fm_write_cmd(radio->core, WL1273_RDS_CONFIG_DATA_SET, val);
1207
1208 if (copy_from_user(radio->write_buf + 1, buf, val)) {
1209 r = -EFAULT;
1210 goto out;
1211 }
1212
1213 dev_dbg(radio->dev, "Count: %d\n", val);
1214 dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf);
1215
1216 radio->write_buf[0] = WL1273_RDS_DATA_SET;
1217 wl1273_fm_write_data(radio->core, radio->write_buf, val + 1);
1218
1219 r = val;
1220out:
1221 mutex_unlock(&radio->core->lock);
1222
1223 return r;
1224}
1225
1226static unsigned int wl1273_fm_fops_poll(struct file *file,
1227 struct poll_table_struct *pts)
1228{
1229 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1230 struct wl1273_core *core = radio->core;
1231
1232 if (radio->owner && radio->owner != file)
1233 return -EBUSY;
1234
1235 radio->owner = file;
1236
1237 if (core->mode == WL1273_MODE_RX) {
1238 poll_wait(file, &radio->read_queue, pts);
1239
1240 if (radio->rd_index != radio->wr_index)
1241 return POLLIN | POLLRDNORM;
1242
1243 } else if (core->mode == WL1273_MODE_TX) {
1244 return POLLOUT | POLLWRNORM;
1245 }
1246
1247 return 0;
1248}
1249
1250static int wl1273_fm_fops_open(struct file *file)
1251{
1252 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1253 struct wl1273_core *core = radio->core;
1254 int r = 0;
1255
1256 dev_dbg(radio->dev, "%s\n", __func__);
1257
1258 if (core->mode == WL1273_MODE_RX && radio->rds_on &&
1259 !radio->rds_users) {
1260 dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode);
1261
1262 if (mutex_lock_interruptible(&core->lock))
1263 return -EINTR;
1264
1265 radio->irq_flags |= WL1273_RDS_EVENT;
1266
1267 r = wl1273_fm_write_cmd(core, WL1273_INT_MASK_SET,
1268 radio->irq_flags);
1269 if (r) {
1270 mutex_unlock(&core->lock);
1271 goto out;
1272 }
1273
1274 radio->rds_users++;
1275
1276 mutex_unlock(&core->lock);
1277 }
1278out:
1279 return r;
1280}
1281
1282static int wl1273_fm_fops_release(struct file *file)
1283{
1284 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1285 struct wl1273_core *core = radio->core;
1286 int r = 0;
1287
1288 dev_dbg(radio->dev, "%s\n", __func__);
1289
1290 if (radio->rds_users > 0) {
1291 radio->rds_users--;
1292 if (radio->rds_users == 0) {
1293 if (mutex_lock_interruptible(&core->lock))
1294 return -EINTR;
1295
1296 radio->irq_flags &= ~WL1273_RDS_EVENT;
1297
1298 if (core->mode == WL1273_MODE_RX) {
1299 r = wl1273_fm_write_cmd(core,
1300 WL1273_INT_MASK_SET,
1301 radio->irq_flags);
1302 if (r) {
1303 mutex_unlock(&core->lock);
1304 goto out;
1305 }
1306 }
1307 mutex_unlock(&core->lock);
1308 }
1309 }
1310
1311 if (file == radio->owner)
1312 radio->owner = NULL;
1313out:
1314 return r;
1315}
1316
1317static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf,
1318 size_t count, loff_t *ppos)
1319{
1320 int r = 0;
1321 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1322 struct wl1273_core *core = radio->core;
1323 unsigned int block_count = 0;
1324 u16 val;
1325
1326 dev_dbg(radio->dev, "%s\n", __func__);
1327
1328 if (radio->core->mode != WL1273_MODE_RX)
1329 return 0;
1330
1331 if (radio->rds_users == 0) {
1332 dev_warn(radio->dev, "%s: RDS not on.\n", __func__);
1333 return 0;
1334 }
1335
1336 if (mutex_lock_interruptible(&core->lock))
1337 return -EINTR;
1338
1339 /*
1340 * Multiple processes can open the device, but only
1341 * one at a time gets read access.
1342 */
1343 if (radio->owner && radio->owner != file) {
1344 r = -EBUSY;
1345 goto out;
1346 }
1347 radio->owner = file;
1348
1349 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
1350 if (r) {
1351 dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__);
1352 goto out;
1353 } else if (val == 0) {
1354 dev_info(radio->dev, "RDS_SYNC: Not synchronized\n");
1355 r = -ENODATA;
1356 goto out;
1357 }
1358
1359 /* block if no new data available */
1360 while (radio->wr_index == radio->rd_index) {
1361 if (file->f_flags & O_NONBLOCK) {
1362 r = -EWOULDBLOCK;
1363 goto out;
1364 }
1365
1366 dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__);
1367 if (wait_event_interruptible(radio->read_queue,
1368 radio->wr_index !=
1369 radio->rd_index) < 0) {
1370 r = -EINTR;
1371 goto out;
1372 }
1373 }
1374
1375 /* calculate block count from byte count */
1376 count /= RDS_BLOCK_SIZE;
1377
1378 /* copy RDS blocks from the internal buffer and to user buffer */
1379 while (block_count < count) {
1380 if (radio->rd_index == radio->wr_index)
1381 break;
1382
1383 /* always transfer complete RDS blocks */
1384 if (copy_to_user(buf, &radio->buffer[radio->rd_index],
1385 RDS_BLOCK_SIZE))
1386 break;
1387
1388 /* increment and wrap the read pointer */
1389 radio->rd_index += RDS_BLOCK_SIZE;
1390 if (radio->rd_index >= radio->buf_size)
1391 radio->rd_index = 0;
1392
1393 /* increment counters */
1394 block_count++;
1395 buf += RDS_BLOCK_SIZE;
1396 r += RDS_BLOCK_SIZE;
1397 }
1398
1399out:
1400 dev_dbg(radio->dev, "%s: exit\n", __func__);
1401 mutex_unlock(&core->lock);
1402
1403 return r;
1404}
1405
1406static const struct v4l2_file_operations wl1273_fops = {
1407 .owner = THIS_MODULE,
1408 .read = wl1273_fm_fops_read,
1409 .write = wl1273_fm_fops_write,
1410 .poll = wl1273_fm_fops_poll,
1411 .ioctl = video_ioctl2,
1412 .open = wl1273_fm_fops_open,
1413 .release = wl1273_fm_fops_release,
1414};
1415
1416static int wl1273_fm_vidioc_querycap(struct file *file, void *priv,
1417 struct v4l2_capability *capability)
1418{
1419 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1420
1421 dev_dbg(radio->dev, "%s\n", __func__);
1422
1423 strlcpy(capability->driver, WL1273_FM_DRIVER_NAME,
1424 sizeof(capability->driver));
1425 strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio",
1426 sizeof(capability->card));
1427 strlcpy(capability->bus_info, radio->bus_type,
1428 sizeof(capability->bus_info));
1429
1430 capability->capabilities = V4L2_CAP_HW_FREQ_SEEK |
1431 V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO |
1432 V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR |
1433 V4L2_CAP_RDS_OUTPUT;
1434
1435 return 0;
1436}
1437
1438static int wl1273_fm_vidioc_g_input(struct file *file, void *priv,
1439 unsigned int *i)
1440{
1441 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1442
1443 dev_dbg(radio->dev, "%s\n", __func__);
1444
1445 *i = 0;
1446
1447 return 0;
1448}
1449
1450static int wl1273_fm_vidioc_s_input(struct file *file, void *priv,
1451 unsigned int i)
1452{
1453 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1454
1455 dev_dbg(radio->dev, "%s\n", __func__);
1456
1457 if (i != 0)
1458 return -EINVAL;
1459
1460 return 0;
1461}
1462
1463/**
1464 * wl1273_fm_set_tx_power() - Set the transmission power value.
1465 * @core: A pointer to the device struct.
1466 * @power: The new power value.
1467 */
1468static int wl1273_fm_set_tx_power(struct wl1273_device *radio, u16 power)
1469{
1470 int r;
1471
1472 if (radio->core->mode == WL1273_MODE_OFF ||
1473 radio->core->mode == WL1273_MODE_SUSPENDED)
1474 return -EPERM;
1475
1476 mutex_lock(&radio->core->lock);
1477
1478 /* Convert the dBuV value to chip presentation */
1479 r = wl1273_fm_write_cmd(radio->core, WL1273_POWER_LEV_SET, 122 - power);
1480 if (r)
1481 goto out;
1482
1483 radio->tx_power = power;
1484
1485out:
1486 mutex_unlock(&radio->core->lock);
1487 return r;
1488}
1489
1490#define WL1273_SPACING_50kHz 1
1491#define WL1273_SPACING_100kHz 2
1492#define WL1273_SPACING_200kHz 4
1493
1494static int wl1273_fm_tx_set_spacing(struct wl1273_device *radio,
1495 unsigned int spacing)
1496{
1497 int r;
1498
1499 if (spacing == 0) {
1500 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1501 WL1273_SPACING_100kHz);
1502 radio->spacing = 100;
1503 } else if (spacing - 50000 < 25000) {
1504 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1505 WL1273_SPACING_50kHz);
1506 radio->spacing = 50;
1507 } else if (spacing - 100000 < 50000) {
1508 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1509 WL1273_SPACING_100kHz);
1510 radio->spacing = 100;
1511 } else {
1512 r = wl1273_fm_write_cmd(radio->core, WL1273_SCAN_SPACING_SET,
1513 WL1273_SPACING_200kHz);
1514 radio->spacing = 200;
1515 }
1516
1517 return r;
1518}
1519
1520static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
1521{
1522 struct wl1273_device *radio = ctrl->priv;
1523 struct wl1273_core *core = radio->core;
1524
1525 dev_dbg(radio->dev, "%s\n", __func__);
1526
1527 if (mutex_lock_interruptible(&core->lock))
1528 return -EINTR;
1529
1530 switch (ctrl->id) {
1531 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1532 ctrl->val = wl1273_fm_get_tx_ctune(radio);
1533 break;
1534
1535 default:
1536 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1537 __func__, ctrl->id);
1538 break;
1539 }
1540
1541 mutex_unlock(&core->lock);
1542
1543 return 0;
1544}
1545
1546#define WL1273_MUTE_SOFT_ENABLE (1 << 0)
1547#define WL1273_MUTE_AC (1 << 1)
1548#define WL1273_MUTE_HARD_LEFT (1 << 2)
1549#define WL1273_MUTE_HARD_RIGHT (1 << 3)
1550#define WL1273_MUTE_SOFT_FORCE (1 << 4)
1551
1552static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl)
1553{
1554 return container_of(ctrl->handler, struct wl1273_device, ctrl_handler);
1555}
1556
1557static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl)
1558{
1559 struct wl1273_device *radio = to_radio(ctrl);
1560 struct wl1273_core *core = radio->core;
1561 int r = 0;
1562
1563 dev_dbg(radio->dev, "%s\n", __func__);
1564
1565 switch (ctrl->id) {
1566 case V4L2_CID_AUDIO_MUTE:
1567 if (mutex_lock_interruptible(&core->lock))
1568 return -EINTR;
1569
1570 if (core->mode == WL1273_MODE_RX && ctrl->val)
1571 r = wl1273_fm_write_cmd(core,
1572 WL1273_MUTE_STATUS_SET,
1573 WL1273_MUTE_HARD_LEFT |
1574 WL1273_MUTE_HARD_RIGHT);
1575 else if (core->mode == WL1273_MODE_RX)
1576 r = wl1273_fm_write_cmd(core,
1577 WL1273_MUTE_STATUS_SET, 0x0);
1578 else if (core->mode == WL1273_MODE_TX && ctrl->val)
1579 r = wl1273_fm_write_cmd(core, WL1273_MUTE, 1);
1580 else if (core->mode == WL1273_MODE_TX)
1581 r = wl1273_fm_write_cmd(core, WL1273_MUTE, 0);
1582
1583 mutex_unlock(&core->lock);
1584 break;
1585
1586 case V4L2_CID_AUDIO_VOLUME:
1587 if (ctrl->val == 0)
1588 r = wl1273_fm_set_mode(radio, WL1273_MODE_OFF);
1589 else
1590 r = core->set_volume(core, core->volume);
1591 break;
1592
1593 case V4L2_CID_TUNE_PREEMPHASIS:
1594 r = wl1273_fm_set_preemphasis(radio, ctrl->val);
1595 break;
1596
1597 case V4L2_CID_TUNE_POWER_LEVEL:
1598 r = wl1273_fm_set_tx_power(radio, ctrl->val);
1599 break;
1600
1601 default:
1602 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n",
1603 __func__, ctrl->id);
1604 break;
1605 }
1606
1607 dev_dbg(radio->dev, "%s\n", __func__);
1608 return r;
1609}
1610
1611static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv,
1612 struct v4l2_audio *audio)
1613{
1614 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1615
1616 dev_dbg(radio->dev, "%s\n", __func__);
1617
1618 if (audio->index > 1)
1619 return -EINVAL;
1620
1621 strlcpy(audio->name, "Radio", sizeof(audio->name));
1622 audio->capability = V4L2_AUDCAP_STEREO;
1623
1624 return 0;
1625}
1626
1627static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv,
1628 struct v4l2_audio *audio)
1629{
1630 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1631
1632 dev_dbg(radio->dev, "%s\n", __func__);
1633
1634 if (audio->index != 0)
1635 return -EINVAL;
1636
1637 return 0;
1638}
1639
1640#define WL1273_RDS_NOT_SYNCHRONIZED 0
1641#define WL1273_RDS_SYNCHRONIZED 1
1642
1643static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv,
1644 struct v4l2_tuner *tuner)
1645{
1646 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1647 struct wl1273_core *core = radio->core;
1648 u16 val;
1649 int r;
1650
1651 dev_dbg(radio->dev, "%s\n", __func__);
1652
1653 if (tuner->index > 0)
1654 return -EINVAL;
1655
1656 strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name));
1657 tuner->type = V4L2_TUNER_RADIO;
1658
1659 tuner->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1660 tuner->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1661
1662 tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1663 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1664
1665 if (radio->stereo)
1666 tuner->audmode = V4L2_TUNER_MODE_STEREO;
1667 else
1668 tuner->audmode = V4L2_TUNER_MODE_MONO;
1669
1670 if (core->mode != WL1273_MODE_RX)
1671 return 0;
1672
1673 if (mutex_lock_interruptible(&core->lock))
1674 return -EINTR;
1675
1676 r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val);
1677 if (r)
1678 goto out;
1679
1680 if (val == 1)
1681 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO;
1682 else
1683 tuner->rxsubchans = V4L2_TUNER_SUB_MONO;
1684
1685 r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val);
1686 if (r)
1687 goto out;
1688
1689 tuner->signal = (s16) val;
1690 dev_dbg(radio->dev, "Signal: %d\n", tuner->signal);
1691
1692 tuner->afc = 0;
1693
1694 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
1695 if (r)
1696 goto out;
1697
1698 if (val == WL1273_RDS_SYNCHRONIZED)
1699 tuner->rxsubchans |= V4L2_TUNER_SUB_RDS;
1700out:
1701 mutex_unlock(&core->lock);
1702
1703 return r;
1704}
1705
1706static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv,
1707 struct v4l2_tuner *tuner)
1708{
1709 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1710 struct wl1273_core *core = radio->core;
1711 int r = 0;
1712
1713 dev_dbg(radio->dev, "%s\n", __func__);
1714 dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index);
1715 dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name);
1716 dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability);
1717 dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans);
1718 dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow);
1719 dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh);
1720
1721 if (tuner->index > 0)
1722 return -EINVAL;
1723
1724 if (mutex_lock_interruptible(&core->lock))
1725 return -EINTR;
1726
1727 r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1728 if (r)
1729 goto out;
1730
1731 if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS)
1732 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1733 else
1734 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1735
1736 if (r)
1737 dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r);
1738
1739 if (tuner->audmode == V4L2_TUNER_MODE_MONO) {
1740 r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET,
1741 WL1273_RX_MONO);
1742 if (r < 0) {
1743 dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1744 __func__, r);
1745 goto out;
1746 }
1747 radio->stereo = false;
1748 } else if (tuner->audmode == V4L2_TUNER_MODE_STEREO) {
1749 r = wl1273_fm_write_cmd(core, WL1273_MOST_MODE_SET,
1750 WL1273_RX_STEREO);
1751 if (r < 0) {
1752 dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n",
1753 __func__, r);
1754 goto out;
1755 }
1756 radio->stereo = true;
1757 } else {
1758 dev_err(radio->dev, "%s: tuner->audmode: %d\n",
1759 __func__, tuner->audmode);
1760 r = -EINVAL;
1761 goto out;
1762 }
1763
1764out:
1765 mutex_unlock(&core->lock);
1766
1767 return r;
1768}
1769
1770static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv,
1771 struct v4l2_frequency *freq)
1772{
1773 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1774 struct wl1273_core *core = radio->core;
1775
1776 dev_dbg(radio->dev, "%s\n", __func__);
1777
1778 if (mutex_lock_interruptible(&core->lock))
1779 return -EINTR;
1780
1781 freq->type = V4L2_TUNER_RADIO;
1782 freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(radio));
1783
1784 mutex_unlock(&core->lock);
1785
1786 return 0;
1787}
1788
1789static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv,
1790 struct v4l2_frequency *freq)
1791{
1792 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1793 struct wl1273_core *core = radio->core;
1794 int r;
1795
1796 dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency);
1797
1798 if (freq->type != V4L2_TUNER_RADIO) {
1799 dev_dbg(radio->dev,
1800 "freq->type != V4L2_TUNER_RADIO: %d\n", freq->type);
1801 return -EINVAL;
1802 }
1803
1804 if (mutex_lock_interruptible(&core->lock))
1805 return -EINTR;
1806
1807 if (core->mode == WL1273_MODE_RX) {
1808 dev_dbg(radio->dev, "freq: %d\n", freq->frequency);
1809
1810 r = wl1273_fm_set_rx_freq(radio,
1811 WL1273_INV_FREQ(freq->frequency));
1812 if (r)
1813 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1814 ": set frequency failed with %d\n", r);
1815 } else {
1816 r = wl1273_fm_set_tx_freq(radio,
1817 WL1273_INV_FREQ(freq->frequency));
1818 if (r)
1819 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1820 ": set frequency failed with %d\n", r);
1821 }
1822
1823 mutex_unlock(&core->lock);
1824
1825 dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n");
1826 return r;
1827}
1828
1829#define WL1273_DEFAULT_SEEK_LEVEL 7
1830
1831static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv,
1832 struct v4l2_hw_freq_seek *seek)
1833{
1834 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1835 struct wl1273_core *core = radio->core;
1836 int r;
1837
1838 dev_dbg(radio->dev, "%s\n", __func__);
1839
1840 if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO)
1841 return -EINVAL;
1842
1843 if (mutex_lock_interruptible(&core->lock))
1844 return -EINTR;
1845
1846 r = wl1273_fm_set_mode(radio, WL1273_MODE_RX);
1847 if (r)
1848 goto out;
1849
1850 r = wl1273_fm_tx_set_spacing(radio, seek->spacing);
1851 if (r)
1852 dev_warn(radio->dev, "HW seek failed: %d\n", r);
1853
1854 r = wl1273_fm_set_seek(radio, seek->wrap_around, seek->seek_upward,
1855 WL1273_DEFAULT_SEEK_LEVEL);
1856 if (r)
1857 dev_warn(radio->dev, "HW seek failed: %d\n", r);
1858
1859out:
1860 mutex_unlock(&core->lock);
1861 return r;
1862}
1863
1864static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv,
1865 struct v4l2_modulator *modulator)
1866{
1867 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1868 struct wl1273_core *core = radio->core;
1869 int r = 0;
1870
1871 dev_dbg(radio->dev, "%s\n", __func__);
1872
1873 if (modulator->index > 0)
1874 return -EINVAL;
1875
1876 if (mutex_lock_interruptible(&core->lock))
1877 return -EINTR;
1878
1879 r = wl1273_fm_set_mode(radio, WL1273_MODE_TX);
1880 if (r)
1881 goto out;
1882
1883 if (modulator->txsubchans & V4L2_TUNER_SUB_RDS)
1884 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON);
1885 else
1886 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF);
1887
1888 if (modulator->txsubchans & V4L2_TUNER_SUB_MONO)
1889 r = wl1273_fm_write_cmd(core, WL1273_MONO_SET, WL1273_TX_MONO);
1890 else
1891 r = wl1273_fm_write_cmd(core, WL1273_MONO_SET,
1892 WL1273_RX_STEREO);
1893 if (r < 0)
1894 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME
1895 "MONO_SET fails: %d\n", r);
1896out:
1897 mutex_unlock(&core->lock);
1898
1899 return r;
1900}
1901
1902static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv,
1903 struct v4l2_modulator *modulator)
1904{
1905 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1906 struct wl1273_core *core = radio->core;
1907 u16 val;
1908 int r;
1909
1910 dev_dbg(radio->dev, "%s\n", __func__);
1911
1912 strlcpy(modulator->name, WL1273_FM_DRIVER_NAME,
1913 sizeof(modulator->name));
1914
1915 modulator->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW);
1916 modulator->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH);
1917
1918 modulator->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS |
1919 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO;
1920
1921 if (core->mode != WL1273_MODE_TX)
1922 return 0;
1923
1924 if (mutex_lock_interruptible(&core->lock))
1925 return -EINTR;
1926
1927 r = wl1273_fm_read_reg(core, WL1273_MONO_SET, &val);
1928 if (r)
1929 goto out;
1930
1931 if (val == WL1273_TX_STEREO)
1932 modulator->txsubchans = V4L2_TUNER_SUB_STEREO;
1933 else
1934 modulator->txsubchans = V4L2_TUNER_SUB_MONO;
1935
1936 if (radio->rds_on)
1937 modulator->txsubchans |= V4L2_TUNER_SUB_RDS;
1938out:
1939 mutex_unlock(&core->lock);
1940
1941 return 0;
1942}
1943
1944static int wl1273_fm_vidioc_log_status(struct file *file, void *priv)
1945{
1946 struct wl1273_device *radio = video_get_drvdata(video_devdata(file));
1947 struct wl1273_core *core = radio->core;
1948 struct device *dev = radio->dev;
1949 u16 val;
1950 int r;
1951
1952 dev_info(dev, DRIVER_DESC);
1953
1954 if (core->mode == WL1273_MODE_OFF) {
1955 dev_info(dev, "Mode: Off\n");
1956 return 0;
1957 }
1958
1959 if (core->mode == WL1273_MODE_SUSPENDED) {
1960 dev_info(dev, "Mode: Suspended\n");
1961 return 0;
1962 }
1963
1964 r = wl1273_fm_read_reg(core, WL1273_ASIC_ID_GET, &val);
1965 if (r)
1966 dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__);
1967 else
1968 dev_info(dev, "ASIC_ID: 0x%04x\n", val);
1969
1970 r = wl1273_fm_read_reg(core, WL1273_ASIC_VER_GET, &val);
1971 if (r)
1972 dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__);
1973 else
1974 dev_info(dev, "ASIC Version: 0x%04x\n", val);
1975
1976 r = wl1273_fm_read_reg(core, WL1273_FIRM_VER_GET, &val);
1977 if (r)
1978 dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__);
1979 else
1980 dev_info(dev, "FW version: %d(0x%04x)\n", val, val);
1981
1982 r = wl1273_fm_read_reg(core, WL1273_BAND_SET, &val);
1983 if (r)
1984 dev_err(dev, "%s: Get BAND fails.\n", __func__);
1985 else
1986 dev_info(dev, "BAND: %d\n", val);
1987
1988 if (core->mode == WL1273_MODE_TX) {
1989 r = wl1273_fm_read_reg(core, WL1273_PUPD_SET, &val);
1990 if (r)
1991 dev_err(dev, "%s: Get PUPD fails.\n", __func__);
1992 else
1993 dev_info(dev, "PUPD: 0x%04x\n", val);
1994
1995 r = wl1273_fm_read_reg(core, WL1273_CHANL_SET, &val);
1996 if (r)
1997 dev_err(dev, "%s: Get CHANL fails.\n", __func__);
1998 else
1999 dev_info(dev, "Tx frequency: %dkHz\n", val*10);
2000 } else if (core->mode == WL1273_MODE_RX) {
2001 int bf = radio->rangelow;
2002
2003 r = wl1273_fm_read_reg(core, WL1273_FREQ_SET, &val);
2004 if (r)
2005 dev_err(dev, "%s: Get FREQ fails.\n", __func__);
2006 else
2007 dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50);
2008
2009 r = wl1273_fm_read_reg(core, WL1273_MOST_MODE_SET, &val);
2010 if (r)
2011 dev_err(dev, "%s: Get MOST_MODE fails.\n",
2012 __func__);
2013 else if (val == 0)
2014 dev_info(dev, "MOST_MODE: Stereo according to blend\n");
2015 else if (val == 1)
2016 dev_info(dev, "MOST_MODE: Force mono output\n");
2017 else
2018 dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val);
2019
2020 r = wl1273_fm_read_reg(core, WL1273_MOST_BLEND_SET, &val);
2021 if (r)
2022 dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__);
2023 else if (val == 0)
2024 dev_info(dev,
2025 "MOST_BLEND: Switched blend & hysteresis.\n");
2026 else if (val == 1)
2027 dev_info(dev, "MOST_BLEND: Soft blend.\n");
2028 else
2029 dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val);
2030
2031 r = wl1273_fm_read_reg(core, WL1273_STEREO_GET, &val);
2032 if (r)
2033 dev_err(dev, "%s: Get STEREO fails.\n", __func__);
2034 else if (val == 0)
2035 dev_info(dev, "STEREO: Not detected\n");
2036 else if (val == 1)
2037 dev_info(dev, "STEREO: Detected\n");
2038 else
2039 dev_info(dev, "STEREO: Unexpected value: %d\n", val);
2040
2041 r = wl1273_fm_read_reg(core, WL1273_RSSI_LVL_GET, &val);
2042 if (r)
2043 dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__);
2044 else
2045 dev_info(dev, "RX signal strength: %d\n", (s16) val);
2046
2047 r = wl1273_fm_read_reg(core, WL1273_POWER_SET, &val);
2048 if (r)
2049 dev_err(dev, "%s: Get POWER fails.\n", __func__);
2050 else
2051 dev_info(dev, "POWER: 0x%04x\n", val);
2052
2053 r = wl1273_fm_read_reg(core, WL1273_INT_MASK_SET, &val);
2054 if (r)
2055 dev_err(dev, "%s: Get INT_MASK fails.\n", __func__);
2056 else
2057 dev_info(dev, "INT_MASK: 0x%04x\n", val);
2058
2059 r = wl1273_fm_read_reg(core, WL1273_RDS_SYNC_GET, &val);
2060 if (r)
2061 dev_err(dev, "%s: Get RDS_SYNC fails.\n",
2062 __func__);
2063 else if (val == 0)
2064 dev_info(dev, "RDS_SYNC: Not synchronized\n");
2065
2066 else if (val == 1)
2067 dev_info(dev, "RDS_SYNC: Synchronized\n");
2068 else
2069 dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val);
2070
2071 r = wl1273_fm_read_reg(core, WL1273_I2S_MODE_CONFIG_SET, &val);
2072 if (r)
2073 dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n",
2074 __func__);
2075 else
2076 dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val);
2077
2078 r = wl1273_fm_read_reg(core, WL1273_VOLUME_SET, &val);
2079 if (r)
2080 dev_err(dev, "%s: Get VOLUME fails.\n", __func__);
2081 else
2082 dev_info(dev, "VOLUME: 0x%04x\n", val);
2083 }
2084
2085 return 0;
2086}
2087
2088static void wl1273_vdev_release(struct video_device *dev)
2089{
2090}
2091
2092static const struct v4l2_ctrl_ops wl1273_ctrl_ops = {
2093 .s_ctrl = wl1273_fm_vidioc_s_ctrl,
2094 .g_volatile_ctrl = wl1273_fm_g_volatile_ctrl,
2095};
2096
2097static const struct v4l2_ioctl_ops wl1273_ioctl_ops = {
2098 .vidioc_querycap = wl1273_fm_vidioc_querycap,
2099 .vidioc_g_input = wl1273_fm_vidioc_g_input,
2100 .vidioc_s_input = wl1273_fm_vidioc_s_input,
2101 .vidioc_g_audio = wl1273_fm_vidioc_g_audio,
2102 .vidioc_s_audio = wl1273_fm_vidioc_s_audio,
2103 .vidioc_g_tuner = wl1273_fm_vidioc_g_tuner,
2104 .vidioc_s_tuner = wl1273_fm_vidioc_s_tuner,
2105 .vidioc_g_frequency = wl1273_fm_vidioc_g_frequency,
2106 .vidioc_s_frequency = wl1273_fm_vidioc_s_frequency,
2107 .vidioc_s_hw_freq_seek = wl1273_fm_vidioc_s_hw_freq_seek,
2108 .vidioc_g_modulator = wl1273_fm_vidioc_g_modulator,
2109 .vidioc_s_modulator = wl1273_fm_vidioc_s_modulator,
2110 .vidioc_log_status = wl1273_fm_vidioc_log_status,
2111};
2112
2113static struct video_device wl1273_viddev_template = {
2114 .fops = &wl1273_fops,
2115 .ioctl_ops = &wl1273_ioctl_ops,
2116 .name = WL1273_FM_DRIVER_NAME,
2117 .release = wl1273_vdev_release,
2118};
2119
2120static int wl1273_fm_radio_remove(struct platform_device *pdev)
2121{
2122 struct wl1273_device *radio = platform_get_drvdata(pdev);
2123 struct wl1273_core *core = radio->core;
2124
2125 dev_info(&pdev->dev, "%s.\n", __func__);
2126
2127 free_irq(core->client->irq, radio);
2128 core->pdata->free_resources();
2129
2130 v4l2_ctrl_handler_free(&radio->ctrl_handler);
2131 video_unregister_device(&radio->videodev);
2132 v4l2_device_unregister(&radio->v4l2dev);
2133 kfree(radio->buffer);
2134 kfree(radio->write_buf);
2135 kfree(radio);
2136
2137 return 0;
2138}
2139
2140static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev)
2141{
2142 struct wl1273_core **core = pdev->dev.platform_data;
2143 struct wl1273_device *radio;
2144 struct v4l2_ctrl *ctrl;
2145 int r = 0;
2146
2147 pr_debug("%s\n", __func__);
2148
2149 if (!core) {
2150 dev_err(&pdev->dev, "No platform data.\n");
2151 r = -EINVAL;
2152 goto pdata_err;
2153 }
2154
2155 radio = kzalloc(sizeof(*radio), GFP_KERNEL);
2156 if (!radio) {
2157 r = -ENOMEM;
2158 goto pdata_err;
2159 }
2160
2161 /* RDS buffer allocation */
2162 radio->buf_size = rds_buf * RDS_BLOCK_SIZE;
2163 radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL);
2164 if (!radio->buffer) {
2165 pr_err("Cannot allocate memory for RDS buffer.\n");
2166 r = -ENOMEM;
2167 goto err_kmalloc;
2168 }
2169
2170 radio->core = *core;
2171 radio->irq_flags = WL1273_IRQ_MASK;
2172 radio->dev = &radio->core->client->dev;
2173 radio->rds_on = false;
2174 radio->core->mode = WL1273_MODE_OFF;
2175 radio->tx_power = 118;
2176 radio->core->audio_mode = WL1273_AUDIO_ANALOG;
2177 radio->band = WL1273_BAND_OTHER;
2178 radio->core->i2s_mode = WL1273_I2S_DEF_MODE;
2179 radio->core->channel_number = 2;
2180 radio->core->volume = WL1273_DEFAULT_VOLUME;
2181 radio->rx_frequency = WL1273_BAND_OTHER_LOW;
2182 radio->tx_frequency = WL1273_BAND_OTHER_HIGH;
2183 radio->rangelow = WL1273_BAND_OTHER_LOW;
2184 radio->rangehigh = WL1273_BAND_OTHER_HIGH;
2185 radio->stereo = true;
2186 radio->bus_type = "I2C";
2187
2188 radio->core->write = wl1273_fm_write_cmd;
2189 radio->core->set_audio = wl1273_fm_set_audio;
2190 radio->core->set_volume = wl1273_fm_set_volume;
2191
2192 if (radio->core->pdata->request_resources) {
2193 r = radio->core->pdata->request_resources(radio->core->client);
2194 if (r) {
2195 dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2196 ": Cannot get platform data\n");
2197 goto err_resources;
2198 }
2199
2200 dev_dbg(radio->dev, "irq: %d\n", radio->core->client->irq);
2201
2202 r = request_threaded_irq(radio->core->client->irq, NULL,
2203 wl1273_fm_irq_thread_handler,
2204 IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
2205 "wl1273-fm", radio);
2206 if (r < 0) {
2207 dev_err(radio->dev, WL1273_FM_DRIVER_NAME
2208 ": Unable to register IRQ handler: %d\n", r);
2209 goto err_request_irq;
2210 }
2211 } else {
2212 dev_err(radio->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ"
2213 " not configured");
2214 r = -EINVAL;
2215 goto err_resources;
2216 }
2217
2218 init_completion(&radio->busy);
2219 init_waitqueue_head(&radio->read_queue);
2220
2221 radio->write_buf = kmalloc(256, GFP_KERNEL);
2222 if (!radio->write_buf) {
2223 r = -ENOMEM;
2224 goto write_buf_err;
2225 }
2226
2227 radio->dev = &pdev->dev;
2228 radio->v4l2dev.ctrl_handler = &radio->ctrl_handler;
2229 radio->rds_users = 0;
2230
2231 r = v4l2_device_register(&pdev->dev, &radio->v4l2dev);
2232 if (r) {
2233 dev_err(&pdev->dev, "Cannot register v4l2_device.\n");
2234 goto device_register_err;
2235 }
2236
2237 /* V4L2 configuration */
2238 memcpy(&radio->videodev, &wl1273_viddev_template,
2239 sizeof(wl1273_viddev_template));
2240
2241 radio->videodev.v4l2_dev = &radio->v4l2dev;
2242
2243 v4l2_ctrl_handler_init(&radio->ctrl_handler, 6);
2244
2245 /* add in ascending ID order */
2246 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2247 V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1,
2248 WL1273_DEFAULT_VOLUME);
2249
2250 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2251 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
2252
2253 v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops,
2254 V4L2_CID_TUNE_PREEMPHASIS,
2255 V4L2_PREEMPHASIS_75_uS, 0x03,
2256 V4L2_PREEMPHASIS_50_uS);
2257
2258 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2259 V4L2_CID_TUNE_POWER_LEVEL, 91, 122, 1, 118);
2260
2261 ctrl = v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops,
2262 V4L2_CID_TUNE_ANTENNA_CAPACITOR,
2263 0, 255, 1, 255);
2264 if (ctrl)
2265 ctrl->is_volatile = 1;
2266
2267 if (radio->ctrl_handler.error) {
2268 r = radio->ctrl_handler.error;
2269 dev_err(&pdev->dev, "Ctrl handler error: %d\n", r);
2270 goto handler_init_err;
2271 }
2272
2273 video_set_drvdata(&radio->videodev, radio);
2274 platform_set_drvdata(pdev, radio);
2275
2276 /* register video device */
2277 r = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr);
2278 if (r) {
2279 dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME
2280 ": Could not register video device\n");
2281 goto handler_init_err;
2282 }
2283
2284 return 0;
2285
2286handler_init_err:
2287 v4l2_ctrl_handler_free(&radio->ctrl_handler);
2288 v4l2_device_unregister(&radio->v4l2dev);
2289device_register_err:
2290 kfree(radio->write_buf);
2291write_buf_err:
2292 free_irq(radio->core->client->irq, radio);
2293err_request_irq:
2294 radio->core->pdata->free_resources();
2295err_resources:
2296 kfree(radio->buffer);
2297err_kmalloc:
2298 kfree(radio);
2299pdata_err:
2300 return r;
2301}
2302
2303MODULE_ALIAS("platform:wl1273_fm_radio");
2304
2305static struct platform_driver wl1273_fm_radio_driver = {
2306 .probe = wl1273_fm_radio_probe,
2307 .remove = __devexit_p(wl1273_fm_radio_remove),
2308 .driver = {
2309 .name = "wl1273_fm_radio",
2310 .owner = THIS_MODULE,
2311 },
2312};
2313
2314static int __init wl1273_fm_module_init(void)
2315{
2316 pr_info("%s\n", __func__);
2317 return platform_driver_register(&wl1273_fm_radio_driver);
2318}
2319module_init(wl1273_fm_module_init);
2320
2321static void __exit wl1273_fm_module_exit(void)
2322{
2323 flush_scheduled_work();
2324 platform_driver_unregister(&wl1273_fm_radio_driver);
2325 pr_info(DRIVER_DESC ", Exiting.\n");
2326}
2327module_exit(wl1273_fm_module_exit);
2328
2329MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>");
2330MODULE_DESCRIPTION(DRIVER_DESC);
2331MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.199928 seconds and 5 git commands to generate.