GNU Linux-libre 5.10.215-gnu1
[releases.git] / drivers / media / radio / wl128x / fmdrv_rx.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  FM Driver for Connectivity chip of Texas Instruments.
4  *  This sub-module of FM driver implements FM RX functionality.
5  *
6  *  Copyright (C) 2011 Texas Instruments
7  *  Author: Raja Mani <raja_mani@ti.com>
8  *  Author: Manjunatha Halli <manjunatha_halli@ti.com>
9  */
10
11 #include "fmdrv.h"
12 #include "fmdrv_common.h"
13 #include "fmdrv_rx.h"
14
15 void fm_rx_reset_rds_cache(struct fmdev *fmdev)
16 {
17         fmdev->rx.rds.flag = FM_RDS_DISABLE;
18         fmdev->rx.rds.last_blk_idx = 0;
19         fmdev->rx.rds.wr_idx = 0;
20         fmdev->rx.rds.rd_idx = 0;
21
22         if (fmdev->rx.af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
23                 fmdev->irq_info.mask |= FM_LEV_EVENT;
24 }
25
26 void fm_rx_reset_station_info(struct fmdev *fmdev)
27 {
28         fmdev->rx.stat_info.picode = FM_NO_PI_CODE;
29         fmdev->rx.stat_info.afcache_size = 0;
30         fmdev->rx.stat_info.af_list_max = 0;
31 }
32
33 int fm_rx_set_freq(struct fmdev *fmdev, u32 freq)
34 {
35         unsigned long timeleft;
36         u16 payload, curr_frq, intr_flag;
37         u32 curr_frq_in_khz;
38         u32 resp_len;
39         int ret;
40
41         if (freq < fmdev->rx.region.bot_freq || freq > fmdev->rx.region.top_freq) {
42                 fmerr("Invalid frequency %d\n", freq);
43                 return -EINVAL;
44         }
45
46         /* Set audio enable */
47         payload = FM_RX_AUDIO_ENABLE_I2S_AND_ANALOG;
48
49         ret = fmc_send_cmd(fmdev, AUDIO_ENABLE_SET, REG_WR, &payload,
50                         sizeof(payload), NULL, NULL);
51         if (ret < 0)
52                 return ret;
53
54         /* Set hilo to automatic selection */
55         payload = FM_RX_IFFREQ_HILO_AUTOMATIC;
56         ret = fmc_send_cmd(fmdev, HILO_SET, REG_WR, &payload,
57                         sizeof(payload), NULL, NULL);
58         if (ret < 0)
59                 return ret;
60
61         /* Calculate frequency index and set*/
62         payload = (freq - fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
63
64         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_WR, &payload,
65                         sizeof(payload), NULL, NULL);
66         if (ret < 0)
67                 return ret;
68
69         /* Read flags - just to clear any pending interrupts if we had */
70         ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2, NULL, NULL);
71         if (ret < 0)
72                 return ret;
73
74         /* Enable FR, BL interrupts */
75         intr_flag = fmdev->irq_info.mask;
76         fmdev->irq_info.mask = (FM_FR_EVENT | FM_BL_EVENT);
77         payload = fmdev->irq_info.mask;
78         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
79                         sizeof(payload), NULL, NULL);
80         if (ret < 0)
81                 return ret;
82
83         /* Start tune */
84         payload = FM_TUNER_PRESET_MODE;
85         ret = fmc_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
86                         sizeof(payload), NULL, NULL);
87         if (ret < 0)
88                 goto exit;
89
90         /* Wait for tune ended interrupt */
91         init_completion(&fmdev->maintask_comp);
92         timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
93                         FM_DRV_TX_TIMEOUT);
94         if (!timeleft) {
95                 fmerr("Timeout(%d sec),didn't get tune ended int\n",
96                            jiffies_to_msecs(FM_DRV_TX_TIMEOUT) / 1000);
97                 ret = -ETIMEDOUT;
98                 goto exit;
99         }
100
101         /* Read freq back to confirm */
102         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, 2, &curr_frq, &resp_len);
103         if (ret < 0)
104                 goto exit;
105
106         curr_frq = be16_to_cpu((__force __be16)curr_frq);
107         curr_frq_in_khz = (fmdev->rx.region.bot_freq + ((u32)curr_frq * FM_FREQ_MUL));
108
109         if (curr_frq_in_khz != freq) {
110                 pr_info("Frequency is set to (%d) but requested freq is (%d)\n",
111                         curr_frq_in_khz, freq);
112         }
113
114         /* Update local cache  */
115         fmdev->rx.freq = curr_frq_in_khz;
116 exit:
117         /* Re-enable default FM interrupts */
118         fmdev->irq_info.mask = intr_flag;
119         payload = fmdev->irq_info.mask;
120         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
121                         sizeof(payload), NULL, NULL);
122         if (ret < 0)
123                 return ret;
124
125         /* Reset RDS cache and current station pointers */
126         fm_rx_reset_rds_cache(fmdev);
127         fm_rx_reset_station_info(fmdev);
128
129         return ret;
130 }
131
132 static int fm_rx_set_channel_spacing(struct fmdev *fmdev, u32 spacing)
133 {
134         u16 payload;
135         int ret;
136
137         if (spacing > 0 && spacing <= 50000)
138                 spacing = FM_CHANNEL_SPACING_50KHZ;
139         else if (spacing > 50000 && spacing <= 100000)
140                 spacing = FM_CHANNEL_SPACING_100KHZ;
141         else
142                 spacing = FM_CHANNEL_SPACING_200KHZ;
143
144         /* set channel spacing */
145         payload = spacing;
146         ret = fmc_send_cmd(fmdev, CHANL_BW_SET, REG_WR, &payload,
147                         sizeof(payload), NULL, NULL);
148         if (ret < 0)
149                 return ret;
150
151         fmdev->rx.region.chanl_space = spacing * FM_FREQ_MUL;
152
153         return ret;
154 }
155
156 int fm_rx_seek(struct fmdev *fmdev, u32 seek_upward,
157                 u32 wrap_around, u32 spacing)
158 {
159         u32 resp_len;
160         u16 curr_frq, next_frq, last_frq;
161         u16 payload, int_reason, intr_flag;
162         u16 offset, space_idx;
163         unsigned long timeleft;
164         int ret;
165
166         /* Set channel spacing */
167         ret = fm_rx_set_channel_spacing(fmdev, spacing);
168         if (ret < 0) {
169                 fmerr("Failed to set channel spacing\n");
170                 return ret;
171         }
172
173         /* Read the current frequency from chip */
174         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL,
175                         sizeof(curr_frq), &curr_frq, &resp_len);
176         if (ret < 0)
177                 return ret;
178
179         curr_frq = be16_to_cpu((__force __be16)curr_frq);
180         last_frq = (fmdev->rx.region.top_freq - fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
181
182         /* Check the offset in order to be aligned to the channel spacing*/
183         space_idx = fmdev->rx.region.chanl_space / FM_FREQ_MUL;
184         offset = curr_frq % space_idx;
185
186         next_frq = seek_upward ? curr_frq + space_idx /* Seek Up */ :
187                                 curr_frq - space_idx /* Seek Down */ ;
188
189         /*
190          * Add or subtract offset in order to stay aligned to the channel
191          * spacing.
192          */
193         if ((short)next_frq < 0)
194                 next_frq = last_frq - offset;
195         else if (next_frq > last_frq)
196                 next_frq = 0 + offset;
197
198 again:
199         /* Set calculated next frequency to perform seek */
200         payload = next_frq;
201         ret = fmc_send_cmd(fmdev, FREQ_SET, REG_WR, &payload,
202                         sizeof(payload), NULL, NULL);
203         if (ret < 0)
204                 return ret;
205
206         /* Set search direction (0:Seek Down, 1:Seek Up) */
207         payload = (seek_upward ? FM_SEARCH_DIRECTION_UP : FM_SEARCH_DIRECTION_DOWN);
208         ret = fmc_send_cmd(fmdev, SEARCH_DIR_SET, REG_WR, &payload,
209                         sizeof(payload), NULL, NULL);
210         if (ret < 0)
211                 return ret;
212
213         /* Read flags - just to clear any pending interrupts if we had */
214         ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2, NULL, NULL);
215         if (ret < 0)
216                 return ret;
217
218         /* Enable FR, BL interrupts */
219         intr_flag = fmdev->irq_info.mask;
220         fmdev->irq_info.mask = (FM_FR_EVENT | FM_BL_EVENT);
221         payload = fmdev->irq_info.mask;
222         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
223                         sizeof(payload), NULL, NULL);
224         if (ret < 0)
225                 return ret;
226
227         /* Start seek */
228         payload = FM_TUNER_AUTONOMOUS_SEARCH_MODE;
229         ret = fmc_send_cmd(fmdev, TUNER_MODE_SET, REG_WR, &payload,
230                         sizeof(payload), NULL, NULL);
231         if (ret < 0)
232                 return ret;
233
234         /* Wait for tune ended/band limit reached interrupt */
235         init_completion(&fmdev->maintask_comp);
236         timeleft = wait_for_completion_timeout(&fmdev->maintask_comp,
237                         FM_DRV_RX_SEEK_TIMEOUT);
238         if (!timeleft) {
239                 fmerr("Timeout(%d sec),didn't get tune ended int\n",
240                            jiffies_to_msecs(FM_DRV_RX_SEEK_TIMEOUT) / 1000);
241                 return -ENODATA;
242         }
243
244         int_reason = fmdev->irq_info.flag & (FM_TUNE_COMPLETE | FM_BAND_LIMIT);
245
246         /* Re-enable default FM interrupts */
247         fmdev->irq_info.mask = intr_flag;
248         payload = fmdev->irq_info.mask;
249         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
250                         sizeof(payload), NULL, NULL);
251         if (ret < 0)
252                 return ret;
253
254         if (int_reason & FM_BL_EVENT) {
255                 if (wrap_around == 0) {
256                         fmdev->rx.freq = seek_upward ?
257                                 fmdev->rx.region.top_freq :
258                                 fmdev->rx.region.bot_freq;
259                 } else {
260                         fmdev->rx.freq = seek_upward ?
261                                 fmdev->rx.region.bot_freq :
262                                 fmdev->rx.region.top_freq;
263                         /* Calculate frequency index to write */
264                         next_frq = (fmdev->rx.freq -
265                                         fmdev->rx.region.bot_freq) / FM_FREQ_MUL;
266                         goto again;
267                 }
268         } else {
269                 /* Read freq to know where operation tune operation stopped */
270                 ret = fmc_send_cmd(fmdev, FREQ_SET, REG_RD, NULL, 2,
271                                 &curr_frq, &resp_len);
272                 if (ret < 0)
273                         return ret;
274
275                 curr_frq = be16_to_cpu((__force __be16)curr_frq);
276                 fmdev->rx.freq = (fmdev->rx.region.bot_freq +
277                                 ((u32)curr_frq * FM_FREQ_MUL));
278
279         }
280         /* Reset RDS cache and current station pointers */
281         fm_rx_reset_rds_cache(fmdev);
282         fm_rx_reset_station_info(fmdev);
283
284         return ret;
285 }
286
287 int fm_rx_set_volume(struct fmdev *fmdev, u16 vol_to_set)
288 {
289         u16 payload;
290         int ret;
291
292         if (fmdev->curr_fmmode != FM_MODE_RX)
293                 return -EPERM;
294
295         if (vol_to_set > FM_RX_VOLUME_MAX) {
296                 fmerr("Volume is not within(%d-%d) range\n",
297                            FM_RX_VOLUME_MIN, FM_RX_VOLUME_MAX);
298                 return -EINVAL;
299         }
300         vol_to_set *= FM_RX_VOLUME_GAIN_STEP;
301
302         payload = vol_to_set;
303         ret = fmc_send_cmd(fmdev, VOLUME_SET, REG_WR, &payload,
304                         sizeof(payload), NULL, NULL);
305         if (ret < 0)
306                 return ret;
307
308         fmdev->rx.volume = vol_to_set;
309         return ret;
310 }
311
312 /* Get volume */
313 int fm_rx_get_volume(struct fmdev *fmdev, u16 *curr_vol)
314 {
315         if (fmdev->curr_fmmode != FM_MODE_RX)
316                 return -EPERM;
317
318         if (curr_vol == NULL) {
319                 fmerr("Invalid memory\n");
320                 return -ENOMEM;
321         }
322
323         *curr_vol = fmdev->rx.volume / FM_RX_VOLUME_GAIN_STEP;
324
325         return 0;
326 }
327
328 /* To get current band's bottom and top frequency */
329 int fm_rx_get_band_freq_range(struct fmdev *fmdev, u32 *bot_freq, u32 *top_freq)
330 {
331         if (bot_freq != NULL)
332                 *bot_freq = fmdev->rx.region.bot_freq;
333
334         if (top_freq != NULL)
335                 *top_freq = fmdev->rx.region.top_freq;
336
337         return 0;
338 }
339
340 /* Returns current band index (0-Europe/US; 1-Japan) */
341 void fm_rx_get_region(struct fmdev *fmdev, u8 *region)
342 {
343         *region = fmdev->rx.region.fm_band;
344 }
345
346 /* Sets band (0-Europe/US; 1-Japan) */
347 int fm_rx_set_region(struct fmdev *fmdev, u8 region_to_set)
348 {
349         u16 payload;
350         u32 new_frq = 0;
351         int ret;
352
353         if (region_to_set != FM_BAND_EUROPE_US &&
354             region_to_set != FM_BAND_JAPAN) {
355                 fmerr("Invalid band\n");
356                 return -EINVAL;
357         }
358
359         if (fmdev->rx.region.fm_band == region_to_set) {
360                 fmerr("Requested band is already configured\n");
361                 return 0;
362         }
363
364         /* Send cmd to set the band  */
365         payload = (u16)region_to_set;
366         ret = fmc_send_cmd(fmdev, BAND_SET, REG_WR, &payload,
367                         sizeof(payload), NULL, NULL);
368         if (ret < 0)
369                 return ret;
370
371         fmc_update_region_info(fmdev, region_to_set);
372
373         /* Check whether current RX frequency is within band boundary */
374         if (fmdev->rx.freq < fmdev->rx.region.bot_freq)
375                 new_frq = fmdev->rx.region.bot_freq;
376         else if (fmdev->rx.freq > fmdev->rx.region.top_freq)
377                 new_frq = fmdev->rx.region.top_freq;
378
379         if (new_frq) {
380                 fmdbg("Current freq is not within band limit boundary,switching to %d KHz\n",
381                       new_frq);
382                  /* Current RX frequency is not in range. So, update it */
383                 ret = fm_rx_set_freq(fmdev, new_frq);
384         }
385
386         return ret;
387 }
388
389 /* Reads current mute mode (Mute Off/On/Attenuate)*/
390 int fm_rx_get_mute_mode(struct fmdev *fmdev, u8 *curr_mute_mode)
391 {
392         if (fmdev->curr_fmmode != FM_MODE_RX)
393                 return -EPERM;
394
395         if (curr_mute_mode == NULL) {
396                 fmerr("Invalid memory\n");
397                 return -ENOMEM;
398         }
399
400         *curr_mute_mode = fmdev->rx.mute_mode;
401
402         return 0;
403 }
404
405 static int fm_config_rx_mute_reg(struct fmdev *fmdev)
406 {
407         u16 payload, muteval;
408         int ret;
409
410         muteval = 0;
411         switch (fmdev->rx.mute_mode) {
412         case FM_MUTE_ON:
413                 muteval = FM_RX_AC_MUTE_MODE;
414                 break;
415
416         case FM_MUTE_OFF:
417                 muteval = FM_RX_UNMUTE_MODE;
418                 break;
419
420         case FM_MUTE_ATTENUATE:
421                 muteval = FM_RX_SOFT_MUTE_FORCE_MODE;
422                 break;
423         }
424         if (fmdev->rx.rf_depend_mute == FM_RX_RF_DEPENDENT_MUTE_ON)
425                 muteval |= FM_RX_RF_DEP_MODE;
426         else
427                 muteval &= ~FM_RX_RF_DEP_MODE;
428
429         payload = muteval;
430         ret = fmc_send_cmd(fmdev, MUTE_STATUS_SET, REG_WR, &payload,
431                         sizeof(payload), NULL, NULL);
432         if (ret < 0)
433                 return ret;
434
435         return 0;
436 }
437
438 /* Configures mute mode (Mute Off/On/Attenuate) */
439 int fm_rx_set_mute_mode(struct fmdev *fmdev, u8 mute_mode_toset)
440 {
441         u8 org_state;
442         int ret;
443
444         if (fmdev->rx.mute_mode == mute_mode_toset)
445                 return 0;
446
447         org_state = fmdev->rx.mute_mode;
448         fmdev->rx.mute_mode = mute_mode_toset;
449
450         ret = fm_config_rx_mute_reg(fmdev);
451         if (ret < 0) {
452                 fmdev->rx.mute_mode = org_state;
453                 return ret;
454         }
455
456         return 0;
457 }
458
459 /* Gets RF dependent soft mute mode enable/disable status */
460 int fm_rx_get_rfdepend_softmute(struct fmdev *fmdev, u8 *curr_mute_mode)
461 {
462         if (fmdev->curr_fmmode != FM_MODE_RX)
463                 return -EPERM;
464
465         if (curr_mute_mode == NULL) {
466                 fmerr("Invalid memory\n");
467                 return -ENOMEM;
468         }
469
470         *curr_mute_mode = fmdev->rx.rf_depend_mute;
471
472         return 0;
473 }
474
475 /* Sets RF dependent soft mute mode */
476 int fm_rx_set_rfdepend_softmute(struct fmdev *fmdev, u8 rfdepend_mute)
477 {
478         u8 org_state;
479         int ret;
480
481         if (fmdev->curr_fmmode != FM_MODE_RX)
482                 return -EPERM;
483
484         if (rfdepend_mute != FM_RX_RF_DEPENDENT_MUTE_ON &&
485             rfdepend_mute != FM_RX_RF_DEPENDENT_MUTE_OFF) {
486                 fmerr("Invalid RF dependent soft mute\n");
487                 return -EINVAL;
488         }
489         if (fmdev->rx.rf_depend_mute == rfdepend_mute)
490                 return 0;
491
492         org_state = fmdev->rx.rf_depend_mute;
493         fmdev->rx.rf_depend_mute = rfdepend_mute;
494
495         ret = fm_config_rx_mute_reg(fmdev);
496         if (ret < 0) {
497                 fmdev->rx.rf_depend_mute = org_state;
498                 return ret;
499         }
500
501         return 0;
502 }
503
504 /* Returns the signal strength level of current channel */
505 int fm_rx_get_rssi_level(struct fmdev *fmdev, u16 *rssilvl)
506 {
507         __be16 curr_rssi_lel;
508         u32 resp_len;
509         int ret;
510
511         if (rssilvl == NULL) {
512                 fmerr("Invalid memory\n");
513                 return -ENOMEM;
514         }
515         /* Read current RSSI level */
516         ret = fmc_send_cmd(fmdev, RSSI_LVL_GET, REG_RD, NULL, 2,
517                         &curr_rssi_lel, &resp_len);
518         if (ret < 0)
519                 return ret;
520
521         *rssilvl = be16_to_cpu(curr_rssi_lel);
522
523         return 0;
524 }
525
526 /*
527  * Sets the signal strength level that once reached
528  * will stop the auto search process
529  */
530 int fm_rx_set_rssi_threshold(struct fmdev *fmdev, short rssi_lvl_toset)
531 {
532         u16 payload;
533         int ret;
534
535         if (rssi_lvl_toset < FM_RX_RSSI_THRESHOLD_MIN ||
536                         rssi_lvl_toset > FM_RX_RSSI_THRESHOLD_MAX) {
537                 fmerr("Invalid RSSI threshold level\n");
538                 return -EINVAL;
539         }
540         payload = (u16)rssi_lvl_toset;
541         ret = fmc_send_cmd(fmdev, SEARCH_LVL_SET, REG_WR, &payload,
542                         sizeof(payload), NULL, NULL);
543         if (ret < 0)
544                 return ret;
545
546         fmdev->rx.rssi_threshold = rssi_lvl_toset;
547
548         return 0;
549 }
550
551 /* Returns current RX RSSI threshold value */
552 int fm_rx_get_rssi_threshold(struct fmdev *fmdev, short *curr_rssi_lvl)
553 {
554         if (fmdev->curr_fmmode != FM_MODE_RX)
555                 return -EPERM;
556
557         if (curr_rssi_lvl == NULL) {
558                 fmerr("Invalid memory\n");
559                 return -ENOMEM;
560         }
561
562         *curr_rssi_lvl = fmdev->rx.rssi_threshold;
563
564         return 0;
565 }
566
567 /* Sets RX stereo/mono modes */
568 int fm_rx_set_stereo_mono(struct fmdev *fmdev, u16 mode)
569 {
570         u16 payload;
571         int ret;
572
573         if (mode != FM_STEREO_MODE && mode != FM_MONO_MODE) {
574                 fmerr("Invalid mode\n");
575                 return -EINVAL;
576         }
577
578         /* Set stereo/mono mode */
579         payload = (u16)mode;
580         ret = fmc_send_cmd(fmdev, MOST_MODE_SET, REG_WR, &payload,
581                         sizeof(payload), NULL, NULL);
582         if (ret < 0)
583                 return ret;
584
585         /* Set stereo blending mode */
586         payload = FM_STEREO_SOFT_BLEND;
587         ret = fmc_send_cmd(fmdev, MOST_BLEND_SET, REG_WR, &payload,
588                         sizeof(payload), NULL, NULL);
589         if (ret < 0)
590                 return ret;
591
592         return 0;
593 }
594
595 /* Gets current RX stereo/mono mode */
596 int fm_rx_get_stereo_mono(struct fmdev *fmdev, u16 *mode)
597 {
598         __be16 curr_mode;
599         u32 resp_len;
600         int ret;
601
602         if (mode == NULL) {
603                 fmerr("Invalid memory\n");
604                 return -ENOMEM;
605         }
606
607         ret = fmc_send_cmd(fmdev, MOST_MODE_SET, REG_RD, NULL, 2,
608                         &curr_mode, &resp_len);
609         if (ret < 0)
610                 return ret;
611
612         *mode = be16_to_cpu(curr_mode);
613
614         return 0;
615 }
616
617 /* Choose RX de-emphasis filter mode (50us/75us) */
618 int fm_rx_set_deemphasis_mode(struct fmdev *fmdev, u16 mode)
619 {
620         u16 payload;
621         int ret;
622
623         if (fmdev->curr_fmmode != FM_MODE_RX)
624                 return -EPERM;
625
626         if (mode != FM_RX_EMPHASIS_FILTER_50_USEC &&
627                         mode != FM_RX_EMPHASIS_FILTER_75_USEC) {
628                 fmerr("Invalid rx de-emphasis mode (%d)\n", mode);
629                 return -EINVAL;
630         }
631
632         payload = mode;
633         ret = fmc_send_cmd(fmdev, DEMPH_MODE_SET, REG_WR, &payload,
634                         sizeof(payload), NULL, NULL);
635         if (ret < 0)
636                 return ret;
637
638         fmdev->rx.deemphasis_mode = mode;
639
640         return 0;
641 }
642
643 /* Gets current RX de-emphasis filter mode */
644 int fm_rx_get_deemph_mode(struct fmdev *fmdev, u16 *curr_deemphasis_mode)
645 {
646         if (fmdev->curr_fmmode != FM_MODE_RX)
647                 return -EPERM;
648
649         if (curr_deemphasis_mode == NULL) {
650                 fmerr("Invalid memory\n");
651                 return -ENOMEM;
652         }
653
654         *curr_deemphasis_mode = fmdev->rx.deemphasis_mode;
655
656         return 0;
657 }
658
659 /* Enable/Disable RX RDS */
660 int fm_rx_set_rds_mode(struct fmdev *fmdev, u8 rds_en_dis)
661 {
662         u16 payload;
663         int ret;
664
665         if (rds_en_dis != FM_RDS_ENABLE && rds_en_dis != FM_RDS_DISABLE) {
666                 fmerr("Invalid rds option\n");
667                 return -EINVAL;
668         }
669
670         if (rds_en_dis == FM_RDS_ENABLE
671             && fmdev->rx.rds.flag == FM_RDS_DISABLE) {
672                 /* Turn on RX RDS and RDS circuit */
673                 payload = FM_RX_PWR_SET_FM_AND_RDS_BLK_ON;
674                 ret = fmc_send_cmd(fmdev, POWER_SET, REG_WR, &payload,
675                                 sizeof(payload), NULL, NULL);
676                 if (ret < 0)
677                         return ret;
678
679                 /* Clear and reset RDS FIFO */
680                 payload = FM_RX_RDS_FLUSH_FIFO;
681                 ret = fmc_send_cmd(fmdev, RDS_CNTRL_SET, REG_WR, &payload,
682                 sizeof(payload), NULL, NULL);
683                 if (ret < 0)
684                         return ret;
685
686                 /* Read flags - just to clear any pending interrupts. */
687                 ret = fmc_send_cmd(fmdev, FLAG_GET, REG_RD, NULL, 2,
688                                 NULL, NULL);
689                 if (ret < 0)
690                         return ret;
691
692                 /* Set RDS FIFO threshold value */
693                 payload = FM_RX_RDS_FIFO_THRESHOLD;
694                 ret = fmc_send_cmd(fmdev, RDS_MEM_SET, REG_WR, &payload,
695                 sizeof(payload), NULL, NULL);
696                 if (ret < 0)
697                         return ret;
698
699                 /* Enable RDS interrupt */
700                 fmdev->irq_info.mask |= FM_RDS_EVENT;
701                 payload = fmdev->irq_info.mask;
702                 ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
703                                 sizeof(payload), NULL, NULL);
704                 if (ret < 0) {
705                         fmdev->irq_info.mask &= ~FM_RDS_EVENT;
706                         return ret;
707                 }
708
709                 /* Update our local flag */
710                 fmdev->rx.rds.flag = FM_RDS_ENABLE;
711         } else if (rds_en_dis == FM_RDS_DISABLE
712                    && fmdev->rx.rds.flag == FM_RDS_ENABLE) {
713                 /* Turn off RX RDS */
714                 payload = FM_RX_PWR_SET_FM_ON_RDS_OFF;
715                 ret = fmc_send_cmd(fmdev, POWER_SET, REG_WR, &payload,
716                                 sizeof(payload), NULL, NULL);
717                 if (ret < 0)
718                         return ret;
719
720                 /* Reset RDS pointers */
721                 fmdev->rx.rds.last_blk_idx = 0;
722                 fmdev->rx.rds.wr_idx = 0;
723                 fmdev->rx.rds.rd_idx = 0;
724                 fm_rx_reset_station_info(fmdev);
725
726                 /* Update RDS local cache */
727                 fmdev->irq_info.mask &= ~(FM_RDS_EVENT);
728                 fmdev->rx.rds.flag = FM_RDS_DISABLE;
729         }
730
731         return 0;
732 }
733
734 /* Returns current RX RDS enable/disable status */
735 int fm_rx_get_rds_mode(struct fmdev *fmdev, u8 *curr_rds_en_dis)
736 {
737         if (fmdev->curr_fmmode != FM_MODE_RX)
738                 return -EPERM;
739
740         if (curr_rds_en_dis == NULL) {
741                 fmerr("Invalid memory\n");
742                 return -ENOMEM;
743         }
744
745         *curr_rds_en_dis = fmdev->rx.rds.flag;
746
747         return 0;
748 }
749
750 /* Sets RDS operation mode (RDS/RDBS) */
751 int fm_rx_set_rds_system(struct fmdev *fmdev, u8 rds_mode)
752 {
753         u16 payload;
754         int ret;
755
756         if (fmdev->curr_fmmode != FM_MODE_RX)
757                 return -EPERM;
758
759         if (rds_mode != FM_RDS_SYSTEM_RDS && rds_mode != FM_RDS_SYSTEM_RBDS) {
760                 fmerr("Invalid rds mode\n");
761                 return -EINVAL;
762         }
763         /* Set RDS operation mode */
764         payload = (u16)rds_mode;
765         ret = fmc_send_cmd(fmdev, RDS_SYSTEM_SET, REG_WR, &payload,
766                         sizeof(payload), NULL, NULL);
767         if (ret < 0)
768                 return ret;
769
770         fmdev->rx.rds_mode = rds_mode;
771
772         return 0;
773 }
774
775 /* Configures Alternate Frequency switch mode */
776 int fm_rx_set_af_switch(struct fmdev *fmdev, u8 af_mode)
777 {
778         u16 payload;
779         int ret;
780
781         if (fmdev->curr_fmmode != FM_MODE_RX)
782                 return -EPERM;
783
784         if (af_mode != FM_RX_RDS_AF_SWITCH_MODE_ON &&
785             af_mode != FM_RX_RDS_AF_SWITCH_MODE_OFF) {
786                 fmerr("Invalid af mode\n");
787                 return -EINVAL;
788         }
789         /* Enable/disable low RSSI interrupt based on af_mode */
790         if (af_mode == FM_RX_RDS_AF_SWITCH_MODE_ON)
791                 fmdev->irq_info.mask |= FM_LEV_EVENT;
792         else
793                 fmdev->irq_info.mask &= ~FM_LEV_EVENT;
794
795         payload = fmdev->irq_info.mask;
796         ret = fmc_send_cmd(fmdev, INT_MASK_SET, REG_WR, &payload,
797                         sizeof(payload), NULL, NULL);
798         if (ret < 0)
799                 return ret;
800
801         fmdev->rx.af_mode = af_mode;
802
803         return 0;
804 }
805
806 /* Returns Alternate Frequency switch status */
807 int fm_rx_get_af_switch(struct fmdev *fmdev, u8 *af_mode)
808 {
809         if (fmdev->curr_fmmode != FM_MODE_RX)
810                 return -EPERM;
811
812         if (af_mode == NULL) {
813                 fmerr("Invalid memory\n");
814                 return -ENOMEM;
815         }
816
817         *af_mode = fmdev->rx.af_mode;
818
819         return 0;
820 }