?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.3-rc6
[linux/fpc-iii.git] / drivers / media / radio / si4713-i2c.c
blob27aba936fb2bcb95c1fb9faedb7832557abeab42
1 /*
2 * drivers/media/radio/si4713-i2c.c
3 *
4 * Silicon Labs Si4713 FM Radio Transmitter I2C commands.
5 *
6 * Copyright (c) 2009 Nokia Corporation
7 * Contact: Eduardo Valentin <eduardo.valentin@nokia.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24 #include <linux/mutex.h>
25 #include <linux/completion.h>
26 #include <linux/delay.h>
27 #include <linux/interrupt.h>
28 #include <linux/i2c.h>
29 #include <linux/slab.h>
30 #include <linux/gpio.h>
31 #include <linux/regulator/consumer.h>
32 #include <linux/module.h>
33 #include <media/v4l2-device.h>
34 #include <media/v4l2-ioctl.h>
35 #include <media/v4l2-common.h>
36
37 #include "si4713-i2c.h"
38
39 /* module parameters */
40 static int debug;
41 module_param(debug, int, S_IRUGO | S_IWUSR);
42 MODULE_PARM_DESC(debug, "Debug level (0 - 2)");
43
44 MODULE_LICENSE("GPL");
45 MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>");
46 MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter");
47 MODULE_VERSION("0.0.1");
48
49 static const char *si4713_supply_names[SI4713_NUM_SUPPLIES] = {
50 "vio",
51 "vdd",
52 };
53
54 #define DEFAULT_RDS_PI 0x00
55 #define DEFAULT_RDS_PTY 0x00
56 #define DEFAULT_RDS_PS_NAME ""
57 #define DEFAULT_RDS_RADIO_TEXT DEFAULT_RDS_PS_NAME
58 #define DEFAULT_RDS_DEVIATION 0x00C8
59 #define DEFAULT_RDS_PS_REPEAT_COUNT 0x0003
60 #define DEFAULT_LIMITER_RTIME 0x1392
61 #define DEFAULT_LIMITER_DEV 0x102CA
62 #define DEFAULT_PILOT_FREQUENCY 0x4A38
63 #define DEFAULT_PILOT_DEVIATION 0x1A5E
64 #define DEFAULT_ACOMP_ATIME 0x0000
65 #define DEFAULT_ACOMP_RTIME 0xF4240L
66 #define DEFAULT_ACOMP_GAIN 0x0F
67 #define DEFAULT_ACOMP_THRESHOLD (-0x28)
68 #define DEFAULT_MUTE 0x01
69 #define DEFAULT_POWER_LEVEL 88
70 #define DEFAULT_FREQUENCY 8800
71 #define DEFAULT_PREEMPHASIS FMPE_EU
72 #define DEFAULT_TUNE_RNL 0xFF
73
74 #define to_si4713_device(sd) container_of(sd, struct si4713_device, sd)
75
76 /* frequency domain transformation (using times 10 to avoid floats) */
77 #define FREQDEV_UNIT 100000
78 #define FREQV4L2_MULTI 625
79 #define si4713_to_v4l2(f) ((f * FREQDEV_UNIT) / FREQV4L2_MULTI)
80 #define v4l2_to_si4713(f) ((f * FREQV4L2_MULTI) / FREQDEV_UNIT)
81 #define FREQ_RANGE_LOW 7600
82 #define FREQ_RANGE_HIGH 10800
83
84 #define MAX_ARGS 7
85
86 #define RDS_BLOCK 8
87 #define RDS_BLOCK_CLEAR 0x03
88 #define RDS_BLOCK_LOAD 0x04
89 #define RDS_RADIOTEXT_2A 0x20
90 #define RDS_RADIOTEXT_BLK_SIZE 4
91 #define RDS_RADIOTEXT_INDEX_MAX 0x0F
92 #define RDS_CARRIAGE_RETURN 0x0D
93
94 #define rds_ps_nblocks(len) ((len / RDS_BLOCK) + (len % RDS_BLOCK ? 1 : 0))
95
96 #define get_status_bit(p, b, m) (((p) & (m)) >> (b))
97 #define set_bits(p, v, b, m) (((p) & ~(m)) | ((v) << (b)))
98
99 #define ATTACK_TIME_UNIT 500
100
101 #define POWER_OFF 0x00
102 #define POWER_ON 0x01
103
104 #define msb(x) ((u8)((u16) x >> 8))
105 #define lsb(x) ((u8)((u16) x & 0x00FF))
106 #define compose_u16(msb, lsb) (((u16)msb << 8) | lsb)
107 #define check_command_failed(status) (!(status & SI4713_CTS) || \
108 (status & SI4713_ERR))
109 /* mute definition */
110 #define set_mute(p) ((p & 1) | ((p & 1) << 1));
111 #define get_mute(p) (p & 0x01)
112
113 #ifdef DEBUG
114 #define DBG_BUFFER(device, message, buffer, size) \
115 { \
116 int i; \
117 char str[(size)*5]; \
118 for (i = 0; i < size; i++) \
119 sprintf(str + i * 5, " 0x%02x", buffer[i]); \
120 v4l2_dbg(2, debug, device, "%s:%s\n", message, str); \
121 }
122 #else
123 #define DBG_BUFFER(device, message, buffer, size)
124 #endif
125
126 /*
127 * Values for limiter release time (sorted by second column)
128 * device release
129 * value time (us)
130 */
131 static long limiter_times[] = {
132 2000, 250,
133 1000, 500,
134 510, 1000,
135 255, 2000,
136 170, 3000,
137 127, 4020,
138 102, 5010,
139 85, 6020,
140 73, 7010,
141 64, 7990,
142 57, 8970,
143 51, 10030,
144 25, 20470,
145 17, 30110,
146 13, 39380,
147 10, 51190,
148 8, 63690,
149 7, 73140,
150 6, 85330,
151 5, 102390,
152 };
153
154 /*
155 * Values for audio compression release time (sorted by second column)
156 * device release
157 * value time (us)
158 */
159 static unsigned long acomp_rtimes[] = {
160 0, 100000,
161 1, 200000,
162 2, 350000,
163 3, 525000,
164 4, 1000000,
165 };
166
167 /*
168 * Values for preemphasis (sorted by second column)
169 * device preemphasis
170 * value value (v4l2)
171 */
172 static unsigned long preemphasis_values[] = {
173 FMPE_DISABLED, V4L2_PREEMPHASIS_DISABLED,
174 FMPE_EU, V4L2_PREEMPHASIS_50_uS,
175 FMPE_USA, V4L2_PREEMPHASIS_75_uS,
176 };
177
178 static int usecs_to_dev(unsigned long usecs, unsigned long const array[],
179 int size)
180 {
181 int i;
182 int rval = -EINVAL;
183
184 for (i = 0; i < size / 2; i++)
185 if (array[(i * 2) + 1] >= usecs) {
186 rval = array[i * 2];
187 break;
188 }
189
190 return rval;
191 }
192
193 static unsigned long dev_to_usecs(int value, unsigned long const array[],
194 int size)
195 {
196 int i;
197 int rval = -EINVAL;
198
199 for (i = 0; i < size / 2; i++)
200 if (array[i * 2] == value) {
201 rval = array[(i * 2) + 1];
202 break;
203 }
204
205 return rval;
206 }
207
208 /* si4713_handler: IRQ handler, just complete work */
209 static irqreturn_t si4713_handler(int irq, void *dev)
210 {
211 struct si4713_device *sdev = dev;
212
213 v4l2_dbg(2, debug, &sdev->sd,
214 "%s: sending signal to completion work.\n", __func__);
215 complete(&sdev->work);
216
217 return IRQ_HANDLED;
218 }
219
220 /*
221 * si4713_send_command - sends a command to si4713 and waits its response
222 * @sdev: si4713_device structure for the device we are communicating
223 * @command: command id
224 * @args: command arguments we are sending (up to 7)
225 * @argn: actual size of @args
226 * @response: buffer to place the expected response from the device (up to 15)
227 * @respn: actual size of @response
228 * @usecs: amount of time to wait before reading the response (in usecs)
229 */
230 static int si4713_send_command(struct si4713_device *sdev, const u8 command,
231 const u8 args[], const int argn,
232 u8 response[], const int respn, const int usecs)
233 {
234 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
235 u8 data1[MAX_ARGS + 1];
236 int err;
237
238 if (!client->adapter)
239 return -ENODEV;
240
241 /* First send the command and its arguments */
242 data1[0] = command;
243 memcpy(data1 + 1, args, argn);
244 DBG_BUFFER(&sdev->sd, "Parameters", data1, argn + 1);
245
246 err = i2c_master_send(client, data1, argn + 1);
247 if (err != argn + 1) {
248 v4l2_err(&sdev->sd, "Error while sending command 0x%02x\n",
249 command);
250 return (err > 0) ? -EIO : err;
251 }
252
253 /* Wait response from interrupt */
254 if (!wait_for_completion_timeout(&sdev->work,
255 usecs_to_jiffies(usecs) + 1))
256 v4l2_warn(&sdev->sd,
257 "(%s) Device took too much time to answer.\n",
258 __func__);
259
260 /* Then get the response */
261 err = i2c_master_recv(client, response, respn);
262 if (err != respn) {
263 v4l2_err(&sdev->sd,
264 "Error while reading response for command 0x%02x\n",
265 command);
266 return (err > 0) ? -EIO : err;
267 }
268
269 DBG_BUFFER(&sdev->sd, "Response", response, respn);
270 if (check_command_failed(response[0]))
271 return -EBUSY;
272
273 return 0;
274 }
275
276 /*
277 * si4713_read_property - reads a si4713 property
278 * @sdev: si4713_device structure for the device we are communicating
279 * @prop: property identification number
280 * @pv: property value to be returned on success
281 */
282 static int si4713_read_property(struct si4713_device *sdev, u16 prop, u32 *pv)
283 {
284 int err;
285 u8 val[SI4713_GET_PROP_NRESP];
286 /*
287 * .First byte = 0
288 * .Second byte = property's MSB
289 * .Third byte = property's LSB
290 */
291 const u8 args[SI4713_GET_PROP_NARGS] = {
292 0x00,
293 msb(prop),
294 lsb(prop),
295 };
296
297 err = si4713_send_command(sdev, SI4713_CMD_GET_PROPERTY,
298 args, ARRAY_SIZE(args), val,
299 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
300
301 if (err < 0)
302 return err;
303
304 *pv = compose_u16(val[2], val[3]);
305
306 v4l2_dbg(1, debug, &sdev->sd,
307 "%s: property=0x%02x value=0x%02x status=0x%02x\n",
308 __func__, prop, *pv, val[0]);
309
310 return err;
311 }
312
313 /*
314 * si4713_write_property - modifies a si4713 property
315 * @sdev: si4713_device structure for the device we are communicating
316 * @prop: property identification number
317 * @val: new value for that property
318 */
319 static int si4713_write_property(struct si4713_device *sdev, u16 prop, u16 val)
320 {
321 int rval;
322 u8 resp[SI4713_SET_PROP_NRESP];
323 /*
324 * .First byte = 0
325 * .Second byte = property's MSB
326 * .Third byte = property's LSB
327 * .Fourth byte = value's MSB
328 * .Fifth byte = value's LSB
329 */
330 const u8 args[SI4713_SET_PROP_NARGS] = {
331 0x00,
332 msb(prop),
333 lsb(prop),
334 msb(val),
335 lsb(val),
336 };
337
338 rval = si4713_send_command(sdev, SI4713_CMD_SET_PROPERTY,
339 args, ARRAY_SIZE(args),
340 resp, ARRAY_SIZE(resp),
341 DEFAULT_TIMEOUT);
342
343 if (rval < 0)
344 return rval;
345
346 v4l2_dbg(1, debug, &sdev->sd,
347 "%s: property=0x%02x value=0x%02x status=0x%02x\n",
348 __func__, prop, val, resp[0]);
349
350 /*
351 * As there is no command response for SET_PROPERTY,
352 * wait Tcomp time to finish before proceed, in order
353 * to have property properly set.
354 */
355 msleep(TIMEOUT_SET_PROPERTY);
356
357 return rval;
358 }
359
360 /*
361 * si4713_powerup - Powers the device up
362 * @sdev: si4713_device structure for the device we are communicating
363 */
364 static int si4713_powerup(struct si4713_device *sdev)
365 {
366 int err;
367 u8 resp[SI4713_PWUP_NRESP];
368 /*
369 * .First byte = Enabled interrupts and boot function
370 * .Second byte = Input operation mode
371 */
372 const u8 args[SI4713_PWUP_NARGS] = {
373 SI4713_PWUP_CTSIEN | SI4713_PWUP_GPO2OEN | SI4713_PWUP_FUNC_TX,
374 SI4713_PWUP_OPMOD_ANALOG,
375 };
376
377 if (sdev->power_state)
378 return 0;
379
380 err = regulator_bulk_enable(ARRAY_SIZE(sdev->supplies),
381 sdev->supplies);
382 if (err) {
383 v4l2_err(&sdev->sd, "Failed to enable supplies: %d\n", err);
384 return err;
385 }
386 if (gpio_is_valid(sdev->gpio_reset)) {
387 udelay(50);
388 gpio_set_value(sdev->gpio_reset, 1);
389 }
390
391 err = si4713_send_command(sdev, SI4713_CMD_POWER_UP,
392 args, ARRAY_SIZE(args),
393 resp, ARRAY_SIZE(resp),
394 TIMEOUT_POWER_UP);
395
396 if (!err) {
397 v4l2_dbg(1, debug, &sdev->sd, "Powerup response: 0x%02x\n",
398 resp[0]);
399 v4l2_dbg(1, debug, &sdev->sd, "Device in power up mode\n");
400 sdev->power_state = POWER_ON;
401
402 err = si4713_write_property(sdev, SI4713_GPO_IEN,
403 SI4713_STC_INT | SI4713_CTS);
404 } else {
405 if (gpio_is_valid(sdev->gpio_reset))
406 gpio_set_value(sdev->gpio_reset, 0);
407 err = regulator_bulk_disable(ARRAY_SIZE(sdev->supplies),
408 sdev->supplies);
409 if (err)
410 v4l2_err(&sdev->sd,
411 "Failed to disable supplies: %d\n", err);
412 }
413
414 return err;
415 }
416
417 /*
418 * si4713_powerdown - Powers the device down
419 * @sdev: si4713_device structure for the device we are communicating
420 */
421 static int si4713_powerdown(struct si4713_device *sdev)
422 {
423 int err;
424 u8 resp[SI4713_PWDN_NRESP];
425
426 if (!sdev->power_state)
427 return 0;
428
429 err = si4713_send_command(sdev, SI4713_CMD_POWER_DOWN,
430 NULL, 0,
431 resp, ARRAY_SIZE(resp),
432 DEFAULT_TIMEOUT);
433
434 if (!err) {
435 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n",
436 resp[0]);
437 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n");
438 if (gpio_is_valid(sdev->gpio_reset))
439 gpio_set_value(sdev->gpio_reset, 0);
440 err = regulator_bulk_disable(ARRAY_SIZE(sdev->supplies),
441 sdev->supplies);
442 if (err)
443 v4l2_err(&sdev->sd,
444 "Failed to disable supplies: %d\n", err);
445 sdev->power_state = POWER_OFF;
446 }
447
448 return err;
449 }
450
451 /*
452 * si4713_checkrev - Checks if we are treating a device with the correct rev.
453 * @sdev: si4713_device structure for the device we are communicating
454 */
455 static int si4713_checkrev(struct si4713_device *sdev)
456 {
457 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd);
458 int rval;
459 u8 resp[SI4713_GETREV_NRESP];
460
461 mutex_lock(&sdev->mutex);
462
463 rval = si4713_send_command(sdev, SI4713_CMD_GET_REV,
464 NULL, 0,
465 resp, ARRAY_SIZE(resp),
466 DEFAULT_TIMEOUT);
467
468 if (rval < 0)
469 goto unlock;
470
471 if (resp[1] == SI4713_PRODUCT_NUMBER) {
472 v4l2_info(&sdev->sd, "chip found @ 0x%02x (%s)\n",
473 client->addr << 1, client->adapter->name);
474 } else {
475 v4l2_err(&sdev->sd, "Invalid product number\n");
476 rval = -EINVAL;
477 }
478
479 unlock:
480 mutex_unlock(&sdev->mutex);
481 return rval;
482 }
483
484 /*
485 * si4713_wait_stc - Waits STC interrupt and clears status bits. Useful
486 * for TX_TUNE_POWER, TX_TUNE_FREQ and TX_TUNE_MEAS
487 * @sdev: si4713_device structure for the device we are communicating
488 * @usecs: timeout to wait for STC interrupt signal
489 */
490 static int si4713_wait_stc(struct si4713_device *sdev, const int usecs)
491 {
492 int err;
493 u8 resp[SI4713_GET_STATUS_NRESP];
494
495 /* Wait response from STC interrupt */
496 if (!wait_for_completion_timeout(&sdev->work,
497 usecs_to_jiffies(usecs) + 1))
498 v4l2_warn(&sdev->sd,
499 "%s: device took too much time to answer (%d usec).\n",
500 __func__, usecs);
501
502 /* Clear status bits */
503 err = si4713_send_command(sdev, SI4713_CMD_GET_INT_STATUS,
504 NULL, 0,
505 resp, ARRAY_SIZE(resp),
506 DEFAULT_TIMEOUT);
507
508 if (err < 0)
509 goto exit;
510
511 v4l2_dbg(1, debug, &sdev->sd,
512 "%s: status bits: 0x%02x\n", __func__, resp[0]);
513
514 if (!(resp[0] & SI4713_STC_INT))
515 err = -EIO;
516
517 exit:
518 return err;
519 }
520
521 /*
522 * si4713_tx_tune_freq - Sets the state of the RF carrier and sets the tuning
523 * frequency between 76 and 108 MHz in 10 kHz units and
524 * steps of 50 kHz.
525 * @sdev: si4713_device structure for the device we are communicating
526 * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz)
527 */
528 static int si4713_tx_tune_freq(struct si4713_device *sdev, u16 frequency)
529 {
530 int err;
531 u8 val[SI4713_TXFREQ_NRESP];
532 /*
533 * .First byte = 0
534 * .Second byte = frequency's MSB
535 * .Third byte = frequency's LSB
536 */
537 const u8 args[SI4713_TXFREQ_NARGS] = {
538 0x00,
539 msb(frequency),
540 lsb(frequency),
541 };
542
543 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_FREQ,
544 args, ARRAY_SIZE(args), val,
545 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
546
547 if (err < 0)
548 return err;
549
550 v4l2_dbg(1, debug, &sdev->sd,
551 "%s: frequency=0x%02x status=0x%02x\n", __func__,
552 frequency, val[0]);
553
554 err = si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
555 if (err < 0)
556 return err;
557
558 return compose_u16(args[1], args[2]);
559 }
560
561 /*
562 * si4713_tx_tune_power - Sets the RF voltage level between 88 and 115 dBuV in
563 * 1 dB units. A value of 0x00 indicates off. The command
564 * also sets the antenna tuning capacitance. A value of 0
565 * indicates autotuning, and a value of 1 - 191 indicates
566 * a manual override, which results in a tuning
567 * capacitance of 0.25 pF x @antcap.
568 * @sdev: si4713_device structure for the device we are communicating
569 * @power: tuning power (88 - 115 dBuV, unit/step 1 dB)
570 * @antcap: value of antenna tuning capacitor (0 - 191)
571 */
572 static int si4713_tx_tune_power(struct si4713_device *sdev, u8 power,
573 u8 antcap)
574 {
575 int err;
576 u8 val[SI4713_TXPWR_NRESP];
577 /*
578 * .First byte = 0
579 * .Second byte = 0
580 * .Third byte = power
581 * .Fourth byte = antcap
582 */
583 const u8 args[SI4713_TXPWR_NARGS] = {
584 0x00,
585 0x00,
586 power,
587 antcap,
588 };
589
590 if (((power > 0) && (power < SI4713_MIN_POWER)) ||
591 power > SI4713_MAX_POWER || antcap > SI4713_MAX_ANTCAP)
592 return -EDOM;
593
594 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_POWER,
595 args, ARRAY_SIZE(args), val,
596 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
597
598 if (err < 0)
599 return err;
600
601 v4l2_dbg(1, debug, &sdev->sd,
602 "%s: power=0x%02x antcap=0x%02x status=0x%02x\n",
603 __func__, power, antcap, val[0]);
604
605 return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE_POWER);
606 }
607
608 /*
609 * si4713_tx_tune_measure - Enters receive mode and measures the received noise
610 * level in units of dBuV on the selected frequency.
611 * The Frequency must be between 76 and 108 MHz in 10 kHz
612 * units and steps of 50 kHz. The command also sets the
613 * antenna tuning capacitance. A value of 0 means
614 * autotuning, and a value of 1 to 191 indicates manual
615 * override.
616 * @sdev: si4713_device structure for the device we are communicating
617 * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz)
618 * @antcap: value of antenna tuning capacitor (0 - 191)
619 */
620 static int si4713_tx_tune_measure(struct si4713_device *sdev, u16 frequency,
621 u8 antcap)
622 {
623 int err;
624 u8 val[SI4713_TXMEA_NRESP];
625 /*
626 * .First byte = 0
627 * .Second byte = frequency's MSB
628 * .Third byte = frequency's LSB
629 * .Fourth byte = antcap
630 */
631 const u8 args[SI4713_TXMEA_NARGS] = {
632 0x00,
633 msb(frequency),
634 lsb(frequency),
635 antcap,
636 };
637
638 sdev->tune_rnl = DEFAULT_TUNE_RNL;
639
640 if (antcap > SI4713_MAX_ANTCAP)
641 return -EDOM;
642
643 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_MEASURE,
644 args, ARRAY_SIZE(args), val,
645 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
646
647 if (err < 0)
648 return err;
649
650 v4l2_dbg(1, debug, &sdev->sd,
651 "%s: frequency=0x%02x antcap=0x%02x status=0x%02x\n",
652 __func__, frequency, antcap, val[0]);
653
654 return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE);
655 }
656
657 /*
658 * si4713_tx_tune_status- Returns the status of the tx_tune_freq, tx_tune_mea or
659 * tx_tune_power commands. This command return the current
660 * frequency, output voltage in dBuV, the antenna tunning
661 * capacitance value and the received noise level. The
662 * command also clears the stcint interrupt bit when the
663 * first bit of its arguments is high.
664 * @sdev: si4713_device structure for the device we are communicating
665 * @intack: 0x01 to clear the seek/tune complete interrupt status indicator.
666 * @frequency: returned frequency
667 * @power: returned power
668 * @antcap: returned antenna capacitance
669 * @noise: returned noise level
670 */
671 static int si4713_tx_tune_status(struct si4713_device *sdev, u8 intack,
672 u16 *frequency, u8 *power,
673 u8 *antcap, u8 *noise)
674 {
675 int err;
676 u8 val[SI4713_TXSTATUS_NRESP];
677 /*
678 * .First byte = intack bit
679 */
680 const u8 args[SI4713_TXSTATUS_NARGS] = {
681 intack & SI4713_INTACK_MASK,
682 };
683
684 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_STATUS,
685 args, ARRAY_SIZE(args), val,
686 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
687
688 if (!err) {
689 v4l2_dbg(1, debug, &sdev->sd,
690 "%s: status=0x%02x\n", __func__, val[0]);
691 *frequency = compose_u16(val[2], val[3]);
692 sdev->frequency = *frequency;
693 *power = val[5];
694 *antcap = val[6];
695 *noise = val[7];
696 v4l2_dbg(1, debug, &sdev->sd, "%s: response: %d x 10 kHz "
697 "(power %d, antcap %d, rnl %d)\n", __func__,
698 *frequency, *power, *antcap, *noise);
699 }
700
701 return err;
702 }
703
704 /*
705 * si4713_tx_rds_buff - Loads the RDS group buffer FIFO or circular buffer.
706 * @sdev: si4713_device structure for the device we are communicating
707 * @mode: the buffer operation mode.
708 * @rdsb: RDS Block B
709 * @rdsc: RDS Block C
710 * @rdsd: RDS Block D
711 * @cbleft: returns the number of available circular buffer blocks minus the
712 * number of used circular buffer blocks.
713 */
714 static int si4713_tx_rds_buff(struct si4713_device *sdev, u8 mode, u16 rdsb,
715 u16 rdsc, u16 rdsd, s8 *cbleft)
716 {
717 int err;
718 u8 val[SI4713_RDSBUFF_NRESP];
719
720 const u8 args[SI4713_RDSBUFF_NARGS] = {
721 mode & SI4713_RDSBUFF_MODE_MASK,
722 msb(rdsb),
723 lsb(rdsb),
724 msb(rdsc),
725 lsb(rdsc),
726 msb(rdsd),
727 lsb(rdsd),
728 };
729
730 err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_BUFF,
731 args, ARRAY_SIZE(args), val,
732 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
733
734 if (!err) {
735 v4l2_dbg(1, debug, &sdev->sd,
736 "%s: status=0x%02x\n", __func__, val[0]);
737 *cbleft = (s8)val[2] - val[3];
738 v4l2_dbg(1, debug, &sdev->sd, "%s: response: interrupts"
739 " 0x%02x cb avail: %d cb used %d fifo avail"
740 " %d fifo used %d\n", __func__, val[1],
741 val[2], val[3], val[4], val[5]);
742 }
743
744 return err;
745 }
746
747 /*
748 * si4713_tx_rds_ps - Loads the program service buffer.
749 * @sdev: si4713_device structure for the device we are communicating
750 * @psid: program service id to be loaded.
751 * @pschar: assumed 4 size char array to be loaded into the program service
752 */
753 static int si4713_tx_rds_ps(struct si4713_device *sdev, u8 psid,
754 unsigned char *pschar)
755 {
756 int err;
757 u8 val[SI4713_RDSPS_NRESP];
758
759 const u8 args[SI4713_RDSPS_NARGS] = {
760 psid & SI4713_RDSPS_PSID_MASK,
761 pschar[0],
762 pschar[1],
763 pschar[2],
764 pschar[3],
765 };
766
767 err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_PS,
768 args, ARRAY_SIZE(args), val,
769 ARRAY_SIZE(val), DEFAULT_TIMEOUT);
770
771 if (err < 0)
772 return err;
773
774 v4l2_dbg(1, debug, &sdev->sd, "%s: status=0x%02x\n", __func__, val[0]);
775
776 return err;
777 }
778
779 static int si4713_set_power_state(struct si4713_device *sdev, u8 value)
780 {
781 int rval;
782
783 mutex_lock(&sdev->mutex);
784
785 if (value)
786 rval = si4713_powerup(sdev);
787 else
788 rval = si4713_powerdown(sdev);
789
790 mutex_unlock(&sdev->mutex);
791 return rval;
792 }
793
794 static int si4713_set_mute(struct si4713_device *sdev, u16 mute)
795 {
796 int rval = 0;
797
798 mute = set_mute(mute);
799
800 mutex_lock(&sdev->mutex);
801
802 if (sdev->power_state)
803 rval = si4713_write_property(sdev,
804 SI4713_TX_LINE_INPUT_MUTE, mute);
805
806 if (rval >= 0)
807 sdev->mute = get_mute(mute);
808
809 mutex_unlock(&sdev->mutex);
810
811 return rval;
812 }
813
814 static int si4713_set_rds_ps_name(struct si4713_device *sdev, char *ps_name)
815 {
816 int rval = 0, i;
817 u8 len = 0;
818
819 /* We want to clear the whole thing */
820 if (!strlen(ps_name))
821 memset(ps_name, 0, MAX_RDS_PS_NAME + 1);
822
823 mutex_lock(&sdev->mutex);
824
825 if (sdev->power_state) {
826 /* Write the new ps name and clear the padding */
827 for (i = 0; i < MAX_RDS_PS_NAME; i += (RDS_BLOCK / 2)) {
828 rval = si4713_tx_rds_ps(sdev, (i / (RDS_BLOCK / 2)),
829 ps_name + i);
830 if (rval < 0)
831 goto unlock;
832 }
833
834 /* Setup the size to be sent */
835 if (strlen(ps_name))
836 len = strlen(ps_name) - 1;
837 else
838 len = 1;
839
840 rval = si4713_write_property(sdev,
841 SI4713_TX_RDS_PS_MESSAGE_COUNT,
842 rds_ps_nblocks(len));
843 if (rval < 0)
844 goto unlock;
845
846 rval = si4713_write_property(sdev,
847 SI4713_TX_RDS_PS_REPEAT_COUNT,
848 DEFAULT_RDS_PS_REPEAT_COUNT * 2);
849 if (rval < 0)
850 goto unlock;
851 }
852
853 strncpy(sdev->rds_info.ps_name, ps_name, MAX_RDS_PS_NAME);
854
855 unlock:
856 mutex_unlock(&sdev->mutex);
857 return rval;
858 }
859
860 static int si4713_set_rds_radio_text(struct si4713_device *sdev, char *rt)
861 {
862 int rval = 0, i;
863 u16 t_index = 0;
864 u8 b_index = 0, cr_inserted = 0;
865 s8 left;
866
867 mutex_lock(&sdev->mutex);
868
869 if (!sdev->power_state)
870 goto copy;
871
872 rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_CLEAR, 0, 0, 0, &left);
873 if (rval < 0)
874 goto unlock;
875
876 if (!strlen(rt))
877 goto copy;
878
879 do {
880 /* RDS spec says that if the last block isn't used,
881 * then apply a carriage return
882 */
883 if (t_index < (RDS_RADIOTEXT_INDEX_MAX *
884 RDS_RADIOTEXT_BLK_SIZE)) {
885 for (i = 0; i < RDS_RADIOTEXT_BLK_SIZE; i++) {
886 if (!rt[t_index + i] || rt[t_index + i] ==
887 RDS_CARRIAGE_RETURN) {
888 rt[t_index + i] = RDS_CARRIAGE_RETURN;
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 goto unlock;
902
903 t_index += RDS_RADIOTEXT_BLK_SIZE;
904
905 if (cr_inserted)
906 break;
907 } while (left > 0);
908
909 copy:
910 strncpy(sdev->rds_info.radio_text, rt, MAX_RDS_RADIO_TEXT);
911
912 unlock:
913 mutex_unlock(&sdev->mutex);
914 return rval;
915 }
916
917 static int si4713_choose_econtrol_action(struct si4713_device *sdev, u32 id,
918 u32 **shadow, s32 *bit, s32 *mask, u16 *property, int *mul,
919 unsigned long **table, int *size)
920 {
921 s32 rval = 0;
922
923 switch (id) {
924 /* FM_TX class controls */
925 case V4L2_CID_RDS_TX_PI:
926 *property = SI4713_TX_RDS_PI;
927 *mul = 1;
928 *shadow = &sdev->rds_info.pi;
929 break;
930 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
931 *property = SI4713_TX_ACOMP_THRESHOLD;
932 *mul = 1;
933 *shadow = &sdev->acomp_info.threshold;
934 break;
935 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
936 *property = SI4713_TX_ACOMP_GAIN;
937 *mul = 1;
938 *shadow = &sdev->acomp_info.gain;
939 break;
940 case V4L2_CID_PILOT_TONE_FREQUENCY:
941 *property = SI4713_TX_PILOT_FREQUENCY;
942 *mul = 1;
943 *shadow = &sdev->pilot_info.frequency;
944 break;
945 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
946 *property = SI4713_TX_ACOMP_ATTACK_TIME;
947 *mul = ATTACK_TIME_UNIT;
948 *shadow = &sdev->acomp_info.attack_time;
949 break;
950 case V4L2_CID_PILOT_TONE_DEVIATION:
951 *property = SI4713_TX_PILOT_DEVIATION;
952 *mul = 10;
953 *shadow = &sdev->pilot_info.deviation;
954 break;
955 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
956 *property = SI4713_TX_AUDIO_DEVIATION;
957 *mul = 10;
958 *shadow = &sdev->limiter_info.deviation;
959 break;
960 case V4L2_CID_RDS_TX_DEVIATION:
961 *property = SI4713_TX_RDS_DEVIATION;
962 *mul = 1;
963 *shadow = &sdev->rds_info.deviation;
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 *shadow = &sdev->rds_info.pty;
971 break;
972 case V4L2_CID_AUDIO_LIMITER_ENABLED:
973 *property = SI4713_TX_ACOMP_ENABLE;
974 *bit = 1;
975 *mask = 1 << 1;
976 *shadow = &sdev->limiter_info.enabled;
977 break;
978 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
979 *property = SI4713_TX_ACOMP_ENABLE;
980 *bit = 0;
981 *mask = 1 << 0;
982 *shadow = &sdev->acomp_info.enabled;
983 break;
984 case V4L2_CID_PILOT_TONE_ENABLED:
985 *property = SI4713_TX_COMPONENT_ENABLE;
986 *bit = 0;
987 *mask = 1 << 0;
988 *shadow = &sdev->pilot_info.enabled;
989 break;
990
991 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
992 *property = SI4713_TX_LIMITER_RELEASE_TIME;
993 *table = limiter_times;
994 *size = ARRAY_SIZE(limiter_times);
995 *shadow = &sdev->limiter_info.release_time;
996 break;
997 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
998 *property = SI4713_TX_ACOMP_RELEASE_TIME;
999 *table = acomp_rtimes;
1000 *size = ARRAY_SIZE(acomp_rtimes);
1001 *shadow = &sdev->acomp_info.release_time;
1002 break;
1003 case V4L2_CID_TUNE_PREEMPHASIS:
1004 *property = SI4713_TX_PREEMPHASIS;
1005 *table = preemphasis_values;
1006 *size = ARRAY_SIZE(preemphasis_values);
1007 *shadow = &sdev->preemphasis;
1008 break;
1009
1010 default:
1011 rval = -EINVAL;
1012 };
1013
1014 return rval;
1015 }
1016
1017 static int si4713_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc);
1018
1019 /* write string property */
1020 static int si4713_write_econtrol_string(struct si4713_device *sdev,
1021 struct v4l2_ext_control *control)
1022 {
1023 struct v4l2_queryctrl vqc;
1024 int len;
1025 s32 rval = 0;
1026
1027 vqc.id = control->id;
1028 rval = si4713_queryctrl(&sdev->sd, &vqc);
1029 if (rval < 0)
1030 goto exit;
1031
1032 switch (control->id) {
1033 case V4L2_CID_RDS_TX_PS_NAME: {
1034 char ps_name[MAX_RDS_PS_NAME + 1];
1035
1036 len = control->size - 1;
1037 if (len < 0 || len > MAX_RDS_PS_NAME) {
1038 rval = -ERANGE;
1039 goto exit;
1040 }
1041 rval = copy_from_user(ps_name, control->string, len);
1042 if (rval) {
1043 rval = -EFAULT;
1044 goto exit;
1045 }
1046 ps_name[len] = '\0';
1047
1048 if (strlen(ps_name) % vqc.step) {
1049 rval = -ERANGE;
1050 goto exit;
1051 }
1052
1053 rval = si4713_set_rds_ps_name(sdev, ps_name);
1054 }
1055 break;
1056
1057 case V4L2_CID_RDS_TX_RADIO_TEXT: {
1058 char radio_text[MAX_RDS_RADIO_TEXT + 1];
1059
1060 len = control->size - 1;
1061 if (len < 0 || len > MAX_RDS_RADIO_TEXT) {
1062 rval = -ERANGE;
1063 goto exit;
1064 }
1065 rval = copy_from_user(radio_text, control->string, len);
1066 if (rval) {
1067 rval = -EFAULT;
1068 goto exit;
1069 }
1070 radio_text[len] = '\0';
1071
1072 if (strlen(radio_text) % vqc.step) {
1073 rval = -ERANGE;
1074 goto exit;
1075 }
1076
1077 rval = si4713_set_rds_radio_text(sdev, radio_text);
1078 }
1079 break;
1080
1081 default:
1082 rval = -EINVAL;
1083 break;
1084 };
1085
1086 exit:
1087 return rval;
1088 }
1089
1090 static int validate_range(struct v4l2_subdev *sd,
1091 struct v4l2_ext_control *control)
1092 {
1093 struct v4l2_queryctrl vqc;
1094 int rval;
1095
1096 vqc.id = control->id;
1097 rval = si4713_queryctrl(sd, &vqc);
1098 if (rval < 0)
1099 goto exit;
1100
1101 if (control->value < vqc.minimum || control->value > vqc.maximum)
1102 rval = -ERANGE;
1103
1104 exit:
1105 return rval;
1106 }
1107
1108 /* properties which use tx_tune_power*/
1109 static int si4713_write_econtrol_tune(struct si4713_device *sdev,
1110 struct v4l2_ext_control *control)
1111 {
1112 s32 rval = 0;
1113 u8 power, antcap;
1114
1115 rval = validate_range(&sdev->sd, control);
1116 if (rval < 0)
1117 goto exit;
1118
1119 mutex_lock(&sdev->mutex);
1120
1121 switch (control->id) {
1122 case V4L2_CID_TUNE_POWER_LEVEL:
1123 power = control->value;
1124 antcap = sdev->antenna_capacitor;
1125 break;
1126 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1127 power = sdev->power_level;
1128 antcap = control->value;
1129 break;
1130 default:
1131 rval = -EINVAL;
1132 goto unlock;
1133 };
1134
1135 if (sdev->power_state)
1136 rval = si4713_tx_tune_power(sdev, power, antcap);
1137
1138 if (rval == 0) {
1139 sdev->power_level = power;
1140 sdev->antenna_capacitor = antcap;
1141 }
1142
1143 unlock:
1144 mutex_unlock(&sdev->mutex);
1145 exit:
1146 return rval;
1147 }
1148
1149 static int si4713_write_econtrol_integers(struct si4713_device *sdev,
1150 struct v4l2_ext_control *control)
1151 {
1152 s32 rval;
1153 u32 *shadow = NULL, val = 0;
1154 s32 bit = 0, mask = 0;
1155 u16 property = 0;
1156 int mul = 0;
1157 unsigned long *table = NULL;
1158 int size = 0;
1159
1160 rval = validate_range(&sdev->sd, control);
1161 if (rval < 0)
1162 goto exit;
1163
1164 rval = si4713_choose_econtrol_action(sdev, control->id, &shadow, &bit,
1165 &mask, &property, &mul, &table, &size);
1166 if (rval < 0)
1167 goto exit;
1168
1169 val = control->value;
1170 if (mul) {
1171 val = control->value / mul;
1172 } else if (table) {
1173 rval = usecs_to_dev(control->value, table, size);
1174 if (rval < 0)
1175 goto exit;
1176 val = rval;
1177 rval = 0;
1178 }
1179
1180 mutex_lock(&sdev->mutex);
1181
1182 if (sdev->power_state) {
1183 if (mask) {
1184 rval = si4713_read_property(sdev, property, &val);
1185 if (rval < 0)
1186 goto unlock;
1187 val = set_bits(val, control->value, bit, mask);
1188 }
1189
1190 rval = si4713_write_property(sdev, property, val);
1191 if (rval < 0)
1192 goto unlock;
1193 if (mask)
1194 val = control->value;
1195 }
1196
1197 if (mul) {
1198 *shadow = val * mul;
1199 } else if (table) {
1200 rval = dev_to_usecs(val, table, size);
1201 if (rval < 0)
1202 goto unlock;
1203 *shadow = rval;
1204 rval = 0;
1205 } else {
1206 *shadow = val;
1207 }
1208
1209 unlock:
1210 mutex_unlock(&sdev->mutex);
1211 exit:
1212 return rval;
1213 }
1214
1215 static int si4713_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f);
1216 static int si4713_s_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *);
1217 /*
1218 * si4713_setup - Sets the device up with current configuration.
1219 * @sdev: si4713_device structure for the device we are communicating
1220 */
1221 static int si4713_setup(struct si4713_device *sdev)
1222 {
1223 struct v4l2_ext_control ctrl;
1224 struct v4l2_frequency f;
1225 struct v4l2_modulator vm;
1226 struct si4713_device *tmp;
1227 int rval = 0;
1228
1229 tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
1230 if (!tmp)
1231 return -ENOMEM;
1232
1233 /* Get a local copy to avoid race */
1234 mutex_lock(&sdev->mutex);
1235 memcpy(tmp, sdev, sizeof(*sdev));
1236 mutex_unlock(&sdev->mutex);
1237
1238 ctrl.id = V4L2_CID_RDS_TX_PI;
1239 ctrl.value = tmp->rds_info.pi;
1240 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1241
1242 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_THRESHOLD;
1243 ctrl.value = tmp->acomp_info.threshold;
1244 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1245
1246 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_GAIN;
1247 ctrl.value = tmp->acomp_info.gain;
1248 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1249
1250 ctrl.id = V4L2_CID_PILOT_TONE_FREQUENCY;
1251 ctrl.value = tmp->pilot_info.frequency;
1252 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1253
1254 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME;
1255 ctrl.value = tmp->acomp_info.attack_time;
1256 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1257
1258 ctrl.id = V4L2_CID_PILOT_TONE_DEVIATION;
1259 ctrl.value = tmp->pilot_info.deviation;
1260 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1261
1262 ctrl.id = V4L2_CID_AUDIO_LIMITER_DEVIATION;
1263 ctrl.value = tmp->limiter_info.deviation;
1264 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1265
1266 ctrl.id = V4L2_CID_RDS_TX_DEVIATION;
1267 ctrl.value = tmp->rds_info.deviation;
1268 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1269
1270 ctrl.id = V4L2_CID_RDS_TX_PTY;
1271 ctrl.value = tmp->rds_info.pty;
1272 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1273
1274 ctrl.id = V4L2_CID_AUDIO_LIMITER_ENABLED;
1275 ctrl.value = tmp->limiter_info.enabled;
1276 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1277
1278 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_ENABLED;
1279 ctrl.value = tmp->acomp_info.enabled;
1280 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1281
1282 ctrl.id = V4L2_CID_PILOT_TONE_ENABLED;
1283 ctrl.value = tmp->pilot_info.enabled;
1284 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1285
1286 ctrl.id = V4L2_CID_AUDIO_LIMITER_RELEASE_TIME;
1287 ctrl.value = tmp->limiter_info.release_time;
1288 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1289
1290 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME;
1291 ctrl.value = tmp->acomp_info.release_time;
1292 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1293
1294 ctrl.id = V4L2_CID_TUNE_PREEMPHASIS;
1295 ctrl.value = tmp->preemphasis;
1296 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1297
1298 ctrl.id = V4L2_CID_RDS_TX_PS_NAME;
1299 rval |= si4713_set_rds_ps_name(sdev, tmp->rds_info.ps_name);
1300
1301 ctrl.id = V4L2_CID_RDS_TX_RADIO_TEXT;
1302 rval |= si4713_set_rds_radio_text(sdev, tmp->rds_info.radio_text);
1303
1304 /* Device procedure needs to set frequency first */
1305 f.frequency = tmp->frequency ? tmp->frequency : DEFAULT_FREQUENCY;
1306 f.frequency = si4713_to_v4l2(f.frequency);
1307 rval |= si4713_s_frequency(&sdev->sd, &f);
1308
1309 ctrl.id = V4L2_CID_TUNE_POWER_LEVEL;
1310 ctrl.value = tmp->power_level;
1311 rval |= si4713_write_econtrol_tune(sdev, &ctrl);
1312
1313 ctrl.id = V4L2_CID_TUNE_ANTENNA_CAPACITOR;
1314 ctrl.value = tmp->antenna_capacitor;
1315 rval |= si4713_write_econtrol_tune(sdev, &ctrl);
1316
1317 vm.index = 0;
1318 if (tmp->stereo)
1319 vm.txsubchans = V4L2_TUNER_SUB_STEREO;
1320 else
1321 vm.txsubchans = V4L2_TUNER_SUB_MONO;
1322 if (tmp->rds_info.enabled)
1323 vm.txsubchans |= V4L2_TUNER_SUB_RDS;
1324 si4713_s_modulator(&sdev->sd, &vm);
1325
1326 kfree(tmp);
1327
1328 return rval;
1329 }
1330
1331 /*
1332 * si4713_initialize - Sets the device up with default configuration.
1333 * @sdev: si4713_device structure for the device we are communicating
1334 */
1335 static int si4713_initialize(struct si4713_device *sdev)
1336 {
1337 int rval;
1338
1339 rval = si4713_set_power_state(sdev, POWER_ON);
1340 if (rval < 0)
1341 goto exit;
1342
1343 rval = si4713_checkrev(sdev);
1344 if (rval < 0)
1345 goto exit;
1346
1347 rval = si4713_set_power_state(sdev, POWER_OFF);
1348 if (rval < 0)
1349 goto exit;
1350
1351 mutex_lock(&sdev->mutex);
1352
1353 sdev->rds_info.pi = DEFAULT_RDS_PI;
1354 sdev->rds_info.pty = DEFAULT_RDS_PTY;
1355 sdev->rds_info.deviation = DEFAULT_RDS_DEVIATION;
1356 strlcpy(sdev->rds_info.ps_name, DEFAULT_RDS_PS_NAME, MAX_RDS_PS_NAME);
1357 strlcpy(sdev->rds_info.radio_text, DEFAULT_RDS_RADIO_TEXT,
1358 MAX_RDS_RADIO_TEXT);
1359 sdev->rds_info.enabled = 1;
1360
1361 sdev->limiter_info.release_time = DEFAULT_LIMITER_RTIME;
1362 sdev->limiter_info.deviation = DEFAULT_LIMITER_DEV;
1363 sdev->limiter_info.enabled = 1;
1364
1365 sdev->pilot_info.deviation = DEFAULT_PILOT_DEVIATION;
1366 sdev->pilot_info.frequency = DEFAULT_PILOT_FREQUENCY;
1367 sdev->pilot_info.enabled = 1;
1368
1369 sdev->acomp_info.release_time = DEFAULT_ACOMP_RTIME;
1370 sdev->acomp_info.attack_time = DEFAULT_ACOMP_ATIME;
1371 sdev->acomp_info.threshold = DEFAULT_ACOMP_THRESHOLD;
1372 sdev->acomp_info.gain = DEFAULT_ACOMP_GAIN;
1373 sdev->acomp_info.enabled = 1;
1374
1375 sdev->frequency = DEFAULT_FREQUENCY;
1376 sdev->preemphasis = DEFAULT_PREEMPHASIS;
1377 sdev->mute = DEFAULT_MUTE;
1378 sdev->power_level = DEFAULT_POWER_LEVEL;
1379 sdev->antenna_capacitor = 0;
1380 sdev->stereo = 1;
1381 sdev->tune_rnl = DEFAULT_TUNE_RNL;
1382
1383 mutex_unlock(&sdev->mutex);
1384
1385 exit:
1386 return rval;
1387 }
1388
1389 /* read string property */
1390 static int si4713_read_econtrol_string(struct si4713_device *sdev,
1391 struct v4l2_ext_control *control)
1392 {
1393 s32 rval = 0;
1394
1395 switch (control->id) {
1396 case V4L2_CID_RDS_TX_PS_NAME:
1397 if (strlen(sdev->rds_info.ps_name) + 1 > control->size) {
1398 control->size = MAX_RDS_PS_NAME + 1;
1399 rval = -ENOSPC;
1400 goto exit;
1401 }
1402 rval = copy_to_user(control->string, sdev->rds_info.ps_name,
1403 strlen(sdev->rds_info.ps_name) + 1);
1404 if (rval)
1405 rval = -EFAULT;
1406 break;
1407
1408 case V4L2_CID_RDS_TX_RADIO_TEXT:
1409 if (strlen(sdev->rds_info.radio_text) + 1 > control->size) {
1410 control->size = MAX_RDS_RADIO_TEXT + 1;
1411 rval = -ENOSPC;
1412 goto exit;
1413 }
1414 rval = copy_to_user(control->string, sdev->rds_info.radio_text,
1415 strlen(sdev->rds_info.radio_text) + 1);
1416 if (rval)
1417 rval = -EFAULT;
1418 break;
1419
1420 default:
1421 rval = -EINVAL;
1422 break;
1423 };
1424
1425 exit:
1426 return rval;
1427 }
1428
1429 /*
1430 * si4713_update_tune_status - update properties from tx_tune_status
1431 * command. Must be called with sdev->mutex held.
1432 * @sdev: si4713_device structure for the device we are communicating
1433 */
1434 static int si4713_update_tune_status(struct si4713_device *sdev)
1435 {
1436 int rval;
1437 u16 f = 0;
1438 u8 p = 0, a = 0, n = 0;
1439
1440 rval = si4713_tx_tune_status(sdev, 0x00, &f, &p, &a, &n);
1441
1442 if (rval < 0)
1443 goto exit;
1444
1445 sdev->power_level = p;
1446 sdev->antenna_capacitor = a;
1447 sdev->tune_rnl = n;
1448
1449 exit:
1450 return rval;
1451 }
1452
1453 /* properties which use tx_tune_status */
1454 static int si4713_read_econtrol_tune(struct si4713_device *sdev,
1455 struct v4l2_ext_control *control)
1456 {
1457 s32 rval = 0;
1458
1459 mutex_lock(&sdev->mutex);
1460
1461 if (sdev->power_state) {
1462 rval = si4713_update_tune_status(sdev);
1463 if (rval < 0)
1464 goto unlock;
1465 }
1466
1467 switch (control->id) {
1468 case V4L2_CID_TUNE_POWER_LEVEL:
1469 control->value = sdev->power_level;
1470 break;
1471 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1472 control->value = sdev->antenna_capacitor;
1473 break;
1474 default:
1475 rval = -EINVAL;
1476 };
1477
1478 unlock:
1479 mutex_unlock(&sdev->mutex);
1480 return rval;
1481 }
1482
1483 static int si4713_read_econtrol_integers(struct si4713_device *sdev,
1484 struct v4l2_ext_control *control)
1485 {
1486 s32 rval;
1487 u32 *shadow = NULL, val = 0;
1488 s32 bit = 0, mask = 0;
1489 u16 property = 0;
1490 int mul = 0;
1491 unsigned long *table = NULL;
1492 int size = 0;
1493
1494 rval = si4713_choose_econtrol_action(sdev, control->id, &shadow, &bit,
1495 &mask, &property, &mul, &table, &size);
1496 if (rval < 0)
1497 goto exit;
1498
1499 mutex_lock(&sdev->mutex);
1500
1501 if (sdev->power_state) {
1502 rval = si4713_read_property(sdev, property, &val);
1503 if (rval < 0)
1504 goto unlock;
1505
1506 /* Keep negative values for threshold */
1507 if (control->id == V4L2_CID_AUDIO_COMPRESSION_THRESHOLD)
1508 *shadow = (s16)val;
1509 else if (mask)
1510 *shadow = get_status_bit(val, bit, mask);
1511 else if (mul)
1512 *shadow = val * mul;
1513 else
1514 *shadow = dev_to_usecs(val, table, size);
1515 }
1516
1517 control->value = *shadow;
1518
1519 unlock:
1520 mutex_unlock(&sdev->mutex);
1521 exit:
1522 return rval;
1523 }
1524
1525 /*
1526 * Video4Linux Subdev Interface
1527 */
1528 /* si4713_s_ext_ctrls - set extended controls value */
1529 static int si4713_s_ext_ctrls(struct v4l2_subdev *sd,
1530 struct v4l2_ext_controls *ctrls)
1531 {
1532 struct si4713_device *sdev = to_si4713_device(sd);
1533 int i;
1534
1535 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
1536 return -EINVAL;
1537
1538 for (i = 0; i < ctrls->count; i++) {
1539 int err;
1540
1541 switch ((ctrls->controls + i)->id) {
1542 case V4L2_CID_RDS_TX_PS_NAME:
1543 case V4L2_CID_RDS_TX_RADIO_TEXT:
1544 err = si4713_write_econtrol_string(sdev,
1545 ctrls->controls + i);
1546 break;
1547 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1548 case V4L2_CID_TUNE_POWER_LEVEL:
1549 err = si4713_write_econtrol_tune(sdev,
1550 ctrls->controls + i);
1551 break;
1552 default:
1553 err = si4713_write_econtrol_integers(sdev,
1554 ctrls->controls + i);
1555 }
1556
1557 if (err < 0) {
1558 ctrls->error_idx = i;
1559 return err;
1560 }
1561 }
1562
1563 return 0;
1564 }
1565
1566 /* si4713_g_ext_ctrls - get extended controls value */
1567 static int si4713_g_ext_ctrls(struct v4l2_subdev *sd,
1568 struct v4l2_ext_controls *ctrls)
1569 {
1570 struct si4713_device *sdev = to_si4713_device(sd);
1571 int i;
1572
1573 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
1574 return -EINVAL;
1575
1576 for (i = 0; i < ctrls->count; i++) {
1577 int err;
1578
1579 switch ((ctrls->controls + i)->id) {
1580 case V4L2_CID_RDS_TX_PS_NAME:
1581 case V4L2_CID_RDS_TX_RADIO_TEXT:
1582 err = si4713_read_econtrol_string(sdev,
1583 ctrls->controls + i);
1584 break;
1585 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1586 case V4L2_CID_TUNE_POWER_LEVEL:
1587 err = si4713_read_econtrol_tune(sdev,
1588 ctrls->controls + i);
1589 break;
1590 default:
1591 err = si4713_read_econtrol_integers(sdev,
1592 ctrls->controls + i);
1593 }
1594
1595 if (err < 0) {
1596 ctrls->error_idx = i;
1597 return err;
1598 }
1599 }
1600
1601 return 0;
1602 }
1603
1604 /* si4713_queryctrl - enumerate control items */
1605 static int si4713_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1606 {
1607 int rval = 0;
1608
1609 switch (qc->id) {
1610 /* User class controls */
1611 case V4L2_CID_AUDIO_MUTE:
1612 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, DEFAULT_MUTE);
1613 break;
1614 /* FM_TX class controls */
1615 case V4L2_CID_RDS_TX_PI:
1616 rval = v4l2_ctrl_query_fill(qc, 0, 0xFFFF, 1, DEFAULT_RDS_PI);
1617 break;
1618 case V4L2_CID_RDS_TX_PTY:
1619 rval = v4l2_ctrl_query_fill(qc, 0, 31, 1, DEFAULT_RDS_PTY);
1620 break;
1621 case V4L2_CID_RDS_TX_DEVIATION:
1622 rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_DEVIATION,
1623 10, DEFAULT_RDS_DEVIATION);
1624 break;
1625 case V4L2_CID_RDS_TX_PS_NAME:
1626 /*
1627 * Report step as 8. From RDS spec, psname
1628 * should be 8. But there are receivers which scroll strings
1629 * sized as 8xN.
1630 */
1631 rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_PS_NAME, 8, 0);
1632 break;
1633 case V4L2_CID_RDS_TX_RADIO_TEXT:
1634 /*
1635 * Report step as 32 (2A block). From RDS spec,
1636 * radio text should be 32 for 2A block. But there are receivers
1637 * which scroll strings sized as 32xN. Setting default to 32.
1638 */
1639 rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1640 break;
1641
1642 case V4L2_CID_AUDIO_LIMITER_ENABLED:
1643 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1644 break;
1645 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1646 rval = v4l2_ctrl_query_fill(qc, 250, MAX_LIMITER_RELEASE_TIME,
1647 50, DEFAULT_LIMITER_RTIME);
1648 break;
1649 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1650 rval = v4l2_ctrl_query_fill(qc, 0, MAX_LIMITER_DEVIATION,
1651 10, DEFAULT_LIMITER_DEV);
1652 break;
1653
1654 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1655 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1656 break;
1657 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1658 rval = v4l2_ctrl_query_fill(qc, 0, MAX_ACOMP_GAIN, 1,
1659 DEFAULT_ACOMP_GAIN);
1660 break;
1661 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1662 rval = v4l2_ctrl_query_fill(qc, MIN_ACOMP_THRESHOLD,
1663 MAX_ACOMP_THRESHOLD, 1,
1664 DEFAULT_ACOMP_THRESHOLD);
1665 break;
1666 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1667 rval = v4l2_ctrl_query_fill(qc, 0, MAX_ACOMP_ATTACK_TIME,
1668 500, DEFAULT_ACOMP_ATIME);
1669 break;
1670 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1671 rval = v4l2_ctrl_query_fill(qc, 100000, MAX_ACOMP_RELEASE_TIME,
1672 100000, DEFAULT_ACOMP_RTIME);
1673 break;
1674
1675 case V4L2_CID_PILOT_TONE_ENABLED:
1676 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1677 break;
1678 case V4L2_CID_PILOT_TONE_DEVIATION:
1679 rval = v4l2_ctrl_query_fill(qc, 0, MAX_PILOT_DEVIATION,
1680 10, DEFAULT_PILOT_DEVIATION);
1681 break;
1682 case V4L2_CID_PILOT_TONE_FREQUENCY:
1683 rval = v4l2_ctrl_query_fill(qc, 0, MAX_PILOT_FREQUENCY,
1684 1, DEFAULT_PILOT_FREQUENCY);
1685 break;
1686
1687 case V4L2_CID_TUNE_PREEMPHASIS:
1688 rval = v4l2_ctrl_query_fill(qc, V4L2_PREEMPHASIS_DISABLED,
1689 V4L2_PREEMPHASIS_75_uS, 1,
1690 V4L2_PREEMPHASIS_50_uS);
1691 break;
1692 case V4L2_CID_TUNE_POWER_LEVEL:
1693 rval = v4l2_ctrl_query_fill(qc, 0, 120, 1, DEFAULT_POWER_LEVEL);
1694 break;
1695 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1696 rval = v4l2_ctrl_query_fill(qc, 0, 191, 1, 0);
1697 break;
1698 default:
1699 rval = -EINVAL;
1700 break;
1701 };
1702
1703 return rval;
1704 }
1705
1706 /* si4713_g_ctrl - get the value of a control */
1707 static int si4713_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1708 {
1709 struct si4713_device *sdev = to_si4713_device(sd);
1710 int rval = 0;
1711
1712 if (!sdev)
1713 return -ENODEV;
1714
1715 mutex_lock(&sdev->mutex);
1716
1717 if (sdev->power_state) {
1718 rval = si4713_read_property(sdev, SI4713_TX_LINE_INPUT_MUTE,
1719 &sdev->mute);
1720
1721 if (rval < 0)
1722 goto unlock;
1723 }
1724
1725 switch (ctrl->id) {
1726 case V4L2_CID_AUDIO_MUTE:
1727 ctrl->value = get_mute(sdev->mute);
1728 break;
1729 }
1730
1731 unlock:
1732 mutex_unlock(&sdev->mutex);
1733 return rval;
1734 }
1735
1736 /* si4713_s_ctrl - set the value of a control */
1737 static int si4713_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1738 {
1739 struct si4713_device *sdev = to_si4713_device(sd);
1740 int rval = 0;
1741
1742 if (!sdev)
1743 return -ENODEV;
1744
1745 switch (ctrl->id) {
1746 case V4L2_CID_AUDIO_MUTE:
1747 if (ctrl->value) {
1748 rval = si4713_set_mute(sdev, ctrl->value);
1749 if (rval < 0)
1750 goto exit;
1751
1752 rval = si4713_set_power_state(sdev, POWER_DOWN);
1753 } else {
1754 rval = si4713_set_power_state(sdev, POWER_UP);
1755 if (rval < 0)
1756 goto exit;
1757
1758 rval = si4713_setup(sdev);
1759 if (rval < 0)
1760 goto exit;
1761
1762 rval = si4713_set_mute(sdev, ctrl->value);
1763 }
1764 break;
1765 }
1766
1767 exit:
1768 return rval;
1769 }
1770
1771 /* si4713_ioctl - deal with private ioctls (only rnl for now) */
1772 long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1773 {
1774 struct si4713_device *sdev = to_si4713_device(sd);
1775 struct si4713_rnl *rnl = arg;
1776 u16 frequency;
1777 int rval = 0;
1778
1779 if (!arg)
1780 return -EINVAL;
1781
1782 mutex_lock(&sdev->mutex);
1783 switch (cmd) {
1784 case SI4713_IOC_MEASURE_RNL:
1785 frequency = v4l2_to_si4713(rnl->frequency);
1786
1787 if (sdev->power_state) {
1788 /* Set desired measurement frequency */
1789 rval = si4713_tx_tune_measure(sdev, frequency, 0);
1790 if (rval < 0)
1791 goto unlock;
1792 /* get results from tune status */
1793 rval = si4713_update_tune_status(sdev);
1794 if (rval < 0)
1795 goto unlock;
1796 }
1797 rnl->rnl = sdev->tune_rnl;
1798 break;
1799
1800 default:
1801 /* nothing */
1802 rval = -ENOIOCTLCMD;
1803 }
1804
1805 unlock:
1806 mutex_unlock(&sdev->mutex);
1807 return rval;
1808 }
1809
1810 static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = {
1811 .queryctrl = si4713_queryctrl,
1812 .g_ext_ctrls = si4713_g_ext_ctrls,
1813 .s_ext_ctrls = si4713_s_ext_ctrls,
1814 .g_ctrl = si4713_g_ctrl,
1815 .s_ctrl = si4713_s_ctrl,
1816 .ioctl = si4713_ioctl,
1817 };
1818
1819 /* si4713_g_modulator - get modulator attributes */
1820 static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1821 {
1822 struct si4713_device *sdev = to_si4713_device(sd);
1823 int rval = 0;
1824
1825 if (!sdev) {
1826 rval = -ENODEV;
1827 goto exit;
1828 }
1829
1830 if (vm->index > 0) {
1831 rval = -EINVAL;
1832 goto exit;
1833 }
1834
1835 strncpy(vm->name, "FM Modulator", 32);
1836 vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW |
1837 V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_CONTROLS;
1838
1839 /* Report current frequency range limits */
1840 vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW);
1841 vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH);
1842
1843 mutex_lock(&sdev->mutex);
1844
1845 if (sdev->power_state) {
1846 u32 comp_en = 0;
1847
1848 rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE,
1849 &comp_en);
1850 if (rval < 0)
1851 goto unlock;
1852
1853 sdev->stereo = get_status_bit(comp_en, 1, 1 << 1);
1854 sdev->rds_info.enabled = get_status_bit(comp_en, 2, 1 << 2);
1855 }
1856
1857 /* Report current audio mode: mono or stereo */
1858 if (sdev->stereo)
1859 vm->txsubchans = V4L2_TUNER_SUB_STEREO;
1860 else
1861 vm->txsubchans = V4L2_TUNER_SUB_MONO;
1862
1863 /* Report rds feature status */
1864 if (sdev->rds_info.enabled)
1865 vm->txsubchans |= V4L2_TUNER_SUB_RDS;
1866 else
1867 vm->txsubchans &= ~V4L2_TUNER_SUB_RDS;
1868
1869 unlock:
1870 mutex_unlock(&sdev->mutex);
1871 exit:
1872 return rval;
1873 }
1874
1875 /* si4713_s_modulator - set modulator attributes */
1876 static int si4713_s_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1877 {
1878 struct si4713_device *sdev = to_si4713_device(sd);
1879 int rval = 0;
1880 u16 stereo, rds;
1881 u32 p;
1882
1883 if (!sdev)
1884 return -ENODEV;
1885
1886 if (vm->index > 0)
1887 return -EINVAL;
1888
1889 /* Set audio mode: mono or stereo */
1890 if (vm->txsubchans & V4L2_TUNER_SUB_STEREO)
1891 stereo = 1;
1892 else if (vm->txsubchans & V4L2_TUNER_SUB_MONO)
1893 stereo = 0;
1894 else
1895 return -EINVAL;
1896
1897 rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS);
1898
1899 mutex_lock(&sdev->mutex);
1900
1901 if (sdev->power_state) {
1902 rval = si4713_read_property(sdev,
1903 SI4713_TX_COMPONENT_ENABLE, &p);
1904 if (rval < 0)
1905 goto unlock;
1906
1907 p = set_bits(p, stereo, 1, 1 << 1);
1908 p = set_bits(p, rds, 2, 1 << 2);
1909
1910 rval = si4713_write_property(sdev,
1911 SI4713_TX_COMPONENT_ENABLE, p);
1912 if (rval < 0)
1913 goto unlock;
1914 }
1915
1916 sdev->stereo = stereo;
1917 sdev->rds_info.enabled = rds;
1918
1919 unlock:
1920 mutex_unlock(&sdev->mutex);
1921 return rval;
1922 }
1923
1924 /* si4713_g_frequency - get tuner or modulator radio frequency */
1925 static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1926 {
1927 struct si4713_device *sdev = to_si4713_device(sd);
1928 int rval = 0;
1929
1930 f->type = V4L2_TUNER_RADIO;
1931
1932 mutex_lock(&sdev->mutex);
1933
1934 if (sdev->power_state) {
1935 u16 freq;
1936 u8 p, a, n;
1937
1938 rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n);
1939 if (rval < 0)
1940 goto unlock;
1941
1942 sdev->frequency = freq;
1943 }
1944
1945 f->frequency = si4713_to_v4l2(sdev->frequency);
1946
1947 unlock:
1948 mutex_unlock(&sdev->mutex);
1949 return rval;
1950 }
1951
1952 /* si4713_s_frequency - set tuner or modulator radio frequency */
1953 static int si4713_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1954 {
1955 struct si4713_device *sdev = to_si4713_device(sd);
1956 int rval = 0;
1957 u16 frequency = v4l2_to_si4713(f->frequency);
1958
1959 /* Check frequency range */
1960 if (frequency < FREQ_RANGE_LOW || frequency > FREQ_RANGE_HIGH)
1961 return -EDOM;
1962
1963 mutex_lock(&sdev->mutex);
1964
1965 if (sdev->power_state) {
1966 rval = si4713_tx_tune_freq(sdev, frequency);
1967 if (rval < 0)
1968 goto unlock;
1969 frequency = rval;
1970 rval = 0;
1971 }
1972 sdev->frequency = frequency;
1973 f->frequency = si4713_to_v4l2(frequency);
1974
1975 unlock:
1976 mutex_unlock(&sdev->mutex);
1977 return rval;
1978 }
1979
1980 static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = {
1981 .g_frequency = si4713_g_frequency,
1982 .s_frequency = si4713_s_frequency,
1983 .g_modulator = si4713_g_modulator,
1984 .s_modulator = si4713_s_modulator,
1985 };
1986
1987 static const struct v4l2_subdev_ops si4713_subdev_ops = {
1988 .core = &si4713_subdev_core_ops,
1989 .tuner = &si4713_subdev_tuner_ops,
1990 };
1991
1992 /*
1993 * I2C driver interface
1994 */
1995 /* si4713_probe - probe for the device */
1996 static int si4713_probe(struct i2c_client *client,
1997 const struct i2c_device_id *id)
1998 {
1999 struct si4713_device *sdev;
2000 struct si4713_platform_data *pdata = client->dev.platform_data;
2001 int rval, i;
2002
2003 sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
2004 if (!sdev) {
2005 dev_err(&client->dev, "Failed to alloc video device.\n");
2006 rval = -ENOMEM;
2007 goto exit;
2008 }
2009
2010 sdev->gpio_reset = -1;
2011 if (pdata && gpio_is_valid(pdata->gpio_reset)) {
2012 rval = gpio_request(pdata->gpio_reset, "si4713 reset");
2013 if (rval) {
2014 dev_err(&client->dev,
2015 "Failed to request gpio: %d\n", rval);
2016 goto free_sdev;
2017 }
2018 sdev->gpio_reset = pdata->gpio_reset;
2019 gpio_direction_output(sdev->gpio_reset, 0);
2020 }
2021
2022 for (i = 0; i < ARRAY_SIZE(sdev->supplies); i++)
2023 sdev->supplies[i].supply = si4713_supply_names[i];
2024
2025 rval = regulator_bulk_get(&client->dev, ARRAY_SIZE(sdev->supplies),
2026 sdev->supplies);
2027 if (rval) {
2028 dev_err(&client->dev, "Cannot get regulators: %d\n", rval);
2029 goto free_gpio;
2030 }
2031
2032 v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
2033
2034 mutex_init(&sdev->mutex);
2035 init_completion(&sdev->work);
2036
2037 if (client->irq) {
2038 rval = request_irq(client->irq,
2039 si4713_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED,
2040 client->name, sdev);
2041 if (rval < 0) {
2042 v4l2_err(&sdev->sd, "Could not request IRQ\n");
2043 goto put_reg;
2044 }
2045 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
2046 } else {
2047 v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
2048 }
2049
2050 rval = si4713_initialize(sdev);
2051 if (rval < 0) {
2052 v4l2_err(&sdev->sd, "Failed to probe device information.\n");
2053 goto free_irq;
2054 }
2055
2056 return 0;
2057
2058 free_irq:
2059 if (client->irq)
2060 free_irq(client->irq, sdev);
2061 put_reg:
2062 regulator_bulk_free(ARRAY_SIZE(sdev->supplies), sdev->supplies);
2063 free_gpio:
2064 if (gpio_is_valid(sdev->gpio_reset))
2065 gpio_free(sdev->gpio_reset);
2066 free_sdev:
2067 kfree(sdev);
2068 exit:
2069 return rval;
2070 }
2071
2072 /* si4713_remove - remove the device */
2073 static int si4713_remove(struct i2c_client *client)
2074 {
2075 struct v4l2_subdev *sd = i2c_get_clientdata(client);
2076 struct si4713_device *sdev = to_si4713_device(sd);
2077
2078 if (sdev->power_state)
2079 si4713_set_power_state(sdev, POWER_DOWN);
2080
2081 if (client->irq > 0)
2082 free_irq(client->irq, sdev);
2083
2084 v4l2_device_unregister_subdev(sd);
2085 regulator_bulk_free(ARRAY_SIZE(sdev->supplies), sdev->supplies);
2086 if (gpio_is_valid(sdev->gpio_reset))
2087 gpio_free(sdev->gpio_reset);
2088 kfree(sdev);
2089
2090 return 0;
2091 }
2092
2093 /* si4713_i2c_driver - i2c driver interface */
2094 static const struct i2c_device_id si4713_id[] = {
2095 { "si4713" , 0 },
2096 { },
2097 };
2098 MODULE_DEVICE_TABLE(i2c, si4713_id);
2099
2100 static struct i2c_driver si4713_i2c_driver = {
2101 .driver = {
2102 .name = "si4713",
2103 },
2104 .probe = si4713_probe,
2105 .remove = si4713_remove,
2106 .id_table = si4713_id,
2107 };
2108
2109 /* Module Interface */
2110 static int __init si4713_module_init(void)
2111 {
2112 return i2c_add_driver(&si4713_i2c_driver);
2113 }
2114
2115 static void __exit si4713_module_exit(void)
2116 {
2117 i2c_del_driver(&si4713_i2c_driver);
2118 }
2119
2120 module_init(si4713_module_init);
2121 module_exit(si4713_module_exit);
2122
Linux with added FPC-III support