1 /* 2 * Driver for the Texas Instruments WL1273 FM radio. 3 * 4 * Copyright (C) 2011 Nokia Corporation 5 * Author: Matti J. Aaltonen <matti.j.aaltonen@nokia.com> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * version 2 as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 */ 20 21 #include <linux/delay.h> 22 #include <linux/firmware.h> 23 #include <linux/interrupt.h> 24 #include <linux/mfd/wl1273-core.h> 25 #include <linux/slab.h> 26 #include <linux/module.h> 27 #include <media/v4l2-common.h> 28 #include <media/v4l2-ctrls.h> 29 #include <media/v4l2-device.h> 30 #include <media/v4l2-ioctl.h> 31 32 #define DRIVER_DESC "Wl1273 FM Radio" 33 34 #define WL1273_POWER_SET_OFF 0 35 #define WL1273_POWER_SET_FM BIT(0) 36 #define WL1273_POWER_SET_RDS BIT(1) 37 #define WL1273_POWER_SET_RETENTION BIT(4) 38 39 #define WL1273_PUPD_SET_OFF 0x00 40 #define WL1273_PUPD_SET_ON 0x01 41 #define WL1273_PUPD_SET_RETENTION 0x10 42 43 #define WL1273_FREQ(x) (x * 10000 / 625) 44 #define WL1273_INV_FREQ(x) (x * 625 / 10000) 45 46 /* 47 * static int radio_nr - The number of the radio device 48 * 49 * The default is 0. 50 */ 51 static int radio_nr; 52 module_param(radio_nr, int, 0); 53 MODULE_PARM_DESC(radio_nr, "The number of the radio device. Default = 0"); 54 55 struct wl1273_device { 56 char *bus_type; 57 58 u8 forbidden; 59 unsigned int preemphasis; 60 unsigned int spacing; 61 unsigned int tx_power; 62 unsigned int rx_frequency; 63 unsigned int tx_frequency; 64 unsigned int rangelow; 65 unsigned int rangehigh; 66 unsigned int band; 67 bool stereo; 68 69 /* RDS */ 70 unsigned int rds_on; 71 72 wait_queue_head_t read_queue; 73 struct mutex lock; /* for serializing fm radio operations */ 74 struct completion busy; 75 76 unsigned char *buffer; 77 unsigned int buf_size; 78 unsigned int rd_index; 79 unsigned int wr_index; 80 81 /* Selected interrupts */ 82 u16 irq_flags; 83 u16 irq_received; 84 85 struct v4l2_ctrl_handler ctrl_handler; 86 struct v4l2_device v4l2dev; 87 struct video_device videodev; 88 struct device *dev; 89 struct wl1273_core *core; 90 struct file *owner; 91 char *write_buf; 92 unsigned int rds_users; 93 }; 94 95 #define WL1273_IRQ_MASK (WL1273_FR_EVENT | \ 96 WL1273_POW_ENB_EVENT) 97 98 /* 99 * static unsigned int rds_buf - the number of RDS buffer blocks used. 100 * 101 * The default number is 100. 102 */ 103 static unsigned int rds_buf = 100; 104 module_param(rds_buf, uint, 0); 105 MODULE_PARM_DESC(rds_buf, "Number of RDS buffer entries. Default = 100"); 106 107 static int wl1273_fm_write_fw(struct wl1273_core *core, 108 __u8 *fw, int len) 109 { 110 struct i2c_client *client = core->client; 111 struct i2c_msg msg; 112 int i, r = 0; 113 114 msg.addr = client->addr; 115 msg.flags = 0; 116 117 for (i = 0; i <= len; i++) { 118 msg.len = fw[0]; 119 msg.buf = fw + 1; 120 121 fw += msg.len + 1; 122 dev_dbg(&client->dev, "%s:len[%d]: %d\n", __func__, i, msg.len); 123 124 r = i2c_transfer(client->adapter, &msg, 1); 125 if (r < 0 && i < len + 1) 126 break; 127 } 128 129 dev_dbg(&client->dev, "%s: i: %d\n", __func__, i); 130 dev_dbg(&client->dev, "%s: len + 1: %d\n", __func__, len + 1); 131 132 /* Last transfer always fails. */ 133 if (i == len || r == 1) 134 r = 0; 135 136 return r; 137 } 138 139 #define WL1273_FIFO_HAS_DATA(status) (1 << 5 & status) 140 #define WL1273_RDS_CORRECTABLE_ERROR (1 << 3) 141 #define WL1273_RDS_UNCORRECTABLE_ERROR (1 << 4) 142 143 static int wl1273_fm_rds(struct wl1273_device *radio) 144 { 145 struct wl1273_core *core = radio->core; 146 struct i2c_client *client = core->client; 147 u16 val; 148 u8 b0 = WL1273_RDS_DATA_GET, status; 149 struct v4l2_rds_data rds = { 0, 0, 0 }; 150 struct i2c_msg msg[] = { 151 { 152 .addr = client->addr, 153 .flags = 0, 154 .buf = &b0, 155 .len = 1, 156 }, 157 { 158 .addr = client->addr, 159 .flags = I2C_M_RD, 160 .buf = (u8 *) &rds, 161 .len = sizeof(rds), 162 } 163 }; 164 int r; 165 166 if (core->mode != WL1273_MODE_RX) 167 return 0; 168 169 r = core->read(core, WL1273_RDS_SYNC_GET, &val); 170 if (r) 171 return r; 172 173 if ((val & 0x01) == 0) { 174 /* RDS decoder not synchronized */ 175 return -EAGAIN; 176 } 177 178 /* copy all four RDS blocks to internal buffer */ 179 do { 180 r = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); 181 if (r != ARRAY_SIZE(msg)) { 182 dev_err(radio->dev, WL1273_FM_DRIVER_NAME 183 ": %s: read_rds error r == %i)\n", 184 __func__, r); 185 } 186 187 status = rds.block; 188 189 if (!WL1273_FIFO_HAS_DATA(status)) 190 break; 191 192 /* copy bits 0-2 (the block ID) to bits 3-5 */ 193 rds.block = V4L2_RDS_BLOCK_MSK & status; 194 rds.block |= rds.block << 3; 195 196 /* copy the error bits to standard positions */ 197 if (WL1273_RDS_UNCORRECTABLE_ERROR & status) { 198 rds.block |= V4L2_RDS_BLOCK_ERROR; 199 rds.block &= ~V4L2_RDS_BLOCK_CORRECTED; 200 } else if (WL1273_RDS_CORRECTABLE_ERROR & status) { 201 rds.block &= ~V4L2_RDS_BLOCK_ERROR; 202 rds.block |= V4L2_RDS_BLOCK_CORRECTED; 203 } 204 205 /* copy RDS block to internal buffer */ 206 memcpy(&radio->buffer[radio->wr_index], &rds, RDS_BLOCK_SIZE); 207 radio->wr_index += 3; 208 209 /* wrap write pointer */ 210 if (radio->wr_index >= radio->buf_size) 211 radio->wr_index = 0; 212 213 /* check for overflow & start over */ 214 if (radio->wr_index == radio->rd_index) { 215 dev_dbg(radio->dev, "RDS OVERFLOW"); 216 217 radio->rd_index = 0; 218 radio->wr_index = 0; 219 break; 220 } 221 } while (WL1273_FIFO_HAS_DATA(status)); 222 223 /* wake up read queue */ 224 if (radio->wr_index != radio->rd_index) 225 wake_up_interruptible(&radio->read_queue); 226 227 return 0; 228 } 229 230 static irqreturn_t wl1273_fm_irq_thread_handler(int irq, void *dev_id) 231 { 232 struct wl1273_device *radio = dev_id; 233 struct wl1273_core *core = radio->core; 234 u16 flags; 235 int r; 236 237 r = core->read(core, WL1273_FLAG_GET, &flags); 238 if (r) 239 goto out; 240 241 if (flags & WL1273_BL_EVENT) { 242 radio->irq_received = flags; 243 dev_dbg(radio->dev, "IRQ: BL\n"); 244 } 245 246 if (flags & WL1273_RDS_EVENT) { 247 msleep(200); 248 249 wl1273_fm_rds(radio); 250 } 251 252 if (flags & WL1273_BBLK_EVENT) 253 dev_dbg(radio->dev, "IRQ: BBLK\n"); 254 255 if (flags & WL1273_LSYNC_EVENT) 256 dev_dbg(radio->dev, "IRQ: LSYNC\n"); 257 258 if (flags & WL1273_LEV_EVENT) { 259 u16 level; 260 261 r = core->read(core, WL1273_RSSI_LVL_GET, &level); 262 if (r) 263 goto out; 264 265 if (level > 14) 266 dev_dbg(radio->dev, "IRQ: LEV: 0x%x04\n", level); 267 } 268 269 if (flags & WL1273_IFFR_EVENT) 270 dev_dbg(radio->dev, "IRQ: IFFR\n"); 271 272 if (flags & WL1273_PI_EVENT) 273 dev_dbg(radio->dev, "IRQ: PI\n"); 274 275 if (flags & WL1273_PD_EVENT) 276 dev_dbg(radio->dev, "IRQ: PD\n"); 277 278 if (flags & WL1273_STIC_EVENT) 279 dev_dbg(radio->dev, "IRQ: STIC\n"); 280 281 if (flags & WL1273_MAL_EVENT) 282 dev_dbg(radio->dev, "IRQ: MAL\n"); 283 284 if (flags & WL1273_POW_ENB_EVENT) { 285 complete(&radio->busy); 286 dev_dbg(radio->dev, "NOT BUSY\n"); 287 dev_dbg(radio->dev, "IRQ: POW_ENB\n"); 288 } 289 290 if (flags & WL1273_SCAN_OVER_EVENT) 291 dev_dbg(radio->dev, "IRQ: SCAN_OVER\n"); 292 293 if (flags & WL1273_ERROR_EVENT) 294 dev_dbg(radio->dev, "IRQ: ERROR\n"); 295 296 if (flags & WL1273_FR_EVENT) { 297 u16 freq; 298 299 dev_dbg(radio->dev, "IRQ: FR:\n"); 300 301 if (core->mode == WL1273_MODE_RX) { 302 r = core->write(core, WL1273_TUNER_MODE_SET, 303 TUNER_MODE_STOP_SEARCH); 304 if (r) { 305 dev_err(radio->dev, 306 "%s: TUNER_MODE_SET fails: %d\n", 307 __func__, r); 308 goto out; 309 } 310 311 r = core->read(core, WL1273_FREQ_SET, &freq); 312 if (r) 313 goto out; 314 315 if (radio->band == WL1273_BAND_JAPAN) 316 radio->rx_frequency = WL1273_BAND_JAPAN_LOW + 317 freq * 50; 318 else 319 radio->rx_frequency = WL1273_BAND_OTHER_LOW + 320 freq * 50; 321 /* 322 * The driver works better with this msleep, 323 * the documentation doesn't mention it. 324 */ 325 usleep_range(10000, 15000); 326 327 dev_dbg(radio->dev, "%dkHz\n", radio->rx_frequency); 328 329 } else { 330 r = core->read(core, WL1273_CHANL_SET, &freq); 331 if (r) 332 goto out; 333 334 dev_dbg(radio->dev, "%dkHz\n", freq); 335 } 336 dev_dbg(radio->dev, "%s: NOT BUSY\n", __func__); 337 } 338 339 out: 340 core->write(core, WL1273_INT_MASK_SET, radio->irq_flags); 341 complete(&radio->busy); 342 343 return IRQ_HANDLED; 344 } 345 346 static int wl1273_fm_set_tx_freq(struct wl1273_device *radio, unsigned int freq) 347 { 348 struct wl1273_core *core = radio->core; 349 int r = 0; 350 351 if (freq < WL1273_BAND_TX_LOW) { 352 dev_err(radio->dev, 353 "Frequency out of range: %d < %d\n", freq, 354 WL1273_BAND_TX_LOW); 355 return -ERANGE; 356 } 357 358 if (freq > WL1273_BAND_TX_HIGH) { 359 dev_err(radio->dev, 360 "Frequency out of range: %d > %d\n", freq, 361 WL1273_BAND_TX_HIGH); 362 return -ERANGE; 363 } 364 365 /* 366 * The driver works better with this sleep, 367 * the documentation doesn't mention it. 368 */ 369 usleep_range(5000, 10000); 370 371 dev_dbg(radio->dev, "%s: freq: %d kHz\n", __func__, freq); 372 373 /* Set the current tx channel */ 374 r = core->write(core, WL1273_CHANL_SET, freq / 10); 375 if (r) 376 return r; 377 378 INIT_COMPLETION(radio->busy); 379 380 /* wait for the FR IRQ */ 381 r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000)); 382 if (!r) 383 return -ETIMEDOUT; 384 385 dev_dbg(radio->dev, "WL1273_CHANL_SET: %d\n", r); 386 387 /* Enable the output power */ 388 r = core->write(core, WL1273_POWER_ENB_SET, 1); 389 if (r) 390 return r; 391 392 INIT_COMPLETION(radio->busy); 393 394 /* wait for the POWER_ENB IRQ */ 395 r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000)); 396 if (!r) 397 return -ETIMEDOUT; 398 399 radio->tx_frequency = freq; 400 dev_dbg(radio->dev, "WL1273_POWER_ENB_SET: %d\n", r); 401 402 return 0; 403 } 404 405 static int wl1273_fm_set_rx_freq(struct wl1273_device *radio, unsigned int freq) 406 { 407 struct wl1273_core *core = radio->core; 408 int r, f; 409 410 if (freq < radio->rangelow) { 411 dev_err(radio->dev, 412 "Frequency out of range: %d < %d\n", freq, 413 radio->rangelow); 414 r = -ERANGE; 415 goto err; 416 } 417 418 if (freq > radio->rangehigh) { 419 dev_err(radio->dev, 420 "Frequency out of range: %d > %d\n", freq, 421 radio->rangehigh); 422 r = -ERANGE; 423 goto err; 424 } 425 426 dev_dbg(radio->dev, "%s: %dkHz\n", __func__, freq); 427 428 core->write(core, WL1273_INT_MASK_SET, radio->irq_flags); 429 430 if (radio->band == WL1273_BAND_JAPAN) 431 f = (freq - WL1273_BAND_JAPAN_LOW) / 50; 432 else 433 f = (freq - WL1273_BAND_OTHER_LOW) / 50; 434 435 r = core->write(core, WL1273_FREQ_SET, f); 436 if (r) { 437 dev_err(radio->dev, "FREQ_SET fails\n"); 438 goto err; 439 } 440 441 r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_PRESET); 442 if (r) { 443 dev_err(radio->dev, "TUNER_MODE_SET fails\n"); 444 goto err; 445 } 446 447 INIT_COMPLETION(radio->busy); 448 449 r = wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(2000)); 450 if (!r) { 451 dev_err(radio->dev, "%s: TIMEOUT\n", __func__); 452 return -ETIMEDOUT; 453 } 454 455 radio->rd_index = 0; 456 radio->wr_index = 0; 457 radio->rx_frequency = freq; 458 return 0; 459 err: 460 return r; 461 } 462 463 static int wl1273_fm_get_freq(struct wl1273_device *radio) 464 { 465 struct wl1273_core *core = radio->core; 466 unsigned int freq; 467 u16 f; 468 int r; 469 470 if (core->mode == WL1273_MODE_RX) { 471 r = core->read(core, WL1273_FREQ_SET, &f); 472 if (r) 473 return r; 474 475 dev_dbg(radio->dev, "Freq get: 0x%04x\n", f); 476 if (radio->band == WL1273_BAND_JAPAN) 477 freq = WL1273_BAND_JAPAN_LOW + 50 * f; 478 else 479 freq = WL1273_BAND_OTHER_LOW + 50 * f; 480 } else { 481 r = core->read(core, WL1273_CHANL_SET, &f); 482 if (r) 483 return r; 484 485 freq = f * 10; 486 } 487 488 return freq; 489 } 490 491 /** 492 * wl1273_fm_upload_firmware_patch() - Upload the firmware. 493 * @radio: A pointer to the device struct. 494 * 495 * The firmware file consists of arrays of bytes where the first byte 496 * gives the array length. The first byte in the file gives the 497 * number of these arrays. 498 */ 499 static int wl1273_fm_upload_firmware_patch(struct wl1273_device *radio) 500 { 501 struct wl1273_core *core = radio->core; 502 unsigned int packet_num; 503 const struct firmware *fw_p; 504 const char *fw_name = "radio-wl1273-fw.bin"; 505 struct device *dev = radio->dev; 506 __u8 *ptr; 507 int r; 508 509 dev_dbg(dev, "%s:\n", __func__); 510 511 /* 512 * Uploading the firmware patch is not always necessary, 513 * so we only print an info message. 514 */ 515 if (request_firmware(&fw_p, fw_name, dev)) { 516 dev_info(dev, "%s - %s not found\n", __func__, fw_name); 517 518 return 0; 519 } 520 521 ptr = (__u8 *) fw_p->data; 522 packet_num = ptr[0]; 523 dev_dbg(dev, "%s: packets: %d\n", __func__, packet_num); 524 525 r = wl1273_fm_write_fw(core, ptr + 1, packet_num); 526 if (r) { 527 dev_err(dev, "FW upload error: %d\n", r); 528 goto out; 529 } 530 531 /* ignore possible error here */ 532 core->write(core, WL1273_RESET, 0); 533 534 dev_dbg(dev, "%s - download OK, r: %d\n", __func__, r); 535 out: 536 release_firmware(fw_p); 537 return r; 538 } 539 540 static int wl1273_fm_stop(struct wl1273_device *radio) 541 { 542 struct wl1273_core *core = radio->core; 543 544 if (core->mode == WL1273_MODE_RX) { 545 int r = core->write(core, WL1273_POWER_SET, 546 WL1273_POWER_SET_OFF); 547 if (r) 548 dev_err(radio->dev, "%s: POWER_SET fails: %d\n", 549 __func__, r); 550 } else if (core->mode == WL1273_MODE_TX) { 551 int r = core->write(core, WL1273_PUPD_SET, 552 WL1273_PUPD_SET_OFF); 553 if (r) 554 dev_err(radio->dev, 555 "%s: PUPD_SET fails: %d\n", __func__, r); 556 } 557 558 if (core->pdata->disable) { 559 core->pdata->disable(); 560 dev_dbg(radio->dev, "Back to reset\n"); 561 } 562 563 return 0; 564 } 565 566 static int wl1273_fm_start(struct wl1273_device *radio, int new_mode) 567 { 568 struct wl1273_core *core = radio->core; 569 struct wl1273_fm_platform_data *pdata = core->pdata; 570 struct device *dev = radio->dev; 571 int r = -EINVAL; 572 573 if (pdata->enable && core->mode == WL1273_MODE_OFF) { 574 dev_dbg(radio->dev, "Out of reset\n"); 575 576 pdata->enable(); 577 msleep(250); 578 } 579 580 if (new_mode == WL1273_MODE_RX) { 581 u16 val = WL1273_POWER_SET_FM; 582 583 if (radio->rds_on) 584 val |= WL1273_POWER_SET_RDS; 585 586 /* If this fails try again */ 587 r = core->write(core, WL1273_POWER_SET, val); 588 if (r) { 589 msleep(100); 590 591 r = core->write(core, WL1273_POWER_SET, val); 592 if (r) { 593 dev_err(dev, "%s: POWER_SET fails\n", __func__); 594 goto fail; 595 } 596 } 597 598 /* rds buffer configuration */ 599 radio->wr_index = 0; 600 radio->rd_index = 0; 601 602 } else if (new_mode == WL1273_MODE_TX) { 603 /* If this fails try again once */ 604 r = core->write(core, WL1273_PUPD_SET, WL1273_PUPD_SET_ON); 605 if (r) { 606 msleep(100); 607 r = core->write(core, WL1273_PUPD_SET, 608 WL1273_PUPD_SET_ON); 609 if (r) { 610 dev_err(dev, "%s: PUPD_SET fails\n", __func__); 611 goto fail; 612 } 613 } 614 615 if (radio->rds_on) 616 r = core->write(core, WL1273_RDS_DATA_ENB, 1); 617 else 618 r = core->write(core, WL1273_RDS_DATA_ENB, 0); 619 } else { 620 dev_warn(dev, "%s: Illegal mode.\n", __func__); 621 } 622 623 if (core->mode == WL1273_MODE_OFF) { 624 r = wl1273_fm_upload_firmware_patch(radio); 625 if (r) 626 dev_warn(dev, "Firmware upload failed.\n"); 627 628 /* 629 * Sometimes the chip is in a wrong power state at this point. 630 * So we set the power once again. 631 */ 632 if (new_mode == WL1273_MODE_RX) { 633 u16 val = WL1273_POWER_SET_FM; 634 635 if (radio->rds_on) 636 val |= WL1273_POWER_SET_RDS; 637 638 r = core->write(core, WL1273_POWER_SET, val); 639 if (r) { 640 dev_err(dev, "%s: POWER_SET fails\n", __func__); 641 goto fail; 642 } 643 } else if (new_mode == WL1273_MODE_TX) { 644 r = core->write(core, WL1273_PUPD_SET, 645 WL1273_PUPD_SET_ON); 646 if (r) { 647 dev_err(dev, "%s: PUPD_SET fails\n", __func__); 648 goto fail; 649 } 650 } 651 } 652 653 return 0; 654 fail: 655 if (pdata->disable) 656 pdata->disable(); 657 658 dev_dbg(dev, "%s: return: %d\n", __func__, r); 659 return r; 660 } 661 662 static int wl1273_fm_suspend(struct wl1273_device *radio) 663 { 664 struct wl1273_core *core = radio->core; 665 int r = 0; 666 667 /* Cannot go from OFF to SUSPENDED */ 668 if (core->mode == WL1273_MODE_RX) 669 r = core->write(core, WL1273_POWER_SET, 670 WL1273_POWER_SET_RETENTION); 671 else if (core->mode == WL1273_MODE_TX) 672 r = core->write(core, WL1273_PUPD_SET, 673 WL1273_PUPD_SET_RETENTION); 674 else 675 r = -EINVAL; 676 677 if (r) { 678 dev_err(radio->dev, "%s: POWER_SET fails: %d\n", __func__, r); 679 goto out; 680 } 681 682 out: 683 return r; 684 } 685 686 static int wl1273_fm_set_mode(struct wl1273_device *radio, int mode) 687 { 688 struct wl1273_core *core = radio->core; 689 struct device *dev = radio->dev; 690 int old_mode; 691 int r; 692 693 dev_dbg(dev, "%s\n", __func__); 694 dev_dbg(dev, "Forbidden modes: 0x%02x\n", radio->forbidden); 695 696 old_mode = core->mode; 697 if (mode & radio->forbidden) { 698 r = -EPERM; 699 goto out; 700 } 701 702 switch (mode) { 703 case WL1273_MODE_RX: 704 case WL1273_MODE_TX: 705 r = wl1273_fm_start(radio, mode); 706 if (r) { 707 dev_err(dev, "%s: Cannot start.\n", __func__); 708 wl1273_fm_stop(radio); 709 goto out; 710 } 711 712 core->mode = mode; 713 r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags); 714 if (r) { 715 dev_err(dev, "INT_MASK_SET fails.\n"); 716 goto out; 717 } 718 719 /* remember previous settings */ 720 if (mode == WL1273_MODE_RX) { 721 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency); 722 if (r) { 723 dev_err(dev, "set freq fails: %d.\n", r); 724 goto out; 725 } 726 727 r = core->set_volume(core, core->volume); 728 if (r) { 729 dev_err(dev, "set volume fails: %d.\n", r); 730 goto out; 731 } 732 733 dev_dbg(dev, "%s: Set vol: %d.\n", __func__, 734 core->volume); 735 } else { 736 r = wl1273_fm_set_tx_freq(radio, radio->tx_frequency); 737 if (r) { 738 dev_err(dev, "set freq fails: %d.\n", r); 739 goto out; 740 } 741 } 742 743 dev_dbg(radio->dev, "%s: Set audio mode.\n", __func__); 744 745 r = core->set_audio(core, core->audio_mode); 746 if (r) 747 dev_err(dev, "Cannot set audio mode.\n"); 748 break; 749 750 case WL1273_MODE_OFF: 751 r = wl1273_fm_stop(radio); 752 if (r) 753 dev_err(dev, "%s: Off fails: %d\n", __func__, r); 754 else 755 core->mode = WL1273_MODE_OFF; 756 757 break; 758 759 case WL1273_MODE_SUSPENDED: 760 r = wl1273_fm_suspend(radio); 761 if (r) 762 dev_err(dev, "%s: Suspend fails: %d\n", __func__, r); 763 else 764 core->mode = WL1273_MODE_SUSPENDED; 765 766 break; 767 768 default: 769 dev_err(dev, "%s: Unknown mode: %d\n", __func__, mode); 770 r = -EINVAL; 771 break; 772 } 773 out: 774 if (r) 775 core->mode = old_mode; 776 777 return r; 778 } 779 780 static int wl1273_fm_set_seek(struct wl1273_device *radio, 781 unsigned int wrap_around, 782 unsigned int seek_upward, 783 int level) 784 { 785 struct wl1273_core *core = radio->core; 786 int r = 0; 787 unsigned int dir = (seek_upward == 0) ? 0 : 1; 788 unsigned int f; 789 790 f = radio->rx_frequency; 791 dev_dbg(radio->dev, "rx_frequency: %d\n", f); 792 793 if (dir && f + radio->spacing <= radio->rangehigh) 794 r = wl1273_fm_set_rx_freq(radio, f + radio->spacing); 795 else if (dir && wrap_around) 796 r = wl1273_fm_set_rx_freq(radio, radio->rangelow); 797 else if (f - radio->spacing >= radio->rangelow) 798 r = wl1273_fm_set_rx_freq(radio, f - radio->spacing); 799 else if (wrap_around) 800 r = wl1273_fm_set_rx_freq(radio, radio->rangehigh); 801 802 if (r) 803 goto out; 804 805 if (level < SCHAR_MIN || level > SCHAR_MAX) 806 return -EINVAL; 807 808 INIT_COMPLETION(radio->busy); 809 dev_dbg(radio->dev, "%s: BUSY\n", __func__); 810 811 r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags); 812 if (r) 813 goto out; 814 815 dev_dbg(radio->dev, "%s\n", __func__); 816 817 r = core->write(core, WL1273_SEARCH_LVL_SET, level); 818 if (r) 819 goto out; 820 821 r = core->write(core, WL1273_SEARCH_DIR_SET, dir); 822 if (r) 823 goto out; 824 825 r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK); 826 if (r) 827 goto out; 828 829 wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000)); 830 if (!(radio->irq_received & WL1273_BL_EVENT)) 831 goto out; 832 833 radio->irq_received &= ~WL1273_BL_EVENT; 834 835 if (!wrap_around) 836 goto out; 837 838 /* Wrap around */ 839 dev_dbg(radio->dev, "Wrap around in HW seek.\n"); 840 841 if (seek_upward) 842 f = radio->rangelow; 843 else 844 f = radio->rangehigh; 845 846 r = wl1273_fm_set_rx_freq(radio, f); 847 if (r) 848 goto out; 849 850 INIT_COMPLETION(radio->busy); 851 dev_dbg(radio->dev, "%s: BUSY\n", __func__); 852 853 r = core->write(core, WL1273_TUNER_MODE_SET, TUNER_MODE_AUTO_SEEK); 854 if (r) 855 goto out; 856 857 wait_for_completion_timeout(&radio->busy, msecs_to_jiffies(1000)); 858 out: 859 dev_dbg(radio->dev, "%s: Err: %d\n", __func__, r); 860 return r; 861 } 862 863 /** 864 * wl1273_fm_get_tx_ctune() - Get the TX tuning capacitor value. 865 * @radio: A pointer to the device struct. 866 */ 867 static unsigned int wl1273_fm_get_tx_ctune(struct wl1273_device *radio) 868 { 869 struct wl1273_core *core = radio->core; 870 struct device *dev = radio->dev; 871 u16 val; 872 int r; 873 874 if (core->mode == WL1273_MODE_OFF || 875 core->mode == WL1273_MODE_SUSPENDED) 876 return -EPERM; 877 878 r = core->read(core, WL1273_READ_FMANT_TUNE_VALUE, &val); 879 if (r) { 880 dev_err(dev, "%s: read error: %d\n", __func__, r); 881 goto out; 882 } 883 884 out: 885 return val; 886 } 887 888 /** 889 * wl1273_fm_set_preemphasis() - Set the TX pre-emphasis value. 890 * @radio: A pointer to the device struct. 891 * @preemphasis: The new pre-amphasis value. 892 * 893 * Possible pre-emphasis values are: V4L2_PREEMPHASIS_DISABLED, 894 * V4L2_PREEMPHASIS_50_uS and V4L2_PREEMPHASIS_75_uS. 895 */ 896 static int wl1273_fm_set_preemphasis(struct wl1273_device *radio, 897 unsigned int preemphasis) 898 { 899 struct wl1273_core *core = radio->core; 900 int r; 901 u16 em; 902 903 if (core->mode == WL1273_MODE_OFF || 904 core->mode == WL1273_MODE_SUSPENDED) 905 return -EPERM; 906 907 mutex_lock(&core->lock); 908 909 switch (preemphasis) { 910 case V4L2_PREEMPHASIS_DISABLED: 911 em = 1; 912 break; 913 case V4L2_PREEMPHASIS_50_uS: 914 em = 0; 915 break; 916 case V4L2_PREEMPHASIS_75_uS: 917 em = 2; 918 break; 919 default: 920 r = -EINVAL; 921 goto out; 922 } 923 924 r = core->write(core, WL1273_PREMPH_SET, em); 925 if (r) 926 goto out; 927 928 radio->preemphasis = preemphasis; 929 930 out: 931 mutex_unlock(&core->lock); 932 return r; 933 } 934 935 static int wl1273_fm_rds_on(struct wl1273_device *radio) 936 { 937 struct wl1273_core *core = radio->core; 938 int r; 939 940 dev_dbg(radio->dev, "%s\n", __func__); 941 if (radio->rds_on) 942 return 0; 943 944 r = core->write(core, WL1273_POWER_SET, 945 WL1273_POWER_SET_FM | WL1273_POWER_SET_RDS); 946 if (r) 947 goto out; 948 949 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency); 950 if (r) 951 dev_err(radio->dev, "set freq fails: %d.\n", r); 952 out: 953 return r; 954 } 955 956 static int wl1273_fm_rds_off(struct wl1273_device *radio) 957 { 958 struct wl1273_core *core = radio->core; 959 int r; 960 961 if (!radio->rds_on) 962 return 0; 963 964 radio->irq_flags &= ~WL1273_RDS_EVENT; 965 966 r = core->write(core, WL1273_INT_MASK_SET, radio->irq_flags); 967 if (r) 968 goto out; 969 970 /* Service pending read */ 971 wake_up_interruptible(&radio->read_queue); 972 973 dev_dbg(radio->dev, "%s\n", __func__); 974 975 r = core->write(core, WL1273_POWER_SET, WL1273_POWER_SET_FM); 976 if (r) 977 goto out; 978 979 r = wl1273_fm_set_rx_freq(radio, radio->rx_frequency); 980 if (r) 981 dev_err(radio->dev, "set freq fails: %d.\n", r); 982 out: 983 dev_dbg(radio->dev, "%s: exiting...\n", __func__); 984 985 return r; 986 } 987 988 static int wl1273_fm_set_rds(struct wl1273_device *radio, unsigned int new_mode) 989 { 990 int r = 0; 991 struct wl1273_core *core = radio->core; 992 993 if (core->mode == WL1273_MODE_OFF || 994 core->mode == WL1273_MODE_SUSPENDED) 995 return -EPERM; 996 997 if (new_mode == WL1273_RDS_RESET) { 998 r = core->write(core, WL1273_RDS_CNTRL_SET, 1); 999 return r; 1000 } 1001 1002 if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_OFF) { 1003 r = core->write(core, WL1273_RDS_DATA_ENB, 0); 1004 } else if (core->mode == WL1273_MODE_TX && new_mode == WL1273_RDS_ON) { 1005 r = core->write(core, WL1273_RDS_DATA_ENB, 1); 1006 } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_OFF) { 1007 r = wl1273_fm_rds_off(radio); 1008 } else if (core->mode == WL1273_MODE_RX && new_mode == WL1273_RDS_ON) { 1009 r = wl1273_fm_rds_on(radio); 1010 } else { 1011 dev_err(radio->dev, "%s: Unknown mode: %d\n", 1012 __func__, new_mode); 1013 r = -EINVAL; 1014 } 1015 1016 if (!r) 1017 radio->rds_on = (new_mode == WL1273_RDS_ON) ? true : false; 1018 1019 return r; 1020 } 1021 1022 static ssize_t wl1273_fm_fops_write(struct file *file, const char __user *buf, 1023 size_t count, loff_t *ppos) 1024 { 1025 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1026 struct wl1273_core *core = radio->core; 1027 u16 val; 1028 int r; 1029 1030 dev_dbg(radio->dev, "%s\n", __func__); 1031 1032 if (core->mode != WL1273_MODE_TX) 1033 return count; 1034 1035 if (radio->rds_users == 0) { 1036 dev_warn(radio->dev, "%s: RDS not on.\n", __func__); 1037 return 0; 1038 } 1039 1040 if (mutex_lock_interruptible(&core->lock)) 1041 return -EINTR; 1042 /* 1043 * Multiple processes can open the device, but only 1044 * one gets to write to it. 1045 */ 1046 if (radio->owner && radio->owner != file) { 1047 r = -EBUSY; 1048 goto out; 1049 } 1050 radio->owner = file; 1051 1052 /* Manual Mode */ 1053 if (count > 255) 1054 val = 255; 1055 else 1056 val = count; 1057 1058 core->write(core, WL1273_RDS_CONFIG_DATA_SET, val); 1059 1060 if (copy_from_user(radio->write_buf + 1, buf, val)) { 1061 r = -EFAULT; 1062 goto out; 1063 } 1064 1065 dev_dbg(radio->dev, "Count: %d\n", val); 1066 dev_dbg(radio->dev, "From user: \"%s\"\n", radio->write_buf); 1067 1068 radio->write_buf[0] = WL1273_RDS_DATA_SET; 1069 core->write_data(core, radio->write_buf, val + 1); 1070 1071 r = val; 1072 out: 1073 mutex_unlock(&core->lock); 1074 1075 return r; 1076 } 1077 1078 static unsigned int wl1273_fm_fops_poll(struct file *file, 1079 struct poll_table_struct *pts) 1080 { 1081 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1082 struct wl1273_core *core = radio->core; 1083 1084 if (radio->owner && radio->owner != file) 1085 return -EBUSY; 1086 1087 radio->owner = file; 1088 1089 if (core->mode == WL1273_MODE_RX) { 1090 poll_wait(file, &radio->read_queue, pts); 1091 1092 if (radio->rd_index != radio->wr_index) 1093 return POLLIN | POLLRDNORM; 1094 1095 } else if (core->mode == WL1273_MODE_TX) { 1096 return POLLOUT | POLLWRNORM; 1097 } 1098 1099 return 0; 1100 } 1101 1102 static int wl1273_fm_fops_open(struct file *file) 1103 { 1104 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1105 struct wl1273_core *core = radio->core; 1106 int r = 0; 1107 1108 dev_dbg(radio->dev, "%s\n", __func__); 1109 1110 if (core->mode == WL1273_MODE_RX && radio->rds_on && 1111 !radio->rds_users) { 1112 dev_dbg(radio->dev, "%s: Mode: %d\n", __func__, core->mode); 1113 1114 if (mutex_lock_interruptible(&core->lock)) 1115 return -EINTR; 1116 1117 radio->irq_flags |= WL1273_RDS_EVENT; 1118 1119 r = core->write(core, WL1273_INT_MASK_SET, 1120 radio->irq_flags); 1121 if (r) { 1122 mutex_unlock(&core->lock); 1123 goto out; 1124 } 1125 1126 radio->rds_users++; 1127 1128 mutex_unlock(&core->lock); 1129 } 1130 out: 1131 return r; 1132 } 1133 1134 static int wl1273_fm_fops_release(struct file *file) 1135 { 1136 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1137 struct wl1273_core *core = radio->core; 1138 int r = 0; 1139 1140 dev_dbg(radio->dev, "%s\n", __func__); 1141 1142 if (radio->rds_users > 0) { 1143 radio->rds_users--; 1144 if (radio->rds_users == 0) { 1145 if (mutex_lock_interruptible(&core->lock)) 1146 return -EINTR; 1147 1148 radio->irq_flags &= ~WL1273_RDS_EVENT; 1149 1150 if (core->mode == WL1273_MODE_RX) { 1151 r = core->write(core, 1152 WL1273_INT_MASK_SET, 1153 radio->irq_flags); 1154 if (r) { 1155 mutex_unlock(&core->lock); 1156 goto out; 1157 } 1158 } 1159 mutex_unlock(&core->lock); 1160 } 1161 } 1162 1163 if (file == radio->owner) 1164 radio->owner = NULL; 1165 out: 1166 return r; 1167 } 1168 1169 static ssize_t wl1273_fm_fops_read(struct file *file, char __user *buf, 1170 size_t count, loff_t *ppos) 1171 { 1172 int r = 0; 1173 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1174 struct wl1273_core *core = radio->core; 1175 unsigned int block_count = 0; 1176 u16 val; 1177 1178 dev_dbg(radio->dev, "%s\n", __func__); 1179 1180 if (core->mode != WL1273_MODE_RX) 1181 return 0; 1182 1183 if (radio->rds_users == 0) { 1184 dev_warn(radio->dev, "%s: RDS not on.\n", __func__); 1185 return 0; 1186 } 1187 1188 if (mutex_lock_interruptible(&core->lock)) 1189 return -EINTR; 1190 1191 /* 1192 * Multiple processes can open the device, but only 1193 * one at a time gets read access. 1194 */ 1195 if (radio->owner && radio->owner != file) { 1196 r = -EBUSY; 1197 goto out; 1198 } 1199 radio->owner = file; 1200 1201 r = core->read(core, WL1273_RDS_SYNC_GET, &val); 1202 if (r) { 1203 dev_err(radio->dev, "%s: Get RDS_SYNC fails.\n", __func__); 1204 goto out; 1205 } else if (val == 0) { 1206 dev_info(radio->dev, "RDS_SYNC: Not synchronized\n"); 1207 r = -ENODATA; 1208 goto out; 1209 } 1210 1211 /* block if no new data available */ 1212 while (radio->wr_index == radio->rd_index) { 1213 if (file->f_flags & O_NONBLOCK) { 1214 r = -EWOULDBLOCK; 1215 goto out; 1216 } 1217 1218 dev_dbg(radio->dev, "%s: Wait for RDS data.\n", __func__); 1219 if (wait_event_interruptible(radio->read_queue, 1220 radio->wr_index != 1221 radio->rd_index) < 0) { 1222 r = -EINTR; 1223 goto out; 1224 } 1225 } 1226 1227 /* calculate block count from byte count */ 1228 count /= RDS_BLOCK_SIZE; 1229 1230 /* copy RDS blocks from the internal buffer and to user buffer */ 1231 while (block_count < count) { 1232 if (radio->rd_index == radio->wr_index) 1233 break; 1234 1235 /* always transfer complete RDS blocks */ 1236 if (copy_to_user(buf, &radio->buffer[radio->rd_index], 1237 RDS_BLOCK_SIZE)) 1238 break; 1239 1240 /* increment and wrap the read pointer */ 1241 radio->rd_index += RDS_BLOCK_SIZE; 1242 if (radio->rd_index >= radio->buf_size) 1243 radio->rd_index = 0; 1244 1245 /* increment counters */ 1246 block_count++; 1247 buf += RDS_BLOCK_SIZE; 1248 r += RDS_BLOCK_SIZE; 1249 } 1250 1251 out: 1252 dev_dbg(radio->dev, "%s: exit\n", __func__); 1253 mutex_unlock(&core->lock); 1254 1255 return r; 1256 } 1257 1258 static const struct v4l2_file_operations wl1273_fops = { 1259 .owner = THIS_MODULE, 1260 .read = wl1273_fm_fops_read, 1261 .write = wl1273_fm_fops_write, 1262 .poll = wl1273_fm_fops_poll, 1263 .unlocked_ioctl = video_ioctl2, 1264 .open = wl1273_fm_fops_open, 1265 .release = wl1273_fm_fops_release, 1266 }; 1267 1268 static int wl1273_fm_vidioc_querycap(struct file *file, void *priv, 1269 struct v4l2_capability *capability) 1270 { 1271 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1272 1273 dev_dbg(radio->dev, "%s\n", __func__); 1274 1275 strlcpy(capability->driver, WL1273_FM_DRIVER_NAME, 1276 sizeof(capability->driver)); 1277 strlcpy(capability->card, "Texas Instruments Wl1273 FM Radio", 1278 sizeof(capability->card)); 1279 strlcpy(capability->bus_info, radio->bus_type, 1280 sizeof(capability->bus_info)); 1281 1282 capability->capabilities = V4L2_CAP_HW_FREQ_SEEK | 1283 V4L2_CAP_TUNER | V4L2_CAP_RADIO | V4L2_CAP_AUDIO | 1284 V4L2_CAP_RDS_CAPTURE | V4L2_CAP_MODULATOR | 1285 V4L2_CAP_RDS_OUTPUT; 1286 1287 return 0; 1288 } 1289 1290 static int wl1273_fm_vidioc_g_input(struct file *file, void *priv, 1291 unsigned int *i) 1292 { 1293 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1294 1295 dev_dbg(radio->dev, "%s\n", __func__); 1296 1297 *i = 0; 1298 1299 return 0; 1300 } 1301 1302 static int wl1273_fm_vidioc_s_input(struct file *file, void *priv, 1303 unsigned int i) 1304 { 1305 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1306 1307 dev_dbg(radio->dev, "%s\n", __func__); 1308 1309 if (i != 0) 1310 return -EINVAL; 1311 1312 return 0; 1313 } 1314 1315 /** 1316 * wl1273_fm_set_tx_power() - Set the transmission power value. 1317 * @core: A pointer to the device struct. 1318 * @power: The new power value. 1319 */ 1320 static int wl1273_fm_set_tx_power(struct wl1273_device *radio, u16 power) 1321 { 1322 struct wl1273_core *core = radio->core; 1323 int r; 1324 1325 if (core->mode == WL1273_MODE_OFF || 1326 core->mode == WL1273_MODE_SUSPENDED) 1327 return -EPERM; 1328 1329 mutex_lock(&core->lock); 1330 1331 /* Convert the dBuV value to chip presentation */ 1332 r = core->write(core, WL1273_POWER_LEV_SET, 122 - power); 1333 if (r) 1334 goto out; 1335 1336 radio->tx_power = power; 1337 1338 out: 1339 mutex_unlock(&core->lock); 1340 return r; 1341 } 1342 1343 #define WL1273_SPACING_50kHz 1 1344 #define WL1273_SPACING_100kHz 2 1345 #define WL1273_SPACING_200kHz 4 1346 1347 static int wl1273_fm_tx_set_spacing(struct wl1273_device *radio, 1348 unsigned int spacing) 1349 { 1350 struct wl1273_core *core = radio->core; 1351 int r; 1352 1353 if (spacing == 0) { 1354 r = core->write(core, WL1273_SCAN_SPACING_SET, 1355 WL1273_SPACING_100kHz); 1356 radio->spacing = 100; 1357 } else if (spacing - 50000 < 25000) { 1358 r = core->write(core, WL1273_SCAN_SPACING_SET, 1359 WL1273_SPACING_50kHz); 1360 radio->spacing = 50; 1361 } else if (spacing - 100000 < 50000) { 1362 r = core->write(core, WL1273_SCAN_SPACING_SET, 1363 WL1273_SPACING_100kHz); 1364 radio->spacing = 100; 1365 } else { 1366 r = core->write(core, WL1273_SCAN_SPACING_SET, 1367 WL1273_SPACING_200kHz); 1368 radio->spacing = 200; 1369 } 1370 1371 return r; 1372 } 1373 1374 static int wl1273_fm_g_volatile_ctrl(struct v4l2_ctrl *ctrl) 1375 { 1376 struct wl1273_device *radio = ctrl->priv; 1377 struct wl1273_core *core = radio->core; 1378 1379 dev_dbg(radio->dev, "%s\n", __func__); 1380 1381 if (mutex_lock_interruptible(&core->lock)) 1382 return -EINTR; 1383 1384 switch (ctrl->id) { 1385 case V4L2_CID_TUNE_ANTENNA_CAPACITOR: 1386 ctrl->val = wl1273_fm_get_tx_ctune(radio); 1387 break; 1388 1389 default: 1390 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n", 1391 __func__, ctrl->id); 1392 break; 1393 } 1394 1395 mutex_unlock(&core->lock); 1396 1397 return 0; 1398 } 1399 1400 #define WL1273_MUTE_SOFT_ENABLE (1 << 0) 1401 #define WL1273_MUTE_AC (1 << 1) 1402 #define WL1273_MUTE_HARD_LEFT (1 << 2) 1403 #define WL1273_MUTE_HARD_RIGHT (1 << 3) 1404 #define WL1273_MUTE_SOFT_FORCE (1 << 4) 1405 1406 static inline struct wl1273_device *to_radio(struct v4l2_ctrl *ctrl) 1407 { 1408 return container_of(ctrl->handler, struct wl1273_device, ctrl_handler); 1409 } 1410 1411 static int wl1273_fm_vidioc_s_ctrl(struct v4l2_ctrl *ctrl) 1412 { 1413 struct wl1273_device *radio = to_radio(ctrl); 1414 struct wl1273_core *core = radio->core; 1415 int r = 0; 1416 1417 dev_dbg(radio->dev, "%s\n", __func__); 1418 1419 switch (ctrl->id) { 1420 case V4L2_CID_AUDIO_MUTE: 1421 if (mutex_lock_interruptible(&core->lock)) 1422 return -EINTR; 1423 1424 if (core->mode == WL1273_MODE_RX && ctrl->val) 1425 r = core->write(core, 1426 WL1273_MUTE_STATUS_SET, 1427 WL1273_MUTE_HARD_LEFT | 1428 WL1273_MUTE_HARD_RIGHT); 1429 else if (core->mode == WL1273_MODE_RX) 1430 r = core->write(core, 1431 WL1273_MUTE_STATUS_SET, 0x0); 1432 else if (core->mode == WL1273_MODE_TX && ctrl->val) 1433 r = core->write(core, WL1273_MUTE, 1); 1434 else if (core->mode == WL1273_MODE_TX) 1435 r = core->write(core, WL1273_MUTE, 0); 1436 1437 mutex_unlock(&core->lock); 1438 break; 1439 1440 case V4L2_CID_AUDIO_VOLUME: 1441 if (ctrl->val == 0) 1442 r = wl1273_fm_set_mode(radio, WL1273_MODE_OFF); 1443 else 1444 r = core->set_volume(core, core->volume); 1445 break; 1446 1447 case V4L2_CID_TUNE_PREEMPHASIS: 1448 r = wl1273_fm_set_preemphasis(radio, ctrl->val); 1449 break; 1450 1451 case V4L2_CID_TUNE_POWER_LEVEL: 1452 r = wl1273_fm_set_tx_power(radio, ctrl->val); 1453 break; 1454 1455 default: 1456 dev_warn(radio->dev, "%s: Unknown IOCTL: %d\n", 1457 __func__, ctrl->id); 1458 break; 1459 } 1460 1461 dev_dbg(radio->dev, "%s\n", __func__); 1462 return r; 1463 } 1464 1465 static int wl1273_fm_vidioc_g_audio(struct file *file, void *priv, 1466 struct v4l2_audio *audio) 1467 { 1468 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1469 1470 dev_dbg(radio->dev, "%s\n", __func__); 1471 1472 if (audio->index > 1) 1473 return -EINVAL; 1474 1475 strlcpy(audio->name, "Radio", sizeof(audio->name)); 1476 audio->capability = V4L2_AUDCAP_STEREO; 1477 1478 return 0; 1479 } 1480 1481 static int wl1273_fm_vidioc_s_audio(struct file *file, void *priv, 1482 struct v4l2_audio *audio) 1483 { 1484 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1485 1486 dev_dbg(radio->dev, "%s\n", __func__); 1487 1488 if (audio->index != 0) 1489 return -EINVAL; 1490 1491 return 0; 1492 } 1493 1494 #define WL1273_RDS_NOT_SYNCHRONIZED 0 1495 #define WL1273_RDS_SYNCHRONIZED 1 1496 1497 static int wl1273_fm_vidioc_g_tuner(struct file *file, void *priv, 1498 struct v4l2_tuner *tuner) 1499 { 1500 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1501 struct wl1273_core *core = radio->core; 1502 u16 val; 1503 int r; 1504 1505 dev_dbg(radio->dev, "%s\n", __func__); 1506 1507 if (tuner->index > 0) 1508 return -EINVAL; 1509 1510 strlcpy(tuner->name, WL1273_FM_DRIVER_NAME, sizeof(tuner->name)); 1511 tuner->type = V4L2_TUNER_RADIO; 1512 1513 tuner->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW); 1514 tuner->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH); 1515 1516 tuner->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS | 1517 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO | 1518 V4L2_TUNER_CAP_HWSEEK_BOUNDED | V4L2_TUNER_CAP_HWSEEK_WRAP; 1519 1520 if (radio->stereo) 1521 tuner->audmode = V4L2_TUNER_MODE_STEREO; 1522 else 1523 tuner->audmode = V4L2_TUNER_MODE_MONO; 1524 1525 if (core->mode != WL1273_MODE_RX) 1526 return 0; 1527 1528 if (mutex_lock_interruptible(&core->lock)) 1529 return -EINTR; 1530 1531 r = core->read(core, WL1273_STEREO_GET, &val); 1532 if (r) 1533 goto out; 1534 1535 if (val == 1) 1536 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO; 1537 else 1538 tuner->rxsubchans = V4L2_TUNER_SUB_MONO; 1539 1540 r = core->read(core, WL1273_RSSI_LVL_GET, &val); 1541 if (r) 1542 goto out; 1543 1544 tuner->signal = (s16) val; 1545 dev_dbg(radio->dev, "Signal: %d\n", tuner->signal); 1546 1547 tuner->afc = 0; 1548 1549 r = core->read(core, WL1273_RDS_SYNC_GET, &val); 1550 if (r) 1551 goto out; 1552 1553 if (val == WL1273_RDS_SYNCHRONIZED) 1554 tuner->rxsubchans |= V4L2_TUNER_SUB_RDS; 1555 out: 1556 mutex_unlock(&core->lock); 1557 1558 return r; 1559 } 1560 1561 static int wl1273_fm_vidioc_s_tuner(struct file *file, void *priv, 1562 struct v4l2_tuner *tuner) 1563 { 1564 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1565 struct wl1273_core *core = radio->core; 1566 int r = 0; 1567 1568 dev_dbg(radio->dev, "%s\n", __func__); 1569 dev_dbg(radio->dev, "tuner->index: %d\n", tuner->index); 1570 dev_dbg(radio->dev, "tuner->name: %s\n", tuner->name); 1571 dev_dbg(radio->dev, "tuner->capability: 0x%04x\n", tuner->capability); 1572 dev_dbg(radio->dev, "tuner->rxsubchans: 0x%04x\n", tuner->rxsubchans); 1573 dev_dbg(radio->dev, "tuner->rangelow: %d\n", tuner->rangelow); 1574 dev_dbg(radio->dev, "tuner->rangehigh: %d\n", tuner->rangehigh); 1575 1576 if (tuner->index > 0) 1577 return -EINVAL; 1578 1579 if (mutex_lock_interruptible(&core->lock)) 1580 return -EINTR; 1581 1582 r = wl1273_fm_set_mode(radio, WL1273_MODE_RX); 1583 if (r) 1584 goto out; 1585 1586 if (tuner->rxsubchans & V4L2_TUNER_SUB_RDS) 1587 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON); 1588 else 1589 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF); 1590 1591 if (r) 1592 dev_warn(radio->dev, "%s: RDS fails: %d\n", __func__, r); 1593 1594 if (tuner->audmode == V4L2_TUNER_MODE_MONO) { 1595 r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_MONO); 1596 if (r < 0) { 1597 dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n", 1598 __func__, r); 1599 goto out; 1600 } 1601 radio->stereo = false; 1602 } else if (tuner->audmode == V4L2_TUNER_MODE_STEREO) { 1603 r = core->write(core, WL1273_MOST_MODE_SET, WL1273_RX_STEREO); 1604 if (r < 0) { 1605 dev_warn(radio->dev, "%s: MOST_MODE fails: %d\n", 1606 __func__, r); 1607 goto out; 1608 } 1609 radio->stereo = true; 1610 } else { 1611 dev_err(radio->dev, "%s: tuner->audmode: %d\n", 1612 __func__, tuner->audmode); 1613 r = -EINVAL; 1614 goto out; 1615 } 1616 1617 out: 1618 mutex_unlock(&core->lock); 1619 1620 return r; 1621 } 1622 1623 static int wl1273_fm_vidioc_g_frequency(struct file *file, void *priv, 1624 struct v4l2_frequency *freq) 1625 { 1626 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1627 struct wl1273_core *core = radio->core; 1628 1629 dev_dbg(radio->dev, "%s\n", __func__); 1630 1631 if (mutex_lock_interruptible(&core->lock)) 1632 return -EINTR; 1633 1634 freq->type = V4L2_TUNER_RADIO; 1635 freq->frequency = WL1273_FREQ(wl1273_fm_get_freq(radio)); 1636 1637 mutex_unlock(&core->lock); 1638 1639 return 0; 1640 } 1641 1642 static int wl1273_fm_vidioc_s_frequency(struct file *file, void *priv, 1643 struct v4l2_frequency *freq) 1644 { 1645 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1646 struct wl1273_core *core = radio->core; 1647 int r; 1648 1649 dev_dbg(radio->dev, "%s: %d\n", __func__, freq->frequency); 1650 1651 if (freq->type != V4L2_TUNER_RADIO) { 1652 dev_dbg(radio->dev, 1653 "freq->type != V4L2_TUNER_RADIO: %d\n", freq->type); 1654 return -EINVAL; 1655 } 1656 1657 if (mutex_lock_interruptible(&core->lock)) 1658 return -EINTR; 1659 1660 if (core->mode == WL1273_MODE_RX) { 1661 dev_dbg(radio->dev, "freq: %d\n", freq->frequency); 1662 1663 r = wl1273_fm_set_rx_freq(radio, 1664 WL1273_INV_FREQ(freq->frequency)); 1665 if (r) 1666 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME 1667 ": set frequency failed with %d\n", r); 1668 } else { 1669 r = wl1273_fm_set_tx_freq(radio, 1670 WL1273_INV_FREQ(freq->frequency)); 1671 if (r) 1672 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME 1673 ": set frequency failed with %d\n", r); 1674 } 1675 1676 mutex_unlock(&core->lock); 1677 1678 dev_dbg(radio->dev, "wl1273_vidioc_s_frequency: DONE\n"); 1679 return r; 1680 } 1681 1682 #define WL1273_DEFAULT_SEEK_LEVEL 7 1683 1684 static int wl1273_fm_vidioc_s_hw_freq_seek(struct file *file, void *priv, 1685 struct v4l2_hw_freq_seek *seek) 1686 { 1687 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1688 struct wl1273_core *core = radio->core; 1689 int r; 1690 1691 dev_dbg(radio->dev, "%s\n", __func__); 1692 1693 if (seek->tuner != 0 || seek->type != V4L2_TUNER_RADIO) 1694 return -EINVAL; 1695 1696 if (mutex_lock_interruptible(&core->lock)) 1697 return -EINTR; 1698 1699 r = wl1273_fm_set_mode(radio, WL1273_MODE_RX); 1700 if (r) 1701 goto out; 1702 1703 r = wl1273_fm_tx_set_spacing(radio, seek->spacing); 1704 if (r) 1705 dev_warn(radio->dev, "HW seek failed: %d\n", r); 1706 1707 r = wl1273_fm_set_seek(radio, seek->wrap_around, seek->seek_upward, 1708 WL1273_DEFAULT_SEEK_LEVEL); 1709 if (r) 1710 dev_warn(radio->dev, "HW seek failed: %d\n", r); 1711 1712 out: 1713 mutex_unlock(&core->lock); 1714 return r; 1715 } 1716 1717 static int wl1273_fm_vidioc_s_modulator(struct file *file, void *priv, 1718 struct v4l2_modulator *modulator) 1719 { 1720 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1721 struct wl1273_core *core = radio->core; 1722 int r = 0; 1723 1724 dev_dbg(radio->dev, "%s\n", __func__); 1725 1726 if (modulator->index > 0) 1727 return -EINVAL; 1728 1729 if (mutex_lock_interruptible(&core->lock)) 1730 return -EINTR; 1731 1732 r = wl1273_fm_set_mode(radio, WL1273_MODE_TX); 1733 if (r) 1734 goto out; 1735 1736 if (modulator->txsubchans & V4L2_TUNER_SUB_RDS) 1737 r = wl1273_fm_set_rds(radio, WL1273_RDS_ON); 1738 else 1739 r = wl1273_fm_set_rds(radio, WL1273_RDS_OFF); 1740 1741 if (modulator->txsubchans & V4L2_TUNER_SUB_MONO) 1742 r = core->write(core, WL1273_MONO_SET, WL1273_TX_MONO); 1743 else 1744 r = core->write(core, WL1273_MONO_SET, 1745 WL1273_RX_STEREO); 1746 if (r < 0) 1747 dev_warn(radio->dev, WL1273_FM_DRIVER_NAME 1748 "MONO_SET fails: %d\n", r); 1749 out: 1750 mutex_unlock(&core->lock); 1751 1752 return r; 1753 } 1754 1755 static int wl1273_fm_vidioc_g_modulator(struct file *file, void *priv, 1756 struct v4l2_modulator *modulator) 1757 { 1758 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1759 struct wl1273_core *core = radio->core; 1760 u16 val; 1761 int r; 1762 1763 dev_dbg(radio->dev, "%s\n", __func__); 1764 1765 strlcpy(modulator->name, WL1273_FM_DRIVER_NAME, 1766 sizeof(modulator->name)); 1767 1768 modulator->rangelow = WL1273_FREQ(WL1273_BAND_JAPAN_LOW); 1769 modulator->rangehigh = WL1273_FREQ(WL1273_BAND_OTHER_HIGH); 1770 1771 modulator->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_RDS | 1772 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_RDS_BLOCK_IO; 1773 1774 if (core->mode != WL1273_MODE_TX) 1775 return 0; 1776 1777 if (mutex_lock_interruptible(&core->lock)) 1778 return -EINTR; 1779 1780 r = core->read(core, WL1273_MONO_SET, &val); 1781 if (r) 1782 goto out; 1783 1784 if (val == WL1273_TX_STEREO) 1785 modulator->txsubchans = V4L2_TUNER_SUB_STEREO; 1786 else 1787 modulator->txsubchans = V4L2_TUNER_SUB_MONO; 1788 1789 if (radio->rds_on) 1790 modulator->txsubchans |= V4L2_TUNER_SUB_RDS; 1791 out: 1792 mutex_unlock(&core->lock); 1793 1794 return 0; 1795 } 1796 1797 static int wl1273_fm_vidioc_log_status(struct file *file, void *priv) 1798 { 1799 struct wl1273_device *radio = video_get_drvdata(video_devdata(file)); 1800 struct wl1273_core *core = radio->core; 1801 struct device *dev = radio->dev; 1802 u16 val; 1803 int r; 1804 1805 dev_info(dev, DRIVER_DESC); 1806 1807 if (core->mode == WL1273_MODE_OFF) { 1808 dev_info(dev, "Mode: Off\n"); 1809 return 0; 1810 } 1811 1812 if (core->mode == WL1273_MODE_SUSPENDED) { 1813 dev_info(dev, "Mode: Suspended\n"); 1814 return 0; 1815 } 1816 1817 r = core->read(core, WL1273_ASIC_ID_GET, &val); 1818 if (r) 1819 dev_err(dev, "%s: Get ASIC_ID fails.\n", __func__); 1820 else 1821 dev_info(dev, "ASIC_ID: 0x%04x\n", val); 1822 1823 r = core->read(core, WL1273_ASIC_VER_GET, &val); 1824 if (r) 1825 dev_err(dev, "%s: Get ASIC_VER fails.\n", __func__); 1826 else 1827 dev_info(dev, "ASIC Version: 0x%04x\n", val); 1828 1829 r = core->read(core, WL1273_FIRM_VER_GET, &val); 1830 if (r) 1831 dev_err(dev, "%s: Get FIRM_VER fails.\n", __func__); 1832 else 1833 dev_info(dev, "FW version: %d(0x%04x)\n", val, val); 1834 1835 r = core->read(core, WL1273_BAND_SET, &val); 1836 if (r) 1837 dev_err(dev, "%s: Get BAND fails.\n", __func__); 1838 else 1839 dev_info(dev, "BAND: %d\n", val); 1840 1841 if (core->mode == WL1273_MODE_TX) { 1842 r = core->read(core, WL1273_PUPD_SET, &val); 1843 if (r) 1844 dev_err(dev, "%s: Get PUPD fails.\n", __func__); 1845 else 1846 dev_info(dev, "PUPD: 0x%04x\n", val); 1847 1848 r = core->read(core, WL1273_CHANL_SET, &val); 1849 if (r) 1850 dev_err(dev, "%s: Get CHANL fails.\n", __func__); 1851 else 1852 dev_info(dev, "Tx frequency: %dkHz\n", val*10); 1853 } else if (core->mode == WL1273_MODE_RX) { 1854 int bf = radio->rangelow; 1855 1856 r = core->read(core, WL1273_FREQ_SET, &val); 1857 if (r) 1858 dev_err(dev, "%s: Get FREQ fails.\n", __func__); 1859 else 1860 dev_info(dev, "RX Frequency: %dkHz\n", bf + val*50); 1861 1862 r = core->read(core, WL1273_MOST_MODE_SET, &val); 1863 if (r) 1864 dev_err(dev, "%s: Get MOST_MODE fails.\n", 1865 __func__); 1866 else if (val == 0) 1867 dev_info(dev, "MOST_MODE: Stereo according to blend\n"); 1868 else if (val == 1) 1869 dev_info(dev, "MOST_MODE: Force mono output\n"); 1870 else 1871 dev_info(dev, "MOST_MODE: Unexpected value: %d\n", val); 1872 1873 r = core->read(core, WL1273_MOST_BLEND_SET, &val); 1874 if (r) 1875 dev_err(dev, "%s: Get MOST_BLEND fails.\n", __func__); 1876 else if (val == 0) 1877 dev_info(dev, 1878 "MOST_BLEND: Switched blend & hysteresis.\n"); 1879 else if (val == 1) 1880 dev_info(dev, "MOST_BLEND: Soft blend.\n"); 1881 else 1882 dev_info(dev, "MOST_BLEND: Unexpected val: %d\n", val); 1883 1884 r = core->read(core, WL1273_STEREO_GET, &val); 1885 if (r) 1886 dev_err(dev, "%s: Get STEREO fails.\n", __func__); 1887 else if (val == 0) 1888 dev_info(dev, "STEREO: Not detected\n"); 1889 else if (val == 1) 1890 dev_info(dev, "STEREO: Detected\n"); 1891 else 1892 dev_info(dev, "STEREO: Unexpected value: %d\n", val); 1893 1894 r = core->read(core, WL1273_RSSI_LVL_GET, &val); 1895 if (r) 1896 dev_err(dev, "%s: Get RSSI_LVL fails.\n", __func__); 1897 else 1898 dev_info(dev, "RX signal strength: %d\n", (s16) val); 1899 1900 r = core->read(core, WL1273_POWER_SET, &val); 1901 if (r) 1902 dev_err(dev, "%s: Get POWER fails.\n", __func__); 1903 else 1904 dev_info(dev, "POWER: 0x%04x\n", val); 1905 1906 r = core->read(core, WL1273_INT_MASK_SET, &val); 1907 if (r) 1908 dev_err(dev, "%s: Get INT_MASK fails.\n", __func__); 1909 else 1910 dev_info(dev, "INT_MASK: 0x%04x\n", val); 1911 1912 r = core->read(core, WL1273_RDS_SYNC_GET, &val); 1913 if (r) 1914 dev_err(dev, "%s: Get RDS_SYNC fails.\n", 1915 __func__); 1916 else if (val == 0) 1917 dev_info(dev, "RDS_SYNC: Not synchronized\n"); 1918 1919 else if (val == 1) 1920 dev_info(dev, "RDS_SYNC: Synchronized\n"); 1921 else 1922 dev_info(dev, "RDS_SYNC: Unexpected value: %d\n", val); 1923 1924 r = core->read(core, WL1273_I2S_MODE_CONFIG_SET, &val); 1925 if (r) 1926 dev_err(dev, "%s: Get I2S_MODE_CONFIG fails.\n", 1927 __func__); 1928 else 1929 dev_info(dev, "I2S_MODE_CONFIG: 0x%04x\n", val); 1930 1931 r = core->read(core, WL1273_VOLUME_SET, &val); 1932 if (r) 1933 dev_err(dev, "%s: Get VOLUME fails.\n", __func__); 1934 else 1935 dev_info(dev, "VOLUME: 0x%04x\n", val); 1936 } 1937 1938 return 0; 1939 } 1940 1941 static void wl1273_vdev_release(struct video_device *dev) 1942 { 1943 } 1944 1945 static const struct v4l2_ctrl_ops wl1273_ctrl_ops = { 1946 .s_ctrl = wl1273_fm_vidioc_s_ctrl, 1947 .g_volatile_ctrl = wl1273_fm_g_volatile_ctrl, 1948 }; 1949 1950 static const struct v4l2_ioctl_ops wl1273_ioctl_ops = { 1951 .vidioc_querycap = wl1273_fm_vidioc_querycap, 1952 .vidioc_g_input = wl1273_fm_vidioc_g_input, 1953 .vidioc_s_input = wl1273_fm_vidioc_s_input, 1954 .vidioc_g_audio = wl1273_fm_vidioc_g_audio, 1955 .vidioc_s_audio = wl1273_fm_vidioc_s_audio, 1956 .vidioc_g_tuner = wl1273_fm_vidioc_g_tuner, 1957 .vidioc_s_tuner = wl1273_fm_vidioc_s_tuner, 1958 .vidioc_g_frequency = wl1273_fm_vidioc_g_frequency, 1959 .vidioc_s_frequency = wl1273_fm_vidioc_s_frequency, 1960 .vidioc_s_hw_freq_seek = wl1273_fm_vidioc_s_hw_freq_seek, 1961 .vidioc_g_modulator = wl1273_fm_vidioc_g_modulator, 1962 .vidioc_s_modulator = wl1273_fm_vidioc_s_modulator, 1963 .vidioc_log_status = wl1273_fm_vidioc_log_status, 1964 }; 1965 1966 static struct video_device wl1273_viddev_template = { 1967 .fops = &wl1273_fops, 1968 .ioctl_ops = &wl1273_ioctl_ops, 1969 .name = WL1273_FM_DRIVER_NAME, 1970 .release = wl1273_vdev_release, 1971 }; 1972 1973 static int wl1273_fm_radio_remove(struct platform_device *pdev) 1974 { 1975 struct wl1273_device *radio = platform_get_drvdata(pdev); 1976 struct wl1273_core *core = radio->core; 1977 1978 dev_info(&pdev->dev, "%s.\n", __func__); 1979 1980 free_irq(core->client->irq, radio); 1981 core->pdata->free_resources(); 1982 1983 v4l2_ctrl_handler_free(&radio->ctrl_handler); 1984 video_unregister_device(&radio->videodev); 1985 v4l2_device_unregister(&radio->v4l2dev); 1986 kfree(radio->buffer); 1987 kfree(radio->write_buf); 1988 kfree(radio); 1989 1990 return 0; 1991 } 1992 1993 static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev) 1994 { 1995 struct wl1273_core **core = pdev->dev.platform_data; 1996 struct wl1273_device *radio; 1997 struct v4l2_ctrl *ctrl; 1998 int r = 0; 1999 2000 pr_debug("%s\n", __func__); 2001 2002 if (!core) { 2003 dev_err(&pdev->dev, "No platform data.\n"); 2004 r = -EINVAL; 2005 goto pdata_err; 2006 } 2007 2008 radio = kzalloc(sizeof(*radio), GFP_KERNEL); 2009 if (!radio) { 2010 r = -ENOMEM; 2011 goto pdata_err; 2012 } 2013 2014 /* RDS buffer allocation */ 2015 radio->buf_size = rds_buf * RDS_BLOCK_SIZE; 2016 radio->buffer = kmalloc(radio->buf_size, GFP_KERNEL); 2017 if (!radio->buffer) { 2018 pr_err("Cannot allocate memory for RDS buffer.\n"); 2019 r = -ENOMEM; 2020 goto err_kmalloc; 2021 } 2022 2023 radio->core = *core; 2024 radio->irq_flags = WL1273_IRQ_MASK; 2025 radio->dev = &radio->core->client->dev; 2026 radio->rds_on = false; 2027 radio->core->mode = WL1273_MODE_OFF; 2028 radio->tx_power = 118; 2029 radio->core->audio_mode = WL1273_AUDIO_ANALOG; 2030 radio->band = WL1273_BAND_OTHER; 2031 radio->core->i2s_mode = WL1273_I2S_DEF_MODE; 2032 radio->core->channel_number = 2; 2033 radio->core->volume = WL1273_DEFAULT_VOLUME; 2034 radio->rx_frequency = WL1273_BAND_OTHER_LOW; 2035 radio->tx_frequency = WL1273_BAND_OTHER_HIGH; 2036 radio->rangelow = WL1273_BAND_OTHER_LOW; 2037 radio->rangehigh = WL1273_BAND_OTHER_HIGH; 2038 radio->stereo = true; 2039 radio->bus_type = "I2C"; 2040 2041 if (radio->core->pdata->request_resources) { 2042 r = radio->core->pdata->request_resources(radio->core->client); 2043 if (r) { 2044 dev_err(radio->dev, WL1273_FM_DRIVER_NAME 2045 ": Cannot get platform data\n"); 2046 goto err_resources; 2047 } 2048 2049 dev_dbg(radio->dev, "irq: %d\n", radio->core->client->irq); 2050 2051 r = request_threaded_irq(radio->core->client->irq, NULL, 2052 wl1273_fm_irq_thread_handler, 2053 IRQF_ONESHOT | IRQF_TRIGGER_FALLING, 2054 "wl1273-fm", radio); 2055 if (r < 0) { 2056 dev_err(radio->dev, WL1273_FM_DRIVER_NAME 2057 ": Unable to register IRQ handler: %d\n", r); 2058 goto err_request_irq; 2059 } 2060 } else { 2061 dev_err(radio->dev, WL1273_FM_DRIVER_NAME ": Core WL1273 IRQ" 2062 " not configured"); 2063 r = -EINVAL; 2064 goto err_resources; 2065 } 2066 2067 init_completion(&radio->busy); 2068 init_waitqueue_head(&radio->read_queue); 2069 2070 radio->write_buf = kmalloc(256, GFP_KERNEL); 2071 if (!radio->write_buf) { 2072 r = -ENOMEM; 2073 goto write_buf_err; 2074 } 2075 2076 radio->dev = &pdev->dev; 2077 radio->v4l2dev.ctrl_handler = &radio->ctrl_handler; 2078 radio->rds_users = 0; 2079 2080 r = v4l2_device_register(&pdev->dev, &radio->v4l2dev); 2081 if (r) { 2082 dev_err(&pdev->dev, "Cannot register v4l2_device.\n"); 2083 goto device_register_err; 2084 } 2085 2086 /* V4L2 configuration */ 2087 memcpy(&radio->videodev, &wl1273_viddev_template, 2088 sizeof(wl1273_viddev_template)); 2089 2090 radio->videodev.v4l2_dev = &radio->v4l2dev; 2091 2092 v4l2_ctrl_handler_init(&radio->ctrl_handler, 6); 2093 2094 /* add in ascending ID order */ 2095 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, 2096 V4L2_CID_AUDIO_VOLUME, 0, WL1273_MAX_VOLUME, 1, 2097 WL1273_DEFAULT_VOLUME); 2098 2099 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, 2100 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1); 2101 2102 v4l2_ctrl_new_std_menu(&radio->ctrl_handler, &wl1273_ctrl_ops, 2103 V4L2_CID_TUNE_PREEMPHASIS, 2104 V4L2_PREEMPHASIS_75_uS, 0x03, 2105 V4L2_PREEMPHASIS_50_uS); 2106 2107 v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, 2108 V4L2_CID_TUNE_POWER_LEVEL, 91, 122, 1, 118); 2109 2110 ctrl = v4l2_ctrl_new_std(&radio->ctrl_handler, &wl1273_ctrl_ops, 2111 V4L2_CID_TUNE_ANTENNA_CAPACITOR, 2112 0, 255, 1, 255); 2113 if (ctrl) 2114 ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE; 2115 2116 if (radio->ctrl_handler.error) { 2117 r = radio->ctrl_handler.error; 2118 dev_err(&pdev->dev, "Ctrl handler error: %d\n", r); 2119 goto handler_init_err; 2120 } 2121 2122 video_set_drvdata(&radio->videodev, radio); 2123 platform_set_drvdata(pdev, radio); 2124 2125 /* register video device */ 2126 r = video_register_device(&radio->videodev, VFL_TYPE_RADIO, radio_nr); 2127 if (r) { 2128 dev_err(&pdev->dev, WL1273_FM_DRIVER_NAME 2129 ": Could not register video device\n"); 2130 goto handler_init_err; 2131 } 2132 2133 return 0; 2134 2135 handler_init_err: 2136 v4l2_ctrl_handler_free(&radio->ctrl_handler); 2137 v4l2_device_unregister(&radio->v4l2dev); 2138 device_register_err: 2139 kfree(radio->write_buf); 2140 write_buf_err: 2141 free_irq(radio->core->client->irq, radio); 2142 err_request_irq: 2143 radio->core->pdata->free_resources(); 2144 err_resources: 2145 kfree(radio->buffer); 2146 err_kmalloc: 2147 kfree(radio); 2148 pdata_err: 2149 return r; 2150 } 2151 2152 static struct platform_driver wl1273_fm_radio_driver = { 2153 .probe = wl1273_fm_radio_probe, 2154 .remove = __devexit_p(wl1273_fm_radio_remove), 2155 .driver = { 2156 .name = "wl1273_fm_radio", 2157 .owner = THIS_MODULE, 2158 }, 2159 }; 2160 2161 module_platform_driver(wl1273_fm_radio_driver); 2162 2163 MODULE_AUTHOR("Matti Aaltonen <matti.j.aaltonen@nokia.com>"); 2164 MODULE_DESCRIPTION(DRIVER_DESC); 2165 MODULE_LICENSE("GPL"); 2166 MODULE_ALIAS("platform:wl1273_fm_radio"); 2167