drivers/staging/go7007/wis-tw2804.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_tw2804 {
  28         int channel;
  29         int norm;
  30         int brightness;
  31         int contrast;
  32         int saturation;
  33         int hue;
  34 };
  35
  36 static u8 global_registers[] =
  37 {
  38         0x39, 0x00,
  39         0x3a, 0xff,
  40         0x3b, 0x84,
  41         0x3c, 0x80,
  42         0x3d, 0x80,
  43         0x3e, 0x82,
  44         0x3f, 0x82,
  45         0xff, 0xff, /* Terminator (reg 0xff does not exist) */
  46 };
  47
  48 static u8 channel_registers[] =
  49 {
  50         0x01, 0xc4,
  51         0x02, 0xa5,
  52         0x03, 0x20,
  53         0x04, 0xd0,
  54         0x05, 0x20,
  55         0x06, 0xd0,
  56         0x07, 0x88,
  57         0x08, 0x20,
  58         0x09, 0x07,
  59         0x0a, 0xf0,
  60         0x0b, 0x07,
  61         0x0c, 0xf0,
  62         0x0d, 0x40,
  63         0x0e, 0xd2,
  64         0x0f, 0x80,
  65         0x10, 0x80,
  66         0x11, 0x80,
  67         0x12, 0x80,
  68         0x13, 0x1f,
  69         0x14, 0x00,
  70         0x15, 0x00,
  71         0x16, 0x00,
  72         0x17, 0x00,
  73         0x18, 0xff,
  74         0x19, 0xff,
  75         0x1a, 0xff,
  76         0x1b, 0xff,
  77         0x1c, 0xff,
  78         0x1d, 0xff,
  79         0x1e, 0xff,
  80         0x1f, 0xff,
  81         0x20, 0x07,
  82         0x21, 0x07,
  83         0x22, 0x00,
  84         0x23, 0x91,
  85         0x24, 0x51,
  86         0x25, 0x03,
  87         0x26, 0x00,
  88         0x27, 0x00,
  89         0x28, 0x00,
  90         0x29, 0x00,
  91         0x2a, 0x00,
  92         0x2b, 0x00,
  93         0x2c, 0x00,
  94         0x2d, 0x00,
  95         0x2e, 0x00,
  96         0x2f, 0x00,
  97         0x30, 0x00,
  98         0x31, 0x00,
  99         0x32, 0x00,
 100         0x33, 0x00,
 101         0x34, 0x00,
 102         0x35, 0x00,
 103         0x36, 0x00,
 104         0x37, 0x00,
 105         0xff, 0xff, /* Terminator (reg 0xff does not exist) */
 106 };
 107
 108 static int write_reg(struct i2c_client *client, u8 reg, u8 value, int channel)
 109 {
 110         return i2c_smbus_write_byte_data(client, reg | (channel << 6), value);
 111 }
 112
 113 static int write_regs(struct i2c_client *client, u8 *regs, int channel)
 114 {
 115         int i;
 116
 117         for (i = 0; regs[i] != 0xff; i += 2)
 118                 if (i2c_smbus_write_byte_data(client,
 119                                 regs[i] | (channel << 6), regs[i + 1]) < 0)
 120                         return -1;
 121         return 0;
 122 }
 123
 124 static int wis_tw2804_command(struct i2c_client *client,
 125                                 unsigned int cmd, void *arg)
 126 {
 127         struct wis_tw2804 *dec = i2c_get_clientdata(client);
 128
 129         if (cmd == DECODER_SET_CHANNEL) {
 130                 int *input = arg;
 131
 132                 if (*input < 0 || *input > 3) {
 133                         printk(KERN_ERR "wis-tw2804: channel %d is not "
 134                                         "between 0 and 3!\n", *input);
 135                         return 0;
 136                 }
 137                 dec->channel = *input;
 138                 printk(KERN_DEBUG "wis-tw2804: initializing TW2804 "
 139                                 "channel %d\n", dec->channel);
 140                 if (dec->channel == 0 &&
 141                                 write_regs(client, global_registers, 0) < 0) {
 142                         printk(KERN_ERR "wis-tw2804: error initializing "
 143                                         "TW2804 global registers\n");
 144                         return 0;
 145                 }
 146                 if (write_regs(client, channel_registers, dec->channel) < 0) {
 147                         printk(KERN_ERR "wis-tw2804: error initializing "
 148                                         "TW2804 channel %d\n", dec->channel);
 149                         return 0;
 150                 }
 151                 return 0;
 152         }
 153
 154         if (dec->channel < 0) {
 155                 printk(KERN_DEBUG "wis-tw2804: ignoring command %08x until "
 156                                 "channel number is set\n", cmd);
 157                 return 0;
 158         }
 159
 160         switch (cmd) {
 161         case VIDIOC_S_STD:
 162         {
 163                 v4l2_std_id *input = arg;
 164                 u8 regs[] = {
 165                         0x01, *input & V4L2_STD_NTSC ? 0xc4 : 0x84,
 166                         0x09, *input & V4L2_STD_NTSC ? 0x07 : 0x04,
 167                         0x0a, *input & V4L2_STD_NTSC ? 0xf0 : 0x20,
 168                         0x0b, *input & V4L2_STD_NTSC ? 0x07 : 0x04,
 169                         0x0c, *input & V4L2_STD_NTSC ? 0xf0 : 0x20,
 170                         0x0d, *input & V4L2_STD_NTSC ? 0x40 : 0x4a,
 171                         0x16, *input & V4L2_STD_NTSC ? 0x00 : 0x40,
 172                         0x17, *input & V4L2_STD_NTSC ? 0x00 : 0x40,
 173                         0x20, *input & V4L2_STD_NTSC ? 0x07 : 0x0f,
 174                         0x21, *input & V4L2_STD_NTSC ? 0x07 : 0x0f,
 175                         0xff,   0xff,
 176                 };
 177                 write_regs(client, regs, dec->channel);
 178                 dec->norm = *input;
 179                 break;
 180         }
 181         case VIDIOC_QUERYCTRL:
 182         {
 183                 struct v4l2_queryctrl *ctrl = arg;
 184
 185                 switch (ctrl->id) {
 186                 case V4L2_CID_BRIGHTNESS:
 187                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 188                         strncpy(ctrl->name, "Brightness", sizeof(ctrl->name));
 189                         ctrl->minimum = 0;
 190                         ctrl->maximum = 255;
 191                         ctrl->step = 1;
 192                         ctrl->default_value = 128;
 193                         ctrl->flags = 0;
 194                         break;
 195                 case V4L2_CID_CONTRAST:
 196                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 197                         strncpy(ctrl->name, "Contrast", sizeof(ctrl->name));
 198                         ctrl->minimum = 0;
 199                         ctrl->maximum = 255;
 200                         ctrl->step = 1;
 201                         ctrl->default_value = 128;
 202                         ctrl->flags = 0;
 203                         break;
 204                 case V4L2_CID_SATURATION:
 205                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 206                         strncpy(ctrl->name, "Saturation", sizeof(ctrl->name));
 207                         ctrl->minimum = 0;
 208                         ctrl->maximum = 255;
 209                         ctrl->step = 1;
 210                         ctrl->default_value = 128;
 211                         ctrl->flags = 0;
 212                         break;
 213                 case V4L2_CID_HUE:
 214                         ctrl->type = V4L2_CTRL_TYPE_INTEGER;
 215                         strncpy(ctrl->name, "Hue", sizeof(ctrl->name));
 216                         ctrl->minimum = 0;
 217                         ctrl->maximum = 255;
 218                         ctrl->step = 1;
 219                         ctrl->default_value = 128;
 220                         ctrl->flags = 0;
 221                         break;
 222                 }
 223                 break;
 224         }
 225         case VIDIOC_S_CTRL:
 226         {
 227                 struct v4l2_control *ctrl = arg;
 228
 229                 switch (ctrl->id) {
 230                 case V4L2_CID_BRIGHTNESS:
 231                         if (ctrl->value > 255)
 232                                 dec->brightness = 255;
 233                         else if (ctrl->value < 0)
 234                                 dec->brightness = 0;
 235                         else
 236                                 dec->brightness = ctrl->value;
 237                         write_reg(client, 0x12, dec->brightness, dec->channel);
 238                         break;
 239                 case V4L2_CID_CONTRAST:
 240                         if (ctrl->value > 255)
 241                                 dec->contrast = 255;
 242                         else if (ctrl->value < 0)
 243                                 dec->contrast = 0;
 244                         else
 245                                 dec->contrast = ctrl->value;
 246                         write_reg(client, 0x11, dec->contrast, dec->channel);
 247                         break;
 248                 case V4L2_CID_SATURATION:
 249                         if (ctrl->value > 255)
 250                                 dec->saturation = 255;
 251                         else if (ctrl->value < 0)
 252                                 dec->saturation = 0;
 253                         else
 254                                 dec->saturation = ctrl->value;
 255                         write_reg(client, 0x10, dec->saturation, dec->channel);
 256                         break;
 257                 case V4L2_CID_HUE:
 258                         if (ctrl->value > 255)
 259                                 dec->hue = 255;
 260                         else if (ctrl->value < 0)
 261                                 dec->hue = 0;
 262                         else
 263                                 dec->hue = ctrl->value;
 264                         write_reg(client, 0x0f, dec->hue, dec->channel);
 265                         break;
 266                 }
 267                 break;
 268         }
 269         case VIDIOC_G_CTRL:
 270         {
 271                 struct v4l2_control *ctrl = arg;
 272
 273                 switch (ctrl->id) {
 274                 case V4L2_CID_BRIGHTNESS:
 275                         ctrl->value = dec->brightness;
 276                         break;
 277                 case V4L2_CID_CONTRAST:
 278                         ctrl->value = dec->contrast;
 279                         break;
 280                 case V4L2_CID_SATURATION:
 281                         ctrl->value = dec->saturation;
 282                         break;
 283                 case V4L2_CID_HUE:
 284                         ctrl->value = dec->hue;
 285                         break;
 286                 }
 287                 break;
 288         }
 289         default:
 290                 break;
 291         }
 292         return 0;
 293 }
 294
 295 static struct i2c_driver wis_tw2804_driver;
 296
 297 static struct i2c_client wis_tw2804_client_templ = {
 298         .name           = "TW2804 (WIS)",
 299         .driver         = &wis_tw2804_driver,
 300 };
 301
 302 static int wis_tw2804_detect(struct i2c_adapter *adapter, int addr, int kind)
 303 {
 304         struct i2c_client *client;
 305         struct wis_tw2804 *dec;
 306
 307         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 308                 return 0;
 309
 310         client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL);
 311         if (client == NULL)
 312                 return -ENOMEM;
 313         memcpy(client, &wis_tw2804_client_templ,
 314                         sizeof(wis_tw2804_client_templ));
 315         client->adapter = adapter;
 316         client->addr = addr;
 317
 318         dec = kmalloc(sizeof(struct wis_tw2804), GFP_KERNEL);
 319         if (dec == NULL) {
 320                 kfree(client);
 321                 return -ENOMEM;
 322         }
 323         dec->channel = -1;
 324         dec->norm = V4L2_STD_NTSC;
 325         dec->brightness = 128;
 326         dec->contrast = 128;
 327         dec->saturation = 128;
 328         dec->hue = 128;
 329         i2c_set_clientdata(client, dec);
 330
 331         printk(KERN_DEBUG "wis-tw2804: creating TW2804 at address %d on %s\n",
 332                 addr, adapter->name);
 333
 334         i2c_attach_client(client);
 335         return 0;
 336 }
 337
 338 static int wis_tw2804_detach(struct i2c_client *client)
 339 {
 340         struct wis_tw2804 *dec = i2c_get_clientdata(client);
 341         int r;
 342
 343         r = i2c_detach_client(client);
 344         if (r < 0)
 345                 return r;
 346
 347         kfree(client);
 348         kfree(dec);
 349         return 0;
 350 }
 351
 352 static struct i2c_driver wis_tw2804_driver = {
 353         .driver = {
 354                 .name   = "WIS TW2804 I2C driver",
 355         },
 356         .id             = I2C_DRIVERID_WIS_TW2804,
 357         .detach_client  = wis_tw2804_detach,
 358         .command        = wis_tw2804_command,
 359 };
 360
 361 static int __init wis_tw2804_init(void)
 362 {
 363         int r;
 364
 365         r = i2c_add_driver(&wis_tw2804_driver);
 366         if (r < 0)
 367                 return r;
 368         return wis_i2c_add_driver(wis_tw2804_driver.id, wis_tw2804_detect);
 369 }
 370
 371 static void __exit wis_tw2804_cleanup(void)
 372 {
 373         wis_i2c_del_driver(wis_tw2804_detect);
 374         i2c_del_driver(&wis_tw2804_driver);
 375 }
 376
 377 module_init(wis_tw2804_init);
 378 module_exit(wis_tw2804_cleanup);
 379
 380 MODULE_LICENSE("GPL v2");