drivers/media/i2c/ths7303.c

   1 /*
   2  * ths7303- THS7303 Video Amplifier driver
   3  *
   4  * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation version 2.
   9  *
  10  * This program is distributed .as is. WITHOUT ANY WARRANTY of any
  11  * kind, whether express or implied; without even the implied warranty
  12  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/init.h>
  18 #include <linux/ctype.h>
  19 #include <linux/slab.h>
  20 #include <linux/i2c.h>
  21 #include <linux/device.h>
  22 #include <linux/delay.h>
  23 #include <linux/module.h>
  24 #include <linux/uaccess.h>
  25 #include <linux/videodev2.h>
  26
  27 #include <media/v4l2-device.h>
  28 #include <media/v4l2-subdev.h>
  29 #include <media/v4l2-chip-ident.h>
  30
  31 #define THS7303_CHANNEL_1       1
  32 #define THS7303_CHANNEL_2       2
  33 #define THS7303_CHANNEL_3       3
  34
  35 enum ths7303_filter_mode {
  36         THS7303_FILTER_MODE_480I_576I,
  37         THS7303_FILTER_MODE_480P_576P,
  38         THS7303_FILTER_MODE_720P_1080I,
  39         THS7303_FILTER_MODE_1080P,
  40         THS7303_FILTER_MODE_DISABLE
  41 };
  42
  43 MODULE_DESCRIPTION("TI THS7303 video amplifier driver");
  44 MODULE_AUTHOR("Chaithrika U S");
  45 MODULE_LICENSE("GPL");
  46
  47 static int debug;
  48 module_param(debug, int, 0644);
  49 MODULE_PARM_DESC(debug, "Debug level 0-1");
  50
  51 /* following function is used to set ths7303 */
  52 int ths7303_setval(struct v4l2_subdev *sd, enum ths7303_filter_mode mode)
  53 {
  54         u8 input_bias_chroma = 3;
  55         u8 input_bias_luma = 3;
  56         int disable = 0;
  57         int err = 0;
  58         u8 val = 0;
  59         u8 temp;
  60
  61         struct i2c_client *client = v4l2_get_subdevdata(sd);
  62
  63         if (!client)
  64                 return -EINVAL;
  65
  66         switch (mode) {
  67         case THS7303_FILTER_MODE_1080P:
  68                 val = (3 << 6);
  69                 val |= (3 << 3);
  70                 break;
  71         case THS7303_FILTER_MODE_720P_1080I:
  72                 val = (2 << 6);
  73                 val |= (2 << 3);
  74                 break;
  75         case THS7303_FILTER_MODE_480P_576P:
  76                 val = (1 << 6);
  77                 val |= (1 << 3);
  78                 break;
  79         case THS7303_FILTER_MODE_480I_576I:
  80                 break;
  81         case THS7303_FILTER_MODE_DISABLE:
  82                 pr_info("mode disabled\n");
  83                 /* disable all channels */
  84                 disable = 1;
  85         default:
  86                 /* disable all channels */
  87                 disable = 1;
  88         }
  89         /* Setup channel 2 - Luma - Green */
  90         temp = val;
  91         if (!disable)
  92                 val |= input_bias_luma;
  93         err = i2c_smbus_write_byte_data(client, THS7303_CHANNEL_2, val);
  94         if (err)
  95                 goto out;
  96
  97         /* setup two chroma channels */
  98         if (!disable)
  99                 temp |= input_bias_chroma;
 100
 101         err = i2c_smbus_write_byte_data(client, THS7303_CHANNEL_1, temp);
 102         if (err)
 103                 goto out;
 104
 105         err = i2c_smbus_write_byte_data(client, THS7303_CHANNEL_3, temp);
 106         if (err)
 107                 goto out;
 108         return err;
 109 out:
 110         pr_info("write byte data failed\n");
 111         return err;
 112 }
 113
 114 static int ths7303_s_std_output(struct v4l2_subdev *sd, v4l2_std_id norm)
 115 {
 116         if (norm & (V4L2_STD_ALL & ~V4L2_STD_SECAM))
 117                 return ths7303_setval(sd, THS7303_FILTER_MODE_480I_576I);
 118         else
 119                 return ths7303_setval(sd, THS7303_FILTER_MODE_DISABLE);
 120 }
 121
 122 /* for setting filter for HD output */
 123 static int ths7303_s_dv_timings(struct v4l2_subdev *sd,
 124                                struct v4l2_dv_timings *dv_timings)
 125 {
 126         u32 height = dv_timings->bt.height;
 127         int interlaced = dv_timings->bt.interlaced;
 128         int res = 0;
 129
 130         if (height == 1080 && !interlaced)
 131                 res = ths7303_setval(sd, THS7303_FILTER_MODE_1080P);
 132         else if ((height == 720 && !interlaced) ||
 133                         (height == 1080 && interlaced))
 134                 res = ths7303_setval(sd, THS7303_FILTER_MODE_720P_1080I);
 135         else if ((height == 480 || height == 576) && !interlaced)
 136                 res = ths7303_setval(sd, THS7303_FILTER_MODE_480P_576P);
 137         else
 138                 /* disable all channels */
 139                 res = ths7303_setval(sd, THS7303_FILTER_MODE_DISABLE);
 140
 141         return res;
 142 }
 143
 144 static int ths7303_g_chip_ident(struct v4l2_subdev *sd,
 145                                 struct v4l2_dbg_chip_ident *chip)
 146 {
 147         struct i2c_client *client = v4l2_get_subdevdata(sd);
 148
 149         return v4l2_chip_ident_i2c_client(client, chip, V4L2_IDENT_THS7303, 0);
 150 }
 151
 152 static const struct v4l2_subdev_video_ops ths7303_video_ops = {
 153         .s_std_output   = ths7303_s_std_output,
 154         .s_dv_timings    = ths7303_s_dv_timings,
 155 };
 156
 157 static const struct v4l2_subdev_core_ops ths7303_core_ops = {
 158         .g_chip_ident = ths7303_g_chip_ident,
 159 };
 160
 161 static const struct v4l2_subdev_ops ths7303_ops = {
 162         .core   = &ths7303_core_ops,
 163         .video  = &ths7303_video_ops,
 164 };
 165
 166 static int ths7303_probe(struct i2c_client *client,
 167                         const struct i2c_device_id *id)
 168 {
 169         struct v4l2_subdev *sd;
 170         v4l2_std_id std_id = V4L2_STD_NTSC;
 171
 172         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 173                 return -ENODEV;
 174
 175         v4l_info(client, "chip found @ 0x%x (%s)\n",
 176                         client->addr << 1, client->adapter->name);
 177
 178         sd = kzalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
 179         if (sd == NULL)
 180                 return -ENOMEM;
 181
 182         v4l2_i2c_subdev_init(sd, client, &ths7303_ops);
 183
 184         return ths7303_s_std_output(sd, std_id);
 185 }
 186
 187 static int ths7303_remove(struct i2c_client *client)
 188 {
 189         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 190
 191         v4l2_device_unregister_subdev(sd);
 192         kfree(sd);
 193
 194         return 0;
 195 }
 196
 197 static const struct i2c_device_id ths7303_id[] = {
 198         {"ths7303", 0},
 199         {},
 200 };
 201
 202 MODULE_DEVICE_TABLE(i2c, ths7303_id);
 203
 204 static struct i2c_driver ths7303_driver = {
 205         .driver = {
 206                 .owner  = THIS_MODULE,
 207                 .name   = "ths7303",
 208         },
 209         .probe          = ths7303_probe,
 210         .remove         = ths7303_remove,
 211         .id_table       = ths7303_id,
 212 };
 213
 214 module_i2c_driver(ths7303_driver);