Commit | Line | Data |
---|---|---|
6789cb52 RR |
1 | /* |
2 | * adv7180.c Analog Devices ADV7180 video decoder driver | |
3 | * Copyright (c) 2009 Intel Corporation | |
cccb83f7 VB |
4 | * Copyright (C) 2013 Cogent Embedded, Inc. |
5 | * Copyright (C) 2013 Renesas Solutions Corp. | |
6789cb52 RR |
6 | * |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License version 2 as | |
9 | * published by the Free Software Foundation. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
19 | */ | |
20 | ||
21 | #include <linux/module.h> | |
22 | #include <linux/init.h> | |
23 | #include <linux/errno.h> | |
24 | #include <linux/kernel.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/i2c.h> | |
5a0e3ad6 | 27 | #include <linux/slab.h> |
6789cb52 RR |
28 | #include <media/v4l2-ioctl.h> |
29 | #include <linux/videodev2.h> | |
30 | #include <media/v4l2-device.h> | |
c9fbeddd | 31 | #include <media/v4l2-ctrls.h> |
42752f7a | 32 | #include <linux/mutex.h> |
6789cb52 | 33 | |
d3124294 RR |
34 | #define ADV7180_INPUT_CONTROL_REG 0x00 |
35 | #define ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM 0x00 | |
36 | #define ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM_PED 0x10 | |
37 | #define ADV7180_INPUT_CONTROL_AD_PAL_N_NTSC_J_SECAM 0x20 | |
38 | #define ADV7180_INPUT_CONTROL_AD_PAL_N_NTSC_M_SECAM 0x30 | |
39 | #define ADV7180_INPUT_CONTROL_NTSC_J 0x40 | |
40 | #define ADV7180_INPUT_CONTROL_NTSC_M 0x50 | |
41 | #define ADV7180_INPUT_CONTROL_PAL60 0x60 | |
42 | #define ADV7180_INPUT_CONTROL_NTSC_443 0x70 | |
43 | #define ADV7180_INPUT_CONTROL_PAL_BG 0x80 | |
44 | #define ADV7180_INPUT_CONTROL_PAL_N 0x90 | |
45 | #define ADV7180_INPUT_CONTROL_PAL_M 0xa0 | |
46 | #define ADV7180_INPUT_CONTROL_PAL_M_PED 0xb0 | |
47 | #define ADV7180_INPUT_CONTROL_PAL_COMB_N 0xc0 | |
48 | #define ADV7180_INPUT_CONTROL_PAL_COMB_N_PED 0xd0 | |
49 | #define ADV7180_INPUT_CONTROL_PAL_SECAM 0xe0 | |
50 | #define ADV7180_INPUT_CONTROL_PAL_SECAM_PED 0xf0 | |
bca7ad1a | 51 | #define ADV7180_INPUT_CONTROL_INSEL_MASK 0x0f |
d3124294 | 52 | |
42752f7a RR |
53 | #define ADV7180_EXTENDED_OUTPUT_CONTROL_REG 0x04 |
54 | #define ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS 0xC5 | |
6789cb52 | 55 | |
42752f7a RR |
56 | #define ADV7180_AUTODETECT_ENABLE_REG 0x07 |
57 | #define ADV7180_AUTODETECT_DEFAULT 0x7f | |
c9fbeddd | 58 | /* Contrast */ |
bca7ad1a | 59 | #define ADV7180_CON_REG 0x08 /*Unsigned */ |
c9fbeddd FV |
60 | #define ADV7180_CON_MIN 0 |
61 | #define ADV7180_CON_DEF 128 | |
62 | #define ADV7180_CON_MAX 255 | |
63 | /* Brightness*/ | |
bca7ad1a | 64 | #define ADV7180_BRI_REG 0x0a /*Signed */ |
c9fbeddd FV |
65 | #define ADV7180_BRI_MIN -128 |
66 | #define ADV7180_BRI_DEF 0 | |
67 | #define ADV7180_BRI_MAX 127 | |
68 | /* Hue */ | |
bca7ad1a | 69 | #define ADV7180_HUE_REG 0x0b /*Signed, inverted */ |
c9fbeddd FV |
70 | #define ADV7180_HUE_MIN -127 |
71 | #define ADV7180_HUE_DEF 0 | |
72 | #define ADV7180_HUE_MAX 128 | |
bca7ad1a | 73 | |
42752f7a RR |
74 | #define ADV7180_ADI_CTRL_REG 0x0e |
75 | #define ADV7180_ADI_CTRL_IRQ_SPACE 0x20 | |
6789cb52 | 76 | |
bca7ad1a FV |
77 | #define ADV7180_PWR_MAN_REG 0x0f |
78 | #define ADV7180_PWR_MAN_ON 0x04 | |
79 | #define ADV7180_PWR_MAN_OFF 0x24 | |
80 | #define ADV7180_PWR_MAN_RES 0x80 | |
81 | ||
d3124294 RR |
82 | #define ADV7180_STATUS1_REG 0x10 |
83 | #define ADV7180_STATUS1_IN_LOCK 0x01 | |
84 | #define ADV7180_STATUS1_AUTOD_MASK 0x70 | |
6789cb52 RR |
85 | #define ADV7180_STATUS1_AUTOD_NTSM_M_J 0x00 |
86 | #define ADV7180_STATUS1_AUTOD_NTSC_4_43 0x10 | |
87 | #define ADV7180_STATUS1_AUTOD_PAL_M 0x20 | |
88 | #define ADV7180_STATUS1_AUTOD_PAL_60 0x30 | |
89 | #define ADV7180_STATUS1_AUTOD_PAL_B_G 0x40 | |
90 | #define ADV7180_STATUS1_AUTOD_SECAM 0x50 | |
91 | #define ADV7180_STATUS1_AUTOD_PAL_COMB 0x60 | |
92 | #define ADV7180_STATUS1_AUTOD_SECAM_525 0x70 | |
93 | ||
94 | #define ADV7180_IDENT_REG 0x11 | |
95 | #define ADV7180_ID_7180 0x18 | |
96 | ||
42752f7a RR |
97 | #define ADV7180_ICONF1_ADI 0x40 |
98 | #define ADV7180_ICONF1_ACTIVE_LOW 0x01 | |
99 | #define ADV7180_ICONF1_PSYNC_ONLY 0x10 | |
100 | #define ADV7180_ICONF1_ACTIVE_TO_CLR 0xC0 | |
c9fbeddd | 101 | /* Saturation */ |
bca7ad1a FV |
102 | #define ADV7180_SD_SAT_CB_REG 0xe3 /*Unsigned */ |
103 | #define ADV7180_SD_SAT_CR_REG 0xe4 /*Unsigned */ | |
c9fbeddd FV |
104 | #define ADV7180_SAT_MIN 0 |
105 | #define ADV7180_SAT_DEF 128 | |
106 | #define ADV7180_SAT_MAX 255 | |
bca7ad1a | 107 | |
42752f7a RR |
108 | #define ADV7180_IRQ1_LOCK 0x01 |
109 | #define ADV7180_IRQ1_UNLOCK 0x02 | |
110 | #define ADV7180_ISR1_ADI 0x42 | |
111 | #define ADV7180_ICR1_ADI 0x43 | |
112 | #define ADV7180_IMR1_ADI 0x44 | |
113 | #define ADV7180_IMR2_ADI 0x48 | |
114 | #define ADV7180_IRQ3_AD_CHANGE 0x08 | |
115 | #define ADV7180_ISR3_ADI 0x4A | |
116 | #define ADV7180_ICR3_ADI 0x4B | |
117 | #define ADV7180_IMR3_ADI 0x4C | |
118 | #define ADV7180_IMR4_ADI 0x50 | |
6789cb52 | 119 | |
bca7ad1a FV |
120 | #define ADV7180_NTSC_V_BIT_END_REG 0xE6 |
121 | #define ADV7180_NTSC_V_BIT_END_MANUAL_NVEND 0x4F | |
122 | ||
6789cb52 | 123 | struct adv7180_state { |
c9fbeddd | 124 | struct v4l2_ctrl_handler ctrl_hdl; |
c277b60a | 125 | struct v4l2_subdev sd; |
42752f7a RR |
126 | struct work_struct work; |
127 | struct mutex mutex; /* mutual excl. when accessing chip */ | |
128 | int irq; | |
c277b60a RR |
129 | v4l2_std_id curr_norm; |
130 | bool autodetect; | |
bca7ad1a | 131 | u8 input; |
6789cb52 | 132 | }; |
c9fbeddd FV |
133 | #define to_adv7180_sd(_ctrl) (&container_of(_ctrl->handler, \ |
134 | struct adv7180_state, \ | |
135 | ctrl_hdl)->sd) | |
6789cb52 | 136 | |
d3124294 | 137 | static v4l2_std_id adv7180_std_to_v4l2(u8 status1) |
6789cb52 | 138 | { |
b294a192 VB |
139 | /* in case V4L2_IN_ST_NO_SIGNAL */ |
140 | if (!(status1 & ADV7180_STATUS1_IN_LOCK)) | |
141 | return V4L2_STD_UNKNOWN; | |
142 | ||
6789cb52 RR |
143 | switch (status1 & ADV7180_STATUS1_AUTOD_MASK) { |
144 | case ADV7180_STATUS1_AUTOD_NTSM_M_J: | |
d3124294 | 145 | return V4L2_STD_NTSC; |
6789cb52 RR |
146 | case ADV7180_STATUS1_AUTOD_NTSC_4_43: |
147 | return V4L2_STD_NTSC_443; | |
148 | case ADV7180_STATUS1_AUTOD_PAL_M: | |
149 | return V4L2_STD_PAL_M; | |
150 | case ADV7180_STATUS1_AUTOD_PAL_60: | |
151 | return V4L2_STD_PAL_60; | |
152 | case ADV7180_STATUS1_AUTOD_PAL_B_G: | |
153 | return V4L2_STD_PAL; | |
154 | case ADV7180_STATUS1_AUTOD_SECAM: | |
155 | return V4L2_STD_SECAM; | |
156 | case ADV7180_STATUS1_AUTOD_PAL_COMB: | |
157 | return V4L2_STD_PAL_Nc | V4L2_STD_PAL_N; | |
158 | case ADV7180_STATUS1_AUTOD_SECAM_525: | |
159 | return V4L2_STD_SECAM; | |
160 | default: | |
161 | return V4L2_STD_UNKNOWN; | |
162 | } | |
163 | } | |
164 | ||
c277b60a RR |
165 | static int v4l2_std_to_adv7180(v4l2_std_id std) |
166 | { | |
167 | if (std == V4L2_STD_PAL_60) | |
168 | return ADV7180_INPUT_CONTROL_PAL60; | |
169 | if (std == V4L2_STD_NTSC_443) | |
170 | return ADV7180_INPUT_CONTROL_NTSC_443; | |
171 | if (std == V4L2_STD_PAL_N) | |
172 | return ADV7180_INPUT_CONTROL_PAL_N; | |
173 | if (std == V4L2_STD_PAL_M) | |
174 | return ADV7180_INPUT_CONTROL_PAL_M; | |
175 | if (std == V4L2_STD_PAL_Nc) | |
176 | return ADV7180_INPUT_CONTROL_PAL_COMB_N; | |
177 | ||
178 | if (std & V4L2_STD_PAL) | |
179 | return ADV7180_INPUT_CONTROL_PAL_BG; | |
180 | if (std & V4L2_STD_NTSC) | |
181 | return ADV7180_INPUT_CONTROL_NTSC_M; | |
182 | if (std & V4L2_STD_SECAM) | |
183 | return ADV7180_INPUT_CONTROL_PAL_SECAM; | |
184 | ||
185 | return -EINVAL; | |
186 | } | |
187 | ||
d3124294 RR |
188 | static u32 adv7180_status_to_v4l2(u8 status1) |
189 | { | |
190 | if (!(status1 & ADV7180_STATUS1_IN_LOCK)) | |
191 | return V4L2_IN_ST_NO_SIGNAL; | |
192 | ||
193 | return 0; | |
194 | } | |
195 | ||
196 | static int __adv7180_status(struct i2c_client *client, u32 *status, | |
bca7ad1a | 197 | v4l2_std_id *std) |
d3124294 RR |
198 | { |
199 | int status1 = i2c_smbus_read_byte_data(client, ADV7180_STATUS1_REG); | |
200 | ||
201 | if (status1 < 0) | |
202 | return status1; | |
203 | ||
204 | if (status) | |
205 | *status = adv7180_status_to_v4l2(status1); | |
206 | if (std) | |
207 | *std = adv7180_std_to_v4l2(status1); | |
208 | ||
209 | return 0; | |
210 | } | |
211 | ||
6789cb52 RR |
212 | static inline struct adv7180_state *to_state(struct v4l2_subdev *sd) |
213 | { | |
214 | return container_of(sd, struct adv7180_state, sd); | |
215 | } | |
216 | ||
217 | static int adv7180_querystd(struct v4l2_subdev *sd, v4l2_std_id *std) | |
218 | { | |
c277b60a | 219 | struct adv7180_state *state = to_state(sd); |
42752f7a RR |
220 | int err = mutex_lock_interruptible(&state->mutex); |
221 | if (err) | |
222 | return err; | |
c277b60a | 223 | |
42752f7a RR |
224 | /* when we are interrupt driven we know the state */ |
225 | if (!state->autodetect || state->irq > 0) | |
c277b60a RR |
226 | *std = state->curr_norm; |
227 | else | |
228 | err = __adv7180_status(v4l2_get_subdevdata(sd), NULL, std); | |
229 | ||
42752f7a | 230 | mutex_unlock(&state->mutex); |
c277b60a | 231 | return err; |
d3124294 | 232 | } |
6789cb52 | 233 | |
bca7ad1a FV |
234 | static int adv7180_s_routing(struct v4l2_subdev *sd, u32 input, |
235 | u32 output, u32 config) | |
236 | { | |
237 | struct adv7180_state *state = to_state(sd); | |
238 | int ret = mutex_lock_interruptible(&state->mutex); | |
239 | struct i2c_client *client = v4l2_get_subdevdata(sd); | |
240 | ||
241 | if (ret) | |
242 | return ret; | |
243 | ||
c9fbeddd | 244 | /* We cannot discriminate between LQFP and 40-pin LFCSP, so accept |
bca7ad1a FV |
245 | * all inputs and let the card driver take care of validation |
246 | */ | |
247 | if ((input & ADV7180_INPUT_CONTROL_INSEL_MASK) != input) | |
248 | goto out; | |
249 | ||
250 | ret = i2c_smbus_read_byte_data(client, ADV7180_INPUT_CONTROL_REG); | |
251 | ||
252 | if (ret < 0) | |
253 | goto out; | |
254 | ||
255 | ret &= ~ADV7180_INPUT_CONTROL_INSEL_MASK; | |
256 | ret = i2c_smbus_write_byte_data(client, | |
257 | ADV7180_INPUT_CONTROL_REG, ret | input); | |
258 | state->input = input; | |
259 | out: | |
260 | mutex_unlock(&state->mutex); | |
261 | return ret; | |
262 | } | |
263 | ||
d3124294 RR |
264 | static int adv7180_g_input_status(struct v4l2_subdev *sd, u32 *status) |
265 | { | |
42752f7a RR |
266 | struct adv7180_state *state = to_state(sd); |
267 | int ret = mutex_lock_interruptible(&state->mutex); | |
268 | if (ret) | |
269 | return ret; | |
270 | ||
271 | ret = __adv7180_status(v4l2_get_subdevdata(sd), status, NULL); | |
272 | mutex_unlock(&state->mutex); | |
273 | return ret; | |
6789cb52 RR |
274 | } |
275 | ||
c277b60a RR |
276 | static int adv7180_s_std(struct v4l2_subdev *sd, v4l2_std_id std) |
277 | { | |
278 | struct adv7180_state *state = to_state(sd); | |
279 | struct i2c_client *client = v4l2_get_subdevdata(sd); | |
42752f7a RR |
280 | int ret = mutex_lock_interruptible(&state->mutex); |
281 | if (ret) | |
282 | return ret; | |
c277b60a RR |
283 | |
284 | /* all standards -> autodetect */ | |
285 | if (std == V4L2_STD_ALL) { | |
bca7ad1a FV |
286 | ret = |
287 | i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, | |
288 | ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM | |
289 | | state->input); | |
c277b60a RR |
290 | if (ret < 0) |
291 | goto out; | |
292 | ||
42752f7a | 293 | __adv7180_status(client, NULL, &state->curr_norm); |
c277b60a RR |
294 | state->autodetect = true; |
295 | } else { | |
296 | ret = v4l2_std_to_adv7180(std); | |
297 | if (ret < 0) | |
298 | goto out; | |
299 | ||
300 | ret = i2c_smbus_write_byte_data(client, | |
bca7ad1a FV |
301 | ADV7180_INPUT_CONTROL_REG, |
302 | ret | state->input); | |
c277b60a RR |
303 | if (ret < 0) |
304 | goto out; | |
305 | ||
306 | state->curr_norm = std; | |
307 | state->autodetect = false; | |
308 | } | |
309 | ret = 0; | |
310 | out: | |
42752f7a | 311 | mutex_unlock(&state->mutex); |
c277b60a RR |
312 | return ret; |
313 | } | |
314 | ||
c9fbeddd | 315 | static int adv7180_s_ctrl(struct v4l2_ctrl *ctrl) |
bca7ad1a | 316 | { |
c9fbeddd | 317 | struct v4l2_subdev *sd = to_adv7180_sd(ctrl); |
bca7ad1a FV |
318 | struct adv7180_state *state = to_state(sd); |
319 | struct i2c_client *client = v4l2_get_subdevdata(sd); | |
320 | int ret = mutex_lock_interruptible(&state->mutex); | |
c9fbeddd FV |
321 | int val; |
322 | ||
bca7ad1a FV |
323 | if (ret) |
324 | return ret; | |
c9fbeddd | 325 | val = ctrl->val; |
bca7ad1a FV |
326 | switch (ctrl->id) { |
327 | case V4L2_CID_BRIGHTNESS: | |
c9fbeddd | 328 | ret = i2c_smbus_write_byte_data(client, ADV7180_BRI_REG, val); |
bca7ad1a FV |
329 | break; |
330 | case V4L2_CID_HUE: | |
bca7ad1a | 331 | /*Hue is inverted according to HSL chart */ |
c9fbeddd | 332 | ret = i2c_smbus_write_byte_data(client, ADV7180_HUE_REG, -val); |
bca7ad1a FV |
333 | break; |
334 | case V4L2_CID_CONTRAST: | |
c9fbeddd | 335 | ret = i2c_smbus_write_byte_data(client, ADV7180_CON_REG, val); |
bca7ad1a FV |
336 | break; |
337 | case V4L2_CID_SATURATION: | |
bca7ad1a FV |
338 | /* |
339 | *This could be V4L2_CID_BLUE_BALANCE/V4L2_CID_RED_BALANCE | |
340 | *Let's not confuse the user, everybody understands saturation | |
341 | */ | |
c9fbeddd FV |
342 | ret = i2c_smbus_write_byte_data(client, ADV7180_SD_SAT_CB_REG, |
343 | val); | |
bca7ad1a FV |
344 | if (ret < 0) |
345 | break; | |
c9fbeddd FV |
346 | ret = i2c_smbus_write_byte_data(client, ADV7180_SD_SAT_CR_REG, |
347 | val); | |
bca7ad1a FV |
348 | break; |
349 | default: | |
350 | ret = -EINVAL; | |
351 | } | |
352 | ||
353 | mutex_unlock(&state->mutex); | |
354 | return ret; | |
355 | } | |
356 | ||
c9fbeddd FV |
357 | static const struct v4l2_ctrl_ops adv7180_ctrl_ops = { |
358 | .s_ctrl = adv7180_s_ctrl, | |
359 | }; | |
360 | ||
361 | static int adv7180_init_controls(struct adv7180_state *state) | |
362 | { | |
363 | v4l2_ctrl_handler_init(&state->ctrl_hdl, 4); | |
364 | ||
365 | v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops, | |
366 | V4L2_CID_BRIGHTNESS, ADV7180_BRI_MIN, | |
367 | ADV7180_BRI_MAX, 1, ADV7180_BRI_DEF); | |
368 | v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops, | |
369 | V4L2_CID_CONTRAST, ADV7180_CON_MIN, | |
370 | ADV7180_CON_MAX, 1, ADV7180_CON_DEF); | |
371 | v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops, | |
372 | V4L2_CID_SATURATION, ADV7180_SAT_MIN, | |
373 | ADV7180_SAT_MAX, 1, ADV7180_SAT_DEF); | |
374 | v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops, | |
375 | V4L2_CID_HUE, ADV7180_HUE_MIN, | |
376 | ADV7180_HUE_MAX, 1, ADV7180_HUE_DEF); | |
377 | state->sd.ctrl_handler = &state->ctrl_hdl; | |
378 | if (state->ctrl_hdl.error) { | |
379 | int err = state->ctrl_hdl.error; | |
380 | ||
381 | v4l2_ctrl_handler_free(&state->ctrl_hdl); | |
382 | return err; | |
383 | } | |
384 | v4l2_ctrl_handler_setup(&state->ctrl_hdl); | |
385 | ||
386 | return 0; | |
387 | } | |
388 | static void adv7180_exit_controls(struct adv7180_state *state) | |
389 | { | |
390 | v4l2_ctrl_handler_free(&state->ctrl_hdl); | |
391 | } | |
392 | ||
cccb83f7 VB |
393 | static int adv7180_enum_mbus_fmt(struct v4l2_subdev *sd, unsigned int index, |
394 | enum v4l2_mbus_pixelcode *code) | |
395 | { | |
396 | if (index > 0) | |
397 | return -EINVAL; | |
398 | ||
399 | *code = V4L2_MBUS_FMT_YUYV8_2X8; | |
400 | ||
401 | return 0; | |
402 | } | |
403 | ||
404 | static int adv7180_mbus_fmt(struct v4l2_subdev *sd, | |
405 | struct v4l2_mbus_framefmt *fmt) | |
406 | { | |
407 | struct adv7180_state *state = to_state(sd); | |
408 | ||
409 | fmt->code = V4L2_MBUS_FMT_YUYV8_2X8; | |
410 | fmt->colorspace = V4L2_COLORSPACE_SMPTE170M; | |
411 | fmt->field = V4L2_FIELD_INTERLACED; | |
412 | fmt->width = 720; | |
413 | fmt->height = state->curr_norm & V4L2_STD_525_60 ? 480 : 576; | |
414 | ||
415 | return 0; | |
416 | } | |
417 | ||
418 | static int adv7180_g_mbus_config(struct v4l2_subdev *sd, | |
419 | struct v4l2_mbus_config *cfg) | |
420 | { | |
421 | /* | |
422 | * The ADV7180 sensor supports BT.601/656 output modes. | |
423 | * The BT.656 is default and not yet configurable by s/w. | |
424 | */ | |
425 | cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING | | |
426 | V4L2_MBUS_DATA_ACTIVE_HIGH; | |
427 | cfg->type = V4L2_MBUS_BT656; | |
428 | ||
429 | return 0; | |
430 | } | |
431 | ||
6789cb52 RR |
432 | static const struct v4l2_subdev_video_ops adv7180_video_ops = { |
433 | .querystd = adv7180_querystd, | |
d3124294 | 434 | .g_input_status = adv7180_g_input_status, |
bca7ad1a | 435 | .s_routing = adv7180_s_routing, |
cccb83f7 VB |
436 | .enum_mbus_fmt = adv7180_enum_mbus_fmt, |
437 | .try_mbus_fmt = adv7180_mbus_fmt, | |
438 | .g_mbus_fmt = adv7180_mbus_fmt, | |
439 | .s_mbus_fmt = adv7180_mbus_fmt, | |
440 | .g_mbus_config = adv7180_g_mbus_config, | |
6789cb52 RR |
441 | }; |
442 | ||
443 | static const struct v4l2_subdev_core_ops adv7180_core_ops = { | |
c277b60a | 444 | .s_std = adv7180_s_std, |
6789cb52 RR |
445 | }; |
446 | ||
447 | static const struct v4l2_subdev_ops adv7180_ops = { | |
448 | .core = &adv7180_core_ops, | |
449 | .video = &adv7180_video_ops, | |
450 | }; | |
451 | ||
42752f7a RR |
452 | static void adv7180_work(struct work_struct *work) |
453 | { | |
454 | struct adv7180_state *state = container_of(work, struct adv7180_state, | |
bca7ad1a | 455 | work); |
42752f7a RR |
456 | struct i2c_client *client = v4l2_get_subdevdata(&state->sd); |
457 | u8 isr3; | |
458 | ||
459 | mutex_lock(&state->mutex); | |
460 | i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, | |
bca7ad1a | 461 | ADV7180_ADI_CTRL_IRQ_SPACE); |
42752f7a RR |
462 | isr3 = i2c_smbus_read_byte_data(client, ADV7180_ISR3_ADI); |
463 | /* clear */ | |
464 | i2c_smbus_write_byte_data(client, ADV7180_ICR3_ADI, isr3); | |
465 | i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, 0); | |
466 | ||
467 | if (isr3 & ADV7180_IRQ3_AD_CHANGE && state->autodetect) | |
468 | __adv7180_status(client, NULL, &state->curr_norm); | |
469 | mutex_unlock(&state->mutex); | |
470 | ||
471 | enable_irq(state->irq); | |
472 | } | |
473 | ||
474 | static irqreturn_t adv7180_irq(int irq, void *devid) | |
475 | { | |
476 | struct adv7180_state *state = devid; | |
477 | ||
478 | schedule_work(&state->work); | |
479 | ||
480 | disable_irq_nosync(state->irq); | |
481 | ||
482 | return IRQ_HANDLED; | |
483 | } | |
484 | ||
bca7ad1a | 485 | static int init_device(struct i2c_client *client, struct adv7180_state *state) |
6789cb52 | 486 | { |
6789cb52 RR |
487 | int ret; |
488 | ||
6789cb52 | 489 | /* Initialize adv7180 */ |
42752f7a | 490 | /* Enable autodetection */ |
bca7ad1a FV |
491 | if (state->autodetect) { |
492 | ret = | |
493 | i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, | |
494 | ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM | |
495 | | state->input); | |
496 | if (ret < 0) | |
497 | return ret; | |
42752f7a | 498 | |
bca7ad1a FV |
499 | ret = |
500 | i2c_smbus_write_byte_data(client, | |
501 | ADV7180_AUTODETECT_ENABLE_REG, | |
502 | ADV7180_AUTODETECT_DEFAULT); | |
503 | if (ret < 0) | |
504 | return ret; | |
505 | } else { | |
506 | ret = v4l2_std_to_adv7180(state->curr_norm); | |
507 | if (ret < 0) | |
508 | return ret; | |
42752f7a | 509 | |
bca7ad1a FV |
510 | ret = |
511 | i2c_smbus_write_byte_data(client, ADV7180_INPUT_CONTROL_REG, | |
512 | ret | state->input); | |
513 | if (ret < 0) | |
514 | return ret; | |
515 | ||
516 | } | |
42752f7a RR |
517 | /* ITU-R BT.656-4 compatible */ |
518 | ret = i2c_smbus_write_byte_data(client, | |
bca7ad1a FV |
519 | ADV7180_EXTENDED_OUTPUT_CONTROL_REG, |
520 | ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS); | |
42752f7a | 521 | if (ret < 0) |
bca7ad1a FV |
522 | return ret; |
523 | ||
524 | /* Manually set V bit end position in NTSC mode */ | |
525 | ret = i2c_smbus_write_byte_data(client, | |
526 | ADV7180_NTSC_V_BIT_END_REG, | |
527 | ADV7180_NTSC_V_BIT_END_MANUAL_NVEND); | |
528 | if (ret < 0) | |
529 | return ret; | |
42752f7a RR |
530 | |
531 | /* read current norm */ | |
532 | __adv7180_status(client, NULL, &state->curr_norm); | |
533 | ||
534 | /* register for interrupts */ | |
535 | if (state->irq > 0) { | |
c9fbeddd | 536 | ret = request_irq(state->irq, adv7180_irq, 0, KBUILD_MODNAME, |
bca7ad1a | 537 | state); |
42752f7a | 538 | if (ret) |
bca7ad1a | 539 | return ret; |
42752f7a RR |
540 | |
541 | ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, | |
bca7ad1a | 542 | ADV7180_ADI_CTRL_IRQ_SPACE); |
42752f7a | 543 | if (ret < 0) |
bca7ad1a | 544 | return ret; |
42752f7a RR |
545 | |
546 | /* config the Interrupt pin to be active low */ | |
547 | ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI, | |
bca7ad1a FV |
548 | ADV7180_ICONF1_ACTIVE_LOW | |
549 | ADV7180_ICONF1_PSYNC_ONLY); | |
42752f7a | 550 | if (ret < 0) |
bca7ad1a | 551 | return ret; |
42752f7a RR |
552 | |
553 | ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0); | |
554 | if (ret < 0) | |
bca7ad1a | 555 | return ret; |
42752f7a RR |
556 | |
557 | ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0); | |
558 | if (ret < 0) | |
bca7ad1a | 559 | return ret; |
42752f7a RR |
560 | |
561 | /* enable AD change interrupts interrupts */ | |
562 | ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI, | |
bca7ad1a | 563 | ADV7180_IRQ3_AD_CHANGE); |
42752f7a | 564 | if (ret < 0) |
bca7ad1a | 565 | return ret; |
42752f7a RR |
566 | |
567 | ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0); | |
568 | if (ret < 0) | |
bca7ad1a | 569 | return ret; |
42752f7a RR |
570 | |
571 | ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG, | |
bca7ad1a | 572 | 0); |
42752f7a | 573 | if (ret < 0) |
bca7ad1a | 574 | return ret; |
6789cb52 RR |
575 | } |
576 | ||
bca7ad1a FV |
577 | return 0; |
578 | } | |
579 | ||
4c62e976 GKH |
580 | static int adv7180_probe(struct i2c_client *client, |
581 | const struct i2c_device_id *id) | |
bca7ad1a FV |
582 | { |
583 | struct adv7180_state *state; | |
584 | struct v4l2_subdev *sd; | |
585 | int ret; | |
586 | ||
587 | /* Check if the adapter supports the needed features */ | |
588 | if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) | |
589 | return -EIO; | |
590 | ||
591 | v4l_info(client, "chip found @ 0x%02x (%s)\n", | |
592 | client->addr, client->adapter->name); | |
593 | ||
c02b211d | 594 | state = devm_kzalloc(&client->dev, sizeof(*state), GFP_KERNEL); |
bca7ad1a FV |
595 | if (state == NULL) { |
596 | ret = -ENOMEM; | |
597 | goto err; | |
598 | } | |
599 | ||
600 | state->irq = client->irq; | |
601 | INIT_WORK(&state->work, adv7180_work); | |
602 | mutex_init(&state->mutex); | |
603 | state->autodetect = true; | |
bca7ad1a FV |
604 | state->input = 0; |
605 | sd = &state->sd; | |
606 | v4l2_i2c_subdev_init(sd, client, &adv7180_ops); | |
607 | ||
c9fbeddd FV |
608 | ret = adv7180_init_controls(state); |
609 | if (ret) | |
bca7ad1a | 610 | goto err_unreg_subdev; |
c9fbeddd FV |
611 | ret = init_device(client, state); |
612 | if (ret) | |
613 | goto err_free_ctrl; | |
6789cb52 | 614 | return 0; |
42752f7a | 615 | |
c9fbeddd FV |
616 | err_free_ctrl: |
617 | adv7180_exit_controls(state); | |
42752f7a | 618 | err_unreg_subdev: |
297a0ae3 | 619 | mutex_destroy(&state->mutex); |
42752f7a | 620 | err: |
42752f7a | 621 | return ret; |
6789cb52 RR |
622 | } |
623 | ||
4c62e976 | 624 | static int adv7180_remove(struct i2c_client *client) |
6789cb52 RR |
625 | { |
626 | struct v4l2_subdev *sd = i2c_get_clientdata(client); | |
42752f7a RR |
627 | struct adv7180_state *state = to_state(sd); |
628 | ||
629 | if (state->irq > 0) { | |
630 | free_irq(client->irq, state); | |
631 | if (cancel_work_sync(&state->work)) { | |
632 | /* | |
633 | * Work was pending, therefore we need to enable | |
634 | * IRQ here to balance the disable_irq() done in the | |
635 | * interrupt handler. | |
636 | */ | |
637 | enable_irq(state->irq); | |
638 | } | |
639 | } | |
6789cb52 RR |
640 | |
641 | v4l2_device_unregister_subdev(sd); | |
b13f4af2 | 642 | adv7180_exit_controls(state); |
297a0ae3 | 643 | mutex_destroy(&state->mutex); |
6789cb52 RR |
644 | return 0; |
645 | } | |
646 | ||
647 | static const struct i2c_device_id adv7180_id[] = { | |
c9fbeddd | 648 | {KBUILD_MODNAME, 0}, |
6789cb52 RR |
649 | {}, |
650 | }; | |
651 | ||
cc1088dc LPC |
652 | #ifdef CONFIG_PM_SLEEP |
653 | static int adv7180_suspend(struct device *dev) | |
bca7ad1a | 654 | { |
cc1088dc | 655 | struct i2c_client *client = to_i2c_client(dev); |
bca7ad1a FV |
656 | int ret; |
657 | ||
658 | ret = i2c_smbus_write_byte_data(client, ADV7180_PWR_MAN_REG, | |
659 | ADV7180_PWR_MAN_OFF); | |
660 | if (ret < 0) | |
661 | return ret; | |
662 | return 0; | |
663 | } | |
664 | ||
cc1088dc | 665 | static int adv7180_resume(struct device *dev) |
bca7ad1a | 666 | { |
cc1088dc | 667 | struct i2c_client *client = to_i2c_client(dev); |
bca7ad1a FV |
668 | struct v4l2_subdev *sd = i2c_get_clientdata(client); |
669 | struct adv7180_state *state = to_state(sd); | |
670 | int ret; | |
671 | ||
672 | ret = i2c_smbus_write_byte_data(client, ADV7180_PWR_MAN_REG, | |
673 | ADV7180_PWR_MAN_ON); | |
674 | if (ret < 0) | |
675 | return ret; | |
676 | ret = init_device(client, state); | |
677 | if (ret < 0) | |
678 | return ret; | |
679 | return 0; | |
680 | } | |
cc1088dc LPC |
681 | |
682 | static SIMPLE_DEV_PM_OPS(adv7180_pm_ops, adv7180_suspend, adv7180_resume); | |
683 | #define ADV7180_PM_OPS (&adv7180_pm_ops) | |
684 | ||
685 | #else | |
686 | #define ADV7180_PM_OPS NULL | |
bca7ad1a FV |
687 | #endif |
688 | ||
6789cb52 RR |
689 | MODULE_DEVICE_TABLE(i2c, adv7180_id); |
690 | ||
691 | static struct i2c_driver adv7180_driver = { | |
692 | .driver = { | |
bca7ad1a | 693 | .owner = THIS_MODULE, |
c9fbeddd | 694 | .name = KBUILD_MODNAME, |
cc1088dc | 695 | .pm = ADV7180_PM_OPS, |
bca7ad1a FV |
696 | }, |
697 | .probe = adv7180_probe, | |
4c62e976 | 698 | .remove = adv7180_remove, |
bca7ad1a | 699 | .id_table = adv7180_id, |
6789cb52 RR |
700 | }; |
701 | ||
c6e8d86f | 702 | module_i2c_driver(adv7180_driver); |
6789cb52 RR |
703 | |
704 | MODULE_DESCRIPTION("Analog Devices ADV7180 video decoder driver"); | |
705 | MODULE_AUTHOR("Mocean Laboratories"); | |
706 | MODULE_LICENSE("GPL v2"); |