drivers/media/video/cx25840/cx25840-audio.c

   1 /* cx25840 audio functions
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License
   5  * as published by the Free Software Foundation; either version 2
   6  * of the License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  16  */
  17
  18
  19 #include <linux/videodev2.h>
  20 #include <linux/i2c.h>
  21 #include <media/v4l2-common.h>
  22 #include <media/cx25840.h>
  23
  24 #include "cx25840-core.h"
  25
  26 /*
  27  * Note: The PLL and SRC parameters are based on a reference frequency that
  28  * would ideally be:
  29  *
  30  * NTSC Color subcarrier freq * 8 = 4.5 MHz/286 * 455/2 * 8 = 28.63636363... MHz
  31  *
  32  * However, it's not the exact reference frequency that matters, only that the
  33  * firmware and modules that comprise the driver for a particular board all
  34  * use the same value (close to the ideal value).
  35  *
  36  * Comments below will note which reference frequency is assumed for various
  37  * parameters.  They will usually be one of
  38  *
  39  *      ref_freq = 28.636360 MHz
  40  *              or
  41  *      ref_freq = 28.636363 MHz
  42  */
  43
  44 static int cx25840_set_audclk_freq(struct i2c_client *client, u32 freq)
  45 {
  46         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
  47
  48         if (state->aud_input != CX25840_AUDIO_SERIAL) {
  49                 switch (freq) {
  50                 case 32000:
  51                         /*
  52                          * VID_PLL Integer = 0x0f, VID_PLL Post Divider = 0x04
  53                          * AUX_PLL Integer = 0x06, AUX PLL Post Divider = 0x10
  54                          */
  55                         cx25840_write4(client, 0x108, 0x1006040f);
  56
  57                         /*
  58                          * VID_PLL Fraction (register 0x10c) = 0x2be2fe
  59                          * 28636360 * 0xf.15f17f0/4 = 108 MHz
  60                          * 432 MHz pre-postdivide
  61                          */
  62
  63                         /*
  64                          * AUX_PLL Fraction = 0x1bb39ee
  65                          * 28636363 * 0x6.dd9cf70/0x10 = 32000 * 384
  66                          * 196.6 MHz pre-postdivide
  67                          * FIXME < 200 MHz is out of specified valid range
  68                          * FIXME 28636363 ref_freq doesn't match VID PLL ref
  69                          */
  70                         cx25840_write4(client, 0x110, 0x01bb39ee);
  71
  72                         /*
  73                          * SA_MCLK_SEL = 1
  74                          * SA_MCLK_DIV = 0x10 = 384/384 * AUX_PLL post dvivider
  75                          */
  76                         cx25840_write(client, 0x127, 0x50);
  77
  78                         if (is_cx2583x(state))
  79                                 break;
  80
  81                         /* src3/4/6_ctl */
  82                         /* 0x1.f77f = (4 * 28636360/8 * 2/455) / 32000 */
  83                         cx25840_write4(client, 0x900, 0x0801f77f);
  84                         cx25840_write4(client, 0x904, 0x0801f77f);
  85                         cx25840_write4(client, 0x90c, 0x0801f77f);
  86                         break;
  87
  88                 case 44100:
  89                         /*
  90                          * VID_PLL Integer = 0x0f, VID_PLL Post Divider = 0x04
  91                          * AUX_PLL Integer = 0x09, AUX PLL Post Divider = 0x10
  92                          */
  93                         cx25840_write4(client, 0x108, 0x1009040f);
  94
  95                         /*
  96                          * VID_PLL Fraction (register 0x10c) = 0x2be2fe
  97                          * 28636360 * 0xf.15f17f0/4 = 108 MHz
  98                          * 432 MHz pre-postdivide
  99                          */
 100
 101                         /*
 102                          * AUX_PLL Fraction = 0x0ec6bd6
 103                          * 28636363 * 0x9.7635eb0/0x10 = 44100 * 384
 104                          * 271 MHz pre-postdivide
 105                          * FIXME 28636363 ref_freq doesn't match VID PLL ref
 106                          */
 107                         cx25840_write4(client, 0x110, 0x00ec6bd6);
 108
 109                         /*
 110                          * SA_MCLK_SEL = 1
 111                          * SA_MCLK_DIV = 0x10 = 384/384 * AUX_PLL post dvivider
 112                          */
 113                         cx25840_write(client, 0x127, 0x50);
 114
 115                         if (is_cx2583x(state))
 116                                 break;
 117
 118                         /* src3/4/6_ctl */
 119                         /* 0x1.6d59 = (4 * 28636360/8 * 2/455) / 44100 */
 120                         cx25840_write4(client, 0x900, 0x08016d59);
 121                         cx25840_write4(client, 0x904, 0x08016d59);
 122                         cx25840_write4(client, 0x90c, 0x08016d59);
 123                         break;
 124
 125                 case 48000:
 126                         /*
 127                          * VID_PLL Integer = 0x0f, VID_PLL Post Divider = 0x04
 128                          * AUX_PLL Integer = 0x0a, AUX PLL Post Divider = 0x10
 129                          */
 130                         cx25840_write4(client, 0x108, 0x100a040f);
 131
 132                         /*
 133                          * VID_PLL Fraction (register 0x10c) = 0x2be2fe
 134                          * 28636360 * 0xf.15f17f0/4 = 108 MHz
 135                          * 432 MHz pre-postdivide
 136                          */
 137
 138                         /*
 139                          * AUX_PLL Fraction = 0x098d6e5
 140                          * 28636363 * 0xa.4c6b728/0x10 = 48000 * 384
 141                          * 295 MHz pre-postdivide
 142                          * FIXME 28636363 ref_freq doesn't match VID PLL ref
 143                          */
 144                         cx25840_write4(client, 0x110, 0x0098d6e5);
 145
 146                         /*
 147                          * SA_MCLK_SEL = 1
 148                          * SA_MCLK_DIV = 0x10 = 384/384 * AUX_PLL post dvivider
 149                          */
 150                         cx25840_write(client, 0x127, 0x50);
 151
 152                         if (is_cx2583x(state))
 153                                 break;
 154
 155                         /* src3/4/6_ctl */
 156                         /* 0x1.4faa = (4 * 28636360/8 * 2/455) / 48000 */
 157                         cx25840_write4(client, 0x900, 0x08014faa);
 158                         cx25840_write4(client, 0x904, 0x08014faa);
 159                         cx25840_write4(client, 0x90c, 0x08014faa);
 160                         break;
 161                 }
 162         } else {
 163                 switch (freq) {
 164                 case 32000:
 165                         /*
 166                          * VID_PLL Integer = 0x0f, VID_PLL Post Divider = 0x04
 167                          * AUX_PLL Integer = 0x08, AUX PLL Post Divider = 0x1e
 168                          */
 169                         cx25840_write4(client, 0x108, 0x1e08040f);
 170
 171                         /*
 172                          * VID_PLL Fraction (register 0x10c) = 0x2be2fe
 173                          * 28636360 * 0xf.15f17f0/4 = 108 MHz
 174                          * 432 MHz pre-postdivide
 175                          */
 176
 177                         /*
 178                          * AUX_PLL Fraction = 0x12a0869
 179                          * 28636363 * 0x8.9504348/0x1e = 32000 * 256
 180                          * 246 MHz pre-postdivide
 181                          * FIXME 28636363 ref_freq doesn't match VID PLL ref
 182                          */
 183                         cx25840_write4(client, 0x110, 0x012a0869);
 184
 185                         /*
 186                          * SA_MCLK_SEL = 1
 187                          * SA_MCLK_DIV = 0x14 = 256/384 * AUX_PLL post dvivider
 188                          */
 189                         cx25840_write(client, 0x127, 0x54);
 190
 191                         if (is_cx2583x(state))
 192                                 break;
 193
 194                         /* src1_ctl */
 195                         /* 0x1.0000 = 32000/32000 */
 196                         cx25840_write4(client, 0x8f8, 0x08010000);
 197
 198                         /* src3/4/6_ctl */
 199                         /* 0x2.0000 = 2 * (32000/32000) */
 200                         cx25840_write4(client, 0x900, 0x08020000);
 201                         cx25840_write4(client, 0x904, 0x08020000);
 202                         cx25840_write4(client, 0x90c, 0x08020000);
 203                         break;
 204
 205                 case 44100:
 206                         /*
 207                          * VID_PLL Integer = 0x0f, VID_PLL Post Divider = 0x04
 208                          * AUX_PLL Integer = 0x09, AUX PLL Post Divider = 0x18
 209                          */
 210                         cx25840_write4(client, 0x108, 0x1809040f);
 211
 212                         /*
 213                          * VID_PLL Fraction (register 0x10c) = 0x2be2fe
 214                          * 28636360 * 0xf.15f17f0/4 = 108 MHz
 215                          * 432 MHz pre-postdivide
 216                          */
 217
 218                         /*
 219                          * AUX_PLL Fraction = 0x0ec6bd6
 220                          * 28636363 * 0x9.7635eb0/0x18 = 44100 * 256
 221                          * 271 MHz pre-postdivide
 222                          * FIXME 28636363 ref_freq doesn't match VID PLL ref
 223                          */
 224                         cx25840_write4(client, 0x110, 0x00ec6bd6);
 225
 226                         /*
 227                          * SA_MCLK_SEL = 1
 228                          * SA_MCLK_DIV = 0x10 = 256/384 * AUX_PLL post dvivider
 229                          */
 230                         cx25840_write(client, 0x127, 0x50);
 231
 232                         if (is_cx2583x(state))
 233                                 break;
 234
 235                         /* src1_ctl */
 236                         /* 0x1.60cd = 44100/32000 */
 237                         cx25840_write4(client, 0x8f8, 0x080160cd);
 238
 239                         /* src3/4/6_ctl */
 240                         /* 0x1.7385 = 2 * (32000/44100) */
 241                         cx25840_write4(client, 0x900, 0x08017385);
 242                         cx25840_write4(client, 0x904, 0x08017385);
 243                         cx25840_write4(client, 0x90c, 0x08017385);
 244                         break;
 245
 246                 case 48000:
 247                         /*
 248                          * VID_PLL Integer = 0x0f, VID_PLL Post Divider = 0x04
 249                          * AUX_PLL Integer = 0x0a, AUX PLL Post Divider = 0x18
 250                          */
 251                         cx25840_write4(client, 0x108, 0x180a040f);
 252
 253                         /*
 254                          * VID_PLL Fraction (register 0x10c) = 0x2be2fe
 255                          * 28636360 * 0xf.15f17f0/4 = 108 MHz
 256                          * 432 MHz pre-postdivide
 257                          */
 258
 259                         /*
 260                          * AUX_PLL Fraction = 0x098d6e5
 261                          * 28636363 * 0xa.4c6b728/0x18 = 48000 * 256
 262                          * 295 MHz pre-postdivide
 263                          * FIXME 28636363 ref_freq doesn't match VID PLL ref
 264                          */
 265                         cx25840_write4(client, 0x110, 0x0098d6e5);
 266
 267                         /*
 268                          * SA_MCLK_SEL = 1
 269                          * SA_MCLK_DIV = 0x10 = 256/384 * AUX_PLL post dvivider
 270                          */
 271                         cx25840_write(client, 0x127, 0x50);
 272
 273                         if (is_cx2583x(state))
 274                                 break;
 275
 276                         /* src1_ctl */
 277                         /* 0x1.8000 = 48000/32000 */
 278                         cx25840_write4(client, 0x8f8, 0x08018000);
 279
 280                         /* src3/4/6_ctl */
 281                         /* 0x1.5555 = 2 * (32000/48000) */
 282                         cx25840_write4(client, 0x900, 0x08015555);
 283                         cx25840_write4(client, 0x904, 0x08015555);
 284                         cx25840_write4(client, 0x90c, 0x08015555);
 285                         break;
 286                 }
 287         }
 288
 289         state->audclk_freq = freq;
 290
 291         return 0;
 292 }
 293
 294 static inline int cx25836_set_audclk_freq(struct i2c_client *client, u32 freq)
 295 {
 296         return cx25840_set_audclk_freq(client, freq);
 297 }
 298
 299 static int cx23885_set_audclk_freq(struct i2c_client *client, u32 freq)
 300 {
 301         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 302
 303         if (state->aud_input != CX25840_AUDIO_SERIAL) {
 304                 switch (freq) {
 305                 case 32000:
 306                 case 44100:
 307                 case 48000:
 308                         /* We don't have register values
 309                          * so avoid destroying registers. */
 310                         /* FIXME return -EINVAL; */
 311                         break;
 312                 }
 313         } else {
 314                 switch (freq) {
 315                 case 32000:
 316                 case 44100:
 317                         /* We don't have register values
 318                          * so avoid destroying registers. */
 319                         /* FIXME return -EINVAL; */
 320                         break;
 321
 322                 case 48000:
 323                         /* src1_ctl */
 324                         /* 0x1.867c = 48000 / (2 * 28636360/8 * 2/455) */
 325                         cx25840_write4(client, 0x8f8, 0x0801867c);
 326
 327                         /* src3/4/6_ctl */
 328                         /* 0x1.4faa = (4 * 28636360/8 * 2/455) / 48000 */
 329                         cx25840_write4(client, 0x900, 0x08014faa);
 330                         cx25840_write4(client, 0x904, 0x08014faa);
 331                         cx25840_write4(client, 0x90c, 0x08014faa);
 332                         break;
 333                 }
 334         }
 335
 336         state->audclk_freq = freq;
 337
 338         return 0;
 339 }
 340
 341 static int cx231xx_set_audclk_freq(struct i2c_client *client, u32 freq)
 342 {
 343         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 344
 345         if (state->aud_input != CX25840_AUDIO_SERIAL) {
 346                 switch (freq) {
 347                 case 32000:
 348                         /* src3/4/6_ctl */
 349                         /* 0x1.f77f = (4 * 28636360/8 * 2/455) / 32000 */
 350                         cx25840_write4(client, 0x900, 0x0801f77f);
 351                         cx25840_write4(client, 0x904, 0x0801f77f);
 352                         cx25840_write4(client, 0x90c, 0x0801f77f);
 353                         break;
 354
 355                 case 44100:
 356                         /* src3/4/6_ctl */
 357                         /* 0x1.6d59 = (4 * 28636360/8 * 2/455) / 44100 */
 358                         cx25840_write4(client, 0x900, 0x08016d59);
 359                         cx25840_write4(client, 0x904, 0x08016d59);
 360                         cx25840_write4(client, 0x90c, 0x08016d59);
 361                         break;
 362
 363                 case 48000:
 364                         /* src3/4/6_ctl */
 365                         /* 0x1.4faa = (4 * 28636360/8 * 2/455) / 48000 */
 366                         cx25840_write4(client, 0x900, 0x08014faa);
 367                         cx25840_write4(client, 0x904, 0x08014faa);
 368                         cx25840_write4(client, 0x90c, 0x08014faa);
 369                         break;
 370                 }
 371         } else {
 372                 switch (freq) {
 373                 /* FIXME These cases make different assumptions about audclk */
 374                 case 32000:
 375                         /* src1_ctl */
 376                         /* 0x1.0000 = 32000/32000 */
 377                         cx25840_write4(client, 0x8f8, 0x08010000);
 378
 379                         /* src3/4/6_ctl */
 380                         /* 0x2.0000 = 2 * (32000/32000) */
 381                         cx25840_write4(client, 0x900, 0x08020000);
 382                         cx25840_write4(client, 0x904, 0x08020000);
 383                         cx25840_write4(client, 0x90c, 0x08020000);
 384                         break;
 385
 386                 case 44100:
 387                         /* src1_ctl */
 388                         /* 0x1.60cd = 44100/32000 */
 389                         cx25840_write4(client, 0x8f8, 0x080160cd);
 390
 391                         /* src3/4/6_ctl */
 392                         /* 0x1.7385 = 2 * (32000/44100) */
 393                         cx25840_write4(client, 0x900, 0x08017385);
 394                         cx25840_write4(client, 0x904, 0x08017385);
 395                         cx25840_write4(client, 0x90c, 0x08017385);
 396                         break;
 397
 398                 case 48000:
 399                         /* src1_ctl */
 400                         /* 0x1.867c = 48000 / (2 * 28636360/8 * 2/455) */
 401                         cx25840_write4(client, 0x8f8, 0x0801867c);
 402
 403                         /* src3/4/6_ctl */
 404                         /* 0x1.4faa = (4 * 28636360/8 * 2/455) / 48000 */
 405                         cx25840_write4(client, 0x900, 0x08014faa);
 406                         cx25840_write4(client, 0x904, 0x08014faa);
 407                         cx25840_write4(client, 0x90c, 0x08014faa);
 408                         break;
 409                 }
 410         }
 411
 412         state->audclk_freq = freq;
 413
 414         return 0;
 415 }
 416
 417 static int set_audclk_freq(struct i2c_client *client, u32 freq)
 418 {
 419         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 420
 421         if (freq != 32000 && freq != 44100 && freq != 48000)
 422                 return -EINVAL;
 423
 424         if (is_cx231xx(state))
 425                 return cx231xx_set_audclk_freq(client, freq);
 426
 427         if (is_cx2388x(state))
 428                 return cx23885_set_audclk_freq(client, freq);
 429
 430         if (is_cx2583x(state))
 431                 return cx25836_set_audclk_freq(client, freq);
 432
 433         return cx25840_set_audclk_freq(client, freq);
 434 }
 435
 436 void cx25840_audio_set_path(struct i2c_client *client)
 437 {
 438         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 439
 440         /* assert soft reset */
 441         cx25840_and_or(client, 0x810, ~0x1, 0x01);
 442
 443         /* stop microcontroller */
 444         cx25840_and_or(client, 0x803, ~0x10, 0);
 445
 446         /* Mute everything to prevent the PFFT! */
 447         cx25840_write(client, 0x8d3, 0x1f);
 448
 449         if (state->aud_input == CX25840_AUDIO_SERIAL) {
 450                 /* Set Path1 to Serial Audio Input */
 451                 cx25840_write4(client, 0x8d0, 0x01011012);
 452
 453                 /* The microcontroller should not be started for the
 454                  * non-tuner inputs: autodetection is specific for
 455                  * TV audio. */
 456         } else {
 457                 /* Set Path1 to Analog Demod Main Channel */
 458                 cx25840_write4(client, 0x8d0, 0x1f063870);
 459         }
 460
 461         set_audclk_freq(client, state->audclk_freq);
 462
 463         if (state->aud_input != CX25840_AUDIO_SERIAL) {
 464                 /* When the microcontroller detects the
 465                  * audio format, it will unmute the lines */
 466                 cx25840_and_or(client, 0x803, ~0x10, 0x10);
 467         }
 468
 469         /* deassert soft reset */
 470         cx25840_and_or(client, 0x810, ~0x1, 0x00);
 471
 472         /* Ensure the controller is running when we exit */
 473         if (is_cx2388x(state) || is_cx231xx(state))
 474                 cx25840_and_or(client, 0x803, ~0x10, 0x10);
 475 }
 476
 477 static int get_volume(struct i2c_client *client)
 478 {
 479         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 480         int vol;
 481
 482         if (state->unmute_volume >= 0)
 483                 return state->unmute_volume;
 484
 485         /* Volume runs +18dB to -96dB in 1/2dB steps
 486          * change to fit the msp3400 -114dB to +12dB range */
 487
 488         /* check PATH1_VOLUME */
 489         vol = 228 - cx25840_read(client, 0x8d4);
 490         vol = (vol / 2) + 23;
 491         return vol << 9;
 492 }
 493
 494 static void set_volume(struct i2c_client *client, int volume)
 495 {
 496         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 497         int vol;
 498
 499         if (state->unmute_volume >= 0) {
 500                 state->unmute_volume = volume;
 501                 return;
 502         }
 503
 504         /* Convert the volume to msp3400 values (0-127) */
 505         vol = volume >> 9;
 506
 507         /* now scale it up to cx25840 values
 508          * -114dB to -96dB maps to 0
 509          * this should be 19, but in my testing that was 4dB too loud */
 510         if (vol <= 23) {
 511                 vol = 0;
 512         } else {
 513                 vol -= 23;
 514         }
 515
 516         /* PATH1_VOLUME */
 517         cx25840_write(client, 0x8d4, 228 - (vol * 2));
 518 }
 519
 520 static int get_bass(struct i2c_client *client)
 521 {
 522         /* bass is 49 steps +12dB to -12dB */
 523
 524         /* check PATH1_EQ_BASS_VOL */
 525         int bass = cx25840_read(client, 0x8d9) & 0x3f;
 526         bass = (((48 - bass) * 0xffff) + 47) / 48;
 527         return bass;
 528 }
 529
 530 static void set_bass(struct i2c_client *client, int bass)
 531 {
 532         /* PATH1_EQ_BASS_VOL */
 533         cx25840_and_or(client, 0x8d9, ~0x3f, 48 - (bass * 48 / 0xffff));
 534 }
 535
 536 static int get_treble(struct i2c_client *client)
 537 {
 538         /* treble is 49 steps +12dB to -12dB */
 539
 540         /* check PATH1_EQ_TREBLE_VOL */
 541         int treble = cx25840_read(client, 0x8db) & 0x3f;
 542         treble = (((48 - treble) * 0xffff) + 47) / 48;
 543         return treble;
 544 }
 545
 546 static void set_treble(struct i2c_client *client, int treble)
 547 {
 548         /* PATH1_EQ_TREBLE_VOL */
 549         cx25840_and_or(client, 0x8db, ~0x3f, 48 - (treble * 48 / 0xffff));
 550 }
 551
 552 static int get_balance(struct i2c_client *client)
 553 {
 554         /* balance is 7 bit, 0 to -96dB */
 555
 556         /* check PATH1_BAL_LEVEL */
 557         int balance = cx25840_read(client, 0x8d5) & 0x7f;
 558         /* check PATH1_BAL_LEFT */
 559         if ((cx25840_read(client, 0x8d5) & 0x80) == 0)
 560                 balance = 0x80 - balance;
 561         else
 562                 balance = 0x80 + balance;
 563         return balance << 8;
 564 }
 565
 566 static void set_balance(struct i2c_client *client, int balance)
 567 {
 568         int bal = balance >> 8;
 569         if (bal > 0x80) {
 570                 /* PATH1_BAL_LEFT */
 571                 cx25840_and_or(client, 0x8d5, 0x7f, 0x80);
 572                 /* PATH1_BAL_LEVEL */
 573                 cx25840_and_or(client, 0x8d5, ~0x7f, bal & 0x7f);
 574         } else {
 575                 /* PATH1_BAL_LEFT */
 576                 cx25840_and_or(client, 0x8d5, 0x7f, 0x00);
 577                 /* PATH1_BAL_LEVEL */
 578                 cx25840_and_or(client, 0x8d5, ~0x7f, 0x80 - bal);
 579         }
 580 }
 581
 582 static int get_mute(struct i2c_client *client)
 583 {
 584         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 585
 586         return state->unmute_volume >= 0;
 587 }
 588
 589 static void set_mute(struct i2c_client *client, int mute)
 590 {
 591         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 592
 593         if (mute && state->unmute_volume == -1) {
 594                 int vol = get_volume(client);
 595
 596                 set_volume(client, 0);
 597                 state->unmute_volume = vol;
 598         }
 599         else if (!mute && state->unmute_volume != -1) {
 600                 int vol = state->unmute_volume;
 601
 602                 state->unmute_volume = -1;
 603                 set_volume(client, vol);
 604         }
 605 }
 606
 607 int cx25840_s_clock_freq(struct v4l2_subdev *sd, u32 freq)
 608 {
 609         struct i2c_client *client = v4l2_get_subdevdata(sd);
 610         struct cx25840_state *state = to_state(sd);
 611         int retval;
 612
 613         if (!is_cx2583x(state))
 614                 cx25840_and_or(client, 0x810, ~0x1, 1);
 615         if (state->aud_input != CX25840_AUDIO_SERIAL) {
 616                 cx25840_and_or(client, 0x803, ~0x10, 0);
 617                 cx25840_write(client, 0x8d3, 0x1f);
 618         }
 619         retval = set_audclk_freq(client, freq);
 620         if (state->aud_input != CX25840_AUDIO_SERIAL)
 621                 cx25840_and_or(client, 0x803, ~0x10, 0x10);
 622         if (!is_cx2583x(state))
 623                 cx25840_and_or(client, 0x810, ~0x1, 0);
 624         return retval;
 625 }
 626
 627 int cx25840_audio_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 628 {
 629         struct i2c_client *client = v4l2_get_subdevdata(sd);
 630
 631         switch (ctrl->id) {
 632         case V4L2_CID_AUDIO_VOLUME:
 633                 ctrl->value = get_volume(client);
 634                 break;
 635         case V4L2_CID_AUDIO_BASS:
 636                 ctrl->value = get_bass(client);
 637                 break;
 638         case V4L2_CID_AUDIO_TREBLE:
 639                 ctrl->value = get_treble(client);
 640                 break;
 641         case V4L2_CID_AUDIO_BALANCE:
 642                 ctrl->value = get_balance(client);
 643                 break;
 644         case V4L2_CID_AUDIO_MUTE:
 645                 ctrl->value = get_mute(client);
 646                 break;
 647         default:
 648                 return -EINVAL;
 649         }
 650         return 0;
 651 }
 652
 653 int cx25840_audio_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 654 {
 655         struct i2c_client *client = v4l2_get_subdevdata(sd);
 656
 657         switch (ctrl->id) {
 658         case V4L2_CID_AUDIO_VOLUME:
 659                 set_volume(client, ctrl->value);
 660                 break;
 661         case V4L2_CID_AUDIO_BASS:
 662                 set_bass(client, ctrl->value);
 663                 break;
 664         case V4L2_CID_AUDIO_TREBLE:
 665                 set_treble(client, ctrl->value);
 666                 break;
 667         case V4L2_CID_AUDIO_BALANCE:
 668                 set_balance(client, ctrl->value);
 669                 break;
 670         case V4L2_CID_AUDIO_MUTE:
 671                 set_mute(client, ctrl->value);
 672                 break;
 673         default:
 674                 return -EINVAL;
 675         }
 676         return 0;
 677 }