1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/completion.h>
21#include <linux/delay.h>
22#include <linux/err.h>
23#include <linux/interrupt.h>
24#include <linux/i2c.h>
25#include <linux/slab.h>
26#include <linux/gpio.h>
27#include <linux/module.h>
28#include <media/v4l2-device.h>
29#include <media/v4l2-ioctl.h>
30#include <media/v4l2-common.h>
31
32#include "si4713.h"
33
34
35static int debug;
36module_param(debug, int, S_IRUGO | S_IWUSR);
37MODULE_PARM_DESC(debug, "Debug level (0 - 2)");
38
39MODULE_LICENSE("GPL");
40MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>");
41MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter");
42MODULE_VERSION("0.0.1");
43
44#define DEFAULT_RDS_PI 0x00
45#define DEFAULT_RDS_PTY 0x00
46#define DEFAULT_RDS_DEVIATION 0x00C8
47#define DEFAULT_RDS_PS_REPEAT_COUNT 0x0003
48#define DEFAULT_LIMITER_RTIME 0x1392
49#define DEFAULT_LIMITER_DEV 0x102CA
50#define DEFAULT_PILOT_FREQUENCY 0x4A38
51#define DEFAULT_PILOT_DEVIATION 0x1A5E
52#define DEFAULT_ACOMP_ATIME 0x0000
53#define DEFAULT_ACOMP_RTIME 0xF4240L
54#define DEFAULT_ACOMP_GAIN 0x0F
55#define DEFAULT_ACOMP_THRESHOLD (-0x28)
56#define DEFAULT_MUTE 0x01
57#define DEFAULT_POWER_LEVEL 88
58#define DEFAULT_FREQUENCY 8800
59#define DEFAULT_PREEMPHASIS FMPE_EU
60#define DEFAULT_TUNE_RNL 0xFF
61
62#define to_si4713_device(sd) container_of(sd, struct si4713_device, sd)
63
64
65#define FREQDEV_UNIT 100000
66#define FREQV4L2_MULTI 625
67#define si4713_to_v4l2(f) ((f * FREQDEV_UNIT) / FREQV4L2_MULTI)
68#define v4l2_to_si4713(f) ((f * FREQV4L2_MULTI) / FREQDEV_UNIT)
69#define FREQ_RANGE_LOW 7600
70#define FREQ_RANGE_HIGH 10800
71
72#define MAX_ARGS 7
73
74#define RDS_BLOCK 8
75#define RDS_BLOCK_CLEAR 0x03
76#define RDS_BLOCK_LOAD 0x04
77#define RDS_RADIOTEXT_2A 0x20
78#define RDS_RADIOTEXT_BLK_SIZE 4
79#define RDS_RADIOTEXT_INDEX_MAX 0x0F
80#define RDS_CARRIAGE_RETURN 0x0D
81
82#define rds_ps_nblocks(len) ((len / RDS_BLOCK) + (len % RDS_BLOCK ? 1 : 0))
83
84#define get_status_bit(p, b, m) (((p) & (m)) >> (b))
85#define set_bits(p, v, b, m) (((p) & ~(m)) | ((v) << (b)))
86
87#define ATTACK_TIME_UNIT 500
88
89#define POWER_OFF 0x00
90#define POWER_ON 0x01
91
92#define msb(x) ((u8)((u16) x >> 8))
93#define lsb(x) ((u8)((u16) x & 0x00FF))
94#define compose_u16(msb, lsb) (((u16)msb << 8) | lsb)
95#define check_command_failed(status) (!(status & SI4713_CTS) || \
96 (status & SI4713_ERR))
97
98#define set_mute(p) ((p & 1) | ((p & 1) << 1));
99
100#ifdef DEBUG
101#define DBG_BUFFER(device, message, buffer, size) \
102 { \
103 int i; \
104 char str[(size)*5]; \
105 for (i = 0; i < size; i++) \
106 sprintf(str + i * 5, " 0x%02x", buffer[i]); \
107 v4l2_dbg(2, debug, device, "%s:%s\n", message, str); \
108 }
109#else
110#define DBG_BUFFER(device, message, buffer, size)
111#endif
112
113
114
115
116
117
118static long limiter_times[] = {
119 2000, 250,
120 1000, 500,
121 510, 1000,
122 255, 2000,
123 170, 3000,
124 127, 4020,
125 102, 5010,
126 85, 6020,
127 73, 7010,
128 64, 7990,
129 57, 8970,
130 51, 10030,
131 25, 20470,
132 17, 30110,
133 13, 39380,
134 10, 51190,
135 8, 63690,
136 7, 73140,
137 6, 85330,
138 5, 102390,
139};
140
141
142
143
144
145
146static unsigned long acomp_rtimes[] = {
147 0, 100000,
148 1, 200000,
149 2, 350000,
150 3, 525000,
151 4, 1000000,
152};
153
154
155
156
157
158
159static unsigned long preemphasis_values[] = {
160 FMPE_DISABLED, V4L2_PREEMPHASIS_DISABLED,
161 FMPE_EU, V4L2_PREEMPHASIS_50_uS,
162 FMPE_USA, V4L2_PREEMPHASIS_75_uS,
163};
164
165static int usecs_to_dev(unsigned long usecs, unsigned long const array[],
166 int size)
167{
168 int i;
169 int rval = -EINVAL;
170
171 for (i = 0; i < size / 2; i++)
172 if (array[(i * 2) + 1] >= usecs) {
173 rval = array[i * 2];
174 break;
175 }
176
177 return rval;
178}
179
180
181static irqreturn_t si4713_handler(int irq, void *dev)
182{
183 struct si4713_device *sdev = dev;
184
185 v4l2_dbg(2, debug, &sdev->sd,
186 "%s: sending signal to completion work.\n", __func__);
187 complete(&sdev->work);
188
189 return IRQ_HANDLED;
190}
191
192
193
194
195
196
197
198
199
200
201
202static int si4713_send_command(struct si4713_device *sdev, const u8 command,
203 const u8 args[], const int argn,
204 u8 response[], const int respn, const int usecs)
205{
206 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
207 unsigned long until_jiffies;
208 u8 data1[MAX_ARGS + 1];
209 int err;
210
211 if (!client->adapter)
212 return -ENODEV;
213
214
215 data1[0] = command;
216 memcpy(data1 + 1, args, argn);
217 DBG_BUFFER(&sdev->sd, "Parameters", data1, argn + 1);
218
219 err = i2c_master_send(client, data1, argn + 1);
220 if (err != argn + 1) {
221 v4l2_err(&sdev->sd, "Error while sending command 0x%02x\n",
222 command);
223 return err < 0 ? err : -EIO;
224 }
225
226 until_jiffies = jiffies + usecs_to_jiffies(usecs) + 1;
227
228
229 if (client->irq) {
230 if (!wait_for_completion_timeout(&sdev->work,
231 usecs_to_jiffies(usecs) + 1))
232 v4l2_warn(&sdev->sd,
233 "(%s) Device took too much time to answer.\n",
234 __func__);
235 }
236
237 do {
238 err = i2c_master_recv(client, response, respn);
239 if (err != respn) {
240 v4l2_err(&sdev->sd,
241 "Error %d while reading response for command 0x%02x\n",
242 err, command);
243 return err < 0 ? err : -EIO;
244 }
245
246 DBG_BUFFER(&sdev->sd, "Response", response, respn);
247 if (!check_command_failed(response[0]))
248 return 0;
249
250 if (client->irq)
251 return -EBUSY;
252 if (usecs <= 1000)
253 usleep_range(usecs, 1000);
254 else
255 usleep_range(1000, 2000);
256 } while (time_is_after_jiffies(until_jiffies));
257
258 return -EBUSY;
259}
260
261
262
263
264
265
266
267static int si4713_read_property(struct si4713_device *sdev, u16 prop, u32 *pv)
268{
269 int err;
270 u8 val[SI4713_GET_PROP_NRESP];
271
272
273
274
275
276 const u8 args[SI4713_GET_PROP_NARGS] = {
277 0x00,
278 msb(prop),
279 lsb(prop),
280 };
281
282 err = si4713_send_command(sdev, SI4713_CMD_GET_PROPERTY,
283 args, ARRAY_SIZE(args), val,
284 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
285
286 if (err < 0)
287 return err;
288
289 *pv = compose_u16(val[2], val[3]);
290
291 v4l2_dbg(1, debug, &sdev->sd,
292 "%s: property=0x%02x value=0x%02x status=0x%02x\n",
293 __func__, prop, *pv, val[0]);
294
295 return err;
296}
297
298
299
300
301
302
303
304static int si4713_write_property(struct si4713_device *sdev, u16 prop, u16 val)
305{
306 int rval;
307 u8 resp[SI4713_SET_PROP_NRESP];
308
309
310
311
312
313
314
315 const u8 args[SI4713_SET_PROP_NARGS] = {
316 0x00,
317 msb(prop),
318 lsb(prop),
319 msb(val),
320 lsb(val),
321 };
322
323 rval = si4713_send_command(sdev, SI4713_CMD_SET_PROPERTY,
324 args, ARRAY_SIZE(args),
325 resp, ARRAY_SIZE(resp),
326 DEFAULT_TIMEOUT);
327
328 if (rval < 0)
329 return rval;
330
331 v4l2_dbg(1, debug, &sdev->sd,
332 "%s: property=0x%02x value=0x%02x status=0x%02x\n",
333 __func__, prop, val, resp[0]);
334
335
336
337
338
339
340 msleep(TIMEOUT_SET_PROPERTY);
341
342 return rval;
343}
344
345
346
347
348
349static int si4713_powerup(struct si4713_device *sdev)
350{
351 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
352 int err;
353 u8 resp[SI4713_PWUP_NRESP];
354
355
356
357
358 u8 args[SI4713_PWUP_NARGS] = {
359 SI4713_PWUP_GPO2OEN | SI4713_PWUP_FUNC_TX,
360 SI4713_PWUP_OPMOD_ANALOG,
361 };
362
363 if (sdev->power_state)
364 return 0;
365
366 if (sdev->vdd) {
367 err = regulator_enable(sdev->vdd);
368 if (err) {
369 v4l2_err(&sdev->sd, "Failed to enable vdd: %d\n", err);
370 return err;
371 }
372 }
373
374 if (sdev->vio) {
375 err = regulator_enable(sdev->vio);
376 if (err) {
377 v4l2_err(&sdev->sd, "Failed to enable vio: %d\n", err);
378 return err;
379 }
380 }
381
382 if (sdev->gpio_reset) {
383 udelay(50);
384 gpiod_set_value(sdev->gpio_reset, 1);
385 }
386
387 if (client->irq)
388 args[0] |= SI4713_PWUP_CTSIEN;
389
390 err = si4713_send_command(sdev, SI4713_CMD_POWER_UP,
391 args, ARRAY_SIZE(args),
392 resp, ARRAY_SIZE(resp),
393 TIMEOUT_POWER_UP);
394
395 if (!err) {
396 v4l2_dbg(1, debug, &sdev->sd, "Powerup response: 0x%02x\n",
397 resp[0]);
398 v4l2_dbg(1, debug, &sdev->sd, "Device in power up mode\n");
399 sdev->power_state = POWER_ON;
400
401 if (client->irq)
402 err = si4713_write_property(sdev, SI4713_GPO_IEN,
403 SI4713_STC_INT | SI4713_CTS);
404 return err;
405 }
406 gpiod_set_value(sdev->gpio_reset, 0);
407
408
409 if (sdev->vdd) {
410 err = regulator_disable(sdev->vdd);
411 if (err)
412 v4l2_err(&sdev->sd, "Failed to disable vdd: %d\n", err);
413 }
414
415 if (sdev->vio) {
416 err = regulator_disable(sdev->vio);
417 if (err)
418 v4l2_err(&sdev->sd, "Failed to disable vio: %d\n", err);
419 }
420
421 return err;
422}
423
424
425
426
427
428static int si4713_powerdown(struct si4713_device *sdev)
429{
430 int err;
431 u8 resp[SI4713_PWDN_NRESP];
432
433 if (!sdev->power_state)
434 return 0;
435
436 err = si4713_send_command(sdev, SI4713_CMD_POWER_DOWN,
437 NULL, 0,
438 resp, ARRAY_SIZE(resp),
439 DEFAULT_TIMEOUT);
440
441 if (!err) {
442 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n",
443 resp[0]);
444 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n");
445 if (sdev->gpio_reset)
446 gpiod_set_value(sdev->gpio_reset, 0);
447
448 if (sdev->vdd) {
449 err = regulator_disable(sdev->vdd);
450 if (err) {
451 v4l2_err(&sdev->sd,
452 "Failed to disable vdd: %d\n", err);
453 }
454 }
455
456 if (sdev->vio) {
457 err = regulator_disable(sdev->vio);
458 if (err) {
459 v4l2_err(&sdev->sd,
460 "Failed to disable vio: %d\n", err);
461 }
462 }
463 sdev->power_state = POWER_OFF;
464 }
465
466 return err;
467}
468
469
470
471
472
473static int si4713_checkrev(struct si4713_device *sdev)
474{
475 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
476 int rval;
477 u8 resp[SI4713_GETREV_NRESP];
478
479 rval = si4713_send_command(sdev, SI4713_CMD_GET_REV,
480 NULL, 0,
481 resp, ARRAY_SIZE(resp),
482 DEFAULT_TIMEOUT);
483
484 if (rval < 0)
485 return rval;
486
487 if (resp[1] == SI4713_PRODUCT_NUMBER) {
488 v4l2_info(&sdev->sd, "chip found @ 0x%02x (%s)\n",
489 client->addr << 1, client->adapter->name);
490 } else {
491 v4l2_err(&sdev->sd, "Invalid product number 0x%X\n", resp[1]);
492 rval = -EINVAL;
493 }
494 return rval;
495}
496
497
498
499
500
501
502
503static int si4713_wait_stc(struct si4713_device *sdev, const int usecs)
504{
505 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
506 u8 resp[SI4713_GET_STATUS_NRESP];
507 unsigned long start_jiffies = jiffies;
508 int err;
509
510 if (client->irq &&
511 !wait_for_completion_timeout(&sdev->work, usecs_to_jiffies(usecs) + 1))
512 v4l2_warn(&sdev->sd,
513 "(%s) Device took too much time to answer.\n", __func__);
514
515 for (;;) {
516
517 err = si4713_send_command(sdev, SI4713_CMD_GET_INT_STATUS,
518 NULL, 0,
519 resp, ARRAY_SIZE(resp),
520 DEFAULT_TIMEOUT);
521
522
523 if (err >= 0) {
524 v4l2_dbg(1, debug, &sdev->sd,
525 "%s: status bits: 0x%02x\n", __func__, resp[0]);
526
527 if (resp[0] & SI4713_STC_INT)
528 return 0;
529 }
530 if (jiffies_to_usecs(jiffies - start_jiffies) > usecs)
531 return err < 0 ? err : -EIO;
532
533
534
535
536 usleep_range(3000, 4000);
537 }
538}
539
540
541
542
543
544
545
546
547static int si4713_tx_tune_freq(struct si4713_device *sdev, u16 frequency)
548{
549 int err;
550 u8 val[SI4713_TXFREQ_NRESP];
551
552
553
554
555
556 const u8 args[SI4713_TXFREQ_NARGS] = {
557 0x00,
558 msb(frequency),
559 lsb(frequency),
560 };
561
562 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_FREQ,
563 args, ARRAY_SIZE(args), val,
564 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
565
566 if (err < 0)
567 return err;
568
569 v4l2_dbg(1, debug, &sdev->sd,
570 "%s: frequency=0x%02x status=0x%02x\n", __func__,
571 frequency, val[0]);
572
573 err = si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
574 if (err < 0)
575 return err;
576
577 return compose_u16(args[1], args[2]);
578}
579
580
581
582
583
584
585
586
587
588
589
590
591static int si4713_tx_tune_power(struct si4713_device *sdev, u8 power,
592 u8 antcap)
593{
594 int err;
595 u8 val[SI4713_TXPWR_NRESP];
596
597
598
599
600
601
602 u8 args[SI4713_TXPWR_NARGS] = {
603 0x00,
604 0x00,
605 power,
606 antcap,
607 };
608
609
610 if (power > 0 && power < SI4713_MIN_POWER)
611 args[2] = power = SI4713_MIN_POWER;
612
613 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_POWER,
614 args, ARRAY_SIZE(args), val,
615 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
616
617 if (err < 0)
618 return err;
619
620 v4l2_dbg(1, debug, &sdev->sd,
621 "%s: power=0x%02x antcap=0x%02x status=0x%02x\n",
622 __func__, power, antcap, val[0]);
623
624 return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE_POWER);
625}
626
627
628
629
630
631
632
633
634
635
636
637
638
639static int si4713_tx_tune_measure(struct si4713_device *sdev, u16 frequency,
640 u8 antcap)
641{
642 int err;
643 u8 val[SI4713_TXMEA_NRESP];
644
645
646
647
648
649
650 const u8 args[SI4713_TXMEA_NARGS] = {
651 0x00,
652 msb(frequency),
653 lsb(frequency),
654 antcap,
655 };
656
657 sdev->tune_rnl = DEFAULT_TUNE_RNL;
658
659 if (antcap > SI4713_MAX_ANTCAP)
660 return -EDOM;
661
662 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_MEASURE,
663 args, ARRAY_SIZE(args), val,
664 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
665
666 if (err < 0)
667 return err;
668
669 v4l2_dbg(1, debug, &sdev->sd,
670 "%s: frequency=0x%02x antcap=0x%02x status=0x%02x\n",
671 __func__, frequency, antcap, val[0]);
672
673 return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
674}
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690static int si4713_tx_tune_status(struct si4713_device *sdev, u8 intack,
691 u16 *frequency, u8 *power,
692 u8 *antcap, u8 *noise)
693{
694 int err;
695 u8 val[SI4713_TXSTATUS_NRESP];
696
697
698
699 const u8 args[SI4713_TXSTATUS_NARGS] = {
700 intack & SI4713_INTACK_MASK,
701 };
702
703 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_STATUS,
704 args, ARRAY_SIZE(args), val,
705 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
706
707 if (!err) {
708 v4l2_dbg(1, debug, &sdev->sd,
709 "%s: status=0x%02x\n", __func__, val[0]);
710 *frequency = compose_u16(val[2], val[3]);
711 sdev->frequency = *frequency;
712 *power = val[5];
713 *antcap = val[6];
714 *noise = val[7];
715 v4l2_dbg(1, debug, &sdev->sd,
716 "%s: response: %d x 10 kHz (power %d, antcap %d, rnl %d)\n",
717 __func__, *frequency, *power, *antcap, *noise);
718 }
719
720 return err;
721}
722
723
724
725
726
727
728
729
730
731
732
733static int si4713_tx_rds_buff(struct si4713_device *sdev, u8 mode, u16 rdsb,
734 u16 rdsc, u16 rdsd, s8 *cbleft)
735{
736 int err;
737 u8 val[SI4713_RDSBUFF_NRESP];
738
739 const u8 args[SI4713_RDSBUFF_NARGS] = {
740 mode & SI4713_RDSBUFF_MODE_MASK,
741 msb(rdsb),
742 lsb(rdsb),
743 msb(rdsc),
744 lsb(rdsc),
745 msb(rdsd),
746 lsb(rdsd),
747 };
748
749 err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_BUFF,
750 args, ARRAY_SIZE(args), val,
751 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
752
753 if (!err) {
754 v4l2_dbg(1, debug, &sdev->sd,
755 "%s: status=0x%02x\n", __func__, val[0]);
756 *cbleft = (s8)val[2] - val[3];
757 v4l2_dbg(1, debug, &sdev->sd,
758 "%s: response: interrupts 0x%02x cb avail: %d cb used %d fifo avail %d fifo used %d\n",
759 __func__, val[1], val[2], val[3], val[4], val[5]);
760 }
761
762 return err;
763}
764
765
766
767
768
769
770
771static int si4713_tx_rds_ps(struct si4713_device *sdev, u8 psid,
772 unsigned char *pschar)
773{
774 int err;
775 u8 val[SI4713_RDSPS_NRESP];
776
777 const u8 args[SI4713_RDSPS_NARGS] = {
778 psid & SI4713_RDSPS_PSID_MASK,
779 pschar[0],
780 pschar[1],
781 pschar[2],
782 pschar[3],
783 };
784
785 err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_PS,
786 args, ARRAY_SIZE(args), val,
787 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
788
789 if (err < 0)
790 return err;
791
792 v4l2_dbg(1, debug, &sdev->sd, "%s: status=0x%02x\n", __func__, val[0]);
793
794 return err;
795}
796
797static int si4713_set_power_state(struct si4713_device *sdev, u8 value)
798{
799 if (value)
800 return si4713_powerup(sdev);
801 return si4713_powerdown(sdev);
802}
803
804static int si4713_set_mute(struct si4713_device *sdev, u16 mute)
805{
806 int rval = 0;
807
808 mute = set_mute(mute);
809
810 if (sdev->power_state)
811 rval = si4713_write_property(sdev,
812 SI4713_TX_LINE_INPUT_MUTE, mute);
813
814 return rval;
815}
816
817static int si4713_set_rds_ps_name(struct si4713_device *sdev, char *ps_name)
818{
819 int rval = 0, i;
820 u8 len = 0;
821
822
823 if (!strlen(ps_name))
824 memset(ps_name, 0, MAX_RDS_PS_NAME + 1);
825
826 if (sdev->power_state) {
827
828 for (i = 0; i < MAX_RDS_PS_NAME; i += (RDS_BLOCK / 2)) {
829 rval = si4713_tx_rds_ps(sdev, (i / (RDS_BLOCK / 2)),
830 ps_name + i);
831 if (rval < 0)
832 return rval;
833 }
834
835
836 if (strlen(ps_name))
837 len = strlen(ps_name) - 1;
838 else
839 len = 1;
840
841 rval = si4713_write_property(sdev,
842 SI4713_TX_RDS_PS_MESSAGE_COUNT,
843 rds_ps_nblocks(len));
844 if (rval < 0)
845 return rval;
846
847 rval = si4713_write_property(sdev,
848 SI4713_TX_RDS_PS_REPEAT_COUNT,
849 DEFAULT_RDS_PS_REPEAT_COUNT * 2);
850 if (rval < 0)
851 return rval;
852 }
853
854 return rval;
855}
856
857static int si4713_set_rds_radio_text(struct si4713_device *sdev, const char *rt)
858{
859 static const char cr[RDS_RADIOTEXT_BLK_SIZE] = { RDS_CARRIAGE_RETURN, 0 };
860 int rval = 0, i;
861 u16 t_index = 0;
862 u8 b_index = 0, cr_inserted = 0;
863 s8 left;
864
865 if (!sdev->power_state)
866 return rval;
867
868 rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_CLEAR, 0, 0, 0, &left);
869 if (rval < 0)
870 return rval;
871
872 if (!strlen(rt))
873 return rval;
874
875 do {
876
877
878
879 if (t_index < (RDS_RADIOTEXT_INDEX_MAX * RDS_RADIOTEXT_BLK_SIZE)) {
880 for (i = 0; i < RDS_RADIOTEXT_BLK_SIZE; i++) {
881 if (!rt[t_index + i] ||
882 rt[t_index + i] == RDS_CARRIAGE_RETURN) {
883 rt = cr;
884 cr_inserted = 1;
885 break;
886 }
887 }
888 }
889
890 rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_LOAD,
891 compose_u16(RDS_RADIOTEXT_2A, b_index++),
892 compose_u16(rt[t_index], rt[t_index + 1]),
893 compose_u16(rt[t_index + 2], rt[t_index + 3]),
894 &left);
895 if (rval < 0)
896 return rval;
897
898 t_index += RDS_RADIOTEXT_BLK_SIZE;
899
900 if (cr_inserted)
901 break;
902 } while (left > 0);
903
904 return rval;
905}
906
907
908
909
910
911
912static int si4713_update_tune_status(struct si4713_device *sdev)
913{
914 int rval;
915 u16 f = 0;
916 u8 p = 0, a = 0, n = 0;
917
918 rval = si4713_tx_tune_status(sdev, 0x00, &f, &p, &a, &n);
919
920 if (rval < 0)
921 goto exit;
922
923
924
925
926
927
928 sdev->tune_rnl = n;
929
930exit:
931 return rval;
932}
933
934static int si4713_choose_econtrol_action(struct si4713_device *sdev, u32 id,
935 s32 *bit, s32 *mask, u16 *property, int *mul,
936 unsigned long **table, int *size)
937{
938 s32 rval = 0;
939
940 switch (id) {
941
942 case V4L2_CID_RDS_TX_PI:
943 *property = SI4713_TX_RDS_PI;
944 *mul = 1;
945 break;
946 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
947 *property = SI4713_TX_ACOMP_THRESHOLD;
948 *mul = 1;
949 break;
950 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
951 *property = SI4713_TX_ACOMP_GAIN;
952 *mul = 1;
953 break;
954 case V4L2_CID_PILOT_TONE_FREQUENCY:
955 *property = SI4713_TX_PILOT_FREQUENCY;
956 *mul = 1;
957 break;
958 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
959 *property = SI4713_TX_ACOMP_ATTACK_TIME;
960 *mul = ATTACK_TIME_UNIT;
961 break;
962 case V4L2_CID_PILOT_TONE_DEVIATION:
963 *property = SI4713_TX_PILOT_DEVIATION;
964 *mul = 10;
965 break;
966 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
967 *property = SI4713_TX_AUDIO_DEVIATION;
968 *mul = 10;
969 break;
970 case V4L2_CID_RDS_TX_DEVIATION:
971 *property = SI4713_TX_RDS_DEVIATION;
972 *mul = 1;
973 break;
974
975 case V4L2_CID_RDS_TX_PTY:
976 *property = SI4713_TX_RDS_PS_MISC;
977 *bit = 5;
978 *mask = 0x1F << 5;
979 break;
980 case V4L2_CID_RDS_TX_DYNAMIC_PTY:
981 *property = SI4713_TX_RDS_PS_MISC;
982 *bit = 15;
983 *mask = 1 << 15;
984 break;
985 case V4L2_CID_RDS_TX_COMPRESSED:
986 *property = SI4713_TX_RDS_PS_MISC;
987 *bit = 14;
988 *mask = 1 << 14;
989 break;
990 case V4L2_CID_RDS_TX_ARTIFICIAL_HEAD:
991 *property = SI4713_TX_RDS_PS_MISC;
992 *bit = 13;
993 *mask = 1 << 13;
994 break;
995 case V4L2_CID_RDS_TX_MONO_STEREO:
996 *property = SI4713_TX_RDS_PS_MISC;
997 *bit = 12;
998 *mask = 1 << 12;
999 break;
1000 case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1001 *property = SI4713_TX_RDS_PS_MISC;
1002 *bit = 10;
1003 *mask = 1 << 10;
1004 break;
1005 case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1006 *property = SI4713_TX_RDS_PS_MISC;
1007 *bit = 4;
1008 *mask = 1 << 4;
1009 break;
1010 case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1011 *property = SI4713_TX_RDS_PS_MISC;
1012 *bit = 3;
1013 *mask = 1 << 3;
1014 break;
1015 case V4L2_CID_AUDIO_LIMITER_ENABLED:
1016 *property = SI4713_TX_ACOMP_ENABLE;
1017 *bit = 1;
1018 *mask = 1 << 1;
1019 break;
1020 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1021 *property = SI4713_TX_ACOMP_ENABLE;
1022 *bit = 0;
1023 *mask = 1 << 0;
1024 break;
1025 case V4L2_CID_PILOT_TONE_ENABLED:
1026 *property = SI4713_TX_COMPONENT_ENABLE;
1027 *bit = 0;
1028 *mask = 1 << 0;
1029 break;
1030
1031 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1032 *property = SI4713_TX_LIMITER_RELEASE_TIME;
1033 *table = limiter_times;
1034 *size = ARRAY_SIZE(limiter_times);
1035 break;
1036 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1037 *property = SI4713_TX_ACOMP_RELEASE_TIME;
1038 *table = acomp_rtimes;
1039 *size = ARRAY_SIZE(acomp_rtimes);
1040 break;
1041 case V4L2_CID_TUNE_PREEMPHASIS:
1042 *property = SI4713_TX_PREEMPHASIS;
1043 *table = preemphasis_values;
1044 *size = ARRAY_SIZE(preemphasis_values);
1045 break;
1046
1047 default:
1048 rval = -EINVAL;
1049 break;
1050 }
1051
1052 return rval;
1053}
1054
1055static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f);
1056static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *);
1057
1058
1059
1060
1061static int si4713_setup(struct si4713_device *sdev)
1062{
1063 struct v4l2_frequency f;
1064 struct v4l2_modulator vm;
1065 int rval;
1066
1067
1068 f.tuner = 0;
1069 f.frequency = sdev->frequency ? sdev->frequency : DEFAULT_FREQUENCY;
1070 f.frequency = si4713_to_v4l2(f.frequency);
1071 rval = si4713_s_frequency(&sdev->sd, &f);
1072
1073 vm.index = 0;
1074 if (sdev->stereo)
1075 vm.txsubchans = V4L2_TUNER_SUB_STEREO;
1076 else
1077 vm.txsubchans = V4L2_TUNER_SUB_MONO;
1078 if (sdev->rds_enabled)
1079 vm.txsubchans |= V4L2_TUNER_SUB_RDS;
1080 si4713_s_modulator(&sdev->sd, &vm);
1081
1082 return rval;
1083}
1084
1085
1086
1087
1088
1089static int si4713_initialize(struct si4713_device *sdev)
1090{
1091 int rval;
1092
1093 rval = si4713_set_power_state(sdev, POWER_ON);
1094 if (rval < 0)
1095 return rval;
1096
1097 rval = si4713_checkrev(sdev);
1098 if (rval < 0)
1099 return rval;
1100
1101 rval = si4713_set_power_state(sdev, POWER_OFF);
1102 if (rval < 0)
1103 return rval;
1104
1105 sdev->frequency = DEFAULT_FREQUENCY;
1106 sdev->stereo = 1;
1107 sdev->tune_rnl = DEFAULT_TUNE_RNL;
1108 return 0;
1109}
1110
1111
1112static int si4713_s_ctrl(struct v4l2_ctrl *ctrl)
1113{
1114 struct si4713_device *sdev =
1115 container_of(ctrl->handler, struct si4713_device, ctrl_handler);
1116 u32 val = 0;
1117 s32 bit = 0, mask = 0;
1118 u16 property = 0;
1119 int mul = 0;
1120 unsigned long *table = NULL;
1121 int size = 0;
1122 bool force = false;
1123 int c;
1124 int ret = 0;
1125
1126 if (ctrl->id != V4L2_CID_AUDIO_MUTE)
1127 return -EINVAL;
1128 if (ctrl->is_new) {
1129 if (ctrl->val) {
1130 ret = si4713_set_mute(sdev, ctrl->val);
1131 if (!ret)
1132 ret = si4713_set_power_state(sdev, POWER_DOWN);
1133 return ret;
1134 }
1135 ret = si4713_set_power_state(sdev, POWER_UP);
1136 if (!ret)
1137 ret = si4713_set_mute(sdev, ctrl->val);
1138 if (!ret)
1139 ret = si4713_setup(sdev);
1140 if (ret)
1141 return ret;
1142 force = true;
1143 }
1144
1145 if (!sdev->power_state)
1146 return 0;
1147
1148 for (c = 1; !ret && c < ctrl->ncontrols; c++) {
1149 ctrl = ctrl->cluster[c];
1150
1151 if (!force && !ctrl->is_new)
1152 continue;
1153
1154 switch (ctrl->id) {
1155 case V4L2_CID_RDS_TX_PS_NAME:
1156 ret = si4713_set_rds_ps_name(sdev, ctrl->p_new.p_char);
1157 break;
1158
1159 case V4L2_CID_RDS_TX_RADIO_TEXT:
1160 ret = si4713_set_rds_radio_text(sdev, ctrl->p_new.p_char);
1161 break;
1162
1163 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1164
1165
1166
1167 if (force)
1168 break;
1169
1170 case V4L2_CID_TUNE_POWER_LEVEL:
1171 ret = si4713_tx_tune_power(sdev,
1172 sdev->tune_pwr_level->val, sdev->tune_ant_cap->val);
1173 if (!ret) {
1174
1175 sdev->tune_ant_cap->is_new = false;
1176 sdev->tune_pwr_level->is_new = false;
1177 }
1178 break;
1179
1180 case V4L2_CID_RDS_TX_ALT_FREQS_ENABLE:
1181 case V4L2_CID_RDS_TX_ALT_FREQS:
1182 if (sdev->rds_alt_freqs_enable->val) {
1183 val = sdev->rds_alt_freqs->p_new.p_u32[0];
1184 val = val / 100 - 876 + 0xe101;
1185 } else {
1186 val = 0xe0e0;
1187 }
1188 ret = si4713_write_property(sdev, SI4713_TX_RDS_PS_AF, val);
1189 break;
1190
1191 default:
1192 ret = si4713_choose_econtrol_action(sdev, ctrl->id, &bit,
1193 &mask, &property, &mul, &table, &size);
1194 if (ret < 0)
1195 break;
1196
1197 val = ctrl->val;
1198 if (mul) {
1199 val = val / mul;
1200 } else if (table) {
1201 ret = usecs_to_dev(val, table, size);
1202 if (ret < 0)
1203 break;
1204 val = ret;
1205 ret = 0;
1206 }
1207
1208 if (mask) {
1209 ret = si4713_read_property(sdev, property, &val);
1210 if (ret < 0)
1211 break;
1212 val = set_bits(val, ctrl->val, bit, mask);
1213 }
1214
1215 ret = si4713_write_property(sdev, property, val);
1216 if (ret < 0)
1217 break;
1218 if (mask)
1219 val = ctrl->val;
1220 break;
1221 }
1222 }
1223
1224 return ret;
1225}
1226
1227
1228static long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1229{
1230 struct si4713_device *sdev = to_si4713_device(sd);
1231 struct si4713_rnl *rnl = arg;
1232 u16 frequency;
1233 int rval = 0;
1234
1235 if (!arg)
1236 return -EINVAL;
1237
1238 switch (cmd) {
1239 case SI4713_IOC_MEASURE_RNL:
1240 frequency = v4l2_to_si4713(rnl->frequency);
1241
1242 if (sdev->power_state) {
1243
1244 rval = si4713_tx_tune_measure(sdev, frequency, 0);
1245 if (rval < 0)
1246 return rval;
1247
1248 rval = si4713_update_tune_status(sdev);
1249 if (rval < 0)
1250 return rval;
1251 }
1252 rnl->rnl = sdev->tune_rnl;
1253 break;
1254
1255 default:
1256
1257 rval = -ENOIOCTLCMD;
1258 }
1259
1260 return rval;
1261}
1262
1263
1264static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1265{
1266 struct si4713_device *sdev = to_si4713_device(sd);
1267 int rval = 0;
1268
1269 if (!sdev)
1270 return -ENODEV;
1271
1272 if (vm->index > 0)
1273 return -EINVAL;
1274
1275 strncpy(vm->name, "FM Modulator", 32);
1276 vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW |
1277 V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_CONTROLS;
1278
1279
1280 vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW);
1281 vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH);
1282
1283 if (sdev->power_state) {
1284 u32 comp_en = 0;
1285
1286 rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE,
1287 &comp_en);
1288 if (rval < 0)
1289 return rval;
1290
1291 sdev->stereo = get_status_bit(comp_en, 1, 1 << 1);
1292 }
1293
1294
1295 if (sdev->stereo)
1296 vm->txsubchans = V4L2_TUNER_SUB_STEREO;
1297 else
1298 vm->txsubchans = V4L2_TUNER_SUB_MONO;
1299
1300
1301 if (sdev->rds_enabled)
1302 vm->txsubchans |= V4L2_TUNER_SUB_RDS;
1303 else
1304 vm->txsubchans &= ~V4L2_TUNER_SUB_RDS;
1305
1306 return rval;
1307}
1308
1309
1310static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *vm)
1311{
1312 struct si4713_device *sdev = to_si4713_device(sd);
1313 int rval = 0;
1314 u16 stereo, rds;
1315 u32 p;
1316
1317 if (!sdev)
1318 return -ENODEV;
1319
1320 if (vm->index > 0)
1321 return -EINVAL;
1322
1323
1324 if (vm->txsubchans & V4L2_TUNER_SUB_STEREO)
1325 stereo = 1;
1326 else if (vm->txsubchans & V4L2_TUNER_SUB_MONO)
1327 stereo = 0;
1328 else
1329 return -EINVAL;
1330
1331 rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS);
1332
1333 if (sdev->power_state) {
1334 rval = si4713_read_property(sdev,
1335 SI4713_TX_COMPONENT_ENABLE, &p);
1336 if (rval < 0)
1337 return rval;
1338
1339 p = set_bits(p, stereo, 1, 1 << 1);
1340 p = set_bits(p, rds, 2, 1 << 2);
1341
1342 rval = si4713_write_property(sdev,
1343 SI4713_TX_COMPONENT_ENABLE, p);
1344 if (rval < 0)
1345 return rval;
1346 }
1347
1348 sdev->stereo = stereo;
1349 sdev->rds_enabled = rds;
1350
1351 return rval;
1352}
1353
1354
1355static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1356{
1357 struct si4713_device *sdev = to_si4713_device(sd);
1358 int rval = 0;
1359
1360 if (f->tuner)
1361 return -EINVAL;
1362
1363 if (sdev->power_state) {
1364 u16 freq;
1365 u8 p, a, n;
1366
1367 rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n);
1368 if (rval < 0)
1369 return rval;
1370
1371 sdev->frequency = freq;
1372 }
1373
1374 f->frequency = si4713_to_v4l2(sdev->frequency);
1375
1376 return rval;
1377}
1378
1379
1380static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f)
1381{
1382 struct si4713_device *sdev = to_si4713_device(sd);
1383 int rval = 0;
1384 u16 frequency = v4l2_to_si4713(f->frequency);
1385
1386 if (f->tuner)
1387 return -EINVAL;
1388
1389
1390 frequency = clamp_t(u16, frequency, FREQ_RANGE_LOW, FREQ_RANGE_HIGH);
1391
1392 if (sdev->power_state) {
1393 rval = si4713_tx_tune_freq(sdev, frequency);
1394 if (rval < 0)
1395 return rval;
1396 frequency = rval;
1397 rval = 0;
1398 }
1399 sdev->frequency = frequency;
1400
1401 return rval;
1402}
1403
1404static const struct v4l2_ctrl_ops si4713_ctrl_ops = {
1405 .s_ctrl = si4713_s_ctrl,
1406};
1407
1408static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = {
1409 .ioctl = si4713_ioctl,
1410};
1411
1412static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = {
1413 .g_frequency = si4713_g_frequency,
1414 .s_frequency = si4713_s_frequency,
1415 .g_modulator = si4713_g_modulator,
1416 .s_modulator = si4713_s_modulator,
1417};
1418
1419static const struct v4l2_subdev_ops si4713_subdev_ops = {
1420 .core = &si4713_subdev_core_ops,
1421 .tuner = &si4713_subdev_tuner_ops,
1422};
1423
1424static const struct v4l2_ctrl_config si4713_alt_freqs_ctrl = {
1425 .id = V4L2_CID_RDS_TX_ALT_FREQS,
1426 .type = V4L2_CTRL_TYPE_U32,
1427 .min = 87600,
1428 .max = 107900,
1429 .step = 100,
1430 .def = 87600,
1431 .dims = { 1 },
1432 .elem_size = sizeof(u32),
1433};
1434
1435
1436
1437
1438
1439static int si4713_probe(struct i2c_client *client,
1440 const struct i2c_device_id *id)
1441{
1442 struct si4713_device *sdev;
1443 struct v4l2_ctrl_handler *hdl;
1444 struct si4713_platform_data *pdata = client->dev.platform_data;
1445 struct device_node *np = client->dev.of_node;
1446 struct radio_si4713_platform_data si4713_pdev_pdata;
1447 struct platform_device *si4713_pdev;
1448 int rval;
1449
1450 sdev = devm_kzalloc(&client->dev, sizeof(*sdev), GFP_KERNEL);
1451 if (!sdev) {
1452 dev_err(&client->dev, "Failed to alloc video device.\n");
1453 rval = -ENOMEM;
1454 goto exit;
1455 }
1456
1457 sdev->gpio_reset = devm_gpiod_get_optional(&client->dev, "reset",
1458 GPIOD_OUT_LOW);
1459 if (IS_ERR(sdev->gpio_reset)) {
1460 rval = PTR_ERR(sdev->gpio_reset);
1461 dev_err(&client->dev, "Failed to request gpio: %d\n", rval);
1462 goto exit;
1463 }
1464
1465 sdev->vdd = devm_regulator_get_optional(&client->dev, "vdd");
1466 if (IS_ERR(sdev->vdd)) {
1467 rval = PTR_ERR(sdev->vdd);
1468 if (rval == -EPROBE_DEFER)
1469 goto exit;
1470
1471 dev_dbg(&client->dev, "no vdd regulator found: %d\n", rval);
1472 sdev->vdd = NULL;
1473 }
1474
1475 sdev->vio = devm_regulator_get_optional(&client->dev, "vio");
1476 if (IS_ERR(sdev->vio)) {
1477 rval = PTR_ERR(sdev->vio);
1478 if (rval == -EPROBE_DEFER)
1479 goto exit;
1480
1481 dev_dbg(&client->dev, "no vio regulator found: %d\n", rval);
1482 sdev->vio = NULL;
1483 }
1484
1485 v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
1486
1487 init_completion(&sdev->work);
1488
1489 hdl = &sdev->ctrl_handler;
1490 v4l2_ctrl_handler_init(hdl, 20);
1491 sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1492 V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE);
1493
1494 sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1495 V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI);
1496 sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1497 V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY);
1498 sdev->rds_compressed = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1499 V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
1500 sdev->rds_art_head = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1501 V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
1502 sdev->rds_stereo = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1503 V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
1504 sdev->rds_tp = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1505 V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
1506 sdev->rds_ta = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1507 V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1508 sdev->rds_ms = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1509 V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
1510 sdev->rds_dyn_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1511 V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
1512 sdev->rds_alt_freqs_enable = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1513 V4L2_CID_RDS_TX_ALT_FREQS_ENABLE, 0, 1, 1, 0);
1514 sdev->rds_alt_freqs = v4l2_ctrl_new_custom(hdl, &si4713_alt_freqs_ctrl, NULL);
1515 sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1516 V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION,
1517 10, DEFAULT_RDS_DEVIATION);
1518
1519
1520
1521
1522
1523 sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1524 V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0);
1525
1526
1527
1528
1529
1530 sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1531 V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1532
1533 sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1534 V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1);
1535 sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1536 V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250,
1537 MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME);
1538 sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1539 V4L2_CID_AUDIO_LIMITER_DEVIATION, 0,
1540 MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV);
1541
1542 sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1543 V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1);
1544 sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1545 V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1,
1546 DEFAULT_ACOMP_GAIN);
1547 sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1548 V4L2_CID_AUDIO_COMPRESSION_THRESHOLD,
1549 MIN_ACOMP_THRESHOLD, MAX_ACOMP_THRESHOLD, 1,
1550 DEFAULT_ACOMP_THRESHOLD);
1551 sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1552 V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0,
1553 MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME);
1554 sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1555 V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000,
1556 MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME);
1557
1558 sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1559 V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1);
1560 sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1561 V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION,
1562 10, DEFAULT_PILOT_DEVIATION);
1563 sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1564 V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY,
1565 1, DEFAULT_PILOT_FREQUENCY);
1566
1567 sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops,
1568 V4L2_CID_TUNE_PREEMPHASIS,
1569 V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS);
1570 sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1571 V4L2_CID_TUNE_POWER_LEVEL, 0, SI4713_MAX_POWER,
1572 1, DEFAULT_POWER_LEVEL);
1573 sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
1574 V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, SI4713_MAX_ANTCAP,
1575 1, 0);
1576
1577 if (hdl->error) {
1578 rval = hdl->error;
1579 goto free_ctrls;
1580 }
1581 v4l2_ctrl_cluster(29, &sdev->mute);
1582 sdev->sd.ctrl_handler = hdl;
1583
1584 if (client->irq) {
1585 rval = devm_request_irq(&client->dev, client->irq,
1586 si4713_handler, IRQF_TRIGGER_FALLING,
1587 client->name, sdev);
1588 if (rval < 0) {
1589 v4l2_err(&sdev->sd, "Could not request IRQ\n");
1590 goto free_ctrls;
1591 }
1592 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
1593 } else {
1594 v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
1595 }
1596
1597 rval = si4713_initialize(sdev);
1598 if (rval < 0) {
1599 v4l2_err(&sdev->sd, "Failed to probe device information.\n");
1600 goto free_ctrls;
1601 }
1602
1603 if (!np && (!pdata || !pdata->is_platform_device))
1604 return 0;
1605
1606 si4713_pdev = platform_device_alloc("radio-si4713", -1);
1607 if (!si4713_pdev) {
1608 rval = -ENOMEM;
1609 goto put_main_pdev;
1610 }
1611
1612 si4713_pdev_pdata.subdev = client;
1613 rval = platform_device_add_data(si4713_pdev, &si4713_pdev_pdata,
1614 sizeof(si4713_pdev_pdata));
1615 if (rval)
1616 goto put_main_pdev;
1617
1618 rval = platform_device_add(si4713_pdev);
1619 if (rval)
1620 goto put_main_pdev;
1621
1622 sdev->pd = si4713_pdev;
1623
1624 return 0;
1625
1626put_main_pdev:
1627 platform_device_put(si4713_pdev);
1628 v4l2_device_unregister_subdev(&sdev->sd);
1629free_ctrls:
1630 v4l2_ctrl_handler_free(hdl);
1631exit:
1632 return rval;
1633}
1634
1635
1636static int si4713_remove(struct i2c_client *client)
1637{
1638 struct v4l2_subdev *sd = i2c_get_clientdata(client);
1639 struct si4713_device *sdev = to_si4713_device(sd);
1640
1641 platform_device_unregister(sdev->pd);
1642
1643 if (sdev->power_state)
1644 si4713_set_power_state(sdev, POWER_DOWN);
1645
1646 v4l2_device_unregister_subdev(sd);
1647 v4l2_ctrl_handler_free(sd->ctrl_handler);
1648
1649 return 0;
1650}
1651
1652
1653static const struct i2c_device_id si4713_id[] = {
1654 { "si4713" , 0 },
1655 { },
1656};
1657MODULE_DEVICE_TABLE(i2c, si4713_id);
1658
1659#if IS_ENABLED(CONFIG_OF)
1660static const struct of_device_id si4713_of_match[] = {
1661 { .compatible = "silabs,si4713" },
1662 { },
1663};
1664MODULE_DEVICE_TABLE(of, si4713_of_match);
1665#endif
1666
1667static struct i2c_driver si4713_i2c_driver = {
1668 .driver = {
1669 .name = "si4713",
1670 .of_match_table = of_match_ptr(si4713_of_match),
1671 },
1672 .probe = si4713_probe,
1673 .remove = si4713_remove,
1674 .id_table = si4713_id,
1675};
1676
1677module_i2c_driver(si4713_i2c_driver);
1678
