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

   1 /* cx25840 - Conexant CX25840 audio/video decoder driver
   2  *
   3  * Copyright (C) 2004 Ulf Eklund
   4  *
   5  * Based on the saa7115 driver and on the first verison of Chris Kennedy's
   6  * cx25840 driver.
   7  *
   8  * Changes by Tyler Trafford <tatrafford@comcast.net>
   9  *    - cleanup/rewrite for V4L2 API (2005)
  10  *
  11  * VBI support by Hans Verkuil <hverkuil@xs4all.nl>.
  12  *
  13  * NTSC sliced VBI support by Christopher Neufeld <television@cneufeld.ca>
  14  * with additional fixes by Hans Verkuil <hverkuil@xs4all.nl>.
  15  *
  16  * CX23885 support by Steven Toth <stoth@linuxtv.org>.
  17  *
  18  * This program is free software; you can redistribute it and/or
  19  * modify it under the terms of the GNU General Public License
  20  * as published by the Free Software Foundation; either version 2
  21  * of the License, or (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  31  */
  32
  33
  34 #include <linux/kernel.h>
  35 #include <linux/module.h>
  36 #include <linux/slab.h>
  37 #include <linux/videodev2.h>
  38 #include <linux/i2c.h>
  39 #include <linux/delay.h>
  40 #include <media/v4l2-common.h>
  41 #include <media/v4l2-chip-ident.h>
  42 #include <media/v4l2-i2c-drv.h>
  43 #include <media/cx25840.h>
  44
  45 #include "cx25840-core.h"
  46
  47 MODULE_DESCRIPTION("Conexant CX25840 audio/video decoder driver");
  48 MODULE_AUTHOR("Ulf Eklund, Chris Kennedy, Hans Verkuil, Tyler Trafford");
  49 MODULE_LICENSE("GPL");
  50
  51 static int cx25840_debug;
  52
  53 module_param_named(debug,cx25840_debug, int, 0644);
  54
  55 MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
  56
  57
  58 /* ----------------------------------------------------------------------- */
  59
  60 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
  61 {
  62         u8 buffer[3];
  63         buffer[0] = addr >> 8;
  64         buffer[1] = addr & 0xff;
  65         buffer[2] = value;
  66         return i2c_master_send(client, buffer, 3);
  67 }
  68
  69 int cx25840_write4(struct i2c_client *client, u16 addr, u32 value)
  70 {
  71         u8 buffer[6];
  72         buffer[0] = addr >> 8;
  73         buffer[1] = addr & 0xff;
  74         buffer[2] = value & 0xff;
  75         buffer[3] = (value >> 8) & 0xff;
  76         buffer[4] = (value >> 16) & 0xff;
  77         buffer[5] = value >> 24;
  78         return i2c_master_send(client, buffer, 6);
  79 }
  80
  81 u8 cx25840_read(struct i2c_client * client, u16 addr)
  82 {
  83         u8 buffer[2];
  84         buffer[0] = addr >> 8;
  85         buffer[1] = addr & 0xff;
  86
  87         if (i2c_master_send(client, buffer, 2) < 2)
  88                 return 0;
  89
  90         if (i2c_master_recv(client, buffer, 1) < 1)
  91                 return 0;
  92
  93         return buffer[0];
  94 }
  95
  96 u32 cx25840_read4(struct i2c_client * client, u16 addr)
  97 {
  98         u8 buffer[4];
  99         buffer[0] = addr >> 8;
 100         buffer[1] = addr & 0xff;
 101
 102         if (i2c_master_send(client, buffer, 2) < 2)
 103                 return 0;
 104
 105         if (i2c_master_recv(client, buffer, 4) < 4)
 106                 return 0;
 107
 108         return (buffer[3] << 24) | (buffer[2] << 16) |
 109             (buffer[1] << 8) | buffer[0];
 110 }
 111
 112 int cx25840_and_or(struct i2c_client *client, u16 addr, unsigned and_mask,
 113                    u8 or_value)
 114 {
 115         return cx25840_write(client, addr,
 116                              (cx25840_read(client, addr) & and_mask) |
 117                              or_value);
 118 }
 119
 120 /* ----------------------------------------------------------------------- */
 121
 122 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
 123                                                 enum cx25840_audio_input aud_input);
 124
 125 /* ----------------------------------------------------------------------- */
 126
 127 static void init_dll1(struct i2c_client *client)
 128 {
 129         /* This is the Hauppauge sequence used to
 130          * initialize the Delay Lock Loop 1 (ADC DLL). */
 131         cx25840_write(client, 0x159, 0x23);
 132         cx25840_write(client, 0x15a, 0x87);
 133         cx25840_write(client, 0x15b, 0x06);
 134         udelay(10);
 135         cx25840_write(client, 0x159, 0xe1);
 136         udelay(10);
 137         cx25840_write(client, 0x15a, 0x86);
 138         cx25840_write(client, 0x159, 0xe0);
 139         cx25840_write(client, 0x159, 0xe1);
 140         cx25840_write(client, 0x15b, 0x10);
 141 }
 142
 143 static void init_dll2(struct i2c_client *client)
 144 {
 145         /* This is the Hauppauge sequence used to
 146          * initialize the Delay Lock Loop 2 (ADC DLL). */
 147         cx25840_write(client, 0x15d, 0xe3);
 148         cx25840_write(client, 0x15e, 0x86);
 149         cx25840_write(client, 0x15f, 0x06);
 150         udelay(10);
 151         cx25840_write(client, 0x15d, 0xe1);
 152         cx25840_write(client, 0x15d, 0xe0);
 153         cx25840_write(client, 0x15d, 0xe1);
 154 }
 155
 156 static void cx25836_initialize(struct i2c_client *client)
 157 {
 158         /* reset configuration is described on page 3-77 of the CX25836 datasheet */
 159         /* 2. */
 160         cx25840_and_or(client, 0x000, ~0x01, 0x01);
 161         cx25840_and_or(client, 0x000, ~0x01, 0x00);
 162         /* 3a. */
 163         cx25840_and_or(client, 0x15a, ~0x70, 0x00);
 164         /* 3b. */
 165         cx25840_and_or(client, 0x15b, ~0x1e, 0x06);
 166         /* 3c. */
 167         cx25840_and_or(client, 0x159, ~0x02, 0x02);
 168         /* 3d. */
 169         udelay(10);
 170         /* 3e. */
 171         cx25840_and_or(client, 0x159, ~0x02, 0x00);
 172         /* 3f. */
 173         cx25840_and_or(client, 0x159, ~0xc0, 0xc0);
 174         /* 3g. */
 175         cx25840_and_or(client, 0x159, ~0x01, 0x00);
 176         cx25840_and_or(client, 0x159, ~0x01, 0x01);
 177         /* 3h. */
 178         cx25840_and_or(client, 0x15b, ~0x1e, 0x10);
 179 }
 180
 181 static void cx25840_work_handler(struct work_struct *work)
 182 {
 183         struct cx25840_state *state = container_of(work, struct cx25840_state, fw_work);
 184         cx25840_loadfw(state->c);
 185         wake_up(&state->fw_wait);
 186 }
 187
 188 static void cx25840_initialize(struct i2c_client *client)
 189 {
 190         DEFINE_WAIT(wait);
 191         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 192         struct workqueue_struct *q;
 193
 194         /* datasheet startup in numbered steps, refer to page 3-77 */
 195         /* 2. */
 196         cx25840_and_or(client, 0x803, ~0x10, 0x00);
 197         /* The default of this register should be 4, but I get 0 instead.
 198          * Set this register to 4 manually. */
 199         cx25840_write(client, 0x000, 0x04);
 200         /* 3. */
 201         init_dll1(client);
 202         init_dll2(client);
 203         cx25840_write(client, 0x136, 0x0a);
 204         /* 4. */
 205         cx25840_write(client, 0x13c, 0x01);
 206         cx25840_write(client, 0x13c, 0x00);
 207         /* 5. */
 208         /* Do the firmware load in a work handler to prevent.
 209            Otherwise the kernel is blocked waiting for the
 210            bit-banging i2c interface to finish uploading the
 211            firmware. */
 212         INIT_WORK(&state->fw_work, cx25840_work_handler);
 213         init_waitqueue_head(&state->fw_wait);
 214         q = create_singlethread_workqueue("cx25840_fw");
 215         prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
 216         queue_work(q, &state->fw_work);
 217         schedule();
 218         finish_wait(&state->fw_wait, &wait);
 219         destroy_workqueue(q);
 220
 221         /* 6. */
 222         cx25840_write(client, 0x115, 0x8c);
 223         cx25840_write(client, 0x116, 0x07);
 224         cx25840_write(client, 0x118, 0x02);
 225         /* 7. */
 226         cx25840_write(client, 0x4a5, 0x80);
 227         cx25840_write(client, 0x4a5, 0x00);
 228         cx25840_write(client, 0x402, 0x00);
 229         /* 8. */
 230         cx25840_and_or(client, 0x401, ~0x18, 0);
 231         cx25840_and_or(client, 0x4a2, ~0x10, 0x10);
 232         /* steps 8c and 8d are done in change_input() */
 233         /* 10. */
 234         cx25840_write(client, 0x8d3, 0x1f);
 235         cx25840_write(client, 0x8e3, 0x03);
 236
 237         cx25840_std_setup(client);
 238
 239         /* trial and error says these are needed to get audio */
 240         cx25840_write(client, 0x914, 0xa0);
 241         cx25840_write(client, 0x918, 0xa0);
 242         cx25840_write(client, 0x919, 0x01);
 243
 244         /* stereo prefered */
 245         cx25840_write(client, 0x809, 0x04);
 246         /* AC97 shift */
 247         cx25840_write(client, 0x8cf, 0x0f);
 248
 249         /* (re)set input */
 250         set_input(client, state->vid_input, state->aud_input);
 251
 252         /* start microcontroller */
 253         cx25840_and_or(client, 0x803, ~0x10, 0x10);
 254 }
 255
 256 static void cx23885_initialize(struct i2c_client *client)
 257 {
 258         DEFINE_WAIT(wait);
 259         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 260         struct workqueue_struct *q;
 261
 262         /* Internal Reset */
 263         cx25840_and_or(client, 0x102, ~0x01, 0x01);
 264         cx25840_and_or(client, 0x102, ~0x01, 0x00);
 265
 266         /* Stop microcontroller */
 267         cx25840_and_or(client, 0x803, ~0x10, 0x00);
 268
 269         /* DIF in reset? */
 270         cx25840_write(client, 0x398, 0);
 271
 272         /* Trust the default xtal, no division */
 273         /* This changes for the cx23888 products */
 274         cx25840_write(client, 0x2, 0x76);
 275
 276         /* Bring down the regulator for AUX clk */
 277         cx25840_write(client, 0x1, 0x40);
 278
 279         /* Sys PLL frac */
 280         cx25840_write4(client, 0x11c, 0x01d1744c);
 281
 282         /* Sys PLL int */
 283         cx25840_write4(client, 0x118, 0x00000416);
 284
 285         /* Disable DIF bypass */
 286         cx25840_write4(client, 0x33c, 0x00000001);
 287
 288         /* DIF Src phase inc */
 289         cx25840_write4(client, 0x340, 0x0df7df83);
 290
 291         /* Vid PLL frac */
 292         cx25840_write4(client, 0x10c, 0x01b6db7b);
 293
 294         /* Vid PLL int */
 295         cx25840_write4(client, 0x108, 0x00000512);
 296
 297         /* Luma */
 298         cx25840_write4(client, 0x414, 0x00107d12);
 299
 300         /* Chroma */
 301         cx25840_write4(client, 0x420, 0x3d008282);
 302
 303         /* Aux PLL frac */
 304         cx25840_write4(client, 0x114, 0x017dbf48);
 305
 306         /* Aux PLL int */
 307         cx25840_write4(client, 0x110, 0x000a030e);
 308
 309         /* ADC2 input select */
 310         cx25840_write(client, 0x102, 0x10);
 311
 312         /* VIN1 & VIN5 */
 313         cx25840_write(client, 0x103, 0x11);
 314
 315         /* Enable format auto detect */
 316         cx25840_write(client, 0x400, 0);
 317         /* Fast subchroma lock */
 318         /* White crush, Chroma AGC & Chroma Killer enabled */
 319         cx25840_write(client, 0x401, 0xe8);
 320
 321         /* Select AFE clock pad output source */
 322         cx25840_write(client, 0x144, 0x05);
 323
 324         /* Do the firmware load in a work handler to prevent.
 325            Otherwise the kernel is blocked waiting for the
 326            bit-banging i2c interface to finish uploading the
 327            firmware. */
 328         INIT_WORK(&state->fw_work, cx25840_work_handler);
 329         init_waitqueue_head(&state->fw_wait);
 330         q = create_singlethread_workqueue("cx25840_fw");
 331         prepare_to_wait(&state->fw_wait, &wait, TASK_UNINTERRUPTIBLE);
 332         queue_work(q, &state->fw_work);
 333         schedule();
 334         finish_wait(&state->fw_wait, &wait);
 335         destroy_workqueue(q);
 336
 337         cx25840_std_setup(client);
 338
 339         /* (re)set input */
 340         set_input(client, state->vid_input, state->aud_input);
 341
 342         /* start microcontroller */
 343         cx25840_and_or(client, 0x803, ~0x10, 0x10);
 344 }
 345
 346 /* ----------------------------------------------------------------------- */
 347
 348 void cx25840_std_setup(struct i2c_client *client)
 349 {
 350         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 351         v4l2_std_id std = state->std;
 352         int hblank, hactive, burst, vblank, vactive, sc;
 353         int vblank656, src_decimation;
 354         int luma_lpf, uv_lpf, comb;
 355         u32 pll_int, pll_frac, pll_post;
 356
 357         /* datasheet startup, step 8d */
 358         if (std & ~V4L2_STD_NTSC)
 359                 cx25840_write(client, 0x49f, 0x11);
 360         else
 361                 cx25840_write(client, 0x49f, 0x14);
 362
 363         if (std & V4L2_STD_625_50) {
 364                 hblank = 132;
 365                 hactive = 720;
 366                 burst = 93;
 367                 vblank = 36;
 368                 vactive = 580;
 369                 vblank656 = 40;
 370                 src_decimation = 0x21f;
 371                 luma_lpf = 2;
 372
 373                 if (std & V4L2_STD_SECAM) {
 374                         uv_lpf = 0;
 375                         comb = 0;
 376                         sc = 0x0a425f;
 377                 } else if (std == V4L2_STD_PAL_Nc) {
 378                         uv_lpf = 1;
 379                         comb = 0x20;
 380                         sc = 556453;
 381                 } else {
 382                         uv_lpf = 1;
 383                         comb = 0x20;
 384                         sc = 688739;
 385                 }
 386         } else {
 387                 hactive = 720;
 388                 hblank = 122;
 389                 vactive = 487;
 390                 luma_lpf = 1;
 391                 uv_lpf = 1;
 392
 393                 src_decimation = 0x21f;
 394                 if (std == V4L2_STD_PAL_60) {
 395                         vblank = 26;
 396                         vblank656 = 26;
 397                         burst = 0x5b;
 398                         luma_lpf = 2;
 399                         comb = 0x20;
 400                         sc = 688739;
 401                 } else if (std == V4L2_STD_PAL_M) {
 402                         vblank = 20;
 403                         vblank656 = 24;
 404                         burst = 0x61;
 405                         comb = 0x20;
 406                         sc = 555452;
 407                 } else {
 408                         vblank = 26;
 409                         vblank656 = 26;
 410                         burst = 0x5b;
 411                         comb = 0x66;
 412                         sc = 556063;
 413                 }
 414         }
 415
 416         /* DEBUG: Displays configured PLL frequency */
 417         pll_int = cx25840_read(client, 0x108);
 418         pll_frac = cx25840_read4(client, 0x10c) & 0x1ffffff;
 419         pll_post = cx25840_read(client, 0x109);
 420         v4l_dbg(1, cx25840_debug, client,
 421                                 "PLL regs = int: %u, frac: %u, post: %u\n",
 422                                 pll_int, pll_frac, pll_post);
 423
 424         if (pll_post) {
 425                 int fin, fsc;
 426                 int pll = (28636363L * ((((u64)pll_int) << 25L) + pll_frac)) >> 25L;
 427
 428                 pll /= pll_post;
 429                 v4l_dbg(1, cx25840_debug, client, "PLL = %d.%06d MHz\n",
 430                                 pll / 1000000, pll % 1000000);
 431                 v4l_dbg(1, cx25840_debug, client, "PLL/8 = %d.%06d MHz\n",
 432                                 pll / 8000000, (pll / 8) % 1000000);
 433
 434                 fin = ((u64)src_decimation * pll) >> 12;
 435                 v4l_dbg(1, cx25840_debug, client,
 436                                 "ADC Sampling freq = %d.%06d MHz\n",
 437                                 fin / 1000000, fin % 1000000);
 438
 439                 fsc = (((u64)sc) * pll) >> 24L;
 440                 v4l_dbg(1, cx25840_debug, client,
 441                                 "Chroma sub-carrier freq = %d.%06d MHz\n",
 442                                 fsc / 1000000, fsc % 1000000);
 443
 444                 v4l_dbg(1, cx25840_debug, client, "hblank %i, hactive %i, "
 445                         "vblank %i, vactive %i, vblank656 %i, src_dec %i, "
 446                         "burst 0x%02x, luma_lpf %i, uv_lpf %i, comb 0x%02x, "
 447                         "sc 0x%06x\n",
 448                         hblank, hactive, vblank, vactive, vblank656,
 449                         src_decimation, burst, luma_lpf, uv_lpf, comb, sc);
 450         }
 451
 452         /* Sets horizontal blanking delay and active lines */
 453         cx25840_write(client, 0x470, hblank);
 454         cx25840_write(client, 0x471,
 455                         0xff & (((hblank >> 8) & 0x3) | (hactive << 4)));
 456         cx25840_write(client, 0x472, hactive >> 4);
 457
 458         /* Sets burst gate delay */
 459         cx25840_write(client, 0x473, burst);
 460
 461         /* Sets vertical blanking delay and active duration */
 462         cx25840_write(client, 0x474, vblank);
 463         cx25840_write(client, 0x475,
 464                         0xff & (((vblank >> 8) & 0x3) | (vactive << 4)));
 465         cx25840_write(client, 0x476, vactive >> 4);
 466         cx25840_write(client, 0x477, vblank656);
 467
 468         /* Sets src decimation rate */
 469         cx25840_write(client, 0x478, 0xff & src_decimation);
 470         cx25840_write(client, 0x479, 0xff & (src_decimation >> 8));
 471
 472         /* Sets Luma and UV Low pass filters */
 473         cx25840_write(client, 0x47a, luma_lpf << 6 | ((uv_lpf << 4) & 0x30));
 474
 475         /* Enables comb filters */
 476         cx25840_write(client, 0x47b, comb);
 477
 478         /* Sets SC Step*/
 479         cx25840_write(client, 0x47c, sc);
 480         cx25840_write(client, 0x47d, 0xff & sc >> 8);
 481         cx25840_write(client, 0x47e, 0xff & sc >> 16);
 482
 483         /* Sets VBI parameters */
 484         if (std & V4L2_STD_625_50) {
 485                 cx25840_write(client, 0x47f, 0x01);
 486                 state->vbi_line_offset = 5;
 487         } else {
 488                 cx25840_write(client, 0x47f, 0x00);
 489                 state->vbi_line_offset = 8;
 490         }
 491 }
 492
 493 /* ----------------------------------------------------------------------- */
 494
 495 static void input_change(struct i2c_client *client)
 496 {
 497         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 498         v4l2_std_id std = state->std;
 499
 500         /* Follow step 8c and 8d of section 3.16 in the cx25840 datasheet */
 501         if (std & V4L2_STD_SECAM) {
 502                 cx25840_write(client, 0x402, 0);
 503         }
 504         else {
 505                 cx25840_write(client, 0x402, 0x04);
 506                 cx25840_write(client, 0x49f, (std & V4L2_STD_NTSC) ? 0x14 : 0x11);
 507         }
 508         cx25840_and_or(client, 0x401, ~0x60, 0);
 509         cx25840_and_or(client, 0x401, ~0x60, 0x60);
 510         cx25840_and_or(client, 0x810, ~0x01, 1);
 511
 512         if (state->radio) {
 513                 cx25840_write(client, 0x808, 0xf9);
 514                 cx25840_write(client, 0x80b, 0x00);
 515         }
 516         else if (std & V4L2_STD_525_60) {
 517                 /* Certain Hauppauge PVR150 models have a hardware bug
 518                    that causes audio to drop out. For these models the
 519                    audio standard must be set explicitly.
 520                    To be precise: it affects cards with tuner models
 521                    85, 99 and 112 (model numbers from tveeprom). */
 522                 int hw_fix = state->pvr150_workaround;
 523
 524                 if (std == V4L2_STD_NTSC_M_JP) {
 525                         /* Japan uses EIAJ audio standard */
 526                         cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
 527                 } else if (std == V4L2_STD_NTSC_M_KR) {
 528                         /* South Korea uses A2 audio standard */
 529                         cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
 530                 } else {
 531                         /* Others use the BTSC audio standard */
 532                         cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
 533                 }
 534                 cx25840_write(client, 0x80b, 0x00);
 535         } else if (std & V4L2_STD_PAL) {
 536                 /* Follow tuner change procedure for PAL */
 537                 cx25840_write(client, 0x808, 0xff);
 538                 cx25840_write(client, 0x80b, 0x10);
 539         } else if (std & V4L2_STD_SECAM) {
 540                 /* Select autodetect for SECAM */
 541                 cx25840_write(client, 0x808, 0xff);
 542                 cx25840_write(client, 0x80b, 0x10);
 543         }
 544
 545         cx25840_and_or(client, 0x810, ~0x01, 0);
 546 }
 547
 548 static int set_input(struct i2c_client *client, enum cx25840_video_input vid_input,
 549                                                 enum cx25840_audio_input aud_input)
 550 {
 551         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 552         u8 is_composite = (vid_input >= CX25840_COMPOSITE1 &&
 553                            vid_input <= CX25840_COMPOSITE8);
 554         u8 reg;
 555
 556         v4l_dbg(1, cx25840_debug, client,
 557                 "decoder set video input %d, audio input %d\n",
 558                 vid_input, aud_input);
 559
 560         if (vid_input >= CX25840_VIN1_CH1) {
 561                 v4l_dbg(1, cx25840_debug, client, "vid_input 0x%x\n",
 562                         vid_input);
 563                 reg = vid_input & 0xff;
 564                 if ((vid_input & CX25840_SVIDEO_ON) == CX25840_SVIDEO_ON)
 565                         is_composite = 0;
 566                 else
 567                         is_composite = 1;
 568
 569                 v4l_dbg(1, cx25840_debug, client, "mux cfg 0x%x comp=%d\n",
 570                         reg, is_composite);
 571         } else
 572         if (is_composite) {
 573                 reg = 0xf0 + (vid_input - CX25840_COMPOSITE1);
 574         } else {
 575                 int luma = vid_input & 0xf0;
 576                 int chroma = vid_input & 0xf00;
 577
 578                 if ((vid_input & ~0xff0) ||
 579                     luma < CX25840_SVIDEO_LUMA1 || luma > CX25840_SVIDEO_LUMA8 ||
 580                     chroma < CX25840_SVIDEO_CHROMA4 || chroma > CX25840_SVIDEO_CHROMA8) {
 581                         v4l_err(client, "0x%04x is not a valid video input!\n",
 582                                 vid_input);
 583                         return -EINVAL;
 584                 }
 585                 reg = 0xf0 + ((luma - CX25840_SVIDEO_LUMA1) >> 4);
 586                 if (chroma >= CX25840_SVIDEO_CHROMA7) {
 587                         reg &= 0x3f;
 588                         reg |= (chroma - CX25840_SVIDEO_CHROMA7) >> 2;
 589                 } else {
 590                         reg &= 0xcf;
 591                         reg |= (chroma - CX25840_SVIDEO_CHROMA4) >> 4;
 592                 }
 593         }
 594
 595         /* The caller has previously prepared the correct routing
 596          * configuration in reg (for the cx23885) so we have no
 597          * need to attempt to flip bits for earlier av decoders.
 598          */
 599         if (!state->is_cx23885) {
 600                 switch (aud_input) {
 601                 case CX25840_AUDIO_SERIAL:
 602                         /* do nothing, use serial audio input */
 603                         break;
 604                 case CX25840_AUDIO4: reg &= ~0x30; break;
 605                 case CX25840_AUDIO5: reg &= ~0x30; reg |= 0x10; break;
 606                 case CX25840_AUDIO6: reg &= ~0x30; reg |= 0x20; break;
 607                 case CX25840_AUDIO7: reg &= ~0xc0; break;
 608                 case CX25840_AUDIO8: reg &= ~0xc0; reg |= 0x40; break;
 609
 610                 default:
 611                         v4l_err(client, "0x%04x is not a valid audio input!\n",
 612                                 aud_input);
 613                         return -EINVAL;
 614                 }
 615         }
 616
 617         cx25840_write(client, 0x103, reg);
 618
 619         /* Set INPUT_MODE to Composite (0) or S-Video (1) */
 620         cx25840_and_or(client, 0x401, ~0x6, is_composite ? 0 : 0x02);
 621
 622         if (!state->is_cx23885) {
 623                 /* Set CH_SEL_ADC2 to 1 if input comes from CH3 */
 624                 cx25840_and_or(client, 0x102, ~0x2, (reg & 0x80) == 0 ? 2 : 0);
 625                 /* Set DUAL_MODE_ADC2 to 1 if input comes from both CH2&CH3 */
 626                 if ((reg & 0xc0) != 0xc0 && (reg & 0x30) != 0x30)
 627                         cx25840_and_or(client, 0x102, ~0x4, 4);
 628                 else
 629                         cx25840_and_or(client, 0x102, ~0x4, 0);
 630         } else {
 631                 if (is_composite)
 632                         /* ADC2 input select channel 2 */
 633                         cx25840_and_or(client, 0x102, ~0x2, 0);
 634                 else
 635                         /* ADC2 input select channel 3 */
 636                         cx25840_and_or(client, 0x102, ~0x2, 2);
 637         }
 638
 639         state->vid_input = vid_input;
 640         state->aud_input = aud_input;
 641         if (!state->is_cx25836) {
 642                 cx25840_audio_set_path(client);
 643                 input_change(client);
 644         }
 645
 646         if (state->is_cx23885) {
 647                 /* Audio channel 1 src : Parallel 1 */
 648                 cx25840_write(client, 0x124, 0x03);
 649
 650                 /* Select AFE clock pad output source */
 651                 cx25840_write(client, 0x144, 0x05);
 652
 653                 /* I2S_IN_CTL: I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1 */
 654                 cx25840_write(client, 0x914, 0xa0);
 655
 656                 /* I2S_OUT_CTL:
 657                  * I2S_IN_SONY_MODE, LEFT SAMPLE on WS=1
 658                  * I2S_OUT_MASTER_MODE = Master
 659                  */
 660                 cx25840_write(client, 0x918, 0xa0);
 661                 cx25840_write(client, 0x919, 0x01);
 662         }
 663
 664         return 0;
 665 }
 666
 667 /* ----------------------------------------------------------------------- */
 668
 669 static int set_v4lstd(struct i2c_client *client)
 670 {
 671         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 672         u8 fmt = 0;     /* zero is autodetect */
 673         u8 pal_m = 0;
 674
 675         /* First tests should be against specific std */
 676         if (state->std == V4L2_STD_NTSC_M_JP) {
 677                 fmt = 0x2;
 678         } else if (state->std == V4L2_STD_NTSC_443) {
 679                 fmt = 0x3;
 680         } else if (state->std == V4L2_STD_PAL_M) {
 681                 pal_m = 1;
 682                 fmt = 0x5;
 683         } else if (state->std == V4L2_STD_PAL_N) {
 684                 fmt = 0x6;
 685         } else if (state->std == V4L2_STD_PAL_Nc) {
 686                 fmt = 0x7;
 687         } else if (state->std == V4L2_STD_PAL_60) {
 688                 fmt = 0x8;
 689         } else {
 690                 /* Then, test against generic ones */
 691                 if (state->std & V4L2_STD_NTSC)
 692                         fmt = 0x1;
 693                 else if (state->std & V4L2_STD_PAL)
 694                         fmt = 0x4;
 695                 else if (state->std & V4L2_STD_SECAM)
 696                         fmt = 0xc;
 697         }
 698
 699         v4l_dbg(1, cx25840_debug, client, "changing video std to fmt %i\n",fmt);
 700
 701         /* Follow step 9 of section 3.16 in the cx25840 datasheet.
 702            Without this PAL may display a vertical ghosting effect.
 703            This happens for example with the Yuan MPC622. */
 704         if (fmt >= 4 && fmt < 8) {
 705                 /* Set format to NTSC-M */
 706                 cx25840_and_or(client, 0x400, ~0xf, 1);
 707                 /* Turn off LCOMB */
 708                 cx25840_and_or(client, 0x47b, ~6, 0);
 709         }
 710         cx25840_and_or(client, 0x400, ~0xf, fmt);
 711         cx25840_and_or(client, 0x403, ~0x3, pal_m);
 712         cx25840_std_setup(client);
 713         if (!state->is_cx25836)
 714                 input_change(client);
 715         return 0;
 716 }
 717
 718 /* ----------------------------------------------------------------------- */
 719
 720 static int cx25840_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 721 {
 722         struct cx25840_state *state = to_state(sd);
 723         struct i2c_client *client = v4l2_get_subdevdata(sd);
 724
 725         switch (ctrl->id) {
 726         case CX25840_CID_ENABLE_PVR150_WORKAROUND:
 727                 state->pvr150_workaround = ctrl->value;
 728                 set_input(client, state->vid_input, state->aud_input);
 729                 break;
 730
 731         case V4L2_CID_BRIGHTNESS:
 732                 if (ctrl->value < 0 || ctrl->value > 255) {
 733                         v4l_err(client, "invalid brightness setting %d\n",
 734                                     ctrl->value);
 735                         return -ERANGE;
 736                 }
 737
 738                 cx25840_write(client, 0x414, ctrl->value - 128);
 739                 break;
 740
 741         case V4L2_CID_CONTRAST:
 742                 if (ctrl->value < 0 || ctrl->value > 127) {
 743                         v4l_err(client, "invalid contrast setting %d\n",
 744                                     ctrl->value);
 745                         return -ERANGE;
 746                 }
 747
 748                 cx25840_write(client, 0x415, ctrl->value << 1);
 749                 break;
 750
 751         case V4L2_CID_SATURATION:
 752                 if (ctrl->value < 0 || ctrl->value > 127) {
 753                         v4l_err(client, "invalid saturation setting %d\n",
 754                                     ctrl->value);
 755                         return -ERANGE;
 756                 }
 757
 758                 cx25840_write(client, 0x420, ctrl->value << 1);
 759                 cx25840_write(client, 0x421, ctrl->value << 1);
 760                 break;
 761
 762         case V4L2_CID_HUE:
 763                 if (ctrl->value < -128 || ctrl->value > 127) {
 764                         v4l_err(client, "invalid hue setting %d\n", ctrl->value);
 765                         return -ERANGE;
 766                 }
 767
 768                 cx25840_write(client, 0x422, ctrl->value);
 769                 break;
 770
 771         case V4L2_CID_AUDIO_VOLUME:
 772         case V4L2_CID_AUDIO_BASS:
 773         case V4L2_CID_AUDIO_TREBLE:
 774         case V4L2_CID_AUDIO_BALANCE:
 775         case V4L2_CID_AUDIO_MUTE:
 776                 if (state->is_cx25836)
 777                         return -EINVAL;
 778                 return cx25840_audio_s_ctrl(sd, ctrl);
 779
 780         default:
 781                 return -EINVAL;
 782         }
 783
 784         return 0;
 785 }
 786
 787 static int cx25840_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
 788 {
 789         struct cx25840_state *state = to_state(sd);
 790         struct i2c_client *client = v4l2_get_subdevdata(sd);
 791
 792         switch (ctrl->id) {
 793         case CX25840_CID_ENABLE_PVR150_WORKAROUND:
 794                 ctrl->value = state->pvr150_workaround;
 795                 break;
 796         case V4L2_CID_BRIGHTNESS:
 797                 ctrl->value = (s8)cx25840_read(client, 0x414) + 128;
 798                 break;
 799         case V4L2_CID_CONTRAST:
 800                 ctrl->value = cx25840_read(client, 0x415) >> 1;
 801                 break;
 802         case V4L2_CID_SATURATION:
 803                 ctrl->value = cx25840_read(client, 0x420) >> 1;
 804                 break;
 805         case V4L2_CID_HUE:
 806                 ctrl->value = (s8)cx25840_read(client, 0x422);
 807                 break;
 808         case V4L2_CID_AUDIO_VOLUME:
 809         case V4L2_CID_AUDIO_BASS:
 810         case V4L2_CID_AUDIO_TREBLE:
 811         case V4L2_CID_AUDIO_BALANCE:
 812         case V4L2_CID_AUDIO_MUTE:
 813                 if (state->is_cx25836)
 814                         return -EINVAL;
 815                 return cx25840_audio_g_ctrl(sd, ctrl);
 816         default:
 817                 return -EINVAL;
 818         }
 819
 820         return 0;
 821 }
 822
 823 /* ----------------------------------------------------------------------- */
 824
 825 static int cx25840_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
 826 {
 827         switch (fmt->type) {
 828         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 829                 return cx25840_vbi_g_fmt(sd, fmt);
 830         default:
 831                 return -EINVAL;
 832         }
 833         return 0;
 834 }
 835
 836 static int cx25840_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
 837 {
 838         struct cx25840_state *state = to_state(sd);
 839         struct i2c_client *client = v4l2_get_subdevdata(sd);
 840         struct v4l2_pix_format *pix;
 841         int HSC, VSC, Vsrc, Hsrc, filter, Vlines;
 842         int is_50Hz = !(state->std & V4L2_STD_525_60);
 843
 844         switch (fmt->type) {
 845         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 846                 pix = &(fmt->fmt.pix);
 847
 848                 Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
 849                 Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
 850
 851                 Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
 852                 Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
 853
 854                 Vlines = pix->height + (is_50Hz ? 4 : 7);
 855
 856                 if ((pix->width * 16 < Hsrc) || (Hsrc < pix->width) ||
 857                     (Vlines * 8 < Vsrc) || (Vsrc < Vlines)) {
 858                         v4l_err(client, "%dx%d is not a valid size!\n",
 859                                     pix->width, pix->height);
 860                         return -ERANGE;
 861                 }
 862
 863                 HSC = (Hsrc * (1 << 20)) / pix->width - (1 << 20);
 864                 VSC = (1 << 16) - (Vsrc * (1 << 9) / Vlines - (1 << 9));
 865                 VSC &= 0x1fff;
 866
 867                 if (pix->width >= 385)
 868                         filter = 0;
 869                 else if (pix->width > 192)
 870                         filter = 1;
 871                 else if (pix->width > 96)
 872                         filter = 2;
 873                 else
 874                         filter = 3;
 875
 876                 v4l_dbg(1, cx25840_debug, client, "decoder set size %dx%d -> scale  %ux%u\n",
 877                             pix->width, pix->height, HSC, VSC);
 878
 879                 /* HSCALE=HSC */
 880                 cx25840_write(client, 0x418, HSC & 0xff);
 881                 cx25840_write(client, 0x419, (HSC >> 8) & 0xff);
 882                 cx25840_write(client, 0x41a, HSC >> 16);
 883                 /* VSCALE=VSC */
 884                 cx25840_write(client, 0x41c, VSC & 0xff);
 885                 cx25840_write(client, 0x41d, VSC >> 8);
 886                 /* VS_INTRLACE=1 VFILT=filter */
 887                 cx25840_write(client, 0x41e, 0x8 | filter);
 888                 break;
 889
 890         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 891                 return cx25840_vbi_s_fmt(sd, fmt);
 892
 893         case V4L2_BUF_TYPE_VBI_CAPTURE:
 894                 return cx25840_vbi_s_fmt(sd, fmt);
 895
 896         default:
 897                 return -EINVAL;
 898         }
 899
 900         return 0;
 901 }
 902
 903 /* ----------------------------------------------------------------------- */
 904
 905 static void log_video_status(struct i2c_client *client)
 906 {
 907         static const char *const fmt_strs[] = {
 908                 "0x0",
 909                 "NTSC-M", "NTSC-J", "NTSC-4.43",
 910                 "PAL-BDGHI", "PAL-M", "PAL-N", "PAL-Nc", "PAL-60",
 911                 "0x9", "0xA", "0xB",
 912                 "SECAM",
 913                 "0xD", "0xE", "0xF"
 914         };
 915
 916         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 917         u8 vidfmt_sel = cx25840_read(client, 0x400) & 0xf;
 918         u8 gen_stat1 = cx25840_read(client, 0x40d);
 919         u8 gen_stat2 = cx25840_read(client, 0x40e);
 920         int vid_input = state->vid_input;
 921
 922         v4l_info(client, "Video signal:              %spresent\n",
 923                     (gen_stat2 & 0x20) ? "" : "not ");
 924         v4l_info(client, "Detected format:           %s\n",
 925                     fmt_strs[gen_stat1 & 0xf]);
 926
 927         v4l_info(client, "Specified standard:        %s\n",
 928                     vidfmt_sel ? fmt_strs[vidfmt_sel] : "automatic detection");
 929
 930         if (vid_input >= CX25840_COMPOSITE1 &&
 931             vid_input <= CX25840_COMPOSITE8) {
 932                 v4l_info(client, "Specified video input:     Composite %d\n",
 933                         vid_input - CX25840_COMPOSITE1 + 1);
 934         } else {
 935                 v4l_info(client, "Specified video input:     S-Video (Luma In%d, Chroma In%d)\n",
 936                         (vid_input & 0xf0) >> 4, (vid_input & 0xf00) >> 8);
 937         }
 938
 939         v4l_info(client, "Specified audioclock freq: %d Hz\n", state->audclk_freq);
 940 }
 941
 942 /* ----------------------------------------------------------------------- */
 943
 944 static void log_audio_status(struct i2c_client *client)
 945 {
 946         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
 947         u8 download_ctl = cx25840_read(client, 0x803);
 948         u8 mod_det_stat0 = cx25840_read(client, 0x804);
 949         u8 mod_det_stat1 = cx25840_read(client, 0x805);
 950         u8 audio_config = cx25840_read(client, 0x808);
 951         u8 pref_mode = cx25840_read(client, 0x809);
 952         u8 afc0 = cx25840_read(client, 0x80b);
 953         u8 mute_ctl = cx25840_read(client, 0x8d3);
 954         int aud_input = state->aud_input;
 955         char *p;
 956
 957         switch (mod_det_stat0) {
 958         case 0x00: p = "mono"; break;
 959         case 0x01: p = "stereo"; break;
 960         case 0x02: p = "dual"; break;
 961         case 0x04: p = "tri"; break;
 962         case 0x10: p = "mono with SAP"; break;
 963         case 0x11: p = "stereo with SAP"; break;
 964         case 0x12: p = "dual with SAP"; break;
 965         case 0x14: p = "tri with SAP"; break;
 966         case 0xfe: p = "forced mode"; break;
 967         default: p = "not defined";
 968         }
 969         v4l_info(client, "Detected audio mode:       %s\n", p);
 970
 971         switch (mod_det_stat1) {
 972         case 0x00: p = "not defined"; break;
 973         case 0x01: p = "EIAJ"; break;
 974         case 0x02: p = "A2-M"; break;
 975         case 0x03: p = "A2-BG"; break;
 976         case 0x04: p = "A2-DK1"; break;
 977         case 0x05: p = "A2-DK2"; break;
 978         case 0x06: p = "A2-DK3"; break;
 979         case 0x07: p = "A1 (6.0 MHz FM Mono)"; break;
 980         case 0x08: p = "AM-L"; break;
 981         case 0x09: p = "NICAM-BG"; break;
 982         case 0x0a: p = "NICAM-DK"; break;
 983         case 0x0b: p = "NICAM-I"; break;
 984         case 0x0c: p = "NICAM-L"; break;
 985         case 0x0d: p = "BTSC/EIAJ/A2-M Mono (4.5 MHz FMMono)"; break;
 986         case 0x0e: p = "IF FM Radio"; break;
 987         case 0x0f: p = "BTSC"; break;
 988         case 0x10: p = "high-deviation FM"; break;
 989         case 0x11: p = "very high-deviation FM"; break;
 990         case 0xfd: p = "unknown audio standard"; break;
 991         case 0xfe: p = "forced audio standard"; break;
 992         case 0xff: p = "no detected audio standard"; break;
 993         default: p = "not defined";
 994         }
 995         v4l_info(client, "Detected audio standard:   %s\n", p);
 996         v4l_info(client, "Audio muted:               %s\n",
 997                     (state->unmute_volume >= 0) ? "yes" : "no");
 998         v4l_info(client, "Audio microcontroller:     %s\n",
 999                     (download_ctl & 0x10) ?
1000                                 ((mute_ctl & 0x2) ? "detecting" : "running") : "stopped");
1001
1002         switch (audio_config >> 4) {
1003         case 0x00: p = "undefined"; break;
1004         case 0x01: p = "BTSC"; break;
1005         case 0x02: p = "EIAJ"; break;
1006         case 0x03: p = "A2-M"; break;
1007         case 0x04: p = "A2-BG"; break;
1008         case 0x05: p = "A2-DK1"; break;
1009         case 0x06: p = "A2-DK2"; break;
1010         case 0x07: p = "A2-DK3"; break;
1011         case 0x08: p = "A1 (6.0 MHz FM Mono)"; break;
1012         case 0x09: p = "AM-L"; break;
1013         case 0x0a: p = "NICAM-BG"; break;
1014         case 0x0b: p = "NICAM-DK"; break;
1015         case 0x0c: p = "NICAM-I"; break;
1016         case 0x0d: p = "NICAM-L"; break;
1017         case 0x0e: p = "FM radio"; break;
1018         case 0x0f: p = "automatic detection"; break;
1019         default: p = "undefined";
1020         }
1021         v4l_info(client, "Configured audio standard: %s\n", p);
1022
1023         if ((audio_config >> 4) < 0xF) {
1024                 switch (audio_config & 0xF) {
1025                 case 0x00: p = "MONO1 (LANGUAGE A/Mono L+R channel for BTSC, EIAJ, A2)"; break;
1026                 case 0x01: p = "MONO2 (LANGUAGE B)"; break;
1027                 case 0x02: p = "MONO3 (STEREO forced MONO)"; break;
1028                 case 0x03: p = "MONO4 (NICAM ANALOG-Language C/Analog Fallback)"; break;
1029                 case 0x04: p = "STEREO"; break;
1030                 case 0x05: p = "DUAL1 (AB)"; break;
1031                 case 0x06: p = "DUAL2 (AC) (FM)"; break;
1032                 case 0x07: p = "DUAL3 (BC) (FM)"; break;
1033                 case 0x08: p = "DUAL4 (AC) (AM)"; break;
1034                 case 0x09: p = "DUAL5 (BC) (AM)"; break;
1035                 case 0x0a: p = "SAP"; break;
1036                 default: p = "undefined";
1037                 }
1038                 v4l_info(client, "Configured audio mode:     %s\n", p);
1039         } else {
1040                 switch (audio_config & 0xF) {
1041                 case 0x00: p = "BG"; break;
1042                 case 0x01: p = "DK1"; break;
1043                 case 0x02: p = "DK2"; break;
1044                 case 0x03: p = "DK3"; break;
1045                 case 0x04: p = "I"; break;
1046                 case 0x05: p = "L"; break;
1047                 case 0x06: p = "BTSC"; break;
1048                 case 0x07: p = "EIAJ"; break;
1049                 case 0x08: p = "A2-M"; break;
1050                 case 0x09: p = "FM Radio"; break;
1051                 case 0x0f: p = "automatic standard and mode detection"; break;
1052                 default: p = "undefined";
1053                 }
1054                 v4l_info(client, "Configured audio system:   %s\n", p);
1055         }
1056
1057         if (aud_input) {
1058                 v4l_info(client, "Specified audio input:     Tuner (In%d)\n", aud_input);
1059         } else {
1060                 v4l_info(client, "Specified audio input:     External\n");
1061         }
1062
1063         switch (pref_mode & 0xf) {
1064         case 0: p = "mono/language A"; break;
1065         case 1: p = "language B"; break;
1066         case 2: p = "language C"; break;
1067         case 3: p = "analog fallback"; break;
1068         case 4: p = "stereo"; break;
1069         case 5: p = "language AC"; break;
1070         case 6: p = "language BC"; break;
1071         case 7: p = "language AB"; break;
1072         default: p = "undefined";
1073         }
1074         v4l_info(client, "Preferred audio mode:      %s\n", p);
1075
1076         if ((audio_config & 0xf) == 0xf) {
1077                 switch ((afc0 >> 3) & 0x3) {
1078                 case 0: p = "system DK"; break;
1079                 case 1: p = "system L"; break;
1080                 case 2: p = "autodetect"; break;
1081                 default: p = "undefined";
1082                 }
1083                 v4l_info(client, "Selected 65 MHz format:    %s\n", p);
1084
1085                 switch (afc0 & 0x7) {
1086                 case 0: p = "chroma"; break;
1087                 case 1: p = "BTSC"; break;
1088                 case 2: p = "EIAJ"; break;
1089                 case 3: p = "A2-M"; break;
1090                 case 4: p = "autodetect"; break;
1091                 default: p = "undefined";
1092                 }
1093                 v4l_info(client, "Selected 45 MHz format:    %s\n", p);
1094         }
1095 }
1096
1097 /* ----------------------------------------------------------------------- */
1098
1099 /* This init operation must be called to load the driver's firmware.
1100    Without this the audio standard detection will fail and you will
1101    only get mono.
1102
1103    Since loading the firmware is often problematic when the driver is
1104    compiled into the kernel I recommend postponing calling this function
1105    until the first open of the video device. Another reason for
1106    postponing it is that loading this firmware takes a long time (seconds)
1107    due to the slow i2c bus speed. So it will speed up the boot process if
1108    you can avoid loading the fw as long as the video device isn't used.  */
1109 static int cx25840_init(struct v4l2_subdev *sd, u32 val)
1110 {
1111         struct cx25840_state *state = to_state(sd);
1112         struct i2c_client *client = v4l2_get_subdevdata(sd);
1113
1114         if (!state->is_initialized) {
1115                 /* initialize on first use */
1116                 state->is_initialized = 1;
1117                 if (state->is_cx25836)
1118                         cx25836_initialize(client);
1119                 else if (state->is_cx23885)
1120                         cx23885_initialize(client);
1121                 else
1122                         cx25840_initialize(client);
1123         }
1124         return 0;
1125 }
1126
1127 #ifdef CONFIG_VIDEO_ADV_DEBUG
1128 static int cx25840_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1129 {
1130         struct i2c_client *client = v4l2_get_subdevdata(sd);
1131
1132         if (!v4l2_chip_match_i2c_client(client, &reg->match))
1133                 return -EINVAL;
1134         if (!capable(CAP_SYS_ADMIN))
1135                 return -EPERM;
1136         reg->size = 1;
1137         reg->val = cx25840_read(client, reg->reg & 0x0fff);
1138         return 0;
1139 }
1140
1141 static int cx25840_s_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
1142 {
1143         struct i2c_client *client = v4l2_get_subdevdata(sd);
1144
1145         if (!v4l2_chip_match_i2c_client(client, &reg->match))
1146                 return -EINVAL;
1147         if (!capable(CAP_SYS_ADMIN))
1148                 return -EPERM;
1149         cx25840_write(client, reg->reg & 0x0fff, reg->val & 0xff);
1150         return 0;
1151 }
1152 #endif
1153
1154 static int cx25840_s_stream(struct v4l2_subdev *sd, int enable)
1155 {
1156         struct cx25840_state *state = to_state(sd);
1157         struct i2c_client *client = v4l2_get_subdevdata(sd);
1158
1159         v4l_dbg(1, cx25840_debug, client, "%s output\n",
1160                         enable ? "enable" : "disable");
1161         if (enable) {
1162                 if (state->is_cx23885) {
1163                         u8 v = (cx25840_read(client, 0x421) | 0x0b);
1164                         cx25840_write(client, 0x421, v);
1165                 } else {
1166                         cx25840_write(client, 0x115,
1167                                         state->is_cx25836 ? 0x0c : 0x8c);
1168                         cx25840_write(client, 0x116,
1169                                         state->is_cx25836 ? 0x04 : 0x07);
1170                 }
1171         } else {
1172                 if (state->is_cx23885) {
1173                         u8 v = cx25840_read(client, 0x421) & ~(0x0b);
1174                         cx25840_write(client, 0x421, v);
1175                 } else {
1176                         cx25840_write(client, 0x115, 0x00);
1177                         cx25840_write(client, 0x116, 0x00);
1178                 }
1179         }
1180         return 0;
1181 }
1182
1183 static int cx25840_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
1184 {
1185         struct cx25840_state *state = to_state(sd);
1186
1187         switch (qc->id) {
1188         case V4L2_CID_BRIGHTNESS:
1189                 return v4l2_ctrl_query_fill(qc, 0, 255, 1, 128);
1190         case V4L2_CID_CONTRAST:
1191         case V4L2_CID_SATURATION:
1192                 return v4l2_ctrl_query_fill(qc, 0, 127, 1, 64);
1193         case V4L2_CID_HUE:
1194                 return v4l2_ctrl_query_fill(qc, -128, 127, 1, 0);
1195         default:
1196                 break;
1197         }
1198         if (state->is_cx25836)
1199                 return -EINVAL;
1200
1201         switch (qc->id) {
1202         case V4L2_CID_AUDIO_VOLUME:
1203                 return v4l2_ctrl_query_fill(qc, 0, 65535,
1204                                 65535 / 100, state->default_volume);
1205         case V4L2_CID_AUDIO_MUTE:
1206                 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1207         case V4L2_CID_AUDIO_BALANCE:
1208         case V4L2_CID_AUDIO_BASS:
1209         case V4L2_CID_AUDIO_TREBLE:
1210                 return v4l2_ctrl_query_fill(qc, 0, 65535, 65535 / 100, 32768);
1211         default:
1212                 return -EINVAL;
1213         }
1214         return -EINVAL;
1215 }
1216
1217 static int cx25840_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
1218 {
1219         struct cx25840_state *state = to_state(sd);
1220         struct i2c_client *client = v4l2_get_subdevdata(sd);
1221
1222         if (state->radio == 0 && state->std == std)
1223                 return 0;
1224         state->radio = 0;
1225         state->std = std;
1226         return set_v4lstd(client);
1227 }
1228
1229 static int cx25840_s_radio(struct v4l2_subdev *sd)
1230 {
1231         struct cx25840_state *state = to_state(sd);
1232
1233         state->radio = 1;
1234         return 0;
1235 }
1236
1237 static int cx25840_s_video_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
1238 {
1239         struct cx25840_state *state = to_state(sd);
1240         struct i2c_client *client = v4l2_get_subdevdata(sd);
1241
1242         return set_input(client, route->input, state->aud_input);
1243 }
1244
1245 static int cx25840_s_audio_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
1246 {
1247         struct cx25840_state *state = to_state(sd);
1248         struct i2c_client *client = v4l2_get_subdevdata(sd);
1249
1250         if (state->is_cx25836)
1251                 return -EINVAL;
1252         return set_input(client, state->vid_input, route->input);
1253 }
1254
1255 static int cx25840_s_frequency(struct v4l2_subdev *sd, struct v4l2_frequency *freq)
1256 {
1257         struct cx25840_state *state = to_state(sd);
1258         struct i2c_client *client = v4l2_get_subdevdata(sd);
1259
1260         if (!state->is_cx25836)
1261                 input_change(client);
1262         return 0;
1263 }
1264
1265 static int cx25840_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1266 {
1267         struct cx25840_state *state = to_state(sd);
1268         struct i2c_client *client = v4l2_get_subdevdata(sd);
1269         u8 vpres = cx25840_read(client, 0x40e) & 0x20;
1270         u8 mode;
1271         int val = 0;
1272
1273         if (state->radio)
1274                 return 0;
1275
1276         vt->signal = vpres ? 0xffff : 0x0;
1277         if (state->is_cx25836)
1278                 return 0;
1279
1280         vt->capability |=
1281                 V4L2_TUNER_CAP_STEREO | V4L2_TUNER_CAP_LANG1 |
1282                 V4L2_TUNER_CAP_LANG2 | V4L2_TUNER_CAP_SAP;
1283
1284         mode = cx25840_read(client, 0x804);
1285
1286         /* get rxsubchans and audmode */
1287         if ((mode & 0xf) == 1)
1288                 val |= V4L2_TUNER_SUB_STEREO;
1289         else
1290                 val |= V4L2_TUNER_SUB_MONO;
1291
1292         if (mode == 2 || mode == 4)
1293                 val = V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
1294
1295         if (mode & 0x10)
1296                 val |= V4L2_TUNER_SUB_SAP;
1297
1298         vt->rxsubchans = val;
1299         vt->audmode = state->audmode;
1300         return 0;
1301 }
1302
1303 static int cx25840_s_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
1304 {
1305         struct cx25840_state *state = to_state(sd);
1306         struct i2c_client *client = v4l2_get_subdevdata(sd);
1307
1308         if (state->radio || state->is_cx25836)
1309                 return 0;
1310
1311         switch (vt->audmode) {
1312                 case V4L2_TUNER_MODE_MONO:
1313                         /* mono      -> mono
1314                            stereo    -> mono
1315                            bilingual -> lang1 */
1316                         cx25840_and_or(client, 0x809, ~0xf, 0x00);
1317                         break;
1318                 case V4L2_TUNER_MODE_STEREO:
1319                 case V4L2_TUNER_MODE_LANG1:
1320                         /* mono      -> mono
1321                            stereo    -> stereo
1322                            bilingual -> lang1 */
1323                         cx25840_and_or(client, 0x809, ~0xf, 0x04);
1324                         break;
1325                 case V4L2_TUNER_MODE_LANG1_LANG2:
1326                         /* mono      -> mono
1327                            stereo    -> stereo
1328                            bilingual -> lang1/lang2 */
1329                         cx25840_and_or(client, 0x809, ~0xf, 0x07);
1330                         break;
1331                 case V4L2_TUNER_MODE_LANG2:
1332                         /* mono      -> mono
1333                            stereo    -> stereo
1334                            bilingual -> lang2 */
1335                         cx25840_and_or(client, 0x809, ~0xf, 0x01);
1336                         break;
1337                 default:
1338                         return -EINVAL;
1339         }
1340         state->audmode = vt->audmode;
1341         return 0;
1342 }
1343
1344 static int cx25840_reset(struct v4l2_subdev *sd, u32 val)
1345 {
1346         struct cx25840_state *state = to_state(sd);
1347         struct i2c_client *client = v4l2_get_subdevdata(sd);
1348
1349         if (state->is_cx25836)
1350                 cx25836_initialize(client);
1351         else if (state->is_cx23885)
1352                 cx23885_initialize(client);
1353         else
1354                 cx25840_initialize(client);
1355         return 0;
1356 }
1357
1358 static int cx25840_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
1359 {
1360         struct cx25840_state *state = to_state(sd);
1361         struct i2c_client *client = v4l2_get_subdevdata(sd);
1362
1363         return v4l2_chip_ident_i2c_client(client, chip, state->id, state->rev);
1364 }
1365
1366 static int cx25840_log_status(struct v4l2_subdev *sd)
1367 {
1368         struct cx25840_state *state = to_state(sd);
1369         struct i2c_client *client = v4l2_get_subdevdata(sd);
1370
1371         log_video_status(client);
1372         if (!state->is_cx25836)
1373                 log_audio_status(client);
1374         return 0;
1375 }
1376
1377 /* ----------------------------------------------------------------------- */
1378
1379 static const struct v4l2_subdev_core_ops cx25840_core_ops = {
1380         .log_status = cx25840_log_status,
1381         .g_chip_ident = cx25840_g_chip_ident,
1382         .g_ctrl = cx25840_g_ctrl,
1383         .s_ctrl = cx25840_s_ctrl,
1384         .queryctrl = cx25840_queryctrl,
1385         .reset = cx25840_reset,
1386         .init = cx25840_init,
1387 #ifdef CONFIG_VIDEO_ADV_DEBUG
1388         .g_register = cx25840_g_register,
1389         .s_register = cx25840_s_register,
1390 #endif
1391 };
1392
1393 static const struct v4l2_subdev_tuner_ops cx25840_tuner_ops = {
1394         .s_frequency = cx25840_s_frequency,
1395         .s_std = cx25840_s_std,
1396         .s_radio = cx25840_s_radio,
1397         .g_tuner = cx25840_g_tuner,
1398         .s_tuner = cx25840_s_tuner,
1399 };
1400
1401 static const struct v4l2_subdev_audio_ops cx25840_audio_ops = {
1402         .s_clock_freq = cx25840_s_clock_freq,
1403         .s_routing = cx25840_s_audio_routing,
1404 };
1405
1406 static const struct v4l2_subdev_video_ops cx25840_video_ops = {
1407         .s_routing = cx25840_s_video_routing,
1408         .g_fmt = cx25840_g_fmt,
1409         .s_fmt = cx25840_s_fmt,
1410         .decode_vbi_line = cx25840_decode_vbi_line,
1411         .s_stream = cx25840_s_stream,
1412 };
1413
1414 static const struct v4l2_subdev_ops cx25840_ops = {
1415         .core = &cx25840_core_ops,
1416         .tuner = &cx25840_tuner_ops,
1417         .audio = &cx25840_audio_ops,
1418         .video = &cx25840_video_ops,
1419 };
1420
1421 /* ----------------------------------------------------------------------- */
1422
1423 static int cx25840_probe(struct i2c_client *client,
1424                          const struct i2c_device_id *did)
1425 {
1426         struct cx25840_state *state;
1427         struct v4l2_subdev *sd;
1428         u32 id;
1429         u16 device_id;
1430
1431         /* Check if the adapter supports the needed features */
1432         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1433                 return -EIO;
1434
1435         v4l_dbg(1, cx25840_debug, client, "detecting cx25840 client on address 0x%x\n", client->addr << 1);
1436
1437         device_id = cx25840_read(client, 0x101) << 8;
1438         device_id |= cx25840_read(client, 0x100);
1439         v4l_dbg(1, cx25840_debug, client, "device_id = 0x%04x\n", device_id);
1440
1441         /* The high byte of the device ID should be
1442          * 0x83 for the cx2583x and 0x84 for the cx2584x */
1443         if ((device_id & 0xff00) == 0x8300) {
1444                 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1445         }
1446         else if ((device_id & 0xff00) == 0x8400) {
1447                 id = V4L2_IDENT_CX25840 + ((device_id >> 4) & 0xf);
1448         } else if (device_id == 0x0000) {
1449                 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1450         } else if (device_id == 0x1313) {
1451                 id = V4L2_IDENT_CX25836 + ((device_id >> 4) & 0xf) - 6;
1452         }
1453         else {
1454                 v4l_dbg(1, cx25840_debug, client, "cx25840 not found\n");
1455                 return -ENODEV;
1456         }
1457
1458         state = kzalloc(sizeof(struct cx25840_state), GFP_KERNEL);
1459         if (state == NULL)
1460                 return -ENOMEM;
1461
1462         sd = &state->sd;
1463         v4l2_i2c_subdev_init(sd, client, &cx25840_ops);
1464         /* Note: revision '(device_id & 0x0f) == 2' was never built. The
1465            marking skips from 0x1 == 22 to 0x3 == 23. */
1466         v4l_info(client, "cx25%3x-2%x found @ 0x%x (%s)\n",
1467                     (device_id & 0xfff0) >> 4,
1468                     (device_id & 0x0f) < 3 ? (device_id & 0x0f) + 1 : (device_id & 0x0f),
1469                     client->addr << 1, client->adapter->name);
1470
1471         state->c = client;
1472         state->is_cx25836 = ((device_id & 0xff00) == 0x8300);
1473         state->is_cx23885 = (device_id == 0x0000) || (device_id == 0x1313);
1474         state->vid_input = CX25840_COMPOSITE7;
1475         state->aud_input = CX25840_AUDIO8;
1476         state->audclk_freq = 48000;
1477         state->pvr150_workaround = 0;
1478         state->audmode = V4L2_TUNER_MODE_LANG1;
1479         state->unmute_volume = -1;
1480         state->default_volume = 228 - cx25840_read(client, 0x8d4);
1481         state->default_volume = ((state->default_volume / 2) + 23) << 9;
1482         state->vbi_line_offset = 8;
1483         state->id = id;
1484         state->rev = device_id;
1485
1486         if (state->is_cx23885) {
1487                 /* Drive GPIO2 direction and values */
1488                 cx25840_write(client, 0x160, 0x1d);
1489                 cx25840_write(client, 0x164, 0x00);
1490         }
1491
1492         return 0;
1493 }
1494
1495 static int cx25840_remove(struct i2c_client *client)
1496 {
1497         struct v4l2_subdev *sd = i2c_get_clientdata(client);
1498
1499         v4l2_device_unregister_subdev(sd);
1500         kfree(to_state(sd));
1501         return 0;
1502 }
1503
1504 static const struct i2c_device_id cx25840_id[] = {
1505         { "cx25840", 0 },
1506         { }
1507 };
1508 MODULE_DEVICE_TABLE(i2c, cx25840_id);
1509
1510 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
1511         .name = "cx25840",
1512         .probe = cx25840_probe,
1513         .remove = cx25840_remove,
1514         .id_table = cx25840_id,
1515 };