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