1/* 2 * drivers/staging/media/radio-bcm2048.c 3 * 4 * Driver for I2C Broadcom BCM2048 FM Radio Receiver: 5 * 6 * Copyright (C) Nokia Corporation 7 * Contact: Eero Nurkkala <ext-eero.nurkkala@nokia.com> 8 * 9 * Copyright (C) Nils Faerber <nils.faerber@kernelconcepts.de> 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * version 2 as published by the Free Software Foundation. 14 * 15 * This program is distributed in the hope that it will be useful, but 16 * WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 * General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 23 * 02110-1301 USA 24 */ 25 26/* 27 * History: 28 * Eero Nurkkala <ext-eero.nurkkala@nokia.com> 29 * Version 0.0.1 30 * - Initial implementation 31 * 2010-02-21 Nils Faerber <nils.faerber@kernelconcepts.de> 32 * Version 0.0.2 33 * - Add support for interrupt driven rds data reading 34 */ 35 36#include <linux/kernel.h> 37#include <linux/module.h> 38#include <linux/init.h> 39#include <linux/version.h> 40#include <linux/interrupt.h> 41#include <linux/sysfs.h> 42#include <linux/completion.h> 43#include <linux/delay.h> 44#include <linux/i2c.h> 45#include <linux/videodev2.h> 46#include <linux/mutex.h> 47#include <linux/slab.h> 48#include <media/v4l2-common.h> 49#include <media/v4l2-ioctl.h> 50#include "radio-bcm2048.h" 51 52/* driver definitions */ 53#define BCM2048_DRIVER_AUTHOR "Eero Nurkkala <ext-eero.nurkkala@nokia.com>" 54#define BCM2048_DRIVER_NAME BCM2048_NAME 55#define BCM2048_DRIVER_VERSION KERNEL_VERSION(0, 0, 1) 56#define BCM2048_DRIVER_CARD "Broadcom bcm2048 FM Radio Receiver" 57#define BCM2048_DRIVER_DESC "I2C driver for BCM2048 FM Radio Receiver" 58 59/* I2C Control Registers */ 60#define BCM2048_I2C_FM_RDS_SYSTEM 0x00 61#define BCM2048_I2C_FM_CTRL 0x01 62#define BCM2048_I2C_RDS_CTRL0 0x02 63#define BCM2048_I2C_RDS_CTRL1 0x03 64#define BCM2048_I2C_FM_AUDIO_PAUSE 0x04 65#define BCM2048_I2C_FM_AUDIO_CTRL0 0x05 66#define BCM2048_I2C_FM_AUDIO_CTRL1 0x06 67#define BCM2048_I2C_FM_SEARCH_CTRL0 0x07 68#define BCM2048_I2C_FM_SEARCH_CTRL1 0x08 69#define BCM2048_I2C_FM_SEARCH_TUNE_MODE 0x09 70#define BCM2048_I2C_FM_FREQ0 0x0a 71#define BCM2048_I2C_FM_FREQ1 0x0b 72#define BCM2048_I2C_FM_AF_FREQ0 0x0c 73#define BCM2048_I2C_FM_AF_FREQ1 0x0d 74#define BCM2048_I2C_FM_CARRIER 0x0e 75#define BCM2048_I2C_FM_RSSI 0x0f 76#define BCM2048_I2C_FM_RDS_MASK0 0x10 77#define BCM2048_I2C_FM_RDS_MASK1 0x11 78#define BCM2048_I2C_FM_RDS_FLAG0 0x12 79#define BCM2048_I2C_FM_RDS_FLAG1 0x13 80#define BCM2048_I2C_RDS_WLINE 0x14 81#define BCM2048_I2C_RDS_BLKB_MATCH0 0x16 82#define BCM2048_I2C_RDS_BLKB_MATCH1 0x17 83#define BCM2048_I2C_RDS_BLKB_MASK0 0x18 84#define BCM2048_I2C_RDS_BLKB_MASK1 0x19 85#define BCM2048_I2C_RDS_PI_MATCH0 0x1a 86#define BCM2048_I2C_RDS_PI_MATCH1 0x1b 87#define BCM2048_I2C_RDS_PI_MASK0 0x1c 88#define BCM2048_I2C_RDS_PI_MASK1 0x1d 89#define BCM2048_I2C_SPARE1 0x20 90#define BCM2048_I2C_SPARE2 0x21 91#define BCM2048_I2C_FM_RDS_REV 0x28 92#define BCM2048_I2C_SLAVE_CONFIGURATION 0x29 93#define BCM2048_I2C_RDS_DATA 0x80 94#define BCM2048_I2C_FM_BEST_TUNE_MODE 0x90 95 96/* BCM2048_I2C_FM_RDS_SYSTEM */ 97#define BCM2048_FM_ON 0x01 98#define BCM2048_RDS_ON 0x02 99 100/* BCM2048_I2C_FM_CTRL */ 101#define BCM2048_BAND_SELECT 0x01 102#define BCM2048_STEREO_MONO_AUTO_SELECT 0x02 103#define BCM2048_STEREO_MONO_MANUAL_SELECT 0x04 104#define BCM2048_STEREO_MONO_BLEND_SWITCH 0x08 105#define BCM2048_HI_LO_INJECTION 0x10 106 107/* BCM2048_I2C_RDS_CTRL0 */ 108#define BCM2048_RBDS_RDS_SELECT 0x01 109#define BCM2048_FLUSH_FIFO 0x02 110 111/* BCM2048_I2C_FM_AUDIO_PAUSE */ 112#define BCM2048_AUDIO_PAUSE_RSSI_TRESH 0x0f 113#define BCM2048_AUDIO_PAUSE_DURATION 0xf0 114 115/* BCM2048_I2C_FM_AUDIO_CTRL0 */ 116#define BCM2048_RF_MUTE 0x01 117#define BCM2048_MANUAL_MUTE 0x02 118#define BCM2048_DAC_OUTPUT_LEFT 0x04 119#define BCM2048_DAC_OUTPUT_RIGHT 0x08 120#define BCM2048_AUDIO_ROUTE_DAC 0x10 121#define BCM2048_AUDIO_ROUTE_I2S 0x20 122#define BCM2048_DE_EMPHASIS_SELECT 0x40 123#define BCM2048_AUDIO_BANDWIDTH_SELECT 0x80 124 125/* BCM2048_I2C_FM_SEARCH_CTRL0 */ 126#define BCM2048_SEARCH_RSSI_THRESHOLD 0x7f 127#define BCM2048_SEARCH_DIRECTION 0x80 128 129/* BCM2048_I2C_FM_SEARCH_TUNE_MODE */ 130#define BCM2048_FM_AUTO_SEARCH 0x03 131 132/* BCM2048_I2C_FM_RSSI */ 133#define BCM2048_RSSI_VALUE 0xff 134 135/* BCM2048_I2C_FM_RDS_MASK0 */ 136/* BCM2048_I2C_FM_RDS_MASK1 */ 137#define BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED 0x01 138#define BCM2048_FM_FLAG_SEARCH_TUNE_FAIL 0x02 139#define BCM2048_FM_FLAG_RSSI_LOW 0x04 140#define BCM2048_FM_FLAG_CARRIER_ERROR_HIGH 0x08 141#define BCM2048_FM_FLAG_AUDIO_PAUSE_INDICATION 0x10 142#define BCM2048_FLAG_STEREO_DETECTED 0x20 143#define BCM2048_FLAG_STEREO_ACTIVE 0x40 144 145/* BCM2048_I2C_RDS_DATA */ 146#define BCM2048_SLAVE_ADDRESS 0x3f 147#define BCM2048_SLAVE_ENABLE 0x80 148 149/* BCM2048_I2C_FM_BEST_TUNE_MODE */ 150#define BCM2048_BEST_TUNE_MODE 0x80 151 152#define BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED 0x01 153#define BCM2048_FM_FLAG_SEARCH_TUNE_FAIL 0x02 154#define BCM2048_FM_FLAG_RSSI_LOW 0x04 155#define BCM2048_FM_FLAG_CARRIER_ERROR_HIGH 0x08 156#define BCM2048_FM_FLAG_AUDIO_PAUSE_INDICATION 0x10 157#define BCM2048_FLAG_STEREO_DETECTED 0x20 158#define BCM2048_FLAG_STEREO_ACTIVE 0x40 159 160#define BCM2048_RDS_FLAG_FIFO_WLINE 0x02 161#define BCM2048_RDS_FLAG_B_BLOCK_MATCH 0x08 162#define BCM2048_RDS_FLAG_SYNC_LOST 0x10 163#define BCM2048_RDS_FLAG_PI_MATCH 0x20 164 165#define BCM2048_RDS_MARK_END_BYTE0 0x7C 166#define BCM2048_RDS_MARK_END_BYTEN 0xFF 167 168#define BCM2048_FM_FLAGS_ALL (FM_FLAG_SEARCH_TUNE_FINISHED | \ 169 FM_FLAG_SEARCH_TUNE_FAIL | \ 170 FM_FLAG_RSSI_LOW | \ 171 FM_FLAG_CARRIER_ERROR_HIGH | \ 172 FM_FLAG_AUDIO_PAUSE_INDICATION | \ 173 FLAG_STEREO_DETECTED | FLAG_STEREO_ACTIVE) 174 175#define BCM2048_RDS_FLAGS_ALL (RDS_FLAG_FIFO_WLINE | \ 176 RDS_FLAG_B_BLOCK_MATCH | \ 177 RDS_FLAG_SYNC_LOST | RDS_FLAG_PI_MATCH) 178 179#define BCM2048_DEFAULT_TIMEOUT 1500 180#define BCM2048_AUTO_SEARCH_TIMEOUT 3000 181 182 183#define BCM2048_FREQDEV_UNIT 10000 184#define BCM2048_FREQV4L2_MULTI 625 185#define dev_to_v4l2(f) ((f * BCM2048_FREQDEV_UNIT) / BCM2048_FREQV4L2_MULTI) 186#define v4l2_to_dev(f) ((f * BCM2048_FREQV4L2_MULTI) / BCM2048_FREQDEV_UNIT) 187 188#define msb(x) ((u8)((u16) x >> 8)) 189#define lsb(x) ((u8)((u16) x & 0x00FF)) 190#define compose_u16(msb, lsb) (((u16)msb << 8) | lsb) 191 192#define BCM2048_DEFAULT_POWERING_DELAY 20 193#define BCM2048_DEFAULT_REGION 0x02 194#define BCM2048_DEFAULT_MUTE 0x01 195#define BCM2048_DEFAULT_RSSI_THRESHOLD 0x64 196#define BCM2048_DEFAULT_RDS_WLINE 0x7E 197 198#define BCM2048_FM_SEARCH_INACTIVE 0x00 199#define BCM2048_FM_PRE_SET_MODE 0x01 200#define BCM2048_FM_AUTO_SEARCH_MODE 0x02 201#define BCM2048_FM_AF_JUMP_MODE 0x03 202 203#define BCM2048_FREQUENCY_BASE 64000 204 205#define BCM2048_POWER_ON 0x01 206#define BCM2048_POWER_OFF 0x00 207 208#define BCM2048_ITEM_ENABLED 0x01 209#define BCM2048_SEARCH_DIRECTION_UP 0x01 210 211#define BCM2048_DE_EMPHASIS_75us 75 212#define BCM2048_DE_EMPHASIS_50us 50 213 214#define BCM2048_SCAN_FAIL 0x00 215#define BCM2048_SCAN_OK 0x01 216 217#define BCM2048_FREQ_ERROR_FLOOR -20 218#define BCM2048_FREQ_ERROR_ROOF 20 219 220/* -60 dB is reported as full signal strenght */ 221#define BCM2048_RSSI_LEVEL_BASE -60 222#define BCM2048_RSSI_LEVEL_ROOF -100 223#define BCM2048_RSSI_LEVEL_ROOF_NEG 100 224#define BCM2048_SIGNAL_MULTIPLIER (0xFFFF / \ 225 (BCM2048_RSSI_LEVEL_ROOF_NEG + \ 226 BCM2048_RSSI_LEVEL_BASE)) 227 228#define BCM2048_RDS_FIFO_DUPLE_SIZE 0x03 229#define BCM2048_RDS_CRC_MASK 0x0F 230#define BCM2048_RDS_CRC_NONE 0x00 231#define BCM2048_RDS_CRC_MAX_2BITS 0x04 232#define BCM2048_RDS_CRC_LEAST_2BITS 0x08 233#define BCM2048_RDS_CRC_UNRECOVARABLE 0x0C 234 235#define BCM2048_RDS_BLOCK_MASK 0xF0 236#define BCM2048_RDS_BLOCK_A 0x00 237#define BCM2048_RDS_BLOCK_B 0x10 238#define BCM2048_RDS_BLOCK_C 0x20 239#define BCM2048_RDS_BLOCK_D 0x30 240#define BCM2048_RDS_BLOCK_C_SCORED 0x40 241#define BCM2048_RDS_BLOCK_E 0x60 242 243#define BCM2048_RDS_RT 0x20 244#define BCM2048_RDS_PS 0x00 245 246#define BCM2048_RDS_GROUP_AB_MASK 0x08 247#define BCM2048_RDS_GROUP_A 0x00 248#define BCM2048_RDS_GROUP_B 0x08 249 250#define BCM2048_RDS_RT_AB_MASK 0x10 251#define BCM2048_RDS_RT_A 0x00 252#define BCM2048_RDS_RT_B 0x10 253#define BCM2048_RDS_RT_INDEX 0x0F 254 255#define BCM2048_RDS_PS_INDEX 0x03 256 257struct rds_info { 258 u16 rds_pi; 259#define BCM2048_MAX_RDS_RT (64 + 1) 260 u8 rds_rt[BCM2048_MAX_RDS_RT]; 261 u8 rds_rt_group_b; 262 u8 rds_rt_ab; 263#define BCM2048_MAX_RDS_PS (8 + 1) 264 u8 rds_ps[BCM2048_MAX_RDS_PS]; 265 u8 rds_ps_group; 266 u8 rds_ps_group_cnt; 267#define BCM2048_MAX_RDS_RADIO_TEXT 255 268 u8 radio_text[BCM2048_MAX_RDS_RADIO_TEXT + 3]; 269 u8 text_len; 270}; 271 272struct region_info { 273 u32 bottom_frequency; 274 u32 top_frequency; 275 u8 deemphasis; 276 u8 channel_spacing; 277 u8 region; 278}; 279 280struct bcm2048_device { 281 struct i2c_client *client; 282 struct video_device videodev; 283 struct work_struct work; 284 struct completion compl; 285 struct mutex mutex; 286 struct bcm2048_platform_data *platform_data; 287 struct rds_info rds_info; 288 struct region_info region_info; 289 u16 frequency; 290 u8 cache_fm_rds_system; 291 u8 cache_fm_ctrl; 292 u8 cache_fm_audio_ctrl0; 293 u8 cache_fm_search_ctrl0; 294 u8 power_state; 295 u8 rds_state; 296 u8 fifo_size; 297 u8 scan_state; 298 u8 mute_state; 299 300 /* for rds data device read */ 301 wait_queue_head_t read_queue; 302 unsigned int users; 303 unsigned char rds_data_available; 304 unsigned int rd_index; 305}; 306 307static int radio_nr = -1; /* radio device minor (-1 ==> auto assign) */ 308module_param(radio_nr, int, 0); 309MODULE_PARM_DESC(radio_nr, 310 "Minor number for radio device (-1 ==> auto assign)"); 311 312static struct region_info region_configs[] = { 313 /* USA */ 314 { 315 .channel_spacing = 20, 316 .bottom_frequency = 87500, 317 .top_frequency = 108000, 318 .deemphasis = 75, 319 .region = 0, 320 }, 321 /* Australia */ 322 { 323 .channel_spacing = 20, 324 .bottom_frequency = 87500, 325 .top_frequency = 108000, 326 .deemphasis = 50, 327 .region = 1, 328 }, 329 /* Europe */ 330 { 331 .channel_spacing = 10, 332 .bottom_frequency = 87500, 333 .top_frequency = 108000, 334 .deemphasis = 50, 335 .region = 2, 336 }, 337 /* Japan */ 338 { 339 .channel_spacing = 10, 340 .bottom_frequency = 76000, 341 .top_frequency = 90000, 342 .deemphasis = 50, 343 .region = 3, 344 }, 345 /* Japan wide band */ 346 { 347 .channel_spacing = 10, 348 .bottom_frequency = 76000, 349 .top_frequency = 108000, 350 .deemphasis = 50, 351 .region = 4, 352 }, 353}; 354 355/* 356 * I2C Interface read / write 357 */ 358static int bcm2048_send_command(struct bcm2048_device *bdev, unsigned int reg, 359 unsigned int value) 360{ 361 struct i2c_client *client = bdev->client; 362 u8 data[2]; 363 364 if (!bdev->power_state) { 365 dev_err(&bdev->client->dev, "bcm2048: chip not powered!\n"); 366 return -EIO; 367 } 368 369 data[0] = reg & 0xff; 370 data[1] = value & 0xff; 371 372 if (i2c_master_send(client, data, 2) == 2) 373 return 0; 374 375 dev_err(&bdev->client->dev, "BCM I2C error!\n"); 376 dev_err(&bdev->client->dev, "Is Bluetooth up and running?\n"); 377 return -EIO; 378} 379 380static int bcm2048_recv_command(struct bcm2048_device *bdev, unsigned int reg, 381 u8 *value) 382{ 383 struct i2c_client *client = bdev->client; 384 385 if (!bdev->power_state) { 386 dev_err(&bdev->client->dev, "bcm2048: chip not powered!\n"); 387 return -EIO; 388 } 389 390 value[0] = i2c_smbus_read_byte_data(client, reg & 0xff); 391 392 return 0; 393} 394 395static int bcm2048_recv_duples(struct bcm2048_device *bdev, unsigned int reg, 396 u8 *value, u8 duples) 397{ 398 struct i2c_client *client = bdev->client; 399 struct i2c_adapter *adap = client->adapter; 400 struct i2c_msg msg[2]; 401 u8 buf; 402 403 if (!bdev->power_state) { 404 dev_err(&bdev->client->dev, "bcm2048: chip not powered!\n"); 405 return -EIO; 406 } 407 408 buf = reg & 0xff; 409 410 msg[0].addr = client->addr; 411 msg[0].flags = client->flags & I2C_M_TEN; 412 msg[0].len = 1; 413 msg[0].buf = &buf; 414 415 msg[1].addr = client->addr; 416 msg[1].flags = client->flags & I2C_M_TEN; 417 msg[1].flags |= I2C_M_RD; 418 msg[1].len = duples; 419 msg[1].buf = value; 420 421 return i2c_transfer(adap, msg, 2); 422} 423 424/* 425 * BCM2048 - I2C register programming helpers 426 */ 427static int bcm2048_set_power_state(struct bcm2048_device *bdev, u8 power) 428{ 429 int err = 0; 430 431 mutex_lock(&bdev->mutex); 432 433 if (power) { 434 bdev->power_state = BCM2048_POWER_ON; 435 bdev->cache_fm_rds_system |= BCM2048_FM_ON; 436 } else { 437 bdev->cache_fm_rds_system &= ~BCM2048_FM_ON; 438 } 439 440 /* 441 * Warning! FM cannot be turned off because then 442 * the I2C communications get ruined! 443 * Comment off the "if (power)" when the chip works! 444 */ 445 if (power) 446 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM, 447 bdev->cache_fm_rds_system); 448 msleep(BCM2048_DEFAULT_POWERING_DELAY); 449 450 if (!power) 451 bdev->power_state = BCM2048_POWER_OFF; 452 453 mutex_unlock(&bdev->mutex); 454 return err; 455} 456 457static int bcm2048_get_power_state(struct bcm2048_device *bdev) 458{ 459 int err; 460 u8 value; 461 462 mutex_lock(&bdev->mutex); 463 464 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM, &value); 465 466 mutex_unlock(&bdev->mutex); 467 468 if (!err && (value & BCM2048_FM_ON)) 469 return BCM2048_POWER_ON; 470 471 return err; 472} 473 474static int bcm2048_set_rds_no_lock(struct bcm2048_device *bdev, u8 rds_on) 475{ 476 int err; 477 u8 flags; 478 479 bdev->cache_fm_rds_system &= ~BCM2048_RDS_ON; 480 481 if (rds_on) { 482 bdev->cache_fm_rds_system |= BCM2048_RDS_ON; 483 bdev->rds_state = BCM2048_RDS_ON; 484 flags = BCM2048_RDS_FLAG_FIFO_WLINE; 485 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK1, 486 flags); 487 } else { 488 flags = 0; 489 bdev->rds_state = 0; 490 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK1, 491 flags); 492 memset(&bdev->rds_info, 0, sizeof(bdev->rds_info)); 493 } 494 495 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM, 496 bdev->cache_fm_rds_system); 497 498 return err; 499} 500 501static int bcm2048_get_rds_no_lock(struct bcm2048_device *bdev) 502{ 503 int err; 504 u8 value; 505 506 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_SYSTEM, &value); 507 508 if (!err && (value & BCM2048_RDS_ON)) 509 return BCM2048_ITEM_ENABLED; 510 511 return err; 512} 513 514static int bcm2048_set_rds(struct bcm2048_device *bdev, u8 rds_on) 515{ 516 int err; 517 518 mutex_lock(&bdev->mutex); 519 520 err = bcm2048_set_rds_no_lock(bdev, rds_on); 521 522 mutex_unlock(&bdev->mutex); 523 return err; 524} 525 526static int bcm2048_get_rds(struct bcm2048_device *bdev) 527{ 528 int err; 529 530 mutex_lock(&bdev->mutex); 531 532 err = bcm2048_get_rds_no_lock(bdev); 533 534 mutex_unlock(&bdev->mutex); 535 return err; 536} 537 538static int bcm2048_get_rds_pi(struct bcm2048_device *bdev) 539{ 540 return bdev->rds_info.rds_pi; 541} 542 543static int bcm2048_set_fm_automatic_stereo_mono(struct bcm2048_device *bdev, 544 u8 enabled) 545{ 546 int err; 547 548 mutex_lock(&bdev->mutex); 549 550 bdev->cache_fm_ctrl &= ~BCM2048_STEREO_MONO_AUTO_SELECT; 551 552 if (enabled) 553 bdev->cache_fm_ctrl |= BCM2048_STEREO_MONO_AUTO_SELECT; 554 555 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_CTRL, 556 bdev->cache_fm_ctrl); 557 558 mutex_unlock(&bdev->mutex); 559 return err; 560} 561 562static int bcm2048_set_fm_hi_lo_injection(struct bcm2048_device *bdev, 563 u8 hi_lo) 564{ 565 int err; 566 567 mutex_lock(&bdev->mutex); 568 569 bdev->cache_fm_ctrl &= ~BCM2048_HI_LO_INJECTION; 570 571 if (hi_lo) 572 bdev->cache_fm_ctrl |= BCM2048_HI_LO_INJECTION; 573 574 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_CTRL, 575 bdev->cache_fm_ctrl); 576 577 mutex_unlock(&bdev->mutex); 578 return err; 579} 580 581static int bcm2048_get_fm_hi_lo_injection(struct bcm2048_device *bdev) 582{ 583 int err; 584 u8 value; 585 586 mutex_lock(&bdev->mutex); 587 588 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_CTRL, &value); 589 590 mutex_unlock(&bdev->mutex); 591 592 if (!err && (value & BCM2048_HI_LO_INJECTION)) 593 return BCM2048_ITEM_ENABLED; 594 595 return err; 596} 597 598static int bcm2048_set_fm_frequency(struct bcm2048_device *bdev, u32 frequency) 599{ 600 int err; 601 602 if (frequency < bdev->region_info.bottom_frequency || 603 frequency > bdev->region_info.top_frequency) 604 return -EDOM; 605 606 frequency -= BCM2048_FREQUENCY_BASE; 607 608 mutex_lock(&bdev->mutex); 609 610 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_FREQ0, lsb(frequency)); 611 err |= bcm2048_send_command(bdev, BCM2048_I2C_FM_FREQ1, 612 msb(frequency)); 613 614 if (!err) 615 bdev->frequency = frequency; 616 617 mutex_unlock(&bdev->mutex); 618 return err; 619} 620 621static int bcm2048_get_fm_frequency(struct bcm2048_device *bdev) 622{ 623 int err; 624 u8 lsb, msb; 625 626 mutex_lock(&bdev->mutex); 627 628 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_FREQ0, &lsb); 629 err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_FREQ1, &msb); 630 631 mutex_unlock(&bdev->mutex); 632 633 if (err) 634 return err; 635 636 err = compose_u16(msb, lsb); 637 err += BCM2048_FREQUENCY_BASE; 638 639 return err; 640} 641 642static int bcm2048_set_fm_af_frequency(struct bcm2048_device *bdev, 643 u32 frequency) 644{ 645 int err; 646 647 if (frequency < bdev->region_info.bottom_frequency || 648 frequency > bdev->region_info.top_frequency) 649 return -EDOM; 650 651 frequency -= BCM2048_FREQUENCY_BASE; 652 653 mutex_lock(&bdev->mutex); 654 655 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AF_FREQ0, 656 lsb(frequency)); 657 err |= bcm2048_send_command(bdev, BCM2048_I2C_FM_AF_FREQ1, 658 msb(frequency)); 659 if (!err) 660 bdev->frequency = frequency; 661 662 mutex_unlock(&bdev->mutex); 663 return err; 664} 665 666static int bcm2048_get_fm_af_frequency(struct bcm2048_device *bdev) 667{ 668 int err; 669 u8 lsb, msb; 670 671 mutex_lock(&bdev->mutex); 672 673 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AF_FREQ0, &lsb); 674 err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_AF_FREQ1, &msb); 675 676 mutex_unlock(&bdev->mutex); 677 678 if (err) 679 return err; 680 681 err = compose_u16(msb, lsb); 682 err += BCM2048_FREQUENCY_BASE; 683 684 return err; 685} 686 687static int bcm2048_set_fm_deemphasis(struct bcm2048_device *bdev, int d) 688{ 689 int err; 690 u8 deemphasis; 691 692 if (d == BCM2048_DE_EMPHASIS_75us) 693 deemphasis = BCM2048_DE_EMPHASIS_SELECT; 694 else 695 deemphasis = 0; 696 697 mutex_lock(&bdev->mutex); 698 699 bdev->cache_fm_audio_ctrl0 &= ~BCM2048_DE_EMPHASIS_SELECT; 700 bdev->cache_fm_audio_ctrl0 |= deemphasis; 701 702 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, 703 bdev->cache_fm_audio_ctrl0); 704 705 if (!err) 706 bdev->region_info.deemphasis = d; 707 708 mutex_unlock(&bdev->mutex); 709 710 return err; 711} 712 713static int bcm2048_get_fm_deemphasis(struct bcm2048_device *bdev) 714{ 715 int err; 716 u8 value; 717 718 mutex_lock(&bdev->mutex); 719 720 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, &value); 721 722 mutex_unlock(&bdev->mutex); 723 724 if (!err) { 725 if (value & BCM2048_DE_EMPHASIS_SELECT) 726 return BCM2048_DE_EMPHASIS_75us; 727 728 return BCM2048_DE_EMPHASIS_50us; 729 } 730 731 return err; 732} 733 734static int bcm2048_set_region(struct bcm2048_device *bdev, u8 region) 735{ 736 int err; 737 u32 new_frequency = 0; 738 739 if (region >= ARRAY_SIZE(region_configs)) 740 return -EINVAL; 741 742 mutex_lock(&bdev->mutex); 743 bdev->region_info = region_configs[region]; 744 mutex_unlock(&bdev->mutex); 745 746 if (bdev->frequency < region_configs[region].bottom_frequency || 747 bdev->frequency > region_configs[region].top_frequency) 748 new_frequency = region_configs[region].bottom_frequency; 749 750 if (new_frequency > 0) { 751 err = bcm2048_set_fm_frequency(bdev, new_frequency); 752 753 if (err) 754 goto done; 755 } 756 757 err = bcm2048_set_fm_deemphasis(bdev, 758 region_configs[region].deemphasis); 759 760done: 761 return err; 762} 763 764static int bcm2048_get_region(struct bcm2048_device *bdev) 765{ 766 int err; 767 768 mutex_lock(&bdev->mutex); 769 err = bdev->region_info.region; 770 mutex_unlock(&bdev->mutex); 771 772 return err; 773} 774 775static int bcm2048_set_mute(struct bcm2048_device *bdev, u16 mute) 776{ 777 int err; 778 779 mutex_lock(&bdev->mutex); 780 781 bdev->cache_fm_audio_ctrl0 &= ~(BCM2048_RF_MUTE | BCM2048_MANUAL_MUTE); 782 783 if (mute) 784 bdev->cache_fm_audio_ctrl0 |= (BCM2048_RF_MUTE | 785 BCM2048_MANUAL_MUTE); 786 787 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, 788 bdev->cache_fm_audio_ctrl0); 789 790 if (!err) 791 bdev->mute_state = mute; 792 793 mutex_unlock(&bdev->mutex); 794 return err; 795} 796 797static int bcm2048_get_mute(struct bcm2048_device *bdev) 798{ 799 int err; 800 u8 value; 801 802 mutex_lock(&bdev->mutex); 803 804 if (bdev->power_state) { 805 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, 806 &value); 807 if (!err) 808 err = value & (BCM2048_RF_MUTE | BCM2048_MANUAL_MUTE); 809 } else { 810 err = bdev->mute_state; 811 } 812 813 mutex_unlock(&bdev->mutex); 814 return err; 815} 816 817static int bcm2048_set_audio_route(struct bcm2048_device *bdev, u8 route) 818{ 819 int err; 820 821 mutex_lock(&bdev->mutex); 822 823 route &= (BCM2048_AUDIO_ROUTE_DAC | BCM2048_AUDIO_ROUTE_I2S); 824 bdev->cache_fm_audio_ctrl0 &= ~(BCM2048_AUDIO_ROUTE_DAC | 825 BCM2048_AUDIO_ROUTE_I2S); 826 bdev->cache_fm_audio_ctrl0 |= route; 827 828 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, 829 bdev->cache_fm_audio_ctrl0); 830 831 mutex_unlock(&bdev->mutex); 832 return err; 833} 834 835static int bcm2048_get_audio_route(struct bcm2048_device *bdev) 836{ 837 int err; 838 u8 value; 839 840 mutex_lock(&bdev->mutex); 841 842 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, &value); 843 844 mutex_unlock(&bdev->mutex); 845 846 if (!err) 847 return value & (BCM2048_AUDIO_ROUTE_DAC | 848 BCM2048_AUDIO_ROUTE_I2S); 849 850 return err; 851} 852 853static int bcm2048_set_dac_output(struct bcm2048_device *bdev, u8 channels) 854{ 855 int err; 856 857 mutex_lock(&bdev->mutex); 858 859 bdev->cache_fm_audio_ctrl0 &= ~(BCM2048_DAC_OUTPUT_LEFT | 860 BCM2048_DAC_OUTPUT_RIGHT); 861 bdev->cache_fm_audio_ctrl0 |= channels; 862 863 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, 864 bdev->cache_fm_audio_ctrl0); 865 866 mutex_unlock(&bdev->mutex); 867 return err; 868} 869 870static int bcm2048_get_dac_output(struct bcm2048_device *bdev) 871{ 872 int err; 873 u8 value; 874 875 mutex_lock(&bdev->mutex); 876 877 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_AUDIO_CTRL0, &value); 878 879 mutex_unlock(&bdev->mutex); 880 881 if (!err) 882 return value & (BCM2048_DAC_OUTPUT_LEFT | 883 BCM2048_DAC_OUTPUT_RIGHT); 884 885 return err; 886} 887 888static int bcm2048_set_fm_search_rssi_threshold(struct bcm2048_device *bdev, 889 u8 threshold) 890{ 891 int err; 892 893 mutex_lock(&bdev->mutex); 894 895 threshold &= BCM2048_SEARCH_RSSI_THRESHOLD; 896 bdev->cache_fm_search_ctrl0 &= ~BCM2048_SEARCH_RSSI_THRESHOLD; 897 bdev->cache_fm_search_ctrl0 |= threshold; 898 899 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0, 900 bdev->cache_fm_search_ctrl0); 901 902 mutex_unlock(&bdev->mutex); 903 return err; 904} 905 906static int bcm2048_get_fm_search_rssi_threshold(struct bcm2048_device *bdev) 907{ 908 int err; 909 u8 value; 910 911 mutex_lock(&bdev->mutex); 912 913 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0, &value); 914 915 mutex_unlock(&bdev->mutex); 916 917 if (!err) 918 return value & BCM2048_SEARCH_RSSI_THRESHOLD; 919 920 return err; 921} 922 923static int bcm2048_set_fm_search_mode_direction(struct bcm2048_device *bdev, 924 u8 direction) 925{ 926 int err; 927 928 mutex_lock(&bdev->mutex); 929 930 bdev->cache_fm_search_ctrl0 &= ~BCM2048_SEARCH_DIRECTION; 931 932 if (direction) 933 bdev->cache_fm_search_ctrl0 |= BCM2048_SEARCH_DIRECTION; 934 935 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0, 936 bdev->cache_fm_search_ctrl0); 937 938 mutex_unlock(&bdev->mutex); 939 return err; 940} 941 942static int bcm2048_get_fm_search_mode_direction(struct bcm2048_device *bdev) 943{ 944 int err; 945 u8 value; 946 947 mutex_lock(&bdev->mutex); 948 949 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_SEARCH_CTRL0, &value); 950 951 mutex_unlock(&bdev->mutex); 952 953 if (!err && (value & BCM2048_SEARCH_DIRECTION)) 954 return BCM2048_SEARCH_DIRECTION_UP; 955 956 return err; 957} 958 959static int bcm2048_set_fm_search_tune_mode(struct bcm2048_device *bdev, 960 u8 mode) 961{ 962 int err, timeout, restart_rds = 0; 963 u8 value, flags; 964 965 value = mode & BCM2048_FM_AUTO_SEARCH; 966 967 flags = BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED | 968 BCM2048_FM_FLAG_SEARCH_TUNE_FAIL; 969 970 mutex_lock(&bdev->mutex); 971 972 /* 973 * If RDS is enabled, and frequency is changed, RDS quits working. 974 * Thus, always restart RDS if it's enabled. Moreover, RDS must 975 * not be enabled while changing the frequency because it can 976 * provide a race to the mutex from the workqueue handler if RDS 977 * IRQ occurs while waiting for frequency changed IRQ. 978 */ 979 if (bcm2048_get_rds_no_lock(bdev)) { 980 err = bcm2048_set_rds_no_lock(bdev, 0); 981 if (err) 982 goto unlock; 983 restart_rds = 1; 984 } 985 986 err = bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK0, flags); 987 988 if (err) 989 goto unlock; 990 991 bcm2048_send_command(bdev, BCM2048_I2C_FM_SEARCH_TUNE_MODE, value); 992 993 if (mode != BCM2048_FM_AUTO_SEARCH_MODE) 994 timeout = BCM2048_DEFAULT_TIMEOUT; 995 else 996 timeout = BCM2048_AUTO_SEARCH_TIMEOUT; 997 998 if (!wait_for_completion_timeout(&bdev->compl, 999 msecs_to_jiffies(timeout))) 1000 dev_err(&bdev->client->dev, "IRQ timeout.\n"); 1001 1002 if (value) 1003 if (!bdev->scan_state) 1004 err = -EIO; 1005 1006unlock: 1007 if (restart_rds) 1008 err |= bcm2048_set_rds_no_lock(bdev, 1); 1009 1010 mutex_unlock(&bdev->mutex); 1011 1012 return err; 1013} 1014 1015static int bcm2048_get_fm_search_tune_mode(struct bcm2048_device *bdev) 1016{ 1017 int err; 1018 u8 value; 1019 1020 mutex_lock(&bdev->mutex); 1021 1022 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_SEARCH_TUNE_MODE, 1023 &value); 1024 1025 mutex_unlock(&bdev->mutex); 1026 1027 if (!err) 1028 return value & BCM2048_FM_AUTO_SEARCH; 1029 1030 return err; 1031} 1032 1033static int bcm2048_set_rds_b_block_mask(struct bcm2048_device *bdev, u16 mask) 1034{ 1035 int err; 1036 1037 mutex_lock(&bdev->mutex); 1038 1039 err = bcm2048_send_command(bdev, 1040 BCM2048_I2C_RDS_BLKB_MASK0, lsb(mask)); 1041 err |= bcm2048_send_command(bdev, 1042 BCM2048_I2C_RDS_BLKB_MASK1, msb(mask)); 1043 1044 mutex_unlock(&bdev->mutex); 1045 return err; 1046} 1047 1048static int bcm2048_get_rds_b_block_mask(struct bcm2048_device *bdev) 1049{ 1050 int err; 1051 u8 lsb, msb; 1052 1053 mutex_lock(&bdev->mutex); 1054 1055 err = bcm2048_recv_command(bdev, 1056 BCM2048_I2C_RDS_BLKB_MASK0, &lsb); 1057 err |= bcm2048_recv_command(bdev, 1058 BCM2048_I2C_RDS_BLKB_MASK1, &msb); 1059 1060 mutex_unlock(&bdev->mutex); 1061 1062 if (!err) 1063 return compose_u16(msb, lsb); 1064 1065 return err; 1066} 1067 1068static int bcm2048_set_rds_b_block_match(struct bcm2048_device *bdev, 1069 u16 match) 1070{ 1071 int err; 1072 1073 mutex_lock(&bdev->mutex); 1074 1075 err = bcm2048_send_command(bdev, 1076 BCM2048_I2C_RDS_BLKB_MATCH0, lsb(match)); 1077 err |= bcm2048_send_command(bdev, 1078 BCM2048_I2C_RDS_BLKB_MATCH1, msb(match)); 1079 1080 mutex_unlock(&bdev->mutex); 1081 return err; 1082} 1083 1084static int bcm2048_get_rds_b_block_match(struct bcm2048_device *bdev) 1085{ 1086 int err; 1087 u8 lsb, msb; 1088 1089 mutex_lock(&bdev->mutex); 1090 1091 err = bcm2048_recv_command(bdev, 1092 BCM2048_I2C_RDS_BLKB_MATCH0, &lsb); 1093 err |= bcm2048_recv_command(bdev, 1094 BCM2048_I2C_RDS_BLKB_MATCH1, &msb); 1095 1096 mutex_unlock(&bdev->mutex); 1097 1098 if (!err) 1099 return compose_u16(msb, lsb); 1100 1101 return err; 1102} 1103 1104static int bcm2048_set_rds_pi_mask(struct bcm2048_device *bdev, u16 mask) 1105{ 1106 int err; 1107 1108 mutex_lock(&bdev->mutex); 1109 1110 err = bcm2048_send_command(bdev, 1111 BCM2048_I2C_RDS_PI_MASK0, lsb(mask)); 1112 err |= bcm2048_send_command(bdev, 1113 BCM2048_I2C_RDS_PI_MASK1, msb(mask)); 1114 1115 mutex_unlock(&bdev->mutex); 1116 return err; 1117} 1118 1119static int bcm2048_get_rds_pi_mask(struct bcm2048_device *bdev) 1120{ 1121 int err; 1122 u8 lsb, msb; 1123 1124 mutex_lock(&bdev->mutex); 1125 1126 err = bcm2048_recv_command(bdev, 1127 BCM2048_I2C_RDS_PI_MASK0, &lsb); 1128 err |= bcm2048_recv_command(bdev, 1129 BCM2048_I2C_RDS_PI_MASK1, &msb); 1130 1131 mutex_unlock(&bdev->mutex); 1132 1133 if (!err) 1134 return compose_u16(msb, lsb); 1135 1136 return err; 1137} 1138 1139static int bcm2048_set_rds_pi_match(struct bcm2048_device *bdev, u16 match) 1140{ 1141 int err; 1142 1143 mutex_lock(&bdev->mutex); 1144 1145 err = bcm2048_send_command(bdev, 1146 BCM2048_I2C_RDS_PI_MATCH0, lsb(match)); 1147 err |= bcm2048_send_command(bdev, 1148 BCM2048_I2C_RDS_PI_MATCH1, msb(match)); 1149 1150 mutex_unlock(&bdev->mutex); 1151 return err; 1152} 1153 1154static int bcm2048_get_rds_pi_match(struct bcm2048_device *bdev) 1155{ 1156 int err; 1157 u8 lsb, msb; 1158 1159 mutex_lock(&bdev->mutex); 1160 1161 err = bcm2048_recv_command(bdev, 1162 BCM2048_I2C_RDS_PI_MATCH0, &lsb); 1163 err |= bcm2048_recv_command(bdev, 1164 BCM2048_I2C_RDS_PI_MATCH1, &msb); 1165 1166 mutex_unlock(&bdev->mutex); 1167 1168 if (!err) 1169 return compose_u16(msb, lsb); 1170 1171 return err; 1172} 1173 1174static int bcm2048_set_fm_rds_mask(struct bcm2048_device *bdev, u16 mask) 1175{ 1176 int err; 1177 1178 mutex_lock(&bdev->mutex); 1179 1180 err = bcm2048_send_command(bdev, 1181 BCM2048_I2C_FM_RDS_MASK0, lsb(mask)); 1182 err |= bcm2048_send_command(bdev, 1183 BCM2048_I2C_FM_RDS_MASK1, msb(mask)); 1184 1185 mutex_unlock(&bdev->mutex); 1186 return err; 1187} 1188 1189static int bcm2048_get_fm_rds_mask(struct bcm2048_device *bdev) 1190{ 1191 int err; 1192 u8 value0, value1; 1193 1194 mutex_lock(&bdev->mutex); 1195 1196 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_MASK0, &value0); 1197 err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_MASK1, &value1); 1198 1199 mutex_unlock(&bdev->mutex); 1200 1201 if (!err) 1202 return compose_u16(value1, value0); 1203 1204 return err; 1205} 1206 1207static int bcm2048_get_fm_rds_flags(struct bcm2048_device *bdev) 1208{ 1209 int err; 1210 u8 value0, value1; 1211 1212 mutex_lock(&bdev->mutex); 1213 1214 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG0, &value0); 1215 err |= bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG1, &value1); 1216 1217 mutex_unlock(&bdev->mutex); 1218 1219 if (!err) 1220 return compose_u16(value1, value0); 1221 1222 return err; 1223} 1224 1225static int bcm2048_get_region_bottom_frequency(struct bcm2048_device *bdev) 1226{ 1227 return bdev->region_info.bottom_frequency; 1228} 1229 1230static int bcm2048_get_region_top_frequency(struct bcm2048_device *bdev) 1231{ 1232 return bdev->region_info.top_frequency; 1233} 1234 1235static int bcm2048_set_fm_best_tune_mode(struct bcm2048_device *bdev, u8 mode) 1236{ 1237 int err; 1238 u8 value; 1239 1240 mutex_lock(&bdev->mutex); 1241 1242 /* Perform read as the manual indicates */ 1243 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_BEST_TUNE_MODE, 1244 &value); 1245 value &= ~BCM2048_BEST_TUNE_MODE; 1246 1247 if (mode) 1248 value |= BCM2048_BEST_TUNE_MODE; 1249 err |= bcm2048_send_command(bdev, BCM2048_I2C_FM_BEST_TUNE_MODE, 1250 value); 1251 1252 mutex_unlock(&bdev->mutex); 1253 return err; 1254} 1255 1256static int bcm2048_get_fm_best_tune_mode(struct bcm2048_device *bdev) 1257{ 1258 int err; 1259 u8 value; 1260 1261 mutex_lock(&bdev->mutex); 1262 1263 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_BEST_TUNE_MODE, 1264 &value); 1265 1266 mutex_unlock(&bdev->mutex); 1267 1268 if (!err && (value & BCM2048_BEST_TUNE_MODE)) 1269 return BCM2048_ITEM_ENABLED; 1270 1271 return err; 1272} 1273 1274static int bcm2048_get_fm_carrier_error(struct bcm2048_device *bdev) 1275{ 1276 int err = 0; 1277 s8 value; 1278 1279 mutex_lock(&bdev->mutex); 1280 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_CARRIER, &value); 1281 mutex_unlock(&bdev->mutex); 1282 1283 if (!err) 1284 return value; 1285 1286 return err; 1287} 1288 1289static int bcm2048_get_fm_rssi(struct bcm2048_device *bdev) 1290{ 1291 int err; 1292 s8 value; 1293 1294 mutex_lock(&bdev->mutex); 1295 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RSSI, &value); 1296 mutex_unlock(&bdev->mutex); 1297 1298 if (!err) 1299 return value; 1300 1301 return err; 1302} 1303 1304static int bcm2048_set_rds_wline(struct bcm2048_device *bdev, u8 wline) 1305{ 1306 int err; 1307 1308 mutex_lock(&bdev->mutex); 1309 1310 err = bcm2048_send_command(bdev, BCM2048_I2C_RDS_WLINE, wline); 1311 1312 if (!err) 1313 bdev->fifo_size = wline; 1314 1315 mutex_unlock(&bdev->mutex); 1316 return err; 1317} 1318 1319static int bcm2048_get_rds_wline(struct bcm2048_device *bdev) 1320{ 1321 int err; 1322 u8 value; 1323 1324 mutex_lock(&bdev->mutex); 1325 1326 err = bcm2048_recv_command(bdev, BCM2048_I2C_RDS_WLINE, &value); 1327 1328 mutex_unlock(&bdev->mutex); 1329 1330 if (!err) { 1331 bdev->fifo_size = value; 1332 return value; 1333 } 1334 1335 return err; 1336} 1337 1338static int bcm2048_checkrev(struct bcm2048_device *bdev) 1339{ 1340 int err; 1341 u8 version; 1342 1343 mutex_lock(&bdev->mutex); 1344 1345 err = bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_REV, &version); 1346 1347 mutex_unlock(&bdev->mutex); 1348 1349 if (!err) { 1350 dev_info(&bdev->client->dev, "BCM2048 Version 0x%x\n", 1351 version); 1352 return version; 1353 } 1354 1355 return err; 1356} 1357 1358static int bcm2048_get_rds_rt(struct bcm2048_device *bdev, char *data) 1359{ 1360 int err = 0, i, j = 0, ce = 0, cr = 0; 1361 char data_buffer[BCM2048_MAX_RDS_RT+1]; 1362 1363 mutex_lock(&bdev->mutex); 1364 1365 if (!bdev->rds_info.text_len) { 1366 err = -EINVAL; 1367 goto unlock; 1368 } 1369 1370 for (i = 0; i < BCM2048_MAX_RDS_RT; i++) { 1371 if (bdev->rds_info.rds_rt[i]) { 1372 ce = i; 1373 /* Skip the carriage return */ 1374 if (bdev->rds_info.rds_rt[i] != 0x0d) { 1375 data_buffer[j++] = bdev->rds_info.rds_rt[i]; 1376 } else { 1377 cr = i; 1378 break; 1379 } 1380 } 1381 } 1382 1383 if (j <= BCM2048_MAX_RDS_RT) 1384 data_buffer[j] = 0; 1385 1386 for (i = 0; i < BCM2048_MAX_RDS_RT; i++) { 1387 if (!bdev->rds_info.rds_rt[i]) { 1388 if (cr && (i < cr)) { 1389 err = -EBUSY; 1390 goto unlock; 1391 } 1392 if (i < ce) { 1393 if (cr && (i >= cr)) 1394 break; 1395 err = -EBUSY; 1396 goto unlock; 1397 } 1398 } 1399 } 1400 1401 memcpy(data, data_buffer, sizeof(data_buffer)); 1402 1403unlock: 1404 mutex_unlock(&bdev->mutex); 1405 return err; 1406} 1407 1408static int bcm2048_get_rds_ps(struct bcm2048_device *bdev, char *data) 1409{ 1410 int err = 0, i, j = 0; 1411 char data_buffer[BCM2048_MAX_RDS_PS+1]; 1412 1413 mutex_lock(&bdev->mutex); 1414 1415 if (!bdev->rds_info.text_len) { 1416 err = -EINVAL; 1417 goto unlock; 1418 } 1419 1420 for (i = 0; i < BCM2048_MAX_RDS_PS; i++) { 1421 if (bdev->rds_info.rds_ps[i]) { 1422 data_buffer[j++] = bdev->rds_info.rds_ps[i]; 1423 } else { 1424 if (i < (BCM2048_MAX_RDS_PS - 1)) { 1425 err = -EBUSY; 1426 goto unlock; 1427 } 1428 } 1429 } 1430 1431 if (j <= BCM2048_MAX_RDS_PS) 1432 data_buffer[j] = 0; 1433 1434 memcpy(data, data_buffer, sizeof(data_buffer)); 1435 1436unlock: 1437 mutex_unlock(&bdev->mutex); 1438 return err; 1439} 1440 1441static void bcm2048_parse_rds_pi(struct bcm2048_device *bdev) 1442{ 1443 int i, cnt = 0; 1444 u16 pi; 1445 1446 for (i = 0; i < bdev->fifo_size; i += BCM2048_RDS_FIFO_DUPLE_SIZE) { 1447 1448 /* Block A match, only data without crc errors taken */ 1449 if (bdev->rds_info.radio_text[i] == BCM2048_RDS_BLOCK_A) { 1450 1451 pi = (bdev->rds_info.radio_text[i+1] << 8) + 1452 bdev->rds_info.radio_text[i+2]; 1453 1454 if (!bdev->rds_info.rds_pi) { 1455 bdev->rds_info.rds_pi = pi; 1456 return; 1457 } 1458 if (pi != bdev->rds_info.rds_pi) { 1459 cnt++; 1460 if (cnt > 3) { 1461 bdev->rds_info.rds_pi = pi; 1462 cnt = 0; 1463 } 1464 } else { 1465 cnt = 0; 1466 } 1467 } 1468 } 1469} 1470 1471static int bcm2048_rds_block_crc(struct bcm2048_device *bdev, int i) 1472{ 1473 return bdev->rds_info.radio_text[i] & BCM2048_RDS_CRC_MASK; 1474} 1475 1476static void bcm2048_parse_rds_rt_block(struct bcm2048_device *bdev, int i, 1477 int index, int crc) 1478{ 1479 /* Good data will overwrite poor data */ 1480 if (crc) { 1481 if (!bdev->rds_info.rds_rt[index]) 1482 bdev->rds_info.rds_rt[index] = 1483 bdev->rds_info.radio_text[i+1]; 1484 if (!bdev->rds_info.rds_rt[index+1]) 1485 bdev->rds_info.rds_rt[index+1] = 1486 bdev->rds_info.radio_text[i+2]; 1487 } else { 1488 bdev->rds_info.rds_rt[index] = bdev->rds_info.radio_text[i+1]; 1489 bdev->rds_info.rds_rt[index+1] = 1490 bdev->rds_info.radio_text[i+2]; 1491 } 1492} 1493 1494static int bcm2048_parse_rt_match_b(struct bcm2048_device *bdev, int i) 1495{ 1496 int crc, rt_id, rt_group_b, rt_ab, index = 0; 1497 1498 crc = bcm2048_rds_block_crc(bdev, i); 1499 1500 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1501 return -EIO; 1502 1503 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) == 1504 BCM2048_RDS_BLOCK_B) { 1505 1506 rt_id = bdev->rds_info.radio_text[i+1] & 1507 BCM2048_RDS_BLOCK_MASK; 1508 rt_group_b = bdev->rds_info.radio_text[i+1] & 1509 BCM2048_RDS_GROUP_AB_MASK; 1510 rt_ab = bdev->rds_info.radio_text[i+2] & 1511 BCM2048_RDS_RT_AB_MASK; 1512 1513 if (rt_group_b != bdev->rds_info.rds_rt_group_b) { 1514 memset(bdev->rds_info.rds_rt, 0, 1515 sizeof(bdev->rds_info.rds_rt)); 1516 bdev->rds_info.rds_rt_group_b = rt_group_b; 1517 } 1518 1519 if (rt_id == BCM2048_RDS_RT) { 1520 /* A to B or (vice versa), means: clear screen */ 1521 if (rt_ab != bdev->rds_info.rds_rt_ab) { 1522 memset(bdev->rds_info.rds_rt, 0, 1523 sizeof(bdev->rds_info.rds_rt)); 1524 bdev->rds_info.rds_rt_ab = rt_ab; 1525 } 1526 1527 index = bdev->rds_info.radio_text[i+2] & 1528 BCM2048_RDS_RT_INDEX; 1529 1530 if (bdev->rds_info.rds_rt_group_b) 1531 index <<= 1; 1532 else 1533 index <<= 2; 1534 1535 return index; 1536 } 1537 } 1538 1539 return -EIO; 1540} 1541 1542static int bcm2048_parse_rt_match_c(struct bcm2048_device *bdev, int i, 1543 int index) 1544{ 1545 int crc; 1546 1547 crc = bcm2048_rds_block_crc(bdev, i); 1548 1549 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1550 return 0; 1551 1552 BUG_ON((index+2) >= BCM2048_MAX_RDS_RT); 1553 1554 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) == 1555 BCM2048_RDS_BLOCK_C) { 1556 if (bdev->rds_info.rds_rt_group_b) 1557 return 1; 1558 bcm2048_parse_rds_rt_block(bdev, i, index, crc); 1559 return 1; 1560 } 1561 1562 return 0; 1563} 1564 1565static void bcm2048_parse_rt_match_d(struct bcm2048_device *bdev, int i, 1566 int index) 1567{ 1568 int crc; 1569 1570 crc = bcm2048_rds_block_crc(bdev, i); 1571 1572 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1573 return; 1574 1575 BUG_ON((index+4) >= BCM2048_MAX_RDS_RT); 1576 1577 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) == 1578 BCM2048_RDS_BLOCK_D) 1579 bcm2048_parse_rds_rt_block(bdev, i, index+2, crc); 1580} 1581 1582static void bcm2048_parse_rds_rt(struct bcm2048_device *bdev) 1583{ 1584 int i, index = 0, crc, match_b = 0, match_c = 0, match_d = 0; 1585 1586 for (i = 0; i < bdev->fifo_size; i += BCM2048_RDS_FIFO_DUPLE_SIZE) { 1587 1588 if (match_b) { 1589 match_b = 0; 1590 index = bcm2048_parse_rt_match_b(bdev, i); 1591 if (index >= 0 && index <= (BCM2048_MAX_RDS_RT - 5)) 1592 match_c = 1; 1593 continue; 1594 } else if (match_c) { 1595 match_c = 0; 1596 if (bcm2048_parse_rt_match_c(bdev, i, index)) 1597 match_d = 1; 1598 continue; 1599 } else if (match_d) { 1600 match_d = 0; 1601 bcm2048_parse_rt_match_d(bdev, i, index); 1602 continue; 1603 } 1604 1605 /* Skip erroneous blocks due to messed up A block altogether */ 1606 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) 1607 == BCM2048_RDS_BLOCK_A) { 1608 crc = bcm2048_rds_block_crc(bdev, i); 1609 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1610 continue; 1611 /* Syncronize to a good RDS PI */ 1612 if (((bdev->rds_info.radio_text[i+1] << 8) + 1613 bdev->rds_info.radio_text[i+2]) == 1614 bdev->rds_info.rds_pi) 1615 match_b = 1; 1616 } 1617 } 1618} 1619 1620static void bcm2048_parse_rds_ps_block(struct bcm2048_device *bdev, int i, 1621 int index, int crc) 1622{ 1623 /* Good data will overwrite poor data */ 1624 if (crc) { 1625 if (!bdev->rds_info.rds_ps[index]) 1626 bdev->rds_info.rds_ps[index] = 1627 bdev->rds_info.radio_text[i+1]; 1628 if (!bdev->rds_info.rds_ps[index+1]) 1629 bdev->rds_info.rds_ps[index+1] = 1630 bdev->rds_info.radio_text[i+2]; 1631 } else { 1632 bdev->rds_info.rds_ps[index] = bdev->rds_info.radio_text[i+1]; 1633 bdev->rds_info.rds_ps[index+1] = 1634 bdev->rds_info.radio_text[i+2]; 1635 } 1636} 1637 1638static int bcm2048_parse_ps_match_c(struct bcm2048_device *bdev, int i, 1639 int index) 1640{ 1641 int crc; 1642 1643 crc = bcm2048_rds_block_crc(bdev, i); 1644 1645 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1646 return 0; 1647 1648 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) == 1649 BCM2048_RDS_BLOCK_C) 1650 return 1; 1651 1652 return 0; 1653} 1654 1655static void bcm2048_parse_ps_match_d(struct bcm2048_device *bdev, int i, 1656 int index) 1657{ 1658 int crc; 1659 1660 crc = bcm2048_rds_block_crc(bdev, i); 1661 1662 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1663 return; 1664 1665 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) == 1666 BCM2048_RDS_BLOCK_D) 1667 bcm2048_parse_rds_ps_block(bdev, i, index, crc); 1668} 1669 1670static int bcm2048_parse_ps_match_b(struct bcm2048_device *bdev, int i) 1671{ 1672 int crc, index, ps_id, ps_group; 1673 1674 crc = bcm2048_rds_block_crc(bdev, i); 1675 1676 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1677 return -EIO; 1678 1679 /* Block B Radio PS match */ 1680 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) == 1681 BCM2048_RDS_BLOCK_B) { 1682 ps_id = bdev->rds_info.radio_text[i+1] & 1683 BCM2048_RDS_BLOCK_MASK; 1684 ps_group = bdev->rds_info.radio_text[i+1] & 1685 BCM2048_RDS_GROUP_AB_MASK; 1686 1687 /* 1688 * Poor RSSI will lead to RDS data corruption 1689 * So using 3 (same) sequential values to justify major changes 1690 */ 1691 if (ps_group != bdev->rds_info.rds_ps_group) { 1692 if (crc == BCM2048_RDS_CRC_NONE) { 1693 bdev->rds_info.rds_ps_group_cnt++; 1694 if (bdev->rds_info.rds_ps_group_cnt > 2) { 1695 bdev->rds_info.rds_ps_group = ps_group; 1696 bdev->rds_info.rds_ps_group_cnt = 0; 1697 dev_err(&bdev->client->dev, 1698 "RDS PS Group change!\n"); 1699 } else { 1700 return -EIO; 1701 } 1702 } else { 1703 bdev->rds_info.rds_ps_group_cnt = 0; 1704 } 1705 } 1706 1707 if (ps_id == BCM2048_RDS_PS) { 1708 index = bdev->rds_info.radio_text[i+2] & 1709 BCM2048_RDS_PS_INDEX; 1710 index <<= 1; 1711 return index; 1712 } 1713 } 1714 1715 return -EIO; 1716} 1717 1718static void bcm2048_parse_rds_ps(struct bcm2048_device *bdev) 1719{ 1720 int i, index = 0, crc, match_b = 0, match_c = 0, match_d = 0; 1721 1722 for (i = 0; i < bdev->fifo_size; i += BCM2048_RDS_FIFO_DUPLE_SIZE) { 1723 1724 if (match_b) { 1725 match_b = 0; 1726 index = bcm2048_parse_ps_match_b(bdev, i); 1727 if (index >= 0 && index < (BCM2048_MAX_RDS_PS - 1)) 1728 match_c = 1; 1729 continue; 1730 } else if (match_c) { 1731 match_c = 0; 1732 if (bcm2048_parse_ps_match_c(bdev, i, index)) 1733 match_d = 1; 1734 continue; 1735 } else if (match_d) { 1736 match_d = 0; 1737 bcm2048_parse_ps_match_d(bdev, i, index); 1738 continue; 1739 } 1740 1741 /* Skip erroneous blocks due to messed up A block altogether */ 1742 if ((bdev->rds_info.radio_text[i] & BCM2048_RDS_BLOCK_MASK) 1743 == BCM2048_RDS_BLOCK_A) { 1744 crc = bcm2048_rds_block_crc(bdev, i); 1745 if (crc == BCM2048_RDS_CRC_UNRECOVARABLE) 1746 continue; 1747 /* Syncronize to a good RDS PI */ 1748 if (((bdev->rds_info.radio_text[i+1] << 8) + 1749 bdev->rds_info.radio_text[i+2]) == 1750 bdev->rds_info.rds_pi) 1751 match_b = 1; 1752 } 1753 } 1754} 1755 1756static void bcm2048_rds_fifo_receive(struct bcm2048_device *bdev) 1757{ 1758 int err; 1759 1760 mutex_lock(&bdev->mutex); 1761 1762 err = bcm2048_recv_duples(bdev, BCM2048_I2C_RDS_DATA, 1763 bdev->rds_info.radio_text, bdev->fifo_size); 1764 if (err != 2) { 1765 dev_err(&bdev->client->dev, "RDS Read problem\n"); 1766 mutex_unlock(&bdev->mutex); 1767 return; 1768 } 1769 1770 bdev->rds_info.text_len = bdev->fifo_size; 1771 1772 bcm2048_parse_rds_pi(bdev); 1773 bcm2048_parse_rds_rt(bdev); 1774 bcm2048_parse_rds_ps(bdev); 1775 1776 mutex_unlock(&bdev->mutex); 1777 1778 wake_up_interruptible(&bdev->read_queue); 1779} 1780 1781static int bcm2048_get_rds_data(struct bcm2048_device *bdev, char *data) 1782{ 1783 int err = 0, i, p = 0; 1784 char *data_buffer; 1785 1786 mutex_lock(&bdev->mutex); 1787 1788 if (!bdev->rds_info.text_len) { 1789 err = -EINVAL; 1790 goto unlock; 1791 } 1792 1793 data_buffer = kcalloc(BCM2048_MAX_RDS_RADIO_TEXT, 5, GFP_KERNEL); 1794 if (!data_buffer) { 1795 err = -ENOMEM; 1796 goto unlock; 1797 } 1798 1799 for (i = 0; i < bdev->rds_info.text_len; i++) { 1800 p += sprintf(data_buffer+p, "%x ", 1801 bdev->rds_info.radio_text[i]); 1802 } 1803 1804 memcpy(data, data_buffer, p); 1805 kfree(data_buffer); 1806 1807unlock: 1808 mutex_unlock(&bdev->mutex); 1809 return err; 1810} 1811 1812/* 1813 * BCM2048 default initialization sequence 1814 */ 1815static int bcm2048_init(struct bcm2048_device *bdev) 1816{ 1817 int err; 1818 1819 err = bcm2048_set_power_state(bdev, BCM2048_POWER_ON); 1820 if (err < 0) 1821 goto exit; 1822 1823 err = bcm2048_set_audio_route(bdev, BCM2048_AUDIO_ROUTE_DAC); 1824 if (err < 0) 1825 goto exit; 1826 1827 err = bcm2048_set_dac_output(bdev, BCM2048_DAC_OUTPUT_LEFT | 1828 BCM2048_DAC_OUTPUT_RIGHT); 1829 1830exit: 1831 return err; 1832} 1833 1834/* 1835 * BCM2048 default deinitialization sequence 1836 */ 1837static int bcm2048_deinit(struct bcm2048_device *bdev) 1838{ 1839 int err; 1840 1841 err = bcm2048_set_audio_route(bdev, 0); 1842 if (err < 0) 1843 goto exit; 1844 1845 err = bcm2048_set_dac_output(bdev, 0); 1846 if (err < 0) 1847 goto exit; 1848 1849 err = bcm2048_set_power_state(bdev, BCM2048_POWER_OFF); 1850 if (err < 0) 1851 goto exit; 1852 1853exit: 1854 return err; 1855} 1856 1857/* 1858 * BCM2048 probe sequence 1859 */ 1860static int bcm2048_probe(struct bcm2048_device *bdev) 1861{ 1862 int err; 1863 1864 err = bcm2048_set_power_state(bdev, BCM2048_POWER_ON); 1865 if (err < 0) 1866 goto unlock; 1867 1868 err = bcm2048_checkrev(bdev); 1869 if (err < 0) 1870 goto unlock; 1871 1872 err = bcm2048_set_mute(bdev, BCM2048_DEFAULT_MUTE); 1873 if (err < 0) 1874 goto unlock; 1875 1876 err = bcm2048_set_region(bdev, BCM2048_DEFAULT_REGION); 1877 if (err < 0) 1878 goto unlock; 1879 1880 err = bcm2048_set_fm_search_rssi_threshold(bdev, 1881 BCM2048_DEFAULT_RSSI_THRESHOLD); 1882 if (err < 0) 1883 goto unlock; 1884 1885 err = bcm2048_set_fm_automatic_stereo_mono(bdev, BCM2048_ITEM_ENABLED); 1886 if (err < 0) 1887 goto unlock; 1888 1889 err = bcm2048_get_rds_wline(bdev); 1890 if (err < BCM2048_DEFAULT_RDS_WLINE) 1891 err = bcm2048_set_rds_wline(bdev, BCM2048_DEFAULT_RDS_WLINE); 1892 if (err < 0) 1893 goto unlock; 1894 1895 err = bcm2048_set_power_state(bdev, BCM2048_POWER_OFF); 1896 1897 init_waitqueue_head(&bdev->read_queue); 1898 bdev->rds_data_available = 0; 1899 bdev->rd_index = 0; 1900 bdev->users = 0; 1901 1902unlock: 1903 return err; 1904} 1905 1906/* 1907 * BCM2048 workqueue handler 1908 */ 1909static void bcm2048_work(struct work_struct *work) 1910{ 1911 struct bcm2048_device *bdev; 1912 u8 flag_lsb, flag_msb, flags; 1913 1914 bdev = container_of(work, struct bcm2048_device, work); 1915 bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG0, &flag_lsb); 1916 bcm2048_recv_command(bdev, BCM2048_I2C_FM_RDS_FLAG1, &flag_msb); 1917 1918 if (flag_lsb & (BCM2048_FM_FLAG_SEARCH_TUNE_FINISHED | 1919 BCM2048_FM_FLAG_SEARCH_TUNE_FAIL)) { 1920 1921 if (flag_lsb & BCM2048_FM_FLAG_SEARCH_TUNE_FAIL) 1922 bdev->scan_state = BCM2048_SCAN_FAIL; 1923 else 1924 bdev->scan_state = BCM2048_SCAN_OK; 1925 1926 complete(&bdev->compl); 1927 } 1928 1929 if (flag_msb & BCM2048_RDS_FLAG_FIFO_WLINE) { 1930 bcm2048_rds_fifo_receive(bdev); 1931 if (bdev->rds_state) { 1932 flags = BCM2048_RDS_FLAG_FIFO_WLINE; 1933 bcm2048_send_command(bdev, BCM2048_I2C_FM_RDS_MASK1, 1934 flags); 1935 } 1936 bdev->rds_data_available = 1; 1937 bdev->rd_index = 0; /* new data, new start */ 1938 } 1939} 1940 1941/* 1942 * BCM2048 interrupt handler 1943 */ 1944static irqreturn_t bcm2048_handler(int irq, void *dev) 1945{ 1946 struct bcm2048_device *bdev = dev; 1947 1948 dev_dbg(&bdev->client->dev, "IRQ called, queuing work\n"); 1949 if (bdev->power_state) 1950 schedule_work(&bdev->work); 1951 1952 return IRQ_HANDLED; 1953} 1954 1955/* 1956 * BCM2048 sysfs interface definitions 1957 */ 1958#define property_write(prop, type, mask, check) \ 1959static ssize_t bcm2048_##prop##_write(struct device *dev, \ 1960 struct device_attribute *attr, \ 1961 const char *buf, \ 1962 size_t count) \ 1963{ \ 1964 struct bcm2048_device *bdev = dev_get_drvdata(dev); \ 1965 type value; \ 1966 int err; \ 1967 \ 1968 if (!bdev) \ 1969 return -ENODEV; \ 1970 \ 1971 if (sscanf(buf, mask, &value) != 1) \ 1972 return -EINVAL; \ 1973 \ 1974 if (check) \ 1975 return -EDOM; \ 1976 \ 1977 err = bcm2048_set_##prop(bdev, value); \ 1978 \ 1979 return err < 0 ? err : count; \ 1980} 1981 1982#define property_read(prop, size, mask) \ 1983static ssize_t bcm2048_##prop##_read(struct device *dev, \ 1984 struct device_attribute *attr, \ 1985 char *buf) \ 1986{ \ 1987 struct bcm2048_device *bdev = dev_get_drvdata(dev); \ 1988 int value; \ 1989 \ 1990 if (!bdev) \ 1991 return -ENODEV; \ 1992 \ 1993 value = bcm2048_get_##prop(bdev); \ 1994 \ 1995 if (value >= 0) \ 1996 value = sprintf(buf, mask "\n", value); \ 1997 \ 1998 return value; \ 1999} 2000 2001#define property_signed_read(prop, size, mask) \ 2002static ssize_t bcm2048_##prop##_read(struct device *dev, \ 2003 struct device_attribute *attr, \ 2004 char *buf) \ 2005{ \ 2006 struct bcm2048_device *bdev = dev_get_drvdata(dev); \ 2007 size value; \ 2008 \ 2009 if (!bdev) \ 2010 return -ENODEV; \ 2011 \ 2012 value = bcm2048_get_##prop(bdev); \ 2013 \ 2014 value = sprintf(buf, mask "\n", value); \ 2015 \ 2016 return value; \ 2017} 2018 2019#define DEFINE_SYSFS_PROPERTY(prop, signal, size, mask, check) \ 2020property_write(prop, signal size, mask, check) \ 2021property_read(prop, size, mask) 2022 2023#define property_str_read(prop, size) \ 2024static ssize_t bcm2048_##prop##_read(struct device *dev, \ 2025 struct device_attribute *attr, \ 2026 char *buf) \ 2027{ \ 2028 struct bcm2048_device *bdev = dev_get_drvdata(dev); \ 2029 int count; \ 2030 u8 *out; \ 2031 \ 2032 if (!bdev) \ 2033 return -ENODEV; \ 2034 \ 2035 out = kzalloc(size + 1, GFP_KERNEL); \ 2036 if (!out) \ 2037 return -ENOMEM; \ 2038 \ 2039 bcm2048_get_##prop(bdev, out); \ 2040 count = sprintf(buf, "%s\n", out); \ 2041 \ 2042 kfree(out); \ 2043 \ 2044 return count; \ 2045} 2046 2047DEFINE_SYSFS_PROPERTY(power_state, unsigned, int, "%u", 0) 2048DEFINE_SYSFS_PROPERTY(mute, unsigned, int, "%u", 0) 2049DEFINE_SYSFS_PROPERTY(audio_route, unsigned, int, "%u", 0) 2050DEFINE_SYSFS_PROPERTY(dac_output, unsigned, int, "%u", 0) 2051 2052DEFINE_SYSFS_PROPERTY(fm_hi_lo_injection, unsigned, int, "%u", 0) 2053DEFINE_SYSFS_PROPERTY(fm_frequency, unsigned, int, "%u", 0) 2054DEFINE_SYSFS_PROPERTY(fm_af_frequency, unsigned, int, "%u", 0) 2055DEFINE_SYSFS_PROPERTY(fm_deemphasis, unsigned, int, "%u", 0) 2056DEFINE_SYSFS_PROPERTY(fm_rds_mask, unsigned, int, "%u", 0) 2057DEFINE_SYSFS_PROPERTY(fm_best_tune_mode, unsigned, int, "%u", 0) 2058DEFINE_SYSFS_PROPERTY(fm_search_rssi_threshold, unsigned, int, "%u", 0) 2059DEFINE_SYSFS_PROPERTY(fm_search_mode_direction, unsigned, int, "%u", 0) 2060DEFINE_SYSFS_PROPERTY(fm_search_tune_mode, unsigned, int, "%u", value > 3) 2061 2062DEFINE_SYSFS_PROPERTY(rds, unsigned, int, "%u", 0) 2063DEFINE_SYSFS_PROPERTY(rds_b_block_mask, unsigned, int, "%u", 0) 2064DEFINE_SYSFS_PROPERTY(rds_b_block_match, unsigned, int, "%u", 0) 2065DEFINE_SYSFS_PROPERTY(rds_pi_mask, unsigned, int, "%u", 0) 2066DEFINE_SYSFS_PROPERTY(rds_pi_match, unsigned, int, "%u", 0) 2067DEFINE_SYSFS_PROPERTY(rds_wline, unsigned, int, "%u", 0) 2068property_read(rds_pi, unsigned int, "%x") 2069property_str_read(rds_rt, (BCM2048_MAX_RDS_RT + 1)) 2070property_str_read(rds_ps, (BCM2048_MAX_RDS_PS + 1)) 2071 2072property_read(fm_rds_flags, unsigned int, "%u") 2073property_str_read(rds_data, BCM2048_MAX_RDS_RADIO_TEXT*5) 2074 2075property_read(region_bottom_frequency, unsigned int, "%u") 2076property_read(region_top_frequency, unsigned int, "%u") 2077property_signed_read(fm_carrier_error, int, "%d") 2078property_signed_read(fm_rssi, int, "%d") 2079DEFINE_SYSFS_PROPERTY(region, unsigned, int, "%u", 0) 2080 2081static struct device_attribute attrs[] = { 2082 __ATTR(power_state, S_IRUGO | S_IWUSR, bcm2048_power_state_read, 2083 bcm2048_power_state_write), 2084 __ATTR(mute, S_IRUGO | S_IWUSR, bcm2048_mute_read, 2085 bcm2048_mute_write), 2086 __ATTR(audio_route, S_IRUGO | S_IWUSR, bcm2048_audio_route_read, 2087 bcm2048_audio_route_write), 2088 __ATTR(dac_output, S_IRUGO | S_IWUSR, bcm2048_dac_output_read, 2089 bcm2048_dac_output_write), 2090 __ATTR(fm_hi_lo_injection, S_IRUGO | S_IWUSR, 2091 bcm2048_fm_hi_lo_injection_read, 2092 bcm2048_fm_hi_lo_injection_write), 2093 __ATTR(fm_frequency, S_IRUGO | S_IWUSR, bcm2048_fm_frequency_read, 2094 bcm2048_fm_frequency_write), 2095 __ATTR(fm_af_frequency, S_IRUGO | S_IWUSR, 2096 bcm2048_fm_af_frequency_read, 2097 bcm2048_fm_af_frequency_write), 2098 __ATTR(fm_deemphasis, S_IRUGO | S_IWUSR, bcm2048_fm_deemphasis_read, 2099 bcm2048_fm_deemphasis_write), 2100 __ATTR(fm_rds_mask, S_IRUGO | S_IWUSR, bcm2048_fm_rds_mask_read, 2101 bcm2048_fm_rds_mask_write), 2102 __ATTR(fm_best_tune_mode, S_IRUGO | S_IWUSR, 2103 bcm2048_fm_best_tune_mode_read, 2104 bcm2048_fm_best_tune_mode_write), 2105 __ATTR(fm_search_rssi_threshold, S_IRUGO | S_IWUSR, 2106 bcm2048_fm_search_rssi_threshold_read, 2107 bcm2048_fm_search_rssi_threshold_write), 2108 __ATTR(fm_search_mode_direction, S_IRUGO | S_IWUSR, 2109 bcm2048_fm_search_mode_direction_read, 2110 bcm2048_fm_search_mode_direction_write), 2111 __ATTR(fm_search_tune_mode, S_IRUGO | S_IWUSR, 2112 bcm2048_fm_search_tune_mode_read, 2113 bcm2048_fm_search_tune_mode_write), 2114 __ATTR(rds, S_IRUGO | S_IWUSR, bcm2048_rds_read, 2115 bcm2048_rds_write), 2116 __ATTR(rds_b_block_mask, S_IRUGO | S_IWUSR, 2117 bcm2048_rds_b_block_mask_read, 2118 bcm2048_rds_b_block_mask_write), 2119 __ATTR(rds_b_block_match, S_IRUGO | S_IWUSR, 2120 bcm2048_rds_b_block_match_read, 2121 bcm2048_rds_b_block_match_write), 2122 __ATTR(rds_pi_mask, S_IRUGO | S_IWUSR, bcm2048_rds_pi_mask_read, 2123 bcm2048_rds_pi_mask_write), 2124 __ATTR(rds_pi_match, S_IRUGO | S_IWUSR, bcm2048_rds_pi_match_read, 2125 bcm2048_rds_pi_match_write), 2126 __ATTR(rds_wline, S_IRUGO | S_IWUSR, bcm2048_rds_wline_read, 2127 bcm2048_rds_wline_write), 2128 __ATTR(rds_pi, S_IRUGO, bcm2048_rds_pi_read, NULL), 2129 __ATTR(rds_rt, S_IRUGO, bcm2048_rds_rt_read, NULL), 2130 __ATTR(rds_ps, S_IRUGO, bcm2048_rds_ps_read, NULL), 2131 __ATTR(fm_rds_flags, S_IRUGO, bcm2048_fm_rds_flags_read, NULL), 2132 __ATTR(region_bottom_frequency, S_IRUGO, 2133 bcm2048_region_bottom_frequency_read, NULL), 2134 __ATTR(region_top_frequency, S_IRUGO, 2135 bcm2048_region_top_frequency_read, NULL), 2136 __ATTR(fm_carrier_error, S_IRUGO, 2137 bcm2048_fm_carrier_error_read, NULL), 2138 __ATTR(fm_rssi, S_IRUGO, 2139 bcm2048_fm_rssi_read, NULL), 2140 __ATTR(region, S_IRUGO | S_IWUSR, bcm2048_region_read, 2141 bcm2048_region_write), 2142 __ATTR(rds_data, S_IRUGO, bcm2048_rds_data_read, NULL), 2143}; 2144 2145static int bcm2048_sysfs_unregister_properties(struct bcm2048_device *bdev, 2146 int size) 2147{ 2148 int i; 2149 2150 for (i = 0; i < size; i++) 2151 device_remove_file(&bdev->client->dev, &attrs[i]); 2152 2153 return 0; 2154} 2155 2156static int bcm2048_sysfs_register_properties(struct bcm2048_device *bdev) 2157{ 2158 int err = 0; 2159 int i; 2160 2161 for (i = 0; i < ARRAY_SIZE(attrs); i++) { 2162 if (device_create_file(&bdev->client->dev, &attrs[i]) != 0) { 2163 dev_err(&bdev->client->dev, 2164 "could not register sysfs entry\n"); 2165 err = -EBUSY; 2166 bcm2048_sysfs_unregister_properties(bdev, i); 2167 break; 2168 } 2169 } 2170 2171 return err; 2172} 2173 2174 2175static int bcm2048_fops_open(struct file *file) 2176{ 2177 struct bcm2048_device *bdev = video_drvdata(file); 2178 2179 bdev->users++; 2180 bdev->rd_index = 0; 2181 bdev->rds_data_available = 0; 2182 2183 return 0; 2184} 2185 2186static int bcm2048_fops_release(struct file *file) 2187{ 2188 struct bcm2048_device *bdev = video_drvdata(file); 2189 2190 bdev->users--; 2191 2192 return 0; 2193} 2194 2195static unsigned int bcm2048_fops_poll(struct file *file, 2196 struct poll_table_struct *pts) 2197{ 2198 struct bcm2048_device *bdev = video_drvdata(file); 2199 int retval = 0; 2200 2201 poll_wait(file, &bdev->read_queue, pts); 2202 2203 if (bdev->rds_data_available) 2204 retval = POLLIN | POLLRDNORM; 2205 2206 return retval; 2207} 2208 2209static ssize_t bcm2048_fops_read(struct file *file, char __user *buf, 2210 size_t count, loff_t *ppos) 2211{ 2212 struct bcm2048_device *bdev = video_drvdata(file); 2213 int i; 2214 int retval = 0; 2215 2216 /* we return at least 3 bytes, one block */ 2217 count = (count / 3) * 3; /* only multiples of 3 */ 2218 if (count < 3) 2219 return -ENOBUFS; 2220 2221 while (!bdev->rds_data_available) { 2222 if (file->f_flags & O_NONBLOCK) { 2223 retval = -EWOULDBLOCK; 2224 goto done; 2225 } 2226 /* interruptible_sleep_on(&bdev->read_queue); */ 2227 if (wait_event_interruptible(bdev->read_queue, 2228 bdev->rds_data_available) < 0) { 2229 retval = -EINTR; 2230 goto done; 2231 } 2232 } 2233 2234 mutex_lock(&bdev->mutex); 2235 /* copy data to userspace */ 2236 i = bdev->fifo_size - bdev->rd_index; 2237 if (count > i) 2238 count = (i / 3) * 3; 2239 2240 i = 0; 2241 while (i < count) { 2242 unsigned char tmpbuf[3]; 2243 2244 tmpbuf[i] = bdev->rds_info.radio_text[bdev->rd_index+i+2]; 2245 tmpbuf[i+1] = bdev->rds_info.radio_text[bdev->rd_index+i+1]; 2246 tmpbuf[i+2] = (bdev->rds_info.radio_text[bdev->rd_index + i] & 0xf0) >> 4; 2247 if ((bdev->rds_info.radio_text[bdev->rd_index+i] & 2248 BCM2048_RDS_CRC_MASK) == BCM2048_RDS_CRC_UNRECOVARABLE) 2249 tmpbuf[i+2] |= 0x80; 2250 if (copy_to_user(buf+i, tmpbuf, 3)) { 2251 retval = -EFAULT; 2252 break; 2253 } 2254 i += 3; 2255 } 2256 2257 bdev->rd_index += i; 2258 if (bdev->rd_index >= bdev->fifo_size) 2259 bdev->rds_data_available = 0; 2260 2261 mutex_unlock(&bdev->mutex); 2262 if (retval == 0) 2263 retval = i; 2264 2265done: 2266 return retval; 2267} 2268 2269/* 2270 * bcm2048_fops - file operations interface 2271 */ 2272static const struct v4l2_file_operations bcm2048_fops = { 2273 .owner = THIS_MODULE, 2274 .unlocked_ioctl = video_ioctl2, 2275 /* for RDS read support */ 2276 .open = bcm2048_fops_open, 2277 .release = bcm2048_fops_release, 2278 .read = bcm2048_fops_read, 2279 .poll = bcm2048_fops_poll 2280}; 2281 2282/* 2283 * Video4Linux Interface 2284 */ 2285static struct v4l2_queryctrl bcm2048_v4l2_queryctrl[] = { 2286 { 2287 .id = V4L2_CID_AUDIO_VOLUME, 2288 .flags = V4L2_CTRL_FLAG_DISABLED, 2289 }, 2290 { 2291 .id = V4L2_CID_AUDIO_BALANCE, 2292 .flags = V4L2_CTRL_FLAG_DISABLED, 2293 }, 2294 { 2295 .id = V4L2_CID_AUDIO_BASS, 2296 .flags = V4L2_CTRL_FLAG_DISABLED, 2297 }, 2298 { 2299 .id = V4L2_CID_AUDIO_TREBLE, 2300 .flags = V4L2_CTRL_FLAG_DISABLED, 2301 }, 2302 { 2303 .id = V4L2_CID_AUDIO_MUTE, 2304 .type = V4L2_CTRL_TYPE_BOOLEAN, 2305 .name = "Mute", 2306 .minimum = 0, 2307 .maximum = 1, 2308 .step = 1, 2309 .default_value = 1, 2310 }, 2311 { 2312 .id = V4L2_CID_AUDIO_LOUDNESS, 2313 .flags = V4L2_CTRL_FLAG_DISABLED, 2314 }, 2315}; 2316 2317static int bcm2048_vidioc_querycap(struct file *file, void *priv, 2318 struct v4l2_capability *capability) 2319{ 2320 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2321 2322 strlcpy(capability->driver, BCM2048_DRIVER_NAME, 2323 sizeof(capability->driver)); 2324 strlcpy(capability->card, BCM2048_DRIVER_CARD, 2325 sizeof(capability->card)); 2326 snprintf(capability->bus_info, 32, "I2C: 0x%X", bdev->client->addr); 2327 capability->device_caps = V4L2_CAP_TUNER | V4L2_CAP_RADIO | 2328 V4L2_CAP_HW_FREQ_SEEK; 2329 capability->capabilities = capability->device_caps | 2330 V4L2_CAP_DEVICE_CAPS; 2331 2332 return 0; 2333} 2334 2335static int bcm2048_vidioc_g_input(struct file *filp, void *priv, 2336 unsigned int *i) 2337{ 2338 *i = 0; 2339 2340 return 0; 2341} 2342 2343static int bcm2048_vidioc_s_input(struct file *filp, void *priv, 2344 unsigned int i) 2345{ 2346 if (i) 2347 return -EINVAL; 2348 2349 return 0; 2350} 2351 2352static int bcm2048_vidioc_queryctrl(struct file *file, void *priv, 2353 struct v4l2_queryctrl *qc) 2354{ 2355 int i; 2356 2357 for (i = 0; i < ARRAY_SIZE(bcm2048_v4l2_queryctrl); i++) { 2358 if (qc->id && qc->id == bcm2048_v4l2_queryctrl[i].id) { 2359 *qc = bcm2048_v4l2_queryctrl[i]; 2360 return 0; 2361 } 2362 } 2363 2364 return -EINVAL; 2365} 2366 2367static int bcm2048_vidioc_g_ctrl(struct file *file, void *priv, 2368 struct v4l2_control *ctrl) 2369{ 2370 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2371 int err = 0; 2372 2373 if (!bdev) 2374 return -ENODEV; 2375 2376 switch (ctrl->id) { 2377 case V4L2_CID_AUDIO_MUTE: 2378 err = bcm2048_get_mute(bdev); 2379 if (err >= 0) 2380 ctrl->value = err; 2381 break; 2382 } 2383 2384 return err; 2385} 2386 2387static int bcm2048_vidioc_s_ctrl(struct file *file, void *priv, 2388 struct v4l2_control *ctrl) 2389{ 2390 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2391 int err = 0; 2392 2393 if (!bdev) 2394 return -ENODEV; 2395 2396 switch (ctrl->id) { 2397 case V4L2_CID_AUDIO_MUTE: 2398 if (ctrl->value) { 2399 if (bdev->power_state) { 2400 err = bcm2048_set_mute(bdev, ctrl->value); 2401 err |= bcm2048_deinit(bdev); 2402 } 2403 } else { 2404 if (!bdev->power_state) { 2405 err = bcm2048_init(bdev); 2406 err |= bcm2048_set_mute(bdev, ctrl->value); 2407 } 2408 } 2409 break; 2410 } 2411 2412 return err; 2413} 2414 2415static int bcm2048_vidioc_g_audio(struct file *file, void *priv, 2416 struct v4l2_audio *audio) 2417{ 2418 if (audio->index > 1) 2419 return -EINVAL; 2420 2421 strncpy(audio->name, "Radio", 32); 2422 audio->capability = V4L2_AUDCAP_STEREO; 2423 2424 return 0; 2425} 2426 2427static int bcm2048_vidioc_s_audio(struct file *file, void *priv, 2428 const struct v4l2_audio *audio) 2429{ 2430 if (audio->index != 0) 2431 return -EINVAL; 2432 2433 return 0; 2434} 2435 2436static int bcm2048_vidioc_g_tuner(struct file *file, void *priv, 2437 struct v4l2_tuner *tuner) 2438{ 2439 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2440 s8 f_error; 2441 s8 rssi; 2442 2443 if (!bdev) 2444 return -ENODEV; 2445 2446 if (tuner->index > 0) 2447 return -EINVAL; 2448 2449 strncpy(tuner->name, "FM Receiver", 32); 2450 tuner->type = V4L2_TUNER_RADIO; 2451 tuner->rangelow = 2452 dev_to_v4l2(bcm2048_get_region_bottom_frequency(bdev)); 2453 tuner->rangehigh = 2454 dev_to_v4l2(bcm2048_get_region_top_frequency(bdev)); 2455 tuner->rxsubchans = V4L2_TUNER_SUB_STEREO; 2456 tuner->capability = V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LOW; 2457 tuner->audmode = V4L2_TUNER_MODE_STEREO; 2458 tuner->afc = 0; 2459 if (bdev->power_state) { 2460 /* 2461 * Report frequencies with high carrier errors to have zero 2462 * signal level 2463 */ 2464 f_error = bcm2048_get_fm_carrier_error(bdev); 2465 if (f_error < BCM2048_FREQ_ERROR_FLOOR || 2466 f_error > BCM2048_FREQ_ERROR_ROOF) { 2467 tuner->signal = 0; 2468 } else { 2469 /* 2470 * RSSI level -60 dB is defined to report full 2471 * signal strenght 2472 */ 2473 rssi = bcm2048_get_fm_rssi(bdev); 2474 if (rssi >= BCM2048_RSSI_LEVEL_BASE) { 2475 tuner->signal = 0xFFFF; 2476 } else if (rssi > BCM2048_RSSI_LEVEL_ROOF) { 2477 tuner->signal = (rssi + 2478 BCM2048_RSSI_LEVEL_ROOF_NEG) 2479 * BCM2048_SIGNAL_MULTIPLIER; 2480 } else { 2481 tuner->signal = 0; 2482 } 2483 } 2484 } else { 2485 tuner->signal = 0; 2486 } 2487 2488 return 0; 2489} 2490 2491static int bcm2048_vidioc_s_tuner(struct file *file, void *priv, 2492 const struct v4l2_tuner *tuner) 2493{ 2494 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2495 2496 if (!bdev) 2497 return -ENODEV; 2498 2499 if (tuner->index > 0) 2500 return -EINVAL; 2501 2502 return 0; 2503} 2504 2505static int bcm2048_vidioc_g_frequency(struct file *file, void *priv, 2506 struct v4l2_frequency *freq) 2507{ 2508 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2509 int err = 0; 2510 int f; 2511 2512 if (!bdev->power_state) 2513 return -ENODEV; 2514 2515 freq->type = V4L2_TUNER_RADIO; 2516 f = bcm2048_get_fm_frequency(bdev); 2517 2518 if (f < 0) 2519 err = f; 2520 else 2521 freq->frequency = dev_to_v4l2(f); 2522 2523 return err; 2524} 2525 2526static int bcm2048_vidioc_s_frequency(struct file *file, void *priv, 2527 const struct v4l2_frequency *freq) 2528{ 2529 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2530 int err; 2531 2532 if (freq->type != V4L2_TUNER_RADIO) 2533 return -EINVAL; 2534 2535 if (!bdev->power_state) 2536 return -ENODEV; 2537 2538 err = bcm2048_set_fm_frequency(bdev, v4l2_to_dev(freq->frequency)); 2539 err |= bcm2048_set_fm_search_tune_mode(bdev, BCM2048_FM_PRE_SET_MODE); 2540 2541 return err; 2542} 2543 2544static int bcm2048_vidioc_s_hw_freq_seek(struct file *file, void *priv, 2545 const struct v4l2_hw_freq_seek *seek) 2546{ 2547 struct bcm2048_device *bdev = video_get_drvdata(video_devdata(file)); 2548 int err; 2549 2550 if (!bdev->power_state) 2551 return -ENODEV; 2552 2553 if ((seek->tuner != 0) || (seek->type != V4L2_TUNER_RADIO)) 2554 return -EINVAL; 2555 2556 err = bcm2048_set_fm_search_mode_direction(bdev, seek->seek_upward); 2557 err |= bcm2048_set_fm_search_tune_mode(bdev, 2558 BCM2048_FM_AUTO_SEARCH_MODE); 2559 2560 return err; 2561} 2562 2563static struct v4l2_ioctl_ops bcm2048_ioctl_ops = { 2564 .vidioc_querycap = bcm2048_vidioc_querycap, 2565 .vidioc_g_input = bcm2048_vidioc_g_input, 2566 .vidioc_s_input = bcm2048_vidioc_s_input, 2567 .vidioc_queryctrl = bcm2048_vidioc_queryctrl, 2568 .vidioc_g_ctrl = bcm2048_vidioc_g_ctrl, 2569 .vidioc_s_ctrl = bcm2048_vidioc_s_ctrl, 2570 .vidioc_g_audio = bcm2048_vidioc_g_audio, 2571 .vidioc_s_audio = bcm2048_vidioc_s_audio, 2572 .vidioc_g_tuner = bcm2048_vidioc_g_tuner, 2573 .vidioc_s_tuner = bcm2048_vidioc_s_tuner, 2574 .vidioc_g_frequency = bcm2048_vidioc_g_frequency, 2575 .vidioc_s_frequency = bcm2048_vidioc_s_frequency, 2576 .vidioc_s_hw_freq_seek = bcm2048_vidioc_s_hw_freq_seek, 2577}; 2578 2579/* 2580 * bcm2048_viddev_template - video device interface 2581 */ 2582static struct video_device bcm2048_viddev_template = { 2583 .fops = &bcm2048_fops, 2584 .name = BCM2048_DRIVER_NAME, 2585 .release = video_device_release_empty, 2586 .ioctl_ops = &bcm2048_ioctl_ops, 2587}; 2588 2589/* 2590 * I2C driver interface 2591 */ 2592static int bcm2048_i2c_driver_probe(struct i2c_client *client, 2593 const struct i2c_device_id *id) 2594{ 2595 struct bcm2048_device *bdev; 2596 int err, skip_release = 0; 2597 2598 bdev = kzalloc(sizeof(*bdev), GFP_KERNEL); 2599 if (!bdev) { 2600 err = -ENOMEM; 2601 goto exit; 2602 } 2603 2604 bdev->client = client; 2605 i2c_set_clientdata(client, bdev); 2606 mutex_init(&bdev->mutex); 2607 init_completion(&bdev->compl); 2608 INIT_WORK(&bdev->work, bcm2048_work); 2609 2610 if (client->irq) { 2611 err = request_irq(client->irq, 2612 bcm2048_handler, IRQF_TRIGGER_FALLING, 2613 client->name, bdev); 2614 if (err < 0) { 2615 dev_err(&client->dev, "Could not request IRQ\n"); 2616 goto free_bdev; 2617 } 2618 dev_dbg(&client->dev, "IRQ requested.\n"); 2619 } else { 2620 dev_dbg(&client->dev, "IRQ not configured. Using timeouts.\n"); 2621 } 2622 2623 bdev->videodev = bcm2048_viddev_template; 2624 video_set_drvdata(&bdev->videodev, bdev); 2625 if (video_register_device(&bdev->videodev, VFL_TYPE_RADIO, radio_nr)) { 2626 dev_dbg(&client->dev, "Could not register video device.\n"); 2627 err = -EIO; 2628 goto free_irq; 2629 } 2630 2631 err = bcm2048_sysfs_register_properties(bdev); 2632 if (err < 0) { 2633 dev_dbg(&client->dev, "Could not register sysfs interface.\n"); 2634 goto free_registration; 2635 } 2636 2637 err = bcm2048_probe(bdev); 2638 if (err < 0) { 2639 dev_dbg(&client->dev, "Failed to probe device information.\n"); 2640 goto free_sysfs; 2641 } 2642 2643 return 0; 2644 2645free_sysfs: 2646 bcm2048_sysfs_unregister_properties(bdev, ARRAY_SIZE(attrs)); 2647free_registration: 2648 video_unregister_device(&bdev->videodev); 2649 skip_release = 1; 2650free_irq: 2651 if (client->irq) 2652 free_irq(client->irq, bdev); 2653free_bdev: 2654 i2c_set_clientdata(client, NULL); 2655 kfree(bdev); 2656exit: 2657 return err; 2658} 2659 2660static int __exit bcm2048_i2c_driver_remove(struct i2c_client *client) 2661{ 2662 struct bcm2048_device *bdev = i2c_get_clientdata(client); 2663 2664 if (!client->adapter) 2665 return -ENODEV; 2666 2667 if (bdev) { 2668 bcm2048_sysfs_unregister_properties(bdev, ARRAY_SIZE(attrs)); 2669 video_unregister_device(&bdev->videodev); 2670 2671 if (bdev->power_state) 2672 bcm2048_set_power_state(bdev, BCM2048_POWER_OFF); 2673 2674 if (client->irq > 0) 2675 free_irq(client->irq, bdev); 2676 2677 cancel_work_sync(&bdev->work); 2678 2679 kfree(bdev); 2680 } 2681 2682 return 0; 2683} 2684 2685/* 2686 * bcm2048_i2c_driver - i2c driver interface 2687 */ 2688static const struct i2c_device_id bcm2048_id[] = { 2689 { "bcm2048", 0 }, 2690 { }, 2691}; 2692MODULE_DEVICE_TABLE(i2c, bcm2048_id); 2693 2694static struct i2c_driver bcm2048_i2c_driver = { 2695 .driver = { 2696 .name = BCM2048_DRIVER_NAME, 2697 }, 2698 .probe = bcm2048_i2c_driver_probe, 2699 .remove = __exit_p(bcm2048_i2c_driver_remove), 2700 .id_table = bcm2048_id, 2701}; 2702 2703module_i2c_driver(bcm2048_i2c_driver); 2704 2705MODULE_LICENSE("GPL"); 2706MODULE_AUTHOR(BCM2048_DRIVER_AUTHOR); 2707MODULE_DESCRIPTION(BCM2048_DRIVER_DESC); 2708MODULE_VERSION("0.0.2"); 2709