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