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