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