2 * Driver for the Texas Instruments WL1273 FM radio.
4 * Copyright (C) 2011 Nokia Corporation
5 * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com>
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.
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.
17 #include <linux/delay.h>
18 #include <linux/firmware.h>
19 #include <linux/interrupt.h>
20 #include <linux/mfd/wl1273-core.h>
21 #include <linux/slab.h>
22 #include <linux/module.h>
23 #include <media/v4l2-common.h>
24 #include <media/v4l2-ctrls.h>
25 #include <media/v4l2-device.h>
26 #include <media/v4l2-ioctl.h>
28 #define DRIVER_DESC "Wl1273 FM Radio"
30 #define WL1273_POWER_SET_OFF 0
31 #define WL1273_POWER_SET_FM BIT(0)
32 #define WL1273_POWER_SET_RDS BIT(1)
33 #define WL1273_POWER_SET_RETENTION BIT(4)
35 #define WL1273_PUPD_SET_OFF 0x00
36 #define WL1273_PUPD_SET_ON 0x01
37 #define WL1273_PUPD_SET_RETENTION 0x10
39 #define WL1273_FREQ(x) (x * 10000 / 625)
40 #define WL1273_INV_FREQ(x) (x * 625 / 10000)
43 * static int radio_nr - The number of the radio device
48 module_param(radio_nr
, int, 0);
49 MODULE_PARM_DESC(radio_nr
, "The number of the radio device. Default = 0");
51 struct wl1273_device
{
55 unsigned int preemphasis
;
57 unsigned int tx_power
;
58 unsigned int rx_frequency
;
59 unsigned int tx_frequency
;
60 unsigned int rangelow
;
61 unsigned int rangehigh
;
68 wait_queue_head_t read_queue
;
69 struct mutex lock
; /* for serializing fm radio operations */
70 struct completion busy
;
72 unsigned char *buffer
;
73 unsigned int buf_size
;
74 unsigned int rd_index
;
75 unsigned int wr_index
;
77 /* Selected interrupts */
81 struct v4l2_ctrl_handler ctrl_handler
;
82 struct v4l2_device v4l2dev
;
83 struct video_device videodev
;
85 struct wl1273_core
*core
;
88 unsigned int rds_users
;
91 #define WL1273_IRQ_MASK (WL1273_FR_EVENT | \
95 * static unsigned int rds_buf - the number of RDS buffer blocks used.
97 * The default number is 100.
99 static unsigned int rds_buf
= 100;
100 module_param(rds_buf
, uint
, 0);
101 MODULE_PARM_DESC(rds_buf
, "Number of RDS buffer entries. Default = 100");
103 static int wl1273_fm_write_fw(struct wl1273_core
*core
,
106 struct i2c_client
*client
= core
->client
;
110 msg
.addr
= client
->addr
;
113 for (i
= 0; i
<= len
; i
++) {
118 dev_dbg(&client
->dev
, "%s:len[%d]: %d\n", __func__
, i
, msg
.len
);
120 r
= i2c_transfer(client
->adapter
, &msg
, 1);
121 if (r
< 0 && i
< len
+ 1)
125 dev_dbg(&client
->dev
, "%s: i: %d\n", __func__
, i
);
126 dev_dbg(&client
->dev
, "%s: len + 1: %d\n", __func__
, len
+ 1);
128 /* Last transfer always fails. */
129 if (i
== len
|| r
== 1)
135 #define WL1273_FIFO_HAS_DATA(status) (1 << 5 & status)
136 #define WL1273_RDS_CORRECTABLE_ERROR (1 << 3)
137 #define WL1273_RDS_UNCORRECTABLE_ERROR (1 << 4)
139 static int wl1273_fm_rds(struct wl1273_device
*radio
)
141 struct wl1273_core
*core
= radio
->core
;
142 struct i2c_client
*client
= core
->client
;
144 u8 b0
= WL1273_RDS_DATA_GET
, status
;
145 struct v4l2_rds_data rds
= { 0, 0, 0 };
146 struct i2c_msg msg
[] = {
148 .addr
= client
->addr
,
154 .addr
= client
->addr
,
162 if (core
->mode
!= WL1273_MODE_RX
)
165 r
= core
->read(core
, WL1273_RDS_SYNC_GET
, &val
);
169 if ((val
& 0x01) == 0) {
170 /* RDS decoder not synchronized */
174 /* copy all four RDS blocks to internal buffer */
176 r
= i2c_transfer(client
->adapter
, msg
, ARRAY_SIZE(msg
));
177 if (r
!= ARRAY_SIZE(msg
)) {
178 dev_err(radio
->dev
, WL1273_FM_DRIVER_NAME
179 ": %s: read_rds error r == %i)\n",
185 if (!WL1273_FIFO_HAS_DATA(status
))
188 /* copy bits 0-2 (the block ID) to bits 3-5 */
189 rds
.block
= V4L2_RDS_BLOCK_MSK
& status
;
190 rds
.block
|= rds
.block
<< 3;
192 /* copy the error bits to standard positions */
193 if (WL1273_RDS_UNCORRECTABLE_ERROR
& status
) {
194 rds
.block
|= V4L2_RDS_BLOCK_ERROR
;
195 rds
.block
&= ~V4L2_RDS_BLOCK_CORRECTED
;
196 } else if (WL1273_RDS_CORRECTABLE_ERROR
& status
) {
197 rds
.block
&= ~V4L2_RDS_BLOCK_ERROR
;
198 rds
.block
|= V4L2_RDS_BLOCK_CORRECTED
;
201 /* copy RDS block to internal buffer */
202 memcpy(&radio
->buffer
[radio
->wr_index
], &rds
, RDS_BLOCK_SIZE
);
203 radio
->wr_index
+= 3;
205 /* wrap write pointer */
206 if (radio
->wr_index
>= radio
->buf_size
)
209 /* check for overflow & start over */
210 if (radio
->wr_index
== radio
->rd_index
) {
211 dev_dbg(radio
->dev
, "RDS OVERFLOW");
217 } while (WL1273_FIFO_HAS_DATA(status
));
219 /* wake up read queue */
220 if (radio
->wr_index
!= radio
->rd_index
)
221 wake_up_interruptible(&radio
->read_queue
);
226 static irqreturn_t
wl1273_fm_irq_thread_handler(int irq
, void *dev_id
)
228 struct wl1273_device
*radio
= dev_id
;
229 struct wl1273_core
*core
= radio
->core
;
233 r
= core
->read(core
, WL1273_FLAG_GET
, &flags
);
237 if (flags
& WL1273_BL_EVENT
) {
238 radio
->irq_received
= flags
;
239 dev_dbg(radio
->dev
, "IRQ: BL\n");
242 if (flags
& WL1273_RDS_EVENT
) {
245 wl1273_fm_rds(radio
);
248 if (flags
& WL1273_BBLK_EVENT
)
249 dev_dbg(radio
->dev
, "IRQ: BBLK\n");
251 if (flags
& WL1273_LSYNC_EVENT
)
252 dev_dbg(radio
->dev
, "IRQ: LSYNC\n");
254 if (flags
& WL1273_LEV_EVENT
) {
257 r
= core
->read(core
, WL1273_RSSI_LVL_GET
, &level
);
262 dev_dbg(radio
->dev
, "IRQ: LEV: 0x%x04\n", level
);
265 if (flags
& WL1273_IFFR_EVENT
)
266 dev_dbg(radio
->dev
, "IRQ: IFFR\n");
268 if (flags
& WL1273_PI_EVENT
)
269 dev_dbg(radio
->dev
, "IRQ: PI\n");
271 if (flags
& WL1273_PD_EVENT
)
272 dev_dbg(radio
->dev
, "IRQ: PD\n");
274 if (flags
& WL1273_STIC_EVENT
)
275 dev_dbg(radio
->dev
, "IRQ: STIC\n");
277 if (flags
& WL1273_MAL_EVENT
)
278 dev_dbg(radio
->dev
, "IRQ: MAL\n");
280 if (flags
& WL1273_POW_ENB_EVENT
) {
281 complete(&radio
->busy
);
282 dev_dbg(radio
->dev
, "NOT BUSY\n");
283 dev_dbg(radio
->dev
, "IRQ: POW_ENB\n");
286 if (flags
& WL1273_SCAN_OVER_EVENT
)
287 dev_dbg(radio
->dev
, "IRQ: SCAN_OVER\n");
289 if (flags
& WL1273_ERROR_EVENT
)
290 dev_dbg(radio
->dev
, "IRQ: ERROR\n");
292 if (flags
& WL1273_FR_EVENT
) {
295 dev_dbg(radio
->dev
, "IRQ: FR:\n");
297 if (core
->mode
== WL1273_MODE_RX
) {
298 r
= core
->write(core
, WL1273_TUNER_MODE_SET
,
299 TUNER_MODE_STOP_SEARCH
);
302 "%s: TUNER_MODE_SET fails: %d\n",
307 r
= core
->read(core
, WL1273_FREQ_SET
, &freq
);
311 if (radio
->band
== WL1273_BAND_JAPAN
)
312 radio
->rx_frequency
= WL1273_BAND_JAPAN_LOW
+
315 radio
->rx_frequency
= WL1273_BAND_OTHER_LOW
+
318 * The driver works better with this msleep,
319 * the documentation doesn't mention it.
321 usleep_range(10000, 15000);
323 dev_dbg(radio
->dev
, "%dkHz\n", radio
->rx_frequency
);
326 r
= core
->read(core
, WL1273_CHANL_SET
, &freq
);
330 dev_dbg(radio
->dev
, "%dkHz\n", freq
);
332 dev_dbg(radio
->dev
, "%s: NOT BUSY\n", __func__
);
336 core
->write(core
, WL1273_INT_MASK_SET
, radio
->irq_flags
);
337 complete(&radio
->busy
);
342 static int wl1273_fm_set_tx_freq(struct wl1273_device
*radio
, unsigned int freq
)
344 struct wl1273_core
*core
= radio
->core
;
348 if (freq
< WL1273_BAND_TX_LOW
) {
350 "Frequency out of range: %d < %d\n", freq
,
355 if (freq
> WL1273_BAND_TX_HIGH
) {
357 "Frequency out of range: %d > %d\n", freq
,
358 WL1273_BAND_TX_HIGH
);
363 * The driver works better with this sleep,
364 * the documentation doesn't mention it.
366 usleep_range(5000, 10000);
368 dev_dbg(radio
->dev
, "%s: freq: %d kHz\n", __func__
, freq
);
370 /* Set the current tx channel */
371 r
= core
->write(core
, WL1273_CHANL_SET
, freq
/ 10);
375 reinit_completion(&radio
->busy
);
377 /* wait for the FR IRQ */
378 t
= wait_for_completion_timeout(&radio
->busy
, msecs_to_jiffies(2000));
382 dev_dbg(radio
->dev
, "WL1273_CHANL_SET: %lu\n", t
);
384 /* Enable the output power */
385 r
= core
->write(core
, WL1273_POWER_ENB_SET
, 1);
389 reinit_completion(&radio
->busy
);
391 /* wait for the POWER_ENB IRQ */
392 t
= wait_for_completion_timeout(&radio
->busy
, msecs_to_jiffies(1000));
396 radio
->tx_frequency
= freq
;
397 dev_dbg(radio
->dev
, "WL1273_POWER_ENB_SET: %lu\n", t
);
402 static int wl1273_fm_set_rx_freq(struct wl1273_device
*radio
, unsigned int freq
)
404 struct wl1273_core
*core
= radio
->core
;
408 if (freq
< radio
->rangelow
) {
410 "Frequency out of range: %d < %d\n", freq
,
416 if (freq
> radio
->rangehigh
) {
418 "Frequency out of range: %d > %d\n", freq
,
424 dev_dbg(radio
->dev
, "%s: %dkHz\n", __func__
, freq
);
426 core
->write(core
, WL1273_INT_MASK_SET
, radio
->irq_flags
);
428 if (radio
->band
== WL1273_BAND_JAPAN
)
429 f
= (freq
- WL1273_BAND_JAPAN_LOW
) / 50;
431 f
= (freq
- WL1273_BAND_OTHER_LOW
) / 50;
433 r
= core
->write(core
, WL1273_FREQ_SET
, f
);
435 dev_err(radio
->dev
, "FREQ_SET fails\n");
439 r
= core
->write(core
, WL1273_TUNER_MODE_SET
, TUNER_MODE_PRESET
);
441 dev_err(radio
->dev
, "TUNER_MODE_SET fails\n");
445 reinit_completion(&radio
->busy
);
447 t
= wait_for_completion_timeout(&radio
->busy
, msecs_to_jiffies(2000));
449 dev_err(radio
->dev
, "%s: TIMEOUT\n", __func__
);
455 radio
->rx_frequency
= freq
;
461 static int wl1273_fm_get_freq(struct wl1273_device
*radio
)
463 struct wl1273_core
*core
= radio
->core
;
468 if (core
->mode
== WL1273_MODE_RX
) {
469 r
= core
->read(core
, WL1273_FREQ_SET
, &f
);
473 dev_dbg(radio
->dev
, "Freq get: 0x%04x\n", f
);
474 if (radio
->band
== WL1273_BAND_JAPAN
)
475 freq
= WL1273_BAND_JAPAN_LOW
+ 50 * f
;
477 freq
= WL1273_BAND_OTHER_LOW
+ 50 * f
;
479 r
= core
->read(core
, WL1273_CHANL_SET
, &f
);
490 * wl1273_fm_upload_firmware_patch() - Upload the firmware.
491 * @radio: A pointer to the device struct.
493 * The firmware file consists of arrays of bytes where the first byte
494 * gives the array length. The first byte in the file gives the
495 * number of these arrays.
497 static int wl1273_fm_upload_firmware_patch(struct wl1273_device
*radio
)
499 struct wl1273_core
*core
= radio
->core
;
500 unsigned int packet_num
;
501 const struct firmware
*fw_p
;
502 const char *fw_name
= "radio-wl1273-fw.bin";
503 struct device
*dev
= radio
->dev
;
507 dev_dbg(dev
, "%s:\n", __func__
);
510 * Uploading the firmware patch is not always necessary,
511 * so we only print an info message.
513 if (request_firmware(&fw_p
, fw_name
, dev
)) {
514 dev_info(dev
, "%s - %s not found\n", __func__
, fw_name
);
519 ptr
= (__u8
*) fw_p
->data
;
521 dev_dbg(dev
, "%s: packets: %d\n", __func__
, packet_num
);
523 r
= wl1273_fm_write_fw(core
, ptr
+ 1, packet_num
);
525 dev_err(dev
, "FW upload error: %d\n", r
);
529 /* ignore possible error here */
530 core
->write(core
, WL1273_RESET
, 0);
532 dev_dbg(dev
, "%s - download OK, r: %d\n", __func__
, r
);
534 release_firmware(fw_p
);
538 static int wl1273_fm_stop(struct wl1273_device
*radio
)
540 struct wl1273_core
*core
= radio
->core
;
542 if (core
->mode
== WL1273_MODE_RX
) {
543 int r
= core
->write(core
, WL1273_POWER_SET
,
544 WL1273_POWER_SET_OFF
);
546 dev_err(radio
->dev
, "%s: POWER_SET fails: %d\n",
548 } else if (core
->mode
== WL1273_MODE_TX
) {
549 int r
= core
->write(core
, WL1273_PUPD_SET
,
550 WL1273_PUPD_SET_OFF
);
553 "%s: PUPD_SET fails: %d\n", __func__
, r
);
556 if (core
->pdata
->disable
) {
557 core
->pdata
->disable();
558 dev_dbg(radio
->dev
, "Back to reset\n");
564 static int wl1273_fm_start(struct wl1273_device
*radio
, int new_mode
)
566 struct wl1273_core
*core
= radio
->core
;
567 struct wl1273_fm_platform_data
*pdata
= core
->pdata
;
568 struct device
*dev
= radio
->dev
;
571 if (pdata
->enable
&& core
->mode
== WL1273_MODE_OFF
) {
572 dev_dbg(radio
->dev
, "Out of reset\n");
578 if (new_mode
== WL1273_MODE_RX
) {
579 u16 val
= WL1273_POWER_SET_FM
;
582 val
|= WL1273_POWER_SET_RDS
;
584 /* If this fails try again */
585 r
= core
->write(core
, WL1273_POWER_SET
, val
);
589 r
= core
->write(core
, WL1273_POWER_SET
, val
);
591 dev_err(dev
, "%s: POWER_SET fails\n", __func__
);
596 /* rds buffer configuration */
600 } else if (new_mode
== WL1273_MODE_TX
) {
601 /* If this fails try again once */
602 r
= core
->write(core
, WL1273_PUPD_SET
, WL1273_PUPD_SET_ON
);
605 r
= core
->write(core
, WL1273_PUPD_SET
,
608 dev_err(dev
, "%s: PUPD_SET fails\n", __func__
);
614 r
= core
->write(core
, WL1273_RDS_DATA_ENB
, 1);
616 r
= core
->write(core
, WL1273_RDS_DATA_ENB
, 0);
618 dev_warn(dev
, "%s: Illegal mode.\n", __func__
);
621 if (core
->mode
== WL1273_MODE_OFF
) {
622 r
= wl1273_fm_upload_firmware_patch(radio
);
624 dev_warn(dev
, "Firmware upload failed.\n");
627 * Sometimes the chip is in a wrong power state at this point.
628 * So we set the power once again.
630 if (new_mode
== WL1273_MODE_RX
) {
631 u16 val
= WL1273_POWER_SET_FM
;
634 val
|= WL1273_POWER_SET_RDS
;
636 r
= core
->write(core
, WL1273_POWER_SET
, val
);
638 dev_err(dev
, "%s: POWER_SET fails\n", __func__
);
641 } else if (new_mode
== WL1273_MODE_TX
) {
642 r
= core
->write(core
, WL1273_PUPD_SET
,
645 dev_err(dev
, "%s: PUPD_SET fails\n", __func__
);
656 dev_dbg(dev
, "%s: return: %d\n", __func__
, r
);
660 static int wl1273_fm_suspend(struct wl1273_device
*radio
)
662 struct wl1273_core
*core
= radio
->core
;
665 /* Cannot go from OFF to SUSPENDED */
666 if (core
->mode
== WL1273_MODE_RX
)
667 r
= core
->write(core
, WL1273_POWER_SET
,
668 WL1273_POWER_SET_RETENTION
);
669 else if (core
->mode
== WL1273_MODE_TX
)
670 r
= core
->write(core
, WL1273_PUPD_SET
,
671 WL1273_PUPD_SET_RETENTION
);
676 dev_err(radio
->dev
, "%s: POWER_SET fails: %d\n", __func__
, r
);
684 static int wl1273_fm_set_mode(struct wl1273_device
*radio
, int mode
)
686 struct wl1273_core
*core
= radio
->core
;
687 struct device
*dev
= radio
->dev
;
691 dev_dbg(dev
, "%s\n", __func__
);
692 dev_dbg(dev
, "Forbidden modes: 0x%02x\n", radio
->forbidden
);
694 old_mode
= core
->mode
;
695 if (mode
& radio
->forbidden
) {
703 r
= wl1273_fm_start(radio
, mode
);
705 dev_err(dev
, "%s: Cannot start.\n", __func__
);
706 wl1273_fm_stop(radio
);
711 r
= core
->write(core
, WL1273_INT_MASK_SET
, radio
->irq_flags
);
713 dev_err(dev
, "INT_MASK_SET fails.\n");
717 /* remember previous settings */
718 if (mode
== WL1273_MODE_RX
) {
719 r
= wl1273_fm_set_rx_freq(radio
, radio
->rx_frequency
);
721 dev_err(dev
, "set freq fails: %d.\n", r
);
725 r
= core
->set_volume(core
, core
->volume
);
727 dev_err(dev
, "set volume fails: %d.\n", r
);
731 dev_dbg(dev
, "%s: Set vol: %d.\n", __func__
,
734 r
= wl1273_fm_set_tx_freq(radio
, radio
->tx_frequency
);
736 dev_err(dev
, "set freq fails: %d.\n", r
);
741 dev_dbg(radio
->dev
, "%s: Set audio mode.\n", __func__
);
743 r
= core
->set_audio(core
, core
->audio_mode
);
745 dev_err(dev
, "Cannot set audio mode.\n");
748 case WL1273_MODE_OFF
:
749 r
= wl1273_fm_stop(radio
);
751 dev_err(dev
, "%s: Off fails: %d\n", __func__
, r
);
753 core
->mode
= WL1273_MODE_OFF
;
757 case WL1273_MODE_SUSPENDED
:
758 r
= wl1273_fm_suspend(radio
);
760 dev_err(dev
, "%s: Suspend fails: %d\n", __func__
, r
);
762 core
->mode
= WL1273_MODE_SUSPENDED
;
767 dev_err(dev
, "%s: Unknown mode: %d\n", __func__
, mode
);
773 core
->mode
= old_mode
;
778 static int wl1273_fm_set_seek(struct wl1273_device
*radio
,
779 unsigned int wrap_around
,
780 unsigned int seek_upward
,
783 struct wl1273_core
*core
= radio
->core
;
785 unsigned int dir
= (seek_upward
== 0) ? 0 : 1;
788 f
= radio
->rx_frequency
;
789 dev_dbg(radio
->dev
, "rx_frequency: %d\n", f
);
791 if (dir
&& f
+ radio
->spacing
<= radio
->rangehigh
)
792 r
= wl1273_fm_set_rx_freq(radio
, f
+ radio
->spacing
);
793 else if (dir
&& wrap_around
)
794 r
= wl1273_fm_set_rx_freq(radio
, radio
->rangelow
);
795 else if (f
- radio
->spacing
>= radio
->rangelow
)
796 r
= wl1273_fm_set_rx_freq(radio
, f
- radio
->spacing
);
797 else if (wrap_around
)
798 r
= wl1273_fm_set_rx_freq(radio
, radio
->rangehigh
);
803 if (level
< SCHAR_MIN
|| level
> SCHAR_MAX
)
806 reinit_completion(&radio
->busy
);
807 dev_dbg(radio
->dev
, "%s: BUSY\n", __func__
);
809 r
= core
->write(core
, WL1273_INT_MASK_SET
, radio
->irq_flags
);
813 dev_dbg(radio
->dev
, "%s\n", __func__
);
815 r
= core
->write(core
, WL1273_SEARCH_LVL_SET
, level
);
819 r
= core
->write(core
, WL1273_SEARCH_DIR_SET
, dir
);
823 r
= core
->write(core
, WL1273_TUNER_MODE_SET
, TUNER_MODE_AUTO_SEEK
);
827 /* wait for the FR IRQ */
828 wait_for_completion_timeout(&radio
->busy
, msecs_to_jiffies(1000));
829 if (!(radio
->irq_received
& WL1273_BL_EVENT
)) {
834 radio
->irq_received
&= ~WL1273_BL_EVENT
;
840 dev_dbg(radio
->dev
, "Wrap around in HW seek.\n");
845 f
= radio
->rangehigh
;
847 r
= wl1273_fm_set_rx_freq(radio
, f
);
851 reinit_completion(&radio
->busy
);
852 dev_dbg(radio
->dev
, "%s: BUSY\n", __func__
);
854 r
= core
->write(core
, WL1273_TUNER_MODE_SET
, TUNER_MODE_AUTO_SEEK
);
858 /* wait for the FR IRQ */
859 if (!wait_for_completion_timeout(&radio
->busy
, msecs_to_jiffies(1000)))
862 dev_dbg(radio
->dev
, "%s: Err: %d\n", __func__
, r
);
867 * wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value.
868 * @radio: A pointer to the device struct.
870 static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device
*radio
)
872 struct wl1273_core
*core
= radio
->core
;
873 struct device
*dev
= radio
->dev
;
877 if (core
->mode
== WL1273_MODE_OFF
||
878 core
->mode
== WL1273_MODE_SUSPENDED
)
881 r
= core
->read(core
, WL1273_READ_FMANT_TUNE_VALUE
, &val
);
883 dev_err(dev
, "%s: read error: %d\n", __func__
, r
);
892 * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value.
893 * @radio: A pointer to the device struct.
894 * @preemphasis: The new pre-amphasis value.
896 * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED,
897 * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS.
899 static int wl1273_fm_set_preemphasis(struct wl1273_device
*radio
,
900 unsigned int preemphasis
)
902 struct wl1273_core
*core
= radio
->core
;
906 if (core
->mode
== WL1273_MODE_OFF
||
907 core
->mode
== WL1273_MODE_SUSPENDED
)
910 mutex_lock(&core
->lock
);
912 switch (preemphasis
) {
913 case V4L2_PREEMPHASIS_DISABLED
:
916 case V4L2_PREEMPHASIS_50_uS
:
919 case V4L2_PREEMPHASIS_75_uS
:
927 r
= core
->write(core
, WL1273_PREMPH_SET
, em
);
931 radio
->preemphasis
= preemphasis
;
934 mutex_unlock(&core
->lock
);
938 static int wl1273_fm_rds_on(struct wl1273_device
*radio
)
940 struct wl1273_core
*core
= radio
->core
;
943 dev_dbg(radio
->dev
, "%s\n", __func__
);
947 r
= core
->write(core
, WL1273_POWER_SET
,
948 WL1273_POWER_SET_FM
| WL1273_POWER_SET_RDS
);
952 r
= wl1273_fm_set_rx_freq(radio
, radio
->rx_frequency
);
954 dev_err(radio
->dev
, "set freq fails: %d.\n", r
);
959 static int wl1273_fm_rds_off(struct wl1273_device
*radio
)
961 struct wl1273_core
*core
= radio
->core
;
967 radio
->irq_flags
&= ~WL1273_RDS_EVENT
;
969 r
= core
->write(core
, WL1273_INT_MASK_SET
, radio
->irq_flags
);
973 /* Service pending read */
974 wake_up_interruptible(&radio
->read_queue
);
976 dev_dbg(radio
->dev
, "%s\n", __func__
);
978 r
= core
->write(core
, WL1273_POWER_SET
, WL1273_POWER_SET_FM
);
982 r
= wl1273_fm_set_rx_freq(radio
, radio
->rx_frequency
);
984 dev_err(radio
->dev
, "set freq fails: %d.\n", r
);
986 dev_dbg(radio
->dev
, "%s: exiting...\n", __func__
);
991 static int wl1273_fm_set_rds(struct wl1273_device
*radio
, unsigned int new_mode
)
994 struct wl1273_core
*core
= radio
->core
;
996 if (core
->mode
== WL1273_MODE_OFF
||
997 core
->mode
== WL1273_MODE_SUSPENDED
)
1000 if (new_mode
== WL1273_RDS_RESET
) {
1001 r
= core
->write(core
, WL1273_RDS_CNTRL_SET
, 1);
1005 if (core
->mode
== WL1273_MODE_TX
&& new_mode
== WL1273_RDS_OFF
) {
1006 r
= core
->write(core
, WL1273_RDS_DATA_ENB
, 0);
1007 } else if (core
->mode
== WL1273_MODE_TX
&& new_mode
== WL1273_RDS_ON
) {
1008 r
= core
->write(core
, WL1273_RDS_DATA_ENB
, 1);
1009 } else if (core
->mode
== WL1273_MODE_RX
&& new_mode
== WL1273_RDS_OFF
) {
1010 r
= wl1273_fm_rds_off(radio
);
1011 } else if (core
->mode
== WL1273_MODE_RX
&& new_mode
== WL1273_RDS_ON
) {
1012 r
= wl1273_fm_rds_on(radio
);
1014 dev_err(radio
->dev
, "%s: Unknown mode: %d\n",
1015 __func__
, new_mode
);
1020 radio
->rds_on
= (new_mode
== WL1273_RDS_ON
) ? true : false;
1025 static ssize_t
wl1273_fm_fops_write(struct file
*file
, const char __user
*buf
,
1026 size_t count
, loff_t
*ppos
)
1028 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1029 struct wl1273_core
*core
= radio
->core
;
1033 dev_dbg(radio
->dev
, "%s\n", __func__
);
1035 if (core
->mode
!= WL1273_MODE_TX
)
1038 if (radio
->rds_users
== 0) {
1039 dev_warn(radio
->dev
, "%s: RDS not on.\n", __func__
);
1043 if (mutex_lock_interruptible(&core
->lock
))
1046 * Multiple processes can open the device, but only
1047 * one gets to write to it.
1049 if (radio
->owner
&& radio
->owner
!= file
) {
1053 radio
->owner
= file
;
1061 core
->write(core
, WL1273_RDS_CONFIG_DATA_SET
, val
);
1063 if (copy_from_user(radio
->write_buf
+ 1, buf
, val
)) {
1068 dev_dbg(radio
->dev
, "Count: %d\n", val
);
1069 dev_dbg(radio
->dev
, "From user: \"%s\"\n", radio
->write_buf
);
1071 radio
->write_buf
[0] = WL1273_RDS_DATA_SET
;
1072 core
->write_data(core
, radio
->write_buf
, val
+ 1);
1076 mutex_unlock(&core
->lock
);
1081 static unsigned int wl1273_fm_fops_poll(struct file
*file
,
1082 struct poll_table_struct
*pts
)
1084 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1085 struct wl1273_core
*core
= radio
->core
;
1087 if (radio
->owner
&& radio
->owner
!= file
)
1090 radio
->owner
= file
;
1092 if (core
->mode
== WL1273_MODE_RX
) {
1093 poll_wait(file
, &radio
->read_queue
, pts
);
1095 if (radio
->rd_index
!= radio
->wr_index
)
1096 return POLLIN
| POLLRDNORM
;
1098 } else if (core
->mode
== WL1273_MODE_TX
) {
1099 return POLLOUT
| POLLWRNORM
;
1105 static int wl1273_fm_fops_open(struct file
*file
)
1107 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1108 struct wl1273_core
*core
= radio
->core
;
1111 dev_dbg(radio
->dev
, "%s\n", __func__
);
1113 if (core
->mode
== WL1273_MODE_RX
&& radio
->rds_on
&&
1114 !radio
->rds_users
) {
1115 dev_dbg(radio
->dev
, "%s: Mode: %d\n", __func__
, core
->mode
);
1117 if (mutex_lock_interruptible(&core
->lock
))
1120 radio
->irq_flags
|= WL1273_RDS_EVENT
;
1122 r
= core
->write(core
, WL1273_INT_MASK_SET
,
1125 mutex_unlock(&core
->lock
);
1131 mutex_unlock(&core
->lock
);
1137 static int wl1273_fm_fops_release(struct file
*file
)
1139 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1140 struct wl1273_core
*core
= radio
->core
;
1143 dev_dbg(radio
->dev
, "%s\n", __func__
);
1145 if (radio
->rds_users
> 0) {
1147 if (radio
->rds_users
== 0) {
1148 if (mutex_lock_interruptible(&core
->lock
))
1151 radio
->irq_flags
&= ~WL1273_RDS_EVENT
;
1153 if (core
->mode
== WL1273_MODE_RX
) {
1154 r
= core
->write(core
,
1155 WL1273_INT_MASK_SET
,
1158 mutex_unlock(&core
->lock
);
1162 mutex_unlock(&core
->lock
);
1166 if (file
== radio
->owner
)
1167 radio
->owner
= NULL
;
1172 static ssize_t
wl1273_fm_fops_read(struct file
*file
, char __user
*buf
,
1173 size_t count
, loff_t
*ppos
)
1176 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1177 struct wl1273_core
*core
= radio
->core
;
1178 unsigned int block_count
= 0;
1181 dev_dbg(radio
->dev
, "%s\n", __func__
);
1183 if (core
->mode
!= WL1273_MODE_RX
)
1186 if (radio
->rds_users
== 0) {
1187 dev_warn(radio
->dev
, "%s: RDS not on.\n", __func__
);
1191 if (mutex_lock_interruptible(&core
->lock
))
1195 * Multiple processes can open the device, but only
1196 * one at a time gets read access.
1198 if (radio
->owner
&& radio
->owner
!= file
) {
1202 radio
->owner
= file
;
1204 r
= core
->read(core
, WL1273_RDS_SYNC_GET
, &val
);
1206 dev_err(radio
->dev
, "%s: Get RDS_SYNC fails.\n", __func__
);
1208 } else if (val
== 0) {
1209 dev_info(radio
->dev
, "RDS_SYNC: Not synchronized\n");
1214 /* block if no new data available */
1215 while (radio
->wr_index
== radio
->rd_index
) {
1216 if (file
->f_flags
& O_NONBLOCK
) {
1221 dev_dbg(radio
->dev
, "%s: Wait for RDS data.\n", __func__
);
1222 if (wait_event_interruptible(radio
->read_queue
,
1224 radio
->rd_index
) < 0) {
1230 /* calculate block count from byte count */
1231 count
/= RDS_BLOCK_SIZE
;
1233 /* copy RDS blocks from the internal buffer and to user buffer */
1234 while (block_count
< count
) {
1235 if (radio
->rd_index
== radio
->wr_index
)
1238 /* always transfer complete RDS blocks */
1239 if (copy_to_user(buf
, &radio
->buffer
[radio
->rd_index
],
1243 /* increment and wrap the read pointer */
1244 radio
->rd_index
+= RDS_BLOCK_SIZE
;
1245 if (radio
->rd_index
>= radio
->buf_size
)
1246 radio
->rd_index
= 0;
1248 /* increment counters */
1250 buf
+= RDS_BLOCK_SIZE
;
1251 r
+= RDS_BLOCK_SIZE
;
1255 dev_dbg(radio
->dev
, "%s: exit\n", __func__
);
1256 mutex_unlock(&core
->lock
);
1261 static const struct v4l2_file_operations wl1273_fops
= {
1262 .owner
= THIS_MODULE
,
1263 .read
= wl1273_fm_fops_read
,
1264 .write
= wl1273_fm_fops_write
,
1265 .poll
= wl1273_fm_fops_poll
,
1266 .unlocked_ioctl
= video_ioctl2
,
1267 .open
= wl1273_fm_fops_open
,
1268 .release
= wl1273_fm_fops_release
,
1271 static int wl1273_fm_vidioc_querycap(struct file
*file
, void *priv
,
1272 struct v4l2_capability
*capability
)
1274 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1276 dev_dbg(radio
->dev
, "%s\n", __func__
);
1278 strlcpy(capability
->driver
, WL1273_FM_DRIVER_NAME
,
1279 sizeof(capability
->driver
));
1280 strlcpy(capability
->card
, "Texas Instruments Wl1273 FM Radio",
1281 sizeof(capability
->card
));
1282 strlcpy(capability
->bus_info
, radio
->bus_type
,
1283 sizeof(capability
->bus_info
));
1285 capability
->device_caps
= V4L2_CAP_HW_FREQ_SEEK
|
1286 V4L2_CAP_TUNER
| V4L2_CAP_RADIO
| V4L2_CAP_AUDIO
|
1287 V4L2_CAP_RDS_CAPTURE
| V4L2_CAP_MODULATOR
|
1288 V4L2_CAP_RDS_OUTPUT
;
1289 capability
->capabilities
= capability
->device_caps
|
1290 V4L2_CAP_DEVICE_CAPS
;
1295 static int wl1273_fm_vidioc_g_input(struct file
*file
, void *priv
,
1298 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1300 dev_dbg(radio
->dev
, "%s\n", __func__
);
1307 static int wl1273_fm_vidioc_s_input(struct file
*file
, void *priv
,
1310 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1312 dev_dbg(radio
->dev
, "%s\n", __func__
);
1321 * wl1273_fm_set_tx_power() - Set the transmission power value.
1322 * @core: A pointer to the device struct.
1323 * @power: The new power value.
1325 static int wl1273_fm_set_tx_power(struct wl1273_device
*radio
, u16 power
)
1327 struct wl1273_core
*core
= radio
->core
;
1330 if (core
->mode
== WL1273_MODE_OFF
||
1331 core
->mode
== WL1273_MODE_SUSPENDED
)
1334 mutex_lock(&core
->lock
);
1336 /* Convert the dBuV value to chip presentation */
1337 r
= core
->write(core
, WL1273_POWER_LEV_SET
, 122 - power
);
1341 radio
->tx_power
= power
;
1344 mutex_unlock(&core
->lock
);
1348 #define WL1273_SPACING_50kHz 1
1349 #define WL1273_SPACING_100kHz 2
1350 #define WL1273_SPACING_200kHz 4
1352 static int wl1273_fm_tx_set_spacing(struct wl1273_device
*radio
,
1353 unsigned int spacing
)
1355 struct wl1273_core
*core
= radio
->core
;
1359 r
= core
->write(core
, WL1273_SCAN_SPACING_SET
,
1360 WL1273_SPACING_100kHz
);
1361 radio
->spacing
= 100;
1362 } else if (spacing
- 50000 < 25000) {
1363 r
= core
->write(core
, WL1273_SCAN_SPACING_SET
,
1364 WL1273_SPACING_50kHz
);
1365 radio
->spacing
= 50;
1366 } else if (spacing
- 100000 < 50000) {
1367 r
= core
->write(core
, WL1273_SCAN_SPACING_SET
,
1368 WL1273_SPACING_100kHz
);
1369 radio
->spacing
= 100;
1371 r
= core
->write(core
, WL1273_SCAN_SPACING_SET
,
1372 WL1273_SPACING_200kHz
);
1373 radio
->spacing
= 200;
1379 static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl
*ctrl
)
1381 struct wl1273_device
*radio
= ctrl
->priv
;
1382 struct wl1273_core
*core
= radio
->core
;
1384 dev_dbg(radio
->dev
, "%s\n", __func__
);
1386 if (mutex_lock_interruptible(&core
->lock
))
1390 case V4L2_CID_TUNE_ANTENNA_CAPACITOR
:
1391 ctrl
->val
= wl1273_fm_get_tx_ctune(radio
);
1395 dev_warn(radio
->dev
, "%s: Unknown IOCTL: %d\n",
1396 __func__
, ctrl
->id
);
1400 mutex_unlock(&core
->lock
);
1405 #define WL1273_MUTE_SOFT_ENABLE (1 << 0)
1406 #define WL1273_MUTE_AC (1 << 1)
1407 #define WL1273_MUTE_HARD_LEFT (1 << 2)
1408 #define WL1273_MUTE_HARD_RIGHT (1 << 3)
1409 #define WL1273_MUTE_SOFT_FORCE (1 << 4)
1411 static inline struct wl1273_device
*to_radio(struct v4l2_ctrl
*ctrl
)
1413 return container_of(ctrl
->handler
, struct wl1273_device
, ctrl_handler
);
1416 static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl
*ctrl
)
1418 struct wl1273_device
*radio
= to_radio(ctrl
);
1419 struct wl1273_core
*core
= radio
->core
;
1422 dev_dbg(radio
->dev
, "%s\n", __func__
);
1425 case V4L2_CID_AUDIO_MUTE
:
1426 if (mutex_lock_interruptible(&core
->lock
))
1429 if (core
->mode
== WL1273_MODE_RX
&& ctrl
->val
)
1430 r
= core
->write(core
,
1431 WL1273_MUTE_STATUS_SET
,
1432 WL1273_MUTE_HARD_LEFT
|
1433 WL1273_MUTE_HARD_RIGHT
);
1434 else if (core
->mode
== WL1273_MODE_RX
)
1435 r
= core
->write(core
,
1436 WL1273_MUTE_STATUS_SET
, 0x0);
1437 else if (core
->mode
== WL1273_MODE_TX
&& ctrl
->val
)
1438 r
= core
->write(core
, WL1273_MUTE
, 1);
1439 else if (core
->mode
== WL1273_MODE_TX
)
1440 r
= core
->write(core
, WL1273_MUTE
, 0);
1442 mutex_unlock(&core
->lock
);
1445 case V4L2_CID_AUDIO_VOLUME
:
1447 r
= wl1273_fm_set_mode(radio
, WL1273_MODE_OFF
);
1449 r
= core
->set_volume(core
, core
->volume
);
1452 case V4L2_CID_TUNE_PREEMPHASIS
:
1453 r
= wl1273_fm_set_preemphasis(radio
, ctrl
->val
);
1456 case V4L2_CID_TUNE_POWER_LEVEL
:
1457 r
= wl1273_fm_set_tx_power(radio
, ctrl
->val
);
1461 dev_warn(radio
->dev
, "%s: Unknown IOCTL: %d\n",
1462 __func__
, ctrl
->id
);
1466 dev_dbg(radio
->dev
, "%s\n", __func__
);
1470 static int wl1273_fm_vidioc_g_audio(struct file
*file
, void *priv
,
1471 struct v4l2_audio
*audio
)
1473 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1475 dev_dbg(radio
->dev
, "%s\n", __func__
);
1477 if (audio
->index
> 1)
1480 strlcpy(audio
->name
, "Radio", sizeof(audio
->name
));
1481 audio
->capability
= V4L2_AUDCAP_STEREO
;
1486 static int wl1273_fm_vidioc_s_audio(struct file
*file
, void *priv
,
1487 const struct v4l2_audio
*audio
)
1489 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1491 dev_dbg(radio
->dev
, "%s\n", __func__
);
1493 if (audio
->index
!= 0)
1499 #define WL1273_RDS_NOT_SYNCHRONIZED 0
1500 #define WL1273_RDS_SYNCHRONIZED 1
1502 static int wl1273_fm_vidioc_g_tuner(struct file
*file
, void *priv
,
1503 struct v4l2_tuner
*tuner
)
1505 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1506 struct wl1273_core
*core
= radio
->core
;
1510 dev_dbg(radio
->dev
, "%s\n", __func__
);
1512 if (tuner
->index
> 0)
1515 strlcpy(tuner
->name
, WL1273_FM_DRIVER_NAME
, sizeof(tuner
->name
));
1516 tuner
->type
= V4L2_TUNER_RADIO
;
1518 tuner
->rangelow
= WL1273_FREQ(WL1273_BAND_JAPAN_LOW
);
1519 tuner
->rangehigh
= WL1273_FREQ(WL1273_BAND_OTHER_HIGH
);
1521 tuner
->capability
= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_RDS
|
1522 V4L2_TUNER_CAP_STEREO
| V4L2_TUNER_CAP_RDS_BLOCK_IO
|
1523 V4L2_TUNER_CAP_HWSEEK_BOUNDED
| V4L2_TUNER_CAP_HWSEEK_WRAP
;
1526 tuner
->audmode
= V4L2_TUNER_MODE_STEREO
;
1528 tuner
->audmode
= V4L2_TUNER_MODE_MONO
;
1530 if (core
->mode
!= WL1273_MODE_RX
)
1533 if (mutex_lock_interruptible(&core
->lock
))
1536 r
= core
->read(core
, WL1273_STEREO_GET
, &val
);
1541 tuner
->rxsubchans
= V4L2_TUNER_SUB_STEREO
;
1543 tuner
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1545 r
= core
->read(core
, WL1273_RSSI_LVL_GET
, &val
);
1549 tuner
->signal
= (s16
) val
;
1550 dev_dbg(radio
->dev
, "Signal: %d\n", tuner
->signal
);
1554 r
= core
->read(core
, WL1273_RDS_SYNC_GET
, &val
);
1558 if (val
== WL1273_RDS_SYNCHRONIZED
)
1559 tuner
->rxsubchans
|= V4L2_TUNER_SUB_RDS
;
1561 mutex_unlock(&core
->lock
);
1566 static int wl1273_fm_vidioc_s_tuner(struct file
*file
, void *priv
,
1567 const struct v4l2_tuner
*tuner
)
1569 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1570 struct wl1273_core
*core
= radio
->core
;
1573 dev_dbg(radio
->dev
, "%s\n", __func__
);
1574 dev_dbg(radio
->dev
, "tuner->index: %d\n", tuner
->index
);
1575 dev_dbg(radio
->dev
, "tuner->name: %s\n", tuner
->name
);
1576 dev_dbg(radio
->dev
, "tuner->capability: 0x%04x\n", tuner
->capability
);
1577 dev_dbg(radio
->dev
, "tuner->rxsubchans: 0x%04x\n", tuner
->rxsubchans
);
1578 dev_dbg(radio
->dev
, "tuner->rangelow: %d\n", tuner
->rangelow
);
1579 dev_dbg(radio
->dev
, "tuner->rangehigh: %d\n", tuner
->rangehigh
);
1581 if (tuner
->index
> 0)
1584 if (mutex_lock_interruptible(&core
->lock
))
1587 r
= wl1273_fm_set_mode(radio
, WL1273_MODE_RX
);
1591 if (tuner
->rxsubchans
& V4L2_TUNER_SUB_RDS
)
1592 r
= wl1273_fm_set_rds(radio
, WL1273_RDS_ON
);
1594 r
= wl1273_fm_set_rds(radio
, WL1273_RDS_OFF
);
1597 dev_warn(radio
->dev
, "%s: RDS fails: %d\n", __func__
, r
);
1599 if (tuner
->audmode
== V4L2_TUNER_MODE_MONO
) {
1600 r
= core
->write(core
, WL1273_MOST_MODE_SET
, WL1273_RX_MONO
);
1602 dev_warn(radio
->dev
, "%s: MOST_MODE fails: %d\n",
1606 radio
->stereo
= false;
1607 } else if (tuner
->audmode
== V4L2_TUNER_MODE_STEREO
) {
1608 r
= core
->write(core
, WL1273_MOST_MODE_SET
, WL1273_RX_STEREO
);
1610 dev_warn(radio
->dev
, "%s: MOST_MODE fails: %d\n",
1614 radio
->stereo
= true;
1616 dev_err(radio
->dev
, "%s: tuner->audmode: %d\n",
1617 __func__
, tuner
->audmode
);
1623 mutex_unlock(&core
->lock
);
1628 static int wl1273_fm_vidioc_g_frequency(struct file
*file
, void *priv
,
1629 struct v4l2_frequency
*freq
)
1631 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1632 struct wl1273_core
*core
= radio
->core
;
1634 dev_dbg(radio
->dev
, "%s\n", __func__
);
1636 if (mutex_lock_interruptible(&core
->lock
))
1639 freq
->type
= V4L2_TUNER_RADIO
;
1640 freq
->frequency
= WL1273_FREQ(wl1273_fm_get_freq(radio
));
1642 mutex_unlock(&core
->lock
);
1647 static int wl1273_fm_vidioc_s_frequency(struct file
*file
, void *priv
,
1648 const struct v4l2_frequency
*freq
)
1650 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1651 struct wl1273_core
*core
= radio
->core
;
1654 dev_dbg(radio
->dev
, "%s: %d\n", __func__
, freq
->frequency
);
1656 if (freq
->type
!= V4L2_TUNER_RADIO
) {
1658 "freq->type != V4L2_TUNER_RADIO: %d\n", freq
->type
);
1662 if (mutex_lock_interruptible(&core
->lock
))
1665 if (core
->mode
== WL1273_MODE_RX
) {
1666 dev_dbg(radio
->dev
, "freq: %d\n", freq
->frequency
);
1668 r
= wl1273_fm_set_rx_freq(radio
,
1669 WL1273_INV_FREQ(freq
->frequency
));
1671 dev_warn(radio
->dev
, WL1273_FM_DRIVER_NAME
1672 ": set frequency failed with %d\n", r
);
1674 r
= wl1273_fm_set_tx_freq(radio
,
1675 WL1273_INV_FREQ(freq
->frequency
));
1677 dev_warn(radio
->dev
, WL1273_FM_DRIVER_NAME
1678 ": set frequency failed with %d\n", r
);
1681 mutex_unlock(&core
->lock
);
1683 dev_dbg(radio
->dev
, "wl1273_vidioc_s_frequency: DONE\n");
1687 #define WL1273_DEFAULT_SEEK_LEVEL 7
1689 static int wl1273_fm_vidioc_s_hw_freq_seek(struct file
*file
, void *priv
,
1690 const struct v4l2_hw_freq_seek
*seek
)
1692 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1693 struct wl1273_core
*core
= radio
->core
;
1696 dev_dbg(radio
->dev
, "%s\n", __func__
);
1698 if (seek
->tuner
!= 0 || seek
->type
!= V4L2_TUNER_RADIO
)
1701 if (file
->f_flags
& O_NONBLOCK
)
1702 return -EWOULDBLOCK
;
1704 if (mutex_lock_interruptible(&core
->lock
))
1707 r
= wl1273_fm_set_mode(radio
, WL1273_MODE_RX
);
1711 r
= wl1273_fm_tx_set_spacing(radio
, seek
->spacing
);
1713 dev_warn(radio
->dev
, "HW seek failed: %d\n", r
);
1715 r
= wl1273_fm_set_seek(radio
, seek
->wrap_around
, seek
->seek_upward
,
1716 WL1273_DEFAULT_SEEK_LEVEL
);
1718 dev_warn(radio
->dev
, "HW seek failed: %d\n", r
);
1721 mutex_unlock(&core
->lock
);
1725 static int wl1273_fm_vidioc_s_modulator(struct file
*file
, void *priv
,
1726 const struct v4l2_modulator
*modulator
)
1728 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1729 struct wl1273_core
*core
= radio
->core
;
1732 dev_dbg(radio
->dev
, "%s\n", __func__
);
1734 if (modulator
->index
> 0)
1737 if (mutex_lock_interruptible(&core
->lock
))
1740 r
= wl1273_fm_set_mode(radio
, WL1273_MODE_TX
);
1744 if (modulator
->txsubchans
& V4L2_TUNER_SUB_RDS
)
1745 r
= wl1273_fm_set_rds(radio
, WL1273_RDS_ON
);
1747 r
= wl1273_fm_set_rds(radio
, WL1273_RDS_OFF
);
1749 if (modulator
->txsubchans
& V4L2_TUNER_SUB_MONO
)
1750 r
= core
->write(core
, WL1273_MONO_SET
, WL1273_TX_MONO
);
1752 r
= core
->write(core
, WL1273_MONO_SET
,
1755 dev_warn(radio
->dev
, WL1273_FM_DRIVER_NAME
1756 "MONO_SET fails: %d\n", r
);
1758 mutex_unlock(&core
->lock
);
1763 static int wl1273_fm_vidioc_g_modulator(struct file
*file
, void *priv
,
1764 struct v4l2_modulator
*modulator
)
1766 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1767 struct wl1273_core
*core
= radio
->core
;
1771 dev_dbg(radio
->dev
, "%s\n", __func__
);
1773 strlcpy(modulator
->name
, WL1273_FM_DRIVER_NAME
,
1774 sizeof(modulator
->name
));
1776 modulator
->rangelow
= WL1273_FREQ(WL1273_BAND_JAPAN_LOW
);
1777 modulator
->rangehigh
= WL1273_FREQ(WL1273_BAND_OTHER_HIGH
);
1779 modulator
->capability
= V4L2_TUNER_CAP_LOW
| V4L2_TUNER_CAP_RDS
|
1780 V4L2_TUNER_CAP_STEREO
| V4L2_TUNER_CAP_RDS_BLOCK_IO
;
1782 if (core
->mode
!= WL1273_MODE_TX
)
1785 if (mutex_lock_interruptible(&core
->lock
))
1788 r
= core
->read(core
, WL1273_MONO_SET
, &val
);
1792 if (val
== WL1273_TX_STEREO
)
1793 modulator
->txsubchans
= V4L2_TUNER_SUB_STEREO
;
1795 modulator
->txsubchans
= V4L2_TUNER_SUB_MONO
;
1798 modulator
->txsubchans
|= V4L2_TUNER_SUB_RDS
;
1800 mutex_unlock(&core
->lock
);
1805 static int wl1273_fm_vidioc_log_status(struct file
*file
, void *priv
)
1807 struct wl1273_device
*radio
= video_get_drvdata(video_devdata(file
));
1808 struct wl1273_core
*core
= radio
->core
;
1809 struct device
*dev
= radio
->dev
;
1813 dev_info(dev
, DRIVER_DESC
);
1815 if (core
->mode
== WL1273_MODE_OFF
) {
1816 dev_info(dev
, "Mode: Off\n");
1820 if (core
->mode
== WL1273_MODE_SUSPENDED
) {
1821 dev_info(dev
, "Mode: Suspended\n");
1825 r
= core
->read(core
, WL1273_ASIC_ID_GET
, &val
);
1827 dev_err(dev
, "%s: Get ASIC_ID fails.\n", __func__
);
1829 dev_info(dev
, "ASIC_ID: 0x%04x\n", val
);
1831 r
= core
->read(core
, WL1273_ASIC_VER_GET
, &val
);
1833 dev_err(dev
, "%s: Get ASIC_VER fails.\n", __func__
);
1835 dev_info(dev
, "ASIC Version: 0x%04x\n", val
);
1837 r
= core
->read(core
, WL1273_FIRM_VER_GET
, &val
);
1839 dev_err(dev
, "%s: Get FIRM_VER fails.\n", __func__
);
1841 dev_info(dev
, "FW version: %d(0x%04x)\n", val
, val
);
1843 r
= core
->read(core
, WL1273_BAND_SET
, &val
);
1845 dev_err(dev
, "%s: Get BAND fails.\n", __func__
);
1847 dev_info(dev
, "BAND: %d\n", val
);
1849 if (core
->mode
== WL1273_MODE_TX
) {
1850 r
= core
->read(core
, WL1273_PUPD_SET
, &val
);
1852 dev_err(dev
, "%s: Get PUPD fails.\n", __func__
);
1854 dev_info(dev
, "PUPD: 0x%04x\n", val
);
1856 r
= core
->read(core
, WL1273_CHANL_SET
, &val
);
1858 dev_err(dev
, "%s: Get CHANL fails.\n", __func__
);
1860 dev_info(dev
, "Tx frequency: %dkHz\n", val
*10);
1861 } else if (core
->mode
== WL1273_MODE_RX
) {
1862 int bf
= radio
->rangelow
;
1864 r
= core
->read(core
, WL1273_FREQ_SET
, &val
);
1866 dev_err(dev
, "%s: Get FREQ fails.\n", __func__
);
1868 dev_info(dev
, "RX Frequency: %dkHz\n", bf
+ val
*50);
1870 r
= core
->read(core
, WL1273_MOST_MODE_SET
, &val
);
1872 dev_err(dev
, "%s: Get MOST_MODE fails.\n",
1875 dev_info(dev
, "MOST_MODE: Stereo according to blend\n");
1877 dev_info(dev
, "MOST_MODE: Force mono output\n");
1879 dev_info(dev
, "MOST_MODE: Unexpected value: %d\n", val
);
1881 r
= core
->read(core
, WL1273_MOST_BLEND_SET
, &val
);
1883 dev_err(dev
, "%s: Get MOST_BLEND fails.\n", __func__
);
1886 "MOST_BLEND: Switched blend & hysteresis.\n");
1888 dev_info(dev
, "MOST_BLEND: Soft blend.\n");
1890 dev_info(dev
, "MOST_BLEND: Unexpected val: %d\n", val
);
1892 r
= core
->read(core
, WL1273_STEREO_GET
, &val
);
1894 dev_err(dev
, "%s: Get STEREO fails.\n", __func__
);
1896 dev_info(dev
, "STEREO: Not detected\n");
1898 dev_info(dev
, "STEREO: Detected\n");
1900 dev_info(dev
, "STEREO: Unexpected value: %d\n", val
);
1902 r
= core
->read(core
, WL1273_RSSI_LVL_GET
, &val
);
1904 dev_err(dev
, "%s: Get RSSI_LVL fails.\n", __func__
);
1906 dev_info(dev
, "RX signal strength: %d\n", (s16
) val
);
1908 r
= core
->read(core
, WL1273_POWER_SET
, &val
);
1910 dev_err(dev
, "%s: Get POWER fails.\n", __func__
);
1912 dev_info(dev
, "POWER: 0x%04x\n", val
);
1914 r
= core
->read(core
, WL1273_INT_MASK_SET
, &val
);
1916 dev_err(dev
, "%s: Get INT_MASK fails.\n", __func__
);
1918 dev_info(dev
, "INT_MASK: 0x%04x\n", val
);
1920 r
= core
->read(core
, WL1273_RDS_SYNC_GET
, &val
);
1922 dev_err(dev
, "%s: Get RDS_SYNC fails.\n",
1925 dev_info(dev
, "RDS_SYNC: Not synchronized\n");
1928 dev_info(dev
, "RDS_SYNC: Synchronized\n");
1930 dev_info(dev
, "RDS_SYNC: Unexpected value: %d\n", val
);
1932 r
= core
->read(core
, WL1273_I2S_MODE_CONFIG_SET
, &val
);
1934 dev_err(dev
, "%s: Get I2S_MODE_CONFIG fails.\n",
1937 dev_info(dev
, "I2S_MODE_CONFIG: 0x%04x\n", val
);
1939 r
= core
->read(core
, WL1273_VOLUME_SET
, &val
);
1941 dev_err(dev
, "%s: Get VOLUME fails.\n", __func__
);
1943 dev_info(dev
, "VOLUME: 0x%04x\n", val
);
1949 static void wl1273_vdev_release(struct video_device
*dev
)
1953 static const struct v4l2_ctrl_ops wl1273_ctrl_ops
= {
1954 .s_ctrl
= wl1273_fm_vidioc_s_ctrl
,
1955 .g_volatile_ctrl
= wl1273_fm_g_volatile_ctrl
,
1958 static const struct v4l2_ioctl_ops wl1273_ioctl_ops
= {
1959 .vidioc_querycap
= wl1273_fm_vidioc_querycap
,
1960 .vidioc_g_input
= wl1273_fm_vidioc_g_input
,
1961 .vidioc_s_input
= wl1273_fm_vidioc_s_input
,
1962 .vidioc_g_audio
= wl1273_fm_vidioc_g_audio
,
1963 .vidioc_s_audio
= wl1273_fm_vidioc_s_audio
,
1964 .vidioc_g_tuner
= wl1273_fm_vidioc_g_tuner
,
1965 .vidioc_s_tuner
= wl1273_fm_vidioc_s_tuner
,
1966 .vidioc_g_frequency
= wl1273_fm_vidioc_g_frequency
,
1967 .vidioc_s_frequency
= wl1273_fm_vidioc_s_frequency
,
1968 .vidioc_s_hw_freq_seek
= wl1273_fm_vidioc_s_hw_freq_seek
,
1969 .vidioc_g_modulator
= wl1273_fm_vidioc_g_modulator
,
1970 .vidioc_s_modulator
= wl1273_fm_vidioc_s_modulator
,
1971 .vidioc_log_status
= wl1273_fm_vidioc_log_status
,
1974 static struct video_device wl1273_viddev_template
= {
1975 .fops
= &wl1273_fops
,
1976 .ioctl_ops
= &wl1273_ioctl_ops
,
1977 .name
= WL1273_FM_DRIVER_NAME
,
1978 .release
= wl1273_vdev_release
,
1979 .vfl_dir
= VFL_DIR_TX
,
1982 static int wl1273_fm_radio_remove(struct platform_device
*pdev
)
1984 struct wl1273_device
*radio
= platform_get_drvdata(pdev
);
1985 struct wl1273_core
*core
= radio
->core
;
1987 dev_info(&pdev
->dev
, "%s.\n", __func__
);
1989 free_irq(core
->client
->irq
, radio
);
1990 core
->pdata
->free_resources();
1992 v4l2_ctrl_handler_free(&radio
->ctrl_handler
);
1993 video_unregister_device(&radio
->videodev
);
1994 v4l2_device_unregister(&radio
->v4l2dev
);
1999 static int wl1273_fm_radio_probe(struct platform_device
*pdev
)
2001 struct wl1273_core
**core
= pdev
->dev
.platform_data
;
2002 struct wl1273_device
*radio
;
2003 struct v4l2_ctrl
*ctrl
;
2006 pr_debug("%s\n", __func__
);
2009 dev_err(&pdev
->dev
, "No platform data.\n");
2014 radio
= devm_kzalloc(&pdev
->dev
, sizeof(*radio
), GFP_KERNEL
);
2020 /* RDS buffer allocation */
2021 radio
->buf_size
= rds_buf
* RDS_BLOCK_SIZE
;
2022 radio
->buffer
= devm_kzalloc(&pdev
->dev
, radio
->buf_size
, GFP_KERNEL
);
2023 if (!radio
->buffer
) {
2024 pr_err("Cannot allocate memory for RDS buffer.\n");
2029 radio
->core
= *core
;
2030 radio
->irq_flags
= WL1273_IRQ_MASK
;
2031 radio
->dev
= &radio
->core
->client
->dev
;
2032 radio
->rds_on
= false;
2033 radio
->core
->mode
= WL1273_MODE_OFF
;
2034 radio
->tx_power
= 118;
2035 radio
->core
->audio_mode
= WL1273_AUDIO_ANALOG
;
2036 radio
->band
= WL1273_BAND_OTHER
;
2037 radio
->core
->i2s_mode
= WL1273_I2S_DEF_MODE
;
2038 radio
->core
->channel_number
= 2;
2039 radio
->core
->volume
= WL1273_DEFAULT_VOLUME
;
2040 radio
->rx_frequency
= WL1273_BAND_OTHER_LOW
;
2041 radio
->tx_frequency
= WL1273_BAND_OTHER_HIGH
;
2042 radio
->rangelow
= WL1273_BAND_OTHER_LOW
;
2043 radio
->rangehigh
= WL1273_BAND_OTHER_HIGH
;
2044 radio
->stereo
= true;
2045 radio
->bus_type
= "I2C";
2047 if (radio
->core
->pdata
->request_resources
) {
2048 r
= radio
->core
->pdata
->request_resources(radio
->core
->client
);
2050 dev_err(radio
->dev
, WL1273_FM_DRIVER_NAME
2051 ": Cannot get platform data\n");
2055 dev_dbg(radio
->dev
, "irq: %d\n", radio
->core
->client
->irq
);
2057 r
= request_threaded_irq(radio
->core
->client
->irq
, NULL
,
2058 wl1273_fm_irq_thread_handler
,
2059 IRQF_ONESHOT
| IRQF_TRIGGER_FALLING
,
2060 "wl1273-fm", radio
);
2062 dev_err(radio
->dev
, WL1273_FM_DRIVER_NAME
2063 ": Unable to register IRQ handler: %d\n", r
);
2064 goto err_request_irq
;
2067 dev_err(radio
->dev
, WL1273_FM_DRIVER_NAME
": Core WL1273 IRQ not configured");
2072 init_completion(&radio
->busy
);
2073 init_waitqueue_head(&radio
->read_queue
);
2075 radio
->write_buf
= devm_kzalloc(&pdev
->dev
, 256, GFP_KERNEL
);
2076 if (!radio
->write_buf
) {
2081 radio
->dev
= &pdev
->dev
;
2082 radio
->v4l2dev
.ctrl_handler
= &radio
->ctrl_handler
;
2083 radio
->rds_users
= 0;
2085 r
= v4l2_device_register(&pdev
->dev
, &radio
->v4l2dev
);
2087 dev_err(&pdev
->dev
, "Cannot register v4l2_device.\n");
2091 /* V4L2 configuration */
2092 radio
->videodev
= wl1273_viddev_template
;
2094 radio
->videodev
.v4l2_dev
= &radio
->v4l2dev
;
2096 v4l2_ctrl_handler_init(&radio
->ctrl_handler
, 6);
2098 /* add in ascending ID order */
2099 v4l2_ctrl_new_std(&radio
->ctrl_handler
, &wl1273_ctrl_ops
,
2100 V4L2_CID_AUDIO_VOLUME
, 0, WL1273_MAX_VOLUME
, 1,
2101 WL1273_DEFAULT_VOLUME
);
2103 v4l2_ctrl_new_std(&radio
->ctrl_handler
, &wl1273_ctrl_ops
,
2104 V4L2_CID_AUDIO_MUTE
, 0, 1, 1, 1);
2106 v4l2_ctrl_new_std_menu(&radio
->ctrl_handler
, &wl1273_ctrl_ops
,
2107 V4L2_CID_TUNE_PREEMPHASIS
,
2108 V4L2_PREEMPHASIS_75_uS
, 0x03,
2109 V4L2_PREEMPHASIS_50_uS
);
2111 v4l2_ctrl_new_std(&radio
->ctrl_handler
, &wl1273_ctrl_ops
,
2112 V4L2_CID_TUNE_POWER_LEVEL
, 91, 122, 1, 118);
2114 ctrl
= v4l2_ctrl_new_std(&radio
->ctrl_handler
, &wl1273_ctrl_ops
,
2115 V4L2_CID_TUNE_ANTENNA_CAPACITOR
,
2118 ctrl
->flags
|= V4L2_CTRL_FLAG_VOLATILE
;
2120 if (radio
->ctrl_handler
.error
) {
2121 r
= radio
->ctrl_handler
.error
;
2122 dev_err(&pdev
->dev
, "Ctrl handler error: %d\n", r
);
2123 goto handler_init_err
;
2126 video_set_drvdata(&radio
->videodev
, radio
);
2127 platform_set_drvdata(pdev
, radio
);
2129 /* register video device */
2130 r
= video_register_device(&radio
->videodev
, VFL_TYPE_RADIO
, radio_nr
);
2132 dev_err(&pdev
->dev
, WL1273_FM_DRIVER_NAME
2133 ": Could not register video device\n");
2134 goto handler_init_err
;
2140 v4l2_ctrl_handler_free(&radio
->ctrl_handler
);
2141 v4l2_device_unregister(&radio
->v4l2dev
);
2143 free_irq(radio
->core
->client
->irq
, radio
);
2145 radio
->core
->pdata
->free_resources();
2150 static struct platform_driver wl1273_fm_radio_driver
= {
2151 .probe
= wl1273_fm_radio_probe
,
2152 .remove
= wl1273_fm_radio_remove
,
2154 .name
= "wl1273_fm_radio",
2158 module_platform_driver(wl1273_fm_radio_driver
);
2160 MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>");
2161 MODULE_DESCRIPTION(DRIVER_DESC
);
2162 MODULE_LICENSE("GPL");
2163 MODULE_ALIAS("platform:wl1273_fm_radio");