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/completion.h> 25 #include <linux/delay.h> 26 #include <linux/interrupt.h> 27 #include <linux/i2c.h> 28 #include <linux/slab.h> 29 #include <linux/gpio.h> 30 #include <linux/module.h> 31 #include <media/v4l2-device.h> 32 #include <media/v4l2-ioctl.h> 33 #include <media/v4l2-common.h> 34 35 #include "si4713.h" 36 37 /* module parameters */ 38 static int debug; 39 module_param(debug, int, S_IRUGO | S_IWUSR); 40 MODULE_PARM_DESC(debug, "Debug level (0 - 2)"); 41 42 MODULE_LICENSE("GPL"); 43 MODULE_AUTHOR("Eduardo Valentin <eduardo.valentin@nokia.com>"); 44 MODULE_DESCRIPTION("I2C driver for Si4713 FM Radio Transmitter"); 45 MODULE_VERSION("0.0.1"); 46 47 #define DEFAULT_RDS_PI 0x00 48 #define DEFAULT_RDS_PTY 0x00 49 #define DEFAULT_RDS_DEVIATION 0x00C8 50 #define DEFAULT_RDS_PS_REPEAT_COUNT 0x0003 51 #define DEFAULT_LIMITER_RTIME 0x1392 52 #define DEFAULT_LIMITER_DEV 0x102CA 53 #define DEFAULT_PILOT_FREQUENCY 0x4A38 54 #define DEFAULT_PILOT_DEVIATION 0x1A5E 55 #define DEFAULT_ACOMP_ATIME 0x0000 56 #define DEFAULT_ACOMP_RTIME 0xF4240L 57 #define DEFAULT_ACOMP_GAIN 0x0F 58 #define DEFAULT_ACOMP_THRESHOLD (-0x28) 59 #define DEFAULT_MUTE 0x01 60 #define DEFAULT_POWER_LEVEL 88 61 #define DEFAULT_FREQUENCY 8800 62 #define DEFAULT_PREEMPHASIS FMPE_EU 63 #define DEFAULT_TUNE_RNL 0xFF 64 65 #define to_si4713_device(sd) container_of(sd, struct si4713_device, sd) 66 67 /* frequency domain transformation (using times 10 to avoid floats) */ 68 #define FREQDEV_UNIT 100000 69 #define FREQV4L2_MULTI 625 70 #define si4713_to_v4l2(f) ((f * FREQDEV_UNIT) / FREQV4L2_MULTI) 71 #define v4l2_to_si4713(f) ((f * FREQV4L2_MULTI) / FREQDEV_UNIT) 72 #define FREQ_RANGE_LOW 7600 73 #define FREQ_RANGE_HIGH 10800 74 75 #define MAX_ARGS 7 76 77 #define RDS_BLOCK 8 78 #define RDS_BLOCK_CLEAR 0x03 79 #define RDS_BLOCK_LOAD 0x04 80 #define RDS_RADIOTEXT_2A 0x20 81 #define RDS_RADIOTEXT_BLK_SIZE 4 82 #define RDS_RADIOTEXT_INDEX_MAX 0x0F 83 #define RDS_CARRIAGE_RETURN 0x0D 84 85 #define rds_ps_nblocks(len) ((len / RDS_BLOCK) + (len % RDS_BLOCK ? 1 : 0)) 86 87 #define get_status_bit(p, b, m) (((p) & (m)) >> (b)) 88 #define set_bits(p, v, b, m) (((p) & ~(m)) | ((v) << (b))) 89 90 #define ATTACK_TIME_UNIT 500 91 92 #define POWER_OFF 0x00 93 #define POWER_ON 0x01 94 95 #define msb(x) ((u8)((u16) x >> 8)) 96 #define lsb(x) ((u8)((u16) x & 0x00FF)) 97 #define compose_u16(msb, lsb) (((u16)msb << 8) | lsb) 98 #define check_command_failed(status) (!(status & SI4713_CTS) || \ 99 (status & SI4713_ERR)) 100 /* mute definition */ 101 #define set_mute(p) ((p & 1) | ((p & 1) << 1)); 102 103 #ifdef DEBUG 104 #define DBG_BUFFER(device, message, buffer, size) \ 105 { \ 106 int i; \ 107 char str[(size)*5]; \ 108 for (i = 0; i < size; i++) \ 109 sprintf(str + i * 5, " 0x%02x", buffer[i]); \ 110 v4l2_dbg(2, debug, device, "%s:%s\n", message, str); \ 111 } 112 #else 113 #define DBG_BUFFER(device, message, buffer, size) 114 #endif 115 116 /* 117 * Values for limiter release time (sorted by second column) 118 * device release 119 * value time (us) 120 */ 121 static long limiter_times[] = { 122 2000, 250, 123 1000, 500, 124 510, 1000, 125 255, 2000, 126 170, 3000, 127 127, 4020, 128 102, 5010, 129 85, 6020, 130 73, 7010, 131 64, 7990, 132 57, 8970, 133 51, 10030, 134 25, 20470, 135 17, 30110, 136 13, 39380, 137 10, 51190, 138 8, 63690, 139 7, 73140, 140 6, 85330, 141 5, 102390, 142 }; 143 144 /* 145 * Values for audio compression release time (sorted by second column) 146 * device release 147 * value time (us) 148 */ 149 static unsigned long acomp_rtimes[] = { 150 0, 100000, 151 1, 200000, 152 2, 350000, 153 3, 525000, 154 4, 1000000, 155 }; 156 157 /* 158 * Values for preemphasis (sorted by second column) 159 * device preemphasis 160 * value value (v4l2) 161 */ 162 static unsigned long preemphasis_values[] = { 163 FMPE_DISABLED, V4L2_PREEMPHASIS_DISABLED, 164 FMPE_EU, V4L2_PREEMPHASIS_50_uS, 165 FMPE_USA, V4L2_PREEMPHASIS_75_uS, 166 }; 167 168 static int usecs_to_dev(unsigned long usecs, unsigned long const array[], 169 int size) 170 { 171 int i; 172 int rval = -EINVAL; 173 174 for (i = 0; i < size / 2; i++) 175 if (array[(i * 2) + 1] >= usecs) { 176 rval = array[i * 2]; 177 break; 178 } 179 180 return rval; 181 } 182 183 /* si4713_handler: IRQ handler, just complete work */ 184 static irqreturn_t si4713_handler(int irq, void *dev) 185 { 186 struct si4713_device *sdev = dev; 187 188 v4l2_dbg(2, debug, &sdev->sd, 189 "%s: sending signal to completion work.\n", __func__); 190 complete(&sdev->work); 191 192 return IRQ_HANDLED; 193 } 194 195 /* 196 * si4713_send_command - sends a command to si4713 and waits its response 197 * @sdev: si4713_device structure for the device we are communicating 198 * @command: command id 199 * @args: command arguments we are sending (up to 7) 200 * @argn: actual size of @args 201 * @response: buffer to place the expected response from the device (up to 15) 202 * @respn: actual size of @response 203 * @usecs: amount of time to wait before reading the response (in usecs) 204 */ 205 static int si4713_send_command(struct si4713_device *sdev, const u8 command, 206 const u8 args[], const int argn, 207 u8 response[], const int respn, const int usecs) 208 { 209 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd); 210 unsigned long until_jiffies; 211 u8 data1[MAX_ARGS + 1]; 212 int err; 213 214 if (!client->adapter) 215 return -ENODEV; 216 217 /* First send the command and its arguments */ 218 data1[0] = command; 219 memcpy(data1 + 1, args, argn); 220 DBG_BUFFER(&sdev->sd, "Parameters", data1, argn + 1); 221 222 err = i2c_master_send(client, data1, argn + 1); 223 if (err != argn + 1) { 224 v4l2_err(&sdev->sd, "Error while sending command 0x%02x\n", 225 command); 226 return err < 0 ? err : -EIO; 227 } 228 229 until_jiffies = jiffies + usecs_to_jiffies(usecs) + 1; 230 231 /* Wait response from interrupt */ 232 if (client->irq) { 233 if (!wait_for_completion_timeout(&sdev->work, 234 usecs_to_jiffies(usecs) + 1)) 235 v4l2_warn(&sdev->sd, 236 "(%s) Device took too much time to answer.\n", 237 __func__); 238 } 239 240 do { 241 err = i2c_master_recv(client, response, respn); 242 if (err != respn) { 243 v4l2_err(&sdev->sd, 244 "Error %d while reading response for command 0x%02x\n", 245 err, command); 246 return err < 0 ? err : -EIO; 247 } 248 249 DBG_BUFFER(&sdev->sd, "Response", response, respn); 250 if (!check_command_failed(response[0])) 251 return 0; 252 253 if (client->irq) 254 return -EBUSY; 255 if (usecs <= 1000) 256 usleep_range(usecs, 1000); 257 else 258 usleep_range(1000, 2000); 259 } while (time_is_after_jiffies(until_jiffies)); 260 261 return -EBUSY; 262 } 263 264 /* 265 * si4713_read_property - reads a si4713 property 266 * @sdev: si4713_device structure for the device we are communicating 267 * @prop: property identification number 268 * @pv: property value to be returned on success 269 */ 270 static int si4713_read_property(struct si4713_device *sdev, u16 prop, u32 *pv) 271 { 272 int err; 273 u8 val[SI4713_GET_PROP_NRESP]; 274 /* 275 * .First byte = 0 276 * .Second byte = property's MSB 277 * .Third byte = property's LSB 278 */ 279 const u8 args[SI4713_GET_PROP_NARGS] = { 280 0x00, 281 msb(prop), 282 lsb(prop), 283 }; 284 285 err = si4713_send_command(sdev, SI4713_CMD_GET_PROPERTY, 286 args, ARRAY_SIZE(args), val, 287 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 288 289 if (err < 0) 290 return err; 291 292 *pv = compose_u16(val[2], val[3]); 293 294 v4l2_dbg(1, debug, &sdev->sd, 295 "%s: property=0x%02x value=0x%02x status=0x%02x\n", 296 __func__, prop, *pv, val[0]); 297 298 return err; 299 } 300 301 /* 302 * si4713_write_property - modifies a si4713 property 303 * @sdev: si4713_device structure for the device we are communicating 304 * @prop: property identification number 305 * @val: new value for that property 306 */ 307 static int si4713_write_property(struct si4713_device *sdev, u16 prop, u16 val) 308 { 309 int rval; 310 u8 resp[SI4713_SET_PROP_NRESP]; 311 /* 312 * .First byte = 0 313 * .Second byte = property's MSB 314 * .Third byte = property's LSB 315 * .Fourth byte = value's MSB 316 * .Fifth byte = value's LSB 317 */ 318 const u8 args[SI4713_SET_PROP_NARGS] = { 319 0x00, 320 msb(prop), 321 lsb(prop), 322 msb(val), 323 lsb(val), 324 }; 325 326 rval = si4713_send_command(sdev, SI4713_CMD_SET_PROPERTY, 327 args, ARRAY_SIZE(args), 328 resp, ARRAY_SIZE(resp), 329 DEFAULT_TIMEOUT); 330 331 if (rval < 0) 332 return rval; 333 334 v4l2_dbg(1, debug, &sdev->sd, 335 "%s: property=0x%02x value=0x%02x status=0x%02x\n", 336 __func__, prop, val, resp[0]); 337 338 /* 339 * As there is no command response for SET_PROPERTY, 340 * wait Tcomp time to finish before proceed, in order 341 * to have property properly set. 342 */ 343 msleep(TIMEOUT_SET_PROPERTY); 344 345 return rval; 346 } 347 348 /* 349 * si4713_powerup - Powers the device up 350 * @sdev: si4713_device structure for the device we are communicating 351 */ 352 static int si4713_powerup(struct si4713_device *sdev) 353 { 354 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd); 355 int err; 356 u8 resp[SI4713_PWUP_NRESP]; 357 /* 358 * .First byte = Enabled interrupts and boot function 359 * .Second byte = Input operation mode 360 */ 361 u8 args[SI4713_PWUP_NARGS] = { 362 SI4713_PWUP_GPO2OEN | SI4713_PWUP_FUNC_TX, 363 SI4713_PWUP_OPMOD_ANALOG, 364 }; 365 366 if (sdev->power_state) 367 return 0; 368 369 if (sdev->supplies) { 370 err = regulator_bulk_enable(sdev->supplies, sdev->supply_data); 371 if (err) { 372 v4l2_err(&sdev->sd, "Failed to enable supplies: %d\n", err); 373 return err; 374 } 375 } 376 if (gpio_is_valid(sdev->gpio_reset)) { 377 udelay(50); 378 gpio_set_value(sdev->gpio_reset, 1); 379 } 380 381 if (client->irq) 382 args[0] |= SI4713_PWUP_CTSIEN; 383 384 err = si4713_send_command(sdev, SI4713_CMD_POWER_UP, 385 args, ARRAY_SIZE(args), 386 resp, ARRAY_SIZE(resp), 387 TIMEOUT_POWER_UP); 388 389 if (!err) { 390 v4l2_dbg(1, debug, &sdev->sd, "Powerup response: 0x%02x\n", 391 resp[0]); 392 v4l2_dbg(1, debug, &sdev->sd, "Device in power up mode\n"); 393 sdev->power_state = POWER_ON; 394 395 if (client->irq) 396 err = si4713_write_property(sdev, SI4713_GPO_IEN, 397 SI4713_STC_INT | SI4713_CTS); 398 return err; 399 } 400 if (gpio_is_valid(sdev->gpio_reset)) 401 gpio_set_value(sdev->gpio_reset, 0); 402 if (sdev->supplies) { 403 err = regulator_bulk_disable(sdev->supplies, sdev->supply_data); 404 if (err) 405 v4l2_err(&sdev->sd, 406 "Failed to disable supplies: %d\n", err); 407 } 408 409 return err; 410 } 411 412 /* 413 * si4713_powerdown - Powers the device down 414 * @sdev: si4713_device structure for the device we are communicating 415 */ 416 static int si4713_powerdown(struct si4713_device *sdev) 417 { 418 int err; 419 u8 resp[SI4713_PWDN_NRESP]; 420 421 if (!sdev->power_state) 422 return 0; 423 424 err = si4713_send_command(sdev, SI4713_CMD_POWER_DOWN, 425 NULL, 0, 426 resp, ARRAY_SIZE(resp), 427 DEFAULT_TIMEOUT); 428 429 if (!err) { 430 v4l2_dbg(1, debug, &sdev->sd, "Power down response: 0x%02x\n", 431 resp[0]); 432 v4l2_dbg(1, debug, &sdev->sd, "Device in reset mode\n"); 433 if (gpio_is_valid(sdev->gpio_reset)) 434 gpio_set_value(sdev->gpio_reset, 0); 435 if (sdev->supplies) { 436 err = regulator_bulk_disable(sdev->supplies, 437 sdev->supply_data); 438 if (err) 439 v4l2_err(&sdev->sd, 440 "Failed to disable supplies: %d\n", err); 441 } 442 sdev->power_state = POWER_OFF; 443 } 444 445 return err; 446 } 447 448 /* 449 * si4713_checkrev - Checks if we are treating a device with the correct rev. 450 * @sdev: si4713_device structure for the device we are communicating 451 */ 452 static int si4713_checkrev(struct si4713_device *sdev) 453 { 454 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd); 455 int rval; 456 u8 resp[SI4713_GETREV_NRESP]; 457 458 rval = si4713_send_command(sdev, SI4713_CMD_GET_REV, 459 NULL, 0, 460 resp, ARRAY_SIZE(resp), 461 DEFAULT_TIMEOUT); 462 463 if (rval < 0) 464 return rval; 465 466 if (resp[1] == SI4713_PRODUCT_NUMBER) { 467 v4l2_info(&sdev->sd, "chip found @ 0x%02x (%s)\n", 468 client->addr << 1, client->adapter->name); 469 } else { 470 v4l2_err(&sdev->sd, "Invalid product number 0x%X\n", resp[1]); 471 rval = -EINVAL; 472 } 473 return rval; 474 } 475 476 /* 477 * si4713_wait_stc - Waits STC interrupt and clears status bits. Useful 478 * for TX_TUNE_POWER, TX_TUNE_FREQ and TX_TUNE_MEAS 479 * @sdev: si4713_device structure for the device we are communicating 480 * @usecs: timeout to wait for STC interrupt signal 481 */ 482 static int si4713_wait_stc(struct si4713_device *sdev, const int usecs) 483 { 484 struct i2c_client *client = v4l2_get_subdevdata(&sdev->sd); 485 u8 resp[SI4713_GET_STATUS_NRESP]; 486 unsigned long start_jiffies = jiffies; 487 int err; 488 489 if (client->irq && 490 !wait_for_completion_timeout(&sdev->work, usecs_to_jiffies(usecs) + 1)) 491 v4l2_warn(&sdev->sd, 492 "(%s) Device took too much time to answer.\n", __func__); 493 494 for (;;) { 495 /* Clear status bits */ 496 err = si4713_send_command(sdev, SI4713_CMD_GET_INT_STATUS, 497 NULL, 0, 498 resp, ARRAY_SIZE(resp), 499 DEFAULT_TIMEOUT); 500 /* The USB device returns errors when it waits for the 501 * STC bit to be set. Hence polling */ 502 if (err >= 0) { 503 v4l2_dbg(1, debug, &sdev->sd, 504 "%s: status bits: 0x%02x\n", __func__, resp[0]); 505 506 if (resp[0] & SI4713_STC_INT) 507 return 0; 508 } 509 if (jiffies_to_usecs(jiffies - start_jiffies) > usecs) 510 return err < 0 ? err : -EIO; 511 /* We sleep here for 3-4 ms in order to avoid flooding the device 512 * with USB requests. The si4713 USB driver was developed 513 * by reverse engineering the Windows USB driver. The windows 514 * driver also has a ~2.5 ms delay between responses. */ 515 usleep_range(3000, 4000); 516 } 517 } 518 519 /* 520 * si4713_tx_tune_freq - Sets the state of the RF carrier and sets the tuning 521 * frequency between 76 and 108 MHz in 10 kHz units and 522 * steps of 50 kHz. 523 * @sdev: si4713_device structure for the device we are communicating 524 * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz) 525 */ 526 static int si4713_tx_tune_freq(struct si4713_device *sdev, u16 frequency) 527 { 528 int err; 529 u8 val[SI4713_TXFREQ_NRESP]; 530 /* 531 * .First byte = 0 532 * .Second byte = frequency's MSB 533 * .Third byte = frequency's LSB 534 */ 535 const u8 args[SI4713_TXFREQ_NARGS] = { 536 0x00, 537 msb(frequency), 538 lsb(frequency), 539 }; 540 541 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_FREQ, 542 args, ARRAY_SIZE(args), val, 543 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 544 545 if (err < 0) 546 return err; 547 548 v4l2_dbg(1, debug, &sdev->sd, 549 "%s: frequency=0x%02x status=0x%02x\n", __func__, 550 frequency, val[0]); 551 552 err = si4713_wait_stc(sdev, TIMEOUT_TX_TUNE); 553 if (err < 0) 554 return err; 555 556 return compose_u16(args[1], args[2]); 557 } 558 559 /* 560 * si4713_tx_tune_power - Sets the RF voltage level between 88 and 120 dBuV in 561 * 1 dB units. A value of 0x00 indicates off. The command 562 * also sets the antenna tuning capacitance. A value of 0 563 * indicates autotuning, and a value of 1 - 191 indicates 564 * a manual override, which results in a tuning 565 * capacitance of 0.25 pF x @antcap. 566 * @sdev: si4713_device structure for the device we are communicating 567 * @power: tuning power (88 - 120 dBuV, unit/step 1 dB) 568 * @antcap: value of antenna tuning capacitor (0 - 191) 569 */ 570 static int si4713_tx_tune_power(struct si4713_device *sdev, u8 power, 571 u8 antcap) 572 { 573 int err; 574 u8 val[SI4713_TXPWR_NRESP]; 575 /* 576 * .First byte = 0 577 * .Second byte = 0 578 * .Third byte = power 579 * .Fourth byte = antcap 580 */ 581 u8 args[SI4713_TXPWR_NARGS] = { 582 0x00, 583 0x00, 584 power, 585 antcap, 586 }; 587 588 /* Map power values 1-87 to MIN_POWER (88) */ 589 if (power > 0 && power < SI4713_MIN_POWER) 590 args[2] = power = SI4713_MIN_POWER; 591 592 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_POWER, 593 args, ARRAY_SIZE(args), val, 594 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 595 596 if (err < 0) 597 return err; 598 599 v4l2_dbg(1, debug, &sdev->sd, 600 "%s: power=0x%02x antcap=0x%02x status=0x%02x\n", 601 __func__, power, antcap, val[0]); 602 603 return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE_POWER); 604 } 605 606 /* 607 * si4713_tx_tune_measure - Enters receive mode and measures the received noise 608 * level in units of dBuV on the selected frequency. 609 * The Frequency must be between 76 and 108 MHz in 10 kHz 610 * units and steps of 50 kHz. The command also sets the 611 * antenna tuning capacitance. A value of 0 means 612 * autotuning, and a value of 1 to 191 indicates manual 613 * override. 614 * @sdev: si4713_device structure for the device we are communicating 615 * @frequency: desired frequency (76 - 108 MHz, unit 10 KHz, step 50 kHz) 616 * @antcap: value of antenna tuning capacitor (0 - 191) 617 */ 618 static int si4713_tx_tune_measure(struct si4713_device *sdev, u16 frequency, 619 u8 antcap) 620 { 621 int err; 622 u8 val[SI4713_TXMEA_NRESP]; 623 /* 624 * .First byte = 0 625 * .Second byte = frequency's MSB 626 * .Third byte = frequency's LSB 627 * .Fourth byte = antcap 628 */ 629 const u8 args[SI4713_TXMEA_NARGS] = { 630 0x00, 631 msb(frequency), 632 lsb(frequency), 633 antcap, 634 }; 635 636 sdev->tune_rnl = DEFAULT_TUNE_RNL; 637 638 if (antcap > SI4713_MAX_ANTCAP) 639 return -EDOM; 640 641 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_MEASURE, 642 args, ARRAY_SIZE(args), val, 643 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 644 645 if (err < 0) 646 return err; 647 648 v4l2_dbg(1, debug, &sdev->sd, 649 "%s: frequency=0x%02x antcap=0x%02x status=0x%02x\n", 650 __func__, frequency, antcap, val[0]); 651 652 return si4713_wait_stc(sdev, TIMEOUT_TX_TUNE); 653 } 654 655 /* 656 * si4713_tx_tune_status- Returns the status of the tx_tune_freq, tx_tune_mea or 657 * tx_tune_power commands. This command return the current 658 * frequency, output voltage in dBuV, the antenna tunning 659 * capacitance value and the received noise level. The 660 * command also clears the stcint interrupt bit when the 661 * first bit of its arguments is high. 662 * @sdev: si4713_device structure for the device we are communicating 663 * @intack: 0x01 to clear the seek/tune complete interrupt status indicator. 664 * @frequency: returned frequency 665 * @power: returned power 666 * @antcap: returned antenna capacitance 667 * @noise: returned noise level 668 */ 669 static int si4713_tx_tune_status(struct si4713_device *sdev, u8 intack, 670 u16 *frequency, u8 *power, 671 u8 *antcap, u8 *noise) 672 { 673 int err; 674 u8 val[SI4713_TXSTATUS_NRESP]; 675 /* 676 * .First byte = intack bit 677 */ 678 const u8 args[SI4713_TXSTATUS_NARGS] = { 679 intack & SI4713_INTACK_MASK, 680 }; 681 682 err = si4713_send_command(sdev, SI4713_CMD_TX_TUNE_STATUS, 683 args, ARRAY_SIZE(args), val, 684 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 685 686 if (!err) { 687 v4l2_dbg(1, debug, &sdev->sd, 688 "%s: status=0x%02x\n", __func__, val[0]); 689 *frequency = compose_u16(val[2], val[3]); 690 sdev->frequency = *frequency; 691 *power = val[5]; 692 *antcap = val[6]; 693 *noise = val[7]; 694 v4l2_dbg(1, debug, &sdev->sd, "%s: response: %d x 10 kHz " 695 "(power %d, antcap %d, rnl %d)\n", __func__, 696 *frequency, *power, *antcap, *noise); 697 } 698 699 return err; 700 } 701 702 /* 703 * si4713_tx_rds_buff - Loads the RDS group buffer FIFO or circular buffer. 704 * @sdev: si4713_device structure for the device we are communicating 705 * @mode: the buffer operation mode. 706 * @rdsb: RDS Block B 707 * @rdsc: RDS Block C 708 * @rdsd: RDS Block D 709 * @cbleft: returns the number of available circular buffer blocks minus the 710 * number of used circular buffer blocks. 711 */ 712 static int si4713_tx_rds_buff(struct si4713_device *sdev, u8 mode, u16 rdsb, 713 u16 rdsc, u16 rdsd, s8 *cbleft) 714 { 715 int err; 716 u8 val[SI4713_RDSBUFF_NRESP]; 717 718 const u8 args[SI4713_RDSBUFF_NARGS] = { 719 mode & SI4713_RDSBUFF_MODE_MASK, 720 msb(rdsb), 721 lsb(rdsb), 722 msb(rdsc), 723 lsb(rdsc), 724 msb(rdsd), 725 lsb(rdsd), 726 }; 727 728 err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_BUFF, 729 args, ARRAY_SIZE(args), val, 730 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 731 732 if (!err) { 733 v4l2_dbg(1, debug, &sdev->sd, 734 "%s: status=0x%02x\n", __func__, val[0]); 735 *cbleft = (s8)val[2] - val[3]; 736 v4l2_dbg(1, debug, &sdev->sd, "%s: response: interrupts" 737 " 0x%02x cb avail: %d cb used %d fifo avail" 738 " %d fifo used %d\n", __func__, val[1], 739 val[2], val[3], val[4], val[5]); 740 } 741 742 return err; 743 } 744 745 /* 746 * si4713_tx_rds_ps - Loads the program service buffer. 747 * @sdev: si4713_device structure for the device we are communicating 748 * @psid: program service id to be loaded. 749 * @pschar: assumed 4 size char array to be loaded into the program service 750 */ 751 static int si4713_tx_rds_ps(struct si4713_device *sdev, u8 psid, 752 unsigned char *pschar) 753 { 754 int err; 755 u8 val[SI4713_RDSPS_NRESP]; 756 757 const u8 args[SI4713_RDSPS_NARGS] = { 758 psid & SI4713_RDSPS_PSID_MASK, 759 pschar[0], 760 pschar[1], 761 pschar[2], 762 pschar[3], 763 }; 764 765 err = si4713_send_command(sdev, SI4713_CMD_TX_RDS_PS, 766 args, ARRAY_SIZE(args), val, 767 ARRAY_SIZE(val), DEFAULT_TIMEOUT); 768 769 if (err < 0) 770 return err; 771 772 v4l2_dbg(1, debug, &sdev->sd, "%s: status=0x%02x\n", __func__, val[0]); 773 774 return err; 775 } 776 777 static int si4713_set_power_state(struct si4713_device *sdev, u8 value) 778 { 779 if (value) 780 return si4713_powerup(sdev); 781 return si4713_powerdown(sdev); 782 } 783 784 static int si4713_set_mute(struct si4713_device *sdev, u16 mute) 785 { 786 int rval = 0; 787 788 mute = set_mute(mute); 789 790 if (sdev->power_state) 791 rval = si4713_write_property(sdev, 792 SI4713_TX_LINE_INPUT_MUTE, mute); 793 794 return rval; 795 } 796 797 static int si4713_set_rds_ps_name(struct si4713_device *sdev, char *ps_name) 798 { 799 int rval = 0, i; 800 u8 len = 0; 801 802 /* We want to clear the whole thing */ 803 if (!strlen(ps_name)) 804 memset(ps_name, 0, MAX_RDS_PS_NAME + 1); 805 806 if (sdev->power_state) { 807 /* Write the new ps name and clear the padding */ 808 for (i = 0; i < MAX_RDS_PS_NAME; i += (RDS_BLOCK / 2)) { 809 rval = si4713_tx_rds_ps(sdev, (i / (RDS_BLOCK / 2)), 810 ps_name + i); 811 if (rval < 0) 812 return rval; 813 } 814 815 /* Setup the size to be sent */ 816 if (strlen(ps_name)) 817 len = strlen(ps_name) - 1; 818 else 819 len = 1; 820 821 rval = si4713_write_property(sdev, 822 SI4713_TX_RDS_PS_MESSAGE_COUNT, 823 rds_ps_nblocks(len)); 824 if (rval < 0) 825 return rval; 826 827 rval = si4713_write_property(sdev, 828 SI4713_TX_RDS_PS_REPEAT_COUNT, 829 DEFAULT_RDS_PS_REPEAT_COUNT * 2); 830 if (rval < 0) 831 return rval; 832 } 833 834 return rval; 835 } 836 837 static int si4713_set_rds_radio_text(struct si4713_device *sdev, const char *rt) 838 { 839 static const char cr[RDS_RADIOTEXT_BLK_SIZE] = { RDS_CARRIAGE_RETURN, 0 }; 840 int rval = 0, i; 841 u16 t_index = 0; 842 u8 b_index = 0, cr_inserted = 0; 843 s8 left; 844 845 if (!sdev->power_state) 846 return rval; 847 848 rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_CLEAR, 0, 0, 0, &left); 849 if (rval < 0) 850 return rval; 851 852 if (!strlen(rt)) 853 return rval; 854 855 do { 856 /* RDS spec says that if the last block isn't used, 857 * then apply a carriage return 858 */ 859 if (t_index < (RDS_RADIOTEXT_INDEX_MAX * RDS_RADIOTEXT_BLK_SIZE)) { 860 for (i = 0; i < RDS_RADIOTEXT_BLK_SIZE; i++) { 861 if (!rt[t_index + i] || 862 rt[t_index + i] == RDS_CARRIAGE_RETURN) { 863 rt = cr; 864 cr_inserted = 1; 865 break; 866 } 867 } 868 } 869 870 rval = si4713_tx_rds_buff(sdev, RDS_BLOCK_LOAD, 871 compose_u16(RDS_RADIOTEXT_2A, b_index++), 872 compose_u16(rt[t_index], rt[t_index + 1]), 873 compose_u16(rt[t_index + 2], rt[t_index + 3]), 874 &left); 875 if (rval < 0) 876 return rval; 877 878 t_index += RDS_RADIOTEXT_BLK_SIZE; 879 880 if (cr_inserted) 881 break; 882 } while (left > 0); 883 884 return rval; 885 } 886 887 /* 888 * si4713_update_tune_status - update properties from tx_tune_status 889 * command. Must be called with sdev->mutex held. 890 * @sdev: si4713_device structure for the device we are communicating 891 */ 892 static int si4713_update_tune_status(struct si4713_device *sdev) 893 { 894 int rval; 895 u16 f = 0; 896 u8 p = 0, a = 0, n = 0; 897 898 rval = si4713_tx_tune_status(sdev, 0x00, &f, &p, &a, &n); 899 900 if (rval < 0) 901 goto exit; 902 903 /* TODO: check that power_level and antenna_capacitor really are not 904 changed by the hardware. If they are, then these controls should become 905 volatiles. 906 sdev->power_level = p; 907 sdev->antenna_capacitor = a;*/ 908 sdev->tune_rnl = n; 909 910 exit: 911 return rval; 912 } 913 914 static int si4713_choose_econtrol_action(struct si4713_device *sdev, u32 id, 915 s32 *bit, s32 *mask, u16 *property, int *mul, 916 unsigned long **table, int *size) 917 { 918 s32 rval = 0; 919 920 switch (id) { 921 /* FM_TX class controls */ 922 case V4L2_CID_RDS_TX_PI: 923 *property = SI4713_TX_RDS_PI; 924 *mul = 1; 925 break; 926 case V4L2_CID_AUDIO_COMPRESSION_THRESHOLD: 927 *property = SI4713_TX_ACOMP_THRESHOLD; 928 *mul = 1; 929 break; 930 case V4L2_CID_AUDIO_COMPRESSION_GAIN: 931 *property = SI4713_TX_ACOMP_GAIN; 932 *mul = 1; 933 break; 934 case V4L2_CID_PILOT_TONE_FREQUENCY: 935 *property = SI4713_TX_PILOT_FREQUENCY; 936 *mul = 1; 937 break; 938 case V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME: 939 *property = SI4713_TX_ACOMP_ATTACK_TIME; 940 *mul = ATTACK_TIME_UNIT; 941 break; 942 case V4L2_CID_PILOT_TONE_DEVIATION: 943 *property = SI4713_TX_PILOT_DEVIATION; 944 *mul = 10; 945 break; 946 case V4L2_CID_AUDIO_LIMITER_DEVIATION: 947 *property = SI4713_TX_AUDIO_DEVIATION; 948 *mul = 10; 949 break; 950 case V4L2_CID_RDS_TX_DEVIATION: 951 *property = SI4713_TX_RDS_DEVIATION; 952 *mul = 1; 953 break; 954 955 case V4L2_CID_RDS_TX_PTY: 956 *property = SI4713_TX_RDS_PS_MISC; 957 *bit = 5; 958 *mask = 0x1F << 5; 959 break; 960 case V4L2_CID_AUDIO_LIMITER_ENABLED: 961 *property = SI4713_TX_ACOMP_ENABLE; 962 *bit = 1; 963 *mask = 1 << 1; 964 break; 965 case V4L2_CID_AUDIO_COMPRESSION_ENABLED: 966 *property = SI4713_TX_ACOMP_ENABLE; 967 *bit = 0; 968 *mask = 1 << 0; 969 break; 970 case V4L2_CID_PILOT_TONE_ENABLED: 971 *property = SI4713_TX_COMPONENT_ENABLE; 972 *bit = 0; 973 *mask = 1 << 0; 974 break; 975 976 case V4L2_CID_AUDIO_LIMITER_RELEASE_TIME: 977 *property = SI4713_TX_LIMITER_RELEASE_TIME; 978 *table = limiter_times; 979 *size = ARRAY_SIZE(limiter_times); 980 break; 981 case V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME: 982 *property = SI4713_TX_ACOMP_RELEASE_TIME; 983 *table = acomp_rtimes; 984 *size = ARRAY_SIZE(acomp_rtimes); 985 break; 986 case V4L2_CID_TUNE_PREEMPHASIS: 987 *property = SI4713_TX_PREEMPHASIS; 988 *table = preemphasis_values; 989 *size = ARRAY_SIZE(preemphasis_values); 990 break; 991 992 default: 993 rval = -EINVAL; 994 break; 995 } 996 997 return rval; 998 } 999 1000 static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f); 1001 static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *); 1002 /* 1003 * si4713_setup - Sets the device up with current configuration. 1004 * @sdev: si4713_device structure for the device we are communicating 1005 */ 1006 static int si4713_setup(struct si4713_device *sdev) 1007 { 1008 struct v4l2_frequency f; 1009 struct v4l2_modulator vm; 1010 int rval; 1011 1012 /* Device procedure needs to set frequency first */ 1013 f.tuner = 0; 1014 f.frequency = sdev->frequency ? sdev->frequency : DEFAULT_FREQUENCY; 1015 f.frequency = si4713_to_v4l2(f.frequency); 1016 rval = si4713_s_frequency(&sdev->sd, &f); 1017 1018 vm.index = 0; 1019 if (sdev->stereo) 1020 vm.txsubchans = V4L2_TUNER_SUB_STEREO; 1021 else 1022 vm.txsubchans = V4L2_TUNER_SUB_MONO; 1023 if (sdev->rds_enabled) 1024 vm.txsubchans |= V4L2_TUNER_SUB_RDS; 1025 si4713_s_modulator(&sdev->sd, &vm); 1026 1027 return rval; 1028 } 1029 1030 /* 1031 * si4713_initialize - Sets the device up with default configuration. 1032 * @sdev: si4713_device structure for the device we are communicating 1033 */ 1034 static int si4713_initialize(struct si4713_device *sdev) 1035 { 1036 int rval; 1037 1038 rval = si4713_set_power_state(sdev, POWER_ON); 1039 if (rval < 0) 1040 return rval; 1041 1042 rval = si4713_checkrev(sdev); 1043 if (rval < 0) 1044 return rval; 1045 1046 rval = si4713_set_power_state(sdev, POWER_OFF); 1047 if (rval < 0) 1048 return rval; 1049 1050 sdev->frequency = DEFAULT_FREQUENCY; 1051 sdev->stereo = 1; 1052 sdev->tune_rnl = DEFAULT_TUNE_RNL; 1053 return 0; 1054 } 1055 1056 /* si4713_s_ctrl - set the value of a control */ 1057 static int si4713_s_ctrl(struct v4l2_ctrl *ctrl) 1058 { 1059 struct si4713_device *sdev = 1060 container_of(ctrl->handler, struct si4713_device, ctrl_handler); 1061 u32 val = 0; 1062 s32 bit = 0, mask = 0; 1063 u16 property = 0; 1064 int mul = 0; 1065 unsigned long *table = NULL; 1066 int size = 0; 1067 bool force = false; 1068 int c; 1069 int ret = 0; 1070 1071 if (ctrl->id != V4L2_CID_AUDIO_MUTE) 1072 return -EINVAL; 1073 if (ctrl->is_new) { 1074 if (ctrl->val) { 1075 ret = si4713_set_mute(sdev, ctrl->val); 1076 if (!ret) 1077 ret = si4713_set_power_state(sdev, POWER_DOWN); 1078 return ret; 1079 } 1080 ret = si4713_set_power_state(sdev, POWER_UP); 1081 if (!ret) 1082 ret = si4713_set_mute(sdev, ctrl->val); 1083 if (!ret) 1084 ret = si4713_setup(sdev); 1085 if (ret) 1086 return ret; 1087 force = true; 1088 } 1089 1090 if (!sdev->power_state) 1091 return 0; 1092 1093 for (c = 1; !ret && c < ctrl->ncontrols; c++) { 1094 ctrl = ctrl->cluster[c]; 1095 1096 if (!force && !ctrl->is_new) 1097 continue; 1098 1099 switch (ctrl->id) { 1100 case V4L2_CID_RDS_TX_PS_NAME: 1101 ret = si4713_set_rds_ps_name(sdev, ctrl->string); 1102 break; 1103 1104 case V4L2_CID_RDS_TX_RADIO_TEXT: 1105 ret = si4713_set_rds_radio_text(sdev, ctrl->string); 1106 break; 1107 1108 case V4L2_CID_TUNE_ANTENNA_CAPACITOR: 1109 /* don't handle this control if we force setting all 1110 * controls since in that case it will be handled by 1111 * V4L2_CID_TUNE_POWER_LEVEL. */ 1112 if (force) 1113 break; 1114 /* fall through */ 1115 case V4L2_CID_TUNE_POWER_LEVEL: 1116 ret = si4713_tx_tune_power(sdev, 1117 sdev->tune_pwr_level->val, sdev->tune_ant_cap->val); 1118 if (!ret) { 1119 /* Make sure we don't set this twice */ 1120 sdev->tune_ant_cap->is_new = false; 1121 sdev->tune_pwr_level->is_new = false; 1122 } 1123 break; 1124 1125 default: 1126 ret = si4713_choose_econtrol_action(sdev, ctrl->id, &bit, 1127 &mask, &property, &mul, &table, &size); 1128 if (ret < 0) 1129 break; 1130 1131 val = ctrl->val; 1132 if (mul) { 1133 val = val / mul; 1134 } else if (table) { 1135 ret = usecs_to_dev(val, table, size); 1136 if (ret < 0) 1137 break; 1138 val = ret; 1139 ret = 0; 1140 } 1141 1142 if (mask) { 1143 ret = si4713_read_property(sdev, property, &val); 1144 if (ret < 0) 1145 break; 1146 val = set_bits(val, ctrl->val, bit, mask); 1147 } 1148 1149 ret = si4713_write_property(sdev, property, val); 1150 if (ret < 0) 1151 break; 1152 if (mask) 1153 val = ctrl->val; 1154 break; 1155 } 1156 } 1157 1158 return ret; 1159 } 1160 1161 /* si4713_ioctl - deal with private ioctls (only rnl for now) */ 1162 static long si4713_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg) 1163 { 1164 struct si4713_device *sdev = to_si4713_device(sd); 1165 struct si4713_rnl *rnl = arg; 1166 u16 frequency; 1167 int rval = 0; 1168 1169 if (!arg) 1170 return -EINVAL; 1171 1172 switch (cmd) { 1173 case SI4713_IOC_MEASURE_RNL: 1174 frequency = v4l2_to_si4713(rnl->frequency); 1175 1176 if (sdev->power_state) { 1177 /* Set desired measurement frequency */ 1178 rval = si4713_tx_tune_measure(sdev, frequency, 0); 1179 if (rval < 0) 1180 return rval; 1181 /* get results from tune status */ 1182 rval = si4713_update_tune_status(sdev); 1183 if (rval < 0) 1184 return rval; 1185 } 1186 rnl->rnl = sdev->tune_rnl; 1187 break; 1188 1189 default: 1190 /* nothing */ 1191 rval = -ENOIOCTLCMD; 1192 } 1193 1194 return rval; 1195 } 1196 1197 /* si4713_g_modulator - get modulator attributes */ 1198 static int si4713_g_modulator(struct v4l2_subdev *sd, struct v4l2_modulator *vm) 1199 { 1200 struct si4713_device *sdev = to_si4713_device(sd); 1201 int rval = 0; 1202 1203 if (!sdev) 1204 return -ENODEV; 1205 1206 if (vm->index > 0) 1207 return -EINVAL; 1208 1209 strncpy(vm->name, "FM Modulator", 32); 1210 vm->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW | 1211 V4L2_TUNER_CAP_RDS | V4L2_TUNER_CAP_RDS_CONTROLS; 1212 1213 /* Report current frequency range limits */ 1214 vm->rangelow = si4713_to_v4l2(FREQ_RANGE_LOW); 1215 vm->rangehigh = si4713_to_v4l2(FREQ_RANGE_HIGH); 1216 1217 if (sdev->power_state) { 1218 u32 comp_en = 0; 1219 1220 rval = si4713_read_property(sdev, SI4713_TX_COMPONENT_ENABLE, 1221 &comp_en); 1222 if (rval < 0) 1223 return rval; 1224 1225 sdev->stereo = get_status_bit(comp_en, 1, 1 << 1); 1226 } 1227 1228 /* Report current audio mode: mono or stereo */ 1229 if (sdev->stereo) 1230 vm->txsubchans = V4L2_TUNER_SUB_STEREO; 1231 else 1232 vm->txsubchans = V4L2_TUNER_SUB_MONO; 1233 1234 /* Report rds feature status */ 1235 if (sdev->rds_enabled) 1236 vm->txsubchans |= V4L2_TUNER_SUB_RDS; 1237 else 1238 vm->txsubchans &= ~V4L2_TUNER_SUB_RDS; 1239 1240 return rval; 1241 } 1242 1243 /* si4713_s_modulator - set modulator attributes */ 1244 static int si4713_s_modulator(struct v4l2_subdev *sd, const struct v4l2_modulator *vm) 1245 { 1246 struct si4713_device *sdev = to_si4713_device(sd); 1247 int rval = 0; 1248 u16 stereo, rds; 1249 u32 p; 1250 1251 if (!sdev) 1252 return -ENODEV; 1253 1254 if (vm->index > 0) 1255 return -EINVAL; 1256 1257 /* Set audio mode: mono or stereo */ 1258 if (vm->txsubchans & V4L2_TUNER_SUB_STEREO) 1259 stereo = 1; 1260 else if (vm->txsubchans & V4L2_TUNER_SUB_MONO) 1261 stereo = 0; 1262 else 1263 return -EINVAL; 1264 1265 rds = !!(vm->txsubchans & V4L2_TUNER_SUB_RDS); 1266 1267 if (sdev->power_state) { 1268 rval = si4713_read_property(sdev, 1269 SI4713_TX_COMPONENT_ENABLE, &p); 1270 if (rval < 0) 1271 return rval; 1272 1273 p = set_bits(p, stereo, 1, 1 << 1); 1274 p = set_bits(p, rds, 2, 1 << 2); 1275 1276 rval = si4713_write_property(sdev, 1277 SI4713_TX_COMPONENT_ENABLE, p); 1278 if (rval < 0) 1279 return rval; 1280 } 1281 1282 sdev->stereo = stereo; 1283 sdev->rds_enabled = rds; 1284 1285 return rval; 1286 } 1287 1288 /* si4713_g_frequency - get tuner or modulator radio frequency */ 1289 static int si4713_g_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *f) 1290 { 1291 struct si4713_device *sdev = to_si4713_device(sd); 1292 int rval = 0; 1293 1294 if (f->tuner) 1295 return -EINVAL; 1296 1297 if (sdev->power_state) { 1298 u16 freq; 1299 u8 p, a, n; 1300 1301 rval = si4713_tx_tune_status(sdev, 0x00, &freq, &p, &a, &n); 1302 if (rval < 0) 1303 return rval; 1304 1305 sdev->frequency = freq; 1306 } 1307 1308 f->frequency = si4713_to_v4l2(sdev->frequency); 1309 1310 return rval; 1311 } 1312 1313 /* si4713_s_frequency - set tuner or modulator radio frequency */ 1314 static int si4713_s_frequency(struct v4l2_subdev *sd, const struct v4l2_frequency *f) 1315 { 1316 struct si4713_device *sdev = to_si4713_device(sd); 1317 int rval = 0; 1318 u16 frequency = v4l2_to_si4713(f->frequency); 1319 1320 if (f->tuner) 1321 return -EINVAL; 1322 1323 /* Check frequency range */ 1324 frequency = clamp_t(u16, frequency, FREQ_RANGE_LOW, FREQ_RANGE_HIGH); 1325 1326 if (sdev->power_state) { 1327 rval = si4713_tx_tune_freq(sdev, frequency); 1328 if (rval < 0) 1329 return rval; 1330 frequency = rval; 1331 rval = 0; 1332 } 1333 sdev->frequency = frequency; 1334 1335 return rval; 1336 } 1337 1338 static const struct v4l2_ctrl_ops si4713_ctrl_ops = { 1339 .s_ctrl = si4713_s_ctrl, 1340 }; 1341 1342 static const struct v4l2_subdev_core_ops si4713_subdev_core_ops = { 1343 .ioctl = si4713_ioctl, 1344 }; 1345 1346 static const struct v4l2_subdev_tuner_ops si4713_subdev_tuner_ops = { 1347 .g_frequency = si4713_g_frequency, 1348 .s_frequency = si4713_s_frequency, 1349 .g_modulator = si4713_g_modulator, 1350 .s_modulator = si4713_s_modulator, 1351 }; 1352 1353 static const struct v4l2_subdev_ops si4713_subdev_ops = { 1354 .core = &si4713_subdev_core_ops, 1355 .tuner = &si4713_subdev_tuner_ops, 1356 }; 1357 1358 /* 1359 * I2C driver interface 1360 */ 1361 /* si4713_probe - probe for the device */ 1362 static int si4713_probe(struct i2c_client *client, 1363 const struct i2c_device_id *id) 1364 { 1365 struct si4713_device *sdev; 1366 struct si4713_platform_data *pdata = client->dev.platform_data; 1367 struct v4l2_ctrl_handler *hdl; 1368 int rval, i; 1369 1370 sdev = kzalloc(sizeof(*sdev), GFP_KERNEL); 1371 if (!sdev) { 1372 dev_err(&client->dev, "Failed to alloc video device.\n"); 1373 rval = -ENOMEM; 1374 goto exit; 1375 } 1376 1377 sdev->gpio_reset = -1; 1378 if (pdata && gpio_is_valid(pdata->gpio_reset)) { 1379 rval = gpio_request(pdata->gpio_reset, "si4713 reset"); 1380 if (rval) { 1381 dev_err(&client->dev, 1382 "Failed to request gpio: %d\n", rval); 1383 goto free_sdev; 1384 } 1385 sdev->gpio_reset = pdata->gpio_reset; 1386 gpio_direction_output(sdev->gpio_reset, 0); 1387 sdev->supplies = pdata->supplies; 1388 } 1389 1390 for (i = 0; i < sdev->supplies; i++) 1391 sdev->supply_data[i].supply = pdata->supply_names[i]; 1392 1393 rval = regulator_bulk_get(&client->dev, sdev->supplies, 1394 sdev->supply_data); 1395 if (rval) { 1396 dev_err(&client->dev, "Cannot get regulators: %d\n", rval); 1397 goto free_gpio; 1398 } 1399 1400 v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops); 1401 1402 init_completion(&sdev->work); 1403 1404 hdl = &sdev->ctrl_handler; 1405 v4l2_ctrl_handler_init(hdl, 20); 1406 sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1407 V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE); 1408 1409 sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1410 V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI); 1411 sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1412 V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY); 1413 sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1414 V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION, 1415 10, DEFAULT_RDS_DEVIATION); 1416 /* 1417 * Report step as 8. From RDS spec, psname 1418 * should be 8. But there are receivers which scroll strings 1419 * sized as 8xN. 1420 */ 1421 sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1422 V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0); 1423 /* 1424 * Report step as 32 (2A block). From RDS spec, 1425 * radio text should be 32 for 2A block. But there are receivers 1426 * which scroll strings sized as 32xN. Setting default to 32. 1427 */ 1428 sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1429 V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0); 1430 1431 sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1432 V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1); 1433 sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1434 V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250, 1435 MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME); 1436 sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1437 V4L2_CID_AUDIO_LIMITER_DEVIATION, 0, 1438 MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV); 1439 1440 sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1441 V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1); 1442 sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1443 V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1, 1444 DEFAULT_ACOMP_GAIN); 1445 sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1446 V4L2_CID_AUDIO_COMPRESSION_THRESHOLD, 1447 MIN_ACOMP_THRESHOLD, MAX_ACOMP_THRESHOLD, 1, 1448 DEFAULT_ACOMP_THRESHOLD); 1449 sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1450 V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0, 1451 MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME); 1452 sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1453 V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000, 1454 MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME); 1455 1456 sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1457 V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1); 1458 sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1459 V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION, 1460 10, DEFAULT_PILOT_DEVIATION); 1461 sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1462 V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY, 1463 1, DEFAULT_PILOT_FREQUENCY); 1464 1465 sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops, 1466 V4L2_CID_TUNE_PREEMPHASIS, 1467 V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS); 1468 sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1469 V4L2_CID_TUNE_POWER_LEVEL, 0, SI4713_MAX_POWER, 1470 1, DEFAULT_POWER_LEVEL); 1471 sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops, 1472 V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, SI4713_MAX_ANTCAP, 1473 1, 0); 1474 1475 if (hdl->error) { 1476 rval = hdl->error; 1477 goto free_ctrls; 1478 } 1479 v4l2_ctrl_cluster(20, &sdev->mute); 1480 sdev->sd.ctrl_handler = hdl; 1481 1482 if (client->irq) { 1483 rval = request_irq(client->irq, 1484 si4713_handler, IRQF_TRIGGER_FALLING, 1485 client->name, sdev); 1486 if (rval < 0) { 1487 v4l2_err(&sdev->sd, "Could not request IRQ\n"); 1488 goto put_reg; 1489 } 1490 v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n"); 1491 } else { 1492 v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n"); 1493 } 1494 1495 rval = si4713_initialize(sdev); 1496 if (rval < 0) { 1497 v4l2_err(&sdev->sd, "Failed to probe device information.\n"); 1498 goto free_irq; 1499 } 1500 1501 return 0; 1502 1503 free_irq: 1504 if (client->irq) 1505 free_irq(client->irq, sdev); 1506 free_ctrls: 1507 v4l2_ctrl_handler_free(hdl); 1508 put_reg: 1509 regulator_bulk_free(sdev->supplies, sdev->supply_data); 1510 free_gpio: 1511 if (gpio_is_valid(sdev->gpio_reset)) 1512 gpio_free(sdev->gpio_reset); 1513 free_sdev: 1514 kfree(sdev); 1515 exit: 1516 return rval; 1517 } 1518 1519 /* si4713_remove - remove the device */ 1520 static int si4713_remove(struct i2c_client *client) 1521 { 1522 struct v4l2_subdev *sd = i2c_get_clientdata(client); 1523 struct si4713_device *sdev = to_si4713_device(sd); 1524 1525 if (sdev->power_state) 1526 si4713_set_power_state(sdev, POWER_DOWN); 1527 1528 if (client->irq > 0) 1529 free_irq(client->irq, sdev); 1530 1531 v4l2_device_unregister_subdev(sd); 1532 v4l2_ctrl_handler_free(sd->ctrl_handler); 1533 regulator_bulk_free(sdev->supplies, sdev->supply_data); 1534 if (gpio_is_valid(sdev->gpio_reset)) 1535 gpio_free(sdev->gpio_reset); 1536 kfree(sdev); 1537 1538 return 0; 1539 } 1540 1541 /* si4713_i2c_driver - i2c driver interface */ 1542 static const struct i2c_device_id si4713_id[] = { 1543 { "si4713" , 0 }, 1544 { }, 1545 }; 1546 MODULE_DEVICE_TABLE(i2c, si4713_id); 1547 1548 static struct i2c_driver si4713_i2c_driver = { 1549 .driver = { 1550 .name = "si4713", 1551 }, 1552 .probe = si4713_probe, 1553 .remove = si4713_remove, 1554 .id_table = si4713_id, 1555 }; 1556 1557 module_i2c_driver(si4713_i2c_driver); 1558