drivers/staging/media/bcm2048/radio-bcm2048.c

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