projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6-block.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);
1012 if (rval < 0)
1013 goto exit;
1014 ps_name[len] = '\0';
1015
1016 if (strlen(ps_name) % vqc.step) {
1017 rval = -ERANGE;
1018 goto exit;
1019 }
1020
1021 rval = si4713_set_rds_ps_name(sdev, ps_name);
1022 }
1023 break;
1024
1025 case V4L2_CID_RDS_TX_RADIO_TEXT: {
1026 char radio_text[MAX_RDS_RADIO_TEXT + 1];
1027
1028 len = control->size - 1;
1029 if (len > MAX_RDS_RADIO_TEXT) {
1030 rval = -ERANGE;
1031 goto exit;
1032 }
1033 rval = copy_from_user(radio_text, control->string, len);
1034 if (rval < 0)
1035 goto exit;
1036 radio_text[len] = '\0';
1037
1038 if (strlen(radio_text) % vqc.step) {
1039 rval = -ERANGE;
1040 goto exit;
1041 }
1042
1043 rval = si4713_set_rds_radio_text(sdev, radio_text);
1044 }
1045 break;
1046
1047 default:
1048 rval = -EINVAL;
1049 break;
1050 };
1051
1052exit:
1053 return rval;
1054}
1055
1056static int validate_range(struct v4l2_subdev *sd,
1057 struct v4l2_ext_control *control)
1058{
1059 struct v4l2_queryctrl vqc;
1060 int rval;
1061
1062 vqc.id = control->id;
1063 rval = si4713_queryctrl(sd, &vqc);
1064 if (rval < 0)
1065 goto exit;
1066
1067 if (control->value < vqc.minimum || control->value > vqc.maximum)
1068 rval = -ERANGE;
1069
1070exit:
1071 return rval;
1072}
1073
1074/* properties which use tx_tune_power*/
1075static int si4713_write_econtrol_tune(struct si4713_device *sdev,
1076 struct v4l2_ext_control *control)
1077{
1078 s32 rval = 0;
1079 u8 power, antcap;
1080
1081 rval = validate_range(&sdev->sd, control);
1082 if (rval < 0)
1083 goto exit;
1084
1085 mutex_lock(&sdev->mutex);
1086
1087 switch (control->id) {
1088 case V4L2_CID_TUNE_POWER_LEVEL:
1089 power = control->value;
1090 antcap = sdev->antenna_capacitor;
1091 break;
1092 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1093 power = sdev->power_level;
1094 antcap = control->value;
1095 break;
1096 default:
1097 rval = -EINVAL;
1098 goto unlock;
1099 };
1100
1101 if (sdev->power_state)
1102 rval = si4713_tx_tune_power(sdev, power, antcap);
1103
1104 if (rval == 0) {
1105 sdev->power_level = power;
1106 sdev->antenna_capacitor = antcap;
1107 }
1108
1109unlock:
1110 mutex_unlock(&sdev->mutex);
1111exit:
1112 return rval;
1113}
1114
1115static int si4713_write_econtrol_integers(struct si4713_device *sdev,
1116 struct v4l2_ext_control *control)
1117{
1118 s32 rval;
1119 u32 *shadow = NULL, val = 0;
1120 s32 bit = 0, mask = 0;
1121 u16 property = 0;
1122 int mul = 0;
1123 unsigned long *table = NULL;
1124 int size = 0;
1125
1126 rval = validate_range(&sdev->sd, control);
1127 if (rval < 0)
1128 goto exit;
1129
1130 rval = si4713_choose_econtrol_action(sdev, control->id, &shadow, &bit,
1131 &mask, &property, &mul, &table, &size);
1132 if (rval < 0)
1133 goto exit;
1134
1135 val = control->value;
1136 if (mul) {
1137 val = control->value / mul;
1138 } else if (table) {
1139 rval = usecs_to_dev(control->value, table, size);
1140 if (rval < 0)
1141 goto exit;
1142 val = rval;
1143 rval = 0;
1144 }
1145
1146 mutex_lock(&sdev->mutex);
1147
1148 if (sdev->power_state) {
1149 if (mask) {
1150 rval = si4713_read_property(sdev, property, &val);
1151 if (rval < 0)
1152 goto unlock;
1153 val = set_bits(val, control->value, bit, mask);
1154 }
1155
1156 rval = si4713_write_property(sdev, property, val);
1157 if (rval < 0)
1158 goto unlock;
1159 if (mask)
1160 val = control->value;
1161 }
1162
1163 if (mul) {
1164 *shadow = val * mul;
1165 } else if (table) {
1166 rval = dev_to_usecs(val, table, size);
1167 if (rval < 0)
1168 goto unlock;
1169 *shadow = rval;
1170 rval = 0;
1171 } else {
1172 *shadow = val;
1173 }
1174
1175unlock:
1176 mutex_unlock(&sdev->mutex);
1177exit:
1178 return rval;
1179}
1180
1181static int si4713_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f);
1182static int si4713_s_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *);
1183/*
1184 * si4713_setup - Sets the device up with current configuration.
1185 * @sdev: si4713_device structure for the device we are communicating
1186 */
1187static int si4713_setup(struct si4713_device *sdev)
1188{
1189 struct v4l2_ext_control ctrl;
1190 struct v4l2_frequency f;
1191 struct v4l2_modulator vm;
1192 struct si4713_device *tmp;
1193 int rval = 0;
1194
1195 tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
1196 if (!tmp)
1197 return -ENOMEM;
1198
1199 /* Get a local copy to avoid race */
1200 mutex_lock(&sdev->mutex);
1201 memcpy(tmp, sdev, sizeof(*sdev));
1202 mutex_unlock(&sdev->mutex);
1203
1204 ctrl.id = V4L2_CID_RDS_TX_PI;
1205 ctrl.value = tmp->rds_info.pi;
1206 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1207
1208 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_THRESHOLD;
1209 ctrl.value = tmp->acomp_info.threshold;
1210 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1211
1212 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_GAIN;
1213 ctrl.value = tmp->acomp_info.gain;
1214 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1215
1216 ctrl.id = V4L2_CID_PILOT_TONE_FREQUENCY;
1217 ctrl.value = tmp->pilot_info.frequency;
1218 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1219
1220 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME;
1221 ctrl.value = tmp->acomp_info.attack_time;
1222 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1223
1224 ctrl.id = V4L2_CID_PILOT_TONE_DEVIATION;
1225 ctrl.value = tmp->pilot_info.deviation;
1226 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1227
1228 ctrl.id = V4L2_CID_AUDIO_LIMITER_DEVIATION;
1229 ctrl.value = tmp->limiter_info.deviation;
1230 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1231
1232 ctrl.id = V4L2_CID_RDS_TX_DEVIATION;
1233 ctrl.value = tmp->rds_info.deviation;
1234 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1235
1236 ctrl.id = V4L2_CID_RDS_TX_PTY;
1237 ctrl.value = tmp->rds_info.pty;
1238 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1239
1240 ctrl.id = V4L2_CID_AUDIO_LIMITER_ENABLED;
1241 ctrl.value = tmp->limiter_info.enabled;
1242 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1243
1244 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_ENABLED;
1245 ctrl.value = tmp->acomp_info.enabled;
1246 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1247
1248 ctrl.id = V4L2_CID_PILOT_TONE_ENABLED;
1249 ctrl.value = tmp->pilot_info.enabled;
1250 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1251
1252 ctrl.id = V4L2_CID_AUDIO_LIMITER_RELEASE_TIME;
1253 ctrl.value = tmp->limiter_info.release_time;
1254 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1255
1256 ctrl.id = V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME;
1257 ctrl.value = tmp->acomp_info.release_time;
1258 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1259
1260 ctrl.id = V4L2_CID_TUNE_PREEMPHASIS;
1261 ctrl.value = tmp->preemphasis;
1262 rval |= si4713_write_econtrol_integers(sdev, &ctrl);
1263
1264 ctrl.id = V4L2_CID_RDS_TX_PS_NAME;
1265 rval |= si4713_set_rds_ps_name(sdev, tmp->rds_info.ps_name);
1266
1267 ctrl.id = V4L2_CID_RDS_TX_RADIO_TEXT;
1268 rval |= si4713_set_rds_radio_text(sdev, tmp->rds_info.radio_text);
1269
1270 /* Device procedure needs to set frequency first */
1271 f.frequency = tmp->frequency ? tmp->frequency : DEFAULT_FREQUENCY;
1272 f.frequency = si4713_to_v4l2(f.frequency);
1273 rval |= si4713_s_frequency(&sdev->sd, &f);
1274
1275 ctrl.id = V4L2_CID_TUNE_POWER_LEVEL;
1276 ctrl.value = tmp->power_level;
1277 rval |= si4713_write_econtrol_tune(sdev, &ctrl);
1278
1279 ctrl.id = V4L2_CID_TUNE_ANTENNA_CAPACITOR;
1280 ctrl.value = tmp->antenna_capacitor;
1281 rval |= si4713_write_econtrol_tune(sdev, &ctrl);
1282
1283 vm.index = 0;
1284 if (tmp->stereo)
1285 vm.txsubchans = V4L2_TUNER_SUB_STEREO;
1286 else
1287 vm.txsubchans = V4L2_TUNER_SUB_MONO;
1288 if (tmp->rds_info.enabled)
1289 vm.txsubchans |= V4L2_TUNER_SUB_RDS;
1290 si4713_s_modulator(&sdev->sd, &vm);
1291
1292 kfree(tmp);
1293
1294 return rval;
1295}
1296
1297/*
1298 * si4713_initialize - Sets the device up with default configuration.
1299 * @sdev: si4713_device structure for the device we are communicating
1300 */
1301static int si4713_initialize(struct si4713_device *sdev)
1302{
1303 int rval;
1304
1305 rval = si4713_set_power_state(sdev, POWER_ON);
1306 if (rval < 0)
1307 goto exit;
1308
1309 rval = si4713_checkrev(sdev);
1310 if (rval < 0)
1311 goto exit;
1312
1313 rval = si4713_set_power_state(sdev, POWER_OFF);
1314 if (rval < 0)
1315 goto exit;
1316
1317 mutex_lock(&sdev->mutex);
1318
1319 sdev->rds_info.pi = DEFAULT_RDS_PI;
1320 sdev->rds_info.pty = DEFAULT_RDS_PTY;
1321 sdev->rds_info.deviation = DEFAULT_RDS_DEVIATION;
1322 strlcpy(sdev->rds_info.ps_name, DEFAULT_RDS_PS_NAME, MAX_RDS_PS_NAME);
1323 strlcpy(sdev->rds_info.radio_text, DEFAULT_RDS_RADIO_TEXT,
1324 MAX_RDS_RADIO_TEXT);
1325 sdev->rds_info.enabled = 1;
1326
1327 sdev->limiter_info.release_time = DEFAULT_LIMITER_RTIME;
1328 sdev->limiter_info.deviation = DEFAULT_LIMITER_DEV;
1329 sdev->limiter_info.enabled = 1;
1330
1331 sdev->pilot_info.deviation = DEFAULT_PILOT_DEVIATION;
1332 sdev->pilot_info.frequency = DEFAULT_PILOT_FREQUENCY;
1333 sdev->pilot_info.enabled = 1;
1334
1335 sdev->acomp_info.release_time = DEFAULT_ACOMP_RTIME;
1336 sdev->acomp_info.attack_time = DEFAULT_ACOMP_ATIME;
1337 sdev->acomp_info.threshold = DEFAULT_ACOMP_THRESHOLD;
1338 sdev->acomp_info.gain = DEFAULT_ACOMP_GAIN;
1339 sdev->acomp_info.enabled = 1;
1340
1341 sdev->frequency = DEFAULT_FREQUENCY;
1342 sdev->preemphasis = DEFAULT_PREEMPHASIS;
1343 sdev->mute = DEFAULT_MUTE;
1344 sdev->power_level = DEFAULT_POWER_LEVEL;
1345 sdev->antenna_capacitor = 0;
1346 sdev->stereo = 1;
1347 sdev->tune_rnl = DEFAULT_TUNE_RNL;
1348
1349 mutex_unlock(&sdev->mutex);
1350
1351exit:
1352 return rval;
1353}
1354
1355/* read string property */
1356static int si4713_read_econtrol_string(struct si4713_device *sdev,
1357 struct v4l2_ext_control *control)
1358{
1359 s32 rval = 0;
1360
1361 switch (control->id) {
1362 case V4L2_CID_RDS_TX_PS_NAME:
1363 if (strlen(sdev->rds_info.ps_name) + 1 > control->size) {
1364 control->size = MAX_RDS_PS_NAME + 1;
1365 rval = -ENOSPC;
1366 goto exit;
1367 }
1368 rval = copy_to_user(control->string, sdev->rds_info.ps_name,
1369 strlen(sdev->rds_info.ps_name) + 1);
1370 break;
1371
1372 case V4L2_CID_RDS_TX_RADIO_TEXT:
1373 if (strlen(sdev->rds_info.radio_text) + 1 > control->size) {
1374 control->size = MAX_RDS_RADIO_TEXT + 1;
1375 rval = -ENOSPC;
1376 goto exit;
1377 }
1378 rval = copy_to_user(control->string, sdev->rds_info.radio_text,
1379 strlen(sdev->rds_info.radio_text) + 1);
1380 break;
1381
1382 default:
1383 rval = -EINVAL;
1384 break;
1385 };
1386
1387exit:
1388 return rval;
1389}
1390
1391/*
1392 * si4713_update_tune_status - update properties from tx_tune_status
1393 * command. Must be called with sdev->mutex held.
1394 * @sdev: si4713_device structure for the device we are communicating
1395 */
1396static int si4713_update_tune_status(struct si4713_device *sdev)
1397{
1398 int rval;
1399 u16 f = 0;
1400 u8 p = 0, a = 0, n = 0;
1401
1402 rval = si4713_tx_tune_status(sdev, 0x00, &f, &p, &a, &n);
1403
1404 if (rval < 0)
1405 goto exit;
1406
1407 sdev->power_level = p;
1408 sdev->antenna_capacitor = a;
1409 sdev->tune_rnl = n;
1410
1411exit:
1412 return rval;
1413}
1414
1415/* properties which use tx_tune_status */
1416static int si4713_read_econtrol_tune(struct si4713_device *sdev,
1417 struct v4l2_ext_control *control)
1418{
1419 s32 rval = 0;
1420
1421 mutex_lock(&sdev->mutex);
1422
1423 if (sdev->power_state) {
1424 rval = si4713_update_tune_status(sdev);
1425 if (rval < 0)
1426 goto unlock;
1427 }
1428
1429 switch (control->id) {
1430 case V4L2_CID_TUNE_POWER_LEVEL:
1431 control->value = sdev->power_level;
1432 break;
1433 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1434 control->value = sdev->antenna_capacitor;
1435 break;
1436 default:
1437 rval = -EINVAL;
1438 };
1439
1440unlock:
1441 mutex_unlock(&sdev->mutex);
1442 return rval;
1443}
1444
1445static int si4713_read_econtrol_integers(struct si4713_device *sdev,
1446 struct v4l2_ext_control *control)
1447{
1448 s32 rval;
1449 u32 *shadow = NULL, val = 0;
1450 s32 bit = 0, mask = 0;
1451 u16 property = 0;
1452 int mul = 0;
1453 unsigned long *table = NULL;
1454 int size = 0;
1455
1456 rval = si4713_choose_econtrol_action(sdev, control->id, &shadow, &bit,
1457 &mask, &property, &mul, &table, &size);
1458 if (rval < 0)
1459 goto exit;
1460
1461 mutex_lock(&sdev->mutex);
1462
1463 if (sdev->power_state) {
1464 rval = si4713_read_property(sdev, property, &val);
1465 if (rval < 0)
1466 goto unlock;
1467
1468 /* Keep negative values for threshold */
1469 if (control->id == V4L2_CID_AUDIO_COMPRESSION_THRESHOLD)
1470 *shadow = (s16)val;
1471 else if (mask)
1472 *shadow = get_status_bit(val, bit, mask);
1473 else if (mul)
1474 *shadow = val * mul;
1475 else
1476 *shadow = dev_to_usecs(val, table, size);
1477 }
1478
1479 control->value = *shadow;
1480
1481unlock:
1482 mutex_unlock(&sdev->mutex);
1483exit:
1484 return rval;
1485}
1486
1487/*
1488 * Video4Linux Subdev Interface
1489 */
1490/* si4713_s_ext_ctrls - set extended controls value */
1491static int si4713_s_ext_ctrls(struct v4l2_subdev *sd,
1492 struct v4l2_ext_controls *ctrls)
1493{
1494 struct si4713_device *sdev = to_si4713_device(sd);
1495 int i;
1496
1497 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
1498 return -EINVAL;
1499
1500 for (i = 0; i < ctrls->count; i++) {
1501 int err;
1502
1503 switch ((ctrls->controls + i)->id) {
1504 case V4L2_CID_RDS_TX_PS_NAME:
1505 case V4L2_CID_RDS_TX_RADIO_TEXT:
1506 err = si4713_write_econtrol_string(sdev,
1507 ctrls->controls + i);
1508 break;
1509 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1510 case V4L2_CID_TUNE_POWER_LEVEL:
1511 err = si4713_write_econtrol_tune(sdev,
1512 ctrls->controls + i);
1513 break;
1514 default:
1515 err = si4713_write_econtrol_integers(sdev,
1516 ctrls->controls + i);
1517 }
1518
1519 if (err < 0) {
1520 ctrls->error_idx = i;
1521 return err;
1522 }
1523 }
1524
1525 return 0;
1526}
1527
1528/* si4713_g_ext_ctrls - get extended controls value */
1529static int si4713_g_ext_ctrls(struct v4l2_subdev *sd,
1530 struct v4l2_ext_controls *ctrls)
1531{
1532 struct si4713_device *sdev = to_si4713_device(sd);
1533 int i;
1534
1535 if (ctrls->ctrl_class != V4L2_CTRL_CLASS_FM_TX)
1536 return -EINVAL;
1537
1538 for (i = 0; i < ctrls->count; i++) {
1539 int err;
1540
1541 switch ((ctrls->controls + i)->id) {
1542 case V4L2_CID_RDS_TX_PS_NAME:
1543 case V4L2_CID_RDS_TX_RADIO_TEXT:
1544 err = si4713_read_econtrol_string(sdev,
1545 ctrls->controls + i);
1546 break;
1547 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1548 case V4L2_CID_TUNE_POWER_LEVEL:
1549 err = si4713_read_econtrol_tune(sdev,
1550 ctrls->controls + i);
1551 break;
1552 default:
1553 err = si4713_read_econtrol_integers(sdev,
1554 ctrls->controls + i);
1555 }
1556
1557 if (err < 0) {
1558 ctrls->error_idx = i;
1559 return err;
1560 }
1561 }
1562
1563 return 0;
1564}
1565
1566/* si4713_queryctrl - enumerate control items */
1567static int si4713_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1568{
1569 int rval = 0;
1570
1571 switch (qc->id) {
1572 /* User class controls */
1573 case V4L2_CID_AUDIO_MUTE:
1574 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, DEFAULT_MUTE);
1575 break;
1576 /* FM_TX class controls */
1577 case V4L2_CID_RDS_TX_PI:
1578 rval = v4l2_ctrl_query_fill(qc, 0, 0xFFFF, 1, DEFAULT_RDS_PI);
1579 break;
1580 case V4L2_CID_RDS_TX_PTY:
1581 rval = v4l2_ctrl_query_fill(qc, 0, 31, 1, DEFAULT_RDS_PTY);
1582 break;
1583 case V4L2_CID_RDS_TX_DEVIATION:
1584 rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_DEVIATION,
1585 10, DEFAULT_RDS_DEVIATION);
1586 break;
1587 case V4L2_CID_RDS_TX_PS_NAME:
1588 /*
1589 * Report step as 8. From RDS spec, psname
1590 * should be 8. But there are receivers which scroll strings
1591 * sized as 8xN.
1592 */
1593 rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_PS_NAME, 8, 0);
1594 break;
1595 case V4L2_CID_RDS_TX_RADIO_TEXT:
1596 /*
1597 * Report step as 32 (2A block). From RDS spec,
1598 * radio text should be 32 for 2A block. But there are receivers
1599 * which scroll strings sized as 32xN. Setting default to 32.
1600 */
1601 rval = v4l2_ctrl_query_fill(qc, 0, MAX_RDS_RADIO_TEXT, 32, 0);
1602 break;
1603
1604 case V4L2_CID_AUDIO_LIMITER_ENABLED:
1605 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1606 break;
1607 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME:
1608 rval = v4l2_ctrl_query_fill(qc, 250, MAX_LIMITER_RELEASE_TIME,
1609 50, DEFAULT_LIMITER_RTIME);
1610 break;
1611 case V4L2_CID_AUDIO_LIMITER_DEVIATION:
1612 rval = v4l2_ctrl_query_fill(qc, 0, MAX_LIMITER_DEVIATION,
1613 10, DEFAULT_LIMITER_DEV);
1614 break;
1615
1616 case V4L2_CID_AUDIO_COMPRESSION_ENABLED:
1617 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1618 break;
1619 case V4L2_CID_AUDIO_COMPRESSION_GAIN:
1620 rval = v4l2_ctrl_query_fill(qc, 0, MAX_ACOMP_GAIN, 1,
1621 DEFAULT_ACOMP_GAIN);
1622 break;
1623 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD:
1624 rval = v4l2_ctrl_query_fill(qc, MIN_ACOMP_THRESHOLD,
1625 MAX_ACOMP_THRESHOLD, 1,
1626 DEFAULT_ACOMP_THRESHOLD);
1627 break;
1628 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME:
1629 rval = v4l2_ctrl_query_fill(qc, 0, MAX_ACOMP_ATTACK_TIME,
1630 500, DEFAULT_ACOMP_ATIME);
1631 break;
1632 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME:
1633 rval = v4l2_ctrl_query_fill(qc, 100000, MAX_ACOMP_RELEASE_TIME,
1634 100000, DEFAULT_ACOMP_RTIME);
1635 break;
1636
1637 case V4L2_CID_PILOT_TONE_ENABLED:
1638 rval = v4l2_ctrl_query_fill(qc, 0, 1, 1, 1);
1639 break;
1640 case V4L2_CID_PILOT_TONE_DEVIATION:
1641 rval = v4l2_ctrl_query_fill(qc, 0, MAX_PILOT_DEVIATION,
1642 10, DEFAULT_PILOT_DEVIATION);
1643 break;
1644 case V4L2_CID_PILOT_TONE_FREQUENCY:
1645 rval = v4l2_ctrl_query_fill(qc, 0, MAX_PILOT_FREQUENCY,
1646 1, DEFAULT_PILOT_FREQUENCY);
1647 break;
1648
1649 case V4L2_CID_TUNE_PREEMPHASIS:
1650 rval = v4l2_ctrl_query_fill(qc, V4L2_PREEMPHASIS_DISABLED,
1651 V4L2_PREEMPHASIS_75_uS, 1,
1652 V4L2_PREEMPHASIS_50_uS);
1653 break;
1654 case V4L2_CID_TUNE_POWER_LEVEL:
1655 rval = v4l2_ctrl_query_fill(qc, 0, 120, 1, DEFAULT_POWER_LEVEL);
1656 break;
1657 case V4L2_CID_TUNE_ANTENNA_CAPACITOR:
1658 rval = v4l2_ctrl_query_fill(qc, 0, 191, 1, 0);
1659 break;
1660 default:
1661 rval = -EINVAL;
1662 break;
1663 };
1664
1665 return rval;
1666}
1667
1668/* si4713_g_ctrl - get the value of a control */
1669static int si4713_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1670{
1671 struct si4713_device *sdev = to_si4713_device(sd);
1672 int rval = 0;
1673
1674 if (!sdev)
1675 return -ENODEV;
1676
1677 mutex_lock(&sdev->mutex);
1678
1679 if (sdev->power_state) {
1680 rval = si4713_read_property(sdev, SI4713_TX_LINE_INPUT_MUTE,
1681 &sdev->mute);
1682
1683 if (rval < 0)
1684 goto unlock;
1685 }
1686
1687 switch (ctrl->id) {
1688 case V4L2_CID_AUDIO_MUTE:
1689 ctrl->value = get_mute(sdev->mute);
1690 break;
1691 }
1692
1693unlock:
1694 mutex_unlock(&sdev->mutex);
1695 return rval;
1696}
1697
1698/* si4713_s_ctrl - set the value of a control */
1699static int si4713_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
1700{
1701 struct si4713_device *sdev = to_si4713_device(sd);
1702 int rval = 0;
1703
1704 if (!sdev)
1705 return -ENODEV;
1706
1707 switch (ctrl->id) {
1708 case V4L2_CID_AUDIO_MUTE:
1709 if (ctrl->value) {
1710 rval = si4713_set_mute(sdev, ctrl->value);
1711 if (rval < 0)
1712 goto exit;
1713
1714 rval = si4713_set_power_state(sdev, POWER_DOWN);
1715 } else {
1716 rval = si4713_set_power_state(sdev, POWER_UP);
1717 if (rval < 0)
1718 goto exit;
1719
1720 rval = si4713_setup(sdev);
1721 if (rval < 0)
1722 goto exit;
1723
1724 rval = si4713_set_mute(sdev, ctrl->value);
1725 }
1726 break;
1727 }
1728
1729exit:
1730 return rval;
1731}
1732
1733/* si4713_ioctl - deal with private ioctls (only rnl for now) */
1734long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg)
1735{
1736 struct si4713_device *sdev = to_si4713_device(sd);
1737 struct si4713_rnl *rnl = arg;
1738 u16 frequency;
1739 int rval = 0;
1740
1741 if (!arg)
1742 return -EINVAL;
1743
1744 mutex_lock(&sdev->mutex);
1745 switch (cmd) {
1746 case SI4713_IOC_MEASURE_RNL:
1747 frequency = v4l2_to_si4713(rnl->frequency);
1748
1749 if (sdev->power_state) {
1750 /* Set desired measurement frequency */
1751 rval = si4713_tx_tune_measure(sdev, frequency, 0);
1752 if (rval < 0)
1753 goto unlock;
1754 /* get results from tune status */
1755 rval = si4713_update_tune_status(sdev);
1756 if (rval < 0)
1757 goto unlock;
1758 }
1759 rnl->rnl = sdev->tune_rnl;
1760 break;
1761
1762 default:
1763 /* nothing */
1764 rval = -ENOIOCTLCMD;
1765 }
1766
1767unlock:
1768 mutex_unlock(&sdev->mutex);
1769 return rval;
1770}
1771
1772static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = {
1773 .queryctrl = si4713_queryctrl,
1774 .g_ext_ctrls = si4713_g_ext_ctrls,
1775 .s_ext_ctrls = si4713_s_ext_ctrls,
1776 .g_ctrl = si4713_g_ctrl,
1777 .s_ctrl = si4713_s_ctrl,
1778 .ioctl = si4713_ioctl,
1779};
1780
1781/* si4713_g_modulator - get modulator attributes */
1782static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1783{
1784 struct si4713_device *sdev = to_si4713_device(sd);
1785 int rval = 0;
1786
1787 if (!sdev) {
1788 rval = -ENODEV;
1789 goto exit;
1790 }
1791
1792 if (vm->index > 0) {
1793 rval = -EINVAL;
1794 goto exit;
1795 }
1796
1797 strncpy(vm->name, "FM Modulator", 32);
1798 vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW |
1799 V4L2_TUNER_CAP_RDS;
1800
1801 /* Report current frequency range limits */
1802 vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW);
1803 vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH);
1804
1805 mutex_lock(&sdev->mutex);
1806
1807 if (sdev->power_state) {
1808 u32 comp_en = 0;
1809
1810 rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE,
1811 &comp_en);
1812 if (rval < 0)
1813 goto unlock;
1814
1815 sdev->stereo = get_status_bit(comp_en, 1, 1 << 1);
1816 sdev->rds_info.enabled = get_status_bit(comp_en, 2, 1 << 2);
1817 }
1818
1819 /* Report current audio mode: mono or stereo */
1820 if (sdev->stereo)
1821 vm->txsubchans = V4L2_TUNER_SUB_STEREO;
1822 else
1823 vm->txsubchans = V4L2_TUNER_SUB_MONO;
1824
1825 /* Report rds feature status */
1826 if (sdev->rds_info.enabled)
1827 vm->txsubchans |= V4L2_TUNER_SUB_RDS;
1828 else
1829 vm->txsubchans &= ~V4L2_TUNER_SUB_RDS;
1830
1831unlock:
1832 mutex_unlock(&sdev->mutex);
1833exit:
1834 return rval;
1835}
1836
1837/* si4713_s_modulator - set modulator attributes */
1838static int si4713_s_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm)
1839{
1840 struct si4713_device *sdev = to_si4713_device(sd);
1841 int rval = 0;
1842 u16 stereo, rds;
1843 u32 p;
1844
a65f3159
HV		 1845 if (!sdev)
1846 return -ENODEV;
02bee89e 1847
a65f3159
HV		 1848 if (vm->index > 0)
1849 return -EINVAL;
02bee89e
EV		 1850
1851 /* Set audio mode: mono or stereo */
1852 if (vm->txsubchans & V4L2_TUNER_SUB_STEREO)
1853 stereo = 1;
1854 else if (vm->txsubchans & V4L2_TUNER_SUB_MONO)
1855 stereo = 0;
1856 else
a65f3159 1857 return -EINVAL;
02bee89e
EV		 1858
1859 rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS);
1860
1861 mutex_lock(&sdev->mutex);
1862
1863 if (sdev->power_state) {
1864 rval = si4713_read_property(sdev,
1865 SI4713_TX_COMPONENT_ENABLE, &p);
1866 if (rval < 0)
1867 goto unlock;
1868
1869 p = set_bits(p, stereo, 1, 1 << 1);
1870 p = set_bits(p, rds, 2, 1 << 2);
1871
1872 rval = si4713_write_property(sdev,
1873 SI4713_TX_COMPONENT_ENABLE, p);
1874 if (rval < 0)
1875 goto unlock;
1876 }
1877
1878 sdev->stereo = stereo;
1879 sdev->rds_info.enabled = rds;
1880
1881unlock:
1882 mutex_unlock(&sdev->mutex);
02bee89e
EV		 1883 return rval;
1884}
1885
1886/* si4713_g_frequency - get tuner or modulator radio frequency */
1887static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1888{
1889 struct si4713_device *sdev = to_si4713_device(sd);
1890 int rval = 0;
1891
1892 f->type = V4L2_TUNER_RADIO;
1893
1894 mutex_lock(&sdev->mutex);
1895
1896 if (sdev->power_state) {
1897 u16 freq;
1898 u8 p, a, n;
1899
1900 rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n);
1901 if (rval < 0)
1902 goto unlock;
1903
1904 sdev->frequency = freq;
1905 }
1906
1907 f->frequency = si4713_to_v4l2(sdev->frequency);
1908
1909unlock:
1910 mutex_unlock(&sdev->mutex);
1911 return rval;
1912}
1913
1914/* si4713_s_frequency - set tuner or modulator radio frequency */
1915static int si4713_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f)
1916{
1917 struct si4713_device *sdev = to_si4713_device(sd);
1918 int rval = 0;
1919 u16 frequency = v4l2_to_si4713(f->frequency);
1920
1921 /* Check frequency range */
1922 if (frequency < FREQ_RANGE_LOW || frequency > FREQ_RANGE_HIGH)
1923 return -EDOM;
1924
1925 mutex_lock(&sdev->mutex);
1926
1927 if (sdev->power_state) {
1928 rval = si4713_tx_tune_freq(sdev, frequency);
1929 if (rval < 0)
1930 goto unlock;
1931 frequency = rval;
1932 rval = 0;
1933 }
1934 sdev->frequency = frequency;
1935 f->frequency = si4713_to_v4l2(frequency);
1936
1937unlock:
1938 mutex_unlock(&sdev->mutex);
1939 return rval;
1940}
1941
1942static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = {
1943 .g_frequency = si4713_g_frequency,
1944 .s_frequency = si4713_s_frequency,
1945 .g_modulator = si4713_g_modulator,
1946 .s_modulator = si4713_s_modulator,
1947};
1948
1949static const struct v4l2_subdev_ops si4713_subdev_ops = {
1950 .core = &si4713_subdev_core_ops,
1951 .tuner = &si4713_subdev_tuner_ops,
1952};
1953
1954/*
1955 * I2C driver interface
1956 */
1957/* si4713_probe - probe for the device */
1958static int si4713_probe(struct i2c_client *client,
1959 const struct i2c_device_id *id)
1960{
1961 struct si4713_device *sdev;
1962 int rval;
1963
1964 sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
1965 if (!sdev) {
1966 dev_err(&client->dev, "Failed to alloc video device.\n");
1967 rval = -ENOMEM;
1968 goto exit;
1969 }
1970
1971 sdev->platform_data = client->dev.platform_data;
1972 if (!sdev->platform_data) {
1973 v4l2_err(&sdev->sd, "No platform data registered.\n");
1974 rval = -ENODEV;
1975 goto free_sdev;
1976 }
1977
1978 v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
1979
1980 mutex_init(&sdev->mutex);
1981 init_completion(&sdev->work);
1982
1983 if (client->irq) {
1984 rval = request_irq(client->irq,
1985 si4713_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED,
1986 client->name, sdev);
1987 if (rval < 0) {
1988 v4l2_err(&sdev->sd, "Could not request IRQ\n");
1989 goto free_sdev;
1990 }
1991 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
1992 } else {
1993 v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
1994 }
1995
1996 rval = si4713_initialize(sdev);
1997 if (rval < 0) {
1998 v4l2_err(&sdev->sd, "Failed to probe device information.\n");
1999 goto free_irq;
2000 }
2001
2002 return 0;
2003
2004free_irq:
2005 if (client->irq)
2006 free_irq(client->irq, sdev);
2007free_sdev:
2008 kfree(sdev);
2009exit:
2010 return rval;
2011}
2012
2013/* si4713_remove - remove the device */
2014static int si4713_remove(struct i2c_client *client)
2015{
2016 struct v4l2_subdev *sd = i2c_get_clientdata(client);
2017 struct si4713_device *sdev = to_si4713_device(sd);
2018
2019 if (sdev->power_state)
2020 si4713_set_power_state(sdev, POWER_DOWN);
2021
2022 if (client->irq > 0)
2023 free_irq(client->irq, sdev);
2024
2025 v4l2_device_unregister_subdev(sd);
2026
2027 kfree(sdev);
2028
2029 return 0;
2030}
2031
2032/* si4713_i2c_driver - i2c driver interface */
2033static const struct i2c_device_id si4713_id[] = {
2034 { "si4713" , 0 },
2035 { },
2036};
2037MODULE_DEVICE_TABLE(i2c, si4713_id);
2038
2039static struct i2c_driver si4713_i2c_driver = {
2040 .driver = {
2041 .name = "si4713",
2042 },
2043 .probe = si4713_probe,
2044 .remove = si4713_remove,
2045 .id_table = si4713_id,
2046};
2047
2048/* Module Interface */
2049static int __init si4713_module_init(void)
2050{
2051 return i2c_add_driver(&si4713_i2c_driver);
2052}
2053
2054static void __exit si4713_module_exit(void)
2055{
2056 i2c_del_driver(&si4713_i2c_driver);
2057}
2058
2059module_init(si4713_module_init);
2060module_exit(si4713_module_exit);
2061
Linux 6.x block layer and io_uring tree(s)