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/i2c.h>
  21 #include <linux/videodev2.h>
  22 #include <linux/ioctl.h>
  23
  24 #include "wis-i2c.h"
  25
  26 struct wis_tw9903 {
  27         int norm;
  28         int brightness;
  29         int contrast;
  30         int hue;
  31 };
  32
  33 static u8 initial_registers[] =
  34 {
  35         0x02, 0x44, /* input 1, composite */
  36         0x03, 0x92, /* correct digital format */
  37         0x04, 0x00,
  38         0x05, 0x80, /* or 0x00 for PAL */
  39         0x06, 0x40, /* second internal current reference */
  40         0x07, 0x02, /* window */
  41         0x08, 0x14, /* window */
  42         0x09, 0xf0, /* window */
  43         0x0a, 0x81, /* window */
  44         0x0b, 0xd0, /* window */
  45         0x0c, 0x8c,
  46         0x0d, 0x00, /* scaling */
  47         0x0e, 0x11, /* scaling */
  48         0x0f, 0x00, /* scaling */
  49         0x10, 0x00, /* brightness */
  50         0x11, 0x60, /* contrast */
  51         0x12, 0x01, /* sharpness */
  52         0x13, 0x7f, /* U gain */
  53         0x14, 0x5a, /* V gain */
  54         0x15, 0x00, /* hue */
  55         0x16, 0xc3, /* sharpness */
  56         0x18, 0x00,
  57         0x19, 0x58, /* vbi */
  58         0x1a, 0x80,
  59         0x1c, 0x0f, /* video norm */
  60         0x1d, 0x7f, /* video norm */
  61         0x20, 0xa0, /* clamping gain (working 0x50) */
  62         0x21, 0x22,
  63         0x22, 0xf0,
  64         0x23, 0xfe,
  65         0x24, 0x3c,
  66         0x25, 0x38,
  67         0x26, 0x44,
  68         0x27, 0x20,
  69         0x28, 0x00,
  70         0x29, 0x15,
  71         0x2a, 0xa0,
  72         0x2b, 0x44,
  73         0x2c, 0x37,
  74         0x2d, 0x00,
  75         0x2e, 0xa5, /* burst PLL control (working: a9) */
  76         0x2f, 0xe0, /* 0xea is blue test frame -- 0xe0 for normal */
  77         0x31, 0x00,
  78         0x33, 0x22,
  79         0x34, 0x11,
  80         0x35, 0x35,
  81         0x3b, 0x05,
  82         0x06, 0xc0, /* reset device */
  83         0x00, 0x00, /* Terminator (reg 0x00 is read-only) */
  84 };
  85
  86 static int write_reg(struct i2c_client *client, u8 reg, u8 value)
  87 {
  88         return i2c_smbus_write_byte_data(client, reg, value);
  89 }
  90
  91 static int write_regs(struct i2c_client *client, u8 *regs)
  92 {
  93         int i;
  94
  95         for (i = 0; regs[i] != 0x00; i += 2)
  96                 if (i2c_smbus_write_byte_data(client, regs[i], regs[i + 1]) < 0)
  97                         return -1;
  98         return 0;
  99 }
 100
 101 static int wis_tw9903_command(struct i2c_client *client,
 102                                 unsigned int cmd, void *arg)
 103 {
 104         struct wis_tw9903 *dec = i2c_get_clientdata(client);
 105
 106         switch (cmd) {
 107         case VIDIOC_S_INPUT:
 108         {
 109                 int *input = arg;
 110
 111                 i2c_smbus_write_byte_data(client, 0x02, 0x40 | (*input << 1));
 112                 break;
 113         }
 114 #if 0
 115         /* 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 int wis_tw9903_probe(struct i2c_client *client,
 272                             const struct i2c_device_id *id)
 273 {
 274         struct i2c_adapter *adapter = client->adapter;
 275         struct wis_tw9903 *dec;
 276
 277         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 278                 return -ENODEV;
 279
 280         dec = kmalloc(sizeof(struct wis_tw9903), GFP_KERNEL);
 281         if (dec == NULL)
 282                 return -ENOMEM;
 283
 284         dec->norm = V4L2_STD_NTSC;
 285         dec->brightness = 0;
 286         dec->contrast = 0x60;
 287         dec->hue = 0;
 288         i2c_set_clientdata(client, dec);
 289
 290         printk(KERN_DEBUG
 291                 "wis-tw9903: initializing TW9903 at address %d on %s\n",
 292                 client->addr, adapter->name);
 293
 294         if (write_regs(client, initial_registers) < 0) {
 295                 printk(KERN_ERR "wis-tw9903: error initializing TW9903\n");
 296                 kfree(dec);
 297                 return -ENODEV;
 298         }
 299
 300         return 0;
 301 }
 302
 303 static int wis_tw9903_remove(struct i2c_client *client)
 304 {
 305         struct wis_tw9903 *dec = i2c_get_clientdata(client);
 306
 307         i2c_set_clientdata(client, NULL);
 308         kfree(dec);
 309         return 0;
 310 }
 311
 312 static struct i2c_device_id wis_tw9903_id[] = {
 313         { "wis_tw9903", 0 },
 314         { }
 315 };
 316
 317 static struct i2c_driver wis_tw9903_driver = {
 318         .driver = {
 319                 .name   = "WIS TW9903 I2C driver",
 320         },
 321         .probe          = wis_tw9903_probe,
 322         .remove         = wis_tw9903_remove,
 323         .command        = wis_tw9903_command,
 324         .id_table       = wis_tw9903_id,
 325 };
 326
 327 static int __init wis_tw9903_init(void)
 328 {
 329         return i2c_add_driver(&wis_tw9903_driver);
 330 }
 331
 332 static void __exit wis_tw9903_cleanup(void)
 333 {
 334         i2c_del_driver(&wis_tw9903_driver);
 335 }
 336
 337 module_init(wis_tw9903_init);
 338 module_exit(wis_tw9903_cleanup);
 339
 340 MODULE_LICENSE("GPL v2");