blob: 377bf05b1efd20a3dea2e4a048fc04c44b2f5d6d [file] [log] [blame]
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * bt819 - BT819A VideoStream Decoder (Rockwell Part)
3 *
4 * Copyright (C) 1999 Mike Bernson <mike@mlb.org>
5 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
6 *
7 * Modifications for LML33/DC10plus unified driver
8 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03009 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
11 * - moved over to linux>=2.4.x i2c protocol (9/9/2002)
12 *
13 * This code was modify/ported from the saa7111 driver written
14 * by Dave Perks.
15 *
16 * This program is free software; you can redistribute it and/or modify
17 * it under the terms of the GNU General Public License as published by
18 * the Free Software Foundation; either version 2 of the License, or
19 * (at your option) any later version.
20 *
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
25 *
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
29 */
30
31#include <linux/module.h>
Mauro Carvalho Chehab18f3fa12007-07-02 15:39:57 -030032#include <linux/types.h>
Hans Verkuil7fd011f2008-10-13 07:30:15 -030033#include <linux/ioctl.h>
Hans Verkuil28839132009-02-19 08:08:07 -030034#include <linux/delay.h>
Hans Verkuil7fd011f2008-10-13 07:30:15 -030035#include <linux/i2c.h>
Hans Verkuilc2179ad2009-02-19 06:36:36 -030036#include <linux/videodev2.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
Hans Verkuilc2179ad2009-02-19 06:36:36 -030038#include <media/v4l2-device.h>
39#include <media/v4l2-chip-ident.h>
Hans Verkuilbd84a652010-12-12 08:19:41 -030040#include <media/v4l2-ctrls.h>
Hans Verkuil1cd3c0f2009-03-08 17:04:38 -030041#include <media/bt819.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43MODULE_DESCRIPTION("Brooktree-819 video decoder driver");
44MODULE_AUTHOR("Mike Bernson & Dave Perks");
45MODULE_LICENSE("GPL");
46
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030047static int debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048module_param(debug, int, 0);
49MODULE_PARM_DESC(debug, "Debug level (0-1)");
50
Hans Verkuilc2179ad2009-02-19 06:36:36 -030051
Linus Torvalds1da177e2005-04-16 15:20:36 -070052/* ----------------------------------------------------------------------- */
53
54struct bt819 {
Hans Verkuilc2179ad2009-02-19 06:36:36 -030055 struct v4l2_subdev sd;
Hans Verkuilbd84a652010-12-12 08:19:41 -030056 struct v4l2_ctrl_handler hdl;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 unsigned char reg[32];
58
Hans Verkuil107063c2009-02-18 17:26:06 -030059 v4l2_std_id norm;
Hans Verkuilc2179ad2009-02-19 06:36:36 -030060 int ident;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 int input;
62 int enable;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063};
64
Hans Verkuilc2179ad2009-02-19 06:36:36 -030065static inline struct bt819 *to_bt819(struct v4l2_subdev *sd)
66{
67 return container_of(sd, struct bt819, sd);
68}
69
Hans Verkuilbd84a652010-12-12 08:19:41 -030070static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
71{
72 return &container_of(ctrl->handler, struct bt819, hdl)->sd;
73}
74
Linus Torvalds1da177e2005-04-16 15:20:36 -070075struct timing {
76 int hactive;
77 int hdelay;
78 int vactive;
79 int vdelay;
80 int hscale;
81 int vscale;
82};
83
84/* for values, see the bt819 datasheet */
85static struct timing timing_data[] = {
86 {864 - 24, 20, 625 - 2, 1, 0x0504, 0x0000},
87 {858 - 24, 20, 525 - 2, 1, 0x00f8, 0x0000},
88};
89
Linus Torvalds1da177e2005-04-16 15:20:36 -070090/* ----------------------------------------------------------------------- */
91
Hans Verkuilc2179ad2009-02-19 06:36:36 -030092static inline int bt819_write(struct bt819 *decoder, u8 reg, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
Hans Verkuilc2179ad2009-02-19 06:36:36 -030094 struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095
96 decoder->reg[reg] = value;
97 return i2c_smbus_write_byte_data(client, reg, value);
98}
99
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300100static inline int bt819_setbit(struct bt819 *decoder, u8 reg, u8 bit, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300102 return bt819_write(decoder, reg,
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300103 (decoder->reg[reg] & ~(1 << bit)) | (value ? (1 << bit) : 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300106static int bt819_write_block(struct bt819 *decoder, const u8 *data, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107{
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300108 struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 int ret = -1;
110 u8 reg;
111
112 /* the bt819 has an autoincrement function, use it if
113 * the adapter understands raw I2C */
114 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
115 /* do raw I2C, not smbus compatible */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 u8 block_data[32];
Jean Delvare9aa45e32006-03-22 03:48:35 -0300117 int block_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 while (len >= 2) {
Jean Delvare9aa45e32006-03-22 03:48:35 -0300120 block_len = 0;
121 block_data[block_len++] = reg = data[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 do {
Jean Delvare9aa45e32006-03-22 03:48:35 -0300123 block_data[block_len++] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 decoder->reg[reg++] = data[1];
125 len -= 2;
126 data += 2;
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300127 } while (len >= 2 && data[0] == reg && block_len < 32);
128 ret = i2c_master_send(client, block_data, block_len);
129 if (ret < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 break;
131 }
132 } else {
133 /* do some slow I2C emulation kind of thing */
134 while (len >= 2) {
135 reg = *data++;
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300136 ret = bt819_write(decoder, reg, *data++);
137 if (ret < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 break;
139 len -= 2;
140 }
141 }
142
143 return ret;
144}
145
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300146static inline int bt819_read(struct bt819 *decoder, u8 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300148 struct i2c_client *client = v4l2_get_subdevdata(&decoder->sd);
149
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 return i2c_smbus_read_byte_data(client, reg);
151}
152
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300153static int bt819_init(struct v4l2_subdev *sd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 static unsigned char init[] = {
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300156 /*0x1f, 0x00,*/ /* Reset */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 0x01, 0x59, /* 0x01 input format */
158 0x02, 0x00, /* 0x02 temporal decimation */
159 0x03, 0x12, /* 0x03 Cropping msb */
160 0x04, 0x16, /* 0x04 Vertical Delay, lsb */
161 0x05, 0xe0, /* 0x05 Vertical Active lsb */
162 0x06, 0x80, /* 0x06 Horizontal Delay lsb */
163 0x07, 0xd0, /* 0x07 Horizontal Active lsb */
164 0x08, 0x00, /* 0x08 Horizontal Scaling msb */
165 0x09, 0xf8, /* 0x09 Horizontal Scaling lsb */
166 0x0a, 0x00, /* 0x0a Brightness control */
167 0x0b, 0x30, /* 0x0b Miscellaneous control */
168 0x0c, 0xd8, /* 0x0c Luma Gain lsb */
169 0x0d, 0xfe, /* 0x0d Chroma Gain (U) lsb */
170 0x0e, 0xb4, /* 0x0e Chroma Gain (V) msb */
171 0x0f, 0x00, /* 0x0f Hue control */
172 0x12, 0x04, /* 0x12 Output Format */
173 0x13, 0x20, /* 0x13 Vertial Scaling msb 0x00
174 chroma comb OFF, line drop scaling, interlace scaling
175 BUG? Why does turning the chroma comb on fuck up color?
176 Bug in the bt819 stepping on my board?
177 */
178 0x14, 0x00, /* 0x14 Vertial Scaling lsb */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300179 0x16, 0x07, /* 0x16 Video Timing Polarity
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 ACTIVE=active low
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300181 FIELD: high=odd,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 vreset=active high,
183 hreset=active high */
184 0x18, 0x68, /* 0x18 AGC Delay */
185 0x19, 0x5d, /* 0x19 Burst Gate Delay */
186 0x1a, 0x80, /* 0x1a ADC Interface */
187 };
188
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300189 struct bt819 *decoder = to_bt819(sd);
Hans Verkuil107063c2009-02-18 17:26:06 -0300190 struct timing *timing = &timing_data[(decoder->norm & V4L2_STD_525_60) ? 1 : 0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
192 init[0x03 * 2 - 1] =
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300193 (((timing->vdelay >> 8) & 0x03) << 6) |
194 (((timing->vactive >> 8) & 0x03) << 4) |
195 (((timing->hdelay >> 8) & 0x03) << 2) |
196 ((timing->hactive >> 8) & 0x03);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 init[0x04 * 2 - 1] = timing->vdelay & 0xff;
198 init[0x05 * 2 - 1] = timing->vactive & 0xff;
199 init[0x06 * 2 - 1] = timing->hdelay & 0xff;
200 init[0x07 * 2 - 1] = timing->hactive & 0xff;
201 init[0x08 * 2 - 1] = timing->hscale >> 8;
202 init[0x09 * 2 - 1] = timing->hscale & 0xff;
203 /* 0x15 in array is address 0x19 */
Hans Verkuil107063c2009-02-18 17:26:06 -0300204 init[0x15 * 2 - 1] = (decoder->norm & V4L2_STD_625_50) ? 115 : 93; /* Chroma burst delay */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 /* reset */
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300206 bt819_write(decoder, 0x1f, 0x00);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 mdelay(1);
208
209 /* init */
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300210 return bt819_write_block(decoder, init, sizeof(init));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211}
212
213/* ----------------------------------------------------------------------- */
214
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300215static int bt819_status(struct v4l2_subdev *sd, u32 *pstatus, v4l2_std_id *pstd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300217 struct bt819 *decoder = to_bt819(sd);
218 int status = bt819_read(decoder, 0x00);
219 int res = V4L2_IN_ST_NO_SIGNAL;
220 v4l2_std_id std;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300222 if ((status & 0x80))
223 res = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300225 if ((status & 0x10))
226 std = V4L2_STD_PAL;
227 else
228 std = V4L2_STD_NTSC;
229 if (pstd)
230 *pstd = std;
231 if (pstatus)
Hans Verkuilba088312011-08-25 10:52:53 -0300232 *pstatus = res;
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300233
234 v4l2_dbg(1, debug, sd, "get status %x\n", status);
235 return 0;
236}
237
238static int bt819_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
239{
240 return bt819_status(sd, NULL, std);
241}
242
243static int bt819_g_input_status(struct v4l2_subdev *sd, u32 *status)
244{
245 return bt819_status(sd, status, NULL);
246}
247
248static int bt819_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
249{
250 struct bt819 *decoder = to_bt819(sd);
251 struct timing *timing = NULL;
252
Hans Verkuilcc5cef82009-03-06 10:15:01 -0300253 v4l2_dbg(1, debug, sd, "set norm %llx\n", (unsigned long long)std);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300254
Hans Verkuil1cd3c0f2009-03-08 17:04:38 -0300255 if (sd->v4l2_dev == NULL || sd->v4l2_dev->notify == NULL)
256 v4l2_err(sd, "no notify found!\n");
257
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300258 if (std & V4L2_STD_NTSC) {
Márton Némethb9fb9b72010-01-16 14:08:39 -0300259 v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300260 bt819_setbit(decoder, 0x01, 0, 1);
261 bt819_setbit(decoder, 0x01, 1, 0);
262 bt819_setbit(decoder, 0x01, 5, 0);
263 bt819_write(decoder, 0x18, 0x68);
264 bt819_write(decoder, 0x19, 0x5d);
265 /* bt819_setbit(decoder, 0x1a, 5, 1); */
266 timing = &timing_data[1];
267 } else if (std & V4L2_STD_PAL) {
Márton Némethb9fb9b72010-01-16 14:08:39 -0300268 v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300269 bt819_setbit(decoder, 0x01, 0, 1);
270 bt819_setbit(decoder, 0x01, 1, 1);
271 bt819_setbit(decoder, 0x01, 5, 1);
272 bt819_write(decoder, 0x18, 0x7f);
273 bt819_write(decoder, 0x19, 0x72);
274 /* bt819_setbit(decoder, 0x1a, 5, 0); */
275 timing = &timing_data[0];
276 } else {
Hans Verkuilcc5cef82009-03-06 10:15:01 -0300277 v4l2_dbg(1, debug, sd, "unsupported norm %llx\n",
278 (unsigned long long)std);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300279 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 }
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300281 bt819_write(decoder, 0x03,
282 (((timing->vdelay >> 8) & 0x03) << 6) |
283 (((timing->vactive >> 8) & 0x03) << 4) |
284 (((timing->hdelay >> 8) & 0x03) << 2) |
285 ((timing->hactive >> 8) & 0x03));
286 bt819_write(decoder, 0x04, timing->vdelay & 0xff);
287 bt819_write(decoder, 0x05, timing->vactive & 0xff);
288 bt819_write(decoder, 0x06, timing->hdelay & 0xff);
289 bt819_write(decoder, 0x07, timing->hactive & 0xff);
290 bt819_write(decoder, 0x08, (timing->hscale >> 8) & 0xff);
291 bt819_write(decoder, 0x09, timing->hscale & 0xff);
292 decoder->norm = std;
Márton Némethb9fb9b72010-01-16 14:08:39 -0300293 v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300294 return 0;
295}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Hans Verkuil5325b422009-04-02 11:26:22 -0300297static int bt819_s_routing(struct v4l2_subdev *sd,
298 u32 input, u32 output, u32 config)
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300299{
300 struct bt819 *decoder = to_bt819(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Hans Verkuil5325b422009-04-02 11:26:22 -0300302 v4l2_dbg(1, debug, sd, "set input %x\n", input);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
Roel Kluinf14a2972009-10-23 07:59:42 -0300304 if (input > 7)
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300305 return -EINVAL;
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300306
Hans Verkuil1cd3c0f2009-03-08 17:04:38 -0300307 if (sd->v4l2_dev == NULL || sd->v4l2_dev->notify == NULL)
308 v4l2_err(sd, "no notify found!\n");
309
Hans Verkuil5325b422009-04-02 11:26:22 -0300310 if (decoder->input != input) {
Márton Némethb9fb9b72010-01-16 14:08:39 -0300311 v4l2_subdev_notify(sd, BT819_FIFO_RESET_LOW, NULL);
Hans Verkuil5325b422009-04-02 11:26:22 -0300312 decoder->input = input;
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300313 /* select mode */
314 if (decoder->input == 0) {
315 bt819_setbit(decoder, 0x0b, 6, 0);
316 bt819_setbit(decoder, 0x1a, 1, 1);
Hans Verkuil107063c2009-02-18 17:26:06 -0300317 } else {
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300318 bt819_setbit(decoder, 0x0b, 6, 1);
319 bt819_setbit(decoder, 0x1a, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 }
Márton Némethb9fb9b72010-01-16 14:08:39 -0300321 v4l2_subdev_notify(sd, BT819_FIFO_RESET_HIGH, NULL);
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300322 }
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300323 return 0;
324}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300326static int bt819_s_stream(struct v4l2_subdev *sd, int enable)
327{
328 struct bt819 *decoder = to_bt819(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300330 v4l2_dbg(1, debug, sd, "enable output %x\n", enable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300332 if (decoder->enable != enable) {
333 decoder->enable = enable;
334 bt819_setbit(decoder, 0x16, 7, !enable);
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300335 }
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300336 return 0;
337}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Hans Verkuilbd84a652010-12-12 08:19:41 -0300339static int bt819_s_ctrl(struct v4l2_ctrl *ctrl)
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300340{
Hans Verkuilbd84a652010-12-12 08:19:41 -0300341 struct v4l2_subdev *sd = to_sd(ctrl);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300342 struct bt819 *decoder = to_bt819(sd);
343 int temp;
344
345 switch (ctrl->id) {
346 case V4L2_CID_BRIGHTNESS:
Hans Verkuilbd84a652010-12-12 08:19:41 -0300347 bt819_write(decoder, 0x0a, ctrl->val);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300348 break;
349
350 case V4L2_CID_CONTRAST:
Hans Verkuilbd84a652010-12-12 08:19:41 -0300351 bt819_write(decoder, 0x0c, ctrl->val & 0xff);
352 bt819_setbit(decoder, 0x0b, 2, ((ctrl->val >> 8) & 0x01));
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300353 break;
354
355 case V4L2_CID_SATURATION:
Hans Verkuilbd84a652010-12-12 08:19:41 -0300356 bt819_write(decoder, 0x0d, (ctrl->val >> 7) & 0xff);
357 bt819_setbit(decoder, 0x0b, 1, ((ctrl->val >> 15) & 0x01));
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300358
359 /* Ratio between U gain and V gain must stay the same as
360 the ratio between the default U and V gain values. */
Hans Verkuilbd84a652010-12-12 08:19:41 -0300361 temp = (ctrl->val * 180) / 254;
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300362 bt819_write(decoder, 0x0e, (temp >> 7) & 0xff);
363 bt819_setbit(decoder, 0x0b, 0, (temp >> 15) & 0x01);
364 break;
365
366 case V4L2_CID_HUE:
Hans Verkuilbd84a652010-12-12 08:19:41 -0300367 bt819_write(decoder, 0x0f, ctrl->val);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300368 break;
369
370 default:
371 return -EINVAL;
372 }
373 return 0;
374}
375
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300376static int bt819_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
377{
378 struct bt819 *decoder = to_bt819(sd);
379 struct i2c_client *client = v4l2_get_subdevdata(sd);
380
381 return v4l2_chip_ident_i2c_client(client, chip, decoder->ident, 0);
382}
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384/* ----------------------------------------------------------------------- */
385
Hans Verkuilbd84a652010-12-12 08:19:41 -0300386static const struct v4l2_ctrl_ops bt819_ctrl_ops = {
387 .s_ctrl = bt819_s_ctrl,
388};
389
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300390static const struct v4l2_subdev_core_ops bt819_core_ops = {
391 .g_chip_ident = bt819_g_chip_ident,
Hans Verkuilbd84a652010-12-12 08:19:41 -0300392 .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
393 .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
394 .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
395 .g_ctrl = v4l2_subdev_g_ctrl,
396 .s_ctrl = v4l2_subdev_s_ctrl,
397 .queryctrl = v4l2_subdev_queryctrl,
398 .querymenu = v4l2_subdev_querymenu,
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300399 .s_std = bt819_s_std,
400};
401
402static const struct v4l2_subdev_video_ops bt819_video_ops = {
403 .s_routing = bt819_s_routing,
404 .s_stream = bt819_s_stream,
405 .querystd = bt819_querystd,
406 .g_input_status = bt819_g_input_status,
407};
408
409static const struct v4l2_subdev_ops bt819_ops = {
410 .core = &bt819_core_ops,
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300411 .video = &bt819_video_ops,
412};
413
414/* ----------------------------------------------------------------------- */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300415
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300416static int bt819_probe(struct i2c_client *client,
417 const struct i2c_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418{
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300419 int i, ver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 struct bt819 *decoder;
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300421 struct v4l2_subdev *sd;
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300422 const char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 /* Check if the adapter supports the needed features */
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300425 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
426 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300428 decoder = kzalloc(sizeof(struct bt819), GFP_KERNEL);
429 if (decoder == NULL)
430 return -ENOMEM;
431 sd = &decoder->sd;
432 v4l2_i2c_subdev_init(sd, client, &bt819_ops);
433
434 ver = bt819_read(decoder, 0x17);
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300435 switch (ver & 0xf0) {
436 case 0x70:
437 name = "bt819a";
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300438 decoder->ident = V4L2_IDENT_BT819A;
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300439 break;
440 case 0x60:
441 name = "bt817a";
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300442 decoder->ident = V4L2_IDENT_BT817A;
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300443 break;
444 case 0x20:
445 name = "bt815a";
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300446 decoder->ident = V4L2_IDENT_BT815A;
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300447 break;
448 default:
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300449 v4l2_dbg(1, debug, sd,
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300450 "unknown chip version 0x%02x\n", ver);
451 return -ENODEV;
452 }
453
454 v4l_info(client, "%s found @ 0x%x (%s)\n", name,
455 client->addr << 1, client->adapter->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Hans Verkuil107063c2009-02-18 17:26:06 -0300457 decoder->norm = V4L2_STD_NTSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 decoder->input = 0;
459 decoder->enable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300461 i = bt819_init(sd);
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300462 if (i < 0)
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300463 v4l2_dbg(1, debug, sd, "init status %d\n", i);
Hans Verkuilbd84a652010-12-12 08:19:41 -0300464
465 v4l2_ctrl_handler_init(&decoder->hdl, 4);
466 v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
467 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0);
468 v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
469 V4L2_CID_CONTRAST, 0, 511, 1, 0xd8);
470 v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
471 V4L2_CID_SATURATION, 0, 511, 1, 0xfe);
472 v4l2_ctrl_new_std(&decoder->hdl, &bt819_ctrl_ops,
473 V4L2_CID_HUE, -128, 127, 1, 0);
474 sd->ctrl_handler = &decoder->hdl;
475 if (decoder->hdl.error) {
476 int err = decoder->hdl.error;
477
478 v4l2_ctrl_handler_free(&decoder->hdl);
479 kfree(decoder);
480 return err;
481 }
482 v4l2_ctrl_handler_setup(&decoder->hdl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 return 0;
484}
485
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300486static int bt819_remove(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300488 struct v4l2_subdev *sd = i2c_get_clientdata(client);
Hans Verkuilbd84a652010-12-12 08:19:41 -0300489 struct bt819 *decoder = to_bt819(sd);
Hans Verkuilc2179ad2009-02-19 06:36:36 -0300490
491 v4l2_device_unregister_subdev(sd);
Hans Verkuilbd84a652010-12-12 08:19:41 -0300492 v4l2_ctrl_handler_free(&decoder->hdl);
493 kfree(decoder);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 return 0;
495}
496
497/* ----------------------------------------------------------------------- */
498
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300499static const struct i2c_device_id bt819_id[] = {
500 { "bt819a", 0 },
501 { "bt817a", 0 },
502 { "bt815a", 0 },
503 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504};
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300505MODULE_DEVICE_TABLE(i2c, bt819_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Hans Verkuil00cc8db2010-09-15 15:15:55 -0300507static struct i2c_driver bt819_driver = {
508 .driver = {
509 .owner = THIS_MODULE,
510 .name = "bt819",
511 },
512 .probe = bt819_probe,
513 .remove = bt819_remove,
514 .id_table = bt819_id,
Hans Verkuil7fd011f2008-10-13 07:30:15 -0300515};
Hans Verkuil00cc8db2010-09-15 15:15:55 -0300516
Axel Linc6e8d862012-02-12 06:56:32 -0300517module_i2c_driver(bt819_driver);