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