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