Pileus Git - ~andy/linux/blob - drivers/media/i2c/ths7303.c

   1 /*
   2  * ths7303/53- THS7303/53 Video Amplifier driver
   3  *
   4  * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
   5  * Copyright 2013 Cisco Systems, Inc. and/or its affiliates.
   6  *
   7  * Author: Chaithrika U S <chaithrika@ti.com>
   8  *
   9  * Contributors:
  10  *     Hans Verkuil <hans.verkuil@cisco.com>
  11  *     Lad, Prabhakar <prabhakar.lad@ti.com>
  12  *     Martin Bugge <marbugge@cisco.com>
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License as
  16  * published by the Free Software Foundation version 2.
  17  *
  18  * This program is distributed .as is. WITHOUT ANY WARRANTY of any
  19  * kind, whether express or implied; without even the implied warranty
  20  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  */
  23
  24 #include <linux/i2c.h>
  25 #include <linux/module.h>
  26 #include <linux/slab.h>
  27
  28 #include <media/ths7303.h>
  29 #include <media/v4l2-device.h>
  30
  31 #define THS7303_CHANNEL_1       1
  32 #define THS7303_CHANNEL_2       2
  33 #define THS7303_CHANNEL_3       3
  34
  35 struct ths7303_state {
  36         struct v4l2_subdev              sd;
  37         const struct ths7303_platform_data *pdata;
  38         struct v4l2_bt_timings          bt;
  39         int std_id;
  40         int stream_on;
  41 };
  42
  43 enum ths7303_filter_mode {
  44         THS7303_FILTER_MODE_480I_576I,
  45         THS7303_FILTER_MODE_480P_576P,
  46         THS7303_FILTER_MODE_720P_1080I,
  47         THS7303_FILTER_MODE_1080P,
  48         THS7303_FILTER_MODE_DISABLE
  49 };
  50
  51 MODULE_DESCRIPTION("TI THS7303 video amplifier driver");
  52 MODULE_AUTHOR("Chaithrika U S");
  53 MODULE_LICENSE("GPL");
  54
  55 static int debug;
  56 module_param(debug, int, 0644);
  57 MODULE_PARM_DESC(debug, "Debug level 0-1");
  58
  59 static inline struct ths7303_state *to_state(struct v4l2_subdev *sd)
  60 {
  61         return container_of(sd, struct ths7303_state, sd);
  62 }
  63
  64 static int ths7303_read(struct v4l2_subdev *sd, u8 reg)
  65 {
  66         struct i2c_client *client = v4l2_get_subdevdata(sd);
  67
  68         return i2c_smbus_read_byte_data(client, reg);
  69 }
  70
  71 static int ths7303_write(struct v4l2_subdev *sd, u8 reg, u8 val)
  72 {
  73         struct i2c_client *client = v4l2_get_subdevdata(sd);
  74         int ret;
  75         int i;
  76
  77         for (i = 0; i < 3; i++) {
  78                 ret = i2c_smbus_write_byte_data(client, reg, val);
  79                 if (ret == 0)
  80                         return 0;
  81         }
  82         return ret;
  83 }
  84
  85 /* following function is used to set ths7303 */
  86 int ths7303_setval(struct v4l2_subdev *sd, enum ths7303_filter_mode mode)
  87 {
  88         struct i2c_client *client = v4l2_get_subdevdata(sd);
  89         struct ths7303_state *state = to_state(sd);
  90         const struct ths7303_platform_data *pdata = state->pdata;
  91         u8 val, sel = 0;
  92         int err, disable = 0;
  93
  94         if (!client)
  95                 return -EINVAL;
  96
  97         switch (mode) {
  98         case THS7303_FILTER_MODE_1080P:
  99                 sel = 0x3;      /*1080p and SXGA/UXGA */
 100                 break;
 101         case THS7303_FILTER_MODE_720P_1080I:
 102                 sel = 0x2;      /*720p, 1080i and SVGA/XGA */
 103                 break;
 104         case THS7303_FILTER_MODE_480P_576P:
 105                 sel = 0x1;      /* EDTV 480p/576p and VGA */
 106                 break;
 107         case THS7303_FILTER_MODE_480I_576I:
 108                 sel = 0x0;      /* SDTV, S-Video, 480i/576i */
 109                 break;
 110         default:
 111                 /* disable all channels */
 112                 disable = 1;
 113         }
 114
 115         val = (sel << 6) | (sel << 3);
 116         if (!disable)
 117                 val |= (pdata->ch_1 & 0x27);
 118         err = ths7303_write(sd, THS7303_CHANNEL_1, val);
 119         if (err)
 120                 goto out;
 121
 122         val = (sel << 6) | (sel << 3);
 123         if (!disable)
 124                 val |= (pdata->ch_2 & 0x27);
 125         err = ths7303_write(sd, THS7303_CHANNEL_2, val);
 126         if (err)
 127                 goto out;
 128
 129         val = (sel << 6) | (sel << 3);
 130         if (!disable)
 131                 val |= (pdata->ch_3 & 0x27);
 132         err = ths7303_write(sd, THS7303_CHANNEL_3, val);
 133         if (err)
 134                 goto out;
 135
 136         return 0;
 137 out:
 138         pr_info("write byte data failed\n");
 139         return err;
 140 }
 141
 142 static int ths7303_s_std_output(struct v4l2_subdev *sd, v4l2_std_id norm)
 143 {
 144         struct ths7303_state *state = to_state(sd);
 145
 146         if (norm & (V4L2_STD_ALL & ~V4L2_STD_SECAM)) {
 147                 state->std_id = 1;
 148                 state->bt.pixelclock = 0;
 149                 return ths7303_setval(sd, THS7303_FILTER_MODE_480I_576I);
 150         }
 151
 152         return ths7303_setval(sd, THS7303_FILTER_MODE_DISABLE);
 153 }
 154
 155 static int ths7303_config(struct v4l2_subdev *sd)
 156 {
 157         struct ths7303_state *state = to_state(sd);
 158         int res;
 159
 160         if (!state->stream_on) {
 161                 ths7303_write(sd, THS7303_CHANNEL_1,
 162                               (ths7303_read(sd, THS7303_CHANNEL_1) & 0xf8) |
 163                               0x00);
 164                 ths7303_write(sd, THS7303_CHANNEL_2,
 165                               (ths7303_read(sd, THS7303_CHANNEL_2) & 0xf8) |
 166                               0x00);
 167                 ths7303_write(sd, THS7303_CHANNEL_3,
 168                               (ths7303_read(sd, THS7303_CHANNEL_3) & 0xf8) |
 169                               0x00);
 170                 return 0;
 171         }
 172
 173         if (state->bt.pixelclock > 120000000)
 174                 res = ths7303_setval(sd, THS7303_FILTER_MODE_1080P);
 175         else if (state->bt.pixelclock > 70000000)
 176                 res = ths7303_setval(sd, THS7303_FILTER_MODE_720P_1080I);
 177         else if (state->bt.pixelclock > 20000000)
 178                 res = ths7303_setval(sd, THS7303_FILTER_MODE_480P_576P);
 179         else if (state->std_id)
 180                 res = ths7303_setval(sd, THS7303_FILTER_MODE_480I_576I);
 181         else
 182                 /* disable all channels */
 183                 res = ths7303_setval(sd, THS7303_FILTER_MODE_DISABLE);
 184
 185         return res;
 186
 187 }
 188
 189 static int ths7303_s_stream(struct v4l2_subdev *sd, int enable)
 190 {
 191         struct ths7303_state *state = to_state(sd);
 192
 193         state->stream_on = enable;
 194
 195         return ths7303_config(sd);
 196 }
 197
 198 /* for setting filter for HD output */
 199 static int ths7303_s_dv_timings(struct v4l2_subdev *sd,
 200                                struct v4l2_dv_timings *dv_timings)
 201 {
 202         struct ths7303_state *state = to_state(sd);
 203
 204         if (!dv_timings || dv_timings->type != V4L2_DV_BT_656_1120)
 205                 return -EINVAL;
 206
 207         state->bt = dv_timings->bt;
 208         state->std_id = 0;
 209
 210         return ths7303_config(sd);
 211 }
 212
 213 static const struct v4l2_subdev_video_ops ths7303_video_ops = {
 214         .s_stream       = ths7303_s_stream,
 215         .s_std_output   = ths7303_s_std_output,
 216         .s_dv_timings   = ths7303_s_dv_timings,
 217 };
 218
 219 #ifdef CONFIG_VIDEO_ADV_DEBUG
 220
 221 static int ths7303_g_register(struct v4l2_subdev *sd,
 222                               struct v4l2_dbg_register *reg)
 223 {
 224         reg->size = 1;
 225         reg->val = ths7303_read(sd, reg->reg);
 226         return 0;
 227 }
 228
 229 static int ths7303_s_register(struct v4l2_subdev *sd,
 230                               const struct v4l2_dbg_register *reg)
 231 {
 232         ths7303_write(sd, reg->reg, reg->val);
 233         return 0;
 234 }
 235 #endif
 236
 237 static const char * const stc_lpf_sel_txt[4] = {
 238         "500-kHz Filter",
 239         "2.5-MHz Filter",
 240         "5-MHz Filter",
 241         "5-MHz Filter",
 242 };
 243
 244 static const char * const in_mux_sel_txt[2] = {
 245         "Input A Select",
 246         "Input B Select",
 247 };
 248
 249 static const char * const lpf_freq_sel_txt[4] = {
 250         "9-MHz LPF",
 251         "16-MHz LPF",
 252         "35-MHz LPF",
 253         "Bypass LPF",
 254 };
 255
 256 static const char * const in_bias_sel_dis_cont_txt[8] = {
 257         "Disable Channel",
 258         "Mute Function - No Output",
 259         "DC Bias Select",
 260         "DC Bias + 250 mV Offset Select",
 261         "AC Bias Select",
 262         "Sync Tip Clamp with low bias",
 263         "Sync Tip Clamp with mid bias",
 264         "Sync Tip Clamp with high bias",
 265 };
 266
 267 static void ths7303_log_channel_status(struct v4l2_subdev *sd, u8 reg)
 268 {
 269         u8 val = ths7303_read(sd, reg);
 270
 271         if ((val & 0x7) == 0) {
 272                 v4l2_info(sd, "Channel %d Off\n", reg);
 273                 return;
 274         }
 275
 276         v4l2_info(sd, "Channel %d On\n", reg);
 277         v4l2_info(sd, "  value 0x%x\n", val);
 278         v4l2_info(sd, "  %s\n", stc_lpf_sel_txt[(val >> 6) & 0x3]);
 279         v4l2_info(sd, "  %s\n", in_mux_sel_txt[(val >> 5) & 0x1]);
 280         v4l2_info(sd, "  %s\n", lpf_freq_sel_txt[(val >> 3) & 0x3]);
 281         v4l2_info(sd, "  %s\n", in_bias_sel_dis_cont_txt[(val >> 0) & 0x7]);
 282 }
 283
 284 static int ths7303_log_status(struct v4l2_subdev *sd)
 285 {
 286         struct ths7303_state *state = to_state(sd);
 287
 288         v4l2_info(sd, "stream %s\n", state->stream_on ? "On" : "Off");
 289
 290         if (state->bt.pixelclock) {
 291                 struct v4l2_bt_timings *bt = bt = &state->bt;
 292                 u32 frame_width, frame_height;
 293
 294                 frame_width = V4L2_DV_BT_FRAME_WIDTH(bt);
 295                 frame_height = V4L2_DV_BT_FRAME_HEIGHT(bt);
 296                 v4l2_info(sd,
 297                           "timings: %dx%d%s%d (%dx%d). Pix freq. = %d Hz. Polarities = 0x%x\n",
 298                           bt->width, bt->height, bt->interlaced ? "i" : "p",
 299                           (frame_height * frame_width) > 0 ?
 300                           (int)bt->pixelclock /
 301                           (frame_height * frame_width) : 0,
 302                           frame_width, frame_height,
 303                           (int)bt->pixelclock, bt->polarities);
 304         } else {
 305                 v4l2_info(sd, "no timings set\n");
 306         }
 307
 308         ths7303_log_channel_status(sd, THS7303_CHANNEL_1);
 309         ths7303_log_channel_status(sd, THS7303_CHANNEL_2);
 310         ths7303_log_channel_status(sd, THS7303_CHANNEL_3);
 311
 312         return 0;
 313 }
 314
 315 static const struct v4l2_subdev_core_ops ths7303_core_ops = {
 316         .log_status = ths7303_log_status,
 317 #ifdef CONFIG_VIDEO_ADV_DEBUG
 318         .g_register = ths7303_g_register,
 319         .s_register = ths7303_s_register,
 320 #endif
 321 };
 322
 323 static const struct v4l2_subdev_ops ths7303_ops = {
 324         .core   = &ths7303_core_ops,
 325         .video  = &ths7303_video_ops,
 326 };
 327
 328 static int ths7303_probe(struct i2c_client *client,
 329                         const struct i2c_device_id *id)
 330 {
 331         struct ths7303_platform_data *pdata = client->dev.platform_data;
 332         struct ths7303_state *state;
 333         struct v4l2_subdev *sd;
 334
 335         if (pdata == NULL) {
 336                 dev_err(&client->dev, "No platform data\n");
 337                 return -EINVAL;
 338         }
 339
 340         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
 341                 return -ENODEV;
 342
 343         v4l_info(client, "chip found @ 0x%x (%s)\n",
 344                         client->addr << 1, client->adapter->name);
 345
 346         state = devm_kzalloc(&client->dev, sizeof(struct ths7303_state),
 347                              GFP_KERNEL);
 348         if (!state)
 349                 return -ENOMEM;
 350
 351         state->pdata = pdata;
 352         sd = &state->sd;
 353         v4l2_i2c_subdev_init(sd, client, &ths7303_ops);
 354
 355         /* set to default 480I_576I filter mode */
 356         if (ths7303_setval(sd, THS7303_FILTER_MODE_480I_576I) < 0) {
 357                 v4l_err(client, "Setting to 480I_576I filter mode failed!\n");
 358                 return -EINVAL;
 359         }
 360
 361         return 0;
 362 }
 363
 364 static int ths7303_remove(struct i2c_client *client)
 365 {
 366         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 367
 368         v4l2_device_unregister_subdev(sd);
 369
 370         return 0;
 371 }
 372
 373 static const struct i2c_device_id ths7303_id[] = {
 374         {"ths7303", 0},
 375         {"ths7353", 0},
 376         {},
 377 };
 378
 379 MODULE_DEVICE_TABLE(i2c, ths7303_id);
 380
 381 static struct i2c_driver ths7303_driver = {
 382         .driver = {
 383                 .owner  = THIS_MODULE,
 384                 .name   = "ths73x3",
 385         },
 386         .probe          = ths7303_probe,
 387         .remove         = ths7303_remove,
 388         .id_table       = ths7303_id,
 389 };
 390
 391 module_i2c_driver(ths7303_driver);