blob: 04bb29720aaf1c7bae4410cbb8f0b608394d0231 [file] [log] [blame]
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * adv7170 - adv7170, adv7171 video encoder driver version 0.0.1
3 *
4 * Copyright (C) 2002 Maxim Yevtyushkin <max@linuxmedialabs.com>
5 *
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -03006 * Based on adv7176 driver by:
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * Copyright (C) 1998 Dave Perks <dperks@ibm.net>
9 * Copyright (C) 1999 Wolfgang Scherr <scherr@net4you.net>
10 * Copyright (C) 2000 Serguei Miridonov <mirsev@cicese.mx>
11 * - some corrections for Pinnacle Systems Inc. DC10plus card.
12 *
13 * Changes by Ronald Bultje <rbultje@ronald.bitfreak.net>
14 * - moved over to linux>=2.4.x i2c protocol (1/1/2003)
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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Hans Verkuilb9a21f82008-09-07 07:58:20 -030034#include <linux/ioctl.h>
Mauro Carvalho Chehab18f3fa12007-07-02 15:39:57 -030035#include <asm/uaccess.h>
Hans Verkuilb9a21f82008-09-07 07:58:20 -030036#include <linux/i2c.h>
Hans Verkuil7d9ef212009-02-19 14:47:22 -030037#include <linux/videodev2.h>
38#include <media/v4l2-device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40MODULE_DESCRIPTION("Analog Devices ADV7170 video encoder driver");
41MODULE_AUTHOR("Maxim Yevtyushkin");
42MODULE_LICENSE("GPL");
43
Hans Verkuil7d9ef212009-02-19 14:47:22 -030044
Douglas Schilling Landgrafff699e62008-04-22 14:41:48 -030045static int debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046module_param(debug, int, 0);
47MODULE_PARM_DESC(debug, "Debug level (0-1)");
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049/* ----------------------------------------------------------------------- */
50
51struct adv7170 {
Hans Verkuil7d9ef212009-02-19 14:47:22 -030052 struct v4l2_subdev sd;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 unsigned char reg[128];
54
Hans Verkuil107063c2009-02-18 17:26:06 -030055 v4l2_std_id norm;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 int input;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057};
58
Hans Verkuil7d9ef212009-02-19 14:47:22 -030059static inline struct adv7170 *to_adv7170(struct v4l2_subdev *sd)
60{
61 return container_of(sd, struct adv7170, sd);
62}
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static char *inputs[] = { "pass_through", "play_back" };
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Christian Gmeiner0d37d352011-10-27 18:50:21 -030066static enum v4l2_mbus_pixelcode adv7170_codes[] = {
67 V4L2_MBUS_FMT_UYVY8_2X8,
68 V4L2_MBUS_FMT_UYVY8_1X16,
69};
70
Linus Torvalds1da177e2005-04-16 15:20:36 -070071/* ----------------------------------------------------------------------- */
72
Hans Verkuil7d9ef212009-02-19 14:47:22 -030073static inline int adv7170_write(struct v4l2_subdev *sd, u8 reg, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
Hans Verkuil7d9ef212009-02-19 14:47:22 -030075 struct i2c_client *client = v4l2_get_subdevdata(sd);
76 struct adv7170 *encoder = to_adv7170(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78 encoder->reg[reg] = value;
79 return i2c_smbus_write_byte_data(client, reg, value);
80}
81
Hans Verkuil7d9ef212009-02-19 14:47:22 -030082static inline int adv7170_read(struct v4l2_subdev *sd, u8 reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070083{
Hans Verkuil7d9ef212009-02-19 14:47:22 -030084 struct i2c_client *client = v4l2_get_subdevdata(sd);
85
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 return i2c_smbus_read_byte_data(client, reg);
87}
88
Hans Verkuil7d9ef212009-02-19 14:47:22 -030089static int adv7170_write_block(struct v4l2_subdev *sd,
Hans Verkuilb9a21f82008-09-07 07:58:20 -030090 const u8 *data, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Hans Verkuil7d9ef212009-02-19 14:47:22 -030092 struct i2c_client *client = v4l2_get_subdevdata(sd);
93 struct adv7170 *encoder = to_adv7170(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 int ret = -1;
95 u8 reg;
96
97 /* the adv7170 has an autoincrement function, use it if
98 * the adapter understands raw I2C */
99 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
100 /* do raw I2C, not smbus compatible */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 u8 block_data[32];
Jean Delvare9aa45e32006-03-22 03:48:35 -0300102 int block_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 while (len >= 2) {
Jean Delvare9aa45e32006-03-22 03:48:35 -0300105 block_len = 0;
106 block_data[block_len++] = reg = data[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 do {
Jean Delvare9aa45e32006-03-22 03:48:35 -0300108 block_data[block_len++] =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 encoder->reg[reg++] = data[1];
110 len -= 2;
111 data += 2;
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300112 } while (len >= 2 && data[0] == reg && block_len < 32);
113 ret = i2c_master_send(client, block_data, block_len);
114 if (ret < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 break;
116 }
117 } else {
118 /* do some slow I2C emulation kind of thing */
119 while (len >= 2) {
120 reg = *data++;
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300121 ret = adv7170_write(sd, reg, *data++);
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300122 if (ret < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 break;
124 len -= 2;
125 }
126 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return ret;
128}
129
130/* ----------------------------------------------------------------------- */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132#define TR0MODE 0x4c
133#define TR0RST 0x80
134
135#define TR1CAPT 0x00
136#define TR1PLAY 0x00
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138static const unsigned char init_NTSC[] = {
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300139 0x00, 0x10, /* MR0 */
140 0x01, 0x20, /* MR1 */
141 0x02, 0x0e, /* MR2 RTC control: bits 2 and 1 */
142 0x03, 0x80, /* MR3 */
143 0x04, 0x30, /* MR4 */
144 0x05, 0x00, /* Reserved */
145 0x06, 0x00, /* Reserved */
146 0x07, TR0MODE, /* TM0 */
147 0x08, TR1CAPT, /* TM1 */
148 0x09, 0x16, /* Fsc0 */
149 0x0a, 0x7c, /* Fsc1 */
150 0x0b, 0xf0, /* Fsc2 */
151 0x0c, 0x21, /* Fsc3 */
152 0x0d, 0x00, /* Subcarrier Phase */
153 0x0e, 0x00, /* Closed Capt. Ext 0 */
154 0x0f, 0x00, /* Closed Capt. Ext 1 */
155 0x10, 0x00, /* Closed Capt. 0 */
156 0x11, 0x00, /* Closed Capt. 1 */
157 0x12, 0x00, /* Pedestal Ctl 0 */
158 0x13, 0x00, /* Pedestal Ctl 1 */
159 0x14, 0x00, /* Pedestal Ctl 2 */
160 0x15, 0x00, /* Pedestal Ctl 3 */
161 0x16, 0x00, /* CGMS_WSS_0 */
162 0x17, 0x00, /* CGMS_WSS_1 */
163 0x18, 0x00, /* CGMS_WSS_2 */
164 0x19, 0x00, /* Teletext Ctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165};
166
167static const unsigned char init_PAL[] = {
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300168 0x00, 0x71, /* MR0 */
169 0x01, 0x20, /* MR1 */
170 0x02, 0x0e, /* MR2 RTC control: bits 2 and 1 */
171 0x03, 0x80, /* MR3 */
172 0x04, 0x30, /* MR4 */
173 0x05, 0x00, /* Reserved */
174 0x06, 0x00, /* Reserved */
175 0x07, TR0MODE, /* TM0 */
176 0x08, TR1CAPT, /* TM1 */
177 0x09, 0xcb, /* Fsc0 */
178 0x0a, 0x8a, /* Fsc1 */
179 0x0b, 0x09, /* Fsc2 */
180 0x0c, 0x2a, /* Fsc3 */
181 0x0d, 0x00, /* Subcarrier Phase */
182 0x0e, 0x00, /* Closed Capt. Ext 0 */
183 0x0f, 0x00, /* Closed Capt. Ext 1 */
184 0x10, 0x00, /* Closed Capt. 0 */
185 0x11, 0x00, /* Closed Capt. 1 */
186 0x12, 0x00, /* Pedestal Ctl 0 */
187 0x13, 0x00, /* Pedestal Ctl 1 */
188 0x14, 0x00, /* Pedestal Ctl 2 */
189 0x15, 0x00, /* Pedestal Ctl 3 */
190 0x16, 0x00, /* CGMS_WSS_0 */
191 0x17, 0x00, /* CGMS_WSS_1 */
192 0x18, 0x00, /* CGMS_WSS_2 */
193 0x19, 0x00, /* Teletext Ctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194};
195
196
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300197static int adv7170_s_std_output(struct v4l2_subdev *sd, v4l2_std_id std)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300199 struct adv7170 *encoder = to_adv7170(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Hans Verkuilcc5cef82009-03-06 10:15:01 -0300201 v4l2_dbg(1, debug, sd, "set norm %llx\n", (unsigned long long)std);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300203 if (std & V4L2_STD_NTSC) {
204 adv7170_write_block(sd, init_NTSC, sizeof(init_NTSC));
205 if (encoder->input == 0)
206 adv7170_write(sd, 0x02, 0x0e); /* Enable genlock */
207 adv7170_write(sd, 0x07, TR0MODE | TR0RST);
208 adv7170_write(sd, 0x07, TR0MODE);
209 } else if (std & V4L2_STD_PAL) {
210 adv7170_write_block(sd, init_PAL, sizeof(init_PAL));
211 if (encoder->input == 0)
212 adv7170_write(sd, 0x02, 0x0e); /* Enable genlock */
213 adv7170_write(sd, 0x07, TR0MODE | TR0RST);
214 adv7170_write(sd, 0x07, TR0MODE);
215 } else {
Hans Verkuilcc5cef82009-03-06 10:15:01 -0300216 v4l2_dbg(1, debug, sd, "illegal norm: %llx\n",
217 (unsigned long long)std);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 return -EINVAL;
219 }
Hans Verkuilcc5cef82009-03-06 10:15:01 -0300220 v4l2_dbg(1, debug, sd, "switched to %llx\n", (unsigned long long)std);
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300221 encoder->norm = std;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 return 0;
223}
224
Hans Verkuil5325b422009-04-02 11:26:22 -0300225static int adv7170_s_routing(struct v4l2_subdev *sd,
226 u32 input, u32 output, u32 config)
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300227{
228 struct adv7170 *encoder = to_adv7170(sd);
229
Hans Verkuil5325b422009-04-02 11:26:22 -0300230 /* RJ: input = 0: input is from decoder
231 input = 1: input is from ZR36060
232 input = 2: color bar */
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300233
234 v4l2_dbg(1, debug, sd, "set input from %s\n",
Hans Verkuil5325b422009-04-02 11:26:22 -0300235 input == 0 ? "decoder" : "ZR36060");
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300236
Hans Verkuil5325b422009-04-02 11:26:22 -0300237 switch (input) {
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300238 case 0:
239 adv7170_write(sd, 0x01, 0x20);
240 adv7170_write(sd, 0x08, TR1CAPT); /* TR1 */
241 adv7170_write(sd, 0x02, 0x0e); /* Enable genlock */
242 adv7170_write(sd, 0x07, TR0MODE | TR0RST);
243 adv7170_write(sd, 0x07, TR0MODE);
244 /* udelay(10); */
245 break;
246
247 case 1:
248 adv7170_write(sd, 0x01, 0x00);
249 adv7170_write(sd, 0x08, TR1PLAY); /* TR1 */
250 adv7170_write(sd, 0x02, 0x08);
251 adv7170_write(sd, 0x07, TR0MODE | TR0RST);
252 adv7170_write(sd, 0x07, TR0MODE);
253 /* udelay(10); */
254 break;
255
256 default:
Hans Verkuil5325b422009-04-02 11:26:22 -0300257 v4l2_dbg(1, debug, sd, "illegal input: %d\n", input);
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300258 return -EINVAL;
259 }
Hans Verkuil5325b422009-04-02 11:26:22 -0300260 v4l2_dbg(1, debug, sd, "switched to %s\n", inputs[input]);
261 encoder->input = input;
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300262 return 0;
263}
264
Christian Gmeiner0d37d352011-10-27 18:50:21 -0300265static int adv7170_enum_fmt(struct v4l2_subdev *sd, unsigned int index,
266 enum v4l2_mbus_pixelcode *code)
267{
268 if (index >= ARRAY_SIZE(adv7170_codes))
269 return -EINVAL;
270
271 *code = adv7170_codes[index];
272 return 0;
273}
274
275static int adv7170_g_fmt(struct v4l2_subdev *sd,
276 struct v4l2_mbus_framefmt *mf)
277{
278 u8 val = adv7170_read(sd, 0x7);
279
280 if ((val & 0x40) == (1 << 6))
281 mf->code = V4L2_MBUS_FMT_UYVY8_1X16;
282 else
283 mf->code = V4L2_MBUS_FMT_UYVY8_2X8;
284
285 mf->colorspace = V4L2_COLORSPACE_SMPTE170M;
286 mf->width = 0;
287 mf->height = 0;
288 mf->field = V4L2_FIELD_ANY;
289
290 return 0;
291}
292
293static int adv7170_s_fmt(struct v4l2_subdev *sd,
294 struct v4l2_mbus_framefmt *mf)
295{
296 u8 val = adv7170_read(sd, 0x7);
297 int ret;
298
299 switch (mf->code) {
300 case V4L2_MBUS_FMT_UYVY8_2X8:
301 val &= ~0x40;
302 break;
303
304 case V4L2_MBUS_FMT_UYVY8_1X16:
305 val |= 0x40;
306 break;
307
308 default:
309 v4l2_dbg(1, debug, sd,
310 "illegal v4l2_mbus_framefmt code: %d\n", mf->code);
311 return -EINVAL;
312 }
313
314 ret = adv7170_write(sd, 0x7, val);
315
316 return ret;
317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319/* ----------------------------------------------------------------------- */
320
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300321static const struct v4l2_subdev_video_ops adv7170_video_ops = {
322 .s_std_output = adv7170_s_std_output,
323 .s_routing = adv7170_s_routing,
Christian Gmeiner0d37d352011-10-27 18:50:21 -0300324 .s_mbus_fmt = adv7170_s_fmt,
325 .g_mbus_fmt = adv7170_g_fmt,
326 .enum_mbus_fmt = adv7170_enum_fmt,
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300327};
328
329static const struct v4l2_subdev_ops adv7170_ops = {
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300330 .video = &adv7170_video_ops,
331};
332
333/* ----------------------------------------------------------------------- */
Mauro Carvalho Chehabd56410e2006-03-25 09:19:53 -0300334
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300335static int adv7170_probe(struct i2c_client *client,
336 const struct i2c_device_id *id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 struct adv7170 *encoder;
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300339 struct v4l2_subdev *sd;
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300340 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
342 /* Check if the adapter supports the needed features */
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300343 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
344 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300346 v4l_info(client, "chip found @ 0x%x (%s)\n",
347 client->addr << 1, client->adapter->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Laurent Pinchartc02b2112013-05-02 08:29:43 -0300349 encoder = devm_kzalloc(&client->dev, sizeof(*encoder), GFP_KERNEL);
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300350 if (encoder == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 return -ENOMEM;
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300352 sd = &encoder->sd;
353 v4l2_i2c_subdev_init(sd, client, &adv7170_ops);
Hans Verkuil107063c2009-02-18 17:26:06 -0300354 encoder->norm = V4L2_STD_NTSC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 encoder->input = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300357 i = adv7170_write_block(sd, init_NTSC, sizeof(init_NTSC));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (i >= 0) {
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300359 i = adv7170_write(sd, 0x07, TR0MODE | TR0RST);
360 i = adv7170_write(sd, 0x07, TR0MODE);
361 i = adv7170_read(sd, 0x12);
362 v4l2_dbg(1, debug, sd, "revision %d\n", i & 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 }
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300364 if (i < 0)
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300365 v4l2_dbg(1, debug, sd, "init error 0x%x\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 return 0;
367}
368
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300369static int adv7170_remove(struct i2c_client *client)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370{
Hans Verkuil7d9ef212009-02-19 14:47:22 -0300371 struct v4l2_subdev *sd = i2c_get_clientdata(client);
372
373 v4l2_device_unregister_subdev(sd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 return 0;
375}
376
377/* ----------------------------------------------------------------------- */
378
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300379static const struct i2c_device_id adv7170_id[] = {
380 { "adv7170", 0 },
381 { "adv7171", 0 },
382 { }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383};
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300384MODULE_DEVICE_TABLE(i2c, adv7170_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Hans Verkuilc9611802010-09-15 15:49:56 -0300386static struct i2c_driver adv7170_driver = {
387 .driver = {
388 .owner = THIS_MODULE,
389 .name = "adv7170",
390 },
391 .probe = adv7170_probe,
392 .remove = adv7170_remove,
393 .id_table = adv7170_id,
Hans Verkuilb9a21f82008-09-07 07:58:20 -0300394};
Hans Verkuilc9611802010-09-15 15:49:56 -0300395
Axel Linc6e8d862012-02-12 06:56:32 -0300396module_i2c_driver(adv7170_driver);