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