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