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