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 #include <media/v4l2-device.h> 24 #include <media/v4l2-ctrls.h> 25 #include <linux/slab.h> 26 27 MODULE_DESCRIPTION("TW9903 I2C subdev driver"); 28 MODULE_LICENSE("GPL v2"); 29 30 /* 31 * This driver is based on the wis-tw9903.c source that was in 32 * drivers/staging/media/go7007. That source had commented out code for 33 * saturation and scaling (neither seemed to work). If anyone ever gets 34 * hardware to test this driver, then that code might be useful to look at. 35 * You need to get the kernel sources of, say, kernel 3.8 where that 36 * wis-tw9903 driver is still present. 37 */ 38 39 struct tw9903 { 40 struct v4l2_subdev sd; 41 struct v4l2_ctrl_handler hdl; 42 v4l2_std_id norm; 43 }; 44 45 static inline struct tw9903 *to_state(struct v4l2_subdev *sd) 46 { 47 return container_of(sd, struct tw9903, sd); 48 } 49 50 static const u8 initial_registers[] = { 51 0x02, 0x44, /* input 1, composite */ 52 0x03, 0x92, /* correct digital format */ 53 0x04, 0x00, 54 0x05, 0x80, /* or 0x00 for PAL */ 55 0x06, 0x40, /* second internal current reference */ 56 0x07, 0x02, /* window */ 57 0x08, 0x14, /* window */ 58 0x09, 0xf0, /* window */ 59 0x0a, 0x81, /* window */ 60 0x0b, 0xd0, /* window */ 61 0x0c, 0x8c, 62 0x0d, 0x00, /* scaling */ 63 0x0e, 0x11, /* scaling */ 64 0x0f, 0x00, /* scaling */ 65 0x10, 0x00, /* brightness */ 66 0x11, 0x60, /* contrast */ 67 0x12, 0x01, /* sharpness */ 68 0x13, 0x7f, /* U gain */ 69 0x14, 0x5a, /* V gain */ 70 0x15, 0x00, /* hue */ 71 0x16, 0xc3, /* sharpness */ 72 0x18, 0x00, 73 0x19, 0x58, /* vbi */ 74 0x1a, 0x80, 75 0x1c, 0x0f, /* video norm */ 76 0x1d, 0x7f, /* video norm */ 77 0x20, 0xa0, /* clamping gain (working 0x50) */ 78 0x21, 0x22, 79 0x22, 0xf0, 80 0x23, 0xfe, 81 0x24, 0x3c, 82 0x25, 0x38, 83 0x26, 0x44, 84 0x27, 0x20, 85 0x28, 0x00, 86 0x29, 0x15, 87 0x2a, 0xa0, 88 0x2b, 0x44, 89 0x2c, 0x37, 90 0x2d, 0x00, 91 0x2e, 0xa5, /* burst PLL control (working: a9) */ 92 0x2f, 0xe0, /* 0xea is blue test frame -- 0xe0 for normal */ 93 0x31, 0x00, 94 0x33, 0x22, 95 0x34, 0x11, 96 0x35, 0x35, 97 0x3b, 0x05, 98 0x06, 0xc0, /* reset device */ 99 0x00, 0x00, /* Terminator (reg 0x00 is read-only) */ 100 }; 101 102 static int write_reg(struct v4l2_subdev *sd, u8 reg, u8 value) 103 { 104 struct i2c_client *client = v4l2_get_subdevdata(sd); 105 106 return i2c_smbus_write_byte_data(client, reg, value); 107 } 108 109 static int write_regs(struct v4l2_subdev *sd, const u8 *regs) 110 { 111 int i; 112 113 for (i = 0; regs[i] != 0x00; i += 2) 114 if (write_reg(sd, regs[i], regs[i + 1]) < 0) 115 return -1; 116 return 0; 117 } 118 119 static int tw9903_s_video_routing(struct v4l2_subdev *sd, u32 input, 120 u32 output, u32 config) 121 { 122 write_reg(sd, 0x02, 0x40 | (input << 1)); 123 return 0; 124 } 125 126 static int tw9903_s_std(struct v4l2_subdev *sd, v4l2_std_id norm) 127 { 128 struct tw9903 *dec = to_state(sd); 129 bool is_60hz = norm & V4L2_STD_525_60; 130 static const u8 config_60hz[] = { 131 0x05, 0x80, 132 0x07, 0x02, 133 0x08, 0x14, 134 0x09, 0xf0, 135 0, 0, 136 }; 137 static const u8 config_50hz[] = { 138 0x05, 0x00, 139 0x07, 0x12, 140 0x08, 0x18, 141 0x09, 0x20, 142 0, 0, 143 }; 144 145 write_regs(sd, is_60hz ? config_60hz : config_50hz); 146 dec->norm = norm; 147 return 0; 148 } 149 150 151 static int tw9903_s_ctrl(struct v4l2_ctrl *ctrl) 152 { 153 struct tw9903 *dec = container_of(ctrl->handler, struct tw9903, hdl); 154 struct v4l2_subdev *sd = &dec->sd; 155 156 switch (ctrl->id) { 157 case V4L2_CID_BRIGHTNESS: 158 write_reg(sd, 0x10, ctrl->val); 159 break; 160 case V4L2_CID_CONTRAST: 161 write_reg(sd, 0x11, ctrl->val); 162 break; 163 case V4L2_CID_HUE: 164 write_reg(sd, 0x15, ctrl->val); 165 break; 166 default: 167 return -EINVAL; 168 } 169 return 0; 170 } 171 172 static int tw9903_log_status(struct v4l2_subdev *sd) 173 { 174 struct tw9903 *dec = to_state(sd); 175 bool is_60hz = dec->norm & V4L2_STD_525_60; 176 177 v4l2_info(sd, "Standard: %d Hz\n", is_60hz ? 60 : 50); 178 v4l2_ctrl_subdev_log_status(sd); 179 return 0; 180 } 181 182 /* --------------------------------------------------------------------------*/ 183 184 static const struct v4l2_ctrl_ops tw9903_ctrl_ops = { 185 .s_ctrl = tw9903_s_ctrl, 186 }; 187 188 static const struct v4l2_subdev_core_ops tw9903_core_ops = { 189 .log_status = tw9903_log_status, 190 }; 191 192 static const struct v4l2_subdev_video_ops tw9903_video_ops = { 193 .s_std = tw9903_s_std, 194 .s_routing = tw9903_s_video_routing, 195 }; 196 197 static const struct v4l2_subdev_ops tw9903_ops = { 198 .core = &tw9903_core_ops, 199 .video = &tw9903_video_ops, 200 }; 201 202 /* --------------------------------------------------------------------------*/ 203 204 static int tw9903_probe(struct i2c_client *client, 205 const struct i2c_device_id *id) 206 { 207 struct tw9903 *dec; 208 struct v4l2_subdev *sd; 209 struct v4l2_ctrl_handler *hdl; 210 211 /* Check if the adapter supports the needed features */ 212 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 213 return -EIO; 214 215 v4l_info(client, "chip found @ 0x%02x (%s)\n", 216 client->addr << 1, client->adapter->name); 217 218 dec = devm_kzalloc(&client->dev, sizeof(*dec), GFP_KERNEL); 219 if (dec == NULL) 220 return -ENOMEM; 221 sd = &dec->sd; 222 v4l2_i2c_subdev_init(sd, client, &tw9903_ops); 223 hdl = &dec->hdl; 224 v4l2_ctrl_handler_init(hdl, 4); 225 v4l2_ctrl_new_std(hdl, &tw9903_ctrl_ops, 226 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0); 227 v4l2_ctrl_new_std(hdl, &tw9903_ctrl_ops, 228 V4L2_CID_CONTRAST, 0, 255, 1, 0x60); 229 v4l2_ctrl_new_std(hdl, &tw9903_ctrl_ops, 230 V4L2_CID_HUE, -128, 127, 1, 0); 231 sd->ctrl_handler = hdl; 232 if (hdl->error) { 233 int err = hdl->error; 234 235 v4l2_ctrl_handler_free(hdl); 236 return err; 237 } 238 239 /* Initialize tw9903 */ 240 dec->norm = V4L2_STD_NTSC; 241 242 if (write_regs(sd, initial_registers) < 0) { 243 v4l2_err(client, "error initializing TW9903\n"); 244 return -EINVAL; 245 } 246 247 return 0; 248 } 249 250 static int tw9903_remove(struct i2c_client *client) 251 { 252 struct v4l2_subdev *sd = i2c_get_clientdata(client); 253 254 v4l2_device_unregister_subdev(sd); 255 v4l2_ctrl_handler_free(&to_state(sd)->hdl); 256 return 0; 257 } 258 259 /* ----------------------------------------------------------------------- */ 260 261 static const struct i2c_device_id tw9903_id[] = { 262 { "tw9903", 0 }, 263 { } 264 }; 265 MODULE_DEVICE_TABLE(i2c, tw9903_id); 266 267 static struct i2c_driver tw9903_driver = { 268 .driver = { 269 .owner = THIS_MODULE, 270 .name = "tw9903", 271 }, 272 .probe = tw9903_probe, 273 .remove = tw9903_remove, 274 .id_table = tw9903_id, 275 }; 276 module_i2c_driver(tw9903_driver); 277