git.oblomov.eu Git - linux-2.6/blob - drivers/staging/go7007/wis-tw9903.c

   1 /*
   2  * Copyright (C) 2005-2006 Micronas USA Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License (Version 2) as
   6  * published by the Free Software Foundation.
   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 Foundation,
  15  * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/init.h>
  20 #include <linux/version.h>
  21 #include <linux/i2c.h>
  22 #include <linux/videodev2.h>
  23 #include <linux/ioctl.h>
  24
  25 #include "wis-i2c.h"
  26
  27 struct wis_tw9903 {
  28         int norm;
  29         int brightness;
  30         int contrast;
  31         int hue;
  32 };
  33
  34 static u8 initial_registers[] =
  35 {
  36         0x02, 0x44, /* input 1, composite */
  37         0x03, 0x92, /* correct digital format */
  38         0x04, 0x00,
  39         0x05, 0x80, /* or 0x00 for PAL */
  40         0x06, 0x40, /* second internal current reference */
  41         0x07, 0x02, /* window */
  42         0x08, 0x14, /* window */
  43         0x09, 0xf0, /* window */
  44         0x0a, 0x81, /* window */
  45         0x0b, 0xd0, /* window */
  46         0x0c, 0x8c,
  47         0x0d, 0x00, /* scaling */
  48         0x0e, 0x11, /* scaling */
  49         0x0f, 0x00, /* scaling */
  50         0x10, 0x00, /* brightness */
  51         0x11, 0x60, /* contrast */
  52         0x12, 0x01, /* sharpness */
  53         0x13, 0x7f, /* U gain */
  54         0x14, 0x5a, /* V gain */
  55         0x15, 0x00, /* hue */
  56         0x16, 0xc3, /* sharpness */
  57         0x18, 0x00,
  58         0x19, 0x58, /* vbi */
  59         0x1a, 0x80,
  60         0x1c, 0x0f, /* video norm */
  61         0x1d, 0x7f, /* video norm */
  62         0x20, 0xa0, /* clamping gain (working 0x50) */
  63         0x21, 0x22,
  64         0x22, 0xf0,
  65         0x23, 0xfe,
  66         0x24, 0x3c,
  67         0x25, 0x38,
  68         0x26, 0x44,
  69         0x27, 0x20,
  70         0x28, 0x00,
  71         0x29, 0x15,
  72         0x2a, 0xa0,
  73         0x2b, 0x44,
  74         0x2c, 0x37,
  75         0x2d, 0x00,
  76         0x2e, 0xa5, /* burst PLL control (working: a9) */
  77         0x2f, 0xe0, /* 0xea is blue test frame -- 0xe0 for normal */
  78         0x31, 0x00,
  79         0x33, 0x22,
  80         0x34, 0x11,
  81         0x35, 0x35,
  82         0x3b, 0x05,
  83         0x06, 0xc0, /* reset device */
  84         0x00, 0x00, /* Terminator (reg 0x00 is read-only) */
  85 };
  86
  87 static int write_reg(struct i2c_client *client, u8 reg, u8 value)
  88 {
  89         return i2c_smbus_write_byte_data(client, reg, value);
  90 }
  91
  92 static int write_regs(struct i2c_client *client, u8 *regs)
  93 {
  94         int i;
  95
  96         for (i = 0; regs[i] != 0x00; i += 2)
  97                 if (i2c_smbus_write_byte_data(client, regs[i], regs[i + 1]) < 0)
  98                         return -1;
  99         return 0;
 100 }
 101
 102 static int wis_tw9903_command(struct i2c_client *client,
 103                                 unsigned int cmd, void *arg)
 104 {
 105         struct wis_tw9903 *dec = i2c_get_clientdata(client);
 106
 107         switch (cmd) {
 108         case VIDIOC_S_INPUT:
 109         {
 110                 int *input = arg;
 111
 112                 i2c_smbus_write_byte_data(client, 0x02, 0x40 | (*input << 1));
 113                 break;
 114         }
 115 #if 0   /* The scaler on this thing seems to be horribly broken */
 116         case DECODER_SET_RESOLUTION:
 117         {
 118                 struct video_decoder_resolution *res = arg;
 119                 /*int hscale = 256 * 720 / res->width;*/
 120                 int hscale = 256 * 720 / (res->width - (res->width > 704 ? 0 : 8));
 121                 int vscale = 256 * (dec->norm & V4L2_STD_NTSC ?  240 : 288)
 122                                 / res->height;
 123                 u8 regs[] = {
 124                         0x0d, vscale & 0xff,
 125                         0x0f, hscale & 0xff,
 126                         0x0e, ((vscale & 0xf00) >> 4) | ((hscale & 0xf00) >> 8),
 127                         0x06, 0xc0, /* reset device */
 128                         0,      0,
 129                 };
 130                 printk(KERN_DEBUG "vscale is %04x, hscale is %04x\n",
 131                                 vscale, hscale);
 132                 /*write_regs(client, regs);*/
 133                 break;
 134         }
 135 #endif
 136         case VIDIOC_S_STD:
 137         {
 138                 v4l2_std_id *input = arg;
 139                 u8 regs[] = {
 140                         0x05, *input & V4L2_STD_NTSC ? 0x80 : 0x00,
 141                         0x07, *input & V4L2_STD_NTSC ? 0x02 : 0x12,
 142                         0x08, *input & V4L2_STD_NTSC ? 0x14 : 0x18,
 143                         0x09, *input & V4L2_STD_NTSC ? 0xf0 : 0x20,
 144                         0,      0,
 145                 };
 146                 write_regs(client, regs);
 147                 dec->norm = *input;
 148                 break;
 149         }
 150         case VIDIOC_QUERYCTRL:
 151         {
 152                 struct v4l2_queryctrl *ctrl = arg;
 153
 154                 switch (ctrl->id) {
 155                 case V4L2_CID_BRIGHTNESS:
 156                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 157                         strncpy(ctrl->name, "Brightness", sizeof(ctrl->name));
 158                         ctrl->minimum = -128;
 159                         ctrl->maximum = 127;
 160                         ctrl->step = 1;
 161                         ctrl->default_value = 0x00;
 162                         ctrl->flags = 0;
 163                         break;
 164                 case V4L2_CID_CONTRAST:
 165                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 166                         strncpy(ctrl->name, "Contrast", sizeof(ctrl->name));
 167                         ctrl->minimum = 0;
 168                         ctrl->maximum = 255;
 169                         ctrl->step = 1;
 170                         ctrl->default_value = 0x60;
 171                         ctrl->flags = 0;
 172                         break;
 173 #if 0
 174                 /* I don't understand how the Chroma Gain registers work... */
 175                 case V4L2_CID_SATURATION:
 176                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 177                         strncpy(ctrl->name, "Saturation", sizeof(ctrl->name));
 178                         ctrl->minimum = 0;
 179                         ctrl->maximum = 127;
 180                         ctrl->step = 1;
 181                         ctrl->default_value = 64;
 182                         ctrl->flags = 0;
 183                         break;
 184 #endif
 185                 case V4L2_CID_HUE:
 186                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 187                         strncpy(ctrl->name, "Hue", sizeof(ctrl->name));
 188                         ctrl->minimum = -128;
 189                         ctrl->maximum = 127;
 190                         ctrl->step = 1;
 191                         ctrl->default_value = 0;
 192                         ctrl->flags = 0;
 193                         break;
 194                 }
 195                 break;
 196         }
 197         case VIDIOC_S_CTRL:
 198         {
 199                 struct v4l2_control *ctrl = arg;
 200
 201                 switch (ctrl->id) {
 202                 case V4L2_CID_BRIGHTNESS:
 203                         if (ctrl->value > 127)
 204                                 dec->brightness = 127;
 205                         else if (ctrl->value < -128)
 206                                 dec->brightness = -128;
 207                         else
 208                                 dec->brightness = ctrl->value;
 209                         write_reg(client, 0x10, dec->brightness);
 210                         break;
 211                 case V4L2_CID_CONTRAST:
 212                         if (ctrl->value > 255)
 213                                 dec->contrast = 255;
 214                         else if (ctrl->value < 0)
 215                                 dec->contrast = 0;
 216                         else
 217                                 dec->contrast = ctrl->value;
 218                         write_reg(client, 0x11, dec->contrast);
 219                         break;
 220 #if 0
 221                 case V4L2_CID_SATURATION:
 222                         if (ctrl->value > 127)
 223                                 dec->saturation = 127;
 224                         else if (ctrl->value < 0)
 225                                 dec->saturation = 0;
 226                         else
 227                                 dec->saturation = ctrl->value;
 228                         /*write_reg(client, 0x0c, dec->saturation);*/
 229                         break;
 230 #endif
 231                 case V4L2_CID_HUE:
 232                         if (ctrl->value > 127)
 233                                 dec->hue = 127;
 234                         else if (ctrl->value < -128)
 235                                 dec->hue = -128;
 236                         else
 237                                 dec->hue = ctrl->value;
 238                         write_reg(client, 0x15, dec->hue);
 239                         break;
 240                 }
 241                 break;
 242         }
 243         case VIDIOC_G_CTRL:
 244         {
 245                 struct v4l2_control *ctrl = arg;
 246
 247                 switch (ctrl->id) {
 248                 case V4L2_CID_BRIGHTNESS:
 249                         ctrl->value = dec->brightness;
 250                         break;
 251                 case V4L2_CID_CONTRAST:
 252                         ctrl->value = dec->contrast;
 253                         break;
 254 #if 0
 255                 case V4L2_CID_SATURATION:
 256                         ctrl->value = dec->saturation;
 257                         break;
 258 #endif
 259                 case V4L2_CID_HUE:
 260                         ctrl->value = dec->hue;
 261                         break;
 262                 }
 263                 break;
 264         }
 265         default:
 266                 break;
 267         }
 268         return 0;
 269 }
 270
 271 static struct i2c_driver wis_tw9903_driver;
 272
 273 static struct i2c_client wis_tw9903_client_templ = {
 274         .name           = "TW9903 (WIS)",
 275         .driver         = &wis_tw9903_driver,
 276 };
 277
 278 static int wis_tw9903_detect(struct i2c_adapter *adapter, int addr, int kind)
 279 {
 280         struct i2c_client *client;
 281         struct wis_tw9903 *dec;
 282
 283         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 284                 return 0;
 285
 286         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 287         if (client == NULL)
 288                 return -ENOMEM;
 289         memcpy(client, &wis_tw9903_client_templ,
 290                         sizeof(wis_tw9903_client_templ));
 291         client->adapter = adapter;
 292         client->addr = addr;
 293
 294         dec = kmalloc(sizeof(struct wis_tw9903), GFP_KERNEL);
 295         if (dec == NULL) {
 296                 kfree(client);
 297                 return -ENOMEM;
 298         }
 299         dec->norm = V4L2_STD_NTSC;
 300         dec->brightness = 0;
 301         dec->contrast = 0x60;
 302         dec->hue = 0;
 303         i2c_set_clientdata(client, dec);
 304
 305         printk(KERN_DEBUG
 306                 "wis-tw9903: initializing TW9903 at address %d on %s\n",
 307                 addr, adapter->name);
 308
 309         if (write_regs(client, initial_registers) < 0) {
 310                 printk(KERN_ERR "wis-tw9903: error initializing TW9903\n");
 311                 kfree(client);
 312                 kfree(dec);
 313                 return 0;
 314         }
 315
 316         i2c_attach_client(client);
 317         return 0;
 318 }
 319
 320 static int wis_tw9903_detach(struct i2c_client *client)
 321 {
 322         struct wis_tw9903 *dec = i2c_get_clientdata(client);
 323         int r;
 324
 325         r = i2c_detach_client(client);
 326         if (r < 0)
 327                 return r;
 328
 329         kfree(client);
 330         kfree(dec);
 331         return 0;
 332 }
 333
 334 static struct i2c_driver wis_tw9903_driver = {
 335         .driver = {
 336                 .name   = "WIS TW9903 I2C driver",
 337         },
 338         .id             = I2C_DRIVERID_WIS_TW9903,
 339         .detach_client  = wis_tw9903_detach,
 340         .command        = wis_tw9903_command,
 341 };
 342
 343 static int __init wis_tw9903_init(void)
 344 {
 345         int r;
 346
 347         r = i2c_add_driver(&wis_tw9903_driver);
 348         if (r < 0)
 349                 return r;
 350         return wis_i2c_add_driver(wis_tw9903_driver.id, wis_tw9903_detect);
 351 }
 352
 353 static void __exit wis_tw9903_cleanup(void)
 354 {
 355         wis_i2c_del_driver(wis_tw9903_detect);
 356         i2c_del_driver(&wis_tw9903_driver);
 357 }
 358
 359 module_init(wis_tw9903_init);
 360 module_exit(wis_tw9903_cleanup);
 361
 362 MODULE_LICENSE("GPL v2");