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